diff -r 000000000000 -r bde4ae8d615e os/security/cryptomgmtlibs/securitytestfw/test/testutil/server/testutilsession.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/security/cryptomgmtlibs/securitytestfw/test/testutil/server/testutilsession.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,472 @@
+/*
+* 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