/*

* 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:  Certificate & key -management class

*

*/

//INCLUDES

#include "WimCertMgmt.h"

#include "WimTrace.h"

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

// RWimCertMgmt::RWimCertMgmt()

// Default constructor

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

//

RWimCertMgmt::RWimCertMgmt(): iCertLst( NULL, 0, 0 ), iCertInfoLst( NULL, 0, 0 )

    {

    iPckgBufAddCertsAllocated = EFalse;

    iPckgBufCertDetailsAllocated = EFalse;

    iPckgBufRemoveCertAllocated = EFalse;

    iPckgBufGetExtrasAllocated = EFalse;

    iPckgBufKeySignAllocated = EFalse;

    iPckgBufExportPublicKeyAllocated = EFalse;

    iPckgBufOmaProvAllocated = EFalse;

    iPckgBufJavaProvAllocated = EFalse;

    iAuthObjsInfoLstPtr = NULL;

    iAuthIdLstPtr = NULL;

	  iPckgBufOmaProv = NULL;

    iPckgBufJavaProv = NULL;

    }

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

// RWimCertMgmt::ClientSessionL()

// Return new RWimCertMgmt object 

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

//

RWimCertMgmt* RWimCertMgmt::ClientSessionL()

    {

    RWimCertMgmt* self = new( ELeave ) RWimCertMgmt;

    CleanupStack::PushL( self );

    User::LeaveIfError( self->Connect() );

    CleanupStack::Pop( self ); //self

    _WIMTRACE ( _L( "RWimCertMgmt::ClientSessionL()" ) );

    return self;

    }

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

// RWimCertMgmt::~RWimCertMgmt() 

// Destructor, all allocated memory is released.

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

//

RWimCertMgmt::~RWimCertMgmt()

    {

    _WIMTRACE ( _L( "RWimCertMgmt::~RWimCertMgmt()" ) );

    iCertLst.Set( NULL, 0, 0 );

    iCertInfoLst.Set( NULL, 0, 0 );

    delete  iAuthObjsInfoLstPtr;

	  delete  iAuthIdLstPtr;

	  delete  iPckgBufOmaProv;

    delete  iPckgBufJavaProv;

    }

/* Certificate management */

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

// RWimCertMgmt::CertCount()

// Returns count of certificates

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

//

TUint8 RWimCertMgmt::CertCount( TWimEntryType aType )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::CertCount()" ) );

    TPckgBuf<TUint8> pckg( 0 );

    TIpcArgs args;

    args.Set( 0, &pckg );

    args.Set( 1, aType );

    SendReceiveData( EGetCertCount, args );

    return pckg();

    }

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

// RWimCertMgmt::CertRefLst()

// Returns certificate list on the WIM

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

//

void  RWimCertMgmt::CertRefLst( TCertificateAddressList aCertAddrLst, 

                                TWimCertInfo* aCertInfoArr, 

                                TUint8 aCount, 

                                TWimEntryType aCertEntryType,

                                TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::CertRefLst()" ) );

    aStatus = KRequestPending;

    TInt16 size = ( TInt16 ) ( sizeof ( TCertificateAddress ) * aCount );

    iCertLst.Set( ( TUint8* ) aCertAddrLst, size, size );   

    size = ( TInt16 )( sizeof ( TWimCertInfo ) * aCount );

    iCertInfoLst.Set( ( TUint8* ) aCertInfoArr, size, size ); 

    TIpcArgs args;

    args.Set( 0, &iCertLst );

    args.Set( 1, &iCertInfoLst );

    args.Set( 2, aCertEntryType );

    SendReceiveData( EGetWIMCertLst, args, aStatus );

    }

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

// RWimCertMgmt::CertRefLst()

// Returns certificate list on the WIM

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

//

