secur.cpp

手机RILGSM实现的源代码

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

    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;
    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) )
        {
            switch(dwStatus)
            {
                case RIL_LOCKINGSTATUS_ENABLED:
                {
                    dwCommandOpts |= CMDOPT_CPINENTERED;
                    SavePINSecure(lpszPassword);
                }
                    break;
                case RIL_LOCKINGSTATUS_DISABLED:
                {
                    dwCommandOpts |= CMDOPT_NOT_CPINENTERD;
                }
                    break;
                default:
                    break;
            }
        }
#endif // RIL_RADIO_RESILIENCE
    if (lpszPassword) {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CLCK=\"%s\",%u,\"%s\"\r",
                         g_rgszLockFacilities[dwFacility], nValue, lpszPassword);
    } else {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CLCK=\"%s\",%u\r",
                         g_rgszLockFacilities[dwFacility], nValue);
    }
    if (!QueueCmd(pHandle, szCmd, dwCommandOpts, APIID_SETLOCKINGSTATUS, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_ChangeLockingPassword(DWORD dwParam, DWORD dwFacility, DWORD dwOldPasswordType, LPCSTR lpszOldPassword, LPCSTR lpszNewPassword)
{
    FUNCTION_TRACE(RILDrv_ChangeLockingPassword);
    DEBUGCHK(dwFacility && NUM_LOCKFACILITIES > dwFacility);
    DEBUGCHK(NULL != lpszOldPassword);
    DEBUGCHK(NULL != lpszNewPassword);

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

    if (RIL_PASSWORDTYPE_PIN == dwOldPasswordType)
    {        
        DWORD dwCommandOpts = CMDOPT_SUPPRESSLOGGING;
#ifdef RIL_RADIO_RESILIENCE
        if ((RIL_LOCKFACILITY_SIM == dwFacility) && (lpszNewPassword))
        {
            dwCommandOpts |= CMDOPT_CPINENTERED;
            SavePINSecure(lpszNewPassword);
        }
#endif // RIL_RADIO_RESILIENCE
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CPWD=\"%s\",\"%s\",\"%s\"\r",
                         g_rgszLockFacilities[dwFacility], lpszOldPassword, lpszNewPassword);
        if (!QueueCmd(pHandle, szCmd, dwCommandOpts, APIID_CHANGELOCKINGPASSWORD, NULL, NULL, hr)) {
            hr = E_FAIL;
            goto Error;
        }
    }
    else if (RIL_PASSWORDTYPE_PUK == dwOldPasswordType)
    {
        // The "old" password is the PIN unblocking key that is used to
        // unblock either PIN or PIN2.
        DEBUGCHK(RIL_LOCKFACILITY_SIM == dwFacility ||
                   RIL_LOCKFACILITY_SIM_PIN2 == dwFacility);
        DWORD dwComOpts = CMDOPT_SUPPRESSLOGGING;
        if ((RIL_LOCKFACILITY_SIM == dwFacility) && (lpszNewPassword))
        {
            dwComOpts |= CMDOPT_CPINENTERED;
            dwComOpts |= CMDOPT_UNLOCKING;
            RETAILMSG(1, (TEXT("[GSM]unlock puk and set CMDOPT_UNLOCKING\r\n")));
            SavePINSecure(lpszNewPassword);
        }
#if defined (OEM1_DRIVER)
        // This hardware uses ATD to get the desired functionality
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "ATD**05%s*%s*%s*%s#\r",
                         ((RIL_LOCKFACILITY_SIM_PIN2 == dwFacility) ? "2" : ""), lpszOldPassword, lpszNewPassword, lpszNewPassword);
        if (!QueueCmd(pHandle, szCmd, dwComOpts, APIID_CHANGELOCKINGPASSWORD, NULL, NULL, hr)) {
            hr = E_FAIL;
            goto Error;
        }
#else
        // Other hardware uses +CPIN and will fail if no PIN request is pending, per GSM 07.07
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CPIN=\"%s\",\"%s\"\r",
                         lpszOldPassword, lpszNewPassword);
        if (!QueueCmd(pHandle, szCmd, dwComOpts, APIID_CHANGELOCKINGPASSWORD, NULL, NULL, hr)) {
            hr = E_FAIL;
            goto Error;
        }
#endif
    }
    else
    {
        hr = E_INVALIDARG;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
static HRESULT ParseGetCallBarringStatus(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetCallBarringStatus);
    UINT nValue;
    UINT nDummy;
    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>"
    if (!ParseRspPrefix(szRsp, szRsp)                           ||
        !MatchStringBeginning(szRsp, "+CLCK: ", szRsp)          ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 2, nValue, szRsp)){
        hr = E_FAIL;
        goto Error;
    }
    // Parse "[,<info_class>]"
    if (MatchStringBeginning(szRsp, ",", szRsp))
        if (!ParseUInt(szRsp, TRUE, nDummy, szRsp)){
            hr = E_FAIL;
            goto Error;
        }
    // Parse "<postfix>"
    if (!ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    *pdwStatus = (nValue ? RIL_BARRINGSTATUS_ENABLED : RIL_BARRINGSTATUS_DISABLED);

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

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


//
//
//
HRESULT RILDrv_GetCallBarringStatus(DWORD dwParam, DWORD dwType, DWORD dwInfoClass, LPCSTR lpszPassword)
{
    FUNCTION_TRACE(RILDrv_GetCallBarringStatus);
    DEBUGCHK(dwType && NUM_BARRINGTYPES > dwType);

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

    for (i = 0 ; i < NUM_INFOCLASSES; i++) {
        if (dwInfoClass & g_rgdwInfoClasses[i]) {
            nValue |= (0x01 << i);
        }
    }

    if (RIL_INFOCLASS_SMS != dwInfoClass && (nValue & 0x8))
    {
        nValue -= 8;
    }

    (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CLCK=\"%s\",2", g_rgszBarringTypes[dwType]);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpszPassword) {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), ",\"%s\"", lpszPassword);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
    // Only need to add a comma if we'll be adding the infoclass next
    else if ((RIL_INFOCLASS_NONE != nValue) && ((RIL_INFOCLASS_VOICE | RIL_INFOCLASS_DATA | RIL_INFOCLASS_FAX) != nValue)) {
        (void) strncpyz(szWalk, ",", SECUR_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
    
    // unspecified infoclass is treated as default
    if ((RIL_INFOCLASS_NONE != nValue) && ((RIL_INFOCLASS_VOICE | RIL_INFOCLASS_DATA | RIL_INFOCLASS_FAX) != nValue)) {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), ",%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

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

    if (!QueueCmd(pHandle, szCmd, CMDOPT_SUPPRESSLOGGING, APIID_GETCALLBARRINGSTATUS, ParseGetCallBarringStatus, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetCallBarringStatus(DWORD dwParam, DWORD dwType, DWORD dwInfoClass, LPCSTR lpszPassword, DWORD dwStatus)
{
    FUNCTION_TRACE(RILDrv_SetCallBarringStatus);
    DEBUGCHK(dwType && NUM_BARRINGTYPES > dwType);

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

    if (RIL_BARRINGSTATUS_DISABLED == dwStatus) {
        nValue1 = 0;
    } else if (RIL_BARRINGSTATUS_ENABLED == dwStatus) {
        nValue1 = 1;
    } else {
        DEBUGCHK(FALSE);
    }

    for (i = 0 ; i < NUM_INFOCLASSES; i++) {
        if (dwInfoClass & g_rgdwInfoClasses[i]) {
            nValue2 |= (0x01 << i);
        }
    }

    if (RIL_INFOCLASS_SMS != dwInfoClass && (nValue2 & 0x8))
    {
        nValue2 -= 8;
    }

    (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CLCK=\"%s\",%u", g_rgszBarringTypes[dwType], nValue1);
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpszPassword) {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), ",\"%s\"", lpszPassword);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
    // Only need to add a comma if we'll be adding the infoclass next
    else if ((RIL_INFOCLASS_NONE != nValue2) && ((RIL_INFOCLASS_VOICE | RIL_INFOCLASS_DATA | RIL_INFOCLASS_FAX) != nValue2)) {
        (void) strncpyz(szWalk, ",", SECUR_CMDBUF_LENGTH - (szWalk - szCmd));  // NO_TYPO: 30
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }
    
    // unspecified infoclass is treated as default
    if ((RIL_INFOCLASS_NONE != nValue2) && ((RIL_INFOCLASS_VOICE | RIL_INFOCLASS_DATA | RIL_INFOCLASS_FAX) != nValue2)) {
        (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), ",%u", nValue2);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

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

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

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_ChangeCallBarringPassword(DWORD dwParam, DWORD dwType, LPCSTR lpszOldPassword, LPCSTR lpszNewPassword)
{
    FUNCTION_TRACE(RILDrv_ChangeCallBarringPassword);
    DEBUGCHK(dwType && NUM_BARRINGTYPES > dwType);
    DEBUGCHK(NULL != lpszOldPassword);
    DEBUGCHK(NULL != lpszNewPassword);

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

    (void)_snprintfz(szWalk, SECUR_CMDBUF_LENGTH - (szWalk - szCmd), "AT+CPWD=\"%s\",\"%s\",\"%s\"\r",
                     g_rgszBarringTypes[dwType], lpszOldPassword, lpszNewPassword);
    if (!QueueCmd(pHandle, szCmd, CMDOPT_SUPPRESSLOGGING, APIID_CHANGECALLBARRINGPASSWORD, NULL, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}