// Copyright (c) 1996-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:
// f32\sfile\sf_cache.cpp
// 
//

#include <e32std.h>
#include <e32std_private.h>
#include "sf_std.h"
#include <e32uid.h>
#include <e32wins.h>
#include <f32file.h>
#include "sf_cache.h"

const TInt KMaxCachedDirectories=6;

TInt RefreshDriveInfo();
void DestroyCachedDirectories(TPathListRecord* aPathRec);
void DestroyCachedDirectory(TDriveNumber aDrive, TDirectoryCacheHeader* aDirCache);
void DestroyCachedDirectory(TDriveNumber aDrive, TPathListRecord* aPathRec);

const TInt KCacheHeapGranularity=0x0800; // Allocate heap in 2K chunks


TBool gInitCacheCheckDrivesAndAddNotifications = EFalse;
TBool gCacheCheckDrives = ETrue;


// Cache per drive
TDriveCacheHeader* gDriveFileNamesCache[KMaxDrives];

TPathListRecord* TPathListRecord::First;
TPathListRecord* TPathListRecord::LastStatic;


#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
void dumpCache()
	{
	TDriveNumber drive;
	for (drive=EDriveA; drive<=EDriveZ; ((TInt&)drive)++)
		{
		TDriveCacheHeader* pDH = gDriveFileNamesCache[drive];
		RDebug::Printf("Dumping Drive %d", drive);
		if (!pDH)
			{
			RDebug::Printf("Drive %d not cached",drive);
			continue;
			}
		TDirectoryCacheHeader* p = pDH->iDirectoryList;
		for (; p; p=p->iNext)
			{
			RDebug::Printf("    Dumping directory %S", p->iPath->PathName());
			TFileCacheRecord** pIndexes = p->iCache;
			TInt j;
			for(j=0; j<p->iRecordCount; j++)
				{
				TFileCacheRecord& f = *pIndexes[j];
				TBuf8<20> en = _S8("Entry ");
				en.AppendNum(j);
				f.Dump((const char*)en.Ptr());
				}
			}
		}
	}
#endif

CCacheNotifyDirChange::CCacheNotifyDirChange(TDriveNumber aDrive, TDirectoryCacheHeader& aDirHead)
	: CActive(EPriorityHigh), iDrive(aDrive), iDirHead(&aDirHead)
	{}

CCacheNotifyDirChange::~CCacheNotifyDirChange()
	{
	__IF_DEBUG(Printf("~CCacheNotifyDirChange"));
	Cancel();
	}

void CCacheNotifyDirChange::DoCancel()
	{
	__IF_DEBUG(Printf("DoCancel"));
	gTheLoaderFs.NotifyChangeCancel(iStatus);
	}
	
void CCacheNotifyDirChange::RunL()
	{
	__IF_DEBUG(Printf("Pop!! for drive %d path %S (%d)", iDrive, iDirHead->iPath->PathName(), iStatus.Int()));

	// unlink directory & delete it
	DestroyCachedDirectory(iDrive, iDirHead);
	gCacheCheckDrives = ETrue;
	}

TInt CCacheNotifyDirChange::RegisterNotification(TPathListRecord* aPathRec, TNotifyType aType)
//
// Notification that a card has been mounted/removed
//
	{
	TDriveUnit drive(iDrive);
	TFileName pathName(drive.Name());
	pathName.Append('\\');
	TInt dl = pathName.Length();
	const TText* ppp = pathName.Ptr() + dl;
	const TDesC8& p8 = *aPathRec->PathName();
	TInt p8l = p8.Length();
	pathName.SetLength(dl + p8l);
	TPtr pp((TText*)ppp, 0, KMaxFileName - dl);
	pp.Copy(p8);
	if (pathName[dl + p8l -1] != '\\')
		pathName.Append('\\');

	__IF_DEBUG(Printf("RegisterNotification for drive %d path %S", iDrive, &p8));
	__IF_DEBUG(Print(_L("register notification for %S"), &pathName));
	gTheLoaderFs.NotifyChange(aType, iStatus, pathName);
	SetActive();
	__LDRTRACE({	\
		if (iStatus != KRequestPending)	\
			RDebug::Printf("Notifier Immediate Complete %d", iStatus.Int()); \
		});
	return KErrNone;
	}	

