// Copyright (c) 2006-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:

// TBase64.cpp

// 

//

#include <tconvbase64.h>

/**

TBase64 constructor

*/

EXPORT_C TBase64::TBase64(): iShiftStored(0), iMaskShiftStored(ESix)

	{}

/**

	Encodes an ASCII string to Base64 string.

	@param aSrcString The source string in ASCII code.

	@param rDestString The destination string with converted base64 values.

	@return Number of characters in the source string that were not Encoded.

*/	

EXPORT_C TInt TBase64::Encode(const TDesC8& aSrcString, TDes8& rDestString)

	{

    // Clears the destination string

    rDestString.Zero();

    // Initialise variables

    const TUint8* srcStringPtr=aSrcString.Ptr();

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

    TUint8* destStringPtr=(TUint8*)rDestString.Ptr();

    TUint8* destStringPtrBase=destStringPtr;

    TInt character=0;

    TUint8 encodedChar=0;

    TInt charStorage=0;

    TInt maskShift=EZero;

    TInt destStringCharNum = 0;

    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;

        destStringCharNum++;

        // Add a CRLF every KMaxB64EncodedCharsPerLine characters so as not to exceed the line length

        // limitation specified in RFC 2822.

        if (destStringCharNum == KMaxB64EncodedCharsPerLine)

	        {

            destStringCharNum = 0;

            *destStringPtr++ = '\r';

            *destStringPtr++ = '\n';

            }

		}

    // Check for not enough chars and pad if required

    if (maskShift==EFour)

	    {

        *destStringPtr++=KImcvConvEquals;

        *destStringPtr++=KImcvConvEquals;

        }

    else

        if(maskShift==ESix)

	        *destStringPtr++=KImcvConvEquals;   

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

    return ((TInt)(srcStringPtr-srcStringEnd));

	}

/**

	Decodes the Base64 string to ASCII pattern.

	@param aSrcString The source string in Base64 codeset.

	@param rDestString The destination string with converted ASCII code values.

	@return ETrue if aSrcString is not long enough to decode fully, resulting in the storage of

		the last character and requiring another aSrcString (poss 0 length) to be passed to it to clear this character. 

		Returns EFalse if the line was decoded OK or the end of the encoded file is reached ie "="

*/	

EXPORT_C TBool TBase64::Decode(const TDesC8& aSrcString, TDes8& rDestString)

	{

	TInt decodedInt=0;

	TInt8 offsetChar=0;

	TUint8 decodedChar=0;

	// Clears the destination string

	rDestString.Zero();

	// Initialise variables

	const TUint8* srcStringPtr=aSrcString.Ptr();

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

	TUint8* destStringPtr=(TUint8*)rDestString.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)

				{

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

				return EFalse;

				}

			// 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;

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

	return maskShift<ESix;

	}