network.cpp

ril source code for Windows CE

        rgroi[nUsed].ronNames.cbSize = sizeof(RILOPERATORNAMES);

        // Parse "<index>"
        if (!ParseUInt(szRsp, TRUE, nValue, szRsp)) {
            goto Continue;
        }
        rgroi[nUsed].dwIndex = nValue;
        rgroi[nUsed].dwParams |= RIL_PARAM_OI_INDEX;

        // Parse ",<format>,"
        if (!MatchStringBeginning(szRsp, ",", szRsp) ||
            !ParseUInt(szRsp, TRUE, nFormat, szRsp)  ||
            !MatchStringBeginning(szRsp, ",", szRsp)) {
            goto Continue;
        }

        if (!nFormat) {
            // The name came in long format
            // Parse "<operator_name>"
            if(!ParseString(szRsp, rgroi[nUsed].ronNames.szLongName, MAXLENGTH_OPERATOR_LONG, szRsp)) {
                goto Continue;
            }
            if (*rgroi[nUsed].ronNames.szLongName) {
                rgroi[nUsed].ronNames.dwParams |= RIL_PARAM_ON_LONGNAME;
                rgroi[nUsed].dwParams |= RIL_PARAM_OI_NAMES;
            }
        } else if (1 == nFormat) {
            // The name came in short format
            // Parse "<operator_name>"
            if(!ParseString(szRsp, rgroi[nUsed].ronNames.szShortName, MAXLENGTH_OPERATOR_SHORT, szRsp)) {
                goto Continue;
            }
            if (*rgroi[nUsed].ronNames.szShortName) {
                rgroi[nUsed].ronNames.dwParams |= RIL_PARAM_ON_SHORTNAME;
                rgroi[nUsed].dwParams |= RIL_PARAM_OI_NAMES;
            }
        } else if (2 == nFormat) {
            // The name came in numeric format
            // Parse "<operator_name>"

            char rgszTemp[20];

            if (!ParseString(szRsp, rgszTemp, sizeof(rgszTemp), szRsp)) {
                goto Continue;
            }
            nValue = atoi(rgszTemp);

            (void)_snprintfz(rgroi[nUsed].ronNames.szNumName, MAXLENGTH_OPERATOR_NUMERIC, "%u", nValue);
            rgroi[nUsed].ronNames.dwParams |= RIL_PARAM_ON_NUMNAME;
            rgroi[nUsed].dwParams |= RIL_PARAM_OI_NAMES;
        } else {
            // Unknown name format
            hr = E_FAIL;
            goto Continue;
        }

        // Fill in the long operator name, if we didn't get it
        GetLongOperatorName(&rgroi[nUsed].ronNames);

        if (MatchStringBeginning(szRsp, ",", szRsp)) {
            // Parse "<GSM_AcT>,<GSM_Compact_AcT>,<UTRAN_AcT>"            
            if (!ParseUInt(szRsp, TRUE, nAcT1, szRsp)    ||
                !MatchStringBeginning(szRsp, ",", szRsp) ||
                !ParseUInt(szRsp, TRUE, nAcT2, szRsp)    ||
                !MatchStringBeginning(szRsp, ",", szRsp) ||
                !ParseUInt(szRsp, TRUE, nAcT3, szRsp)) {
                goto Continue;
            }

            if (1 == nAcT3) {
                rgroi[nUsed].ronNames.dwParams |= RIL_PARAM_ON_UMTS_ACT;
            }
            else if (1 == nAcT2) {
                rgroi[nUsed].ronNames.dwParams |= RIL_PARAM_ON_GSMCOMPACT_ACT;
            }
            else {
                if (1 == nAcT1) {
                    rgroi[nUsed].ronNames.dwParams |= RIL_PARAM_ON_GSM_ACT;
                }
            }
        }

        // Increment the array index
        nUsed++;

Continue:
        // Find "<postfix>"
        if (!FindRspPostfix(szRsp, szRsp)) {
            hr = E_FAIL;
            goto Error;
        }
    }

    pBlob = (void*)rgroi;
    cbBlob = nUsed * sizeof(RILOPERATORINFO);

Error:
    if (FAILED(hr)) {
        FreeBlob(rgroi);
    }
    return hr;
}


