// Copyright (c) 1997-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:
//

#include "SYSIF.H"
#include <estlib.h>
#include "FDESC.H"
#include "PIPEDESC.H"
#include <stdlib.h>

/**
@internalComponent
*/
const TInt KCPosixMajorVersionNumber=2;
const TInt KCPosixMinorVersionNumber=0;
/**
@internalComponent
*/
enum TPosixServerPanic 
	{
	EPosix_BadWaitCompletion=1,
	EPosix_NoPendingIO=2,
	};
/**
@internalComponent
*/
enum PosixMessage {
	// asynchronous operations which need SetActive/RunL
	PMread, PMwrite, PMfsync, 
	PMsendto, PMrecvfrom, PMconnect, PMshutdown, PMaccept,
//NOTIFY PROBLEM
//	PMioctl, 
	PMioctl, PMioctlN,
	// asynchronous operations which just delay completion
	PMwaitpid,
	// synchronous operations
	PMdup, PMdup2,
	PMopen, PMclose, PMlseek, PMfstat,
	PMgetcwd,
	PMchdir, PMmkdir, PMrmdir, 
	PMchmod, PMunlink, PMstat, PMrename,
	PMResolvePath,
	PMsocket, PMbind, PMlisten, PMsockname, PMgetsockopt, PMsetsockopt,
	PMioctlcomplete, PMcancel,
	PMTerminateProcess,
	PMgetenv, PMsetenv, PMunsetenv,
	PMpopen3, 
	// inter-process operations
	PMAreYouMyMother, PMHelloMum, PMPipeWrite, PMPipeRead, PMPipeIoctl, PMPipeClose, PMPipeCancel
	};
/**
@internalComponent
*/
struct PosixParams
	{
	int ret;
	int fid;
	int pint[3];
	const char* cptr[2];
	char* ptr[2];
	const wchar_t* cwptr[2];
	wchar_t* wptr[2];
	wchar_t** eptr[1];
	unsigned long len[1];
	unsigned long* lenp[1];
	TUSockAddr addr;
	};

/**
Package which holds client's process Id.
@internalComponent
*/
typedef TPckgBuf<TInt> TPosixIPCPid;

/**
Package used by server to pass data to client.
@internalComponent
*/
struct PosixIPCReply
	{
	TUint iVarCount;
	TUint iEnvironmentSize;
	TUint iWorkingDirectorySize;
	TUint iPipeMask;
	};
/**
@internalComponent
*/
typedef TPckgBuf<PosixIPCReply> TPosixIPCReply;


//
class RPosixSession : public RSessionBase
/**
@internalComponent
*/
	{
public:
	TInt Connect();
	TInt Connect(TDesC& aServerName);
	
	// for specific posix functions
	int Request(TInt aFunction, int& anErrno, PosixParams& params) const;
	void Request(TInt aFunction, int& anErrno, PosixParams& params, TRequestStatus& aStatus) const;
	// for generic messages
	TInt Request(TInt aFunction, const TIpcArgs& aArg) const;
	void Request(TInt aFunction, const TIpcArgs& aArg, TRequestStatus &aStatus) const;
	
	static TVersion Version();
	};


//
class CPosixRequest;
class CPosixServer;
class CPosixIPCSession;
NONSHARABLE_CLASS(CPosixProcess) : public CActive
/**
@internalComponent
*/
	{
public:
	CPosixProcess(CPosixServer& aServer);
	~CPosixProcess();
	void POpen3L(PosixParams* aParams);
	static CPosixProcess* Find(CPosixProcess* head, TInt pid);
	static void Release(CPosixProcess** aHead, CPosixProcess* aProc);
	void Sizes(TPosixIPCReply& aReply) const;
	void CopyToChildL(const RMessage2& aMessage);
	inline TInt IsAlive() const {return IsActive();}
	inline void Queue(CPosixRequest* aWaiter); 
protected:
	void RunL();
	void DoCancel();

private:
	inline CEnvironment& Env() const;
	inline CFileTable& Fids() const;
	inline RFs& Fs() const;
	inline RCommServ& Cs() const;

public:
	CPosixProcess* iNextProcess;
	TInt iPid;
	TInt iExitReason;
private:
	CPosixServer& iServer;

	RProcess iChild;
	CPosixRequest* iWaiters;

	TUint iVarCount;
	HBufC16* iEnvironment;
	HBufC* iWorkingDirectory;
	CPipeDesc* iPipes[3];
	};
