/*

* 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: 

* CCTCertInfo.H

*

*/

/**

 @file 

 @publishedAll

 @released

*/

#ifndef __CCTCERTINFO_H__

#define __CCTCERTINFO_H__

#include <e32base.h>

#include <s32strm.h>

#include <securitydefs.h>

#include <ct/mcttokentype.h>

#include <ct/mcttoken.h>

#include <ct/mcttokenobject.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

/** Mask constants used for serializing iDeletable and iFormat attributes 

*/

const TUint KReadOnlyFlagMask = 128;

const TUint KFormatMask = 127;

/** The UID of a CertInfo MCTTokenObject. */

const TInt KCTObjectCertInfo = 0x101F50E6;

#endif

/** The maximum length of a certificate label. */

const TUint32 KMaxCertLabelLength = 64;

/** Defines a modifiable buffer descriptor to contain a human-readable certificate label. 

*

*/

typedef TBuf<KMaxCertLabelLength> TCertLabel;

/**

 * Mix-in class representnig data about a stored certificate.  Provides

 * implementation of serialization.

 * 

 * Note that for backward compatibility reasons, the issuer hash is not serialised.

 *

 */

class MCertInfo

	{

 public:

	// Internalization/Externalization

	// Externalize. Writes the data out to a stream

  /** Externalises an object of this class to a write stream.

	* 

	* The presence of this function means that the standard templated operator<<() 

	* can be used to externalise objects of this class.

	* 

	* @param aStream	Stream to which the object should be externalised. */

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

	// Internalize. Reads the data from a stream 

	/** Internalises an object of this class from a read stream.

	* 

	* The presence of this function means that the standard templated operator>>() 

	* can be used to internalise objects of this class.

	* 

	* Note that this function has assignment semantics: it replaces the old value 

	* of the object with a new value read from the read stream.	

	* 

	* @param aStream	Stream from which the object should be internalised. */

	IMPORT_C void InternalizeL(RReadStream& aStream);

 protected:

	IMPORT_C MCertInfo();

	IMPORT_C MCertInfo(const TDesC& aLabel,

					   TCertificateFormat aFormat,

					   TCertificateOwnerType aCertificateOwnerType, 

					   TInt aSize,

					   const TKeyIdentifier* aSubjectKeyId,

					   const TKeyIdentifier* aIssuerKeyId, 

					   TInt aCertificateId,

					   TBool aDeletable);

	IMPORT_C MCertInfo(const MCertInfo& aOther);

	IMPORT_C ~MCertInfo();

	IMPORT_C void ConstructL(const TDesC8* aIssuerHash);

	const TDesC8* IssuerHash() const;

 private:

	TBool Valid() const;

	const MCertInfo& operator=(const MCertInfo& aOther);

 protected:

	TCertLabel iLabel;

	TInt iCertificateId;

	TCertificateFormat iFormat;

	TCertificateOwnerType iCertificateOwnerType;

	TInt iSize;

	TKeyIdentifier iSubjectKeyId;

	TKeyIdentifier iIssuerKeyId;

	TBool iDeletable;

 private:

	HBufC8* iIssuerHash;

	};

/** Encapsulates information about a stored certificate.

 * 

 * Objects of this type are usually returned by a certificate store, to allow 

 * a client to query the contents of the store.

 * 

 * Note that these objects are normally constructed by certificate stores, not 

 * by clients. 

 *

 */

