// 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 <e32std.h>
#include <e32atomics.h>
#include <e32cons.h>
#include <f32file.h>
#include <es_sock.h>
#include <c32comm.h>
#include <stddef.h>
#include <cdblen.h>
#include <commdb.h>
#include <commdbconnpref.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <rpipe.h>
#include <in_sock.h>
#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<TUint> 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<TAccessPointRecord> *&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<TAccessPointRecord> *aRecordPtr, TInt &aLength);
TInt GetRConnectionDetails(RConnection *aRc, TAccessPointRecord &aApr);
TInt StartConnection(void *aParam);
TInt GetConnectionPreference(TCommDbConnPref &aApr);
void GetIapDetailsByNameL(TBuf<KCommsDbSvrMaxColumnNameLength> 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<TSoInetInterfaceInfo>& aIface);
TInt Copy(TInetAddr& aDest, TInetAddr& aSrc);
TInt GetRemoteIpAddress( void *aParam );
TInt GetInterafceParamInfo( void *aParam,TInt aType);
void FindConnectionDetailsL(CArrayFixFlat<TAccessPointRecord>*& 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<KMaxFileName> 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