// Copyright (c) 1998-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <e32base.h>

#include "IMUTDLL.H"

#include "IMCVTEXT.H"

#include "IMCVRECV.H"

#include "IMCVCODC.H"	// TImConvert

#include "IMCVUTIL.H"

#include "CMsvPlainBodyTextEntry.H"

#include <cmsvplainbodytext.h>

#include <miuthdr.h>	// CImHeader

#include <miutatch.h>	// TImAttachmentFile

#include <msvids.h>

#include <txtrich.h>

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

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

#include <barsread.h>	// TResourceReader

#include <cmsvbodytext.h>

#ifdef __WINS__

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

#include <msvapi.h>

#endif

#ifndef __WINS__

#include <msvapi.h>

#endif

#include <cmsvattachment.h> 

#include <mmsvattachmentmanager.h>

#include <mmsvattachmentmanagersync.h>

#ifndef _MSG_NO_LOGGING

#define __IMUT_LOGGING

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

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

_LIT8(KFound, "found: ");

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

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

_LIT8(KEndOFHeader, "End of header");

_LIT8(KSkippingData, "Skipping data");

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

_LIT8(KCollectingDataQP, "Collecting QP data");

_LIT8(KCollectingBase64, "Collecting BASE64 data");

_LIT8(KCollectingUU, "Collecting UU data");

_LIT8(KDecodingBase64, "Decoding BASE64 data");

_LIT8(KDecodedBase64, "Decoded BASE64 data");

_LIT8(KDecodingUU, "Decoding UU data");

_LIT8(KDecodedUU, "Decoded UU data");

_LIT8(KDecodingQP, "Decoding QP data");

_LIT8(KDecodedQP, "Decoded QP data");

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

_LIT8(KFoundUUEStartBoundary, "UUE start boundary");

_LIT8(KFoundUUEEndBoundary, "UUE end boundary");

_LIT8(KClosingAttachFile, "Closing attachment file");

_LIT8(KDeletingAttachFile, "Deleting attachment file");

_LIT8(KDeletedAttachFile, "Deleted attachment file");

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

_LIT8(KSectionHeader, "Section header");

_LIT8(KFoundMIMEBoundary, "MIME boundary");

_LIT8(KWritingToBody, "writing body");

_LIT8(KWroteToBody, "wrote body");

_LIT8(KWritingToFile, "writing attachment");

_LIT8(KWroteToFile, "wrote attachment");

_LIT8(KReset, "Resetting CImRecvConvert");

_LIT8(KReseted, "Resetting CImRecvConvert");

_LIT8(KDelete, "Deleting CImRecvConvert");

_LIT8(KDeleted, "Deleting CImRecvConvert");

_LIT8(KLineHasLineBreak, "Linebreak");

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

_LIT8(KBlankLine, "Blank line");

_LIT8(KRemoveBoundary, "Remove boundary");

_LIT8(KRemovedBoundary, "Removed boundary");

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

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

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

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

_LIT8(KCreatingEntry, "Creating Entry");

_LIT8(KCreatedEntry, "Created Entry");

_LIT8(KUpdatingEntry, "Updating Entry");

_LIT8(KUpdatedEntry, "Updated Entry");

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

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

_LIT8(KStoringHeader, "Storing CImHeader");

_LIT8(KStoredHeader, "Stored CImHeader");

_LIT8(KStoringBody, "Storing CRichText");

_LIT8(KStoring8BitBody, "Storing CMsvBodyText");

_LIT8(KStoredBody, "Stored CRichText");

_LIT8(KStored8BitBody, "Stored CMsvBodyText");

_LIT8(KStoringMIMEHeader, "Storing CImMimeHeader");

_LIT8(KStoredMIMEHeader, "Stored CImMimeHeader");

_LIT8(KIgnoringStreams, "Discarding streams");

_LIT8(KStartMessageComplete, "Start Message Complete");

_LIT8(KMessageComplete, "Message Complete");

_LIT8(KHeaderComplete, "Message Header complete");

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

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

_LIT8(KStoringEntryStream, "Storing Entry Stream");

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

#endif // _MSG_NO_LOGGING

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

#if defined(__IMUT_LOGGING)

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

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

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

#else

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

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

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

#endif

const TInt KBodyTextChunkSizeBytes = 512;

_LIT(KIntegerKey,"%d");

const TInt KSpaceToAddNumber=20;

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

