data.cpp

ril source code for Windows CE

        DEBUGCHK(RIL_BSVCNAME_PACKETACCESS_SYNC_RDI >= lpBearerServiceInfo->dwServiceName);

        if ( RIL_BSVCNAME_UNKNOWN == lpBearerServiceInfo->dwServiceName ||
             lpBearerServiceInfo->dwServiceName > RIL_BSVCNAME_PACKETACCESS_SYNC_RDI )
        {
            hr = E_INVALIDARG;
            goto Error;
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", g_rgdwBearerSvcNames[lpBearerServiceInfo->dwServiceName]);
        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);

    // Add "<conn_elem>"
    if (lpBearerServiceInfo->dwParams & RIL_PARAM_BSI_CONNECTIONELEMENT)
    {
        DEBUGCHK(RIL_BSVCCE_BOTH_NONTRANSPARENT >= lpBearerServiceInfo->dwConnectionElement);

        if ( RIL_BSVCCE_UNKNOWN == lpBearerServiceInfo->dwConnectionElement ||
             lpBearerServiceInfo->dwConnectionElement > RIL_BSVCCE_BOTH_NONTRANSPARENT )
        {
            hr = E_INVALIDARG;
            goto Error;
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u",
                         g_rgdwBearerSvcConnElems[lpBearerServiceInfo->dwConnectionElement]);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Add "<CR>"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETBEARERSERVICEOPTIONS, NULL, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}


//
//
//
HRESULT ParseGetRLPOptions(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetRLPOptions);
    UINT nValue;
    UINT nUsed = 0;
    UINT nAllocated = 0;
    RILRLPINFO* rgrrlpi = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "+CRLP: "
    while (MatchStringBeginning(szRsp, "+CRLP: ", szRsp))
    {
        if (nUsed == nAllocated)
        {
            if (!AllocateOrReallocateStorage((BYTE**)&rgrrlpi, sizeof(RILRLPINFO), nUsed, &nAllocated, DATA_ALLOC_NUMBER))
            {
                hr = E_OUTOFMEMORY;
                goto Error;
            }
        }

        memset(&rgrrlpi[nUsed], 0x00, sizeof(RILRLPINFO));
        rgrrlpi[nUsed].cbSize = sizeof(RILRLPINFO);

        // Parse "<iws>"
        if (!ParseUInt(szRsp, TRUE, nValue, szRsp))
        {
            goto Continue;
        }
        rgrrlpi[nUsed].dwIWS = nValue;
        rgrrlpi[nUsed].dwParams |= RIL_PARAM_RLPI_IWS;

        // Parse ",<mws>"
        if (!MatchStringBeginning(szRsp, ",", szRsp) ||
            !ParseUInt(szRsp, TRUE, nValue, szRsp))
        {
            goto Continue;
        }
        rgrrlpi[nUsed].dwMWS = nValue;
        rgrrlpi[nUsed].dwParams |= RIL_PARAM_RLPI_MWS;

        // Parse ",<ack_timer>"
        if (!MatchStringBeginning(szRsp, ",", szRsp) ||
            !ParseUInt(szRsp, TRUE, nValue, szRsp))
        {
            goto Continue;
        }
        rgrrlpi[nUsed].dwAckTimer = nValue;
        rgrrlpi[nUsed].dwParams |= RIL_PARAM_RLPI_ACKTIMER;

        // Parse ",<retr_att>"
        if (!MatchStringBeginning(szRsp, ",", szRsp) ||
            !ParseUInt(szRsp, TRUE, nValue, szRsp))
        {
            goto Continue;
        }
        rgrrlpi[nUsed].dwRetransmissionAttempts = nValue;
        rgrrlpi[nUsed].dwParams |= RIL_PARAM_RLPI_RETRANSMISSIONATTEMPTS;

        // Parse ","
        if (MatchStringBeginning(szRsp, ",", szRsp))
        {
            // Parse "<version>"
            if (!ParseUInt(szRsp, TRUE, nValue, szRsp))
            {
                goto Continue;
            }
            rgrrlpi[nUsed].dwVersion = nValue;
            rgrrlpi[nUsed].dwParams |= RIL_PARAM_RLPI_VERSION;

            // Parse ","
            if (MatchStringBeginning(szRsp, ",", szRsp))
            {
                // Parse "<reseq_period>"
                if (!ParseUInt(szRsp, TRUE, nValue, szRsp))
                {
                    goto Continue;
                }
                rgrrlpi[nUsed].dwResequencingPeriod = nValue;
                rgrrlpi[nUsed].dwParams |= RIL_PARAM_RPLI_RESEQUENCINGPERIOD;
            }
        }

        // If we didn't see the version, assume 0 (per GSM 07.07, ch6.8)
        if (!(rgrrlpi[nUsed].dwParams & RIL_PARAM_RLPI_VERSION))
        {
            rgrrlpi[nUsed].dwVersion = 0;
            rgrrlpi[nUsed].dwParams |= RIL_PARAM_RLPI_VERSION;
        }

        // Increment the array index
        nUsed++;

        Continue:
        // Find "<postfix>"
        if (!FindRspPostfix(szRsp, szRsp))
        {
            hr = E_FAIL;
            goto Error;
        }
    }

    pBlob = (void*)rgrrlpi;
    cbBlob = nUsed * sizeof(RILRLPINFO);

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


