/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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 FILES

#include <x500dn.h>

#include <asn1dec.h>

#include <asn1enc.h>

#include "CCMSSignedData.h"

// CONSTANTS

const TInt KMinNumberOfSubModules = 4;

const TInt KMaxNumberOfSubModules = 6;

const TInt KDefaultGranularity = 1;

const TInt KDefaultVersion = 1;

const TInt KAlternativeVersion = 3;

const TUint8 KCertificateSetTag = 0;

const TUint8 KRevokedCertificatesTag = 1;

// Defaulta id-data oid

_LIT( KIDDataOID, "1.2.840.113549.1.7.1" );

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CCMSSignedData::CCMSSignedData

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

EXPORT_C CCMSSignedData::CCMSSignedData()

    {

    }

// -----------------------------------------------------------------------------

// CCMSSignedData::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

EXPORT_C void CCMSSignedData::ConstructL()

    {

	iVersion = KDefaultVersion;

	iDigestAlgorithmIdentifiers =

				new( ELeave )CArrayPtrFlat< CCMSX509AlgorithmIdentifier >

														( KDefaultGranularity );

	iContentInfo = CCMSEncapsulatedContentInfo::NewLC();

	CleanupStack::Pop( iContentInfo );

	iSignerInfos =

				new( ELeave )CArrayPtrFlat< CCMSSignerInfo >

														( KDefaultGranularity );

    }

// -----------------------------------------------------------------------------

// CCMSSignedData::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

EXPORT_C void CCMSSignedData::ConstructL(

	const CArrayPtr< CCMSX509AlgorithmIdentifier >& aDigestAlgorithmIdentifiers,

   	const CCMSEncapsulatedContentInfo& aContentInfo,

   	const CArrayPtr< CCMSSignerInfo >& aSignerInfos,

   	const CArrayPtr< CCMSCertificateChoices >* aCertificates,

   	const CArrayPtr< CCMSX509CertificateList >* aRevokedCertificates )

    {

	SetSignerInfosL( aSignerInfos );

	SetDigestAlgorithmIdentifiersL( aDigestAlgorithmIdentifiers );

	SetEncapsulatedContentInfoL( aContentInfo );

	SetCertificatesL( aCertificates );

	SetRevokedCertificatesL( aRevokedCertificates );

    }

// -----------------------------------------------------------------------------

// CCMSSignedData::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CCMSSignedData* CCMSSignedData::NewLC()

	{

	CCMSSignedData* self = new( ELeave ) CCMSSignedData();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CCMSSignedData* CCMSSignedData::NewLC(

	const CArrayPtr< CCMSX509AlgorithmIdentifier >& aDigestAlgorithmIdentifiers,

   	const CCMSEncapsulatedContentInfo& aContentInfo,

   	const CArrayPtr< CCMSSignerInfo >& aSignerInfos )

    {

    CCMSSignedData* self = new( ELeave ) CCMSSignedData();

    CleanupStack::PushL( self );

    self->ConstructL( aDigestAlgorithmIdentifiers,

    				  aContentInfo,

    				  aSignerInfos,

    				  NULL,

    				  NULL );

    return self;

    }

// -----------------------------------------------------------------------------

// CCMSSignedData::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CCMSSignedData* CCMSSignedData::NewLC(

	const CArrayPtr< CCMSX509AlgorithmIdentifier >& aDigestAlgorithmIdentifiers,

   	const CCMSEncapsulatedContentInfo& aContentInfo,

   	const CArrayPtr< CCMSSignerInfo >& aSignerInfos,

   	const CArrayPtr< CCMSCertificateChoices >* aCertificates,

   	const CArrayPtr< CCMSX509CertificateList >* aRevokedCertificates )

    {

    CCMSSignedData* self = new( ELeave ) CCMSSignedData();

    CleanupStack::PushL( self );

    self->ConstructL( aDigestAlgorithmIdentifiers,

    				  aContentInfo,

    				  aSignerInfos,

    				  aCertificates,

    				  aRevokedCertificates );

    return self;

    }

// Destructor

CCMSSignedData::~CCMSSignedData()

    {

	if( iDigestAlgorithmIdentifiers )

		{

		iDigestAlgorithmIdentifiers->ResetAndDestroy();

		delete iDigestAlgorithmIdentifiers;

		}

	delete iContentInfo;

	if( iSignerInfos )

		{

		iSignerInfos->ResetAndDestroy();

		delete iSignerInfos;

		}

	if( iCertificates )

		{

		iCertificates->ResetAndDestroy();

		delete iCertificates;

		}

	if( iRevokedCertificates )

		{

		iRevokedCertificates->ResetAndDestroy();

		delete iRevokedCertificates;

		}

    }

