gprs.cpp

ril source code for Windows CE

        }
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"",szString);
        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 (pRilGprsContextCopy->dwParams & RIL_PARAM_GCONT_ACCESSPOINTNAME)
    {
        // Force the NULL-termination
        pRilGprsContextCopy->wszAccessPointName[ARRAY_LENGTH(pRilGprsContextCopy->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)-1,
                                  (LPWSTR)pRilGprsContextCopy->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 (pRilGprsContextCopy->dwParams & RIL_PARAM_GCONT_ADDRESS)
    {
        // Force the NULL-termination
        pRilGprsContextCopy->wszAddress[ARRAY_LENGTH(pRilGprsContextCopy->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)pRilGprsContextCopy->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 (pRilGprsContextCopy->dwParams & RIL_PARAM_GCONT_DATACOMPRESSION)
    {
        if (!ValueFromFlag(pRilGprsContextCopy->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 (pRilGprsContextCopy->dwParams & RIL_PARAM_GCONT_HEADERCOMPRESSION)
    {
        if (!ValueFromFlag(pRilGprsContextCopy->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 (pRilGprsContextCopy->dwParams & RIL_PARAM_GCONT_PARAMETERS)
    {
        // Force null termination on szParameters to prevent reading beyond memory.
        if ( pRilGprsContextCopy->cbSize  > sizeof(*pRilGprsContextCopy) )
        {
            DWORD ParametersSize = pRilGprsContextCopy->cbSize - sizeof(*pRilGprsContextCopy);
            pRilGprsContextCopy->szParameters[ParametersSize-1] = 0;
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), ",%s", pRilGprsContextCopy->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:
    if ( pRilGprsContextCopy )
    {
        LocalFree(pRilGprsContextCopy);
    }
    return hr;
}

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

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

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

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

// +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")));

    HRESULT hr = E_INVALIDARG;
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    UINT Value;

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

    (void)_snprintfz(szCmd, MAX_PATH, "AT%s=%u", szATCmd, lpGprsQosProfile->dwContextID);