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

#include "cl_std.h"
#include "cl_scan.h"

const TInt KDirStackGranularity=8;

/** Replace long names in path and filename with their sohrter version (if exists). Optionally appends
filename to path name creating fully qualified file name.
@param aFs (connected) File system session
@param aCurrentPath  on input contains current full path name, 
upon return contains the shortest version (using either shor or long names) of the same path
@param aItem on input contains item with long name in the current path, 
upon return contains shorter name of either long or short name
@param aAppend if ETrue aItem will be appended to aCurrentPath before successful return
@return KErrNone if successful, otherwise one of the other system-wide error codes.
*/
TInt ShrinkNames(RFs& aFs, TFileName& aCurrentPath, TFileName& aItem, TBool aAppend)
	{
	TInt ret = KErrNone;
	TBuf<8+1+3> shortname;
	TFileName* current = NULL;
    TRAPD(r,current = new (ELeave) TFileName);
    if (r)
        return r;

    TInt pos = 0;
	TInt lastslash = KErrNotFound;
	TInt lastnewslash = KErrNotFound;
	while(ret == KErrNone && pos < aCurrentPath.Length())
		{
		if(aCurrentPath[pos] == KPathDelimiter)
			{
			if(lastslash != KErrNotFound)
				{
				ret = aFs.GetShortName(*current, shortname);
				if(ret == KErrNone && pos-lastslash > shortname.Length())
					{
					current->SetLength(lastnewslash);
					current->Append(shortname);
					}
				}
			lastslash = pos+1;
			lastnewslash = current->Length()+1;
			}
		current->Append(aCurrentPath[pos++]);
		}
	if(ret == KErrNone && current->Length() + aItem.Length() <= KMaxFileName)
		{
		aCurrentPath = *current;
		TInt lenBefore = aCurrentPath.Length();
		aCurrentPath.Append(aItem);
		ret = aFs.GetShortName(aCurrentPath, shortname);
		aCurrentPath.SetLength(lenBefore);

		if(ret == KErrNone && aItem.Length() > shortname.Length())
			{
			aItem = shortname;
			}
		}
	if(aAppend && ret == KErrNone && aCurrentPath.Length() + aItem.Length() <= KMaxFileName)
		{
		aCurrentPath.Append(aItem); 
		}
    delete current;
	return ret;
}
  
LOCAL_C TPtrC LeafDir(const TDesC& aPath)
//
// Returns the leaf directory of a path
//
	{

	TInt end=aPath.LocateReverse('\\');
	__ASSERT_DEBUG(end!=KErrNotFound,Panic(EDirListError));
	TPtrC ret(aPath.Ptr(),end);
	TInt start=ret.LocateReverse('\\');
	if (start==KErrNotFound)
		start=end-1;
	return ret.Right(end-start-1);
	}

CDirScan::CDirScan(RFs& aFs)
//
// Constructor
//
	: iFs(&aFs)
	{
	}




EXPORT_C CDirScan* CDirScan::NewLC(RFs& aFs)
/**
Constructs and allocates memory for a new CDirScan object, putting a pointer
to the object onto the cleanup stack.

@param aFs The file server session.

@return A pointer to the new directory scan object.
*/
	{
	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanNewLC, MODULEUID, aFs.Handle());

	CDirScan* scan=new(ELeave) CDirScan(aFs);
	CleanupStack::PushL(scan);
	scan->iStack=CDirStack::NewL();

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanNewLCReturn, MODULEUID, scan);
	return scan;
	}




EXPORT_C CDirScan* CDirScan::NewL(RFs& aFs)
/**
Constructs and allocates memory for a new CDirScan object.

@param aFs The file server session.

@return A pointer to the new directory scan object.
*/
	{
	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanNewL, MODULEUID, aFs.Handle());

	CDirScan* scan=CDirScan::NewLC(aFs);
	CleanupStack::Pop();

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanNewLReturn, MODULEUID, scan);
	return scan;
	}




