gprs.cpp

手机RILGSM实现的源代码

    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);
#if 0
//zhaozipeng 20070718, add for muti-connection on GSM side
{
    //if there is CSD, diconnect CSD before GPRS.
    UINT8 nFirstCSDCallID = 0;
    if( RILDrv_CC_GetCallIDFromType(CALL_TYPE_CSD, nFirstCSDCallID) )
    {
        RETAILMSG(1, (TEXT("[GSM] RILDrv_SetGPRSContext:find CSD Call exsit and CallID=[%d]\r\n"),nFirstCSDCallID));
        char szCmd_ath[MAX_PATH];
        (void)_snprintfz(szCmd_ath, MAX_PATH, "AT%%CHLD=7%u\r", nFirstCSDCallID);	
        QueueCmdIgnoreRsp(APIID_NONE, szCmd_ath, CMDOPT_NONE, g_TimeoutAPIDefault, NULL, NULL, 0, 0, 0);
        Sleep( 500 );
    }

    //if there is GPRS, disconnect the old one before the new GPRS begin.
    if(0 != g_dwActiveGPRSContextID)
    {
        CRilHandle *pDevice = pHandle->GetDevice();
        RILGPRSCONTEXTACTIVATED rGPRSca;
        memset(&rGPRSca, 0x00, sizeof(RILGPRSCONTEXTACTIVATED));
        rGPRSca.cbSize = sizeof(rGPRSca);
        rGPRSca.fActivated = FALSE;
        if(0 == g_dwActiveGPRSContextID)
            rGPRSca.dwContextID = 1;
        else
            rGPRSca.dwContextID = g_dwActiveGPRSContextID;
        RETAILMSG(1, (TEXT("[GSM] g_dwActiveGPRSContextID=[%d]\r\n"), g_dwActiveGPRSContextID));
        rGPRSca.dwEvent = RIL_RILGPRSCONTEXTACTIVATED_MEDEACT;
        if( pDevice->BroadcastRealBlobNotification(RIL_NOTIFY_GPRS_DISCONNECT, &rGPRSca, sizeof(rGPRSca)) )
        {
            RETAILMSG(1, (TEXT("[GSM] Broadcast ME DEACT first, OK\r\n")));
        }
        else
        {
            RETAILMSG(1, (TEXT("[GSM] Broadcast ME DEACT first, Failed\r\n")));
            goto Error;
        }
    }
}
//end zhaozipeng 20070718
#endif
    if (RilGprsContextCopy.dwParams & RIL_PARAM_GCONT_ACCESSPOINTNAME)
    {
        // Force the NULL-termination
        RilGprsContextCopy.wszAccessPointName[ARRAY_LENGTH(RilGprsContextCopy.wszAccessPointName)-1]=WCHAR ('\0');
        // Filter the access point name to only contain valid characters.
        WCHAR wszFilteredApn[MAXLENGTH_GPRSACCESSPOINTNAME];
        if (FAILED( StringFilterW(wszFilteredApn,
                                  ARRAY_LENGTH(wszFilteredApn),
                                  (LPWSTR)RilGprsContextCopy.wszAccessPointName,
                                  VALID_GPRS_APN_CHARACTERS) ))
        {
            goto Error;
        }
        // Force the NULL-termination
        wszFilteredApn[ARRAY_LENGTH(wszFilteredApn)-1] = WCHAR ('\0');
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"", AnsiString(wszFilteredApn));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

#ifdef RIL_WATSON_REPORT
        // Copy APN being set to the info cache
        EnterCriticalSection(&g_csRilInfoCache);
        strncpy(g_RilInfoCache.szAPN, AnsiString(wszFilteredApn), MAXLENGTH_GPRSACCESSPOINTNAME);
        LeaveCriticalSection(&g_csRilInfoCache);
