sl@0: // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // TBase64.cpp
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include <tconvbase64.h>
sl@0: 
sl@0: /**
sl@0: TBase64 constructor
sl@0: */
sl@0: EXPORT_C TBase64::TBase64(): iShiftStored(0), iMaskShiftStored(ESix)
sl@0: 	{}
sl@0: 	
sl@0: 	
sl@0: /**
sl@0: 	Encodes an ASCII string to Base64 string.
sl@0: 
sl@0: 	@param aSrcString The source string in ASCII code.
sl@0: 	@param rDestString The destination string with converted base64 values.
sl@0: 	@return Number of characters in the source string that were not Encoded.
sl@0: */	
sl@0: EXPORT_C TInt TBase64::Encode(const TDesC8& aSrcString, TDes8& rDestString)
sl@0: 	{
sl@0:     // Clears the destination string
sl@0:     rDestString.Zero();
sl@0:     // Initialise variables
sl@0:     const TUint8* srcStringPtr=aSrcString.Ptr();
sl@0:     const TUint8* srcStringEnd=aSrcString.Length()+srcStringPtr;
sl@0:     TUint8* destStringPtr=(TUint8*)rDestString.Ptr();
sl@0:     TUint8* destStringPtrBase=destStringPtr;
sl@0:     TInt character=0;
sl@0:     TUint8 encodedChar=0;
sl@0:     TInt charStorage=0;
sl@0:     TInt maskShift=EZero;
sl@0:     TInt destStringCharNum = 0;
sl@0: 
sl@0:     while(srcStringPtr<=srcStringEnd)
sl@0: 	    {
sl@0:         // maskShift is used as a char read counter
sl@0: 	    if(maskShift==ESix)
sl@0:             {
sl@0: 	        // If the 3rd char read is also the last char then the while loop
sl@0:             // is broken on the next check.
sl@0:             if(srcStringPtr==srcStringEnd)
sl@0:             	srcStringPtr++;
sl@0:             maskShift=EZero;
sl@0:             character=0;   
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             if(srcStringPtr==srcStringEnd)
sl@0: 	            character=0;
sl@0:             else
sl@0: 		        character=*srcStringPtr;
sl@0:  
sl@0: 			srcStringPtr++;
sl@0: 		    // Shifts charStorage ready for the next char
sl@0: 	        charStorage=charStorage<<8;
sl@0:             maskShift+=ETwo;
sl@0:             }
sl@0:         charStorage=charStorage|character;
sl@0:         // Shifts the mask to the correct bit location
sl@0:         // Masks (AND's) the valid bits from charStorage
sl@0:         // Shifts the valid bits into the low order 8bits
sl@0:         // Converts to BASE64 char, Casts the result to an unsigned char (which it should be ?....I hope)
sl@0:         encodedChar=(TUint8)Base64ToAscii[((charStorage>>maskShift)&ESixBitMask)];
sl@0: 
sl@0:         *destStringPtr++=encodedChar;
sl@0:         destStringCharNum++;
sl@0: 
sl@0:         // Add a CRLF every KMaxB64EncodedCharsPerLine characters so as not to exceed the line length
sl@0:         // limitation specified in RFC 2822.
sl@0:         if (destStringCharNum == KMaxB64EncodedCharsPerLine)
sl@0: 	        {
sl@0:             destStringCharNum = 0;
sl@0:             *destStringPtr++ = '\r';
sl@0:             *destStringPtr++ = '\n';
sl@0:             }
sl@0: 		}
sl@0:      
sl@0:     // Check for not enough chars and pad if required
sl@0:     if (maskShift==EFour)
sl@0: 	    {
sl@0:         *destStringPtr++=KImcvConvEquals;
sl@0:         *destStringPtr++=KImcvConvEquals;
sl@0:         }
sl@0:     else
sl@0:         if(maskShift==ESix)
sl@0: 	        *destStringPtr++=KImcvConvEquals;   
sl@0:             
sl@0:     rDestString.SetLength((TInt)(destStringPtr-destStringPtrBase));
sl@0:     return ((TInt)(srcStringPtr-srcStringEnd));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: 	Decodes the Base64 string to ASCII pattern.
sl@0: 
sl@0: 	@param aSrcString The source string in Base64 codeset.
sl@0: 	@param rDestString The destination string with converted ASCII code values.
sl@0: 	@return ETrue if aSrcString is not long enough to decode fully, resulting in the storage of
sl@0: 		the last character and requiring another aSrcString (poss 0 length) to be passed to it to clear this character. 
sl@0: 		Returns EFalse if the line was decoded OK or the end of the encoded file is reached ie "="
sl@0: */	
sl@0: EXPORT_C TBool TBase64::Decode(const TDesC8& aSrcString, TDes8& rDestString)
sl@0: 	{
sl@0: 	TInt decodedInt=0;
sl@0: 	TInt8 offsetChar=0;
sl@0: 	TUint8 decodedChar=0;
sl@0: 	 
sl@0: 	// Clears the destination string
sl@0: 	rDestString.Zero();
sl@0: 
sl@0: 	// Initialise variables
sl@0: 	const TUint8* srcStringPtr=aSrcString.Ptr();
sl@0: 	const TUint8* srcStringEnd=aSrcString.Length()+srcStringPtr;
sl@0: 	TUint8* destStringPtr=(TUint8*)rDestString.Ptr();
sl@0: 	TUint8* destStringPtrBase=destStringPtr;
sl@0: 
sl@0: 	TInt maskShift=iMaskShiftStored;
sl@0: 	TInt shiftStorage=iShiftStored;
sl@0: 	
sl@0: 	// Main character process loop
sl@0: 	while(srcStringPtr<srcStringEnd)	
sl@0: 		{
sl@0: 		offsetChar=(TInt8)(*srcStringPtr-KImcvLookUpStartOffset);
sl@0: 		srcStringPtr++;
sl@0: 
sl@0: 		// Check for valid B64 character		
sl@0: 		if((offsetChar>=0)&&(offsetChar<80))
sl@0: 			{
sl@0: 			// Read in next character and B64 decode
sl@0: 			decodedInt=AsciiToBase64[offsetChar];
sl@0: 
sl@0: 			// Exits when a PAD char is reached
sl@0: 			if(decodedInt==EPadChar)
sl@0: 				{
sl@0: 				rDestString.SetLength((TInt)(destStringPtr-destStringPtrBase));
sl@0: 				return EFalse;
sl@0: 				}
sl@0: 
sl@0: 			// Ensures the first 2 chars of 4 are received before processing
sl@0: 			if(maskShift==ESix)
sl@0: 				maskShift=EFour;
sl@0: 			else
sl@0: 				{
sl@0: 				shiftStorage=shiftStorage<<ESix;
sl@0: 				shiftStorage=shiftStorage|decodedInt;
sl@0: 				decodedChar=(TUint8)((shiftStorage>>maskShift)&EEightBitMask);
sl@0: 				
sl@0: 				if((maskShift-=ETwo)<EZero)
sl@0: 					maskShift=ESix; 
sl@0: 				
sl@0: 				*destStringPtr++=decodedChar;
sl@0: 				}
sl@0: 			shiftStorage=decodedInt;
sl@0: 			}
sl@0: 		}
sl@0: 	iShiftStored=shiftStorage;
sl@0: 	iMaskShiftStored=maskShift;
sl@0: 	
sl@0: 	rDestString.SetLength((TInt)(destStringPtr-destStringPtrBase));
sl@0: 	
sl@0: 	return maskShift<ESix;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0:     Encodes an ASCII string to Base64 string.
sl@0: 
sl@0:     @param aSrcString The source string in ASCII.
sl@0:     @param aDestString The destination string with converted base64 values.
sl@0:     @param aLineLength The maximum line length of the encoded base64 values.
sl@0:          A CR/LF sequence will be added after these many characters. 
sl@0:          The default value is -1, which means no CR/LF is added to output. The encoding is compliant with RFC 4648 
sl@0:     @return Number of characters in the source string that were not encoded.
sl@0: */  
sl@0: EXPORT_C TInt TBase64::PortableEncode(const TDesC8& aSrcString, TDes8& aDestString, TInt aLineLength)
sl@0:     {
sl@0:     // Clears the destination string
sl@0:     aDestString.Zero();
sl@0:     // Initialise variables
sl@0:     const TUint8* srcStringPtr=aSrcString.Ptr();
sl@0:     const TUint8* srcStringEnd=aSrcString.Length()+srcStringPtr;
sl@0:     TUint8* destStringPtr=(TUint8*)aDestString.Ptr();
sl@0:     TUint8* destStringPtrBase=destStringPtr;
sl@0:     TInt character=0;
sl@0:     TUint8 encodedChar=0;
sl@0:     TInt charStorage=0;
sl@0:     TInt maskShift=EZero;
sl@0:     TInt destStringCharNum = 0;
sl@0: 
sl@0:     while(srcStringPtr<=srcStringEnd)
sl@0:         {
sl@0:         // maskShift is used as a char read counter
sl@0:         if(maskShift==ESix)
sl@0:             {
sl@0:             // If the 3rd char read is also the last char then the while loop
sl@0:             // is broken on the next check.
sl@0:             if(srcStringPtr==srcStringEnd)
sl@0:                 srcStringPtr++;
sl@0:             maskShift=EZero;
sl@0:             character=0;   
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             if(srcStringPtr==srcStringEnd)
sl@0:                 character=0;
sl@0:             else
sl@0:                 character=*srcStringPtr;
sl@0:  
sl@0:             srcStringPtr++;
sl@0:             // Shifts charStorage ready for the next char
sl@0:             charStorage=charStorage<<8;
sl@0:             maskShift+=ETwo;
sl@0:             }
sl@0:         charStorage=charStorage|character;
sl@0:         // Shifts the mask to the correct bit location
sl@0:         // Masks (AND's) the valid bits from charStorage
sl@0:         // Shifts the valid bits into the low order 8bits
sl@0:         // Converts to BASE64 char, Casts the result to an unsigned char (which it should be ?....I hope)
sl@0:         encodedChar=(TUint8)Base64ToAscii[((charStorage>>maskShift)&ESixBitMask)];
sl@0: 
sl@0:         *destStringPtr++=encodedChar;
sl@0:         destStringCharNum++;
sl@0: 
sl@0:         // Add a CRLF every aLineLength number of characters 
sl@0:         if (destStringCharNum == aLineLength)
sl@0:             {
sl@0:             destStringCharNum = 0;
sl@0:             *destStringPtr++ = '\r';
sl@0:             *destStringPtr++ = '\n';
sl@0:             }
sl@0:         }
sl@0:      
sl@0:     // Check for not enough chars and pad if required
sl@0:     if (maskShift==EFour)
sl@0:         {
sl@0:         *destStringPtr++=KImcvConvEquals;
sl@0:         *destStringPtr++=KImcvConvEquals;
sl@0:         }
sl@0:     else
sl@0:         if(maskShift==ESix)
sl@0:             *destStringPtr++=KImcvConvEquals;   
sl@0:             
sl@0:     aDestString.SetLength((TInt)(destStringPtr-destStringPtrBase));
sl@0:     return ((TInt)(srcStringPtr-srcStringEnd));
sl@0:     }