/*
* 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: Interface which fetches all keyInfos from WIM -card.
*
*/
#ifndef WIMKEYDETAILS_H
#define WIMKEYDETAILS_H
#include "WimClsv.h"
#include <ct.h>
#include <mctkeystore.h>
#include <e32base.h>
//FORWARD DECLARATION
class RWimCertMgmt;
//CLASS DECLARATION
/**
* This class lists all keyInfos found from WIM -card.
* @lib WimClient
* @since Series60 2.1
*/
class CWimKeyDetails: public CActive
{
public:
/**
* Two-phased constructor.
* @param aToken -Reference to current token
*/
IMPORT_C static CWimKeyDetails* NewL( MCTToken& aToken );
/**
* Destructor
*/
IMPORT_C virtual ~CWimKeyDetails();
/**
* Lists all the keys in the WIM and creates CCTKeyInfo objects
* from received information. CCTKeyInfo objects are inserted to array
* aKeys.
* @param aKeys -Array where keyInfos are
* inserted. Caller is responsible
* to deallocate Array.(OUT)
* @param aKeyNumbers -Array where keynumbers are inserted. Each key
* has its own number. This number helps to solve
* which key is associated with which PIN.
* Caller is responsible to
* deallocate Array. (OUT)
* @aStatus -TRequestStatus from caller (IN/OUT)
* @return void
*/
IMPORT_C void GetKeyList( RPointerArray<CCTKeyInfo>& aKeys,
CArrayFixFlat<TUint8>& aKeyNumbers,
TRequestStatus& aStatus );
/*
* Cancels outgoing listing operation
* @return void
*/
IMPORT_C void CancelList();
/*
* Sign some data. Authentication is handled by server.
* @since Series 60 2.6
* @param aData The data to be signed - this should be some
* form of hash of the actual message to be signed.
* If the data is too long, this method will return
* KErrOverflow through aStatus. (IN)
* @param aSignature Signature which is given back to caller. (OUT)
* @param aKeyId. KeyId for signing operation.(IN)
* @param aStatus Caller's status (IN/OUT)
* @return void
*/
IMPORT_C void Sign( const TDesC8& aData,
TDesC8& aKeyId,
HBufC8*& aSignature,
TRequestStatus& aStatus );
/**
* Cancel signing operation
* @since Series 60 2.6
* @return void
*/
IMPORT_C void CancelSign();
/**
* Export public key
* @since Series 60 2.6
* @param aKeyId -The KeyId of the key to be exported (IN)
* @param aPublicKey -DER Encoded public key. Must be allocated
* by caller(OUT)
* @param aStatus -Caller's status (IN/OUT)
*/
IMPORT_C void ExportPublicKeyL( TDesC8& aKeyId,
HBufC8*& aPublicKey,
TRequestStatus& aStatus );
/**
* Cancels ongoing export operation
* @since Series 60 2.6
* @return void
*/
IMPORT_C void CancelExport();
private:
/**
* Allocates memory for Array which is filled by server.
* @return void
*/
void AllocMemoryForKeyListL();
/**
* Deallocates memory from the Array which was filled by server.
* @return void
*/
void DeallocMemoryFromKeyList();
/**
* Allocates memory for Keyinfo structure.
* @param aKeyInfo -Struct where allocated pointers are inserted.
* @return void
*/
void AllocMemoryForKeyInfoL( TKeyInfo& aKeyInfo );
/**
* Deallocates memory from Keyinfo structure.
* @return void
*/
void DeallocMemoryFromKeyInfo();
/**
* Allocates memory for data to be signed
* @param aData -Data to be signed
* @param aKeyId -KeyId of the key to be used for sign
* @return void
*/
void AllocMemoryForSignL( const TDesC8& aData, const TDesC8& aKeyId );
/**
* Deallocates previously allocated data after signing operation.
* @return void
*/
void DeallocMemoryFromSign();
/**
* Sets own iStatus to KRequestPending, and signals it
* with User::RequestComplete() -request. This gives chance
* to activescheduler to run other active objects. After a quick
* visit in activescheduler, signal returns to RunL() and starts next
* phase of operation.
* @return void
*/
void SignalOwnStatusAndComplete();
/**
* Converts key list parameters. Extracts data out from key list
* & key number. Extracted data is inserted to an RArray.
* @return void
*/
void ConvertKeyListL();
/*
* Converts key usage to match new key usage requirement
* @param aKeyUsage -Value to be converted
* @return TKeyUsagePKCS15 -New form of key usage
*/
TKeyUsagePKCS15 ConvertKeyUsage( TUint16 aKeyUsage );
private: //from CActive
/**
* Different phases are handled here.
* @return void
*/
void RunL();
/**
* Cancellation function
* Deallocates member variables and completes client status with
* KErrCancel error code.
* @return void
*/
void DoCancel();
/**
* The active scheduler calls this function if this active
* object's RunL() function leaves.
* Handles necessary cleanup and completes request with
* received error code.
* @param aError -Error which caused this event
* @return TInt -Error code to activescheduler, is always KErrNone.
*/
TInt RunError( TInt aError );
private:
/**
* Default constructor is private.
*/
void ConstructL();
/**
* Default constructor
* @param aToken -Reference to current token
*/
CWimKeyDetails( MCTToken& aToken );
private:
/**
* Seven different phases which handles list, sign and export public
* key operations
*/
enum TPhase
{
EGetKeyList,
EConvertParams,
EGetKeyInfo,
ESign,
ESignCompleted,
EExportPublicKey
};
private:
//Reference to current token. Needed in CCTCertInfo creation.
MCTToken& iToken;
//Handle to connection with server. Owned.
RWimCertMgmt* iConnectionHandle;
//Client status is stored here while operation
//on the server side is done.
TRequestStatus* iClientStatus;
//Used to handle different phases in RunL()
TPhase iPhase;
//Array which is used to contain key list.
//Not owned. Caller is responsible to destroy array.
RPointerArray<CCTKeyInfo>* iKeys;
//Buffer which is used to contain keyreference information. Owned.
HBufC8* iKeyList;
//Pointer to iKeylist. Owned.
TPtr8* iKeyListPtr;
// The number of keys
TInt iKeyNumber;
//Buffer which is used for keys label when constructing new keyinfo
//-objects. Owned.
HBufC8* iLabel;
//Pointer to iLabel. Owned.
TPtr8* iLabelPtr;
//Buffer which is used to contain unique modifier for a key. Used when
//constructing new keyinfo -objects. Owned.
HBufC8* iKeyId;
//Pointer to iKeyId. Owned.
TPtr8* iKeyIdPtr;
//Array which holds keyReferences. These references are needed when
//getting keyinfo for a single key.Owned.
RArray<TInt32> iKeyReferences;
//Array which hold keyNumber for each CCTKeyInfo -object, which are
//created and inserted to iKeys -array. Not owned.
CArrayFixFlat<TUint8>* iKeyNumberArray;
//counter which informs how many keyinfos have been created.
TInt iFetchedKeyInfos;
//Struct which is used when signing data.
TKeySignParameters iKeySignParameters;
//Struct which is used when exporting a key.
TExportPublicKey iExportPublicKey;
//Buffer which holds data to be signed. Owned.
HBufC8* iSigningData;
//Pointer to iSigningData. Owned.
TPtr8* iSigningDataPtr;
//Holds information which key is used for signing
TInt iSignKeyHandle;
//Buffer which holds received signature from WIM, if signing was
//succesful. Not owned
HBufC8* iSignature;
//Pointer to iSignature. Owned.
TPtr8* iSignaturePtr;
//Buffer which holds DER encoded public key. Not owned.
HBufC8* iPublicKey;
//Pointer to iPublicKey.Owned
TPtr8* iPublicKeyPtr;
//The pack to store key number
TPckg<TInt> iPckg;
};
#endif //WIMKEYDETAILS_H