TInt SetupNotify(TDriveNumber aDrive, TDirectoryCacheHeader& aDirHead)
	{
	if (aDirHead.iNotify != NULL)
		{
		__IF_DEBUG(Printf("SetupNotify!! notification already registered on drive %d path %S", aDrive, aDirHead.iPath->PathName()));
		return KErrNone;
		}

	__IF_DEBUG(Printf("SetupNotify!! on drive %d path %S", aDrive, aDirHead.iPath->PathName()));
	CCacheNotifyDirChange* pNotifier = new CCacheNotifyDirChange(aDrive, aDirHead);
	if (!pNotifier)
		return KErrNoMemory;
	aDirHead.iNotify = pNotifier;
	CActiveSchedulerLoader::Add(pNotifier);
	return pNotifier->RegisterNotification(aDirHead.iPath, ENotifyFile);
	}

TInt AddNotifications()
	{
	TDriveNumber drive;
	for (drive=EDriveA; drive<EDriveZ; ((TInt&)drive)++)	// Z always read-only so no notifiers required
		{
		TDriveCacheHeader* pDH = gDriveFileNamesCache[drive];
		if (!pDH)
			continue;

		__IF_DEBUG(Printf("AddNotifications on drive %d att=0x%08x", drive, pDH->iDriveAtt));

		TDirectoryCacheHeader* p = pDH->iDirectoryList;
		for (; p; p=p->iNext)
			{
			TInt r = SetupNotify(drive, *p);
			if (r != KErrNone)
				{
				DestroyCachedDirectory(drive, p);
				return r;
				}
			}
		}
	gCacheCheckDrives = EFalse;
	return KErrNone;
	}

//=============================== TFileCacheRecord ==================================
//
TInt TFileCacheRecord::Order(const TFileCacheRecord& aL, const TFileCacheRecord& aR)
	{
	return aL.Name().CompareF(aR.Name());
	}

//=============================== TPathListRecord ==================================
//
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
void dumpPathList()
	{
	RDebug::Printf("Dumping Pathlist");
	TPathListRecord* p = TPathListRecord::First;
	TInt count=0;
	for (; p; p=p->iNext, ++count)
		RDebug::Printf("Pathlist pos %d %S",count,p->PathName());
	}
#endif

_LIT8(KDirSystemPrograms, "System\\Programs");
_LIT8(KDirSystemLibs, "System\\Libs");
_LIT8(KDirSystemBin, "System\\Bin");
_LIT8(KDirSysBin, "Sys\\Bin");

TInt TPathListRecord::Init()
	{
	if (!AddToPathList(KDirSysBin, ETrue))
		return KErrNoMemory;
	if(!PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))
		{
		if (!AddToPathList(KDirSystemPrograms, ETrue))
			return KErrNoMemory;
		if (!AddToPathList(KDirSystemLibs, ETrue))
			return KErrNoMemory;
		if (!AddToPathList(KDirSystemBin, ETrue))
			return KErrNoMemory;
		}
	return KErrNone;
	}

void TPathListRecord::MoveToHead()
	{
	if (iKeep || this == LastStatic->iNext)
		return;
	TPathListRecord* p = First;
	// the record is always in the list
	for (; p && p->iNext!=this; p=p->iNext) {}
    __ASSERT_DEBUG(p, User::Invariant());
	p->iNext = iNext;
	iNext = LastStatic->iNext;
	LastStatic->iNext = this;
	}

TPathListRecord* TPathListRecord::FindPathNameInList(const TDesC8& aPath)
	{
	__IF_DEBUG(Printf("TPathListRecord::FindPathNameInList %S",&aPath));
	TPathListRecord* p = DoFindPathNameInList(aPath);
	if (!p)
		p = AddToPathList(aPath, EFalse);
	return p;
	}

TPathListRecord* TPathListRecord::DoFindPathNameInList(const TDesC8& aPath)
	{
	// Accesses pathname list to retrieve pathname record
	TPathListRecord* p = First;
	for (; p; p=p->iNext)
		{
		if (p->PathName()->CompareF(aPath) == 0)
			{
			p->MoveToHead();
			return p;
			}
		}
	return NULL;
	}

