secur.cpp

ril source code for Windows CE

//
// 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:

secur.cpp

Abstract:


Notes:


--*/


#include "precomp.h"


//
// Locked states
//
const LPCSTR g_rgszLockedStates[] =
{
    "",                 // RIL_LOCKEDSTATE_UNKNOWN
    "READY",            // RIL_LOCKEDSTATE_READY
    "SIM PIN",          // RIL_LOCKEDSTATE_SIM_PIN
    "SIM PUK",          // RIL_LOCKEDSTATE_SIM_PUK
    "PH-SIM PIN",       // RIL_LOCKEDSTATE_PH_SIM_PIN
    "PH-FSIM PIN",      // RIL_LOCKEDSTATE_PH_FSIM_PIN
    "PH-FSIM PUK",      // RIL_LOCKEDSTATE_PH_FSIM_PUK
    "SIM PIN2",         // RIL_LOCKEDSTATE_SIM_PIN2
    "SIM PUK2",         // RIL_LOCKEDSTATE_SIM_PUK2
    "PH-NET PIN",       // RIL_LOCKEDSTATE_PH_NET_PIN
    "PH-NET PUK",       // RIL_LOCKEDSTATE_PH_NET_PUK
    "PH-NETSUB PIN",    // RIL_LOCKEDSTATE_PH_NETSUB_PIN
    "PH-NETSUB PUK",    // RIL_LOCKEDSTATE_PH_NETSUB_PUK
    "PH-SP PIN",        // RIL_LOCKEDSTATE_PH_SP_PIN
    "PH-SP PUK",        // RIL_LOCKEDSTATE_PH_SP_PUK
    "PH-CORP PIN",      // RIL_LOCKEDSTATE_PH_CORP_PIN
    "PH-CORP PUK",      // RIL_LOCKEDSTATE_PH_COPR_PUK
};
const size_t fLockedStatesEcount = (sizeof(g_rgszLockedStates) / sizeof(LPCSTR) - 1);


//
// Lock facilities
//
const LPCSTR g_rgszLockFacilities[] =
{
    "",     // 0
    "CS",   // RIL_LOCKFACILITY_CNTRL
    "PS",   // RIL_LOCKFACILITY_PH_SIM
    "PF",   // RIL_LOCKFACILITY_PH_FSIM
    "SC",   // RIL_LOCKFACILITY_SIM
    "P2",   // RIL_LOCKFACILITY_SIM_PIN2
    "FD",   // RIL_LOCKFACILITY_SIM_FIXEDIALING
    "PN",   // RIL_LOCKFACILITY_NETWORKPERS
    "PU",   // RIL_LOCKFACILITY_NETWORKSUBPERS
    "PP",   // RIL_LOCKFACILITY_SERVICEPROVPERS
    "PC",   // RIL_LOCKFACILITY_CORPPERS

};
const size_t fLockFacilitiesEcount = (sizeof(g_rgszLockFacilities) / sizeof(LPCSTR));


//
// Call barring types
//
const LPCSTR g_rgszBarringTypes[] =
{
    "",     // 0
    "AO",   // RIL_BARRTYPE_ALLOUTGOING
    "OI",   // RIL_BARRTYPE_OUTGOINGINT
    "OX",   // RIL_BARRTYPE_OUTGOINGINTEXTOHOME
    "AI",   // RIL_BARRTYPE_ALLINCOMING
    "IR",   // RIL_BARRTYPE_INCOMINGROAMING
    "NS",   // RIL_BARRTYPE_INCOMINGNOTINSIM
    "AB",   // RIL_BARRTYPE_ALLBARRING
    "AG",   // RIL_BARRTYPE_ALLOUTGOINGBARRING
    "AC",   // RIL_BARRTYPE_ALLINCOMINGBARRING

};
const size_t fBarringTypesEcount = (sizeof(g_rgszBarringTypes) / sizeof(LPCSTR));


//
//
//
HRESULT ParseGetUserIdentity(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetUserIdentity);
    LPSTR szUserID = NULL;
#ifdef RIL_WATSON_REPORT
    char* szUserIDCache = g_RilInfoCache.szIMSI;
