diff -r 000000000000 -r e4d67989cc36 genericopenlibs/openenvcore/backend/inc/sysif.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/genericopenlibs/openenvcore/backend/inc/sysif.h Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,931 @@ +/* +* Copyright (c) 1998-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: +* +*/ + + +#ifndef SYSIF_H +#define SYSIF_H +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ipcclient.h" +#include +#include +#include +#include +#include +#include + +#ifdef SYMBIAN_OE_POSIX_SIGNALS +#include "signalclient.h" +#include "tsignalmessage.h" + +typedef void (*TSignalHandler)(int); +typedef void (*TSignalAction)(int, siginfo_t *, void *); +#endif + +/* +@internalComponent +*/ +_LIT(KEstlibInit, "STDLIBS-INIT"); + +_LIT(KFDTransferSvr,"FDTrnsfrSvr"); +//Forward declaration for references below +class RPipe; +class CFileDesTransferServer; +class RFileDesTransferSession; +class CFileDescBase; +/* TODO: We don't have to do this in CFileTable. Move to methods */ +class CFileSocketDesc; + +struct TChild +/* +@internalComponent +*/ + { + TInt iFid; + TProcessId iPid; + RProcess iProc; + +#ifdef __X86GCC__ + // The underlying data for a TProcessId is a TUint64. GCC raises an error if this is intialised to a negative value. Consider changing for all platforms. + TChild(TInt aFid = -1, TProcessId aPid = 0) : iFid(aFid), iPid(aPid) +#else + TChild(TInt aFid = -1, TProcessId aPid = -1) : iFid(aFid), iPid(aPid) +#endif //__X86GCC__ + { + // nada + } + +#ifdef __X86GCC__ + // The underlying data for a TProcessId is a TUint64. GCC raises an error if this is intialised to a negative value. Consider changing for all platforms. + TChild(RProcess &aProc, TProcessId aFid = 0) : iProc(aProc), iFid(aFid) +#else + TChild(RProcess &aProc, TProcessId aFid = -1) : iProc(aProc), iFid(aFid) +#endif //__X86GCC__ + { + iPid = aProc.Id(); + } + + + static TBool MatchByFid(const TChild& aChild1, const TChild& aChild2) + { + if (aChild1.iFid == aChild2.iFid) + { + return ETrue; + } + return EFalse; + } + + static TBool MatchByPid(const TChild& aChild1, const TChild& aChild2) + { + if (aChild1.iPid == aChild2.iPid) + { + return ETrue; + } + return EFalse; + } + }; + +class TCLSICleanup +/* +@internalComponent +*/ + { +public: + void StorePtrs(RHeap* aHeap, RFs* aFs, RSocketServ* aSs, RCommServ* aCs, RFastLock* aSsLock, RFastLock* aCsLock) + { + iHeap = aHeap; + iFs = aFs; + iSs = aSs; + iCs = aCs; + iSsLock = aSsLock; + iCsLock = aCsLock; + } + + ~TCLSICleanup() + { + iFs->Close(); + iSs->Close(); + iSsLock->Close(); + iCs->Close(); + iCsLock->Close(); + iHeap->Close(); + } +private: + RHeap* iHeap; + RFs* iFs; + RSocketServ* iSs; + RCommServ* iCs; + RFastLock* iSsLock; + RFastLock* iCsLock; + }; + + +class TFileTableCleanup +{ +public: + void SaveUserHeap(RHeap* aHeap) + { + iUserHeap = aHeap; + } + + ~TFileTableCleanup() + { + User::SwitchHeap(iUserHeap); + } + +private: + RHeap* iUserHeap; +}; + + +class CFileTable +/* +@internalComponent +*/ + { +public: + CFileTable(); + ~CFileTable(); + + TInt Init(RHeap* aHeap = NULL); + void Close(); + void Default(CFileDescBase* aRedirMedia, CFileDescBase* aStdErrMedia); + TInt Reserve(); + TInt Attach(TInt aFid, CFileDescBase* aFile); + TInt Detach(TInt aFid, CFileDescBase*& aDetached); + TInt At(TInt aFid, CFileDescBase*& aFound) const; + TInt Reserve(TInt aFids[3]); + TInt Detach(TInt aFids[3]); + + int dup (int fid, int& anErrno); + int dup2 (int fid1, int fid2, int& anErrno); + int open (const wchar_t* name, int mode, int perms, int& anErrno); + int close (int fid, int& anErrno); + + int UserClose (int fid, int& anErrno); + + off_t lseek (int fid, off_t offset, int whence, int& anErrno); + int fstat (int fid, struct stat* st, int& anErrno); + int socket (int family, int style, int protocol, int& anErrno, RSocketServ& aSs); + int listen (int fd, int n, int& anErrno); + int bind (int fd, const struct sockaddr* addr, unsigned long size, int& anErrno); + int sockname (int fd, struct sockaddr* address, unsigned long* aAddrLen,int anEnd, int& anErrno); + int getsockopt (int fd, int level, int opt, void* buf, unsigned long* len, int& anErrno); + int setsockopt (int fd, int level, int opt, void* buf, unsigned long len, int& anErrno); + int ioctlcomplete (int fid, int cmd, void* param, TRequestStatus& aStatus, int& anErrno); + int ioctlcancel (int fid, int& anErrno); + int fcntl (int aFid, int aCmd, long anArg, int& anErrno); + + TInt Asynch (int fid, CFileDescBase*& aFile); + + int popen (const wchar_t* file, const wchar_t* cmd,const char* mode, int& anErrno); + int pclose (int aFid, int& anErrno); + int popen3 (const wchar_t *file, const wchar_t *cmd, wchar_t** envp, int fids[3], int& anErrno); + int system (const wchar_t* aCmd, const wchar_t* aCmdArg, int& anErrno); + int waitpid (int pid, int* status, int options, int& anErrno); + + int posix_spawn (int* pid, const wchar_t* wpath, + const posix_spawn_file_actions_t* file_actions, + const posix_spawnattr_t* attrp, + const wchar_t* wargs, wchar_t** wenvp); + + void TransferToChild (RProcess& child, TInt aFds[], TInt aWhich, TInt aSlot); + void PassEnvToChild (RProcess& child, wchar_t** aEnvp); + void PassFileActionsToChild (RProcess& child, + const posix_spawn_file_actions_t* aFileActions); + +#ifdef SYMBIAN_OE_POSIX_SIGNALS + void TransferSigMaskToChild(RProcess& childproc,TDes& sigmask); + void CheckOrigins (wchar_t**& wenvp, int& aCount, TUint64 & aSigMask); +#else + void CheckOrigins (wchar_t**& wenvp, int& aCount); +#endif + TInt InheritFiles(CFileDesTransferServer* server); + int pipe (int fildes[2], int& anErrno); + int mkfifo (const wchar_t *pathname, mode_t mode, int& anErrno, RFs& aFs); + int CreatePipeDesc (int fildes, RPipe& aHandle, TUint16 aMode = 0); + void ClosePipe (int fds[2], int& err); + + static CFileDescBase* FifoOpen (const wchar_t* pathName, mode_t mode, int perms, int& anErrno); + int link (const wchar_t *oldpathName, const wchar_t *newpathName, int& anErrno, RFs& aFs); + static CFileDescBase* LinkOpen (const wchar_t* pathName, mode_t mode, int perms, int& anErrno, RFs& aFs); + int unlink (RFs& aFs, const wchar_t *pathName, int& anErrno); + int AcceptFileSocket(CFileSocketDesc* pfs, const struct sockaddr_un* addr, int& anErrno, RFs& aFs); + TInt RConnectionCount(); + TInt RConnectionAt (TInt aRcIndex, RConnection *&aRc); + TInt AddRConnectionPtr (RConnection *aRc, TInt &aRcIndex); + void RemoveRConnectionPtrAt (TInt aRcIndex); + void DeleteRConnectionList(); + + CFileDesTransferServer* NewFDTransferServerL(RSemaphore &sem); + void StartFDTransferServer(CFileDesTransferServer* pServer); + void CloseFDTransferServer(CFileDesTransferServer* pServer); + + int SetEcho(int aFd, TUint8 aEcho, int& aErrno); + + void DoTransferAll(RSemaphore &sem,TDesC& name); + TInt GetFileCount() const + { + return iFids.Count(); + } + + void Lock() + { + iFidLock.Wait(); + } + + void Unlock() + { + iFidLock.Signal(); + } + +private: + TFileTableCleanup iCleanup; + CArrayPtrSeg iFids; + // invoked by dup + TInt Dup(TInt aFid); + // invoked by both dup2 and fcntl with F_DUPFD + TInt Dup2(TInt aFid, TInt aFid2, TBool aCloseFid2); + // the real dup-er. + TInt DupFd(TInt aFid1, TInt aFid2); + void Release(TInt aFid); + + //Lock for protecting FIDs across threads + RFastLock iFidLock; + + //stores pids of all children of this process + RArray iChildren; + + //Methods to manipulate iChildren + void AddChild(const TChild& aChild); + void RemoveChild(TInt aIdx); + + void ExpandFTableL(TInt count); + + const RArray& GetChildren() const + { + return iChildren; + } + + TInt FindChild(const TInt aFid) const + { + return iChildren.Find(TChild(aFid), + TIdentityRelation(TChild::MatchByFid)); + } + + TInt FindChild(const TProcessId aPid) const + { + return iChildren.Find(TChild(-1, aPid), + TIdentityRelation(TChild::MatchByPid)); + } + + CArrayPtrSeg iRConnectionList; + //Lock for protecting iRConnectionList across threads + RFastLock iRcLock; + + // A pointer to the private heap + RHeap* iPrivateHeap; + friend class CFileDesTransferSession; + }; + + +class PosixFilesystem +/* +@internalComponent +*/ + { +public: + static wchar_t* getcwd(RFs& aFs, wchar_t* buf, unsigned long len, int& anErrno); + static int chdir(RFs& aFs, const wchar_t* path, int& anErrno); + static int mkdir(RFs& aFs, const wchar_t* path, int perms, int& anErrno); + static int rmdir(RFs& aFs, const wchar_t* path, int& anErrno); + static int chmod(RFs& aFs, const wchar_t* path, int perms, int& anErrno); + static int reg_unlink(RFs& aFs, const wchar_t* path, int& anErrno); + static int stat(RFs& aFs, const wchar_t* name, struct stat* st, int& anErrno); + static int rename(RFs& aFs, const wchar_t* oldname, const wchar_t* newname, int& anErrno); + static TInt ResolvePath(TParse& aResult, const wchar_t* path, TDes* aFilename); + static TInt SetDefaultDir(RFs& aFs); + static TInt CreateDefaultPrivatePath(RFs& aFs); + static int utime(RFs& aFs, const wchar_t* name, const struct utimbuf* filetimes, int& anErrno); + }; + + +class TAccessPointRecord + { +public: + TUint32 iId; + TBuf iName; + TUint32 iDialogPref; + TUint32 iDirection; + TUint32 iService; + TBuf iServiceType; + TUint32 iBearer; + TBuf iBearerType; + TUint32 iNetwork; + TUint32 iNetworkWeighting; + TUint32 iLocation; +public: + TAccessPointRecord(); + + }; + +// This structure encapsulates an aselect request +NONSHARABLE_STRUCT ( TaselectRequestInfo ) + { + TThreadId iId; + int iMaxFd; + fd_set* iReadFds; + fd_set* iWriteFds; + fd_set* iExceptFds; + struct timeval *itvptr; + TRequestStatus* iRequestStatus; + }; + +// Holds the information about aselect requests, this used required +// for cancellation of the aselect requests +NONSHARABLE_CLASS ( TASelectRequest ) + { +public: + // Thread id of the thread processing the aselect + TThreadId iThreadId; + // Request object used for the request + TRequestStatus* iRequestStatus; + }; + +NONSHARABLE_CLASS(CLocalSystemInterface) : public CBase +/* +@internalComponent +*/ + { +public: + + + IMPORT_C CLocalSystemInterface(); + IMPORT_C ~CLocalSystemInterface(); + +#ifdef __SYMBIAN_COMPILE_UNUSED__ + CLocalSystemInterface& Clone(); + void Release(); + void TerminateProcess(int status); +#endif //__SYMBIAN_COMPILE_UNUSED__ + + int AddToDirList(DIR *aDir); + int RemoveDirFromList(DIR* aDir); + int FindInDirList(DIR* aDir); + + void Exit(int code); + + int dup (int fid, int& anErrno); + int dup2 (int fid, int fid2, int& anErrno); + int open (const wchar_t* name, int mode, int perms, int& anErrno); + int read (int fid, char* buf, unsigned long len, int& anErrno); + int write (int fid, const char* buf, unsigned long len, int& anErrno); + int fsync (int fid, int& anErrno); + int close (int fid, int& anErrno); + off_t lseek (int fid, off_t offset, int whence, int& anErrno); + int fstat (int fid, struct stat* st, int& anErrno); + int ioctl (int fid, int cmd, void* param, int& anErrno); + int ioctl (int fid, int cmd, void* param, TRequestStatus& aStatus, int& anErrno); + int ioctl_complete (int fid, int cmd, void* param, TRequestStatus& aStatus, int& anErrno); + +#ifdef __SYMBIAN_COMPILE_UNUSED__ + int ioctl_cancel (int fid, int& anErrno); +#endif //__SYMBIAN_COMPILE_UNUSED__ + + wchar_t* getcwd (wchar_t* buf, unsigned long len, int& anErrno); + + int chdir (const wchar_t* path, int& anErrno); + int mkdir (const wchar_t* path, int perms, int& anErrno); + int rmdir (const wchar_t* path, int& anErrno); + int chmod (const wchar_t* path, int perms, int& anErrno); + int stat (const wchar_t* name, struct stat* st, int& anErrno); + int rename (const wchar_t* oldname, const wchar_t* newname, int& anErrno); + + IMPORT_C TInt ResolvePath (TParse& aResult, const wchar_t* path, TDes* aFilename); + int socket (int family, int style, int protocol, int& anErrno); + int recvfrom (int fd, char* buf, unsigned long cnt, int flags, struct sockaddr* from, unsigned long* fromsize, int& anErrno); + int sendto (int fd, const char* buf, unsigned long cnt, int flags, struct sockaddr* to, unsigned long tosize, int& anErrno); + int shutdown (int fd, int how, int& anErrno); + int listen (int fd, int n, int& anErrno); + int accept (int fd, struct sockaddr *addr, size_t *size, int& anErrno); + int bind (int fd, const struct sockaddr* addr, unsigned long size, int& anErrno); + int connect (int fd, const struct sockaddr* addr, unsigned long size, int& anErrno); + int sockname (int fd, struct sockaddr* addr, unsigned long* size, int anEnd, int& anErrno); + int getsockopt (int fd, int level, int opt, void* buf, unsigned long* len, int& anErrno); + int setsockopt (int fd, int level, int opt, void* buf, unsigned long len, int& anErrno); + + int popen3 (const wchar_t *file, const wchar_t *cmd, wchar_t** envp, int fids[3], int& anErrno); + int waitpid (int pid, int* status, int options, int& anErrno); + + int fcntl (int aFid, int aCmd, long anArg, int& anErrno); + int utime (const wchar_t* name, const struct utimbuf* filetimes, int& anErrno); + + int popen (const wchar_t* file, const wchar_t* cmd, const char* mode, int& anErrno); + int pclose (int aFid, int& anErrno); + IMPORT_C void CheckOrigins (wchar_t**& wenvp, int& aCount); +#ifdef SYMBIAN_OE_POSIX_SIGNALS + TInt SignalHandler(); + IMPORT_C void InitSignalHandler(); + void RegisterExitNotification(TProcessId aPid); + + inline TUint64 GetSigMask()const + { + return iSigMask; + } + + int kill(pid_t pid, int sig, int& anErrno); + int raise(int sig, int& anErrno); + int sigqueue(pid_t pid, int sig, const union sigval val, int& anErrno); + + int sigfillset(sigset_t *set, int& anErrno); + int sigaddset(sigset_t *set, int signo, int& anErrno); + int sigdelset(sigset_t *set, int signo, int& anErrno); + int sigismember(const sigset_t *set, int signo, int& anErrno); + int sigandset(sigset_t * set, const sigset_t * left, const sigset_t * right, int& anErrno); + int sigorset(sigset_t * set, const sigset_t * left, const sigset_t * right, int& anErrno); + int sigisemptyset(const sigset_t * set, int& anErrno); + int sigemptyset(sigset_t * set, int& anErrno); + + int sigprocmask(int how, const sigset_t *set, sigset_t *oset, int& anErrno); + int sighold(int signo, int& anErrno); + int sigrelse(int signo, int& anErrno); + int sigpause(int signo, int& anErrno); + + int sigwait(const sigset_t *set, int *sig, int& anErrno); + int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout, int& anErrno); + int sigwaitinfo(const sigset_t *set, siginfo_t *info, int& anErrno); + int sigaction(int sig, const struct sigaction *act, struct sigaction *oact, int& anErrno); + TSignalHandler sigset(int aSigNum, TSignalHandler disp, int& anErrno); + TSignalHandler bsd_signal(int aSigNum, TSignalHandler aFunc,int& anErrno); + TSignalHandler signal(int aSigNum, TSignalHandler aFunc,int& anErrno); + int sigignore(int aSigNum, int& anErrno); + unsigned int alarm(unsigned int seconds); + int sigpending(sigset_t *set,int& anErrno); + +#ifdef SYMBIAN_OE_LIBRT + //start timers... + IMPORT_C TInt AddTimer(const TInt& aTimerId); + IMPORT_C TInt DeleteTimer(const TInt& aTimerId); + IMPORT_C TInt IncrementOverrun(const TInt& aTimerId); + IMPORT_C TInt ResetOverrun(const TInt& aTimerId); + IMPORT_C TInt Overrun(const TInt& aTimerId); + IMPORT_C TInt RaiseTimerSignal(int sig, int timerid); + //end timers +#endif //SYMBIAN_OE_LIBRT +#endif // SYMBIAN_OE_POSIX_SIGNALS + int pipe (int fildes[2], int& anErrno ); + int mkfifo (const wchar_t *pathname, mode_t mode, int& anErrno); + int link (const wchar_t *oldpathName, const wchar_t *newpathName, int& anErrno ); + int unlink (const wchar_t *pathName, int& anErrno ); + + int select (int maxfd, fd_set* readfds,fd_set* writefds,fd_set* exceptfds, struct timeval* tvptr, int& anErrno); + + int aselect(int maxfd, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *tvptr, TRequestStatus* requeststatus,int& anErrno); + + int cancelaselect(TRequestStatus* requeststatus,int& anErrno,int performcleanup = 0); + + int eselect(int maxfd, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *tvptr, int arraycount,TRequestStatus* waitarray,int& anErrno); + + static TInt handleaselect(TAny* aPtr); + + RArray& ASelectRequest(); + + RFastLock& ASelectLock(); + int system (const wchar_t* aCmd, const wchar_t* aCmdArg, int& anErrno ); + const wchar_t* GetDirName (int aFid); + IMPORT_C int Truncate (int aFid, off_t anOffset, int& anErrno); + int fchmod (int fd , mode_t perms, int& anErrno); + + int posix_spawn (int* pid, const wchar_t* wpath, + const posix_spawn_file_actions_t* file_actions, + const posix_spawnattr_t* attrp, + const wchar_t* wargs, wchar_t** wenvp); + + int SetEcho(int aFd, TUint8 aEcho, int& aErrno); + + //Set the default interface for network operations + int setdefaultif(const struct ifreq* aIfReq); + + IMPORT_C CFileDescBase* GetDesc(int aFid); + + // functions returning session to File Server + IMPORT_C RFs& FileSession(); + RCommServ& CommServSession(); + RSocketServ& SockServSession(); + + //Dynamic Memory related APIs + IMPORT_C void* Alloc(size_t aNBytes); + IMPORT_C void* ReAlloc(void* aPtr, size_t aNBytes); + IMPORT_C void Free(void* aPtr); + IMPORT_C void* AllocTLD(TInt aSize); + + //Return the private Heap memory + IMPORT_C RHeap* Heap(); + + //Return the Comms Server Lock + RFastLock& CommsSessionLock(); + + //Return reference to file table + const CFileTable& FileTable() const; + + //Get the default connection (RConnection) instance + RConnection& GetDefaultConnection(); + + //Get the saved session path of the file server session + TInt GetSessionPath(TDes& aPath); + + //Save the file server session path + TInt SaveSessionPath(const TDesC& aPath); + + static void WaitForNRequest(TRequestStatus aStatusArray[], TInt aNum); + +private: + //Helper function to read a record from the IAP table + void ReadRecordFromIapTableL(CCommsDbTableView* aView, TAccessPointRecord &aRecord); + //Get the connection preferences from an IAP name + TInt GetConnectionPreferencesL(TBuf aIapName, + TCommDbConnPref &aConnPref); + + // Helper function used by "select" api. + // The function returns "True", if an ioctl call has been made and it is to be waited upon. + // The function returns "False", (if an ioctl call is not made)/(an ioctl call was made but is not to be waited upon, and will get cancelled). + TBool SelectPollIssueIoctl(fd_set** aInputFds, fd_set** aOutputFds, + TRequestStatus* aReqArray, TInt *aReqFds, TInt aNumReqs, TInt& nDescriptorsSet) ; + TInt CreateaselectThread(int maxfd, fd_set* readfds, fd_set* writefds, + fd_set* exceptfds, struct timeval* tvptr, + TRequestStatus* requeststatus, int& anErrno); + + // Helper function for the setdefaultif() API to restart the + // default RConnection with the new settings. + TInt StartDefConnection(); + +private: + // NOTE: iCleanup should be the first member of CLSI, since iPrivateHeap + // will be destroyed from within iCleanup destructor. + TCLSICleanup iCleanup; + + CFileTable iFids; + + //The backend file session for the application + RFs iFs; + //The current session path of the application. + TFileName iSessionPath; + //Lock to guard the session path + RFastLock iSessionPathLock; + + RSocketServ iSs; + RCommServ iCs; + + //Lock for protecting Socket Session across threads + RFastLock iSSLock; + //Lock for protecting Comms Session across threads + RFastLock iCSLock; + + //Private Heap which will be used by the library for all memory allocation + RHeap* iPrivateHeap; + + //used for Opendir + const static TInt KDirGran = 2; + RPointerArray iOpenDirList; + + //in class consts + const static TInt KTLDInfoListGran = 4; + const static TInt KPtrsGran = 2; + + //Thread-TLS pointers mapping + class TTLDInfo + { + public: + TTLDInfo(TThreadId id, TAny* ptr) : iTid(id), iPtrs(CLocalSystemInterface::KPtrsGran) + { + iPtrs.Append(ptr); + } + void Close(RHeap* pHeap) + { + TInt nptrs = iPtrs.Count(); + for (TInt j = 0; j < nptrs; ++j) + { + pHeap->Free(iPtrs[j]); + } + iPtrs.Close(); + } + TThreadId iTid; + RPointerArray iPtrs; + }; + + //Array of Thread-TLS pointers mappings + RArray iTLDInfoList; + + //Protect the array from concurrent access + RFastLock iTLDListLock; + //The default connection to be used for all network apis. + RConnection iDefConnection; + //Protect the iDefConnection from concurrent GetDefaultConnection calls + RFastLock iDefConnLock; + //Lock for protecting iASelectRequest across threads + RFastLock iASelectLock; + + // iASelectRequest holds the TASelectRequest objects of the aselect requests + RArray iASelectRequest; + + // Default connection settings, set/cleared using setdefaultif + TConnPref* iDefConnPref; + +#ifdef SYMBIAN_OE_POSIX_SIGNALS + // Signal handler thread + RThread iSignalHandlerThread; + RPipe iSignalReadPipe; + RPipe iSignalWritePipe; + TBool iSignalLoopRunning; + RSignalSession iSignalSession; + TUint64 iSigMask; + RArray iBlockedSigArray; + RMutex iBlockedSAMutex; + TRequestStatus iPipeReadStatus; + + // For thread(s) to wait till signals initialization happens + TInt iSigInitWaitCount; + RSemaphore iSigInitWaitSemaphore; + RMutex iSigInitWaitMutex; + TBool iSignalsInitialized; + + RSemaphore iSignalInitSemaphore; + + class TChildWaiter + { + public: + TChildWaiter() + { + iWaiterStatus = KRequestPending; + iWaiterPid = 0; + } + + virtual ~TChildWaiter() {} + + TRequestStatus iWaiterStatus; + TProcessId iWaiterPid; + + static TBool MatchByPid(const TChildWaiter& aWaiter1, const TChildWaiter& aWaiter2) + { + if((aWaiter1.iWaiterPid == aWaiter2.iWaiterPid) != 0) + return ETrue; + else + return EFalse; + } + + static TBool MatchNotPending(const TChildWaiter& aWaiter1, const TChildWaiter& aWaiter2) + { + if(aWaiter1.iWaiterStatus == KRequestPending || aWaiter2.iWaiterStatus == KRequestPending) + return EFalse; + else + return ETrue; + } + }; + + class TSignalActionInfo + { + public: + TSignalActionInfo() + { + iSigHandler = SIG_DFL; + iSigAction = 0; + iSigFlags = 0; + } + + virtual ~TSignalActionInfo() {} + + TSignalHandler iSigHandler; + TSignalAction iSigAction; + TUint32 iSigFlags; + }; + + TFixedArray iSigActions; + RMutex iSigHandlerMutex; + RTimer iAlarmTimer; + TTime iAlarmStartTime; + TRequestStatus iAlarmStatus; + TBool iIsTimerActive; + TUint iCurrentTimeout; + + void HandleSignal(TSignalMessage& aMsg, TBool aIsDequeued = EFalse); + void InitializeSignalHandlers(); + void CallDefaultHandler(int aSigNum); + void WaitOrHandleSignal(TSignalMessage aMsg); + TInt SuspendOtherThreads(); + TInt ResumeOtherThreads(); + TInt EnsureSignalsInitialized(); + TInt SigWaitInternal(TUint64 aWaitSet,TSignalMessage* aMsg,TInt aTimeout,TBool aTimeCheckFailed=EFalse); + + class TSignalWaiter + { + public: + TSignalWaiter(TUint64 aWaitMask, TSignalMessage* aMsgPtr) + { + iSigWaitSemaphore.CreateLocal(0); + iSigWaitMessagePtr = aMsgPtr; + iSigWaitMask = aWaitMask; + + RThread lThread; + iSigWaitThreadId = lThread.Id(); + lThread.Close(); + } + + virtual ~TSignalWaiter() + { + iSigWaitSemaphore.Close(); + } + + TUint64 iSigWaitMask; + RSemaphore iSigWaitSemaphore; + TSignalMessage* iSigWaitMessagePtr; + TThreadId iSigWaitThreadId; + + static TBool MatchByMask(const TSignalWaiter& aWaiter1, const TSignalWaiter& aWaiter2) + { + if((aWaiter1.iSigWaitMask & aWaiter2.iSigWaitMask) != 0) + return ETrue; + else + return EFalse; + } + + static TBool MatchByThreadId(const TSignalWaiter& aWaiter1, const TSignalWaiter& aWaiter2) + { + if(aWaiter1.iSigWaitThreadId == aWaiter2.iSigWaitThreadId) + return ETrue; + else + return EFalse; + } + }; + + RArray iSignalWaiterArray; + RArray iChildWaiterArray; + RMutex iSignalWaiterMutex; + +#ifdef SYMBIAN_OE_LIBRT + //timers.. + TInt FindTimer(const TInt& aTimerId); + class TOverrun + { + public: + TOverrun(const TInt& aTimerId):iTimerId(aTimerId), Overruns(0) + { + } + + TInt iTimerId; + TInt Overruns; + }; + + RArray iTimerOverruns; + RMutex iTimerOverrunsMutex; + //timers.. +#endif // SYMBIAN_OE_LIBRT + +#endif // SYMBIAN_OE_POSIX_SIGNALS +public: +//ipc server session +RIpcSession iIpcS; +friend class RFileDesTransferSession; + }; + + +/* +* Return global backend object to libraries +*/ +IMPORT_C CLocalSystemInterface* Backend(); + + + + +// LIBC-BACKEND specific Symbian Error Codes +const TInt KErrMaxFdOpened = -1025; +const TInt KErrDirectoryOpen = -1026; + + + +// Directory enumeration + +NONSHARABLE_STRUCT(__EPOC32_WDIR) : public CBase // aka "class __EPOC32_WDIR with everything public" + { +public: + __EPOC32_WDIR() {} + ~__EPOC32_WDIR(); + + TInt Open(); + TInt Open(const TDesC& aPath); + TInt Open(const wchar_t *_path,int*); + virtual TInt UpdateNarrow(); + HBufC* iPath; + CDir* iEntries; + TInt iIndex; // counting down, 0 means "finished" + struct wdirent iCurrent; + TInt iCount ; + TBuf16 iCurrentName; + /* ***************************************************************** + Overloading new and delete operators so that they will + allocate and deallocare memory from/to the private heap of backend + ********************************************************************/ + inline TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW + { + Mem::FillZ(aBase, aSize); return aBase; + } + + inline TAny* operator new(TUint aSize) __NO_THROW + { + return Backend()->Alloc(aSize); + } + + inline TAny* operator new(TUint aSize, TLeave) + { + TAny* ptr = Backend()->Alloc(aSize); + if (ptr == NULL) + { + User::Leave(KErrNoMemory); + } + return ptr; + } + + inline TAny* operator new(TUint aSize, TUint aExtraSize) __NO_THROW + { + return Backend()->Alloc(aSize + aExtraSize); + } + + inline TAny* operator new(TUint aSize, TLeave, TUint aExtraSize) + { + TAny* ptr = Backend()->Alloc(aSize + aExtraSize); + if (ptr == NULL) + { + User::Leave(KErrNoMemory); + } + return ptr; + } + + inline void operator delete(TAny *aPtr) __NO_THROW + { + Backend()->Free( aPtr ); + } + }; + +NONSHARABLE_STRUCT(__EPOC32_DIR) : public __EPOC32_WDIR + { +public: + __EPOC32_DIR(){} + ~__EPOC32_DIR(){} + + virtual TInt UpdateNarrow(); + struct dirent iCurrentNarrow; + TBuf8 iCurrentNarrowName; + }; + +NONSHARABLE_STRUCT (_iconv_t) + { + TUint toCode; + TUint fromCode; + }; + +class TUSockAddr : public TSockAddr +/* +Utility class for converting struct sockaddr to and from EPOC32 TSockAddr +@internalComponent +*/ + { +public: + TUSockAddr() : TSockAddr(), iError(0) {} + + TUSockAddr(TAny* addr); // constructor form of Prepare + IMPORT_C TUSockAddr(const TAny* addr, TUint len); // constructor form of Set +private: + void Prepare(TAny* addr); + void Set(const TAny* addr, TUint len); +public: + IMPORT_C void Get(TAny* addr, unsigned long* len); +public: + TInt iError; // To store error status of TUSockAddr functions, refers errno.h. Notebly not Symbian error codes. + }; + + + + + +#endif //SYSIF_H +