EXPORT_C CDirScan::~CDirScan()
/**
Desctructor.

Frees all resources owned by the object, prior to its destruction.
*/
	{
	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanDestructor, MODULEUID, this);

	delete iStack;

	TRACE0(UTF::EBorder, UTraceModuleEfsrv::ECDirScanDestructorReturn, MODULEUID);
	}




EXPORT_C void CDirScan::SetScanDataL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,TScanDirection aScanDir)
/**
Initialises the scan.

This involves specifying:

1. the directory at the top of the structure to be scanned

2. a filter for the entry types of interest

3. the order in which the entries in each directory in the structure are to be sorted

4. the scan direction.

Whether the scan direction is upwards or downwards, the directories that are
scanned are those in the part of the hierarchy below the directory
specified in aMatchName. By default, the scan direction is downwards.
If the scan direction is set to CDirScan::EScanUpTree, then all branches of
the tree are explored starting at the lowest level directory in
the tree below aMatchName, and ending at aMatchName.
This option is provided for deleting a directory structure.

@param aMatchName     The top level directory for the scan. Any path components
                      that are not specified here are taken from the session path. 
                      Note that the trailing backslash is required to specify the directory.
                      I.e. path x:\\dir1\\dir2\\ means that the scan will start from dir2, while
                      path x:\\dir1\\dir2 assumes scan starting from x:\\dir1\\

@param anEntryAttMask A bit mask that filters the entry types which should be returned by
		              NextL(). The mask works as follows:
		              To match files only, specify KEntryAttNormal.
		              To match both files and directories,
		              specify KEntryAttDir.
		              To match directories only,
		              specify KEntryAttDir|KEntryAttMatchExclusive.
		              To match files with a	specific attribute,
		              then OR the attribute involved with
                      KEntryAttMatchExclusive.
                      For example, to match read-only files,
                      specify KEntryAttReadOnly|KEntryAttMatchExclusive.
                      For more information,
                      see KEntryAttNormal or
                      the other file/directory attributes.
@param anEntrySortKey The order in which the directories are scanned by
                      NextL(). This flag is defined in TEntryKey.
@param aScanDir       The direction of the scan. The default is downwards.
*/
	{
	TRACEMULT5(UTF::EBorder, UTraceModuleEfsrv::ECDirScanSetScanDataL, MODULEUID, (TUint) 
		this, aMatchName, anEntryAttMask, anEntrySortKey, (TUint) aScanDir);

	TInt r = Fs().Parse(aMatchName,iFullPath);
	if (r != KErrNone)
		{
		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanSetScanDataLReturn, MODULEUID, r);
		User::Leave(r);
		}

	iScanning = ETrue;
	iEntryAttMask=anEntryAttMask;
	iEntrySortMask=anEntrySortKey;
	iStack->ResetL(LeafDir(iFullPath.FullName()));
	iAbbreviatedPathPos=iFullPath.DriveAndPath().Length()-1;
	iAbbreviatedPath.Set(_L("\\"));
	iScanDir=aScanDir;
	if (aScanDir==EScanDownTree)
		iFullPath.PopDir();

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanSetScanDataLReturn, MODULEUID, KErrNone);
	}

void CDirScan::UpdateAbbreviatedPath()
//
// Set the abbreviated path based on the full path
//
	{

	TInt length=iFullPath.DriveAndPath().Length();
	TPtrC fullName=iFullPath.FullName();
	if (length>iAbbreviatedPathPos)
		iAbbreviatedPath.Set(&fullName[0]+iAbbreviatedPathPos,length-iAbbreviatedPathPos);
	else
		iAbbreviatedPath.Set(_L("\\"));
	}




