// 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 <e32cons.h>

#include <f32file.h>

#include <es_sock.h>

#include <c32comm.h>

#include <stddef.h>

#include <redircli.h>

#include <redircliinternal.h>

// Queuing support for asynchronous requests

//

class CPosixRequest;

class TPosixRequestQueue : public TSglQue<CPosixRequest>

/**

@internalComponent

*/

	{

public:

	inline TPosixRequestQueue();

	};

//  The base class for all flavours of FileDescriptor

//

class CSerialTimer;

class CPosixRequest;

class CSocketDesc;

NONSHARABLE_CLASS(CFileDescBase) : public CBase

/**

@internalComponent

*/

	{

public:

	static CFileDescBase* Open(RSessionBase& aSession, 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 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 TInt RecvFromCompletion(TInt& aLength, TInt aStatus);

	virtual void RecvFromCancel();

	virtual void SendTo(TDes8& aDesc, TSockAddr& to, int flags, TRequestStatus& aStatus);

	virtual TInt SendToCompletion(TDes8& aDesc, TInt aStatus);

	virtual void SendToCancel();

	virtual void Sync(TRequestStatus& aStatus);

	virtual void SyncCancel();

	virtual void Accept(CSocketDesc*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs);

	virtual void AcceptCancel();

	virtual void Connect(TSockAddr& anAddr,TRequestStatus& aStatus);

	virtual void ConnectCancel();

	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(int& offset, int whence);

	virtual TInt FStat(struct stat* st);

	virtual TInt Bind(TSockAddr& anAddr);

	virtual TInt Listen(TUint qSize);

	virtual TInt SockName(int anEnd, TSockAddr& anAddr);

	virtual TInt GetSockOpt(TUint anOptionName,TUint anOptionLevel,TDes8& anOption);

	virtual TInt SetSockOpt(TUint anOptionName,TUint anOptionLevel,TDesC8& anOption);

	static void Cleanup(TAny *aPtr);

	void PushLC();

	TInt Close();

	virtual void UserClose() {return;}

	inline CFileDescBase* Dup();

	enum IOQueues 

		{ 

		IOreadQ=0, IOwriteQ=1, IOioctlQ=2,IOioctlNQ=3,

		IOmaxQ=IOioctlNQ 

		};

	void AddLast(CPosixRequest& aRequest, IOQueues aQueue);

	void Remove(CPosixRequest& aRequest, IOQueues aQueue);

	TBool ReadIsTimed;

	TBool ReadWasCancelled;

	CSerialTimer * TimedMessage;

protected:

	CFileDescBase();

	virtual TInt FinalClose();

	static void Complete(TRequestStatus& aStatus, TInt aResult);

	TInt iReadTimeout;

private:

	TInt iDupCount;

	TFixedArray<TPosixRequestQueue,IOmaxQ+1> iQueues;

	};

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

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

protected:

	virtual TInt FinalClose();

private:

	void MapCodeAndEcho(TDes8& aDesc, TKeyCode aCode);

	void CheckConsoleCreated();

	void Write(TDes8& aDesc);

	CConsoleBase *iConsole;

	};

inline CTtyDesc::CTtyDesc(CConsoleBase *c) : CFileDescBase(), iConsole(c) {}

inline CTtyDesc::CTtyDesc() : CFileDescBase() {}

NONSHARABLE_CLASS(CRedirDesc) : public CFileDescBase

/**

client-side connection to the redirection server

@internalComponent

*/

	{

public:

	CRedirDesc();

	virtual TInt Connect();

	virtual void Read(TDes8& aDesc, TRequestStatus& aStatus);

	virtual void Write(TDes8& aDesc, TRequestStatus& aStatus);

	virtual void Sync(TRequestStatus& aStatus);

	TInt FinalClose();

private:

	RRedirSession2 iRedirSession;

	TBool iAttemptedConnection;

	};

NONSHARABLE_CLASS(CFileDesc) : public CFileDescBase

