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

#define RETURNIFERROR(a,b,t)  					\

	{											\

	if ((a=b)!=KErrNone)						\

		{										\

		if(iStatus)								\

			User::RequestComplete(iStatus,a);	\

		TInt _t = t;							\

		if (_t)	{TRACE1(UTF::EBorder, t, MODULEUID, a);}	\

		return(a);								\

		}										\

	}

#define RETURNIFERRORD(a,b,t)  		 			\

	TInt a; 									\

	RETURNIFERROR(a,b,t)

const TUint KRecurseFlag	=	0x40000000;

const TUint KScanDownFlag	=	0x20000000;

const TUint KFManBusyFlag	=	0x10000000;

const TUint KOverWriteFlag	=	0x08000000;

const TUint KMoveRenameFlag	=	0x04000000;

const TUint KCopyFromHandle	=	0x00000001;

const TInt KPathIncGran=32;

const TUint KMovingFilesMask = KEntryAttMatchExclude | KEntryAttDir;

TInt ShrinkNames(RFs& aFs, TFileName& aParent, TFileName& aItem, TBool aAppend);

LOCAL_C HBufC8* AllocateBuffer(TInt64 aLength)

	{

const TInt KBigBufSize = 512 * 1024;

const TInt KMediumBufSize = 32 * 1024;

const TInt KSmallBufSize = 4 * 1024;

	// Min result shall be of TInt size

	// Hence to suppress warning

	TInt big = (TInt)(Min(aLength,(TInt64)KBigBufSize));

	HBufC8* bufPtr=HBufC8::New(big);

	if (bufPtr==NULL)

		bufPtr=HBufC8::New(KMediumBufSize);

	if (bufPtr==NULL)

		bufPtr=HBufC8::New(KSmallBufSize);

	return(bufPtr);

	}

LOCAL_C TInt IncPathLength(TInt aLen)

	{

	return(((aLen+KPathIncGran-1)/KPathIncGran)*KPathIncGran);

	}

LOCAL_C TInt CreateTargetNameFromSource(TDes& aTrgName, const TDesC& aTrgMask, const TDesC& aSrcName)

// Replace the wildcards with letters from the matched file.

	{

	TFileName destName;

	TParsePtrC trg(aTrgMask);

	TParsePtrC src(aSrcName);

	TPtrC mask(trg.NameAndExt());

	TPtrC source(src.NameAndExt());

	TInt steps = 1;

	TBool starCharFound = EFalse;

	if(mask.LocateReverse('.')!=KErrNotFound || aTrgMask.Right(1)==_L("*"))

		{

		mask.Set(trg.Name());

		source.Set(src.Name());

		steps = 2;

		}

	for(TInt i = 0; i < steps;

	    i++, mask.Set(trg.ExtPresent() ? trg.Ext() : _L(".*")) , source.Set(src.Ext()))

		{

		TInt offset = 0;

		starCharFound = EFalse;

		while(offset < mask.Length())

			{

			TChar currentChar = mask[offset];

			switch(currentChar)

				{

				case KMatchAny:

					if(offset < source.Length() && !starCharFound)

						{

						destName.Append(source.Mid(offset));

						starCharFound = ETrue;

						}

					break;

				case KMatchOne:

					if(offset < source.Length())

				    {

				    destName.Append(source[offset]);

				    }

					break;

				default:

					destName.Append(currentChar);

					break;

				}

			offset++;

			}

		}

	if(destName.Right(1) == _L("."))

		{

		destName.SetLength(destName.Length()-1);

		}

	if(aTrgName.Length()+destName.Length() > KMaxFileName)

		{

		return KErrBadName;

		}

	aTrgName.Append(destName);

	return KErrNone;

	}

EXPORT_C MFileManObserver::TControl MFileManObserver::NotifyFileManStarted()

/**

Inform the observer that an operation is about to start.

This is done immediately before each entry is processed.

@return The implementation of this function should return:

        MFileManObserver::EContinue, to allow processing of the current file

        to proceed;

        MFileManObserver::ECancel, to skip processing the current file and move

        to the next file;

        MFileManObserver::EAbort to abort the entire operation.

        The default return value is MFileManObserver::EContinue.

*/

	{

	return(EContinue);

	}

