// Copyright (c) 1999-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 "IMCVCODC.H"

#include "IMUTDLL.H"

#include "IMCVSEND.H"

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 

	};

const TInt8 KImcvLookUpStartOffset = 43;

const TUint8 KImcvConvEquals = '=';

const TInt KImMaxLengthForEncodedWordAndExtraEncodingTokens = 9;

// Define the maximum length that one encoded character should occupy.

// For certain encoding schemes such as Japanese, a single unicode character

// may need a multi character string to represent it when it is sent as part

// of an email header. This constant defines a maximum length for that string.

// The value is based on the maximum length for a Japanese character

const TInt KImMaxLengthForEncodedChar = 8;

//---------------------------------------------------------------------------------

//              Class TImNoCodec Functions

//---------------------------------------------------------------------------------

//

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

	{

	rDestString.Copy(aSrcString);

	return 0;

	}

//	

TBool TImCodecNull::Decode( const TDesC8& aInputLine, TDes8& rOutputLine)

	{

	rOutputLine.Copy(aInputLine);

	return ETrue;

	}

//---------------------------------------------------------------------------------

//              Class TImCodecQP Functions

//

//			Utility class, providing encoding/decoding functions for :

//			Quotable-printable, Base64 & UU.

//			Input/output consisting of 8bit strings.

//---------------------------------------------------------------------------------

//

EXPORT_C TImCodecQP::TImCodecQP() : iPlainCharList(TPtrC8()), iEncodeCharList(TPtrC8())

	{

	iQPCharacter=KImcvEquals;

	}

//

TBool TImCodecQP::SmartBreak( TInt written, const TDesC8& pSource )

	{

	TLex8 source( pSource );

	// only check for whether we should break if the current char is breakable

	if ( !IsBreakable(source.Peek()) )

		return EFalse;

 	// scan ahead looking for the next breakable char.

	source.Inc();

	TBool found = EFalse;

	TInt encodingOffset=(IsPlain(source.Peek()) ? 0 : 2);

	while ( !found && !source.Eos() )

		{

		found = IsBreakable(source.Peek());

		if (!found)

			{

			encodingOffset+=(IsPlain(source.Peek()) ? 0 : 2);

			source.Inc();

			}

		}

	// there's another breakable char before the end of the text 

	// - we need to break now if it's too far away

	// but only if the non-breakable text fits on a line itself.

	return ((written+source.Offset()+encodingOffset) > KMaxIMailBodyLineLength-4);

	}

//

