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