network.cpp

ril source code for Windows CE

    if (!ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

#ifdef RIL_ENABLE_EONS
    UINT nMode = 0;
    UINT nValue2 = 0;
    UINT nLac = 0;
    UINT nCi = 0;

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

    // Parse "[,<lac>,<ci>]"
    if (2 == nMode)
    {
        const int c = 2;
        UINT v[c];
        for( int i = 0; i < c; i++ )
        {
            SkipChars( szRsp, szRsp, " " );
            if (!MatchStringBeginning(szRsp, ",", szRsp))
            {
                hr = E_FAIL;
                goto Error;
            }
            SkipChars( szRsp, szRsp, " " );

            BOOL fQuote = MatchStringBeginning(szRsp, "\"", szRsp);
            if (!ParseHexUInt(szRsp, TRUE, v[i], szRsp))
            {
                hr = E_FAIL;
                goto Error;
            }
            if ( fQuote )
            {
                /* skip end quote */
                if (!MatchStringBeginning(szRsp, "\"", szRsp))
                {
                    hr = E_FAIL;
                    goto Error;
                }
            }
        }
        SkipChars( szRsp, szRsp, " " );

        nLac = v[0];
        nCi  = v[1];
    }

    // Parse "<postfix>"
    if (!ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    GetLongOperatorNameEx(pron, static_cast<DWORD>(nLac));
#else
    // Fill in the long operator name, if we didn't get it
    GetLongOperatorName(pron);
#endif

    pBlob = (void*)pron;
    cbBlob = sizeof(RILOPERATORNAMES);

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


//
//
//
HRESULT RILDrv_GetCurrentOperator(DWORD dwParam, DWORD dwFormat)
{
    FUNCTION_TRACE(RILDrv_GetCurrentOperator);
    char szCmd[MAX_PATH];
    UINT i;
    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;
    }

#ifdef RIL_ENABLE_EONS
    (void)_snprintfz(szCmd, ARRAY_LENGTH(szCmd), "AT+COPS=3,%u;+COPS?;+CREG?\r", i);
#else
    (void)_snprintfz(szCmd, MAX_PATH, "AT+COPS=3,%u;+COPS?\r", i);
#endif
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_GETCURRENTOPERATOR, ParseGetCurrentOperator, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_RegisterOnNetwork(DWORD dwParam, DWORD dwMode, const RILOPERATORNAMES* lpOperatorNames)
{
    FUNCTION_TRACE(RILDrv_RegisterOnNetwork);
    char szCmd[NETWK_CMDBUF_LENGTH];
    LPSTR szWalk = szCmd;
    UINT i;
    HRESULT hr = S_OK;
    const char *pszName;

    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    // Figure out the mode ID to use
    for (i = 0; i < NUM_OPSELMODES; i++) {
        if (dwMode == g_rgdwOperSelModes[i]) {
            break;
        }
    }
    if (NUM_OPSELMODES == i) {
        hr = E_INVALIDARG;
        goto Error;
    }

    // Add the mode
    (void)_snprintfz(szWalk, NETWK_CMDBUF_LENGTH - (szWalk - szCmd), "AT+COPS=%u", i);

    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if ( (lpOperatorNames!=NULL) && (lpOperatorNames->dwParams!=0) )
    {
        if (lpOperatorNames->dwParams & RIL_PARAM_ON_NUMNAME)
        {
            // numeric format
            (void)strncpyz(szWalk, ",2", NETWK_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30
            pszName = lpOperatorNames->szNumName;
        }
        else if (lpOperatorNames->dwParams & RIL_PARAM_ON_SHORTNAME)
        {
            // short name format
            (void)strncpyz(szWalk, ",1", NETWK_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30
            pszName = lpOperatorNames->szShortName;
        }
        else if (lpOperatorNames->dwParams & RIL_PARAM_ON_LONGNAME)
        {
            // long name format
            (void)strncpyz(szWalk, ",0", NETWK_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30
            pszName = lpOperatorNames->szLongName;
        }
        else
        {
            // None of the names are specified
            hr = E_INVALIDARG;
            goto Error;
        }

        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

        if ((dwMode!=RIL_OPSELMODE_AUTOMATIC) && (pszName[0]!='\0'))
        {
            (void)_snprintfz(szWalk, NETWK_CMDBUF_LENGTH - (szWalk - szCmd), ",\"%s\"", pszName);

            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);

            //Select access type
            if (lpOperatorNames->dwParams & RIL_PARAM_ON_UMTS_ACT) {          
                (void)strncpyz(szWalk, ",2", 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, ",1", 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, ",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_REGISTERONNETWORK, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

#ifdef RIL_RADIO_RESILIENCE
    g_fOperatorSelected = TRUE;
    (void)strncpyz(g_szOpSelCmd, szCmd, ARRAYSIZE(g_szOpSelCmd));
#endif // RIL_RADIO_RESILIENCE

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_UnregisterFromNetwork(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_UnregisterFromNetwork);
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    if (!QueueCmd(pHandle, "AT+COPS=2\r", CMDOPT_NONE, APIID_UNREGISTERFROMNETWORK, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT ParseGetRegistrationStatus(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetRegistrationStatus);
    UINT nMode = 0;
    UINT nValue = 0;
    UINT nLac = 0;
    UINT nCi = 0;
    DWORD* pdwRegStatus = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    pdwRegStatus = (DWORD*)AllocBlob(sizeof(DWORD));
    if (!pdwRegStatus) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(pdwRegStatus, 0x00, sizeof(DWORD));

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

    // 3GPP TS 27.007 version 5.4.0 Release 5 section 7.2
    // Parse "[,<lac>,<ci>]" iff location information is enabled
    // and MT is registered in (home or roaming) network.
    if (2 == nMode && (1 == nValue || 5 == nValue)) {
        const int c = 2;
        UINT v[c];
        for( int i = 0; i < c; i++ )
        {
            SkipChars( szRsp, szRsp, " " );
            if (!MatchStringBeginning(szRsp, ",", szRsp))
            {
                hr = E_FAIL;
                goto Error;
            }
            SkipChars( szRsp, szRsp, " " );

            BOOL fQuote = MatchStringBeginning(szRsp, "\"", szRsp);
            if (!ParseHexUInt(szRsp, TRUE, v[i], szRsp))
            {
                hr = E_FAIL;
                goto Error;
            }
            if ( fQuote )
            {
                /* skip end quote */
                if (!MatchStringBeginning(szRsp, "\"", szRsp))
                {
                    hr = E_FAIL;
                    goto Error;
                }
            }
        }
        SkipChars( szRsp, szRsp, " " );

        nLac = v[0];
        nCi  = v[1];
    }

    // Parse "<postfix>"
    if (!ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

    if (NUM_REGSTATS > nValue) {
        *pdwRegStatus = g_rgdwRegStats[nValue];
    } else {
        *pdwRegStatus = RIL_REGSTAT_UNKNOWN;
    }

    if (!(g_dwReadyState & RIL_READYSTATE_UNLOCKED) && (*pdwRegStatus == RIL_REGSTAT_DENIED))
    {
        // We tell a white lie here since we are SIM locked, and we don't want to bum out the users
        // by telling them they were denied.
        *pdwRegStatus = RIL_REGSTAT_UNREGISTERED;
    }

    g_dwRegStatus = *pdwRegStatus;
#ifdef RIL_WATSON_REPORT
    // Copy network registration status to info cache.
    g_RilInfoCache.dwRegStatus = *pdwRegStatus;
#endif //RIL_WATSON_REPORT

    pBlob = (void*)pdwRegStatus;
    cbBlob = sizeof(DWORD);

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


//
//
//
HRESULT RILDrv_GetRegistrationStatus(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetRegistrationStatus);
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    if (!QueueCmd(pHandle, "AT+CREG?\r", CMD