secur.cpp

ril source code for Windows CE

Error:
    return hr;
}


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

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

    if (!pHandle) {
        goto Error;
    }

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

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

#ifdef RIL_RADIO_RESILIENCE
        if ((RIL_LOCKFACILITY_SIM == dwFacility) && (lpszPassword) && (RIL_LOCKINGSTATUS_ENABLED == dwStatus))
        {
            dwCommandOpts |= CMDOPT_CPINENTERED;
            SavePINSecure(lpszPassword);
        }
#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(NULL != lpszOldPassword);
    DEBUGCHK(NULL != lpszNewPassword);

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

    if ( !dwFacility || dwFacility >= NUM_LOCKFACILITIES )
    {
        hr = E_INVALIDARG;
        ASSERT( FALSE );
        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(szCmd, SECUR_CMDBUF_LENGTH, "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);

        *szCmd = 0;
        hr = PDD_CreateCommand_ChangeLockingPassword(szCmd, SECUR_CMDBUF_LENGTH, dwFacility, lpszOldPassword, lpszNewPassword);
        szCmd[ SECUR_CMDBUF_LENGTH - 1 ] = 0;
        
        if ( FAILED( hr ) )
        {
            DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : PDD_CreateCommand_ChangeLockingPassword failed , hr = [0x%08x]\r\n"), hr));
            goto Error;
        }
    
        if (!QueueCmd(pHandle, szCmd, CMDOPT_SUPPRESSLOGGING, APIID_CHANGELOCKINGPASSWORD, NULL, NULL, hr)) {
            hr = E_FAIL;
            goto Error;
        }
    }
    else
    {
        hr = E_INVALIDARG;
        goto Error;
    }

Error:
    return hr;
}


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

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

    if ( !dwType || dwType >= fBarringTypesEcount ) {
        hr = E_INVALIDARG;
        ASSERT( FALSE );
        goto Error;
    }
    (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);

    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 {
        hr = E_INVALIDARG;
        DEBUGCHK(FALSE);
        goto Error;
    }

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

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

    if ( !dwType || dwType >= fBarringTypesEcount ) {
        hr = E_INVALIDARG;
        ASSERT( FALSE );
        goto Error;
    }
    (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(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 ( !dwType || dwType >= fBarringTypesEcount ) {
        hr = E_INVALIDARG;
        ASSERT( FALSE );
        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;
}