diff -r 000000000000 -r 33413c0669b9 vpnengine/dmadpki/src/DmAdRtNodeData.cpp --- /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 + +#include +#include +#include +#include + +#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 + + +// 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* 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 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 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& applicability = u.iCert->Applicability(); + + CXmlWriter* writer = CXmlWriter::NewL(); + CleanupStack::PushL(static_cast(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(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& 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& aApplicability) + { + TRACE("CDmAdCertData::SetApplicabilityL"); + + iCertParms->SetApplicabilityL(aApplicability); + } + +const RArray& 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* 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* uriSegList; + TDmAdUtil::ParseUriLC(childUriList->Ptr(0), uriSegList); + + TBool found = EFalse; + HBufC8* uri = 0; + HBufC8* uriKeyId = 0; + for (TInt i=0; iCount(); ++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& aApplicability) + { + TRACE("CDmAdPKCS12Data::SetApplicabilityL"); + + iPKCS12Parms->SetApplicabilityL(aApplicability); + } + +const RArray& 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()); + } +