EXPORT_C MFileManObserver::TControl MFileManObserver::NotifyFileManOperation()

/**

Informs the observer that an operation, i.e. a copy or a move, is proceeding.

Large files are copied and moved in stages.

After each portion of the source file has been copied to the target, this

function is called.

It may be useful to call CFileMan::BytesTransferredByCopyStep() from this

function to retrieve the current status of the operation.

@return The implementation of this function should return:

        MFileManObserver::ECancel, to cancel the current operation, closing the current source

        and target files, the current target file is deleted.

        If the operation is performed on several files, cancelling one will not abort whole batch.

        MFileManObserver::EContinue, to continue with the operation.

        The default return value is MFileManObserver::EContinue.

@see CFileMan

*/

	{

	return(EContinue);

	}

EXPORT_C MFileManObserver::TControl MFileManObserver::NotifyFileManEnded()

/**

Informs the observer that an operation is complete.

This is done immediately after a directory entry has been processed.

It may be useful to call CFileBase::GetLastError()

and CFileBase::GetMoreInfoAboutError() from this function to retrieve

information about how the operation ended.

@return The implementation of this function should return:

        MFileManObserver::EContinue or MFileManObserver::ECancel, to proceed

        with processing the next entry. MFileManObserver::ECancel will not

        cancel processing the current entry;

        MFileManObserver::ERetry, to re-attempt processing the previous file;

        MFileManObserver::EAbort, to abort the entire operation.

        The default return value is MFileManObserver::EContinue.

@see CFileBase

*/

	{

	return(EContinue);

	}

EXPORT_C CFileBase::CFileBase(RFs& aFs)

/**

Protected default constructor.

Note that the class is intended only as an abstract base for other classes.

@param aFs File server session.

*/

	: iFs(aFs)

	{

	}

EXPORT_C void CFileBase::ConstructL()

/**

Second phase constructor.

*/

	{

	iScanner=CDirScan::NewL(iFs);

	User::LeaveIfError(iSynchronizer.CreateLocal(0));

	}

EXPORT_C CFileBase::~CFileBase()

/**

Destructor.

Frees resources prior to destruction of the object.

*/

	{

	delete iScanner;

	delete iDirList;

	iSynchronizer.Close();

	User::Free(iSessionPath);

	}

GLDEF_C void DoFManBaseOperationL(TAny* aPtr)

//

// File manager asynchronous thread

//

	{

	CFileBase& fMan=*(CFileBase*)aPtr;

	User::LeaveIfError(fMan.iFs.Connect());

	User::LeaveIfError(fMan.iFs.SetSessionPath(*fMan.iSessionPath));

	fMan.iNumberOfFilesProcessed = 0;

	fMan.RunL();

	}

GLDEF_C TInt FManBaseThreadFunction(TAny* aPtr)

//

// Initialise New thread

//

	{

	CTrapCleanup* cleanup=CTrapCleanup::New();

	if (cleanup==NULL)

		return(KErrNoMemory);

	CFileBase& fMan=*(CFileBase*)aPtr;

	fMan.iSynchronizer.Wait();

	TRAPD(ret,DoFManBaseOperationL(aPtr));

	if (ret==KErrNone)

		ret=fMan.iLastError;

	delete cleanup;

	fMan.iSwitches=0;

	fMan.iFs=fMan.iFsOld;

	fMan.iStatus=NULL;

	fMan.iFManThread.Close();

	return(ret);

	}

EXPORT_C void CFileBase::RunInSeparateThreadL(TThreadFunction aThreadFunction)

/**

Creates a separate thread to run the command.

@param aThreadFunction The thread function.

*/

	{

	iSwitches|=KFManBusyFlag;

	User::LeaveIfError(iFManThread.Create(KNullDesC,aThreadFunction,KDefaultStackSize,NULL,this));

	iFManThread.SetPriority(EPriorityMuchLess);

	TFileName sessionPath;

	User::LeaveIfError(iFs.SessionPath(sessionPath));

	if (iSessionPath==NULL)

		iSessionPath=HBufC::NewL((sessionPath.Length()));

	else if (iSessionPath->Des().MaxLength()<sessionPath.Length())

		iSessionPath=iSessionPath->ReAllocL(IncPathLength(sessionPath.Length()));

	iSessionPath->Des()=sessionPath;

	iFsOld=iFs;

	iLastError=KErrNone;

	iFManThread.Logon(*iStatus);

	iFManThread.Resume();

	}

