diff -r 000000000000 -r 164170e6151a wim/WimServer/src/WimServer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wim/WimServer/src/WimServer.cpp Tue Jan 26 15:20:08 2010 +0200 @@ -0,0 +1,1036 @@ +/* +* Copyright (c) 2003-2009 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: Server startup and initialization +* +*/ + + + +// INCLUDE FILES +#include "WimServer.h" +#include "WimSession.h" +#include "WimSig.h" +#include "WimSessionRegistry.h" +#include "WimTrustSettingsStore.h" +#include "WimDefs.h" +#include "WimTrace.h" +#include "WimUtilityFuncs.h" +#include "WimCallbackImpl.h" +#include // UserSvr + +#include "WimCertInfo.h" +#include "Wimi.h" // WIMI definitions +#include "WimSatRefreshObserver.h" +#include "WimBTSapObserver.h" + +#include // RProperty +#include // Property values + +#ifdef WIMSERVER_SHUTDOWN +const TInt KServerShutdownDelay = 0x200000; +#endif +// Initialize static variables. These variables are static because static +// callback functions in CWimCallBack. +CWimServer* CWimServer::iWimServer = NULL; +TInt CWimServer::iWimStatus = KErrNone; +TBool CWimServer::iWimInitialized = EFalse; + + +// ============================= LOCAL FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// StartServer +// Server startup method. Creates active scheduler for the server. +// Returns: TInt: error code +// ----------------------------------------------------------------------------- +// +static void StartServerL() + { + _WIMTRACE(_L("WIM | WIMServer | StartServer | Enter")); + User::LeaveIfError( User::RenameThread( KWIMServerName ) ); + _WIMTRACE(_L("WIM | WIMServer | StartServer | Create AS")); + + CActiveScheduler* s = new(ELeave) CActiveScheduler; + CleanupStack::PushL( s ); + + CActiveScheduler::Install( s ); + + _WIMTRACE(_L("WIM | WIMServer | StartServer | Create server")); + + CWimServer::NewL(); + + _WIMTRACE(_L("WIM | WIMServer | StartServer | Notify client")); + // Notify Client that server has starter + RProcess::Rendezvous( KErrNone ); + + _WIMTRACE(_L("WIM | WIMServer | StartServer | Start ActiveScheduler")); + CActiveScheduler::Start(); + + CleanupStack::PopAndDestroy( s ); + } + + +// ----------------------------------------------------------------------------- +// E32Main +// Server entry point +// Returns: TInt: error code +// ----------------------------------------------------------------------------- +// +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + _WIMTRACE(_L("WIM | WIMServer | E32Main | Begin")); + + CTrapCleanup* cleanup=CTrapCleanup::New(); + TInt r=KErrNoMemory; + + if ( cleanup ) + { + TRAP( r, StartServerL() ); + delete cleanup; + } + _WIMTRACE(_L("WIM | WIMServer | E32Main Memory leak checking line")); + __UHEAP_MARKEND; + _WIMTRACE(_L("WIM | WIMServer | E32Main Memory checking passed")); + return r; + } + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CWimServer::CWimServer +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CWimServer::CWimServer( TInt aPriority ) + : CPolicyServer( aPriority, wimPolicy, ESharableSessions ) + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::CWimServer | Begin")); + } + +// ----------------------------------------------------------------------------- +// CWimServer::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CWimServer::ConstructL() + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::ConstructL | Begin")); + StartL( KWIMServerName ); + _WIMTRACE(_L("WIM | WIMServer | CWimServer::ConstructL | StartL")); + + iWimServer = this; + InitializeCallbackFunctions(); // Initialize WIMI callback functions + iWimSessionRegistry = CWimSessionRegistry::NewL(); + iWimTrustSettingsStore = CWimTrustSettingsStore::NewL(); + iWimTimer = CWimTimer::NewL( this ); +#ifdef WIMSERVER_SHUTDOWN + iShutdown.ConstructL(); + iShutdown.Start(); +#endif + _WIMTRACE(_L("WIM | WIMServer | CWimServer::ConstructL | End")); + } + +// ----------------------------------------------------------------------------- +// CWimServer::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CWimServer* CWimServer::NewL() + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::NewL | Begin")); + CWimServer* self = new( ELeave ) CWimServer( EPriorityHigh ); + CleanupStack::PushL( self ); + self->ConstructL() ; + CleanupStack::Pop( self ); + return self; + } + +// Destructor +CWimServer::~CWimServer() + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::~CWimServer | Begin")); + if ( iRefreshObserver ) + { + delete iRefreshObserver; + iRefreshObserver = NULL; + } + if ( iBTSapObserver ) + { + delete iBTSapObserver; + iBTSapObserver = NULL; + } + // Call close down request only if WIM is initialized + if ( iWimInitialized ) + { + WIMI_CloseDownReq(); + _WIMTRACE(_L("WIM | WIMServer | CWimServer::~CWimServer | WIMI_CloseDownReq")); + } + //iWimTrustSettingsStore->CloseD(); + delete iWimTrustSettingsStore; + delete iWimSessionRegistry; + delete iWimTimer; + CWimCallBack::DeletegApdu(); + _WIMTRACE(_L("WIM | WIMServer | CWimServer::~CWimServer | delete iWimSessionRegistry")); + } + +// ----------------------------------------------------------------------------- +// CWimServer::WimInitialize +// Initialize WIMI API, fetches WIM data to WIMI. +// ----------------------------------------------------------------------------- +// +void CWimServer::WimInitialize( const RMessage2& aMessage ) + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::WimInitialize | Begin")); + + // Create observer for bluetooth sap event. + // This is checked every time we enter here. + if ( !iBTSapObserver ) + { + TRAPD( err, iBTSapObserver = CWimBTSapObserver::NewL()); + if ( KErrNone != err ) + { + // creation failed + iBTSapObserver = NULL; // to be sure + _WIMTRACE(_L("WIM|CWimServer::WimInitialize | BT Sap observer NOT created.")); + } + } + // If BT SAP observer exists, start it + if ( iBTSapObserver ) + { + iBTSapObserver->Start(); //If already started, this doesn't start again + } + + // Get state of smart card + TInt simState = CWimUtilityFuncs::SimState(); + + // Check whether state of Smart Card is OK and whether BT SAP is connected + if ( simState != KErrNone ) // Card is not OK + { + SetWimInitialized( EFalse, simState ); + iWimStatus = simState; + aMessage.Complete( iWimStatus ); + } + else // Smart Card is ready + { + // Initialize WIMI if not yet done + // iWimInitialized is set in callback function InitOKResp() + if ( !iWimInitialized ) + { + TInt initStatus = CWimUtilityFuncs::MapWIMError( + WIMI_InitializeReq( &iWimCallBack ) ); + + _WIMTRACE2(_L("WIM|WIMServer|CWimServer::WimInitialize|initStatus=%d"), initStatus ); + + // In case WIMI_InitializeReq returs error + // iWimStatus may not be set + if ( initStatus != KErrNone ) + { + SetWimInitialized( EFalse, initStatus ); + iWimStatus = KErrNotReady; + } + } + else // WIMI already initialized + { + _WIMTRACE(_L("WIM|WIMServer|CWimServer::WimInitialize|Wim already initialized")); + iWimStatus = KErrNone; + } + + // Create observer for SAT refresh event. + // This is checked every time we enter here. It may have failed before + // because SAT Server wasn't started. + if ( !iRefreshObserver ) + { + TRAPD( err, iRefreshObserver = CWimSatRefreshObserver::NewL()); + if ( KErrNone != err ) + { + // creation failed + iRefreshObserver = NULL; // to be sure + _WIMTRACE(_L("WIM|CWimServer::WimInitialize | SAT Refresh observer NOT created.")); + } + } + + aMessage.Complete( iWimStatus ); + } + } + +// ----------------------------------------------------------------------------- +// CWimServer::SetWimInitialized +// Set iWimInitialized flag +// ----------------------------------------------------------------------------- +// +void CWimServer::SetWimInitialized( TBool aInitialized, TInt aStatus ) + { + _WIMTRACE2(_L("WIM|WIMServer|CWimServer::SetWimInitialized|Value=%d"), aInitialized); + iWimInitialized = aInitialized; + + if ( !aInitialized ) + { + iWimStatus = aStatus; + } + } + +// ----------------------------------------------------------------------------- +// CWimServer::NewSessionL +// Creates a new sharable session. +// ----------------------------------------------------------------------------- +// +CSession2* CWimServer::NewSessionL( + const TVersion& aVersion, + const RMessage2& /*aMessage*/ ) const + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::NewSessionL | Begin")); + TVersion v( KWIMServMajorVersionNumber, KWIMServMinorVersionNumber, + KWIMServBuildVersionNumber ); + + if ( !User::QueryVersionSupported( v, aVersion ) ) + { + User::Leave( KErrNotSupported ); + } + + CWimSession* wimSession; + wimSession = CWimSession::NewL( ( CWimServer* )this ); + iWimSessionRegistry->AddSessionL( wimSession ); + + return wimSession; + } + +// ----------------------------------------------------------------------------- +// CWimServer::InitializeCallbackFunctions +// WIMI API callback initialization. +// ----------------------------------------------------------------------------- +// +void CWimServer::InitializeCallbackFunctions() + { + _WIMTRACE(_L("WIM | WIMServer | CWimSession::InitializeCallbackFunctions | Begin")); + _WIMTRACE2(_L("WIM | WIMServer | CWimSession::InitializeCallbackFunctions | iWimCallBack = %d"), iWimCallBack ); + + iWimCallBack.InitOkResp = CWimCallBack::InitOkResp; + iWimCallBack.CloseDownResp = CWimCallBack::CloseDownResp; + iWimCallBack.SignResp = CWimCallBack::SignResp; + iWimCallBack.CertificateResp = CWimCallBack::CertificateResp; + iWimCallBack.CertificateDeleteResp = CWimCallBack::CertificateDeleteResp; + iWimCallBack.CertificateStoreResp = CWimCallBack::CertificateStoreResp; + iWimCallBack.VerifyPINResp = CWimCallBack::VerifyPINResp; + iWimCallBack.ChangePINResp = CWimCallBack::ChangePINResp; + iWimCallBack.UnblockPINResp = CWimCallBack::UnblockPINResp; + iWimCallBack.EnablePINResp = CWimCallBack::EnablePINResp; + iWimCallBack.CardInsertedResp = CWimCallBack::CardInsertedResp; + iWimCallBack.Open = CWimCallBack::Open; + iWimCallBack.Close = CWimCallBack::Close; + iWimCallBack.APDUReq = CWimCallBack::APDUReq; + iWimCallBack.GetATRReq = CWimCallBack::GetATRReq; + iWimCallBack.GetReaderListReq = CWimCallBack::GetReaderListReq; + iWimCallBack.ReadSimFileReq = CWimCallBack::ReadSimFileReq; + iWimCallBack.ProvSCFileResp = CWimCallBack::OmaProvisioningResp; + + _WIMTRACE(_L("WIM | WIMServer | CWimSession::InitializeCallbackFunctions | END")); + } + +// ----------------------------------------------------------------------------- +// CWimServer::PanicServer +// Panics the server. +// ----------------------------------------------------------------------------- +// +void CWimServer::PanicServer( TWimServerPanic aPanic ) + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::PanicServer | Begin")); + // Set server state to EWimServerNotRunning + TInt retVal = RProperty::Set( KUidSystemCategory, + KWimServerUid.iUid, + EWimServerNotRunning ); + retVal = retVal; // To prevent warning + + User::Panic( KWIMServerName, aPanic ); + } + +// ----------------------------------------------------------------------------- +// CWimServer::Server +// Return static iServer +// ----------------------------------------------------------------------------- +// +CWimServer* CWimServer::Server() + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::Server | Begin")); + return CWimServer::iWimServer; + } + +// ----------------------------------------------------------------------------- +// CWimServer::WimSessionRegistry +// Get pointer to WimSessionRegistry +// ----------------------------------------------------------------------------- +// +CWimSessionRegistry* CWimServer::WimSessionRegistry() + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::WimSessionRegistry | Begin")); + return iWimSessionRegistry; + } + +// ----------------------------------------------------------------------------- +// CWimServer::GetSessions +// Return all sessions of server +// ----------------------------------------------------------------------------- +// +void CWimServer::GetSessionsL( RArray& aSessions ) const + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::GetSessionsL | Begin")); + iWimSessionRegistry->GetSessionsL( aSessions ); + } + +// ----------------------------------------------------------------------------- +// CWimServer::WimTrustSettingsStore +// Return TrustSettingsStore pointer +// ----------------------------------------------------------------------------- +// +CWimTrustSettingsStore* CWimServer::WimTrustSettingsStore() + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::WimTrustSettingsStore | Begin")); + return iWimTrustSettingsStore; + } + +// ----------------------------------------------------------------------------- +// CWimServer::CustomSecurityCheckL +// Custom policy check for requests of certain WimServer services.Called by +// framework. +// ----------------------------------------------------------------------------- +// + CPolicyServer::TCustomResult +CWimServer::CustomSecurityCheckL( const RMessage2& aMsg, + TInt& /*aAction*/, + TSecurityInfo& /*aMissing*/ ) + { + _WIMTRACE2(_L("CWimServer::CustomSecurityCheckL | Begin, heap=%d"), + User::CountAllocCells()); + + WIMI_STAT callStatus; + TUint8 usage( 255 ); // init stg unused + // Set initial return value to failed + CPolicyServer::TCustomResult test( EFail ); + TInt function = aMsg.Function(); + + _WIMTRACE4(_L("CWimServer::CustomSecurityCheckL: SID=%d,VID=%d, Function=%d"), + aMsg.SecureId().iId, aMsg.VendorId().iId, function); + + switch ( function ) + { + case EGetWIMCertDetails: + { + //Leave the capability checking to Certificate Handler object + test = EPass; + break; + } + + case EGetCertExtras: + { + // Int2 contains usage of required cert + TWimEntryType certEntryType = ( TWimEntryType ) aMsg.Int2(); + + switch ( certEntryType ) + { + case EWimEntryTypeCA: + { + // CA cert reading does not require caps + _WIMTRACE(_L("CWimServer::CustomSecurityCheckL: CA cert read req, OK")); + test = EPass; + break; + } + case EWimEntryTypePersonal: //lint -fallthrough + case EWimEntryTypeAll: + { + // User cert reading requires caps + test = CheckReadCapsForUsage( aMsg, WIMI_CU_Client ); + break; + } + default: + { + test = EFail; + break; + } + } + break; + } + + case EStoreCertificate: + { + ResolveStoreCertReqL( aMsg, usage ); + test = CheckWriteCapsForUsage( aMsg, usage ); + break; + } + + case ERemoveCertificate: + { + callStatus = ResolveRemoveCertReqL( aMsg, usage ); + if ( WIMI_Ok == callStatus ) + { + test = CheckWriteCapsForUsage( aMsg, usage ); + } + break; + } + + case ESignTextReq: + { + test = CheckReadCapsForUsage( aMsg, WIMI_CU_Client ); + break; + } + + case ESetApplicability: //lint -fallthrough + case ESetTrust: //lint -fallthrough + case ESetDefaultTrustSettings: //lint -fallthrough + case ERemoveTrustSettings: + { + if ( ResolveTrustModficationReqL( aMsg, usage )) + { + test = CheckWriteCapsForUsage( aMsg, usage ); + } + break; + } + + case EExportPublicKey: + { + ResolveExportPublicReqL( aMsg, usage ); + test = CheckReadCapsForUsage( aMsg, usage ); + break; + } + + default: + { + _WIMTRACE2(_L("CWimServer::CustomSecurityCheckL: UNKNOWN FUNCTION %d"), + function); + // Inconsistent policy, should not be here. Panic. + PanicServer( EWimIncorrectPolicy ); + break; + } + } // switch ( function ) + + _WIMTRACE2(_L("CWimServer::CustomSecurityCheckL: Result=%d"), test); + _WIMTRACE2(_L("CWimServer::CustomSecurityCheckL | End, heap=%d"), + User::CountAllocCells()); + + return test; + } + + +// ----------------------------------------------------------------------------- +// CWimServer::ResolveCertUsage +// Resolves usage (CA/User) for a certificate. +// ----------------------------------------------------------------------------- +// +WIMI_STAT CWimServer::ResolveCertUsage( const RMessage2& aMsg, + TUint8& aUsage ) + { + _WIMTRACE(_L("CWimServer::ResolveCertUsage | Begin")); + + // aMsg.Ptr0 contains reference to certificate + WIMI_Ref_pt pCertRef = const_cast< WIMI_Ref_pt >( aMsg.Ptr0() ); + + WIMI_STAT callStatus = GetCertificateInfo( pCertRef, aUsage ); + + _WIMTRACE(_L("CWimServer::ResolveCertUsage | End")); + return callStatus; + } + + +// ----------------------------------------------------------------------------- +// CWimServer::GetCertificateInfo +// Fetches certificate info. Wrapper for WIMI call. +// ----------------------------------------------------------------------------- +// +WIMI_STAT CWimServer::GetCertificateInfo( WIMI_Ref_pt aCertRef, + TUint8& aUsage ) + { + _WIMTRACE(_L("CWimServer::GetCertificateInfo | Begin")); + + WIMI_Ref_pt pWimRef = NULL; + WIMI_BinData_t ptLabel; + WIMI_BinData_t ptKeyID; + WIMI_BinData_t ptCAID; + WIMI_BinData_t ptIssuerHash; + WIMI_BinData_t ptTrustedUsage; + TUint8 uiCDFRefs; + TUint8 type; + TUint16 certLen; + TUint8 modifiable = 0; + + WIMI_STAT callStatus = WIMI_GetCertificateInfo( + aCertRef, + &pWimRef, + &ptLabel, + &ptKeyID, // Key Id (hash) + &ptCAID, + &ptIssuerHash, + &ptTrustedUsage, + &uiCDFRefs, + &aUsage, // 0 = client, 1 = CA + &type, // WTLSCert(1), + // X509Cert(2), + // X968Cert(3), + // CertURL(4) + &certLen, // cert. content or URL length + &modifiable ); + + if ( callStatus == WIMI_Ok ) + { + free_WIMI_Ref_t( pWimRef ); + WSL_OS_Free( ptLabel.pb_buf ); + WSL_OS_Free( ptKeyID.pb_buf ); + WSL_OS_Free( ptCAID.pb_buf ); + WSL_OS_Free( ptIssuerHash.pb_buf ); + WSL_OS_Free( ptTrustedUsage.pb_buf ); + } + + _WIMTRACE(_L("CWimServer::GetCertificateInfo | End")); + return callStatus; + } + + +// ----------------------------------------------------------------------------- +// CWimServer::ResolveStoreCertReqL +// Resolves which kind of certificate (CA/User) client is accessing. +// ----------------------------------------------------------------------------- +// +void CWimServer::ResolveStoreCertReqL( const RMessage2& aMsg, + TUint8& aUsage ) + { + _WIMTRACE(_L("CWimServer::ResolveStoreCertReqL | Begin")); + TPckgBuf certInfoPckg; + aMsg.ReadL( 1, certInfoPckg ); + + // Convert from TWimCertType to TUint8 + if ( certInfoPckg().iUsage == EWimCertTypeCA ) + { + aUsage = WIMI_CU_CA; // 1 + _WIMTRACE(_L("CWimServer::ResolveStoreCertReqL | Usage=CA")); + } + else + { + aUsage = WIMI_CU_Client; // 0 + _WIMTRACE(_L("CWimServer::ResolveStoreCertReqL | Usage=Client")); + } + _WIMTRACE(_L("CWimServer::ResolveStoreCertReqL | End")); + } + + +// ----------------------------------------------------------------------------- +// CWimServer::ResolveRemoveCertReqL +// Resolves which kind of certificate client is accessing. +// ----------------------------------------------------------------------------- +// +WIMI_STAT CWimServer::ResolveRemoveCertReqL( const RMessage2& aMsg, + TUint8& aUsage ) + { + _WIMTRACE2(_L("CWimServer::ResolveRemoveCertReqL | Begin, heap=%d"), + User::CountAllocCells()); + + WIMI_STAT callStatus = WIMI_Ok; + TWimCertRemoveAddr dataStruct = {0}; + + TPckgBuf wimCertRemoveAddrPckg( dataStruct ); + aMsg.ReadL( 0, wimCertRemoveAddrPckg ); + WIMI_Ref_pt pCertRef = ( void* )wimCertRemoveAddrPckg().iCertAddr; + + callStatus = GetCertificateInfo( pCertRef, aUsage ); + + _WIMTRACE2(_L("CWimServer::ResolveRemoveCertReqL | End, heap=%d"), + User::CountAllocCells()); + + return callStatus; + } + + +// ----------------------------------------------------------------------------- +// CWimServer::ResolveTrustModficationReqL +// Resolves which kind of certificate client is accessing. +// ----------------------------------------------------------------------------- +// +TBool CWimServer::ResolveTrustModficationReqL( const RMessage2& aMsg, + TUint8& aUsage ) + { + _WIMTRACE(_L("CWimServer::ResolveTrustModficationReqL | Begin")); + TBool rc( EFalse ); + TPckgBuf pckg; + aMsg.ReadL( 0, pckg ); + + TInt owner = pckg().iCertificateOwnerType; + + switch ( owner ) + { + case ECACertificate: + { + aUsage = WIMI_CU_CA; + rc = ETrue; + _WIMTRACE(_L("CWimServer::ResolveTrustModficationReqL | Usage=CA")); + break; + } + case EUserCertificate: //lint -fallthrough + case EPeerCertificate: + { + aUsage = WIMI_CU_Client; + rc = ETrue; + _WIMTRACE(_L("CWimServer::ResolveTrustModficationReqL | Usage=Client")); + break; + } + default: + { + rc = EFalse; + _WIMTRACE(_L("CWimServer::ResolveTrustModficationReqL | FAIL")); + break; + } + } + return rc; + } + + +// ----------------------------------------------------------------------------- +// CWimServer::ResolveExportPublicReqL +// Resolves which kind of key (CA/User) client requests. +// ----------------------------------------------------------------------------- +// +WIMI_STAT CWimServer::ResolveExportPublicReqL( const RMessage2& aMsg, + TUint8& aUsage ) + { + _WIMTRACE2(_L("CWimServer::ResolveExportPublicReqL | Begin, heap=%d"), + User::CountAllocCells()); + + WIMI_STAT callStatus = WIMI_Ok; + + TPckgBuf keyExportPckg; + aMsg.ReadL( 0, keyExportPckg ); + + TBuf8 keyIdBuf = keyExportPckg().iKeyId; + TUint8 clicertCount = 0; + WIMI_RefList_t clicertRefList = NULL; + const TUint16 KInvalidUsage = 10; + TUint16 usage = KInvalidUsage; + + callStatus = WIMI_GetCertificateListByKeyHash( ( TUint8* ) keyIdBuf.Ptr(), + WIMI_CU_Client, + &clicertCount, + &clicertRefList ); + if( callStatus != WIMI_Ok ) + { + return callStatus; + } + free_WIMI_RefList_t( clicertRefList ); + + if ( clicertCount > 0 ) + { + usage = WIMI_CU_Client; + } + else + { + TUint8 cacertCount = 0; + WIMI_RefList_t cacertRefList = NULL; + + callStatus = WIMI_GetCertificateListByKeyHash( ( TUint8* ) keyIdBuf.Ptr(), + WIMI_CU_CA, + &cacertCount, + &cacertRefList ); + if ( callStatus != WIMI_Ok ) + { + return callStatus; + } + free_WIMI_RefList_t( cacertRefList ); + + if ( cacertCount > 0 ) + { + usage = WIMI_CU_CA; + } + else + { + aMsg.Complete( KErrBadHandle ); + } + } + + aUsage = static_cast< TUint8 >( usage ); + + _WIMTRACE2(_L("CWimServer::ResolveExportPublicReqL | End, heap=%d"), + User::CountAllocCells()); + + return callStatus; + } + + +// ----------------------------------------------------------------------------- +// CWimServer::CheckReadCapsForUsage +// Check if client has sufficient read capability for service in question. +// ----------------------------------------------------------------------------- +// + CPolicyServer::TCustomResult +CWimServer::CheckReadCapsForUsage( const RMessage2& aMsg, + TUint8 aUsage ) + { + _WIMTRACE2(_L("CWimServer::CheckReadCapsForUsage | Begin, usage=%d"), aUsage ); + + CPolicyServer::TCustomResult rc( EFail ); + + switch ( aUsage ) + { + case WIMI_CU_CA: + { + // CA certificate reading doesn't require any capability. + _WIMTRACE(_L("CWimServer::CheckReadCapsForUsage: CA cert read req, OK.")); + rc = EPass; + break; + } + case WIMI_CU_Client: + { + // User certificate reading requires ReadUserData capability. + if ( aMsg.HasCapability( ECapabilityReadUserData )) + { + rc = EPass; + _WIMTRACE(_L("CWimServer::CheckReadCapsForUsage: User cert read capa PASS")); + } + else + { + rc = EFail; + _WIMTRACE(_L("CWimServer::CheckReadCapsForUsage: User cert read capa FAIL")); + } + break; + } + default: + { + _WIMTRACE(_L("CWimServer::CheckReadCapsAccordingToUsage: FAIL:Unknown usage.")); + rc = EFail; + break; + } + } + _WIMTRACE(_L("CWimServer::CheckReadCapsForUsage | End")); + return rc; + } + + +// ----------------------------------------------------------------------------- +// CWimServer::CheckWriteCapsForUsage +// Check if client has sufficient write capability for service in question. +// ----------------------------------------------------------------------------- +// + CPolicyServer::TCustomResult +CWimServer::CheckWriteCapsForUsage( const RMessage2& aMsg, + TUint8 aUsage ) + { + _WIMTRACE2(_L("CWimServer::CheckWriteCapsForUsage | Begin, usage=%d"), aUsage); + + CPolicyServer::TCustomResult rc( EFail ); + + switch ( aUsage ) + { + case WIMI_CU_CA: + { + // CA certificate writing/modifying requires WriteDeviceData + // capability. + if ( aMsg.HasCapability( ECapabilityWriteDeviceData )) + { + rc = EPass; + _WIMTRACE(_L("CWimServer::CheckWriteCapsForUsage: CA cert write capa PASS")); + } + else + { + rc = EFail; + _WIMTRACE(_L("CWimServer::CheckWriteCapsForUsage: CA cert write capa FAIL")); + } + break; + } + case WIMI_CU_Client: + { + // User certificate writing/modifying requires WriteUserData + // capability. + if ( aMsg.HasCapability( ECapabilityWriteUserData )) + { + rc = EPass; + _WIMTRACE(_L("CWimServer::CheckWriteCapsForUsage: User cert write capa PASS")); + } + else + { + rc = EFail; + _WIMTRACE(_L("CWimServer::CheckWriteCapsForUsage: User cert write capa FAIL")); + } + break; + } + default: + { + _WIMTRACE(_L("CWimServer::CheckWriteCapsForUsage: FAIL:Unknown usage.")); + rc = EFail; // Unknown cert usage -> fail to be sure + break; + } + } + _WIMTRACE(_L("CWimServer::CheckWriteCapsForUsage | End")); + return rc; + } + + +// ----------------------------------------------------------------------------- +// CWimServer::IsAccessingToken +// Tells if currently requested service is accessing physical token. +// ----------------------------------------------------------------------------- +// +TBool CWimServer::IsAccessingToken() + { + return iIsAccessingToken; + } + +// ----------------------------------------------------------------------------- +// CWimServer::SetIsAccessingToken +// Tell that currently requested service is accessing physical token. +// ----------------------------------------------------------------------------- +// +void CWimServer::SetIsAccessingToken( TBool aValue ) + { + iIsAccessingToken = aValue; + } + +// ----------------------------------------------------------------------------- +// CWimServer::RefreshNotificationReceived +// Informs server about completed SIM Refresh operation. Returns true if SIM +// Refresh notification is received in the middle of service request that +// accesses physical token. See IsAccessingToken(). +// Server shall re-initialize itself at earliest convenience. +// ----------------------------------------------------------------------------- +// +TBool CWimServer::RefreshNotificationReceived() + { + return iRefreshNotificationReceived; + } + +// ----------------------------------------------------------------------------- +// CWimServer::SetRefreshNotificationReceived +// Tell server about completed SIM Refresh operation. Is set if SIM +// Refresh notification is received in the middle of service request +// that accesses physical token. See IsAccessingToken(). +// Server shall re-initialize itself at earliest convenience. +// ----------------------------------------------------------------------------- +// +void CWimServer::SetRefreshNotificationReceived( TBool aValue ) + { + iRefreshNotificationReceived = aValue; + } + +// ----------------------------------------------------------------------------- +// CWimServer::TimerExpired() +// Interface derived from +// ----------------------------------------------------------------------------- +// +void CWimServer::TimerExpired() + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::TimerExpired | Begin")); + WIMI_Ref_pt pWimRefTemp = NULL; + + pWimRefTemp = WIMI_GetWIMRef( 0 ); + + if ( pWimRefTemp ) // Close the WIM + { + WIMI_CloseWIM( pWimRefTemp ); + free_WIMI_Ref_t( pWimRefTemp ); + } + //SetWimInitialized( EFalse ); + } + +// ----------------------------------------------------------------------------- +// CWimServer::WimTimer() +// Return the pointer of Timer +// ----------------------------------------------------------------------------- +// +CWimTimer* CWimServer::WimTimer() + { + _WIMTRACE(_L("WIM | WIMServer | CWimServer::WimTimer | Begin")); + return iWimTimer; + } + +// ----------------------------------------------------------------------------- +// CWimServer::CancelWimInitialize() +// Cancel Wim Initialize +// ----------------------------------------------------------------------------- +// +void CWimServer::CancelWimInitialize( const RMessage2& aMessage ) + { + if ( !iWimInitialized ) + { + CWimCallBack::CancelWimInitialize(); + } + aMessage.Complete( KErrNone ); + } + + +#ifdef WIMSERVER_SHUTDOWN + +// CShutdown + +// --------------------------------------------------------------------------- +// CShutdown::CShutdown() +// --------------------------------------------------------------------------- +// +inline CShutdown::CShutdown() : + CTimer(-1) + { + CActiveScheduler::Add(this); + } + + +// --------------------------------------------------------------------------- +// CShutdown::ConstructL() +// --------------------------------------------------------------------------- +// +inline void CShutdown::ConstructL() + { + CTimer::ConstructL(); + } + + +// --------------------------------------------------------------------------- +// CShutdown::Start() +// --------------------------------------------------------------------------- +// +inline void CShutdown::Start() + { + After(KServerShutdownDelay); + } + + +// --------------------------------------------------------------------------- +// CShutdown::RunL() +// Initiate server exit when the timer expires. +// --------------------------------------------------------------------------- +// +void CShutdown::RunL() + { + _WIMTRACE(_L("WIM | WIMServer | CShutdown::RunL")); + CActiveScheduler::Stop(); + _WIMTRACE(_L("WIM | WIMServer | CShutdown::End")); + } + +// --------------------------------------------------------------------------- +// CWimServer::DropSession() +// --------------------------------------------------------------------------- +// +void CWimServer::AddSession() + { + ++iSessionCount; + iShutdown.Cancel(); + } + + +// --------------------------------------------------------------------------- +// CWimServer::DropSession() +// --------------------------------------------------------------------------- +// +void CWimServer::DropSession() + { + if (--iSessionCount==0) + { + iShutdown.Start(); + } + } + +#endif //WIMSERVER_SHUTDOWN