caps.cpp

ril source code for Windows CE

    FUNCTION_TRACE(ParseGetDevCapsBroadcastMsgLangs);

    DWORD dwLanguages = (RIL_CAPS_DCSLANG_GERMAN | RIL_CAPS_DCSLANG_ENGLISH | RIL_CAPS_DCSLANG_ITALIAN |
                         RIL_CAPS_DCSLANG_FRENCH | RIL_CAPS_DCSLANG_SPANISH | RIL_CAPS_DCSLANG_DUTCH | RIL_CAPS_DCSLANG_SWEDISH |
                         RIL_CAPS_DCSLANG_DANISH | RIL_CAPS_DCSLANG_PORTUGUESE | RIL_CAPS_DCSLANG_FINNISH |
                         RIL_CAPS_DCSLANG_NORWEGIAN | RIL_CAPS_DCSLANG_GREEK | RIL_CAPS_DCSLANG_TURKISH |
                         RIL_CAPS_DCSLANG_HUNGARIAN | RIL_CAPS_DCSLANG_POLISH | RIL_CAPS_DCSLANG_CZECH);

    HRESULT hr = ParseFakeDWord(dwLanguages, pBlob, cbBlob);

    return hr;
}


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

    return hr;
}


//
//
//
static HRESULT ParseGetDevCapsMsgStatusValues(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsMsgStatusValues);
    return ParseRangeListRsp("+CMGL: ", g_rglvmCapsMsgStatusValues, NUM_CAPSMSGSTATUSVALUES, FALSE, szRsp, pBlob, cbBlob);
}


//
//
//
static HRESULT ParseGetDevCapsPrefOpIndexRange(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsPrefOpIndexRange);
    return ParseRangeRsp("+CPOL: ", TRUE, szRsp, pBlob, cbBlob);
}


//
//
//
static HRESULT ParseGetDevCapsLockFacilities(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsLockFacilities);
    HRESULT hr =  ParseStringListRsp("+CLCK: ", g_rglsmCapsLockFacilities, NUM_CAPSLOCKFACILITIES, szRsp, pBlob, cbBlob);
#ifdef RIL_RADIO_RESILIENCE
    if (SUCCEEDED(hr))
    {
        g_cbLastLockCapsSize = cbBlob;
        if (g_pLastLockCaps)
            FreeBlob(g_pLastLockCaps);
        g_pLastLockCaps = AllocBlob(cbBlob);
        if (!g_pLastLockCaps)
        {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
        memcpy(g_pLastLockCaps, pBlob, cbBlob);
    }
Error:
#endif // RIL_RADIO_RESILIENCE
    return hr;
}


//
//
//
static HRESULT ParseGetDevCapsLockPwdLengths(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsLockPwdLengths);
    char szFacility[MAX_PATH];
    UINT nValue;
    UINT i;
    UINT nUsed = 0;
    UINT nAllocated = 0;
    RILCAPSLOCKINGPWDLENGTH* rgrclpl = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "("
    while (1) {
        if (nUsed == nAllocated) {
            if (!AllocateOrReallocateStorage((BYTE**)&rgrclpl, sizeof(RILCAPSLOCKINGPWDLENGTH), nUsed, &nAllocated, CAPS_ALLOC_NUMBER)) {
                hr = E_OUTOFMEMORY;
                goto Error;
            }
        }

        memset(&rgrclpl[nUsed], 0x00, sizeof(RILCAPSLOCKINGPWDLENGTH));
        rgrclpl[nUsed].cbSize = sizeof(RILCAPSLOCKINGPWDLENGTH);

        // Parse "(<facility>,<pwd_length>)"
        if (!MatchStringBeginning(szRsp, "(", szRsp)         ||
            !ParseString(szRsp, szFacility, MAX_PATH, szRsp) ||
            !MatchStringBeginning(szRsp, ",", szRsp)         ||
            !ParseUInt(szRsp, TRUE, nValue, szRsp)           ||
            !MatchStringBeginning(szRsp, ")", szRsp)) {
            goto Continue;
        }

        for (i = 0; i < NUM_LOCKFACILITIES; i++) {
            if (!strcmp(szFacility, g_rgszLockFacilities[i])) {
                rgrclpl[nUsed].dwFacility = i;
                rgrclpl[nUsed].dwPasswordLength = nValue;
                rgrclpl[nUsed].dwParams |= (RIL_PARAM_CLPL_FACILITY | RIL_PARAM_CLPL_PASSWORDLENGTH);
                break;
            }
        }
        if (NUM_LOCKFACILITIES == i) {
            // We couldn't match the response with anything
            goto Continue;
        }

        // Increment the array index
        nUsed++;

Continue:
        // Parse ","
        if (!MatchStringAnywhere(szRsp, ",", szRsp)) {
            break;
        }
    }

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

    pBlob = (void*)rgrclpl;
    cbBlob = nUsed * sizeof(RILCAPSLOCKINGPWDLENGTH);

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


