/*

* 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    "CCMSCertificateChoices.h"

#include "CCMSX509Certificate.h"

#include "CCMSX509AttributeCertificate.h"

#include <asn1dec.h>

#include <asn1enc.h>

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

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

// CCMSCertificateChoices::CCMSCertificateChoices

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

// might leave.

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

//

EXPORT_C CCMSCertificateChoices::CCMSCertificateChoices()

    {

    }

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

// CCMSCertificateChoices::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CCMSCertificateChoices::ConstructL(

    const CCMSX509Certificate& aCertificate )

    {

    SetCertificateL( aCertificate );

    }

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

// CCMSCertificateChoices::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CCMSCertificateChoices::ConstructL(

    const CCMSX509AttributeCertificate& aAttrCert )

    {

    SetAttrCertL( aAttrCert );

    }

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

// CCMSCertificateChoices::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSCertificateChoices* CCMSCertificateChoices::NewL()

	{

	// creating with empty/default values

    CCMSX509Certificate* certificate = CCMSX509Certificate::NewL( );

	CleanupStack::PushL( certificate );

	CCMSCertificateChoices* self = NewL( *certificate );

	CleanupStack::PopAndDestroy( certificate );

	return self;

	}

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

// CCMSCertificateChoices::NewLC

// Two-phased constructor.

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

//

EXPORT_C CCMSCertificateChoices* CCMSCertificateChoices::NewLC()

	{

	// creating with empty/default values

    CCMSX509Certificate* certificate = CCMSX509Certificate::NewL( );

	CleanupStack::PushL( certificate );

	CCMSCertificateChoices* self = NewL( *certificate );

	CleanupStack::PopAndDestroy( certificate );

    CleanupStack::PushL( self );

	return self;

	}

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

// CCMSCertificateChoices::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSCertificateChoices* CCMSCertificateChoices::NewL(

    const CCMSX509Certificate& aCertificate )

    {

    CCMSCertificateChoices* self = NewLC( aCertificate );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCMSCertificateChoices::NewLC

// Two-phased constructor.

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

//

EXPORT_C CCMSCertificateChoices* CCMSCertificateChoices::NewLC(

    const CCMSX509Certificate& aCertificate )

    {

    CCMSCertificateChoices* self =

    	new( ELeave ) CCMSCertificateChoices();

    CleanupStack::PushL( self );

    self->ConstructL( aCertificate );

    return self;

    }

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

// CCMSCertificateChoices::NewL

// Two-phased constructor.

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

//

EXPORT_C CCMSCertificateChoices* CCMSCertificateChoices::NewL(

    const CCMSX509AttributeCertificate& aAttrCert )

    {

    CCMSCertificateChoices* self = NewLC( aAttrCert );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCMSCertificateChoices::NewLC

// Two-phased constructor.

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

//

EXPORT_C CCMSCertificateChoices* CCMSCertificateChoices::NewLC(

    const CCMSX509AttributeCertificate& aAttrCert )

    {

    CCMSCertificateChoices* self =

    	new( ELeave ) CCMSCertificateChoices();

    CleanupStack::PushL( self );

    self->ConstructL( aAttrCert );

    return self;

    }

// Destructor

CCMSCertificateChoices::~CCMSCertificateChoices()

    {

    delete iCertificate;

    delete iAttrCert;

    }

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

// CCMSCertificateChoices::DecodeL

// Decrypts raw data to this instance

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

void CCMSCertificateChoices::DecodeL( const TDesC8& aRawData )

	{

    TASN1DecGeneric decGen( aRawData );

    decGen.InitL();

    switch( decGen.Tag() )

        {

        case EASN1Sequence:

            {

            // check class and decode certificate

            if( decGen.Class() != EUniversal )

                {

                User::Leave( KErrArgument );

                }

            CCMSX509Certificate* certificate = CCMSX509Certificate::NewL();

            CleanupStack::PushL( certificate );

            certificate->DecodeL( aRawData );

            delete iAttrCert;

            iAttrCert = NULL;

            delete iCertificate;

            iCertificate = certificate;

            CleanupStack::Pop( certificate );

            break;

            }

        case KCMSAttrCertTag:

            {

            // check class and decode attrCert

            if( decGen.Class() != EContextSpecific )

                {

                User::Leave( KErrArgument );

                }

            CCMSX509AttributeCertificate* attrCert =

                CCMSX509AttributeCertificate::NewL();

            CleanupStack::PushL( attrCert );

            attrCert->DecodeImplicitTagL( aRawData, KCMSAttrCertTag );

            delete iCertificate;

            iCertificate = NULL;

            delete iAttrCert;

            iAttrCert = attrCert;

            CleanupStack::Pop( attrCert );

            break;

            }

        default:

            {

            User::Leave( KErrArgument );

            }

        }

	}

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

// CCMSCertificateChoices::EncodeL

// Encrypts this instance to descriptor

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

void CCMSCertificateChoices::EncodeL( HBufC8*& aResult ) const

	{

	CASN1EncBase* root = EncoderLC();

	// encode the object in a DER encoding

    HBufC8* der = HBufC8::NewMaxLC( root->LengthDER() );

    TPtr8 pder( der->Des() );

    TUint pos = 0;

    root->WriteDERL( pder, pos );

    CleanupStack::Pop( der );

    aResult = der;

	CleanupStack::PopAndDestroy( root );

	}

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

// CCMSCertificateChoices::EncoderLC

// Returns ASN1 encoder for this instance

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

CASN1EncBase* CCMSCertificateChoices::EncoderLC() const

	{

    if( iCertificate )

        {

        return iCertificate->EncoderLC();

        }

    else

        {

        CASN1EncBase* encoder = iAttrCert->EncoderLC();

        encoder->SetTag( KCMSAttrCertTag );

        return encoder;

        }

	}

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

// CCMSCertificateChoices::Certificate

// certificate getter.

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

EXPORT_C const CCMSX509Certificate*

CCMSCertificateChoices::Certificate() const

	{

	return iCertificate;

	}

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

// CCMSCertificateChoices::AttrCert

// attrCert getter.

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

EXPORT_C const CCMSX509AttributeCertificate*

CCMSCertificateChoices::AttrCert() const

	{

	return iAttrCert;

	}

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

// CCMSCertificateChoices::SetCertificateL

// Certificate setter

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

EXPORT_C void CCMSCertificateChoices::SetCertificateL(

	const CCMSX509Certificate& aCertificate )

	{

    CCMSX509Certificate* certificate = CCMSX509Certificate::NewL(

        aCertificate.SerialNumber(),

        aCertificate.Signature(),

        aCertificate.Issuer(),

        aCertificate.Validity(),

        aCertificate.Subject(),

        aCertificate.SubjectPublicKeyInfo(),

        aCertificate.AlgorithmIdentifier(),

        aCertificate.Encrypted() );

    CleanupStack::PushL( certificate );

    certificate->SetVersion( aCertificate.Version() );

    const TDesC8* issuerUniqueIdentifier = aCertificate.IssuerUniqueIdentifier();

    if( issuerUniqueIdentifier )

        {

        certificate->SetIssuerUniqueIdentifierL( *issuerUniqueIdentifier );

        }

    const TDesC8* subjectUniqueIdentifier =

        aCertificate.SubjectUniqueIdentifier();

    if( subjectUniqueIdentifier )

        {

        certificate->SetSubjectUniqueIdentifierL( *subjectUniqueIdentifier );

        }

    delete iAttrCert;

    iAttrCert = NULL;

    delete iCertificate;

    iCertificate = certificate;

    CleanupStack::Pop( certificate );

	}

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

// CCMSCertificateChoices::SetAttrCertL

// AttrCert setter

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

EXPORT_C void CCMSCertificateChoices::SetAttrCertL(

	const CCMSX509AttributeCertificate& aAttrCert )

	{

    CCMSX509AttributeCertificate* attrCert = CCMSX509AttributeCertificate::NewL(

        aAttrCert.Info(),

        aAttrCert.AlgorithmIdentifier(),

        aAttrCert.Encrypted() );

    delete iCertificate;

    iCertificate = NULL;

    delete iAttrCert;

    iAttrCert = attrCert;

	}

//  End of File