/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation of the CWimUtilityFuncs class.

*

*/

// INCLUDE FILES

#include    "WimUtilityFuncs.h"

#include    "Wimi.h"                // WIMI definitions

#include    "WimDefs.h" 

#include    "WimTrace.h"

#include    <e32property.h>         // RProperty

#ifdef RD_STARTUP_CHANGE

#include    <startupdomainpskeys.h> // Property values

#else

#include    <PSVariables.h>         // Property values

#endif // RD_STARTUP_CHANGE

#ifdef BT_SAP_TEST_BY_CHARGER

#include    <PSVariables.h>         // Property values

#else

//#include    <BTSapInternalPSKeys.h> // BT Sap property values

#include    <BTSapDomainPSKeys.h>

#endif // BT_SAP_TEST_BY_CHARGER

//If want to use emulator hw, uncomment this line

#define __EMULATOR_HW__ 

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CWimUtilityFuncs::CWimUtilityFuncs

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CWimUtilityFuncs::CWimUtilityFuncs()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimUtilityFuncs::CWimUtilityFuncs | Begin"));

    }

// -----------------------------------------------------------------------------

// CWimUtilityFuncs::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CWimUtilityFuncs::ConstructL()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimUtilityFuncs::ConstructL | Begin"));

    }

// -----------------------------------------------------------------------------

// CWimUtilityFuncs::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CWimUtilityFuncs* CWimUtilityFuncs::NewL()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimUtilityFuncs::NewL | Begin"));

    CWimUtilityFuncs* self = new( ELeave ) CWimUtilityFuncs;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CWimUtilityFuncs::~CWimUtilityFuncs()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimUtilityFuncs::~CWimUtilityFuncs | Begin"));

    }

// -----------------------------------------------------------------------------

// CWimUtilityFuncs::::MapWIMError

// Map WIMI errors to WIM errors

// -----------------------------------------------------------------------------

//

TInt CWimUtilityFuncs::MapWIMError( WIMI_STAT aStatus )

    {

    _WIMTRACE2(_L("WIM | WIMServer | CWimUtilityFuncs::MapWIMError aStatus=%d"), aStatus);

    TInt err = KErrUnknown; 

    switch ( aStatus ) 

        {

        case WIMI_Err:

        case WIMI_ERR_Internal:

             err = KErrCorrupt;

            break;

        case WIMI_ERR_OutOfMemory:

            err = KErrNoMemory;

            break;

        case WIMI_Ok:

            err = KErrNone;

            break;

        case WIMI_ERR_BadParameters:

            err = KErrArgument;

            break;

        case WIMI_ERR_ServerCertRejected:

            err = KErrCorrupt;

            break;

        case WIMI_ERR_CipherNotSupported:

        case WIMI_ERR_MACANotSupported:

            err = KErrNotSupported;

            break;

        case WIMI_ERR_UnsupportedCertificate:

            err = KErrNotSupported;

            break;

        case WIMI_ERR_SessionNotSet:

            err = KErrDisconnected;

            break;

        case WIMI_ERR_WrongKES:

            err = KErrCorrupt;

            break;

        case WIMI_ERR_DecodeError:

            err = KErrCorrupt;

            break;

        case WIMI_ERR_ExpiredReference:

            err = KErrArgument;

            break;

        case WIMI_ERR_NoKey:

            err = KErrNotFound;

            break;

        case WIMI_ERR_CertNotYetValid:

            err = KErrCorrupt;

            break;

        case WIMI_ERR_CertExpired:

            err = KErrTimedOut;

            break;

        case WIMI_ERR_UnknownCA:

            err = KErrArgument;

            break;

        case WIMI_ERR_CertParseError:

            err = KErrCorrupt;

            break;

        case WIMI_ERR_KeyStorageFull:

            err = KErrDirFull;

            break;

        case WIMI_ERR_BadKey:

            err = KErrArgument;

            break;

        case WIMI_ERR_CertStorageFull:

            err = KErrDirFull;

            break;

        case WIMI_ERR_BadCert:

            err = KErrArgument;

            break;

        case WIMI_ERR_PStorageError:

            err = KErrDirFull;

            break;

        case WIMI_ERR_CertNotFound:

            err = KErrNotFound;

            break;

        case WIMI_ERR_KeyNotFound:

            err = KErrNotFound;

            break;

        case WIMI_ERR_BadReference:

            err = KErrCorrupt;

            break;

        case WIMI_ERR_OperNotSupported:

            err = KErrNotSupported;

            break;

        case WIMI_ERR_BadPIN:

            err = KErrArgument;

            break;

        case WIMI_ERR_PINBlocked:

            err = KErrLocked;

            break;

        case WIMI_ERR_CardDriverInitError:

            err = KErrBadDriver;

            break;

        case WIMI_ERR_CardIOError:

            err = KErrHardwareNotAvailable;

            break;

        case WIMI_ERR_AlgorithmNotYetImplemented:

            err = KErrNotSupported;

            break;

        case WIMI_ERR_UserCancelled:

            err = KErrCancel;

            break;

        default:

            err = KErrUnknown;

        }

    return err;

    }

