1 // Copyright (c) 2006-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 the License "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 

    18 /**

    19  @file

    20 */

    21 

    22 

    23 // epoc include

    24 #include <e32base.h>

    25 #include <imutdll.h>

    26 #include <imcvtext.h>

    27 #include "Local_imcvrecv.h"

    28 #include <imcvcodc.h>	// TImConvert

    29 #include <imcvutil.h>

    30 

    31 #include <miuthdr.h>	// CImHeader

    32 #include <miutatch.h>	// TImAttachmentFile

    33 #include <txtrich.h>

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

    35 

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

    37 #include <barsread.h>	// TResourceReader

    38 

    39 #include <cmsvbodytext.h>

    40 

    41 #ifdef __WINS__

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

    43 #include <msvapi.h>

    44 #endif

    45 

    46 #ifndef __WINS__

    47 #include <msvapi.h>

    48 #endif

    49 #include <cmsvattachment.h> 

    50 #include <mmsvattachmentmanager.h>

    51 #include <mmsvattachmentmanagersync.h>

    52 #ifndef _MSG_NO_LOGGING

    53 #define __IMUT_LOGGING

    54 

    55 

    56 // literals used

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

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

    59 _LIT8(KFound, "found: ");

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

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

    62 _LIT8(KSkippingData, "Skipping data");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    80 _LIT8(KSectionHeader, "Section header");

    81 _LIT8(KFoundMIMEBoundary, "MIME boundary");

    82 _LIT8(KWritingToBody, "writing body");

    83 _LIT8(KWroteToBody, "wrote body");

    84 _LIT8(KWritingToFile, "writing attachment");

    85 _LIT8(KWroteToFile, "wrote attachment");

    86 _LIT8(KReset, "Resetting CLocalImRecvConvert");

    87 _LIT8(KReseted, "Resetting CLocalImRecvConvert");

    88 _LIT8(KDeleted, "Deleting CLocalImRecvConvert");

    89 _LIT8(KLineHasLineBreak, "Linebreak");

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

    91 _LIT8(KBlankLine, "Blank line");

    92 _LIT8(KRemoveBoundary, "Remove boundary");

    93 _LIT8(KRemovedBoundary, "Removed boundary");

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

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

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

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

    98 _LIT8(KCreatingEntry, "Creating Entry");

    99 _LIT8(KCreatedEntry, "Created Entry");

   100 _LIT8(KUpdatingEntry, "Updating Entry");

   101 _LIT8(KUpdatedEntry, "Updated Entry");

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

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

   104 _LIT8(KStoringHeader, "Storing CImHeader");

   105 _LIT8(KStoredHeader, "Stored CImHeader");

   106 _LIT8(KStoringBody, "Storing CRichText");

   107 _LIT8(KStoring8BitBody, "Storing CMsvBodyText");

   108 _LIT8(KStoredBody, "Stored CRichText");

   109 _LIT8(KStored8BitBody, "Stored CMsvBodyText");

   110 _LIT8(KStoringMIMEHeader, "Storing CImMimeHeader");

   111 _LIT8(KStoredMIMEHeader, "Stored CImMimeHeader");

   112 _LIT8(KIgnoringStreams, "Discarding streams");

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

   114 _LIT8(KMessageComplete, "Message Complete");

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

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

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

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

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

   120 #endif // _MSG_NO_LOGGING

   121 

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

   123 

   124 #if defined(__IMUT_LOGGING)

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

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

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

   128 #else

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

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

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

   132 #endif

   133 

   134 #define UNUSED_VAR( var ) var = var  // fix for armv5 build warnings

   135 const TInt KBodyTextChunkSizeBytes = 512;

   136 

   137 _LIT(KIntegerKey,"%d");

   138 const TInt KSpaceToAddNumber=20;

   139 

   140 // added this to handle DRM files

   141 _LIT8(KTImcvDrm, "testagent.drm");

   142 

   143 

   144 /**

   145 IsIllegalChar()

   146 Checks if the character is illegal in EPOC32 file system

   147 

   148 @param aChar

   149 @return

   150 */

   151 LOCAL_C TBool IsIllegalChar(const TUint aChar)

   152 	{

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

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

   155 			aChar == ':'  || aChar == '"' ||  aChar    == '/' || aChar == '|' ||

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

   157 	}

   158 

   159 /**

   160 RemoveSurroundingCharacters()

   161 

   162 @param aLeft

   163 @param aRight

   164 @param aString

   165 */

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

   167 	{

   168 	TPtr8 des = aString.Des();

   169 	TInt len  = des.Length();

   170 	

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

   172 		{

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

   174 		des.Copy(mid);

   175 		des.SetLength(len - 2);

   176 		}

   177 	}

   178 

   179 

   180 //****************************************************************************************

   181 //              Class CLocalRfc822Token Functions

   182 //****************************************************************************************

   183 

   184 

   185 /**

   186 NewLC()

   187 Static factory constructor. Uses two phase 

   188 construction.

   189 

   190 @leave KErrNoMemory

   191 @return

   192 A pointer to the newly created CLocalRfc822Token object.

   193 */

   194 CLocalRfc822Token* CLocalRfc822Token::NewLC()

   195 	{

   196 	CLocalRfc822Token* self = new (ELeave) CLocalRfc822Token;

   197 	CleanupStack::PushL(self);

   198 	self->ConstructL();

   199 	return self;

   200 	}

   201 

   202 

   203 /**

   204 ConstructL()

   205 

   206 */

   207 void CLocalRfc822Token::ConstructL()

   208 	{

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

   210 	Reset();

   211 	}

   212 

   213 

   214 /**

   215 CLocalRfc822Token()

   216 Constructor

   217 */

   218 CLocalRfc822Token::CLocalRfc822Token()

   219 	{

   220 	__DECLARE_NAME(_S("CLocalRfc822Token"));

   221 	}

   222 

   223 

   224 /**

   225 ~CLocalRfc822Token()

   226 Destructor

   227 */

   228 CLocalRfc822Token::~CLocalRfc822Token()

   229 	{

   230 	delete iOutputLine;

   231 	iOutputLine=NULL;

   232 	}

   233 

   234 

   235 /**

   236 Reset()

   237 

   238 */

   239 void CLocalRfc822Token::Reset()

   240 	{

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

   242 	iBufferedInput.SetLength(0);

   243 	iBufferedInput.FillZ();

   244 

   245 	iLastToken = EFalse;

   246 	iFirstLine = ETrue;

   247 	i822FieldsExist=EFalse;

   248 	}

   249 

   250 

   251 /**

   252 ParseNextLineL()

   253 

   254 @param aSourceLine

   255 */

   256 void CLocalRfc822Token::ParseNextLineL(const TDesC8& aSourceLine)

   257 	{

   258 	TBool hitEof = EFalse;

   259 	TBool endOfField = EFalse;

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

   261 

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

   263 	// previous rfc822 field:*******

   264 

   265 	if(iBufferedInput.Length())

   266 		{

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

   268 		*iOutputLine = iBufferedInput;

   269 		

   270  		iBufferedInput.FillZ();

   271 		iBufferedInput.SetLength(0);

   272 		}

   273 	iInputLine = aSourceLine;

   274 

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

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

   277 		iInputLine.Delete(0, 1);

   278 

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

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

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

   282 

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

   284 	iLastToken = !iInputLine.Length();

   285 

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

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

   288 		{

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

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

   291 			{

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

   293 			iBufferedInput = iInputLine;

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

   295 			}

   296 		else // the line belongs in the current field, but without any leading whitespace

   297 			{

   298 			// find the first non-whitespace character

   299 			const TUint8* ptr = iInputLine.Ptr();

   300 			while((*ptr == KImcvSP || *ptr == KImcvTab) && (ptr - iInputLine.Ptr() < iInputLine.Length())) ptr++;

   301 		

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

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

   304 				iOutputLine = iOutputLine->ReAlloc(iOutputLine->Length() + iInputLine.Length());

   305 

   306 			// now copy the remaining data into the buffer

   307 			iOutputLine->Des().Append(iInputLine.Right(iInputLine.Length() - (ptr - iInputLine.Ptr())));

   308 			}

   309 		}

   310 	else

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

   312 	iFirstLine = EFalse;

   313 

   314 	if(endOfField || iLastToken)

   315 		{ 

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

   317 		// or we just found the blank line that

   318 		// separates the body from the header

   319 		if(MatchAndRemoveL(KImcvFromPrompt))

   320 			iHeaderPart = EFrom;

   321 		else if(MatchAndRemoveL(KImcvReplyToPrompt))

   322 			iHeaderPart = EReplyTo;

   323 		else if(MatchAndRemoveL(KImcvToPrompt))

   324 			iHeaderPart = ETo;

   325 		else if(MatchAndRemoveL(KImcvCcPrompt))

   326 			iHeaderPart = ECc;

   327 		else if(MatchAndRemoveL(KImcvBccPrompt))

   328 			iHeaderPart = EBcc;

   329 		else if(MatchAndRemoveL(KImcvSubjectPrompt))

   330 			iHeaderPart = ESubject;

   331 		else if(MatchAndRemoveL(KImcvDatePrompt))

   332 			iHeaderPart = EDate;

   333 		else if(MatchAndRemoveL(KImcvMessageIdPrompt))

   334 			{

   335 			iHeaderPart = EMessageId;

   336 			RemoveSurroundingCharacters(KImcvLeftChevron, KImcvRightChevron, *iOutputLine);

   337 			}

   338 		else if (PriorityAndReceiptsMatchAndRemoveL(EPriority))

   339 			iHeaderPart=EPriority;

   340 		else if (PriorityAndReceiptsMatchAndRemoveL(EReturnReceiptTo))

   341 			iHeaderPart=EReturnReceiptTo;

   342 		else if(hitEof)

   343 			iHeaderPart = EEndOfHeader;

   344 		else

   345 			{

   346 			iHeaderPart = EUnknown;

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

   348 			}

   349 		}

   350 	else 

   351 		iHeaderPart = ENotFinished;

   352 	}

   353 

   354 

   355 /**

   356 PriorityAndReceiptsMatchAndRemoveL()

   357 

   358 @param aPriority

   359 */

   360 TBool CLocalRfc822Token::PriorityAndReceiptsMatchAndRemoveL(THeaderPart aPriority)

   361 	{

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

   363 	CleanupStack::PushL(fields);

   364 	if (aPriority==EPriority)

   365 		CImcvUtils::PriorityFieldsL(*fields);

   366 	else if (aPriority==EReturnReceiptTo)

   367 		CImcvUtils::ReceiptFieldsL(*fields);

   368 	else

   369 		{

   370 		CleanupStack::PopAndDestroy(); //fields

   371 		return EFalse;

   372 		}

   373 	TInt count=fields->Count();

   374 	TBool matched=EFalse;

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

   376 		{

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

   378 			{

   379 			matched=ETrue;

   380 			break;

   381 			}

   382 		}

   383 	CleanupStack::PopAndDestroy(); //fields

   384 	return matched;

   385 	}

   386 

   387 

   388 /**

   389 MatchAndRemoveL()

   390 

   391 @param aString

   392 @return

   393 TBool

   394 */

   395 TBool CLocalRfc822Token::MatchAndRemoveL(const TDesC8& aString)

   396 	{

   397 	TInt comparison;

   398 	TInt stringLength = aString.Length();

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

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

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

   402 	

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

   404 	comparison = left.CompareF(aString);

   405 	if(!comparison)

   406 		{

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

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

   409 		if (!i822FieldsExist)

   410 			i822FieldsExist=ETrue;

   411 		TInt whitespaceLength=0;

   412 		TInt maxLength=desLength-stringLength;

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

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

   415 			whitespaceLength++;

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

   417 		}

   418 	return (comparison==0);

   419 	}

   420 

   421 //****************************************************************************************

   422 //             Class CLocalImRecvConvert

   423 //****************************************************************************************

   424 

   425 

   426 /**

   427 NewLC()

   428 Static factory constructor. Uses two phase construction 

   429 and pushes the newly created object into the Cleanup stack.

   430 

   431 @param anFs

   432 @param aServerEntry

   433 @param aMsgType

   434 @param aEmailServiceId

   435 @leave KErrNoMemory

   436 @return

   437 A pointer to the newly created CLocalImRecvConvert object.

   438 */

   439 CLocalImRecvConvert* CLocalImRecvConvert::NewLC(RFs& anFs, CMsvServerEntry* aServerEntry, 

   440 												TUid aMsgType, TMsvId aEmailServiceId)

   441 	{

   442 	CLocalImRecvConvert* self = new (ELeave) CLocalImRecvConvert(anFs, aServerEntry, aMsgType, 

   443 																		aEmailServiceId);

   444 	CleanupStack::PushL(self);

   445 	self->ConstructL(anFs);

   446 	return self;

   447 	}

   448 

   449 

   450 /**

   451 NewL()

   452 Static factory constructor. Uses two phase 

   453 construction.

   454 

   455 @param anFs

   456 @param aServerEntry

   457 @param aMsgType

   458 @param aEmailServiceId

   459 @leave KErrNoMemory

   460 @return

   461 A pointer to the newly created CLocalImRecvConvert object.

   462 */

   463 CLocalImRecvConvert* CLocalImRecvConvert::NewL(RFs& anFs, CMsvServerEntry* aServerEntry, 

   464 												TUid aMsgType, TMsvId aEmailServiceId)

   465 	{

   466 	CLocalImRecvConvert* self = CLocalImRecvConvert::NewLC(anFs, aServerEntry, aMsgType, 

   467 																aEmailServiceId);

   468 	CleanupStack::Pop();

   469 	return self;

   470 	}

   471 

   472   

   473 /**

   474 ConstructL()

   475 

   476 @param anFs

   477 */

   478 void CLocalImRecvConvert::ConstructL(RFs& anFs)

   479 	{

   480 	iFsSession = &anFs;  

   481 

   482 	RResourceFile resFile;

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

   484 

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

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

   487 	TCleanupItem close( CloseResourceFile, &resFile );

   488 	CleanupStack::PushL( close );

   489 	

   490 	// Read iStore8BitData flag.

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

   492 	TResourceReader reader;

   493 	reader.SetBuffer(buf);

   494 	iStore8BitData = reader.ReadInt8();

   495 	CleanupStack::PopAndDestroy(buf);

   496 

   497 	buf = resFile.AllocReadLC( REMOVED_ATTACHMENT_TAG );

   498 	reader.SetBuffer(buf);

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

   500 	CleanupStack::PopAndDestroy(buf);

   501 	

   502 	buf = resFile.AllocReadLC( DEFAULT_ATTACHMENT_NAME );

   503 	reader.SetBuffer(buf);

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

   505 	CleanupStack::PopAndDestroy(buf);

   506 	buf = resFile.AllocReadLC(PARTIAL_DOWNLOAD_FOOTER_MESSAGE);

   507 	reader.SetBuffer(buf);

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

   509 	CleanupStack::PopAndDestroy(buf);

   510 	buf = NULL;

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

   512 

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

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

   515 	CleanupStack::Pop();				// iHeader

   516 

   517 	if (iStore8BitData)

   518 		{

   519 		//Create body text storage helper.

   520 		iBodyText = CMsvBodyText::NewL();

   521 		}

   522 	else

   523 		{

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

   525 		iParaLayer = CParaFormatLayer::NewL();

   526 		iCharLayer = CCharFormatLayer::NewL();

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

   528 		}

   529 	

   530 	// Create Rfc822 filter object...

   531 	iRfc822Token = CLocalRfc822Token::NewLC(); // PushL(iRfc822Token)

   532 	CleanupStack::Pop();				  // iRfc822Token

   533 	iRfc822Token->SetImRecvConvert(this);

   534 

   535 	// Create converter objects...

   536 	iCharacterConverter = CCnvCharacterSetConverter::NewL();

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

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

   539 

   540 	

   541 	// Create MIME filter object...

   542 	iMimeParser = CLocalMimeParser::NewL(*this);

   543 	

   544 	

   545 	// logfile stuff

   546 	iImcvLog=NULL;

   547 

   548 #ifdef __IMUT_LOGGING	

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

   550 	UNUSED_VAR( err );

   551 #endif

   552 

   553 	iRootEntryId = EntryId();

   554 

   555 	iNotFinishedRfc822Header = ETrue;

   556 	

   557 	iEmailEntry = new (ELeave) TMsvEmailEntry;

   558 	iReceivingHeadersOnly=EFalse;	

   559 

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

   561 

   562 	iFirstBoundaryReached=EFalse;

   563 

   564 	ResetL();

   565 	

   566 	RECVLOG( KNewLogHeader )

   567 	}

   568 

   569 

   570 /**

   571 CLocalImRecvConvert()

   572 

   573 @param anFs

   574 @param aServerEntry

   575 @param aMsgType

   576 @param aEmailServiceId

   577 */

   578 CLocalImRecvConvert::CLocalImRecvConvert(RFs& anFs, CMsvServerEntry* aServerEntry, 

   579 							   TUid aMsgType, TMsvId aEmailServiceId)

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

   581 			  	  iEmailServiceId(aEmailServiceId), iAttachmentFile(anFs)

   582 	{

   583 	__DECLARE_NAME(_S("CLocalImRecvConvert"));

   584 	}

   585 

   586   

   587 /**

   588 ~CLocalImRecvConvert()

   589 Destructor

   590 */

   591 CLocalImRecvConvert::~CLocalImRecvConvert()

   592 	{

   593 	delete iEmailEntry;

   594 	iEmailEntry=NULL;

   595 	delete iOutputHeader;

   596 	iOutputHeader=NULL;

   597 	delete iBodyText;

   598 	iBodyText=NULL;

   599 	delete iBodyBuf;

   600 	iBodyBuf=NULL;

   601 	delete iParaLayer;

   602 	iParaLayer=NULL;

   603 	delete iCharLayer;

   604 	iCharLayer=NULL;

   605 	delete iOutputBody;

   606 	iOutputBody=NULL;

   607 	delete iRemovedAttachmentTag;

   608 	iRemovedAttachmentTag=NULL;

   609 	delete iDefaultAttachmentName;

   610 	iDefaultAttachmentName=NULL;

   611 	delete iRfc822Token;

   612 	iRfc822Token=NULL;

   613 	delete iMimeParser;

   614 	iMimeParser=NULL;

   615 	delete iHeaderConverter;

   616 	iHeaderConverter=NULL;

   617 	delete iCharConv;

   618 	iCharConv=NULL;

   619 	delete iCharacterConverter;

   620 	iCharacterConverter=NULL;

   621 	delete iAttachmentFullPath;

   622 	iAttachmentFullPath=NULL;

   623 	delete iImcvUtils;

   624 	iImcvUtils=NULL;

   625 	delete iParent;

   626 	iParent=NULL;

   627 	RECVLOG(KDeleted)

   628 	delete iImcvLog;

   629 	iImcvLog=NULL;

   630 	delete iPartialEmailFooter;

   631 	iPartialEmailFooter=NULL;

   632 	}

   633 

   634 

   635 /**

   636 ResetForHeadersL()

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

   638 only wishes to create  email entries in the remote mailbox - 

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

   640 entry

   641 

   642 */

   643 void CLocalImRecvConvert::ResetForHeadersL()

   644 	{

   645 	ResetL();

   646 	iReceivingHeadersOnly=ETrue;

   647 	}

   648 

   649 /**

   650 ResetL()

   651 

   652 */

   653 void CLocalImRecvConvert::ResetL()

   654 	{

   655 	RECVLOG(KReset) 

   656 	iBodyId=KMsvNullIndexEntryId;

   657 	iSizeOfAttachmentsRemoved=0;

   658 

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

   660 	

   661 	iReceivingHeadersOnly=EFalse;

   662 	iMessageEntryCalled=EFalse;

   663 	iLeaveError=KErrNone; 		

   664 	iCurrentMultipartFolderEntryId=0;

   665 

   666 	TParentDetails parent;

   667 	parent.iAttachment=parent.iMHTML=EFalse;

   668 	parent.iSize=0;

   669 	iParent->InsertL(0,parent);

   670 

   671 	delete iEmailEntry;

   672 	iEmailEntry=NULL;

   673 	iEmailEntry = new (ELeave) TMsvEmailEntry;

   674 

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

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

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

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

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

   680 	iSavingAttachments=ETrue;

   681 	iAttachmentFileState=EFileIsClosed;

   682 

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

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

   685 

   686 	iGlobalIndent=0;

   687 	iLongestLine=50;

   688 	

   689 	iImPriority=EMsvMediumPriority;

   690 	delete iImcvUtils;

   691 	iImcvUtils=NULL;

   692 	iImcvUtils=CImcvUtils::NewL();

   693 

   694 	// reset internal date

   695 	iTimeDate.HomeTime();

   696 	

   697 	iMimeParser->Reset();

   698 	

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

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

   701 	ResetForNewEntryL(iDefaultEntryType);

   702 	iMIMEPart_822Header = EFalse;

   703 	iPartialEmail=EFalse;

   704 

   705 	RECVLOG(KReseted) 

   706 	}

   707 

   708 

   709 /**

   710 ResetForNewEntryL()

   711 

   712 @param entryType

   713 */

   714 void CLocalImRecvConvert::ResetForNewEntryL(TValidEntryType entryType)

   715 	{

   716 	RECVLOG(KResetForNewEntry) 

   717 

   718 	iFinishedHeader = EFalse;

   719 

   720 	iPreviousLineLength = 0;

   721 	iPreviousTrailingWhitespace = 0;

   722 	iLastChar = 0;

   723 

   724 	// Reset the new entry state

   725 	ResetForNonMimeEntryL();

   726 

   727 	// Clear the storage classes

   728 	iMimeParser->ResetForNewEntry();

   729 	iRfc822Token->Reset();

   730 

   731 	iEmailPart = KNoPart;

   732 	iEntryType=entryType;

   733 

   734 	if (iEntryType==EMessageEntry)

   735 		{

   736 		iEmailPart = KParentPart;

   737 		iMimeParser->SetMessageFolderType(EFolderTypeRFC822);

   738 		}

   739 	}

   740 

   741 

   742 /**

   743 ResetForNonMimeEntryL()

   744 

   745 */

   746 void CLocalImRecvConvert::ResetForNonMimeEntryL()

   747 	{

   748 	iEntryType = ETextEntry;

   749 	RECVLOG(KResetForNonMimeEntry) 

   750 

   751 	iSkipData = EFalse;

   752 	iPrepared = EFalse;

   753 	iNewNonMIMEBodyPart=ETrue;

   754 	iEncounteredLineEndingInCarriageReturn=EFalse;

   755 

   756 	iAlgorithm = ENoAlgorithm;

   757 	iCurrentPartIsRichText = ETrue;	

   758 	CloseAttachmentFileL();

   759 	iEntryDataSize = 0;

   760 	

   761 	if (iStore8BitData)

   762 		{

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

   764 		delete iBodyBuf;

   765 		iBodyBuf = NULL;

   766 		iBodyBuf = CBufSeg::NewL(KBodyTextChunkSizeBytes);

   767 		}

   768 	else

   769 		{

   770 		iOutputBody->Reset();

   771 		}

   772 	

   773 	iAttachmentName.Zero();

   774 	iFinalLine = EFalse;

   775 

   776 	iOutputHeader->Reset();

   777 	iEmptyHeaderSize=iOutputHeader->DataSize();

   778 	RECVLOG(KResetedForNonMimeEntry) 

   779 	}

   780 

   781 

   782 /**

   783 ParseNextField()

   784 

   785 @param aSourceLine

   786 */

   787 TInt CLocalImRecvConvert::ParseNextField(const TDesC8& aSourceLine) 

   788 	{

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

   790 	RECVLOG_OUT(aSourceLine);

   791 

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

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

   794 		iLeaveError = iServerEntry->SetEntry(iSavedEntryId);

   795 

   796 	if(iLeaveError==KErrNone)

   797 		TRAP(iLeaveError, ParseNextLineL(aSourceLine));		

   798 

   799 	// Save the current entry id for later.

   800 	if (iLeaveError==KErrNone)

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

   802 

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

   804 	if( type != KUidMsvMessageEntry    &&

   805 		type != KUidMsvEmailTextEntry  &&

   806 		type != KUidMsvEmailHtmlEntry  &&

   807 		type != KUidMsvAttachmentEntry)

   808 		{

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

   810 	iServerEntry->SetEntry(KMsvNullIndexEntryId);

   811 		}

   812 

   813 	return iLeaveError;

   814 	}

   815 

   816 

   817 /**

   818 ParseNextLineL()

   819 

   820 @param aSourceLine

   821 */

   822 void CLocalImRecvConvert::ParseNextLineL(const TDesC8& aSourceLine)

   823 	{

   824 	iParsedMimeBoundaryLast=0;

   825 	if(!iFinishedHeader)

   826 		{

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

   828 		iRfc822Token->ParseNextLineL(aSourceLine);

   829 

   830 		switch(iRfc822Token->iHeaderPart)

   831 			{

   832 			case CLocalRfc822Token::EUnknown:

   833 			case CLocalRfc822Token::ENotFinished:

   834 				RECVLOG(KPartLine)

   835 				break;

   836 			case CLocalRfc822Token::EFrom:

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

   838 				LOGGING(KFound,KImcvFromPrompt);

   839 				break;

   840 			case CLocalRfc822Token::EReplyTo:

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

   842 				LOGGING(KFound,KImcvReplyToPrompt);

   843 				break;

   844 			case CLocalRfc822Token::ETo:

   845 				ParseRecipientListL(iOutputHeader->ToRecipients());

   846 				LOGGING(KFound,KImcvToPrompt);

   847 				break;

   848 			case CLocalRfc822Token::ECc: 

   849 				ParseRecipientListL(iOutputHeader->CcRecipients());

   850 				LOGGING(KFound,KImcvCcPrompt);

   851 				break;

   852 			case CLocalRfc822Token::EBcc: 

   853 				ParseRecipientListL(iOutputHeader->BccRecipients());

   854 				LOGGING(KFound,KImcvBccPrompt);

   855 				break;

   856 			case CLocalRfc822Token::ESubject:

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

   858 				LOGGING(KFound,KImcvSubjectPrompt);

   859 				break;

   860 			case CLocalRfc822Token::EDate:

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

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

   863 					{

   864 					iEmailEntry->iDate = iTimeDate;

   865 					}

   866 				LOGGING(KFound,KImcvDatePrompt);

   867 				break;

   868 			case CLocalRfc822Token::EMessageId:

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

   870 				LOGGING(KFound,KImcvMessageIdPrompt);

   871 				break;

   872 			case CLocalRfc822Token::EPriority:

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

   874 				LOGGING(KFound,KImcvPriorityPrompt);

   875 				break;

   876 			case CLocalRfc822Token::EReturnReceiptTo:

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

   878 				LOGGING(KFound,KReturnReceiptTo);

   879 				break;

   880 			case CLocalRfc822Token::EEndOfHeader:

   881 				// the next line goes in the body part

   882 				iFinishedHeader = ETrue;

   883 				RECVLOG(KEndOFHeader)

   884 				break;

   885 			default:

   886 				RECVLOG(KEndOFHeader)

   887 				break;

   888 			}

   889 

   890 

   891 		if(iRfc822Token->iHeaderPart != CLocalRfc822Token::ENotFinished)

   892 			{

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

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

   895 

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

   897 			// the header from the body

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

   899 				{

   900 				RECVLOG(KLastToken);

   901 				iNotFinishedRfc822Header = EFalse;

   902 

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

   904 				iHeaderConverter->DecodeAllHeaderFieldsL(*iOutputHeader);

   905 

   906 				if (iMimeParser->MessageIsMime())

   907 					EndOfHeaderMIMEProcessingL();

   908 				else

   909 					EndOfHeaderProcessingL();

   910 

   911 				if (iStore8BitData)

   912 					{

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

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

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

   916 					else

   917 						iBodyText->SetCharacterSet(0);

   918 					}

   919 				else

   920 					{

   921 					// Get charset for decoding.

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

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

   924 					else

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

   926 					}

   927 				}

   928 			}

   929 		}

   930 	else if (iReceivingHeadersOnly == EFalse)

   931 		{	

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

   933 		iCommitLine=ETrue; 

   934 

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

   936 		if(iMimeParser->MessageIsMime())

   937 			ParseMimeLineL(aSourceLine);

   938 		else

   939 			ParseBodyLineL(aSourceLine);	

   940 

   941 		if((iCommitLine) && (!iSkipData))

   942 			DecodeAndStoreLineL(aSourceLine);

   943 		}

   944 	}

   945 

   946 

   947 /**

   948 MessageEntryDetailsL()

   949 

   950 @return

   951 */

   952 TMsvEmailEntry CLocalImRecvConvert::MessageEntryDetailsL()

   953 	{

   954 	iMessageEntryCalled=ETrue;

   955 	CloseAttachmentFileL();

   956 

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

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

   959 		StoreEntryStreamsL(KStore822Header|KStoreMIMEHeader);

   960 	else

   961 		{

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

   963 		delete iEmailEntry;

   964 		iEmailEntry=NULL;

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

   966 		}

   967 		

   968 	return *iEmailEntry;

   969 	}

   970 

   971 

   972 /**

   973 MessageCompleteL()

   974 

   975 @param aEmailEntry

   976 */

   977 void CLocalImRecvConvert::MessageCompleteL(TMsvEmailEntry aEmailEntry)

   978 	{

   979 	// Restore the entry context

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

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

   982 

   983 	__ASSERT_DEBUG(iMessageEntryCalled, gPanic(KPanicMessageEntryNotCalled));

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

   985 

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

   987 	__ASSERT_DEBUG(iReceivingHeadersOnly, gPanic(KPanicIncorrectResetState)); 

   988 

   989 	if(iEmailEntry)

   990 		{

   991 		if (iEmailEntry->Id())

   992 			{

   993 			if(iLeaveError==KErrNone)

   994 				{

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

   996 				aEmailEntry.SetAttachment(EFalse);

   997 				aEmailEntry.SetMHTMLEmail(EFalse);

   998 				aEmailEntry.SetComplete(EFalse);

   999 				User::LeaveIfError(iServerEntry->ChangeEntry(aEmailEntry));

  1000 				RECVLOG(KHeaderComplete)

  1001 				}

  1002 			else

  1003 				{

  1004 				if (!iPopulateMessage)

  1005 					{

  1006 					TMsvId currentId = EntryId();

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

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

  1009 					}

  1010 				User::Leave(iLeaveError);

  1011 				}

  1012 			}

  1013 		}

  1014 

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

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

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

  1018 	}

  1019 

  1020 

  1021 /**

  1022 MessageCompleteL()

  1023 

  1024 @param aPartialDownload

  1025 */

  1026 void CLocalImRecvConvert::MessageCompleteL(TBool aPartialDownload)

  1027 	{

  1028 	iPartialEmail=aPartialDownload;

  1029 	MessageCompleteL();

  1030 	}

  1031   

  1032 

  1033 /**

  1034 MessageCompleteL()

  1035 */

  1036 void CLocalImRecvConvert::MessageCompleteL()

  1037 	{

  1038 	// Restore the entry context

  1039 	RECVLOG(KStartMessageComplete)

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

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

  1042 

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

  1044 		{

  1045 		iAttachmentFileState=EFileTopIncomplete;

  1046 		}

  1047 

  1048 	CloseAttachmentFileL();

  1049 

  1050 	if(!iEmailEntry->Id())

  1051 		return;

  1052 

  1053 	if(iLeaveError!=KErrNone)

  1054 		{

  1055 		User::Leave(iLeaveError);

  1056 		}

  1057 

  1058 	if (EntryId()!=iTopMessagePart)

  1059 		{

  1060 		iEmailEntry->SetComplete(ETrue);

  1061 		StoreEntryStreamsL(KStoreBodyText);

  1062 		MoveToParentEntryL();

  1063 

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

  1065 			{

  1066 			iEmailEntry->SetVisible(ETrue);

  1067 			iEmailEntry->SetInPreparation(EFalse);

  1068 			iEmailEntry->SetBodyTextComplete(ETrue);

  1069 			iEmailEntry->SetComplete(ETrue);

  1070 

  1071 			// Main message.

  1072 			StoreMessageEntryDetailsL();

  1073 			return;

  1074 			}

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

  1076 			{

  1077 			StoreMessageEntryDetailsL();

  1078 			MoveToParentEntryL();

  1079 			StoreMessageEntryDetailsL();

  1080 			}

  1081 		}

  1082 

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

  1084 	// a MIME part header.

  1085 

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

  1087 	if(NULL!=iEmailEntry)

  1088 		{

  1089 		delete iEmailEntry;

  1090 		iEmailEntry=NULL;

  1091 		}

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

  1093 	iEmailEntry->SetVisible(ETrue);

  1094 	iEmailEntry->SetInPreparation(EFalse);

  1095 	iEmailEntry->SetComplete(ETrue);

  1096 	iEmailEntry->SetBodyTextComplete(ETrue);

  1097 

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

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

  1100 

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

  1102 		{

  1103 		iEmailEntry->SetAttachment(ETrue);

  1104 		}

  1105 	iRelatedAttachments=EFalse;

  1106 	

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

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

  1109 

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

  1111 

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

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

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

  1115 	RECVLOG(KMessageComplete)

  1116 	}

  1117 

  1118 

  1119 /**

  1120 PrepareDecoder()

  1121 

  1122 */

  1123 void CLocalImRecvConvert::PrepareDecoder()

  1124 	{

  1125 	switch(iMimeParser->ContentEncoding())

  1126 		{

  1127 		case EEncodingTypeNone:

  1128 		case EEncodingType7Bit:

  1129 		case EEncodingType8Bit:

  1130 			iAlgorithm = ENoAlgorithm;

  1131 			RECVLOG(KCollectingData7)

  1132 			break;

  1133 		case EEncodingTypeQP:

  1134 			iAlgorithm = EQPDecode;