TInt RWimCertMgmt::CertRefLst( TCertificateAddressList aCertAddrLst, 

                               TWimCertInfo* aCertInfoArr, 

                               TUint8 aCount, 

                               TWimEntryType aCertEntryType )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::CertRefLst()" ) );

    TInt16 size = ( TInt16 ) ( sizeof ( TCertificateAddress ) * aCount );

    iCertLst.Set( ( TUint8* ) aCertAddrLst, size, size );   

    size = ( TInt16 )( sizeof ( TWimCertInfo ) * aCount );

    iCertInfoLst.Set( ( TUint8* ) aCertInfoArr, size, size ); 

    TIpcArgs args;

    args.Set( 0, &iCertLst );

    args.Set( 1, &iCertInfoLst );

    args.Set( 2, aCertEntryType );

    return SendReceiveData( EGetWIMCertLst, args );

    }

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

// RWimCertMgmt::CertDetailsL() 

// Returns certificate details.

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

//

void RWimCertMgmt::CertDetailsL( const TCertificateAddress aCertAddr, 

                                 TWimCertDetails& aWimCertDetails,

                                 TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::CertDetailsL()" ) );

    aStatus = KRequestPending;

    iPckgBufCertDetails  = new( ELeave ) 

        CWimCertPckgBuf<TWimCertDetails>( aWimCertDetails );

    iPckgBufCertDetailsAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, aCertAddr );

    args.Set( 1, iPckgBufCertDetails->PckgBuf() );

    args.Set( 2, aWimCertDetails.iCert );

    SendReceiveData( EGetWIMCertDetails, args, aStatus );

    }

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

// RWimCertMgmt::StoreCertificateL() 

// Stores the certificate to WIM

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

//

void RWimCertMgmt::StoreCertificateL( const TDes8& aCertificate,

                                     TWimCertAddParameters& aParams,

                                     TWimCertLocation aLocation,

                                     TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::StoreCertificateL()" ) );

    aStatus = KRequestPending;

    iPckgBufAddCerts = new( ELeave )  

        CWimCertPckgBuf<TWimCertAddParameters>( aParams ); 

    iPckgBufAddCertsAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, &aCertificate );

    args.Set( 1, iPckgBufAddCerts->PckgBuf() );

    args.Set( 2, aLocation );

    SendReceiveData( EStoreCertificate, args, aStatus );

    }

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

// RWimCertMgmt::GetCertExtrasL()

// Gets certificate extra data from one certificate

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

//

void RWimCertMgmt::GetCertExtrasL( const TPtr8* aKeyId, 

                                 TCertExtrasInfo& aCertExtrasInfo,

                                 TUint aUsage,

                                 TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::GetCertExtrasL()" ) );

    aStatus = KRequestPending;

    iPckgBufGetExtras  = new( ELeave ) 

              CWimCertPckgBuf<TCertExtrasInfo>( aCertExtrasInfo );

    iPckgBufGetExtrasAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, aKeyId );

    args.Set( 1, iPckgBufGetExtras->PckgBuf() );

    args.Set( 2, aUsage );

    args.Set( 3, aCertExtrasInfo.iTrustedUsage );

    SendReceiveData( EGetCertExtras, args, aStatus );

    }

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

// RWimCertMgmt::CertExtrasPckgBuf()

// Returns CWimCertPckgBuf<TCertExtrasInfo>* member variable.

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

//

CWimCertPckgBuf<TCertExtrasInfo>* RWimCertMgmt::CertExtrasPckgBuf()

    {

    _WIMTRACE ( _L( "RWimCertMgmt::CertExtrasPckgBuf()" ) );

    return iPckgBufGetExtras;

    }

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

// RWimCertMgmt::RemoveL() 

// Removes a certificate from WIM

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

//

void RWimCertMgmt::RemoveL( TWimCertRemoveAddr aWimCertRemoveAddr,

                            TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::RemoveL()" ) );

    aStatus = KRequestPending;

    iPckgBufRemoveCert = new( ELeave ) 

        CWimCertPckgBuf<TWimCertRemoveAddr>( aWimCertRemoveAddr );

    iPckgBufRemoveCertAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, iPckgBufRemoveCert->PckgBuf() );

    SendReceiveData( ERemoveCertificate, args, aStatus );

    }

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

// RWimCertMgmt::DeallocWimCertPckgBuf()

// DeAllocates memory from iPckgBufCertDetails.

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

//

