/*
* 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"

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