gprs.cpp

windows mobile RIL软件

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

#ifndef EMP_DRIVER
    // EMP does not support <pd1>...<pdN>
    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);
    }
#endif

    // 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];
#ifdef EMP_DRIVER
    // EMP use *EIAD to delete a context
    (void)_snprintfz(szCmd, MAX_PATH, "AT*EIAD=%u,1\r", dwContextID);
#else
    (void)_snprintfz(szCmd, MAX_PATH, "AT+CGDCONT=%u\r", dwContextID);
#endif
    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;
}

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

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

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

    Error:
    return hr;
}

// +CGQREQ=[<cid> [,<precedence > [,<delay> [,<reliability.> [,<peak> [,<mean>]]]]]]
// +CGQMIN=[<cid> [,<precedence > [,<delay> [,<reliability.> [,<peak> [,<mean>]]]]]]
/*
typedef struct rilgprsqosprofile_tag {
    DWORD cbSize;                       // @field structure size in bytes
    DWORD dwParams;                     // @field indicates valid parameters
    DWORD dwContextID;                  // @field the context number
    DWORD dwPrecedenceClass;            // @field a RIL_GPRSPRECEDENCECLASS_* constant
    DWORD dwDelayClass;                 // @field a RIL_GPRSDELAYCLASS_* constant
    WCHAR dwReliabilityClass;           // @field a RIL_GPRSRELIABILITYCLASS_* constant
    DWORD dwPeakThruClass;              // @field a RIL_GPRSPEAKTHRUCLASS_* constant
    DWORD dwMeanThruClass;              // @field a RIL_GPRSMEANTHRUCLASS_* constant
} RILGPRSQOSPROFILE, *LPRILGPRSQOSPROFILE;
*/
HRESULT SetQOS(DWORD dwParam, const RILGPRSQOSPROFILE* lpGprsQosProfile, LPCSTR szATCmd, const APIID apiid)
{
    FUNCTION_TRACE(RILDrv_SetRequestedQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetRequestedQualityOfService\r\n")));

    NKDbgPrintfW(TEXT("RILDrv : E : RILDrv_SetRequestedQualityOfService\r\n"));
    HRESULT hr = E_INVALIDARG;
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    UINT Value;

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