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

// wins/specific/serialpdd.cpp

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

// 

//

/**

 @file

*/

#include "winscomm.h"

#include <nkern/nk_priv.h>

#include <nkern/win32/nk_plat.h>

#include <emulator.h>

#include <kernel/win32/property.h>

#define WIN32_LEAN_AND_MEAN

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

#include <windows.h>

#include <winsock2.h>

#include <string.h>

#include <stdlib.h>

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

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

//  note that MSVCRTD.LIB isn't included to the serialpdd.mmp, because this **** CW does not 

//  have it. Use it from MSVC package.

#include <crtdbg.h>

//#define WINTUN_PDD_LOGGING 

#ifdef WINTUN_PDD_LOGGING 

    #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

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

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

#ifdef FAULT

#undef FAULT

#endif

#define FAULT() Kern::Fault(__FILE__,__LINE__)

_LIT(KComName,"COM");

// needs ldd version..

const TInt KMinimumLddMajorVersion=1;

const TInt KMinimumLddMinorVersion=1;

const TInt KMinimumLddBuild=1;		

//used for the read and write buffers in the driver.

//large buffer reserved so any transfer to/from the client can fit into a driver buffer

const TInt KSerialBufferMaxSize = 0x800000;

const TInt KSerialBufferInitialSize = 0x10000;

const TInt KSerialBufferIncrementSize = 0x1000;	//granularity.  must be power of 2	

const DWORD KReadOneOrMoreTimeout = MAXDWORD-1;	//milliseconds

//buffer sizes passed to NT for setting its own driver buffer sizes

const TInt KDefaultWinNTReadBufSize = 1024;

const TInt KDefaultWinNTWriteBufSize = 1024;

static DWORD dummyLen = 0;

enum TDCommWinsFault 

	{

	EWindowsUnexpectedError,

	EUnknownCommand,

	EBadIOLen,

	EEofOnSerial,

	EWriteEarlyCompletion,

	ELineErrorNotReported,

	ESerialBufferTooBig,

	EReadLength,

	};

class DDriverComm : public DPhysicalDevice

	{

public:

	DDriverComm();

	virtual TInt Install();

	virtual TInt Remove();

	virtual void GetCaps(TDes8 &aDes) const;

	virtual TInt Create(DBase*& aChannel, TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);

	virtual TInt Validate(TInt aUnit, const TDesC8* aInfo, const TVersion &aVer);

	};