LOCAL_C TBool IsIllegalChar(const TUint aChar)

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

	{

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

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

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

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

	}

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

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

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

	{

	TPtr8 des = aString.Des();

	TInt len  = des.Length();

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

		{

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

		des.Copy(mid);

		des.SetLength(len-2);

		}

	}

//****************************************************************************************

//              Class CRfc822Token Functions

//****************************************************************************************

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

EXPORT_C CRfc822Token* CRfc822Token::NewLC()

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

	{

	CRfc822Token* self = new (ELeave) CRfc822Token;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

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

void CRfc822Token::ConstructL()

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

	{

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

	Reset();

	}

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

CRfc822Token::CRfc822Token()

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

	{

	__DECLARE_NAME(_S("CRfc822Token"));

	}

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

EXPORT_C CRfc822Token::~CRfc822Token()

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

	{

	delete iOutputLine;

	}

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

EXPORT_C void CRfc822Token::Reset()

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

	{

	iOutputLine->Des().FillZ();

	iBufferedInput.SetLength(0);

	iBufferedInput.FillZ();

	iLastToken = EFalse;

	iFirstLine = ETrue;

	i822FieldsExist=EFalse;

	}

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

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

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

	{

	TBool hitEof = EFalse;

	TBool endOfField = EFalse;

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

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

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

	if(iBufferedInput.Length())

		{

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

		*iOutputLine = iBufferedInput;

 		iBufferedInput.FillZ();

		iBufferedInput.SetLength(0);

		}

	iInputLine = aSourceLine;

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

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

		iInputLine.Delete(0, 1);

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

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

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

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

	iLastToken = !iInputLine.Length();

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

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

		{

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

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

			{

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

			iBufferedInput = iInputLine;

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

			}

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

			 // Folding headers, RFC 2822, section 2.2.3

			{

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

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

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

			if (iOutputLine->Length()<5000)

				{

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

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

				// now copy the remaining data into the buffer

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

			    }

			}

		}

	else

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

	iFirstLine = EFalse;

	if(endOfField || iLastToken)

		{ 

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

		// or we just found the blank line that

		// separates the body from the header

		if(MatchAndRemoveL(KImcvFromPrompt))

			iHeaderPart = EFrom;

		else if(MatchAndRemoveL(KImcvReplyToPrompt))

			iHeaderPart = EReplyTo;

		else if(MatchAndRemoveL(KImcvToPrompt))

			iHeaderPart = ETo;

		else if(MatchAndRemoveL(KImcvCcPrompt))

			iHeaderPart = ECc;

		else if(MatchAndRemoveL(KImcvBccPrompt))

			iHeaderPart = EBcc;

		else if(MatchAndRemoveL(KImcvSubjectPrompt))

			iHeaderPart = ESubject;

		else if(MatchAndRemoveL(KImcvDatePrompt))

			iHeaderPart = EDate;

		else if(MatchAndRemoveL(KImcvReceivedPrompt))

			iHeaderPart = EReceived;

		else if(MatchAndRemoveL(KImcvMessageIdPrompt))

			{

			iHeaderPart = EMessageId;

			RemoveSurroundingCharacters(KImcvLeftChevron, KImcvRightChevron, *iOutputLine);

			}

		else if (PriorityAndReceiptsMatchAndRemoveL(EPriority))

			iHeaderPart=EPriority;

		else if (PriorityAndReceiptsMatchAndRemoveL(EReturnReceiptTo))

			iHeaderPart=EReturnReceiptTo;

		else if(hitEof)

			iHeaderPart = EEndOfHeader;

		else

			{

			iHeaderPart = EUnknown;

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

			}

		}

	else 

		iHeaderPart = ENotFinished;

	}

TBool CRfc822Token::PriorityAndReceiptsMatchAndRemoveL(THeaderPart aPriority)

	{

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

	CleanupStack::PushL(fields);

	if (aPriority==EPriority)

		CImcvUtils::PriorityFieldsL(*fields);

	else if (aPriority==EReturnReceiptTo)

		CImcvUtils::ReceiptFieldsL(*fields);

	else

		{

		CleanupStack::PopAndDestroy(); //fields

		return EFalse;

		}

	TInt count=fields->Count();

	TBool matched=EFalse;

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

		{

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

			{

			matched=ETrue;

			break;

			}

		}

	CleanupStack::PopAndDestroy(); //fields

	return matched;

	}

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

TBool CRfc822Token::MatchAndRemoveL(const TDesC8& aString)

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

	{

	TInt comparison;

	TInt stringLength = aString.Length();

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

	TInt compareLength = stringLength > desLength ? desLength : stringLength;

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

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

	comparison = left.CompareF(aString);

	if(!comparison)

		{

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

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

		if (!i822FieldsExist)

			i822FieldsExist=ETrue;

		TInt whitespaceLength=0;

		TInt maxLength=desLength-stringLength;

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

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

			whitespaceLength++;

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

		}

	return (comparison==0);

	}

//****************************************************************************************

//             Class CImRecvConvert

//****************************************************************************************

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

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

												TUid aMsgType, TMsvId aEmailServiceId)

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

	{

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

																		aEmailServiceId);

	CleanupStack::PushL(self);

	self->ConstructL(anFs);

	return self;

	}

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

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

												TUid aMsgType, TMsvId aEmailServiceId)

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

	{

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

																aEmailServiceId);

	CleanupStack::Pop();

	return self;

	}

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