//
class CPosixRequest;

/**
@internalComponent
*/
NONSHARABLE_CLASS(CPosixServer) : public CServer2
	{
public:
	static TInt ThreadFunction(TAny* aPtr);
	static void InitL(TInt aPriority);
	RFs& Fs()           { return iFs; }
	RCommServ& Cs()     { return iCs; }
	CFileTable& Fids()  { return iFids; }
	RSocketServ& Ss()   { return iSs; }
	CEnvironment& Env() { return iEnv; }

	int POpen3(PosixParams* aParams, int& anErrno);
	CPosixProcess* Child(TInt pid)	{ return CPosixProcess::Find(iChildren, pid); }
	void Release(CPosixProcess* aChild) { CPosixProcess::Release(&iChildren, aChild); }
	inline void WaitForAnyChild(CPosixRequest* aWaiter);
	CPosixRequest* Waiters();
	static void ServerPanic(TPosixServerPanic aPanic);

protected:
	CPosixServer(TInt aPriority);
	CSession2* NewSessionL(const TVersion& aVersion, const RMessage2& aMessage) const;
	void FindParentL();
	void DefaultConsoleL();
private:
	RFs iFs;
	CFileTable iFids;
	RSocketServ iSs;
	RCommServ	iCs;

	CEnvironment iEnv;
	RPosixSession iParent;
	CPosixProcess* iChildren;
	CPosixRequest* iWaitAnyQueue;
	};

//
class CPosixSession;
NONSHARABLE_CLASS(CPosixRequest) : public CActive
/**
@internalComponent
*/
	{
public:
	CPosixRequest(CPosixServer& aServer);
	~CPosixRequest();
	void Service(const RMessage2& aMessage);
	void EnList(CPosixRequest*& aHead);	// simple single linked list
	void WaitCompleted(TInt aPid, TInt aReason);
protected:
	void RunL();
	void DoCancel();
private:
	RFs& Fs() const           { return iServer.Fs(); }
	RCommServ& Cs() const           { return iServer.Cs(); }
	CFileTable& Fids() const  { return iServer.Fids(); }
	RSocketServ& Ss() const   { return iServer.Ss(); }
	CEnvironment& Env() const { return iServer.Env(); }
private:
	void QueueAsynch(const RMessage2& aMessage);
	void StartAsynch();
	void EndAsynch(TInt aResult);

	CPosixServer& iServer;

	RMessage2 iMessage;

	CFileDescBase* iFile;
	CSocketDesc* iNewF;
	int iNewFid;
	TPtr8 iPtr;

	CPosixRequest* iNext;	// for Enlist
	TSglQueLink iLink;
	enum CFileDescBase::IOQueues iQueue;

	friend class TPosixRequestQueue;
	friend class CFileDescBase;		// friend functions AddLast & Remove perhaps? 
	};
//
inline CEnvironment& CPosixProcess::Env() const { return iServer.Env(); }
inline CFileTable& CPosixProcess::Fids() const  { return iServer.Fids(); }
inline RFs& CPosixProcess::Fs() const           { return iServer.Fs(); }
inline RCommServ& CPosixProcess::Cs() const           { return iServer.Cs(); }
inline void CPosixProcess::Queue(CPosixRequest* aWaiter)          { aWaiter->EnList(iWaiters); }
inline void CPosixServer::WaitForAnyChild(CPosixRequest* aWaiter) { aWaiter->EnList(iWaitAnyQueue); }

//
/**
@internalComponent
*/
NONSHARABLE_CLASS(CPosixSession) : public CSession2
	{
public:
	CPosixSession(CPosixServer& aServer);
	virtual void ServiceL(const RMessage2& aMessage);
protected:
	CPosixRequest iActive;
	};

