// Copyright (c) 1995-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:

// Modified serial pdd that supports IP tunneling data from the emulator to  socket.

// Beech specific version.

// 

//

/**

 @file

*/

#if defined(_UNICODE)

#if !defined(UNICODE)

#define UNICODE

#endif

#endif

#define _WIN32_WINDOWS 0x0410 // Need NT4 / 98 or higher for the timer

#define WIN32_LEAN_AND_MEAN

#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union

#include <windows.h>

#include <winsock2.h>

#pragma warning( default : 4201 ) // nonstandard extension used : nameless struct/union

#include <k32std.h>

#include <e32wins.h>

#include "uansi.h"

#include "d_comm.h"

//#include "iostream.h"

// Dumps everything written to the serial port to temp files.

//#define _LOG_OUTPUT

//----------------------------------------------------------------

//  logging macros. Just define WINTUN_PDD_LOGGING to enable debug trace

//  require MSVCRTD.LIB

#include <crtdbg.h>

//#define WINTUN_PDD_LOGGING 

#ifdef WINTUN_PDD_LOGGING 

    #pragma warning( disable : 4127 ) 

    #define _Log(a)         _RPT0(_CRT_WARN,a)

    #define _Log2(a,b)      _RPT1(_CRT_WARN,a,b)

    #define _Log3(a,b,c)    _RPT2(_CRT_WARN,a,b,c)

    #define _Log4(a,b,c,d)  _RPT3(_CRT_WARN,a,b,c,d)

#else

    #define _Log(a)       

    #define _Log2(a,b)    

    #define _Log3(a,b,c)  

    #define _Log4(a,b,c,d)

#endif

const TInt KReadBufSize = 1024;

const TInt KWriteBufSize = 16;

//const TInt KWinNTReadBufSize = 1024;

const TInt KWinNTReadBufSize = 1500;

const TInt KWinNTWriteBufSize = KWriteBufSize;

static DWORD dummyLen=0;

enum TDCommWinsFault 

	{

	EWindowsUnexpectedError,

	EUnknownCommand,

	EBadIOLen,

	EEofOnSerial,

	EWriteEarlyCompletion,

	ELineErrorNotReported,

	};

class DDriverComm : public DPhysicalDevice

	{

public:

	DDriverComm();

	virtual TInt Install();

	virtual TInt Remove();

	virtual void GetCaps(TDes8 &aDes) const;

	virtual CBase *CreateL(TInt aUnit,const TDesC *anInfo,const TVersion &aVer);

	};

class DCommWins : public DComm

	{

public:

	enum TDriverCommand {ESetBreak,EClearBreak,ETransmit,

						EGetSignals,ESetSignals,EConfigure,

						EStop,EStopNoDrain,EStart,EDie,EInvalidCommand};

public:

	DCommWins();

	~DCommWins();

	virtual TInt Start();

	virtual void Stop(TStopMode aMode);

	virtual void Break(TBool aState);

	virtual void EnableTransmit();

	virtual TUint Signals() const;

	virtual void SetSignals(TUint aSetMask,TUint aClearMask);

	virtual TInt Validate(const TCommConfigV01 &aConfig) const;

	virtual void Configure(TCommConfigV01 &aConfig);

	virtual void DoConfigure();

	virtual void CheckConfig(TCommConfigV01& aConfig);

	virtual void Caps(TDes8 &aCaps) const;

	virtual void EnableInterrupts();

	virtual void DisableInterrupts();

	TInt CompleteSlowOpen(DThread *aThread,TRequestStatus *aReqStat);

	void EnterCritical();

	void LeaveCritical();

	TInt DoCreate(TInt aUnit,const TDesC *anInfo);

	void WaitForEvent();

	void DriverCommand(TDriverCommand aCommand);

	void DoTransmit(TInt aByteCount);

	void DoReceive(TInt aByteCount);

	void RunCommThread(TDriverCommand aCommand);

	inline void SignalDriverThread();

	TInt DoTransmitIsr(TInt anOffset);

	void DoReceiveIsr(TUint aCharAndMask);

	void DoStateIsr();

    void SetTimer(const TUint aTimeOut); 

    void CancelTimer(); 

private:

	TBool iWritePending;

	TBool iReadPending;

    TBool iStopping;

	// TBool iReading;

	TBool iRunning;

	TDriverCommand iCommand;

	TCommConfigV01 *iConfig;

	TUint iSignals;

	TUint8 iInBuf[KReadBufSize];

	DWORD iNumInChars;

	TUint8 iOutBuf[KWriteBufSize];

	DWORD iNumOutChars;

	HANDLE iThread;

	HANDLE iCommThreadSem;

	HANDLE iDriverThreadSem;

	HANDLE iCommPort;

    HANDLE iWaitableTimer; 

    LARGE_INTEGER iTimeOut; 

	DWORD iThreadID;

	DWORD iSignalStatus;

	OVERLAPPED iReadOverLapped;

	OVERLAPPED iWriteOverLapped;

	OVERLAPPED iSignalOverLapped;

#if defined (_DEBUG)

	TInt iUnit;

	HANDLE iLogFile;

#endif

#if defined (_LOG_OUTPUT)

	HANDLE iWritesHandle;

	HANDLE iReadsHandle;

#endif

	CRITICAL_SECTION iCriticalSection;

	TInt iIntRefCount;

	TBool iSkipTransmitIsrNextTime;

	SOCKET iSocket;

    /** @return ETrue if we use socket instead of a real COM port */

    TBool inline UseSocket(void) const

        {return  (iSocket != INVALID_SOCKET) && (iSocket != NULL); }

    TInt QueSocketRead();

    TBool GetComPortMapping(LPCSTR aFileName, TInt aPortNum, TDes8& aPortMapStr);

	};

