diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericopenlibs/openenvcore/backend/inc/fdesc.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericopenlibs/openenvcore/backend/inc/fdesc.h Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1049 @@ +// 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: +// Abstraction representing a UNIX file descriptor +// CFileDescBase maintains the simple semantics of +// Dup() and Close(), so the final Close() will +// delete the object and hence call the destructor. +// +// + +#ifndef _FDESC_H +#define _FDESC_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "base.h" +#include "StdioClient.h" + +//FD attributes used internally by the backend +const TUint KInvalidFd = 0x00000001; +const TUint KMMapedFd = 0x00000002; +const TUint KCloseonExec = 0x00000004; +const TUint KPipeFd = 0x00000008; +const TUint KIoctlOutstanding = 0x00000010; +const TUint KConsoleFd = 0x00000020; +const TUint KFifoFd = 0x00000030; +const TUint KSpawnCloseInChild = 0x00000040; + +#define SET_CLOSE_ON_EXEC_FLG (1 << 2) + +#if defined(SYMBIAN_OE_LARGE_FILE_SUPPORT) && !defined(SYMBIAN_OE_NO_LFS) + +//Large File Support - Use RFile64 and 64 bit file sizes +#define RFILE RFile64 +#define FSIZE TInt64 + +#else + +//No large file support - Use RFile and 32 bit file sizes +#define RFILE RFile +#define FSIZE TInt + +#endif //SYMBIAN_OE_LARGE_FILE_SUPPORT && !SYMBIAN_OE_NO_LFS + +// Atomic socket operations support + +#define ATOMICSOCKETOP(realcall,on_error) \ + { \ + if (__e32_atomic_tau_ord32((void *)&iCount, 0x8000, 0, 1) >= 0x8000) \ + { \ + on_error; \ + } \ + else \ + { \ + realcall; \ + __e32_atomic_tas_ord32((void *)&iCount, 0, -1, 0); \ + } \ + } + +#define NOP + +//Enumarations for Polling +enum TPollMode + { + EReadyForReading = 1, + EReadyForWriting = 2, + EAnyException = 4 + }; + +//Enumarations for Redirection Server +enum TRedirConnState + { + ENotConnected, + EConnected, + ENoServer + }; + +//Enumerations for the console echo +enum TConsoleEcho + { + EOff = 0, //Turn Off the echo + EOn = 1, //Turn On the echo + EPrintValid = 33, //Printable ascii character set <33-126> + EPrintInvalid=127 + }; + +// The base class for all flavours of FileDescriptor +// +class CSocketDesc; + +NONSHARABLE_CLASS(CFileDescBase) : public CBase +/* +@internalComponent +*/ + { +public: + + static CFileDescBase* Open(const wchar_t* name, int mode, int perms, TInt& err); + static CFileDescBase* Socket(RSocketServ& aSs, int family, int style, int protocol, TInt& err); + + virtual void Read(TDes8& aDesc, TRequestStatus& aStatus); + virtual TInt ReadCompletion(TDes8& aDesc, TInt aStatus); + virtual void ReadCancel(); + + virtual void Write(TDes8& aDesc, TRequestStatus& aStatus); + virtual TInt WriteCompletion(TDes8& aDesc, TInt aStatus); + virtual void WriteCancel(); + virtual TInt SetAtt(TUint aSetAttMask, TUint aClearAttMask); + + virtual void Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus); + virtual TInt IoctlCompletion(int aCmd, void* aParam, TInt aStatus); + virtual void IoctlCancel(); + + virtual void RecvFrom(TDes8& aDesc, TSockAddr& from, int flags, TRequestStatus& aStatus); + virtual void RecvFromCancel(); + + virtual void SendTo(TDes8& aDesc, const struct sockaddr* anAddr, unsigned long aAddrLen,int flags, TRequestStatus& aStatus); + + virtual void SendToCancel(); + + virtual TInt CompletionStatus(TInt& aLength, TInt aStatus); + + virtual void Sync(TRequestStatus& aStatus); + virtual void SyncCancel(); + + virtual void Accept(CFileDescBase*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs,TSockAddr *aAddr); + virtual void AcceptCancel(); + + virtual void Connect(const struct sockaddr* aAddr,unsigned long size,TRequestStatus& aStatus); + virtual void ConnectCancel(); + virtual TBool GetConnectionProgress(); + virtual void SetConnectionProgress( TBool aInProgress ); + + virtual void Shutdown(TUint aHow,TRequestStatus& aStatus); + virtual void ShutdownCancel(); + + virtual TBool TimedRead() {return EFalse;} //default implementation + TInt TimeoutValue() const {return iReadTimeout;} + + virtual TInt LSeek(off_t& offset, int whence); + virtual TInt FStat(struct stat* st); + virtual TInt Bind(const struct sockaddr* addr, unsigned long size); + virtual TInt Listen(TUint qSize); + virtual TInt SockName(int anEnd, struct sockaddr* anAddr,unsigned long* aSize); + virtual TInt GetSockOpt(TInt anOptionName,TInt anOptionLevel,TDes8& anOption); + virtual TInt SetSockOpt(TInt anOptionName,TInt anOptionLevel,TDesC8& anOption); + virtual TInt Fcntl(TUint anArg, TUint aCmd); + + virtual TInt Poll(TPollMode aMode,TBool& aReadyStatus,TInt& aErrno); + virtual TInt Poll(TUint aEvents); + virtual TInt NotifyActivity(TUint aEvents, TRequestStatus& aRequest, TTimeIntervalMicroSeconds32 timeout); + virtual void TweakWatchedEvents(TUint& events); + virtual TInt TweakReadyEvents(TInt errval); + virtual void CancelNotify(); + + //Truncate the File + virtual TInt Truncate(off_t /*anOffset*/) + { + return KErrNotSupported; + } + //Type of the Descriptor + virtual TInt Type() + { + return EBaseDesc; + } + + //Set/reset the Attributes of the FD + inline void SetAttributes( TUint32 aBit, TBool aFlag ) + { + if( aFlag ) + { + //Set the bit to 1 + iFdAttrib |= aBit; + } + else + { + //Reset the bit to 0 + iFdAttrib &= ~aBit; + } + } + + //Get the Attributes of the FD + inline const TUint32 Attributes() const + { + return iFdAttrib; + } + + inline const TUint32 FcntlFlag() const + { + return iFcntlFlag; + } + + static inline void Cleanup(TAny *aPtr) + { + ((CFileDescBase*)aPtr)->Close(); + } + + inline void PushLC() + { + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + } + + IMPORT_C TInt Close(); + virtual void UserClose() {return;} + inline CFileDescBase* Dup(); + inline void SetFid(TInt aFid) { iFid = aFid; } + virtual void SetFids(void *aFids); + + inline void operator delete(TAny *aPtr) __NO_THROW + { + Backend()->Free(aPtr); + } + + inline void operator delete(TAny *aPtr, TLeave) __NO_THROW + { + Backend()->Free(aPtr); + } + + inline void operator delete(TAny *aPtr, TAny*) __NO_THROW + { + Backend()->Free(aPtr); + } + + TBool ReadIsTimed; + TBool ReadWasCancelled; + +protected: + CFileDescBase( TUint aFcntl = 0, TUint32 aFdAttrib = 0 ); + virtual TInt FinalClose(); + static void Complete(TRequestStatus& aStatus, TInt aResult); + TInt iReadTimeout; + //Used in case of CRedirDesc + TInt iFid; + //For FD's fcntl + TUint iFcntlFlag; + //For FD's other attributes + TUint32 iFdAttrib; + +private: + //Check if the path corresponds to a directory + static TBool CheckIfDirectory(const TDesC& aPath, RFs& aFs); + +public: + enum TDescType + { + EBaseDesc, + EFileDesc, + EFileTempDesc, + ESocketDesc, + ESerialDesc, + EDirDesc, + ETtyDesc, + EPopenPipeDesc, + EPipeDesc, + ERedirDesc, + EStdErrDesc, + EFileSocketDesc + }; +private: + TInt iDupCount; +public: + // Poll is required to return any of the requested events. + // In case of any error, "iPollErr" should be checked by the socket-descriptor + // to take any corrective action. + TInt iPollErr; + }; + + +inline CFileDescBase* CFileDescBase::Dup () + { iDupCount += 1; return this; } + + +NONSHARABLE_CLASS(CTtyDesc) : public CFileDescBase +/* +Abstraction of a teletype device, which will be used for +the console. +@internalComponent +*/ + { +public: + inline CTtyDesc(CConsoleBase *c); + inline CTtyDesc(); + ~CTtyDesc(); + virtual TInt Type() + { + return ETtyDesc; + } + void Read(TDes8& aDesc, TRequestStatus &aStatus); + void ReadCancel(); + TInt ReadCompletion(TDes8& aDesc, TInt aStatus); + void Write(TDes8& aDesc, TRequestStatus& aStatus); + void Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus); + TInt IoctlCompletion(int aCmd, void* aParam, TInt aStatus); + TInt SetEcho(TUint8 aEcho); +protected: + virtual TInt FinalClose(); +private: + void MapCodeAndEcho(TDes8& aDesc, TKeyCode aCode); + void CheckConsoleCreated(); + void Write(TDes8& aDesc); + CConsoleBase *iConsole; + //To store last non-modifiable data position and flag for reading data + TInt iCurPosX; + TInt iCurPosY; + TBool iReadingData; + TUint8 iEchoVal; + }; + +inline CTtyDesc::CTtyDesc(CConsoleBase *c) : CFileDescBase(), iConsole(c), iEchoVal(EOn){} +inline CTtyDesc::CTtyDesc() : CFileDescBase(), iEchoVal(EOn) {} + + +NONSHARABLE_CLASS(CRedirDesc) : public CFileDescBase +/* +client-side CRedirDesc desc class which will be used to connecting to the Redirection Server +@internalComponent +*/ + { +public: + CRedirDesc(); + virtual TInt Type() + { + return ERedirDesc; + } + virtual void Read(TDes8& aDesc, TRequestStatus& aStatus); + virtual void Write(TDes8& aDesc, TRequestStatus& aStatus); + TInt WriteCompletion(TDes8& aDesc, TInt /*aStatus*/); + TInt ReadCompletion(TDes8& aDesc, TInt /*aStatus*/); + virtual TInt Fcntl(TUint anArg, TUint aCmd); + TInt FinalClose(); + TInt Configure(); + TInt Poll(TUint aEvents); + TInt NotifyActivity(TUint aEvents, TRequestStatus& aRequest, TTimeIntervalMicroSeconds32 timeout); + TInt TweakReadyEvents(TInt errval); + void CancelNotify(); + TInt SetEcho(TUint8 aEcho); + TBool iReadNone; + TBool iWriteNone; +private: + //Handle to StdioSession + RStdioSession iSession; + TRedirConnState iStatus; + RFastLock iLock; + }; + + +NONSHARABLE_CLASS(CStdErrDesc) : public CFileDescBase + +/* +client-side Standard Error desc class which will be used to put all stderr to RDebug::Printf +@internalComponent +*/ + { +public: + CStdErrDesc(); + virtual void Write(TDes8& aDesc, TRequestStatus& aStatus); + TInt WriteCompletion(TDes8& aDesc, TInt /*aStatus*/); + virtual TInt Fcntl(TUint anArg, TUint aCmd); + virtual TInt Type() + { + return EStdErrDesc; + } + }; + +NONSHARABLE_CLASS(CFileDesc) : public CFileDescBase +/* +Abstractions for a plain file and a temporary file +@internalComponent +*/ + { +public: + CFileDesc(); + ~CFileDesc(); + + void SetState(const TDes& params); + + TInt Open(RFs& aSession, const TDesC& aName, int mode, int perms); + TInt LSeek(off_t& offset, int whence); + void Read(TDes8& aDesc, TRequestStatus& aStatus); + void Write(TDes8& aDesc, TRequestStatus& aStatus); + TInt FStat(struct stat *st); + void Sync(TRequestStatus &aStatus); + TInt IoctlCompletion(int aCmd, void* aParam, TInt aStatus); + TInt Fcntl(TUint anArg, TUint aCmd); + static void MapStat(struct stat& st, const TTime& aModTime, TUint& aAttr, const mode_t aMode = S_IFREG); + TInt Truncate(off_t anOffset); + TInt SetAtt(TUint aSetAttMask, TUint aClearAttMask); + TInt ProcessLockParams(FSIZE& pos, FSIZE &lock_len, TInt& lock_type, struct flock* anArg); + inline int CreateLock() + { + return iLock.CreateLocal(); + } + + inline RFILE& FileHandle() + { + return iFile; + } + + inline const FSIZE Offset() const + { + return iPos; + } + + inline const FSIZE Size() const + { + return iSize; + } + inline void setSize(TUint32 param) + { + iSize = param; + } + inline const FSIZE Extent() const + { + return iExt; + } + virtual TInt Type() + { + return EFileDesc; + } +protected: + virtual TInt FinalClose(); + TInt Alloc(); +private: + TInt FileRead(TUint8* aPtr,TInt aLength); + TInt FileWrite(TUint8* aPtr,TInt aLength); + TInt Flush(); + TInt DoSync(); + TInt DoRead(TDes8& aDesc); + TInt DoWrite(TDes8& aDesc); + FSIZE Pos(); + FSIZE Ext(); + +private: + enum {EAlloc,EReading,EWriting}; + enum {EBufferSize = 0x600,EReadAhead = 0x200}; +protected: + RFILE iFile; + TInt16 iDrive; // for use with stat() +private: + TUint8 iState; + TUint8* iBuffer; + TUint8* iPtr; + TUint8* iEnd; + + FSIZE iSize; + FSIZE iPos; + FSIZE iExt; + + //For locking the descriptor before any operation. + //To make it thread safe. + RFastLock iLock; + friend class RFileDesTransferSession; + friend class CFileDesTransferSession; + }; + +NONSHARABLE_CLASS(CTempFileDesc) : public CFileDesc +/* +@internalComponent +*/ + { +public: + TInt Open(const wchar_t* aName, TInt mode); + virtual TInt Type() + { + return EFileTempDesc; + } +protected: + virtual TInt FinalClose(); +private: + RFs iSession; + TFileName iName; + }; + +/* +Implements common functionality between CSocketDesc and CFileSocketDesc. +Not meant to be instantaible. +*/ +NONSHARABLE_CLASS(CSockDescBase) : public CFileDescBase + { +public: + virtual TInt Socket(RSocketServ& aSs, int family, int style, int protocol); + TInt Fcntl(TUint anArg, TUint aCmd); + TInt FStat(struct stat *st); + TInt FinalClose(); + void Read(TDes8& aDesc, TRequestStatus& aStatus); + void Write(TDes8& aDesc, TRequestStatus& aStatus); + void RecvFrom(TDes8& aDesc, TSockAddr& from, int flags, TRequestStatus& aStatus); + void SendTo(TDes8& aDesc, TSockAddr& to, int flags, TRequestStatus& aStatus); + TInt Poll(TUint aEvents); + TInt NotifyActivity(TUint aEvents, TRequestStatus& aRequest, TTimeIntervalMicroSeconds32 aTimeout); + void TweakWatchedEvents(TUint& events); + TInt TweakReadyEvents(TInt errval); + void CancelNotify(); + TInt Listen(TUint qSize); + void ReadCancel(); + TInt ReadCompletion(TDes8& aBuf, TInt aStatus); + void RecvFromCancel(); + void SendToCancel(); + void WriteCancel(); + TInt SockName(int anEnd, TSockAddr& anAddr); + void Shutdown(TUint aHow,TRequestStatus& aStatus); + TInt CompletionStatus(TInt& aLength, TInt aStatus); + const TUint& GetSelectEvents() + { + iIoctlLock.Signal(); + return iSelectEvents(); + } + + inline TInt CreateLock() + { + TInt err = iIoctlLock.CreateLocal(1) || iReadLock.CreateLocal() || iWriteLock.CreateLocal(); + if (err != KErrNone) + { + // closes on unopened handles are safe + iIoctlLock.Close(); + iReadLock.Close(); + iWriteLock.Close(); + } + return err; + } + + inline RSemaphore& GetIoctlLock() + { + return iIoctlLock; + } + inline TBool GetConnectionProgress() + { + return iConnectInProgress; + } + + inline void SetConnectionProgress( TBool aInProgress ) + { + iConnectInProgress = aInProgress; + } + +protected: + //rearrange these + CSockDescBase():iAddrFamily(-1),iProtocol(KUndefinedProtocol),iIoctlFlag(EFalse),iCount(0) + { + + } + RSocket iSocket; + TSockXfrLength iLength; + TFileName iPath; + TPckgBuf iSelectEvents; + TInt iAddrFamily; + TInt iProtocol; + TInt iStyle; + // For preventing simultaneous ioctl calls. + // No native support. + RSemaphore iIoctlLock; + // Is this required? + TBool iIoctlFlag; + // Safeguard against issue of a second Read/Write request while the first is pending. + // The iReadLock also guards OpenUsingPreference + //For locking the descriptor before any operation. + //To make it thread safe. + RFastLock iReadLock; + RFastLock iWriteLock; + + //Flag to mark the connect status of a non-blocking socket as "in progress" + //to prevent duplicate connection request + TBool iConnectInProgress; + volatile TInt iCount; +protected: + + inline TInt isStream() const // inline, but private + { + return iStyle==SOCK_STREAM; + } + }; + +NONSHARABLE_CLASS(CSocketDesc) : public CSockDescBase +/* +Abstraction for a socket +@internalComponent +*/ + { +public: + CSocketDesc(); + TInt Socket(RSocketServ& aSs, int family, int style, int protocol); + void Read(TDes8& aDesc, TRequestStatus& aStatus); + TInt ReadCompletion (TDes8& /*aBuf*/, TInt aStatus); + void ReadCancel(); + void Write(TDes8& aDesc, TRequestStatus& aStatus); + void WriteCancel(); + void Sync(TRequestStatus& aStatus); + void Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus); + TInt IoctlCompletion(int aCmd, void* aParam, TInt aStatus); + void IoctlCancel(); + + void RecvFrom(TDes8& aDesc, TSockAddr& from, int flags, TRequestStatus& aStatus); + void RecvFromCancel(); + void SendTo(TDes8& aDesc, const struct sockaddr* anAddr, unsigned long aAddrLen, int flags, TRequestStatus& aStatus); + + void SendToCancel(); + + void Shutdown(TUint aHow,TRequestStatus& aStatus); + void Accept(CFileDescBase*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs,TSockAddr *aAddr); + void AcceptCancel(); + void Connect(const struct sockaddr* aAddr,unsigned long size,TRequestStatus& aStatus); + void ConnectCancel(); + + TInt Bind(const struct sockaddr* addr, unsigned long size); + TInt Listen(TUint qSize); + TInt SockName(int anEnd, struct sockaddr* anAddr,unsigned long* aSize); + TInt GetSockOpt(TInt anOptionName,TInt anOptionLevel,TDes8& anOption); + TInt SetSockOpt(TInt anOptionName,TInt anOptionLevel,TDesC8& anOption); + TInt Fcntl(TUint anArg, TUint aCmd); + + TInt Poll(TPollMode aMode,TBool& aReadyStatus,TInt& aErrno); + TInt Poll(TUint aEvents); + void CancelNotify(); + void TempClose(); + + void SetFids(void *aFids); + virtual TInt Type() + { + return ESocketDesc; + } + +protected: + TInt FinalClose(); +private: + + TInt GetInterfaceIndex(TUint32 aAddr); + TInt GetInterfaceList(void *aParam); + TInt GetActiveInterface( void *aParam); + TInt GetInterfaceIndexByName(void *aParam); + TInt GetActiveInterfaceList(void *aParam); + TInt SetInterfaceByName(void *aParam); + TInt StartInterface(void *aParam); + TInt StartActiveInterface(void *aParam); + TInt StopInterface(void *aParam); + TInt OpenUsingPreference(); + void AccessPointListL(CArrayFixFlat *&aRecordPtr, TInt &aLength); + void AccessPointCountL(TInt &aCount); + void ReadRecordFromIapTableL(CCommsDbTableView* aView, TAccessPointRecord &aRecord); + void OpenIapTableLC(CCommsDatabase **aIapDatabase, CCommsDbTableView **aView); + TInt ActiveConnectionCount(TInt &aCount); + TInt ActiveConnectionListL(CArrayFixFlat *aRecordPtr, TInt &aLength); + TInt GetRConnectionDetails(RConnection *aRc, TAccessPointRecord &aApr); + TInt StartConnection(void *aParam); + TInt GetConnectionPreference(TCommDbConnPref &aApr); + void GetIapDetailsByNameL(TBuf aIapName, TAccessPointRecord &aRecord); + void StopSubConnection(); + void StopConnection(); + TInt StartSubConnection(void *aParam); + TInt GetInterface(void *Param, TInt aType); + TInt GetInterafceNumber(void *aParam); + TInt GetIpAddress( void *aParam ); + + TInt RouteRequest(TInt aReq, void *aParam); + TInt GetInterfaceHWAddress(void *aParam); + + TInt ConvertRtEntry(TSoInetRouteInfo& aRouteInfo, struct rtentry *aRouteEntry); + TInt ConvertSockAddr(TInetAddr& aInetAddr, struct sockaddr_in *aSockAddr); + + TInt GetInterfaceByName(const TDesC& aIfName, TPckgBuf& aIface); + TInt Copy(TInetAddr& aDest, TInetAddr& aSrc); + + TInt GetRemoteIpAddress( void *aParam ); + TInt GetInterafceParamInfo( void *aParam,TInt aType); + void FindConnectionDetailsL(CArrayFixFlat*& aRecordPtr, TInt& aCount); + void FindConnectionInfoL(TAccessPointRecord &aRecord,char *ptr); + TInt GetInterfaceDetails( void *aParam ,TInt aFlag, TInt aType ); + TInt SetInterafceParamInfo( void *aParam,TInt aType); + TInt SetInterfaceDetails( void *aParam ,TInt aFlag, TInt aType ); + + TInt maybe_reopen_socket() + { + TInt err = KErrNone; + if (!__e32_atomic_load_acq32(&iSocketPtr)) + { + iReadLock.Wait(); + if (!iSocketPtr) + { + err = OpenUsingPreference(); + } + iReadLock.Signal(); + } + return err; + } + + enum InterfaceType + { + EACCESS_POINT, + EACTIVE_CONNECTION, + EACTIVE_GETIP, + EACCESS_GETMETRIC, + EACCESS_GETMTU, + EACCESS_GETNETMASK, + EACCESS_GETBROADCAST, + EACCESS_GETPHYSADDR, + EACCESS_GETFLAGS, + EACCESS_SETMETRIC, + EACCESS_SETMTU, + EACCESS_SETFLAGS, + EACCESS_SETPHYSADDR, + EACTIVE_SETIP, + EACCESS_SETNETMASK, + EACCESS_SETBROADCAST + }; + + TPtr8 iIoctlBuf; + RSocket *iSocketPtr; + TAccessPointRecord iConnPref; + RConnection iConnection; + RConnection *iConnectionPtr; + RSubConnection iSubConnection; + RSubConnection *iSubConnectionPtr; + TInt iRConnectionIndex; + RSocketServ *iSockServPtr; + void *iFids; + + }; + + +class CNotifier; + +NONSHARABLE_CLASS(CSerialDesc) : public CFileDescBase +/* +@internalComponent +*/ + { + + friend class CNotifier; + + public: + CSerialDesc() : CFileDescBase(), iReadThreshold(-1), iRequestedSignals(0), + iNotifyStatus(NULL), iNotifyParamPtr(NULL) {} + + TInt Open(const wchar_t* name, int mode, int perms); + TInt FinalClose(); + + void Read(TDes8& aDesc, TRequestStatus& aStatus); + void ReadCancel(); + + TInt& TimeoutValue() const; + void Write(TDes8& aDesc, TRequestStatus& aStatus); + TInt WriteCompletion(TDes8& aDesc, TInt aStatus); + + + void Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus); + TInt IoctlCompletion(int aCmd, void* aParam, TInt aStatus); + void IoctlCancel(); + + TBool TimedRead(); + void UserClose(); + virtual TInt Type() + { + return ESerialDesc; + } + +protected: + +private: + + void NotifyDataAvailable(TRequestStatus& aStatus); + void NotifyOutputEmpty(TRequestStatus& aStatus); + void NotifyBreak(TRequestStatus& aStatus); + void NotifyWriteErrors(TRequestStatus& aStatus, TUint* aRequestParams, TUint aSignalsMask); + void NotifySignalChange(TRequestStatus& iStatus, TUint& aRequestParam, TUint aSignalsMask); + void NotifyDataAvailableCancel(); + void NotifyOutputEmptyCancel(); + void NotifyBreakCancel(); + void NotifyWriteErrorsCancel(); + void NotifySignalChangeCancel(); + void Notify(TInt aVal); //complete the notify request + TInt NotifiesSupported(); //return the notifies supported at the moment + TBool RequestedNotifiesSupported(TInt aRequested); //see if the notifies requested are supported + void CancelNotifiers(const CNotifier* aCompletedNotifier); //cancel them all apart from the passed one + TUint Signals(); + + TInt ReadCompletion (TDes8& aBuf, TInt aStatus); + + TInt iReadThreshold; + RComm iCommPort; + + TInt iRequestedSignals; + TRequestStatus* iNotifyStatus; + TUint* iNotifyParamPtr; + TUint* iRequestDataPtr; + + CNotifier* iDataAvailableNotifier; + CNotifier* iOutputEmptyNotifier; + CNotifier* iBreakNotifier; + CNotifier* iErrorsNotifier; + CNotifier* iSignalsNotifier; + + }; + + +NONSHARABLE_CLASS(CPipeDescBase) : public CFileDescBase +/* +Base class with the RPipe handle and common methods +@internalComponent +*/ + { +public: + CPipeDescBase(const TUint16 aMode = 0) : CFileDescBase() + { + iFdAttrib |= KPipeFd; + if (aMode & O_NONBLOCK) + { + iFcntlFlag |= O_NONBLOCK; + } + } + + TInt Fcntl(TUint anArg, TUint aCmd); + TInt FStat(struct stat *st); + void Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus); + TInt FinalClose(); + + RPipe& Handle() + { + return iHandle; + } + + TUint& FcntlFlag() + { + return iFcntlFlag; + } + + TUint32& FDAttrib() + { + return iFdAttrib; + } + virtual TInt Type() + { + return EPipeDesc; + } + +protected: + RPipe iHandle; + }; + +NONSHARABLE_CLASS(CPipeReadDesc) : public CPipeDescBase +/* +Handle to the read-end of an RPipe object. +@internalComponent +*/ + { +public: + CPipeReadDesc(const TUint16 aMode = 0) : CPipeDescBase(aMode) + { + iFcntlFlag |= O_RDONLY; + } + + void Read(TDes8& aDesc, TRequestStatus& aStatus); + void Write(TDes8& aDesc, TRequestStatus& aStatus); + TInt Poll(TUint aEvents); + TInt NotifyActivity(TUint aEvents, TRequestStatus& aRequest, TTimeIntervalMicroSeconds32 /*timeout*/); + TInt TweakReadyEvents(TInt errval); + void CancelNotify(); + +protected: + TInt DoRead(TDes8& aDesc); + }; + +NONSHARABLE_CLASS(CPipeWriteDesc) : public CPipeDescBase +/* +Handle to the write-end of an RPipe object. +@internalComponent +*/ + { +public: + CPipeWriteDesc(const TUint16 aMode = 0) : CPipeDescBase(aMode) + { + iFcntlFlag |= O_WRONLY; + } + + void Write(TDes8& aDesc, TRequestStatus& aStatus); + void Read(TDes8& aDesc, TRequestStatus& aStatus); + TInt Poll(TUint aEvents); + TInt NotifyActivity(TUint aEvents, TRequestStatus& aRequest, TTimeIntervalMicroSeconds32 timeout); + TInt TweakReadyEvents(TInt errval); + void CancelNotify(); + +protected: + TInt DoWrite(TDes8& aDesc); + }; +NONSHARABLE_CLASS(CFileSocketDesc) : public CSockDescBase +/* +Class representing AF_UNIX socket descriptors +Implemented using 2 FIFOs +@internalComponent +*/ + { +public: + CFileSocketDesc(const TUint16 aMode = 0) + { + if (aMode & O_NONBLOCK) + { + iFcntlFlag |= O_NONBLOCK; + } + iFcntlFlag |= O_RDWR; + iPath.Zero(); + } + + void Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus); + TInt FinalClose(); + void Read(TDes8& aDesc, TRequestStatus& aStatus); + void Write(TDes8& aDesc, TRequestStatus& aStatus); + void RecvFrom(TDes8& aDesc, TSockAddr& from, int flags, TRequestStatus& aStatus); + void SendTo(TDes8& aDesc, const struct sockaddr* anAddr, unsigned long aAddrLen, int flags, TRequestStatus& aStatus); + TInt Listen(TUint qSize); + TInt GetSockOpt(TInt anOptionName,TInt anOptionLevel,TDes8& anOption); + TInt SetSockOpt(TInt anOptionName,TInt anOptionLevel,TDesC8& anOption); + TInt Bind(const struct sockaddr* addr, unsigned long size); + void Connect(const struct sockaddr* aAddr,unsigned long size, TRequestStatus& aStatus); + void Accept(CFileDescBase*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs, TSockAddr *); + TInt Socket(RSocketServ& aSs, int family, int style, int protocol); + TInt SockName(int anEnd, struct sockaddr* anAddr,unsigned long* aSize); + void AcceptCancel(); + void ConnectCancel(); + + TUint& FcntlFlag() + { + return iFcntlFlag; + } + + TUint32& FDAttrib() + { + return iFdAttrib; + } + virtual TInt Type() + { + return EFileSocketDesc; + } + + TInt GetLocalSockAddrByPort(struct sockaddr_un* aAddr,unsigned long* aAddrLen,TUint aPortNum); + TInt GetLocalSockPortByPath(const struct sockaddr_un* aAddr,unsigned long aAddrLen,TUint& aPortNum); + +private: + TInt ValidateAddress(const struct sockaddr_un* aAddr,unsigned long* aAddrLen); + TInt RemoveLocalSockAddr(); +private: + TBuf8 iPath; + RFastLock iReadLock; + RFastLock iWriteLock; + class TAutoFastLock + { + public: + TAutoFastLock(RFastLock &aLock):iAutoLock(aLock) + { + iAutoLock.Wait() ; + } + ~TAutoFastLock() + { + iAutoLock.Signal() ; + } + private: + RFastLock &iAutoLock; + }; + }; + +NONSHARABLE_CLASS(CDirectoryDesc) : public CFileDescBase +/* +Abstractions for a directory +@internalComponent +*/ + { +public: + CDirectoryDesc(); + ~CDirectoryDesc(); + + TInt Open(RFs& aSession, const TDesC& aName, int mode, int perms); + void Read(TDes8& aDesc, TRequestStatus& aStatus); + void Write(TDes8& aDesc, TRequestStatus& aStatus); + TInt Fcntl(TUint anArg, TUint aCmd); + TInt LSeek(off_t& offset, int whence); + TInt FStat(struct stat *st); + //Get the Name of the directory + inline const wchar_t* GetDirName() + { + return (const wchar_t*)iDirName.Ptr(); + } + virtual TInt Type() + { + return EDirDesc; + } + +private: + RDir iDir; + //Name of the directory + TFileName iDirName; + }; + +#ifdef SYMBIAN_OE_LIBRT +NONSHARABLE_CLASS(CSharedMemDesc) : public CFileDescBase +/* +Abstractions for shared memory +@internalComponent +*/ + { +public: + CSharedMemDesc(); + ~CSharedMemDesc(); + + TInt Open(const wchar_t* aName, int mode, int perms); + void Read(TDes8& aDesc, TRequestStatus& aStatus); + void Write(TDes8& aDesc, TRequestStatus& aStatus); + TInt Fcntl(TUint anArg, TUint aCmd); + TInt FStat(struct stat *st); + TInt LSeek(off_t& offset, int whence); +private: + TInt ShmRead(TUint8* aPtr,TInt aLength); + TInt ShmWrite(TUint8* aPtr,TInt aLength); + TInt DoShmRead(TDes8& aDesc); + TInt DoShmWrite(TDes8& aDesc); + TInt Pos(); + TInt Ext(); +protected: + TInt FinalClose(); +private: + RFastLock iLock; + void* iPtr; + TInt iSize; + TInt iPos; + TInt iExt; + TInt iPerms; + TInt iKey; + }; +#endif //SYMBIAN_OE_LIBRT +#endif // !_FDESC_H