NONSHARABLE_CLASS(CPosixIPCSession) : public CPosixSession
/**
@internalComponent
*/
	{
public:
	inline CPosixIPCSession(CPosixServer& aServer) 
		: CPosixSession(aServer) {}
	virtual void ServiceL(const RMessage2& aMessage);	 // override the local ServiceL
	void SetPipes(CPipeDesc* aPipes[3]);
	~CPosixIPCSession();

private:
	TInt AreYouMyMotherL(const RMessage2& aMessage);
	TInt HelloMumL(const RMessage2& aMessage);
	void PipeRead(const RMessage2& aMessage);
	void PipeWrite(const RMessage2& aMessage);
	void PipeIoctl(const RMessage2& aMessage);
	void PipeClose(const RMessage2& aMessage);
	void PipeCancel(const RMessage2& aMessage);

	CPipeDesc* iPipes[3];
	};
//
NONSHARABLE_CLASS(CProcessSystemInterface) : public MSystemInterface, public CBase
/**
@internalComponent
*/
	{
public:
	CProcessSystemInterface();
	~CProcessSystemInterface();

	TInt Connect();
	virtual MSystemInterface& Clone();
	virtual void Release();
	virtual void TerminateProcess(int status);

	virtual int dup (int fid, int& anErrno);
	virtual int dup2 (int fid, int fid2, int& anErrno);
	virtual int open (const wchar_t* name, int mode, int perms, int& anErrno);
	virtual int read (int fid, char* buf, unsigned long len, int& anErrno);
	virtual int write (int fid, const char* buf, unsigned long len, int& anErrno);
	virtual int fsync (int fid, int& anErrno);
	virtual int close (int fid, int& anErrno);
	virtual int lseek (int fid, int offset, int whence, int& anErrno);
	virtual int fstat (int fid, struct stat *st, int& anErrno);
	virtual int ioctl (int fid, int cmd, void* param, int& anErrno);
	virtual int ioctl (int fid, int cmd, void* param, TRequestStatus& aStatus, int& anErrno);
	virtual int ioctl_complete (int fid, int cmd, void* param, TRequestStatus& aStatus, int& anErrno);
	virtual int ioctl_cancel (int fid, int& anErrno);

	virtual wchar_t * getcwd (wchar_t * buf, unsigned long len, int& anErrno);

	virtual int chdir (const wchar_t* path, int& anErrno);
	virtual int mkdir (const wchar_t* path, int perms, int& anErrno);
	virtual int rmdir (const wchar_t* path, int& anErrno);
	virtual int chmod (const wchar_t* path, int perms, int& anErrno);
	virtual int unlink (const wchar_t* path, int& anErrno);
	virtual int stat (const wchar_t* name, struct stat *st, int& anErrno);
	virtual int rename (const wchar_t* oldname, const wchar_t* newname, int& anErrno);

	virtual TInt ResolvePath (TParse& aResult, const wchar_t* path, TDes* aFilename);

	virtual int socket (int family, int style, int protocol, int& anErrno);
	virtual int recvfrom (int fd, char* buf, unsigned long cnt, int flags, struct sockaddr* from, unsigned long* fromsize, int& anErrno);
	virtual int sendto (int fd, const char* buf, unsigned long cnt, int flags, struct sockaddr* to, unsigned long tosize, int& anErrno);
	virtual int shutdown (int fd, int how, int& anErrno);
	virtual int listen (int fd, int n, int& anErrno);
	virtual int accept (int fd, int& anErrno);
	virtual int bind (int fd, struct sockaddr* addr, unsigned long size, int& anErrno);
	virtual int connect (int fd, struct sockaddr* addr, unsigned long size, int& anErrno);
	virtual int sockname (int fd, struct sockaddr* addr, unsigned long* size, int anEnd, int& anErrno);
	virtual int getsockopt (int fd, int level, int opt, void* buf, unsigned long* len, int& anErrno);
	virtual int setsockopt (int fd, int level, int opt, void* buf, unsigned long len, int& anErrno);

	virtual wchar_t* getenv (const wchar_t* name); 
	virtual void unsetenv (const wchar_t* name);
	virtual int setenv (const wchar_t* name, const wchar_t* value, int rewrite, int& anErrno);

	virtual int popen3 (const wchar_t *file, const wchar_t *cmd, const wchar_t *mode, wchar_t** envp, int fids[3], int& anErrno);
	virtual int waitpid (int pid, int* status, int options, int& anErrno);

private:
	int Request(TInt aFunction, int& anErrno);
	void Request(TInt aFunction, int& anErrno, TRequestStatus& aStatus);
	RPosixSession iSession;
	PosixParams iParams;
	};