diff options
Diffstat (limited to 'src/MTS_IO_CellularRadio.cpp')
| -rw-r--r-- | src/MTS_IO_CellularRadio.cpp | 299 |
1 files changed, 246 insertions, 53 deletions
diff --git a/src/MTS_IO_CellularRadio.cpp b/src/MTS_IO_CellularRadio.cpp index f0df7fd..fb1d02b 100644 --- a/src/MTS_IO_CellularRadio.cpp +++ b/src/MTS_IO_CellularRadio.cpp @@ -22,6 +22,7 @@ #include <unistd.h> #include <sys/stat.h> +#include <algorithm> #include <mts/MTS_IO_MccMncTable.h> #include <mts/MTS_Thread.h> @@ -1779,27 +1780,81 @@ ICellularRadio::CODE CellularRadio::sendBasicQuery(const std::string& sCmd, cons return SUCCESS; } +ICellularRadio::CODE CellularRadio::isCommandSupported(const std::string& sCmd, bool& bIsSupported) { + CODE rc; + bIsSupported = false; + + rc = sendBasicCommand(sCmd); + + if (SUCCESS == rc) { + bIsSupported = true; + } else if (ERROR == rc) { + // if not applicable + rc = SUCCESS; + } + + return rc; +} + ICellularRadio::CODE CellularRadio::getSelectedBandsRaw(std::string& sRawBands) { printTrace("%s| Acquiring selected bands: not applicable", m_sName.c_str()); return NOT_APPLICABLE; } -ICellularRadio::CODE CellularRadio::getPdpContexts(Json::Value& jData) { - printTrace("%s| Fetching the list of PDP contexts from the radio", getName().c_str()); +ICellularRadio::CODE CellularRadio::convertPdpContextAuthTypeToString(PDP_CONTEXT_AUTH_TYPE eAuthType, std::string& sAuthType) { + CODE rc = FAILURE; + + switch (eAuthType) { + case NONE: sAuthType = VALUE_PDP_CONTEXT_AUTH_TYPE_NONE; rc = SUCCESS; break; + case PAP: sAuthType = VALUE_PDP_CONTEXT_AUTH_TYPE_PAP; rc = SUCCESS; break; + case CHAP: sAuthType = VALUE_PDP_CONTEXT_AUTH_TYPE_CHAP; rc = SUCCESS; break; + case PAP_CHAP: sAuthType = VALUE_PDP_CONTEXT_AUTH_TYPE_PAP_CHAP; rc = SUCCESS; break; + default: sAuthType = ICellularRadio::VALUE_UNKNOWN; break; + } + return rc; +} + +ICellularRadio::CODE MTS::IO::CellularRadio::convertStringToPdpContextAuthType(const std::string& sAuthType, PDP_CONTEXT_AUTH_TYPE& eAuthType) { + CODE rc = FAILURE; + if (VALUE_PDP_CONTEXT_AUTH_TYPE_NONE == sAuthType) { + eAuthType = PDP_CONTEXT_AUTH_TYPE::NONE; + rc = SUCCESS; + } else if (VALUE_PDP_CONTEXT_AUTH_TYPE_PAP == sAuthType) { + eAuthType = PDP_CONTEXT_AUTH_TYPE::PAP; + rc = SUCCESS; + } else if (VALUE_PDP_CONTEXT_AUTH_TYPE_CHAP == sAuthType) { + eAuthType = PDP_CONTEXT_AUTH_TYPE::CHAP; + rc = SUCCESS; + } else if (VALUE_PDP_CONTEXT_AUTH_TYPE_PAP_CHAP == sAuthType) { + eAuthType = PDP_CONTEXT_AUTH_TYPE::PAP_CHAP; + rc = SUCCESS; + } + return rc; +} + +// When there are no defined contexts +// Telit returns: +// OK +// Quectel returns: +// +CGDCONT: +// +// OK +ICellularRadio::CODE CellularRadio::getPdpContextsBase(Json::Value& jData) { CODE rc; const std::string sCommand = "AT+CGDCONT?"; const int dTimeout = 1000; std::string sResult; + jData = Json::objectValue; + rc = sendBasicQuery(sCommand, "", sResult, dTimeout); if (rc != SUCCESS) { return rc; } - std::vector<std::string> vContexts = MTS::Text::split(sResult, "+CGDCONT: "); - std::vector<std::string> vContextParams; + std::vector<std::string> vContexts = MTS::Text::split(sResult, "+CGDCONT:"); for (size_t i = 0; i < vContexts.size(); i++) { vContexts[i] = MTS::Text::trim(vContexts[i]); @@ -1808,7 +1863,7 @@ ICellularRadio::CODE CellularRadio::getPdpContexts(Json::Value& jData) { continue; } - vContextParams = MTS::Text::split(vContexts[i], ",", 4); + std::vector<std::string> vContextParams = MTS::Text::split(vContexts[i], ",", 4); if (vContextParams.size() < 3) { return FAILURE; @@ -1825,78 +1880,216 @@ ICellularRadio::CODE CellularRadio::getPdpContexts(Json::Value& jData) { return SUCCESS; } -ICellularRadio::CODE CellularRadio::setPdpContext(const std::string& sId, const Json::Value& jConfig) { - printTrace("%s| Setting context to the radio", getName().c_str()); +ICellularRadio::CODE CellularRadio::getPdpContexts(Json::Value& jData) { + printTrace("%s| Fetching the list of PDP contexts from the radio", getName().c_str()); CODE rc; + bool bPdpAuthSupported; - if (sId.empty()) { - printError("%s| PDP Context ID is not specified", getName().c_str()); - return FAILURE; + // check if pdp context authentication is applicable + rc = isPdpContextAuthSupported(bPdpAuthSupported); + if (SUCCESS != rc) { + return rc; } - std::string sCommand = "AT+CGDCONT=" + sId; - const int dTimeout = 1000; - - Json::Value jAllContexts; + rc = getPdpContextsBase(jData); - rc = getPdpContexts(jAllContexts); - if (rc != SUCCESS) { - printError("%s| Failed to retrieve the current PDP context configuration: [%d]", getName().c_str(), rc); + if (SUCCESS != rc) { + printError("%s| Failed to fetch the list of the defined PDP contexts from the radio", getName().c_str()); return rc; } - // Remove the context if no parameters defined - if (!jConfig.isMember(ICellularRadio::KEY_PDP_CONTEXT_IPMODE) && !jConfig.isMember(ICellularRadio::KEY_PDP_CONTEXT_APN)) { - if (jAllContexts.isMember(sId)) { - rc = sendBasicCommand(sCommand, dTimeout); + if (bPdpAuthSupported) { + rc = fillPdpContextAuthFields(jData); + + if (SUCCESS != rc) { + printError("%s| Failed to fetch the authentication parameters for PDP contexts", getName().c_str()); return rc; - } else { - printError("%s| PDP Context [%s] does not exist", getName().c_str(), sId.c_str()); - return FAILURE; } } - std::string sIpMode; + return SUCCESS; +} - if (jConfig.isMember(ICellularRadio::KEY_PDP_CONTEXT_IPMODE)) { - if (jConfig[ICellularRadio::KEY_PDP_CONTEXT_IPMODE] == "IP" || jConfig[ICellularRadio::KEY_PDP_CONTEXT_IPMODE] == "PPP" || - jConfig[ICellularRadio::KEY_PDP_CONTEXT_IPMODE] == "IPV6" || jConfig[ICellularRadio::KEY_PDP_CONTEXT_IPMODE] == "IPV4V6") { - sIpMode = jConfig[ICellularRadio::KEY_PDP_CONTEXT_IPMODE].asString(); - } else { - printError("%s| Invalid IP Mode defined: [%s]", getName().c_str(), jConfig[ICellularRadio::KEY_PDP_CONTEXT_IPMODE].asString().c_str()); - return FAILURE; +ICellularRadio::CODE CellularRadio::mergePdpContexts(const std::string& sId, const Json::Value& jCurrentContext, const Json::Value& jChanges, Json::Value& jResult) { + jResult[KEY_PDP_CONTEXT_ID] = sId; + + if (jChanges.isMember(KEY_PDP_CONTEXT_IPMODE)) { + jResult[KEY_PDP_CONTEXT_IPMODE] = jChanges[KEY_PDP_CONTEXT_IPMODE].asString(); + } else if (jCurrentContext.isMember(KEY_PDP_CONTEXT_IPMODE)) { + printInfo("%s| Re-using IP Mode [%s] for PDP context [%s]", getName().c_str(), jCurrentContext[KEY_PDP_CONTEXT_IPMODE].asString().c_str(), sId.c_str()); + jResult[KEY_PDP_CONTEXT_IPMODE] = jCurrentContext[KEY_PDP_CONTEXT_IPMODE].asString(); + } + + if (jChanges.isMember(KEY_PDP_CONTEXT_APN)) { + jResult[KEY_PDP_CONTEXT_APN] = jChanges[KEY_PDP_CONTEXT_APN].asString(); + } else if (jCurrentContext.isMember(KEY_PDP_CONTEXT_APN)) { + printInfo("%s| Re-using APN [%s] for PDP context [%s]", getName().c_str(), jCurrentContext[KEY_PDP_CONTEXT_APN].asString().c_str(), sId.c_str()); + jResult[KEY_PDP_CONTEXT_APN] = jCurrentContext[KEY_PDP_CONTEXT_APN].asString(); + } + + if (jChanges.isMember(KEY_PDP_CONTEXT_AUTH_TYPE)) { + jResult[KEY_PDP_CONTEXT_AUTH_TYPE] = jChanges[KEY_PDP_CONTEXT_AUTH_TYPE].asString(); + } + + if (jChanges.isMember(KEY_PDP_CONTEXT_AUTH_USERNAME)) { + jResult[KEY_PDP_CONTEXT_AUTH_USERNAME] = jChanges[KEY_PDP_CONTEXT_AUTH_USERNAME].asString(); + } + + if (jChanges.isMember(KEY_PDP_CONTEXT_AUTH_PASSWORD)) { + jResult[KEY_PDP_CONTEXT_AUTH_PASSWORD] = jChanges[KEY_PDP_CONTEXT_AUTH_PASSWORD].asString(); + } + + return SUCCESS; +} + +ICellularRadio::CODE CellularRadio::initPdpContextInfo(const Json::Value& jConfig, PdpContextInfo& pdpContextResult) { + // validate IP mode + if (jConfig[KEY_PDP_CONTEXT_IPMODE].asString() != VALUE_PDP_CONTEXT_IP_MODE_IP && + jConfig[KEY_PDP_CONTEXT_IPMODE].asString() != VALUE_PDP_CONTEXT_IP_MODE_IPV6 && + jConfig[KEY_PDP_CONTEXT_IPMODE].asString() != VALUE_PDP_CONTEXT_IP_MODE_IPV4V6) { + printError("%s| The PDP context IP mode value is invalid [%s]", getName().c_str(), jConfig[KEY_PDP_CONTEXT_IPMODE].asString().c_str()); + return INVALID_ARGS; + } + + // validate authentication fields only if it is present + if (jConfig.isMember(KEY_PDP_CONTEXT_AUTH_TYPE)) { + + // check if the PDP context authentication is supported by the radio + const auto& sRequested = jConfig[KEY_PDP_CONTEXT_AUTH_TYPE].asString(); + const auto& vSupported = getSupportedPdpContextAuthTypes(); + + auto supportCheck = [sRequested](const std::string& sElement) { + return sRequested == sElement; + }; + + if (std::none_of(vSupported.begin(), vSupported.end(), supportCheck)) { + printError("%s| PDP context parameters: authentication type [%s] is not supported", getName().c_str(), jConfig[KEY_PDP_CONTEXT_AUTH_TYPE].asString().c_str()); + return INVALID_ARGS; } - } else if (jAllContexts.isMember(sId)) { - printInfo("%s| Re-using IP Mode [%s] for PDP context [%s]", getName().c_str(), jAllContexts[sId][ICellularRadio::KEY_PDP_CONTEXT_IPMODE].asString().c_str(), sId.c_str()); - sIpMode = jAllContexts[sId][ICellularRadio::KEY_PDP_CONTEXT_IPMODE].asString(); - } else { - printError("%s| Failed to edit PDP context [%s] - no such context defined", getName().c_str(), sId.c_str()); - return FAILURE; } - sCommand += ",\""; - sCommand += sIpMode; - sCommand += "\""; + if (! jConfig.isMember(KEY_PDP_CONTEXT_AUTH_TYPE) && (jConfig.isMember(KEY_PDP_CONTEXT_AUTH_USERNAME) || jConfig.isMember(KEY_PDP_CONTEXT_AUTH_PASSWORD))) { + printError("%s| PDP context authentication type is not provided, but username or password are given", getName().c_str()); + return INVALID_ARGS; + } - std::string sApn; + if (jConfig.isMember(KEY_PDP_CONTEXT_AUTH_TYPE) && jConfig[KEY_PDP_CONTEXT_AUTH_TYPE].asString() != VALUE_PDP_CONTEXT_AUTH_TYPE_NONE && + ! (jConfig.isMember(KEY_PDP_CONTEXT_AUTH_USERNAME) && jConfig.isMember(KEY_PDP_CONTEXT_AUTH_PASSWORD))) { + printError("%s| PDP context authentication type [%s]. The username or password are not provided", getName().c_str(), jConfig[KEY_PDP_CONTEXT_AUTH_TYPE].asString().c_str()); + return INVALID_ARGS; + } - if (jConfig.isMember(ICellularRadio::KEY_PDP_CONTEXT_APN)) { - sApn = jConfig[ICellularRadio::KEY_PDP_CONTEXT_APN].asString(); - } else if (jAllContexts.isMember(sId)) { - printInfo("%s| Re-using APN [%s] for PDP context [%s]", getName().c_str(), jAllContexts[sId][ICellularRadio::KEY_PDP_CONTEXT_APN].asString().c_str(), sId.c_str()); - sApn = jAllContexts[sId][ICellularRadio::KEY_PDP_CONTEXT_APN].asString(); - } else { - printError("%s| Failed to edit PDP context [%s] - no such context defined", getName().c_str(), sId.c_str()); - return FAILURE; + // fills with empty string if there are no such fields + pdpContextResult.sId = jConfig[KEY_PDP_CONTEXT_ID].asString(); + pdpContextResult.sIpMode = jConfig[KEY_PDP_CONTEXT_IPMODE].asString(); + pdpContextResult.sApn = jConfig[KEY_PDP_CONTEXT_APN].asString(); + pdpContextResult.sAuthType = jConfig[KEY_PDP_CONTEXT_AUTH_TYPE].asString(); + pdpContextResult.sUsername = jConfig[KEY_PDP_CONTEXT_AUTH_USERNAME].asString(); + pdpContextResult.sPassword = jConfig[KEY_PDP_CONTEXT_AUTH_PASSWORD].asString(); + + return SUCCESS; +} + +ICellularRadio::CODE CellularRadio::isPdpContextAuthEditRequired(const Json::Value& jConfig, bool& bIsAuthEditRequired) { + bIsAuthEditRequired = false; + + if (jConfig.isMember(KEY_PDP_CONTEXT_AUTH_TYPE) || + jConfig.isMember(KEY_PDP_CONTEXT_AUTH_PASSWORD) || + jConfig.isMember(KEY_PDP_CONTEXT_AUTH_USERNAME)) { + bIsAuthEditRequired = true; } + return SUCCESS; +} + +ICellularRadio::CODE CellularRadio::setPdpContextBase(const PdpContextInfo& pdpContext) { + std::string sCommand = "AT+CGDCONT="; + const int dTimeout = 1000; + + sCommand += pdpContext.sId; sCommand += ",\""; - sCommand += sApn; + sCommand += pdpContext.sIpMode; + sCommand += "\",\""; + sCommand += pdpContext.sApn; sCommand += "\""; - rc = sendBasicCommand(sCommand, dTimeout); + return sendBasicCommand(sCommand, dTimeout); +} + +ICellularRadio::CODE CellularRadio::deletePdpContext(const std::string& sId) { + std::string sCommand = "AT+CGDCONT=" + sId; + const int dTimeout = 1000; - return rc; + return sendBasicCommand(sCommand, dTimeout); +} + +ICellularRadio::CODE CellularRadio::setPdpContext(const std::string& sId, const Json::Value& jConfig) { + printTrace("%s| Setting PDP context [%s] to the radio", getName().c_str(), sId.c_str()); + + CODE rc; + Json::Value jCurrentContexts; + bool bPdpAuthSupported; + bool bPdpAuthEditRequired; + PdpContextInfo pdpContext; + + if (sId.empty()) { + printError("%s| PDP Context ID is not specified", getName().c_str()); + return INVALID_ARGS; + } + + rc = getPdpContexts(jCurrentContexts); + if (SUCCESS != rc) { + return rc; + } + + // DELETE context + + if (jConfig.empty()) { + rc = deletePdpContext(sId); + if (SUCCESS != rc) { + printError("%s| Failed to delete PDP context [%s]", getName().c_str(), sId.c_str()); + } + return rc; + } + + // ADD or EDIT context + + // check if PDP context authentication is applicable + + (void) isPdpContextAuthEditRequired(jConfig, bPdpAuthEditRequired); + + rc = isPdpContextAuthSupported(bPdpAuthSupported); + if (SUCCESS != rc) { + return rc; + } + + if (! bPdpAuthSupported && bPdpAuthEditRequired) { + printError("%s| PDP context authentication is not supported by this radio, but arguments are provided", getName().c_str()); + return INVALID_ARGS; + } + + Json::Value jResult; + + // Edit - fetch missing arguments from the current state. + (void) mergePdpContexts(sId, jCurrentContexts[sId], jConfig, jResult); + + // validate fields and create a PDP context structure to use in the commands + rc = initPdpContextInfo(jResult, pdpContext); + if (SUCCESS != rc) { + return rc; + } + + // setting context + rc = setPdpContextBase(pdpContext); + if (SUCCESS != rc) { + return rc; + } + + if (bPdpAuthSupported && bPdpAuthEditRequired) { + return setPdpContextAuth(pdpContext); + } + + return SUCCESS; } ICellularRadio::CODE CellularRadio::getDiagnostics(std::string& sReport) { |