TPathListRecord* TPathListRecord::AddToPathList(const TDesC8& aPath, TBool aKeep)
	{
	__LDRTRACE(dumpPathList());
	__IF_DEBUG(Printf("Pathlist adding path %S keep %d",&aPath,aKeep));

	TPathListRecord* n = TPathListRecord::New(aPath, aKeep);
	if (!n)
		return NULL;
	TPathListRecord* p = First;
	TPathListRecord* q = NULL;
	TInt count = 0;
	for (; p && ++count<KMaxCachedDirectories; q=p, p=p->iNext) {}
	if (p)
		{
		// need to kill off entry pointed to by p
		__IF_DEBUG(Printf("In AddToPathList killing %S", p->PathName()));
		__ASSERT_ALWAYS(!aKeep, User::Invariant());
		q->iNext = NULL;
		DestroyCachedDirectories(p);
		delete p;
		}

	if (aKeep)
		{
		// add to front of list
		n->iNext = First;
		First = n;
		if (!LastStatic)
			LastStatic = n;
		}
	else
		{
		// add new entry to front of dynamic list
		n->iNext = LastStatic->iNext;
		LastStatic->iNext = n;
		}

	// Refresh cache now we've added a new path
	gCacheCheckDrives = ETrue;

	__LDRTRACE(dumpPathList());
	return n;
	}

TPathListRecord* TPathListRecord::New(const TDesC8& aPath, TBool aKeep)
	{
	TInt l = aPath.Length();
	TInt size = sizeof(TPathListRecord) + Align4(l) + sizeof(TDesC8);
	TPathListRecord* p = (TPathListRecord*)User::Alloc(size);
	if (p)
		{
		p->iNext = NULL;
		p->iKeep = aKeep;
		TInt* pb = (TInt*)(p+1);
		*pb = l;
		memcpy(pb+1, aPath.Ptr(), l);
		}
	return p;
	}

void DestroyCachedDirectory(TDriveNumber aDrive, TPathListRecord* aPathRec)
	{
	__IF_DEBUG(Printf("DestroyCachedDirectory drive=%d path=%S",aDrive,aPathRec->PathName()));
	TDriveCacheHeader* pDH = gDriveFileNamesCache[aDrive];
	TDirectoryCacheHeader* p = pDH->iDirectoryList;
	TDirectoryCacheHeader* q = 0;
	for (; p && p->iPath!=aPathRec; q=p, p=p->iNext) {}
	if (p)
		{
		__IF_DEBUG(Printf("    unlinking directory %S",p->iPath->PathName()));
		if (q)
			q->iNext = p->iNext;
		else
			pDH->iDirectoryList = p->iNext;
		__IF_DEBUG(Printf("    deleting directory %S",p->iPath->PathName()));
		delete p;
		}
	}

void DestroyCachedDirectory(TDriveNumber aDrive, TDirectoryCacheHeader* aDirCache)
	{
	// First see if it contained in our list
	__IF_DEBUG(Printf("DestroyCachedDirectory drive=%d path=%S", aDrive, aDirCache->iPath->PathName()));

	TDriveCacheHeader* pDH = gDriveFileNamesCache[aDrive];
	TDirectoryCacheHeader* p = pDH->iDirectoryList;
	TDirectoryCacheHeader* q = 0;
	for (; p && p!=aDirCache; q=p, p=p->iNext) {}
	if (p)
		{
		__IF_DEBUG(Printf("    unlinking directory %S",p->iPath->PathName()));
		if (q)
			q->iNext = p->iNext;
		else
			pDH->iDirectoryList = p->iNext;
		}
	__IF_DEBUG(Printf("    deleting directory %S", aDirCache->iPath->PathName()));
	delete aDirCache;
	}

void DestroyCachedDirectories(TPathListRecord* aPathRec)
	{
	__IF_DEBUG(Printf("DestroyCachedDirectories %S",aPathRec->PathName()));
	TDriveNumber drive;
	for (drive=EDriveA; drive<=EDriveZ; ((TInt&)drive)++)
		{
		TDriveCacheHeader* pDH = gDriveFileNamesCache[drive];
		if (pDH)
			{
			__IF_DEBUG(Printf("DestroyCachedDirectories drive=%d driveatt=0x%08x",drive,pDH->iDriveAtt));
			DestroyCachedDirectory(drive, aPathRec);
			}
		}
	}

//=============================== TCacheHeapList ==================================
//
TCacheHeapList::TCacheHeapList(TInt aSize)
	:	iAllocated(Align4(sizeof(TCacheHeapList))),
		iSize(aSize)
	{}

TAny* TCacheHeapList::Allocate(TInt aBytes)
	{
	__IF_DEBUG(Printf("TCacheHeapList::Allocate used=%d request=%d",iAllocated,aBytes));
	TInt req = Align4(aBytes);
	if (iAllocated+req > iSize)
		return NULL;
	TAny* p = PtrAdd(this, iAllocated);
	iAllocated+=req;
	return p;
	}


//=============================== TDriveCacheHeader==================================
//
TDriveCacheHeader::TDriveCacheHeader()
	: iDirectoryList(NULL)
	{}

