// ProxyServer.cpp
// 
// Copyright (c) 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//
#include "ProxyServer.h"
#include <fshell/memoryaccess.h>

#define LOG(x...)
#define LOG8(x...)
//#include <e32debug.h>
//#define LOG(x...) RDebug::Print(x)
//#define LOG8(x...) RDebug::Printf(x)

//const TInt KShutdownProxy = 1000;
//const TInt KPingProxy = 1001;

NONSHARABLE_CLASS(CAsyncWaiter) : public CActive
	{
public:
	CAsyncWaiter(RUnderlyingSession& aRealSession, const RMessage2& aOriginalMessage, const TIpcArgs& aArgs);
	~CAsyncWaiter();
	//void ForwardMessageL();

protected:
	void RunL();
	void DoCancel();

private:
	RUnderlyingSession& iRealSession;
	RMessage2 iMsg;
	TIpcArgs iArgs;
	};

CProxyServer* CProxyServer::NewInSeparateThreadL(const TDesC& aServerToReplace, MMessageHandler* aHandler)
	{
	CProxyServer* self = new(ELeave) CProxyServer(aServerToReplace, aHandler);
	CleanupStack::PushL(self);
	self->ThreadConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CProxyServer::CProxyServer(const TDesC& aServerToReplace, MMessageHandler* aHandler)
	: CServer2(0, ESharableSessions), iServerName(aServerToReplace), iHandler(aHandler)
	{
	// Name the server after tid and this pointer, should be unique enough
	iRealServerName.AppendNum(RThread().Id(), EHex);
	iRealServerName.Append('.');
	iRealServerName.AppendNum((TInt)this, EHex);
	}

void CProxyServer::ThreadConstructL()
	{
	User::LeaveIfError(iServerThread.Create(iRealServerName, &StartServerThreadFunction, 8192, NULL, this));
	TRequestStatus stat;
	iServerThread.Rendezvous(stat);
	if (stat == KRequestPending)
		{
		iServerThread.Resume();
		}
	else
		{
		iServerThread.Kill(stat.Int());
		}
	User::WaitForRequest(stat);
	User::LeaveIfError(stat.Int());
	}

void CProxyServer::ConstructL()
	{
	iShutdownCallback = new(ELeave) CAsyncCallBack(CActive::EPriorityHigh);
	iShutdownCallback->Set(TCallBack(&Shutdown, this));

	User::LeaveIfError(iMemAccess.Open());
	if (iRealServerName.Length() > iServerName.Length()) User::Leave(KErrTooBig); // Mem access doesn't like this

	_LIT(KTempName, "TemporaryReallyLongServerNameThatLeavesUsSpaceToManuever");
	StartL(KTempName);

	TServerKernelInfoBuf buf;
	TInt err = iMemAccess.GetObjectInfo(EServer, iServerName, buf);
	User::LeaveIfError(err);
	TUint8* realServer = buf().iAddressOfKernelObject;
	err = iMemAccess.GetObjectInfo(EServer, KTempName, buf);
	User::LeaveIfError(err);
	TUint8* myServer = buf().iAddressOfKernelObject;

	// Should really have some kind of swap operation here...
	TBuf8<KMaxName> name8;
	name8.Copy(iRealServerName);
	iMemAccess.InPlaceObjectRename(EServer, realServer, name8);
	name8.Copy(iServerName);
	iMemAccess.InPlaceObjectRename(EServer, myServer, name8);
	iProxying = ETrue;
	}

TInt CProxyServer::Shutdown(TAny* aSelf)
	{
	CProxyServer* self = static_cast<CProxyServer*>(aSelf);
	delete self;
	CActiveScheduler::Stop();
	return 0;
	}

void CProxyServer::Destroy()
	{
	if (iShutdownCallback && iServerThread.Handle() && iServerThread.Id() != RThread().Id()) // Don't try shutting down the thread if the server is actually running in the main thread
		{
		TRequestStatus stat;
		// This is far harder than it should be... need to make sure we don't reference any member vars after calling the shutdown callback
		RThread serverThread;
		Mem::Swap(&serverThread, &iServerThread, sizeof(RThread));
		serverThread.Logon(stat);
		iShutdownCallback->CallBack();
		User::WaitForRequest(stat);
		serverThread.Close();
		}
	else
		{
		delete this;
		}
	}

CProxyServer::~CProxyServer()
	{
	if (iProxying)
		{
		TServerKernelInfoBuf buf;
		TInt err = iMemAccess.GetObjectInfo(EServer, iRealServerName, buf);
		if (!err)
			{
			TUint8* realServer = buf().iAddressOfKernelObject;
			TBuf8<KMaxName> name8;
			name8.Copy(iServerName);
			iMemAccess.InPlaceObjectRename(EServer, realServer, name8);
			// Temporarily both us and the real server will have name iServerName. When we finish destructing, we'll clean up and the system should be back in a sensible state
			}
		}
	delete iShutdownCallback;
	iServerThread.Close();
	iMemAccess.Close();
	}

CSession2* CProxyServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const
	{
	CProxySession* res = new(ELeave) CProxySession();
	CleanupStack::PushL(res);
	res->ConstructL(iRealServerName, aVersion);
	CleanupStack::Pop(res);
	return res;
	}


void CProxyServer::ServerThreadRunL()
	{
	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);
	
	ConstructL();
	RThread::Rendezvous(KErrNone);

	CActiveScheduler::Start();
	CleanupStack::PopAndDestroy(scheduler);
	}

