/*

* 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:  X.509 AttributeCertificateInfo type

*

*/

// INCLUDE FILES

#include    "CCMSX509AttributeCertificateInfo.h"

#include "CCMSX509IssuerSerial.h"

#include "CCMSX509GeneralNames.h"

#include "CCMSX509AlgorithmIdentifier.h"

#include "CCMSAttribute.h"

#include <asn1dec.h>

#include <asn1enc.h>

// CONSTANTS

const TInt KMinNumberOfSubModules = 6;

const TInt KMaxNumberOfSubModules = 9;

const TInt KValidityPeriodModuleCount = 2;

const TInt KValidityNotBeforeIndex = 0;

const TInt KValidityNotAfterIndex = 1;

const TInt KDefaultGranularity = 1;

const TInt KDefaultVersion = 0; // v1 == 0

const TTagType KBaseCertificateIDTag = 0;

const TTagType KSubjectNameTag = 1;

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

// Destructor

CCMSX509AttributeCertificateInfo::CAttributeCertificateData::

~CAttributeCertificateData()

    {

	delete iBaseCertificateID;

	delete iSubjectName;

	delete iIssuer;

	delete iSignature;

 	if( iAttributes )

 		{

 		iAttributes->ResetAndDestroy();

		delete iAttributes;

		}

    delete iIssuerUniqueID;

    }

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

// CCMSX509AttributeCertificateInfo::CCMSX509AttributeCertificateInfo

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

// might leave.

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

//

EXPORT_C CCMSX509AttributeCertificateInfo::CCMSX509AttributeCertificateInfo()

    {

    }

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

// CCMSX509AttributeCertificateInfo::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CCMSX509AttributeCertificateInfo::ConstructL(

    const CCMSX509IssuerSerial& aBaseCertificateID,

    const CCMSX509GeneralNames& aIssuer,

    const CCMSX509AlgorithmIdentifier& aSignature,

    const TInt aSerialNumber,

    const TTime& aNotBeforeTime,

    const TTime& aNotAfterTime,

    const CArrayPtr< CCMSAttribute >& aAttributes )

    {

    iData = new( ELeave ) CAttributeCertificateData();

    iData->iVersion = KDefaultVersion;

    SetBaseCertificateIDL( aBaseCertificateID );

    SetIssuerL( aIssuer );

    SetSignatureL( aSignature );

    SetSerialNumber( aSerialNumber );

    SetNotBeforeTimeL( aNotBeforeTime );

    SetNotAfterTimeL( aNotAfterTime );

    SetAttributesL( aAttributes );

    }

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

// CCMSX509AttributeCertificateInfo::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CCMSX509AttributeCertificateInfo::ConstructL(

    const CCMSX509GeneralNames& aSubjectName,

    const CCMSX509GeneralNames& aIssuer,

    const CCMSX509AlgorithmIdentifier& aSignature,

    const TInt aSerialNumber,

    const TTime& aNotBeforeTime,

    const TTime& aNotAfterTime,

    const CArrayPtr< CCMSAttribute >& aAttributes )

    {

    iData = new( ELeave ) CAttributeCertificateData();

    iData->iVersion = KDefaultVersion;

    SetSubjectNameL( aSubjectName );

    SetIssuerL( aIssuer );

    SetSignatureL( aSignature );

    SetSerialNumber( aSerialNumber );

    SetNotBeforeTimeL( aNotBeforeTime );

    SetNotAfterTimeL( aNotAfterTime );

    SetAttributesL( aAttributes );

    }

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

// CCMSX509AttributeCertificateInfo::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CCMSX509AttributeCertificateInfo::ConstructL( )

    {

    // creating empty/default values

    CAttributeCertificateData* data = new( ELeave ) CAttributeCertificateData();

    CleanupStack::PushL( data );

    data->iVersion = KDefaultVersion;

    data->iBaseCertificateID = CCMSX509IssuerSerial::NewL();

    data->iIssuer = CCMSX509GeneralNames::NewL();

    data->iSignature = CCMSX509AlgorithmIdentifier::NewL();

    data->iNotBeforeTime.UniversalTime();

    data->iNotAfterTime.UniversalTime();

    data->iNotAfterTime+=TTimeIntervalYears( 1 );

    data->iAttributes = new( ELeave ) CArrayPtrFlat< CCMSAttribute >( 1 );

    CleanupStack::Pop( data );

    iData = data;

    }

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

