// 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);