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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

//

/**

 @file

*/

// epoc include

#include <e32base.h>

#include <imutdll.h>

#include <imcvtext.h>

#include "Local_imcvrecv.h"

#include <imcvcodc.h>	// TImConvert

#include <imcvutil.h>

#include <miuthdr.h>	// CImHeader

#include <miutatch.h>	// TImAttachmentFile

#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

// literals used

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

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

_LIT8(KFound, "found: ");

_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 CLocalImRecvConvert");

_LIT8(KReseted, "Resetting CLocalImRecvConvert");

_LIT8(KDeleted, "Deleting CLocalImRecvConvert");

_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

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

const TInt KBodyTextChunkSizeBytes = 512;

_LIT(KIntegerKey,"%d");

const TInt KSpaceToAddNumber=20;

// added this to handle DRM files

_LIT8(KTImcvDrm, "testagent.drm");

/**

IsIllegalChar()

Checks if the character is illegal in EPOC32 file system

@param aChar

@return

*/

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 == '?');

	}

/**

RemoveSurroundingCharacters()

@param aLeft

@param aRight

@param aString

*/

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 CLocalRfc822Token Functions

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

/**

NewLC()

Static factory constructor. Uses two phase 

construction.

@leave KErrNoMemory

@return

A pointer to the newly created CLocalRfc822Token object.

*/

CLocalRfc822Token* CLocalRfc822Token::NewLC()

	{

	CLocalRfc822Token* self = new (ELeave) CLocalRfc822Token;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

ConstructL()

*/

void CLocalRfc822Token::ConstructL()

	{

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

	Reset();

	}

/**

CLocalRfc822Token()

Constructor

*/

CLocalRfc822Token::CLocalRfc822Token()

	{

	__DECLARE_NAME(_S("CLocalRfc822Token"));

	}

/**

~CLocalRfc822Token()

Destructor

*/

CLocalRfc822Token::~CLocalRfc822Token()

	{

	delete iOutputLine;

	iOutputLine=NULL;

	}

/**

Reset()

*/

void CLocalRfc822Token::Reset()

	{

	iOutputLine->Des().FillZ();

	iBufferedInput.SetLength(0);

	iBufferedInput.FillZ();

	iLastToken = EFalse;

	iFirstLine = ETrue;

	i822FieldsExist=EFalse;

	}

/**

ParseNextLineL()

@param aSourceLine

*/

void CLocalRfc822Token::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, but without any leading whitespace

			{

			// find the first non-whitespace character

			const TUint8* ptr = iInputLine.Ptr();

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

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

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

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

			// now copy the remaining data into the buffer

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

			}

		}

	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(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;

	}

/**

PriorityAndReceiptsMatchAndRemoveL()

@param aPriority

*/

TBool CLocalRfc822Token::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;

	}

/**

MatchAndRemoveL()

@param aString

@return

TBool

*/

TBool CLocalRfc822Token::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 CLocalImRecvConvert

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

/**

NewLC()

Static factory constructor. Uses two phase construction 

and pushes the newly created object into the Cleanup stack.

@param anFs

@param aServerEntry

@param aMsgType

@param aEmailServiceId

@leave KErrNoMemory

@return

A pointer to the newly created CLocalImRecvConvert object.

*/

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

												TUid aMsgType, TMsvId aEmailServiceId)

	{

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

																		aEmailServiceId);

	CleanupStack::PushL(self);

	self->ConstructL(anFs);

	return self;

	}

/**

NewL()

Static factory constructor. Uses two phase 

construction.

@param anFs

@param aServerEntry

@param aMsgType

@param aEmailServiceId

@leave KErrNoMemory

@return

A pointer to the newly created CLocalImRecvConvert object.

*/

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

												TUid aMsgType, TMsvId aEmailServiceId)

	{

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

																aEmailServiceId);

	CleanupStack::Pop();

	return self;

	}

/**

ConstructL()

@param anFs

*/

void CLocalImRecvConvert::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);

	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);

	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);

		}