TInt CProxyServer::StartServerThreadFunction(TAny* aSelf)
	{
	TInt err = KErrNoMemory;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	if (cleanup)
		{
		TRAP(err, static_cast<CProxyServer*>(aSelf)->ServerThreadRunL());
		delete cleanup;
		}
	return err;
	}

MMessageHandler* CProxyServer::Handler() const
	{
	return iHandler;
	}

//

void CProxySession::ConstructL(const TDesC& aServerName, const TVersion& aVersion)
	{
	User::LeaveIfError(iSession.CreateSession(aServerName, aVersion));
	}

CProxyServer& CProxySession::Server()
	{
	return *const_cast<CProxyServer*>(static_cast<const CProxyServer*>(CSession2::Server()));
	}

const CProxyServer& CProxySession::Server() const
	{
	return *static_cast<const CProxyServer*>(CSession2::Server());
	}

void CProxySession::ServiceL(const RMessage2 &aMessage)
	{
	MMessageHandler* handler = Server().Handler();
	TBool handled = EFalse;
	if (handler)
		{
		handled = handler->HandleMessageL(this, aMessage);
		}

	if (!handled)
		{
		ForwardUnhandledMessageL(aMessage);
		}
	}

TInt Val(const RMessage2& aMessage, TInt aIndex)
	{
	switch (aIndex)
		{
	case 0:
		return aMessage.Int0();
	case 1:
		return aMessage.Int1();
	case 2:
		return aMessage.Int2();
	case 3:
		return aMessage.Int3();
	default:
		return 0;
		}
	}

void CleanupArgs(TAny* aArgs)
	{
	TIpcArgs& args = *static_cast<TIpcArgs*>(aArgs);
	for (TInt i = 0; i < KMaxMessageArguments; i++)
		{
		if (args.iFlags & (TIpcArgs::EFlagDes<<(i*TIpcArgs::KBitsPerType)))
			{
			LOG8("+++ deleting %x", args.iArgs[i]);
			delete (TAny*)args.iArgs[i];
			}
		}
	args.iFlags = 0;
	}

void CProxySession::ForwardUnhandledMessageL(const RMessage2& aMessage)
	{
	TIpcArgs args;
	CleanupStack::PushL(TCleanupItem(&CleanupArgs, &args));
	
	LOG(_L("Forwarding message fn=%d"), aMessage.Function());

	for (TInt i = 0; i < KMaxMessageArguments; i++)
		{
		// For each arg, try and figure out if it's a descriptor and if so what type
		TInt len = aMessage.GetDesLength(i);
		if (len < 0)
			{
			// Not a descriptor
			args.Set(i, Val(aMessage, i));
			LOG(_L("Int arg %d: %d"), i, args.iArgs[i]);
			}
		else
			{
			// It's a descriptor, now see if it's 16-bit or 8-bit
			TBuf<1> wbuf;
			TInt err = aMessage.Read(i, wbuf); // This check only works if platsec enforcement is turned on (!) but fshell.bat was the only thing that generally ran with enforcement off, and I've fixed that
			if (err == KErrNone)
				{
				// 16-bit
				// Gaah where's HBuf when you need it
				TPtr* buf = (TPtr*)User::AllocL(len*2 + sizeof(TPtr));
				new(buf) TPtr((TUint16*)(buf+1), len);
				aMessage.ReadL(i, *buf);

				// Figure out if it's writeable by trying to write back what we just read
				TBool writeable = (aMessage.Write(i, *buf) == KErrNone);

				if (writeable)
					{
					LOG(_L("TDes16 arg %d: %S"), i, buf);
					args.Set(i, buf);
					}
				else
					{
					LOG(_L("TDesC16 arg %d: %S"), i, buf);
					args.Set(i, (const TDesC16*)buf);
					}
				}
			else
				{
				// 8-bit
				// Gaah where's HBuf when you need it
				TPtr8* buf = (TPtr8*)User::AllocL(len + sizeof(TPtr8));
				new(buf) TPtr8((TUint8*)(buf+1), len);
				aMessage.ReadL(i, *buf);

				// Figure out if it's writeable by trying to write back what we just read
				TBool writeable = (aMessage.Write(i, *buf) == KErrNone);

				if (writeable)
					{
					LOG8("TDes8 arg %d: %S", i, buf);
					args.Set(i, buf);
					}
				else
					{
					LOG8("TDesC8 arg %d: %S", i, buf);
					args.Set(i, (const TDesC8*)buf);
					}
				}
			}
		}
	ForwardMessageArgsL(aMessage, args);
	CleanupStack::Pop(&args); // ForwardMessageArgs takes ownership
	}

