AdeonGSM.cpp

Go to the documentation of this file.

 
#include <AdeonGSM.h>
 
void Adeon::addUser(const char* phoneNum, uint16_t userGroup){
    userList.addItem(phoneNum, userGroup);
}
 
void Adeon::deleteUser(const char* phoneNum){
    userList.deleteItem(userList.findItem(phoneNum));
}
 
void Adeon::deleteList(){
    userList.deleteHead();
}
 
char* Adeon::editUserPhone(const char* actualPhoneNum, const char* newPhoneNum){
    return userList.editItemId(userList.findItem(actualPhoneNum), newPhoneNum);
}
 
void Adeon::editUserRights(const char* phoneNum, uint16_t userGroup){
    userList.editItemVal(userList.findItem(phoneNum), userGroup);
}
 
bool Adeon::isUserInAdeon(const char* phoneNum){
    return userList.isInList(userList.findItem(phoneNum));
}
 
uint8_t Adeon::getNumOfUsers(){
    return userList.getNumOfItems();
}
 
uint16_t Adeon::getUserRightsLevel(const char* phoneNum){
    return userList.getItemVal(userList.findItem(phoneNum));
}
 
void Adeon::printUsers(){
    userList.printData();
}
 
void Adeon::addParam(const char* pName, uint16_t val){
    paramList.addItem(pName, val);
}
 
void Adeon::addParamWithCallback(void (*callback)(uint16_t), const char* pName, uint16_t val){
    paramList.addItemWithCallback(pName, val, callback);
}
 
void Adeon::setParamAccess(const char* pName, uint8_t access){
    paramList.setParamAccess(paramList.findItem(pName), access);
}
 
void Adeon::deleteParam(const char* pName){
    paramList.deleteItem(paramList.findItem(pName));
}
 
char* Adeon::editParamName(const char* pActualName, const char* pNewName){
    return paramList.editItemId(paramList.findItem(pActualName), pNewName);
}
 
void Adeon::editParamValue(const char* pName, uint16_t val){
    paramList.editItemVal(paramList.findItem(pName), val);
}
 
bool Adeon::isParamInAdeon(const char* pName){
    return paramList.isInList(paramList.findItem(pName));
}
 
uint8_t Adeon::getNumOfParams(){
    return paramList.getNumOfItems();
}
 
uint16_t Adeon::getParamValue(const char* pName){
    return paramList.getItemVal(paramList.findItem(pName));
}
 
void Adeon::printParams(){
    paramList.printData();
}
 
void Adeon::parseBuf(const char* pMsg, uint8_t userGroup){
    char* tmpName;
    if(strlen(pMsg) <= MSG_BUFFER_LENGTH && parser.isParserReady() && !paramList.isListEmpty()){
        _ready = false;
        memset(_msg, 0, sizeof(_msg));
        strcpy(_msg, pMsg);
        if(parser.isMsgValid()){
            while(parser.isNameAvailable()){
                parser.parse();
                tmpName = parser.getTmpName();
                if(isParamInAdeon(tmpName) && (getParamAccess(tmpName) >= userGroup)){
                    editParamValue(tmpName, parser.getValue());
                }
            }
        }
        else{
            Serial.println("Message is invalid");
        }
        _ready = true;
    }
}
 
bool Adeon::isAdeonReady(){
    return _ready;
}
 
uint8_t Adeon::getParamAccess(const char* pName){
    return paramList.getParamAccess(paramList.findItem(pName));
}
 
Adeon::Parser::Parser(char* pMsg){
    _pMsg = pMsg;
}
 
bool Adeon::Parser::isParserReady(){
    return parsState == State::READY;
}
 
bool Adeon::Parser::isMsgValid(){
    if(isHashParsingValid()){
        parsState = State::INIT;
        parse();
        return true;
    }
    return false;
}
 
bool Adeon::Parser::isNameAvailable(){
    if(_processedNames < _numberOfNames){
        return true;
    }
    parsState = State::READY;    
    return false;
}
 
void Adeon::Parser::parse(){
    switch(parsState){
    case State::INIT:
        _processedNames = 0;
        _numberOfNames = getNumberOfNames();        
        parsState = State::PROCESSING;
        break;
    case State::PROCESSING:
        char* tmpStr;
        tmpStr = parseName();
        parseValue(tmpStr);
        _processedNames++;
        break;
        default:
        break;
    }
}
 