#endif // RIL_WATSON_REPORT
    HRESULT hr = S_OK;

    szUserID = (LPSTR)AllocBlob(MAXLENGTH_USERID);
    if (!szUserID) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(szUserID, 0x00, MAXLENGTH_USERID);

    // Parse "<prefix><IMSI><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                                        ||
        !ParseUnquotedString(szRsp, '\r', szUserID, MAXLENGTH_USERID, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

#ifdef RIL_WATSON_REPORT
    // Copy IMSI to RIL Info Cache
    strncpy(szUserIDCache, szUserID, MAXLENGTH_USERID);
#endif // RIL_WATSON_REPORT
    
    pBlob = (void*)szUserID;
    cbBlob = MAXLENGTH_USERID;

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


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

    if (!QueueCmd(pHandle, "AT+CIMI\r", CMDOPT_SUPPRESSLOGGING, APIID_GETUSERIDENTITY, ParseGetUserIdentity, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT ParseGetPhoneLockedState(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetPhoneLockedState);
    UINT i;
    DWORD* pdwState = NULL;
    char szState[MAX_PATH];
#ifdef RIL_WATSON_REPORT
    char* szUserIDCache = g_RilInfoCache.szIMSI;
#endif // RIL_WATSON_REPORT
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    pdwState = (DWORD*)AllocBlob(sizeof(DWORD));
    if (!pdwState) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(pdwState, 0x00, sizeof(DWORD));

    // Parse "<prefix>+CPIN: <state><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                               ||
        !MatchStringBeginning(szRsp, "+CPIN: ", szRsp)              ||
        !ParseUnquotedString(szRsp, '\r', szState, MAX_PATH, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    for (i = 1; i <= NUM_LOCKEDSTATES; i++) {
        if (!strcmp(szState, g_rgszLockedStates[i])) {
            *pdwState = i;
            break;
        }
    }
    if (i > NUM_LOCKEDSTATES) {
        // We couldn't match the response with anything
        *pdwState = RIL_LOCKEDSTATE_UNKNOWN;
    }
    else
    {
        UpdateSIMState(*pdwState);

#ifdef RIL_WATSON_REPORT
        // Send command to update the IMSI in the info cache
        // if the IMSI cache has not been updated yet and the 
        // SIM state is ready.
        if (('\0' == *szUserIDCache) && (RIL_LOCKEDSTATE_READY == *pdwState) )
        {
            QueueCmdIgnoreRsp(APIID_NONE, "AT+CIMI\r", CMDOPT_SUPPRESSLOGGING | CMDOPT_IGNORERADIOOFF, g_TimeoutCmdInit, ParseGetUserIdentity, NULL, 0, 0, 0);
        }
#endif // RIL_WATSON_REPORT
    }

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

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


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

    if (!QueueCmd(pHandle, "AT+CPIN?\r", CMDOPT_NONE, APIID_GETPHONELOCKEDSTATE, ParseGetPhoneLockedState, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_UnlockPhone(DWORD dwParam, LPCSTR lpszPassword, LPCSTR lpszNewPassword)
{
    FUNCTION_TRACE(RILDrv_UnlockPhone);
    DEBUGCHK(NULL != lpszPassword);

    char szCmd[SECUR_CMDBUF_LENGTH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpszPassword) {
        hr = E_FAIL;
        goto Error;
    }

    (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CPIN=\"%s\"", lpszPassword);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpszNewPassword) {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), ",\"%s\"", lpszNewPassword);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
    (void)strncpyz(szWalk, "\r", SECUR_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30

#ifdef RIL_RADIO_RESILIENCE
        // save the unlock code in case of radio reset 
        SavePINSecure(lpszNewPassword ? lpszNewPassword : lpszPassword);
#endif // RIL_RADIO_RESILIENCE
    
    if (!QueueCmd(pHandle, szCmd, CMDOPT_UNLOCKING | CMDOPT_SUPPRESSLOGGING | CMDOPT_CPINENTERED, APIID_UNLOCKPHONE, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
static HRESULT ParseGetLockingStatus(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetLockingStatus);
    UINT nValue;
    DWORD* pdwStatus = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    pdwStatus = (DWORD*)AllocBlob(sizeof(DWORD));
    if (!pdwStatus) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(pdwStatus, 0x00, sizeof(DWORD));

    // Parse "<prefix>+CLCK: <status><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                           ||
        !MatchStringBeginning(szRsp, "+CLCK: ", szRsp)          ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 2, nValue, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    *pdwStatus = (nValue ? RIL_LOCKINGSTATUS_ENABLED : RIL_LOCKINGSTATUS_DISABLED);

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

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


//
//
//
HRESULT RILDrv_GetLockingStatus(DWORD dwParam, DWORD dwFacility, LPCSTR lpszPassword)
{
    FUNCTION_TRACE(RILDrv_GetLockingStatus);

    char szCmd[SECUR_CMDBUF_LENGTH];
    LPSTR szWalk = szCmd;
    HRESULT hr = E_FAIL;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        goto Error;
    }

    if ( !dwFacility || dwFacility >= NUM_LOCKFACILITIES )
    {
        hr = E_INVALIDARG;
        ASSERT( FALSE );
        goto Error;
    }

    if (lpszPassword) {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CLCK=\"%s\",2,\"%s\"\r",
                         g_rgszLockFacilities[dwFacility], lpszPassword);
    } else {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CLCK=\"%s\",2\r",
                         g_rgszLockFacilities[dwFacility]);
    }
    if (!QueueCmd(pHandle, szCmd, CMDOPT_SUPPRESSLOGGING, APIID_GETLOCKINGSTATUS, ParseGetLockingStatus, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }