diff -r 000000000000 -r 9736f095102e buildverification/smoketest/Utils/Src/SmokeTestSecureFSserver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/buildverification/smoketest/Utils/Src/SmokeTestSecureFSserver.cpp	Tue Jan 26 15:16:33 2010 +0200
@@ -0,0 +1,393 @@
+// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "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:
+// TestServer - server implementation
+// 
+//
+
+#include "e32std.h"
+#include "SmokeTestSecureFSserver.h"
+#include <f32file.h>
+
+TRequestStatus aStatus;
+TRequestStatus* aSt = &aStatus;
+
+
+inline CTestSecureFSshutdown::CTestSecureFSshutdown()
+	:CTimer(-1)
+	{CActiveScheduler::Add(this);}
+inline void CTestSecureFSshutdown::ConstructL()
+	{CTimer::ConstructL();}
+inline void CTestSecureFSshutdown::Start()
+	{After(KMyShutdownDelay);}
+
+inline CTestSecureFSserver::CTestSecureFSserver()
+	:CServer2(0,ESharableSessions)
+	{}
+
+inline CTestSecureFSSession::CTestSecureFSSession()
+	{}
+inline CTestSecureFSserver& CTestSecureFSSession::Server()
+	{return *static_cast<CTestSecureFSserver*>(const_cast<CServer2*>(CSession2::Server()));}
+inline TBool CTestSecureFSSession::ReceivePending() const
+	{return !iReceive.IsNull();}
+
+//
+
+void CTestSecureFSSession::CreateL()
+//
+// 2nd phase construct for sessions - called by the CServer framework
+//
+	{
+	//RDebug::Print(_L("Server::CTestSecureFSSession::CreateL - start"));
+
+	Server().AddSession();
+	//RDebug::Print(_L("Server::CTestSecureFSSession::CreateL - end"));
+	}
+
+CTestSecureFSSession::~CTestSecureFSSession()
+	{
+	Server().DropSession();
+	}
+
+void CTestSecureFSSession::Send(const TDesC& aMessage)
+//
+// Deliver the message to the client, truncating if required
+// If the write fails, panic the client, not the sender
+//
+	{
+	if (ReceivePending())
+		{
+		TPtrC m(aMessage);
+		if (iReceive.Int1()<aMessage.Length())
+			m.Set(m.Left(iReceive.Int1()));
+		TInt r=iReceive.Write(0,m);
+		if (r==KErrNone)
+			iReceive.Complete(KErrNone);
+		else
+			PanicClient(iReceive,EPanicBadDescriptor);
+		}
+	}
+
+void CTestSecureFSSession::ServiceL(const RMessage2& aMessage)
+//
+// Handle a client request.
+// Leaving is handled by CMyServer::ServiceError() which reports
+// the error code to the client
+//
+	{
+	TInt result = KErrNone;
+
+	switch (aMessage.Function())
+		{
+	case ETestIpcSetHomeTime:
+		DoSetHomeTime(aMessage);
+		break;
+
+	case ETestIpcDeleteFile:
+		result = DoDeleteFileL(aMessage);
+		break;
+	
+	case ETestIpcKillProcess:
+		DoKillProcess(aMessage);
+		break;
+
+	case ETestIpcChangeLocale:
+		result = DoChangeLocale(aMessage);
+		break;
+		
+	case ETestIpcCheckForFile:
+	    result = DoCheckForFile(aMessage);
+	    break;
+	    
+	case ETestIpcCopyFile:
+	    result = DoCopyFile(aMessage);
+	    break; 
+	    
+	case ETestIpcSetUpFbs:
+	    DoSetUpFbs(); 
+	    break;
+	     
+	default:
+		PanicClient(aMessage,EPanicIllegalFunction);
+		break;
+		}
+	aMessage.Complete(result);
+	}
+
+//
+
+void CTestSecureFSSession::DoSetHomeTime(const RMessage2& aMessage)
+	{
+	TPckgBuf<TTime> pckg;
+	aMessage.Read(0,pckg);
+	User::SetHomeTime(pckg());
+	}
+
+TInt CTestSecureFSSession::DoDeleteFileL(const RMessage2& aMessage)
+	{
+	RFs fs;
+	TFileName* const fileName=new(ELeave) TFileName;
+	CleanupStack::PushL(fileName);
+	User::LeaveIfError(fs.Connect());
+
+	CleanupClosePushL(fs);
+	aMessage.ReadL(0,*fileName);
+	TInt err=fs.Delete(*fileName);
+	if (!(err==KErrNone || err==KErrNotFound || err==KErrPathNotFound)) // ignore not found error
+		{
+		User::Leave(err);
+		}
+	CleanupStack::PopAndDestroy(&fs);
+	CleanupStack::PopAndDestroy(fileName);
+	return err;
+	}
+
+void CTestSecureFSSession::DoKillProcess(const RMessage2& aMessage)
+	{
+	TFullName* name = new(ELeave) TFullName;
+	CleanupStack::PushL(name);
+
+	aMessage.ReadL(0,*name);
+	TFindProcess* finder = new (ELeave) TFindProcess(*name);
+	CleanupStack::PushL(finder);
+	RProcess* process = new (ELeave) RProcess;
+	CleanupStack::PushL(process);
+
+	if (finder->Next(*name) == KErrNone)
+		{
+		if (process->Open(*name) == KErrNone)
+			{
+			process->Kill(KErrNone);
+			}
+		}
+
+	if (process != NULL)
+		{
+		process->Close();
+		}
+	CleanupStack::PopAndDestroy(process);
+	CleanupStack::PopAndDestroy(finder);
+	CleanupStack::PopAndDestroy(name);		
+	}
+
+
+TInt CTestSecureFSSession::DoChangeLocale(const RMessage2& aMessage)
+	{
+	TBuf<50> locname;
+	TInt result;
+	aMessage.ReadL(0,locname);
+
+	result = UserSvr::ChangeLocale(locname);
+
+	return result;
+	}
+
+TInt CTestSecureFSSession::DoCheckForFile(const RMessage2& aMessage)
+{
+    RFs fs;
+    TInt err;
+	TFileName* const fileName=new(ELeave) TFileName;
+	CleanupStack::PushL(fileName);
+	User::LeaveIfError(fs.Connect());
+
+	CleanupClosePushL(fs);
+	aMessage.ReadL(0,*fileName);
+	
+	TUint attribs;
+	err=fs.Att(*fileName, attribs);
+	fs.Close();
+		
+	CleanupStack::PopAndDestroy(&fs);
+	CleanupStack::PopAndDestroy(fileName);
+	return err;
+	
+}
+
+TInt CTestSecureFSSession::DoCopyFile(const RMessage2& aMessage)
+{
+
+    RFs fs;
+    TInt result;
+ 
+    User::LeaveIfError(fs.Connect());
+    CleanupClosePushL(fs);
+
+    TFileName fileSource;
+    TFileName fileDest;
+
+    aMessage.ReadL(0,fileSource);
+    aMessage.ReadL(1,fileDest);
+    	   
+	CFileMan* fileMan = NULL;
+	
+	fileMan = CFileMan::NewL(fs);
+	CleanupStack::PushL( fileMan );
+	
+	fs.MkDirAll(fileDest);
+	result = fileMan->Copy( fileSource, fileDest, CFileMan::EOverWrite );
+	
+	User::LeaveIfError(fs.Connect());
+	fs.SetAtt(fileDest,KEntryAttNormal,KEntryAttReadOnly);
+	fs.Close();
+
+    CleanupStack::PopAndDestroy(fileMan);
+    CleanupStack::PopAndDestroy(&fs);
+	return result;
+	
+}
+
+void CTestSecureFSSession::DoSetUpFbs()
+{
+//	FbsStartup();
+//    User::LeaveIfError( RFbsSession::Connect() );
+//   CleanupStack::PushL( TCleanupItem( TCleanupOperation(&RFbsSession::Disconnect ), NULL ) );
+}
+
+//
+
+void CTestSecureFSSession::ServiceError(const RMessage2& aMessage,TInt aError)
+//
+// Handle an error from CMySession::ServiceL()
+// A bad descriptor error implies a badly programmed client, so panic it;
+// otherwise use the default handling (report the error to the client)
+//
+	{
+	if (aError==KErrBadDescriptor)
+		PanicClient(aMessage,EPanicBadDescriptor);
+	CSession2::ServiceError(aMessage,aError);
+	}
+
+void CTestSecureFSshutdown::RunL()
+//
+// Initiate server exit when the timer expires
+//
+	{
+	CActiveScheduler::Stop();
+	}
+
+CServer2* CTestSecureFSserver::NewLC()
+	{
+	CTestSecureFSserver* self=new(ELeave) CTestSecureFSserver;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CTestSecureFSserver::ConstructL()
+//
+// 2nd phase construction - ensure the timer and server objects are running
+//
+	{
+	StartL(KTestServerName);
+	iShutdown.ConstructL();
+	// ensure that the server still exits even if the 1st client fails to connect
+	iShutdown.Start();
+	}
+
+
+CSession2* CTestSecureFSserver::NewSessionL(const TVersion&,const RMessage2&) const
+//
+// Cretae a new client session. This should really check the version number.
+//
+	{
+	return new(ELeave) CTestSecureFSSession();
+	}
+
+void CTestSecureFSserver::AddSession()
+//
+// A new session is being created
+// Cancel the shutdown timer if it was running
+//
+	{
+	++iSessionCount;
+	iShutdown.Cancel();
+	}
+
+void CTestSecureFSserver::DropSession()
+//
+// A session is being destroyed
+// Start the shutdown timer if it is the last session.
+//
+	{
+	if (--iSessionCount==0)
+		iShutdown.Start();
+	}
+
+void CTestSecureFSserver::Send(const TDesC& aMessage)
+//
+// Pass on the signal to all clients
+//
+	{
+	iSessionIter.SetToFirst();
+	CSession2* s;
+	while ((s=iSessionIter++)!=0)
+		static_cast<CTestSecureFSSession*>(s)->Send(aMessage);
+	}
+
+void PanicClient(const RMessage2& aMessage,TTestPanic aPanic)
+//
+// RMessage::Panic() also completes the message. This is:
+// (a) important for efficient cleanup within the kernel
+// (b) a problem if the message is completed a second time
+//
+	{
+	_LIT(KPanic,"TestServer");
+ 	aMessage.Panic(KPanic,aPanic);
+	}
+
+
+
+/**
+Perform all server initialisation, in particular creation of the
+scheduler and server and then run the scheduler
+*/
+
+static void RunServerL()
+	{
+	// naming the server thread after the server helps to debug panics
+  	User::LeaveIfError(RThread::RenameMe(KTestServerName));
+	// create and install the active scheduler we need
+	CActiveScheduler* s=new(ELeave) CActiveScheduler;
+	CleanupStack::PushL(s);
+	CActiveScheduler::Install(s);
+	CTestSecureFSserver::NewLC(); // create the server (leave it on the cleanup stack)
+	RProcess::Rendezvous(KErrNone);
+	CActiveScheduler::Start();
+	CleanupStack::PopAndDestroy(2); 	// Cleanup the server and scheduler
+	}
+
+
+
+
+TInt E32Main()
+//
+// Server process entry-point
+//
+	{
+	__UHEAP_MARK;
+	//
+	RDebug::Print(_L("Server::E32Main Version 0.0.0"));
+	CTrapCleanup* cleanup=CTrapCleanup::New();
+	TInt r=KErrNoMemory;
+	if (cleanup)
+		{
+		TRAP(r,RunServerL());
+		delete cleanup;
+		}
+	//
+	__UHEAP_MARKEND;
+	return r;
+	}
+
+