EXPORT_C void CFileBase::RunL()

/**

Executes a command.

@capability Dependent the capabilities required by this method, of the abstract class CFileBase,

					  will be dependent on and provided by the concrete-class implementation of

					  the DoOperationL method

*/

	{

	if (iStatus && (iSwitches&KFManBusyFlag)==EFalse)

		{

		RunInSeparateThreadL(FManBaseThreadFunction);

		return;

		}

	TBool copyFromHandle = (iSwitches & KCopyFromHandle)?(TBool)ETrue:(TBool)EFalse;

	CDirScan::TScanDirection scanDir=(iSwitches&KScanDownFlag) ? CDirScan::EScanDownTree : CDirScan::EScanUpTree;

	if (!copyFromHandle)

		{

		TRAP(iLastError,iScanner->SetScanDataL(iSrcFile.FullName(),iMatchEntry,ESortByName|EAscending,scanDir));

		if (iLastError==KErrNone)

			TRAP(iLastError,iScanner->NextL(iDirList));

		if (iLastError!=KErrNone)

			{

			iErrorInfo=EInitializationFailed;

			User::Leave(iLastError);

			}

		}

	FOREVER

		{

		if (copyFromHandle || iDirList->Count())

			{

			iLastError=KErrNone;

			iErrorInfo=ENoExtraInformation;

			TInt action=(iObserver) ? iObserver->NotifyFileManStarted() : MFileManObserver::EContinue;

			// Check if NotifyFileManStarted returned ECancel.

			if ( action == MFileManObserver::ECancel)

				iLastError=KErrCancel;

			if (action==MFileManObserver::EContinue)

				{

				iNumberOfFilesProcessed++;

				TRAP(iLastError,DoOperationL());

				action=(iObserver) ? iObserver->NotifyFileManEnded() : MFileManObserver::EContinue;

				}

			else if(action==MFileManObserver::ERetry)

			  {

			  Panic(EFManBadValueFromObserver);

			  }

			switch(action)

				{

			case MFileManObserver::EContinue:

			case MFileManObserver::ECancel:

				break;

			case MFileManObserver::ERetry:

				continue;

			case MFileManObserver::EAbort:

				delete iDirList;

				iDirList=NULL;

				iCurrentEntry = 0;

				User::Leave(KErrCancel);

			default:

				Panic(EFManBadValueFromObserver);

				}

			}

		iCurrentEntry++;

		if (copyFromHandle || iCurrentEntry>=iDirList->Count())

			{

			delete iDirList;

			iDirList=NULL;

			iCurrentEntry=0;

			if (iSwitches&KRecurseFlag)

				{

				TRAPD(ret,iScanner->NextL(iDirList));

				if (ret!=KErrNone && ret!=KErrPathNotFound)

					{

					iErrorInfo=EScanNextDirectoryFailed;

					iLastError = ret;

					User::Leave(iLastError);

					}

				}

			if (iDirList==NULL)

				{

				CompleteOperationL();

				return;

				}

			}

		}

	}

EXPORT_C void CFileBase::SetObserver(MFileManObserver* anObserver)

/**

Sets the observer.

Use this function to provide CFileMan with an MFileManObserver, or, if one

already exists, to change the observer.

@param anObserver File management observer.

@see CFileMan

@see MFileManObserver

*/

	{

	iObserver=anObserver;

	}

EXPORT_C const TEntry& CFileBase::CurrentEntry()

/**

Gets the entry currently being processed.

@return Contains the current entry.

*/

	{

	__ASSERT_ALWAYS(iDirList && iCurrentEntry>=0 && iCurrentEntry<iDirList->Count(),Panic(EFManCurrentEntryInvalid));

	return (*iDirList)[iCurrentEntry];

	}

EXPORT_C TPtrC CFileBase::AbbreviatedPath()

/**

Gets the abbreviated path of the file or directory currently being processed.

The abbreviated path is its path relative to the top level directory

specified in the operation.

@return The abbreviated path.

*/

	{

	return iScanner->AbbreviatedPath();

	}

EXPORT_C TPtrC CFileBase::FullPath()

/**

Gets the full path of the file or directory currently being processed.

The full path includes the drive letter, path and filename.

@return The full path.

*/

	{

	return iScanner->FullPath();

	}

EXPORT_C TInt CFileBase::GetLastError()

/**

Gets the latest error code returned during a CFileMan

operation.

This function may be called from MFileManObserver::NotifyFileManEnded().

@return KErrNone, or another error code that might have been

        returned by a CFileMan operation.

*/

	{

	return(iLastError);

	}

EXPORT_C TFileManError CFileBase::GetMoreInfoAboutError()

/**

Gets additional information about the latest error returned during

a CFileMan operation.

For example, if a rename fails, this function

can be used to report whether the source or target name caused the problem.

This information supplements that provided GetLastError().

@return The extra information about the last CFileMan error.

@see CFileMan

@see CFileBase::GetLastError()

*/

	{

	return(iErrorInfo);

	}

EXPORT_C CFileMan* CFileMan::NewL(RFs& aFs)

/**

Constructs and allocates memory for a new CFileMan object.

@param aFs File server session.

@return Newly created CFileMan object.

*/

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECFileManNewL1, MODULEUID, aFs.Handle());

	CFileMan* fileMan=new(ELeave) CFileMan(aFs);

	CleanupStack::PushL(fileMan);

	fileMan->CFileBase::ConstructL();

	CleanupStack::Pop();

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECFileManNewL1Return, MODULEUID, fileMan);

	return fileMan;

	}

EXPORT_C CFileMan* CFileMan::NewL(RFs& aFs,MFileManObserver* anObserver)

/**

Constructs and allocates memory for a new CFileMan object with an observer.

@param aFs        File server session.

@param anObserver File management observer.

@return Newly created CFileMan object.

*/

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::ECFileManNewL2, MODULEUID, aFs.Handle(), anObserver);

	CFileMan* fileMan=new(ELeave) CFileMan(aFs);

	CleanupStack::PushL(fileMan);

	fileMan->CFileBase::ConstructL();

	CleanupStack::Pop();

	fileMan->SetObserver(anObserver);

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECFileManNewL2Return, MODULEUID, fileMan);

	return fileMan;

	}

CFileMan::CFileMan(RFs& aFs)

//

// Constructor and destructor

//

	: CFileBase(aFs)

	{

	}

CFileMan::~CFileMan()

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECFileManDestructor, MODULEUID, this);

	TRACE0(UTF::EBorder, UTraceModuleEfsrv::ECFileManDestructorReturn, MODULEUID);

	}

EXPORT_C CFileMan::TAction CFileMan::CurrentAction()

/**

Gets the action which CFileMan is currently carrying out.

@return The action which CFileMan is carrying out.

*/

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECFileManCurrentAction, MODULEUID, this);

	TAction action = ENone;

	// Mapping table between internal and external action indicators.

	switch(iAction)

		{

	case EInternalNone:

		action = ENone;

		break;

	case EInternalAttribs:

		action = EAttribs;

		break;

	case EInternalCopy:

		action = ECopy;

		break;

	case EInternalCopyForMove:

		action = EMove;

		break;

	case EInternalDelete:

		action = EDelete;

		break;

	case EInternalRenameInvalidEntry:

		action = ERenameInvalidEntry;

		break;

	case EInternalRenameForMove:

	case EInternalRename:

		action = ERename;

		break;

	case EInternalRmDir:

		action = ERmDir;

		break;

	case EInternalCopyFromHandle:

		action = ECopyFromHandle;

		break;

	default:

		Panic(EFManUnknownAction);

		}

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECFileManCurrentActionReturn, MODULEUID, action);

	return (action);

	}