EXPORT_C TInt TImCodecQP::Encode( const TDesC8& aInputLine, TDes8& rOutputLine)

	{

	 // number of characters written to the current line.

	TInt written=0; 

	// Used to check we do not 'fold' a line after encountering an ESC character.

	TInt escapeChar=0;

	// number of characters introduced into the line by the encoding mechanism.

	TInt localPaddingCount=0; 

	TChar nextChar=0;

	// buffer used for preparing the hex encoding of a non-printable char

	TBuf8<5> formatted; 

	TLex8 lexSource(aInputLine);

	TDes8& ptr = rOutputLine;

	TInt ptrEnd = ptr.MaxLength();

	if (!lexSource.Eos())

		{

		lexSource.Get();

		nextChar = lexSource.Peek();

		lexSource.Inc(-1);

		}

	while (written<KImMailMaxBufferSize-2 && !lexSource.Eos())

		{

		if (written>=KMaxIMailBodyLineLength-3 && !escapeChar)

			{

			// force a soft line break.

			__ASSERT_ALWAYS( ptr.Length()+4< ptr.MaxLength(), gPanic(KPanicDescriptorToSmall) );

			ptr.Append(iQPCharacter);

			ptr.Append(KImcvCRLF);

			written+=3; localPaddingCount+=3;

			break;

			}

		TChar peek = lexSource.Peek();

		if (peek==KImcvESC)

			escapeChar=3;

		if ( SmartBreak(written,lexSource.Remainder()) && !escapeChar)

			{

			AddSoftLineBreak( ptr, localPaddingCount, written);

			break;

			}

		else if ( IsPlain(peek) && peek!=KImcvSP && peek!=KImcvEquals )

			// simple case, printable character

			{

			__ASSERT_ALWAYS( ptr.Length()+1<ptrEnd, gPanic(KPanicDescriptorToSmall) );

			ptr.Append(peek);

			written++;

			}

		else if ( peek==KImcvTab || peek==KImcvSP )

			// Tab or space, need to check for immediate EOL so we can keep the space character

			{

			TChar thisChar =lexSource.Get();

			TChar nextChar =(lexSource.Eos() ? (TChar)0 : lexSource.Get());

			if (nextChar==KImcvCR && lexSource.Peek()==KImcvLF)

				// Encode space, as EOL follows.

				{

				__ASSERT_ALWAYS( ptr.Length()+5<ptrEnd, gPanic(KPanicDescriptorToSmall) );

				formatted.Format( KImcvQPFormatString, (TUint) thisChar );

				formatted.UpperCase();

				ptr.Append( formatted );

				// also skip EOL the characters we just allowed for

				written+=5;

				localPaddingCount+=2;

				break;

				}

			else

				// no EOL, just carry on after the whitespace

				{

				__ASSERT_ALWAYS( ptr.Length()+1<ptrEnd, gPanic(KPanicDescriptorToSmall) );

				ptr.Append( thisChar );

				written++;

				lexSource.Inc(-1);

				if (nextChar)

					lexSource.Inc(-1);

				}

			}

		else if (peek==KImcvCR && nextChar==KImcvLF)

			// Do not encode.

			{

			__ASSERT_ALWAYS( ptr.Length()+2<ptrEnd, gPanic(KPanicDescriptorToSmall) );

			ptr.Append(KImcvCRLF);

			written+=2;

			lexSource.Inc();

			break;

			}

		else if ( (TUint8)peek==iQPCharacter )

			// '=' in source text

			{

			__ASSERT_ALWAYS( ptr.Length()+3<ptrEnd, gPanic(KPanicDescriptorToSmall) );

			ptr.Append( KImcvQPEqualsSign );

			written += 3;

			localPaddingCount+=2;

			}

		else if (peek==KImcvTab || peek==KImcvHyphen || peek==KImcvSP)

			{

			__ASSERT_ALWAYS( ptr.Length()+1<ptrEnd, gPanic(KPanicDescriptorToSmall) );

			ptr.Append( peek );

			written++;

			}

		else

			// non-printable char, must encode with Hex value

			{

			__ASSERT_ALWAYS( ptr.Length()+3<ptrEnd, gPanic(KPanicDescriptorToSmall) );

			formatted.Format( KImcvQPEncoded, (TUint) peek );

			formatted.UpperCase();

			ptr.Append(formatted);

			written += 3;

			localPaddingCount += 2;

			}

		// advance to next source character	

		lexSource.Inc();

		if (escapeChar)

			escapeChar--;

		// check whether we should give up without creating all the output

		// non-quotable char to come & we're nearly at max length.

		TChar thisChar = lexSource.Get();

		// just in case we're pointing at the last character

		nextChar = (lexSource.Eos() ? (TChar)0 : lexSource.Peek());

		if (thisChar != 0)

			lexSource.Inc(-1);

		} // while

	return written-localPaddingCount;

	}

//