/**

Abstractions for a plain file and a temporary file

@internalComponent

*/

	{

public:

	CFileDesc();

	~CFileDesc();

	TInt Open(RFs& aSession, const TDesC& aName, int mode, int perms);

	TInt LSeek(int& 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);

	static void MapStat(struct stat& st, const TTime& aModTime, TUint& aAttr);

protected:

	virtual TInt FinalClose();

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

	TInt Pos();

	TInt Ext();

	TInt Alloc();

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;

	TInt iSize;

	TInt iPos;

	TInt iExt;

	};

NONSHARABLE_CLASS(CTempFileDesc) : public CFileDesc

/**

@internalComponent

*/

	{

public:

	TInt Open(RFs& aSession, const TDesC& aPath);

protected:

	virtual TInt FinalClose();

private:

	RFs iSession;

	TFileName iName;

	};

NONSHARABLE_CLASS(CSocketDesc) : public CFileDescBase

/**

Abstraction for a socket

@internalComponent

*/

	{

public:

	CSocketDesc() : CFileDescBase(), iIoctlBuf(0,0) {}

	TInt Socket(RSocketServ& aSs, int family, int style, int protocol);

	TInt LSeek(int& offset, int whence);

	void Read(TDes8& aDesc, TRequestStatus& aStatus);

	void ReadCancel();

	void Write(TDes8& aDesc, TRequestStatus& aStatus);

	void WriteCancel();

	TInt FStat(struct stat* st);

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

	TInt RecvFromCompletion(TInt& aLength, TInt aStatus);

	void RecvFromCancel();

	void SendTo(TDes8& aDesc, TSockAddr& to, int flags, TRequestStatus& aStatus);

	void SendToCancel();

	void Shutdown(TUint aHow,TRequestStatus& aStatus);

	void Accept(CSocketDesc*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs);

	void AcceptCancel();

	void Connect(TSockAddr& anAddr,TRequestStatus& aStatus);

	void ConnectCancel();

	TInt Bind(TSockAddr& anAddr);

	TInt Listen(TUint qSize);

	TInt SockName(int anEnd, TSockAddr& anAddr);

	TInt GetSockOpt(TUint anOptionName,TUint anOptionLevel,TDes8& anOption);

	TInt SetSockOpt(TUint anOptionName,TUint anOptionLevel,TDesC8& anOption);

protected:

	TInt FinalClose();

private:

	inline TInt isStream() const;

	RSocket iSocket;

	TInt iStyle;

	TSockXfrLength iLength;

	TPtr8 iIoctlBuf;

	};

class TUSockAddr : public TSockAddr

/**

Utility class for converting struct sockaddr to and from EPOC32 TSockAddr

@internalComponent

*/

	{

public:

	TUSockAddr() : TSockAddr() {}

	TUSockAddr(TAny* addr);			// constructor form of Prepare

	TUSockAddr(TAny* addr, TUint len);	// constructor form of Set

	void Prepare(TAny* addr);

	void Set(TAny* addr, TUint len);

	void Get(TAny* addr, unsigned long* len);

	};

NONSHARABLE_CLASS(CSerialTimer) : public CTimer

/**

the serial timer class

@internalComponent

*/

  	{

public:

	CSerialTimer();

	~CSerialTimer();

public:

	static CSerialTimer* NewLC(CFileDescBase*);

	static CSerialTimer* NewL(CFileDescBase*);

public:

	void ConstructL(CFileDescBase*);

	void IssueRequest(); 

	void DoCancel();

	void RunL();

private:

	CFileDescBase* iFile;

	};

class CNotifier;

NONSHARABLE_CLASS(CSerialDesc) : public CFileDescBase

/**

@internalComponent

*/

	{

	friend class CNotifier;

	public:

	CSerialDesc() : CFileDescBase(), iReadThreshold(-1), iRequestedSignals(0),

					iNotifyStatus(NULL), iNotifyParamPtr(NULL) {}

	TInt Open(RCommServ& aSession, 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);

	void Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus);

	TInt IoctlCompletion(int aCmd, void* aParam, TInt aStatus);

	void IoctlCancel();

	TBool TimedRead();

	void UserClose();

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;

	};

#endif // !_FDESC_H