EXPORT_C void CFileMan::GetCurrentTarget(TFileName& aTrgName)

/**

Gets the name of the target file for the CFileMan operation currently

being carried out.

This function is relevant when copying, moving or renaming files.

@param aTrgName The full path and filename of the target file for

                the current CFileMan operation

*/

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECFileManGetCurrentTarget, MODULEUID, this);

	GetSrcAndTrg(iTmpParse, aTrgName);

	TRACEMULT1(UTF::EBorder, UTraceModuleEfsrv::ECFileManGetCurrentTargetReturn, MODULEUID, aTrgName);

	}

EXPORT_C void CFileMan::GetCurrentSource(TFileName& aSrcName)

/**

Gets the name of the source file or directory for the CFileMan operation

currently being carried out.

The source is the file or directory which is being copied, moved or deleted.

@param aSrcName The full path and filename of the source file for the current

                CFileMan operation.

*/

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::ECFileManGetCurrentSource, MODULEUID, this);

    TPtrC fullPath(FullPath());

	iTmpParse.Set(CurrentEntry().iName, &fullPath, NULL);

	aSrcName = iTmpParse.FullName();

	TRACEMULT1(UTF::EBorder, UTraceModuleEfsrv::ECFileManGetCurrentSourceReturn, MODULEUID, aSrcName);

	}

void CFileMan::GetSrcAndTrg(TParse& aSrcName,TFileName& aTrgName)

//

// Get the current target for the operation

//

	{

	TFileName fullpath = FullPath();

	TInt ret = aSrcName.Set(CurrentEntry().iName, &fullpath, NULL);

	if(ret == KErrBadName)

		{

		// Try heap variables first

		TBool done = EFalse;

		TFileName* current = new TFileName;

		if (current != NULL)

			{

			current->Copy(CurrentEntry().iName);

			ret = ShrinkNames(iFs, fullpath, *current, EFalse);

			if(ret == KErrNone)

				{

				ret = aSrcName.Set(*current, &fullpath, NULL);

				done = ETrue;

				}

			delete current;

			}

		if (!done) //heap method failed

			{

			TFileName current = CurrentEntry().iName;

			ret = ShrinkNames(iFs, fullpath, current, EFalse);

			if(ret == KErrNone)

				{

				ret = aSrcName.Set(current, &fullpath, NULL);

				}

			}

		}

	__ASSERT_DEBUG(ret == KErrNone, Panic(EBadLength));

	aTrgName=iTrgFile.DriveAndPath();

	TPtrC relPath=iScanner->AbbreviatedPath();

	aTrgName.Append(relPath.Right(relPath.Length()-1));

	CreateTargetNameFromSource(aTrgName,iTrgFile.NameAndExt(),aSrcName.NameAndExt());

	}

EXPORT_C TInt CFileMan::BytesTransferredByCopyStep()

/**

Gets the number of bytes transferred during a copy or move operation.

Large files are copied and moved in stages. After each portion of

the source file has been copied to the target, the number of bytes

transferred is updated. This function may be called

from MFileManObserver::NotifyFileManOperation()

and may be used to support the increment of progress bars.

@return The number of bytes transferred.

*/

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::ECFileManBytesTransferredByCopyStep, MODULEUID, this, iBytesTransferred);

	return(iBytesTransferred);

	}

LOCAL_C void MakeParseWild(TParse& aParse, TFileName& aName)

//

// Append _L("\\*") or _L("*") to aParse

//

	{

	if(!aParse.IsWild())

		{

		aName = aParse.FullName();

		if (aParse.NamePresent() || aParse.ExtPresent())

			{

			if (aName.Length()<=254)

				aName.Append(_L("\\*"));

			}

		else

			{

			if (aName.Length()<=255)

				aName.Append(_L("*"));

			}

		aParse.Set(aName,NULL,NULL);

		}

	}

void CFileMan::CheckForDirectory()

//

// If iTrgFile is a directory set target to iTrgFile\\*