TDriveCacheHeader::~TDriveCacheHeader()
	{
	__IF_DEBUG(Printf("~TDriveCacheHeader"));
	while (iDirectoryList)
		{
		TDirectoryCacheHeader* p = iDirectoryList;
		iDirectoryList = p->iNext;
		__IF_DEBUG(Printf("    deleting directory %S",p->iPath->PathName()));
		delete p;
		}
	}

TDirectoryCacheHeader* TDriveCacheHeader::FindDirCache(TPathListRecord* aPath)
	{
	TDirectoryCacheHeader* p = iDirectoryList;
	for (; p && p->iPath!=aPath; p=p->iNext) {}
	return p;
	}

TInt TDriveCacheHeader::GetDirCache(TDirectoryCacheHeader*& aCache, TPathListRecord* aPath, const TDesC8& aDriveAndPath)
	{
	__IF_DEBUG(Printf(">GetDirCache %S", &aDriveAndPath));
	aCache = FindDirCache(aPath);
	if (aCache)
		{
		__IF_DEBUG(Printf("<GetDirCache already exists %08x", aCache));
		return KErrNone;
		}
	TDirectoryCacheHeader* p = new TDirectoryCacheHeader(aPath);
	if (!p)
		return KErrNoMemory;
	TInt r = p->PopulateFromDrive(aDriveAndPath);
	__IF_DEBUG(Printf("PopulateFromDrive ret %d", r));
	if (r != KErrNoMemory && r != KErrLocked && iDriveNumber != EDriveZ)
		r = SetupNotify((TDriveNumber)iDriveNumber, *p);
	if (r == KErrNoMemory || r == KErrLocked)
		{
		delete p;
		return r;
		}
	// Ignore other errors and keep created entry anyway, so for things like 'path not found'
	// we have an empty directory cache which will get updated (via notification) if it get created.
	// This empty entry also allows for a quicker check the second time around.

	p->iNext = iDirectoryList;
	iDirectoryList = p;
	__IF_DEBUG(Printf("<GetDirCache new %08x", p));
	aCache = p;
	return KErrNone;
	}

//============================= TDirectoryCacheHeader================================
//
TDirectoryCacheHeader::TDirectoryCacheHeader(TPathListRecord* aPath)
	:	iFirstHeapBlock(NULL), iPath(aPath), iRecordCount(0), iCache(NULL),
		iNotPresent(ETrue), iNotify(NULL)
	{}

TDirectoryCacheHeader::~TDirectoryCacheHeader()
	{
	__IF_DEBUG(Printf("~TDirectoryCacheHeader %S",iPath->PathName()));
	User::Free(iCache);
	delete iNotify;

	while (iFirstHeapBlock)
		{
		TCacheHeapList* p = iFirstHeapBlock;
		iFirstHeapBlock = p->iNext;
		User::Free(p);
		}
	}

TInt TDirectoryCacheHeader::GetMoreHeap()
	{
	TAny* mem = User::Alloc(KCacheHeapGranularity);
	if (!mem)
		return KErrNoMemory;
	TCacheHeapList* n = new (mem) TCacheHeapList(KCacheHeapGranularity);
	n->iNext = iFirstHeapBlock;
	iFirstHeapBlock = n;
	return KErrNone;
	}

TAny* TDirectoryCacheHeader::Allocate(const TInt aBytes)
	{
	TAny* p = iFirstHeapBlock ? iFirstHeapBlock->Allocate(aBytes) : NULL;
	if (!p)
		{
		if (GetMoreHeap()!=KErrNone)
			return NULL;
		p = iFirstHeapBlock->Allocate(aBytes);
		}
	return p;
	}

TFileCacheRecord* TDirectoryCacheHeader::NewRecord(const TDesC8& aName, TUint32 aAttr, TUint32 aVer, const TEntry& aEntry)
	{
	TInt l = aName.Length();
	TInt minsize = l + sizeof(TFileCacheRecord);
	TInt extra = aEntry.iSize >> 12;		// allow for 8 exports per 4K of file
	if(extra>128)
		extra = 128;
	TInt size = (minsize + extra + 15) &~ 15;

	TFileCacheRecord* p = (TFileCacheRecord*)Allocate(size);
	if (p)
		{
		memclr(p, sizeof(TFileCacheRecord));
		p->iAttr = aAttr;
		p->iModuleVersion = aVer;
		p->iExportDirCount = size - minsize;
		p->iNameLength = l;
		p->iExportDescType = (aEntry.iAtt & KEntryAttXIP) ? KImageHdr_ExpD_Xip : KImageHdr_ExpD_NoHoles;	// for now
		p->iCacheStatus = 0;
		memcpy(p+1, aName.Ptr(), l);
		}
	return p;
	}

