diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericopenlibs/cstdlib/INC/POSIXIF.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericopenlibs/cstdlib/INC/POSIXIF.H Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,361 @@ +// 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 +#include "FDESC.H" +#include "PIPEDESC.H" +#include + +/** +@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 TPosixIPCPid; + +/** +Package used by server to pass data to client. +@internalComponent +*/ +struct PosixIPCReply + { + TUint iVarCount; + TUint iEnvironmentSize; + TUint iWorkingDirectorySize; + TUint iPipeMask; + }; +/** +@internalComponent +*/ +typedef TPckgBuf 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; + };