// -----------------------------------------------------------------------------

// CWimUtilityFuncs::TrIdLC

// Creates a new TWimReqTrId item.

// -----------------------------------------------------------------------------

//

TWimReqTrId* CWimUtilityFuncs::TrIdLC( TAny* aTrId, TWimReqType aReqType ) const 

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimUtilityFuncs::GetTrIdLC | Begin"));

    TWimReqTrId* reqTrId = new( ELeave ) TWimReqTrId;

    CleanupStack::PushL( reqTrId );

    reqTrId->iReqType = aReqType;

    reqTrId->iReqTrId = aTrId;

    return reqTrId;

    }

// -----------------------------------------------------------------------------

// CWimUtilityFuncs::DesLC

// Utility function that reads a descriptor from the clients address

// space. The caller has to free the returned HBufC8.

// -----------------------------------------------------------------------------

//

HBufC8* CWimUtilityFuncs::DesLC(

    const TInt aIndex,

    const RMessage2& aMessage ) const

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimUtilityFuncs::GetDesLC | Begin"));

    TInt len = aMessage.GetDesLength( aIndex );    

    //User might cancelled operation, so we need to leave before

    //HBufC panics. We do not want panic at this point. Leave is Trapped in 

    //session

    if ( len < 0 )

        {

        User::Leave( KErrArgument );

        }

    HBufC8* buf = HBufC8::NewLC( len ); // free'd by caller

    TPtr8 ptr = buf->Des();

    aMessage.ReadL( aIndex, ptr );

    return buf;

    }

// -----------------------------------------------------------------------------

// CWimUtilityFuncs::SimState

// Get state of SIM/SWIM card. Uses system wide repository to get state.

// If card is OK return KErrNone, otherwise some other system wide state.

// -----------------------------------------------------------------------------

//