TFileCacheRecord* TDirectoryCacheHeader::NewRecord(const TFileCacheRecord& aRecord, TInt aEDS)
	{
	TInt l = aRecord.Name().Length();
	TInt minsize = l + sizeof(TFileCacheRecord);
	TInt extra = aEDS + 2;
	TInt size = (minsize + extra + 15) &~ 15;

	TFileCacheRecord* p = (TFileCacheRecord*)Allocate(size);
	if (p)
		{
		memcpy(p, &aRecord, minsize);
		memclr((TUint8*)p + minsize, size - minsize);
		}
	return p;
	}

TInt TDirectoryCacheHeader::PopulateFromDrive(const TDesC8& aPathName)
	{
	// Wildcard searches through a named directory on a drive.
	// Creates and fills records to newly populate the drive cache..

	// only want gen-u-ine files
	RDir d;
	TFileName dp;
	dp.Copy(aPathName);
	__IF_DEBUG(Print(_L("Opening Directory %S"), &dp));

	iNotPresent=ETrue;
	TInt r=d.Open(gTheLoaderFs, dp, KEntryAttMatchExclude|KEntryAttDir|KEntryAttVolume);
	__IF_DEBUG(Printf("Returns %d", r));
	if (r != KErrNone)
		{
		return r;
		}
	
	TEntryArray array;
	TInt sizeofIndexArray=0;
	TFileCacheRecord** pIndexes=NULL;
	TInt currentIndex=0;
	do	{
		r=d.Read(array);
		if (r==KErrNone || r==KErrEof)
			{
			TInt count=array.Count();
			if (count==0)
				break;
			TInt newSize=currentIndex+count;
			// Round alloc granularity up to the size of the cache cells, to avoid heap fragmentation when
			// indexing large dirs (z:\sys\bin) - interference effect is minimised by allocating in larger blocks and by
			// ensuring the freed memory can be reused for cache cells. See INC065949 for original defect.
			const TInt arrayGranularity = KCacheHeapGranularity + RHeap::EAllocCellSize;
			sizeofIndexArray = (sizeof(TFileCacheRecord*)*newSize + arrayGranularity - 1) / arrayGranularity * arrayGranularity;
			TFileCacheRecord** p=(TFileCacheRecord**)User::ReAlloc(pIndexes,sizeofIndexArray);
			if (!p)
				{
				r=KErrNoMemory;
				break;
				}
			pIndexes=p;
			TInt i=0;
			while (i<count)
				{
				const TEntry& e = array[i++];
				TInt nl = e.iName.Length();
				if (nl > KMaxKernelName)
					{
					__IF_DEBUG(Printf("Name length %d - too long", nl));
					continue;
					}
				TBuf8<KMaxKernelName> n8;
				r = CheckedCollapse(n8, e.iName);
				if (r != KErrNone)
					{
					__IF_DEBUG(Printf("Non-ASCII name"));
					continue;
					}
				TFileNameInfo fni;
				r = fni.Set(n8, 0);
				if (r != KErrNone)
					{
					__IF_DEBUG(Printf("Bad name"));
					continue;
					}
				TBuf8<KMaxKernelName> rootname;
				fni.GetName(rootname, TFileNameInfo::EIncludeBaseExt);
				TUint32 attr = fni.VerLen() ? ECodeSegAttExpVer : 0;
				TFileCacheRecord* pR = NewRecord(rootname, attr, fni.Version(), e);
				if (!pR)
					{
					r=KErrNoMemory;
					break;
					}
				pIndexes[currentIndex] = pR;
				currentIndex++;
				}
			}
		} while (r==KErrNone);
	d.Close();
	if(r==KErrNoMemory)
		return r;

	iNotPresent = EFalse;
	iCache = (TFileCacheRecord**)User::ReAlloc(pIndexes,sizeof(TFileCacheRecord*)*currentIndex);
	iRecordCount = currentIndex;
	if (currentIndex>1)
		{
		// don't sort an empty list, or a list with only 1 element
		RPointerArray<TFileCacheRecord> rarray(iCache, iRecordCount);
		rarray.Sort(&TFileCacheRecord::Order);
		}

	__LDRTRACE(	{	\
	RDebug::Printf("RArray sorted");		\
	TInt i;									\
	for (i=0; i<iRecordCount; i++)			\
		{									\
		TFileCacheRecord* f = iCache[i];	\
		const TDesC8& name = f->Name();		\
		RDebug::Printf("%d: Entry=%S att %08x ver %08x", i, &name, f->iAttr, f->iModuleVersion);	\
		}									\
		});
	return KErrNone;
	}