//

	{

	TInt trg = iFs.Entry(iTrgFile.FullName(), iTmpEntry);

	if (trg==KErrNone && iTmpEntry.iAtt&KEntryAttDir)

		MakeParseWild(iTrgFile, iTmpName1);

	TInt src = iFs.Entry(iSrcFile.FullName(), iTmpEntry);

	if (src==KErrNone && iTmpEntry.iAtt&KEntryAttDir)

		{

		MakeParseWild(iSrcFile, iTmpName1);

		if (trg==KErrNotFound && (iSwitches&KRecurseFlag))

			MakeParseWild(iTrgFile, iTmpName1);

		}

	}

void CFileMan::DoSynchronize(TInt aRetValue)

//

// Synchronise with fmanthread

//

	{

	if (iStatus && aRetValue==KErrNone)

		iSynchronizer.Signal(); // FManThread started

	if (iStatus && aRetValue!=KErrNone)

		iStatus=NULL; // FManThread failed to start

	}

LOCAL_C void NextInPath(const TDesC& aPath,TPtrC& anEntry,TInt& aPos)

//

// Returns the next entry in the path

//

	{

	anEntry.Set(NULL,0);

	if ((aPos+1)>=aPath.Length())

		return;

	TPtrC path(aPath.Mid(aPos+1)); // Skip delimiter

	TInt delimiterPos=path.Locate(KPathDelimiter);

	if (delimiterPos==KErrNotFound)

		delimiterPos=aPath.Length()-(aPos+1);

	if (delimiterPos<=0)

		return;

	if (path[delimiterPos-1]==KExtDelimiter) // return "F32." as "F32"

		anEntry.Set(aPath.Mid(aPos+1,delimiterPos-1));

	else

		anEntry.Set(aPath.Mid(aPos+1,delimiterPos));

	aPos+=delimiterPos+1;

	}

LOCAL_C TBool ComparePaths(const TDesC& aPath1,const TDesC& aPath2)

//

// Return ETrue if the paths are identical

// To catch case "\\F32.\\GROUP\\" == "\\F32\\GROUP\\"

//

	{

	TPtrC entry1(NULL,0);

	TPtrC entry2(NULL,0);

	TInt pos1=0;

	TInt pos2=0;

	do {

		NextInPath(aPath1,entry1,pos1);

		NextInPath(aPath2,entry2,pos2);

		if (entry1.MatchF(entry2)==KErrNotFound)

			return(EFalse);

		} while (entry1.Length() && entry2.Length());

	return(ETrue);

	}

EXPORT_C TBool FileNamesIdentical(const TDesC& aFileName1,const TDesC& aFileName2)

//

// Return ETrue if the filenames (and paths) are identical

// NB "Agenda" == "AGENda."

//

	{

	TParsePtrC file1(aFileName1);

	TParsePtrC file2(aFileName2);

	if (file1.Drive().MatchF(file2.Drive())==KErrNotFound)

		return(EFalse);

	if (file1.Name().MatchF(file2.Name())==KErrNotFound)

		return(EFalse);

	if (ComparePaths(file1.Path(),file2.Path())==EFalse)

		return(EFalse);

	if (file1.Ext().Length()==0 || file2.Ext().Length()==0)

		{ // Agenda == Agenda.

		if (file1.Ext().Length()==1 || file2.Ext().Length()==1)

			return(ETrue);

		}

	if (file1.Ext().MatchF(file2.Ext())==KErrNotFound &&

		file1.NameAndExt().MatchF(file2.NameAndExt())==KErrNotFound)

		return(EFalse);

	return(ETrue);

	}

EXPORT_C TInt CFileMan::Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitches,TRequestStatus& aStatus)

