1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // wins/specific/serialpdd.cpp

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

    16 // 

    17 //

    18 

    19 /**

    20  @file

    21 */

    22 

    23 #include "winscomm.h"

    24 #include <nkern/nk_priv.h>

    25 #include <nkern/win32/nk_plat.h>

    26 #include <emulator.h>

    27 

    28 #include <kernel/win32/property.h>

    29 

    30 #define WIN32_LEAN_AND_MEAN

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

    32 

    33 #include <windows.h>

    34 #include <winsock2.h>

    35 #include <string.h>

    36 #include <stdlib.h>

    37 

    38 //----------------------------------------------------------------

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

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

    41 //  have it. Use it from MSVC package.

    42 

    43 #include <crtdbg.h>

    44 

    45 //#define WINTUN_PDD_LOGGING 

    46 

    47 #ifdef WINTUN_PDD_LOGGING 

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

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

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

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

    52 

    53 #else

    54     #define _Log(a)       

    55     #define _Log2(a,b)    

    56     #define _Log3(a,b,c)  

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

    58 

    59 #endif

    60 

    61 //----------------------------------------------------------------

    62 

    63 

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

    65 

    66 #ifdef FAULT

    67 #undef FAULT

    68 #endif

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

    70 

    71 _LIT(KComName,"COM");

    72 

    73 // needs ldd version..

    74 const TInt KMinimumLddMajorVersion=1;

    75 const TInt KMinimumLddMinorVersion=1;

    76 const TInt KMinimumLddBuild=1;		

    77 

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

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

    80 const TInt KSerialBufferMaxSize = 0x800000;

    81 const TInt KSerialBufferInitialSize = 0x10000;

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

    83 

    84 

    85 const DWORD KReadOneOrMoreTimeout = MAXDWORD-1;	//milliseconds

    86 

    87 

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

    89 const TInt KDefaultWinNTReadBufSize = 1024;

    90 const TInt KDefaultWinNTWriteBufSize = 1024;

    91 

    92 static DWORD dummyLen = 0;

    93 

    94 enum TDCommWinsFault 

    95 	{

    96 	EWindowsUnexpectedError,

    97 	EUnknownCommand,

    98 	EBadIOLen,

    99 	EEofOnSerial,

   100 	EWriteEarlyCompletion,

   101 	ELineErrorNotReported,

   102 	ESerialBufferTooBig,

   103 	EReadLength,

   104 	};

   105 

   106 

   107 class DDriverComm : public DPhysicalDevice

   108 	{

   109 public:

   110 	DDriverComm();

   111 	virtual TInt Install();

   112 	virtual TInt Remove();

   113 	virtual void GetCaps(TDes8 &aDes) const;

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

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

   116 	};

   117 

   118 

   119 class DCommWins : public DComm

   120 	{

   121 public:

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

   123 						EGetSignals,ESetSignals,EConfigure,

   124 						EStop,EStopNoDrain,EStart,EDie,	ETransmitCancel,

   125 						EReceive, EReceiveOneOrMore, EReceiveCancel,ENotifyDataAvailable,

   126 						ENotifySignals, EInvalidCommand};

   127 public:

   128 	DCommWins();

   129 	~DCommWins();

   130 	virtual TInt Start();

   131 	virtual void Stop(TStopMode aMode);

   132 	virtual void Break(TBool aState);

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

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

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

   136 	virtual void NotifyDataAvailable();

   137 	virtual TUint Signals() const;

   138 	virtual void SetSignals(TUint aSetMask,TUint aClearMask);

   139 	virtual TInt ValidateConfig(const TCommConfigV01 &aConfig) const;

   140 	virtual void Configure(TCommConfigV01 &aConfig);

   141 	virtual void Caps(TDes8 &aCaps) const;

   142 	virtual void CheckConfig(TCommConfigV01& aConfig);

   143 	virtual TDfcQue* DfcQ(TInt aUnit);

   144 

   145 	inline void CheckTxBuffer();

   146 	inline TBool Transmitting();

   147 	virtual TInt RxCount();

   148 	virtual void ResetBuffers(TBool);

   149 	virtual TInt SetRxBufferSize(TInt aSize);

   150 	virtual TInt RxBufferSize();

   151 	virtual TDes8* RxBuffer();

   152 	virtual void DoConfigure();

   153 	virtual TBool AreAnyPending();

   154 	virtual void ReadCancel();

   155 	virtual void WriteCancel();

   156 	virtual void SignalChangeCancel();

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

   158 	void WaitForEvent();

   159 	void DriverCommand(TDriverCommand aCommand);

   160 	void DoWriteComplete(TInt aErr);

   161 	void DoReadComplete(TInt aErr, TInt aBytes);

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

   163 	void DoDataAvailableCompletion();

   164 	void RunCommThread(TDriverCommand aCommand);

   165 	inline void SignalDriverThread();

   166 

   167     TInt QueSocketRead();

   168 

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

   170     TBool inline UseSocket(void) const

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

   172 

   173 private:

   174 	void ReleaseBuffers();

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

   176 	TBool IsATerminator(TText8 aChar);

   177 	void CompleteRead(TInt aLength);

   178 	void DataAvailableNotificationCancel();

   179 

   180 

   181 private:

   182 	TInt iWritePending;

   183 	TInt iReadPending;

   184 	TBool iStopping;

   185 	TBool iRunning;

   186 	TDriverCommand iCommand;

   187 	TCommConfigV01 *iConfig;

   188 	TUint iSignals;

   189 	TUint iFailSignals;

   190 	TUint iSavedSignals;

   191 	TBool iLineFail;

   192 	TBool iRXLineFail;

   193 	TBool iTXLineFail;

   194 

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

   196 	TInt iInBufLength;

   197 	TPtr8 iInDes;

   198 

   199 	TInt iReadSoFar;

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

   201 

   202 	TUint8 * iOutBufPtr;

   203 	TInt iOutBufLength;

   204 	TPtr8 iOutDes;

   205 

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

   207 							//used to determine xon and xoff levels

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

   209 	TUint iSignalsWanted;		//mask we are asked to check 

   210 	TBool iDataAvailableNotification;

   211 	HANDLE iThread;

   212 	HANDLE iCommThreadSem;

   213 	HANDLE iDriverThreadSem;

   214 	HANDLE iCommPort;

   215 	DWORD iThreadID;

   216 	DWORD iSignalStatus;

   217 	OVERLAPPED iReadOverLapped;

   218 	OVERLAPPED iWriteOverLapped;

   219 	OVERLAPPED iSignalOverLapped;

   220 

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

   222 

   223     //-- win tunnel specific members

   224 	SOCKET  iSocket;        //< socket for serial port simulation

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

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

   227 

   228 	};

   229 

   230 void Panic(TDCommWinsFault aFault)

   231 //

   232 // Panic the driver 

   233 //

   234 	{

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

   236 	}

   237 

   238 

   239 TUint commThread(DCommWins *comm)

   240 //

   241 // Comm thread entry point

   242 //

   243 	{

   244 

   245 	comm->WaitForEvent();

   246 	return 0;

   247 	}

   248 

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

   250 	{

   251 

   252 	aDrv->DoWriteComplete(aErr);

   253 	}

   254 

   255 

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

   257 	{

   258 

   259 	aDrv->DoReadComplete(aErr, numBytes);

   260 	}

   261 

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

   263 	{

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

   265 	}

   266 

   267 VOID WINAPI DataAvailableCompletion(DCommWins *aDrv)

   268 	{

   269 	aDrv->DoDataAvailableCompletion();

   270 	}

   271 

   272 

   273 

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

   275 	{

   276 	DWORD   err;

   277 	DWORD   lastError = 0;

   278 	BOOL    res;

   279 	COMSTAT s;

   280 	

   281 	if(bUseSocket)

   282 	{

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

   284 	}

   285 	else

   286 	do

   287 	{

   288 		ClearCommError(hFile, &err, &s);

   289 		res = EscapeCommFunction(hFile,dwFunc);

   290 		if(!res)

   291 			lastError = GetLastError();

   292 	}

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

   294 

   295 	return res;

   296 	}

   297 

   298 

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

   300 {

   301 	DWORD err;

   302 	DWORD lastError = 0;

   303 	BOOL res;

   304 	COMSTAT s;

   305 

   306 	if(bUseSocket)

   307 	{

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

   309 	}

   310 	else

   311 	do

   312 	{

   313 		ClearCommError(hFile, &err, &s);

   314 		res = GetCommModemStatus(hFile,lpModemStat);

   315 		if(!res)

   316 			lastError  = GetLastError();

   317 	}

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

   319 

   320 	return(res);

   321 }

   322 

   323 

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

   325 {

   326 	DWORD err;

   327 	DWORD lastError = 0;

   328 	BOOL res;

   329 	COMSTAT s;

   330 	

   331 	if(bUseSocket)

   332 	{

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

   334 	}

   335 	else

   336 	do

   337 	{

   338 		ClearCommError(hFile,&err,&s);

   339 		res = GetCommState(hFile,lpDCB);

   340 		if (!res)

   341 			lastError = GetLastError();

   342 	}

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

   344 

   345 	return(res);

   346 }

   347 

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

   349 	{

   350 	DWORD   err;

   351 	DWORD   lastError = 0;

   352 	BOOL    res;

   353 	COMSTAT s;

   354 	

   355 	if(bUseSocket)

   356 	{

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

   358 	}

   359 	else

   360 	do

   361 	{

   362 		ClearCommError(hFile, &err, &s);

   363 		res = SetCommState(hFile, lpDCB);

   364 		if (!res)

   365 			lastError = GetLastError();

   366 	}

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

   368 

   369 	return(res);

   370 	}

   371 

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

   373 {

   374 	DWORD   err;

   375 	DWORD   lastError = 0;

   376 	BOOL    res;

   377 	COMSTAT s;

   378 	

   379 	if(bUseSocket)

   380 	{

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

   382 	}

   383 	else

   384 	do

   385 	{

   386 		ClearCommError(hFile, &err, &s);

   387 		res = SetCommMask(hFile, dwEvtMask);

   388 		if (!res)

   389 			lastError = GetLastError();

   390 	}

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

   392 

   393 	return(res);

   394 }

   395 

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

   397 	{

   398 	DWORD err;

   399 	DWORD lastError = 0;

   400 	BOOL res;

   401 	COMSTAT s;

   402 	

   403 	if(bUseSocket)

   404 	{//-- tunnel data to the socket

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

   406 	}

   407 	else

   408 	do

   409 	{//-- normal operation with serial port

   410 		ClearCommError(hFile, &err, &s);

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

   412 		if (!res)

   413 			lastError = GetLastError();

   414 	}

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

   416 

   417 	return(res);

   418 	}

   419 

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

   421 	{

   422 	DWORD err;

   423 	DWORD lastError = 0;

   424 	BOOL res;

   425 	COMSTAT s;

   426 

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

   428 

   429 	if(bUseSocket)

   430 	{//-- tunnel data to the socket

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

   432 	}

   433 	

   434 	else

   435 	do

   436 	{//-- normal operation with serial port

   437 		ClearCommError(hFile, &err, &s);

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

   439 		if (!res)

   440 			lastError = GetLastError();

   441 	}

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

   443 

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

   445 

   446 	return(res);

   447 	}

   448 

   449 

   450 

   451 

   452 DDriverComm::DDriverComm()

   453 	{

   454 #if defined (__COM_ONE_ONLY__)

   455 	iUnitsMask=0x1; // Support units 0

   456 #elif defined (__COM_TWO_ONLY__)

   457 	iUnitsMask=0x2; // Support units 1

   458 #else

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

   460 #endif

   461 

   462 	iVersion=TVersion(KCommsMajorVersionNumber,KCommsMinorVersionNumber,KCommsBuildVersionNumber);

   463 	}

   464 

   465 TInt DDriverComm::Install()

   466 	{

   467 #if defined (__COM_ONE_ONLY__)

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

   469 	return(SetName(&buf));

   470 #elif defined (__COM_TWO_ONLY__)

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

   472 	return(SetName(&buf));

   473 #else

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

   475 	return(SetName(&buf));

   476 #endif

   477 	}

   478 

   479 TInt DDriverComm::Remove()

   480 	{

   481 	return(KErrNone);

   482 	}

   483 

   484 

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

   486 //

   487 //	Validate the requested configuration

   488 //

   489 	{

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

   491 		return KErrNotSupported;

   492 #if defined (__COM_ONE_ONLY__)

   493 	if (aUnit!=0)

   494 		return KErrNotSupported;

   495 #elif defined (__COM_TWO_ONLY__)

   496 	if (aUnit!=1)

   497 		return KErrNotSupported;

   498 #endif

   499 	// leave Unit check to CreateFile

   500 	return KErrNone;

   501 	}

   502 

   503 

   504 void GetWinsCommsCaps(TDes8 &aCaps)

   505 	{

   506 

   507 	TCommCaps2 capsBuf;

   508 	TCommCapsV02 &c=capsBuf();

   509 //

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

   511 //

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

   513 

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

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

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

   517 	c.iHandshake = 0x3BF;	//all except KConfigObeyDCD

   518 	c.iSignals=0x3f; // All signals

   519 	c.iSIR=0;//No Ir

   520 	c.iNotificationCaps=KNotifySignalsChangeSupported|KNotifyDataAvailableSupported;

   521 	c.iRoleCaps=0;

   522 	c.iFlowControlCaps=0;

   523 	aCaps.FillZ(aCaps.MaxLength());

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

   525 	}

   526 

   527 void DDriverComm::GetCaps(TDes8 &aDes) const

   528 	{

   529 

   530 	GetWinsCommsCaps(aDes);

   531 	}

   532 TInt DDriverComm::Create(DBase*& aChannel, TInt aUnit,const TDesC8* aInfo,const TVersion& aVer)

   533 	{

   534 

   535 	if (!Kern::QueryVersionSupported(iVersion,aVer))

   536 		return KErrNotSupported;

   537 

   538 	DCommWins *pD= new DCommWins;

   539 	if (!pD) return KErrNoMemory;

   540 

   541 	TInt ret=pD->DoCreate(aUnit,aInfo);

   542 

   543 	if (ret!=KErrNone)

   544 	{

   545 		delete pD;

   546 		return ret;

   547 	}

   548 	

   549 	aChannel = pD;			    

   550 

   551 	return KErrNone;

   552 	}

   553 

   554 /**

   555     Associate event with our socket

   556 */

   557 TInt DCommWins::QueSocketRead()

   558 {

   559 	_Log("# DCommWins::QueSocketRead()\n");

   560 	if(WSAEventSelect(iSocket, iReadOverLapped.hEvent, FD_READ | FD_CLOSE))

   561 		{// Some error?!?

   562 		DWORD res = WSAGetLastError();

   563 		return res;

   564 		}

   565 		

   566 	return KErrNone;

   567 

   568 }

   569 

   570 void DCommWins::DoWriteComplete(TInt aErr)

   571 	{

   572 	iWritePending = 0;

   573 	StartOfInterrupt();

   574 	iLdd->iTxError = aErr;

   575 	iLdd->iTxCompleteDfc.Add();

   576 	EndOfInterrupt();

   577 	}

   578 

   579 

   580 

   581 void DCommWins::DoSignalCompletion(TInt aError, TUint aChanged, TUint aValues)

   582 	{

   583 

   584 	//aValues contains the signal values.  EPOC constants

   585 	//aChanged contains the signals which have changed

   586 	//we return the signal values

   587 	TUint res = aValues & iSignalsWanted;

   588 	res |= (aChanged << 12);

   589 	

   590 	iLdd->iSignalResult = res;

   591 	iLdd->iSignalError = aError;

   592 	StartOfInterrupt();

   593 	iLdd->iSigNotifyDfc.Add();

   594 	EndOfInterrupt();

   595 	}

   596 

   597 void DCommWins::DoDataAvailableCompletion()

   598 	{

   599 	StartOfInterrupt();

   600 	iLdd->iRxDataAvailableDfc.Add();

   601 	EndOfInterrupt();

   602 	}

   603 

   604 

   605 

   606 void DCommWins::CompleteRead(TInt aLength)

   607 	{

   608 	

   609 	_Log2("# DCommWins::CompleteRead(), len=%d\n", aLength);

   610 	

   611 	iReadPending = 0;

   612 	iInDes.SetLength(aLength);

   613 	StartOfInterrupt();

   614 	iLdd->iRxCompleteDfc.Add();

   615 	EndOfInterrupt();

   616 	}

   617 

   618 

   619 

   620 void DCommWins::DoReadComplete(TInt aErr, TInt aBytes)

   621 	{

   622 	_Log3("# DCommWins::DoReadComplete(), err=%d, bytes=%d\n", aErr, aBytes);

   623 	

   624 	iLdd->iRxError = aErr;

   625 	//write back the length and the data

   626 	//process for any terminating characters.

   627 	//win32 only does binary reads and ignores the eofchar, so terminated reads

   628 	//require reading one char at a time

   629 	if (iTerminatedRead && !aErr)

   630 		{

   631 		__NK_ASSERT_ALWAYS(aBytes <= 1);

   632 		if (aBytes == 0)

   633 			{

   634 			// not sure why we get this somtimes, but handle it anyway : read another character

   635 			ReadFileP(iCommPort,(void*)(iInBufPtr+iReadSoFar), 1, &dummyLen, &iReadOverLapped, UseSocket());

   636 			}

   637 		else if (++iReadSoFar == iClientReadLength)	//see if we have read enough characters into the buffer

   638 			{

   639 			//got them all so complete it

   640 			CompleteRead(iReadSoFar);

   641 			}

   642 		else if (IsATerminator(iInBufPtr[iReadSoFar-1]))	//see if the char just read was the terminator

   643 			{

   644 			//it's a terminated read and we've found one of the terminbators

   645 			CompleteRead(iReadSoFar);

   646 			}

   647 		else if (iReadPending == EReceive)

   648 			{

   649 			//read another character

   650 			ReadFileP(iCommPort,(void*)(iInBufPtr+iReadSoFar), 1, &dummyLen, &iReadOverLapped, UseSocket());

   651 			}

   652 		else

   653 			{

   654 			//it's a receive 1 or more with terminators, we've got 1 so that'll do

   655 			CompleteRead(iReadSoFar);

   656 			}

   657 		}

   658 	else

   659 		{

   660 		CompleteRead(aBytes);

   661 		}

   662 	}

   663 

   664 

   665 

   666 

   667 void DCommWins::RunCommThread(TDriverCommand aCommand)

   668 //

   669 // Wake up the comms thread

   670 //

   671 	{

   672 	 _Log2("# DCommWins::RunCommThread, command=%d\n", aCommand);

   673 	 

   674 	__ASSERT_DEBUG(aCommand!=EInvalidCommand,Panic(EUnknownCommand));

   675 	iCommand=aCommand;

   676 //

   677 // Are we about to go re-entrant?

   678 //

   679 	if(GetCurrentThreadId()==iThreadID)

   680 		{

   681 		_Log("# DCommWins::RunCommThread() DriverCommand #1\n");

   682 		DriverCommand(aCommand);

   683 

   684 		_Log("#~ DCommWins::RunCommThread() WaitForSingleObject #1\n");

   685 		WaitForSingleObject(iDriverThreadSem,INFINITE);

   686 		}

   687 	else

   688 		{

   689 		Sleep(0); // Possible deadlock solution - see MSDN Knowledge Base Article Q173260

   690 										   

   691 		_Log("# DCommWins::RunCommThread() Release iCommThreadSem\n");

   692 		if (ReleaseSemaphore(iCommThreadSem,1,NULL)==FALSE)

   693 			{

   694 			DWORD ret=GetLastError();

   695 			ret=ret;

   696 			Panic(EWindowsUnexpectedError);

   697 			}

   698 				  

   699         _Log("#~ DCommWins::RunCommThread() WaitForSingleObject #2\n");

   700 		WaitForSingleObject(iDriverThreadSem,INFINITE);

   701 		_Log("# DCommWins::RunCommThread() checkpoint #2\n");

   702 		}

   703 	}

   704 

   705 inline void DCommWins::SignalDriverThread()

   706 //

   707 // Wake up the comms thread

   708 //

   709 	{

   710 	_Log("# DCommWins::SignalDriverThread(), release iDriverThreadSem\n");

   711 	

   712 	Sleep(0); // Possible deadlock solution - see MSDN Knowledge Base Article Q173260

   713 	if (ReleaseSemaphore(iDriverThreadSem,1,NULL)==FALSE)

   714 		{

   715 		DWORD ret=GetLastError();

   716 		ret=ret;

   717 		Panic(EWindowsUnexpectedError);

   718 		}

   719 	}

   720 

   721 

   722 

   723 //

   724 #pragma warning( disable : 4705 )	// statement has no effect

   725 DCommWins::DCommWins() :  iOutDes(0,0), iInDes(0,0), iRxBufferSize(KDefaultWinNTReadBufSize), iSignalsRequested(0)

   726 	{

   727 	__DECLARE_NAME(_S("DCommWins"));

   728 	

   729     _Log("# ------------------------------------------------\n");

   730 	_Log("# DCommWins::DCommWins()\n");

   731 		

   732 	iSocket = INVALID_SOCKET;

   733 	}

   734 #pragma warning( default : 4705 )

   735 

   736 

   737 //-----------------------------------------------------------------------------------------------

   738 

   739 /**

   740 *   Create the comms driver.

   741 *   @param  aUnit serial porn number to work with (starts with 0)

   742 */

   743 

   744 

   745 //-----------------------------------------------------------------------------------------------

   746 TInt DCommWins::DoCreate(TInt aUnit,const TDesC8 * /*aInfo*/)

   747 	{

   748 

   749     _Log("# DCommWins::DoCreate()\n");

   750 

   751 #if defined (__COM_ONE_ONLY__)

   752 	if (aUnit!=0)

   753 		return KErrNotSupported;

   754 #elif defined (__COM_TWO_ONLY__)

   755 	if (aUnit!=1)

   756 		return KErrNotSupported;

   757 #endif

   758     

   759     //-- obtain and parse a string with mapping serial ports to IP addresses

   760 	//-- the string shall look like: WIN_TUNNEL=0,10.35.2.53,110;4,10.35.2.59,110;5,10.35.2.50,110;6,10.35.2.50,443;7,10.35.2.53,443

   761 	TInt    foundPort   = 0;

   762 	TInt    supposedPort= -1;

   763 	char*   hostname    = iOptions;

   764 	TInt16  portNumber  = 0;

   765 

   766 	const char * property = Property::GetString("WIN_TUNNEL");    

   767 	

   768 	if(property)

   769 	{

   770 		if((strlen(property) < 5) || (strlen(property) > 150))

   771 		    FAULT(); //-- illegal parameter string length

   772 			

   773 		strcpy(iOptions, property);

   774 	    char* pchBeg = iOptions;

   775 	    

   776 	    while(!foundPort && pchBeg)

   777 		{

   778 			char* pchEnd;

   779 		

   780 			supposedPort = strtol(pchBeg, &pchEnd, 10);

   781 		

   782 			if(aUnit == supposedPort)

   783 			{//-- found a com port number, extract IP address and port for the socket

   784 				if(*pchEnd++ != ',')

   785 					FAULT();

   786 		    

   787 				hostname = pchBeg = pchEnd;

   788 				pchEnd = strchr(pchBeg, ',');

   789 				pchBeg = pchEnd + 1;

   790 				*pchEnd = '\0';

   791 		    

   792 				portNumber = (TInt16)strtol(pchBeg, &pchEnd, 10);

   793 		    

   794 				foundPort = 1;

   795 			}

   796 			else

   797 			{

   798 				pchBeg = strchr(pchBeg, ';');

   799 				

   800 				if(pchBeg)

   801 					pchBeg ++;

   802 			}

   803 		}

   804 	}//if(property)

   805     

   806 

   807     //-----------------------------------------

   808 

   809 	//create the buffers.

   810 	//the buffers need to be as big as the client will ever use.  8mb reserved, but commit less

   811 	iInBufPtr = (TUint8*)VirtualAlloc(NULL, KSerialBufferMaxSize,MEM_RESERVE | MEM_TOP_DOWN, PAGE_READWRITE);

   812 	if (!iInBufPtr)

   813 		return(Emulator::LastError());

   814 

   815 	//commit the first bit of the buffer

   816 	if (!VirtualAlloc(iInBufPtr, KSerialBufferInitialSize, MEM_COMMIT,PAGE_READWRITE))

   817 		return(Emulator::LastError());

   818 

   819 	iInBufLength = KSerialBufferInitialSize;

   820 	iInDes.Set(iInBufPtr, 0, iInBufLength);

   821 

   822 	//reserve address space for the output buffer

   823 	iOutBufPtr = (TUint8*)VirtualAlloc(NULL, KSerialBufferMaxSize,MEM_RESERVE | MEM_TOP_DOWN, PAGE_READWRITE);

   824 	if (!iOutBufPtr)

   825 		return(Emulator::LastError());

   826 

   827 	//commit a smaller region of it

   828 	if (!VirtualAlloc(iOutBufPtr, KSerialBufferInitialSize, MEM_COMMIT,PAGE_READWRITE))

   829 		return(Emulator::LastError());

   830 

   831 	iOutBufLength = KSerialBufferInitialSize;

   832 	iOutDes.Set(iOutBufPtr, 0, iOutBufLength);

   833 

   834 	//-----------------------------------------

   835 

   836 

   837 	if(aUnit == supposedPort)

   838 	{//-- a serial port number is found in the parameter string.

   839 	 //-- create and connect socket.

   840 	    

   841 	    WORD    wVersionRequested;

   842 		WSADATA wsaData;

   843 		int     err; 

   844 		wVersionRequested = MAKEWORD(2, 0);

   845 		

   846 		err = WSAStartup(wVersionRequested, &wsaData);

   847 		if (err != 0)

   848 		    return(Emulator::LastError());

   849 

   850 

   851 		//-- create a socket

   852 		iSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, 0, WSA_FLAG_OVERLAPPED);

   853 

   854 		_Log3("# DCommWins: created socket id: %d, port emulation: %d\n", iSocket, supposedPort);

   855 		

   856 		if(iSocket == INVALID_SOCKET)

   857 			{

   858 			err = WSAGetLastError();

   859 			return(Emulator::LastError());

   860 			}

   861 

   862 		sockaddr_in sin;

   863 		u_long      nRemoteAddr = inet_addr(hostname);

   864 

   865 		if (nRemoteAddr != INADDR_NONE)

   866 		{

   867 			sin.sin_addr.s_addr = nRemoteAddr;

   868 		}

   869 		else

   870 		{

   871 			struct hostent FAR * hostaddr = gethostbyname (hostname);

   872 			if(hostaddr == NULL)

   873 			{

   874 				err = WSAGetLastError();

   875 				return(Emulator::LastError());

   876 			}

   877 			sin.sin_addr.s_addr = *((u_long*)hostaddr->h_addr_list[0]);

   878 		}

   879 

   880 		sin.sin_family  = AF_INET;

   881 		sin.sin_port    = htons(portNumber);

   882 

   883         //-- connect to the server

   884 		err = WSAConnect(iSocket, (sockaddr*)&sin, sizeof(sin), 0, 0, 0, 0);

   885 		if(err)

   886 		{

   887 			err = WSAGetLastError();

   888 			return(Emulator::LastError());

   889 		}

   890 

   891         _Log("# DCommWins: socket connected. \n");

   892 

   893 		iCommPort = (void*)iSocket;

   894 		

   895     }

   896 

   897     //-----------------------------------------    

   898     

   899     if( !UseSocket() )

   900     {

   901         _Log2("# DCommWins: Using serial port# %d \n",aUnit);

   902         

   903         //-- Open a true serial port

   904         TBuf8<0x10> n;

   905     	n.Append(KComName);

   906     	n.AppendNum(aUnit+1);

   907     	n.Append('\0');

   908 

   909     	iCommPort=CreateFileA((LPCSTR)n.Ptr(),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);

   910     	if (iCommPort==INVALID_HANDLE_VALUE)	

   911     		{	

   912     	//	Reused code from Emulator::LastError() rather than adding an extra case 

   913     	//	to Emulator::LastError() because mapping KErrNotSupported to the returned

   914     	//	FILE_NOT_FOUND is non-intuitive and special to this case only

   915     		DWORD winErr=GetLastError();

   916     		switch (winErr)

   917     			{

   918     			case ERROR_INVALID_USER_BUFFER:

   919     			case ERROR_NOT_ENOUGH_MEMORY:

   920     			case ERROR_INSUFFICIENT_BUFFER:

   921     				return(KErrNoMemory);

   922     			case ERROR_ACCESS_DENIED:

   923     				return(KErrAccessDenied);

   924     			case ERROR_FILE_NOT_FOUND:		//	Reflects value returned by

   925     				return(KErrNotSupported);	//	corresponding MARM Pdd  

   926     			case ERROR_NOT_SUPPORTED:

   927     				return(KErrNotSupported);

   928     			default:

   929     				return(KErrGeneral);

   930     			}

   931     		}

   932 

   933     	

   934     	DCB dcb;

   935     	//set the dcb size

   936     	dcb.DCBlength = sizeof(dcb);

   937     	if (!GetCommStateP(iCommPort,&dcb, UseSocket()))

   938     		return(Emulator::LastError());

   939 

   940     	EscapeCommFunctionP(iCommPort,0, UseSocket());

   941 

   942     	if (!SetCommMaskP(iCommPort,EV_CTS|EV_ERR|EV_DSR|EV_RLSD|EV_RXCHAR|EV_RING, UseSocket()))

   943     		return(Emulator::LastError());

   944 

   945     	if(!SetupComm(iCommPort,KDefaultWinNTReadBufSize,KDefaultWinNTWriteBufSize))

   946     		return(Emulator::LastError());

   947 

   948     }//if( !UseSocket() )

   949 	

   950     _Log("# DCommWins: creating semaphores. \n");

   951     

   952     //--- create thread semaphores 

   953 	if ((iCommThreadSem=CreateSemaphoreA(NULL,0,0x7fffffff,NULL))==NULL)

   954 		return(Emulator::LastError());

   955 

   956 	if ((iDriverThreadSem=CreateSemaphoreA(NULL,0,0x7fffffff,NULL))==NULL)

   957 		return(Emulator::LastError());

   958 

   959     //-----------------------------------------    

   960 

   961     if( !UseSocket() )

   962     {// The serial port seems to open with the error condition set

   963     	DWORD err,res;

   964     	COMSTAT s;

   965     	if (ClearCommError(iCommPort,&err,&s)==FALSE)

   966     		res=GetLastError();

   967     }

   968 

   969     _Log("# DCommWins: creating comm thread. \n");

   970 

   971     iReadCancel = EFalse;

   972 

   973 	if ((iThread=CreateWin32Thread(EThreadEvent,(LPTHREAD_START_ROUTINE)commThread,(void *)this, FALSE))==NULL)

   974 		return(Emulator::LastError());

   975 

   976 	SetThreadPriority(iThread,THREAD_PRIORITY_HIGHEST);

   977 	

   978 	_Log("# DCommWins::DoCreate() exit\n");

   979 	return(KErrNone);

   980 	}

   981 

   982 

   983 	

   984 void DCommWins::ReleaseBuffers()

   985 	{

   986 	if (iInBufPtr)

   987 		{

   988 		//decommit the buffer

   989 		VirtualFree(iInBufPtr,KSerialBufferMaxSize, MEM_DECOMMIT);

   990 		//and release the region

   991 		VirtualFree(iInBufPtr, NULL, MEM_RELEASE);

   992 		iInBufPtr = NULL;

   993 		}

   994 	if (iOutBufPtr)

   995 		{

   996 		VirtualFree(iOutBufPtr,KSerialBufferMaxSize, MEM_DECOMMIT);

   997 		VirtualFree(iOutBufPtr, NULL, MEM_RELEASE);

   998 		iOutBufPtr = NULL;

   999 		}

  1000 	}

  1001 	

  1002 

  1003 DCommWins::~DCommWins()

  1004 	{

  1005 	_Log("# DCommWins::~DCommWins()\n");

  1006 	if (iThread)

  1007 		{

  1008 		if (! iRunning)

  1009 			{

  1010 			__ASSERT_ALWAYS(

  1011 				ResumeThread(iThread) != 0xffffffff,

  1012 				Panic(EWindowsUnexpectedError)); 

  1013 			}

  1014 

  1015 		iRunning=ETrue;

  1016 		RunCommThread(EDie);

  1017 		}

  1018 

  1019 	if(UseSocket())

  1020 	{

  1021 	    closesocket(iSocket);

  1022 	    WSACleanup();

  1023 		iCommPort = (HANDLE) NULL;

  1024 		iSocket   = NULL;

  1025 	}

  1026 	

  1027 	if (iCommPort)

  1028 	{

  1029 		CloseHandle(iCommPort);

  1030 	}

  1031 

  1032 	if (iDriverThreadSem)

  1033 		CloseHandle(iDriverThreadSem);

  1034 

  1035 	if (iCommThreadSem)

  1036 		CloseHandle(iCommThreadSem);

  1037 

  1038 	if (iReadOverLapped.hEvent)

  1039 		CloseHandle(iReadOverLapped.hEvent);

  1040 

  1041 	if (iWriteOverLapped.hEvent)

  1042 		CloseHandle(iWriteOverLapped.hEvent);

  1043 

  1044 	if (iSignalOverLapped.hEvent)

  1045 		CloseHandle(iSignalOverLapped.hEvent);

  1046 

  1047 	if (iThread)

  1048 		CloseHandle(iThread);

  1049 

  1050 	//free up the memory

  1051 	ReleaseBuffers();

  1052 

  1053 	_Log("# DCommWins::~DCommWins() exit\n");

  1054 	

  1055 	}

  1056 

  1057 TInt DCommWins::Start()

  1058 	{

  1059 

  1060 	__ASSERT_ALWAYS(ResumeThread(iThread)!=0xffffffff,Panic(EWindowsUnexpectedError));

  1061 	iRunning=ETrue;

  1062 	RunCommThread(EStart);

  1063 	return(KErrNone);

  1064 	}

  1065 

  1066 void DCommWins::Stop(TStopMode aMode)

  1067 	{

  1068 

  1069 	RunCommThread((aMode==EStopEmergency) ? EStopNoDrain : EStop);

  1070 	SuspendThread(iThread);

  1071 	iRunning=EFalse;

  1072 	}

  1073 

  1074 void DCommWins::Break(TBool aState)

  1075 //

  1076 // Assert a break signal

  1077 //

  1078 	{

  1079 

  1080 	if (aState)

  1081 		RunCommThread(ESetBreak);

  1082 	else

  1083 		RunCommThread(EClearBreak);

  1084 	}

  1085 

  1086 

  1087 

  1088 TInt DCommWins::RxCount()

  1089 	{

  1090 	DWORD err =0;

  1091 	COMSTAT stat;

  1092 	if (ClearCommError(iCommPort,&err, &stat))

  1093 		return stat.cbInQue;

  1094 	else

  1095 		return Emulator::LastError();

  1096 	}

  1097 

  1098 

  1099 void DCommWins::ResetBuffers(TBool aTx)

  1100 	{

  1101 	PurgeComm(iCommPort, PURGE_RXCLEAR | (aTx ? PURGE_TXCLEAR : 0));

  1102 	}

  1103 

  1104 

  1105 TBool DCommWins::AreAnyPending()

  1106 	{

  1107 	return (iReadPending != 0) || (iWritePending != 0);

  1108 	}

  1109 

  1110 

  1111 void DCommWins::WriteCancel()

  1112 	{

  1113 	DriverCommand(ETransmitCancel);

  1114 	}

  1115 

  1116 

  1117 void DCommWins::ReadCancel()

  1118 	{

  1119 	DriverCommand(EReceiveCancel);

  1120 	}

  1121 

  1122 void DCommWins::SignalChangeCancel()

  1123 	{

  1124 	if (iSignalsRequested)

  1125 		{

  1126 		iSignalsRequested = 0;

  1127 		}

  1128 

  1129 	}

  1130 

  1131 void DCommWins::DataAvailableNotificationCancel()

  1132 	{

  1133 	if (iDataAvailableNotification)

  1134 		{