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

 	}

 /**

     Encodes an ASCII string to Base64 string.

     @param aSrcString The source string in ASCII.

     @param aDestString The destination string with converted base64 values.

     @param aLineLength The maximum line length of the encoded base64 values.

          A CR/LF sequence will be added after these many characters. 

          The default value is -1, which means no CR/LF is added to output. The encoding is compliant with RFC 4648 

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

 */  

 EXPORT_C TInt TBase64::PortableEncode(const TDesC8& aSrcString, TDes8& aDestString, TInt aLineLength)

     {

     // Clears the destination string

     aDestString.Zero();

     // Initialise variables

     const TUint8* srcStringPtr=aSrcString.Ptr();

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

     TUint8* destStringPtr=(TUint8*)aDestString.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 aLineLength number of characters 

         if (destStringCharNum == aLineLength)

             {

             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;   

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

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

     }