//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:

supsvc.cpp

Abstract:


Notes:


--*/


#include "precomp.h"


//
// Information classes
//
const DWORD g_rgdwInfoClasses[] =
{
    RIL_INFOCLASS_VOICE,            // 1  = 2^0
    RIL_INFOCLASS_DATA,             // 2  = 2^1
    RIL_INFOCLASS_FAX,              // 4  = 2^2
    RIL_INFOCLASS_SMS,              // 8  = 2^3
    RIL_INFOCLASS_DATACIRCUITSYNC,  // 16 = 2^4
    RIL_INFOCLASS_DATACIRCUITASYNC, // 32 = 2^5
    RIL_INFOCLASS_PACKETACCESS,     // 32 = 2^6
    RIL_INFOCLASS_PADACCESS,        // 64 = 2^7
};
const size_t fInfoClassesEcount = (sizeof(g_rgdwInfoClasses) / sizeof(DWORD));

//
// CallerID, DialedID, Closed User Group status values
//
static const DWORD g_rgdwSupSvcStats[] =
{
    RIL_SVCSTAT_DISABLED,           // 0
    RIL_SVCSTAT_ENABLED,            // 1
};
#define NUM_SUPSVCSTATS     (sizeof(g_rgdwSupSvcStats) / sizeof(DWORD))

//
// HideID status values
//
static const DWORD g_rgdwHideIDStats[] =
{
    RIL_SVCSTAT_DEFAULT,            // 0
    RIL_SVCSTAT_ENABLED,            // 1
    RIL_SVCSTAT_DISABLED,           // 2
};
#define NUM_HIDEIDSTATS   (sizeof(g_rgdwHideIDStats) / sizeof(DWORD))

//
// CallerID and DialedID provisioning values
//
static const DWORD g_rgdwSupSvcProv[] =
{
    RIL_SVCPROV_NOTPROVISIONED,     // 0
    RIL_SVCPROV_PROVISIONED,        // 1
    RIL_SVCPROV_UNKNOWN,            // 2
};
#define NUM_SUPSVCPROV      (sizeof(g_rgdwSupSvcProv) / sizeof(DWORD))


//
// HideID provisioning values
//
static const DWORD g_rgdwHideIDProv[] =
{
    RIL_SVCPROV_NOTPROVISIONED,     // 0
    RIL_SVCPROV_PROVISIONED,        // 1
    RIL_SVCPROV_UNKNOWN,            // 2
    RIL_SVCPROV_TEMPMODERESTRICTED, // 3
    RIL_SVCPROV_TEMPMODEALLOWED,    // 4
};
#define NUM_HIDEIDPROV   (sizeof(g_rgdwHideIDProv) / sizeof(DWORD))


//
// Closed User Group info values
//
static const DWORD g_rgdwClosedGroupInfos[] =
{
    RIL_CUGINFO_NONE,               // 0
    RIL_CUGINFO_SUPPRESSOA,         // 1
    RIL_CUGINFO_SUPRESSPREF,        // 2
    RIL_CUGINFO_SUPPRESSOAANDPREF,  // 3
};
#define NUM_CLOSEDGROUPINFOS    (sizeof(g_rgdwClosedGroupInfos) / sizeof(DWORD))


//
// Call Forwarding Reasons
//
static const DWORD g_rgdwFwdReasons[] =
{
    RIL_FWDREASON_UNCONDITIONAL,    // 0
    RIL_FWDREASON_MOBILEBUSY,       // 1
    RIL_FWDREASON_NOREPLY,          // 2
    RIL_FWDREASON_UNREACHABLE,      // 3
    RIL_FWDREASON_ALLFORWARDING,    // 4
    RIL_FWDREASON_ALLCONDITIONAL,   // 5
};
#define NUM_FWDREASONS          (sizeof(g_rgdwFwdReasons) / sizeof(DWORD))

static BOOL g_fAllowEnableHideCallerId = TRUE;
extern HRESULT ParseGetCallBarringStatus(LPCSTR szRsp, void*& pBlob, UINT& cbBlob);