// -----------------------------------------------------------------------------

// CCMSSignedData::DecodeL

// Decrypts raw data to this instance

// -----------------------------------------------------------------------------

void CCMSSignedData::DecodeL( const TDesC8& aRawData )

	{

	CArrayPtr<TASN1DecGeneric>* itemsData =

							DecodeSequenceLC( aRawData,

											  KMinNumberOfSubModules,

											  KMaxNumberOfSubModules );

	TInt pos = 0;

	// decode Version

	TASN1DecInteger version;

	TInt tmpVersion;

	tmpVersion = version.DecodeDERShortL( *itemsData->At( pos++ ) );

	// decode digest algorithms

	CArrayPtrFlat< CCMSX509AlgorithmIdentifier >* tmpAlgs =

		new( ELeave )CArrayPtrFlat< CCMSX509AlgorithmIdentifier >

													( KDefaultGranularity );

	CleanupStack::PushL( tmpAlgs );

	CleanupResetAndDestroyPushL( *tmpAlgs );

	//there must be atleast 1 algorithm

	CArrayPtr<TASN1DecGeneric>* digestAlgorithms =

		DecodeSequenceLC( itemsData->At( pos++ )->Encoding(),

						  1,

						  KMaxTInt );

	TInt algCount = digestAlgorithms->Count();

	for( TInt i = 0; i < algCount; i++ )

		{

		CCMSX509AlgorithmIdentifier* alg =

										CCMSX509AlgorithmIdentifier::NewL();

		CleanupStack::PushL( alg );

		alg->DecodeL( digestAlgorithms->At( i )->Encoding() );

		tmpAlgs->AppendL( alg );

		CleanupStack::Pop( alg );

		}

	CleanupStack::PopAndDestroy( digestAlgorithms );

	// decode encapsulated content info

	CCMSEncapsulatedContentInfo* tmpInfo = CCMSEncapsulatedContentInfo::NewLC();

	tmpInfo->DecodeL( itemsData->At( pos++ )->Encoding() );

	CArrayPtrFlat< CCMSCertificateChoices >* tmpCerts = NULL;

	// decode possible certificate set

	if( itemsData->At( pos )->Tag() == KCertificateSetTag )

		{

		tmpCerts =

			new( ELeave )CArrayPtrFlat< CCMSCertificateChoices >

													( KDefaultGranularity );

		CleanupStack::PushL( tmpCerts );

		CleanupResetAndDestroyPushL( *tmpCerts );

		TASN1DecSequence decSeq;

		CArrayPtr<TASN1DecGeneric>* certs =

			decSeq.DecodeDERLC( *itemsData->At( pos++ ) );

		TInt certCount = certs->Count();

		for( TInt i = 0; i < certCount; i++ )

			{

			CCMSCertificateChoices* tmpCert =

				CCMSCertificateChoices::NewLC();

			tmpCert->DecodeL( certs->At( i )->Encoding() );

			tmpCerts->AppendL( tmpCert );

			CleanupStack::Pop( tmpCert );

			}

		CleanupStack::PopAndDestroy( certs );

		}

	// decode possible revoked certificates

	CArrayPtrFlat< CCMSX509CertificateList >* tmpRevokedCertificates = NULL;

	if( ( pos < itemsData->Count() ) &&

		( itemsData->At( pos )->Tag() == KRevokedCertificatesTag ) )

		{

		tmpRevokedCertificates =

			new( ELeave )CArrayPtrFlat< CCMSX509CertificateList >

													( KDefaultGranularity );

		CleanupStack::PushL( tmpRevokedCertificates );

		CleanupResetAndDestroyPushL( *tmpRevokedCertificates );

		TASN1DecSequence decSeq;

		CArrayPtr<TASN1DecGeneric>* certs =

			decSeq.DecodeDERLC( *itemsData->At( pos++ ) );

		TInt certCount = certs->Count();

		for( TInt i = 0; i < certCount; i++ )

			{

			CCMSX509CertificateList* tmpCert = CCMSX509CertificateList::NewLC();

			tmpCert->DecodeL( certs->At( i )->Encoding() );

			tmpRevokedCertificates->AppendL( tmpCert );

			CleanupStack::Pop( tmpCert );

			}

		CleanupStack::PopAndDestroy( certs );

		}

	// decode Signer Infos

	if( pos >= itemsData->Count() )

		{

		// Missing mandatory signer infos

		User::Leave( KErrArgument );

		}

	CArrayPtrFlat< CCMSSignerInfo >* tmpSignerInfos =

		new( ELeave )CArrayPtrFlat< CCMSSignerInfo >( KDefaultGranularity );

	CleanupStack::PushL( tmpSignerInfos );

	CleanupResetAndDestroyPushL( *tmpSignerInfos );

	CArrayPtr<TASN1DecGeneric>* sInfos =

		DecodeSequenceLC( itemsData->At( pos )->Encoding() );

	TInt sInfoCount = sInfos->Count();

	for( TInt j = 0; j < sInfoCount; j++ )

		{

		CCMSSignerInfo* tmpInfo = CCMSSignerInfo::NewL();

		CleanupStack::PushL( tmpInfo );

		tmpInfo->DecodeL( sInfos->At( j )->Encoding() );

		tmpSignerInfos->AppendL( tmpInfo );

		CleanupStack::Pop( tmpInfo );

		}

	CleanupStack::PopAndDestroy( sInfos );

	// All done, setting new values

	iSignerInfos->ResetAndDestroy();

	delete iSignerInfos;

	iSignerInfos = tmpSignerInfos;

	CleanupStack::Pop( tmpSignerInfos ); // ResetAndDestroy

	CleanupStack::Pop( tmpSignerInfos ); // Normal cleanup

	if( iRevokedCertificates )

		{

		iRevokedCertificates->ResetAndDestroy();

		delete iRevokedCertificates;

		}

	iRevokedCertificates = tmpRevokedCertificates;

	if( tmpRevokedCertificates )

		{

		CleanupStack::Pop( tmpRevokedCertificates ); // ResetAndDestroy

		CleanupStack::Pop( tmpRevokedCertificates ); // Normal cleanup

		}

	if( iCertificates )

		{

		iCertificates->ResetAndDestroy();

		delete iCertificates;

		}

	iCertificates = tmpCerts;

	if( tmpCerts )

		{

		CleanupStack::Pop( tmpCerts ); // ResetAndDestory

		CleanupStack::Pop( tmpCerts ); // Normal cleanup

		}

	delete iContentInfo;

	iContentInfo = tmpInfo;

	CleanupStack::Pop( tmpInfo );

	iDigestAlgorithmIdentifiers->ResetAndDestroy();

	delete iDigestAlgorithmIdentifiers;

	iDigestAlgorithmIdentifiers = tmpAlgs;

	CleanupStack::Pop( tmpAlgs ); // ResetAndDestroy

	CleanupStack::Pop( tmpAlgs ); // Normal cleanup

	iVersion = tmpVersion;

	CleanupStack::PopAndDestroy( itemsData );

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::EncoderLC

// Returns ASN1 encoder for this instance

// -----------------------------------------------------------------------------

CASN1EncBase* CCMSSignedData::EncoderLC() const

	{

	CASN1EncSequence* root = CASN1EncSequence::NewLC();

	// Add version

	CASN1EncInt* version = CASN1EncInt::NewLC( iVersion );

	root->AddAndPopChildL( version );

	// Add digest algorithms

	CASN1EncSequence* digestAlgorithms = CASN1EncSequence::NewLC();

	digestAlgorithms->SetTag( EASN1Set, EUniversal );

	TInt count = iDigestAlgorithmIdentifiers->Count();

	if( count == 0 )

		{

		// there is no mandatory algorithms

		User::Leave( KErrArgument );

		}

	for( TInt i = 0; i < count; i++ )

		{

		CCMSX509AlgorithmIdentifier* alg =

			iDigestAlgorithmIdentifiers->At( i );

		CASN1EncBase* algEnc = alg->EncoderLC();

		digestAlgorithms->AddAndPopChildL( algEnc );

		}

	root->AddAndPopChildL( digestAlgorithms );

	// add encapsulated content info

	CASN1EncBase* encContentInfo = iContentInfo->EncoderLC();

	root->AddAndPopChildL( encContentInfo );

	// add possible certificates

	if( iCertificates &&

		iCertificates->Count() > 0 )

		{

		CASN1EncSequence* certificates = CASN1EncSequence::NewLC();

		certificates->SetTag( KCertificateSetTag );

		TInt certCount = iCertificates->Count();

		for( TInt i = 0; i < certCount; i++ )

			{

			CCMSCertificateChoices* cert = iCertificates->At( i );

			CASN1EncBase* certEnc = cert->EncoderLC();

			certificates->AddAndPopChildL( certEnc );

			}

		root->AddAndPopChildL( certificates );

		}

	// add possible revoked certificates

	if( iRevokedCertificates &&

		iRevokedCertificates->Count() > 0 )

		{

		CASN1EncSequence* certificates = CASN1EncSequence::NewLC();

		certificates->SetTag( KRevokedCertificatesTag );

		TInt certCount = iRevokedCertificates->Count();

		for( TInt i = 0; i < certCount; i++ )

			{

			CCMSX509CertificateList* list = iRevokedCertificates->At( i );

			CASN1EncBase* rCerts = list->EncoderLC();

			certificates->AddAndPopChildL( rCerts );

			}

		root->AddAndPopChildL( certificates );

		}

	// add signer infos

	CASN1EncSequence* signerInfos = CASN1EncSequence::NewLC();

	signerInfos->SetTag( EASN1Set, EUniversal );

	TInt sCount = iSignerInfos->Count();

	if( sCount == 0 )

		{

		// there is no mandatory signer infos

		User::Leave( KErrArgument );

		}

	for( TInt j = 0; j < sCount; j++ )

		{

		CASN1EncBase* sInfo = iSignerInfos->At( j )->EncoderLC();

		signerInfos->AddAndPopChildL( sInfo );

		}

	root->AddAndPopChildL( signerInfos );

	return root;

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::Version

// Getter for Version

// -----------------------------------------------------------------------------

EXPORT_C TInt CCMSSignedData::Version() const

	{

	return iVersion;

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::DigestAlgorithmIdentifiers

// Getter for DigestAlgorithmIdentifiers

// -----------------------------------------------------------------------------

EXPORT_C const CArrayPtr< CCMSX509AlgorithmIdentifier >&

	CCMSSignedData::DigestAlgorithmIdentifiers() const

	{

	return *iDigestAlgorithmIdentifiers;

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::EncapsulatedContentInfo

// Getter for EncapsulatedContentInfo

// -----------------------------------------------------------------------------

EXPORT_C const CCMSEncapsulatedContentInfo&

	CCMSSignedData::EncapsulatedContentInfo() const

	{

	return *iContentInfo;

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::SignerInfos

// Getter for SignerInfos

// -----------------------------------------------------------------------------

EXPORT_C const CArrayPtr< CCMSSignerInfo >&

	CCMSSignedData::SignerInfos() const

	{

	return *iSignerInfos;

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::Certificates

// Getter for Certificates

// -----------------------------------------------------------------------------

EXPORT_C const CArrayPtr< CCMSCertificateChoices >*

	CCMSSignedData::Certificates() const

	{

	return iCertificates;

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::RevokedCertificates

// Getter for RevokedCertificates

// -----------------------------------------------------------------------------

EXPORT_C const CArrayPtr< CCMSX509CertificateList >*

	CCMSSignedData::RevokedCertificates() const

	{

	return iRevokedCertificates;

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::SetDigestAlgorithmIdentifiersL

// Setter for DigestAlgorithmIdentifiers, takes copy

// -----------------------------------------------------------------------------

EXPORT_C void CCMSSignedData::SetDigestAlgorithmIdentifiersL(

	const CArrayPtr< CCMSX509AlgorithmIdentifier >& aDigestAlgorithmIdentifiers )

	{

	CArrayPtrFlat< CCMSX509AlgorithmIdentifier >* tmpAlgs =

		new( ELeave )CArrayPtrFlat< CCMSX509AlgorithmIdentifier >( KDefaultGranularity );

	CleanupStack::PushL( tmpAlgs );

	TInt algCount = aDigestAlgorithmIdentifiers.Count();

	for( TInt i = 0; i < algCount; i++ )

		{

		CCMSX509AlgorithmIdentifier* origAlg = aDigestAlgorithmIdentifiers[ i ];

		CCMSX509AlgorithmIdentifier* tmpAlg = NULL;

		if( origAlg->DigestAlgorithm() )

			{

			tmpAlg =

			CCMSX509AlgorithmIdentifier::NewL( origAlg->AlgorithmIdentifier(),

											   *origAlg->DigestAlgorithm() );

			}

		else

			{

			tmpAlg =

			CCMSX509AlgorithmIdentifier::NewL( origAlg->AlgorithmIdentifier() );

			}

		CleanupStack::PushL( tmpAlg );

		tmpAlgs->AppendL( tmpAlg );

		CleanupStack::Pop( tmpAlg );

		}

	delete iDigestAlgorithmIdentifiers;

	iDigestAlgorithmIdentifiers = tmpAlgs;

	CleanupStack::Pop( tmpAlgs );

	}

// -----------------------------------------------------------------------------

// CCMSSignedData::SetEncapsulatedContentInfoL

// Setter for EncapsulatedContentInfo, takes copy

// -----------------------------------------------------------------------------

EXPORT_C void CCMSSignedData::SetEncapsulatedContentInfoL(

	const CCMSEncapsulatedContentInfo& aContentInfo )

	{

	CCMSEncapsulatedContentInfo* copy =

		CCMSEncapsulatedContentInfo::NewLC( aContentInfo.ContentType(),

											aContentInfo.Content() );

	delete iContentInfo;

	iContentInfo = copy;

	CleanupStack::Pop( copy );

	ValidateVersion();