--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/pkiutilities/DeviceToken/Src/Certstore/client/DevandTruSrvCertStore.cpp Tue Jan 26 15:20:08 2010 +0200
@@ -0,0 +1,696 @@
+/*
+* Copyright (c) 2006 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 DevandTruSrvCertStore
+*
+*/
+
+
+
+#include "DevandTruSrvCertStore.h"
+#include "DevTokenType.h"
+#include "DevToken.h"
+#include "DevTokenUtils.h"
+#include "DevTokenImplementationUID.hrh"
+
+// This is sized for roughly five cert infos, to ensure that the overflow
+// mechanism gets tested.
+const TInt KDefaultBufferSize = 256;
+
+// ======== MEMBER FUNCTIONS ========
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::NewWritableInterfaceL()
+// -----------------------------------------------------------------------------
+//
+MCTTokenInterface* CDevandTruSrvCertStore::NewWritableInterfaceL(MCTToken& aToken,
+ RDevTokenClientSession& aClient)
+ {
+ // Destroyed by MCTTokenInterface::DoRelease() (no refcounting)
+ CDevandTruSrvCertStore* me = new (ELeave) CDevandTruSrvCertStore(KInterfaceWritableCertStore,
+ aToken,
+ aClient);
+ CleanupStack::PushL(me);
+ me->ConstructL();
+ CleanupStack::Pop(me);
+ return (me);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::NewReadableInterfaceL()
+// -----------------------------------------------------------------------------
+//
+MCTTokenInterface* CDevandTruSrvCertStore::NewReadableInterfaceL(MCTToken& aToken,
+ RDevTokenClientSession& aClient)
+ {
+ // Destroyed by MCTTokenInterface::DoRelease() (no refcounting)
+ CDevandTruSrvCertStore* me = new (ELeave) CDevandTruSrvCertStore(KInterfaceCertStore,
+ aToken,
+ aClient);
+ CleanupStack::PushL(me);
+ me->ConstructL();
+ CleanupStack::Pop(me);
+ return (me);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CDevandTruSrvCertStore()
+// -----------------------------------------------------------------------------
+//
+CDevandTruSrvCertStore::CDevandTruSrvCertStore(TInt aUID,
+ MCTToken& aToken,
+ RDevTokenClientSession& aClient) :
+ CDTClient(aUID, aToken, aClient)
+ {
+ iFilter = NULL;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::~CDevandTruSrvCertStore()
+// -----------------------------------------------------------------------------
+//
+CDevandTruSrvCertStore::~CDevandTruSrvCertStore()
+ {
+ if( iFilter )
+ {
+ delete iFilter;
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::ConstructL()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::ConstructL()
+ {
+ CActiveScheduler::Add(this);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::DoRelease()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::DoRelease()
+ {
+ MCTTokenInterface::DoRelease();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::Token()
+// -----------------------------------------------------------------------------
+//
+MCTToken& CDevandTruSrvCertStore::Token()
+ {
+ return iToken;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::RunL()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::RunL()
+ {
+ // Never active, so should never get called
+ DevTokenPanic(ENoRequestOutstanding);
+ }
+
+
+//MCTCertStore
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::List()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::List(RMPointerArray<CCTCertInfo>& aCerts,
+ const CCertAttributeFilter& aFilter,
+ TRequestStatus& aStatus)
+ {
+ CDevToken* token = static_cast<CDevToken*>( &iToken );
+
+ CDevTokenType* tokenType = static_cast<CDevTokenType*>( &(token->TokenType()) );
+
+ if ( tokenType->iUid.iUid == DEVCERTSTORE_IMPLEMENTATION_UID )
+ {
+ if (aFilter.iOwnerType != EUserCertificate)
+ {
+ if( aFilter.iOwnerTypeIsSet )
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, KErrNone );
+ return;
+ }
+ //If the owner type is not set, we create a filter and
+ // set the type to EUserCertificate
+ else
+ {
+ //alway use new filter.
+ if( iFilter )
+ {
+ delete iFilter;
+ iFilter = NULL;
+ }
+ TRAPD( err, iFilter = CCertAttributeFilter::NewL() );
+ if ( err != KErrNone )
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, err );
+ return;
+ }
+
+ CopyFilter( iFilter, aFilter );
+ //Set owner type to user certificate
+ iFilter->SetOwnerType( EUserCertificate );
+
+ TRAPD(r, DoListL(aCerts, *iFilter));
+ FreeRequestBuffer();
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, r);
+ return;
+ }
+ }
+ }
+ else if ( tokenType->iUid.iUid == TRUSRVCERTSTORE_IMPLEMENTATION_UID )
+ {
+ if (aFilter.iOwnerType != EPeerCertificate)
+ {
+ if( aFilter.iOwnerTypeIsSet )
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, KErrNone );
+ return;
+ }
+ //If the owner type is not set, we create a filter and
+ // set the type to EPeerCertificate
+ else
+ {
+ if( iFilter )
+ {
+ delete iFilter;
+ iFilter = NULL;
+ }
+
+ TRAPD( er, iFilter = CCertAttributeFilter::NewL() );
+ if ( er != KErrNone )
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, er );
+ return;
+ }
+
+ CopyFilter( iFilter, aFilter );
+
+ iFilter->SetOwnerType( EPeerCertificate );
+ TRAPD(r, DoListL(aCerts, *iFilter));
+ FreeRequestBuffer();
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, r);
+ return;
+ }
+ }
+ }
+ else
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, KErrNone );
+ return;
+ }
+
+ TRAPD(r, DoListL(aCerts, aFilter));
+ FreeRequestBuffer();
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, r);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CopyFilterL()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CopyFilter( CCertAttributeFilter* aDesFilter, const CCertAttributeFilter& aSrcFilter )
+ {
+ if ( aSrcFilter.iLabelIsSet )
+ {
+ aDesFilter->SetLabel( aSrcFilter.iLabel );
+ }
+
+ if ( aSrcFilter.iUidIsSet )
+ {
+ aDesFilter->SetUid( aSrcFilter.iUid );
+ }
+
+ if ( aSrcFilter.iFormatIsSet )
+ {
+ aDesFilter->SetFormat( aSrcFilter.iFormat );
+ }
+
+ if ( aSrcFilter.iOwnerTypeIsSet )
+ {
+ aDesFilter->SetOwnerType( aSrcFilter.iOwnerType );
+ }
+
+
+ if ( aSrcFilter.iSubjectKeyIdIsSet )
+ {
+ aDesFilter->SetSubjectKeyId( aSrcFilter.iSubjectKeyId );
+ }
+
+ if ( aSrcFilter.iIssuerKeyIdIsSet )
+ {
+ aDesFilter->SetIssuerKeyId( aSrcFilter.iIssuerKeyId );
+ }
+
+ aDesFilter->SetKeyUsage( aSrcFilter.iKeyUsage );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::DoListL()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::DoListL(RMPointerArray<CCTCertInfo>& aCerts,
+ const CCertAttributeFilter& aFilter)
+ {
+ HBufC8* filterBuf = HBufC8::NewLC(DevTokenDataMarshaller::Size(aFilter));
+ TPtr8 ptr(filterBuf->Des());
+ DevTokenDataMarshaller::WriteL(aFilter, ptr);
+ TIpcArgs args(0, filterBuf, 0, &iRequestPtr);
+ SendSyncRequestAndHandleOverflowL(EListCerts, KDefaultBufferSize, args);
+ CleanupStack::PopAndDestroy(filterBuf);
+ DevTokenDataMarshaller::ReadL(iRequestPtr, iToken, aCerts);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelList()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelList()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::GetCert()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::GetCert(CCTCertInfo*& aCertInfo,
+ const TCTTokenObjectHandle& aHandle,
+ TRequestStatus& aStatus)
+ {
+ TRAPD(r, DoGetCertL(aCertInfo, aHandle));
+ FreeRequestBuffer();
+ TRequestStatus* stat = &aStatus;
+ User::RequestComplete(stat, r);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::DoGetCertL()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::DoGetCertL(CCTCertInfo*& aCertInfo,
+ const TCTTokenObjectHandle& aHandle)
+ {
+ User::LeaveIfError(AllocRequestBuffer(sizeof(CCTCertInfo))); // assumes serialized size <= sizeof class
+ TIpcArgs args(aHandle.iObjectId, 0, 0, &iRequestPtr);
+ User::LeaveIfError(iClientSession.SendRequest(EGetCert, args));
+ DevTokenDataMarshaller::ReadL(iRequestPtr, iToken, aCertInfo);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelGetCert()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelGetCert()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::Applications()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::Applications(const CCTCertInfo& aCertInfo,
+ RArray<TUid>& aApplications,
+ TRequestStatus& aStatus)
+ {
+ TRAPD(r, DoApplicationsL(aCertInfo, aApplications));
+ FreeRequestBuffer();
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, r);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::DoApplicationsL()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::DoApplicationsL(const CCTCertInfo& aCertInfo,
+ RArray<TUid>& aApplications)
+ {
+ TIpcArgs args(aCertInfo.Handle().iObjectId, 0, 0, &iRequestPtr);
+ SendSyncRequestAndHandleOverflowL(EApplications, KDefaultBufferSize, args);
+ DevTokenDataMarshaller::ReadL(iRequestPtr, aApplications);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelApplications()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelApplications()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::IsApplicable()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::IsApplicable(const CCTCertInfo& aCertInfo, TUid aApplication,
+ TBool& aIsApplicable, TRequestStatus& aStatus)
+ {
+ TIpcArgs args(aCertInfo.Handle().iObjectId, 0, aApplication.iUid);
+ TInt r = iClientSession.SendRequest(EIsApplicable, args);
+ if (r >= 0)
+ {
+ aIsApplicable = !!r; // Convert TInt to TBool
+ r = KErrNone;
+ }
+
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, r);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelIsApplicable()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelIsApplicable()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::Trusted()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::Trusted(const CCTCertInfo& aCertInfo, TBool& aTrusted,
+ TRequestStatus& aStatus)
+ {
+ TIpcArgs args(aCertInfo.Handle().iObjectId);
+ TInt r = iClientSession.SendRequest(ETrusted, args);
+ if (r >= 0)
+ {
+ aTrusted = !!r; // Convert TInt to TBool
+ r = KErrNone;
+ }
+
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, r);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelTrusted()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelTrusted()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::Retrieve()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::Retrieve(const CCTCertInfo& aCertInfo, TDes8& aEncodedCert,
+ TRequestStatus& aStatus)
+ {
+ TInt err = DoRetrieve(aCertInfo, aEncodedCert);
+ FreeRequestBuffer();
+ TRequestStatus* stat = &aStatus;
+ User::RequestComplete(stat, err);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::DoRetrieve()
+// -----------------------------------------------------------------------------
+//
+TInt CDevandTruSrvCertStore::DoRetrieve(const CCTCertInfo& aCertInfo, TDes8& aEncodedCert)
+ {
+ if (aCertInfo.Size() <= 0)
+ {
+ return KErrArgument;
+ }
+
+ if (aEncodedCert.MaxSize() < aCertInfo.Size())
+ {
+ return KErrOverflow;
+ }
+
+ TInt r = AllocRequestBuffer(aEncodedCert.MaxSize());
+ if (KErrNone!=r)
+ {
+ return r;
+ }
+
+ TIpcArgs args(aCertInfo.Handle().iObjectId, 0, 0, &iRequestPtr);
+ r = iClientSession.SendRequest(ERetrieve, args);
+ if (r == KErrNone)
+ {
+ aEncodedCert.Copy(iRequestPtr);
+ }
+
+ return r;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelRetrieve()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelRetrieve()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// MCTWritableCertStore interface
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::Add()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::Add(const TDesC& aLabel, TCertificateFormat aFormat,
+ TCertificateOwnerType aCertificateOwnerType,
+ const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,
+ const TDesC8& aCert, TRequestStatus& aStatus)
+ {
+ Add(aLabel, aFormat, aCertificateOwnerType, aSubjectKeyId, aIssuerKeyId, aCert,
+ ETrue, aStatus);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::Add()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::Add(const TDesC& aLabel, TCertificateFormat aFormat,
+ TCertificateOwnerType aCertificateOwnerType,
+ const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,
+ const TDesC8& aCert, const TBool aDeletable,
+ TRequestStatus& aStatus)
+ {
+ CDevToken* token = static_cast<CDevToken*>( &iToken );
+
+ CDevTokenType* tokenType = static_cast<CDevTokenType*>( &(token->TokenType()) );
+
+ if ( tokenType->iUid.iUid == DEVCERTSTORE_IMPLEMENTATION_UID )
+ {
+ if (aCertificateOwnerType != EUserCertificate)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, KErrArgument );
+ return;
+ }
+ }
+ else if ( tokenType->iUid.iUid == TRUSRVCERTSTORE_IMPLEMENTATION_UID )
+ {
+ if (aCertificateOwnerType != EPeerCertificate)
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, KErrArgument );
+ return;
+ }
+ }
+ else
+ {
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, KErrArgument );
+ return;
+ }
+
+
+ TRequestStatus* stat = &aStatus;
+ if (aLabel.Length() > KMaxCertLabelLength)
+ {
+ // Too long to be a label
+ User::RequestComplete(stat, KErrOverflow);
+ return;
+ }
+
+ TPckgBuf<TDevTokenAddCertDataStruct> data;
+ data().iLabel.Zero();
+ data().iSubjectKeyId.Zero();
+ data().iIssuerKeyId.Zero();
+ data().iLabel.Copy(aLabel);
+ data().iFormat = aFormat;
+ data().iCertificateOwnerType = aCertificateOwnerType;
+ if (aSubjectKeyId)
+ {
+ data().iSubjectKeyId.Copy(*aSubjectKeyId);
+ }
+ if (aIssuerKeyId)
+ {
+ data().iIssuerKeyId.Copy(*aIssuerKeyId);
+ }
+ data().iDeletable = aDeletable;
+
+ TInt r = AllocRequestBuffer(aCert.Size());
+
+ if (r!=KErrNone)
+ {
+ User::RequestComplete(stat, r);
+ return;
+ }
+
+ iRequestPtr.FillZ();
+ iRequestPtr.Copy(aCert);
+
+ TIpcArgs args(0, &data, 0, &iRequestPtr);
+ r = iClientSession.SendRequest(EAddCert, args);
+
+ FreeRequestBuffer();
+ User::RequestComplete(stat, r);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelAdd()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelAdd()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::Remove()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::Remove(const CCTCertInfo& aCertInfo, TRequestStatus& aStatus)
+ {
+ TIpcArgs args(aCertInfo.Handle().iObjectId);
+ TInt r = iClientSession.SendRequest(ERemoveCert, args);
+ TRequestStatus* stat = &aStatus;
+ User::RequestComplete(stat, r);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelRemove()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelRemove()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::SetApplicability()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::SetApplicability(const CCTCertInfo& aCertInfo,
+ const RArray<TUid>& aApplications,
+ TRequestStatus &aStatus)
+ {
+ TInt r = AllocRequestBuffer(DevTokenDataMarshaller::Size(aApplications));
+ if (r != KErrNone)
+ {
+ TRequestStatus* stat = &aStatus;
+ User::RequestComplete(stat, r);
+ return;
+ }
+ DevTokenDataMarshaller::Write(aApplications, iRequestPtr);
+
+ TIpcArgs args(aCertInfo.Handle().iObjectId, 0, &iRequestPtr);
+ TInt err = iClientSession.SendRequest(ESetApplicability, args);
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, err);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelSetApplicability()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelSetApplicability()
+ {
+ // synchronous, nothing to do
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::SetTrust()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::SetTrust(const CCTCertInfo& aCertInfo,
+ TBool aTrusted,
+ TRequestStatus& aStatus)
+ {
+ TIpcArgs args(aCertInfo.Handle().iObjectId, 0, aTrusted);
+ TInt err = iClientSession.SendRequest(ESetTrust, args);
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete(status, err);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CDevandTruSrvCertStore::CancelSetTrust()
+// -----------------------------------------------------------------------------
+//
+void CDevandTruSrvCertStore::CancelSetTrust()
+ {
+ // synchronous, nothing to do
+ }
+
+//EOF
+