//
//
//
static HRESULT ParseGetCallerIdSettings(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetCallerIdSettings);
    UINT nValue;
    RILCALLERIDSETTINGS* prcids = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

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

    if (NUM_SUPSVCSTATS > nValue) {
        prcids->dwStatus = g_rgdwSupSvcStats[nValue];
    } else {
        prcids->dwStatus = RIL_SVCSTAT_UNKNOWN;
    }
    prcids->dwParams |= RIL_PARAM_CIDS_STATUS;

    // cache this value because the radio does not persist it across reboots or radio resets
    g_dwLastCLIP = nValue;
    SetRegistryDWORD(HKEY_LOCAL_MACHINE, g_tszRegKeyRIL, TEXT("LastCLIP"), g_dwLastCLIP);
    DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : RILDrv_SetCallerIdStatus : Saved LastCLIP=0x%x\r\n"),g_dwLastCLIP));
    

    // Parse ",<provisioning><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)   ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    if (NUM_SUPSVCPROV > nValue) {
        prcids->dwProvisioning = g_rgdwSupSvcProv[nValue];
    } else {
        prcids->dwProvisioning = RIL_SVCPROV_UNKNOWN;
    }
    prcids->dwParams |= RIL_PARAM_CIDS_PROVISIONING;

    pBlob = (void*)prcids;
    cbBlob = sizeof(RILCALLERIDSETTINGS);

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


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

    if (!QueueCmd(pHandle, "AT+CLIP?\r", CMDOPT_NONE, APIID_GETCALLERIDSETTINGS, ParseGetCallerIdSettings, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetCallerIdStatus(DWORD dwParam, DWORD dwStatus)
{
    FUNCTION_TRACE(RILDrv_SetCallerIdStatus);
    UINT i;
    UINT nValue;
    char szCmd[MAX_PATH];
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = (CRilInstanceHandle*)dwParam;
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

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

    (void)_snprintfz(szCmd, MAX_PATH, "AT+CLIP=%d\r", nValue);
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETCALLERIDSTATUS, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

    // cache this value because the radio does not persist it across reboots or radio resets
    g_dwLastCLIP = nValue;
    SetRegistryDWORD(HKEY_LOCAL_MACHINE, g_tszRegKeyRIL, TEXT("LastCLIP"), g_dwLastCLIP);
    DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : RILDrv_SetCallerIdStatus : Saved LastCLIP=0x%x\r\n"),g_dwLastCLIP));
    

Error:
    return hr;
}


//
//
//
static HRESULT ParseGetHideIdSettings(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetHideIdSettings);
    UINT nValue;
    RILHIDEIDSETTINGS* prhids = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "<prefix>+CLIR: <status>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CLIR: ", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    if (NUM_HIDEIDSTATS > nValue) {
        prhids->dwStatus = g_rgdwHideIDStats[nValue];
    } else {
        prhids->dwStatus = RIL_SVCSTAT_UNKNOWN;
    }
    prhids->dwParams |= RIL_PARAM_HIDS_STATUS;

    // cache this value because the radio does not persist it across reboots or radio resets
    g_dwLastCLIR = nValue;
    SetRegistryDWORD(HKEY_LOCAL_MACHINE, g_tszRegKeyRIL, TEXT("LastCLIR"), g_dwLastCLIR);
    DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : ParseGetHideIdSettings : Saved LastCLIR=0x%x\r\n"),g_dwLastCLIP));  

    // Parse ",<provisioning><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)   ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    if (NUM_HIDEIDPROV > nValue) {
        prhids->dwProvisioning = g_rgdwHideIDProv[nValue];
    } else {
        prhids->dwProvisioning = RIL_SVCPROV_UNKNOWN;
    }
    prhids->dwParams |= RIL_PARAM_HIDS_PROVISIONING;

    if (RIL_SVCPROV_NOTPROVISIONED == prhids->dwProvisioning) {
        g_fAllowEnableHideCallerId = FALSE;
    } else {
        g_fAllowEnableHideCallerId = TRUE;
    }

    pBlob = (void*)prhids;
    cbBlob = sizeof(RILHIDEIDSETTINGS);

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


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

    if (!QueueCmd(pHandle, "AT+CLIR?\r", CMDOPT_NONE, APIID_GETHIDEIDSETTINGS, ParseGetHideIdSettings, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetHideIdStatus(DWORD dwParam, DWORD dwStatus)
{
    FUNCTION_TRACE(RILDrv_SetHideIdStatus);
    UINT i;
    UINT nValue;
    char szCmd[MAX_PATH];
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    //do not allow CLIR invocation if it is not provisioned
    if ((RIL_SVCSTAT_ENABLED == dwStatus) && !g_fAllowEnableHideCallerId) {
        hr = RIL_E_SVCNOTSUBSCRIBED;
        goto Error;
    }

    for (i = 0; i < NUM_HIDEIDSTATS; i++) {
        if (dwStatus == g_rgdwHideIDStats[i]) {
            nValue = i;
            break;
        }
    }
    if (NUM_HIDEIDSTATS == i) {
        hr = E_INVALIDARG;
        goto Error;
    }

    (void)_snprintfz(szCmd, MAX_PATH, "AT+CLIR=%u\r", nValue);
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETHIDEIDSTATUS, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

    // cache this value because the radio does not persist it across reboots or radio resets
    g_dwLastCLIR = nValue;
    SetRegistryDWORD(HKEY_LOCAL_MACHINE, g_tszRegKeyRIL, TEXT("LastCLIR"), g_dwLastCLIR);
    DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : RILDrv_SetHideIdStatus : Saved LastCLIR=0x%x\r\n"),g_dwLastCLIP));

Error:
    return hr;
}


//
//
//
static HRESULT ParseGetDialedIdSettings(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDialedIdSettings);
    UINT nValue;
    RILDIALEDIDSETTINGS* prdids = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

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

#ifdef RIL_PARAM_DIDS_STATUS
    if (NUM_SUPSVCSTATS > nValue) {
        prdids->dwStatus = g_rgdwSupSvcStats[nValue];
    } else {
        prdids->dwStatus = RIL_SVCSTAT_UNKNOWN;
    }
    prdids->dwParams |= RIL_PARAM_DIDS_STATUS;
#endif

    // Parse ",<provisioning><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)   ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    if (NUM_SUPSVCPROV > nValue) {
        prdids->dwProvisioning = g_rgdwSupSvcProv[nValue];
    } else {
        prdids->dwProvisioning = RIL_SVCPROV_UNKNOWN;
    }
    prdids->dwParams |= RIL_PARAM_DIDS_PROVISIONING;

    pBlob = (void*)prdids;
    cbBlob = sizeof(RILDIALEDIDSETTINGS);

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


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

    if (!QueueCmd(pHandle, "AT+COLP?\r", CMDOPT_NONE, APIID_GETDIALEDIDSETTINGS, ParseGetDialedIdSettings, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}

//
//
//
HRESULT RILDrv_SetDialedIdStatus(DWORD dwParam, DWORD dwStatus)
{
    FUNCTION_TRACE(RILDrv_SetDialedIdStatus);
    UINT i;
    UINT nValue;
    char szCmd[MAX_PATH];
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = (CRilInstanceHandle*)dwParam;
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

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

    (void)_snprintfz(szCmd, MAX_PATH, "AT+COLP=%d\r", nValue);