class DCommWins : public DComm

	{

public:

	enum TDriverCommand {ESetBreak=1,EClearBreak,ETransmit,ETransmit0,

						EGetSignals,ESetSignals,EConfigure,

						EStop,EStopNoDrain,EStart,EDie,	ETransmitCancel,

						EReceive, EReceiveOneOrMore, EReceiveCancel,ENotifyDataAvailable,

						ENotifySignals, EInvalidCommand};

public:

	DCommWins();

	~DCommWins();

	virtual TInt Start();

	virtual void Stop(TStopMode aMode);

	virtual void Break(TBool aState);

	virtual void Write(DThread* aThread, TAny *aTxDes, TInt aLength);

	virtual void Read(DThread* aThread, TAny *aTxDes, TInt aLength);

	virtual void NotifySignals(DThread* aThread, TInt aMask);

	virtual void NotifyDataAvailable();

	virtual TUint Signals() const;

	virtual void SetSignals(TUint aSetMask,TUint aClearMask);

	virtual TInt ValidateConfig(const TCommConfigV01 &aConfig) const;

	virtual void Configure(TCommConfigV01 &aConfig);

	virtual void Caps(TDes8 &aCaps) const;

	virtual void CheckConfig(TCommConfigV01& aConfig);

	virtual TDfcQue* DfcQ(TInt aUnit);

	inline void CheckTxBuffer();

	inline TBool Transmitting();

	virtual TInt RxCount();

	virtual void ResetBuffers(TBool);

	virtual TInt SetRxBufferSize(TInt aSize);

	virtual TInt RxBufferSize();

	virtual TDes8* RxBuffer();

	virtual void DoConfigure();

	virtual TBool AreAnyPending();

	virtual void ReadCancel();

	virtual void WriteCancel();

	virtual void SignalChangeCancel();

	TInt DoCreate(TInt aUnit,const TDesC8 *aInfo);

	void WaitForEvent();

	void DriverCommand(TDriverCommand aCommand);

	void DoWriteComplete(TInt aErr);

	void DoReadComplete(TInt aErr, TInt aBytes);

	void DoSignalCompletion(TInt aError, TUint changed, TUint aValues);

	void DoDataAvailableCompletion();

	void RunCommThread(TDriverCommand aCommand);

	inline void SignalDriverThread();

    TInt QueSocketRead();

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

    TBool inline UseSocket(void) const

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

private:

	void ReleaseBuffers();

	void ReSizeBuffer(TUint8*& aBuf, TInt& iBufLen, TPtr8& aDes, const TInt aNewLen);

	TBool IsATerminator(TText8 aChar);

	void CompleteRead(TInt aLength);

	void DataAvailableNotificationCancel();

private:

	TInt iWritePending;

	TInt iReadPending;

	TBool iStopping;

	TBool iRunning;

	TDriverCommand iCommand;

	TCommConfigV01 *iConfig;

	TUint iSignals;

	TUint iFailSignals;

	TUint iSavedSignals;

	TBool iLineFail;

	TBool iRXLineFail;

	TBool iTXLineFail;

	TUint8 * iInBufPtr;		//input buffer used by driver.

	TInt iInBufLength;

	TPtr8 iInDes;

	TInt iReadSoFar;

	TBool iTerminatedRead;	//true if we are reading with 1 or more terminating characters

	TUint8 * iOutBufPtr;

	TInt iOutBufLength;

	TPtr8 iOutDes;

	TInt iRxBufferSize;		//size of receivebuffer passed to windows & set by calls to SetReceiveBufferSize 

							//used to determine xon and xoff levels

	TUint iSignalsRequested;  //mask of signals we are waiting for

	TUint iSignalsWanted;		//mask we are asked to check 

	TBool iDataAvailableNotification;

	HANDLE iThread;

	HANDLE iCommThreadSem;

	HANDLE iDriverThreadSem;

	HANDLE iCommPort;

	DWORD iThreadID;

	DWORD iSignalStatus;

	OVERLAPPED iReadOverLapped;

	OVERLAPPED iWriteOverLapped;

	OVERLAPPED iSignalOverLapped;

	TInt iClientReadLength;		//how much data the client has requested in a read

    //-- win tunnel specific members

	SOCKET  iSocket;        //< socket for serial port simulation

	char    iOptions[151];  //< contains a string with mapping serial port numbers to the IPs

    TBool   iReadCancel;    //< flag, used to indicate that the read was cancelled during socket read

	};

void Panic(TDCommWinsFault aFault)

//

// Panic the driver 

//

	{

	Kern::PanicCurrentThread(_L("DCommWins"), aFault);

	}

TUint commThread(DCommWins *comm)

//

// Comm thread entry point

//

	{

	comm->WaitForEvent();

	return 0;

	}

VOID WINAPI WriteCompletion(DCommWins *aDrv, DWORD aErr,DWORD /*numBytes*/)

	{

	aDrv->DoWriteComplete(aErr);

	}

VOID WINAPI ReadCompletion(DCommWins *aDrv, DWORD aErr,DWORD numBytes)

	{

	aDrv->DoReadComplete(aErr, numBytes);

	}

VOID WINAPI SignalCompletion(DCommWins *aDrv, TInt aError, TUint aChanged, TUint aValues)

	{

	aDrv->DoSignalCompletion(aError, aChanged, aValues);

	}

