gprs.cpp

windows mobile RIL软件

    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)

//Alan Luo: CMS92 modem not support CGDATA,So use ATD* instead. (GPRS issue)
#if defined(OEM1_DRIVER) || defined(OEM2_DRIVER) ||(PHILIP_DRIVER)
    // Send "ATD*99#" instead of "AT+CDATA" because the former is tested by OEM1 and acts in the same manner as far as we're concerned
    // 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>]]]]#).
    strcpy(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));

#else
    strcpy(szCmd,"AT+CGDATA=");
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpEnterGprsDataMode)
    {

        // Build command
        LPSTR szString;
        if (!StringFromFlag(lpEnterGprsDataMode->dwL2Protocol,g_GprsL2Protocols, NUM_GPRSL2PROTOCOLS,szString))
        {
            hr = E_INVALIDARG;
            goto Error;
        }
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"",szString);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

        for (DWORD i=0;i<lpEnterGprsDataMode->dwNumContexts;i++)
        {
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), ",%u", lpEnterGprsDataMode->dwContextID[i]);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }
    }

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

#ifdef EMP_DRIVER
    // Look up the mapping table to get a VSP for sending AT+CGDATA command
    HANDLE hVeiHandle = INVALID_HANDLE_VALUE;
    CCidSerialPortHandleMap* pCidHandleMap = CCidSerialPortHandleMap::Instance();
    pCidHandleMap->GetSerialPortHandleFromContextID(lpEnterGprsDataMode->dwContextID[0], &hVeiHandle);
    if (INVALID_HANDLE_VALUE == hVeiHandle)
    {
        DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : Error : RILDrv_EnterGPRSDataMode : Failed to get VEI handle for context %d\r\n"), lpEnterGprsDataMode->dwContextID[0]));
        hr = E_FAIL;
        goto Error;
    }

    // Send an empty AT command so that the response and notifications after AT+CGDATA can still be processed
    if (!QueueCmd(pHandle,
                "AT\r",
                CMDOPT_NOOP,
                APIID_ENTERGPRSDATAMODE,
                pfnParse,
                NULL,
                hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    // Send an AT command through CAIF driver
    const DWORD IOCTL_CAIF_SEND_AT_COMMAND = CTL_CODE(FILE_DEVICE_UNKNOWN, 0x901, METHOD_BUFFERED, FILE_ANY_ACCESS);
    if (!DeviceIoControl(hVeiHandle, IOCTL_CAIF_SEND_AT_COMMAND, szCmd, strlen(szCmd), NULL, 0, NULL, NULL))
    {
        DEBUGMSG(ZONE_INFO, (TEXT("RILDrv : Error : RILDrv_EnterGPRSDataMode : Failed to send %s\r\n"), TString(PrintableString(szCmd, strlen(szCmd)))));
        hr = E_FAIL;
        goto Error;
    }
    DEBUGMSG(ZONE_INFO, (TEXT("RILDrv : i : Sending cmd: %s\r\n"), TString(PrintableString(szCmd, strlen(szCmd)))));
#else
    if (!QueueCmd(pHandle,
                  szCmd,
                  dwOptions,
                  APIID_ENTERGPRSDATAMODE,
                  pfnParse,  // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }
#endif

    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;

#ifdef EMP_DRIVER
    // EMP does not support +CGANS
    hr = E_NOTIMPL;
    goto Error;
#endif

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

    LPSTR 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);

    for (i=0;i<lpGprsAnswer->dwNumContexts;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;
    }