EXPORT_C void CDirScan::NextL(CDir*& aDirEntries)
/**
Scans the next directory entry in the structure.

The order in which the structure is scanned is determined by the scan
direction and the entry sort mask. These values are specified when setting up
the scan. The type of entries retrieved by this function is determined by the
entry attribute mask. This is also specified when setting up the scan.

Notes:

1. The function first sets aDirEntries to NULL, and then allocates memory for
   it before appending entries to it. Therefore, aDirEntries should have no
   memory allocated to it before this function is called, otherwise this
   memory will become orphaned.
	 
2. The caller of this function is responsible for deleting aDirEntries after
   the function has returned.
   
@param aDirEntries On return, a pointer to an array containing filtered entries
                   from the next directory in the structure. NULL if there are
                   no more directories in the structure.
*/
	{
	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanNextL, MODULEUID, this);

	if (iScanDir==EScanUpTree)
		ScanUpTreeL(aDirEntries);
	else
		ScanDownTreeL(aDirEntries);

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::ECDirScanNextLReturn, MODULEUID, 
		KErrNone, aDirEntries ? (*aDirEntries).Count() : 0);
	}

void CDirScan::ScanUpTreeL(CDir*& aDirEntries)
//
// Get the next directory starting from the bottom of the tree
// eg: for deleting a directory structure
//
	{
	TInt r;
	iFullPath.PopDir();
	CDirList* list=iStack->Peek();
	if (!list->MoreEntries())
		{
		iStack->Pop();
		if (iStack->IsEmpty())
			{
			aDirEntries=NULL;
			return;
			}
		UpdateAbbreviatedPath();
		GetDirEntriesL(aDirEntries);
		return;
		}
			
	TFileName* next = new (ELeave) TFileName;
    CleanupStack::PushL(next);
	TFileName* current = new (ELeave) TFileName;
    CleanupStack::PushL(current);
			
	FOREVER
		{
		TPtrC dirName=list->Next().iName;
		r = iFullPath.AddDir(dirName);	
		if (r==KErrGeneral)	//	adding dirName would make iFullPath > 256 characters
			{
			current->Copy(iFullPath.DriveAndPath());
			next->Copy(dirName);
			
			r = ShrinkNames(Fs(), *current, *next, EFalse);
			if(r == KErrNone)
				{
				r = iFullPath.Set(*current, NULL, NULL);
				if(r == KErrNone)
					{
					r = iFullPath.AddDir(*next);
					}
				}
			}
		if (r != KErrNone)
			{
			TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanLeave, MODULEUID, r);
			User::LeaveIfError(r);
			}

		CDir* dirList;
		//	Start by searching for directories only	from top to bottom
		r = Fs().GetDir(iFullPath.DriveAndPath(),
						KEntryAttDir|KEntryAttMatchExclusive|(iEntryAttMask&KEntryAttMatchMask),
						iEntrySortMask,
						dirList);
		if (r == KErrPermissionDenied && !iScanning)
			{
			UpdateAbbreviatedPath();
			aDirEntries = CDirFactory::NewL();
			}
		else if (r != KErrNone)
			{
			iScanning = EFalse;
			TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanLeave, MODULEUID, r);
			User::Leave(r);
			}
		
		iScanning= EFalse;
		
		// Permission denied case. No entry
		if(!dirList)
			break;

		if (dirList->Count()==0)//	No more directory entries - bottom of tree reached
			{
			delete dirList;
			break;
			}
		iStack->PushL(*dirList);
		list=iStack->Peek();
		} //END OF FOREVER
		
	CleanupStack::PopAndDestroy(2); // current and next pointers

	UpdateAbbreviatedPath();
	//	Now get all valid entries for the lowest level directory encountered	
	
	if(r!=KErrPermissionDenied )
		{
		GetDirEntriesL(aDirEntries);
		}	
	}
	
void CDirScan::GetDirEntriesL(CDir*& aDirEntries)
//
// Call GetDir.
//
	{
	TInt r = Fs().GetDir(iFullPath.FullName(),iEntryAttMask,iEntrySortMask,aDirEntries);
	if (r != KErrNone)
		{
		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanLeave, MODULEUID, r);
		User::Leave(r);
		}
	}