void CImRecvConvert::ConstructL(RFs& anFs)

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

	{

	iFsSession = &anFs;  

	RResourceFile resFile;

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

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

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

	TCleanupItem close( CloseResourceFile, &resFile );

	CleanupStack::PushL( close );

	// Read iStore8BitData flag.

	HBufC8* buf = resFile.AllocReadLC( STORE_8BIT_BODY_TEXT );

	TResourceReader reader;

	reader.SetBuffer(buf);

	iStore8BitData = reader.ReadInt8();

	CleanupStack::PopAndDestroy(buf);

	//read iStorePlainBodyText flag for writing bodytext chunk by chunk.

	//For Pop case, it always writes bodytext chunk by chunk

	iStorePlainBodyText = 1;

	buf = resFile.AllocReadLC( REMOVED_ATTACHMENT_TAG );

	reader.SetBuffer(buf);

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

	CleanupStack::PopAndDestroy(buf);

	buf = resFile.AllocReadLC( DEFAULT_ATTACHMENT_NAME );

	reader.SetBuffer(buf);

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

	CleanupStack::PopAndDestroy(buf);

	buf = resFile.AllocReadLC(PARTIAL_DOWNLOAD_FOOTER_MESSAGE);

	reader.SetBuffer(buf);

	if(iStore8BitData)

		{

		iPartialEmailFooter8 = buf;

		CleanupStack::Pop(buf);

		}

	else

		{

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

		CleanupStack::PopAndDestroy(buf);

		}

	buf = NULL;

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

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

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

	CleanupStack::Pop();				// iHeader

	if (iStore8BitData)

		{

		//Create body text storage helper.

		iBodyText = CMsvBodyText::NewL();

		}

	else

		{

		// create CRichText object to store body...

		iParaLayer = CParaFormatLayer::NewL();

		iCharLayer = CCharFormatLayer::NewL();

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

		}

	// Create Rfc822 filter object...

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

	CleanupStack::Pop();				  // iRfc822Token

	iRfc822Token->SetImRecvConvert(this);

	// Create converter objects...

	iCharacterConverter = CCnvCharacterSetConverter::NewL();

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

	iHeaderConverter = CImConvertHeader::NewL(*iCharConv); 

	// Create MIME filter object...

	iMimeParser = CMimeParser::NewL(*this);

	// logfile stuff

	iImcvLog=NULL;

#ifdef __IMUT_LOGGING	

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

#endif

	iRootEntryId = EntryId();

	iNotFinishedRfc822Header = ETrue;

	iEmailEntry = new (ELeave) TMsvEmailEntry;

	iReceivingHeadersOnly=EFalse;	

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

	iFirstBoundaryReached=EFalse;

	ResetL();

	RECVLOG( KNewLogHeader )

	}

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

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

							   TUid aMsgType, TMsvId aEmailServiceId)

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

			  	  iEmailServiceId(aEmailServiceId), iAttachmentFile(anFs)

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

	{

	__DECLARE_NAME(_S("CImRecvConvert"));

	}

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

EXPORT_C CImRecvConvert::~CImRecvConvert()

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

	{

	delete iEmailEntry;

	delete iOutputHeader;

	delete iBodyText;

	delete iBodyBuf;

	delete iParaLayer;

	delete iCharLayer;

	delete iOutputBody;

	delete iRemovedAttachmentTag;

	delete iDefaultAttachmentName;

	delete iRfc822Token;

	delete iMimeParser;

	delete iHeaderConverter;

	delete iCharConv;

	delete iCharacterConverter;