/*
* 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    "CCMSRecipientEncryptedKey.h"
#include "CCMSIssuerAndSerialNumber.h"
#include "CCMSKeyIdentifier.h"
#include <asn1dec.h>
#include <asn1enc.h>

// CONSTANTS
const TInt KNumberOfSubModules = 2;
const TTagType KRKeyIdTag = 0;

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

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::CCMSRecipientEncryptedKey
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSRecipientEncryptedKey::CCMSRecipientEncryptedKey()
    {
    }

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSRecipientEncryptedKey::ConstructL(
    const CCMSIssuerAndSerialNumber& aIssuerAndSerialNumber,
	const TDesC8& aEncryptedKey )
    {
    SetIssuerAndSerialNumberL( aIssuerAndSerialNumber );
	SetEncryptedKeyL( aEncryptedKey );
    }

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSRecipientEncryptedKey::ConstructL(
    const CCMSKeyIdentifier& aRKeyId,
	const TDesC8& aEncryptedKey )
    {
    SetRKeyIdL( aRKeyId );
	SetEncryptedKeyL( aEncryptedKey );
    }


// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSRecipientEncryptedKey* CCMSRecipientEncryptedKey::NewL()
	{
	// creating with empty/default values
    CCMSIssuerAndSerialNumber* issuer = CCMSIssuerAndSerialNumber::NewL();
    CleanupStack::PushL( issuer );
	CCMSRecipientEncryptedKey* self = NewL( *issuer, KNullDesC8() );
    CleanupStack::PopAndDestroy( issuer );
	return self;
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::NewL
// Two-phased copy constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSRecipientEncryptedKey* CCMSRecipientEncryptedKey::NewL(
    const CCMSIssuerAndSerialNumber& aIssuerAndSerialNumber,
    const TDesC8& aEncryptedKey )
	{
    CCMSRecipientEncryptedKey* self =
    	new( ELeave ) CCMSRecipientEncryptedKey();

    CleanupStack::PushL( self );
    self->ConstructL( aIssuerAndSerialNumber, aEncryptedKey );
    CleanupStack::Pop( self );
	return self;
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::NewL
// Two-phased copy constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSRecipientEncryptedKey* CCMSRecipientEncryptedKey::NewL(
    const CCMSKeyIdentifier& aRKeyId,
    const TDesC8& aEncryptedKey )
	{
    CCMSRecipientEncryptedKey* self =
    	new( ELeave ) CCMSRecipientEncryptedKey();

    CleanupStack::PushL( self );
    self->ConstructL( aRKeyId, aEncryptedKey );
    CleanupStack::Pop( self );
	return self;
	}


// Destructor
CCMSRecipientEncryptedKey::~CCMSRecipientEncryptedKey()
    {
	delete iEncryptedKey;
    delete iIssuerAndSerialNumber;
    delete iRKeyId;
    }

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::DecodeL
// Decrypts raw data to this instance
// -----------------------------------------------------------------------------
void CCMSRecipientEncryptedKey::DecodeL( const TDesC8& aRawData )
	{
    CArrayPtr< TASN1DecGeneric >* itemsData =
        DecodeSequenceLC( aRawData, KNumberOfSubModules, KNumberOfSubModules );

    // decode rid KeyAgreeRecipientIdentifier
    TASN1DecGeneric gen( *itemsData->At( 0 ) );
    gen.InitL();
    if( gen.Tag() == KRKeyIdTag )
        {
        // decode rKeyId
        CCMSKeyIdentifier* keyId = CCMSKeyIdentifier::NewL();
        CleanupStack::PushL( keyId );
        keyId->DecodeImplicitTagL( gen.Encoding(), KRKeyIdTag );
        CleanupStack::Pop( keyId );
        delete iIssuerAndSerialNumber;
        iIssuerAndSerialNumber = NULL;
        delete iRKeyId;
        iRKeyId = keyId;
        }
    else
        {
        // delete issuerAndSerialNumber
        CCMSIssuerAndSerialNumber* issuer = CCMSIssuerAndSerialNumber::NewL();
        CleanupStack::PushL( issuer );
        issuer->DecodeL( gen.Encoding() );
        CleanupStack::Pop( issuer );
        delete iRKeyId;
        iRKeyId = NULL;
        delete iIssuerAndSerialNumber;
        iIssuerAndSerialNumber = issuer;
        }

    //decode encryptedKey
    TASN1DecGeneric keyDecoder( *itemsData->At( 1 ) );
    keyDecoder.InitL();
    TASN1DecOctetString octetStringDecoder;
    HBufC8* tmp = octetStringDecoder.DecodeDERL( keyDecoder );
    delete iEncryptedKey;
    iEncryptedKey = tmp;
    CleanupStack::PopAndDestroy( itemsData );
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::EncoderLC
// Returns ASN1 encoder for this instance
// -----------------------------------------------------------------------------

CASN1EncBase* CCMSRecipientEncryptedKey::EncoderLC() const
	{
    CASN1EncSequence* root = CASN1EncSequence::NewLC();

    // encode rid KeyAgreeRecipientIdentifier
    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 rKeyId [0] IMPLICIT RecipientKeyIdentifier
        HBufC8* encodedRKeyId = NULL;
        iRKeyId->EncodeL( encodedRKeyId );
        CleanupStack::PushL( encodedRKeyId );
        CASN1EncEncoding* rKeyId = CASN1EncEncoding::NewLC( *encodedRKeyId );
        rKeyId->SetTag( KRKeyIdTag );
        root->AddAndPopChildL( rKeyId );
        CleanupStack::PopAndDestroy( encodedRKeyId );
        }

    // encode encryptedKey
    CASN1EncOctetString* encryptedKey =
        CASN1EncOctetString::NewLC( *iEncryptedKey );
    root->AddAndPopChildL( encryptedKey );

    return root;
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::EncryptedKey
// EncryptedKey getter
// -----------------------------------------------------------------------------
EXPORT_C const TDesC8&
CCMSRecipientEncryptedKey::EncryptedKey() const
	{
	return *iEncryptedKey;
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::IssuerAndSerialNumber
// IssuerAndSerialNumber getter
// -----------------------------------------------------------------------------
EXPORT_C const CCMSIssuerAndSerialNumber*
CCMSRecipientEncryptedKey::IssuerAndSerialNumber() const
	{
	return iIssuerAndSerialNumber;
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::RecipientKeyIdentifier
// RecipientKeyIdentifier getter
// -----------------------------------------------------------------------------
EXPORT_C const CCMSKeyIdentifier*
CCMSRecipientEncryptedKey::RKeyId() const
	{
	return iRKeyId;
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::SetEncryptedKeyL
// EncryptedKey setter
// -----------------------------------------------------------------------------
EXPORT_C void CCMSRecipientEncryptedKey::SetEncryptedKeyL(
	const TDesC8& aEncryptedKey )
	{
    HBufC8* encryptedKey = aEncryptedKey.AllocL();
    delete iEncryptedKey;
    iEncryptedKey = encryptedKey;
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::SetIssuerAndSerialNumberL
// IssuerAndSerialNumber setter, deletes also rKeyId
// -----------------------------------------------------------------------------
EXPORT_C void CCMSRecipientEncryptedKey::SetIssuerAndSerialNumberL(
	const CCMSIssuerAndSerialNumber& aIssuerAndSerialNumber )
	{
    CCMSIssuerAndSerialNumber* issuer = CCMSIssuerAndSerialNumber::NewL(
        aIssuerAndSerialNumber.IssuerName(),
        aIssuerAndSerialNumber.SerialNumber() );
    delete iRKeyId;
    iRKeyId = NULL;
    delete iIssuerAndSerialNumber;
    iIssuerAndSerialNumber = issuer;
	}

// -----------------------------------------------------------------------------
// CCMSRecipientEncryptedKey::SetRKeyIdL
// rKeyId setter, deletes also IssuerAndSerialNumber
// -----------------------------------------------------------------------------
EXPORT_C void CCMSRecipientEncryptedKey::SetRKeyIdL(
	const CCMSKeyIdentifier& aRKeyId )
	{
    CCMSKeyIdentifier* keyId = NULL;
    const TTime* keyIdDate = aRKeyId.Date();
    if( keyIdDate )
        {
        keyId = CCMSKeyIdentifier::NewL(
            aRKeyId.KeyIdentifier(), *keyIdDate );
        }
    else
        {
        keyId = CCMSKeyIdentifier::NewL(
            aRKeyId.KeyIdentifier() );
        }
    delete iIssuerAndSerialNumber;
    iIssuerAndSerialNumber = NULL;
    delete iRKeyId;
    iRKeyId = keyId;
	}

//  End of File