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

const TInt KMinNumberOfSubModules = 1;
const TInt KMaxNumberOfSubModules = 2;

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

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

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSX509AlgorithmIdentifier::ConstructL(
	const TAlgorithmId& aAlgorithmId )
    {
	TAlgorithmId id = aAlgorithmId;
	iAlgorithmIdentifier = CAlgorithmIdentifier::NewL( id, KNullDesC8() );
    }

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSX509AlgorithmIdentifier::ConstructL(
	const CAlgorithmIdentifier& aAlgorithmIdentifier )
    {
	iAlgorithmIdentifier = CAlgorithmIdentifier::NewL( aAlgorithmIdentifier );
    }

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSX509AlgorithmIdentifier* CCMSX509AlgorithmIdentifier::NewL()
	{
    return NewL( ERSA );
	}

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSX509AlgorithmIdentifier* CCMSX509AlgorithmIdentifier::NewL(
	const TAlgorithmId& aAlgorithmId )
    {
    CCMSX509AlgorithmIdentifier* self = new( ELeave ) CCMSX509AlgorithmIdentifier();
    CleanupStack::PushL( self );
    self->ConstructL( aAlgorithmId );
	CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSX509AlgorithmIdentifier* CCMSX509AlgorithmIdentifier::NewL(
	const CAlgorithmIdentifier& aAlgorithmIdentifier )
	{
	CCMSX509AlgorithmIdentifier* self = new( ELeave ) CCMSX509AlgorithmIdentifier();
	CleanupStack::PushL( self );
	self->ConstructL( aAlgorithmIdentifier );
	CleanupStack::Pop( self );
    return self;
	}

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CCMSX509AlgorithmIdentifier* CCMSX509AlgorithmIdentifier::NewL(
	const CAlgorithmIdentifier& aAlgorithmIdentifier,
	const CAlgorithmIdentifier& aDigestIdentifier )
	{
	CCMSX509AlgorithmIdentifier* self = new( ELeave ) CCMSX509AlgorithmIdentifier();
	CleanupStack::PushL( self );
	self->ConstructL( aAlgorithmIdentifier );
	self->SetDigestAlgorithmL( &aDigestIdentifier );
	CleanupStack::Pop( self );
    return self;
	}

// Destructor
CCMSX509AlgorithmIdentifier::~CCMSX509AlgorithmIdentifier()
    {
	delete iAlgorithmIdentifier;
	delete iDigestAlgorithmIdentifier;
    }

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::DecodeL
// Decrypts raw data to this instance
// -----------------------------------------------------------------------------
void CCMSX509AlgorithmIdentifier::DecodeL( const TDesC8& aRawData )
	{

    CAlgorithmIdentifier* tmpAlgorithmIdentifier = NULL;
    CAlgorithmIdentifier* tmpDigestAI = NULL;

    // try simple algorithm
	TRAPD( error, tmpAlgorithmIdentifier =
					CX509AlgorithmIdentifier::NewL( aRawData ) ); 

	// it is not simple algorithm identifier, trying with SigningAlgorithm
	if( error == KErrNotSupported )
		{
        CX509SigningAlgorithmIdentifier* tmpSigning = NULL;
		TRAPD( error2, tmpSigning =
               CX509SigningAlgorithmIdentifier::NewL( aRawData ) );
        if( error2 == KErrNone )
            {
            CleanupStack::PushL( tmpSigning );
            tmpAlgorithmIdentifier = CAlgorithmIdentifier::NewLC(
                tmpSigning->AsymmetricAlgorithm() );
            tmpDigestAI =
                CAlgorithmIdentifier::NewL( tmpSigning->DigestAlgorithm() );
            CleanupStack::Pop( tmpAlgorithmIdentifier );
            CleanupStack::PopAndDestroy( tmpSigning );
            }
        // it is not SigningAlgorithm, decode manually
        else if( error2 == KErrNotSupported )
            {
            CArrayPtr<TASN1DecGeneric>* itemsData =
							DecodeSequenceLC( aRawData,
											  KMinNumberOfSubModules,
											  KMaxNumberOfSubModules );
            TInt pos = 0;
            TInt count = itemsData->Count();
            TASN1DecObjectIdentifier decOID;
            HBufC* oid = decOID.DecodeDERL( *( itemsData->At( pos++ ) ) );
            CleanupStack::PushL( oid );
            if( *oid == KSHA1 )
                {
                TAlgorithmId algId( ESHA1 );
                if( count > pos )
                    {
                    TASN1DecGeneric* gen = itemsData->At( pos );
                    TPtrC8 encodedParams( gen->Encoding() );
                    tmpAlgorithmIdentifier =
                        CAlgorithmIdentifier::NewL( algId, encodedParams );
                    }
                else
                    {
                    TPtrC8 encodedParams( KNullDesC8() );
                    tmpAlgorithmIdentifier =
                        CAlgorithmIdentifier::NewL( algId, encodedParams );
                    }
                }
            else
                {
                User::Leave( KErrNotSupported );
                }
            CleanupStack::PopAndDestroy( 2 ); // oid, itemsData
            }
        else
            {
            User::Leave( error2 );
            }
		}
	else if( error != KErrNone )
		{
		User::Leave( error );
		}
	delete iAlgorithmIdentifier;
	iAlgorithmIdentifier = tmpAlgorithmIdentifier;
	delete iDigestAlgorithmIdentifier;
	iDigestAlgorithmIdentifier = tmpDigestAI;
	}

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

CASN1EncBase* CCMSX509AlgorithmIdentifier::EncoderLC() const
	{
	CASN1EncSequence* root = CASN1EncSequence::NewLC();
	CASN1EncObjectIdentifier* oid = NULL;
	if( !iDigestAlgorithmIdentifier )
		{
		switch ( iAlgorithmIdentifier->Algorithm() )
			{
			case ERSA:
				{
				oid = CASN1EncObjectIdentifier::NewLC( KRSA );
				break;
				}
			case EDSA:
				{
				oid = CASN1EncObjectIdentifier::NewLC( KDSA );
				break;
				}
			case EDH:
				{
				oid = CASN1EncObjectIdentifier::NewLC( KDH );
				break;
				}
			case EMD2:
				{
				oid = CASN1EncObjectIdentifier::NewLC( KMD2 );
				break;
				}
			case EMD5:
				{
				oid = CASN1EncObjectIdentifier::NewLC( KMD5 );
				break;
				}
			case ESHA1:
				{
				oid = CASN1EncObjectIdentifier::NewLC( KSHA1 );
				break;
				}
			default:
				{
				User::Leave( KErrArgument );
				}
			}
		}
	else
		{
		// only valid combinations are MD2WithRSA, MD5WithRSA
		// SHA1WithRSA and DSAWithSHA1
		if( iAlgorithmIdentifier->Algorithm() == ERSA )
			{
			switch ( iDigestAlgorithmIdentifier->Algorithm() )
				{
				case EMD2:
					{
					oid = CASN1EncObjectIdentifier::NewLC( KMD2WithRSA );
					break;
					}
				case EMD5:
					{
					oid = CASN1EncObjectIdentifier::NewLC( KMD5WithRSA );
					break;
					}
				case ESHA1:
					{
					oid = CASN1EncObjectIdentifier::NewLC( KSHA1WithRSA );
					break;
					}
				default:
					{
					User::Leave( KErrArgument );
					}
				}
			}
		else if( ( iAlgorithmIdentifier->Algorithm() == EDSA ) &&
				 ( iDigestAlgorithmIdentifier->Algorithm() == ESHA1 ) )
			{
			oid = CASN1EncObjectIdentifier::NewLC( KDSAWithSHA1 );
			}
		else
			{
			// not valid combination
			User::Leave( KErrArgument );
			}
		}

	// add algorithm id
	root->AddAndPopChildL( oid );

	// add parameters
	CASN1EncBase* parameters = NULL;
	if( iAlgorithmIdentifier->EncodedParams() != KNullDesC8() )
		{
		parameters = CASN1EncEncoding::NewLC( iAlgorithmIdentifier->EncodedParams() );
		}
	else
		{
		parameters = CASN1EncNull::NewLC();
		}
	root->AddAndPopChildL( parameters );

	return root;
	}

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::AlgorithmIdentifier
// Getter for AlgorithIdentifier
// -----------------------------------------------------------------------------
EXPORT_C const CAlgorithmIdentifier& CCMSX509AlgorithmIdentifier::AlgorithmIdentifier() const
	{
	return *iAlgorithmIdentifier;
	}

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::SetAlgorithmIdentifierL
// Setter for attribute type, takes copy
// -----------------------------------------------------------------------------
EXPORT_C void CCMSX509AlgorithmIdentifier::SetAlgorithmIdentifierL(
	const CAlgorithmIdentifier& aAlgorithmIdentifier )
	{
	CAlgorithmIdentifier* tmpAi = CAlgorithmIdentifier::NewL( aAlgorithmIdentifier );
	delete iAlgorithmIdentifier;
	iAlgorithmIdentifier = tmpAi;
	}

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::DigestAlgorithm
// Getter for DigestAlgorithIdentifier
// -----------------------------------------------------------------------------
EXPORT_C const CAlgorithmIdentifier* CCMSX509AlgorithmIdentifier::DigestAlgorithm() const
	{
	return iDigestAlgorithmIdentifier;
	}

// -----------------------------------------------------------------------------
// CCMSX509AlgorithmIdentifier::SetDigestAlgorithmL
// Setter for digest algorithm identifier, takes copy
// -----------------------------------------------------------------------------
EXPORT_C void CCMSX509AlgorithmIdentifier::SetDigestAlgorithmL(
	const CAlgorithmIdentifier* aAlgorithmIdentifier )
	{
	CAlgorithmIdentifier* tmpAi = CAlgorithmIdentifier::NewL( *aAlgorithmIdentifier );
	delete iDigestAlgorithmIdentifier;
	iDigestAlgorithmIdentifier = tmpAi;
	}
//  End of File