secur.cpp

windows mobile RIL软件

/*++
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.
Copyright (c) 1995-1999  Microsoft Corporation

Module Name:

secur.cpp

Abstract:


Notes:


--*/


#include "precomp.h"


//
//
//
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);

    }

    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 1//#ifdef WAVECOM_DRIVER
    // HW-SPECIFIC: WaveCom hardware doesn't provide an OK at the end of an AT+CPIN? response

    if (!QueueCmd(pHandle, "AT+CPIN?\r", CMDOPT_NONE, APIID_GETPHONELOCKEDSTATE, NULL, NULL, hr)) {
#else  // WAVECOM_DRIVER

    if (!QueueCmd(pHandle, "AT+CPIN?\r", CMDOPT_NONE, APIID_GETPHONELOCKEDSTATE, ParseGetPhoneLockedState, NULL, hr)) {
#endif // WAVECOM_DRIVER

        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);
    DEBUGCHK(dwFacility && NUM_LOCKFACILITIES > dwFacility);

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

#ifdef EMP_DRIVER
    // EMP doesn't support RIL_LOCKFACILITY_PH_FSIM
    if (RIL_LOCKFACILITY_PH_FSIM == dwFacility)
    {
        hr = E_NOTIMPL;
        goto Error;
    }
#endif

    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;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetLockingStatus(DWORD dwParam, DWORD dwFacility, LPCSTR lpszPassword, DWORD dwStatus)
{
    FUNCTION_TRACE(RILDrv_SetLockingStatus);
    DEBUGCHK(dwFacility && NUM_LOCKFACILITIES > dwFacility);

    char szCmd[SECUR_CMDBUF_LENGTH];
    LPSTR szWalk = szCmd;
    UINT nValue = 0;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    DWORD dwCommandOpts = CMDOPT_SUPPRESSLOGGING;

    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    if (RIL_LOCKINGSTATUS_DISABLED == dwStatus) {
        nValue = 0;
    } else if (RIL_LOCKINGSTATUS_ENABLED == dwStatus) {
        nValue = 1;
    } else {
        DEBUGCHK(FALSE);
    }

#ifdef RIL_RADIO_RESILIENCE
        if ((RIL_LOCKFACILITY_SIM == dwFacility) && (lpszPassword) && (RIL_LOCKINGSTATUS_ENABLED == dwStatus))
        {
            dwCommandOpts |= CMDOPT_CPINENTERED;
            SavePINSecure(lpszPassword);
        }
#endif // RIL_RADIO_RESILIENCE

#ifdef EMP_DRIVER
    // EMP doesn't support RIL_LOCKFACILITY_PH_FSIM
    if (RIL_LOCKFACILITY_PH_FSIM == dwFacility)
    {
        hr = E_NOTIMPL;
        goto Error;
    }
#endif // EMP_DRIVER