gprs.cpp

windows mobile RIL软件

    // Build command
#if !defined(OEM2_DRIVER)
    (void)_snprintfz(szCmd, MAX_PATH, "AT%s=%u,", szATCmd, lpGprsQosProfile->dwContextID);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    {
#else
    (void)_snprintfz(szCmd, MAX_PATH, "AT%s=%u", szATCmd, lpGprsQosProfile->dwContextID);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpGprsQosProfile->dwParams & (RIL_PARAM_GQOSP_PRECEDENCECLASS     |
                                      RIL_PARAM_GQOSP_DELAYCLASS          |
                                      RIL_PARAM_GQOSP_RELIABILITYCLASS    |
                                      RIL_PARAM_GQOSP_PEAKTHRUCLASS       |
                                      RIL_PARAM_GQOSP_MEANTHRUCLASS))
    {
        (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
#endif // defined(OEM2_DRIVER)
        if (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_PRECEDENCECLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwPrecedenceClass,g_GprsPrecedenceClass,NUM_GPRSPRECEDENCECLASS,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 (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_DELAYCLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwDelayClass,g_GprsDelayClass,NUM_GPRSDELAYCLASS,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 (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_RELIABILITYCLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwReliabilityClass,g_GprsReliabilityClass,NUM_GPRSRELIABILITYCLASS,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 (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_PEAKTHRUCLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwPeakThruClass,g_GprsPeakThruClass,NUM_GPRSPEAKTHRUCLASS,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 (lpGprsQosProfile->dwParams & RIL_PARAM_GQOSP_MEANTHRUCLASS)
        {
            if (!ValueFromFlag(lpGprsQosProfile->dwMeanThruClass,g_GprsMeanThruClass,NUM_GPRSMEANTHRUCLASS,Value))
            {
                goto Error;
            }
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",Value);

            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,
                  NULL,     // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +CGQREQ=<params>
HRESULT RILDrv_SetRequestedQualityOfService (DWORD dwParam, const RILGPRSQOSPROFILE* lpGprsQosProfile)
{
    FUNCTION_TRACE(RILDrv_SetRequestedQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetRequestedQualityOfService\r\n")));
    return SetQOS(dwParam,lpGprsQosProfile, "+CGQREQ",APIID_SETREQUESTEDQUALITYOFSERVICE);
}

// +CGQMIN=<params>
HRESULT RILDrv_SetMinimumQualityOfService (DWORD dwParam, const RILGPRSQOSPROFILE* lpGprsQosProfile)
{
    FUNCTION_TRACE(RILDrv_SetRequestedQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetMinimumQualityOfService\r\n")));
    return SetQOS(dwParam,lpGprsQosProfile, "+CGQMIN",APIID_SETMINIMUMQUALITYOFSERVICE);
}

HRESULT DeleteQOS(DWORD dwParam, DWORD dwContextID, LPCSTR szATCmd, const APIID apiid)
{
    FUNCTION_TRACE(DeleteQOS);

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

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

    if (!QueueCmd(pHandle,
                  szCmd,
#ifdef GPRS_QOS_DELETE_NOOP_HACK
    // QOS deletion happens before every GPRS call currently,
    // and on some radios this is not a good idea.  For now,
    // just NOOP the QOS deletion
                  CMDOPT_NOOP,
#else
                  CMDOPT_NONE,
#endif
                  apiid,
                  NULL,     // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +CGQREQ=<dwContextID>
HRESULT RILDrv_DeleteRequestedQualityOfService (DWORD dwParam, DWORD dwContextID)
{
    FUNCTION_TRACE(RILDrv_DeleteRequestedQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_DeleteRequestedQualityOfService\r\n")));

    return DeleteQOS(dwParam, dwContextID, "+CGQREQ", APIID_DELETEREQUESTEDQUALITYOFSERVICE);
}

// +CGQMIN=<dwContextID)
HRESULT RILDrv_DeleteMinimumQualityOfService (DWORD dwParam, DWORD dwContextID)
{
    FUNCTION_TRACE(RILDrv_DeleteMinimumQualityOfService);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_DeleteMinimumQualityOfService\r\n")));

    return DeleteQOS(dwParam, dwContextID, "+CGQMIN", APIID_DELETEMINIMUMQUALITYOFSERVICE);
}

// +CGATT=[0|1]
HRESULT RILDrv_SetGPRSAttached (DWORD dwParam, BOOL fAttached)
{
    FUNCTION_TRACE(RILDrv_SetGPRSAttached);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetGPRSAttached\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+CGATT=%u\r", fAttached ? 1 : 0);

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

    Error:
    return hr;
}

/*
+CGATT: <state>
<state>: indicates the state of GPRS attachment
0 - detached
1 - attached
*/
HRESULT ParseGetGPRSAttached(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetGPRSAttached);

    UINT nValue;
    HRESULT hr = E_FAIL;
    BOOL *pbResult=NULL;

    pBlob = NULL;
    cbBlob = 0;

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

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

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

    pbResult = (BOOL*)AllocBlob(sizeof(BOOL));
    if (!pbResult)
    {
        goto Error;
    }
    *pbResult=nValue;
    pBlob = (void*)pbResult;
    cbBlob = sizeof(BOOL);
    hr = S_OK;

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

    return hr;
}

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

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

#ifdef RIL_RADIO_RESILIENCE
    if (ShouldSpoofCommand())
    {
        // If the radio was reset recently, just return FALSE.  Otherwise this may get
        // queued up after all the init commands, and take a long time to execute.
        // This is bad, since we want to handle the RIL_NOTIFY_DISCONNECT that
        // is sent up during reset so the UI can be updated quickly
        BOOL* pfAttachState = (BOOL*)AllocBlob(sizeof(BOOL));
        if (!pfAttachState) {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
        hr = pHandle->GetDevice()->GetNextCmdID();
        *pfAttachState = FALSE;
        pHandle->Notify(RIL_RESULT_OK, hr, pfAttachState, sizeof(BOOL));
    }
    else
#endif // RIL_RADIO_RESILIENCE
    {
        if (!QueueCmd(pHandle,
                      "AT+CGATT?\r",
                      CMDOPT_NONE,
                      APIID_GETGPRSATTACHED,
                      ParseGetGPRSAttached,  // Parse fn
                      NULL,     // Ptr to notification data
                      hr))
        {
            hr=E_FAIL;
            goto Error;
        }
    }
    Error:
    return hr;
}

// +CGACT=[0|1],<dwContextID>[,<dwContextID>...]
HRESULT RILDrv_SetGPRSContextActivated (DWORD dwParam, DWORD dwContextID, BOOL fContextActivation)
{
    FUNCTION_TRACE(RILDrv_SetGPRSContextActivated);
    DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : RILDrv_SetGPRSContextActivated\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+CGACT=%u,%u\r", fContextActivation ? 1 : 0, dwContextID);

    // CMDOPT_NOOP is used when fContextActivation=1 because:
    //   If GPRS context activation requires a username/password, then that information would need to be
    //   provided at the time of activation - but the activating entity (CellTSP) does not have access
    //   to the username/password - therefore, we're going to defer activation to the time of
    //   RILDrv_EnterGPRSDataMode and allow the PPP negotiation process to provide the username/password
    //   as it does with normal CSD RAS connections
   
    if (!QueueCmd(pHandle,
        szCmd,
        fContextActivation ? CMDOPT_NOOP : CMDOPT_DEACT,
        APIID_SETGPRSCONTEXTACTIVATED,
        NULL,  // Parse fn
        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;