/*
* 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 <e32std.h>
#include <e32base.h>
#include <f32file.h>
#include <es_sock.h>
#include <c32comm.h>
#include <sys/select.h>
#include <spawn.h>
#include <sys/types.h>
#include <wchar.h>
#include "ipcclient.h"
#include <dirent.h>
#include <sys/socket.h>
#include <stdapis/net/if.h>
#include <commdb.h>
#include <commdbconnpref.h>
#include <rpipe.h>
#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<CFileDescBase> 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<TChild> iChildren;
//Methods to manipulate iChildren
void AddChild(const TChild& aChild);
void RemoveChild(TInt aIdx);
void ExpandFTableL(TInt count);
const RArray<TChild>& GetChildren() const
{
return iChildren;
}
TInt FindChild(const TInt aFid) const
{
return iChildren.Find(TChild(aFid),
TIdentityRelation<TChild>(TChild::MatchByFid));
}
TInt FindChild(const TProcessId aPid) const
{
return iChildren.Find(TChild(-1, aPid),
TIdentityRelation<TChild>(TChild::MatchByPid));
}
CArrayPtrSeg<RConnection> 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<KCommsDbSvrMaxColumnNameLength> iName;
TUint32 iDialogPref;
TUint32 iDirection;
TUint32 iService;
TBuf<KCommsDbSvrMaxColumnNameLength> iServiceType;
TUint32 iBearer;
TBuf<KCommsDbSvrMaxColumnNameLength> 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<TASelectRequest>& 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<KCommsDbSvrMaxColumnNameLength> 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<TAny> 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<TAny> iPtrs;
};
//Array of Thread-TLS pointers mappings
RArray<TTLDInfo> 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<TASelectRequest> 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<TSignalMessage> 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<TSignalActionInfo,SIGRTMAX> 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<TSignalWaiter> iSignalWaiterArray;
RArray<TChildWaiter> 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<TOverrun> 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<KMaxFileName> 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<KMaxFileName> 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