EXPORT_C TInt TImCodecQP::Decode( const TDesC8& aSrcString, TDes8& rDestString )

	{

	TInt error = KErrNone;

	__ASSERT_DEBUG(aSrcString.Length(), gPanic(KPanicInvalidSMTPLine));

	rDestString = KNullDesC8;

	TPtrC8 source( aSrcString.Ptr(), aSrcString.Length() );

	const TUint8* pSource = source.Ptr();

	const TUint8* pEnd = pSource+aSrcString.Length();

	// find out if this is a blank line, if so then we'll add a paragraph delimiter instead

	// assume it's blank and then look for non-blank characters

	// avoid the CRLF at the end of the line (we know it's there thanks to the assertion above)

	TBool blankLine = ETrue; 

	while (pSource < pEnd-2) 

		{

		if (*pSource!=KImcvSP && *pSource!=KImcvTab)

			{

			blankLine = EFalse;

			break;

			}

		pSource++;

		}

	if ( blankLine )

		{

		rDestString.Copy( aSrcString );

		return KErrNone;

		}

	TInt outputLength=0;

	TUint8 loBits;

	TUint8 hiBits;

	TUint8 asciiValue;

	pSource = source.Ptr();	// reset to start of source data

	const TUint8 zero = '0';

	const TUint8 alphaAdjust = 55;  // 'A' is ascii 65 so we need to subtract 55 from 

									// alphabetical hex digits to get their numeric value

	while( pSource < pEnd )

		{

		if (*pSource != iQPCharacter )

			{

			//  Quoted character or Attachment bound, just bung it on & move to the next one

			// *ptr++ = *pSource;

			outputLength++;

			rDestString.Append( *pSource );

			}

		else	// check for encoded character

			{

			// start looking at the next two characters, if they are there.

			if ( pSource+2 < pEnd )

				{

				pSource++;

				// check for '=' at EOL => this is a soft break, so remove it

				if (*pSource != KImcvCR) 

					{

					if(*pSource != KImcvLF) 

						{

					 	 // now decode hex value into ASCII code : hi-order bits come first

						 hiBits = (TUint8)(0x0F & (IsDigit( *pSource ) ? (TUint8)(*pSource-zero) : (TUint8)(*pSource-alphaAdjust)));

						 pSource++;

						 loBits = (TUint8)(0x0F & (IsDigit( *pSource ) ? (TUint8)(*pSource-zero) : (TUint8)(*pSource-alphaAdjust)));

						 asciiValue = (TUint8)( (hiBits<<4) + loBits);

						 // bung the character thus formed onto the decoded string

						 rDestString.Append( asciiValue );

						 // *ptr++ = asciiValue;

						 outputLength++;

						}

					}

				else

					{

					pSource++;

					if(*pSource != KImcvLF)

						{

						error=KErrCorrupt;

						pSource-=2;

						rDestString.Append( *pSource );

						pSource++;

						rDestString.Append( *pSource );

						pSource++;

						outputLength+=2;

						}

					}

				}

			else

				{

				// copy the rest of the data & use up the input string in the process.

				while (pSource < pEnd)

					{

					error=KErrCorrupt; // not QP compliant

					//*ptr++ = *pSource++;

					outputLength++;

					rDestString.Append( *pSource );

					pSource++;

					}

				}

			} // check for '=' char

		pSource++;  // next source charactery

	} // while

	rDestString.SetLength(outputLength);

	return error;

	}

// Not used. Remove in 6.3

//

