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

// CONSTANTS
const TInt KNumberOfSubModules = 2;

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

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

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSOriginatorPublicKey::ConstructL(
	const CCMSX509AlgorithmIdentifier& aAlgorithm,
	const TDesC8& aPublicKey )
    {
	SetAlgorithmL( aAlgorithm );
	SetPublicKeyL( aPublicKey );
    }

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

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::NewL
// Two-phased copy constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSOriginatorPublicKey* CCMSOriginatorPublicKey::NewL(
    const CCMSOriginatorPublicKey& aOriginatorPublicKey )
	{
	CCMSOriginatorPublicKey* self = NewLC( aOriginatorPublicKey );
    CleanupStack::Pop( self );
	return self;
	}

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::NewLC
// Two-phased copy constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSOriginatorPublicKey* CCMSOriginatorPublicKey::NewLC(
    const CCMSOriginatorPublicKey& aOriginatorPublicKey )
	{
	CCMSOriginatorPublicKey* self = NewLC(
        aOriginatorPublicKey.Algorithm(), aOriginatorPublicKey.PublicKey() );
	return self;
	}

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSOriginatorPublicKey* CCMSOriginatorPublicKey::NewL(
	const CCMSX509AlgorithmIdentifier& aAlgorithm,
	const TDesC8& aPublicKey )
    {
    CCMSOriginatorPublicKey* self = NewLC( aAlgorithm, aPublicKey );
    CleanupStack::Pop();
    return self;
    }

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSOriginatorPublicKey* CCMSOriginatorPublicKey::NewLC(
	const CCMSX509AlgorithmIdentifier& aAlgorithm,
	const TDesC8& aPublicKey )
    {
    CCMSOriginatorPublicKey* self =
    	new( ELeave ) CCMSOriginatorPublicKey();

    CleanupStack::PushL( self );
    self->ConstructL( aAlgorithm, aPublicKey );
    return self;
    }


// Destructor
CCMSOriginatorPublicKey::~CCMSOriginatorPublicKey()
    {
	delete iAlgorithm;
	delete iPublicKey;
    }

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::DecodeL
// Decrypts raw data to this instance
// -----------------------------------------------------------------------------
void CCMSOriginatorPublicKey::DecodeL( const TDesC8& aRawData )
	{
    TASN1DecGeneric decGen( aRawData );
    decGen.InitL();
    TASN1DecSequence decSeq;
    CArrayPtr< TASN1DecGeneric >* itemsData =
        decSeq.DecodeDERLC( decGen );
    TInt count = itemsData->Count();
    if( count != KNumberOfSubModules )
        {
        User::Leave( KErrArgument );
        }
	// we would not get this far if there is not 2 elements

	// decoding algorithm identifier
    CCMSX509AlgorithmIdentifier* algorithm =
        CCMSX509AlgorithmIdentifier::NewL( );
    CleanupStack::PushL( algorithm );
    algorithm->DecodeL( itemsData->At( 0 )->Encoding() );
    CleanupStack::Pop( algorithm );
    delete iAlgorithm;
    iAlgorithm = algorithm;

	// decoding public key
	TASN1DecGeneric gen( *itemsData->At( 1 ) );
	gen.InitL();
    // Symbian decoder can't handle zero length bit strings
    if( gen.LengthDERContent() > 1 )
        {
        TASN1DecBitString bitStringDecoder;
        HBufC8* tmp = bitStringDecoder.ExtractOctetStringL( gen );
        delete iPublicKey;
        iPublicKey = tmp;
        }
    else
        {
        HBufC8* tmp = KNullDesC8().AllocL();
        delete iPublicKey;
        iPublicKey = tmp;
        }

	CleanupStack::PopAndDestroy( itemsData );
	}

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

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

    // encode the algorithm identifier
    HBufC8* encodedAlgorithm = NULL;
    iAlgorithm->EncodeL( encodedAlgorithm );
    CleanupStack::PushL( encodedAlgorithm );
    CASN1EncEncoding* algorithm = CASN1EncEncoding::NewLC( *encodedAlgorithm );
    root->AddAndPopChildL( algorithm );
    CleanupStack::PopAndDestroy( encodedAlgorithm );

    // add public key
    CASN1EncBitString* publicKey = CASN1EncBitString::NewLC( *iPublicKey );
    root->AddAndPopChildL( publicKey );

	return root;
	}

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::Algorithm
// Algorithm identifier getter
// -----------------------------------------------------------------------------
EXPORT_C const CCMSX509AlgorithmIdentifier&
CCMSOriginatorPublicKey::Algorithm() const
	{
	return *iAlgorithm;
	}

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::PublicKey
// PublicKey getter
// -----------------------------------------------------------------------------
EXPORT_C const TDesC8& CCMSOriginatorPublicKey::PublicKey() const
	{
	return *iPublicKey;
	}

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::SetAlgorithmL
// Algorithm setter
// -----------------------------------------------------------------------------
EXPORT_C void CCMSOriginatorPublicKey::SetAlgorithmL(
	const CCMSX509AlgorithmIdentifier& aAlgorithm )
	{
	CCMSX509AlgorithmIdentifier* algorithm = NULL;
    const CAlgorithmIdentifier& algorithmId = aAlgorithm.AlgorithmIdentifier();
    const CAlgorithmIdentifier* digestAlgorithm = aAlgorithm.DigestAlgorithm();
    if( digestAlgorithm )
        {
        algorithm = CCMSX509AlgorithmIdentifier::NewL( algorithmId,
                                                       *digestAlgorithm );
        }
    else
        {
        algorithm = CCMSX509AlgorithmIdentifier::NewL( algorithmId );
        }
	delete iAlgorithm;
	iAlgorithm = algorithm;
	}

// -----------------------------------------------------------------------------
// CCMSOriginatorPublicKey::SetPublicKeyL
// PublicKey setter
// -----------------------------------------------------------------------------
EXPORT_C void CCMSOriginatorPublicKey::SetPublicKeyL(
	const TDesC8& aPublicKey )
	{
	HBufC8* tmp = aPublicKey.AllocL();
	delete iPublicKey;
	iPublicKey = tmp;
	}

//  End of File