--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/pkiservice/src/pkisession.cpp Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,416 @@
+/*
+* Copyright (c) 2006-2008 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:
+* A server side session object. Owns instances of the CPKIService
+* and CPKIWrapper classes. All requests to the service objects go
+* through this object.
+*
+*/
+
+
+
+#include "pkisession.h"
+#include "pkiservice.h"
+#include "PKIMapper.h"
+#include "pkiwrapper.h"
+#include "certificaterequeststore.h"
+#include "keyoperationqueue.h"
+#include "pkiserviceconstants.h"
+
+#include "log_r6.h"
+#include "pkiserviceassert.h"
+
+static const TInt KBufferSizeNotDefined = -1;
+
+CPKISession* CPKISession::NewL(CPKIService& aServer,
+ CPKIMapper& aMapper,
+ CKeyOperationQueue& aKeyOperationQueue)
+ {
+ CPKISession* self;
+ self = new (ELeave) CPKISession(aServer, aMapper, aKeyOperationQueue);
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+
+CPKISession::CPKISession(CPKIService& aServer, CPKIMapper& aMapper, CKeyOperationQueue& aKeyOperationQueue)
+:iServer(aServer), iMapper(aMapper),
+ iKeyOperationQueue(aKeyOperationQueue), iRequiredBufferSize(KBufferSizeNotDefined)
+ {
+ }
+
+
+void CPKISession::ConstructL()
+{
+ LOG_("-> CPKISession::ConstructL()");
+ iWrapper = CPKIWrapper::NewL(iMapper);
+ LOG_("<- CPKISession::ConstructL()");
+}
+
+/**---------------------------------------------------------
+ *
+ * ~CPKISession(void)
+ *
+ *----------------------------------------------------------*/
+CPKISession::~CPKISession(void)
+ {
+ LOG_("-> CPKISession::~CPKISession()");
+
+ delete iKeyList;
+ delete iWrapper;
+ iUidArray.Close();
+
+ iServer.SessionDeleted();
+ LOG_("<- CPKISession::~CPKISession()");
+ }
+
+
+/**---------------------------------------------------------
+ *
+ * ServiceL(const RMessage& aMessage)
+ *
+ *----------------------------------------------------------*/
+void CPKISession::ServiceL(const RMessage2& aMessage)
+ {
+ TInt Status = KErrNone;
+ TInt count = 0;
+
+ LOG_1("CPKISession::ServiceL: function = %d", aMessage.Function());
+
+ switch(aMessage.Function())
+ {
+ case PkiService::ECancelPendingOperation:
+ iWrapper->CancelPendingOperation();
+ aMessage.Complete(Status);
+ break;
+
+ case PkiService::EGetRequiredBufferSize:
+ if (iRequiredBufferSize == KBufferSizeNotDefined)
+ {
+ Status = iWrapper->GetRequiredBufferSizeL(aMessage);
+ }
+ else
+ {
+ TPckg<TInt> pckgSize(iRequiredBufferSize);
+ aMessage.WriteL(0, pckgSize);
+ aMessage.Complete(KErrNone);
+ }
+ break;
+
+ case PkiService::ECertCount:
+ count = iMapper.CertCount();
+ aMessage.Complete(count); // Status <==> count
+ break;
+
+ case PkiService::EApplicableCertCount:
+ {
+ TInt aC = 0;
+ TPckg<TInt> pckgApplCount(aC);
+ aMessage.ReadL(0, pckgApplCount);
+
+ // Read applications
+ // Allocate list for applications
+ CBufFlat* list = CBufFlat::NewL(sizeof(TUid));
+ CleanupStack::PushL(list);
+ list->ResizeL(aC * sizeof(TUid));
+ TPtr8 ptrList = list->Ptr(0);
+ aMessage.ReadL(1, ptrList);
+ iUidArray.Close();
+ if(aC > 0)
+ {
+ TUid tempUid;
+ for (TInt i = 0; i < aC; i++)
+ {
+ list->Read(i * sizeof(TUid), (TAny*)&tempUid, sizeof(TUid));
+ iUidArray.Append(tempUid);
+ }
+ }
+ CleanupStack::PopAndDestroy(1); // list
+
+ TInt matchCount = iMapper.ApplicableCertCount(iUidArray);
+ aMessage.Complete(matchCount); // Status <==> count
+ }
+ break;
+ case PkiService::EGetCertDetails:
+ Status = iMapper.GetCertListL(aMessage, iWrapper->CertStoreType(), ETrue);
+ aMessage.Complete(Status);
+ break;
+ case PkiService::EGetCertList:
+ iMapper.GetCertListL(aMessage, iWrapper->CertStoreType());
+ aMessage.Complete(KErrNone);
+ break;
+
+ case PkiService::EGetApplicableCertList:
+ iMapper.GetApplicableCertListL(aMessage, iUidArray);
+ aMessage.Complete(KErrNone);
+ break;
+
+ case PkiService::EGetKeyList:
+ {
+ PKISERVICE_ASSERT(iKeyList != NULL);
+
+ CBufFlat* list = CBufFlat::NewL(sizeof(TKeyListEntry));
+ CleanupStack::PushL(list);
+ list->ResizeL(iKeyList->Count() * sizeof(TKeyListEntry));
+
+ for(TInt i = 0; i < iKeyList->Count(); i++)
+ {
+ const TKeyListEntry& keyInfo = (*iKeyList)[i];
+ list->Write(i * sizeof(TKeyListEntry),
+ (TAny*)&keyInfo,
+ sizeof(TKeyListEntry));
+ }
+ TPtr8 ptrList = list->Ptr(0);
+ aMessage.WriteL(0, ptrList);
+ CleanupStack::PopAndDestroy(list); // list
+
+ delete iKeyList;
+ iKeyList = NULL;
+ aMessage.Complete(KErrNone);
+ }
+ break;
+
+ case PkiService::ECertReqCount:
+ count = iServer.CertificateRequestStore().CertReqCountL();
+ aMessage.Complete(count); // Status <==> count
+ break;
+
+ case PkiService::EGetCertReqList:
+ {
+ CArrayFixFlat<TCertificateRequestListEntry>* certReqList =
+ iServer.CertificateRequestStore().GetCertReqListLC();
+
+ TUint bufferGranularity = sizeof(TCertificateRequestListEntry);
+ if (certReqList->Count() > 0)
+ {
+ bufferGranularity = bufferGranularity * certReqList->Count();
+ }
+ CBufFlat* list = CBufFlat::NewL(bufferGranularity);
+ CleanupStack::PushL(list);
+
+ if (certReqList->Count() > 0)
+ {
+ list->ResizeL(sizeof(TCertificateRequestListEntry) * certReqList->Count());
+ }
+
+ for (TInt i = 0; i < certReqList->Count(); ++i)
+ {
+ const TCertificateRequestListEntry &certReqInfo = (*certReqList)[i];
+ list->Write(i * sizeof(TCertificateRequestListEntry),
+ &certReqInfo,
+ sizeof(TCertificateRequestListEntry));
+
+ }
+ TPtr8 ptrList = list->Ptr(0);
+ aMessage.WriteL(0, ptrList);
+
+ CleanupStack::PopAndDestroy(list);
+ CleanupStack::PopAndDestroy(certReqList);
+
+ aMessage.Complete(KErrNone);
+ }
+ break;
+
+ case PkiService::ESaveCertificateRequest:
+ {
+ TInt requestSize = aMessage.GetDesLength(0);
+ HBufC8* request = HBufC8::NewLC(requestSize);
+ TPtr8 requestPtr = request->Des();
+
+ TKeyIdentifier keyId;
+
+ aMessage.ReadL(0, requestPtr);
+ aMessage.ReadL(2, keyId); //keyId is ignored.
+
+ HBufC* certRequestRef =
+ iServer.CertificateRequestStore().SaveCertRequestLC(*request);
+
+ aMessage.WriteL(1, *certRequestRef);
+
+ CleanupStack::PopAndDestroy(certRequestRef);
+ CleanupStack::PopAndDestroy(request);
+
+ aMessage.Complete(KErrNone);
+ }
+ break;
+
+ case PkiService::EReadCertificateRequest:
+ {
+ TInt certRequestRefSize = aMessage.GetDesLength(0);
+ HBufC *certRequestRef = HBufC::NewLC(certRequestRefSize);
+ TPtr certRequestRefPtr = certRequestRef->Des();
+
+ aMessage.ReadL(0, certRequestRefPtr);
+
+ if (certRequestRef->Length() == 0)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ HBufC8* certificateRequest =
+ iServer.CertificateRequestStore().ReadCertRequestLC(*certRequestRef);
+
+ if (aMessage.GetDesMaxLength(1) >= certificateRequest->Length())
+ {
+ aMessage.WriteL(1, *certificateRequest);
+ aMessage.Complete(KErrNone);
+ }
+ else
+ {
+ iRequiredBufferSize = certificateRequest->Length();
+ aMessage.Complete(KPKIErrBufferTooShort);
+ }
+
+ CleanupStack::PopAndDestroy(certificateRequest);
+ CleanupStack::PopAndDestroy(certRequestRef);
+
+ }
+ break;
+
+ case PkiService::EDeleteCertificateRequest:
+ {
+ TInt certRequestRefSize = aMessage.GetDesLength(0);
+ HBufC *certRequestRef = HBufC::NewLC(certRequestRefSize);
+ TPtr certRequestRefPtr = certRequestRef->Des();
+
+ aMessage.ReadL(0, certRequestRefPtr);
+
+ iServer.CertificateRequestStore().DeleteCertRequestL(*certRequestRef);
+
+ CleanupStack::PopAndDestroy(certRequestRef);
+ aMessage.Complete(KErrNone);
+ }
+ break;
+ case PkiService::ESetCertStoreType:
+ iWrapper->SetCertStoreType(static_cast<TPkiServiceStoreType>(aMessage.Int0()));
+ aMessage.Complete(KErrNone);
+ break;
+
+ case PkiService::ESetKeyStoreType:
+ SetKeyStoreL(static_cast<TPkiServiceStoreType>(aMessage.Int0()));
+ aMessage.Complete(KErrNone);
+ break;
+
+ case PkiService::ESetStoreType:
+ iWrapper->SetCertStoreType(static_cast<TPkiServiceStoreType>(aMessage.Int0()));
+ SetKeyStoreL(static_cast<TPkiServiceStoreType>(aMessage.Int1()));
+ aMessage.Complete(KErrNone);
+ break;
+
+ case PkiService::EGetCertStoreType:
+ {
+ Status = iWrapper->CertStoreType();
+ aMessage.Complete(Status);
+ break;
+ }
+
+ case PkiService::EGetKeyStoreType:
+ {
+ Status = KeyStore();
+ aMessage.Complete(Status);
+ break;
+ }
+
+ case PkiService::ESetInformational:
+ {
+ iWrapper->SetInformational(aMessage.Int0());
+ aMessage.Complete(KErrNone);
+ }
+ break;
+
+ case PkiService::EInitialize://falls through
+ case PkiService::EKeyCount: //falls through
+ case PkiService::EGetKeyDetails: //falls through
+ case PkiService::EDecrypt: //falls through
+ case PkiService::ESignWithKeyId: //falls through
+ case PkiService::ESignWithCert: //falls through
+ case PkiService::EReadPublicKey: //falls through
+ case PkiService::ELogon: //falls through
+ case PkiService::ELogoff: //falls through
+ case PkiService::EChangePassword: //falls through
+ case PkiService::ERemoveKeypair: //falls through
+ case PkiService::EGenerateKeypair: //falls through
+ case PkiService::EStoreKeypair: //falls through
+ iKeyOperationQueue.AddOperationL(*this, aMessage,
+ iUsedKeyStore, iWrapper->CertStoreType());
+ break;
+ default:
+ iRequiredBufferSize = KBufferSizeNotDefined;
+ Status = iWrapper->InitOperation(aMessage);
+ break;
+ }
+ }
+
+
+void CPKISession::SetKeyStoreL(TPkiServiceStoreType aStoreType)
+ {
+ switch(aStoreType)
+ {
+ case EPkiStoreTypeAny:
+ iUsedKeyStore = STORETYPE_ANY_KEY_ID;
+ break;
+ case EPkiStoreTypeUser:
+ iUsedKeyStore = STORETYPE_USER_KEY_ID;
+ break;
+ case EPkiStoreTypeDevice:
+ iUsedKeyStore = STORETYPE_DEVICE_KEY_ID;
+ break;
+ default:
+ User::Leave(KPKIErrNotSupported);
+ break;
+ }
+ }
+
+
+TPkiServiceStoreType CPKISession::KeyStore() const
+ {
+
+ TPkiServiceStoreType usedStore = EPkiStoreTypeAny;
+ switch(iUsedKeyStore)
+ {
+ case STORETYPE_USER_KEY_ID:
+ usedStore = EPkiStoreTypeUser;
+ break;
+ case STORETYPE_DEVICE_KEY_ID:
+ usedStore = EPkiStoreTypeDevice;
+ break;
+ case STORETYPE_ANY_KEY_ID:
+ usedStore = EPkiStoreTypeAny;
+ break;
+ default:
+ PKISERVICE_ASSERT(iUsedKeyStore == 0);
+ break;
+ }
+ return usedStore;
+ }
+
+
+void CPKISession::SetRequiredBufferSize(TInt aSize)
+ {
+ iRequiredBufferSize = aSize;
+ }
+
+
+void CPKISession::SetKeyList(CArrayFixFlat<TKeyListEntry> *aKeyList)
+ {
+ iKeyList = aKeyList;
+ }
+
+
+void CPKISession::InitializeWrapperL(const RMessage2& aMessage)
+ {
+ iWrapper->InitializeL(aMessage);
+ }