1 // Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 #include "IMCVCODC.H"

    18 #include "IMUTDLL.H"

    19 #include "IMCVSEND.H"

    20 

    21 const TInt8 AsciiToBase64[80]=

    22 	{

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

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

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

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

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

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

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

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

    31 	};

    32 

    33 const TInt8 Base64ToAscii[65]=

    34 	{

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

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

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

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

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

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

    41 	 56, 57, 43, 47, 61 

    42 	};

    43 

    44 const TInt8 KImcvLookUpStartOffset = 43;

    45 const TUint8 KImcvConvEquals = '=';

    46 

    47 const TInt KImMaxLengthForEncodedWordAndExtraEncodingTokens = 9;

    48 

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

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

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

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

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

    54 const TInt KImMaxLengthForEncodedChar = 8;

    55 

    56 

    57 //---------------------------------------------------------------------------------

    58 //              Class TImNoCodec Functions

    59 //---------------------------------------------------------------------------------

    60 

    61 

    62 //

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

    64 	{

    65 	rDestString.Copy(aSrcString);

    66 	return 0;

    67 	}

    68 

    69 //	

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

    71 	{

    72 	rOutputLine.Copy(aInputLine);

    73 	return ETrue;

    74 	}

    75 

    76 

    77 

    78 //---------------------------------------------------------------------------------

    79 //              Class TImCodecQP Functions

    80 //

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

    82 //			Quotable-printable, Base64 & UU.

    83 //			Input/output consisting of 8bit strings.

    84 //---------------------------------------------------------------------------------

    85 

    86 //

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

    88 	{

    89 	iQPCharacter=KImcvEquals;

    90 	}

    91 

    92 //

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

    94 	{

    95 	TLex8 source( pSource );

    96 

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

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

    99 		return EFalse;

   100 

   101  	// scan ahead looking for the next breakable char.

   102 

   103 	source.Inc();

   104 	TBool found = EFalse;

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

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

   107 		{

   108 		found = IsBreakable(source.Peek());

   109 		if (!found)

   110 			{

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

   112 			source.Inc();

   113 			}

   114 		}

   115 

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

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

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

   119 

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

   121 	}

   122 

   123 //

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

   125 	{

   126 	 // number of characters written to the current line.

   127 	TInt written=0; 

   128 

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

   130 	TInt escapeChar=0;

   131 

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

   133 	TInt localPaddingCount=0; 

   134 	

   135 	TChar nextChar=0;

   136 

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

   138 	TBuf8<5> formatted; 

   139 	

   140 	TLex8 lexSource(aInputLine);

   141 	TDes8& ptr = rOutputLine;

   142 	TInt ptrEnd = ptr.MaxLength();

   143 

   144 	if (!lexSource.Eos())

   145 		{

   146 		lexSource.Get();

   147 		nextChar = lexSource.Peek();

   148 		lexSource.Inc(-1);

   149 		}

   150 

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

   152 		{

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

   154 			{

   155 			// force a soft line break.

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

   157 			ptr.Append(iQPCharacter);

   158 			ptr.Append(KImcvCRLF);

   159 			written+=3; localPaddingCount+=3;

   160 			break;

   161 			}

   162 

   163 		TChar peek = lexSource.Peek();

   164 

   165 		if (peek==KImcvESC)

   166 			escapeChar=3;

   167 

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

   169 			{

   170 			AddSoftLineBreak( ptr, localPaddingCount, written);

   171 			break;

   172 			}

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

   174 			// simple case, printable character

   175 			{

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

   177 			ptr.Append(peek);

   178 			written++;

   179 			}

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

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

   182 			{

   183 			TChar thisChar =lexSource.Get();

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

   185 

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

   187 				// Encode space, as EOL follows.

   188 				{

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

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

   191 				formatted.UpperCase();

   192 				ptr.Append( formatted );

   193 

   194 				// also skip EOL the characters we just allowed for

   195 				written+=5;

   196 				localPaddingCount+=2;

   197 				break;

   198 				}

   199 			else

   200 				// no EOL, just carry on after the whitespace

   201 				{

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

   203 				ptr.Append( thisChar );

   204 				written++;

   205 				lexSource.Inc(-1);

   206 				if (nextChar)

   207 					lexSource.Inc(-1);

   208 				}

   209 			}

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

   211 			// Do not encode.

   212 			{

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

   214 			ptr.Append(KImcvCRLF);

   215 			written+=2;

   216 			lexSource.Inc();

   217 			break;

   218 			}

   219 		else if ( (TUint8)peek==iQPCharacter )

   220 			// '=' in source text

   221 			{

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

   223 			ptr.Append( KImcvQPEqualsSign );

   224 			written += 3;

   225 			localPaddingCount+=2;

   226 			}

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

   228 			{

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

   230 			ptr.Append( peek );

   231 			written++;

   232 			}

   233 		else

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

   235 			{

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

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

   238 			formatted.UpperCase();

   239 			ptr.Append(formatted);

   240 			written += 3;

   241 			localPaddingCount += 2;

   242 			}

   243 		

   244 		// advance to next source character	

   245 		lexSource.Inc();

   246 		if (escapeChar)

   247 			escapeChar--;

   248 

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

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

   251 

   252 		TChar thisChar = lexSource.Get();

   253 

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

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

   256 		if (thisChar != 0)

   257 			lexSource.Inc(-1);

   258 

   259 		} // while

   260 

   261 	return written-localPaddingCount;

   262 	}

   263 

   264 //

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

   266 	{

   267 	TInt error = KErrNone;

   268 

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

   270 

   271 	rDestString = KNullDesC8;

   272 

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

   274 	const TUint8* pSource = source.Ptr();

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

   276 	

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

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

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

   280 

   281 	TBool blankLine = ETrue; 

   282 	while (pSource < pEnd-2) 

   283 		{

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

   285 			{

   286 			blankLine = EFalse;

   287 			break;

   288 			}

   289 		pSource++;

   290 		}

   291 

   292 	if ( blankLine )

   293 		{

   294 		rDestString.Copy( aSrcString );

   295 		return KErrNone;

   296 		}

   297 

   298 	TInt outputLength=0;

   299 	TUint8 loBits;

   300 	TUint8 hiBits;

   301 	TUint8 asciiValue;

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

   303 	const TUint8 zero = '0';

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

   305 									// alphabetical hex digits to get their numeric value

   306 	while( pSource < pEnd )

   307 		{

   308 		if (*pSource != iQPCharacter )

   309 			{

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

   311 			// *ptr++ = *pSource;

   312 			outputLength++;

   313 			rDestString.Append( *pSource );

   314 			}

   315 		else	// check for encoded character

   316 			{

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

   318 

   319 			if ( pSource+2 < pEnd )

   320 				{

   321 				pSource++;

   322 

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

   324 				if (*pSource != KImcvCR) 

   325 					{

   326 					if(*pSource != KImcvLF) 

   327 						{

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

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

   330 						 pSource++;

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

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

   333 						 // bung the character thus formed onto the decoded string

   334 						 rDestString.Append( asciiValue );

   335 						 // *ptr++ = asciiValue;

   336 						 outputLength++;

   337 						}

   338 					}

   339 				else

   340 					{

   341 					pSource++;

   342 					if(*pSource != KImcvLF)

   343 						{

   344 						error=KErrCorrupt;

   345 						pSource-=2;

   346 						rDestString.Append( *pSource );

   347 						pSource++;

   348 						rDestString.Append( *pSource );

   349 						pSource++;

   350 						outputLength+=2;

   351 						}

   352 					}

   353 				}

   354 			else

   355 				{

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

   357 

   358 				while (pSource < pEnd)

   359 					{

   360 					error=KErrCorrupt; // not QP compliant

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

   362 					outputLength++;

   363 					rDestString.Append( *pSource );

   364 					pSource++;

   365 					}

   366 				}

   367 			} // check for '=' char

   368 		

   369 		pSource++;  // next source charactery

   370 	} // while

   371 

   372 	rDestString.SetLength(outputLength);

   373 

   374 	return error;

   375 	}

   376 

   377 

   378 // Not used. Remove in 6.3

   379 //

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

   381 	{

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

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

   384 	

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

   386 	TBuf8<5> formatted; 

   387 	

   388 	TLex8 lexSource(aInputLine);

   389 	TDes8& ptr = rOutputLine;

   390 	TInt ptrEnd = ptr.MaxLength();

   391 

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

   393 		{

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

   395 			{

   396 			AddSoftLineBreak(ptr, localPaddingCount, written);

   397 			break;

   398 			}

   399 

   400 		TChar peek = lexSource.Peek();

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

   402 			// simple case, printable character

   403 			{

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

   405 			ptr.Append(peek);

   406 			written++;

   407 			}

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

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

   410 			{

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

   412 

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

   414 				{

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

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

   417 				formatted.UpperCase();

   418 				ptr.Append( formatted );

   419 				ptr.Append(KImcvCRLF);

   420 

   421 				// also skip EOL the characters we just allowed for

   422 				written+=7;

   423 				localPaddingCount+=4;

   424 

   425 				// advance to next source character	

   426 				lexSource.Inc();

   427 				break;

   428 				}

   429 			else

   430 				// no EOL, just carry on after the whitespace

   431 				{

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

   433 				ptr.Append( thisChar );

   434 				written++;

   435 				lexSource.Inc(-1);

   436 				}

   437 			}

   438 		else if ( (TUint8)peek==iQPCharacter )

   439 			// '=' in source text

   440 			{

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

   442 			if(written > KMaxIMailBodyLineLength-6)

   443 				break;

   444 

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

   446 			ptr.Append( KImcvQPEqualsSign );

   447 			written += 3;

   448 			localPaddingCount+=2;

   449 			}

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

   451 			// check for CEditableText control character

   452 			{

   453 			TChar replacement = ReplacementChar(peek);

   454 			if (replacement)

   455 				{

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

   457 				ptr.Append( replacement );

   458 				written++;

   459 				}

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

   461 				{

   462 				ptr.Append(KImcvCRLF);

   463 				written+=2;

   464 				localPaddingCount+=1;

   465 				break;

   466 				}

   467 			else

   468 				localPaddingCount-=1;

   469 			}

   470 		else

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

   472 			{

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

   474 			if(written > KMaxIMailBodyLineLength-6)

   475 				{

   476 				if (written+3 < KMaxIMailBodyLineLength)

   477 					{

   478 					AddSoftLineBreak(ptr, localPaddingCount, written);

   479 					}

   480 				break;

   481 				}

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

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

   484 			formatted.UpperCase();

   485 			ptr.Append(formatted);

   486 			written += 3;

   487 			localPaddingCount += 2;

   488 			}

   489 		

   490 		// advance to next source character	

   491 		lexSource.Inc();

   492 

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

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

   495 

   496 		TChar thisChar = lexSource.Get();

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

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

   499 		if (thisChar != 0)

   500 			lexSource.Inc(-1);

   501 

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

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

   504 			&& nextChar==CEditableText::EParagraphDelimiter 

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

   506 			break;

   507 		} // while

   508 

   509 	rOutputLine.SetLength( written );

   510 

   511 	return 	(written-localPaddingCount);

   512 	}

   513 

   514 

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

   516 	{

   517 	TInt error = KErrNone;

   518 

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

   520 

   521 	rDestString = KNullDesC;

   522 

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

   524 	const TUint8* pSource = source.Ptr();

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

   526 	

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

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

   529 	while (pSource < pEnd-2) // avoid the CRLF at the end of the line (we know it's there thanks to the assertion above)

   530 		{

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

   532 			{

   533 			blankLine = EFalse;

   534 			break;

   535 			}

   536 		else

   537 			pSource++;

   538 		}

   539 

   540 	if ( blankLine )

   541 		rDestString.Copy( aSrcString )

   542 		;	

   543 	else

   544 		{

   545 		TInt outputLength=0;

   546 		TUint8 loBits;

   547 		TUint8 hiBits;

   548 		TUint8 asciiValue;

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

   550 		const TUint8 zero = '0';

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

   552 										// alphabetical hex digits to get their numeric value

   553 		while( pSource < pEnd )

   554 			{

   555 			// check for encoded character

   556 			if (*pSource == iQPCharacter )

   557 				{

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

   559 				if ( pSource+2 < pEnd )

   560 					{

   561 					pSource++;

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

   563 					if (*pSource != KImcvCR) 

   564 						{

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

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

   567 						pSource++;

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

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

   570 						// bung the character thus formed onto the decoded string

   571 						rDestString.Append( asciiValue );

   572 						// *ptr++ = asciiValue;

   573 						outputLength++;

   574 						}

   575 					else

   576 						{

   577 						pSource++;

   578 						if(*pSource != KImcvLF)

   579 							{

   580 							error=KErrCorrupt;

   581 							pSource-=2;

   582 							rDestString.Append( *pSource );

   583 							pSource++;

   584 							rDestString.Append( *pSource );

   585 							pSource++;

   586 							outputLength+=2;

   587 							}

   588 						}

   589 					}

   590 				else

   591 					{

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

   593 					while (pSource < pEnd)

   594 						{

   595 						error=KErrCorrupt; // not QP compliant

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

   597 						outputLength++;

   598 						rDestString.Append( *pSource );

   599 						pSource++;

   600 						}

   601 					}

   602 				} // check for '=' char

   603 			else

   604 				{

   605 				if ( *pSource == KImcvCR && (pSource+1 < pEnd && *(pSource+1) == KImcvLF))

   606 					{

   607 					// this is a hard CRLF, so replace it with a Paragraph Delimiter

   608 					

   609 					// *ptr++ = ETextParagraphDelimiter;

   610 					rDestString.Append( (TChar) CEditableText::EParagraphDelimiter );

   611 					outputLength++;

   612 					

   613 					// ... and skip an extra char (the LF)

   614 					pSource++;

   615 					}

   616 				else

   617 					{

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

   619 					// *ptr++ = *pSource;

   620 					outputLength++;

   621 					rDestString.Append( *pSource );

   622 					}

   623 				}

   624 			// next source character

   625 			pSource++;

   626 			} // while

   627 		rDestString.SetLength(outputLength);

   628 		} // else

   629 	return error;

   630 	}

   631 

   632 

   633 //---------------------------------------------------------------------------------

   634 //              Class TImFileCodec Functions

   635 //---------------------------------------------------------------------------------

   636 	

   637 

   638 TInt TImFileCodec::PostfixNextLine(TDes8&  rOutputLine, TInt& rPaddingCount)

   639 	{

   640 	return BlankLine(rOutputLine, rPaddingCount);

   641 	}

   642 

   643 

   644 TInt TImFileCodec::PrefixNextLineL(TDes8& /* rOutputLine*/, const TFileName& /*aName*/, TInt& /*rPaddingCount*/)

   645 	{

   646 	return KImAttFinished;

   647 	}

   648 

   649 

   650 void TImFileCodec::Initialise()

   651 	{

   652 	iPostfixState=0;

   653 	iPrefixState=0;

   654 	}

   655 

   656 //---------------------------------------------------------------------------------

   657 //              Class TImCodecB64 Functions

   658 //---------------------------------------------------------------------------------

   659 

   660 

   661 EXPORT_C TImCodecB64::TImCodecB64(): iShiftStored(0), iMaskShiftStored(ESix)

   662 	{}

   663 

   664 

   665 // Returns ETrue if aSrcString is not long enough to decode fully, resulting in the storage of

   666 // the last character and requiring another aSrcString (poss 0 length) to be passed to it to 

   667 // clear this character. 

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

   669 //

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

   671 	{

   672 	TInt decodedInt=0;

   673 	TInt8 offsetChar=0;

   674 	TUint8 decodedChar=0;

   675 	 

   676 	// Clears the destination string

   677 	rDestString.Zero();

   678 

   679 	// Initialise variables

   680 	const TUint8* srcStringPtr=aSrcString.Ptr();

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

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

   683 	TUint8* destStringPtrBase=destStringPtr;

   684 

   685 	TInt maskShift=iMaskShiftStored;

   686 	TInt shiftStorage=iShiftStored;

   687 	

   688 	// Main character process loop

   689 	while(srcStringPtr<srcStringEnd)	

   690 		{

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

   692 		srcStringPtr++;

   693 

   694 		// Check for valid B64 character		

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

   696 			{

   697 			// Read in next character and B64 decode

   698 			decodedInt=AsciiToBase64[offsetChar];

   699 

   700 			// Exits when a PAD char is reached

   701 			if(decodedInt==EPadChar)

   702 				{

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

   704 				return EFalse;

   705 				}

   706 

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

   708 			if(maskShift==ESix)

   709 				maskShift=EFour;

   710 			else

   711 				{

   712 				shiftStorage=shiftStorage<<ESix;

   713 				shiftStorage=shiftStorage|decodedInt;

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

   715 				

   716 				if((maskShift-=ETwo)<EZero)

   717 					maskShift=ESix; 

   718 				

   719 				*destStringPtr++=decodedChar;

   720 				}

   721 			shiftStorage=decodedInt;

   722 			}

   723 		}

   724 	iShiftStored=shiftStorage;

   725 	iMaskShiftStored=maskShift;

   726 	

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

   728 	

   729 	return maskShift<ESix;

   730 	}

   731 

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

   733 	{

   734 	return DoEncode(aSrcString, rDestString, EFalse);

   735 	}

   736 

   737 EXPORT_C void TImCodecB64::Initialise()

   738 	{

   739 	iMaskShiftStored=ESix;

   740 	}

   741 

   742 TInt TImCodecB64::DoEncode(const TDesC8& aSrcString, TDes8& rDestString, TBool aInsertLineBreaks)

   743 	{

   744 	// Clears the destination string

   745 	rDestString.Zero();

   746 	

   747 	// Initialise variables

   748 	const TUint8* srcStringPtr=aSrcString.Ptr();

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

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

   751 	TUint8* destStringPtrBase=destStringPtr;

   752 

   753 	TInt character=0;

   754 	TUint8 encodedChar=0;

   755 	TInt charStorage=0;

   756  	TInt maskShift=EZero;

   757 	TInt destStringCharNum = 0;

   758 

   759 	while(srcStringPtr<=srcStringEnd)

   760 		{

   761 		// maskShift is used as a char read counter

   762 		if(maskShift==ESix)

   763 			{

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

   765 			// is broken on the next check.

   766 			if(srcStringPtr==srcStringEnd)

   767 				srcStringPtr++;

   768 			maskShift=EZero;

   769 			character=0;   

   770 			}

   771 		else

   772 			{

   773 			if(srcStringPtr==srcStringEnd)

   774 				character=0;

   775 			else

   776 				character=*srcStringPtr;

   777 

   778 			srcStringPtr++;

   779 			// Shifts charStorage ready for the next char

   780 			charStorage=charStorage<<8;

   781 			maskShift+=ETwo;

   782 			}

   783 		charStorage=charStorage|character;

   784 		// Shifts the mask to the correct bit location

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

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

   787 		// Converts to BASE64 char, Casts the result to an unsigned char (which it should be ?....I hope)

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

   789 

   790 		*destStringPtr++=encodedChar;

   791 		destStringCharNum++;

   792 

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

   794 		// limitation specified in RFC 2822.

   795 		if (aInsertLineBreaks && destStringCharNum == KMaxB64EncodedCharsPerLine)

   796 			{

   797 			destStringCharNum = 0;

   798 			*destStringPtr++ = '\r';

   799 			*destStringPtr++ = '\n';

   800 			}

   801 		}

   802 	

   803 	// Check for not enough chars and pad if required

   804 	if (maskShift==EFour)

   805 		{

   806 		*destStringPtr++=KImcvConvEquals;

   807 		*destStringPtr++=KImcvConvEquals;

   808 		}

   809 	else

   810 		if(maskShift==ESix)

   811 			*destStringPtr++=KImcvConvEquals;	

   812 			

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

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

   815 	}

   816 

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

   818    	{

   819 	return DoEncode(aSrcString, rDestString, ETrue);

   820    	}

   821 

   822 //---------------------------------------------------------------------------------

   823 //              Class TImCodecUU Functions

   824 //---------------------------------------------------------------------------------

   825 

   826 

   827 EXPORT_C TImCodecUU::TImCodecUU()

   828 	{}

   829 

   830 

   831 // returns ETrue if aSrcString is not long enough, relative to its line length character.

   832 // or if an invalid UU encoded character is found.

   833 // returns EFalse if the line was decoded OK

   834 //

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

   836 	{

   837 	// Clears the destination string

   838 	rDestString.Zero();

   839 

   840 	// Initialise variables

   841 	const TUint8* srcStringPtr=aSrcString.Ptr();

   842 	TInt numEncChrs=*srcStringPtr++-ESpace;

   843 	TInt maskShift=ESix;

   844 	TInt numDecChrs=0;

   845 	TInt shiftStorage=0;

   846 	TInt character=0;

   847 	TUint8 decodedChar=0;

   848 	

   849 	// Checks if the srcString is atleast long enough to decode.

   850 	if((numEncChrs*4)>((aSrcString.Length()-1)*3)) return ETrue;

   851 

   852 	// Main character process loop

   853 	while(numDecChrs<numEncChrs)	

   854 		{

   855 		// Read in next character

   856 		character=*srcStringPtr++;

   857 

   858 		// Check for UU character validity

   859 		if((character<ESpace)||(character>EBackQuote)) return ETrue;

   860 

   861 		// Protocol thing		

   862 		if(character==EBackQuote)

   863 			character=ESpace;

   864 

   865 		character-=ESpace;

   866 		

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

   868 		if(maskShift==ESix)

   869 			maskShift=EFour;

   870 		else

   871 			{

   872 			shiftStorage=shiftStorage<<ESix;

   873 			shiftStorage=shiftStorage|character;

   874 

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

   876 			maskShift=((maskShift==EZero)? ESix:(maskShift-ETwo)); 

   877 				

   878 			rDestString.Append(decodedChar);

   879 			numDecChrs++;

   880 			}

   881 		shiftStorage=character;

   882 		}

   883 	return EFalse;

   884 	}

   885 

   886 

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

   888 	{

   889 	// Clears the destination string

   890 	rDestString.Zero();

   891 	

   892 	// Initialise variables

   893 	const TUint8* srcStringPtr=aSrcString.Ptr();

   894 	const TInt srcLength=aSrcString.Length();

   895 	const TUint8* srcStringEnd=srcStringPtr+srcLength;

   896 	TInt charStorage=0;

   897 	TInt maskShift=EZero;

   898 	TInt character=0;

   899 	TUint8 encodedChar=0;

   900 	TInt destStringCharNum = 0;

   901 	TInt srcStringBytesRemaining = 0;

   902 

   903    	while(srcStringPtr<=srcStringEnd)

   904    		{

   905 		// Add unencoded length to start of line as per UU specification.

   906 		if (destStringCharNum == 0)

   907 			{

   908 			srcStringBytesRemaining = srcStringEnd - srcStringPtr;

   909 			if ( srcStringBytesRemaining < KMaxUUUnEncodedCharsPerLine ) 

   910 				rDestString.Append(static_cast<TUint8>(srcStringBytesRemaining) + ESpace);

   911 			else

   912 				rDestString.Append(KMaxUUUnEncodedCharsPerLine + ESpace);

   913 			}

   914 

   915 		if(maskShift==ESix)

   916 			{

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

   918 			// is broken on the next check.

   919 			if(srcStringPtr==srcStringEnd)

   920 				srcStringPtr++;

   921 			character=0;

   922 			maskShift=EZero;

   923 			}

   924 		else

   925 			{

   926 			if(srcStringPtr==srcStringEnd)

   927 				character=0;

   928 			else

   929 				character=*srcStringPtr;

   930 

   931 			srcStringPtr++;

   932 			charStorage=charStorage<<8;

   933 			maskShift+=ETwo;

   934 			}

   935 		charStorage=charStorage|character;

   936 		// Shifts the mask to the correct bit location

   937 		// Masks (AND's) the valid bits

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

   939 		// Adds 32 (SPACE), Casts the result to an unsigned char (which it should be ?....I hope)

   940 		encodedChar=(TUint8)(((charStorage>>maskShift)&ESixBitMask)+ESpace);

   941 

   942 		// Protocol thing		

   943 		if(encodedChar==ESpace)

   944 			encodedChar=EBackQuote;

   945 

   946 		rDestString.Append(encodedChar);

   947 		++destStringCharNum;

   948 

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

   950 		// limitation recommended for UUE.

   951 		if (destStringCharNum == KMaxUUEncodedCharsPerLine)

   952 			{

   953 			destStringCharNum = 0;

   954 			rDestString.Append(KImcvCRLF);

   955 			}

   956 		}

   957 

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

   959 	}

   960 

   961 

   962 TInt TImCodecUU::PrefixNextLineL( TDes8& rOutputLine, const TFileName& aName, TInt& rPaddingCount )

   963 	{

   964 	rOutputLine.Append( KImcvUueStart );

   965 	rOutputLine.Append( KImcvUue644 );

   966 	AppendFilenameL( rOutputLine, aName );

   967 	rPaddingCount=rOutputLine.Length();

   968 	return 1;

   969 	}

   970 

   971 TInt TImCodecUU::PostfixNextLine( TDes8& rOutputLine, TInt& rPaddingCount )

   972 	{

   973 	switch( iPostfixState )

   974 		{

   975 		case EInvertedComma:

   976 			rOutputLine.Append( KImcvInvertedComma );

   977 			break;

   978 		case EEndString:

   979 			rOutputLine = KImcvUueEnd;

   980 			break;

   981 		}

   982 	

   983 	iPostfixState++;

   984 	rPaddingCount=rOutputLine.Length();

   985 

   986 	return (iPostfixState==EEndOfPostfix ? KImAttFinished : KErrNone);

   987 	}

   988 

   989 

   990 

   991 void TImCodecUU::AppendFilenameL( TDes8& rOutputLine, const TFileName& aName)

   992 	{

   993 	HBufC8* buf = HBufC8::NewLC( aName.Length() );

   994 	buf->Des().Copy( aName );

   995 	rOutputLine.Append(KImcvSpace);

   996 	rOutputLine.Append( *buf );

   997 	CleanupStack::PopAndDestroy(); // buf

   998 	}

   999 

  1000 

  1001 

  1002 

  1003 //---------------------------------------------------------------------------------

  1004 //              Class CImConvertHeader Functions

  1005 //

  1006 // Utility class, providing functionality for encoding/decoding header fields.

  1007 // Requires use of Charconv "Wrapper" class.

  1008 //------------------------------------------------------------------------------

  1009 

  1010 /**

  1011 @publishedPartner

  1012 @released

  1013 */

  1014 EXPORT_C CImConvertHeader* CImConvertHeader::NewL(CImConvertCharconv& aConverter)

  1015 	{

  1016 	CImConvertHeader* self = new (ELeave) CImConvertHeader (aConverter);

  1017 	CleanupStack::PushL(self);

  1018 	self->ConstructL();

  1019 	CleanupStack::Pop(self);

  1020 	return self;

  1021 	}

  1022 

  1023 CImConvertHeader::CImConvertHeader(CImConvertCharconv& aConverter) : 

  1024 	iCharConv (aConverter)

  1025 	{

  1026 	}

  1027 

  1028 CImConvertHeader::~CImConvertHeader() 

  1029 	{

  1030 	iHeader = NULL;

  1031 	}

  1032 

  1033 void CImConvertHeader::ConstructL() 

  1034 	{

  1035 	iQPCodec.AddEncodeChar(KImcvEncodeCharacterList);

  1036 

  1037 	// Default setting.

  1038 	iCharConv.PrepareToConvertToFromOurCharsetL(iCharConv.DefaultCharset());

  1039 	}

  1040 

  1041 EXPORT_C void CImConvertHeader::SetMessageType(TBool aIsMIME)

  1042 	{

  1043 	isMIMEMessageHeader=aIsMIME;

  1044 	}

  1045 

  1046 EXPORT_C void CImConvertHeader::SetOverrideCharset(TUint aCharset)

  1047 /**

  1048 Sets the override character set to use when decoding the 8 bit data. Zero

  1049 indicates the charset not to be used.

  1050 

  1051 @param aCharset

  1052 The new character set to use as an overriding character set.

  1053 */

  1054 	{

  1055 	iOverrideCharset = aCharset;

  1056 	}

  1057 

  1058 EXPORT_C TUint CImConvertHeader::OverrideCharset() const

  1059 /**

  1060 Retrieves the override character set that will be used when decoding the 8 bit

  1061 data. A character set value of zero indicates no overriding character set will

  1062 be used.

  1063 */

  1064 	{

  1065 	return iOverrideCharset;

  1066 	}

  1067 

  1068 //------------------------------------------------------------------------------

  1069 

  1070 EXPORT_C void CImConvertHeader::DecodeAllHeaderFieldsL(CImHeader& rHeader)

  1071 	{

  1072 	iHeader = &rHeader;

  1073 

  1074 	iHeader->SaveEncodedHeadersL();

  1075 	

  1076 	// If Header field does not have a Mime info, but header has encoded words, then 

  1077 	// we need to parse it accordingly. 

  1078 	TBool nonMime = EFalse; 

  1079 	if (!isMIMEMessageHeader) 

  1080 		{ 

  1081 		isMIMEMessageHeader = ETrue; 

  1082 		nonMime = ETrue; 

  1083 		}

  1084 

  1085 	// FROM:

  1086 	iEncodingInfo.SetField(TImHeaderEncodingInfo::EFrom);

  1087 	DecodeFieldL( rHeader.From());

  1088 

  1089 	// SUBJECT:

  1090 	iEncodingInfo.SetField(TImHeaderEncodingInfo::ESubject);

  1091 	DecodeFieldL( rHeader.Subject());

  1092 

  1093 	// REPLYTO:

  1094 	iEncodingInfo.SetField(TImHeaderEncodingInfo::EReplyTo);

  1095 	DecodeFieldL( rHeader.ReplyTo());

  1096 

  1097 	// TO:

  1098 	iEncodingInfo.SetField(TImHeaderEncodingInfo::ETo);

  1099 	DecodeRecipientListL(rHeader.ToRecipients());

  1100 

  1101 	// CC:

  1102 	iEncodingInfo.SetField(TImHeaderEncodingInfo::ECc);

  1103 	DecodeRecipientListL(rHeader.CcRecipients());

  1104 

  1105 	// BCC:

  1106 	iEncodingInfo.SetField(TImHeaderEncodingInfo::EBcc);

  1107 	DecodeRecipientListL(rHeader.BccRecipients());

  1108 

  1109 	if(nonMime) 

  1110 		{ 

  1111 		isMIMEMessageHeader = EFalse; 

  1112 		} 	

  1113 		

  1114 	iHeader = NULL; // iHeader is not used outside non-exported function DecodeFieldL

  1115 	}

  1116 

  1117 

  1118 void CImConvertHeader::DecodeFieldL(const TDesC& aField)

  1119 	{

  1120 	HBufC* buf = HBufC::NewLC(aField.Size());

  1121 	TPtr ptr(buf->Des());

  1122 	DecodeHeaderFieldL(aField, ptr);

  1123 

  1124 	switch (iEncodingInfo.Field())

  1125 		{

  1126 	case TImHeaderEncodingInfo::EFrom:

  1127 		iHeader->SetFromL(*buf);

  1128 		break;

  1129 	case TImHeaderEncodingInfo::ESubject:

  1130 		iHeader->SetSubjectL(*buf);

  1131 		break;

  1132 	case TImHeaderEncodingInfo::EReplyTo:

  1133 		iHeader->SetReplyToL(*buf);

  1134 		break;