gprs.cpp

ril source code for Windows CE

        bSuccess = FindRspPostfix(szRsp, szRsp);
        if (!bSuccess)
        {
            goto Error;
        }
    }

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

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

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

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

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

    Error:
    return hr;
}

HRESULT ParseForceFailureResponse(LPCSTR, void*&, UINT&)
{
    // Force a failure
    return E_FAIL;
}

// +CGDATA=<params>
HRESULT RILDrv_EnterGPRSDataMode (DWORD dwParam, const RILENTERGPRSDATAMODE * lpEnterGprsDataMode)
{
    FUNCTION_TRACE(RILDrv_EnterGPRSDataMode);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_EnterGPRSDataMode\r\n")));

    HRESULT hr = E_INVALIDARG;
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    DWORD dwOptions = CMDOPT_NONE;
    PFN_CMD_PARSE pfnParse = NULL;

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

#if defined (GPRSDIAL_REQUIRES_REGISTRATION) || defined (GPRSDIAL_REQUIRES_GPRSREGISTRATION)
    if(((g_dwRegStatus != RIL_REGSTAT_HOME) && (g_dwRegStatus != RIL_REGSTAT_ROAMING))
#if defined (GPRSDIAL_REQUIRES_GPRSREGISTRATION)
        || ((g_dwGPRSRegStatus != RIL_REGSTAT_HOME) && (g_dwGPRSRegStatus != RIL_REGSTAT_ROAMING))
#endif // #if defined (GPRSDIAL_REQUIRES_GPRSREGISTRATION)
        )
    {
        dwOptions = CMDOPT_NOOP;
         pfnParse = ParseForceFailureResponse;
    }
#endif //defined (GPRSDIAL_REQUIRES_REGISTRATION) || defined (GPRSDIAL_REQUIRES_GPRSREGISTRATION)

    // Parameters to RILDrv_EnterGPRSDataMode() may be ignored or arguments can be supplied as part of the dial string instead
    // strcpy(szCmd,"ATD*99#\r");

     // Use a more flexible dial string instead (D*<GPRS_SC>[*[<called_address>][*[<L2P>][*[<cid>]]]]#).
    StringCbCopyA( szCmd, sizeof(szCmd), "ATD*99***" );
    szWalk = strchr(szWalk, '\0');
    DEBUGCHK(NULL != szWalk);

    // In theory we can specify more than one PDP contexts to activate, but since we only support
    // one right now, simply choose the first one in the array.
    if (lpEnterGprsDataMode->dwNumContexts >= 1)
    {
        (void)_snprintfz( szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpEnterGprsDataMode->dwContextID[0] );
        szWalk = strchr(szWalk, '\0');
        DEBUGCHK(NULL != szWalk);
    }

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

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

    Error:
    return hr;
}
/*
+CGPADDR: <cid>,<PDP_addr>
[<CR><LF>+CGPADDR: <cid>,<PDP_addr>
[...]]
*/
HRESULT ParseGetGPRSAddress(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetGPRSAddress);

    UINT nValue;
    HRESULT hr = E_FAIL;
    LPCSTR szAddr, szAddrEnd;
    LPTSTR wszAddrReturned=NULL;
    DWORD dwStringLength=0;
    pBlob = NULL;
    cbBlob = 0;

    // Note: The pdp address is optional, so ignore it if it's not there and return an empty string
    // Also, ericsson doesn't even give us the cid, so ignore that if it's not present also

    if (  (!ParseRspPrefix(szRsp, szRsp))
       || (!MatchStringBeginning(szRsp, "+CGPADDR: ", szRsp))
       || (!ParseUInt(szRsp, TRUE, nValue, szRsp))
       || (!MatchStringBeginning(szRsp, ",", szRsp)) )
    {
        // Rig szAddr so that if we don't find anything, we'll return an empty string
        szAddr=szAddrEnd="\r\n";
    }
    else
    {
        szAddr = szRsp;

        // Parse ,<pd1>[,...[,pdN]]
        szAddrEnd = strstr(szAddr, "\r\n");
        if (!szAddrEnd)
        {
            goto Error;
        }

        szRsp = szAddrEnd;
    }

    // Set dwParameterLength to be size of string in bytes counting null char at end
    dwStringLength = ((szAddrEnd-szAddr)+1);
    wszAddrReturned = (LPTSTR)AllocBlob(dwStringLength * sizeof(TCHAR));
    if (!wszAddrReturned)
    {
        goto Error;
    }

    (void)wcsncpyz(wszAddrReturned, WideString(szAddr,'\r'), dwStringLength);

    pBlob = (void*)wszAddrReturned;
    cbBlob = dwStringLength * sizeof(TCHAR);
    hr = S_OK;

    Error:
    if (FAILED(hr))
    {
        FreeBlob(wszAddrReturned);
    }

    return hr;
}

