/*
* 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    "CCMSKeyAgreeRecipientInfo.h"
#include "CCMSX509AlgorithmIdentifier.h"
#include "CCMSOriginatorIdentifierOrKey.h"
#include "CCMSRecipientEncryptedKey.h"
#include <asn1dec.h>
#include <asn1enc.h>

// CONSTANTS
const TInt KMinNumberOfSubModules = 4;
const TInt KMaxNumberOfSubModules = 5;
const TTagType KOriginatorTag = 0;
const TTagType KUkmTag = 1;
const TInt KDefaultGranularity = 1;


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

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

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSKeyAgreeRecipientInfo::ConstructL( )
    {
    // creates empty/default values
    CCMSX509AlgorithmIdentifier* algorithm = CCMSX509AlgorithmIdentifier::NewL( );
    CleanupStack::PushL( algorithm );
    BaseConstructL( *algorithm );
    CleanupStack::PopAndDestroy( algorithm );

    iOriginator = CCMSOriginatorIdentifierOrKey::NewL( );
    iRecipientEncryptedKeys = new( ELeave )
        CArrayPtrFlat< CCMSRecipientEncryptedKey >( KDefaultGranularity );
    }

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSKeyAgreeRecipientInfo::ConstructL(
    const CCMSOriginatorIdentifierOrKey& aOriginator,
    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,
    const CArrayPtr< CCMSRecipientEncryptedKey >& aRecipientEncryptedKeys )
    {
    BaseConstructL( aKeyEncryptionAlgorithm );
    SetOriginatorL( aOriginator );
    SetRecipientEncryptedKeysL( aRecipientEncryptedKeys );
    }

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSKeyAgreeRecipientInfo::ConstructL(
    const CCMSOriginatorIdentifierOrKey& aOriginator,
    const TDesC8& aUkm,
    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,
    const CArrayPtr< CCMSRecipientEncryptedKey >& aRecipientEncryptedKeys )
    {
    ConstructL( aOriginator, aKeyEncryptionAlgorithm, aRecipientEncryptedKeys );
    SetUserKeyingMaterialL( aUkm );
    }

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSKeyAgreeRecipientInfo* CCMSKeyAgreeRecipientInfo::NewLC()
	{
	// creating with empty/default values
    CCMSKeyAgreeRecipientInfo* self = new( ELeave ) CCMSKeyAgreeRecipientInfo( );
    CleanupStack::PushL( self );
    self->ConstructL( );
    return self;
	}

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSKeyAgreeRecipientInfo* CCMSKeyAgreeRecipientInfo::NewL()
	{
	// creating with empty/default values
    CCMSKeyAgreeRecipientInfo* self = NewLC();
    CleanupStack::Pop( self );
    return self;
	}

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSKeyAgreeRecipientInfo* CCMSKeyAgreeRecipientInfo::NewL(
    const CCMSOriginatorIdentifierOrKey& aOriginator,
    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,
    const CArrayPtr< CCMSRecipientEncryptedKey >& aRecipientEncryptedKeys )
	{
    CCMSKeyAgreeRecipientInfo* self =
    	new( ELeave ) CCMSKeyAgreeRecipientInfo( );

    CleanupStack::PushL( self );
    self->ConstructL( aOriginator, aKeyEncryptionAlgorithm,
                      aRecipientEncryptedKeys );
    CleanupStack::Pop( self );
	return self;
	}

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSKeyAgreeRecipientInfo* CCMSKeyAgreeRecipientInfo::NewL(
    const CCMSOriginatorIdentifierOrKey& aOriginator,
    const TDesC8& aUkm,
    const CCMSX509AlgorithmIdentifier& aKeyEncryptionAlgorithm,
    const CArrayPtr< CCMSRecipientEncryptedKey >& aRecipientEncryptedKeys )
	{
    CCMSKeyAgreeRecipientInfo* self =
    	new( ELeave ) CCMSKeyAgreeRecipientInfo( );

    CleanupStack::PushL( self );
    self->ConstructL( aOriginator,aUkm, aKeyEncryptionAlgorithm,
                      aRecipientEncryptedKeys );
    CleanupStack::Pop( self );
	return self;
	}


// Destructor
CCMSKeyAgreeRecipientInfo::~CCMSKeyAgreeRecipientInfo()
    {
	delete iOriginator;
    delete iKeyEncryptionAlgorithm;
    if( iRecipientEncryptedKeys )
        {
        iRecipientEncryptedKeys->ResetAndDestroy();
        delete iRecipientEncryptedKeys;
        }
    delete iUserKeyingMaterial;
    }

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::DecodeL
// Decrypts raw data to this instance
// -----------------------------------------------------------------------------
void CCMSKeyAgreeRecipientInfo::DecodeL( const TDesC8& aRawData )
	{
    TASN1DecGeneric decGen( aRawData );
    decGen.InitL();
    // accept only sequence or implicit [1] tag
    if( ( decGen.Tag() != EASN1Sequence ) &&
        ( decGen.Tag() != KCMSKeyAgreeRecipientInfoTag ) )
        {
        User::Leave( KErrArgument );
        }
    TASN1DecSequence decSeq;
    CArrayPtr< TASN1DecGeneric >* itemsData = decSeq.DecodeDERLC( decGen );
    TInt count = itemsData->Count();
    if( ( count < KMinNumberOfSubModules ) ||
        ( count > KMaxNumberOfSubModules ) )
        {
        User::Leave( KErrArgument );
        }

    TInt sequenceCounter = 0;

    // Decode version
    TASN1DecGeneric versionDec( *itemsData->At( sequenceCounter++ ) );
    versionDec.InitL();
    TASN1DecInteger intDecoder;
    TInt version = intDecoder.DecodeDERShortL( versionDec );

    // decode originator [0] EXPLICIT OriginatorIdentifierOrKey
    TASN1DecGeneric taggedOriginatorDec( *itemsData->At( sequenceCounter++ ) );
    if( taggedOriginatorDec.Tag() != KOriginatorTag )
        {
        User::Leave( KErrArgument );
        }
    CCMSOriginatorIdentifierOrKey* originator =
        CCMSOriginatorIdentifierOrKey::NewL();
    CleanupStack::PushL( originator );
    originator->DecodeL( taggedOriginatorDec.GetContentDER() );

    // decode ukm [1] EXPLICIT UserKeyingMaterial OPTIONAL
    HBufC8* ukm = NULL;
    TASN1DecGeneric taggedUkmDec( *itemsData->At( sequenceCounter ) );
    if( taggedUkmDec.Tag() == KUkmTag )
        {
        TASN1DecOctetString octetStringDecoder;
        TASN1DecGeneric ukmDec( taggedUkmDec.GetContentDER() );
        ukmDec.InitL();
        ukm = octetStringDecoder.DecodeDERL( ukmDec );
        CleanupStack::PushL( ukm );
        sequenceCounter++;
        if( itemsData->Count() < KMaxNumberOfSubModules )
            {
            User::Leave( KErrArgument );
            }
        }

    // decode keyEncryptionAlgorithm
    CCMSX509AlgorithmIdentifier* algId = CCMSX509AlgorithmIdentifier::NewL();
    CleanupStack::PushL( algId );
    algId->DecodeL( itemsData->At( sequenceCounter++ )->Encoding() );

    // decode recipientEncryptedKeys
    CArrayPtr< TASN1DecGeneric >* keysData =
        DecodeSequenceLC( itemsData->At( sequenceCounter )->Encoding() );
    TInt keyCount = keysData->Count();
    CArrayPtr< CCMSRecipientEncryptedKey >* keys = NULL;
    if( keyCount > 0 )
        {
        keys = new( ELeave ) CArrayPtrFlat< CCMSRecipientEncryptedKey >(
            keyCount );
        CleanupStack::PushL( keys );

        for( TInt i = 0; i < keyCount; i++ )
            {
            CCMSRecipientEncryptedKey* key = CCMSRecipientEncryptedKey::NewL();
            CleanupStack::PushL( key );
            key->DecodeL( keysData->At( i )->Encoding() );
            keys->AppendL( key );
            }
        CleanupStack::Pop( keyCount ); // key
        }
    else
        {
        keys = new( ELeave ) CArrayPtrFlat< CCMSRecipientEncryptedKey >( 1 );
        CleanupStack::PushL( keys );
        }

    // everything has been decoded, now we can change state
    iVersion = version;
    delete iOriginator;
    iOriginator = originator;
    delete iUserKeyingMaterial;
    iUserKeyingMaterial = ukm;
    delete iKeyEncryptionAlgorithm;
    iKeyEncryptionAlgorithm = algId;
    if( iRecipientEncryptedKeys )
        {
        iRecipientEncryptedKeys->ResetAndDestroy();
        delete iRecipientEncryptedKeys;
        }
    iRecipientEncryptedKeys = keys;

    CleanupStack::Pop( keys );
    CleanupStack::PopAndDestroy( keysData );
    CleanupStack::Pop( algId );
    if( ukm )
        {
        CleanupStack::Pop( ukm );
        }
    CleanupStack::Pop( originator );
    CleanupStack::PopAndDestroy( itemsData );
	}

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

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

    // encode version
    AddVersionL( root );

    // encode originator [0] EXPLICIT OriginatorIdentifierOrKey,
    CASN1EncBase* originator = iOriginator->EncoderLC();

    // CASN1EncExplicitTag takes ownership of originator even when leaving
    CleanupStack::Pop( originator );
    CASN1EncExplicitTag* taggedOriginator =
        CASN1EncExplicitTag::NewLC( originator, KOriginatorTag );
    root->AddAndPopChildL( taggedOriginator );

    // encode ukm [1] EXPLICIT UserKeyingMaterial OPTIONAL
    if( iUserKeyingMaterial )
        {
        CASN1EncOctetString* ukm =
            CASN1EncOctetString::NewL( *iUserKeyingMaterial );
        CASN1EncExplicitTag* taggedUkm =
            CASN1EncExplicitTag::NewLC( ukm, KUkmTag );
        root->AddAndPopChildL( taggedUkm );
        }

    // encode keyEncryptionAlgorithm KeyEncryptionAlgorithmIdentifier
    AddKeyEncryptionAlgorithmL( root );

    // encode RecipientEncryptedKeys ::= SEQUENCE OF RecipientEncryptedKey
    CASN1EncSequence* recipientEncryptedKeys = CASN1EncSequence::NewLC();
    TInt keyCount = iRecipientEncryptedKeys->Count();
    for( TInt i = 0; i < keyCount; i++ )
        {
        HBufC8* encodedKey = NULL;
        iRecipientEncryptedKeys->At( i )->EncodeL( encodedKey );
        CleanupStack::PushL( encodedKey );
        CASN1EncEncoding* singleKey = CASN1EncEncoding::NewLC( *encodedKey );
        recipientEncryptedKeys->AddAndPopChildL( singleKey );
        CleanupStack::PopAndDestroy( encodedKey );
        }
    root->AddAndPopChildL( recipientEncryptedKeys );

    return root;
	}

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::TaggedEncoderLC
// Returns ASN1 encoder for this instance inside tag
// -----------------------------------------------------------------------------
CASN1EncBase* CCMSKeyAgreeRecipientInfo::TaggedEncoderLC() const
    {
    CASN1EncBase* encoder = EncoderLC();
    encoder->SetTag( KCMSKeyAgreeRecipientInfoTag );
    return encoder;
    }

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::Originator
// Originator getter
// -----------------------------------------------------------------------------
EXPORT_C const CCMSOriginatorIdentifierOrKey&
CCMSKeyAgreeRecipientInfo::Originator() const
	{
	return *iOriginator;
	}

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::RecipientEncryptedKeys
// RecipientEncryptedKeys getter
// -----------------------------------------------------------------------------
EXPORT_C const CArrayPtr< CCMSRecipientEncryptedKey >&
CCMSKeyAgreeRecipientInfo::RecipientEncryptedKeys() const
	{
	return *iRecipientEncryptedKeys;
	}

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::UserKeyingMaterial
// UserKeyingMaterial getter
// -----------------------------------------------------------------------------
EXPORT_C const TDesC8*
CCMSKeyAgreeRecipientInfo::UserKeyingMaterial() const
	{
	return iUserKeyingMaterial;
	}

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::SetOriginatorL
// Originator setter
// -----------------------------------------------------------------------------
EXPORT_C void CCMSKeyAgreeRecipientInfo::SetOriginatorL(
	const CCMSOriginatorIdentifierOrKey& aOriginator )
	{
    CCMSOriginatorIdentifierOrKey* originator = NULL;
    switch( aOriginator.Type() )
        {
        case CCMSOriginatorIdentifierOrKey::ESubjectKeyIdentifier:
            {
            originator = CCMSOriginatorIdentifierOrKey::NewL(
                aOriginator.SubjectKeyIdentifierL() );
            break;
            }
        case CCMSOriginatorIdentifierOrKey::EOriginatorKey:
            {
            originator = CCMSOriginatorIdentifierOrKey::NewL(
                aOriginator.OriginatorKeyL() );
            break;
            }
        case CCMSOriginatorIdentifierOrKey::EIssuerAndSerialNumber:
            {
            originator = CCMSOriginatorIdentifierOrKey::NewL(
                aOriginator.IssuerAndSerialNumberL() );
            break;
            }
        default:
            {
            User::Leave( KErrArgument );
            }
        }
    delete iOriginator;
    iOriginator = originator;
	}

// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::SetRecipientEncryptedKeysL
// RecipientEncryptedKeys setter, deep copy
// -----------------------------------------------------------------------------
EXPORT_C void CCMSKeyAgreeRecipientInfo::SetRecipientEncryptedKeysL(
	const CArrayPtr< CCMSRecipientEncryptedKey >& aRecipientEncryptedKeys )
	{
    TInt keyCount = aRecipientEncryptedKeys.Count();
    CArrayPtr< CCMSRecipientEncryptedKey >* keys = NULL;
    if( keyCount > 0 )
        {
        keys = new( ELeave ) CArrayPtrFlat< CCMSRecipientEncryptedKey >(
            keyCount );
        CleanupStack::PushL( keys );
        for( TInt i = 0; i < keyCount; i++ )
            {
            const CCMSRecipientEncryptedKey* key = aRecipientEncryptedKeys[ i ];
            const CCMSIssuerAndSerialNumber* issuer = key->IssuerAndSerialNumber();
            const TDesC8& encryptedKey = key->EncryptedKey();
            CCMSRecipientEncryptedKey* newKey = NULL;
            if( issuer )
                {
                newKey = CCMSRecipientEncryptedKey::NewL(
                    *issuer, encryptedKey );
                }
            else
                {
                newKey = CCMSRecipientEncryptedKey::NewL( *( key->RKeyId() ),
                                                          encryptedKey );
                }
            CleanupStack::PushL( newKey );
            keys->AppendL( newKey );
            }
        CleanupStack::Pop( keyCount ); // newKeys
        CleanupStack::Pop( keys );
        }
    else
        {
        keys = new( ELeave ) CArrayPtrFlat< CCMSRecipientEncryptedKey >( 1 );
        }
    if( iRecipientEncryptedKeys )
        {
        iRecipientEncryptedKeys->ResetAndDestroy();
        delete iRecipientEncryptedKeys;
        }
    iRecipientEncryptedKeys = keys;
    }
// -----------------------------------------------------------------------------
// CCMSKeyAgreeRecipientInfo::SetUserKeyingMaterialL
// UserKeyingMaterial setter.
// -----------------------------------------------------------------------------
EXPORT_C void CCMSKeyAgreeRecipientInfo::SetUserKeyingMaterialL(
	const TDesC8& aUkm )
	{
    HBufC8* ukm = aUkm.AllocL();
    delete iUserKeyingMaterial;
    iUserKeyingMaterial = ukm;
	}

//  End of File