TInt CWimUtilityFuncs::SimState()

    {

    TInt simState = KErrNotReady;

    TInt stateError = 0;

    // Get SIM state

#ifdef RD_STARTUP_CHANGE

    stateError = RProperty::Get( KPSUidStartup,

                                 KPSSimStatus,

                                 simState );

#else

    stateError = RProperty::Get( KUidSystemCategory,

                                 KPSUidSIMStatusValue,

                                 simState );

#endif // RD_STARTUP_CHANGE

    // In WINS may not return real SIM state -> ignore

    #ifdef __WINS__

    stateError = 0;

    #endif

    if ( stateError == KErrNone ) // Got SIM state succesfully

        {

        // In WINS may not return real SIM state -> ignore

#ifdef __WINS__

#ifdef __EMULATOR_HW__

#ifdef RD_STARTUP_CHANGE

        simState = ESimUsable;

#else

        simState = EPSSimOk;

#endif // RD_STARTUP_CHANGE

#else  //__EMULATOR_HW__

#ifdef RD_STARTUP_CHANGE

        simState = ESimNotPresent;

#else

        simState = EPSSimNotPresent;

#endif // RD_STARTUP_CHANGE

#endif //__EMULATOR_HW__

#endif // __WINS__

        _WIMTRACE2(_L("WIM | WIMServer | CWimUtilityFuncs::SimState|simState=%d"),simState);

#ifdef RD_STARTUP_CHANGE

        if ( simState == ESimUsable )

#else

        if ( simState == EPSSimOk )

#endif // RD_STARTUP_CHANGE        

            {

            simState = KErrInUse;

#ifdef BT_SAP_TEST_BY_CHARGER

            // Test of BT Sap by charger. To emulate connected BT Sap, charger must be

            // connected and charging.

            stateError = RProperty::Get( KUidSystemCategory,

                                         KPSUidChargerStatusValue,

                                         simState );  

#else

            // Get state of BT Sap

            stateError = RProperty::Get( KPSUidBluetoothSapConnectionState,

                                         KBTSapConnectionState,

                                         simState );

#endif // BT_SAP_TEST_BY_CHARGER

       // In WINS may not return real SIM state -> ignore

#ifdef __WINS__

            stateError = 0;

#endif

            if ( KErrNone == stateError ) // Got BT SAP state succesfully

                {

       // In WINS may not return real SIM state -> ignore 

#ifdef __WINS__

#ifdef BT_SAP_TEST_BY_CHARGER

        simState = EPSChargerDisconnected;

#else

        simState = EBTSapNotConnected;

#endif // BT_SAP_TEST_BY_CHARGER

#endif // __WINS__            

                _WIMTRACE2(_L("WIM | WIMServer | CWimUtilityFuncs::SimState|simState=%d"),simState);

#ifdef BT_SAP_TEST_BY_CHARGER

                if ( EPSChargerConnected != simState )

#else

                if ( EBTSapConnected != simState )

#endif // BT_SAP_TEST_BY_CHARGER 

                    {

                    simState = KErrNone;

                    }

                else

                    {

                    simState = KErrInUse;

                    }               

                }

            else if ( KErrNotFound == stateError )

                {

                _WIMTRACE(_L("WIM | WIMServer | CWimUtilityFuncs::SimState|BTSap not found, WIM initialization continued"));

                simState = KErrNone;

                }

            else

                {

                _WIMTRACE2(_L("WIM | WIMServer | CWimUtilityFuncs::SimState|BTSap ERROR| stateError=%d"),stateError);    

                }

            }

        else // simState != ESimUsable/EPSSimOk

            {

            simState = KErrNotReady;

            }

        }

    _WIMTRACE2(_L("WIM | WIMServer | CWimUtilityFuncs::SimState|End|simState=%d"),simState); 

    return simState;

    }

// -----------------------------------------------------------------------------

// CWimCertHandler::MapCertLocation

// Map Wimlib certificate CDF to our own type

// -----------------------------------------------------------------------------

//

TUint8 CWimUtilityFuncs::MapCertLocation( const TUint8 aCertCDF ) const

    {

    TWimCertificateCDF certCDF;

    switch ( aCertCDF )

        {

        case WIMLIB_CERTIFICATES_CDF:

            {

            certCDF = EWimCertificatesCDF;

            break;

            }

        case WIMLIB_TRUSTEDCERTS_CDF:

            {

            certCDF = EWimTrustedCertsCDF;

            break;

            }

        case WIMLIB_USEFULCERTS_CDF:

            {

            certCDF = EWimUsefulCertsCDF;

            break;

            }

        default:

            {

            certCDF = EWimUnknownCDF;

            break;

            }

        }

    return ( TUint8 )certCDF;

    }

//  End of File