class CCTCertInfo : protected CBase, public MCTTokenObject, public MCertInfo

	{

public:

	/** Construction -- Note that these objects are normally constructed by certificate stores, not by clients. */

	/** 

	*

	* Creates the certificate information object by copying from an existing object.

	* 

	* @param aCertInfo			The source certificate information.

	* @return					A pointer to the new certificate information object.

	* @leave KErrNoMemory	There is no memory to construct it. */

	IMPORT_C static CCTCertInfo* NewL(const CCTCertInfo& aCertInfo);

	/** 

	*

	* Creates the certificate information object by copying from an existing object, 

	* and puts a pointer to the new object onto the cleanup stack.

	* 

	* @param aCertInfo			The source certificate information.

	* @return					A pointer to the new certificate information object.

	* @leave KErrNoMemory	There is no memory to construct it. */

	IMPORT_C static CCTCertInfo* NewLC(const CCTCertInfo& aCertInfo);

	/** 

	*

	* Creates the certificate information object from its constituent parts.

	* 

	* @param aLabel					The certificate's label.

	* @param aFormat				The certificate's format.

	* @param aCertificateOwnerType	The owner type.

	* @param aSize					The size of the certificate.

	* @param aSubjectKeyId			The subject key ID.

	* @param aIssuerKeyId			The issuer key ID.

	* @param aToken					The token that the certificate is within.

	* @param aCertificateId			The ID within the object handle.

	* @param aDeletable				The certificate is deletable.

	* @param aIssuerHash			The hash of the DN of the issuer.

	* @return						A pointer to the new certificate information object. 

	* @leave KErrNoMemory		There is no memory to construct it.*/

	IMPORT_C static CCTCertInfo* NewL(const TDesC& aLabel, TCertificateFormat aFormat,

		TCertificateOwnerType aCertificateOwnerType, TInt aSize,

		const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,

		MCTToken& aToken, TInt aCertificateId, TBool aDeletable, 

									  const TDesC8* aIssuerHash = NULL);

	/** 

	*

	* Creates the certificate information object from its constituent parts.	

	* 

	* @param aLabel					The certificate's label.

	* @param aFormat 				The certificate's format.

	* @param aCertificateOwnerType	The owner type.

	* @param aSize					The size of the certificate.

	* @param aSubjectKeyId			The subject key ID.

	* @param aIssuerKeyId			The issuer key ID.

	* @param aToken					The token that the certificate is within.

	* @param aCertificateId			The ID within the object handle.

	* @return 						A pointer to the new certificate information object.

	* @leave KErrNoMemory		There is no memory to construct it.*/

	IMPORT_C static CCTCertInfo* NewL(const TDesC& aLabel, TCertificateFormat aFormat,

		TCertificateOwnerType aCertificateOwnerType, TInt aSize,

		const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,

		MCTToken& aToken, TInt aCertificateId);

	/** 

	* 

	* Creates the certificate information object from its constituent parts, 

	* and puts a pointer to the new object onto the cleanup stack.

	* 

	* @param aLabel					The certificate's label.

	* @param aFormat				The certificate's format.

	* @param aCertificateOwnerType	The owner type.

	* @param aSize					The size of the certificate.

	* @param aSubjectKeyId			The subject key ID.

	* @param aIssuerKeyId			The issuer key ID.

	* @param aToken					The token that the certificate is within.

	* @param aCertificateId			The ID within the object handle.

	* @param aDeletable				The certificate is deletable.

	* @param aIssuerHash			The hash of the issuer's DN.

	* @return						A pointer to the new certificate information object. 

	* @leave KErrNoMemory		There is no memory to construct it.*/

	IMPORT_C static CCTCertInfo* NewLC(const TDesC& aLabel, TCertificateFormat aFormat,

		TCertificateOwnerType aCertificateOwnerType, TInt aSize,

		const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,

		MCTToken& aToken, TInt aCertificateId, TBool aDeletable, 

									   const TDesC8* aIssuerHash = NULL);

	/**

	*

	* Creates the certificate information object from its constituent parts, and puts 

	* a pointer to the new object onto the cleanup stack.

	* 

	* @param aLabel					The certificate's label.

	* @param aFormat				The certificate's format.

	* @param aCertificateOwnerType	The owner type.

	* @param aSize					The size of the certificate.

	* @param aSubjectKeyId			The subject key ID.

	* @param aIssuerKeyId			The issuer key ID.

	* @param aToken					The token that the certificate is within.

	* @param aCertificateId			The ID within the object handle.

	* @return						A pointer to the new certificate information object.

	* @leave KErrNoMemory		There is no memory to construct it.*/

	IMPORT_C static CCTCertInfo* NewLC(const TDesC& aLabel, TCertificateFormat aFormat,

		TCertificateOwnerType aCertificateOwnerType, TInt aSize,

		const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,

		MCTToken& aToken, TInt aCertificateId);

	/** 

	* 

	* Creates the certificate information object by internalising a previously externalised 

	* one.

	* 

	* @param aStream			The stream from which the object is to be internalised.

	* @param aToken				The token that it is within.

	* @return					A pointer to the new certificate information object. 

	* @leave KErrNoMemory	There is no memory to construct it.

	* @see ExternalizeL

	* @see InternalizeL */

	IMPORT_C static CCTCertInfo* NewL(RReadStream& aStream, MCTToken& aToken);

	/** 

	* 

	* Creates the certificate information object, by internalising a previously externalised 

	* one, and puts a pointer to the new object onto the cleanup stack.	

	* 

	* @param aStream			The stream from which the object is to be internalised.

	* @param aToken				The token that it is within.

	* @return					A pointer to the new certificate information object. 

	* @leave KErrNoMemory	There is no memory to construct it.

	* @see ExternalizeL

	* @see InternalizeL */

	IMPORT_C static CCTCertInfo* NewLC(RReadStream& aStream, MCTToken& aToken);

	/** Gets the subject key ID.	

	* 

	* @return A reference to a key identifier object. */

	IMPORT_C const TKeyIdentifier& SubjectKeyId() const;

	/** Gets the issuer key ID.

	* 

	* @return A reference to a key identifier object. */

	IMPORT_C const TKeyIdentifier& IssuerKeyId() const;

	/** Gets the certificate format.

	* 

	* @return The certificate format. */

	IMPORT_C TCertificateFormat CertificateFormat() const;

	/** Gets the owner type.

	* 

	* @return The owner type. */

	IMPORT_C TCertificateOwnerType CertificateOwnerType() const;

	/** Gets the size of the certificate.

	* 

	* Note that this function must be called so that the correct size of descriptor 

	* can be allocated when retrieving the certificate (with MCertStore::Retrieve()).

	* 

	* @return The size of the certificate. */

	IMPORT_C TInt Size() const;

	/** Gets a handle for the object.

	* 

	* The primary purpose of the handle is to allow token objects to be 'passed' 

	* between processes.

	* 

	* @return	A handle for the object. 

	* @see TCTTokenObjectHandle */

	IMPORT_C TCTTokenObjectHandle Handle() const;

	/** Whether the certificate is deletable.

	* 

	* @return	ETrue if it is possible to delete the certificate; EFalse, otherwise. */

	IMPORT_C TBool IsDeletable() const;

	/** Gets the hash of the issuer's DN.

	* 

	* @return	The hash of the issuer's DN, or NULL if not known. */

	IMPORT_C const TDesC8* IssuerHash() const;

 public:	

  // from MCTTokenObject

	/** Gets the object's human-readable label.

	* 

	* @return	The object's human-readable label.

	* @see MCTTokenObject::Label()*/

	virtual const TDesC& Label() const;

	/** Gets a reference to the associated token.

	* 

	* @return	A reference to the associated token.

	* @see MCTTokenObject::Token()*/

	virtual MCTToken& Token() const;

	/** Gets a UID representing the type of the token object.

	* 

	* The function overrides MCTTokenObject::Type().

	* 

	* The meanings of possible UIDs should be documented in the documentation for 

	* the interface that returns them.

	* 

	* @return	A UID representing the type of the token object; this implementation 

	* 			returns KCTObjectCertInfo.

	* @see MCTTokenObject::Type() */

	virtual TUid Type() const;

	// Compares 2 cert infos

	/** Compares this certificate information object with a specified Certificate 

	* Information object for equality.

	* 

	* @param aCertInfo	The certificate information object to be compared.

	* @return			ETrue, if they are the same; EFalse, otherwise. */

	IMPORT_C TBool operator ==(const CCTCertInfo& aCertInfo) const;

	/** Sets the certificate Id.

	* 

	* @param aCertId The certificate Id.*/

	IMPORT_C void SetCertificateId(TInt aCertId);

 protected:

	IMPORT_C virtual ~CCTCertInfo();

 private:

	CCTCertInfo(MCTToken& aToken);

	CCTCertInfo(const TDesC& aLabel, TCertificateFormat aFormat,

				TCertificateOwnerType aCertificateOwnerType, 

				TInt aSize,

				const TKeyIdentifier* aSubjectKeyId,

				const TKeyIdentifier* aIssuerKeyId,

				MCTToken& aToken, TInt aCertificateId,

				TBool aDeletable);

	CCTCertInfo(const CCTCertInfo& aCertInfo);

	void ConstructL(RReadStream& aStream);

	void ConstructL(const TDesC8* aIssuerHash);

 private:

	const CCTCertInfo& operator=(const CCTCertInfo& aOther);

 private:	

	MCTToken& iToken;

	};

#endif