VOID WINAPI DataAvailableCompletion(DCommWins *aDrv)

	{

	aDrv->DoDataAvailableCompletion();

	}

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

	{

	DWORD   err;

	DWORD   lastError = 0;

	BOOL    res;

	COMSTAT s;

	if(bUseSocket)

	{

	    res = FALSE;//, not supported... EscapeCommFunction(hFile,dwFunc);

	}

	else

	do

	{

		ClearCommError(hFile, &err, &s);

		res = EscapeCommFunction(hFile,dwFunc);

		if(!res)

			lastError = GetLastError();

	}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return res;

	}

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

{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	if(bUseSocket)

	{

	    res = FALSE;//, not supported... GetCommModemStatus(hFile,lpModemStat);

	}

	else

	do

	{

		ClearCommError(hFile, &err, &s);

		res = GetCommModemStatus(hFile,lpModemStat);

		if(!res)

			lastError  = GetLastError();

	}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

}

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

{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	if(bUseSocket)

	{

	    res = FALSE;//, not supported... GetCommState(hFile,lpDCB);

	}

	else

	do

	{

		ClearCommError(hFile,&err,&s);

		res = GetCommState(hFile,lpDCB);

		if (!res)

			lastError = GetLastError();

	}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

}

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

	{

	DWORD   err;

	DWORD   lastError = 0;

	BOOL    res;

	COMSTAT s;

	if(bUseSocket)

	{

        res = FALSE;//, not supported... SetCommState(hFile, lpDCB);

	}

	else

	do

	{

		ClearCommError(hFile, &err, &s);

		res = SetCommState(hFile, lpDCB);

		if (!res)

			lastError = GetLastError();

	}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

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

{

	DWORD   err;

	DWORD   lastError = 0;

	BOOL    res;

	COMSTAT s;

	if(bUseSocket)

	{

	    res = FALSE;//, not supported... SetCommMask(hFile, dwEvtMask);

	}

	else

	do

	{

		ClearCommError(hFile, &err, &s);

		res = SetCommMask(hFile, dwEvtMask);

		if (!res)

			lastError = GetLastError();

	}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

}

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

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

	if(bUseSocket)

	{//-- tunnel data to the socket

		WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);

	}

	else

	do

	{//-- normal operation with serial port

		ClearCommError(hFile, &err, &s);

		res = WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);

		if (!res)

			lastError = GetLastError();

	}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

	return(res);

	}

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

	{

	DWORD err;

	DWORD lastError = 0;

	BOOL res;

	COMSTAT s;

    _Log2("#ReadFileP()#1 to read: %d bytes \n", nNumberOfBytesToRead);

	if(bUseSocket)

	{//-- tunnel data to the socket

		ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);

	}

	else

	do

	{//-- normal operation with serial port

		ClearCommError(hFile, &err, &s);

		res = ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);

		if (!res)

			lastError = GetLastError();

	}

	while((!res) && (lastError == ERROR_OPERATION_ABORTED));

    _Log2("#ReadFileP()#2 read: %d bytes \n", *lpNumberOfBytesRead);

	return(res);

	}

DDriverComm::DDriverComm()

	{

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

	{

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

	{

	return(KErrNone);

	}

TInt DDriverComm::Validate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

//

//	Validate the requested configuration

//

	{

	if ((!Kern::QueryVersionSupported(iVersion,aVer)) || (!Kern::QueryVersionSupported(aVer,TVersion(KMinimumLddMajorVersion,KMinimumLddMinorVersion,KMinimumLddBuild))))

		return KErrNotSupported;

#if defined (__COM_ONE_ONLY__)

	if (aUnit!=0)

		return KErrNotSupported;

#elif defined (__COM_TWO_ONLY__)

	if (aUnit!=1)

		return KErrNotSupported;

#endif

	// leave Unit check to CreateFile

	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 = 0x3BF;	//all except KConfigObeyDCD

	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

	{