caps.cpp

ril source code for Windows CE

        goto Error;
    }
    memset(pdw, 0x00, sizeof(DWORD));

    // Parse "<prefix><command><list><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                                        ||
        !MatchStringBeginning(szRsp, szCmd, szRsp)                           ||
        !ParseStringList(szRsp, rglsmMapArray, nMapArrayLength, *pdw, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

    pBlob = (void*)pdw;
    cbBlob = sizeof(DWORD);

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


//
//
//
static HRESULT ParseGetDevCapsDial(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsDial);
    HRESULT hr = E_NOTIMPL;

    return hr;
}



//
//
//
static HRESULT ParseGetDevCapsDTMFDurationRange(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsDTMFDurationRange);
    return ParseRangeRsp("+VTD: ", FALSE, szRsp, pBlob, cbBlob);
}


//
//
//
static HRESULT ParseGetDevCapsCallMgtCmds(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsCallMgtCmds);
    return ParseRangeListRsp("+CHLD: ", g_rglvmCapsCallCmds, NUM_CAPSCALLCMDS, FALSE, szRsp, pBlob, cbBlob);
}


//
//
//
HRESULT ParseGetDevCapsBearerSvc(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsBearerSvc);
    RILCAPSBEARERSVC* prcbs = NULL;
    LPCSTR szDummy;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "<prefix>+CBST: <speed_list>"
    if (!ParseRspPrefix(szRsp, szRsp)                                                                  ||
        !MatchStringBeginning(szRsp, "+CBST: ", szRsp)                                                 ||
        !ParseRangeList(szRsp, g_rglvmCapsConnSpeeds1, NUM_CAPSCONNSPEEDS1, prcbs->dwSpeeds1, szDummy) ||
        !ParseRangeList(szRsp, g_rglvmCapsConnSpeeds2, NUM_CAPSCONNSPEEDS2, prcbs->dwSpeeds2, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prcbs->dwParams |= (RIL_PARAM_CBS_SPEEDS1 | RIL_PARAM_CBS_SPEEDS2);

    // Parse ",<svcname_list>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseRangeList(szRsp, g_rglvmCapsSvcNames, NUM_CAPSSVCNAMES, prcbs->dwServiceNames, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prcbs->dwParams |= RIL_PARAM_CBS_SERVICENAMES;

    // Parse ",<connelem_list><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)                                                            ||
        !ParseRangeList(szRsp, g_rglvmCapsConnElems, NUM_CAPSCONNELEMS, prcbs->dwConnectionElements, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prcbs->dwParams |= RIL_PARAM_CBS_CONNECTIONELEMENTS;

    pBlob = (void*)prcbs;
    cbBlob = sizeof(RILCAPSBEARERSVC);

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


//
//
//
static HRESULT ParseGetDevCapsRLP(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsRLP);
    UINT nValue;
    UINT nUsed = 0;
    UINT nAllocated = 0;
    RILCAPSRLP* rgrcrlp = 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**)&rgrcrlp, sizeof(RILCAPSRLP), nUsed, &nAllocated, CAPS_ALLOC_NUMBER)) {
                hr = E_OUTOFMEMORY;
                goto Error;
            }
        }

        memset(&rgrcrlp[nUsed], 0x00, sizeof(RILCAPSRLP));
        rgrcrlp[nUsed].cbSize = sizeof(RILCAPSRLP);

        // Parse "<iws_range>"
        if (!ParseRange(szRsp, rgrcrlp[nUsed].rrIWSRange, szRsp)) {
            goto Continue;
        }
        rgrcrlp[nUsed].dwParams |= RIL_PARAM_CRLP_IWSRANGE;

        // Parse ",<mws_range>"
        if (!MatchStringBeginning(szRsp, ",", szRsp) ||
            !ParseRange(szRsp, rgrcrlp[nUsed].rrMWSRange, szRsp)) {
            goto Continue;
        }
        rgrcrlp[nUsed].dwParams |= RIL_PARAM_CRLP_MWSRANGE;

        // Parse ",<acktimer_range>"
        if (!MatchStringBeginning(szRsp, ",", szRsp) ||
            !ParseRange(szRsp, rgrcrlp[nUsed].rrAckTimerRange, szRsp)) {
            goto Continue;
        }
        rgrcrlp[nUsed].dwParams |= RIL_PARAM_CRLP_ACKTIMERRANGE;

        // Parse ",<retransmissionatts_range>"
        if (!MatchStringBeginning(szRsp, ",", szRsp) ||
            !ParseRange(szRsp, rgrcrlp[nUsed].rrRetransmissionAttsRange, szRsp)) {
            goto Continue;
        }
        rgrcrlp[nUsed].dwParams |= RIL_PARAM_CRLP_RETRANSMISSIONATTSRANGE;

        // Parse ","
        if (MatchStringBeginning(szRsp, ",", szRsp)) {

            if (*szRsp=='(') szRsp++;    // Ignore '(' and ')' characters around version

            // Parse "<version>"
            if (!ParseUInt(szRsp, TRUE, nValue, szRsp)) {
                goto Continue;
            }

            if (*szRsp==')') szRsp++;    // Ignore '(' and ')' characters around version

            rgrcrlp[nUsed].dwVersion = nValue;
            rgrcrlp[nUsed].dwParams |= RIL_PARAM_CRLP_VERSION;

            // Parse ","
            if ((nValue>1) && (MatchStringBeginning(szRsp, ",", szRsp))) {
                // Parse "<reseqperiod_range>"
                if (!ParseRange(szRsp, rgrcrlp[nUsed].rrReseqPeriodRange, szRsp)) {
                    goto Continue;
                }
                rgrcrlp[nUsed].dwParams |= RIL_PARAM_CRLP_RESEQPERIODRANGE;
            }
        }

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

        // Increment the array index
        nUsed++;

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

    pBlob = (void*)rgrcrlp;
    cbBlob = nUsed * sizeof(RILCAPSRLP);

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


