/*
* 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;
}