//
//
//
static HRESULT ParseGetDevCapsBarrTypes(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsBarrTypes);
    return ParseStringListRsp("+CLCK: ", g_rglsmCapsBarrTypes, NUM_CAPSBARRTYPES, szRsp, pBlob, cbBlob);
}


//
//
//
static HRESULT ParseGetDevCapsBarrPwdLengths(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsBarrPwdLengths);
    char szType[MAX_PATH];
    UINT nValue;
    UINT i;
    UINT nUsed = 0;
    UINT nAllocated = 0;
    RILCAPSBARRINGPWDLENGTH* rgrcbpl = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "("
    while (1) {
        if (nUsed == nAllocated) {
            if (!AllocateOrReallocateStorage((BYTE**)&rgrcbpl, sizeof(RILCAPSBARRINGPWDLENGTH), nUsed, &nAllocated, CAPS_ALLOC_NUMBER)) {
                hr = E_OUTOFMEMORY;
                goto Error;
            }
        }

        memset(&rgrcbpl[nUsed], 0x00, sizeof(RILCAPSBARRINGPWDLENGTH));
        rgrcbpl[nUsed].cbSize = sizeof(RILCAPSBARRINGPWDLENGTH);

        // Parse "(<facility>,<pwd_length>)"
        if (!MatchStringBeginning(szRsp, "(", szRsp)     ||
            !ParseString(szRsp, szType, MAX_PATH, szRsp) ||
            !MatchStringBeginning(szRsp, ",", szRsp)     ||
            !ParseUInt(szRsp, TRUE, nValue, szRsp)       ||
            !MatchStringBeginning(szRsp, ")", szRsp)) {
            goto Continue;
        }

        for (i = 0; i < NUM_BARRINGTYPES; i++) {
            if (!strcmp(szType, g_rgszBarringTypes[i])) {
                rgrcbpl[nUsed].dwType = i;
                rgrcbpl[nUsed].dwPasswordLength = nValue;
                rgrcbpl[nUsed].dwParams |= (RIL_PARAM_CBPL_TYPE | RIL_PARAM_CBPL_PASSWORDLENGTH);
                break;
            }
        }
        if (NUM_BARRINGTYPES == i) {
            // We couldn't match the response with anything
            goto Continue;
        }

        // Increment the array index
        nUsed++;

Continue:
        // Parse ","
        if (!MatchStringAnywhere(szRsp, ",", szRsp)) {
            break;
        }
    }

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

    pBlob = (void*)rgrcbpl;
    cbBlob = nUsed * sizeof(RILCAPSBARRINGPWDLENGTH);

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


//
//
//
static HRESULT ParseGetDevCapsFwdReasons(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsFwdReasons);
    return ParseRangeListRsp("+CCFC: ", g_rglvmCapsFwdReasons, NUM_CAPSFWDREASONS, FALSE, szRsp, pBlob, cbBlob);
}


//
//
//
static HRESULT ParseGetDevCapsInfoClasses(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsInfoClasses);
    HRESULT hr = ParseFakeDWord(RIL_CAPS_INFOCLASS_VOICE | RIL_CAPS_INFOCLASS_DATA | RIL_CAPS_INFOCLASS_FAX, pBlob, cbBlob);

    return hr;
}


