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