// CCMSX509AttributeCertificateInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSX509AttributeCertificateInfo*

CCMSX509AttributeCertificateInfo::NewL()

	{

	// creating with empty values

    CCMSX509AttributeCertificateInfo* self =

        new( ELeave ) CCMSX509AttributeCertificateInfo();

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

	return self;

	}

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

// CCMSX509AttributeCertificateInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSX509AttributeCertificateInfo*

CCMSX509AttributeCertificateInfo::NewL(

    const CCMSX509IssuerSerial& aBaseCertificateID,

    const CCMSX509GeneralNames& aIssuer,

    const CCMSX509AlgorithmIdentifier& aSignature,

    const TInt aSerialNumber,

    const TTime& aNotBeforeTime,

    const TTime& aNotAfterTime,

    const CArrayPtr< CCMSAttribute >& aAttributes )

    {

    CCMSX509AttributeCertificateInfo* self =

        new( ELeave ) CCMSX509AttributeCertificateInfo();

    CleanupStack::PushL( self );

    self->ConstructL( aBaseCertificateID, aIssuer, aSignature, aSerialNumber,

                      aNotBeforeTime, aNotAfterTime,

                      aAttributes );

    CleanupStack::Pop();

    return self;

    }

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

// CCMSX509AttributeCertificateInfo::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSX509AttributeCertificateInfo*

