network.cpp

windows mobile RIL软件

        
        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>"
    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);
	RILRetailTrace((TEXT("+RILDrv_GetCurrentOperator()!\r\n")));
    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);
	RILRetailTrace((TEXT("+RILDrv_RegisterOnNetwork()!\r\n")));
    char szCmd[NETWK_CMDBUF_LENGTH];
    LPSTR szWalk = szCmd;
    UINT i;    
    HRESULT hr = S_OK;
    BOOL bUseQuotes=TRUE;
    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;
    }

#ifdef EMP_DRIVER
    // 2 (unregister from the network) is not supported on EMP platform
    if (2 == i)
    {
        hr = E_INVALIDARG;
        goto Error;
    }
#endif

    // 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;

    #if (!defined(WAVECOM_DRIVER) && !defined(OEM1_DRIVER) && !defined(OEM2_DRIVER) && !defined(EMP_DRIVER) && !defined(PHILIP_DRIVER))
            bUseQuotes=FALSE;
    #endif

        }
        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'))
        {
            if (bUseQuotes)
            {
                (void)_snprintfz(szWalk, NETWK_CMDBUF_LENGTH - (szWalk - szCmd), ",\"%s\"", pszName);
            }
            else
            {
                (void)_snprintfz(szWalk, NETWK_CMDBUF_LENGTH - (szWalk - szCmd), ",%s", pszName);
            }

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

			#ifndef PHILIP_DRIVER
            //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);
                }			
            }
			#endif
        }
    }

    (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);
	RILRetailTrace((TEXT("+RILDrv_UnregisterFromNetwork()!\r\n")));
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

#ifdef EMP_DRIVER
    // EMP doesn't support +COPS=2
    hr = E_NOTIMPL;
    goto Error;
#endif
#ifdef PHILIP_DRIVER

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

Error:
    return hr;
}


//
//
//
static 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