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