void CDirScan::ScanDownTreeL(CDir*& aDirEntries)
//
// Get the next directory starting from the top of the tree 
// eg: for copying a directory structure
//
	{
	CDir* dirEntries = NULL;
	TInt r;
	aDirEntries=NULL;
	CDirList* list=iStack->Peek();
	while (!list->MoreEntries())
		{
		iStack->Pop();
		if (iStack->IsEmpty())
			{
			aDirEntries=NULL;
			return;
			}
		iFullPath.PopDir();
		UpdateAbbreviatedPath();
		list=iStack->Peek();
		}

	TPtrC dirName=list->Next().iName;
	r=iFullPath.AddDir(dirName);
	if (r==KErrGeneral)	//	Adding dirName makes iFullPath>256 characters
		{
		TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanLeave, MODULEUID, KErrTooBig);
		User::Leave(KErrTooBig);
		}

	//	Get all valid entries in this directory
	
	// coverity[alloc_arg]
	TRAP(r, GetDirEntriesL(dirEntries));

	if (r == KErrNone)
		{
		iScanning = EFalse;
		CleanupStack::PushL(dirEntries);
		//	Get all directories within this directory - the next level down in the tree
		CDir* dirList;

		// coverity[alloc_fn]
		r = Fs().GetDir(iFullPath.DriveAndPath(),
									   KEntryAttDir|KEntryAttMatchExclusive|(iEntryAttMask&KEntryAttMatchMask),
									   iEntrySortMask,dirList);
		if (r != KErrNone)
			{
			TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanLeave, MODULEUID, r);
			User::Leave(r);
			}
		iStack->PushL(*dirList);
		CleanupStack::Pop();	// dirEntries
		UpdateAbbreviatedPath();
		aDirEntries=dirEntries;
		}
	else if (r == KErrPermissionDenied && !iScanning)
		{
		CDir* dirList = CDirFactory::NewL();
		iStack->PushL(*dirList);
		aDirEntries = CDirFactory::NewL();
		}
	else
		{
		iScanning = EFalse;
		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanLeave, MODULEUID, r);
		User::Leave(r);
		}
	}




EXPORT_C TPtrC CDirScan::AbbreviatedPath()
/**
Gets the abbreviated path of the entry currently being scanned.

The abbreviated path is the path relative to the top level directory
in the scan.

@return A non modifiable pointer descriptor for the abbreviated path of
        the entry currently being scanned.
*/
	{
	
	return iAbbreviatedPath;
	}




EXPORT_C TPtrC CDirScan::FullPath()
/**
Gets the full path of the entry currently being scanned.

The full path includes the drive letter.

@return A non modifiable pointer descriptor for the full path of the entry
        currently being scanned.
*/
	{
	
	return iFullPath.DriveAndPath();
	} 




CDirStack* CDirStack::NewL()
// 
// Create new directory stack
//
	{

	return new(ELeave) CDirStack;
	}

CDirStack::CDirStack()
//
// Constructor
//
	: iDirStack(KDirStackGranularity)
	{
	}

CDirStack::~CDirStack()
//
// Destructor
//
	{

	
	iDirStack.ResetAndDestroy();
	}
	
TInt CDirStack::IsEmpty()
//
// Return number of directories stacked
//
	{

	return (iDirStack.Count()==0);
	}

void CDirStack::ResetL(const TDesC& aStartDir)
//
// Reset stack to containing only aStartDir
//
	{

	iDirStack.ResetAndDestroy();
	CDir* dir=CDirFactory::NewL(aStartDir);
	PushL(*dir);
	}

void CDirStack::PushL(CDir& aDirContents)
//
// Push a list of directories onto the stack
//
	{

	CleanupStack::PushL(&aDirContents);
	CDirList* nextLevel=CDirList::NewL(aDirContents);
	CleanupStack::Pop(); // aDirContents now owned by CDirList

	TInt r=iDirStack.Append(nextLevel);
	if (r!=KErrNone)
		{
		delete nextLevel;
		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanLeave, MODULEUID, r);
		User::Leave(r);
		}
	}