char* Adeon::Parser::getTmpName(){
    return _pTmpName;
}
 
uint16_t Adeon::Parser::getValue(){
    return _tmpValue;
}
 
bool Adeon::Parser::isHashParsingValid(){
    char* pEndSymbol = strchr(_pMsg, _hashEndSymbol);
    //if wrong format (no colon) return false
    if(pEndSymbol != nullptr){
        uint8_t hashLen = strlen(_pMsg) - strlen(pEndSymbol);
        
        if(hashLen == SHORT_HASH_LENGTH){
            strncpy(_tmpHash, _pMsg, hashLen);
            return _pHash.isHashValid(pEndSymbol + 2, _tmpHash);
        }
    }
    return false;
}
 
uint8_t Adeon::Parser::getNumberOfNames(){
    uint8_t msgLen = strlen(_pMsg);
    uint8_t semicolonCount = 0;
 
    for(int i = 0; i < msgLen; i++){
        if(_pMsg[i] == _semicolon){
            semicolonCount++;
        }
    }
    return semicolonCount;
}
 
char* Adeon::Parser::parseName(){
    char* tmp;
    if(_processedNames == 0){
        tmp = positionOfStr(_pMsg, 1, _gap);
        strcpy(_pTmpName,getCharsUntilEndSym(tmp, _gap));
    }
    else{
        tmp = positionOfStr(_pMsg, _processedNames, _semicolon);
        strcpy(_pTmpName, getCharsUntilEndSym(tmp, _gap));
    }
    return tmp;
}
 
void Adeon::Parser::parseValue(char* pActualParam){
    char* tmp;
    tmp = positionOfStr(pActualParam, 1, _equal) + 1; //address plus one because of the gap
    tmp = getCharsUntilEndSym(tmp, _semicolon);
    _tmpValue = (uint16_t)atoi(tmp);
}
 
char* Adeon::Parser::getCharsUntilEndSym(char* pActualParam, char endSymbol){
    int i = 0;
    char* endPointer;
    while(pActualParam[i] != endSymbol){
        i++;
    }
    endPointer = &pActualParam[i];
 
    memset(_subStr, 0, sizeof(_subStr));
    i = 0;
    while(&pActualParam[i] != endPointer){
      _subStr[i] = pActualParam[i];
      i++;
    }
    _subStr[i] = _nullChar;
    return _subStr;
}
 
char* Adeon::Parser::positionOfStr(char* pStr, uint8_t pos, char startSymbol){
    uint8_t symCount = 0;
    uint8_t i = 0;
    while(symCount != pos){
        if(pStr[i] == startSymbol){
            symCount++;
        }
        i++;
    }
    return &pStr[i];
}
 
Adeon::Parser::Hash::Hash(){
 
}
 
bool Adeon::Parser::Hash::isHashValid(char* msg, char* hash){
    makeHashFromStr(msg);
    return(strcmp(_shortHash, hash) == 0);
}
 
void Adeon::Parser::Hash::makeHashFromStr(char* msg){
    unsigned char* hash = MD5::make_hash(msg);
    char* md5Str = MD5::make_digest(hash, 16);   
    free(hash);
    makeShortHash(md5Str);
    free(md5Str);
}
 
void Adeon::Parser::Hash::makeShortHash(char* str){
    uint8_t strLength = strlen(str); 
    memset(_shortHash, 0, sizeof(_shortHash));
    strcpy(_shortHash, &str[strLength - SHORT_HASH_LENGTH]);
}
 
void Adeon::ParameterList::addItemWithCallback(const char* pId, uint16_t val, void (*callback)(uint16_t)){
    Item* pItem = addItem(pId, val);
 
    if (pItem == nullptr) {
        Serial.print("Adeon: Unable to add parameter "); Serial.println(pId);
        return;
    }
 
    pItem->_pCallback = callback;
}
 
void Adeon::ParameterList::setParamAccess(Item* pItem, uint8_t access){
    pItem->accessRights = access;
}
 
uint8_t Adeon::ParameterList::getParamAccess(Item* pItem){
    return pItem->accessRights;
}