// +CGPADDR=<dwContextID>[,<dwContextID>...]
HRESULT RILDrv_GetGPRSAddress (DWORD dwParam, DWORD dwContextID)
{
    FUNCTION_TRACE(RILDrv_GetGPRSAddress);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_GetGPRSAddress\r\n")));

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

    // Build command
    char szCmd[MAX_PATH];
    (void)_snprintfz(szCmd, MAX_PATH, "AT+CGPADDR=%u\r", dwContextID);

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

    Error:
    return hr;
}

// +CGANS=<params>
/*
typedef struct rilgprsanswer_tag
{
    DWORD cbSize;                       // @field structure size in bytes
    BOOL fAnswer;                       // @parm TRUE: accept, FALSE: reject
    DWORD dwL2Protocol;                 // @parm an optional RILL2PROTOCOL_* constant
    DWORD dwNumContexts;                // @parm number of contexts which follow
    DWORD dwContextID[];                // @parm identifies the context(s) to enter data state
} RILGPRSANSWER, *LPRILGPRSANSWER;
*/
HRESULT RILDrv_GPRSAnswer (DWORD dwParam, const RILGPRSANSWER *lpGprsAnswer)
{
    FUNCTION_TRACE(RILDrv_GPRSAnswer);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_GPRSAnswer\r\n")));

    HRESULT hr = E_INVALIDARG;
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    DWORD i;

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

    // Build command

    (void)_snprintfz(szCmd, MAX_PATH, "AT+CGANS=%u,", lpGprsAnswer->fAnswer ? 1 : 0);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    LPCSTR szString;
    if (!StringFromFlag(lpGprsAnswer->dwL2Protocol,g_GprsL2Protocols, NUM_GPRSL2PROTOCOLS,szString))
    {
        goto Error;
    }
    (void)_snprintfz(szWalk, MAX_PATH, "\"%s\"", szString);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    DWORD NumContexts = 0;
    if ( lpGprsAnswer->cbSize > sizeof(RILGPRSANSWER) )
    {
        NumContexts = (lpGprsAnswer->cbSize - sizeof(RILGPRSANSWER))/ sizeof(*lpGprsAnswer->dwContextID);
    }

    for (i=0;i<NumContexts;i++)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), ",%u", lpGprsAnswer->dwContextID[i]);
        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_GPRSANSWER,
                  NULL,  // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

/*
+CGREG: <n>,<stat>[,<lac>,<ci>]
*/
HRESULT ParseGetGPRSRegistrationStatus(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetGPRSRegistrationStatus);
    UINT nValue;
    HRESULT hr = E_FAIL;
    DWORD *pdwRegStatus=NULL;
    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "+CGREG: "
    if (!MatchStringBeginning(szRsp, "+CGREG: ", szRsp))
    {
        goto Error;
    }

    // Parse <n> and throw away
    if (!ParseUInt(szRsp, TRUE, nValue, szRsp))
    {
        goto Error;
    }

    // Parse ","
    if (!MatchStringBeginning(szRsp, ",", szRsp))
    {
        goto Error;
    }

    // Parse <stat>
    if (!ParseUInt(szRsp, TRUE, nValue, szRsp))
    {
        goto Error;
    }

    pdwRegStatus = (DWORD*)AllocBlob(sizeof(DWORD));
    if (!pdwRegStatus)
    {
        goto Error;
    }

    if (NUM_REGSTATS > nValue)
    {
        *pdwRegStatus = g_rgdwRegStats[nValue];
    }
    else
    {
        *pdwRegStatus = RIL_REGSTAT_UNKNOWN;
    }
    g_dwGPRSRegStatus = *pdwRegStatus;
#ifdef RIL_WATSON_REPORT
    // Copy gprs registration status to the info cache.
    g_RilInfoCache.dwGPRSRegStatus = *pdwRegStatus;
#endif // RIL_WATSON_REPORT

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

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

    return hr;
}

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

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


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

    Error:
    return hr;
}

/*
+CGCLASS: <class>
<class>: a string parameter which indicates the GPRS mobile class (in descending order of functionality)
A class A (highest)
B classB
C class C in GPRS and circuit switched alternate mode
CG class C in GPRS only mode
CC class C in circuit switched only mode (lowest)
*/
HRESULT ParseGetGPRSClass(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetGPRSClass);
    char szValue[MAX_PATH];
    DWORD *pdwClass=NULL;
    HRESULT hr = E_FAIL;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "+CGCLASS: "
    if (!MatchStringBeginning(szRsp, "+CGCLASS: ", szRsp))
    {
        goto Error;
    }

    pdwClass = (DWORD*)AllocBlob(sizeof(DWORD));
    if (!pdwClass)
    {
        goto Error;
    }

    // Parse <class>
    if (!ParseString(szRsp, szValue, MAX_PATH, szRsp))
    {
        goto Error;
    }