void RWimCertMgmt::DeallocWimCertPckgBuf()

    {

    _WIMTRACE ( _L( "RWimCertMgmt::DeallocWimCertPckgBuf()" ) );

    if ( iPckgBufCertDetailsAllocated )

        {

        delete iPckgBufCertDetails; 

        iPckgBufCertDetails = NULL;

        iPckgBufCertDetailsAllocated = EFalse;

        }

    }

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

// RWimCertMgmt::DeallocCertAddParametersPckgBuf()

// DeAllocates memory from iPckgBufAddCerts.

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

//

void RWimCertMgmt::DeallocCertAddParametersPckgBuf()

    {

    _WIMTRACE ( _L( "RWimCertMgmt::DeallocCertAddParametersPckgBuf()" ) );

    if ( iPckgBufAddCertsAllocated )

        {

        delete iPckgBufAddCerts;

        iPckgBufAddCerts = NULL;

        iPckgBufAddCertsAllocated = EFalse;

        }

    }

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

// RWimCertMgmt::DeallocRemoveCertPckgBuf()

// DeAllocates memory from iPckgBufRemoveCert.

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

//

void RWimCertMgmt::DeallocRemoveCertPckgBuf()

    {

    _WIMTRACE ( _L( "RWimCertMgmt::DeallocRemoveCertPckgBuf()" ) );

    if ( iPckgBufRemoveCertAllocated )

        {

        delete iPckgBufRemoveCert;

        iPckgBufRemoveCert = NULL;

        iPckgBufRemoveCertAllocated = EFalse;

        }

    }

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

// RWimCertMgmt::DeallocGetExtrasPckgBuf()

// DeAllocates memory from iPckgBufGetExtras.

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

//

void RWimCertMgmt::DeallocGetExtrasPckgBuf()

    {

    _WIMTRACE ( _L( "RWimCertMgmt::DeallocGetExtrasPckgBuf()" ) );

    if ( iPckgBufGetExtrasAllocated )

        {

        delete iPckgBufGetExtras;

        iPckgBufGetExtras = NULL;

        iPckgBufGetExtrasAllocated = EFalse;

        }

    }

/*  Key Management */

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

// RWimCertMgmt::KeyList()

//                              

// Gets the KeyList from the WIM

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

//

void RWimCertMgmt::KeyList( TDes8& aKeyList,

                            TDes8& aKeyCountPkg, 

                            TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::KeyList()" ) );

    aStatus = KRequestPending;

    TIpcArgs args;

    args.Set( 0, &aKeyList );

    args.Set( 1, &aKeyCountPkg );

    SendReceiveData( EGetKeyList, args, aStatus );

    }

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

// RWimCertMgmt::GetKeyInfo()

//

// Gets Info for single key

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

//

TInt RWimCertMgmt::GetKeyInfo( const TInt32 aKeyReference,                                

                               TKeyInfo& aKeyInfo )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::GetKeyInfo()" ) );

    TPckg<TKeyInfo> keyinfo ( aKeyInfo );

    TIpcArgs args;

    args.Set( 0, aKeyReference );

    args.Set( 1, &keyinfo );

    return SendReceiveData( EGetKeyDetails, args );

    }

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

// RWimCertMgmt::SignL()

// Sign some data

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

//

void RWimCertMgmt::SignL( TKeySignParameters& aSignParameters, 

                         TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::SignL" ) );

    aStatus = KRequestPending;

    iPckgBufKeySignParameters = new( ELeave ) 

              CWimCertPckgBuf<TKeySignParameters>( aSignParameters );

    iPckgBufKeySignAllocated = ETrue;

    TIpcArgs args;

    args.Set( 1, iPckgBufKeySignParameters->PckgBuf() );

    args.Set( 2, aSignParameters.iSigningData );

    args.Set( 3, aSignParameters.iSignature );

    SendReceiveData( ESignTextReq, args, aStatus );

    }

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

// RWimCertMgmt::DeallocKeySignPckgBuf()

// Deallocates member variable

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

//

void RWimCertMgmt::DeallocKeySignPckgBuf()

    {

    _WIMTRACE ( _L( "RWimCertMgmt::DeallocKeySignPckgBuf" ) );

    if ( iPckgBufKeySignAllocated )

        {

        delete iPckgBufKeySignParameters;

        iPckgBufKeySignParameters = NULL;

        iPckgBufKeySignAllocated = EFalse;

        }

    }

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

