1 // Copyright (c) 1998-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 #include <e32base.h>

    17 #include "IMUTDLL.H"

    18 #include "IMCVTEXT.H"

    19 #include "IMCVRECV.H"

    20 #include "IMCVCODC.H"	// TImConvert

    21 #include "IMCVUTIL.H"

    22 #include "CMsvPlainBodyTextEntry.H"

    23 #include <cmsvplainbodytext.h>

    24 

    25 #include <miuthdr.h>	// CImHeader

    26 #include <miutatch.h>	// TImAttachmentFile

    27 #include <msvids.h>

    28 #include <txtrich.h>

    29 #include <imcm.rsg>		// resource definition for IMCM

    30 

    31 #include <pop3set.h>	// For including KUidMsgTypePOP3

    32 #include <barsread.h>	// TResourceReader

    33 

    34 #include <cmsvbodytext.h>

    35 

    36 #ifdef __WINS__

    37 #include <e32wins.h>    // for maxfilename lengths

    38 #include <msvapi.h>

    39 #endif

    40 

    41 #ifndef __WINS__

    42 #include <msvapi.h>

    43 #endif

    44 #include <cmsvattachment.h> 

    45 #include <mmsvattachmentmanager.h>

    46 #include <mmsvattachmentmanagersync.h>

    47 

    48 #ifndef _MSG_NO_LOGGING

    49 #define __IMUT_LOGGING

    50 _LIT(KLogFilePath, "c:\\logs\\mailtext\\in.txt");

    51 _LIT8(KNewLogHeader, "\r\n------ New Receive Session ------\r\n");

    52 _LIT8(KFound, "found: ");

    53 _LIT8(KFoundIncomplete, "found but incomplete: ");

    54 _LIT8(KPartLine, "unknown or part line");

    55 _LIT8(KEndOFHeader, "End of header");

    56 _LIT8(KSkippingData, "Skipping data");

    57 _LIT8(KCollectingData7, "Collecting 7/8-bit data");

    58 _LIT8(KCollectingDataQP, "Collecting QP data");

    59 _LIT8(KCollectingBase64, "Collecting BASE64 data");

    60 _LIT8(KCollectingUU, "Collecting UU data");

    61 _LIT8(KDecodingBase64, "Decoding BASE64 data");

    62 _LIT8(KDecodedBase64, "Decoded BASE64 data");

    63 _LIT8(KDecodingUU, "Decoding UU data");

    64 _LIT8(KDecodedUU, "Decoded UU data");

    65 _LIT8(KDecodingQP, "Decoding QP data");

    66 _LIT8(KDecodedQP, "Decoded QP data");

    67 _LIT8(KUUEDataCorrupt, "UU Data is corrupt");

    68 _LIT8(KFoundUUEStartBoundary, "UUE start boundary");

    69 _LIT8(KFoundUUEEndBoundary, "UUE end boundary");

    70 _LIT8(KClosingAttachFile, "Closing attachment file");

    71 _LIT8(KDeletingAttachFile, "Deleting attachment file");

    72 _LIT8(KDeletedAttachFile, "Deleted attachment file");

    73 _LIT8(KFailedToWriteToFile, "Failed to write to attachment file");

    74 _LIT8(KSectionHeader, "Section header");

    75 _LIT8(KFoundMIMEBoundary, "MIME boundary");

    76 _LIT8(KWritingToBody, "writing body");

    77 _LIT8(KWroteToBody, "wrote body");

    78 _LIT8(KWritingToFile, "writing attachment");

    79 _LIT8(KWroteToFile, "wrote attachment");

    80 _LIT8(KReset, "Resetting CImRecvConvert");

    81 _LIT8(KReseted, "Resetting CImRecvConvert");

    82 _LIT8(KDelete, "Deleting CImRecvConvert");

    83 _LIT8(KDeleted, "Deleting CImRecvConvert");

    84 _LIT8(KLineHasLineBreak, "Linebreak");

    85 _LIT8(KLastToken, "That was the last token");

    86 _LIT8(KBlankLine, "Blank line");

    87 _LIT8(KRemoveBoundary, "Remove boundary");

    88 _LIT8(KRemovedBoundary, "Removed boundary");

    89 _LIT8(KResetForNewEntry, "Reset for a New Entry");

    90 _LIT8(KResetedForNewEntry, "Reseted for a New Entry");

    91 _LIT8(KResetForNonMimeEntry, "Reset for a New Non-Mime Entry");

    92 _LIT8(KResetedForNonMimeEntry, "Reseted for a New Non-Mime Entry");

    93 _LIT8(KCreatingEntry, "Creating Entry");

    94 _LIT8(KCreatedEntry, "Created Entry");

    95 _LIT8(KUpdatingEntry, "Updating Entry");

    96 _LIT8(KUpdatedEntry, "Updated Entry");

    97 _LIT8(KMoveToParentEntry, "Moved to parent entry");

    98 _LIT8(KMovedToParentEntry, "End of Moved to parent entry");

    99 _LIT8(KStoringHeader, "Storing CImHeader");

   100 _LIT8(KStoredHeader, "Stored CImHeader");

   101 _LIT8(KStoringBody, "Storing CRichText");

   102 _LIT8(KStoring8BitBody, "Storing CMsvBodyText");

   103 _LIT8(KStoredBody, "Stored CRichText");

   104 _LIT8(KStored8BitBody, "Stored CMsvBodyText");

   105 _LIT8(KStoringMIMEHeader, "Storing CImMimeHeader");

   106 _LIT8(KStoredMIMEHeader, "Stored CImMimeHeader");

   107 _LIT8(KIgnoringStreams, "Discarding streams");

   108 _LIT8(KStartMessageComplete, "Start Message Complete");

   109 _LIT8(KMessageComplete, "Message Complete");

   110 _LIT8(KHeaderComplete, "Message Header complete");

   111 _LIT8(KReturnReceiptTo, "return-receipt-To is set");

   112 _LIT8(KStartStoringEntryStream, "Starting Storing Entry Stream");

   113 _LIT8(KStoringEntryStream, "Storing Entry Stream");

   114 _LIT8(KDoneStoringEntryStream, "Done Storing Entry Stream");

   115 #endif // _MSG_NO_LOGGING

   116 

   117 // uncomment the line below if logging is to be enabled

   118 

   119 #if defined(__IMUT_LOGGING)

   120 #define RECVLOG(text) (iImcvLog?iImcvLog->AppendComment(text):void(0));

   121 #define RECVLOG_OUT(text) (iImcvLog?iImcvLog->AppendOut(text):void(0));

   122 #define LOGGING(string1, string2) (Logging(string1, string2));

   123 #else

   124 #define RECVLOG(text) (void(0));

   125 #define RECVLOG_OUT(text) (void(0));

   126 #define LOGGING(string1, string2) (void(0));

   127 #endif

   128 

   129 

   130 const TInt KBodyTextChunkSizeBytes = 512;

   131 

   132 _LIT(KIntegerKey,"%d");

   133 const TInt KSpaceToAddNumber=20;

   134 

   135 

   136 //----------------------------------------------------------------------------------------  

   137 LOCAL_C TBool IsIllegalChar(const TUint aChar)

   138 //----------------------------------------------------------------------------------------  

   139 	{

   140 	// EPOC32 filenames must not contain any of the following chars

   141     return (aChar == '*' || aChar == '\\' || aChar == '<' || aChar == '>' ||

   142 			aChar == ':'  || aChar == '"' ||  aChar    == '/' || aChar == '|' ||

   143 			aChar < ' ' || aChar =='?');

   144 	}

   145 

   146 //----------------------------------------------------------------------------------------

   147 LOCAL_C void RemoveSurroundingCharacters( const TUint8& aLeft, const TUint8& aRight, HBufC8& aString)

   148 //----------------------------------------------------------------------------------------

   149 	{

   150 	TPtr8 des = aString.Des();

   151 	TInt len  = des.Length();

   152 	

   153 	if( len>2 && des[0]==aLeft && des[len-1]==aRight )

   154 		{

   155 		TPtrC8 mid = des.Mid(1, len-1);

   156 		des.Copy(mid);

   157 		des.SetLength(len-2);

   158 		}

   159 	}

   160 

   161 

   162 //****************************************************************************************

   163 //              Class CRfc822Token Functions

   164 //****************************************************************************************

   165 

   166 //----------------------------------------------------------------------------------------

   167 EXPORT_C CRfc822Token* CRfc822Token::NewLC()

   168 //----------------------------------------------------------------------------------------

   169 	{

   170 	CRfc822Token* self = new (ELeave) CRfc822Token;

   171 	CleanupStack::PushL(self);

   172 	self->ConstructL();

   173 	return self;

   174 	}

   175 

   176 //----------------------------------------------------------------------------------------

   177 void CRfc822Token::ConstructL()

   178 //----------------------------------------------------------------------------------------

   179 	{

   180 	iOutputLine = HBufC8::NewL(KMaxIMailHeaderReadLineLength+1);

   181 	Reset();

   182 	}

   183 

   184 //----------------------------------------------------------------------------------------

   185 CRfc822Token::CRfc822Token()

   186 //----------------------------------------------------------------------------------------

   187 	{

   188 	__DECLARE_NAME(_S("CRfc822Token"));

   189 	}

   190 

   191 //----------------------------------------------------------------------------------------

   192 EXPORT_C CRfc822Token::~CRfc822Token()

   193 //----------------------------------------------------------------------------------------

   194 	{

   195 	delete iOutputLine;

   196 	}

   197 

   198 //----------------------------------------------------------------------------------------

   199 EXPORT_C void CRfc822Token::Reset()

   200 //----------------------------------------------------------------------------------------

   201 	{

   202 	iOutputLine->Des().FillZ();

   203 	iBufferedInput.SetLength(0);

   204 	iBufferedInput.FillZ();

   205 

   206 	iLastToken = EFalse;

   207 	iFirstLine = ETrue;

   208 	i822FieldsExist=EFalse;

   209 	}

   210 

   211 //----------------------------------------------------------------------------------------

   212 EXPORT_C void CRfc822Token::ParseNextLineL(const TDesC8& aSourceLine)

   213 //----------------------------------------------------------------------------------------

   214 	{

   215 	TBool hitEof = EFalse;

   216 	TBool endOfField = EFalse;

   217 	// Always read one more packet than we need so we know we've read the entire field.

   218 

   219 	// Consequently, we need to check whether there is any buffered input from the

   220 	// previous rfc822 field:*******

   221 

   222 	if(iBufferedInput.Length())

   223 		{

   224 		// the buffered input is never more than a line of text...

   225 		*iOutputLine = iBufferedInput;

   226 		

   227  		iBufferedInput.FillZ();

   228 		iBufferedInput.SetLength(0);

   229 		}

   230 	iInputLine = aSourceLine;

   231 

   232 	// discard any LF character from the begining of the line (this is abit strange?)

   233 	while(iInputLine.Length() > 0 && (iInputLine[0] == KImcvLF || iInputLine[0] == KImcvCR))

   234 		iInputLine.Delete(0, 1);

   235 

   236 	// remove the CR at the end but only if there's stuff before it

   237 	while(iInputLine.Length() > 0 && (iInputLine[iInputLine.Length()-1] == KImcvLF || iInputLine[iInputLine.Length()-1] == KImcvCR))

   238 		iInputLine.Delete(iInputLine.Length()-1, 1);

   239 

   240 	// if the newly read line is now empty, then don't read any more through this tokeniser

   241 	iLastToken = !iInputLine.Length();

   242 

   243 	// only bother with the rest of the parsing if there's any data left

   244 	if(iInputLine.Length() > 0 || iOutputLine->Length() > 0)

   245 		{

   246 		// check whether we're on the next field or still on the current one

   247 		if(!iFirstLine && iInputLine.Length() > 0 && iInputLine[0] != KImcvSP && iInputLine[0] != KImcvTab)

   248 			{

   249 			// we've read the first line of the next field

   250 			iBufferedInput = iInputLine;

   251 			endOfField = ETrue; // flag the fact that the current field is ready for parsing

   252 			}

   253 		else // the line belongs in the current field, we need to keep the leading whitespace

   254 			 // Folding headers, RFC 2822, section 2.2.3

   255 			{

   256 			// make sure we're not about to exceed the buffer

   257 			//Restricting the field size of the header to 5000, to avoid -4 error

   258 			//and which at times ends up in DOS condition [denial of service- user wouldn't be able to download any further mails]. 

   259 			if (iOutputLine->Length()<5000)

   260 				{

   261 				if((iOutputLine->Length() + iInputLine.Length()) > iOutputLine->Des().MaxLength())

   262 					iOutputLine = iOutputLine->ReAllocL(iOutputLine->Length() + iInputLine.Length());

   263 

   264 				// now copy the remaining data into the buffer

   265 				iOutputLine->Des().Append(iInputLine);

   266 			    }

   267 			}

   268 		}

   269 	else

   270 		hitEof = ETrue;		//this means that EEndOfHeader is set if a line of zero length is parsed - ie. (clean CRLF - CRLF) = 0.

   271 	iFirstLine = EFalse;

   272 

   273 	if(endOfField || iLastToken)

   274 		{ 

   275 		// only parse the input when we have a whole field, 

   276 		// or we just found the blank line that

   277 		// separates the body from the header

   278 		if(MatchAndRemoveL(KImcvFromPrompt))

   279 			iHeaderPart = EFrom;

   280 		else if(MatchAndRemoveL(KImcvReplyToPrompt))

   281 			iHeaderPart = EReplyTo;

   282 		else if(MatchAndRemoveL(KImcvToPrompt))

   283 			iHeaderPart = ETo;

   284 		else if(MatchAndRemoveL(KImcvCcPrompt))

   285 			iHeaderPart = ECc;

   286 		else if(MatchAndRemoveL(KImcvBccPrompt))

   287 			iHeaderPart = EBcc;

   288 		else if(MatchAndRemoveL(KImcvSubjectPrompt))

   289 			iHeaderPart = ESubject;

   290 		else if(MatchAndRemoveL(KImcvDatePrompt))

   291 			iHeaderPart = EDate;

   292 		else if(MatchAndRemoveL(KImcvReceivedPrompt))

   293 			iHeaderPart = EReceived;

   294 		else if(MatchAndRemoveL(KImcvMessageIdPrompt))

   295 			{

   296 			iHeaderPart = EMessageId;

   297 			RemoveSurroundingCharacters(KImcvLeftChevron, KImcvRightChevron, *iOutputLine);

   298 			}

   299 		else if (PriorityAndReceiptsMatchAndRemoveL(EPriority))

   300 			iHeaderPart=EPriority;

   301 		else if (PriorityAndReceiptsMatchAndRemoveL(EReturnReceiptTo))

   302 			iHeaderPart=EReturnReceiptTo;

   303 		else if(hitEof)

   304 			iHeaderPart = EEndOfHeader;

   305 		else

   306 			{

   307 			iHeaderPart = EUnknown;

   308 			iImRecvConvert->iMimeParser->ParseLineL(*iOutputLine);

   309 			}

   310 		}

   311 	else 

   312 		iHeaderPart = ENotFinished;

   313 	}

   314 

   315 TBool CRfc822Token::PriorityAndReceiptsMatchAndRemoveL(THeaderPart aPriority)

   316 	{

   317 	CDesC8Array* fields=new (ELeave)CDesC8ArrayFlat(6);

   318 	CleanupStack::PushL(fields);

   319 	if (aPriority==EPriority)

   320 		CImcvUtils::PriorityFieldsL(*fields);

   321 	else if (aPriority==EReturnReceiptTo)

   322 		CImcvUtils::ReceiptFieldsL(*fields);

   323 	else

   324 		{

   325 		CleanupStack::PopAndDestroy(); //fields

   326 		return EFalse;

   327 		}

   328 	TInt count=fields->Count();

   329 	TBool matched=EFalse;

   330 	for (TInt i=0;i<count;i++)

   331 		{

   332 		if (MatchAndRemoveL((*fields)[i]))

   333 			{

   334 			matched=ETrue;

   335 			break;

   336 			}

   337 		}

   338 	CleanupStack::PopAndDestroy(); //fields

   339 	return matched;

   340 	}

   341 

   342 //----------------------------------------------------------------------------------------

   343 TBool CRfc822Token::MatchAndRemoveL(const TDesC8& aString)

   344 //----------------------------------------------------------------------------------------

   345 	{

   346 	TInt comparison;

   347 	TInt stringLength = aString.Length();

   348 	TInt desLength = (*iOutputLine).Length();

   349 	TInt compareLength = stringLength > desLength ? desLength : stringLength;

   350 	TPtrC8 left((*iOutputLine).Left(compareLength));

   351 	

   352 	// now see whether the current line contains the search string

   353 	comparison = left.CompareF(aString);

   354 	if(!comparison)

   355 		{

   356 		// found the match string at the start of the output line, so remove it

   357 		// get rid of any whitespace betweebn the tag and the data while we have a chance

   358 		if (!i822FieldsExist)

   359 			i822FieldsExist=ETrue;

   360 		TInt whitespaceLength=0;

   361 		TInt maxLength=desLength-stringLength;

   362 		const TUint8* ptr = (*iOutputLine).Ptr();

   363 		while(whitespaceLength <= maxLength && (ptr[stringLength+whitespaceLength] == KImcvSP || ptr[stringLength+whitespaceLength] == KImcvTab))

   364 			whitespaceLength++;

   365 		(iOutputLine->Des()).Delete(0, stringLength+whitespaceLength);

   366 		}

   367 	return (comparison==0);

   368 	}

   369 

   370 

   371 //****************************************************************************************

   372 //             Class CImRecvConvert

   373 //****************************************************************************************

   374 //----------------------------------------------------------------------------------------    

   375 EXPORT_C CImRecvConvert* CImRecvConvert::NewLC(RFs& anFs, CMsvServerEntry* aServerEntry, 

   376 												TUid aMsgType, TMsvId aEmailServiceId)

   377 //----------------------------------------------------------------------------------------  

   378 	{

   379 	CImRecvConvert* self = new (ELeave) CImRecvConvert(anFs, aServerEntry, aMsgType, 

   380 																		aEmailServiceId);

   381 	CleanupStack::PushL(self);

   382 	self->ConstructL(anFs);

   383 	return self;

   384 	}

   385 

   386 //----------------------------------------------------------------------------------------  

   387 EXPORT_C CImRecvConvert* CImRecvConvert::NewL(RFs& anFs, CMsvServerEntry* aServerEntry, 

   388 												TUid aMsgType, TMsvId aEmailServiceId)

   389 //----------------------------------------------------------------------------------------  

   390 	{

   391 	CImRecvConvert* self = CImRecvConvert::NewLC(anFs, aServerEntry, aMsgType, 

   392 																aEmailServiceId);

   393 	CleanupStack::Pop();

   394 	return self;

   395 	}

   396 

   397 //----------------------------------------------------------------------------------------  

   398 void CImRecvConvert::ConstructL(RFs& anFs)

   399 //----------------------------------------------------------------------------------------  

   400 	{

   401 	iFsSession = &anFs;  

   402 

   403 	RResourceFile resFile;

   404 	OpenResourceFileL(resFile, anFs);	// NB leaves if file not found

   405 

   406 	// make sure the resource file will be closed if anything goes wrong

   407 	// CloseResourceFile is declared in IMUTDLL.H and defined in IMUTDLL.CPP

   408 	TCleanupItem close( CloseResourceFile, &resFile );

   409 	CleanupStack::PushL( close );

   410 	

   411 	// Read iStore8BitData flag.

   412 	HBufC8* buf = resFile.AllocReadLC( STORE_8BIT_BODY_TEXT );

   413 	TResourceReader reader;

   414 	reader.SetBuffer(buf);

   415 	iStore8BitData = reader.ReadInt8();

   416 	CleanupStack::PopAndDestroy(buf);

   417 	

   418 	//read iStorePlainBodyText flag for writing bodytext chunk bu chunk.

   419 	buf = resFile.AllocReadLC( STORE_PLAIN_BODY_TEXT );

   420 	reader.SetBuffer(buf);

   421 	iStorePlainBodyText = reader.ReadInt8();

   422 	CleanupStack::PopAndDestroy(buf);

   423 

   424 

   425 	buf = resFile.AllocReadLC( REMOVED_ATTACHMENT_TAG );

   426 	reader.SetBuffer(buf);

   427 	iRemovedAttachmentTag = reader.ReadTPtrC().AllocL();

   428 	CleanupStack::PopAndDestroy(buf);

   429 	

   430 	buf = resFile.AllocReadLC( DEFAULT_ATTACHMENT_NAME );

   431 	reader.SetBuffer(buf);

   432 	iDefaultAttachmentName = reader.ReadTPtrC().AllocL();

   433 	CleanupStack::PopAndDestroy(buf);

   434 

   435 	buf = resFile.AllocReadLC(PARTIAL_DOWNLOAD_FOOTER_MESSAGE);

   436 	reader.SetBuffer(buf);

   437 	if(iStore8BitData)

   438 		{

   439 		iPartialEmailFooter8 = buf;

   440 		CleanupStack::Pop(buf);

   441 		}

   442 	else

   443 		{

   444 		iPartialEmailFooter = (reader.ReadTPtrC()).AllocL();

   445 		CleanupStack::PopAndDestroy(buf);

   446 		}

   447 	buf = NULL;

   448 	CleanupStack::PopAndDestroy(&resFile); // resFile (Close resfile)

   449 

   450 	// create CImHeader object to store Rfc822 header info...

   451 	iOutputHeader = CImHeader::NewLC();	// PushL(iHeader)

   452 	CleanupStack::Pop();				// iHeader

   453 	if (iStore8BitData)

   454 		{

   455 		//Create body text storage helper.

   456 		iBodyText = CMsvBodyText::NewL();

   457 		}

   458 	else

   459 		{

   460 		// create CRichText object to store body...

   461 		iParaLayer = CParaFormatLayer::NewL();

   462 		iCharLayer = CCharFormatLayer::NewL();

   463 		iOutputBody = CRichText::NewL(iParaLayer, iCharLayer);

   464 		}

   465 		

   466 	// Create Rfc822 filter object...

   467 	iRfc822Token = CRfc822Token::NewLC(); // PushL(iRfc822Token)

   468 	CleanupStack::Pop();				  // iRfc822Token

   469 	iRfc822Token->SetImRecvConvert(this);

   470 

   471 	// Create converter objects...

   472 	iCharacterConverter = CCnvCharacterSetConverter::NewL();

   473 	iCharConv = CImConvertCharconv::NewL(*iCharacterConverter, anFs);

   474 	iHeaderConverter = CImConvertHeader::NewL(*iCharConv); 

   475 		

   476 	// Create MIME filter object...

   477 	iMimeParser = CMimeParser::NewL(*this);

   478 	

   479 	

   480 	// logfile stuff

   481 	iImcvLog=NULL;

   482 

   483 #ifdef __IMUT_LOGGING	

   484 	TRAPD(err,iImcvLog=CImLog::NewL(KLogFilePath, EAppend));

   485 #endif

   486 

   487 	iRootEntryId = EntryId();

   488 

   489 	iNotFinishedRfc822Header = ETrue;

   490 	

   491 	iEmailEntry = new (ELeave) TMsvEmailEntry;

   492 	iReceivingHeadersOnly=EFalse;	

   493 

   494 	iParent = new (ELeave) CArrayFixFlat<TParentDetails>(3);

   495 

   496 	iFirstBoundaryReached=EFalse;

   497 

   498 	ResetL();

   499 	

   500 	RECVLOG( KNewLogHeader )

   501 	}

   502 

   503 //----------------------------------------------------------------------------------------  

   504 CImRecvConvert::CImRecvConvert(RFs& anFs, CMsvServerEntry* aServerEntry, 

   505 							   TUid aMsgType, TMsvId aEmailServiceId)

   506 				: iServerEntry(aServerEntry), iNewMsgType(aMsgType), iDefaultEntryType(ETextEntry), 

   507 			  	  iEmailServiceId(aEmailServiceId), iAttachmentFile(anFs)

   508 //----------------------------------------------------------------------------------------  

   509 	{

   510 	__DECLARE_NAME(_S("CImRecvConvert"));

   511 	}

   512 

   513 //----------------------------------------------------------------------------------------  

   514 EXPORT_C CImRecvConvert::~CImRecvConvert()

   515 //----------------------------------------------------------------------------------------  

   516 	{

   517 	delete iEmailEntry;

   518 	delete iOutputHeader;

   519 	delete iBodyText;

   520 	delete iBodyBuf;

   521 	delete iParaLayer;

   522 	delete iCharLayer;

   523 	delete iOutputBody;

   524 	delete iRemovedAttachmentTag;

   525 	delete iDefaultAttachmentName;

   526 	delete iRfc822Token;

   527 	delete iMimeParser;

   528 	delete iHeaderConverter;

   529 	delete iCharConv;

   530 	delete iCharacterConverter;

   531 	delete iAttachmentFullPath;

   532 	delete iImcvUtils;

   533 	delete iParent;

   534 	RECVLOG(KDeleted)

   535 	delete iImcvLog;

   536 	delete iPartialEmailFooter8;

   537 	delete iPartialEmailFooter;

   538 	delete iPlainBodyTextEntry;

   539 	delete iPartialRetrievalBody;

   540 	iPartialRetrievalBody=NULL;

   541 	}

   542 

   543 //----------------------------------------------------------------------------------------  

   544 EXPORT_C void CImRecvConvert::Cancel()

   545 //----------------------------------------------------------------------------------------  

   546 	{

   547 	if(iAttachmentFileState == EFileIsOpen)

   548 		{

   549 		iAttachmentFileState = EFileIsIncomplete; //because of cancel during download

   550 		}

   551 	TRAPD(ignore, CloseAttachmentFileL()); //ensure the file is closed, and deleted

   552 	}

   553 

   554 

   555 

   556 //----------------------------------------------------------------------------------------  

   557 EXPORT_C void CImRecvConvert::ResetForHeadersL()

   558 //----------------------------------------------------------------------------------------  

   559 	{

   560 	// This function is used in preference to ResetL() when the owner

   561 	// only wishes to create  email entries in the remote mailbox - 

   562 	// they do not wish to create any stores associated with the message

   563 	// entry

   564 	ResetL();

   565 	iReceivingHeadersOnly=ETrue;

   566 	}

   567 //----------------------------------------------------------------------------------------  

   568 EXPORT_C void CImRecvConvert::ResetL()

   569 //----------------------------------------------------------------------------------------  

   570 	{

   571 	RECVLOG(KReset) 

   572 

   573 	iBodyId = KMsvNullIndexEntryId;

   574 	iSizeOfAttachmentsRemoved = 0;

   575 

   576 	User::LeaveIfError(iServerEntry->SetEntry(iRootEntryId));

   577 	

   578 	iReceivingHeadersOnly = EFalse;

   579 	iMessageEntryCalled = EFalse;

   580 	iLeaveError = KErrNone; 		

   581 	iCurrentMultipartFolderEntryId = 0;

   582 

   583 	TParentDetails parent;

   584 	parent.iAttachment = EFalse;

   585 	parent.iMHTML = EFalse;

   586 	parent.iICal = EFalse;

   587 	parent.iVCal = EFalse;

   588 	parent.iSize = 0;

   589 	iParent->InsertL(0,parent);

   590 

   591 	if(iEmailEntry)

   592 		{

   593 		delete iEmailEntry;

   594 		iEmailEntry = NULL;

   595 		}

   596 	iEmailEntry = new (ELeave) TMsvEmailEntry;

   597 

   598 	// "iSavingAttachments" commands this code to store attachments in files.

   599 	// Currently this is always set to ETrue as we intend to save all attachments

   600 	// However, if the user wishes to discard (ie do not save) any 

   601 	// attachments in incoming email messages - then this member variable

   602 	// may be set to EFalse by the inline accessor function "SaveAllAttachments(TBool)"

   603 	iSavingAttachments = ETrue;

   604 	iAttachmentFileState = EFileIsClosed;

   605 

   606 	// iLeaveError contains the error value of any functions that leaves (ie CRichText::InsertL)

   607 	// or any returned error value that generates a leave from within CImRecvConvert (ie RFile::Create)

   608 

   609 	iGlobalIndent = 0;

   610 	iLongestLine = 50;

   611 	

   612 	iImPriority = EMsvMediumPriority;

   613 	delete iImcvUtils;

   614 	iImcvUtils = NULL;

   615 	iImcvUtils = CImcvUtils::NewL();

   616 

   617 	// reset internal date

   618 	iTimeDate.UniversalTime();

   619 	iParsedTime=EFalse;

   620 	

   621 	iMimeParser->Reset();

   622 	

   623 	iNewEntry = EFalse; //EFalse if the entry was moved to. ETrue if the entry was just created

   624 	iTopMessagePart = KMsvNullIndexEntryId; //A value of NULL indicates the next entry created is a main message entry

   625 	ResetForNewEntryL(iDefaultEntryType);

   626 	iMIMEPart_822Header = EFalse;

   627 	iPartialEmail = EFalse;

   628 

   629 	RECVLOG(KReseted) 

   630 	}

   631 

   632 //----------------------------------------------------------------------------------------

   633 void CImRecvConvert::ResetForNewEntryL(TValidEntryType entryType)

   634 //----------------------------------------------------------------------------------------

   635 	{

   636 	RECVLOG(KResetForNewEntry) 

   637 

   638 	iFinishedHeader = EFalse;

   639 

   640 	iPreviousLineLength = 0;

   641 	iPreviousTrailingWhitespace = 0;

   642 	iLastChar = 0;

   643 

   644 	// Reset the new entry state

   645 	ResetForNonMimeEntryL();

   646 

   647 	// Clear the storage classes

   648 	iMimeParser->ResetForNewEntry();

   649 	iRfc822Token->Reset();

   650 

   651 	iEmailPart = KNoPart;

   652 	iEntryType=entryType;

   653 

   654 	if (iEntryType==EMessageEntry)

   655 		{

   656 		iEmailPart = KParentPart;

   657 		iMimeParser->SetMessageFolderType(EFolderTypeRFC822);

   658 		}

   659 	}

   660 

   661 //----------------------------------------------------------------------------------------

   662 void CImRecvConvert::ResetForNonMimeEntryL()

   663 //----------------------------------------------------------------------------------------

   664 	{

   665 	iEntryType = ETextEntry;

   666 	RECVLOG(KResetForNonMimeEntry) 

   667 

   668 	iSkipData = EFalse;

   669 	iPrepared = EFalse;

   670 	iNewNonMIMEBodyPart=ETrue;

   671 	iEncounteredLineEndingInCarriageReturn=EFalse;

   672 

   673 	iAlgorithm = ENoAlgorithm;

   674 	iCurrentPartIsRichText = ETrue;	

   675 	CloseAttachmentFileL();

   676 	iEntryDataSize = 0;

   677 	

   678 	if (iStore8BitData)

   679 		{

   680 		//Create a buffer to hold the body text as it is down loaded.

   681 		delete iBodyBuf;

   682 		iBodyBuf = NULL;

   683 		iBodyBuf = CBufSeg::NewL(KBodyTextChunkSizeBytes);

   684 		}

   685 	else

   686 		{

   687 		iOutputBody->Reset();

   688 		}	

   689 	iAttachmentName.Zero();

   690 	iFinalLine = EFalse;

   691 

   692 	iOutputHeader->Reset();

   693 	iEmptyHeaderSize=iOutputHeader->DataSize();

   694 	RECVLOG(KResetedForNonMimeEntry) 

   695 	}

   696 

   697 //----------------------------------------------------------------------------------------  

   698 EXPORT_C TInt CImRecvConvert::ParseNextField(const TDesC8& aSourceLine) 

   699 //----------------------------------------------------------------------------------------  

   700 	{

   701 	__ASSERT_DEBUG(iRootEntryId!=KMsvNullIndexEntryId, gPanic(KPanicServiceIdNotValid));

   702 	RECVLOG_OUT(aSourceLine);

   703 

   704 	// If we are temporarily on the null entry then move back to the entry we are working on

   705 	if ((iLeaveError == KErrNone) && (iServerEntry->Entry().Id() == KMsvNullIndexEntryId))

   706 		iLeaveError = iServerEntry->SetEntry(iSavedEntryId);

   707 

   708 	if(iLeaveError==KErrNone)

   709 		TRAP(iLeaveError, ParseNextLineL(aSourceLine));		

   710 

   711 	// Save the current entry id for later.

   712 	if (iLeaveError==KErrNone)

   713 		iSavedEntryId = iServerEntry->Entry().Id();

   714 

   715 	TUid type = iServerEntry->Entry().iType;

   716 	if( type != KUidMsvMessageEntry    &&

   717 		type != KUidMsvEmailTextEntry  &&

   718 		type != KUidMsvEmailHtmlEntry  &&

   719 		type != KUidMsvAttachmentEntry)

   720 		{

   721 		// Set the current id to null so that we aren't locking any folders

   722 		iServerEntry->SetEntry(KMsvNullIndexEntryId); 

   723 		}

   724 

   725 	return iLeaveError;

   726 	}

   727 

   728 

   729 //----------------------------------------------------------------------------------------  

   730 void CImRecvConvert::ParseNextLineL(const TDesC8& aSourceLine)

   731 //----------------------------------------------------------------------------------------  

   732 	{

   733 	iParsedMimeBoundaryLast=0;

   734 	if(!iFinishedHeader)

   735 		{

   736 		// start by getting the next token from the header

   737 		iRfc822Token->ParseNextLineL(aSourceLine);

   738 

   739 		switch(iRfc822Token->iHeaderPart)

   740 			{

   741 			case CRfc822Token::EUnknown:

   742 			case CRfc822Token::ENotFinished:

   743 				RECVLOG(KPartLine)

   744 				break;

   745 			case CRfc822Token::EFrom:

   746 				iOutputHeader->SetFromL(*iRfc822Token->OutputLine());

   747 				LOGGING(KFound,KImcvFromPrompt);

   748 				break;

   749 			case CRfc822Token::EReplyTo:

   750 				iOutputHeader->SetReplyToL(*iRfc822Token->OutputLine());

   751 				LOGGING(KFound,KImcvReplyToPrompt);

   752 				break;

   753 			case CRfc822Token::ETo:

   754 				ParseRecipientListL(iOutputHeader->ToRecipients());

   755 				LOGGING(KFound,KImcvToPrompt);

   756 				break;

   757 			case CRfc822Token::ECc: 

   758 				ParseRecipientListL(iOutputHeader->CcRecipients());

   759 				LOGGING(KFound,KImcvCcPrompt);

   760 				break;

   761 			case CRfc822Token::EBcc: 

   762 				ParseRecipientListL(iOutputHeader->BccRecipients());

   763 				LOGGING(KFound,KImcvBccPrompt);

   764 				break;

   765 			case CRfc822Token::ESubject:

   766 				iOutputHeader->SetSubjectL(*iRfc822Token->OutputLine());

   767 				LOGGING(KFound,KImcvSubjectPrompt);

   768 				break;

   769 			case CRfc822Token::EDate:

   770 			// if we have not already parsed the date from the received header.

   771 				if(!iParsedTime)

   772 					{

   773 					iRfc822Date.ParseDateField(*iRfc822Token->OutputLine() , iTimeDate);

   774 					

   775 					//if this is an embedded entry

   776 					if (iEmailEntry->Id() != iTopMessagePart)

   777 						{

   778 						iEmailEntry->iDate = iTimeDate;

   779 						}

   780 						

   781 					LOGGING(KFound,KImcvDatePrompt);	

   782 					}

   783 				break;

   784 			case CRfc822Token::EReceived:

   785 				if(!iParsedTime)

   786 					{

   787 					//	remove the data before the comma, to just leave the date

   788 					TPtr8 ptr(iRfc822Token->OutputLine()->Des());

   789 					TInt lPos=ptr.Locate(';');

   790 

   791 					// No point trying to process a date if we did not find the ';' or

   792 					// if there is no data after the ';'

   793 					if ((lPos != KErrNotFound) && (lPos < ptr.Length() - 2))

   794 						{

   795 						ptr = ptr.Right(ptr.Length()-lPos-2);

   796 						iRfc822Date.ParseDateField(ptr,iTimeDate);

   797 					

   798 						//if this is an embedded entry

   799 						if (iEmailEntry->Id() != iTopMessagePart)

   800 							{

   801 							iEmailEntry->iDate=iTimeDate;	

   802 							}

   803 						//indicate that we have the time stamp for the entry

   804 						iParsedTime=ETrue;

   805 						

   806 						LOGGING(KFound,KImcvReceivedPrompt);	

   807 						}

   808 					else

   809 						{

   810 						LOGGING(KFoundIncomplete, KImcvReceivedPrompt);

   811 						}

   812 					}

   813 				break;

   814 				

   815 			case CRfc822Token::EMessageId:

   816 				iOutputHeader->SetImMsgIdL(*iRfc822Token->OutputLine());

   817 				LOGGING(KFound,KImcvMessageIdPrompt);

   818 				break;

   819 			case CRfc822Token::EPriority:

   820 				iImPriority=iImcvUtils->EvaluatePriorityText(*iRfc822Token->OutputLine());

   821 				LOGGING(KFound,KImcvPriorityPrompt);

   822 				break;

   823 			case CRfc822Token::EReturnReceiptTo:

   824 				iOutputHeader->SetReceiptAddressL(*iRfc822Token->OutputLine());

   825 				LOGGING(KFound,KReturnReceiptTo);

   826 				break;

   827 			case CRfc822Token::EEndOfHeader:

   828 				// the next line goes in the body part

   829 				iFinishedHeader = ETrue;

   830 				RECVLOG(KEndOFHeader)

   831 				break;

   832 			default:

   833 				RECVLOG(KEndOFHeader)

   834 				break;

   835 			}

   836 

   837 

   838 		if(iRfc822Token->iHeaderPart != CRfc822Token::ENotFinished)

   839 			{

   840 			// Now that we've used the data, we also need to clear the output line from the tokeniser....

   841 			iRfc822Token->OutputLine()->Des() = KNullDesC8;

   842 

   843 			// whatever part we just read, we may also have read the empty line that separates

   844 			// the header from the body

   845 			if((iFinishedHeader = iRfc822Token->LastToken()) != EFalse)	//iFinishedHeader set to 1 on CRLF-

   846 				{

   847 				RECVLOG(KLastToken);

   848 				iNotFinishedRfc822Header = EFalse;

   849 

   850 				iHeaderConverter->SetMessageType(iMimeParser->MessageIsMime());

   851 				iHeaderConverter->DecodeAllHeaderFieldsL(*iOutputHeader);

   852 

   853 				if (iMimeParser->MessageIsMime())

   854 					EndOfHeaderMIMEProcessingL();

   855 				else

   856 					EndOfHeaderProcessingL();

   857 

   858 				// CMsvPlainBodyText will be using for storing bodytext in chunks.

   859 				if(iStorePlainBodyText && iEmailEntry->iType==KUidMsvEmailTextEntry)

   860 					{	

   861 					iFirstLinePlainText = ETrue;

   862 					}

   863 				else

   864 					{

   865 					if (iStore8BitData)

   866 						{

   867 						iBodyText->SetDefaultCharacterSet(iCharConv->SystemDefaultCharset());

   868 						if ( iMimeParser->MessageIsMime() && iMimeParser->ContentType()==EMimeText )

   869 							iBodyText->SetCharacterSet(iMimeParser->CurrentCharsetL());

   870 						else

   871 							iBodyText->SetCharacterSet(0);

   872 						}

   873 					else

   874 						{

   875 						// Get charset for decoding.

   876 						if ( iMimeParser->MessageIsMime() && iMimeParser->ContentType()==EMimeText )

   877 							iCharConv->PrepareToConvertToFromOurCharsetL(iMimeParser->CurrentCharsetL());

   878 						else

   879 							iCharConv->PrepareToConvertToFromOurCharsetL(iCharConv->SystemDefaultCharset());						

   880 						}

   881 					}

   882 				}

   883 			}

   884 		}

   885 	else if (iReceivingHeadersOnly==EFalse)

   886 		{	

   887 		//Set to EFalse when a single line is to be skipped (ie boundary line)

   888 		iCommitLine=ETrue; 

   889 

   890 		// read one line of the message body if I am processing a whole email message

   891 		if(iMimeParser->MessageIsMime())

   892 			ParseMimeLineL(aSourceLine);

   893 		else

   894 			ParseBodyLineL(aSourceLine);	

   895 

   896 		if((iCommitLine)&&(!iSkipData))

   897 			DecodeAndStoreLineL(aSourceLine);

   898 		}

   899 	}

   900 

   901 //----------------------------------------------------------------------------------------  

   902 EXPORT_C TMsvEmailEntry CImRecvConvert::MessageEntryDetailsL()

   903 //----------------------------------------------------------------------------------------  

   904 	{

   905 

   906 	iMessageEntryCalled=ETrue;

   907 	CloseAttachmentFileL();

   908 

   909 	// A message requiring manual termination and not part way through a MIME part header

   910 	if( iTopMessagePart==EntryId() && iFinishedHeader) 

   911 		StoreEntryStreamsL(KStore822Header|KStoreMIMEHeader);

   912 	else

   913 		{

   914 		User::LeaveIfError(iServerEntry->SetEntry(iTopMessagePart));         

   915 		if(iEmailEntry)

   916 			{

   917 			delete iEmailEntry;

   918 			iEmailEntry=NULL;

   919 			}

   920 	

   921 		iEmailEntry = new (ELeave) TMsvEmailEntry(iServerEntry->Entry());

   922 		}

   923 		

   924 	return *iEmailEntry;

   925 	}

   926 

   927 

   928 //----------------------------------------------------------------------------------------  

   929 EXPORT_C void CImRecvConvert::MessageCompleteL(TMsvEmailEntry aEmailEntry)

   930 //----------------------------------------------------------------------------------------  

   931 	{

   932 	// Restore the entry context

   933 	if (iServerEntry->Entry().Id() == KMsvNullIndexEntryId)

   934 		User::LeaveIfError(iServerEntry->SetEntry(iSavedEntryId));

   935 

   936 	__ASSERT_DEBUG(iMessageEntryCalled, gPanic(KPanicMessageEntryNotCalled));

   937 	__ASSERT_DEBUG(aEmailEntry.Id()==iTopMessagePart, gPanic(KPanicMessageEntryIdHasChanged)); // Id should be set to iTopMessagePart

   938 

   939 	// Called ResetL() to reset object instead of ResetForHeadersL()

   940 	__ASSERT_DEBUG(iReceivingHeadersOnly, gPanic(KPanicIncorrectResetState)); 

   941 

   942 	if(iEmailEntry)

   943 		{

   944 		if (iEmailEntry->Id())

   945 			{

   946 			if(iLeaveError==KErrNone)

   947 				{

   948 				// a remote email header cannot have any attachments or be marked as complete...

   949 				aEmailEntry.SetAttachment(EFalse);

   950 				aEmailEntry.SetMHTMLEmail(EFalse);

   951 				aEmailEntry.SetComplete(EFalse);

   952 				User::LeaveIfError(iServerEntry->ChangeEntryBulk(aEmailEntry));

   953 				RECVLOG(KHeaderComplete)

   954 				}

   955 			else

   956 				{

   957 				if (!iPopulateMessage)

   958 					{

   959 					TMsvId currentId = EntryId();

   960 					User::LeaveIfError(iServerEntry->SetEntry(iServerEntry->Entry().Parent()));			

   961 					User::LeaveIfError(iServerEntry->DeleteEntry(currentId));

   962 					}

   963 				User::Leave(iLeaveError);

   964 				}

   965 			}

   966 		}

   967 

   968 	// Save the entry context and move it to null so that we're not locking any folders

   969 	iSavedEntryId = iServerEntry->Entry().Id();

   970 	User::LeaveIfError(iServerEntry->SetEntry(KMsvNullIndexEntryId));

   971 	}

   972 

   973 

   974 EXPORT_C void CImRecvConvert::MessageCompleteL(TBool aPartialDownload)

   975 	{

   976 	iPartialEmail=aPartialDownload;

   977 	MessageCompleteL();

   978 	}

   979 

   980 

   981 //----------------------------------------------------------------------------------------  

   982 EXPORT_C void CImRecvConvert::MessageCompleteL()

   983 //----------------------------------------------------------------------------------------  

   984 	{

   985 	// Restore the entry context

   986 	RECVLOG(KStartMessageComplete)

   987 	if (iServerEntry->Entry().Id() == KMsvNullIndexEntryId)

   988 		User::LeaveIfError(iServerEntry->SetEntry(iSavedEntryId));

   989 

   990 	if (iParsedMimeBoundaryLast==EFalse && iAttachmentFileState==EFileIsOpen && iPartialEmail!=EFalse)

   991 		{

   992 		iAttachmentFileState=EFileTopIncomplete;

   993 		}

   994 

   995 	CloseAttachmentFileL();

   996 

   997 	if(!iEmailEntry->Id())

   998 		return;

   999 

  1000 	if(iLeaveError!=KErrNone)

  1001 		{

  1002 		User::Leave(iLeaveError);

  1003 		}

  1004 

  1005 	if (EntryId()!=iTopMessagePart)

  1006 		{

  1007 		iEmailEntry->SetComplete(ETrue);

  1008 		StoreEntryStreamsL(KStoreMIMEHeader | KStoreBodyText);

  1009 		MoveToParentEntryL();

  1010 

  1011 		if( iTopMessagePart==EntryId() && iFinishedHeader) 

  1012 			{

  1013 			iEmailEntry->SetVisible(ETrue);

  1014 			iEmailEntry->SetInPreparation(EFalse);

  1015 			iEmailEntry->SetBodyTextComplete(ETrue);

  1016 			iEmailEntry->SetComplete(ETrue);

  1017 			if(iEmailEntry->PartialDownloaded())

  1018 				{

  1019 				iEmailEntry->SetPartialDownloaded( EFalse );	

  1020 				}

  1021 			// Main message.

  1022 			StoreMessageEntryDetailsL();

  1023 			return;

  1024 			}

  1025 		else if(iEmailEntry->iType == KUidMsvMessageEntry)

  1026 			{

  1027 			StoreMessageEntryDetailsL();

  1028 			MoveToParentEntryL();

  1029 			StoreMessageEntryDetailsL();

  1030 			}

  1031 		}

  1032 

  1033 	// A message requiring manual termination and not part way through 

  1034 	// a MIME part header.

  1035 

  1036 	User::LeaveIfError(iServerEntry->SetEntry(iTopMessagePart));         

  1037 	if(iEmailEntry)

  1038 		{

  1039 		delete iEmailEntry;

  1040 		iEmailEntry=NULL;

  1041 		}

  1042 	iEmailEntry = new (ELeave) TMsvEmailEntry(iServerEntry->Entry());

  1043 	iEmailEntry->SetVisible(ETrue);

  1044 	iEmailEntry->SetInPreparation(EFalse);

  1045 	iEmailEntry->SetComplete(ETrue);

  1046 	iEmailEntry->SetBodyTextComplete(ETrue);

  1047 	if(iEmailEntry->PartialDownloaded())

  1048 		{

  1049 		iEmailEntry->SetPartialDownloaded( EFalse );	

  1050 		}

  1051 

  1052 	iEmailEntry->SetAttachment(iParent->At(0).iAttachment);

  1053 	iEmailEntry->SetMHTMLEmail(iParent->At(0).iMHTML);

  1054 	iEmailEntry->SetVCalendar(iParent->At(0).iVCal);

  1055 	iEmailEntry->SetICalendar(iParent->At(0).iICal);

  1056 	

  1057 	if(iEmailEntry->MHTMLEmail() == EFalse && iEmailEntry->Attachment() == EFalse && iRelatedAttachments !=EFalse)

  1058 		{

  1059 		iEmailEntry->SetAttachment(ETrue);

  1060 		}

  1061 	iRelatedAttachments=EFalse;

  1062 	

  1063 	iEmailEntry->iSize=iParent->At(0).iSize;

  1064 	iEmailEntry->SetMessageFolderType(iParent->At(0).iFolder);

  1065 

  1066 	User::LeaveIfError(iServerEntry->ChangeEntry(*iEmailEntry));

  1067 

  1068 	// Save the entry context and move it to null so that we're not locking any folders

  1069 	iSavedEntryId = iServerEntry->Entry().Id();

  1070 	User::LeaveIfError(iServerEntry->SetEntry(KMsvNullIndexEntryId));

  1071 	RECVLOG(KMessageComplete)

  1072 	}

  1073 

  1074 EXPORT_C void CImRecvConvert::SetCaf(CImCaf& aCaf)

  1075 /**

  1076 Initialise class CimCaf reference

  1077 @param aCaf - Reference to a CAF instance

  1078 */

  1079 	{

  1080 	iCaf = &aCaf;

  1081 	}

  1082 //----------------------------------------------------------------------------------------  

  1083 void CImRecvConvert::PrepareDecoder()

  1084 //----------------------------------------------------------------------------------------  

  1085 	{

  1086 	switch(iMimeParser->ContentEncoding())

  1087 		{

  1088 		case EEncodingTypeNone:

  1089 		case EEncodingType7Bit:

  1090 		case EEncodingType8Bit:

  1091 			iAlgorithm = ENoAlgorithm;

  1092 			RECVLOG(KCollectingData7)

  1093 			break;

  1094 		case EEncodingTypeQP:

  1095 			iAlgorithm = EQPDecode;

  1096 			RECVLOG(KCollectingDataQP)

  1097 			break;

  1098 		case EEncodingTypeBASE64:

  1099 			iAlgorithm = EBase64Decode;

  1100 			RECVLOG(KCollectingBase64)

  1101 			break;	

  1102 		case EEncodingTypeUU:

  1103 			iAlgorithm = EUUDecode;

  1104 			RECVLOG(KCollectingUU)

  1105 			break;	

  1106 		default:	// EEncodingTypeUnknown, EEncodingTypeNone, EEncodingTypeBinary	

  1107 			iAlgorithm = ENoAlgorithm;

  1108 			break;

  1109 		} // switch

  1110 	iPrepared = ETrue;

  1111 	}

  1112 

  1113 

  1114 //----------------------------------------------------------------------------------------  

  1115 void CImRecvConvert::DecodeAndStoreLineL(const TDesC8& aSourceLine)

  1116 //----------------------------------------------------------------------------------------  

  1117 	{

  1118 	//If bodytext has been stored using chunk storage mechanism.

  1119 	if(iFirstLinePlainText && iEmailEntry->iType==KUidMsvEmailTextEntry)

  1120 		{

  1121 		iBodyId = iEmailEntry->Id();

  1122 		

  1123 		delete iPlainBodyTextEntry;

  1124 		iPlainBodyTextEntry = NULL;

  1125 		

  1126 		iPlainBodyTextEntry = CMsvPlainBodyTextEntry::NewL(iStore8BitData, *iServerEntry, iMimeParser->CurrentCharsetL(), iCharConv->SystemDefaultCharset());

  1127 		iFirstLinePlainText = EFalse;

  1128 		}

  1129 	

  1130 	TInt sourceLineLength=aSourceLine.Length();

  1131 	TBool blankLine = EFalse;

  1132 	TBool decodeError = EFalse;

  1133 

  1134 	// create a temporary buffer to write the decoded data into.