// Override from base class BOOL CChannel_ATCmd::OpenPort() { BOOL bRetVal = FALSE; RIL_LOG_INFO("CChannel_ATCmd::OpenPort() - Opening COM Port: %s...\r\n", g_szCmdPort); RIL_LOG_INFO("CChannel_ATCmd::OpenPort() - g_bIsSocket=[%d]...\r\n", g_bIsSocket); bRetVal = m_Port.Open(g_szCmdPort, g_bIsSocket); RIL_LOG_INFO("CChannel_ATCmd::OpenPort() - Opening COM Port: %s\r\n", bRetVal ? "SUCCESS" : "FAILED!"); return bRetVal; }
BOOL CellInfoCache::updateCache(const P_ND_N_CELL_INFO_DATA pData, const INT32 aItemsCount) { BOOL ret = FALSE; RIL_LOG_VERBOSE("CellInfoCache::updateCache() - aItemsCount %d \r\n",aItemsCount); if (NULL == pData || aItemsCount > RRIL_MAX_CELL_ID_COUNT) { RIL_LOG_INFO("CellInfoCache::updateCache() - Invalid data\r\n"); goto Error; } else { // if there were more items in the cache before if (aItemsCount != m_iCacheSize) { ret = TRUE; } else { for (INT32 storeIndex= 0; storeIndex < aItemsCount; storeIndex++) { if (checkCache(pData->pnCellData[storeIndex]) < 0 ) // new item { ret = TRUE; break; } } } } if (ret) { RIL_LOG_INFO("CellInfoCache::updateCache() -" "Updating cache with %d items\r\n", aItemsCount); // Access mutex CMutex::Lock(m_pCacheLock); m_iCacheSize = aItemsCount; memset(&m_sCellInfo, 0, sizeof(S_ND_N_CELL_INFO_DATA)); for (INT32 j = 0; j < m_iCacheSize; j++) { m_sCellInfo.pnCellData[j] = pData->pnCellData[j]; } // release mutex CMutex::Unlock(m_pCacheLock); } Error: return ret; }
// CContextInitString void CContextInitString::Execute(BOOL bRes, UINT32 /*uiErrorCode*/) { if (m_bFinalCmd) { RIL_LOG_INFO("CContextInitString::Execute() - Last command for init index [%d] on channel" " [%d] had result [%s]\r\n", m_eInitIndex, m_uiChannel, bRes ? "OK" : "FAIL"); if (!bRes) { char szIndex[MAX_STRING_SIZE_FOR_INT] = { '\0' }; char szChannel[MAX_STRING_SIZE_FOR_INT] = { '\0' }; snprintf(szIndex, sizeof(szIndex), "%d", (int) m_eInitIndex); snprintf(szChannel, sizeof(szChannel), "%u", m_uiChannel); RIL_LOG_CRITICAL("CContextInitString::Execute() - " "Init command send failed, set system state as uninitialized !\r\n"); CSystemManager::GetInstance().SetInitializationUnsuccessful(); DO_REQUEST_CLEAN_UP(4, "Init command failed", "", szIndex, szChannel); } else { CSystemManager::GetInstance().TriggerInitStringCompleteEvent(m_uiChannel, m_eInitIndex); } } }
BOOL CPort::OpenSocket(const char* pszSocketName) { RIL_LOG_VERBOSE("CPort::OpenSocket() - Enter\r\n"); // TODO : Pull this from repository const char szSocketInit[] = "gsm"; UINT32 uiBytesWritten = 0; UINT32 uiBytesRead = 0; char szResponse[10] = {0}; BOOL fRet = FALSE; const UINT32 uiRetries = 30; const UINT32 uiInterval = 2000; for (UINT32 uiAttempts = 0; uiAttempts < uiRetries; uiAttempts++) { fRet = CFile::Open(m_pFile, pszSocketName, 0, 0, TRUE); if (fRet) { m_fIsPortOpen = TRUE; RIL_LOG_INFO("CPort::OpenSocket() - Port is open!!\r\n"); break; } Sleep(uiInterval); } if (fRet) { if (Write(szSocketInit, strlen(szSocketInit), uiBytesWritten)) { if (Read(szResponse, sizeof(szResponse), uiBytesRead)) { m_fIsPortOpen = TRUE; } else { RIL_LOG_CRITICAL("CPort::OpenSocket() - Unable to read response from socket\r\n"); fRet = FALSE; } } else { RIL_LOG_CRITICAL("CPort::OpenSocket() - Unable to write \"%s\" to socket\r\n", szSocketInit); fRet = FALSE; } } RIL_LOG_VERBOSE("CPort::OpenSocket() - Exit\r\n"); return fRet; }
BOOL setmtu(int s, struct ifreq* ifr) { ifr->ifr_mtu = CTE::GetTE().GetMTU(); RIL_LOG_INFO("setmtu - calling SIOCSIFMTU\r\n"); if(ioctl(s, SIOCSIFMTU, ifr) < 0) { RIL_LOG_CRITICAL("setmtu: ERROR: SIOCSIFMTU\r\n"); return FALSE; } return TRUE; }
BOOL setflags(int s, struct ifreq* ifr, int set, int clr) { int ret; RIL_LOG_INFO("setflags - calling SIOCGIFFLAGS\r\n"); ret = ioctl(s, SIOCGIFFLAGS, ifr); if (ret < 0) { RIL_LOG_CRITICAL("setflags : SIOCGIFFLAGS : %s\r\n", strerror(errno)); return FALSE; } ifr->ifr_flags = (ifr->ifr_flags & (~clr)) | set; RIL_LOG_INFO("setflags - calling SIOCGIFFLAGS 2\r\n"); ret = ioctl(s, SIOCSIFFLAGS, ifr); if (ret < 0) { RIL_LOG_CRITICAL("setflags: SIOCSIFFLAGS 2 : %s\r\n", strerror(errno)); return FALSE; } return TRUE; }
BOOL setaddr(int s, struct ifreq* ifr, const char* addr) { int ret; init_sockaddr_in((struct sockaddr_in*) &ifr->ifr_addr, addr); RIL_LOG_INFO("setaddr - calling SIOCSIFADDR\r\n"); errno = 0; // NOERROR ret = ioctl(s, SIOCSIFADDR, ifr); if (ret < 0) { RIL_LOG_CRITICAL("setaddr() : SIOCSIFADDR : %s\r\n", strerror(errno)); return FALSE; } return TRUE; }
BOOL CSilo_Data::ParseNoCarrier(CResponse* const pResponse, const char*& /*rszPointer*/) { RIL_LOG_INFO("CSilo_Data::ParseNoCarrier() - Enter\r\n"); BOOL fRet = FALSE; CChannel_Data* pChannelData = NULL; if (pResponse == NULL) { RIL_LOG_CRITICAL("CSilo_Data::ParseNoCarrier() : pResponse was NULL\r\n"); goto Error; } pResponse->SetUnsolicitedFlag(TRUE); // Free this channel's context ID. pChannelData = CChannel_Data::GetChnlFromRilChannelNumber(m_pChannel->GetRilChannel()); if (NULL != pChannelData) { RIL_LOG_INFO("CSilo_Data::ParseNoCarrier() : Calling DataConfigDown chnl=[%u]," " cid=[%u]\r\n", m_pChannel->GetRilChannel(), pChannelData->GetContextID()); // Release network interface if (!CTE::GetTE().DataConfigDown(pChannelData->GetContextID(), TRUE)) { RIL_LOG_CRITICAL("CSilo_Data::ParseNoCarrier() - DataConfigDown FAILED chnl=[%u]," " cid=[%u]\r\n", m_pChannel->GetRilChannel(), pChannelData->GetContextID()); } } fRet = TRUE; Error: RIL_LOG_INFO("CSilo_Data::ParseNoCarrier() - Exit\r\n"); return fRet; }
// // IMS network support reporting // BOOL CSilo_IMS::ParseCIREPI(CResponse* const pResponse, const char*& rszPointer) { RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREPI() - Enter\r\n"); BOOL fRet = FALSE; UINT32 uiNwimsvops = 0; char szAlpha[MAX_BUFFER_SIZE]; int pos = 0; sOEM_HOOK_RAW_UNSOL_IMS_SUPPORT_STATUS data; if (NULL == pResponse) { RIL_LOG_CRITICAL("CSilo_IMS::ParseCIREPI() - pResponse is NULL.\r\n"); goto Error; } pResponse->SetUnsolicitedFlag(TRUE); // Throw out the alpha chars if there are any (void)ExtractQuotedString(rszPointer, szAlpha, MAX_BUFFER_SIZE, rszPointer); // Parse "<nwimsvops>" if (!ExtractUInt32(rszPointer, uiNwimsvops, rszPointer)) { RIL_LOG_CRITICAL("CSilo_IMS::ParseCIREPI() - Could not parse IMS Voice over PS" "support indication\r\n"); goto Error; } data.command = RIL_OEM_HOOK_RAW_UNSOL_IMS_SUPPORT_STATUS; data.status = uiNwimsvops; // Framework will trigger IMS registration depending on this information. RIL_LOG_INFO("CSilo_IMS::ParseCIREPI() - CIREPI=[%d]\r\n", uiNwimsvops); pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW); if (!pResponse->SetData((void*)&data, sizeof(sOEM_HOOK_RAW_UNSOL_IMS_SUPPORT_STATUS), TRUE)) { goto Error; } fRet = TRUE; Error: RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREPI() - Exit\r\n"); return fRet; }
// // IMS SRVCC Handover reporting // BOOL CSilo_IMS::ParseCIREPH(CResponse* const pResponse, const char*& rszPointer) { RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREPH() - Enter\r\n"); BOOL fRet = FALSE; UINT32 uiSrvcch = 0; char szAlpha[MAX_BUFFER_SIZE]; sOEM_HOOK_RAW_UNSOL_IMS_SRVCCH_STATUS data; if (NULL == pResponse) { RIL_LOG_CRITICAL("CSilo_IMS::ParseCIREPH() - pResponse is NULL.\r\n"); goto Error; } pResponse->SetUnsolicitedFlag(TRUE); // Throw out the alpha chars if there are any (void)ExtractQuotedString(rszPointer, szAlpha, MAX_BUFFER_SIZE, rszPointer); // Parse "<srvcch>" if (!ExtractUInt32(rszPointer, uiSrvcch, rszPointer)) { RIL_LOG_CRITICAL("CSilo_IMS::ParseCIREPH() - Could not parse IMS SRVCC" "Handover information\r\n"); goto Error; } data.command = RIL_OEM_HOOK_RAW_UNSOL_IMS_SRVCCH_STATUS; data.status = uiSrvcch; RIL_LOG_INFO("CSilo_IMS::ParseCIREPH() - CIREPH=[%d]\r\n", uiSrvcch); pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW); if (!pResponse->SetData((void*)&data, sizeof(sOEM_HOOK_RAW_UNSOL_IMS_SRVCCH_STATUS), TRUE)) { goto Error; } fRet = TRUE; Error: RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREPH() - Exit\r\n"); return fRet; }
BOOL CPort::WaitForAvailableData(UINT32 uiTimeout) { RIL_LOG_VERBOSE("CPort::WaitForAvailableData() - Enter\r\n"); BOOL fRet = FALSE; UINT32 uiMask = 0; if (m_fIsPortOpen) { fRet = CFile::WaitForEvent(m_pFile, uiMask, uiTimeout); if(fRet) { if (uiMask & FILE_EVENT_ERROR) { RIL_LOG_CRITICAL("CPort::WaitForAvailableData() - FILE_EVENT_ERROR received" " on port\r\n"); } if (uiMask & FILE_EVENT_BREAK) { RIL_LOG_INFO("CPort::WaitForAvailableData() - FILE_EVENT_BREAK received on" " port\r\n"); } if (uiMask & FILE_EVENT_RXCHAR) { fRet = TRUE; } } else { RIL_LOG_CRITICAL("CPort::WaitForAvailableData() - Returning failure\r\n"); } } else { CModemRestart::SaveRequestReason(3, "Port is not open", "", CFile::GetName(m_pFile)); RIL_LOG_CRITICAL("CPort::WaitForAvailableData() - Port is not open!\r\n"); } Error: RIL_LOG_VERBOSE("CPort::WaitForAvailableData() - Exit\r\n"); return fRet; }
CInitializer* CTE_XMM2230::GetInitializer() { RIL_LOG_VERBOSE("CTE_XMM2230::GetInitializer() - Enter\r\n"); CInitializer* pRet = NULL; RIL_LOG_INFO("CTE_XMM2230::GetInitializer() - Creating CInit2230 initializer\r\n"); m_pInitializer = new CInit2230(); if (NULL == m_pInitializer) { RIL_LOG_CRITICAL("CTE_XMM2230::GetInitializer() - Failed to create a CInit2230 " "initializer!\r\n"); goto Error; } pRet = m_pInitializer; Error: RIL_LOG_VERBOSE("CTE_XMM2230::GetInitializer() - Exit\r\n"); return pRet; }
BOOL setaddr6(int sockfd6, struct ifreq* ifr, const char* addr) { int ret; struct in6_ifreq ifr6; inet_pton(AF_INET6, addr, &ifr6.ifr6_addr); ioctl(sockfd6, SIOGIFINDEX, ifr); ifr6.ifr6_ifindex = ifr->ifr_ifindex; ifr6.ifr6_prefixlen = 64; //prefix_len; RIL_LOG_INFO("setaddr6() - calling SIOCSIFADDR ADDR:%s INET:%s\r\n",addr,ifr->ifr_name); errno = 0; ret = ioctl(sockfd6, SIOCSIFADDR, &ifr6); if (ret < 0) { RIL_LOG_CRITICAL("setaddr6() : SIOCSIFADDR : %s\r\n", strerror(errno)); return FALSE; } return TRUE; }
RIL_RESULT_CODE CTE_XMM2230::ParseBasebandVersion(RESPONSE_DATA& rRspData) { RIL_LOG_VERBOSE("CTE_XMM2230::ParseBasebandVersion() - Enter\r\n"); RIL_RESULT_CODE res = RRIL_RESULT_ERROR; const char* pszRsp = rRspData.szResponse; /* As baseband version is stored in a system property, it cannot be longer than * PROPERTY_VALUE_MAX-1 characters long (PROPERTY_VALUE_MAX counts the zero termination). * * + 1 is needed here as 'sscanf' will read PROPERTY_VALUE_MAX characters AND will add the * zero termination (cf comment above sscanf code). */ char* pszBasebandVersion = (char*) malloc(PROPERTY_VALUE_MAX + 1); if (NULL == pszBasebandVersion) { RIL_LOG_CRITICAL("CTE_XMM2230::ParseBasebandVersion() - Could not allocate memory" "for pszBasebandVersion\r\n"); goto Error; } memset(pszBasebandVersion, 0, PROPERTY_VALUE_MAX + 1); /* Modem version is what is reported between '*' in the +XGENDATA reply: * +XGENDATA: " XMM2230_REV_2.0 2013-Jul-31 13:42:17 * *CLV_2230_MODEM_01.1332.A* * OK * * This is retrieved using 'sscanf': * = %*[^*] : consumes (without storing) everything that is not '*' * = %*c : consumes (without storing) the '*' character * = %XXX[^*]: stores up to XXX chars or up to next '*' character in pszBasebandVersion * XXX's numerical value is constructed by converting the PROPERTY_VALUE_MAX * define to a string using the TO_STRING macro */ if (!sscanf(pszRsp, "%*[^*]%*c%" TO_STRING(PROPERTY_VALUE_MAX) "[^*]", pszBasebandVersion)) { RIL_LOG_CRITICAL("CTE_XMM2230::ParseBasebandVersion() - Could not " "extract the baseband version string.\r\n"); goto Error; } if (pszBasebandVersion[PROPERTY_VALUE_MAX - 1] != '\0') { RIL_LOG_WARNING("CTE_XMM6360::ParseBasebandVersion() - " "Modem version too long, reporting truncated version.\r\n"); pszBasebandVersion[PROPERTY_VALUE_MAX - 1] = '\0'; } if (pszBasebandVersion[0] == '\0') { RIL_LOG_CRITICAL("CTE_XMM2230::ParseBasebandVersion() - " "Invalid baseband version string.\r\n"); goto Error; } RIL_LOG_INFO("CTE_XMM2230::ParseBasebandVersion() - " "pszBasebandVersion=[%s]\r\n", pszBasebandVersion); rRspData.pData = (void*)pszBasebandVersion; rRspData.uiDataSize = sizeof(char*); res = RRIL_RESULT_OK; Error: if (RRIL_RESULT_OK != res) { free(pszBasebandVersion); pszBasebandVersion = NULL; } RIL_LOG_VERBOSE("CTE_XMM2230::ParseBasebandVersion() - Exit\r\n"); return res; }
// // Thermal sensor notification // BOOL CSilo_MISC::ParseXDRVI(CResponse* const pResponse, const char*& rszPointer) { RIL_LOG_VERBOSE("CSilo_MISC::ParseXDRVI() - Enter\r\n"); BOOL fRet = FALSE; sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND* pData = NULL; UINT32 nIpcChrGrp; UINT32 nIpcChrTempThresholdInd; UINT32 nXdrvResult; UINT32 nSensorId; UINT32 nTemp; if (NULL == pResponse) { RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - pResponse is NULL.\r\n"); goto Error; } pResponse->SetUnsolicitedFlag(TRUE); // Extract "<IPC_CHR_GRP>" if (!ExtractUInt32(rszPointer, nIpcChrGrp, rszPointer)) { RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Could not parse nIpcChrGrp.\r\n"); goto Error; } // Parse <IPC_CHR_TEMP_THRESHOLD_IND> if (!SkipString(rszPointer, ",", rszPointer) || !ExtractUInt32(rszPointer, nIpcChrTempThresholdInd, rszPointer)) { RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() -" " Unable to parse <IPC_CHR_TEMP_THRESHOLD_IND>!\r\n"); goto Error; } // Parse <xdrv_result> if (!SkipString(rszPointer, ",", rszPointer) || !ExtractUInt32(rszPointer, nXdrvResult, rszPointer)) { RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Unable to parse <xdrv_result>!\r\n"); goto Error; } // Parse <temp_sensor_id> if (!SkipString(rszPointer, ",", rszPointer) || !ExtractUInt32(rszPointer, nSensorId, rszPointer)) { RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Unable to parse <temp_sensor_id>!\r\n"); goto Error; } // Parse <temp> if (!SkipString(rszPointer, ",", rszPointer) || !ExtractUInt32(rszPointer, nTemp, rszPointer)) { RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Unable to parse <temp>!\r\n"); goto Error; } RIL_LOG_INFO("CSilo_MISC::ParseXDRVI - IPC_CHR_GRP: %u, IPC_CHR_TEMP_THRESHOLD_IND: %u," " xdrv_result: %u\r\n", nIpcChrGrp, nIpcChrTempThresholdInd, nXdrvResult); RIL_LOG_INFO("CSilo_MISC::ParseXDRVI - temp_sensor_id: %u, temp: %u\r\n", nSensorId, nTemp); pData = (sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND*)malloc( sizeof(sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND)); if (NULL == pData) { RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Could not allocate memory for pData.\r\n"); goto Error; } memset(pData, 0, sizeof(sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND)); pData->nCommand = RIL_OEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND; pData->nSensorId = nSensorId; pData->nTemp = nTemp; pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW); if (!pResponse->SetData((void*)pData, sizeof(sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND), FALSE)) { goto Error; } fRet = TRUE; Error: if (!fRet) { free(pData); pData = NULL; } RIL_LOG_VERBOSE("CSilo_MISC::ParseXDRVI() - Exit\r\n"); return fRet; }
// // No complexity is needed to parse the URC received for Coexistence purpose (+XMETRIC/+XNRTCWS). // The goal is just to extract the URC name/value and notify the up-layer (CWS Manager) about it. // BOOL CSilo_MISC::ParseCoexURC(CResponse* const pResponse, const char*& rszPointer, const char* pUrcPrefix) { RIL_LOG_VERBOSE("CSilo_MISC::ParseCoexURC() - Enter\r\n"); BOOL fRet = FALSE; char szExtInfo[MAX_BUFFER_SIZE] = {0}; sOEM_HOOK_RAW_UNSOL_COEX_INFO* pData = NULL; if (NULL == pResponse) { RIL_LOG_CRITICAL("CSilo_MISC::ParseCoexURC() - pResponse is NULL.\r\n"); goto Error; } pResponse->SetUnsolicitedFlag(TRUE); // Performing a backup of the URC string (rszPointer) into szExtInfo, to not modify rszPointer ExtractUnquotedString(rszPointer, '\r', szExtInfo, MAX_BUFFER_SIZE, rszPointer); RIL_LOG_VERBOSE("CSilo_MISC::ParseCoexURC() - URC prefix=[%s] URC value=[%s]\r\n", pUrcPrefix, szExtInfo); // Creating the response pData = (sOEM_HOOK_RAW_UNSOL_COEX_INFO*)malloc( sizeof(sOEM_HOOK_RAW_UNSOL_COEX_INFO)); if (NULL == pData) { RIL_LOG_CRITICAL("CSilo_MISC::ParseCoexURC() -" " Could not allocate memory for pData.\r\n"); goto Error; } memset(pData, 0, sizeof(sOEM_HOOK_RAW_UNSOL_COEX_INFO)); // pData.response will contain the final result (URC name + URC value) // Adding the prefix of the URC (+XMETRIC or +XNRTCWS) to pData->response if (!CopyStringNullTerminate(pData->response, pUrcPrefix, COEX_INFO_BUFFER_SIZE)) { RIL_LOG_CRITICAL("CSilo_MISC:ParseCoexURC - Copy of URC prefix failed\r\n"); goto Error; } // Adding the value of the URC to pData->response if (!ConcatenateStringNullTerminate(pData->response, sizeof(pData->response), szExtInfo)) { RIL_LOG_CRITICAL("CSilo_MISC::ParseCoexURC() : Failed to concat the URC " "prefix to its value!\r\n"); goto Error; } RIL_LOG_INFO("CSilo_MISC::ParseCoexURC() - Final Response=[%s]\r\n", pData->response); pData->command = RIL_OEM_HOOK_RAW_UNSOL_COEX_INFO; pData->responseSize = strnlen(pData->response, COEX_INFO_BUFFER_SIZE); pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW); if (!pResponse->SetData((void*)pData, sizeof(sOEM_HOOK_RAW_UNSOL_COEX_INFO), FALSE)) { goto Error; } fRet = TRUE; Error: if (!fRet) { free(pData); pData = NULL; } RIL_LOG_VERBOSE("CSilo_MISC::ParseCoexURC() - Exit\r\n"); return fRet; }
void CRequestInfoTable::GetRequestInfo(int requestID, REQ_INFO& rReqInfo) { RIL_LOG_VERBOSE("CRequestInfoTable::GetRequestInfo() - Enter\r\n"); // Set defaults if we can't find the request id rReqInfo.uiTimeout = CTE::GetTE().GetTimeoutAPIDefault(); if (m_rgpRequestInfos == NULL) { RIL_LOG_INFO("CRequestInfoTable::GetRequestInfo() - m_rgpRequestInfos is NULL\r\n"); goto Error; } else if (REQ_ID_NONE == requestID) { RIL_LOG_INFO("CRequestInfoTable::GetRequestInfo() - Request ID NONE given; assigning" " default values.\r\n"); goto Error; } else if ((requestID >= REQ_ID_TOTAL && requestID < INTERNAL_REQ_ID_START) || (requestID < 0)) { RIL_LOG_CRITICAL("CRequestInfoTable::GetRequestInfo() - Invalid request ID [0x%x]\r\n", requestID); goto Error; } // Internal request if (requestID >= INTERNAL_REQ_ID_START) { int index = requestID - INTERNAL_REQ_ID_START; CRepository repository; int iTemp = 0; memset(&rReqInfo, 0, sizeof(rReqInfo)); rReqInfo.uiTimeout = CTE::GetTE().GetTimeoutAPIDefault(); if (index < INTERNAL_REQ_ID_TOTAL) { if (repository.Read(g_szGroupInternalRequestTimeouts, g_ReqInternal[index].reqInfo.szName, iTemp)) { rReqInfo.uiTimeout = (UINT32)iTemp; } } } // Request from ril else if (NULL == m_rgpRequestInfos[requestID]) { CRepository repository; int iTemp = 0; memset(&rReqInfo, 0, sizeof(rReqInfo)); if (repository.Read(g_szGroupRequestTimeouts, g_pReqInfo[requestID].szName, iTemp)) { rReqInfo.uiTimeout = (UINT32)iTemp; } else { rReqInfo.uiTimeout = CTE::GetTE().GetTimeoutAPIDefault(); } // Use WAIT_FOREVER timeout if given time was 0 if (!rReqInfo.uiTimeout) { rReqInfo.uiTimeout = WAIT_FOREVER; } else if (CHardwareConfig::GetInstance().IsMultiSIM()) { // Timeout values need to be extended for Multi SIM capable modems, // depending on type of command (ie. network/non-network) switch (requestID) { case RIL_REQUEST_SETUP_DATA_CALL: // +CGACT, +CGDATA, +CGDCONT, +CGPADDR, +XDNS case RIL_REQUEST_DEACTIVATE_DATA_CALL: rReqInfo.uiTimeout = 2 * rReqInfo.uiTimeout + 50000; break; // network commands case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS: // +CCFC case RIL_REQUEST_SET_CALL_FORWARD: // +CCFC case RIL_REQUEST_QUERY_CALL_WAITING: // +CCWA case RIL_REQUEST_SET_CALL_WAITING: // +CCWA case RIL_REQUEST_RADIO_POWER: // +CFUN case RIL_REQUEST_DATA_CALL_LIST: // +CGACT? case RIL_REQUEST_HANGUP: // +CHLD case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: // +CHLD case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: // +CHLD case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: // +CHLD case RIL_REQUEST_CONFERENCE: // +CHLD case RIL_REQUEST_UDUB: // +CHLD case RIL_REQUEST_SEPARATE_CONNECTION: // +CHLD case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: // +CHLD case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: // +CLCK case RIL_REQUEST_QUERY_FACILITY_LOCK: // +CLCK case RIL_REQUEST_SET_FACILITY_LOCK: // +CLCK case RIL_REQUEST_GET_CLIR: // +CLIR? case RIL_REQUEST_SET_CLIR: // +CLIR case RIL_REQUEST_SEND_SMS: // +CMGS case RIL_REQUEST_SMS_ACKNOWLEDGE: // +CNMA case RIL_REQUEST_OPERATOR: // +XCOPS case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: // +COPS? case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS: // +COPS=? case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: // +COPS case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL: // +COPS case RIL_REQUEST_SEND_USSD: // +CUSD case RIL_REQUEST_CANCEL_USSD: // +CUSD case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: // +SATD case RIL_REQUEST_DTMF_START: // +XVTS case RIL_REQUEST_DTMF_STOP: // +XVTS case RIL_REQUEST_DIAL: // ATD // non-network cmds requiring response case RIL_REQUEST_DELETE_SMS_ON_SIM: // +CMGD case RIL_REQUEST_SEND_SMS_EXPECT_MORE: // +CMMS, +CMGS case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG: // +CSCB? case RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION: // +CSCB case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: // +XCELLINFO case RIL_REQUEST_GET_CELL_INFO_LIST: // +XCELLINFO case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS: // +XTESM rReqInfo.uiTimeout = 2 * rReqInfo.uiTimeout + 10000; break; } } // Cache the data we just read (taking the cache access lock) if (m_pCacheAccessMutex) { CMutex::Lock(m_pCacheAccessMutex); } // Recheck if the cache is still empty if (NULL == m_rgpRequestInfos[requestID]) { REQ_INFO* pNewReqInfo = new REQ_INFO; if (NULL != pNewReqInfo) { *pNewReqInfo = rReqInfo; m_rgpRequestInfos[requestID] = pNewReqInfo; } } if (m_pCacheAccessMutex) { CMutex::Unlock(m_pCacheAccessMutex); } } else { rReqInfo = *m_rgpRequestInfos[requestID]; } Error: RIL_LOG_INFO("CRequestInfoTable::GetRequestInfo() - RequestID %d: Timeout [%u]\r\n", requestID, rReqInfo.uiTimeout); RIL_LOG_VERBOSE("CRequestInfoTable::GetRequestInfo() - Exit\r\n"); }
void ProfileProcess::run() { RIL_LOG_VERBOSE("ProfileProcess::run() - Enter\r\n"); bool isTeWriteNeeded = true; bool isMtWriteNeeded = true; // Char array that holds MT profile read in NVM char szReadMtProfile[UsatInitStateMachine::MAX_SIZE_PROFILE * 2 + 1] = {'\0'}; // Char array that holds TE profile to write read from repository.txt char szDefaultTeProfile[UsatInitStateMachine::MAX_SIZE_PROFILE * 2 + 1] = {'\0'}; // Char array that holds calculated TE profile to write char szTeCalculatedProfile[UsatInitStateMachine::MAX_SIZE_PROFILE * 2 + 1] = {'\0'}; // Char array that holds calculated MT profile to write char szMtCalculatedProfile[UsatInitStateMachine::MAX_SIZE_PROFILE * 2 + 1] = {'\0'}; // Array of char array that holds all of the profiles read in NVM char** ppszProfiles = NULL; // Byte array that holds TE profile to write read in repository.txt const BYTE* achDefaultTeProfile; // Byte array that holds MT mask to apply read in repository.txt const BYTE* achDefaultMtMask; // Char array that holds TE profile read in NVM const char* pszReadTeProfile; // Char array that holds MT profile read in NVM const char* pszReadMtProfile; // Char array that holds MT only profile read in NVM const char* pszReadMtOnlyProfile; // Features that can be both supported by MT and TE : see 3GPP 31.111 Annex Q // Byte 3.8: REFRESH // Byte 5.1: SET_UP_EVENT_LIST // Byte 12.1: OPEN_CHANNEL // Byte 12.2: CLOSE_CHANNEL // Byte 12.3: RECEIVE_DATA // Byte 12.4: SEND_DATA // Byte 12.5: GET_CHANNEL_STATUS // Byte 12.6: SERVICE_SEARCH // Byte 12.7: GET_SERVICE_INFORMATION // Byte 12.8: DECLARE_SERVICE const char TE_MT_SUPPORTED[] = "0000800001000000000000FF0000000000000000000000000000000000000000"; CCatProfile* pCatProfile = m_usatInitStateMachine.GetCatProfile(); ppszProfiles = m_usatInitStateMachine.GetProfileArray(); if (NULL == ppszProfiles) { RIL_LOG_CRITICAL("ProfileProcess::run() - Profile array is NULL\r\n"); goto Out; } pszReadTeProfile = isValidString(ppszProfiles[TE_PROFILE_STORAGE]) ? ppszProfiles[TE_PROFILE_STORAGE] : UsatInitStateMachine::DEFAULT_PROFILE; pszReadMtProfile = isValidString(ppszProfiles[MT_PROFILE_STORAGE]) ? ppszProfiles[MT_PROFILE_STORAGE] : UsatInitStateMachine::DEFAULT_PROFILE; pszReadMtOnlyProfile = isValidString(ppszProfiles[MT_ONLY_PROFILE_STORAGE]) ? ppszProfiles[MT_ONLY_PROFILE_STORAGE] : UsatInitStateMachine::DEFAULT_PROFILE; if (NULL == pCatProfile) { RIL_LOG_CRITICAL("ProfileProcess::run() - pCatProfile is NULL\r\n"); goto Out; } // Set new TE profile to use to the value in NVM in case of an error pCatProfile->SetTeProfile(pszReadTeProfile, strlen(pszReadTeProfile)); // Get TE profile read in repository.txt that should be written in NVM achDefaultTeProfile = pCatProfile->GetTeDefaultProfile(); if (NULL == achDefaultTeProfile) { RIL_LOG_CRITICAL("ProfileProcess::run() - TE profile read is NULL\r\n"); goto Out; } // Get MT mask read in repository.txt that should be apply to MT profile to disable // some modem features achDefaultMtMask = pCatProfile->GetMtMask(); if (NULL == achDefaultMtMask) { RIL_LOG_CRITICAL("ProfileProcess::run() - MT mask read is NULL\r\n"); goto Out; } if (!convertByteArrayIntoString(achDefaultTeProfile, UsatInitStateMachine::MAX_SIZE_PROFILE, szDefaultTeProfile)) { RIL_LOG_CRITICAL("ProfileProcess::run() - Could not convert TE into string\r\n"); goto Out; } // compare if TE read is equal to TE to write read in repository.txt if (CompareProfiles(pszReadTeProfile, szDefaultTeProfile)) { RIL_LOG_VERBOSE("ProfileProcess::run() - Same TE\r\n"); isTeWriteNeeded = false; // copy read TE to calculated TE memcpy(szTeCalculatedProfile, szDefaultTeProfile, strlen(szDefaultTeProfile) + 1); } else { // calculate new TE profile by doing Te = TeRepository AND NOT MtOnly if (!CalculateTeProfile(szDefaultTeProfile, pszReadMtOnlyProfile, szTeCalculatedProfile)) { RIL_LOG_CRITICAL("ProfileProcess::run() - Cannot calculate TE profile\r\n"); goto Out; } // Check if TE writing is needed by comparing calculated TE to the modem TE isTeWriteNeeded = !CompareProfiles(szTeCalculatedProfile, pszReadTeProfile); // Set new calculated TE profile pCatProfile->SetTeProfile(szTeCalculatedProfile, strlen(szTeCalculatedProfile)); } // Calculate new MT profile by doing Mt = MtModem AND NOT Te // then the MT mask is applied to remove some modem features if (!CalculateMtProfile(pszReadMtProfile, szTeCalculatedProfile, TE_MT_SUPPORTED, achDefaultMtMask, szMtCalculatedProfile)) { RIL_LOG_CRITICAL("ProfileProcess::run() - Cannot calculate MT profile\r\n"); goto Out; } // Check if writing MT is needed by comparing it to MT read in NVM isMtWriteNeeded = !CompareProfiles(szMtCalculatedProfile, pszReadMtProfile); if (!isMtWriteNeeded && !isTeWriteNeeded) { RIL_LOG_INFO("ProfileProcess::run() - No need to write profiles\r\n"); goto Out; } // Write profiles CTE::GetTE().WriteUsatProfiles(szTeCalculatedProfile, isTeWriteNeeded, szMtCalculatedProfile, isMtWriteNeeded); return; Out: if (m_usatInitStateMachine.GetReadyToActivate() && m_usatInitStateMachine.GetUiccState() == UsatInitStateMachine::UICC_ACTIVE) { m_usatInitStateMachine.PassToNextEvent(UsatInitStateMachine::SIM_READY_TO_ACTIVATE); } }
void UsatState::SimReadyToActivate() { RIL_LOG_INFO("UsatState::SimReadyToActivate() - Nothing to do\r\n"); }
void UsatState::SimReadyForReset() { RIL_LOG_INFO("UsatState::SimReadyForReset() - Nothing to do\r\n"); }
void UsatState::SimUnavailable() { RIL_LOG_INFO("UsatState::SimUnavailable() - Nothing to do\r\n"); }
void UsatState::ProfileRead() { RIL_LOG_INFO("UsatState::ProfileRead() - Nothing to do\r\n"); }
// // IMS-Register notification // BOOL CSilo_IMS::ParseCIREGU(CResponse* const pResponse, const char*& rszPointer) { RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREGU() - Enter\r\n"); BOOL fRet = FALSE; UINT32 uiRegInfo = 0; char szExtInfo[MAX_BUFFER_SIZE]; char szAlpha[MAX_BUFFER_SIZE]; int pos = 0; sOEM_HOOK_RAW_UNSOL_IMS_REG_STATUS data; if (NULL == pResponse) { RIL_LOG_CRITICAL("CSilo_IMS::ParseCIREGU() - pResponse is NULL.\r\n"); goto Error; } pResponse->SetUnsolicitedFlag(TRUE); // Throw out the alpha chars if there are any (void)ExtractQuotedString(rszPointer, szAlpha, MAX_BUFFER_SIZE, rszPointer); // Parse "<reg_info>" if (!ExtractUInt32(rszPointer, uiRegInfo, rszPointer)) { RIL_LOG_CRITICAL("CSilo_IMS::ParseCIREGU() - Could not parse IMS registration" "status indication\r\n"); goto Error; } // Parse ",<ext_info>" if any. Debug purpose only. if (SkipString(rszPointer, ",", rszPointer) && ExtractUnquotedString(rszPointer, m_cTerminator, szExtInfo, MAX_BUFFER_SIZE, rszPointer)) { RIL_LOG_INFO("CSilo_IMS::ParseCIREGU() - IMS capabilities: %s", szExtInfo); } data.command = RIL_OEM_HOOK_RAW_UNSOL_IMS_REG_STATUS; data.status = uiRegInfo; CTE::GetTE().SetImsRegistrationStatus(uiRegInfo); RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREGU() - CIREGU=[%d]\r\n", uiRegInfo); pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW); if (!pResponse->SetData((void*)&data, sizeof(sOEM_HOOK_RAW_UNSOL_IMS_REG_STATUS), TRUE)) { goto Error; } /* * When the IMS registration status change force the framework to query the data * registration state by completing RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED. */ RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, NULL, 0); fRet = TRUE; Error: RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREGU() - Exit\r\n"); return fRet; }
void triggerCellInfoList(void* param) { // querying cell information when radio request pending or not registered // results in no response from modem. if (NULL == param || CTE::GetTE().IsRadioRequestPending() || !CTE::GetTE().IsRegistered()) { CTE::GetTE().SetCellInfoTimerRunning(FALSE); return; } // Get the CellInfo rate and compare. // if the newly set rate is less or equal,continue reading cellinfo from modem // if it is more, then start a new timed call back with the difference in timeout RIL_LOG_VERBOSE("triggerCellInfoList- Enter\r\n"); int storedRate = CTE::GetTE().GetCellInfoListRate(); int requestedRate = (int)param; RIL_LOG_INFO("triggerCellInfoList- StoredRate %d Rate with callback %d\r\n", storedRate, requestedRate); if (requestedRate >= storedRate || requestedRate <= 0) { REQUEST_DATA rReqData; memset(&rReqData, 0, sizeof(REQUEST_DATA)); if (!CopyStringNullTerminate(rReqData.szCmd1, CTE::GetTE().GetReadCellInfoString(), sizeof(rReqData.szCmd1))) { RIL_LOG_CRITICAL("triggerCellInfoList() - Unable to create cellinfo command!\r\n"); return; } rReqData.pContextData = (void*)requestedRate; // The rate setting has not changed while waiting for time out // read the cell information and report to framework CCommand* pCmd = new CCommand(g_pReqInfo[RIL_REQUEST_GET_CELL_INFO_LIST].uiChannel, NULL, RIL_REQUEST_GET_CELL_INFO_LIST, rReqData, &CTE::ParseUnsolCellInfoListRate, &CTE::PostUnsolCellInfoListRate); if (pCmd) { if (!CCommand::AddCmdToQueue(pCmd)) { RIL_LOG_CRITICAL("triggerCellInfoList() - Unable to queue command!\r\n"); delete pCmd; pCmd = NULL; } } else { RIL_LOG_CRITICAL("triggerCellInfoList() - " "Unable to allocate memory for new command!\r\n"); } /* * requestedRate <= 0 means that the cell information query is triggered on * cell information change. Stop the timer only if the query is due to * timer expiry. */ if (requestedRate > 0) { CTE::GetTE().SetCellInfoTimerRunning(FALSE); } } // the settings have changed to not to report CELLINFO else if (INT_MAX == storedRate) { CTE::GetTE().SetCellInfoTimerRunning(FALSE); RIL_LOG_INFO("triggerCellInfoList- Unsol cell info disabled: %d\r\n", storedRate); } else { // A new rate setting, re run the timer for the difference if (storedRate > requestedRate) { RIL_requestTimedCallback(triggerCellInfoList, (void*)storedRate, ((storedRate - requestedRate) / 1000), 0); } } RIL_LOG_VERBOSE("triggerCellInfoList- Exit\r\n"); }
// // No complexity is needed to parse the URC received for Coexistence purpose (+XMETRIC/+XNRTCWS). // The goal is just to extract the URC name/value and notify the up-layer (CWS Manager) about it. // BOOL CSilo_rfcoexistence::ParseCoexReportURC(CResponse* const pResponse, const char*& rszPointer, const char* pUrcPrefix) { RIL_LOG_VERBOSE("CSilo_rfcoexistence::ParseCoexReportURC() - Enter\r\n"); BOOL bRet = FALSE; // prefix can be "+XMETRIC: " or "+XNRTCWSI: " const int MAX_PREFIX_SIZE = 12; // KW fix, total size of pData->response is COEX_INFO_BUFFER_SIZE // pData->response is made by pUrcPrefix + szExtInfo char szExtInfo[COEX_INFO_BUFFER_SIZE - MAX_PREFIX_SIZE] = {0}; sOEM_HOOK_RAW_UNSOL_COEX_REPORT* pData = NULL; if (NULL == pResponse) { RIL_LOG_CRITICAL("CSilo_rfcoexistence::ParseCoexReportURC() - pResponse is NULL.\r\n"); goto Error; } pResponse->SetUnsolicitedFlag(TRUE); // Extract the URC string (rszPointer) into szExtInfo, to not modify rszPointer ExtractUnquotedString(rszPointer, '\r', szExtInfo, (COEX_INFO_BUFFER_SIZE - MAX_PREFIX_SIZE), rszPointer); RIL_LOG_VERBOSE("CSilo_rfcoexistence::ParseCoexReportURC()- URC prefix=[%s] URC value=[%s]\r\n", pUrcPrefix, szExtInfo); // Creating the response pData = (sOEM_HOOK_RAW_UNSOL_COEX_REPORT*) malloc(sizeof(sOEM_HOOK_RAW_UNSOL_COEX_REPORT)); if (NULL == pData) { RIL_LOG_CRITICAL("CSilo_rfcoexistence::ParseCoexReportURC() -" " Could not allocate memory for pData.\r\n"); goto Error; } memset(pData, 0, sizeof(sOEM_HOOK_RAW_UNSOL_COEX_REPORT)); // pData.response will contain the final result (URC name + URC value) // Adding the prefix of the URC (+XMETRIC or +XNRTCWS) to pData->response if (!CopyStringNullTerminate(pData->response, pUrcPrefix, MAX_PREFIX_SIZE)) { RIL_LOG_CRITICAL("CSilo_rfcoexistence:ParseCoexReportURC - Copy of URC prefix failed\r\n"); goto Error; } // Adding the value of the URC to pData->response if (!ConcatenateStringNullTerminate(pData->response, sizeof(pData->response), szExtInfo)) { RIL_LOG_CRITICAL("CSilo_rfcoexistence::ParseCoexReportURC() : Failed to concat the URC " "prefix to its value!\r\n"); goto Error; } RIL_LOG_INFO("CSilo_rfcoexistence::ParseCoexReportURC() - Final Response=[%s]\r\n", pData->response); pData->commandId = RIL_OEM_HOOK_RAW_UNSOL_COEX_REPORT; pData->responseSize = strlen(pData->response); pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW); if (!pResponse->SetData(pData, sizeof(sOEM_HOOK_RAW_UNSOL_COEX_REPORT), FALSE)) { goto Error; } bRet = TRUE; Error: if (!bRet) { free(pData); pData = NULL; } RIL_LOG_VERBOSE("CSilo_rfcoexistence::ParseCoexReportURC() - Exit\r\n"); return bRet; }
void UsatState::ProfileToActivate() { RIL_LOG_INFO("UsatState::ProfileToActivate() - Nothing to do\r\n"); }
void UsatState::run() { RIL_LOG_INFO("UsatState::run() - Nothing to do\r\n"); }
// Helper function to convert IP addresses to Android-readable format. // szIpIn [IN] - The IP string to be converted // szIpOut [OUT] - The converted IPv4 address in Android-readable format if there is an IPv4 address. // uiIpOutSize [IN] - The size of the szIpOut buffer // szIpOut2 [OUT] - The converted IPv6 address in Android-readable format if there is an IPv6 address. // uiIpOutSize [IN] - The size of szIpOut2 buffer // // If IPv4 format a1.a2.a3.a4, then szIpIn is copied to szIpOut. // If Ipv6 format: // Convert a1.a2.a3.a4.a5. ... .a15.a16 to XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX IPv6 format // output is copied to szIpOut2 // If Ipv4v6 format: // Convert a1.a2.a3.a4.a5. ... .a19.a20 to // a1.a2.a3.a4 to szIpOut // XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX (a5-a20) to szIpOut2 // If szIpOut2 is NULL, then this parameter is ignored BOOL ConvertIPAddressToAndroidReadable(char* szIpIn, char* szIpOut, UINT32 uiIpOutSize, char* szIpOut2, UINT32 uiIpOutSize2) { RIL_LOG_VERBOSE("ConvertIPAddressToAndroidReadable() - Enter\r\n"); BOOL bRet = FALSE; const int MAX_AIPV4_INDEX = 4; // Number of 'a' values read from modem for IPv4 case const int MAX_AIPV6_INDEX = 16; // Number of 'a' values read from modem for IPv6 case const int MAX_AIPV4V6_INDEX = 20; // Number of 'a' values read from modem for IPv4v6 case // Sanity checks if ( (NULL == szIpIn) || (NULL == szIpOut) || (0 == uiIpOutSize)) { RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() : Invalid inputs!\r\n"); return FALSE; } // Count number of '.' int nDotCount = 0; for (UINT32 i = 0; szIpIn[i] != '\0'; i++) { if ('.' == szIpIn[i]) { // Found a '.' nDotCount++; } } // If 3 dots, IPv4. If 15 dots, IPv6. If 19 dots, then IPv4v6. switch(nDotCount) { case 3: { // Extract a1...a4 into uiIP. // Then convert aAddress to szIpOut. UINT32 uiIP[MAX_AIPV4_INDEX] = {'\0'}; if (EOF == sscanf(szIpIn, "%u.%u.%u.%u", &uiIP[0], &uiIP[1], &uiIP[2], &uiIP[3])) { RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " cannot sscanf into ipv4 format\r\n"); goto Error; } if (0 == uiIP[0] && 0 == uiIP[0] && 0 == uiIP[0] && 0 == uiIP[0]) { RIL_LOG_INFO("ConvertIPAddressToAndroidReadable() -" "Invalid address - ignore\r\n"); } else { if (snprintf(szIpOut, uiIpOutSize, "%u.%u.%u.%u", uiIP[0], uiIP[1], uiIP[2], uiIP[3]) <= 0) { RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " error with snprintf() ipv4 part\r\n"); goto Error; } } } break; case 15: { // IPv6 format. Need to re-format this to Android IPv6 format. // Extract a1...a16 into aIP. // Then convert aAddress to szIpOut. UINT32 aIP[MAX_AIPV6_INDEX] = {0}; unsigned char acIP[MAX_AIPV6_INDEX] = {0}; if (EOF == sscanf(szIpIn, "%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u", &aIP[0], &aIP[1], &aIP[2], &aIP[3], &aIP[4], &aIP[5], &aIP[6], &aIP[7], &aIP[8], &aIP[9], &aIP[10], &aIP[11], &aIP[12], &aIP[13], &aIP[14], &aIP[15])) { RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " cannot sscanf into aIP[]! ipv6\r\n"); goto Error; } // Loop through array, check values from modem is from 0-255. for (int i=0; i<MAX_AIPV6_INDEX; i++) { if (aIP[i] > 255) { // Value is not between 0-255. RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " ipv6 aIP[%d] not in range 0-255. val=%u\r\n", i, aIP[i]); goto Error; } } // Convert unsigned int to unsigned char (for inet_ntop) // The value read in should be in range 0-255. for (int i=0; i<MAX_AIPV6_INDEX; i++) { acIP[i] = (unsigned char)(aIP[i]); } if (NULL != szIpOut2 && 0 != uiIpOutSize2) { if (inet_ntop(AF_INET6, (void*)acIP, szIpOut2, uiIpOutSize2) <= 0) { RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " cannot inet_ntop ipv6\r\n"); goto Error; } } } break; case 19: { // IPv4v6 format. Grab a1.a2.a3.a4 and that's the IPv4 part. The rest is IPv6. // Extract a1...a20 into aIP. // Then IPv4 part is extracted into szIpOut. // IPV6 part is extracted into szIpOut2. UINT32 aIP[MAX_AIPV4V6_INDEX] = {0}; if (EOF == sscanf(szIpIn, "%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u.%u." "%u.%u.%u.%u.%u.%u", &aIP[0], &aIP[1], &aIP[2], &aIP[3], &aIP[4], &aIP[5], &aIP[6], &aIP[7], &aIP[8], &aIP[9], &aIP[10], &aIP[11], &aIP[12], &aIP[13], &aIP[14], &aIP[15], &aIP[16], &aIP[17], &aIP[18], &aIP[19] )) { RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " cannot sscanf into aIP[]! ipv4v6\r\n"); goto Error; } // Loop through array, check values from modem is from 0-255. for (int i=0; i<MAX_AIPV4V6_INDEX; i++) { if (aIP[i] > 255) { // Value is not between 0-255. RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " ipv4v6 aIP[%d] not in range 0-255. val=%u\r\n", i, aIP[i]); goto Error; } } if (snprintf(szIpOut, uiIpOutSize, "%u.%u.%u.%u", aIP[0], aIP[1], aIP[2], aIP[3]) <= 0) { RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " error with snprintf()! ipv4v6 v4 part\r\n"); goto Error; } if (NULL != szIpOut2 && 0 != uiIpOutSize2) { unsigned char acIP[MAX_AIPV6_INDEX] = {0}; // Convert unsigned int to unsigned char (for inet_ntop) // The value read in should be in range 0-255, from check done above. for (int i=0; i<MAX_AIPV6_INDEX; i++) { acIP[i] = (unsigned char)(aIP[i+4]); } if (inet_ntop(AF_INET6, (void*)acIP, szIpOut2, uiIpOutSize2) <= 0) { RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " cannot inet_ntop ipv4v6\r\n"); goto Error; } } } break; default: RIL_LOG_CRITICAL("ConvertIPAddressToAndroidReadable() -" " Unknown address format nDotCount=[%d]\r\n", nDotCount); goto Error; } bRet = TRUE; Error: RIL_LOG_VERBOSE("ConvertIPAddressToAndroidReadable() - Exit\r\n"); return bRet; }