void CDirStack::Pop()
//
// Pop subdirectory list off the stack
//
	{

	__ASSERT_DEBUG(iDirStack.Count(),Panic(EDirListError));
	TInt tos=iDirStack.Count()-1;
	delete iDirStack[tos];
	iDirStack.Remove(tos);
	}

CDirList* CDirStack::Peek()
//
// Return current subdirectory
//
	{

	__ASSERT_DEBUG(iDirStack.Count(),Panic(EDirListError));
	return iDirStack[iDirStack.Count()-1];
	}

CDirList* CDirList::NewL(CDir& aDirList)
//
// Create a new directory list - takes ownership of aDirList
//
	{

	CDirList* dirLevel=new(ELeave) CDirList;
	dirLevel->iDirList=&aDirList;
	return dirLevel;
	}

CDirList::CDirList()
//
// Construct directory list
//
	{
	}

CDirList::~CDirList()
//
// Destroy directory list
//
	{

	delete iDirList;
	}

const TEntry& CDirList::Next()
//
// Return next directory in list.
//
	{

	__ASSERT_DEBUG(iCurrentPos>=0 && iCurrentPos<iDirList->Count(),Panic(EDirListError));
	const TEntry& entry=(*iDirList)[iCurrentPos];
	iCurrentPos++;
	return entry;
	}

TBool CDirList::MoreEntries() const
//
// Return EFalse if the entire list has been read
//
	{

	__ASSERT_DEBUG(iCurrentPos>=0 && iCurrentPos<=iDirList->Count(),Panic(EDirListError));
	return (iCurrentPos!=iDirList->Count());
	}

CDir* CDirFactory::NewL(const TDesC& anEntryName)
//
// Create a CDir containing a single entry. Used to initialize the scanner
//
	{

	CDirFactory* dir=(CDirFactory*)CDir::NewL();
	CleanupStack::PushL(dir);
	TEntry entry;
	entry.iName=anEntryName;
	dir->AddL(entry);
	CleanupStack::Pop();
	return dir;
	}

CDir* CDirFactory::NewL()
//
// Create a CDir with nothing in it
//
	{

	CDirFactory* dir=(CDirFactory*)CDir::NewL();
	return dir;
	}




EXPORT_C TOpenFileScan::TOpenFileScan(RFs& aFs)
/**
Constructs the object with the specified file server session.

@param aFs The file server session.
*/
	: iFs(&aFs), iScanPos(0), iEntryListPos(0)
	{}




EXPORT_C void TOpenFileScan::NextL(CFileList*& aFileList)
/**
Gets a list of entries for the open files in the file server session.

@param aFileList On return, contains a list of entries for all open files
                 in the file server session.
*/
	{


	aFileList=NULL;
	if (iScanPos==KErrNotFound)
		return;
	TEntryArray* pArray=new(ELeave) TEntryArray;
	CleanupStack::PushL(pArray);
	TEntryArray& array=*pArray;
	FOREVER
		{
		TThreadId theId;
		TInt r = iFs->GetOpenFileList(iScanPos,iEntryListPos,theId,array);
		if (r != KErrNone)
			{
			TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECDirScanLeave, MODULEUID, r);
			User::Leave(r);
			}
		TInt count=array.Count();
		if (count==0)
			{
			if (aFileList==NULL)
				iScanPos=KErrNotFound;
			else
				CleanupStack::Pop(); // aFileList
			iEntryListPos=0;
			CleanupStack::PopAndDestroy(); // pArray
			return;
			}
		iThreadId = theId;
		if (aFileList==NULL)
			{
			aFileList=CFileList::NewL();
			CleanupStack::PushL(aFileList);
			}
		TInt i=0;
		while (i<count)
			aFileList->AddL(array[i++]);
		}
	}




EXPORT_C TThreadId TOpenFileScan::ThreadId() const
/**
Gets the ID of the thread that opened the files retrieved by NextL().

@return The ID of the thread that opened the files in the file list.
*/
	{

	return(iThreadId);
	}