void Panic(TDCommWinsFault aFault)

//

// Panic the driver 

//

	{

	Plat::Panic(_L("DCommWins"),aFault);

	}

TInt MapWinError(TInt aErrCode)

{

	switch (aErrCode)

	{

	case ERROR_INVALID_USER_BUFFER:

	case ERROR_NOT_ENOUGH_MEMORY:

	case ERROR_INSUFFICIENT_BUFFER:

		return(KErrNoMemory);

	case ERROR_ACCESS_DENIED:

		return(KErrAccessDenied);

	case ERROR_NOT_SUPPORTED:

		return(KErrNotSupported);

	default:

		return(KErrGeneral);

	} 

}

TInt MapWinError()

//

// Make an E32 error from the dodgy old thing windows tells us

//

{

	DWORD winErr=GetLastError();

    return MapWinError(winErr);

}

TUint commThread(DCommWins *comm)

//

// Comm thread entry point

//

	{

	comm->WaitForEvent();

	return 0;

	}

//VOID WINAPI ReadComplete(DWORD anErr,DWORD numBytes,LPOVERLAPPED anOverLapped)

//

// Windows read completion routine

//

//	{

//

//	if (numBytes>KReadBufSize)

//		Panic(EBadIOLen); 

//	if (anErr==ERROR_HANDLE_EOF)

//		Panic(EEofOnSerial);

//	((DCommWins *)(anOverLapped->hEvent))->DoReceive(numBytes);

//	}

VOID WINAPI WriteCompletion(DCommWins *aDrv, DWORD anErr,DWORD numBytes)

//

// Windows read completion routine

//

	{

	if (numBytes>KWriteBufSize+1)	// May have written an Xon

		Panic(EBadIOLen); 

	if (anErr==ERROR_HANDLE_EOF)

		Panic(EEofOnSerial);

	aDrv->DoTransmit(numBytes);

	}

BOOL WINAPI EscapeCommFunctionP(HANDLE hFile,DWORD dwFunc, BOOL bUseSocket)

//

// Protected Set/Clear modem control signals: protects against this operation being cancelled by another thread

//

    {

	if(bUseSocket)

        return TRUE;

    DWORD err,res,res1;

	COMSTAT s;

	BOOL result;

	result=FALSE;

	do

		{

		ClearCommError(hFile,&err,&s);

		if((res1=EscapeCommFunction(hFile,dwFunc))==FALSE)

			res=GetLastError();

		else

			{

			result=TRUE;

			break;

			}

		}

	while((res1==FALSE) && (res==ERROR_OPERATION_ABORTED));

	return(result);

	}

BOOL WINAPI GetCommModemStatusP(HANDLE hFile,LPDWORD lpModemStat, BOOL bUseSocket)

//

// Protected read modem control signals: protects against this operation being cancelled by another thread

//

	{

	if(bUseSocket)

        return TRUE;

	DWORD err,res,res1;

	COMSTAT s;

	BOOL result;

	result=FALSE;

	do

		{

		ClearCommError(hFile,&err,&s);

		if((res1=GetCommModemStatus(hFile,lpModemStat))==FALSE)

			res=GetLastError();

		else

			{

			result=TRUE;

			break;

			}

		}

	while((res1==FALSE) && (res==ERROR_OPERATION_ABORTED));

	return(result);

	}

BOOL WINAPI GetCommStateP(HANDLE hFile,LPDCB lpDCB, BOOL bUseSocket)

//

// Retrieves the current control settings for a specified communications device: protected against

// this operation being cancelled by another thread

//

	{

	if(bUseSocket)

        return TRUE;

	DWORD err,res,res1;

	COMSTAT s;

	BOOL result;

	result=FALSE;

	do

		{

		ClearCommError(hFile,&err,&s);

		if((res1=GetCommState(hFile,lpDCB))==FALSE)

			res=GetLastError();

		else

			{

			result=TRUE;

			break;

			}

		}

	while((res1==FALSE) && (res==ERROR_OPERATION_ABORTED));

	return(result);

	}

BOOL WINAPI SetCommStateP(HANDLE hFile,LPDCB lpDCB, BOOL bUseSocket)

//

// Configures a communications device according to the specifications in a device-control block: protected against

// this operation being cancelled by another thread