EXPORT_C TInt TImCodecQP::EncodeRichText( const TDesC8& aInputLine, TDes8& rOutputLine)

	{

	TInt written=0;  // number of characters written to the current line

	TInt localPaddingCount=0; // number of characters introduced into the line by the encoding mechanism

	// buffer used for preparing the hex encoding of a non-printable char

	TBuf8<5> formatted; 

	TLex8 lexSource(aInputLine);

	TDes8& ptr = rOutputLine;

	TInt ptrEnd = ptr.MaxLength();

	while (written < KMaxIMailBodyLineLength-3 &&!lexSource.Eos())

		{

		if ( SmartBreak(written,lexSource.Remainder()) )

			{

			AddSoftLineBreak(ptr, localPaddingCount, written);

			break;

			}

		TChar peek = lexSource.Peek();

		if ( IsPlain(peek)  && peek!=KImcvSP )

			// simple case, printable character

			{

			__ASSERT_ALWAYS( ptr.Length()+1<ptrEnd, gPanic(KPanicDescriptorToSmall) );

			ptr.Append(peek);

			written++;

			}

		else if ( peek==KImcvTab || peek==KImcvSP )

			// Tab or space, need to check for immediate EOL so we can keep the space character

			{

			TChar thisChar = (lexSource.Eos() ? (TChar)0 : lexSource.Get());

			if ( lexSource.Peek()==ETextParagraphDelimiter )

				{

				__ASSERT_ALWAYS( ptr.Length()+5<ptrEnd, gPanic(KPanicDescriptorToSmall) );

				formatted.Format( KImcvQPFormatString, (TUint) thisChar );

				formatted.UpperCase();

				ptr.Append( formatted );

				ptr.Append(KImcvCRLF);

				// also skip EOL the characters we just allowed for

				written+=7;

				localPaddingCount+=4;

				// advance to next source character	

				lexSource.Inc();

				break;

				}

			else

				// no EOL, just carry on after the whitespace

				{

				__ASSERT_ALWAYS( ptr.Length()+1<ptrEnd, gPanic(KPanicDescriptorToSmall) );

				ptr.Append( thisChar );

				written++;

				lexSource.Inc(-1);

				}

			}

		else if ( (TUint8)peek==iQPCharacter )

			// '=' in source text

			{

			//is there enough space to encoded a char and put a soft break on the end.

			if(written > KMaxIMailBodyLineLength-6)

				break;

			__ASSERT_ALWAYS( ptr.Length()+3<ptrEnd, gPanic(KPanicDescriptorToSmall) );

			ptr.Append( KImcvQPEqualsSign );

			written += 3;

			localPaddingCount+=2;

			}

		else if (peek<KImcvSP  && peek!=KImcvLF && peek !=KImcvCR )

			// check for CEditableText control character

			{

			TChar replacement = ReplacementChar(peek);

			if (replacement)

				{

				__ASSERT_ALWAYS( ptr.Length()+1<ptrEnd, gPanic(KPanicDescriptorToSmall) );

				ptr.Append( replacement );

				written++;

				}

			else if ( lexSource.Peek()==ETextParagraphDelimiter )

				{

				ptr.Append(KImcvCRLF);

				written+=2;

				localPaddingCount+=1;

				break;

				}

			else

				localPaddingCount-=1;

			}

		else

			// non-printable char, must encode with Hex value

			{

			//is there enough space to encoded a char and put a soft break on the end

			if(written > KMaxIMailBodyLineLength-6)

				{

				if (written+3 < KMaxIMailBodyLineLength)

					{

					AddSoftLineBreak(ptr, localPaddingCount, written);

					}

				break;

				}

			__ASSERT_ALWAYS( ptr.Length()+3<ptrEnd, gPanic(KPanicDescriptorToSmall) );

			formatted.Format( KImcvQPEncoded, (TUint) peek );

			formatted.UpperCase();

			ptr.Append(formatted);

			written += 3;

			localPaddingCount += 2;

			}

		// advance to next source character	

		lexSource.Inc();

		// check whether we should give up without creating all the output

		// non-quotable char to come & we're nearly at max length.

		TChar thisChar = lexSource.Get();

		// just in case we're pointing at the last character

		TChar nextChar = (lexSource.Eos() ? (TChar)0 : lexSource.Peek());

		if (thisChar != 0)

			lexSource.Inc(-1);

		if ( !IsPlain( thisChar ) && (written >= KMaxIMailBodyLineLength-2) 

			|| ( thisChar==KImcvSP ||  thisChar==KImcvTab) 

			&& nextChar==CEditableText::EParagraphDelimiter 

			&& (written >= KMaxIMailBodyLineLength-3) ) // whitespace just before linebreak

			break;

		} // while

	rOutputLine.SetLength( written );

	return 	(written-localPaddingCount);

	}

EXPORT_C TInt TImCodecQP::DecodeRichText( const TDesC8& aSrcString, TDes& rDestString )

	{

	TInt error = KErrNone;

	__ASSERT_DEBUG(aSrcString.Length()>=2&&aSrcString[aSrcString.Length()-2]==KImcvCR&&aSrcString[aSrcString.Length()-1]==KImcvLF, gPanic(KPanicInvalidSMTPLine));

	rDestString = KNullDesC;

	TPtrC8 source( aSrcString.Ptr(), aSrcString.Length() );

	const TUint8* pSource = source.Ptr();

	const TUint8* pEnd = pSource+aSrcString.Length();

	// find out if this is a blank line, if so then we'll add a paragraph delimiter instead

	TBool blankLine = ETrue; // assume it's blank and then look for non-blank characters