// 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 "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:
// MsgTestUtilsServer.cpp
// MessagingTestUtilityServer implementation
// 
//

#include <e32std.h>
#include "MessagingTestUtilityServer.h"
#include "messagingtestutility.h"

//DoDeleteMessageStore headers:
#include "TestUtilityServerObserver.h"

//DoCopyFile headers:
#include <bautils.h>


inline CShutdown::CShutdown()
	:CTimer(-1)
	{CActiveScheduler::Add(this);}
inline void CShutdown::ConstructL()
	{CTimer::ConstructL();}
inline void CShutdown::Start()
	{After(KMyShutdownDelay);}

inline CMessagingTestUtilityServer::CMessagingTestUtilityServer()
	:CServer2(0,ESharableSessions)
	{}

inline CMessagingTestUtilitySession::CMessagingTestUtilitySession()
	{}
inline CMessagingTestUtilityServer& CMessagingTestUtilitySession::Server()
	{return *static_cast<CMessagingTestUtilityServer*>(const_cast<CServer2*>(CSession2::Server()));}


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,"MessagingTestUtilityServer");
 	aMessage.Panic(KPanic,aPanic);
	}

void CMessagingTestUtilitySession::CreateL()
//
// 2nd phase construct for sessions - called by the CServer framework
//
	{
	Server().AddSession();
	
	User::LeaveIfError(iFs.Connect());
	}

CMessagingTestUtilitySession::~CMessagingTestUtilitySession()
	{
	Server().DropSession();
	
	iFs.Close();
	delete iDir;
	}


void CMessagingTestUtilitySession::ServiceL(const RMessage2& aMessage)
//
// Entry point for when a new message is received
//
	{
	TInt result = KErrNone;

	switch (aMessage.Function())
		{
	case EDeleteMessageStore:
		result = DoDeleteMessageStoreL(aMessage);
		break;
	case EKillProcess:
		result = DoKillProcessL(aMessage);
		break;
	case ECopyFile:
		result = DoCopyFileL(aMessage);
		break;
	case EDeleteFile:
		result = DoDeleteFileL(aMessage);
		break;
	case EMkDir:
		result = DoMkDirL(aMessage);
		break;
	case ERmDir:
		result = DoRmDirL(aMessage);
		break;
	case EGetDir:
		result = DoGetDirL(aMessage);
		break;
	case EGetDirCount:
		result = DoGetDirCountL(aMessage);
		break;
	case EGetDirEntry:
		result = DoGetDirEntryL(aMessage);
		break;
	case EFileExists:
		result = DoFileExistsL(aMessage);
		break;
	default:
		PanicClient(aMessage,ETestPanicIllegalFunction);
		break;
		}
	aMessage.Complete(result);
	}

void CMessagingTestUtilitySession::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,ETestPanicBadDescriptor);
	CSession2::ServiceError(aMessage,aError);
	}

void CShutdown::RunL()
//
// Initiate server exit when the timer expires
//
	{
	CActiveScheduler::Stop();
	}

CServer2* CMessagingTestUtilityServer::NewLC()
	{
	CMessagingTestUtilityServer* self=new(ELeave) CMessagingTestUtilityServer;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

void CMessagingTestUtilityServer::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* CMessagingTestUtilityServer::NewSessionL(const TVersion&,const RMessage2&) const
//
// Create a new client session. This should really check the version number.
//
	{
	return new(ELeave) CMessagingTestUtilitySession();
	}

void CMessagingTestUtilityServer::AddSession()
//
// A new session is being created
// Cancel the shutdown timer if it was running
//
	{
	++iSessionCount;
	iShutdown.Cancel();
	}

void CMessagingTestUtilityServer::DropSession()
//
// A session is being destroyed
// Start the shutdown timer if it is the last session.
//
	{
	if (--iSessionCount==0)
		iShutdown.Start();
	}
	
//
//Functions to service calls to the Messaging Test Utility Server:

TInt CMessagingTestUtilitySession::DoDeleteMessageStoreL(const RMessage2& aMessage)
	{
	TPckgBuf<TMsvId> msvIdBuf;
	aMessage.ReadL(0,msvIdBuf);
	TMsvId msvId;	
	msvId = msvIdBuf();
	
	CTestUtilityServerObserver* ob = CTestUtilityServerObserver::NewLC();
	
	CMsvSession* session = CMsvSession::OpenSyncL(*ob);
	CleanupStack::PushL(session);

	CMsvEntry* cEntry = CMsvEntry::NewL(*session, msvId, TMsvSelectionOrdering());
	CleanupStack::PushL(cEntry);

	TInt ret = KErrNone;
/*
	if (cEntry->HasStoreL())
		{
		CMsvStore* store = cEntry->EditStoreL();
		store->DeleteL();
//		test(cEntry->HasStoreL()==EFalse);
		}
	else
		{
		ret = KErrInUse;
		}
*/		
	CMsvStore* store = cEntry->EditStoreL();
	store->DeleteL();
	
	delete store;

	CleanupStack::PopAndDestroy(3); //cEntry, session, ob.
	
	return ret;
	}
	
TInt CMessagingTestUtilitySession::DoKillProcessL(const RMessage2& aMessage)
	{
	TPckgBuf<TProcessId> procIdBuf;
	aMessage.ReadL(0,procIdBuf);
	TProcessId procId;	
	procId = procIdBuf();
	
	RProcess process;
	
	TInt ret;
	
	ret = process.Open(procId);
	
	if (ret != KErrNone)
		return ret;
	
	if (User::ProcessCritical() != User::ENotCritical)
		ret = KErrPermissionDenied;
	else
		process.Kill(KErrNone);
	
	process.Close();
	
	return ret;
	}
	
TInt CMessagingTestUtilitySession::DoCopyFileL(const RMessage2& aMessage)
	{
	TBuf<255> srcPath, destPath;
	aMessage.ReadL(0, srcPath);
	aMessage.ReadL(1, destPath);
	
	TInt ret = BaflUtils::CopyFile(iFs, srcPath, destPath);
	
	return ret;
	}
	
TInt CMessagingTestUtilitySession::DoDeleteFileL(const RMessage2& aMessage)
	{
	TBuf<255> filePath;
	aMessage.ReadL(0, filePath);
		
	TInt ret = iFs.Delete(filePath);
		
	return ret;
	}
	
TInt CMessagingTestUtilitySession::DoMkDirL(const RMessage2& aMessage)
	{
	TBuf<255> dirPath;
	aMessage.ReadL(0, dirPath);
		
	TInt ret = iFs.MkDirAll(dirPath);
		
	return ret;
	}

TInt CMessagingTestUtilitySession::DoRmDirL(const RMessage2& aMessage)
	{
	TBuf<255> dirPath;
	aMessage.ReadL(0, dirPath);
		
	TInt ret = iFs.RmDir(dirPath);
		
	return ret;
	}

TInt CMessagingTestUtilitySession::DoGetDirL(const RMessage2& aMessage)
	{
	TBuf<255> dirPath;
	aMessage.ReadL(0, dirPath);
	
	TPckgBuf<TUint> entryAttMaskBuf;
	aMessage.ReadL(1,entryAttMaskBuf);
	TUint entryAttMask = entryAttMaskBuf();

	TPckgBuf<TUint> entrySortKeyBuf;
	aMessage.ReadL(2,entrySortKeyBuf);
	TUint entrySortKey = entrySortKeyBuf();
	
	delete iDir; //clean up first.
	
	// Hold the CDir* in the Session object.
	// Used by calls to DoGetDirCount() and DoGetDirEntry().	
	TInt ret = iFs.GetDir(dirPath, entryAttMask, entrySortKey, iDir);
	
	return ret;
	}

TInt CMessagingTestUtilitySession::DoGetDirCountL(const RMessage2& aMessage)
	{
	TUint count =0;
	
	if(iDir != 0)
	{
		count = iDir->Count();
		
		TPckgBuf<TUint> countBuf(count);
		aMessage.WriteL(0, countBuf);
		return KErrNone;
	}
	
	return KErrNotFound;
	}

TInt CMessagingTestUtilitySession::DoGetDirEntryL(const RMessage2& aMessage)
	{
	TPckgBuf<TInt> indexBuf;
	aMessage.ReadL(0,indexBuf);
	TInt index = indexBuf();
	
	TEntry entry;
	
	if(iDir != 0)
	{
		entry = iDir->operator[](index);

		TPckgBuf<TEntry> entryBuf(entry);		
		aMessage.WriteL(1, entryBuf);
		return KErrNone;
	}
	
	return KErrNotFound;	
	}
	
TBool CMessagingTestUtilitySession::DoFileExistsL(const RMessage2& aMessage)
	{
	TBuf<255> filePath;
	aMessage.ReadL(0, filePath);
	
	TBool ret = BaflUtils::FileExists(iFs, filePath);
		
	return ret;
	}
	
//EOF