//
//
//
static HRESULT ParseGetDevCapsEquipmentStates(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsEquipmentStates);
    return ParseRangeListRsp("+CFUN: ", g_rglvmCapsEqStates, NUM_CAPSEQSTATES, TRUE, szRsp, pBlob, cbBlob);
}


//
//
//
static HRESULT ParseGetDevCapsPBStoreLocs(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsPBStoreLocs);
    return ParseStringListRsp("+CPBS: ", g_rppPDDParams->plsmPhoneBookLocationCapsTable, g_rppPDDParams->uiPhoneBookLocationCapsTableSize, szRsp, pBlob, cbBlob);
}


//
//
//
static HRESULT ParseGetDevCapsPBIndexRange(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsPBIndexRange);
    HRESULT hr = ParseRangeRsp("+CPBR: ", TRUE, szRsp, pBlob, cbBlob);
	if (SUCCEEDED(hr)) {
		RILRANGE * pRange = (RILRANGE*)pBlob;
		if (255 == pRange->dwMaxValue) {
			--(pRange->dwMaxValue);
		}
	}
	return hr;
}


//
//
//
static HRESULT ParseGetDevCapsPBEntryLength(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsPBEntryLength);
    RILCAPSPBENTRYLENGTH* prcpbel = NULL;
    UINT nValue;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

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

    // Parse "<num_length>", not a required value
    if (ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        prcpbel->dwMaxAddressLength = nValue;
        prcpbel->dwParams |= RIL_PARAM_CPBEL_MAXADDRESSLENGTH;
    }

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

    // Parse "<text_length>", not a required value
    if (ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        prcpbel->dwMaxTextLength = nValue;
        prcpbel->dwParams |= RIL_PARAM_CPBEL_MAXTEXTLENGTH;
    }

    // Parse <postfix>
    if (!ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

    pBlob = (void*)prcpbel;
    cbBlob = sizeof(RILCAPSPBENTRYLENGTH);

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

//
//
//
static HRESULT ParseGetDevCapsMsgSvcTypes(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsMsgSvcTypes);
    return ParseRangeListRsp("+CSMS: ", g_rglvmCapsMsgSvcTypes, NUM_CAPSMSGSVCTYPES, FALSE, szRsp, pBlob, cbBlob);
}


//
//
//
static HRESULT ParseGetDevCapsMsgMemoryLocs(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsMsgMemoryLocs);
    RILCAPSMSGMEMORYLOCATIONS* prcmml = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

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

    if (!MatchStringBeginning(szRsp, "+CPMS: ", szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    // Skip extraneous '(' at beginning if it's there
    if ((szRsp[0]=='(') && (szRsp[1]=='('))
    {
        szRsp++;
    }

    if (!ParseStringList(szRsp, g_rglsmCapsMsgLocations, NUM_CAPSMSGLOCS, prcmml->dwReadLocations, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    prcmml->dwParams |= RIL_PARAM_CMML_READLOCATIONS;

    // Parse ","
    if (MatchStringBeginning(szRsp, ",", szRsp)) {
        // Parse "<writeloc_list>"
        if (!ParseStringList(szRsp, g_rglsmCapsMsgLocations, NUM_CAPSMSGLOCS, prcmml->dwWriteLocations, szRsp)) {
            hr = E_FAIL;
            goto Error;
        }
        prcmml->dwParams |= RIL_PARAM_CMML_WRITELOCATIONS;

        // Parse ","
        if (MatchStringBeginning(szRsp, ",", szRsp)) {
            // Parse "<storeloc_list>"
            if (!ParseStringList(szRsp, g_rglsmCapsMsgLocations, NUM_CAPSMSGLOCS, prcmml->dwStoreLocations, szRsp)) {
                hr = E_FAIL;
                goto Error;
            }
            prcmml->dwParams |= RIL_PARAM_CMML_STORELOCATIONS;
        }
    }

    pBlob = (void*)prcmml;
    cbBlob = sizeof(RILCAPSMSGMEMORYLOCATIONS);

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


//
//
//
static HRESULT ParseGetDevCapsBroadcastMsgLangs(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{