// Copyright (c) 1997-2009 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 <e32base.h>

#include <e32def.h>

#include "BASE64.H"

#include "BASE64DF.H"

//

// class CBase64CodecBase

// 

// Provides 3 octet encoding and decoding alone

// Returns an error code in the case of invalid source

//

void CBase64CodecBase::Reset()

//

// Reset the internal buffer

	{

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

		iQuart[i] = NULL;

	iQuartCount = 0;

	}

TInt CBase64CodecBase::Encode(const TDesC8& aSource, TDes8& aResult) const

//

// Encode an arbitrary number of octets in aSource append the output to aResult.

// If the number of octets in aSource is not a multiple of 3

// padding will be added terminating the encoding

//

	{

	TInt sourceLength = aSource.Length();

	if (sourceLength == 0)

		return KErrNone;

	__ASSERT_ALWAYS(((sourceLength * 4)/3 + sourceLength%3) <= (aResult.MaxLength()-aResult.Length()), Panic(EBase64Overflow));

	sourceLength -= sourceLength%3;

	TUint8 sixBit=NULL;

	TText8 source;

	TInt i;

	for (i = 0; i < sourceLength; i++)

		{

		source=aSource[i];

		sixBit = STATIC_CAST(TUint8,(source & 0xFC) >> 2);

		aResult.Append(KBase64Alphabet[sixBit]);

		sixBit = NULL;

		sixBit = STATIC_CAST(TUint8,(source & 0x03) << 4);

		source=aSource[++i];

		sixBit |= STATIC_CAST(TUint8,(source & 0xF0) >> 4);

		aResult.Append(KBase64Alphabet[sixBit]);

		sixBit = NULL;

		sixBit = STATIC_CAST(TUint8,(source & 0x0F) << 2);

		source=aSource[++i];

		sixBit |= STATIC_CAST(TUint8,(source & 0xC0) >> 6);

		aResult.Append(KBase64Alphabet[sixBit]);

		sixBit = NULL;

		sixBit = STATIC_CAST(TUint8,(source & 0x3F));

		aResult.Append(KBase64Alphabet[sixBit]);

		}

	switch (aSource.Length() % 3)

		{

	case 2:

		source=aSource[i];

		sixBit = STATIC_CAST(TUint8,(source & 0xFC) >> 2);

		aResult.Append(KBase64Alphabet[sixBit]);

		sixBit = NULL;

		sixBit = STATIC_CAST(TUint8,(source & 0x03) << 4);

		source=aSource[++i];

		sixBit |= STATIC_CAST(TUint8,(source & 0xF0) >> 4);

		aResult.Append(KBase64Alphabet[sixBit]);

		sixBit = NULL;

		sixBit = STATIC_CAST(TUint8,(source & 0x0F) << 2);

		aResult.Append(KBase64Alphabet[sixBit]);

		aResult.Append(KBase64Alphabet[KBase64Pad]);

		break;

	case 1:

		source=aSource[i];

		sixBit = STATIC_CAST(TUint8,(source & 0xFC) >> 2);

		aResult.Append(KBase64Alphabet[sixBit]);

		sixBit = NULL;

		sixBit = STATIC_CAST(TUint8,(source & 0x03) << 4);

		aResult.Append(KBase64Alphabet[sixBit]);

		aResult.Append(KBase64Alphabet[KBase64Pad]);

		aResult.Append(KBase64Alphabet[KBase64Pad]);

		break;

	default:

		break;

		}

	return KErrNone;

	}

TInt CBase64CodecBase::Decode(const TDesC8& aSource, TDes8& aResult)

//

// Decode the base64 stream in aSource append the output to aResult.

// Any non base64 chars are discarded while decoding

// Returns if either an end of stream is found, or all aSource is exhausted

// 

// Octets are only decoded when complete

// 

	{

	__ASSERT_ALWAYS((aSource.Length() * 3)/4 <= (aResult.MaxLength() - aResult.Length()), Panic(EBase64Overflow));

	if (aSource.Length() == 0)

		return KErrNone;

	TText8* readPtr=CONST_CAST(TText8*,aSource.Ptr());

	TText8* writePtr=CONST_CAST(TText8*,aResult.Ptr());

	TText8* writeStart=writePtr;

	writePtr += aResult.Length();

	TText8 result;

	TText8* readEnd=(readPtr + aSource.Length());

	for (; readPtr < readEnd; readPtr++)

		{

		TUint8 base64code = Base64Char(*readPtr);

		switch (base64code)

			{

		case KBase64Pad:

			if (iQuartCount == 0)

				return KErrNone;

			result = STATIC_CAST(TText8,iQuart[0] << 2);

			result |= STATIC_CAST(TText8,((iQuart[1] & 0x30) >> 4));

			*writePtr=result;

			writePtr++;

			if (iQuartCount == 3)

				{

				result = STATIC_CAST(TText8,(iQuart[1] & 0x0F) << 4);

				result |= STATIC_CAST(TText8,((iQuart[2] & 0x3C) >> 2));

				*writePtr=result;

				writePtr++;

				}

			aResult.SetLength(writePtr-writeStart);	

			iQuartCount = 0;

			return KErrNone;

		case KErrInvalidCharacter:

			// Do nothing

			break;

		default:

			{

			iQuart[iQuartCount++] = base64code;

			if (iQuartCount == 4)

				{

				result = STATIC_CAST(TText8,iQuart[0] << 2);

				result |= STATIC_CAST(TText8,((iQuart[1] & 0x30) >> 4));

				*writePtr=result;

				writePtr++;

				result = STATIC_CAST(TText8,(iQuart[1] & 0x0F) << 4);

				result |= STATIC_CAST(TText8,((iQuart[2] & 0x3C) >> 2));

				*writePtr=result;

				writePtr++;

				result = STATIC_CAST(TText8,((iQuart[2] & 0x03) << 6));

				result |= STATIC_CAST(TText8,iQuart[3]);

				*writePtr=result;

				writePtr++;

				iQuartCount = 0;

				}

			}

			}

		}

	aResult.SetLength(writePtr-writeStart);

	return KErrNone;

	}

TUint8 CBase64CodecBase::Base64Char(TText8 aChar) const

//

// Return the code or KErrInvalidCharacter

	{

	for (TUint8 i = 0; i < 65; i++)

		{

		if (aChar == KBase64Alphabet[i])

			return i;

		}

	return KErrInvalidCharacter;

	}

GLDEF_C void Panic(TBase64Panic aPanic)

// Panic the process with Base64 codec as the category.

//

	{

	_LIT(KPanicBase64Codec,"Base64 codec");

	User::Panic(KPanicBase64Codec,aPanic);

	}