// RWimCertMgmt::ExportPublicKeyL()

// Export public key

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

//

void RWimCertMgmt::ExportPublicKeyL( TExportPublicKey& aPublicKeyParams, 

                               TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::ExportPublicKeyL" ) );

    aStatus = KRequestPending;

    iPckgBufExportPublicKey = new( ELeave ) 

        CWimCertPckgBuf<TExportPublicKey>( aPublicKeyParams );

    iPckgBufExportPublicKeyAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, iPckgBufExportPublicKey->PckgBuf() );

    args.Set( 1, aPublicKeyParams.iPublicKey );

    SendReceiveData( EExportPublicKey, args, aStatus );

    }

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

// RWimCertMgmt::DeallocExportPublicKeyPckgBuf()

// Deallocates member variable.

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

//

void RWimCertMgmt::DeallocExportPublicKeyPckgBuf()

    {

    _WIMTRACE ( _L( "RWimCertMgmt::DeallocExportPublicKeyPckgBuf" ) );

    if ( iPckgBufExportPublicKey )

        {

        delete iPckgBufExportPublicKey;

        iPckgBufExportPublicKey = NULL;

        iPckgBufExportPublicKeyAllocated = EFalse;

        }

    }

/*  OMA Provisioning */

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

// RWimCertMgmt::RetrieveOmaDataL()

// Retrieves OMA provisioning data.

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

//

void RWimCertMgmt::RetrieveOmaDataL( TOmaProv& aOmaProvStruct, 

                                     TRequestStatus& aStatus,

                                     const TWimServRqst aOpCode )

    {

    _WIMTRACE ( _L( "RWimCertMgmt::RetrieveOmaDataL" ) );

    aStatus = KRequestPending;

    iPckgBufOmaProv = new( ELeave ) 

                CWimCertPckgBuf<TOmaProv>( aOmaProvStruct );

    iPckgBufOmaProvAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, iPckgBufOmaProv->PckgBuf() );

    args.Set( 1, aOmaProvStruct.iOmaData );

    SendReceiveData( aOpCode, args, aStatus );

    }

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

// RWimCertMgmt::RetrieveACIFDataL()

// Retrieves ACIF data.

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

//    

void RWimCertMgmt::RetrieveACIFDataL( TJavaProv& aJavaProvStruct,

                               TRequestStatus& aStatus,

                               const TWimServRqst aOpCode )

    {

	_WIMTRACE ( _L( "RWimCertMgmt::RetrieveACIFDataL" ) );

    aStatus = KRequestPending;

    iPckgBufJavaProv = new( ELeave ) 

                CWimCertPckgBuf<TJavaProv>( aJavaProvStruct );

    iPckgBufJavaProvAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, iPckgBufJavaProv->PckgBuf() );

    args.Set( 1, aJavaProvStruct.iJavaData );

    SendReceiveData( aOpCode, args, aStatus );

    }

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

// RWimCertMgmt::RetrieveACFDataL()

// Retrieves ACF data.

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

//    

void RWimCertMgmt::RetrieveACFDataL( TJavaProv& aJavaProvStruct,

                               TRequestStatus& aStatus,

                               const TWimServRqst aOpCode )

    {

	_WIMTRACE ( _L( "RWimCertMgmt::RetrieveACFDataL" ) );

    aStatus = KRequestPending;

    iPckgBufJavaProv = new( ELeave ) 

                CWimCertPckgBuf<TJavaProv>( aJavaProvStruct );

    iPckgBufJavaProvAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, iPckgBufJavaProv->PckgBuf() );

    args.Set( 1, aJavaProvStruct.iJavaData );

    args.Set( 2, aJavaProvStruct.iPath );

    SendReceiveData( aOpCode, args, aStatus );

    }    

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

// RWimCertMgmt::GetAuthObjsInfo()

// Get Authentication Object information

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

//

void RWimCertMgmt::RetrieveAuthObjsInfoL( const RArray<TInt>& aAuthIdList,

                      RArray<TJavaPINParams>& aAuthObjsInfoList,

                      TRequestStatus& aStatus,

                      const TWimServRqst aOpCode )             

    {