// sandbox.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 <e32base.h>

#include "sandbox.h"

#include <APMREC.H>

#include <fshell/memoryaccess.h>

enum TMsg

	{

	EGetRecog,

	EGetRecog2,

	ECloseServer,

	EGetVTablePtr,

	EMaxArgs,

	};

#ifndef SERVER

class RSandboxSession : public RSessionBase

	{

public:

	TInt Connect(const TDesC& aServerName)

		{

		return CreateSession(aServerName, TVersion(0,0,0));

		}

	TInt GetRecogniserInfo(TUid aImplementationUid, RArray<TDataType>& aMimeTypes)

		{

		TInt size = SendReceive(EGetRecog, TIpcArgs(aImplementationUid.iUid));

		if (size < 0) return size;

		TInt err = aMimeTypes.Reserve(size/sizeof(TDataType));

		if (err) return err;

		RBuf8 buf;

		err = buf.Create(size);

		if (err) return err;

		err = SendReceive(EGetRecog2, TIpcArgs(&buf));

		if (err) { buf.Close(); return err; }

		const TDataType* ptr = (const TDataType*)buf.Ptr();

		for (TInt i = 0; i < size/sizeof(TDataType); i++)

			{

			err = aMimeTypes.Append(ptr[i]);

			if (err) break;

			}

		buf.Close();

		return err;

		}

	TInt GetVTablePtrFromEcomUid(TUid aUid, TAny*& vtablePtr)

		{

		TPckgBuf<TAny*> pkg(NULL);

		TInt err = SendReceive(EGetVTablePtr, TIpcArgs(aUid.iUid, &pkg));

		if (err) return err;

		vtablePtr = pkg();

		return KErrNone;

		}

	void Byebye()

		{

		SendReceive(ECloseServer);

		}

	};

#define GETSESSIONL(process, session)										\

	RProcess process;														\

	User::LeaveIfError(process.Create(_L("QR3Sandbox.exe"), KNullDesC));	\

	TRequestStatus stat;													\

	process.Rendezvous(stat);												\

	process.Resume();														\

	User::WaitForRequest(stat);												\

																			\

	RSandboxSession session;												\

	User::LeaveIfError(session.Connect(sandbox.FullName()));

void Sandbox::GetRecogniserInfoL(TUid aImplementationUid, RArray<TDataType>& aMimeTypes)

	{

	GETSESSIONL(sandbox, sess);

	User::LeaveIfError(sess.GetRecogniserInfo(aImplementationUid, aMimeTypes));

	sess.Byebye();

	sandbox.Close();

	}

void Sandbox::GetDllNameFromEcomUidL(RMemoryAccess& aMemAccess, TUid aUid, TFileName& aFileName)

	{

	// Try and instanciate object and figure out what DLL it belongs to by looking up its vtable pointer

	// We do the instanciation in a separate process so as to avoid worrying about cleanup or side-effects of instanciation

	GETSESSIONL(sandbox, sess);

	TAny* vtablePtr = NULL;

	TInt err = sess.GetVTablePtrFromEcomUid(aUid, vtablePtr);

	TFullName8 dllName;

	if (!err)

		{

		err = aMemAccess.FindAddressInCodeSegments(dllName, vtablePtr);

		}

	sess.Byebye(); // We have to call FindAddressInCodeSegments before sandbox exits, because when it does the code segment will most likely be unloaded!

	sandbox.Close();

	User::LeaveIfError(err);

	aFileName.Copy(dllName);

	}

#else

#include <e32property.h>

#include <ecom/ecom.h>

void GoL();

class CSandboxSession : public CSession2

	{

	void ServiceL(const RMessage2 &aMessage);

	RBuf8 iBuf;

	};

class CSandboxServer : public CServer2

	{

public:

	CSandboxServer() : CServer2(0,ESharableSessions) {}

protected:

	CSession2* NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

		{

		return new(ELeave) CSandboxSession();

		}

	};

TInt E32Main()

	{

	User::SetJustInTime(EFalse); // Don't want to debug problems in the sandbox

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TRAPD(err, GoL());

	return err;

	}

void GoL()

	{

	CActiveScheduler* s=new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(s);

	CSandboxServer* server = new(ELeave) CSandboxServer();

	// Scope the TFullName

		{

		TFullName serverName = RProcess().FullName();

		server->StartL(serverName);

		}

	RProcess::Rendezvous(KErrNone);

	CActiveScheduler::Start();

	}

void CSandboxSession::ServiceL(const RMessage2 &aMessage)

	{

	if (aMessage.Function() >= EMaxArgs)

		{

		aMessage.Complete(KErrArgument);

		return;

		}

	if (aMessage.Function() == EGetRecog2)

		{

		aMessage.WriteL(0, iBuf);

		iBuf.Close();

		aMessage.Complete(KErrNone);

		}

	else if (aMessage.Function() == EGetRecog)

		{

		if (iBuf.MaxLength() == 0)

			{

			iBuf.ReAllocL(1024); // Must be > sizeof(TDataType) otherwise the reallocating logic below is flawed

			}

		TUid uid = TUid::Uid(aMessage.Int0());

		TUid destructorKey;

		CApaDataRecognizerType* rec = static_cast<CApaDataRecognizerType*>(REComSession::CreateImplementationL(uid, destructorKey));

		TInt count = rec->MimeTypesCount();

		for (TInt j = 0; j < count; j++)

			{

			TDataType type = rec->SupportedDataTypeL(j);

			TPckg<TDataType> buf(type);

			if (iBuf.Length() + buf.Length() >= iBuf.MaxLength())

				{

				iBuf.ReAllocL(iBuf.MaxLength() * 2);

				}

			iBuf.Append(buf);

			}

		aMessage.Complete(iBuf.Size());

		}

	else if (aMessage.Function() == ECloseServer)

		{

		aMessage.Complete(KErrNone);

		CActiveScheduler::Stop();

		}

	else if (aMessage.Function() == EGetVTablePtr)

		{

		TUid destructorKey;

		TAny* obj = NULL;

		obj = REComSession::CreateImplementationL(TUid::Uid(aMessage.Int0()), destructorKey);

		TAny* vtablePtr = *((TAny**)obj);	

		TPckg<TAny*> res(vtablePtr);

		aMessage.WriteL(1, res);

		aMessage.Complete(KErrNone);

		}

	else

		{

		ASSERT(0);

		}

	}

#endif