CCMSX509AttributeCertificateInfo::NewL(

    const CCMSX509GeneralNames& aSubjectName,

    const CCMSX509GeneralNames& aIssuer,

    const CCMSX509AlgorithmIdentifier& aSignature,

    const TInt aSerialNumber,

    const TTime& aNotBeforeTime,

    const TTime& aNotAfterTime,

    const CArrayPtr< CCMSAttribute >& aAttributes )

    {

    CCMSX509AttributeCertificateInfo* self =

        new( ELeave ) CCMSX509AttributeCertificateInfo();

    CleanupStack::PushL( self );

    self->ConstructL( aSubjectName, aIssuer, aSignature, aSerialNumber,

                      aNotBeforeTime, aNotAfterTime,

                      aAttributes );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CCMSX509AttributeCertificateInfo::~CCMSX509AttributeCertificateInfo()

    {

	delete iData;

    }

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

// CCMSX509AttributeCertificateInfo::DecodeL

// Decrypts raw data to this instance

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

void CCMSX509AttributeCertificateInfo::DecodeL( const TDesC8& aRawData )

	{

    CAttributeCertificateData* data = new( ELeave ) CAttributeCertificateData();

    CleanupStack::PushL( data );

    CArrayPtr< TASN1DecGeneric >* itemList = DecodeSequenceLC(

        aRawData, KMinNumberOfSubModules, KMaxNumberOfSubModules );

    TInt sequenceCounter = 0;

    // decode version

    TASN1DecGeneric* version = itemList->At( sequenceCounter );

    TASN1DecInteger intDecoder;

    if( ( version->Tag() == EASN1Integer ) &&

        ( version->Class() == EUniversal ) )

        {

        data->iVersion =

            intDecoder.DecodeDERShortL( *version );

        sequenceCounter++;

        }

    else

        {

        data->iVersion = KDefaultVersion;

        }

    // decode subject

    TASN1DecGeneric* subject = itemList->At( sequenceCounter++ );

    subject->InitL( );

    TTagType subjectTag( subject->Tag() );

    switch( subjectTag )

        {

        case KBaseCertificateIDTag:

            {

            data->iBaseCertificateID = CCMSX509IssuerSerial::NewL();

            data->iBaseCertificateID->DecodeL( subject->GetContentDER() );

            break;

            }

        case KSubjectNameTag:

            {

            data->iSubjectName = CCMSX509GeneralNames::NewL();

            data->iSubjectName->DecodeL( subject->GetContentDER() );

            break;

            }

        default:

            {

            User::Leave( KErrArgument );

            }

        }

    // decode issuer

    TASN1DecGeneric* issuer = itemList->At( sequenceCounter++ );

    issuer->InitL();

    data->iIssuer = CCMSX509GeneralNames::NewL();

    data->iIssuer->DecodeL( issuer->Encoding() );

    // decode signature

    TASN1DecGeneric* signature = itemList->At( sequenceCounter++ );

    signature->InitL();

    data->iSignature = CCMSX509AlgorithmIdentifier::NewL();

    data->iSignature->DecodeL( signature->Encoding() );

    // decode serialNumber

    data->iSerialNumber =

        intDecoder.DecodeDERShortL( *( itemList->At( sequenceCounter++ ) ) );

    // decode attCertValidityPeriod

    TASN1DecGeneric* validityPeriodDecoder = itemList->At( sequenceCounter++ );

    validityPeriodDecoder->InitL();

    CArrayPtr< TASN1DecGeneric >* validityPeriod = DecodeSequenceLC(

        validityPeriodDecoder->Encoding(), KValidityPeriodModuleCount,

        KValidityPeriodModuleCount );

    TASN1DecGeneralizedTime timeDecoder;

    data->iNotBeforeTime = timeDecoder.DecodeDERL(

        *( validityPeriod->At( KValidityNotBeforeIndex ) ) );

    data->iNotAfterTime = timeDecoder.DecodeDERL(

        *( validityPeriod->At( KValidityNotAfterIndex ) ) );

    CleanupStack::PopAndDestroy( validityPeriod );

    // decode attributes

    TASN1DecGeneric* attributesDecoder = itemList->At( sequenceCounter++ );

    attributesDecoder->InitL();

    CArrayPtr< TASN1DecGeneric >* attributes = DecodeSequenceLC(

        attributesDecoder->Encoding() );

    TInt attributeCount = attributes->Count();

    data->iAttributes = new( ELeave ) CArrayPtrFlat< CCMSAttribute >(

        attributeCount ? attributeCount : KDefaultGranularity );

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

        {

        TASN1DecGeneric* attributeDecoder = attributes->At( i );

        attributeDecoder->InitL();

        CCMSAttribute* attribute = CCMSAttribute::NewLC();

        attribute->DecodeL( attributeDecoder->Encoding() );

        data->iAttributes->AppendL( attribute );

        CleanupStack::Pop( attribute );

        }

    CleanupStack::PopAndDestroy( attributes );

    // decode issuerUniqueID

    if( itemList->Count() > sequenceCounter )

        {

        TASN1DecBitString bsDecoder;

        data->iIssuerUniqueID = bsDecoder.ExtractOctetStringL(

            *( itemList->At( sequenceCounter ) ) );

        }

    // all decoded, change state

    CleanupStack::PopAndDestroy( itemList );

    delete iData;

    iData = data;

    CleanupStack::Pop( data );

	}

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

// CCMSX509AttributeCertificateInfo::EncoderLC

// Returns ASN1 encoder for this instance

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

CASN1EncBase* CCMSX509AttributeCertificateInfo::EncoderLC() const

	{

    CASN1EncSequence* root = CASN1EncSequence::NewLC();

    // encode version

    CASN1EncInt* version = CASN1EncInt::NewLC( iData->iVersion );

    root->AddAndPopChildL( version );

    // encode subject

    CASN1EncBase* subject = NULL;

    if( iData->iBaseCertificateID )

        {

        // encode baseCertificateID  [0]  IssuerSerial

        CASN1EncBase* baseCertificateID =

            iData->iBaseCertificateID->EncoderLC( );

        CleanupStack::Pop( baseCertificateID );

        subject = CASN1EncExplicitTag::NewLC(

            baseCertificateID, KBaseCertificateIDTag );

        }

    else

        {

        // encode subjectName        [1]  GeneralNames

        CASN1EncBase* subjectName = iData->iSubjectName->EncoderLC( );

        CleanupStack::Pop( subjectName );

        subject = CASN1EncExplicitTag::NewLC( subjectName, KSubjectNameTag );

        }

    root->AddAndPopChildL( subject );

    // encode issuer

    CASN1EncBase* issuer = iData->iIssuer->EncoderLC();

    root->AddAndPopChildL( issuer );

    // encode signature

    CASN1EncBase* signature = iData->iSignature->EncoderLC();

    root->AddAndPopChildL( signature );

    // encode serialNumber

    CASN1EncInt* serialNumber = CASN1EncInt::NewLC( iData->iSerialNumber );

    root->AddAndPopChildL( serialNumber );

    // encode attCertValidityPeriod

    CASN1EncSequence* validityPeriod = CASN1EncSequence::NewLC( );

    // encode notBeforeTime

    CASN1EncGeneralizedTime* notBeforeTime =

        CASN1EncGeneralizedTime::NewLC( iData->iNotBeforeTime );

    validityPeriod->AddAndPopChildL( notBeforeTime );

    //encode notAfterTime

    CASN1EncGeneralizedTime* notAfterTime =

        CASN1EncGeneralizedTime::NewLC( iData->iNotAfterTime );

    validityPeriod->AddAndPopChildL( notAfterTime );

    root->AddAndPopChildL( validityPeriod );

    // encode attributes             SEQUENCE OF Attribute

    CASN1EncSequence* attributes = CASN1EncSequence::NewLC();

    TInt attributeCount = iData->iAttributes->Count();

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

        {

        CCMSAttribute* attribute = iData->iAttributes->At( i );

        CASN1EncBase* attributeEncoder = attribute->EncoderLC( );

        attributes->AddAndPopChildL( attributeEncoder );

        }

    root->AddAndPopChildL( attributes );

    // encode issuerUniqueID         UniqueIdentifier OPTIONAL

    if( iData->iIssuerUniqueID )

        {

        CASN1EncBitString* uniqueID =

            CASN1EncBitString::NewLC( *( iData->iIssuerUniqueID ) );

        root->AddAndPopChildL( uniqueID );

        }

    return root;

	}

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

// CCMSX509AttributeCertificateInfo::Version()

// Getter for Version

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

EXPORT_C TInt CCMSX509AttributeCertificateInfo::Version() const

	{

	return iData->iVersion;

	}

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

// CCMSX509AttributeCertificateInfo::BaseCertificateID()

// Getter for baseCertificateID

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

EXPORT_C const CCMSX509IssuerSerial*

CCMSX509AttributeCertificateInfo::BaseCertificateID() const

	{

	return iData->iBaseCertificateID;

	}

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

// CCMSX509AttributeCertificateInfo::SubjectName()

// Getter for subjectName

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

EXPORT_C const CCMSX509GeneralNames*

CCMSX509AttributeCertificateInfo::SubjectName() const

	{

	return iData->iSubjectName;

	}

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

// CCMSX509AttributeCertificateInfo::Issuer()

// Getter for Issuer

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

EXPORT_C const CCMSX509GeneralNames&

CCMSX509AttributeCertificateInfo::Issuer() const

	{

	return *iData->iIssuer;

	}

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

// CCMSX509AttributeCertificateInfo::Signature()

// Getter for signature

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

EXPORT_C const CCMSX509AlgorithmIdentifier&

CCMSX509AttributeCertificateInfo::Signature() const

	{

	return *iData->iSignature;

	}

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

// CCMSX509AttributeCertificateInfo::SerialNumber()

// Getter for serialNumber

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

EXPORT_C TInt

CCMSX509AttributeCertificateInfo::SerialNumber() const

	{

	return iData->iSerialNumber;

	}

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

// CCMSX509AttributeCertificateInfo::NotBeforeTime()

// Getter for notBeforeTime

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

EXPORT_C const TTime& CCMSX509AttributeCertificateInfo::NotBeforeTime()	 const

	{

	return iData->iNotBeforeTime;

	}

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

// CCMSX509AttributeCertificateInfo::NotAfterTime()

// Getter for notAfterTime

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

EXPORT_C const TTime& CCMSX509AttributeCertificateInfo::NotAfterTime()	 const

	{

	return iData->iNotAfterTime;

	}

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

// CCMSX509AttributeCertificateInfo::Attributes()

// Getter for Attributes

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

EXPORT_C const CArrayPtr<CCMSAttribute>&

CCMSX509AttributeCertificateInfo::Attributes() const

	{

	return *iData->iAttributes;

	}

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

// CCMSX509AttributeCertificateInfo::IssuerUniqueID()

// Getter for subjectName

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

EXPORT_C const TDesC8*

CCMSX509AttributeCertificateInfo::IssuerUniqueID() const

	{

	return iData->iIssuerUniqueID;

	}

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

// CCMSX509AttributeCertificateInfo::SetVersion()

// Setter for version

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

EXPORT_C void CCMSX509AttributeCertificateInfo::SetVersion(

    const TInt aVersion )

	{

	iData->iVersion = aVersion;

	}

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

// CCMSX509AttributeCertificateInfo::SetBaseCertificateIDL()

// Setter for baseCertificateID, deletes also subjectName

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

EXPORT_C void CCMSX509AttributeCertificateInfo::SetBaseCertificateIDL(

    const CCMSX509IssuerSerial& aBaseCertificateID )

	{

    CCMSX509IssuerSerial* id = CCMSX509IssuerSerial::NewL(