/**

Sets or clears attributes for one or more files using two bitmasks.

This is an asynchronous function.

Its behaviour is the same as the synchronous overload.

@param aName      Path indicating the file(s) whose attributes are to be

                  changed. Any path components which are not specified

                  here will be taken from the session path.

                  Use wildcards to specify more than one file.

@param aSetMask   Bitmask indicating the attributes to be set.

@param aClearMask Bitmask indicating the attributes to be cleared.

                  For more information, see KEntryAttNormal and the other

                  file/directory attributes.

@param aTime      Contains the new modification date and time for the files, in UTC.

                  To preserve the file's timestamps, specify a TTime value of 0.

@param aSwitches  Specify zero for no recursion;

                  CFileMan::ERecurse for recursion.

                  By default, the synchronous variant of this function operates

                  non-recursively.

@param aStatus    The request status object. On request completion,

                  indicates how the request completed:

                  KErrNone, if successful, otherwise one of the other system-wide error

                  codes.

@return KErrNone if the asynchronous request is made successfully; KErrInUse if an asynchronous request

					is still pending; otherwise one of the other system-wide error codes

@capability Dependent If aName is /Sys then Tcb capability is required.

@capability Dependent If aName begins with /Private and does not match

					  this process' SID then AllFiles capability is required.

@capability Dependent If aName is /Resource then Tcb capability is required.

*/

	{

	TRACEMULT8(UTF::EBorder, UTraceModuleEfsrv::ECFileManAttribs1, MODULEUID,

		(TUint) this, aName, aSetMask, aClearMask, I64LOW(aTime.Int64()), I64HIGH(aTime.Int64()), aSwitches, (TUint) &aStatus);

	TInt r;

	if (iSwitches&KFManBusyFlag)

		{

		r = KErrInUse;

		}

	else

		{

		iStatus=&aStatus;

		r = Attribs(aName,aSetMask,aClearMask,aTime,aSwitches);

		}

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::ECFileManAttribs1Return, MODULEUID, r);

	return r;

	}

EXPORT_C TInt CFileMan::Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitches)

/**

Sets or clears attributes for one or more files using two bitmasks

This is a synchronous function.

The first bitmask specifies the attributes to be set.

The second specifies the attributes to be cleared.

The date and time of the files' last modification can also be changed.

The function can operate recursively or non-recursively.

When operating non-recursively, only the matching files located in the directory

specified in aName are affected. When operating recursively, all matching files

in the directory hierarchy below the directory specified in aName will be affected.

Notes:

1. A panic is raised if any attribute is specified in both bitmasks.

2. Attempting to change the attributes for an open file results in an error

   for that file, as retrieved by CFileBase::GetLastError().

3. An attempt to set or clear the KEntryAttDir or KEntryAttVolume attribute

   for a file or directory will have no effect.

@param aName      Path indicating the file(s) whose attributes are to be

                  changed. Any path components which are not specified

                  here will be taken from the session path.

                  Use wildcards to specify more than one file.

@param aSetMask   Bitmask indicating the attributes to be set.

@param aClearMask Bitmask indicating the attributes to be cleared.

                  For more information, see KEntryAttNormal and the other

                  file/directory attributes.

@param aTime      Contains the new modification date and time for the files, in UTC.

                  To preserve the file's timestamps, specify a TTime value of 0.

@param aSwitches  Specify zero for no recursion;

                  CFileMan::ERecurse for recursion.

                  By default, the synchronous variant of this function operates

                  non-recursively.

@return KErrNone if successful, otherwise one of the other system-wide error codes.

@capability Dependent If aName is /Sys then Tcb capability is required.

@capability Dependent If aName begins with /Private and does not match

					  this process' SID then AllFiles capability is required.

@capability Dependent If aName is /Resource then Tcb capability is required.

*/

	{

	TRACEMULT7(UTF::EBorder, UTraceModuleEfsrv::ECFileManAttribs2, MODULEUID,

		(TUint) this, aName, aSetMask, aClearMask, I64LOW(aTime.Int64()), I64HIGH(aTime.Int64()), aSwitches);

	TInt ret;

	if (iSwitches&KFManBusyFlag)

		{

		ret = KErrInUse;

		}

	else

		{

		SetFlags(aSwitches&EOverWrite,aSwitches&ERecurse,ETrue,EFalse);

		RETURNIFERRORD(r,iFs.Parse(aName,iSrcFile),UTraceModuleEfsrv::ECFileManAttribs2Return);

		iSetMask=aSetMask;

		iClearMask=aClearMask;

		iTime=aTime;

		iAction = EInternalAttribs;

		iMatchEntry=KEntryAttMaskSupported; // all entries

		iNumberOfFilesProcessed = 0;