TInt RefreshDriveInfo()
	{
	// Find out what drives are present
	__IF_DEBUG(Printf(">RefreshDriveInfo"));
	TDriveList list;
	TInt r = gTheLoaderFs.DriveList(list);
	if (r!=KErrNone)
		{
		return r;
		}
	TDriveInfo d;
	TDriveNumber drive;
	for (drive=EDriveA; drive<=EDriveZ; ((TInt&)drive)++)
		{
		TInt att = list[drive];
		if (att)
			{
			r = gTheLoaderFs.Drive(d,drive);
			if (r != KErrNone)
				continue;
			if ((d.iDriveAtt & KDriveAttRemote) || (d.iDriveAtt & KDriveAttSubsted))
	            continue; //Don't cache remote or substituted drives
			if (gDriveFileNamesCache[drive] == NULL)
				{
				__IF_DEBUG(Printf("In RefreshDriveInfo adding drive %d, drive= 0x%08x media=0x%08x", drive, d.iDriveAtt, d.iMediaAtt));
				TDriveCacheHeader* pDH = new TDriveCacheHeader;
				if (!pDH)
					return KErrNoMemory;
				gDriveFileNamesCache[drive] = pDH;
				pDH->iDriveAtt = d.iDriveAtt;
				pDH->iDriveNumber = drive;
				}
			continue;
			}
		TDriveCacheHeader* pDH = gDriveFileNamesCache[drive];
		delete pDH;
		gDriveFileNamesCache[drive] = NULL;
		}
	__IF_DEBUG(Printf("<RefreshDriveInfo"));
	return KErrNone;
	}

//
void InitializeFileNameCache()
	{
	__IF_DEBUG(Printf("InitializeFileNameCache"));
	gInitCacheCheckDrivesAndAddNotifications = EFalse;
	gCacheCheckDrives = ETrue;
	__ASSERT_ALWAYS(TPathListRecord::Init()==KErrNone, User::Invariant());
	}

TInt CheckLoaderCacheInit()
	{
	TInt r=KErrNone;
	if(RefreshZDriveCache)
		{
		// force z: drive cache to be refreshed
		__IF_DEBUG(Print(_L("Deleting z: drive cache\r\n")));
		TDriveCacheHeader* pDH=gDriveFileNamesCache[EDriveZ];
		delete pDH;
		gDriveFileNamesCache[EDriveZ]=NULL;
		gCacheCheckDrives=ETrue;
		RefreshZDriveCache=EFalse;
		}
	if (gCacheCheckDrives)
		{
		__IF_DEBUG(Printf("Refreshing cache"));
		r = RefreshDriveInfo();						// refreshing is a 'once-only' operation after setting
		gCacheCheckDrives = EFalse;					// gCacheCheckDrives so as to prevent excessive refreshing
		}
	if (!gInitCacheCheckDrivesAndAddNotifications && StartupInitCompleted)
		{
		__IF_DEBUG(Printf("Refreshing cache and adding notifications after FS initialisation"));
		r = RefreshDriveInfo();						// this is to provide an extra refresh to explicitly find
		r = AddNotifications();						// all drives set up during FS initialisation
		gInitCacheCheckDrivesAndAddNotifications = ETrue;	
		}
	return r;
	}

TFileCacheRecordSearch::TFileCacheRecordSearch(const TDesC8& aSearchName)
	{
	iNameLength = aSearchName.Length();
	if(iNameLength>sizeof(iSearchName))
		User::Invariant();
	memcpy(iSearchName, aSearchName.Ptr(), iNameLength);
	}