//

	{

	if(bUseSocket)

        return TRUE;

	DWORD err,res,res1;

	COMSTAT s;

	BOOL result;

	result=FALSE;

	do

		{

		ClearCommError(hFile,&err,&s);

		if((res1=SetCommState(hFile,lpDCB))==FALSE)

			res=GetLastError();

		else

			{

			result=TRUE;

			break;

			}

		}

	while((res1==FALSE) && (res==ERROR_OPERATION_ABORTED));

	return(result);

	}

BOOL WINAPI SetCommMaskP(HANDLE hFile,DWORD dwEvtMask, BOOL bUseSocket)

//

// Specifies a set of events to be monitored for a communications device: protected against

// this operation being cancelled by another thread

//

	{

	if(bUseSocket)

        return TRUE;

	DWORD err,res,res1;

	COMSTAT s;

	BOOL result;

	result=FALSE;

	do

		{

		ClearCommError(hFile,&err,&s);

		if((res1=SetCommMask(hFile,dwEvtMask))==FALSE)

			res=GetLastError();

		else

			{

			result=TRUE;

			break;

			}

		}

	while((res1==FALSE) && (res==ERROR_OPERATION_ABORTED));

	return(result);

	}

BOOL WINAPI WriteFileP(HANDLE hFile,LPCVOID lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,LPOVERLAPPED lpOverlapped)

//

// Writes data to device pointed by hFile: protected against

// this operation being cancelled by another thread

//

	{

	DWORD err,res,res1;

	COMSTAT s;

	BOOL result;

	result=FALSE;

	do

		{

		ClearCommError(hFile,&err,&s);

		if((res1=WriteFile(hFile,lpBuffer,nNumberOfBytesToWrite,lpNumberOfBytesWritten,lpOverlapped))==FALSE)

			res=GetLastError();

		else

			{

			result=TRUE;

			break;

			}

		}

	while((res1==FALSE) && (res==ERROR_OPERATION_ABORTED));

	return(result);

	}

BOOL WINAPI ReadFileP(HANDLE hFile,LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead,LPOVERLAPPED lpOverlapped)

//

// Writes data to device pointed by hFile: protected against

// this operation being cancelled by another thread

//

	{

	DWORD err,res,res1;

	COMSTAT s;

	BOOL result;

	result=FALSE;

	do

		{

		ClearCommError(hFile,&err,&s);

		if((res1=ReadFile(hFile,lpBuffer,nNumberOfBytesToRead,lpNumberOfBytesRead,lpOverlapped))==FALSE)

			res=GetLastError();

		else

			{

			result=TRUE;

			break;

			}

		}

	while((res1==FALSE) && (res==ERROR_OPERATION_ABORTED));

	return(result);

	}

DDriverComm::DDriverComm()

//

// Constructor

//

	{

#if defined (__COM_ONE_ONLY__)

	iUnitsMask=0x1; // Support units 0

#elif defined (__COM_TWO_ONLY__)

	iUnitsMask=0x2; // Support units 1

#else

	iUnitsMask=0x3ff; // Support units 0 to 9

#endif

	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

	}

TInt DDriverComm::Install()

//

// Install the device driver.

//

	{

#if defined (__COM_ONE_ONLY__)

	TPtrC buf=_L("Comm.Wins1");

	return(SetName(&buf));

#elif defined (__COM_TWO_ONLY__)

	TPtrC buf=_L("Comm.Wins2");

	return(SetName(&buf));

#else

	TPtrC buf=_L("Comm.Wins");

	return(SetName(&buf));

#endif

	}

TInt DDriverComm::Remove()

//

// Remove the device driver.

//

	{

	return(KErrNone);

	}

void GetWinsCommsCaps(TDes8 &aCaps)

	{

	TCommCaps2 capsBuf;

	TCommCapsV02 &c=capsBuf();

//

// All rates except 50,2000, 3600 and special

//

	c.iRate=KCapsBps75|KCapsBps110|KCapsBps134|KCapsBps150|KCapsBps300|KCapsBps600|KCapsBps1200|KCapsBps1800|KCapsBps2400|KCapsBps4800|KCapsBps7200|KCapsBps9600|KCapsBps19200|KCapsBps38400|KCapsBps57600|KCapsBps115200;

	c.iDataBits=0xf; // All data sizes

	c.iStopBits=0x3; // 1 and 2 stop bits

	c.iParity=0x7; // None, Even and Odd

	c.iHandshake=0x1ff; // All handshakes

	c.iSignals=0x3f; // All signals

	c.iSIR=0;//No Ir

	c.iNotificationCaps=KNotifySignalsChangeSupported|KNotifyDataAvailableSupported;

	c.iRoleCaps=0;

	c.iFlowControlCaps=0;

	aCaps.FillZ(aCaps.MaxLength());

	aCaps=capsBuf.Left(Min(capsBuf.Length(),aCaps.MaxLength()));

	}

void DDriverComm::GetCaps(TDes8 &aDes) const

//

// Return the drivers capabilities.

//

	{

	GetWinsCommsCaps(aDes);

	}

CBase *DDriverComm::CreateL(TInt aUnit,const TDesC *anInfo,const TVersion &aVer)

//