/*

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

#include "TCMSTimeUtil.h"

#include "CCMSCertificateChoices.h"

#include "CCMSX509CertificateList.h"

#include <asn1dec.h>

#include <asn1enc.h>

// CONSTANTS

const TInt KMinNumberOfSubModules = 0;

const TInt KMaxNumberOfSubModules = 2;

const TTagType KCertsTag = 0;

const TTagType KCrlsTag = 1;

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

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

// CCMSOriginatorInfo::CCMSOriginatorInfo

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

// might leave.

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

//

EXPORT_C CCMSOriginatorInfo::CCMSOriginatorInfo( )

    {

    }

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

// CCMSOriginatorInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSOriginatorInfo*

CCMSOriginatorInfo::NewL()

	{

	// creating with empty values

    CCMSOriginatorInfo* self =

        new( ELeave ) CCMSOriginatorInfo();

	return self;

	}

// Destructor

CCMSOriginatorInfo::~CCMSOriginatorInfo()

    {

    if( iCerts )

        {

        iCerts->ResetAndDestroy();

        delete iCerts;

        }

    if( iCrls )

        {

        iCrls->ResetAndDestroy();

        delete iCrls;

        }

    }

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

// CCMSOriginatorInfo::DecodeL

// Decrypts raw data to this instance

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

void CCMSOriginatorInfo::DecodeL( const TDesC8& aRawData )

	{

    CArrayPtr< TASN1DecGeneric >* itemList = DecodeSequenceLC(

        aRawData, KMinNumberOfSubModules, KMaxNumberOfSubModules );

    DecodeArrayL( itemList );

    CleanupStack::PopAndDestroy( itemList );

	}

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

// CCMSOriginatorInfo::EncoderLC

// Returns ASN1 encoder for this instance

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

CASN1EncBase* CCMSOriginatorInfo::EncoderLC() const

	{

    CASN1EncSequence* root = CASN1EncSequence::NewLC();

    if( iCerts )

        {

        // encode certs [0] IMPLICIT CertificateSet OPTIONAL

        CASN1EncSequence* certs = CASN1EncSequence::NewLC();

        TInt certCount = iCerts->Count();

        for( TInt i = 0; i < certCount; i++ )

            {

            CASN1EncBase* certEncoder = iCerts->At( i )->EncoderLC();

            certs->AddAndPopChildL( certEncoder );

            }

        certs->SetTag( KCertsTag );

        root->AddAndPopChildL( certs );

        }

    if( iCrls )

        {

        // encode crls [1] IMPLICIT CertificateRevocationLists OPTIONAL

        CASN1EncSequence* crls = CASN1EncSequence::NewLC();

        TInt crlCount = iCrls->Count();

        for( TInt i = 0; i < crlCount; i++ )

            {

            CASN1EncBase* crlEncoder = iCrls->At( i )->EncoderLC();

            crls->AddAndPopChildL( crlEncoder );

            }

        crls->SetTag( KCrlsTag );

        root->AddAndPopChildL( crls );

        }

    return root;

	}

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

// CCMSOriginatorInfo::Certs()

// Getter for certs

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

EXPORT_C const CArrayPtr< CCMSCertificateChoices >*

CCMSOriginatorInfo::Certs() const

	{

	return iCerts;

	}

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

// CCMSOriginatorInfo::Crls()

// Getter for crls

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

EXPORT_C const CArrayPtr< CCMSX509CertificateList >*

CCMSOriginatorInfo::Crls() const

	{

	return iCrls;

	}

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

// CCMSOriginatorInfo::SetCertsL()

// Setter for certs

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

EXPORT_C void CCMSOriginatorInfo::SetCerts(

    CArrayPtr< CCMSCertificateChoices >* aCerts )

	{

    delete iCerts;

    iCerts = aCerts;

	}

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

// CCMSOriginatorInfo::SetCrlsL()

// Setter for Crls

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

EXPORT_C void CCMSOriginatorInfo::SetCrls(

    CArrayPtr< CCMSX509CertificateList >* aCrls )

	{

    delete iCrls;

    iCrls = aCrls;

	}

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

// CCMSOriginatorInfo::DecodeImplicitTagL

// Decrypts raw data with implicit tag

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

void CCMSOriginatorInfo::DecodeImplicitTagL(

    const TDesC8& aRawData,

    const TTagType aImplicitTag )

    {

    // Check the tag

    TASN1DecGeneric decGen( aRawData );

    decGen.InitL();

    // Accept only given tag

    if( decGen.Tag() != aImplicitTag )

        {

        User::Leave( KErrArgument );

        }

    TASN1DecSequence decSeq;

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

    TInt itemCount = items->Count();

    if( ( itemCount > KMaxNumberOfSubModules ) ||

        ( itemCount < KMinNumberOfSubModules ) )

        {

        User::Leave( KErrArgument );

        }

    DecodeArrayL( items );

    CleanupStack::PopAndDestroy( items );

    }

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

// CCMSOriginatorInfo::DecodeArrayL

// Decodes data from an array of decoders

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

void CCMSOriginatorInfo::DecodeArrayL(

    CArrayPtr< TASN1DecGeneric >* aItems )

    {

    TInt itemCount = aItems->Count();

    TInt sequenceCounter = 0;

    TASN1DecSequence decSeq;

    CArrayPtr< CCMSCertificateChoices >* certs = NULL;

    TInt certCount = 0;

    if( sequenceCounter < itemCount )

        {

        TASN1DecGeneric* certsGenericDecoder = aItems->At( sequenceCounter );

        if( certsGenericDecoder->Tag() == KCertsTag )

            {

            CArrayPtr< TASN1DecGeneric >* certList =

                decSeq.DecodeDERLC( *certsGenericDecoder );

            certCount = certList->Count();

            certs = new( ELeave ) CArrayPtrFlat< CCMSCertificateChoices >(

                certCount );

            CleanupStack::PushL( certs );

            for( TInt i = 0; i < certCount; i++ )

                {

                CCMSCertificateChoices* choices = CCMSCertificateChoices::NewL();

                CleanupStack::PushL( choices );

                choices->DecodeL( certList->At( i )->Encoding() );

                certs->AppendL( choices );

                }

            sequenceCounter++;

            }

        }

    CArrayPtr< CCMSX509CertificateList >* crls = NULL;

    TInt crlCount = 0;

    if( sequenceCounter < itemCount )

        {

        TASN1DecGeneric* crlsGenericDecoder = aItems->At( sequenceCounter );

        if( crlsGenericDecoder->Tag() != KCrlsTag )

            {

            User::Leave( KErrArgument );

            }

        CArrayPtr< TASN1DecGeneric >* crlList =

            decSeq.DecodeDERLC( *crlsGenericDecoder );

        crlCount = crlList->Count();

        crls = new( ELeave ) CArrayPtrFlat< CCMSX509CertificateList >(

            crlCount );

        CleanupStack::PushL( crls );

        for( TInt i = 0; i < crlCount; i++ )

            {

            CCMSX509CertificateList* cList = CCMSX509CertificateList::NewLC();

            cList->DecodeL( crlList->At( i )->Encoding() );

            crls->AppendL( cList );

            }

        }

    if( iCerts )

        {

        iCerts->ResetAndDestroy();

        delete iCerts;

        }

    iCerts = certs;

    if( iCrls )

        {

        iCrls->ResetAndDestroy();

        delete iCrls;

        }

    iCrls = crls;

    if( crls )

        {

        CleanupStack::Pop( crlCount );

        CleanupStack::Pop( crls );

        CleanupStack::PopAndDestroy( ); // crlList

        }

    if( certs )

        {

        CleanupStack::Pop( certCount );

        CleanupStack::Pop( certs );

        CleanupStack::PopAndDestroy( ); // certList

        }

    }

//  End of File