/*

 * 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 <e32base.h>

 #include <ct.h>

 #include "mctauthobject.h"

 #include "mctkeystore.h"

 #include "mctkeystoremanager.h"

 #include <securityerr.h>

 #include "ct/logger.h"

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 /** The type ID of CCTKeyInfo objects */

 const TUid KKeyInfoUID = {0x101F5152};

 #endif

 ////////////////////////////////////////////////////////////////////////////////

 // CKeyInfoBase

 ////////////////////////////////////////////////////////////////////////////////

 EXPORT_C CKeyInfoBase::CKeyInfoBase(TKeyIdentifier aID,

 									TKeyUsagePKCS15 aUsage,

 									TUint aSize, 

 									HBufC* aLabel,

 									TInt aHandle,

 									const TSecurityPolicy& aUsePolicy,

 									const TSecurityPolicy& aManagementPolicy,

 									EKeyAlgorithm aAlgorithm,

 									TInt aAccessType,

 									TBool aNative,

 									TTime aStartDate,

 									TTime aEndDate,

 									HBufC8* aPKCS8AttributeSet) :

 	iID(aID),

 	iUsage(aUsage),

 	iSize(aSize), 

 	iLabel(aLabel),

 	iHandle(aHandle),

 	iUsePolicy(aUsePolicy),

 	iManagementPolicy(aManagementPolicy),

 	iAlgorithm(aAlgorithm),

 	iAccessType(aAccessType),

 	iNative(aNative),

 	iStartDate(aStartDate), 

 	iEndDate(aEndDate),

 	iPKCS8AttributeSet(aPKCS8AttributeSet)

 	{

 	}

 EXPORT_C CKeyInfoBase::CKeyInfoBase()

 	{

 	}

 EXPORT_C CKeyInfoBase::~CKeyInfoBase()

 	{

 	delete iLabel;

 	delete iPKCS8AttributeSet;

 	}

 EXPORT_C void CKeyInfoBase::ConstructL()

 	{

 	}

 EXPORT_C void CKeyInfoBase::ConstructL(RReadStream& aIn)

 	{

 	// Called from derived classes' NewL methods when interalizing a stream

 	InternalizeL(aIn);

 	}

 EXPORT_C void CKeyInfoBase::ExternalizeL(RWriteStream& aStream) const

 	{

 	aStream.WriteL(iID);

 	aStream.WriteInt32L(iUsage);

 	aStream.WriteUint32L(iSize);

   	aStream.WriteInt32L(iLabel->Length());

   	TPtr16 theLabel(iLabel->Des());

   	aStream.WriteL(theLabel);

 	aStream.WriteInt32L(iHandle);

 	aStream.WriteL(TPckgC<TSecurityPolicy>(iUsePolicy));

 	aStream.WriteL(TPckgC<TSecurityPolicy>(iManagementPolicy));		

 	aStream.WriteInt32L(iAlgorithm);

 	aStream.WriteInt32L(iAccessType);

 	aStream.WriteInt32L(iNative);

 	aStream.WriteL(TPckgC<TTime>(iStartDate));

 	aStream.WriteL(TPckgC<TTime>(iEndDate));

 	if (iPKCS8AttributeSet)

 		{

 		aStream.WriteInt32L(iPKCS8AttributeSet->Length());

 		TPtr8 theAttributes(iPKCS8AttributeSet->Des());

 		aStream.WriteL(theAttributes);

 		}

 	else

 		aStream.WriteInt32L(0);

 	}

 void CKeyInfoBase::InternalizeL(RReadStream& aStream)

 	{

 	aStream.ReadL(iID);

 	iUsage = static_cast<TKeyUsagePKCS15>(aStream.ReadInt32L());

 	iSize = aStream.ReadUint32L();

 	TInt labelLen = aStream.ReadInt32L();

 	iLabel = HBufC::NewMaxL(labelLen);

 	TPtr pLabel(iLabel->Des());

 	pLabel.FillZ();

 	// This will have made the length of pLabel equal to the length of

 	// the alloc cell of iLabel, which may be longer than labelLen. So

 	// we need to pass the length we want to read into ReadL

 	aStream.ReadL(pLabel, labelLen);

 	iHandle = aStream.ReadInt32L();

 	TPckg<TSecurityPolicy> usePolicy(iUsePolicy);

 	aStream.ReadL(usePolicy);

 	TPckg<TSecurityPolicy> managementPolicy(iManagementPolicy);

 	aStream.ReadL(managementPolicy);

 	iAlgorithm = (EKeyAlgorithm)(aStream.ReadInt32L());

 	iAccessType = (EKeyAccess)(aStream.ReadInt32L());

 	iNative = (TBool)(aStream.ReadInt32L());

 	TPckg<TTime> startDate(iStartDate);

 	aStream.ReadL(startDate);

 	TPckg<TTime> endDate(iEndDate);

 	aStream.ReadL(endDate);

 	TInt attributeLen = aStream.ReadInt32L();

 	if (attributeLen > 0)

 		{

 		iPKCS8AttributeSet = HBufC8::NewMaxL(attributeLen);

 		TPtr8 pAttributes(iPKCS8AttributeSet->Des());

 		pAttributes.FillZ();

 		//	This will have made the length of pAttributes equal to the length of

 		//	the alloc cell of iPKCS8AttributeSet, which may be longer than attributeLen

 		//	So we need to pass the length we want to read into ReadL

 		aStream.ReadL(pAttributes, attributeLen);

 		}

 	}

 ////////////////////////////////////////////////////////////////////////////////

 // CCTKeyInfo

 ////////////////////////////////////////////////////////////////////////////////

 EXPORT_C CCTKeyInfo* CCTKeyInfo::NewL(TKeyIdentifier aID,

 									  TKeyUsagePKCS15 aUsage, 

 									  TUint aSize,

 									  MCTAuthenticationObject* aProtector,

 									  HBufC* aLabel,

 									  MCTToken& aToken,

 									  TInt aHandle,

 									  const TSecurityPolicy& aUsePolicy,

 									  const TSecurityPolicy& aManagementPolicy,

 									  EKeyAlgorithm aAlgorithm,

 									  TInt aAccessType,

 									  TBool aNative,

 									  TTime aStartDate,

 									  TTime aEndDate,

 									  HBufC8* aPKCS8AttributeSet /*= NULL*/)

 	{

 	CCTKeyInfo* me = NULL;

 	me = new (ELeave) CCTKeyInfo(aID,

 								 aUsage,

 								 aSize,

 								 aProtector,

 								 aLabel,

 								 aToken,

 								 aHandle,

 								 aUsePolicy,

 								 aManagementPolicy,

 								 aAlgorithm,

 								 aAccessType,

 								 aNative,

 								 aStartDate,

 								 aEndDate,

 								 aPKCS8AttributeSet);

 	CleanupReleasePushL(*me);

 	me->ConstructL();

 	CleanupStack::Pop();

 	return me;

 	}

 CCTKeyInfo::CCTKeyInfo(TKeyIdentifier aID,

 					   TKeyUsagePKCS15 aUsage,

 					   TUint aSize, 

 					   MCTAuthenticationObject* aProtector,

 					   HBufC* aLabel,

 					   MCTToken& aToken,

 					   TInt aHandle,

 					   const TSecurityPolicy& aUsePolicy,

 					   const TSecurityPolicy& aManagementPolicy,

 					   EKeyAlgorithm aAlgorithm,

 					   TInt aAccessType,

 					   TBool aNative, 

 					   TTime aStartDate,

 					   TTime aEndDate,

 					   HBufC8* aPKCS8AttributeSet /*= NULL*/) :

 	CKeyInfoBase(aID,

 				 aUsage,

 				 aSize,

 				 aLabel,

 				 aHandle,

 				 aUsePolicy,

 				 aManagementPolicy,

 				 aAlgorithm,

 				 aAccessType,

 				 aNative,

 				 aStartDate,

 				 aEndDate,

 				 aPKCS8AttributeSet),

 	MCTTokenObject(aToken),

 	iToken(aToken),

 	iProtector(aProtector)

 	{

 	LOG1(_L("CCTKeyInfo::CCTKeyInfo() with iProtector %08x"), iProtector);

 	}

 EXPORT_C CCTKeyInfo* CCTKeyInfo::NewL(RReadStream& aStream, MCTToken& aToken)

 	{

 	CCTKeyInfo* me = new (ELeave) CCTKeyInfo(aToken);

 	CleanupReleasePushL(*me);

 	me->ConstructL(aStream);

 	CleanupStack::Pop();

 	return me;

 	}

 CCTKeyInfo::CCTKeyInfo(MCTToken& aToken) :

 	CKeyInfoBase(),

 	MCTTokenObject(aToken),

 	iToken(aToken)

 	{

 	}

 CCTKeyInfo::~CCTKeyInfo()

 	{

 	LOG(_L("CCTKeyInfo::~CCTKeyInfo"));

 	if (iProtector)

 		{

 		LOG_INC_INDENT();

 		iProtector->Release();

 		LOG_DEC_INDENT();

 		}

 	}

 const TDesC& CCTKeyInfo::Label() const

 	{

 	return CKeyInfoBase::Label();

 	}

 MCTToken& CCTKeyInfo::Token() const

 	{

 	return iToken;

 	}

 TUid CCTKeyInfo::Type() const

 	{

 	return KKeyInfoUID;

 	}

 TCTTokenObjectHandle CCTKeyInfo::Handle() const

 	{

 	return TCTTokenObjectHandle(Token().Handle(), HandleID());

 	}

 ////////////////////////////////////////////////////////////////////////////////

 // TCTKeyAttributeFilter

 ////////////////////////////////////////////////////////////////////////////////

 EXPORT_C TCTKeyAttributeFilter::TCTKeyAttributeFilter()

 	{

 	iKeyId = KNullDesC8;

 	iUsage = EPKCS15UsageAll;

 	iPolicyFilter = EUsableKeys;

 	iKeyAlgorithm = CCTKeyInfo::EInvalidAlgorithm;

 	}