/*

 * Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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: 

 * Define methods for asn1-encoding base class

 *

 */

 #include "base128enc.h"

 #include "panic.h"

 #include <asn1enc.h>

 const TUint KMaxLowNumberFormTag = 30;

 const TUint KMaxShortFormLength = 127;

 EXPORT_C CASN1EncBase::CASN1EncBase(const TTagType aType, const TASN1Class aClass)

 : iType(aType), iClass(aClass)

 	{

 	CalculateTagLengthDER();

 	}

 EXPORT_C CASN1EncBase::~CASN1EncBase()

 	{

 	}

 EXPORT_C void CASN1EncBase::ConstructL()

 	{

 	ContentsLengthChanged();

 	}

 void CASN1EncBase::ContentsLengthChanged()

 	{

 	CalculateContentsLengthDER();

 	CalculateLengthLengthDER();

 	if (iParent)

 		{

 		iParent->ContentsLengthChanged();

 		}

 	}

 // Set tagging scheme/tag/class

 EXPORT_C void CASN1EncBase::SetTag(const TTagType aType, const TASN1Class aClass)

 	{

 	iType = aType;

 	iClass = aClass;

 	CalculateTagLengthDER();

 	}

 // Gives total number of octets in the DER encoding of this object

 EXPORT_C TUint CASN1EncBase::LengthDER() const

 	{

 	return iTagLengthDER + iLengthLengthDER + iContentsLengthDER;

 	}

 // Writes entire DER encoding of this object into the given buffer

 EXPORT_C void CASN1EncBase::WriteDERL(TDes8& aBuf, TUint& aPos) const

 	{

 	__ASSERT_ALWAYS(aBuf.Length() - STATIC_CAST(TInt, aPos) >= STATIC_CAST(TInt, LengthDER()),

 		Panic(KErrDescriptorTooShort));

 	WriteHelperL(aBuf, aPos, iTagLengthDER,      &CASN1EncBase::WriteTagDERL);

 	WriteHelperL(aBuf, aPos, iLengthLengthDER,   &CASN1EncBase::WriteLengthDER);

 	WriteHelperL(aBuf, aPos, iContentsLengthDER, &CASN1EncBase::WriteContentsDERL);

 	}

 // Internal helper method, used for efficiency

 void CASN1EncBase::WriteHelperL(TDes8& aBuf, TUint& aPos, const TUint aLength,

 									WriteFunc aWriteFunc) const

 	{

 	if (aLength)

 		{

 		// Get the middle bit of buffer we should be using

 		TPtr8 ptr(&aBuf[aPos], aLength, aLength);

 		// Call the function to actually write the data

 		(this->*aWriteFunc)(ptr);

 		aPos += aLength;

 		}

 	}

 // Give number of octets in tag section

 void CASN1EncBase::CalculateTagLengthDER()

 	{

 	if (iType <= KMaxLowNumberFormTag)

 		{

 		// Low tag number form

 		iTagLengthDER = 1;

 		}

 	else

 		{

 		// High tag number form

 		TASN1EncBase128DER encoder(iType);

 		iTagLengthDER = encoder.LengthDER() + 1;

 		}

 	}

 // Give number of octets in length section

 // Only called after contents length is worked out

 void CASN1EncBase::CalculateLengthLengthDER()

 	{

 	iLengthLengthDER = 1;

 	if (iContentsLengthDER > KMaxShortFormLength)

 		{

 		// Long form - need number of octets in base256 representation

 		// of length, plus 1.

 		TUint working = iContentsLengthDER;

 		do

 			{

 			++iLengthLengthDER;

 			}

 		while (working >>= 8);

 		}

 	}

 // Writes the tag section into the given buffer

 void CASN1EncBase::WriteTagDERL(TDes8& aBuf) const

 	{

 	// Write class - bits 7-8

 	aBuf[0] = STATIC_CAST(TUint8, iClass << 6);

 	// Write constructed/primitive flag in bit 6

 	if (IsConstructed())

 		{

 		aBuf[0] |= 0x20;

 		}

 	// Write length

 	if (iType <= KMaxLowNumberFormTag)

 		{

 		aBuf[0] |= iType;

 		}

 	else

 		{

 		// First byte signals more to come

 		aBuf[0] |= 0x1F;

 		// The rest we delegate

 		TASN1EncBase128DER encoder(iType);

 		TUint offset = 1;

 		encoder.WriteDERL(aBuf, offset);

 		}

 	}

 // Writes the length section into the given buffer

 void CASN1EncBase::WriteLengthDER(TDes8& aBuf) const

 	{

 	if (iContentsLengthDER > KMaxShortFormLength)

 		{

 		// First byte is the number of other bytes, with top bit also set

 		TUint octets = iLengthLengthDER - 1;

 		// Cast takes 8 least sig bits

 		aBuf[0] = STATIC_CAST(TUint8, octets);

 		aBuf[0] |= 0x80;

 		// Other bytes are base 256 representation of length, most significant first

 		TUint working = iContentsLengthDER;

 		do

 			{

 			// Cast to TUint8 takes 8 least sig bits

 			aBuf[octets] = STATIC_CAST(TUint8, working);

 			working >>= 8;

 			}

 		while (--octets);

 		}

 	else

 		{

 		// Short form, nice and easy - take least sig 8 bits with a cast

 		aBuf[0] = STATIC_CAST(TUint8, iContentsLengthDER);

 		}

 	}

 // Sets the parent (can only do this once)

 void CASN1EncBase::SetParent(CASN1EncBase* aParent)

 	{

 	__ASSERT_ALWAYS(iParent == 0, Panic(KErrAlreadyHasParent));

 	iParent = aParent;

 	}