/*

* 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    "CCMSKeyTransRecipientInfo.h"

#include "CCMSIssuerAndSerialNumber.h"

#include "CCMSX509AlgorithmIdentifier.h"

#include <asn1dec.h>

#include <asn1enc.h>

// CONSTANTS

const TInt KNumberOfSubModules = 4;

const TTagType KSubjectKeyIdentifierTag = 0;

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

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

// CCMSKeyTransRecipientInfo::CCMSKeyTransRecipientInfo

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

// might leave.

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

//

EXPORT_C CCMSKeyTransRecipientInfo::CCMSKeyTransRecipientInfo( TInt aVersion)

    : CCMSRecipientInfo( aVersion )

    {

    }

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

// CCMSKeyTransRecipientInfo::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CCMSKeyTransRecipientInfo::ConstructL(

    const CCMSIssuerAndSerialNumber& aIssuerAndSerialNumber,

    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,

	const TDesC8& aEncryptedKey )

    {

    BaseConstructL( aKeyEncryptionAlgorithm );

    SetIssuerAndSerialNumberL( aIssuerAndSerialNumber );

	SetEncryptedKeyL( aEncryptedKey );

    }

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

// CCMSKeyTransRecipientInfo::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CCMSKeyTransRecipientInfo::ConstructL(

    const TDesC8& aSubjectKeyIdentifier,

    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,

	const TDesC8& aEncryptedKey )

    {

    BaseConstructL( aKeyEncryptionAlgorithm );

    SetSubjectKeyIdentifierL( aSubjectKeyIdentifier );

	SetEncryptedKeyL( aEncryptedKey );

    }

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

// CCMSKeyTransRecipientInfo::NewLC

// Two-phased constructor.

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

//

EXPORT_C CCMSKeyTransRecipientInfo* CCMSKeyTransRecipientInfo::NewLC()

	{

	// creating with empty/default values

    CCMSKeyTransRecipientInfo* self =

    	new( ELeave ) CCMSKeyTransRecipientInfo(

            KCMSKeyTransRecipientInfoSubjectKeyIdentifierVersion );

    CleanupStack::PushL( self );

    CCMSX509AlgorithmIdentifier* algorithmIdentifier =

        CCMSX509AlgorithmIdentifier::NewL();

    CleanupStack::PushL( algorithmIdentifier );

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

    CleanupStack::PopAndDestroy( algorithmIdentifier );

	return self;

	}

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

// CCMSKeyTransRecipientInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSKeyTransRecipientInfo* CCMSKeyTransRecipientInfo::NewL()

	{

	// creating with empty/default values

	CCMSKeyTransRecipientInfo* self = NewLC();

    CleanupStack::Pop( self );

	return self;

	}

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

// CCMSKeyTransRecipientInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSKeyTransRecipientInfo* CCMSKeyTransRecipientInfo::NewL(

    const CCMSIssuerAndSerialNumber& aIssuerAndSerialNumber,

    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,

    const TDesC8& aEncryptedKey )

	{

    CCMSKeyTransRecipientInfo* self =

    	new( ELeave ) CCMSKeyTransRecipientInfo(

            KCMSKeyTransRecipientInfoIssuerAndSerialNumberVersion );

    CleanupStack::PushL( self );

    self->ConstructL( aIssuerAndSerialNumber, aKeyEncryptionAlgorithm,

                      aEncryptedKey );

    CleanupStack::Pop( self );

	return self;

	}

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

// CCMSKeyTransRecipientInfo::NewLC

// Two-phased constructor.

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

//

EXPORT_C CCMSKeyTransRecipientInfo* CCMSKeyTransRecipientInfo::NewLC(

    const TDesC8& aSubjectKeyIdentifier,

    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,

    const TDesC8& aEncryptedKey )

	{

    CCMSKeyTransRecipientInfo* self =

    	new( ELeave ) CCMSKeyTransRecipientInfo(

            KCMSKeyTransRecipientInfoSubjectKeyIdentifierVersion );

    CleanupStack::PushL( self );

    self->ConstructL( aSubjectKeyIdentifier, aKeyEncryptionAlgorithm,

                      aEncryptedKey );

	return self;

	}

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

// CCMSKeyTransRecipientInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSKeyTransRecipientInfo* CCMSKeyTransRecipientInfo::NewL(

    const TDesC8& aSubjectKeyIdentifier,

    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,

    const TDesC8& aEncryptedKey )

	{

    CCMSKeyTransRecipientInfo* self =

        NewLC( aSubjectKeyIdentifier, aKeyEncryptionAlgorithm, aEncryptedKey );

    CleanupStack::Pop( self );

	return self;

	}

// Destructor

CCMSKeyTransRecipientInfo::~CCMSKeyTransRecipientInfo()

    {

	delete iEncryptedKey;

    delete iIssuerAndSerialNumber;

    delete iSubjectKeyIdentifier;

    }

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

// CCMSKeyTransRecipientInfo::DecodeL

// Decrypts raw data to this instance

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

void CCMSKeyTransRecipientInfo::DecodeL( const TDesC8& aRawData )

	{

    CArrayPtr< TASN1DecGeneric >* itemsData =

        DecodeSequenceLC( aRawData, KNumberOfSubModules, KNumberOfSubModules );

    // Decode version

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

    versionDec.InitL();

    TASN1DecInteger intDecoder;

    TInt version = intDecoder.DecodeDERShortL( versionDec );

    // decode rid RecipientIdentifier

    TASN1DecOctetString octetStringDecoder;

    TASN1DecGeneric ridDec( *itemsData->At( 1 ) );

    HBufC8* keyIdentifier = NULL;

    CCMSIssuerAndSerialNumber* issuer = NULL;

    switch( version )

        {

        case KCMSKeyTransRecipientInfoSubjectKeyIdentifierVersion:

            {

            if( ridDec.Tag() != KSubjectKeyIdentifierTag )

                {

                User::Leave( KErrArgument );

                }

            TInt pos = 0;

            keyIdentifier = octetStringDecoder.DecodeDERL(

                ridDec.GetContentDER(), pos );

            CleanupStack::PushL( keyIdentifier );

            break;

            }

        case KCMSKeyTransRecipientInfoIssuerAndSerialNumberVersion:

            {

            issuer = CCMSIssuerAndSerialNumber::NewL();

            CleanupStack::PushL( issuer );

            issuer->DecodeL( ridDec.Encoding() );

            break;

            }

        default:

            {

            User::Leave( KErrArgument );

            }

        }

    // decode keyEncryptionAlgorithm

    CCMSX509AlgorithmIdentifier* algId = CCMSX509AlgorithmIdentifier::NewL();

    CleanupStack::PushL( algId );

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

    // decode encryptedKey

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

    keyDecoder.InitL();

    HBufC8* tmp = octetStringDecoder.DecodeDERL( keyDecoder );

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

    iVersion = version;

    delete iSubjectKeyIdentifier;

    iSubjectKeyIdentifier = keyIdentifier;

    delete iIssuerAndSerialNumber;

    iIssuerAndSerialNumber = issuer;

    delete iKeyEncryptionAlgorithm;

    iKeyEncryptionAlgorithm = algId;

    delete iEncryptedKey;

    iEncryptedKey = tmp;

    CleanupStack::Pop( 2 ); // keyIdentifier/issuer, algId

    CleanupStack::PopAndDestroy( itemsData );

	}

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

// CCMSKeyTransRecipientInfo::EncoderLC

// Returns ASN1 encoder for this instance

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

CASN1EncBase* CCMSKeyTransRecipientInfo::EncoderLC() const

	{

    CASN1EncSequence* root = CASN1EncSequence::NewLC();

    // encode version

    AddVersionL( root );

    // encode rid RecipientIdentifier

    if( iIssuerAndSerialNumber )

        {

        // encode issuerAndSerialNumber

        HBufC8* encodedIssuer = NULL;

        iIssuerAndSerialNumber->EncodeL( encodedIssuer );

        CleanupStack::PushL( encodedIssuer );

        CASN1EncEncoding* issuer = CASN1EncEncoding::NewLC( *encodedIssuer );

        root->AddAndPopChildL( issuer );

        CleanupStack::PopAndDestroy( encodedIssuer );

        }

    else

        {

        // encode subjectKeyIdentifier [0] SubjectKeyIdentifier

        CASN1EncOctetString* subjectKeyIdentifier =

            CASN1EncOctetString::NewL( *iSubjectKeyIdentifier );

        CASN1EncExplicitTag* taggedIdentifier =

            CASN1EncExplicitTag::NewLC( subjectKeyIdentifier, KSubjectKeyIdentifierTag );

        root->AddAndPopChildL( taggedIdentifier );

        }

    // encode keyEncryptionAlgorithm KeyEncryptionAlgorithmIdentifier

    AddKeyEncryptionAlgorithmL( root );

    // encode encryptedKey

    CASN1EncOctetString* encryptedKey =

        CASN1EncOctetString::NewLC( *iEncryptedKey );

    root->AddAndPopChildL( encryptedKey );

    return root;

	}

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

// CCMSKeyTransRecipientInfo::TaggedEncoderLC

// Returns ASN1 encoder for this instance

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

CASN1EncBase* CCMSKeyTransRecipientInfo::TaggedEncoderLC() const

    {

    return EncoderLC();

    }

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

// CCMSKeyTransRecipientInfo::EncryptedKey

// EncryptedKey getter

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

EXPORT_C const TDesC8&

CCMSKeyTransRecipientInfo::EncryptedKey() const

	{

	return *iEncryptedKey;

	}

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

// CCMSKeyTransRecipientInfo::IssuerAndSerialNumber

// IssuerAndSerialNumber getter

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

EXPORT_C const CCMSIssuerAndSerialNumber*

CCMSKeyTransRecipientInfo::IssuerAndSerialNumber() const

	{

	return iIssuerAndSerialNumber;

	}

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

// CCMSKeyTransRecipientInfo::SubjectKeyIdentifier

// SubjectKeyIdentifier getter

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

EXPORT_C const TDesC8*

CCMSKeyTransRecipientInfo::SubjectKeyIdentifier() const

	{

	return iSubjectKeyIdentifier;

	}

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

// CCMSKeyTransRecipientInfo::SetEncryptedKeyL

// EncryptedKey setter

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

EXPORT_C void CCMSKeyTransRecipientInfo::SetEncryptedKeyL(

	const TDesC8& aEncryptedKey )

	{

    HBufC8* encryptedKey = aEncryptedKey.AllocL();

    delete iEncryptedKey;

    iEncryptedKey = encryptedKey;

	}

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

// CCMSKeyTransRecipientInfo::SetIssuerAndSerialNumberL

// IssuerAndSerialNumber setter, deletes also SubjectKeyIdentifier and

// sets version to KVersionIssuerAndSerialNumber

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

EXPORT_C void CCMSKeyTransRecipientInfo::SetIssuerAndSerialNumberL(

	const CCMSIssuerAndSerialNumber& aIssuerAndSerialNumber )

	{

    CCMSIssuerAndSerialNumber* issuer = CCMSIssuerAndSerialNumber::NewL(

        aIssuerAndSerialNumber.IssuerName(),

        aIssuerAndSerialNumber.SerialNumber() );

    delete iSubjectKeyIdentifier;

    iSubjectKeyIdentifier = NULL;

    delete iIssuerAndSerialNumber;

    iIssuerAndSerialNumber = issuer;

    iVersion = KCMSKeyTransRecipientInfoIssuerAndSerialNumberVersion;

	}

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

// CCMSKeyTransRecipientInfo::SetSubjectKeyIdentifierL

// SubjectKeyIdentifier setter. Copies parameters, deletes also

// IssuerAndSerialNumber and set version to KVersionSubjectKeyIdentifier

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

EXPORT_C void CCMSKeyTransRecipientInfo::SetSubjectKeyIdentifierL(

	const TDesC8& aSubjectKeyIdentifier )

	{

    HBufC8* identifier = aSubjectKeyIdentifier.AllocL();

    delete iIssuerAndSerialNumber;

    iIssuerAndSerialNumber = NULL;

    delete iSubjectKeyIdentifier;

    iSubjectKeyIdentifier = identifier;

    iVersion = KCMSKeyTransRecipientInfoSubjectKeyIdentifierVersion;

	}

//  End of File