//
//
//
HRESULT RILDrv_GetPreferredOperatorList(DWORD dwParam, DWORD dwFormat)
{
    FUNCTION_TRACE(RILDrv_GetPreferredOperatorList);
    UINT i;
    char szCmd[MAX_PATH];
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    // Figure out the operator formats ID to use
    for (i = 0; i < NUM_OPERFORMATS; i++) {
        if (dwFormat == g_rgdwOperFormats[i]) {
            break;
        }
    }
    if (NUM_OPERFORMATS == i) {
        hr = E_INVALIDARG;
        goto Error;
    }

    (void)_snprintfz(szCmd, MAX_PATH, "AT+CPOL=,%u;+CPOL?\r", i);
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_GETPREFERREDOPERATORLIST, ParseGetPreferredOperatorList, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_AddPreferredOperator(DWORD dwParam, DWORD dwIndex, const RILOPERATORNAMES* lpOperatorNames)
{
    FUNCTION_TRACE(RILDrv_AddPreferredOperator);
    char szCmd[NETWK_CMDBUF_LENGTH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpOperatorNames) {
        hr = E_FAIL;
        goto Error;
    }

    // Add the index (if supplied)
    if (RIL_PREFOPINDEX_FIRSTAVAILABLE == dwIndex) {
        (void)strncpyz(szWalk, "AT+CPOL=,", NETWK_CMDBUF_LENGTH - (szWalk - szCmd));
    } else {
        (void)_snprintfz(szWalk, NETWK_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CPOL=%u,", dwIndex);
    }
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpOperatorNames->dwParams & RIL_PARAM_ON_NUMNAME) {
        // We have a numeric name -- use it
        (void)_snprintfz(szWalk, NETWK_CMDBUF_LENGTH - (szWalk - szCmd), "2,\"%s\"", lpOperatorNames->szNumName);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    } else if (lpOperatorNames->dwParams & RIL_PARAM_ON_SHORTNAME) {
        // We have a short name -- use it
        (void)_snprintfz(szWalk, NETWK_CMDBUF_LENGTH - (szWalk - szCmd), "1,\"%s\"", lpOperatorNames->szShortName);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    } else if (lpOperatorNames->dwParams & RIL_PARAM_ON_LONGNAME) {
        // We only have a long name
        (void)_snprintfz(szWalk, NETWK_CMDBUF_LENGTH - (szWalk - szCmd), "0,\"%s\"", lpOperatorNames->szLongName);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    } else {
        // None of the names are specified
        hr = E_INVALIDARG;
        goto Error;
    }

    //Select access type
    if (lpOperatorNames->dwParams & RIL_PARAM_ON_UMTS_ACT) {  
        (void)strncpyz(szWalk, ",0,0,1", NETWK_CMDBUF_LENGTH - (szWalk - szCmd));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);        
    }
    else if (lpOperatorNames->dwParams & RIL_PARAM_ON_GSMCOMPACT_ACT) {
        (void)strncpyz(szWalk, ",0,1,0", NETWK_CMDBUF_LENGTH - (szWalk - szCmd));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
    else {
        if (lpOperatorNames->dwParams & RIL_PARAM_ON_GSM_ACT) {
            (void)strncpyz(szWalk, ",1,0,0", NETWK_CMDBUF_LENGTH - (szWalk - szCmd));
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }
    }

    (void)strncpyz(szWalk, "\r", NETWK_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30

    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_ADDPREFERREDOPERATOR, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_RemovePreferredOperator(DWORD dwParam, DWORD dwIndex)
{
    FUNCTION_TRACE(RILDrv_RemovePreferredOperator);
    char szCmd[MAX_PATH];
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    // Add the index
    (void)_snprintfz(szCmd, MAX_PATH, "AT+CPOL=%u\r", dwIndex);
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_REMOVEPREFERREDOPERATOR, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
static HRESULT ParseGetCurrentOperator(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetCurrentOperator);
    UINT nValue;
    UINT nFormat;
    UINT nAccessType;    
    RILOPERATORNAMES* pron = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    pron = (RILOPERATORNAMES*)AllocBlob(sizeof(RILOPERATORNAMES));
    if (!pron) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(pron, 0x00, sizeof(RILOPERATORNAMES));
    pron->cbSize = sizeof(RILOPERATORNAMES);

    // Parse "<prefix>+COPS: <mode>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+COPS: ", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

    // See if we have the operator info
    if (!MatchStringBeginning(szRsp, ",", szRsp)) {
        // We're not currently registered with an operator
        hr = RIL_E_OPFMTUNAVAILABLE;
#ifdef RIL_WATSON_REPORT
        // Clear Operator Name in Info cache
        *(g_RilInfoCache.szOperatorName) = '\0';           
#endif // RIL_WATSON_REPORT
        goto Error;
    }

    // Parse "<format>"
    if (!ParseUInt(szRsp, TRUE, nFormat, szRsp) ||
        !MatchStringBeginning(szRsp, ",", szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

    if (!nFormat) {
        // The name came in long format
        // Parse "<operator_name>"
        if(!ParseString(szRsp, pron->szLongName, MAXLENGTH_OPERATOR_LONG, szRsp)) {
            hr = E_FAIL;
            goto Error;
        }
        if (*pron->szLongName) {
            pron->dwParams |= RIL_PARAM_ON_LONGNAME;

#ifdef RIL_WATSON_REPORT
            // Copy Operator Name to Info cache
            EnterCriticalSection(&g_csRilInfoCache);
            strncpyz(g_RilInfoCache.szOperatorName, pron->szLongName, MAXLENGTH_OPERATOR_LONG);           
            LeaveCriticalSection(&g_csRilInfoCache);
#endif // RIL_WATSON_REPORT
        }
    } else if (1 == nFormat) {
        // The name came in short format
        // Parse "<operator_name>"
        if(!ParseString(szRsp, pron->szShortName, MAXLENGTH_OPERATOR_SHORT, szRsp)) {
            hr = E_FAIL;
            goto Error;
        }
        if (*pron->szShortName) {
            pron->dwParams |= RIL_PARAM_ON_SHORTNAME;

#ifdef RIL_WATSON_REPORT
            // Copy Operator Name to Info cache
            EnterCriticalSection(&g_csRilInfoCache);
            strncpyz(g_RilInfoCache.szOperatorName, pron->szShortName, MAXLENGTH_OPERATOR_SHORT);
            LeaveCriticalSection(&g_csRilInfoCache);
#endif // RIL_WATSON_REPORT
        }
    } else if (2 == nFormat) {
        // The name came in numeric format
        // Parse "<operator_name>"
        if (*szRsp=='\"') szRsp++;    // Ignore " characters around operator number

        if (!ParseUInt(szRsp, TRUE, nValue, szRsp)) {
            hr = E_FAIL;
            goto Error;
        }

        if (*szRsp=='\"') szRsp++;    // Ignore " characters around operator number

        (void)_snprintfz(pron->szNumName, MAXLENGTH_OPERATOR_NUMERIC, "%u", nValue);
        pron->dwParams |= RIL_PARAM_ON_NUMNAME;

#ifdef RIL_WATSON_REPORT
        // Copy Operator Name to Info cache
        EnterCriticalSection(&g_csRilInfoCache);
        strncpyz(g_RilInfoCache.szOperatorName, pron->szNumName, MAXLENGTH_OPERATOR_NUMERIC);           
        LeaveCriticalSection(&g_csRilInfoCache);
#endif // RIL_WATSON_REPORT
    } else {
        // Unknown name format
        hr = E_FAIL;
        goto Error;
    }

    if (MatchStringBeginning(szRsp, ",", szRsp)) {            
        // Parse ",<AcT>"
        nAccessType = 0;
        ParseUInt(szRsp, TRUE, nAccessType, szRsp);       
        
        switch (nAccessType)
        {
        case 0:
            pron->dwParams |= RIL_PARAM_ON_GSM_ACT;
            break;

        case 1:
            pron->dwParams |= RIL_PARAM_ON_GSMCOMPACT_ACT;
            break;

        case 2:
            pron->dwParams |= RIL_PARAM_ON_UMTS_ACT;
            break;

        default:
            break;
        }
    }

    // Parse "<postfix>"