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 			if((iOutputLine->Length() + iInputLine.Length()) > iOutputLine->Des().MaxLength())

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

   259 

   260 			// now copy the remaining data into the buffer

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

   262 			}

   263 		}

   264 	else

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

   266 	iFirstLine = EFalse;

   267 

   268 	if(endOfField || iLastToken)

   269 		{ 

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

   271 		// or we just found the blank line that

   272 		// separates the body from the header

   273 		if(MatchAndRemoveL(KImcvFromPrompt))

   274 			iHeaderPart = EFrom;

   275 		else if(MatchAndRemoveL(KImcvReplyToPrompt))

   276 			iHeaderPart = EReplyTo;

   277 		else if(MatchAndRemoveL(KImcvToPrompt))

   278 			iHeaderPart = ETo;

   279 		else if(MatchAndRemoveL(KImcvCcPrompt))

   280 			iHeaderPart = ECc;

   281 		else if(MatchAndRemoveL(KImcvBccPrompt))

   282 			iHeaderPart = EBcc;

   283 		else if(MatchAndRemoveL(KImcvSubjectPrompt))

   284 			iHeaderPart = ESubject;

   285 		else if(MatchAndRemoveL(KImcvDatePrompt))

   286 			iHeaderPart = EDate;

   287 		else if(MatchAndRemoveL(KImcvReceivedPrompt))

   288 			iHeaderPart = EReceived;

   289 		else if(MatchAndRemoveL(KImcvMessageIdPrompt))

   290 			{

   291 			iHeaderPart = EMessageId;

   292 			RemoveSurroundingCharacters(KImcvLeftChevron, KImcvRightChevron, *iOutputLine);

   293 			}

   294 		else if (PriorityAndReceiptsMatchAndRemoveL(EPriority))

   295 			iHeaderPart=EPriority;

   296 		else if (PriorityAndReceiptsMatchAndRemoveL(EReturnReceiptTo))

   297 			iHeaderPart=EReturnReceiptTo;

   298 		else if(hitEof)

   299 			iHeaderPart = EEndOfHeader;

   300 		else

   301 			{

   302 			iHeaderPart = EUnknown;

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

   304 			}

   305 		}

   306 	else 

   307 		iHeaderPart = ENotFinished;

   308 	}

   309 

   310 TBool CRfc822Token::PriorityAndReceiptsMatchAndRemoveL(THeaderPart aPriority)

   311 	{

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

   313 	CleanupStack::PushL(fields);

   314 	if (aPriority==EPriority)

   315 		CImcvUtils::PriorityFieldsL(*fields);

   316 	else if (aPriority==EReturnReceiptTo)

   317 		CImcvUtils::ReceiptFieldsL(*fields);

   318 	else

   319 		{

   320 		CleanupStack::PopAndDestroy(); //fields

   321 		return EFalse;

   322 		}

   323 	TInt count=fields->Count();

   324 	TBool matched=EFalse;

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

   326 		{

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

   328 			{

   329 			matched=ETrue;

   330 			break;

   331 			}

   332 		}

   333 	CleanupStack::PopAndDestroy(); //fields

   334 	return matched;

   335 	}

   336 

   337 //----------------------------------------------------------------------------------------

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

   339 //----------------------------------------------------------------------------------------

   340 	{

   341 	TInt comparison;

   342 	TInt stringLength = aString.Length();

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

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

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

   346 	

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

   348 	comparison = left.CompareF(aString);

   349 	if(!comparison)

   350 		{

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

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

   353 		if (!i822FieldsExist)

   354 			i822FieldsExist=ETrue;

   355 		TInt whitespaceLength=0;

   356 		TInt maxLength=desLength-stringLength;

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

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

   359 			whitespaceLength++;

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

   361 		}

   362 	return (comparison==0);

   363 	}

   364 

   365 

   366 //****************************************************************************************

   367 //             Class CImRecvConvert

   368 //****************************************************************************************

   369 //----------------------------------------------------------------------------------------    

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

   371 												TUid aMsgType, TMsvId aEmailServiceId)

   372 //----------------------------------------------------------------------------------------  

   373 	{

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

   375 																		aEmailServiceId);

   376 	CleanupStack::PushL(self);

   377 	self->ConstructL(anFs);

   378 	return self;

   379 	}

   380 

   381 //----------------------------------------------------------------------------------------  

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

   383 												TUid aMsgType, TMsvId aEmailServiceId)

   384 //----------------------------------------------------------------------------------------  

   385 	{

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

   387 																aEmailServiceId);

   388 	CleanupStack::Pop();

   389 	return self;

   390 	}

   391 

   392 //----------------------------------------------------------------------------------------  

   393 void CImRecvConvert::ConstructL(RFs& anFs)

   394 //----------------------------------------------------------------------------------------  

   395 	{

   396 	iFsSession = &anFs;  

   397 

   398 	RResourceFile resFile;

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

   400 

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

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

   403 	TCleanupItem close( CloseResourceFile, &resFile );

   404 	CleanupStack::PushL( close );

   405 	

   406 	// Read iStore8BitData flag.

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

   408 	TResourceReader reader;

   409 	reader.SetBuffer(buf);

   410 	iStore8BitData = reader.ReadInt8();

   411 	CleanupStack::PopAndDestroy(buf);

   412 	

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

   414 	buf = resFile.AllocReadLC( STORE_PLAIN_BODY_TEXT );

   415 	reader.SetBuffer(buf);

   416 	iStorePlainBodyText = reader.ReadInt8();

   417 	CleanupStack::PopAndDestroy(buf);

   418 

   419 

   420 	buf = resFile.AllocReadLC( REMOVED_ATTACHMENT_TAG );

   421 	reader.SetBuffer(buf);

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

   423 	CleanupStack::PopAndDestroy(buf);

   424 	

   425 	buf = resFile.AllocReadLC( DEFAULT_ATTACHMENT_NAME );

   426 	reader.SetBuffer(buf);

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

   428 	CleanupStack::PopAndDestroy(buf);

   429 

   430 	buf = resFile.AllocReadLC(PARTIAL_DOWNLOAD_FOOTER_MESSAGE);

   431 	reader.SetBuffer(buf);

   432 	if(iStore8BitData)

   433 		{

   434 		iPartialEmailFooter8 = buf;

   435 		CleanupStack::Pop(buf);

   436 		}

   437 	else

   438 		{

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

   440 		CleanupStack::PopAndDestroy(buf);

   441 		}

   442 	buf = NULL;

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

   444 

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

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

   447 	CleanupStack::Pop();				// iHeader

   448 	if (iStore8BitData)

   449 		{

   450 		//Create body text storage helper.

   451 		iBodyText = CMsvBodyText::NewL();

   452 		}

   453 	else

   454 		{

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

   456 		iParaLayer = CParaFormatLayer::NewL();

   457 		iCharLayer = CCharFormatLayer::NewL();

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

   459 		}

   460 		

   461 	// Create Rfc822 filter object...

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

   463 	CleanupStack::Pop();				  // iRfc822Token

   464 	iRfc822Token->SetImRecvConvert(this);

   465 

   466 	// Create converter objects...

   467 	iCharacterConverter = CCnvCharacterSetConverter::NewL();

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

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

   470 		

   471 	// Create MIME filter object...

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

   473 	

   474 	

   475 	// logfile stuff

   476 	iImcvLog=NULL;

   477 

   478 #ifdef __IMUT_LOGGING	

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

   480 #endif

   481 

   482 	iRootEntryId = EntryId();

   483 

   484 	iNotFinishedRfc822Header = ETrue;

   485 	

   486 	iEmailEntry = new (ELeave) TMsvEmailEntry;

   487 	iReceivingHeadersOnly=EFalse;	

   488 

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

   490 

   491 	iFirstBoundaryReached=EFalse;

   492 

   493 	ResetL();

   494 	

   495 	RECVLOG( KNewLogHeader )

   496 	}

   497 

   498 //----------------------------------------------------------------------------------------  

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

   500 							   TUid aMsgType, TMsvId aEmailServiceId)

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

   502 			  	  iEmailServiceId(aEmailServiceId), iAttachmentFile(anFs)

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

   504 	{

   505 	__DECLARE_NAME(_S("CImRecvConvert"));

   506 	}

   507 

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

   509 EXPORT_C CImRecvConvert::~CImRecvConvert()

   510 //----------------------------------------------------------------------------------------  

   511 	{

   512 	delete iEmailEntry;

   513 	delete iOutputHeader;

   514 	delete iBodyText;

   515 	delete iBodyBuf;

   516 	delete iParaLayer;

   517 	delete iCharLayer;

   518 	delete iOutputBody;

   519 	delete iRemovedAttachmentTag;

   520 	delete iDefaultAttachmentName;

   521 	delete iRfc822Token;

   522 	delete iMimeParser;

   523 	delete iHeaderConverter;

   524 	delete iCharConv;

   525 	delete iCharacterConverter;

   526 	delete iAttachmentFullPath;

   527 	delete iImcvUtils;

   528 	delete iParent;

   529 	RECVLOG(KDeleted)

   530 	delete iImcvLog;

   531 	delete iPartialEmailFooter8;

   532 	delete iPartialEmailFooter;

   533 	delete iPlainBodyTextEntry;

   534 	delete iPartialRetrievalBody;

   535 	iPartialRetrievalBody=NULL;

   536 	}

   537 

   538 //----------------------------------------------------------------------------------------  

   539 EXPORT_C void CImRecvConvert::Cancel()

   540 //----------------------------------------------------------------------------------------  

   541 	{

   542 	if(iAttachmentFileState == EFileIsOpen)

   543 		{

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

   545 		}

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

   547 	}

   548 

   549 

   550 

   551 //----------------------------------------------------------------------------------------  

   552 EXPORT_C void CImRecvConvert::ResetForHeadersL()

   553 //----------------------------------------------------------------------------------------  

   554 	{

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

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

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

   558 	// entry

   559 	ResetL();

   560 	iReceivingHeadersOnly=ETrue;

   561 	}

   562 //----------------------------------------------------------------------------------------  

   563 EXPORT_C void CImRecvConvert::ResetL()

   564 //----------------------------------------------------------------------------------------  

   565 	{

   566 	RECVLOG(KReset) 

   567 

   568 	iBodyId = KMsvNullIndexEntryId;

   569 	iSizeOfAttachmentsRemoved = 0;

   570 

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

   572 	

   573 	iReceivingHeadersOnly = EFalse;

   574 	iMessageEntryCalled = EFalse;

   575 	iLeaveError = KErrNone; 		

   576 	iCurrentMultipartFolderEntryId = 0;

   577 

   578 	TParentDetails parent;

   579 	parent.iAttachment = EFalse;

   580 	parent.iMHTML = EFalse;

   581 	parent.iICal = EFalse;

   582 	parent.iVCal = EFalse;

   583 	parent.iSize = 0;

   584 	iParent->InsertL(0,parent);

   585 

   586 	if(iEmailEntry)

   587 		{

   588 		delete iEmailEntry;

   589 		iEmailEntry = NULL;

   590 		}

   591 	iEmailEntry = new (ELeave) TMsvEmailEntry;

   592 

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

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

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

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

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

   598 	iSavingAttachments = ETrue;

   599 	iAttachmentFileState = EFileIsClosed;

   600 

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

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

   603 

   604 	iGlobalIndent = 0;

   605 	iLongestLine = 50;

   606 	

   607 	iImPriority = EMsvMediumPriority;

   608 	delete iImcvUtils;

   609 	iImcvUtils = NULL;

   610 	iImcvUtils = CImcvUtils::NewL();

   611 

   612 	// reset internal date

   613 	iTimeDate.UniversalTime();

   614 	iParsedTime=EFalse;

   615 	

   616 	iMimeParser->Reset();

   617 	

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

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

   620 	ResetForNewEntryL(iDefaultEntryType);

   621 	iMIMEPart_822Header = EFalse;

   622 	iPartialEmail = EFalse;

   623 

   624 	RECVLOG(KReseted) 

   625 	}

   626 

   627 //----------------------------------------------------------------------------------------

   628 void CImRecvConvert::ResetForNewEntryL(TValidEntryType entryType)

   629 //----------------------------------------------------------------------------------------

   630 	{

   631 	RECVLOG(KResetForNewEntry) 

   632 

   633 	iFinishedHeader = EFalse;

   634 

   635 	iPreviousLineLength = 0;

   636 	iPreviousTrailingWhitespace = 0;

   637 	iLastChar = 0;

   638 

   639 	// Reset the new entry state

   640 	ResetForNonMimeEntryL();

   641 

   642 	// Clear the storage classes

   643 	iMimeParser->ResetForNewEntry();

   644 	iRfc822Token->Reset();

   645 

   646 	iEmailPart = KNoPart;

   647 	iEntryType=entryType;

   648 

   649 	if (iEntryType==EMessageEntry)

   650 		{

   651 		iEmailPart = KParentPart;

   652 		iMimeParser->SetMessageFolderType(EFolderTypeRFC822);

   653 		}

   654 	}

   655 

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

   657 void CImRecvConvert::ResetForNonMimeEntryL()

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

   659 	{

   660 	iEntryType = ETextEntry;

   661 	RECVLOG(KResetForNonMimeEntry) 

   662 

   663 	iSkipData = EFalse;

   664 	iPrepared = EFalse;

   665 	iNewNonMIMEBodyPart=ETrue;

   666 	iEncounteredLineEndingInCarriageReturn=EFalse;

   667 

   668 	iAlgorithm = ENoAlgorithm;

   669 	iCurrentPartIsRichText = ETrue;	

   670 	CloseAttachmentFileL();

   671 	iEntryDataSize = 0;

   672 	

   673 	if (iStore8BitData)

   674 		{

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

   676 		delete iBodyBuf;

   677 		iBodyBuf = NULL;

   678 		iBodyBuf = CBufSeg::NewL(KBodyTextChunkSizeBytes);

   679 		}

   680 	else

   681 		{

   682 		iOutputBody->Reset();

   683 		}	

   684 	iAttachmentName.Zero();

   685 	iFinalLine = EFalse;

   686 

   687 	iOutputHeader->Reset();

   688 	iEmptyHeaderSize=iOutputHeader->DataSize();

   689 	RECVLOG(KResetedForNonMimeEntry) 

   690 	}

   691 

   692 //----------------------------------------------------------------------------------------  

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

   694 //----------------------------------------------------------------------------------------  

   695 	{

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

   697 	RECVLOG_OUT(aSourceLine);

   698 

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

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

   701 		iLeaveError = iServerEntry->SetEntry(iSavedEntryId);

   702 

   703 	if(iLeaveError==KErrNone)

   704 		TRAP(iLeaveError, ParseNextLineL(aSourceLine));		

   705 

   706 	// Save the current entry id for later.

   707 	if (iLeaveError==KErrNone)

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

   709 

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

   711 	if( type != KUidMsvMessageEntry    &&

   712 		type != KUidMsvEmailTextEntry  &&

   713 		type != KUidMsvEmailHtmlEntry  &&

   714 		type != KUidMsvAttachmentEntry)

   715 		{

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

   717 		iServerEntry->SetEntry(KMsvNullIndexEntryId); 

   718 		}

   719 

   720 	return iLeaveError;

   721 	}

   722 

   723 

   724 //----------------------------------------------------------------------------------------  

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

   726 //----------------------------------------------------------------------------------------  

   727 	{

   728 	iParsedMimeBoundaryLast=0;

   729 	if(!iFinishedHeader)

   730 		{

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

   732 		iRfc822Token->ParseNextLineL(aSourceLine);

   733 

   734 		switch(iRfc822Token->iHeaderPart)

   735 			{

   736 			case CRfc822Token::EUnknown:

   737 			case CRfc822Token::ENotFinished:

   738 				RECVLOG(KPartLine)

   739 				break;

   740 			case CRfc822Token::EFrom:

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

   742 				LOGGING(KFound,KImcvFromPrompt);

   743 				break;

   744 			case CRfc822Token::EReplyTo:

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

   746 				LOGGING(KFound,KImcvReplyToPrompt);

   747 				break;

   748 			case CRfc822Token::ETo:

   749 				ParseRecipientListL(iOutputHeader->ToRecipients());

   750 				LOGGING(KFound,KImcvToPrompt);

   751 				break;

   752 			case CRfc822Token::ECc: 

   753 				ParseRecipientListL(iOutputHeader->CcRecipients());

   754 				LOGGING(KFound,KImcvCcPrompt);

   755 				break;

   756 			case CRfc822Token::EBcc: 

   757 				ParseRecipientListL(iOutputHeader->BccRecipients());

   758 				LOGGING(KFound,KImcvBccPrompt);

   759 				break;

   760 			case CRfc822Token::ESubject:

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

   762 				LOGGING(KFound,KImcvSubjectPrompt);

   763 				break;

   764 			case CRfc822Token::EDate:

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

   766 				if(!iParsedTime)

   767 					{

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

   769 					

   770 					//if this is an embedded entry

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

   772 						{

   773 						iEmailEntry->iDate = iTimeDate;

   774 						}

   775 						

   776 					LOGGING(KFound,KImcvDatePrompt);	

   777 					}

   778 				break;

   779 			case CRfc822Token::EReceived:

   780 				if(!iParsedTime)

   781 					{

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

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

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

   785 

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

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

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

   789 						{

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

   791 						iRfc822Date.ParseDateField(ptr,iTimeDate);

   792 					

   793 						//if this is an embedded entry

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

   795 							{

   796 							iEmailEntry->iDate=iTimeDate;	

   797 							}

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

   799 						iParsedTime=ETrue;

   800 						

   801 						LOGGING(KFound,KImcvReceivedPrompt);	

   802 						}

   803 					else

   804 						{

   805 						LOGGING(KFoundIncomplete, KImcvReceivedPrompt);

   806 						}

   807 					}

   808 				break;

   809 				

   810 			case CRfc822Token::EMessageId:

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

   812 				LOGGING(KFound,KImcvMessageIdPrompt);

   813 				break;

   814 			case CRfc822Token::EPriority:

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

   816 				LOGGING(KFound,KImcvPriorityPrompt);

   817 				break;

   818 			case CRfc822Token::EReturnReceiptTo:

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

   820 				LOGGING(KFound,KReturnReceiptTo);

   821 				break;

   822 			case CRfc822Token::EEndOfHeader:

   823 				// the next line goes in the body part

   824 				iFinishedHeader = ETrue;

   825 				RECVLOG(KEndOFHeader)

   826 				break;

   827 			default:

   828 				RECVLOG(KEndOFHeader)

   829 				break;

   830 			}

   831 

   832 

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

   834 			{

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

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

   837 

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

   839 			// the header from the body

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

   841 				{

   842 				RECVLOG(KLastToken);

   843 				iNotFinishedRfc822Header = EFalse;

   844 

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

   846 				iHeaderConverter->DecodeAllHeaderFieldsL(*iOutputHeader);

   847 

   848 				if (iMimeParser->MessageIsMime())

   849 					EndOfHeaderMIMEProcessingL();

   850 				else

   851 					EndOfHeaderProcessingL();

   852 

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

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

   855 					{	

   856 					iFirstLinePlainText = ETrue;

   857 					}

   858 				else

   859 					{

   860 					if (iStore8BitData)

   861 						{

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

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

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

   865 						else

   866 							iBodyText->SetCharacterSet(0);

   867 						}

   868 					else

   869 						{

   870 						// Get charset for decoding.

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

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

   873 						else

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

   875 						}

   876 					}

   877 				}

   878 			}

   879 		}

   880 	else if (iReceivingHeadersOnly==EFalse)

   881 		{	

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

   883 		iCommitLine=ETrue; 

   884 

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

   886 		if(iMimeParser->MessageIsMime())

   887 			ParseMimeLineL(aSourceLine);

   888 		else

   889 			ParseBodyLineL(aSourceLine);	

   890 

   891 		if((iCommitLine)&&(!iSkipData))

   892 			DecodeAndStoreLineL(aSourceLine);

   893 		}

   894 	}

   895 

   896 //----------------------------------------------------------------------------------------  

   897 EXPORT_C TMsvEmailEntry CImRecvConvert::MessageEntryDetailsL()

   898 //----------------------------------------------------------------------------------------  

   899 	{

   900 

   901 	iMessageEntryCalled=ETrue;

   902 	CloseAttachmentFileL();

   903 

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

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

   906 		StoreEntryStreamsL(KStore822Header|KStoreMIMEHeader);

   907 	else

   908 		{

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

   910 		if(iEmailEntry)

   911 			{

   912 			delete iEmailEntry;

   913 			iEmailEntry=NULL;

   914 			}

   915 	

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

   917 		}

   918 		

   919 	return *iEmailEntry;

   920 	}

   921 

   922 

   923 //----------------------------------------------------------------------------------------  

   924 EXPORT_C void CImRecvConvert::MessageCompleteL(TMsvEmailEntry aEmailEntry)

   925 //----------------------------------------------------------------------------------------  

   926 	{

   927 	// Restore the entry context

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

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

   930 

   931 	__ASSERT_DEBUG(iMessageEntryCalled, gPanic(KPanicMessageEntryNotCalled));

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

   933 

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

   935 	__ASSERT_DEBUG(iReceivingHeadersOnly, gPanic(KPanicIncorrectResetState)); 

   936 

   937 	if(iEmailEntry)

   938 		{

   939 		if (iEmailEntry->Id())

   940 			{

   941 			if(iLeaveError==KErrNone)

   942 				{

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

   944 				aEmailEntry.SetAttachment(EFalse);

   945 				aEmailEntry.SetMHTMLEmail(EFalse);

   946 				aEmailEntry.SetComplete(EFalse);

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

   948 				RECVLOG(KHeaderComplete)

   949 				}

   950 			else

   951 				{

   952 				if (!iPopulateMessage)

   953 					{

   954 					TMsvId currentId = EntryId();

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

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

   957 					}

   958 				User::Leave(iLeaveError);

   959 				}

   960 			}

   961 		}

   962 

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

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

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

   966 	}

   967 

   968 

   969 EXPORT_C void CImRecvConvert::MessageCompleteL(TBool aPartialDownload)

   970 	{

   971 	iPartialEmail=aPartialDownload;

   972 	MessageCompleteL();

   973 	}

   974 

   975 

   976 //----------------------------------------------------------------------------------------  

   977 EXPORT_C void CImRecvConvert::MessageCompleteL()

   978 //----------------------------------------------------------------------------------------  

   979 	{

   980 	// Restore the entry context

   981 	RECVLOG(KStartMessageComplete)

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

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

   984 

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

   986 		{

   987 		iAttachmentFileState=EFileTopIncomplete;

   988 		}

   989 

   990 	CloseAttachmentFileL();

   991 

   992 	if(!iEmailEntry->Id())

   993 		return;

   994 

   995 	if(iLeaveError!=KErrNone)

   996 		{

   997 		User::Leave(iLeaveError);

   998 		}

   999 

  1000 	if (EntryId()!=iTopMessagePart)

  1001 		{

  1002 		iEmailEntry->SetComplete(ETrue);

  1003 		StoreEntryStreamsL(KStoreMIMEHeader | KStoreBodyText);

  1004 		MoveToParentEntryL();

  1005 

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

  1007 			{

  1008 			iEmailEntry->SetVisible(ETrue);

  1009 			iEmailEntry->SetInPreparation(EFalse);

  1010 			iEmailEntry->SetBodyTextComplete(ETrue);

  1011 			iEmailEntry->SetComplete(ETrue);

  1012 			if(iEmailEntry->PartialDownloaded())

  1013 				{

  1014 				iEmailEntry->SetPartialDownloaded( EFalse );	

  1015 				}

  1016 			// Main message.

  1017 			StoreMessageEntryDetailsL();

  1018 			return;

  1019 			}

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

  1021 			{

  1022 			StoreMessageEntryDetailsL();

  1023 			MoveToParentEntryL();

  1024 			StoreMessageEntryDetailsL();

  1025 			}

  1026 		}

  1027 

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

  1029 	// a MIME part header.

  1030 

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

  1032 	if(iEmailEntry)

  1033 		{

  1034 		delete iEmailEntry;

  1035 		iEmailEntry=NULL;

  1036 		}

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

  1038 	iEmailEntry->SetVisible(ETrue);

  1039 	iEmailEntry->SetInPreparation(EFalse);

  1040 	iEmailEntry->SetComplete(ETrue);

  1041 	iEmailEntry->SetBodyTextComplete(ETrue);

  1042 	if(iEmailEntry->PartialDownloaded())

  1043 		{

  1044 		iEmailEntry->SetPartialDownloaded( EFalse );	

  1045 		}

  1046 

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

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

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

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

  1051 	

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

  1053 		{

  1054 		iEmailEntry->SetAttachment(ETrue);

  1055 		}

  1056 	iRelatedAttachments=EFalse;

  1057 	

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

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

  1060 

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

  1062 

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

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

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

  1066 	RECVLOG(KMessageComplete)

  1067 	}

  1068 

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

  1070 /**

  1071 Initialise class CimCaf reference

  1072 @param aCaf - Reference to a CAF instance

  1073 */

  1074 	{

  1075 	iCaf = &aCaf;

  1076 	}

  1077 //----------------------------------------------------------------------------------------  

  1078 void CImRecvConvert::PrepareDecoder()

  1079 //----------------------------------------------------------------------------------------  

  1080 	{

  1081 	switch(iMimeParser->ContentEncoding())

  1082 		{

  1083 		case EEncodingTypeNone:

  1084 		case EEncodingType7Bit:

  1085 		case EEncodingType8Bit:

  1086 			iAlgorithm = ENoAlgorithm;

  1087 			RECVLOG(KCollectingData7)

  1088 			break;

  1089 		case EEncodingTypeQP:

  1090 			iAlgorithm = EQPDecode;

  1091 			RECVLOG(KCollectingDataQP)

  1092 			break;

  1093 		case EEncodingTypeBASE64:

  1094 			iAlgorithm = EBase64Decode;

  1095 			RECVLOG(KCollectingBase64)

  1096 			break;	

  1097 		case EEncodingTypeUU:

  1098 			iAlgorithm = EUUDecode;

  1099 			RECVLOG(KCollectingUU)

  1100 			break;	

  1101 		default:	// EEncodingTypeUnknown, EEncodingTypeNone, EEncodingTypeBinary	

  1102 			iAlgorithm = ENoAlgorithm;

  1103 			break;

  1104 		} // switch

  1105 	iPrepared = ETrue;

  1106 	}

  1107 

  1108 

  1109 //----------------------------------------------------------------------------------------  

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

  1111 //----------------------------------------------------------------------------------------  

  1112 	{

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

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

  1115 		{

  1116 		iBodyId = iEmailEntry->Id();

  1117 		

  1118 		delete iPlainBodyTextEntry;

  1119 		iPlainBodyTextEntry = NULL;

  1120 		

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

  1122 		iFirstLinePlainText = EFalse;

  1123 		}

  1124 	

  1125 	TInt sourceLineLength=aSourceLine.Length();

  1126 	TBool blankLine = EFalse;

  1127 	TBool decodeError = EFalse;

  1128 

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

  1130 	// This will always be as long as or shorter than the original.

  1131 	

  1132 	HBufC8* convertedLine = HBufC8::NewLC(sourceLineLength+KConversionRemainderLength);

  1133 	TPtr8 des(convertedLine->Des());

  1134