/*

* Copyright (c) 2004 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    "CCMSKEKRecipientInfo.h"

#include "CCMSX509AlgorithmIdentifier.h"

#include "CCMSKeyIdentifier.h"

#include <asn1dec.h>

#include <asn1enc.h>

// CONSTANTS

const TInt KNumberOfSubModules = 4;

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

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

// CCMSKEKRecipientInfo::CCMSKEKRecipientInfo

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

// might leave.

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

//

EXPORT_C CCMSKEKRecipientInfo::CCMSKEKRecipientInfo( )

    : CCMSRecipientInfo( KCMSKEKRecipientInfoVersion )

    {

    }

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

// CCMSKEKRecipientInfo::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CCMSKEKRecipientInfo::ConstructL(

    const CCMSKeyIdentifier& aKekid,

    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,

	const TDesC8& aEncryptedKey )

    {

    BaseConstructL( aKeyEncryptionAlgorithm );

    SetKekidL( aKekid );

	SetEncryptedKeyL( aEncryptedKey );

    }

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

// CCMSKEKRecipientInfo::NewLC

// Two-phased constructor.

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

//

EXPORT_C CCMSKEKRecipientInfo* CCMSKEKRecipientInfo::NewLC()

	{

	CCMSKEKRecipientInfo* self =

    	new( ELeave ) CCMSKEKRecipientInfo( );

    CleanupStack::PushL( self );

    // creating with empty/default values

    CCMSX509AlgorithmIdentifier* algorithmIdentifier =

        CCMSX509AlgorithmIdentifier::NewL();

    CleanupStack::PushL( algorithmIdentifier );

    CCMSKeyIdentifier* kekid = CCMSKeyIdentifier::NewL();

    CleanupStack::PushL( kekid );

	self->ConstructL( *kekid, *algorithmIdentifier, KNullDesC8() );

    CleanupStack::PopAndDestroy( 2 ); // kekid, algorithmIdentifier

	return self;

	}

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

// CCMSKEKRecipientInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSKEKRecipientInfo* CCMSKEKRecipientInfo::NewL()

	{

    CCMSKEKRecipientInfo* self = NewLC();

    CleanupStack::Pop( self );

	return self;

	}

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

// CCMSKEKRecipientInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSKEKRecipientInfo* CCMSKEKRecipientInfo::NewL(

    const CCMSKeyIdentifier& aKekid,

    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,

    const TDesC8& aEncryptedKey )

	{

    CCMSKEKRecipientInfo* self =

    	new( ELeave ) CCMSKEKRecipientInfo( );

    CleanupStack::PushL( self );

    self->ConstructL( aKekid, aKeyEncryptionAlgorithm,

                      aEncryptedKey );

    CleanupStack::Pop( self );

	return self;

	}

// Destructor

CCMSKEKRecipientInfo::~CCMSKEKRecipientInfo()

    {

	delete iEncryptedKey;

    delete iKekid;

    }

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

// CCMSKEKRecipientInfo::DecodeL

// Decrypts raw data to this instance

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

void CCMSKEKRecipientInfo::DecodeL( const TDesC8& aRawData )

	{

    TASN1DecGeneric decGen( aRawData );

    decGen.InitL();

    // accept only sequence or implicit [2] tag

    if( ( decGen.Tag() != EASN1Sequence ) &&

        ( decGen.Tag() != KCMSKEKRecipientInfoTag ) )

        {

        User::Leave( KErrArgument );

        }

    TASN1DecSequence decSeq;

    CArrayPtr< TASN1DecGeneric >* itemsData = decSeq.DecodeDERLC( decGen );

    TInt count = itemsData->Count();

    if( count != KNumberOfSubModules )

        {

        User::Leave( KErrArgument );

        }

    // Decode version

    TASN1DecGeneric versionDec( *itemsData->At( 0 ) );

    versionDec.InitL();

    TASN1DecInteger intDecoder;

    TInt version = intDecoder.DecodeDERShortL( versionDec );

    // decode kekid KEKIdentifier

    CCMSKeyIdentifier* keyId = CCMSKeyIdentifier::NewL();

    CleanupStack::PushL( keyId );

    keyId->DecodeL( itemsData->At( 1 )->Encoding() );

    // decode keyEncryptionAlgorithm KeyEncryptionAlgorithmIdentifier

    CCMSX509AlgorithmIdentifier* algId = CCMSX509AlgorithmIdentifier::NewL();

    CleanupStack::PushL( algId );

    algId->DecodeL( itemsData->At( 2 )->Encoding() );

    // decode encryptedKey

    TASN1DecGeneric keyDecoder( *itemsData->At( 3 ) );

    TASN1DecOctetString octetStringDecoder;

    keyDecoder.InitL();

    HBufC8* tmp = octetStringDecoder.DecodeDERL( keyDecoder );

    // now we have created all new members, so we can change state

    iVersion = version;

    delete iKekid;

    iKekid = keyId;

    delete iKeyEncryptionAlgorithm;

    iKeyEncryptionAlgorithm = algId;

    delete iEncryptedKey;

    iEncryptedKey = tmp;

    CleanupStack::Pop( 2 ); // algId, keyId

    CleanupStack::PopAndDestroy( itemsData );

	}

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

// CCMSKEKRecipientInfo::EncoderLC

// Returns ASN1 encoder for this instance

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

CASN1EncBase* CCMSKEKRecipientInfo::EncoderLC() const

	{

    CASN1EncSequence* root = CASN1EncSequence::NewLC();

    // encode version

    AddVersionL( root );

    // encode kekid

    HBufC8* encodedKekId = NULL;

    iKekid->EncodeL( encodedKekId );

    CleanupStack::PushL( encodedKekId );

    CASN1EncEncoding* kekId = CASN1EncEncoding::NewLC( *encodedKekId );

    root->AddAndPopChildL( kekId );

    CleanupStack::PopAndDestroy( encodedKekId );

    // encode keyEncryptionAlgorithm

    AddKeyEncryptionAlgorithmL( root );

    // encode encryptedKey

    CASN1EncOctetString* encryptedKey =

        CASN1EncOctetString::NewLC( *iEncryptedKey );

    root->AddAndPopChildL( encryptedKey );

    return root;

	}

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

// CCMSKEKRecipientInfo::TaggedEncoderLC

// Returns ASN1 encoder for this instance inside tag

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

CASN1EncBase* CCMSKEKRecipientInfo::TaggedEncoderLC() const

    {

    CASN1EncBase* encoder = EncoderLC();

    encoder->SetTag( KCMSKEKRecipientInfoTag );

    return encoder;

    }

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

// CCMSKEKRecipientInfo::EncryptedKey

// EncryptedKey getter

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

EXPORT_C const TDesC8&

CCMSKEKRecipientInfo::EncryptedKey() const

	{

	return *iEncryptedKey;

	}

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

// CCMSKEKRecipientInfo::Kekid

// KEKIdentifier getter

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

EXPORT_C const CCMSKeyIdentifier&

CCMSKEKRecipientInfo::Kekid() const

	{

	return *iKekid;

	}

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

// CCMSKEKRecipientInfo::SetEncryptedKeyL

// EncryptedKey setter

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

EXPORT_C void CCMSKEKRecipientInfo::SetEncryptedKeyL(

	const TDesC8& aEncryptedKey )

	{

    HBufC8* encryptedKey = aEncryptedKey.AllocL();

    delete iEncryptedKey;

    iEncryptedKey = encryptedKey;

	}

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

// CCMSKEKRecipientInfo::SetKekidL

// iKekid setter

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

EXPORT_C void CCMSKEKRecipientInfo::SetKekidL(

	const CCMSKeyIdentifier& aKekid )

	{

    CCMSKeyIdentifier* keyId = CCMSKeyIdentifier::NewL( aKekid.KeyIdentifier() );

    CleanupStack::PushL( keyId );

    const TTime* date = keyId->Date();

    if( date )

        {

        keyId->SetDateL( *date );

        }

    CleanupStack::Pop( keyId );

    delete iKekid;

    iKekid = keyId;

	}

//  End of File