TInt RImageFinder::SearchSingleDir()
	{
	__IF_DEBUG(Printf("SearchSingleDir %S drive %d", &iCurrentPath, iCurrentDrive));

	TDriveCacheHeader* pDH = gDriveFileNamesCache[iCurrentDrive];
	if (!pDH)
		{
		__IF_DEBUG(Printf("No such drive"));
		return KErrNone;
		}

	TInt pl = iCurrentPath.Length();
	TInt start = 0;
	TInt len = pl;
	if (pl)
		{
		if (iCurrentPath[0] == '\\')
			start = 1, --len;
		if (len>0 && iCurrentPath[start + len - 1] == '\\')
			--len;
		}
	TPtrC8 path(iCurrentPath.Mid(start, len));
	__IF_DEBUG(Printf("Normalised path %S", &path));
	TChar c;
	RFs::DriveToChar(iCurrentDrive, c);
	TBuf8<KMaxFileName> drive_and_path = _S8("?:\\");
	drive_and_path[0] = (TText8)c;
	drive_and_path.Append(path);
	if (drive_and_path[drive_and_path.Length()-1] != '\\')
		drive_and_path.Append('\\');

	TPathListRecord* prec = TPathListRecord::FindPathNameInList(path);
	if (!prec)
		return KErrNoMemory;
	TDirectoryCacheHeader* dch = NULL;
	TInt r = pDH->GetDirCache(dch, prec, drive_and_path);
	if (r != KErrNone || dch->iNotPresent || dch->iRecordCount==0)
		{
		return r;
		}

	// set up to search for root name
	__IF_DEBUG(Printf("Search directory for %S", &iRootName));
	TFileCacheRecordSearch search(iRootName);
	__LDRTRACE({const TDesC8& sr = search.Name(); RDebug::Printf("Search record %S", &sr);});
	RPointerArray<TFileCacheRecord> rarray(dch->iCache, dch->iRecordCount);
	TInt first = rarray.SpecificFindInOrder(&search, &TFileCacheRecord::Order, EArrayFindMode_First);
	TInt last = rarray.SpecificFindInOrder(&search, &TFileCacheRecord::Order, EArrayFindMode_Last);
	__IF_DEBUG(Printf("First %d Last %d", first, last));
	TInt ix;
	for (ix = first; ix < last; ++ix)
		{
		TFileCacheRecord* f = dch->iCache[ix];
		RImageInfo img_info;
		r = KErrNone;
		if (!f->ExtrasValid())
			{
			r = f->GetImageInfo(img_info, drive_and_path, dch, ix);
			if (r == KErrNoMemory)
				return r;
			f = dch->iCache[ix];	// may have been moved
			}
		if (r==KErrNone)
			{
			img_info = *f;
			r = Try(img_info, f->Name(), drive_and_path);
			if (r == KErrNoMemory)
				{
				img_info.Close();
				return r;
				}
			f->iCacheStatus = img_info.iCacheStatus;
			}
		else
			RecordCorruptFile();
		img_info.Close();
		if (r==KErrCompletion)
			break;
		}
	return KErrNone;
	}

// Populate the 'extras' in the cache record by reading the file header
// aPathName must be of the form ?:\dir\...\dir\ so that a fully qualified file name is obtained by
// appending the file name.
TInt TFileCacheRecord::GetImageInfo(RImageInfo& aInfo, const TDesC8& aPathName, TDirectoryCacheHeader* aDirHead, TInt aIndex)
	{
	const TDesC8& rootname = Name();
	TBuf8<KMaxFileName> fn = aPathName;
	TFileNameInfo fni;
	fni.Set(rootname, 0);
	fni.iVersion = iModuleVersion;
	TUint flags = (iAttr & ECodeSegAttExpVer) ? TFileNameInfo::EForceVer : 0;
	fni.GetName(fn, TFileNameInfo::EIncludeBaseExt | flags);
	__IF_DEBUG(Printf("Opening file %S", &fn));
	TInt r = OpenFile8(aInfo.iFile, fn);
	__IF_DEBUG(Printf("Open file returns %d", r));
	if (r != KErrNone)
		return r;
	TInt address = 0;
	r = aInfo.iFile.Seek(ESeekAddress, address);
	if (r!=KErrNotSupported)
		{
		__IF_DEBUG(Printf("ROM file at %08x", address));
		TUint att;
		r = aInfo.iFile.Att(att);
		if (r!=KErrNone)
			{
			aInfo.Close();
			return r;
			}
		if (att & KEntryAttXIP)
			{
			const TRomImageHeader& rih = *(const TRomImageHeader*)address;
			__IF_DEBUG(Printf("XIP file"));
			SetXIP(&rih);
			if ((iAttr & ECodeSegAttExpVer) && iModuleVersion != rih.iModuleVersion)
				{
				// version in file name does not match version in header
				aInfo.Close();
				return KErrBadName;
				}
			iModuleVersion = rih.iModuleVersion;
			iS = rih.iS;
			iExportDirCount = (TUint16)rih.iExportDirCount;
			iExportDescType = (TUint8)KImageHdr_ExpD_Xip;
			iAttr |= rih.iFlags & (KRomImageFlagFixedAddressExe|KRomImageABIMask);
			__LDRTRACE(Dump("Cached Info XIP"));
			return KErrNone;
			}
		}
	TFileCacheRecord* t = this;
	r = E32ImageHeader::New(aInfo.iHeader, aInfo.iFile);
	if (r != KErrNone)
		{
		aInfo.Close();
		__IF_DEBUG(Printf("E32ImageHeader::New returns %d", r));
		return r;
		}
	E32ImageHeader* h = aInfo.iHeader;
	if ((iAttr & ECodeSegAttExpVer) && iModuleVersion != h->iModuleVersion)
		{
		// version in file name does not match version in header
		aInfo.Close();
		return KErrBadName;
		}
	wordmove(iUid, &h->iUid1, sizeof(iUid));
	iModuleVersion = h->ModuleVersion();
	h->GetSecurityInfo(iS);
	iAttr |= (h->iFlags & ECodeSegAttFixed) | h->ABI();
	if(h->iFlags&KImageNmdExpData)
		iAttr |= ECodeSegAttNmdExpData;
	TUint avail = iExportDirCount;
	iExportDirCount = (TUint16)h->iExportDirCount;
	iExportDescType = KImageHdr_ExpD_NoHoles;

	// get export description...
	E32ImageHeaderV* v = (E32ImageHeaderV*)h;
	iExportDescType = v->iExportDescType;
	TUint eds = v->iExportDescSize;
	if (eds + 2 > avail)
		{
		// must reallocate this entry
		t = aDirHead->NewRecord(*this, eds);
		if (!t)
			{
			aInfo.Close();
			return KErrNoMemory;
			}
		aDirHead->iCache[aIndex] = t;
		}
	TUint8* xd = (TUint8*)t->ExportDescription();
	xd[0] = (TUint8)eds;
	xd[1] = (TUint8)(eds>>8);
	memcpy(xd+2, v->iExportDesc, eds);

	__LDRTRACE(t->Dump("Cached Info"));
	return KErrNone;
	}

