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

		 {