//
//
//
HRESULT RILDrv_GetRLPOptions(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetRLPOptions);
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle)
    {
        hr = E_FAIL;
        goto Error;
    }

    if (!QueueCmd(pHandle, "AT+CRLP?\r", CMDOPT_NONE, APIID_GETRLPOPTIONS, ParseGetRLPOptions, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetRLPOptions(DWORD dwParam, const RILRLPINFO* lpRlpInfo)
{
    FUNCTION_TRACE(RILDrv_SetRLPOptions);
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpRlpInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

    // Add "AT+CRLP="
    (void)strncpyz(szWalk, "AT+CRLP=", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    // Add "<iws>"
    if (lpRlpInfo->dwParams & RIL_PARAM_RLPI_IWS)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpRlpInfo->dwIWS);
        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);

    // Add "<mws>"
    if (lpRlpInfo->dwParams & RIL_PARAM_RLPI_MWS)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpRlpInfo->dwMWS);
        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);

    // Add "<ack_timer>"
    if (lpRlpInfo->dwParams & RIL_PARAM_RLPI_ACKTIMER)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpRlpInfo->dwAckTimer);
        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);

    // Add "<retr_att>"
    if (lpRlpInfo->dwParams & RIL_PARAM_RLPI_RETRANSMISSIONATTEMPTS)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpRlpInfo->dwRetransmissionAttempts);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Only include version info if version is 2 or above
    if ((lpRlpInfo->dwParams & RIL_PARAM_RLPI_VERSION) && (lpRlpInfo->dwVersion>=2))
    {
        // Add ","
        (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

        // Add "<version>"
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpRlpInfo->dwVersion);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

        if (lpRlpInfo->dwParams & RIL_PARAM_RPLI_RESEQUENCINGPERIOD)
        {
            // Add ","
            (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);

            // Add "<reseq_period>"
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpRlpInfo->dwResequencingPeriod);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);
        }
    }

    // Add "<CR>"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETRLPOPTIONS, NULL, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +DS: <dir>,<neg>,<P1>,<P2>
HRESULT ParseGetDataCompression(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDataCompression);
    UINT nValue;
    RILDATACOMPINFO* prdci = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    prdci = (RILDATACOMPINFO*)AllocBlob(sizeof(RILDATACOMPINFO));
    if (!prdci)
    {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(prdci, 0x00, sizeof(RILDATACOMPINFO));
    prdci->cbSize = sizeof(RILDATACOMPINFO);

    // Parse "<prefix>+DS: <dir>"
    if (!ParseRspPrefix(szRsp, szRsp)                   ||
        !MatchStringBeginning(szRsp, "+DS: ", szRsp)    ||
        !ParseUInt(szRsp, FALSE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    if (FlagFromValue(nValue, g_DataCompDirection, NUM_DATACOMPDIRECTION, prdci->dwDirection))
    {
        prdci->dwParams |= RIL_PARAM_DCI_DIRECTION;
    }

    // Parse ",<neg>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)        ||
        !ParseUInt(szRsp, FALSE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    if (FlagFromValue(nValue, g_DataCompNegotiation, NUM_DATACOMPNEGOTIATION, prdci->dwNegotiation))
    {
        prdci->dwParams |= RIL_PARAM_DCI_NEGOTIATION;
    }

    // Parse ",<P1>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)        ||
        !ParseUInt(szRsp, FALSE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    prdci->dwMaxDictEntries = nValue;
    prdci->dwParams |= RIL_PARAM_DCI_MAXDICTENTRIES;

    // Parse ",<P2><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)        ||
        !ParseUInt(szRsp, FALSE, nValue, szRsp)         ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    prdci->dwMaxStringLength = nValue;
    prdci->dwParams |= RIL_PARAM_DCI_MAXSTRING;

    pBlob = (void*)prdci;
    cbBlob = sizeof(RILDATACOMPINFO);

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

HRESULT RILDrv_GetDataCompression (DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetDataCompression);
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle)
    {
        hr = E_FAIL;
        goto Error;
    }

    if (!QueueCmd(pHandle, "AT+DS?\r", CMDOPT_NONE, APIID_GETDATACOMPRESSION, ParseGetDataCompression, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +DS=[<dir>[,<neg>[,<P1>[,<P2>]]]]
HRESULT RILDrv_SetDataCompression (DWORD dwParam, const RILDATACOMPINFO* lpDataCompInfo)
{
    FUNCTION_TRACE(RILDrv_SetDataCompression);
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    UINT nValue;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpDataCompInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

    // Add "AT+DS="
    (void)strncpyz(szWalk, "AT+DS=", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    // Add "<dir>"
    if (lpDataCompInfo->dwParams & RIL_PARAM_DCI_DIRECTION)
    {
        if (!ValueFromFlag(lpDataCompInfo->dwDirection, g_DataCompDirection, NUM_DATACOMPDIRECTION, nValue))
        {
            hr = E_INVALIDARG;
            goto Error;
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }