--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptomgmtlibs/cryptotokenfw/source/ctframework/Cctcertinfo.cpp Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,392 @@
+/*
+* Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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:
+*
+*/
+
+
+#include "cctcertinfo.h"
+
+// MCertInfo ///////////////////////////////////////////////////////////////////
+
+EXPORT_C MCertInfo::MCertInfo() :
+ iDeletable(ETrue)
+ {
+ }
+
+EXPORT_C MCertInfo::MCertInfo(const TDesC& aLabel,
+ TCertificateFormat aFormat,
+ TCertificateOwnerType aCertificateOwnerType,
+ TInt aSize,
+ const TKeyIdentifier* aSubjectKeyId,
+ const TKeyIdentifier* aIssuerKeyId,
+ TInt aCertificateId,
+ TBool aDeletable) :
+ iLabel(aLabel), iCertificateId(aCertificateId),
+ iFormat(aFormat), iCertificateOwnerType(aCertificateOwnerType),
+ iSize(aSize), iDeletable(aDeletable)
+ {
+ if (aSubjectKeyId)
+ {
+ iSubjectKeyId = *aSubjectKeyId;
+ }
+ else
+ {
+ iSubjectKeyId = KNullDesC8;
+ }
+ if (aIssuerKeyId)
+ {
+ iIssuerKeyId = *aIssuerKeyId;
+ }
+ else
+ {
+ iIssuerKeyId = KNullDesC8;
+ }
+ }
+
+EXPORT_C MCertInfo::MCertInfo(const MCertInfo& aOther) :
+ iLabel(aOther.iLabel),
+ iCertificateId(aOther.iCertificateId),
+ iFormat(aOther.iFormat),
+ iCertificateOwnerType(aOther.iCertificateOwnerType),
+ iSize(aOther.iSize),
+ iSubjectKeyId(aOther.iSubjectKeyId),
+ iIssuerKeyId(aOther.iIssuerKeyId),
+ iDeletable(aOther.iDeletable)
+ {
+ }
+
+EXPORT_C MCertInfo::~MCertInfo()
+ {
+ delete iIssuerHash;
+ }
+
+const TDesC8* MCertInfo::IssuerHash() const
+ {
+ return iIssuerHash;
+ }
+
+EXPORT_C void MCertInfo::ConstructL(const TDesC8* aIssuerHash)
+ {
+ delete iIssuerHash;
+ iIssuerHash = NULL;
+ if (aIssuerHash)
+ {
+ iIssuerHash = aIssuerHash->AllocL();
+ }
+
+ if (!Valid())
+ {
+ User::Leave(KErrArgument);
+ }
+ }
+
+TBool MCertInfo::Valid() const
+ {
+ if (iLabel.Length() == 0)
+ {
+ return EFalse;
+ }
+
+ if (iCertificateId < 0)
+ {
+ return EFalse;
+ }
+
+ if (iFormat != EX509Certificate && iFormat != EWTLSCertificate &&
+ iFormat != EX968Certificate && iFormat != EX509CertificateUrl &&
+ iFormat != EWTLSCertificateUrl && iFormat != EX968CertificateUrl)
+ {
+ return EFalse;
+ }
+
+ if (iCertificateOwnerType != ECACertificate &&
+ iCertificateOwnerType != EUserCertificate &&
+ iCertificateOwnerType != EPeerCertificate)
+ {
+ return EFalse;
+ }
+
+ if (iSize <= 0)
+ {
+ return EFalse;
+ }
+
+ if (iIssuerHash && *iIssuerHash == KNullDesC8)
+ {
+ return EFalse;
+ }
+
+ return ETrue;
+ }
+
+/**
+ EXPORT_C void MCertInfo::ExternalizeL(RWriteStream& aStream) const
+
+ This method externalizes the MCertInfo object to the given stream.
+ The iDeletable boolean attribute is combined with the iFormat attribute
+ for certstore backward compatibility
+*/
+EXPORT_C void MCertInfo::ExternalizeL(RWriteStream& aStream) const
+ {
+ // insert iDeletable flag as most significant digit of iFormat in order
+ // store the flag without changing the externalized record format
+ // The value is OPPOSITE for backward compatibility
+ TUint8 tmpValue = static_cast <TUint8>(iFormat | (iDeletable ? 0 : KReadOnlyFlagMask));
+
+ aStream.WriteUint8L(tmpValue);
+ aStream.WriteInt32L(iSize);
+ aStream << iLabel;
+ aStream.WriteInt32L(iCertificateId);
+ aStream.WriteUint8L(iCertificateOwnerType);
+ aStream << iSubjectKeyId;
+ aStream << iIssuerKeyId;
+ }
+
+/**
+ EXPORT_C void MCertInfo::InternalizeL(RReadStream& aStream)
+
+ This method internalizes a MCertInfo object from the given stream.
+ The iDeletable boolean and iFormat attributes are both extracted
+ from the stored iFormat value using for certstore backward compatibility
+*/
+EXPORT_C void MCertInfo::InternalizeL(RReadStream& aStream)
+ {
+ // get first byte from stream containing iDeletable flag and iFormat value
+ TUint8 tmpValue = aStream.ReadUint8L();
+
+ // extract iDeletable flag from most significant digit of iFormat
+ // set iDeletable to the OPPOSITE of the 8th bit value
+ iDeletable = !(tmpValue & KReadOnlyFlagMask);
+
+ // extract iFormat = the value of the 7 least significant bits
+ iFormat = static_cast <TCertificateFormat>(tmpValue & KFormatMask);
+
+ iSize = aStream.ReadInt32L();
+ aStream >> iLabel;
+ iCertificateId = aStream.ReadInt32L();
+ iCertificateOwnerType = static_cast<TCertificateOwnerType>(aStream.ReadUint8L());
+ aStream >> iSubjectKeyId;
+ aStream >> iIssuerKeyId;
+
+ if (!Valid())
+ {
+ User::Leave(KErrCorrupt);
+ }
+ }
+
+// CCTCertInfo /////////////////////////////////////////////////////////////////
+
+EXPORT_C CCTCertInfo* CCTCertInfo::NewL(RReadStream& aStream, MCTToken& aToken)
+ {
+ CCTCertInfo* self = CCTCertInfo::NewLC(aStream, aToken);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+EXPORT_C CCTCertInfo* CCTCertInfo::NewLC(RReadStream& aStream, MCTToken& aToken)
+ {
+ CCTCertInfo* self = new(ELeave) CCTCertInfo(aToken);
+ CleanupReleasePushL(*self);
+ self->ConstructL(aStream);
+ return self;
+ }
+
+EXPORT_C CCTCertInfo* CCTCertInfo::NewL(const TDesC& aLabel,
+ TCertificateFormat aFormat,
+ TCertificateOwnerType aCertificateOwnerType,
+ TInt aSize,
+ const TKeyIdentifier* aSubjectKeyId,
+ const TKeyIdentifier* aIssuerKeyId,
+ MCTToken& aToken,
+ TInt aCertificateId)
+ {
+ CCTCertInfo* self = CCTCertInfo::NewLC(aLabel,
+ aFormat, aCertificateOwnerType, aSize, aSubjectKeyId, aIssuerKeyId, aToken,
+ aCertificateId, ETrue);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+EXPORT_C CCTCertInfo* CCTCertInfo::NewL(const TDesC& aLabel,
+ TCertificateFormat aFormat,
+ TCertificateOwnerType aCertificateOwnerType,
+ TInt aSize,
+ const TKeyIdentifier* aSubjectKeyId,
+ const TKeyIdentifier* aIssuerKeyId,
+ MCTToken& aToken,
+ TInt aCertificateId,
+ TBool aIsDeletable,
+ const TDesC8* aIssuerHash)
+ {
+ CCTCertInfo* self = CCTCertInfo::NewLC(aLabel,
+ aFormat, aCertificateOwnerType, aSize, aSubjectKeyId, aIssuerKeyId, aToken,
+ aCertificateId, aIsDeletable, aIssuerHash);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+EXPORT_C CCTCertInfo* CCTCertInfo::NewLC(const TDesC& aLabel,
+ TCertificateFormat aFormat,
+ TCertificateOwnerType aCertificateOwnerType,
+ TInt aSize,
+ const TKeyIdentifier* aSubjectKeyId,
+ const TKeyIdentifier* aIssuerKeyId,
+ MCTToken& aToken,
+ TInt aCertificateId)
+ {
+ return CCTCertInfo::NewLC(aLabel,
+ aFormat, aCertificateOwnerType, aSize, aSubjectKeyId, aIssuerKeyId,
+ aToken, aCertificateId, ETrue);
+ }
+
+EXPORT_C CCTCertInfo* CCTCertInfo::NewLC(const TDesC& aLabel,
+ TCertificateFormat aFormat,
+ TCertificateOwnerType aCertificateOwnerType,
+ TInt aSize,
+ const TKeyIdentifier* aSubjectKeyId,
+ const TKeyIdentifier* aIssuerKeyId,
+ MCTToken& aToken,
+ TInt aCertificateId,
+ TBool aIsDeletable,
+ const TDesC8* aIssuerHash)
+ {
+ CCTCertInfo* self = new(ELeave) CCTCertInfo(aLabel,
+ aFormat, aCertificateOwnerType, aSize, aSubjectKeyId,
+ aIssuerKeyId, aToken, aCertificateId, aIsDeletable);
+ CleanupReleasePushL(*self);
+ self->ConstructL(aIssuerHash);
+ return self;
+ }
+
+EXPORT_C CCTCertInfo* CCTCertInfo::NewL(const CCTCertInfo& aCertInfo)
+ {
+ CCTCertInfo* self = CCTCertInfo::NewLC(aCertInfo);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+EXPORT_C CCTCertInfo* CCTCertInfo::NewLC(const CCTCertInfo& aCertInfo)
+ {
+ CCTCertInfo* self = new(ELeave) CCTCertInfo(aCertInfo);
+ CleanupReleasePushL(*self);
+ self->ConstructL(aCertInfo.IssuerHash());
+ return self;
+ }
+
+CCTCertInfo::CCTCertInfo(MCTToken& aToken)
+ : MCTTokenObject(aToken), iToken(aToken)
+ {
+ }
+
+CCTCertInfo::CCTCertInfo(const TDesC& aLabel,
+ TCertificateFormat aFormat,
+ TCertificateOwnerType aCertificateOwnerType,
+ TInt aSize,
+ const TKeyIdentifier* aSubjectKeyId,
+ const TKeyIdentifier* aIssuerKeyId,
+ MCTToken& aToken,
+ TInt aCertificateId,
+ TBool aIsDeletable)
+ : MCTTokenObject(aToken),
+ MCertInfo(aLabel, aFormat, aCertificateOwnerType, aSize, aSubjectKeyId,
+ aIssuerKeyId, aCertificateId, aIsDeletable),
+ iToken(aToken)
+ {
+ }
+
+CCTCertInfo::CCTCertInfo(const CCTCertInfo& aOther)
+ : MCTTokenObject(aOther.iToken), MCertInfo(aOther), iToken(aOther.iToken)
+ {
+ }
+
+void CCTCertInfo::ConstructL(RReadStream& aStream)
+ {
+ InternalizeL(aStream);
+ }
+
+void CCTCertInfo::ConstructL(const TDesC8* aIssuerHash)
+ {
+ MCertInfo::ConstructL(aIssuerHash);
+ }
+
+EXPORT_C CCTCertInfo::~CCTCertInfo()
+ {
+ }
+
+const TDesC& CCTCertInfo::Label() const
+ {
+ return iLabel;
+ }
+
+TUid CCTCertInfo::Type() const
+ {
+ TUid uid = { KCTObjectCertInfo };
+ return uid;
+ }
+
+EXPORT_C const TKeyIdentifier& CCTCertInfo::SubjectKeyId() const
+ {
+ return iSubjectKeyId;
+ }
+
+EXPORT_C const TKeyIdentifier& CCTCertInfo::IssuerKeyId() const
+ {
+ return iIssuerKeyId;
+ }
+
+EXPORT_C TCertificateFormat CCTCertInfo::CertificateFormat() const
+ {
+ return iFormat;
+ }
+
+EXPORT_C TCertificateOwnerType CCTCertInfo::CertificateOwnerType() const
+ {
+ return iCertificateOwnerType;
+ }
+
+EXPORT_C TInt CCTCertInfo::Size() const
+ {
+ return iSize;
+ }
+
+MCTToken& CCTCertInfo::Token() const
+ {
+ return iToken;
+ }
+
+EXPORT_C TCTTokenObjectHandle CCTCertInfo::Handle() const
+ {
+ return TCTTokenObjectHandle(iToken.Handle(), iCertificateId);
+ }
+
+EXPORT_C TBool CCTCertInfo::IsDeletable() const
+ {
+ return iDeletable;
+ }
+
+EXPORT_C const TDesC8* CCTCertInfo::IssuerHash() const
+ {
+ return MCertInfo::IssuerHash();
+ }
+
+EXPORT_C TBool CCTCertInfo::operator==(const CCTCertInfo& aCertInfo) const
+ {
+ return aCertInfo.iLabel == iLabel;
+ }
+
+EXPORT_C void CCTCertInfo::SetCertificateId(TInt aCertId)
+{
+ iCertificateId = aCertId;
+}