gprs.cpp

手机RILGSM实现的源代码

        NULL,  // Ptr to notification data
        hr)) {
        hr=E_FAIL;
        goto Error;
        }

    Error:
    return hr;
}

/*
+CGACT: <cid>, <state>
[<CR><LF>+CGACT: <cid>, <state>
[...]]
*/
HRESULT ParseGetGPRSContextActivatedList(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetGPRSContextActivatedList);
    PBYTE pBuffer=NULL;
    DWORD dwBufferSize=0;

    RILGPRSCONTEXTACTIVATED *pCtxtAct;

    UINT nValue;

    HRESULT hr = E_FAIL;
    BOOL bSuccess;

    pBlob = NULL;
    cbBlob = 0;

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

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

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

        dwBufferSize+=sizeof(RILGPRSCONTEXTACTIVATED);

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

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

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

// +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 (IfForbidConnectGprs())
    {
        CRilHandle *pDevice = pHandle->GetDevice();
        if( pDevice->BroadcastDWORDBlobNotification(RIL_NOTIFY_GPRS_DISCONNECT,
                                                             RIL_DISCINIT_REMOTE))
        {
            RETAILMSG(1, (TEXT("[TI] Broadcast RIL_NOTIFY_GPRS_DISCONNECT first, OK\r\n")));
        }
        RETAILMSG(1,(TEXT("[TI]RILDrv_EnterGPRSDataMode:ForbidConnectGprs\r\n")));
       dwOptions = CMDOPT_NOOP;
       pfnParse = ParseForceFailureResponse;
    }

    

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

#if defined(OEM1_DRIVER) || defined(OEM2_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);
        //g_dwActiveGPRSContextID = lpEnterGprsDataMode->dwContextID[0];		//zhaozipeng 20070718
    }

    // 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))
        {
            goto Error;
        }
        (void)_snprintfz(szWalk, MAX_PATH, "\"%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


    //not access to GPRS when set AT+COPS=2	or not attached GPRS yet
  RETAILMSG(1, (TEXT("[TI]g_bCurrentGprsAttachStatus is [%d],g_bManualUnregister is [%d]\r\n"),g_bCurrentGprsAttachStatus,g_bManualUnregister));
  if(FALSE == g_bCurrentGprsAttachStatus || (TRUE == g_bManualUnregister))
  {
      RETAILMSG(1, (TEXT("[TI]RILDrv : E : gprs do not attach\r\n")));
      dwOptions = CMDOPT_NOOP;
      pfnParse = ParseForceFailureResponse;
  }
	
    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);

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