#endif // RIL_WATSON_REPORT

    }

    // Add ","
    (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (RilGprsContextCopy.dwParams & RIL_PARAM_GCONT_ADDRESS)
    {
        // Force the NULL-termination
        RilGprsContextCopy.wszAddress[ARRAY_LENGTH(RilGprsContextCopy.wszAddress)-1]=WCHAR ('\0');

        // Filter the address to only contain valid characters. Valid characters are defined the
        // same as the APN, but could possibly be limited even more to digits and periods.
        WCHAR wszFilteredAddr[MAXLENGTH_GPRSADDRESS];
        if (FAILED( StringFilterW(wszFilteredAddr,
                                  ARRAY_LENGTH(wszFilteredAddr),
                                  (LPWSTR)RilGprsContextCopy.wszAddress,
                                  VALID_GPRS_APN_CHARACTERS) ))
        {
            goto Error;
        }
        // Force the NULL-termination
        wszFilteredAddr[ARRAY_LENGTH(wszFilteredAddr)-1] = WCHAR ('\0');
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"", AnsiString(wszFilteredAddr));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Add ","
    (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (RilGprsContextCopy.dwParams & RIL_PARAM_GCONT_DATACOMPRESSION)
    {
        if (!ValueFromFlag(RilGprsContextCopy.dwDataCompression,g_GprsDataComp,NUM_GPRSDATACOMP,Value))
        {
            goto Error;
        }
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",Value);

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

    // Add ","
    (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (RilGprsContextCopy.dwParams & RIL_PARAM_GCONT_HEADERCOMPRESSION)
    {
        if (!ValueFromFlag(RilGprsContextCopy.dwHeaderCompression,g_GprsHeaderComp,NUM_GPRSHEADERCOMP,Value))
        {
            goto Error;
        }
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",Value);

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

    if (RilGprsContextCopy.dwParams & RIL_PARAM_GCONT_PARAMETERS)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), ",%s", RilGprsContextCopy.szParameters);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Add "\r"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));

    if (!QueueCmd(pHandle,
                  szCmd,
                  CMDOPT_NONE,
                  APIID_SETGPRSCONTEXT,
                  NULL,     // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

HRESULT RILDrv_NdisSetGPRSContextActivated (DWORD dwParam, const RILNDISGPRSCONTEXT *lpNdisSetGprsContextActivated )
{
    HRESULT hr = E_INVALIDARG;

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

    if ( lpNdisSetGprsContextActivated && (lpNdisSetGprsContextActivated->cbSize == sizeof(*lpNdisSetGprsContextActivated)))
    {
       hr = pHandle->CRilInstanceNdis.NdisSetGPRSContextActivated( lpNdisSetGprsContextActivated);
    }

    Error:
    return hr;
}

HRESULT RILDrv_NdisReceivePacketDone (DWORD dwParam,  RILNDISPACKET* lpNdisPacket)
{
    HRESULT hr = E_INVALIDARG;

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

   hr = pHandle->CRilInstanceNdis.NdisReceivePacketDone(lpNdisPacket);

    Error:
    return hr;
}

HRESULT RILDrv_NdisSendPacket (DWORD dwParam,  RILNDISPACKET* lpNdisPacket)
{
    HRESULT hr = E_INVALIDARG;

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

   hr = pHandle->CRilInstanceNdis.NdisSendPacket(lpNdisPacket);

    Error:
    return hr;
}
// +CGDCONT=<dwContextID>
HRESULT RILDrv_DeleteGPRSContext (DWORD dwParam, DWORD dwContextID)
{
    FUNCTION_TRACE(RILDrv_DeleteGPRSContext);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_DeleteGPRSContext\r\n")));

#ifdef GPRS_CONTEXT_CACHING
    ClearGPRSContextCommandCache();
#endif // GPRS_CONTEXT_CACHING

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

    // Build command
    char szCmd[MAX_PATH];
    (void)_snprintfz(szCmd, MAX_PATH, "AT+CGDCONT=%u\r", dwContextID);
    if (!QueueCmd(pHandle,
                  szCmd,
                  CMDOPT_NONE,
                  APIID_DELETEGPRSCONTEXT,
                  NULL,     // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

#ifdef RIL_WATSON_REPORT
    // Reset Ril Info cache of the APN
    *(g_RilInfoCache.szAPN) = '\0';
#endif // RIL_WATSON_REPORT

    Error:
    return hr;
}

/*
+XXXXXX: <cid>,<precedence>,<delay>,<reliability>,<peak>,<mean>
[<CR><LF>+XXXXXX: <cid>,<precedence>,<delay>,<reliability.>,<peak>,<mean>
[...]]
*/
HRESULT ParseQOSList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob, LPCSTR szCmd)
{
    FUNCTION_TRACE(ParseGetRequestedQualityOfServiceList);
    PBYTE pBuffer=NULL;
    DWORD dwBufferSize=0;

    RILGPRSQOSPROFILE *pQOSProfile;

    UINT nValue;

    HRESULT hr = E_FAIL;
    BOOL bSuccess;

    pBlob = NULL;
    cbBlob = 0;

    // Parse "<prefix>"
    if (!ParseRspPrefix(szRsp, szRsp))
    {
        goto Error;
    }

    // Parse "+XXXXXX: "
    while (MatchStringBeginning(szRsp, szCmd, szRsp))
    {
        // Reallocate our buffer for the additional data
        pBuffer = (PBYTE)ReallocBlob(pBuffer,dwBufferSize+sizeof(RILGPRSQOSPROFILE));
        if (!pBuffer)
        {
            goto Error;
        }

        pQOSProfile = (RILGPRSQOSPROFILE *)(pBuffer+dwBufferSize);
        memset(pQOSProfile, 0x00, sizeof(RILGPRSQOSPROFILE));
        pQOSProfile->cbSize=sizeof(RILGPRSQOSPROFILE);

        dwBufferSize+=sizeof(RILGPRSQOSPROFILE);

        // Parse <cid>
        if (!ParseUInt(szRsp, TRUE, nValue, szRsp))
        {
            goto Continue;
        }
        pQOSProfile->dwContextID=nValue;
        pQOSProfile->dwParams|= RIL_PARAM_GQOSP_CONTEXTID;

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

        if (FlagFromValue(nValue,g_GprsPrecedenceClass,NUM_GPRSPRECEDENCECLASS,pQOSProfile->dwPrecedenceClass))
        {
            pQOSProfile->dwParams|= RIL_PARAM_GQOSP_PRECEDENCECLASS;
        }

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

        if (FlagFromValue(nValue,g_GprsDelayClass,NUM_GPRSDELAYCLASS, pQOSProfile->dwDelayClass))
        {
            pQOSProfile->dwParams|= RIL_PARAM_GQOSP_DELAYCLASS;
        }

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

        if (FlagFromValue(nValue,g_GprsReliabilityClass,NUM_GPRSRELIABILITYCLASS,pQOSProfile->dwReliabilityClass))
        {
            pQOSProfile->dwParams|= RIL_PARAM_GQOSP_RELIABILITYCLASS;
        }

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

        if (FlagFromValue(nValue,g_GprsPeakThruClass,NUM_GPRSPEAKTHRUCLASS,pQOSProfile->dwPeakThruClass))
        {
            pQOSProfile->dwParams|= RIL_PARAM_GQOSP_PEAKTHRUCLASS;
        }

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

        if (FlagFromValue(nValue,g_GprsMeanThruClass,NUM_GPRSMEANTHRUCLASS,pQOSProfile->dwMeanThruClass))
        {
            pQOSProfile->dwParams|= RIL_PARAM_GQOSP_MEANTHRUCLASS;
        }

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

    pBlob = (void*)pBuffer;
    cbBlob = dwBufferSize;
    hr = S_OK;

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

/*
+CGQREQ: <cid>, <precedence >, <delay>,<reliability>, <peak>, <mean>
[<CR><LF>+CGQREQ: <cid>, <precedence >,<delay>, <reliability.>, <peak>, <mean>
[...]]
*/
HRESULT ParseGetRequestedQualityOfServiceList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetRequestedQualityOfServiceList);
    return ParseQOSList(szRsp,pBlob,cbBlob,"+CGQREQ: ");
}

/*
+CGQMIN: <cid>, <precedence >, <delay>,<reliability>, <peak>, <mean>
[<CR><LF>+CGQMIN: <cid>, <precedence >, <delay>, <reliability.>, <peak>, <mean>
[...]]
*/
HRESULT ParseGetMinimumQualityOfServiceList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetMinimumQualityOfServiceList);
    return ParseQOSList(szRsp,pBlob,cbBlob,"+CGQMIN: ");
}

// +CGQREQ?
HRESULT RILDrv_GetRequestedQualityOfServiceList (DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetRequestedQualityOfServiceList);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_GetRequestedQualityOfServiceList\r\n")));

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

    if (!QueueCmd(pHandle,
                  "AT+CGQREQ?\r",
                  CMDOPT_NONE,
                  APIID_GETREQUESTEDQUALITYOFSERVICELIST,
                  ParseGetRequestedQualityOfServiceList,  // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;