supsvc.cpp

ril source code for Windows CE

    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETDIALEDIDSTATUS, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
static HRESULT ParseGetClosedGroupSettings(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetClosedGroupSettings);
    UINT nValue;
    RILCLOSEDGROUPSETTINGS* prcgs = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "<prefix>+CCUG: <status>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CCUG: ", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    if (NUM_SUPSVCSTATS > nValue) {
        prcgs->dwStatus = g_rgdwSupSvcStats[nValue];
    } else {
        prcgs->dwStatus = RIL_SVCSTAT_UNKNOWN;
    }
    prcgs->dwParams |= RIL_PARAM_CGS_STATUS;

    // Parse ",<index>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 11, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    if (10 == nValue) {
        // Special index value that means "no index"
        prcgs->dwIndex = RIL_CUGINDEX_NONE;
    } else {
        prcgs->dwIndex = nValue;
    }
    prcgs->dwParams |= RIL_PARAM_CGS_INDEX;

    // Parse ",<info><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)   ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    if (NUM_CLOSEDGROUPINFOS > nValue) {
        prcgs->dwInfo = g_rgdwClosedGroupInfos[nValue];
    } else {
        prcgs->dwInfo = RIL_CUGINFO_NONE;
    }
    prcgs->dwParams |= RIL_PARAM_CGS_INFO;

    pBlob = (void*)prcgs;
    cbBlob = sizeof(RILCLOSEDGROUPSETTINGS);

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


