--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/dmadpki/src/DmAdRtNodeData.cpp Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,1596 @@
+/*
+* Copyright (c) 2000-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: Implementation of CDmAdRtNodeData
+*
+*/
+
+
+
+#include <utf.h>
+
+#include <x509cert.h>
+#include <x509keys.h>
+#include <x500dn.h>
+#include <x509certext.h>
+
+#include "DmAdRtNodeData.h"
+#include "dmadddf.h"
+#include "dmadutil.h"
+#include "vpnlogger.h"
+#include "dmadstoreprivkey.h"
+#include "pkidefs.h"
+#include "XwImpl.h"
+#include "dmadcertxmldefs.h"
+#include "XppImpl.h"
+#include <vpnlogmessages.rsg>
+
+
+// Macro to encode key usage bits
+// See method CDmAdCertData::KeyUsageLC
+#define ENC_BIT(a) \
+ if( EFalse == keyUsageExt->IsSet(a) ) \
+ { \
+ keyUsagePtr.Append('0'); \
+ } \
+ else \
+ { \
+ keyUsagePtr.Append('1'); \
+ }
+
+
+CDmAdRtNodeData* CDmAdRtNodeData::NewL(const TDesC8& aUri, MDmAdCallBack* aCallBack)
+ {
+ TRACE("CDmAdRtNodeData::NewL");
+
+ CDmAdRtNodeData *self = new (ELeave) CDmAdRtNodeData();
+ CleanupStack::PushL(self);
+ self->ConstructL(aUri, aCallBack);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CDmAdRtNodeData::ConstructL(const TDesC8& aUri, MDmAdCallBack* aCallBack)
+ {
+ TRACE("CDmAdRtNodeData::ConstructL");
+
+ iUriType = UriTypeL(aUri);
+
+ switch (iUriType)
+ {
+ case EDmAdUriTypeCert:
+ u.iCert = CDmAdCertData::NewL(aCallBack);
+ break;
+ case EDmAdUriTypeCertReq:
+ u.iCertReq = CDmAdCertReqData::NewL(aCallBack);
+ break;
+ case EDmAdUriTypePrivKey:
+ u.iPrivKey = CDmAdPrivKeyData::NewL();
+ break;
+ case EDmAdUriTypePKCS12:
+ u.iPKCS12 = CDmAdPKCS12Data::NewL();
+ break;
+ default:
+ DEBUG_LOG(_L("Unknown URI type"));
+ User::Leave(KErrGeneral);
+ break;
+ }
+ }
+
+CDmAdRtNodeData::CDmAdRtNodeData()
+ {
+ }
+
+CDmAdRtNodeData::~CDmAdRtNodeData()
+ {
+ TRACE("CDmAdRtNodeData::~CDmAdRtNodeData");
+
+ switch (iUriType)
+ {
+ case EDmAdUriTypeCert:
+ delete u.iCert;
+ break;
+ case EDmAdUriTypeCertReq:
+ delete u.iCertReq;
+ break;
+ case EDmAdUriTypePrivKey:
+ delete u.iPrivKey;
+ break;
+ case EDmAdUriTypePKCS12:
+ delete u.iPKCS12;
+ break;
+ default:
+ DEBUG_LOG(_L("Unknown URI type"));
+ break;
+ }
+ }
+
+//--------------------------------------------------------------------------
+
+TDmAdUriType CDmAdRtNodeData::UriType() const
+ {
+ TRACE("CDmAdRtNodeData::UriType");
+
+ return iUriType;
+ }
+
+TDmAdUriType CDmAdRtNodeData::UriTypeL(const TDesC8& aUri)
+ {
+ TRACE("CDmAdRtNodeData::UriTypeL");
+
+ TDmAdUriType ret = EDmAdUriTypeCert;
+ CArrayFix<TPtrC8>* uriSegList;
+ TDmAdUtil::ParseUriLC(aUri, uriSegList);
+
+ if (uriSegList->Count() < 2)
+ {
+ DEBUG_LOG(_L("uriSegList->Count() is less than 2"));
+ User::Leave(KErrGeneral);
+ }
+
+ if (uriSegList->At(0).Compare(KDmAdNodeNokiaPki) == 0)
+ {
+ if (uriSegList->At(1).Compare(KDmAdNodeCert) == 0)
+ {
+ ret = EDmAdUriTypeCert;
+ }
+ else if (uriSegList->At(1).Compare(KDmAdNodeCertReq) == 0)
+ {
+ ret = EDmAdUriTypeCertReq;
+ }
+ else if (uriSegList->At(1).Compare(KDmAdNodePrivKey) == 0)
+ {
+ ret = EDmAdUriTypePrivKey;
+ }
+ else if (uriSegList->At(1).Compare(KDmAdNodePKCS12) == 0)
+ {
+ ret = EDmAdUriTypePKCS12;
+ }
+ else
+ {
+ DEBUG_LOG(_L("Unknown URI type"));
+ User::Leave(KErrGeneral);
+ }
+ }
+ else
+ {
+ DEBUG_LOG(_L("Unknown URI type"));
+ User::Leave(KErrGeneral);
+ }
+
+ CleanupStack::PopAndDestroy(uriSegList);
+ return ret;
+ }
+
+//--------------------------------------------------------------------------
+
+void CDmAdRtNodeData::UpdateLeafDataL(const TDesC8& aUri, const TDesC8& aObject)
+ {
+ TRACE("CDmAdRtNodeData::UpdateLeafDataL");
+
+ switch (iUriType)
+ {
+ case EDmAdUriTypeCert:
+ TRAPD(err, UpdateLeafDataCertL(aUri, aObject));
+ if(err != KErrNone)
+ User::Leave(err);
+ break;
+ case EDmAdUriTypeCertReq:
+ UpdateLeafDataCertReqL(aUri, aObject);
+ break;
+ case EDmAdUriTypePrivKey:
+ UpdateLeafDataPrivKeyL(aUri, aObject);
+ break;
+ case EDmAdUriTypePKCS12:
+ UpdateLeafDataPKCS12L(aUri, aObject);
+ break;
+ default:
+ DEBUG_LOG(_L("Unknown URI type"));
+ User::Leave(KErrGeneral);
+ break;
+ }
+ }
+
+void CDmAdRtNodeData::UpdateLeafDataCertL(const TDesC8& aUri, const TDesC8& aObject)
+ {
+ TRACE("CDmAdRtNodeData::UpdateLeafDataCertL");
+
+ TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);
+ if (lastSeg.Compare(KDmAdLeafContent) == 0)
+ {
+ u.iCert->SetContentL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafType) == 0)
+ {
+ u.iCert->SetTypeL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafFormat) == 0)
+ {
+ u.iCert->SetFormatL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)
+ {
+ u.iCert->SetDeletableL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafTrusted) == 0)
+ {
+ u.iCert->SetTrustedL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)
+ {
+ RArray<TUid> applicability;
+ CleanupClosePushL(applicability);
+
+ ParseApplicabilityL(aObject, applicability);
+ u.iCert->SetApplicabilityL(applicability);
+
+ CleanupStack::PopAndDestroy(); //applicability
+ }
+ else
+ {
+ DEBUG_LOG(_L("No match found"));
+ User::Leave(KErrNotFound);
+ }
+ }
+
+void CDmAdRtNodeData::UpdateLeafDataCertReqL(const TDesC8& aUri, const TDesC8& aObject)
+ {
+ TRACE("CDmAdRtNodeData::UpdateLeafDataCertReqL");
+
+ TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);
+ if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)
+ {
+ u.iCertReq->SetSubjectNameL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafRfc822Name) == 0)
+ {
+ u.iCertReq->SetRfc822NameL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)
+ {
+ u.iCertReq->SetKeyUriL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)
+ {
+ u.iCertReq->SetKeyLength(aObject);
+ }
+ else
+ {
+ DEBUG_LOG(_L("No match found"));
+ User::Leave(KErrNotFound);
+ }
+ }
+
+void CDmAdRtNodeData::UpdateLeafDataPrivKeyL(const TDesC8& aUri, const TDesC8& aObject)
+ {
+ TRACE("CDmAdRtNodeData::UpdateLeafDataPrivKeyL");
+
+ TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);
+ if (lastSeg.Compare(KDmAdLeafKeyType) == 0)
+ {
+ u.iPrivKey->SetKeyTypeL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)
+ {
+ u.iPrivKey->SetKeyLength(aObject);
+ }
+ else
+ {
+ DEBUG_LOG(_L("No match found"));
+ User::Leave(KErrNotFound);
+ }
+ }
+
+void CDmAdRtNodeData::UpdateLeafDataPKCS12L(const TDesC8& aUri, const TDesC8& aObject)
+ {
+ TRACE("CDmAdRtNodeData::UpdateLeafDataPKCS12L");
+
+ TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);
+ if (lastSeg.Compare(KDmAdLeafContent) == 0)
+ {
+ u.iPKCS12->SetContentL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)
+ {
+ u.iPKCS12->SetDeletableL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafPKCS12Password) == 0)
+ {
+ u.iPKCS12->SetPasswordL(aObject);
+ }
+ else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)
+ {
+ RArray<TUid> applicability;
+ CleanupClosePushL(applicability);
+
+ ParseApplicabilityL(aObject, applicability);
+ u.iPKCS12->SetApplicabilityL(applicability);
+
+ CleanupStack::PopAndDestroy(); //applicability
+ }
+ else
+ {
+ DEBUG_LOG(_L("No match found"));
+ User::Leave(KErrNotFound);
+ }
+
+ }
+
+void CDmAdRtNodeData::FetchLeafObjectLC(const TDesC8& aUri, const TDesC8& aLuid, CBufBase*& aObject)
+ {
+ switch (iUriType)
+ {
+ case EDmAdUriTypeCert:
+ FetchLeafObjectCertLC(aUri, aLuid, aObject);
+ break;
+ case EDmAdUriTypeCertReq:
+ FetchLeafObjectCertReqLC(aUri, aLuid, aObject);
+ break;
+ case EDmAdUriTypePrivKey:
+ FetchLeafObjectPrivKeyLC(aUri, aLuid, aObject);
+ break;
+ case EDmAdUriTypePKCS12:
+ // PKCS#12 special case
+ break;
+ default:
+ DEBUG_LOG(_L("Unknown URI type"));
+ User::Leave(KErrGeneral);
+ break;
+ }
+ }
+
+void CDmAdRtNodeData::FetchLeafObjectCertLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, CBufBase*& aObject)
+ {
+ CBufBase* object = CBufFlat::NewL(32);
+ CleanupStack::PushL(object);
+
+ TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);
+ if (lastSeg.Compare(KDmAdLeafType) == 0)
+ {
+ HBufC8* obj = u.iCert->TypeLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafFormat) == 0)
+ {
+ HBufC8* obj = u.iCert->FormatLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)
+ {
+ HBufC8* obj = u.iCert->DeletableLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafTrusted) == 0)
+ {
+ HBufC8* obj = u.iCert->TrustedLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)
+ {
+
+ DEBUG_LOG(_L("Fetching applicability"));
+ const RArray<TUid>& applicability = u.iCert->Applicability();
+
+ CXmlWriter* writer = CXmlWriter::NewL();
+ CleanupStack::PushL(static_cast<CBase*>(writer));
+ writer->AddStartTagL(KXmlElemCertApps);
+
+ DEBUG_LOG(_L("KXmlElemCertApps Start tag added"));
+
+ for (TInt i = 0; i < applicability.Count(); ++i)
+ {
+ HBufC8* idInt = TDmAdUtil::IntToDes8LC((TInt)applicability[i].iUid);
+ writer->OpenStartTagL(KXmlElemApp);
+ writer->AddAttributeL(KXmlAttrId, *idInt);
+ writer->CloseStartTagL(ETrue);
+ CleanupStack::PopAndDestroy(idInt);
+ }
+ writer->AddEndTagL(KXmlElemCertApps);
+
+ DEBUG_LOG(_L("KXmlElemCertApps end tag added"));
+
+ TPtrC8 docDataPtr(writer->DocPart(0, writer->Length()-1));
+ object->InsertL(0, docDataPtr);
+
+ DEBUG_LOG(_L("document inserted"));
+
+ CleanupStack::PopAndDestroy(static_cast<CBase*>(writer));
+
+ DEBUG_LOG(_L("writer popped"));
+ }
+ else if (lastSeg.Compare(KDmAdLeafContent) == 0)
+ {
+ TPtrC8 obj(u.iCert->Content());
+ object->InsertL(0, obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafSerialNumber) == 0)
+ {
+ HBufC8* obj = u.iCert->SerialNumberLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafIssuerName) == 0)
+ {
+ HBufC8* obj = u.iCert->IssuerNameLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafFingerprintAlg) == 0)
+ {
+ HBufC8* obj = u.iCert->FingerprintAlgLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafFingerprintValue) == 0)
+ {
+ HBufC8* obj = u.iCert->FingerprintValueLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafValidityBegin) == 0)
+ {
+ HBufC8* obj = u.iCert->ValidityBeginLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafValidityEnd) == 0)
+ {
+ HBufC8* obj = u.iCert->ValidityEndLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)
+ {
+ HBufC8* obj = u.iCert->SubjectNameLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafSubjectAltName) == 0)
+ {
+ HBufC8* obj = u.iCert->SubjectAltNameLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)
+ {
+ HBufC8* obj = u.iCert->KeyUriLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyId) == 0)
+ {
+ HBufC8* obj = u.iCert->KeyIdLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyUsage) == 0)
+ {
+ HBufC8* obj = u.iCert->KeyUsageLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else
+ {
+ DEBUG_LOG(_L("No match found"));
+ User::Leave(KErrNotFound);
+ }
+
+ aObject = object;
+ }
+
+void CDmAdRtNodeData::FetchLeafObjectCertReqLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, CBufBase*& aObject)
+ {
+ CBufBase* object = CBufFlat::NewL(32);
+ CleanupStack::PushL(object);
+
+ TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);
+ if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)
+ {
+ TPtrC8 obj(u.iCertReq->SubjectName());
+ object->InsertL(0, obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafRfc822Name) == 0)
+ {
+ TPtrC8 obj(u.iCertReq->Rfc822Name());
+ object->InsertL(0, obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)
+ {
+ HBufC8* obj = u.iCertReq->KeyUriL();
+ CleanupStack::PushL(obj);
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(obj);
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)
+ {
+ HBufC8* obj = u.iCertReq->KeyLengthLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(); //obj
+ }
+ else if (lastSeg.Compare(KDmAdLeafContent) == 0)
+ {
+ TPtrC8 obj(u.iCertReq->Content());
+ object->InsertL(0, obj);
+ }
+ else
+ {
+ DEBUG_LOG(_L("No match found"));
+ User::Leave(KErrNotFound);
+ }
+
+ aObject = object;
+ }
+
+void CDmAdRtNodeData::FetchLeafObjectPrivKeyLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, CBufBase*& aObject)
+ {
+ CBufBase* object = CBufFlat::NewL(32);
+ CleanupStack::PushL(object);
+
+ TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);
+ if (lastSeg.Compare(KDmAdLeafKeyType) == 0)
+ {
+ HBufC8* obj = u.iPrivKey->KeyTypeLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(); //obj
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)
+ {
+ HBufC8* obj = u.iPrivKey->KeyLengthLC();
+ object->InsertL(0, *obj);
+ CleanupStack::PopAndDestroy(); //obj
+ }
+ else if (lastSeg.Compare(KDmAdLeafKeyId) == 0)
+ {
+ TPtrC8 obj(u.iPrivKey->KeyId());
+ object->InsertL(0, obj);
+ }
+ else
+ {
+ DEBUG_LOG(_L("No match found"));
+ User::Leave(KErrNotFound);
+ }
+
+ aObject = object;
+ }
+
+void CDmAdRtNodeData::SetDefaultSettingsL(const TDesC8& /*aUri*/)
+ {
+ TRACE("CDmAdRtNodeData::SetDefaultSettingsL");
+
+ switch (iUriType)
+ {
+ case EDmAdUriTypeCert:
+ u.iCert->SetDefaultSettings();
+ break;
+ case EDmAdUriTypeCertReq:
+ u.iCertReq->SetDefaultSettings();
+ break;
+ case EDmAdUriTypePrivKey:
+ u.iPrivKey->SetDefaultSettingsL();
+ break;
+ case EDmAdUriTypePKCS12:
+ u.iPKCS12->SetDefaultSettings();
+ break;
+ default:
+ DEBUG_LOG(_L("Unknown URI type"));
+ User::Leave(KErrGeneral);
+ break;
+ }
+ }
+
+
+void CDmAdRtNodeData::ParseApplicabilityL(const TDesC8& aApplicabilityData,
+ RArray<TUid>& aApplicabilityList) const
+ {
+ TRACE("CDmAdRtNodeData::ParseApplicabilityL");
+
+ aApplicabilityList.Reset();
+
+ if (aApplicabilityData.Length() == 0)
+ {
+ return;
+ }
+
+ CDesC8ArrayFlat* parserValueArray = new (ELeave) CDesC8ArrayFlat(10);
+ CleanupStack::PushL(parserValueArray);
+ CXmlPullParser* parser = CXmlPullParser::NewLC(*parserValueArray);
+ TPtrC8 name;
+ TPtrC8 attribute;
+
+ parser->SetInput(aApplicabilityData);
+ parser->NextL();
+ parser->Name(name);
+
+ if (parser->State() != CXmlPullParser::EStateStartTag || name != KXmlElemCertApps)
+ {
+ DEBUG_LOG(_L("Wrong state or name. (Expected EStateStartTag and CertApps"));
+ DEBUG_LOG2(_L8("State = %d, name = %S"), parser->State(), &name);
+ User::Leave(KErrCorrupt);
+ }
+
+ parser->NextL();
+ while (parser->State() == CXmlPullParser::EStateText)
+ {
+ DEBUG_LOG(_L8("Found text. Ignoring it..."));
+ parser->NextL();
+ }
+
+ while (parser->State() == CXmlPullParser::EStateStartTag)
+ {
+ parser->Name(name);
+ DEBUG_LOG1(_L8("Parsed: %S"), &name);
+
+ if (name != KXmlElemApp)
+ {
+ DEBUG_LOG1(_L8("Invalid name: %S"), &name);
+ User::Leave(KErrCorrupt);
+ }
+
+ parser->AttributeValueL(KXmlAttrId, attribute);
+ TUid uid = { TDmAdUtil::DesToInt(attribute) };
+ DEBUG_LOG1(_L("Uid: 0x%x"), uid.iUid);
+
+ aApplicabilityList.Append(uid);
+ parser->NextL();
+
+ while (parser->State() == CXmlPullParser::EStateText)
+ {
+ DEBUG_LOG(_L8("Found text. Ignoring it..."));
+ parser->NextL();
+ }
+ }
+ parser->Name(name);
+
+ if (parser->State() != CXmlPullParser::EStateEndTag || name != KXmlElemCertApps)
+ {
+ DEBUG_LOG(_L("Wrong state or name. (Expected EStateEndTag and CertApps)"));
+ DEBUG_LOG2(_L8("State = %d, name = %S"), parser->State(), &name);
+ User::Leave(KErrCorrupt);
+ }
+ CleanupStack::PopAndDestroy(2); //parser, parserValueArray
+ }
+
+
+//======================================================================================
+//======================================================================================
+
+CDmAdCertData* CDmAdCertData::NewL(MDmAdCallBack* aCallBack)
+ {
+ TRACE("CDmAdCertData::NewL");
+
+ CDmAdCertData* self = new (ELeave) CDmAdCertData(aCallBack);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CDmAdCertData::ConstructL()
+ {
+ TRACE("CDmAdCertData::ConstructL");
+
+ iCertParms = CDmAdCertParms::NewL();
+ }
+
+CDmAdCertData::CDmAdCertData(MDmAdCallBack* aCallBack) : iCallBack(aCallBack)
+ {
+ }
+
+CDmAdCertData::~CDmAdCertData()
+ {
+ TRACE("CDmAdCertData::~CDmAdCertData");
+
+ delete iCertParms;
+ delete iCertCx509;
+ }
+
+void CDmAdCertData::SetDefaultSettings()
+ {
+ TRACE("CDmAdCertData::SetDefaultSettings");
+
+ iCertParms->SetDeletable(ETrue);
+ iCertParms->SetTrusted(ETrue);
+ }
+
+//--------------------------------------------------------------------------
+
+void CDmAdCertData::SetTypeL(const TDesC8& aType)
+ {
+ TRACE("CDmAdCertData::SetType");
+
+ TInt value = TDmAdUtil::DesToInt(aType);
+
+ TPKICertificateOwnerType type = EPKICACertificate;
+ switch(value)
+ {
+ case 1:
+ type = EPKICACertificate;
+ break;
+ case 2:
+ type = EPKIUserCertificate;
+ break;
+ case 3:
+ type = EPKIPeerCertificate;
+ break;
+ default:
+ User::Leave(KErrCorrupt);
+ break;
+ }
+
+ iCertParms->SetType(type);
+ }
+
+HBufC8* CDmAdCertData::TypeLC()
+ {
+
+ TPKICertificateOwnerType type = iCertParms->Type();
+ TInt omaDmType = 0;
+ switch(type)
+ {
+ case EPKICACertificate:
+ omaDmType = 1;
+ break;
+ case EPKIUserCertificate:
+ omaDmType = 2;
+ break;
+ case EPKIPeerCertificate:
+ omaDmType = 3;
+ break;
+ default:
+ User::Leave(KErrCorrupt);
+ break;
+ }
+
+ return TDmAdUtil::IntToDes8LC(omaDmType);
+ }
+
+void CDmAdCertData::SetFormatL(const TDesC8& aFormat)
+ {
+ TRACE("CDmAdCertData::SetFormat");
+ TInt value = TDmAdUtil::DesToInt(aFormat);
+
+ if (value != 1)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ }
+
+HBufC8* CDmAdCertData::FormatLC()
+ {
+ //The format is always 1, which means X509 cert.
+ return TDmAdUtil::IntToDes8LC(1);
+ }
+
+void CDmAdCertData::SetDeletableL(const TDesC8& aDeletable)
+ {
+ TRACE("CDmAdCertData::SetDeletableL");
+
+ if (aDeletable.Compare(KDmAdDfFormatBoolTrue) == 0)
+ {
+ iCertParms->SetDeletable(ETrue);
+ }
+ else if (aDeletable.Compare(KDmAdDfFormatBoolFalse) == 0)
+ {
+ iCertParms->SetDeletable(EFalse);
+ }
+ else
+ {
+ DEBUG_LOG(_L("Comparization failed"));
+ User::Leave(KErrGeneral);
+ }
+ }
+
+HBufC8* CDmAdCertData::DeletableLC()
+ {
+ if (iCertParms->Deletable())
+ {
+ return KDmAdDfFormatBoolTrue().AllocLC();
+ }
+ else
+ {
+ return KDmAdDfFormatBoolFalse().AllocLC();
+ }
+ }
+
+void CDmAdCertData::SetTrustedL(const TDesC8& aTrusted)
+ {
+ TRACE("CDmAdCertData::SetTrustedL");
+
+ if (aTrusted.Compare(KDmAdDfFormatBoolTrue) == 0)
+ {
+ iCertParms->SetTrusted(ETrue);
+ }
+ else if (aTrusted.Compare(KDmAdDfFormatBoolFalse) == 0)
+ {
+ iCertParms->SetTrusted(EFalse);
+ }
+ else
+ {
+ DEBUG_LOG(_L("No match found"));
+ User::Leave(KErrGeneral);
+ }
+ }
+
+HBufC8* CDmAdCertData::TrustedLC()
+ {
+ if (iCertParms->Trusted())
+ {
+ return KDmAdDfFormatBoolTrue().AllocLC();
+ }
+ else
+ {
+ return KDmAdDfFormatBoolFalse().AllocLC();
+ }
+ }
+
+void CDmAdCertData::SetApplicabilityL(const RArray<TUid>& aApplicability)
+ {
+ TRACE("CDmAdCertData::SetApplicabilityL");
+
+ iCertParms->SetApplicabilityL(aApplicability);
+ }
+
+const RArray<TUid>& CDmAdCertData::Applicability() const
+ {
+ TRACE("CDmAdCertData::Applicability");
+
+ return iCertParms->Applicability();
+ }
+
+void CDmAdCertData::SetContentL(const TDesC8& aContent)
+ {
+ TRACE("CDmAdCertData::SetContentL");
+
+ delete iCertCx509;
+ iCertCx509 = NULL;
+ iCertParms->SetContentL(aContent);
+ if (iCertParms->Content().Length() > 0)
+ {
+ iCertCx509 = CX509Certificate::NewL(iCertParms->Content());
+ }
+ }
+
+TPtrC8 CDmAdCertData::Content()
+ {
+ TRACE("CDmAdCertData::Content");
+
+ return iCertParms->Content();
+ }
+
+//-----------------
+
+HBufC8* CDmAdCertData::SerialNumberLC()
+ {
+ HBufC8* ret = NULL;
+ const TPtrC8 serialNumber(iCertCx509->SerialNumber());
+ //const TPtrC8 serialNumber(*(iCertCx509->DataElementEncoding(CX509Certificate::ESerialNumber)));
+ if (serialNumber.Length() == 0)
+ {
+ ret = HBufC8::NewLC(1);
+ }
+ else
+ {
+ ret = serialNumber.AllocLC();
+ }
+ return ret;
+ }
+
+HBufC8* CDmAdCertData::IssuerNameLC()
+ {
+ HBufC8* ret = NULL;
+ const TPtrC8 issuerName(*(iCertCx509->DataElementEncoding(CX509Certificate::EIssuerName)));
+ if (issuerName.Length() == 0)
+ {
+ ret = HBufC8::NewLC(1);
+ }
+ else
+ {
+ ret = issuerName.AllocLC();
+ }
+ return ret;
+ }
+
+HBufC8* CDmAdCertData::FingerprintAlgLC()
+ {
+ if (iCertCx509->Fingerprint().Length() == 16)
+ {
+ return TDmAdUtil::IntToDes8LC(1); // MD5
+ }
+ else
+ {
+ return TDmAdUtil::IntToDes8LC(2); // SHA1
+ }
+ }
+
+HBufC8* CDmAdCertData::FingerprintValueLC()
+ {
+ return iCertCx509->Fingerprint().AllocLC();
+ }
+
+HBufC8* CDmAdCertData::ValidityBeginLC()
+ {
+ TTime beginTime = iCertCx509->ValidityPeriod().Start();
+ return FormatCertValidityTimeLC(beginTime);
+ }
+
+HBufC8* CDmAdCertData::ValidityEndLC()
+ {
+ TTime endTime = iCertCx509->ValidityPeriod().Finish();
+ return FormatCertValidityTimeLC(endTime);
+ }
+
+HBufC8* CDmAdCertData::SubjectNameLC()
+ {
+ HBufC8* ret = NULL;
+ const TPtrC8 subjectName(*(iCertCx509->DataElementEncoding(CX509Certificate::ESubjectName)));
+ if (subjectName.Length() == 0)
+ {
+ ret = HBufC8::NewLC(1);
+ }
+ else
+ {
+ ret = subjectName.AllocLC();
+ }
+ return ret;
+ }
+
+HBufC8* CDmAdCertData::SubjectAltNameLC()
+ {
+ HBufC8* subjectAltNameExtRfc822 = HBufC8::NewLC(KMaxRfc822);
+ TPtr8 subjectAltNameExtRfc822Ptr(subjectAltNameExtRfc822->Des());
+
+ const CX509CertExtension* subjAltName;
+ subjAltName = iCertCx509->Extension(KSubjectAltName);
+ if (subjAltName)
+ {
+ CX509AltNameExt* subjectAlt = CX509AltNameExt::NewLC(subjAltName->Data());
+ if (subjectAlt)
+ {
+ const CArrayPtrFlat<CX509GeneralName>* nameArray;
+ nameArray = &subjectAlt->AltName();
+ // Search rfc822
+ for (TInt i = 0; i < nameArray->Count(); i++)
+ {
+ if(nameArray->At(i)->Tag() == EX509RFC822Name)
+ {
+ TPtrC8 data = nameArray->At(i)->Data();
+ subjectAltNameExtRfc822Ptr.Copy(data.Right(data.Length() - 2));
+ break;
+ }
+ }
+ CleanupStack::PopAndDestroy(subjectAlt);
+ }
+ }
+ return subjectAltNameExtRfc822;
+ }
+
+HBufC8* CDmAdCertData::KeyUriLC()
+ {
+ HBufC8* keyId = KeyIdLC();
+ HBufC8* keyUri = FindKeyUriLC(*keyId);
+ CleanupStack::Pop(keyUri);
+ CleanupStack::PopAndDestroy(keyId);
+ CleanupStack::PushL(keyUri);
+ return keyUri;
+ }
+
+HBufC8* CDmAdCertData::KeyIdLC()
+ {
+#if 0
+ const CSubjectPublicKeyInfo* subjectPublicKeyInfo = &iCertCx509->PublicKey();
+ if (subjectPublicKeyInfo->AlgorithmId() != ERSA)
+ {
+ return HBufC8::NewLC(1);
+ }
+
+ return TDmAdCertUtil::RSAKeyIdentifierLC(subjectPublicKeyInfo->KeyData());
+#else
+ return iCertCx509->KeyIdentifierL().AllocLC();
+#endif
+ }
+
+
+HBufC8* CDmAdCertData::KeyUsageLC()
+ {
+ const TInt KKeyUsageTxtLen = 12;
+ HBufC8* keyUsage = HBufC8::NewLC(KKeyUsageTxtLen);
+ TPtr8 keyUsagePtr(keyUsage->Des());
+
+ const CX509CertExtension* certExt = iCertCx509->Extension(KKeyUsage);
+
+ if(0 == certExt)
+ {
+ return keyUsage;
+ }
+
+ const CX509KeyUsageExt* keyUsageExt =
+ CX509KeyUsageExt::NewLC(certExt->Data());
+
+ // Encode key usage values to bstring format
+ // See IETF RFC 3641.
+ keyUsagePtr.Append('\'');
+
+ ENC_BIT( EX509DigitalSignature );
+ ENC_BIT( EX509NonRepudiation );
+ ENC_BIT( EX509KeyEncipherment );
+ ENC_BIT( EX509DataEncipherment );
+ ENC_BIT( EX509KeyAgreement );
+ ENC_BIT( EX509KeyCertSign );
+ ENC_BIT( EX509CRLSign );
+ ENC_BIT( EX509EncipherOnly );
+ ENC_BIT( EX509DecipherOnly );
+
+ keyUsagePtr.Append(_L8("'B"));
+
+ CleanupStack::PopAndDestroy(); // keyUsageExt
+
+ return keyUsage;
+ }
+
+
+HBufC8* CDmAdCertData::FormatCertValidityTimeLC(const TTime& aTime)
+ {
+ TDateTime time = aTime.DateTime();
+
+ HBufC8* ret = HBufC8::NewLC(20);
+ TPtr8 retPtr(ret->Des());
+
+ _LIT8(KFormatTxt,"%4d%02d%02dT%02d%02d%02dZ");
+ retPtr.Format(KFormatTxt,
+ time.Year(),
+ TInt(time.Month()+1),
+ // Format the month as a TInt to preserve locale independence
+ time.Day()+1,
+ // Day and month ranges begin at zero (0-30 and 0-11),
+ // so add one when formatting
+ time.Hour(),
+ time.Minute(),
+ time.Second());
+ return ret;
+ }
+
+HBufC8* CDmAdCertData::FindKeyUriLC(const TDesC8& aKeyId)
+ {
+ DEBUG_LOG(_L("CDmAdCertData::FindKeyUriLC:"));
+ DEBUG_LOG_HEX(aKeyId);
+
+ _LIT8(KDmAdPrivKeyUri, "NokiaPKI/PrivKey");
+
+#if 1
+
+ HBufC8* uri = iCallBack->FindChildUriL(KDmAdPrivKeyUri, aKeyId);
+ if (uri != 0)
+ {
+ DEBUG_LOG(_L("CDmAdCertData::FindKeyUriLC:"));
+ DEBUG_LOG_HEX(*uri);
+ }
+ else
+ {
+ DEBUG_LOG(_L("URI not found"));
+ uri = HBufC8::NewL(1);
+ }
+
+ CleanupStack::PushL(uri);
+ return uri;
+
+#else
+
+ HBufC8* ret = 0;
+
+ CBufBase* childUriList = CBufFlat::NewL(16);
+ CleanupStack::PushL(childUriList);
+ MSmlDmAdapter::TError status;
+ iCallBack->FetchLinkL(KDmAdPrivKeyUri, *childUriList, status);
+ if (status != MSmlDmAdapter::EOk)
+ {
+ DMADERR(DmAdErr::Printf(_L("***CDmAdCertData::FindKeyUriLC: %d (line=%d)\n"), KDmAdErr1, __LINE__));
+ User::Leave(KErrGeneral);
+ }
+
+ CArrayFix<TPtrC8>* uriSegList;
+ TDmAdUtil::ParseUriLC(childUriList->Ptr(0), uriSegList);
+
+ TBool found = EFalse;
+ HBufC8* uri = 0;
+ HBufC8* uriKeyId = 0;
+ for (TInt i=0; i<uriSegList->Count(); ++i)
+ {
+ uri = TDmAdUtil::BuildUriLC(KDmAdPrivKeyUri, uriSegList->At(i));
+ uriKeyId = TDmAdUtil::BuildUriLC(*uri, KDmAdLeafKeyId);
+
+ CBufBase* keyId = CBufFlat::NewL(16);
+ CleanupStack::PushL(keyId);
+ iCallBack->FetchLinkL(*uriKeyId, *keyId, status);
+ if (status != MSmlDmAdapter::EOk)
+ {
+ DMADERR(DmAdErr::Printf(_L("***CDmAdCertData::FindKeyUriLC: %d (line=%d)\n"), KDmAdErr1, __LINE__));
+ User::Leave(KErrGeneral);
+ }
+ if (keyId->Ptr(0).Compare(aKeyId) == 0)
+ {
+ found = ETrue;
+ CleanupStack::PopAndDestroy(2); // keyId, uriKeyId
+ break;
+ }
+ CleanupStack::PopAndDestroy(3); // keyId, uriKeyId, uri
+ }
+
+ if (found)
+ {
+ DMADLOG(DmAdLog::Printf(_L("CDmAdCertData::FindKeyUriLC:\n")));
+ DMADLOG(DmAdLog::HexDump(NULL, NULL, uri->Ptr(), uri->Size()));
+ CleanupStack::Pop(uri);
+ ret = uri;
+ }
+ else
+ {
+ DMADLOG(DmAdLog::Printf(_L("CDmAdCertData::FindKeyUriLC: not found\n")));
+ ret = HBufC8::NewL(1);
+ }
+
+ CleanupStack::PopAndDestroy(2); //uriSegList, childUriList
+ CleanupStack::PushL(ret);
+ return ret;
+#endif
+ }
+
+
+
+//--------------------------------------------------------------------------
+
+void CDmAdCertData::RestoreL(const CDmAdCertParms& aCertParms)
+ {
+ TRACE("CDmAdCertData::RestoreL");
+
+ iCertParms->SetType(aCertParms.Type());
+ iCertParms->SetDeletable(aCertParms.Deletable());
+ iCertParms->SetTrusted(aCertParms.Trusted());
+ iCertParms->SetApplicabilityL(aCertParms.Applicability());
+
+ delete iCertCx509;
+ iCertCx509 = 0;
+ iCertParms->SetContentL(aCertParms.Content());
+ if (iCertParms->Content().Length() > 0)
+ {
+ iCertCx509 = CX509Certificate::NewL(iCertParms->Content());
+ }
+
+ iCertParms->SetKeyId(aCertParms.KeyId()); // now NULL
+ }
+
+void CDmAdCertData::ToStoreL(CDmAdCertParms& aCertParms)
+ {
+ TRACE("CDmAdCertData::ToStoreL");
+
+ aCertParms.SetType(iCertParms->Type());
+ aCertParms.SetDeletable(iCertParms->Deletable());
+ aCertParms.SetTrusted(iCertParms->Trusted());
+ aCertParms.SetApplicabilityL(iCertParms->Applicability());
+ aCertParms.SetContentL(iCertParms->Content());
+
+ if (iCertCx509 == NULL)
+ {
+ DEBUG_LOG(_L("No cert!"));
+ User::Leave(KErrGeneral);
+ }
+ TKeyIdentifier keyId = iCertCx509->KeyIdentifierL(); //TKeyIdentifier is 20 bytes long
+ aCertParms.SetKeyId(keyId);
+ }
+
+
+
+//======================================================================================
+//======================================================================================
+
+CDmAdCertReqData* CDmAdCertReqData::NewL(MDmAdCallBack* aCallBack)
+ {
+ TRACE("CDmAdCertReqData::NewL");
+
+ CDmAdCertReqData* self = new (ELeave) CDmAdCertReqData(aCallBack);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CDmAdCertReqData::ConstructL()
+ {
+ TRACE("CDmAdCertReqData::ConstructL");
+ iCertReqParms = CDmAdCertReqParms::NewL();
+ }
+
+CDmAdCertReqData::CDmAdCertReqData(MDmAdCallBack* aCallBack) : iCallBack(aCallBack)
+ {
+ }
+
+CDmAdCertReqData::~CDmAdCertReqData()
+ {
+ TRACE("CDmAdCertReqData::~CDmAdCertReqData");
+ delete iCertReqParms;
+ }
+
+void CDmAdCertReqData::SetDefaultSettings()
+ {
+ TRACE("CDmAdCertReqData::SetDefaultSettings");
+ iCertReqParms->SetKeyLength(1024);
+ }
+
+//--------------------------------------------------------------------------
+
+void CDmAdCertReqData::SetSubjectNameL(const TDesC8& aSubjectName)
+ {
+ TRACE("CDmAdCertReqData::SetSubjectNameL");
+ iCertReqParms->SetSubjectNameL(aSubjectName);
+ }
+
+TPtrC8 CDmAdCertReqData::SubjectName()
+ {
+ TRACE("CDmAdCertReqData::SubjectName");
+ return iCertReqParms->SubjectName();
+ }
+
+void CDmAdCertReqData::SetRfc822NameL(const TDesC8& aRfc822Name)
+ {
+ TRACE("CDmAdCertReqData::SetRfc822NameL");
+ iCertReqParms->SetRfc822NameL(aRfc822Name);
+ }
+
+TPtrC8 CDmAdCertReqData::Rfc822Name()
+ {
+ TRACE("CDmAdCertReqData::Rfc822Name");
+ return iCertReqParms->Rfc822Name();
+ }
+
+void CDmAdCertReqData::SetKeyUriL(const TDesC8& aKeyUri)
+ {
+ TRACE("CDmAdCertReqData::SetKeyUriL");
+
+ //We save key luid (which is also key id) to the data
+ //structure. Not the actual key uri.
+
+ HBufC8* keyId = iCallBack->GetLuidAllocL(aKeyUri);
+ CleanupStack::PushL(keyId);
+
+ if (keyId->Length() == 0)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ iCertReqParms->SetKeyIdentifierByUriL(*keyId);
+ CleanupStack::PopAndDestroy(keyId);
+ }
+
+HBufC8* CDmAdCertReqData::KeyUriL() const
+ {
+ TRACE("CDmAdCertReqData::KeyUri");
+
+ TPtrC8 keyId = iCertReqParms->KeyIdentifierByUri();
+ HBufC8* keyUri = iCallBack->FindChildUriL(KDmAdOwnAdUriForPrivateKeys, keyId);
+ CleanupStack::PushL(keyUri);
+
+ if (keyUri->Length() == 0)
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ CleanupStack::Pop(keyUri);
+ return keyUri;
+ }
+
+void CDmAdCertReqData::SetKeyLength(const TDesC8& aKeyLength)
+ {
+ TRACE("CDmAdCertReqData::SetKeyLength");
+ iCertReqParms->SetKeyLength(TDmAdUtil::DesToInt(aKeyLength));
+ }
+
+HBufC8* CDmAdCertReqData::KeyLengthLC()
+ {
+ return TDmAdUtil::IntToDes8LC(iCertReqParms->KeyLength());
+ }
+
+//------------
+
+
+TPtrC8 CDmAdCertReqData::Content()
+ {
+ TRACE("CDmAdCertReqData::Content");
+ return iCertReqParms->Content();
+ }
+
+//--------------------------------------------------------------------------
+
+void CDmAdCertReqData::RestoreL(const CDmAdCertReqParms& aCertReqParms)
+ {
+ TRACE("CDmAdCertReqData::RestoreL");
+ iCertReqParms->SetSubjectNameL(aCertReqParms.SubjectName());
+ iCertReqParms->SetRfc822NameL(aCertReqParms.Rfc822Name());
+ iCertReqParms->SetKeyLength(aCertReqParms.KeyLength());
+ iCertReqParms->SetKeyIdentifierByUriL(aCertReqParms.KeyIdentifierByUri());
+ iCertReqParms->SetContentL(aCertReqParms.Content());
+ }
+
+void CDmAdCertReqData::ToStoreL(CDmAdCertReqParms& aCertReqParms)
+ {
+ TRACE("CDmAdCertReqData::ToStoreL");
+
+ aCertReqParms.SetSubjectNameL(iCertReqParms->SubjectName());
+ aCertReqParms.SetRfc822NameL(iCertReqParms->Rfc822Name());
+ aCertReqParms.SetKeyLength(iCertReqParms->KeyLength());
+ aCertReqParms.SetKeyIdentifierByUriL(iCertReqParms->KeyIdentifierByUri());
+ aCertReqParms.SetContentL(iCertReqParms->Content());
+ }
+
+//======================================================================================
+//======================================================================================
+
+CDmAdPrivKeyData* CDmAdPrivKeyData::NewL()
+ {
+ TRACE("CDmAdPrivKeyData::NewL");
+ CDmAdPrivKeyData *self = new (ELeave) CDmAdPrivKeyData();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CDmAdPrivKeyData::ConstructL()
+ {
+ TRACE("CDmAdPrivKeyData::ConstructL");
+ iPrivKeyParms = CDmAdPrivKeyParms::NewL();
+ }
+
+CDmAdPrivKeyData::CDmAdPrivKeyData()
+ {
+ }
+
+CDmAdPrivKeyData::~CDmAdPrivKeyData()
+ {
+ TRACE("CDmAdPrivKeyData::~CDmAdPrivKeyData");
+ delete iPrivKeyParms;
+ }
+
+void CDmAdPrivKeyData::SetDefaultSettingsL()
+ {
+ TRACE("CDmAdPrivKeyData::SetDefaultSettings");
+ iPrivKeyParms->SetKeyTypeL(EPKIRSA);
+ iPrivKeyParms->SetKeyLength(2048);
+ }
+
+//--------------------------------------------------------------------------
+
+void CDmAdPrivKeyData::SetKeyTypeL(const TDesC8& aKeyType)
+ {
+ TRACE("CDmAdPrivKeyData::SetKeyType");
+ TInt value = TDmAdUtil::DesToInt(aKeyType);
+
+ TPKIKeyAlgorithm keyType = EPKIRSA;
+ switch(value)
+ {
+ case 1:
+ keyType = EPKIRSA;
+ break;
+ case 2:
+ keyType = EPKIDSA;
+ break;
+ default:
+ User::Leave(KErrCorrupt);
+ break;
+ }
+
+ iPrivKeyParms->SetKeyTypeL(keyType);
+ }
+
+HBufC8* CDmAdPrivKeyData::KeyTypeLC()
+ {
+ TInt keyType = 1;
+ switch(iPrivKeyParms->KeyType())
+ {
+ case EPKIRSA:
+ keyType = 1;
+ break;
+ case EPKIDSA:
+ keyType = 2;
+ break;
+ default:
+ User::Invariant();
+ break;
+ }
+ return TDmAdUtil::IntToDes8LC(keyType);
+ }
+
+void CDmAdPrivKeyData::SetKeyLength(const TDesC8& aKeyLength)
+ {
+ TRACE("CDmAdPrivKeyData::SetKeyLength");
+ iPrivKeyParms->SetKeyLength(TDmAdUtil::DesToInt(aKeyLength));
+ }
+
+HBufC8* CDmAdPrivKeyData::KeyLengthLC()
+ {
+ return TDmAdUtil::IntToDes8LC(iPrivKeyParms->KeyLength());
+ }
+
+//------------
+
+TPtrC8 CDmAdPrivKeyData::KeyId()
+ {
+ TRACE("CDmAdPrivKeyData::KeyId");
+ return iPrivKeyParms->KeyId();
+ }
+
+//--------------------------------------------------------------------------
+
+void CDmAdPrivKeyData::RestoreL(const CDmAdPrivKeyParms& aPrivKeyParms)
+ {
+ TRACE("CDmAdPrivKeyData::RestoreL");
+ iPrivKeyParms->SetKeyTypeL(aPrivKeyParms.KeyType());
+ iPrivKeyParms->SetKeyIdL(aPrivKeyParms.KeyId());
+ iPrivKeyParms->SetKeyLength(aPrivKeyParms.KeyLength());
+ }
+
+void CDmAdPrivKeyData::ToStoreL(CDmAdPrivKeyParms& aPrivKeyParms)
+ {
+ TRACE("CDmAdPrivKeyData::ToStoreL");
+ aPrivKeyParms.SetKeyTypeL(iPrivKeyParms->KeyType());
+ aPrivKeyParms.SetKeyIdL(iPrivKeyParms->KeyId());
+ aPrivKeyParms.SetKeyLength(iPrivKeyParms->KeyLength());
+ }
+
+
+
+//======================================================================================
+//======================================================================================
+
+CDmAdPKCS12Data* CDmAdPKCS12Data::NewL(/*MDmAdCallBack* aCallBack*/)
+ {
+ TRACE("CDmAdPKCS12Data::NewL");
+
+// CDmAdPKCS12Data* self = new (ELeave) CDmAdPKCS12Data(aCallBack);
+ CDmAdPKCS12Data* self = new (ELeave) CDmAdPKCS12Data();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CDmAdPKCS12Data::ConstructL()
+ {
+ TRACE("CDmAdPKCS12Data::ConstructL");
+
+ iPKCS12Parms = CDmAdPKCS12Parms::NewL();
+ }
+
+CDmAdPKCS12Data::CDmAdPKCS12Data(/*MDmAdCallBack* aCallBack*/)
+// : iCallBack(aCallBack)
+ {
+ }
+
+CDmAdPKCS12Data::~CDmAdPKCS12Data()
+ {
+ TRACE("CDmAdPKCS12Data::~CDmAdPKCS12Data");
+
+ delete iPKCS12Parms;
+ }
+
+void CDmAdPKCS12Data::SetDefaultSettings()
+ {
+ TRACE("CDmAdPKCS12Data::SetDefaultSettings");
+
+ TPtrC8 emptyPwd(KNullDesC8);
+ iPKCS12Parms->SetDeletable(ETrue);
+ TRAP_IGNORE(iPKCS12Parms->SetPasswordL(emptyPwd));
+ }
+
+//--------------------------------------------------------------------------
+
+void CDmAdPKCS12Data::SetDeletableL(const TDesC8& aDeletable)
+ {
+ TRACE("CDmAdPKCS12Data::SetDeletableL");
+
+ if (aDeletable.Compare(KDmAdDfFormatBoolTrue) == 0)
+ {
+ iPKCS12Parms->SetDeletable(ETrue);
+ }
+ else if (aDeletable.Compare(KDmAdDfFormatBoolFalse) == 0)
+ {
+ iPKCS12Parms->SetDeletable(EFalse);
+ }
+ else
+ {
+ DEBUG_LOG(_L("Comparization failed"));
+ User::Leave(KErrGeneral);
+ }
+ }
+
+HBufC8* CDmAdPKCS12Data::DeletableLC()
+ {
+ if (iPKCS12Parms->Deletable())
+ {
+ return KDmAdDfFormatBoolTrue().AllocLC();
+ }
+ else
+ {
+ return KDmAdDfFormatBoolFalse().AllocLC();
+ }
+ }
+
+void CDmAdPKCS12Data::SetApplicabilityL(const RArray<TUid>& aApplicability)
+ {
+ TRACE("CDmAdPKCS12Data::SetApplicabilityL");
+
+ iPKCS12Parms->SetApplicabilityL(aApplicability);
+ }
+
+const RArray<TUid>& CDmAdPKCS12Data::Applicability() const
+ {
+ TRACE("CDmAdPKCS12Data::Applicability");
+
+ return iPKCS12Parms->Applicability();
+ }
+
+void CDmAdPKCS12Data::SetContentL(const TDesC8& aContent)
+ {
+ TRACE("CDmAdPKCS12Data::SetContentL");
+
+ iPKCS12Parms->SetContentL(aContent);
+ }
+
+TPtrC8 CDmAdPKCS12Data::Content()
+ {
+ TRACE("CDmAdPKCS12Data::Content");
+
+ return iPKCS12Parms->Content();
+ }
+
+void CDmAdPKCS12Data::SetPasswordL(const TDesC8& aPassword)
+ {
+ TRACE("CDmAdPKCS12Data::SetPasswordL");
+
+ iPKCS12Parms->SetPasswordL(aPassword);
+ }
+
+TPtrC8 CDmAdPKCS12Data::Password()
+ {
+ TRACE("CDmAdPKCS12Data::Password");
+
+ return iPKCS12Parms->Password();
+ }
+
+//-----------------
+
+
+
+//--------------------------------------------------------------------------
+
+void CDmAdPKCS12Data::RestoreL(const CDmAdPKCS12Parms& aPKCS12Parms)
+ {
+ TRACE("CDmAdPKCS12Data::RestoreL");
+ iPKCS12Parms->SetDeletable(aPKCS12Parms.Deletable());
+ iPKCS12Parms->SetApplicabilityL(aPKCS12Parms.Applicability());
+ iPKCS12Parms->SetContentL(aPKCS12Parms.Content());
+ iPKCS12Parms->SetPasswordL(aPKCS12Parms.Content());
+ }
+
+void CDmAdPKCS12Data::ToStoreL(CDmAdPKCS12Parms& aPKCS12Parms)
+ {
+ TRACE("CDmAdPKCS12Data::ToStoreL");
+
+ aPKCS12Parms.SetDeletable(iPKCS12Parms->Deletable());
+ aPKCS12Parms.SetApplicabilityL(iPKCS12Parms->Applicability());
+ aPKCS12Parms.SetContentL(iPKCS12Parms->Content());
+ aPKCS12Parms.SetPasswordL(iPKCS12Parms->Password());
+ }
+