RImageInfo& RImageInfo::operator=(const TFileCacheRecord& aRecord)
	{
	wordmove(this, &aRecord, sizeof(TImageInfo));
	if (aRecord.ExtrasValid())
		{
		if (aRecord.IsXIP())
			{
			iRomImageHeader = aRecord.RomImageHeader();
			wordmove(iUid, &iRomImageHeader->iUid1, sizeof(iUid));
			}
		else if (iExportDescType != KImageHdr_ExpD_NoHoles)
			{
			const TUint8* xd = (TUint8*)aRecord.ExportDescription();
			iExportDescSize = (TUint16)(xd[0] | (xd[1]<<8));
			iExportDesc = xd + 2;
			}
		}
	return *this;
	}


#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
extern void memory_dump(const TAny* a, TUint l);

void TFileCacheRecord::Dump(const char* aTitle)
	{
	RDebug::Printf(aTitle);
	TUint32 uid1 = iUid[0];
	TBool xip = (uid1 != (TUint32)KExecutableImageUidValue && uid1 != (TUint32)KDynamicLibraryUidValue);
	const TDesC8& name = Name();
	if (xip)
		{
		const TRomImageHeader* rih = RomImageHeader();
		RDebug::Printf("Name: %S Ver %08x Attr %08x", &name, rih->iModuleVersion, iAttr);
		RDebug::Printf("UIDS %08x %08x %08x SID %08x CAP %08x %08x", rih->iUid1, rih->iUid2, rih->iUid3,
										rih->iS.iSecureId, rih->iS.iCaps[1], rih->iS.iCaps[0]);
		RDebug::Printf("ExportDirCount %d ExportDescType %02x", rih->iExportDirCount, iExportDescType);
		}
	else
		{
		RDebug::Printf("Name: %S Ver %08x Attr %08x", &name, iModuleVersion, iAttr);
		RDebug::Printf("UIDS %08x %08x %08x SID %08x CAP %08x %08x", iUid[0], iUid[1], iUid[2],
										iS.iSecureId, iS.iCaps[1], iS.iCaps[0]);
		RDebug::Printf("ExportDirCount %d ExportDescType %02x", iExportDirCount, iExportDescType);
		if (iExportDescType != KImageHdr_ExpD_NoHoles)
			{
			const TUint8* xd = ExportDescription();
			TUint eds = (xd[1]<<8) | xd[0];
			RDebug::Printf("ExportDescSize %04x", eds);
			memory_dump(xd+2, eds);
			}
		}
	}
#endif