/*

* Copyright (c) 2008-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: 

* Base64 encoding and decoding functions.

*

*/

/**

 @file

*/

#include "base64.h"

// Constants used by the Base64 algorithm

const TUint8 TBase64::iAlphabet[] =

	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

const TInt8 KImcvLookUpStartOffset = 43;

const TUint8 KImcvConvEquals = '=';

const TInt8 AsciiToBase64[80]=

	{

	 62, -1, -1, -1, 63, 52, 53, 54, 55, 56,

	 57, 58, 59, 60, 61, -1, -1, -1, 64, -1,

	 -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,

	  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,

	 18, 19, 20, 21, 22, 23, 24, 25, -1, -1,

	 -1, -1, -1, -1, 26, 27, 28, 29, 30, 31,

	 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,

	 42, 43, 44, 45, 46, 47, 48, 49, 50, 51

	};

const TInt8 Base64ToAscii[65]=

	{

	 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,

	 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,

	 85, 86, 87, 88, 89, 90, 97, 98, 99,100,

	101,102,103,104,105,106,107,108,109,110,

	111,112,113,114,115,116,117,118,119,120,

	121,122, 48, 49, 50, 51, 52, 53, 54, 55,

	 56, 57, 43, 47, 61

	};

EXPORT_C TBase64::TBase64() :

	iShiftStored(0),

	iMaskShiftStored(ESix)

	{

	}

EXPORT_C void TBase64::Initialize()

	{

	iMaskShiftStored = ESix;

	}

//Encodes data to Base64.

EXPORT_C HBufC8* TBase64::EncodeLC(const TDesC8& aSrcString)

	{

	// Allocate and clear destination string

	TInt destLen = ((aSrcString.Length() - 1) / 3 + 1) * 4;

	HBufC8* destString = HBufC8::NewMaxLC(destLen);

	TPtr8 destPtr = destString->Des();

	// Initialise variables

	const TUint8* srcStringPtr = aSrcString.Ptr();

	const TUint8* srcStringEnd = aSrcString.Length() + srcStringPtr;

	TUint8* destStringPtr = (TUint8*)destString->Ptr();

	TUint8* destStringPtrBase = destStringPtr;

	TInt character = 0;

	TUint8 encodedChar = 0;

	TInt charStorage = 0;

 	TInt maskShift = EZero;

	while (srcStringPtr <= srcStringEnd)

		{

		// maskShift is used as a char read counter

		if(maskShift == ESix)

			{

			// If the 3rd char read is also the last char then the while loop

			// is broken on the next check.

			if(srcStringPtr == srcStringEnd)

				srcStringPtr++;

			maskShift = EZero;

			character = 0;

			}

		else

			{

			if (srcStringPtr == srcStringEnd)

				character=0;

			else

				character = *srcStringPtr;

			srcStringPtr++;

			// Shifts charStorage ready for the next char

			charStorage = charStorage << 8;

			maskShift += ETwo;

			}

		charStorage = charStorage | character;

		// Shifts the mask to the correct bit location

		// Masks (AND's) the valid bits from charStorage

		// Shifts the valid bits into the low order 8bits

		// Converts to BASE64 char, Casts the result to an unsigned

		// char (which it should be ?....I hope)

		encodedChar = (TUint8)Base64ToAscii[((charStorage >> maskShift) & ESixBitMask)];

		*destStringPtr++ = encodedChar;

		}

	// Check for not enough chars and pad if required

	if (maskShift == EFour)

		{

		*destStringPtr++ = KImcvConvEquals;

		*destStringPtr++ = KImcvConvEquals;

		}

	else

		if (maskShift == ESix)

			*destStringPtr++ = KImcvConvEquals;

	destPtr.SetLength((TInt)(destStringPtr - destStringPtrBase));

	return destString;

	}

//Decodes Base64-encoded data.

EXPORT_C HBufC8* TBase64::DecodeLC(const TDesC8& aSrcString, TBool& aNeedMoreData)

	{

	// The source string must be a multiple of 4 bytes long

	if (aSrcString.Length() & 0x3)

		{

		User::Leave(KErrCorrupt);

		}

	TInt decodedInt = 0;

	TInt8 offsetChar = 0;

	TUint8 decodedChar = 0;

    // Find out how long the decoded string will be.

    TInt outLen = aSrcString.Length() / 4 * 3;

    if (aSrcString[aSrcString.Length() - 1] == '=')

        outLen--;

    if (aSrcString[aSrcString.Length() - 2] == '=')

        outLen--;

	// Construct output buffer.

	HBufC8* destString = HBufC8::NewMaxLC(outLen);

	TPtr8 destPtr = destString->Des();

	destPtr.Zero();

	// Initialise variables

	const TUint8* srcStringPtr = aSrcString.Ptr();

	const TUint8* srcStringEnd = aSrcString.Length() + srcStringPtr;

	TUint8* destStringPtr = (TUint8*)destString->Ptr();

	TUint8* destStringPtrBase = destStringPtr;

	TInt maskShift = iMaskShiftStored;

	TInt shiftStorage = iShiftStored;

	// Main character process loop

	while (srcStringPtr<srcStringEnd)

		{

		offsetChar = (TInt8)(*srcStringPtr - KImcvLookUpStartOffset);

		srcStringPtr++;

		// Check for valid B64 character

		if ((offsetChar >= 0) && (offsetChar < 80))

			{

			// Read in next character and B64 decode

			decodedInt = AsciiToBase64[offsetChar];

			// Exits when a PAD char is reached

			if(decodedInt == EPadChar)

				{

				destPtr.SetLength((TInt)(destStringPtr - destStringPtrBase));

				aNeedMoreData = EFalse;

				return destString;

				}

			// Ensures the first 2 chars of 4 are received before processing

			if(maskShift == ESix)

				maskShift = EFour;

			else

				{

				shiftStorage = shiftStorage << ESix;

				shiftStorage = shiftStorage | decodedInt;

				decodedChar = (TUint8)((shiftStorage >> maskShift) & EEightBitMask);

				if((maskShift -= ETwo) < EZero)

					maskShift = ESix;

				*destStringPtr++ = decodedChar;

				}

			shiftStorage = decodedInt;

			}

		}

	iShiftStored = shiftStorage;

	iMaskShiftStored = maskShift;

	destPtr.SetLength((TInt)(destStringPtr - destStringPtrBase));

	aNeedMoreData = maskShift < ESix;

	return destString;

	}