void CProxySession::ForwardMessageArgsL(const RMessage2& aMessage, const TIpcArgs& aArgs)
	{
	CAsyncWaiter* waiter = new(ELeave) CAsyncWaiter(iSession, aMessage, aArgs);
	// That's all that's needed
	}

void CProxySession::Disconnect(const RMessage2 &aMessage)
	{
	iSession.Close();
	//TODO Need to wait for any CAsyncWaiters to be completed? If so, do it here and defer the super call until that time
	CSession2::Disconnect(aMessage);
	}

// CAsyncWaiter

CAsyncWaiter::CAsyncWaiter(RUnderlyingSession& aRealSession, const RMessage2& aOriginalMessage, const TIpcArgs& aArgs)
	: CActive(CActive::EPriorityStandard), iRealSession(aRealSession), iMsg(aOriginalMessage), iArgs(aArgs)
	{
	CActiveScheduler::Add(this);
	LOG(_L("Sending to real server: fn=%d, args=%x,%x,%x,%x flags=%x"), aOriginalMessage.Function(), iArgs.iArgs[0], iArgs.iArgs[1], iArgs.iArgs[2], iArgs.iArgs[3], iArgs.iFlags);
	iRealSession.SendReceive(aOriginalMessage.Function(), iArgs, iStatus);
	SetActive();
	}

CAsyncWaiter::~CAsyncWaiter()
	{
	CleanupArgs(&iArgs);
	}

void CAsyncWaiter::RunL()
	{
	const TInt serverErr = iStatus.Int();
	TInt writeErr = KErrNone;

	// First check for any TDes args that we need to write back to the real client
	for (TInt i = 0; i < KMaxMessageArguments; i++)
		{
		if ((iArgs.iFlags & (TIpcArgs::EFlagDes<<(i*TIpcArgs::KBitsPerType))) && !(iArgs.iFlags & (TIpcArgs::EFlagConst<<(i*TIpcArgs::KBitsPerType))))
			{
			if (iArgs.iFlags & (TIpcArgs::EFlag16Bit<<(i*TIpcArgs::KBitsPerType)))
				{
				TDes16* des = (TDes16*)iArgs.iArgs[i];
				writeErr = iMsg.Write(i, *des);
				LOG(_L("Writing back %S returned %d"), des, writeErr);
				}
			else
				{
				TDes8* des = (TDes8*)iArgs.iArgs[i];
				writeErr = iMsg.Write(i, *des);
				LOG8("Writing back %S returned %d", des, writeErr);
				}

			if (writeErr) break; // Who knows how the real server would have handled such a case
			}
		}

	LOG(_L("Completing original request function %d with writeErr=%d serverErr=%d"), iMsg.Function(), writeErr, serverErr);
	if (writeErr) iMsg.Complete(writeErr);
	else iMsg.Complete(serverErr);

	delete this; // Our work here is done
	}

void CAsyncWaiter::DoCancel()
	{
	// We never call Cancel on our waiters
	}

/*
EXPORT_C TInt ShutdownProxyNotifier()
	{
	RDebugNotifier notifier;
	TInt err = notifier.Connect();
	if (err == KErrNotFound)
		{
		// Oh dear, !Notifier isn't running. Meaning we renamed it then crashed, probably. Try renaming the real one
		RMemoryAccess::LoadDriver();
		RMemoryAccess mem;
		err = mem.Open();
		if (err) return err;
		TServerKernelInfoBuf buf;
		TInt err = mem.GetObjectInfo(EServer, KRealNotifierServerName, buf);
		if (!err)
			{
			TUint8* realServer = buf().iAddressOfKernelObject;
			mem.InPlaceObjectRename(EServer, realServer, _L8("!Notifier"));
			}
		mem.Close();
		return err;
		}

	err = notifier.ShutdownProxy();
	if (err == KErrServerTerminated) err = KErrNone; // It's expected to get KErrServerTerminated, because we deliberately don't complete the message. This way the client is more likely to get the completion once the server has actually gone, and not slightly before
	notifier.Close();

	return err;
	}

EXPORT_C TBool NotifierProxyIsRunning()
	{
	RDebugNotifier notifier;
	TInt err = notifier.Connect();
	if (err) return EFalse; // Not even original notifier is running?!
	err = notifier.PingProxy();
	notifier.Close();
	return err == KErrNone; // The real proxy will return KErrNotSupported in this scenario
	}
*/