// Copyright (c) 1999-2009 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:

// MIUTRSLV.CPP

//

#include "MIUTRSLV.H"

#include <msvuids.h>

#include "MIUTMSG.H"

#include "MIUT_ERR.H"

#include <cmsvmimeheaders.h>

#include <mmsvattachmentmanager.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "cimmessagepart.h"

#include "miut_errconsts.h"

#include "timrfc822datefield.h"

#endif

_LIT(KImMhtmlCidString, "cid");

_LIT8(KImMhtmlStartString, "start");

// This class implements the URI resolving process described in RFC 2110.

// Also see RFC 2112 and 1808.

// MHTML messages may contain multiple HTML body parts. Each of these body parts

// is able to reference another body part within the same multipart/related

// structure. These references are called URI's.

// When an MHTML message is parsed by the message engine, the HTML body of each

// part is stored as a file. The following classes are a means of finding the

// file name of the body part that corresponds to a given a URI.

CImMhtmlUriResolver* CImMhtmlUriResolver::NewL(CMsvEntry& aEntry)

	{

	CImMhtmlUriResolver* self = NewLC(aEntry);

	CleanupStack::Pop(); // self

	return self;

	}

CImMhtmlUriResolver* CImMhtmlUriResolver::NewLC(CMsvEntry& aEntry)

	{

	CImMhtmlUriResolver* self = new (ELeave) CImMhtmlUriResolver(aEntry);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CImMhtmlUriResolver::ResolveL(const TDesC& aURI, const TDesC& aHtmlBase, TMsvId aCurrentPartId,TBool aFileNameOnly, TRequestStatus& aStatus)

	{

	Queue(aStatus);

	iResolved = EFalse;

	delete iUri;

	iUri = CImMhtmlUri::NewL(aURI);

	iBodyPartId = aCurrentPartId;

	iCurrentEntry.SetEntryL(aCurrentPartId);

	iState = EImResolvingUri;

	iTryingThisMessage = EFalse;

	iFileNameOnly = aFileNameOnly;

	ResolveL(aHtmlBase, aCurrentPartId);

	}

void CImMhtmlUriResolver::ResolveL(const TDesC& aHtmlBase, TMsvId aCurrentPartId)

	{

	if (!(iUri->IsAbsolute()))

	// Use the aHtmlBase parameter as a base to make an absolute URI from the given relative one.

	// Try and find a match for this URI.

		{

		if (aHtmlBase.Length() != 0)

			{

			CImMhtmlUri* baseUri = CImMhtmlUri::NewLC(aHtmlBase);

			if (baseUri->IsAbsolute())

				{

				iUri->MakeAbsoluteL(*baseUri);

				}

			CleanupStack::PopAndDestroy(); // baseUri

			}

		}

	if (!(iUri->IsAbsolute()))

	// Use the Content-location value that is associated with the current part as a base.

	// Use this base to make an absolute URI from the given one and then search for it.

		{

		HBufC* contentLocation = GetContentLocationL(aCurrentPartId);

		if (contentLocation)

			{

			CleanupStack::PushL(contentLocation);

			CImMhtmlUri* baseUri = CImMhtmlUri::NewLC(contentLocation->Des());

			if (baseUri->IsAbsolute())

				{

				iUri->MakeAbsoluteL(*baseUri);

				}

			CleanupStack::PopAndDestroy(2); // baseUri, contentLocation

			}

		}

	iStatus=KRequestPending;

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	}

void CImMhtmlUriResolver::FindFirstL(TMsvId aRootMessageId,TBool aFileNameOnly, TRequestStatus &aStatus)

	{

	Queue(aStatus);

	iMhtmlFirstPageFinder->FindL(aRootMessageId,aFileNameOnly, iStatus);

	iFileNameOnly = aFileNameOnly;

	iState = EImFindingFirstUri;

	SetActive();

	}

CImMhtmlUriResolver::~CImMhtmlUriResolver()

	{

	iFile.Close();

	delete iUri;

	delete iMhtmlFileFinder;

	delete iMhtmlFirstPageFinder;

	iUriCacheArray.ResetAndDestroy();

	}

TInt CImMhtmlUriResolver::FileHandle(RFile& aFile) const	

	{

	if(iResolved)

		{

		// someone requested for the file handle,

		// pass the handle and create a empty file handle

		aFile = iFile;

		iFile=RFile();

		return KErrNone;	

		}

	else

		{

		return KErrNotFound;	

		}	

	}

HBufC* CImMhtmlUriResolver::FileNameL() const

	{

	if (iResolved)

		{

		HBufC* fileName = HBufC::NewL(iFileName.Length());

		(*fileName) = iFileName;

		return fileName;

		}

	else

		{

		return iUri ? iUri->TextL(ETrue) : 0;

		}

	}

TMsvId CImMhtmlUriResolver::LinkedEntryId() const

	{

	return iLinkedEntryId;

	}

void CImMhtmlUriResolver::ConstructL()

	{

	CActiveScheduler::Add(this);

	iMhtmlFileFinder = CImMhtmlFileFinder::NewL(iCurrentEntry,iUriCacheArray);

	iMhtmlFirstPageFinder = CImMhtmlFirstPageFinder::NewL(iCurrentEntry);

	}

void CImMhtmlUriResolver::DoRunL()

	{

	TBool matchUri = EFalse;

	if ((iState == EImFindingFile)

		&& (!iMhtmlFileFinder->MatchFound())

		&& (iTryingThisMessage))

		// Fix for MIME::lite.

		// The body part could not be found using the thismessage: scheme,

		// so look for a content location with the original unresolved URI.

		{

		matchUri = ETrue;

		iTryingThisMessage = EFalse;

		CImMhtmlUri* unresolvedUri = CImMhtmlUri::NewLC(iUri->OriginalUriText()->Des());

		delete iUri;

		iUri = unresolvedUri;

		CleanupStack::Pop(); // unresolvedUri

		}

	if (EImResolvingUri == iState)

		{

		if (!(iUri->IsAbsolute()))

			{

			iCurrentEntry.SetEntryL(iCurrentEntry.Entry().Parent());

			if ((KUidMsvMessageEntry != iCurrentEntry.Entry().iType)

				&& (KUidMsvFolderEntry != iCurrentEntry.Entry().iType))

			// If there are no parent entries then use 'thismessage:/' as the base.

				{

				_LIT(KDefaultBase, "thismessage:/");

				CImMhtmlUri* defaultBase = CImMhtmlUri::NewLC(KDefaultBase);

				iUri->MakeAbsoluteL(*defaultBase);

				CleanupStack::PopAndDestroy(); // defaultBase

				matchUri = ETrue;

				iTryingThisMessage = ETrue;

				}

			// If a valid base is still needed to complete the uri then try and find it in the parent headers.

			else

				{

				ResolveL(KNullDesC ,iCurrentEntry.Entry().Id());

				iState=EImTryingWithoutResolve;

				}

			}

		else

			{

			matchUri = ETrue;

			}

		}

	else if (iState == EImTryingWithoutResolve)

		{

		matchUri = ETrue;

		}

	if (matchUri)

		{

		if(CheckCacheForLinkedEntryL())

			{

			if (iStatus == KImcmHTMLPartNotPopulated)					

				{

				User::Leave(KImcmHTMLPartNotPopulated);	

				}

			}	

		else

			{

			// Search the appropriate structures for the file that matches the absolute URI.

			TBool cidUri = iUri->CompareScheme(KImMhtmlCidString);

			// Do not include the scheme if the URI is a content-id ('cid:').

			HBufC* uriText = iUri->TextL(!cidUri);

			CleanupStack::PushL(uriText);

			iMhtmlFileFinder->FindL(uriText->Des(), iBodyPartId,iFileNameOnly, iStatus);

			CleanupStack::PopAndDestroy(); // uriText

			iState = EImFindingFile;

			SetActive();

			}

		}

	}

/** 

Searches in cache for a URl that need to be resolved. If URL found in cache then it implies that URL 

has been resolved in previous look ups (Each entry of cache contains a URL and its corresponding Linked Entry)

@return True if cache contains URI else false

*/

TBool CImMhtmlUriResolver::CheckCacheForLinkedEntryL()

	{	

	TInt count = iUriCacheArray.Count();

	if(count)

		{

		CImCacheUriEntry* cacheEntry = NULL;

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

			{

			cacheEntry = iUriCacheArray[i];

			if((iUri->OriginalUriText()->Des().Compare(cacheEntry->GetContentLocation()->Des()) == 0 ) || (iUri->OriginalUriText()->Des().Compare(cacheEntry->GetContentId()->Des()) == 0 ))

				{

				iLinkedEntryId = cacheEntry->GetUriEntry();

				iCurrentEntry.SetEntryL(iLinkedEntryId);

				CMsvStore* store = iCurrentEntry.ReadStoreL();

				CleanupStack::PushL(store);

				MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL();

				// emails have one attachment per attachment entry

				if(attachmentMgr.AttachmentCount())

					{

					if(iFileNameOnly)

						{

						CMsvAttachment* attachment = attachmentMgr.GetAttachmentInfoL(0);

						iFileName = attachment->FilePath();

						delete attachment;

						}

					else 

						{

						iFile = attachmentMgr.GetAttachmentFileL(0);	

						}		

					}

				CleanupStack::PopAndDestroy(store);

			// Check that the file exists. If it doesn't then complete with an error.

			if (!iCurrentEntry.Entry().Complete())

					{

					iStatus = KImcmHTMLPartNotPopulated;

					}

				iResolved = ETrue;	//need to constract the uriresolver entry.

				return ETrue;

				}

			}

		}

	return EFalse;

	}

void CImMhtmlUriResolver::DoComplete(TInt& aStatus)

	{

	if (EImFindingFirstUri == iState)

		{

		if ((iStatus == KErrNone) || (iStatus == KImcmHTMLPartNotPopulated))

			{

			if(iFileNameOnly)	

				{

				iMhtmlFirstPageFinder->Result(iFileName, iLinkedEntryId);			

				}

			else

				{

				iMhtmlFirstPageFinder->Result(iFile,iLinkedEntryId);

				}

			iResolved = ETrue;

			}

		}

	else if (EImFindingFile == iState)

		{

		if ((iMhtmlFileFinder->MatchFound()) || (iStatus == KImcmHTMLPartNotPopulated))

			{

			if(iFileNameOnly)	

				{

				iMhtmlFileFinder->Result(iFileName, iLinkedEntryId);					

				}

			else

				{

				iMhtmlFileFinder->Result(iFile,iLinkedEntryId);

				}

			iResolved = ETrue;

			}

		}

	if ((!iResolved) && (aStatus != KImcmHTMLPartNotPopulated))

		{

		aStatus = KErrNotFound;

		}

	}

void CImMhtmlUriResolver::DoCancel()

	{

	switch (iState)

		{

		case EImFindingFile:

			iMhtmlFileFinder->Cancel();

			break;

		case EImFindingFirstUri:

			iMhtmlFirstPageFinder->Cancel();

			break;

		default:

			break;

		}

	CMsgActive::DoCancel();

	}

CImMhtmlUriResolver::CImMhtmlUriResolver(CMsvEntry& aEntry) :  CMsgActive(EPriorityStandard), iCurrentEntry(aEntry)

	{

	}

HBufC* CImMhtmlUriResolver::GetContentLocationL(TMsvId aEntryId)

	{

// Get the Content-location value from the mime header of the specified entry.

	iCurrentEntry.SetEntryL(aEntryId);

	HBufC* result = 0;

	if(iCurrentEntry.HasStoreL())

		{

		CMsvStore* entryStore = iCurrentEntry.ReadStoreL();

		CleanupStack::PushL(entryStore);

		if (entryStore->IsPresentL(KUidMsgFileMimeHeader))

			{

			CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();

			mimeHeader->RestoreL(*entryStore);

			TPtrC16 contentLocationPtr = mimeHeader->ContentLocation();

			result = HBufC::NewL(contentLocationPtr.Length());

			(*result) = contentLocationPtr;

			CleanupStack::PopAndDestroy(); // mimeHeader

			}

		CleanupStack::PopAndDestroy(); // entryStore

		}

	return result;

	}

CImMhtmlChildEntrySearcher* CImMhtmlChildEntrySearcher::NewL(CMsvEntry& aEntry, RPointerArray<CImCacheUriEntry>& aUriCacheUriArray)

	{

	CImMhtmlChildEntrySearcher* self = new (ELeave) CImMhtmlChildEntrySearcher(aEntry, aUriCacheUriArray);

	CActiveScheduler::Add(self);

	return self;

	}

void CImMhtmlChildEntrySearcher::StartL(TMsvId aEntry, TDesC& aUri, TRequestStatus& aStatus)

	{

	delete iUri;

	iUri = 0;

	iUri = HBufC::NewL(aUri.Length());

	(*iUri) = aUri;

	delete iChildEntries;

	iChildEntries = 0;

	iEntry.SetEntryL(aEntry);

	iChildEntries = iEntry.ChildrenL();

 	TInt index = iChildEntries->Count();

 	while (index--)

 		{

 		if (iEntry.ChildDataL((*iChildEntries)[index]).iType == KUidMsvFolderEntry)

 			iChildEntries->Delete(index);

 		}

	iChildEntryIndex = 0;

	iFound = EFalse;

	if (iChildEntries->Count() != 0)

		{

		CheckCurrentEntryL();

		Queue(aStatus);

		}

	else

		{

		Queue(aStatus);

		iStatus=KRequestPending;

		SetActive();

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		}

	}

CImMhtmlChildEntrySearcher::~CImMhtmlChildEntrySearcher()

	{

	delete iUri;

	delete iChildEntries;

	}

TBool CImMhtmlChildEntrySearcher::SearchResult(TMsvId& aSearchResultEntry)

	{

	if (iFound)

		{

		aSearchResultEntry = (*iChildEntries)[iChildEntryIndex];

		}

	return iFound;

	}

void CImMhtmlChildEntrySearcher::DoRunL()

	{

	if (!iFound)

		{

		iChildEntryIndex++;

		if (iChildEntryIndex < iChildEntries->Count())

			{

			CheckCurrentEntryL();

			}

		}

	}

void CImMhtmlChildEntrySearcher::DoComplete(TInt& )

	{

	}

/** 

Search for a TMsvId entry in cache. If found there is no need to open 

store to get content-location, content-id of that entry because cache contains that information

@return index of the cache if cache contains URI else 0

*/

TInt CImMhtmlChildEntrySearcher::CheckCacheForEntryId(TMsvId aId)

{

	TInt count = iUriCacheArray.Count();

	if(count)

		{

		CImCacheUriEntry* cacheEntry = NULL;

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

			{

			cacheEntry = iUriCacheArray[i];

			if(cacheEntry->GetUriEntry() == aId)

			return i;

			}

		}

	return KErrNotFound;

}

void CImMhtmlChildEntrySearcher::CheckCurrentEntryL()

//Compares the search URI with the content-location and content-id fields of each child entry in cache if not found then

// compares the search URI with the content-location and content-id fields of each child entry from store.

// It sets iFound if either content field in the current entry matches the URI.

	{

	TInt index = CheckCacheForEntryId((*iChildEntries)[iChildEntryIndex]);

	if( index != KErrNotFound )

		{

		CImCacheUriEntry* uriEntry = iUriCacheArray[index];

		iFound = CheckContentDetailsL(uriEntry->GetContentLocation()->Des(),uriEntry->GetContentId()->Des());

		}

	else

		{

		iEntry.SetEntryL((*iChildEntries)[iChildEntryIndex]);

		if (iEntry.HasStoreL() && (iEntry.Entry().iType != KUidMsvFolderEntry))

			{

			CMsvStore* entryStore = iEntry.ReadStoreL();

			CleanupStack::PushL(entryStore);

			// Get the content-location and content-id values for the current entry.

			if (entryStore->IsPresentL(KUidMsgFileMimeHeader))

				{

				CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();

				mimeHeader->RestoreL(*entryStore);

				TPtrC16 contentLocationPtr = mimeHeader->ContentLocation();

				TPtrC8 contentIdPtr = mimeHeader->ContentID();

				// Copy the 8 bit contentId string into a 16 bit wide descriptor.

				TInt contentIdLength = contentIdPtr.Length();

				HBufC* contentId = HBufC::NewL(contentIdLength);

				CleanupStack::PushL(contentId);

				TInt contentIdCopyCounter = 0;

				TPtr copyOfContentId = contentId->Des();

				for (contentIdCopyCounter = 0; contentIdCopyCounter < contentIdLength; contentIdCopyCounter++)

					{

					copyOfContentId.Append(contentIdPtr[contentIdCopyCounter]);

					}

				// Compare the content-location and content-id values to the search URI string.