//
//
//
static HRESULT ParseGetDevCapsHSCSD(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsHSCSD);
    RILCAPSHSCSD* prchscsd = NULL;
    UINT nValue;
    UINT i;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "<prefix>+CHSD: <multislot_class>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CHSD: ", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prchscsd->dwMultislotClass = nValue;
    prchscsd->dwParams |= RIL_PARAM_CHSCSD_MULTISLOTCLASS;

    // Parse ",<max_rx_timeslots>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prchscsd->dwMaxRxTimeslots = nValue;
    prchscsd->dwParams |= RIL_PARAM_CHSCSD_MAXRXTIMESLOTS;

    // Parse ",<max_tx_timeslots>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prchscsd->dwMaxTxTimeslots = nValue;
    prchscsd->dwParams |= RIL_PARAM_CHSCSD_MAXTXTIMESLOTS;

    // Parse ",<max_timeslots>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prchscsd->dwMaxTotalTimeslots = nValue;
    prchscsd->dwParams |= RIL_PARAM_CHSCSD_MAXTOTALTIMESLOTS;

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

    // Set all required channel coding bits
    if (!nValue) {
        prchscsd->dwChannelCodings = RIL_HSCSDCODING_ALL;
    } else {
        for (i = 0 ; i < NUM_CAPSHSCSDCODINGS; i++) {
            if (nValue & (0x01 << i)) {
                prchscsd->dwChannelCodings |= g_rgdwCapsHSCSDCodings[i];
            }
        }
    }
    prchscsd->dwParams |= RIL_PARAM_CHSCSD_CHANNELCODINGS;


    // Parse "<prefix>+CHSN: <aiur_list>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CHSN: ", szRsp) ||
        !ParseRangeList(szRsp, g_rglvmHSCSDAirRates, NUM_CAPSHSCSDAIRRATES, prchscsd->dwAirInterfaceUserRates,
                        szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prchscsd->dwParams |= RIL_PARAM_CHSCSD_AIRINTERFACEUSERRATES;

    // Parse ",<junk>,<top_rx_timeslot_range>,<junk><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)                  ||
        !MatchStringAnywhere(szRsp, ",", szRsp)                   ||
        !ParseRange(szRsp, prchscsd->rrTopRxTimeslotRange, szRsp) ||
        !FindRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prchscsd->dwParams |= RIL_PARAM_CHSCSD_TOPRXTIMESLOTRANGE;

    pBlob = (void*)prchscsd;
    cbBlob = sizeof(RILCAPSHSCSD);

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


//
//
//
static HRESULT ParseGetDevCapsSimToolkitNotifications(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsSimToolkitNotifications);

    RILSIMTOOLKITNOTIFYCAPS *prstnc = NULL;
    RILSIMTOOLKITEVENTCAPS *prstec = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    prstnc = (RILSIMTOOLKITNOTIFYCAPS *)AllocBlob(sizeof(RILSIMTOOLKITNOTIFYCAPS));
    if (!prstnc) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    memset(prstnc, 0x00, sizeof(RILSIMTOOLKITNOTIFYCAPS));
    prstnc->cbSize              = sizeof(RILSIMTOOLKITNOTIFYCAPS);
    prstnc->dwParams            = RIL_PARAM_SIMTKN_ALL;
    prstnc->dwRefresh           = RIL_SIMTKN_RADIOIMPLEMENTS_NONOTIFICATION;
    prstnc->dwMoreTime          = RIL_SIMTKN_RADIOIMPLEMENTS_NONOTIFICATION;
    prstnc->dwPollInterval      = RIL_SIMTKN_RADIOIMPLEMENTS_NONOTIFICATION;
    prstnc->dwPollingOff        = RIL_SIMTKN_RADIOIMPLEMENTS_NONOTIFICATION;

    prstnc->dwSetUpCall         = g_rppPDDParams->dwDevCapsSIMTKN_SetUpCall;
    
    prstnc->dwSendSS            = RIL_SIMTKN_RADIOIMPLEMENTS_NOTIFICATION;
    prstnc->dwSendUSSD          = RIL_SIMTKN_RADIOIMPLEMENTS_NOTIFICATION;
    prstnc->dwSendSMS           = RIL_SIMTKN_RADIOIMPLEMENTS_NOTIFICATION;
    prstnc->dwPlayTone          = RIL_SIMTKN_MEIMPLEMENTS;
    prstnc->dwDisplayText       = RIL_SIMTKN_MEIMPLEMENTS;