//
//
//
HRESULT RILDrv_GetClosedGroupSettings(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetClosedGroupSettings);

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

    if (!QueueCmd(pHandle, "AT+CCUG?\r", CMDOPT_NONE, APIID_GETCLOSEDGROUPSETTINGS, ParseGetClosedGroupSettings,
                  NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetClosedGroupSettings(DWORD dwParam, const RILCLOSEDGROUPSETTINGS* lpSettings)
{
    FUNCTION_TRACE(RILDrv_SetClosedGroupSettings);

    DEBUGCHK(NULL != lpSettings);

    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    UINT i;
    UINT nValue;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpSettings) {
        hr = E_FAIL;
        goto Error;
    }

    if (!(lpSettings->dwParams & RIL_PARAM_CGS_STATUS)) {
        hr = E_INVALIDARG;
        goto Error;
    }

    for (i = 0; i < NUM_SUPSVCSTATS; i++) {
        if (lpSettings->dwStatus == g_rgdwSupSvcStats[i]) {
            nValue = i;
            break;
        }
    }
    if (NUM_SUPSVCSTATS == i) {
        hr = E_INVALIDARG;
        goto Error;
    }

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

    if (lpSettings->dwParams & RIL_PARAM_CGS_INDEX) {
        nValue = (RIL_CUGINDEX_NONE == lpSettings->dwIndex ? 10 : lpSettings->dwIndex);
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), ",%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    if (lpSettings->dwParams & RIL_PARAM_CGS_INFO) {
        for (i = 0; i < NUM_CLOSEDGROUPINFOS; i++) {
            if (lpSettings->dwInfo == g_rgdwClosedGroupInfos[i]) {
                nValue = i;
                break;
            }
        }
        if (NUM_CLOSEDGROUPINFOS == i) {
            hr = E_INVALIDARG;
            goto Error;
        }

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

    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETCLOSEDGROUPSETTINGS, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
static HRESULT ParseGetCallForwardingSettings(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetCallForwardingSettings);
    UINT i;
    UINT nValue;
    char szAddress[MAXLENGTH_ADDRESS];
    char szSubAddress[MAXLENGTH_SUBADDR];
    UINT nUsed = 0;
    UINT nAllocated = 0;
    RILCALLFORWARDINGSETTINGS* rgrcfs = NULL;
    BOOL fSubAddressPresent = FALSE;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "+CCFC: "
    while (MatchStringBeginning(szRsp, "+CCFC: ", szRsp)) {
        if (nUsed == nAllocated) {
            if (!AllocateOrReallocateStorage((BYTE**)&rgrcfs, sizeof(RILCALLFORWARDINGSETTINGS), nUsed, &nAllocated, SUPSVC_ALLOC_NUMBER)) {
                hr = E_OUTOFMEMORY;
                goto Error;
            }
        }

        (void)memset(&rgrcfs[nUsed], 0x00, sizeof(RILCALLFORWARDINGSETTINGS));
        rgrcfs[nUsed].cbSize = sizeof(RILCALLFORWARDINGSETTINGS);

        // Parse "<status>"
        if (!ParseUInt(szRsp, TRUE, nValue, szRsp)) {
            goto Continue;
        }
        if (NUM_SUPSVCSTATS > nValue) {
            rgrcfs[nUsed].dwStatus = g_rgdwSupSvcStats[nValue];
        } else {
            rgrcfs[nUsed].dwStatus = RIL_SVCSTAT_UNKNOWN;
        }
        rgrcfs[nUsed].dwParams |= RIL_PARAM_CFS_STATUS;

        // Parse ",<class>"
        if (!MatchStringBeginning(szRsp, ",", szRsp) ||
            !ParseUInt(szRsp, TRUE, nValue, szRsp)) {
            goto Continue;
        }
        for (i = 0 ; i < NUM_INFOCLASSES; i++) {
            if (nValue & (0x01 << i)) {
                rgrcfs[nUsed].dwInfoClasses |= g_rgdwInfoClasses[i];
            }
        }
        rgrcfs[nUsed].dwParams |= RIL_PARAM_CFS_INFOCLASSES;

        // Parse ","
        if (MatchStringBeginning(szRsp, ",", szRsp)) {
            // Parse "<address>,<type>"
            if (!ParseString(szRsp, szAddress, MAXLENGTH_ADDRESS, szRsp)     ||
                !MatchStringBeginning(szRsp, ",", szRsp)                     ||
                !ParseUIntAndVerifyAbove(szRsp, FALSE, 0x100, nValue, szRsp) ||
                !StringToRILAddress(szAddress, (BYTE)nValue, rgrcfs[nUsed].raAddress)) {
                goto Continue;
            }
            rgrcfs[nUsed].dwParams |= RIL_PARAM_CFS_ADDRESS;

            // Parse ","
            if (MatchStringBeginning(szRsp, ",", szRsp)) {
                // Parse "<subaddr>,<subaddr_type>"
                if (ParseString(szRsp, szSubAddress, MAXLENGTH_SUBADDR, szRsp)) {
                    fSubAddressPresent = TRUE;
                }

                // Parse ","
                if (!MatchStringBeginning(szRsp, ",", szRsp)) {
                    goto Continue;
                }

                // Parse "<subaddr_type>"
                if (ParseUIntAndVerifyAbove(szRsp, FALSE, 0x100, nValue, szRsp) &&
                    fSubAddressPresent                                          &&
                    StringToRILSubAddress(szSubAddress, (BYTE)nValue, rgrcfs[nUsed].rsaSubAddress)) {
                    rgrcfs[nUsed].dwParams |= RIL_PARAM_RPI_SUBADDRESS;
                }

                // Parse ","
                if (MatchStringBeginning(szRsp, ",", szRsp)) {
                    // Parse "<time>
                    if (!ParseUInt(szRsp, FALSE, nValue, szRsp)) {
                        goto Continue;
                    }
                    rgrcfs[nUsed].dwDelayTime = nValue;
                    rgrcfs[nUsed].dwParams |= RIL_PARAM_CFS_DELAYTIME;
                }
            }
        }

        // Increment the array index
        nUsed++;

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

    pBlob = (void*)rgrcfs;
    cbBlob = nUsed * sizeof(RILCALLFORWARDINGSETTINGS);

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


//
//
//
HRESULT RILDrv_GetCallForwardingSettings(DWORD dwParam, DWORD dwReason, DWORD dwInfoClasses)
{
    FUNCTION_TRACE(RILDrv_GetCallForwardingSettings);
    UINT i;
    UINT nValue;
    DWORD dwClass = 0;
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    for (i = 0; i < NUM_FWDREASONS; i++) {
        if (dwReason == g_rgdwFwdReasons[i]) {
            nValue = i;
            break;
        }
    }
    if (NUM_FWDREASONS == i) {
        hr = E_INVALIDARG;
        goto Error;
    }

    szWalk = BeginLineSpecificCommand(szCmd, MAX_PATH, 0);

    // unspecified infoclass is treated as default
    if ((RIL_INFOCLASS_NONE == dwInfoClasses) || ((RIL_INFOCLASS_VOICE | RIL_INFOCLASS_DATA | RIL_INFOCLASS_FAX) == dwInfoClasses)) {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CCFC=%u,2\r", nValue);
    }
    else {
        for (i = 0 ; i < NUM_INFOCLASSES; i++) {
            if (dwInfoClasses & g_rgdwInfoClasses[i]) {
                dwClass |= (0x01 << i);
            }
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CCFC=%u,2,,,%u\r", nValue, dwClass);
    }
    
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_GETCALLFORWARDINGSETTINGS, ParseGetCallForwardingSettings, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_AddCallForwarding(DWORD dwParam, DWORD dwReason, const RILCALLFORWARDINGSETTINGS* lpSettings)
{
    FUNCTION_TRACE(RILDrv_AddCallForwarding);
    UINT i;
    UINT nValue;
    DWORD dwClass = 0;
    BYTE bTypeOfAddress;
    char szAddress[MAXLENGTH_ADDRESS];
    char szCmd[SUPSVC_CMDBUF_LENGTH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpSettings) {
        hr = E_FAIL;
        goto Error;
    }

    // Address and information classes must be specified
    if (!(lpSettings->dwParams & RIL_PARAM_CFS_ADDRESS) ||
        !(lpSettings->dwParams & RIL_PARAM_CFS_INFOCLASSES)) {
        hr = E_INVALIDARG;
        goto Error;
    }

    // Determine the reason value
    for (i = 0; i < NUM_FWDREASONS; i++) {
        if (dwReason == g_rgdwFwdReasons[i]) {
            nValue = i;
            break;
        }
    }
    if (NUM_FWDREASONS == i) {
        hr = E_INVALIDARG;
        goto Error;
    }

    // Determine address and type-of-address byte
    hr = RILAddressToString(lpSettings->raAddress, szAddress, MAXLENGTH_ADDRESS, bTypeOfAddress);
    if (FAILED(hr)) {
        goto Error;
    }

    szWalk = BeginLineSpecificCommand(szCmd, SUPSVC_CMDBUF_LENGTH, 0);

    for (i = 0 ; i < NUM_INFOCLASSES; i++) {
        if (lpSettings->dwInfoClasses & g_rgdwInfoClasses[i]) {
            dwClass |= (0x01 << i);
        }
    }

    if (dwClass) {
        (void)_snprintfz(szWalk, SUPSVC_CMDBUF_LENGTH - (szWalk - szCmd), "+CCFC=%u,3,\"%s\",%u,%u", nValue, szAddress,
                         bTypeOfAddress, dwClass);
    }
    else {
        (void)_snprintfz(szWalk, SUPSVC_CMDBUF_LENGTH - (szWalk - szCmd), "+CCFC=%u,3,\"%s\",%u", nValue, szAddress,
                         bTypeOfAddress);
    }

    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);
    
    // Add delay time
    if ((lpSettings->dwParams & RIL_PARAM_CFS_DELAYTIME) &&
        ((RIL_FWDREASON_NOREPLY == dwReason) || // GSM 07.07: <time>: when "no reply" is enabled or queried...
         (RIL_FWDREASON_ALLFORWARDING == dwReason) ||
         (RIL_FWDREASON_ALLCONDITIONAL == dwReason))) {

        if (dwClass) {
            (void)_snprintfz(szWalk, SUPSVC_CMDBUF_LENGTH - (szWalk - szCmd), ",,,%u", lpSettings->dwDelayTime);
        }
        else {
            (void)_snprintfz(szWalk, SUPSVC_CMDBUF_LENGTH - (szWalk - szCmd), ",,,,%u", lpSettings->dwDelayTime);
        }

        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    (void)strncpyz(szWalk, "\r", SUPSVC_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30

    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_ADDCALLFORWARDING, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_RemoveCallForwarding(DWORD dwParam, DWORD dwReason, DWORD dwInfoClasses)
{
    FUNCTION_TRACE(RILDrv_RemoveCallForwarding);
    UINT i;
    UINT nValue;
    DWORD dwClass = 0;
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    // Determine the reason value
    for (i = 0; i < NUM_FWDREASONS; i++) {
        if (dwReason == g_rgdwFwdReasons[i]) {
            nValue = i;
            break;
        }
    }
    if (NUM_FWDREASONS == i) {
        hr = E_INVALIDARG;
        goto Error;
    }


    szWalk = BeginLineSpecificCommand(szCmd, MAX_PATH, 0);

    // unspecified infoclass is treated as default
    if ((RIL_INFOCLASS_NONE == dwInfoClasses) || ((RIL_INFOCLASS_VOICE | RIL_INFOCLASS_DATA | RIL_INFOCLASS_FAX) == dwInfoClasses)) {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CCFC=%u,4", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    } else {
        for (i = 0 ; i < NUM_INFOCLASSES; i++) {
            if (dwInfoClasses & g_rgdwInfoClasses[i]) {
                dwClass |= (0x01 << i);
            }
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CCFC=%u,4,,,%u", nValue, dwClass);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));  // NO_TYPO: 30

    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_REMOVECALLFORWARDING, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}