/*

* Copyright (c) 2004-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: 

* TestUtil - server implementation

*

*/

/**

 @file 

 @test

 @internalComponent

*/

#include "testutilserver.h"

#include "testutilsession.h"

#include "testutilclientserver.h"

// Timer implementation

CGenericTimer* CGenericTimer::NewL(MTimeoutClient& aClient)

	{

	CGenericTimer* self = new(ELeave) CGenericTimer(aClient);

	CleanupStack::PushL(self);

	self->ConstructL(); // calls CTimer::Construct

	CleanupStack::Pop(self);

	return self;

	}

CGenericTimer::CGenericTimer(MTimeoutClient& aClient)

	: CTimer(-1), iClient(aClient)

	{

	CActiveScheduler::Add(this);

	}

void CGenericTimer::RunL()

	{

	// When the timeout expires, then call the client's handler

	iClient.HandleTimeout();

	};

// file detector implementation

CTestFileDetector* CTestFileDetector::NewL(const RMessage2& aMessage, RFs& aFs)

	{

	CTestFileDetector* self = new (ELeave) CTestFileDetector(aMessage, aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestFileDetector::CTestFileDetector(const RMessage2& aMessage, RFs& aFs)

	:CActive(EPriorityNormal), iFs(aFs), iMessage(aMessage)

	{

	iTimeInterval = iMessage.Int1();

	CActiveScheduler::Add(this);

	}

CTestFileDetector::~CTestFileDetector()

	{

	Cancel();

	delete iTimer;

	delete iFileName;

	}

void CTestFileDetector::ConstructL()

	{

	if (iTimeInterval!=0)

		{

		iTimer=CGenericTimer::NewL(*this);

		}

	iFileName = CTestUtilSessionCommon::AllocateInputBufferLC(iMessage, 0);

	CleanupStack::Pop();

	}

void CTestFileDetector::DetectFile()

	{

	if (!iTimer)

		{

		CheckAndComplete();

		}

	else

		{

		TEntry entry;

		TInt err=iFs.Entry(iFileName->Des(), entry);

		if (err == KErrNone)

			{

			TPckgC<TBool> exists(ETrue);

			iMessage.WriteL(2, exists);

			iMessage.Complete(KErrNone);

			}

		else

			{

			iTimer->After(iTimeInterval*1000);

			iFs.NotifyChange(ENotifyFile, 

							iStatus, 

							iFileName->Des());

			SetActive();			

			}

		}

	}

void CTestFileDetector::RunL()

	{

	if (iTimer)

		{

		iTimer->Cancel();

		}

	CheckAndComplete();

	}

void CTestFileDetector::DoCancel()

	{

	iFs.NotifyChangeCancel(iStatus);

	}

void CTestFileDetector::HandleTimeout()

	{

	Cancel();

	CheckAndComplete();

	}

void CTestFileDetector::CheckAndComplete()

	{

	TEntry entry;

	TInt err=iFs.Entry(iFileName->Des(), entry);

	if (err == KErrNone)

		{

		TPckgC<TBool> exists(ETrue);

		iMessage.WriteL(2, exists);

		iMessage.Complete(KErrNone);

		}

	else if (err == KErrNotFound 

			|| err == KErrPathNotFound

			|| err == KErrNotReady 

			|| err == KErrCorrupt)

		{

		TPckgC<TBool> exists(EFalse);

		iMessage.WriteL(2, exists);

		iMessage.Complete(KErrNone);

		}

	else

		{

		iMessage.Complete(err);

		}

	}

// CTestUtilSession Implementation

CTestUtilSession::CTestUtilSession()

	{

	}

CTestUtilSession::~CTestUtilSession()

	{

	Server().DropSession();

	for (TInt i = 0;i < iLockedFileHandles.Count(); i++)

		{

		iLockedFileHandles[i].Close();

		}

	iLockedFileHandles.Close();

	delete iFileWatcher;

	delete iDetector;

	}

void CTestUtilSession::CreateL()

 	{

	Server().AddSession();

  	}

_LIT(KBP, ":\\");

_LIT(KFAT,"Fat");

void CTestUtilSession::ServiceL(const RMessage2& aMessage)

	{

	switch (aMessage.Function())

		{

		case ECopy:

			{

			HBufC* source = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			HBufC* destination = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,1);

			TInt err = Server().FileMan().Copy(*source, *destination, CFileMan::ERecurse | CFileMan::EOverWrite);

			if (err == KErrNone)

				{

				// Turn off the read only attributes

				TTime time(0); // must specify 0, or a valid time, otherwise sets time to a random value and causes -6/-21 errors

				err = Server().FileMan().Attribs(*destination, 0, KEntryAttReadOnly, time, CFileMan::ERecurse);

				}

			CleanupStack::PopAndDestroy(destination);

			CleanupStack::PopAndDestroy(source);

			aMessage.Complete(err);

			break;

			}

		case EMove:

			{

			HBufC* source = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			HBufC* destination = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,1);

			TInt err = Server().FS().Rename(*source,*destination);

			if (err == KErrNone)

				{

				// Turn off the read only attributes

				TTime time(0); // must specify 0, or a valid time, otherwise sets time to a random value and causes -6/-21 errors

				err = Server().FileMan().Attribs(*destination, 0, KEntryAttReadOnly, time, CFileMan::ERecurse);

				}

			CleanupStack::PopAndDestroy(destination);

			CleanupStack::PopAndDestroy(source);

			aMessage.Complete(err);

			break;

			}

		case EDelete:

			{

			HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			TEntry entry;

			TInt err = Server().FS().Entry(*fileName, entry);

			if (err == KErrNone)

				{

				if (entry.IsDir())

					{

					TPath pathName(*fileName);

					if (pathName[pathName.Length() - 1] != KPathDelimiter)

						{

						pathName.Append(KPathDelimiter);

						}

					err = Server().FileMan().RmDir(pathName);

					}

				else

					{

					err = Server().FS().Delete(*fileName);

					}

				}

			CleanupStack::PopAndDestroy(fileName);

			aMessage.Complete(err);

			break;

			}

		case ERmDir:

			{

			HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			TParsePtrC parsePtr(*fileName);

			if(parsePtr.IsRoot())

				{

				User::Leave(KErrAccessDenied);

				}

			TInt err = Server().FileMan().RmDir(*fileName);

			CleanupStack::PopAndDestroy(fileName);

			aMessage.Complete(err);

			break;

			}

		case EMkDirAll:

			{

			HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			TInt err = Server().FS().MkDirAll(*fileName);

			CleanupStack::PopAndDestroy(fileName);

			aMessage.Complete(err);

			break;

			}

		case EFileExists:

			{			

			delete iDetector;

			iDetector=CTestFileDetector::NewL(aMessage,

												Server().FS());			

			iDetector->DetectFile();

			break;

			}

		case ELock:

			{

			HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			RFile lockFile;

			TInt err = lockFile.Open(Server().FS(), *fileName, EFileWrite);

			if (err == KErrNone)

				iLockedFileHandles.Append(lockFile);

			CleanupStack::PopAndDestroy(fileName);			

			aMessage.Complete(err);

			break;

			}			

		case EUnlock:

			{

			HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			TInt err = KErrNotFound;

			TFileName lockedFileName;

			for (TInt i = 0; i < iLockedFileHandles.Count() && err;i++)

				{

				TInt err2 = iLockedFileHandles[i].FullName(lockedFileName);

				User::LeaveIfError(err2);

				if (lockedFileName.MatchF(*fileName) != KErrNotFound)

					{

					iLockedFileHandles[i].Close();

					iLockedFileHandles.Remove(i);

					err = KErrNone;

					}

				}

			CleanupStack::PopAndDestroy(fileName);			

			aMessage.Complete(err);

			break;

			}

			case EFormat:

			{

			TInt drive = aMessage.Int0();

			TBool formatFatOnly = aMessage.Int1();

			TChar aDriveChar;

			User::LeaveIfError(Server().FS().DriveToChar(drive, aDriveChar));

			TBuf<3> bfDrv;

			bfDrv.Append(aDriveChar);

			bfDrv.Append(KBP);

			RFormat format;

			TInt count;

			User::LeaveIfError(format.Open(Server().FS(), bfDrv, EHighDensity, count));

			CleanupClosePushL(format);

			if (formatFatOnly)

   				{

   				User::LeaveIfError(format.Next(count));

   				}

			else

				{

				while (count > 0)

					{

					User::LeaveIfError(format.Next(count));

					}

				}

			CleanupStack::PopAndDestroy(&format);

			aMessage.Complete(KErrNone);

			break;

			}

		case EMount:

			{

			TInt drive = aMessage.Int0();

			User::LeaveIfError(Server().FS().Connect());

			//Mount the drive synchronizely to make sure the drive is ready for the next operation

			User::LeaveIfError(Server().FS().MountFileSystem(KFAT, drive, ETrue));

			aMessage.Complete(KErrNone);

			break;

			}

		case EUnMount:

			{

			TInt drive = aMessage.Int0();

			TFileName fsName;

			User::LeaveIfError(Server().FS().FileSystemName(fsName, drive));

			User::LeaveIfError(Server().FS().DismountFileSystem(fsName, drive));

			aMessage.Complete(KErrNone);

			break;

			}

		case ESetReadOnly:

			{

			HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			TInt setReadOnly = aMessage.Int1();

			TUint setmask;

			TUint clearmask;

			if (setReadOnly)

				{

				// Setting read only attribute

				setmask = KEntryAttReadOnly;

				clearmask = 0;

				}

			else

				{

				// Clearing read only attribute

				setmask = 0;

				clearmask = KEntryAttReadOnly;				

				}

			// Turn off the read only attributes

			TTime time(0);

			TInt err = Server().FileMan().Attribs(*fileName, setmask, clearmask, time);

			CleanupStack::PopAndDestroy(fileName);			

			aMessage.Complete(err);

			break;

			}

		case EGetFileHandle:

			{

			HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0); 

			RFile file;

			CleanupClosePushL(file);

			User::LeaveIfError(file.Open(Server().FS(), *fileName, EFileRead | EFileShareReadersOnly));

			User::LeaveIfError(file.TransferToClient(aMessage, 1));

			CleanupStack::PopAndDestroy(2, fileName); // file

			break;

			}

		case EWatchFile:

			{

			if (iFileWatcher)

				{

				if (iFileWatcher->IsActive())

					{

					aMessage.Complete(KErrServerBusy);

					break;

					}

				else

					{

					delete iFileWatcher;

					iFileWatcher = NULL;

					}

				}

			// Create a new file watcher for this session

			iFileWatcher = CFileWatcher::NewL(Server().FS(), aMessage);

			break;

			}

		case EWatchFileCancel:

			{

			if (iFileWatcher)

				{

				iFileWatcher->Cancel();

				aMessage.Complete(KErrNone);

				}

			else

				{

				// No file watch request to cancel!

				aMessage.Complete(KErrNotReady);

				}

			break;

			}

		case EGetNumFiles:

			{

			HBufC* dirPath = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);

			CDir* dirContents = NULL;

			User::LeaveIfError(Server().FS().GetDir(*dirPath, KEntryAttNormal, ESortNone, dirContents));

			TPckg<TInt> numFiles(dirContents->Count());

			delete dirContents;

			aMessage.WriteL(1, numFiles);

			aMessage.Complete(KErrNone);

			CleanupStack::PopAndDestroy(dirPath);

			break;

			}

		case ESetSecureClock:

			{

			TTime currentTime(0);

			currentTime.UniversalTime();

			TTimeIntervalSeconds increment(aMessage.Int0());

			currentTime += increment;

			User::SetUTCTimeSecure(currentTime);

			aMessage.Complete(KErrNone);

			}

			break;

		default:

			{

			PanicClient(aMessage,EPanicIllegalFunction);

			break;

			}

		}

	}

void CTestUtilSession::ServiceError(const RMessage2& aMessage,TInt aError)

	{

	if (aError==KErrBadDescriptor)

		PanicClient(aMessage,EPanicBadDescriptor);

	CSession2::ServiceError(aMessage,aError);

	}

// End of file