ReactOS  0.4.14-dev-317-g96040ec
comm.c File Reference
#include <k32.h>
#include <ntddser.h>
#include <debug.h>
Include dependency graph for comm.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Typedefs

typedef LARGE_INTEGER PHYSICAL_ADDRESS
 
typedef LARGE_INTEGERPPHYSICAL_ADDRESS
 

Functions

 DEBUG_CHANNEL (comm)
 
static LPCWSTR COMM_ParseStart (LPCWSTR ptr)
 
static LPCWSTR COMM_ParseNumber (LPCWSTR ptr, LPDWORD lpnumber)
 
static LPCWSTR COMM_ParseParity (LPCWSTR ptr, LPBYTE lpparity)
 
static LPCWSTR COMM_ParseByteSize (LPCWSTR ptr, LPBYTE lpbytesize)
 
static LPCWSTR COMM_ParseStopBits (LPCWSTR ptr, LPBYTE lpstopbits)
 
static LPCWSTR COMM_ParseOnOff (LPCWSTR ptr, LPDWORD lponoff)
 
static BOOL COMM_BuildOldCommDCB (LPCWSTR device, LPDCB lpdcb)
 
static BOOL COMM_BuildNewCommDCB (LPCWSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
 
BOOL WINAPI BuildCommDCBA (LPCSTR device, LPDCB lpdcb)
 
BOOL WINAPI BuildCommDCBAndTimeoutsA (LPCSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
 
BOOL WINAPI BuildCommDCBAndTimeoutsW (LPCWSTR devid, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
 
BOOL WINAPI BuildCommDCBW (LPCWSTR devid, LPDCB lpdcb)
 
BOOL WINAPI SetCommBreak (HANDLE handle)
 
BOOL WINAPI ClearCommBreak (HANDLE handle)
 
BOOL WINAPI EscapeCommFunction (HANDLE handle, DWORD func)
 
BOOL WINAPI PurgeComm (HANDLE handle, DWORD flags)
 
BOOL WINAPI ClearCommError (HANDLE handle, LPDWORD errors, LPCOMSTAT lpStat)
 
BOOL WINAPI SetupComm (HANDLE handle, DWORD insize, DWORD outsize)
 
BOOL WINAPI GetCommMask (HANDLE handle, LPDWORD evtmask)
 
BOOL WINAPI SetCommMask (HANDLE handle, DWORD evtmask)
 
static void dump_dcb (const DCB *lpdcb)
 
BOOL WINAPI SetCommState (HANDLE handle, LPDCB lpdcb)
 
BOOL WINAPI GetCommState (HANDLE handle, LPDCB lpdcb)
 
BOOL WINAPI TransmitCommChar (HANDLE hComm, CHAR chTransmit)
 
BOOL WINAPI GetCommTimeouts (HANDLE hComm, LPCOMMTIMEOUTS lptimeouts)
 
BOOL WINAPI SetCommTimeouts (HANDLE hComm, LPCOMMTIMEOUTS lptimeouts)
 
BOOL WINAPI GetCommModemStatus (HANDLE hFile, LPDWORD lpModemStat)
 
BOOL WINAPI WaitCommEvent (HANDLE hFile, LPDWORD lpdwEvents, LPOVERLAPPED lpOverlapped)
 
BOOL WINAPI GetCommProperties (HANDLE hFile, LPCOMMPROP lpCommProp)
 
BOOL WINAPI CommConfigDialogA (LPCSTR lpszDevice, HWND hWnd, LPCOMMCONFIG lpCommConfig)
 
BOOL WINAPI CommConfigDialogW (LPCWSTR lpszDevice, HWND hWnd, LPCOMMCONFIG lpCommConfig)
 
BOOL WINAPI GetCommConfig (HANDLE hFile, LPCOMMCONFIG lpCommConfig, LPDWORD lpdwSize)
 
BOOL WINAPI SetCommConfig (HANDLE hFile, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
 
BOOL WINAPI SetDefaultCommConfigW (LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
 
BOOL WINAPI SetDefaultCommConfigA (LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
 
BOOL WINAPI GetDefaultCommConfigW (LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize)
 
BOOL WINAPI GetDefaultCommConfigA (LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize)
 

Variables

static const WCHAR lpszSerialUI []
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 44 of file comm.c.

Typedef Documentation

◆ PHYSICAL_ADDRESS

Definition at line 23 of file comm.c.

◆ PPHYSICAL_ADDRESS

Definition at line 23 of file comm.c.

Function Documentation

◆ BuildCommDCBA()

BOOL WINAPI BuildCommDCBA ( LPCSTR  device,
LPDCB  lpdcb 
)

Definition at line 429 of file comm.c.

432 {
433  return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
434 }
Definition: devices.h:37
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI BuildCommDCBAndTimeoutsA(LPCSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
Definition: comm.c:447

Referenced by test_BuildCommDCBA().

◆ BuildCommDCBAndTimeoutsA()

BOOL WINAPI BuildCommDCBAndTimeoutsA ( LPCSTR  device,
LPDCB  lpdcb,
LPCOMMTIMEOUTS  lptimeouts 
)

Definition at line 447 of file comm.c.

451 {
452  BOOL ret = FALSE;
454 
455  TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
457  else deviceW.Buffer = NULL;
458 
459  if(deviceW.Buffer) ret = BuildCommDCBAndTimeoutsW(deviceW.Buffer,lpdcb,lptimeouts);
460 
462  return ret;
463 }
BOOL WINAPI BuildCommDCBAndTimeoutsW(LPCWSTR devid, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
Definition: comm.c:476
static const WCHAR deviceW[]
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
smooth NULL
Definition: ftsmooth.c:416
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
#define TRACE(s)
Definition: solgame.cpp:4
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
int ret

Referenced by BuildCommDCBA(), and test_BuildCommDCBAndTimeoutsA().

◆ BuildCommDCBAndTimeoutsW()

BOOL WINAPI BuildCommDCBAndTimeoutsW ( LPCWSTR  devid,
LPDCB  lpdcb,
LPCOMMTIMEOUTS  lptimeouts 
)

Definition at line 476 of file comm.c.

480 {
481  DCB dcb;
483  BOOL result;
484  LPCWSTR ptr = devid;
485 
486  TRACE("(%s,%p,%p)\n",debugstr_w(devid),lpdcb,lptimeouts);
487 
488  memset(&timeouts, 0, sizeof timeouts);
489 
490  /* Set DCBlength. (Windows NT does not do this, but 9x does) */
491  lpdcb->DCBlength = sizeof(DCB);
492 
493  /* Make a copy of the original data structures to work with since if
494  if there is an error in the device control string the originals
495  should not be modified (except possibly DCBlength) */
496  dcb = *lpdcb;
497  if(lptimeouts) timeouts = *lptimeouts;
498 
500 
501  if(ptr == NULL)
502  result = FALSE;
503  else if(strchrW(ptr, ','))
505  else
507 
508  if(result)
509  {
510  *lpdcb = dcb;
511  if(lptimeouts) *lptimeouts = timeouts;
512  return TRUE;
513  }
514  else
515  {
516  WARN("Invalid device control string: %s\n", debugstr_w(devid));
518  return FALSE;
519  }
520 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define TRUE
Definition: types.h:120
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
Definition: cdstruc.h:908
WINE_UNICODE_INLINE WCHAR * strchrW(const WCHAR *str, WCHAR ch)
Definition: unicode.h:248
#define WARN(fmt,...)
Definition: debug.h:111
FCB DCB
Definition: fatstruc.h:1183
unsigned int BOOL
Definition: ntddk_ex.h:94
#define debugstr_w
Definition: kernel32.h:32
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
static LPCWSTR COMM_ParseStart(LPCWSTR ptr)
Definition: comm.c:54
static BOOL COMM_BuildNewCommDCB(LPCWSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
Definition: comm.c:297
#define TRACE(s)
Definition: solgame.cpp:4
#define SetLastError(x)
Definition: compat.h:409
DWORD DCBlength
Definition: winbase.h:624
static BOOL COMM_BuildOldCommDCB(LPCWSTR device, LPDCB lpdcb)
Definition: comm.c:197
struct timeout * timeouts
Definition: dispatch.c:53
GLuint64EXT * result
Definition: glext.h:11304
#define memset(x, y, z)
Definition: compat.h:39

Referenced by BuildCommDCBAndTimeoutsA(), BuildCommDCBW(), and test_BuildCommDCBAndTimeoutsW().

◆ BuildCommDCBW()

BOOL WINAPI BuildCommDCBW ( LPCWSTR  devid,
LPDCB  lpdcb 
)

Definition at line 533 of file comm.c.

536 {
537  return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
538 }
BOOL WINAPI BuildCommDCBAndTimeoutsW(LPCWSTR devid, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
Definition: comm.c:476
smooth NULL
Definition: ftsmooth.c:416

Referenced by test_BuildCommDCBW().

◆ ClearCommBreak()

BOOL WINAPI ClearCommBreak ( HANDLE  handle)

Definition at line 580 of file comm.c.

581 {
582  DWORD dwBytesReturned;
583  return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_OFF, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
584 }
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
#define IOCTL_SERIAL_SET_BREAK_OFF
Definition: ntddser.h:86

Referenced by test_WaitBreak().

◆ ClearCommError()

BOOL WINAPI ClearCommError ( HANDLE  handle,
LPDWORD  errors,
LPCOMSTAT  lpStat 
)

Definition at line 663 of file comm.c.

664 {
666  DWORD dwBytesReturned;
667 
669  &ss, sizeof(ss), &dwBytesReturned, NULL))
670  return FALSE;
671 
672  if (errors)
673  {
674  *errors = 0;
675  if (ss.Errors & SERIAL_ERROR_BREAK) *errors |= CE_BREAK;
676  if (ss.Errors & SERIAL_ERROR_FRAMING) *errors |= CE_FRAME;
677  if (ss.Errors & SERIAL_ERROR_OVERRUN) *errors |= CE_OVERRUN;
678  if (ss.Errors & SERIAL_ERROR_QUEUEOVERRUN) *errors |= CE_RXOVER;
679  if (ss.Errors & SERIAL_ERROR_PARITY) *errors |= CE_RXPARITY;
680  }
681 
682  if (lpStat)
683  {
684  memset(lpStat, 0, sizeof(*lpStat));
685 
686  if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_CTS) lpStat->fCtsHold = TRUE;
687  if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DSR) lpStat->fDsrHold = TRUE;
688  if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DCD) lpStat->fRlsdHold = TRUE;
689  if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_XON) lpStat->fXoffHold = TRUE;
690  if (ss.HoldReasons & SERIAL_TX_WAITING_XOFF_SENT) lpStat->fXoffSent = TRUE;
691  if (ss.EofReceived) lpStat->fEof = TRUE;
692  if (ss.WaitForImmediate) lpStat->fTxim = TRUE;
693  lpStat->cbInQue = ss.AmountInInQueue;
694  lpStat->cbOutQue = ss.AmountInOutQueue;
695  }
696  return TRUE;
697 }
#define SERIAL_ERROR_PARITY
Definition: ntddser.h:402
#define TRUE
Definition: types.h:120
#define SERIAL_TX_WAITING_FOR_DSR
Definition: ntddser.h:420
DWORD cbOutQue
Definition: winbase.h:704
#define SERIAL_TX_WAITING_FOR_CTS
Definition: ntddser.h:419
#define CE_FRAME
Definition: winbase.h:137
DWORD cbInQue
Definition: winbase.h:703
#define SERIAL_TX_WAITING_FOR_DCD
Definition: ntddser.h:421
DWORD fDsrHold
Definition: winbase.h:696
#define CE_OVERRUN
Definition: winbase.h:141
#define SERIAL_ERROR_OVERRUN
Definition: ntddser.h:400
#define SERIAL_TX_WAITING_FOR_XON
Definition: ntddser.h:422
smooth NULL
Definition: ftsmooth.c:416
DWORD fXoffSent
Definition: winbase.h:699
#define SERIAL_ERROR_BREAK
Definition: ntddser.h:398
DWORD fRlsdHold
Definition: winbase.h:697
DWORD fEof
Definition: winbase.h:700
#define CE_BREAK
Definition: winbase.h:135
#define SERIAL_ERROR_QUEUEOVERRUN
Definition: ntddser.h:401
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD fCtsHold
Definition: winbase.h:695
#define CE_RXPARITY
Definition: winbase.h:144
#define SERIAL_ERROR_FRAMING
Definition: ntddser.h:399
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
DWORD fTxim
Definition: winbase.h:701
#define IOCTL_SERIAL_GET_COMMSTATUS
Definition: ntddser.h:54
DWORD fXoffHold
Definition: winbase.h:698
#define CE_RXOVER
Definition: winbase.h:143
#define ss
Definition: i386-dis.c:432
#define SERIAL_TX_WAITING_XOFF_SENT
Definition: ntddser.h:423
#define memset(x, y, z)
Definition: compat.h:39

Referenced by main(), test_ClearCommError(), test_FlushFileBuffers(), test_non_pending_errors(), test_OpenComm(), and test_waittxempty().

◆ COMM_BuildNewCommDCB()

static BOOL COMM_BuildNewCommDCB ( LPCWSTR  device,
LPDCB  lpdcb,
LPCOMMTIMEOUTS  lptimeouts 
)
static

Definition at line 297 of file comm.c.

298 {
299  DWORD temp;
300  BOOL baud = FALSE, stop = FALSE;
301  static const WCHAR baudW[] = {'b','a','u','d','=',0};
302  static const WCHAR parityW[] = {'p','a','r','i','t','y','=',0};
303  static const WCHAR dataW[] = {'d','a','t','a','=',0};
304  static const WCHAR stopW[] = {'s','t','o','p','=',0};
305  static const WCHAR toW[] = {'t','o','=',0};
306  static const WCHAR xonW[] = {'x','o','n','=',0};
307  static const WCHAR odsrW[] = {'o','d','s','r','=',0};
308  static const WCHAR octsW[] = {'o','c','t','s','=',0};
309  static const WCHAR dtrW[] = {'d','t','r','=',0};
310  static const WCHAR rtsW[] = {'r','t','s','=',0};
311  static const WCHAR idsrW[] = {'i','d','s','r','=',0};
312 
313  while(*device)
314  {
315  while(*device == ' ') device++;
316 
317  if(!strncmpiW(baudW, device, 5))
318  {
319  baud = TRUE;
320 
321  if(!(device = COMM_ParseNumber(device + 5, &lpdcb->BaudRate)))
322  return FALSE;
323  }
324  else if(!strncmpiW(parityW, device, 7))
325  {
326  if(!(device = COMM_ParseParity(device + 7, &lpdcb->Parity)))
327  return FALSE;
328  }
329  else if(!strncmpiW(dataW, device, 5))
330  {
331  if(!(device = COMM_ParseByteSize(device + 5, &lpdcb->ByteSize)))
332  return FALSE;
333  }
334  else if(!strncmpiW(stopW, device, 5))
335  {
336  stop = TRUE;
337 
338  if(!(device = COMM_ParseStopBits(device + 5, &lpdcb->StopBits)))
339  return FALSE;
340  }
341  else if(!strncmpiW(toW, device, 3))
342  {
343  if(!(device = COMM_ParseOnOff(device + 3, &temp)))
344  return FALSE;
345 
346  lptimeouts->ReadIntervalTimeout = 0;
347  lptimeouts->ReadTotalTimeoutMultiplier = 0;
348  lptimeouts->ReadTotalTimeoutConstant = 0;
349  lptimeouts->WriteTotalTimeoutMultiplier = 0;
350  lptimeouts->WriteTotalTimeoutConstant = temp ? 60000 : 0;
351  }
352  else if(!strncmpiW(xonW, device, 4))
353  {
354  if(!(device = COMM_ParseOnOff(device + 4, &temp)))
355  return FALSE;
356 
357  lpdcb->fOutX = temp;
358  lpdcb->fInX = temp;
359  }
360  else if(!strncmpiW(odsrW, device, 5))
361  {
362  if(!(device = COMM_ParseOnOff(device + 5, &temp)))
363  return FALSE;
364 
365  lpdcb->fOutxDsrFlow = temp;
366  }
367  else if(!strncmpiW(octsW, device, 5))
368  {
369  if(!(device = COMM_ParseOnOff(device + 5, &temp)))
370  return FALSE;
371 
372  lpdcb->fOutxCtsFlow = temp;
373  }
374  else if(!strncmpiW(dtrW, device, 4))
375  {
376  if(!(device = COMM_ParseOnOff(device + 4, &temp)))
377  return FALSE;
378 
379  lpdcb->fDtrControl = temp;
380  }
381  else if(!strncmpiW(rtsW, device, 4))
382  {
383  if(!(device = COMM_ParseOnOff(device + 4, &temp)))
384  return FALSE;
385 
386  lpdcb->fRtsControl = temp;
387  }
388  else if(!strncmpiW(idsrW, device, 5))
389  {
390  if(!(device = COMM_ParseOnOff(device + 5, &temp)))
391  return FALSE;
392 
393  /* Win NT sets the fDsrSensitivity member based on the
394  idsr parameter. Win 9x sets fOutxDsrFlow instead. */
395  lpdcb->fDsrSensitivity = temp;
396  }
397  else
398  return FALSE;
399 
400  /* After the above parsing, the next character (if not the end of
401  the string) should be a space */
402  if(*device && *device != ' ')
403  return FALSE;
404  }
405 
406  /* If stop bits were not specified, a default is always supplied. */
407  if(!stop)
408  {
409  if(baud && lpdcb->BaudRate == 110)
410  lpdcb->StopBits = TWOSTOPBITS;
411  else
412  lpdcb->StopBits = ONESTOPBIT;
413  }
414 
415  return TRUE;
416 }
static LPCWSTR COMM_ParseByteSize(LPCWSTR ptr, LPBYTE lpbytesize)
Definition: comm.c:129
static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
Definition: comm.c:91
DWORD fDsrSensitivity
Definition: winbase.h:631
#define TRUE
Definition: types.h:120
DWORD fOutxCtsFlow
Definition: winbase.h:628
#define strncmpiW(s1, s2, n)
Definition: unicode.h:40
DWORD fInX
Definition: winbase.h:634
#define TWOSTOPBITS
Definition: winbase.h:441
#define ONESTOPBIT
Definition: winbase.h:439
DWORD WriteTotalTimeoutMultiplier
Definition: winbase.h:690
static LPCWSTR COMM_ParseParity(LPCWSTR ptr, LPBYTE lpparity)
Definition: comm.c:99
static LPCWSTR COMM_ParseStopBits(LPCWSTR ptr, LPBYTE lpstopbits)
Definition: comm.c:145
DWORD BaudRate
Definition: winbase.h:625
unsigned int BOOL
Definition: ntddk_ex.h:94
Definition: devices.h:37
BYTE ByteSize
Definition: winbase.h:643
__wchar_t WCHAR
Definition: xmlstorage.h:180
static const WCHAR stopW[]
Definition: lex.c:81
DWORD fOutX
Definition: winbase.h:633
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD ReadTotalTimeoutConstant
Definition: winbase.h:689
static LPCWSTR COMM_ParseOnOff(LPCWSTR ptr, LPDWORD lponoff)
Definition: comm.c:171
DWORD ReadIntervalTimeout
Definition: winbase.h:687
DWORD fOutxDsrFlow
Definition: winbase.h:629
BYTE StopBits
Definition: winbase.h:645
static calc_node_t temp
Definition: rpn_ieee.c:38
DWORD fDtrControl
Definition: winbase.h:630
DWORD fRtsControl
Definition: winbase.h:637
BYTE Parity
Definition: winbase.h:644
DWORD ReadTotalTimeoutMultiplier
Definition: winbase.h:688
static const WCHAR toW[]
Definition: lex.c:84
DWORD WriteTotalTimeoutConstant
Definition: winbase.h:691

Referenced by BuildCommDCBAndTimeoutsW().

◆ COMM_BuildOldCommDCB()

static BOOL COMM_BuildOldCommDCB ( LPCWSTR  device,
LPDCB  lpdcb 
)
static

Definition at line 197 of file comm.c.

198 {
199  WCHAR last = 0;
200 
201  if(!(device = COMM_ParseNumber(device, &lpdcb->BaudRate)))
202  return FALSE;
203 
204  switch(lpdcb->BaudRate)
205  {
206  case 11:
207  case 30:
208  case 60:
209  lpdcb->BaudRate *= 10;
210  break;
211  case 12:
212  case 24:
213  case 48:
214  case 96:
215  lpdcb->BaudRate *= 100;
216  break;
217  case 19:
218  lpdcb->BaudRate = 19200;
219  break;
220  }
221 
222  while(*device == ' ') device++;
223  if(*device++ != ',') return FALSE;
224  while(*device == ' ') device++;
225 
226  if(!(device = COMM_ParseParity(device, &lpdcb->Parity)))
227  return FALSE;
228 
229  while(*device == ' ') device++;
230  if(*device++ != ',') return FALSE;
231  while(*device == ' ') device++;
232 
233  if(!(device = COMM_ParseByteSize(device, &lpdcb->ByteSize)))
234  return FALSE;
235 
236  while(*device == ' ') device++;
237  if(*device++ != ',') return FALSE;
238  while(*device == ' ') device++;
239 
240  if(!(device = COMM_ParseStopBits(device, &lpdcb->StopBits)))
241  return FALSE;
242 
243  /* The last parameter for flow control is optional. */
244  while(*device == ' ') device++;
245  if(*device == ',')
246  {
247  device++;
248  while(*device == ' ') device++;
249  if(*device) last = toupperW(*device++);
250  while(*device == ' ') device++;
251  }
252 
253  /* Win NT sets the flow control members based on (or lack of) the last
254  parameter. Win 9x does not set these members. */
255  switch(last)
256  {
257  case 0:
258  lpdcb->fInX = FALSE;
259  lpdcb->fOutX = FALSE;
260  lpdcb->fOutxCtsFlow = FALSE;
261  lpdcb->fOutxDsrFlow = FALSE;
264  break;
265  case 'X':
266  lpdcb->fInX = TRUE;
267  lpdcb->fOutX = TRUE;
268  lpdcb->fOutxCtsFlow = FALSE;
269  lpdcb->fOutxDsrFlow = FALSE;
272  break;
273  case 'P':
274  lpdcb->fInX = FALSE;
275  lpdcb->fOutX = FALSE;
276  lpdcb->fOutxCtsFlow = TRUE;
277  lpdcb->fOutxDsrFlow = TRUE;
280  break;
281  default:
282  return FALSE;
283  }
284 
285  /* This should be the end of the string. */
286  if(*device) return FALSE;
287 
288  return TRUE;
289 }
static LPCWSTR COMM_ParseByteSize(LPCWSTR ptr, LPBYTE lpbytesize)
Definition: comm.c:129
static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
Definition: comm.c:91
#define TRUE
Definition: types.h:120
#define RTS_CONTROL_ENABLE
Definition: winbase.h:518
POINT last
Definition: font.c:46
#define RTS_CONTROL_HANDSHAKE
Definition: winbase.h:519
DWORD fOutxCtsFlow
Definition: winbase.h:628
DWORD fInX
Definition: winbase.h:634
static LPCWSTR COMM_ParseParity(LPCWSTR ptr, LPBYTE lpparity)
Definition: comm.c:99
static LPCWSTR COMM_ParseStopBits(LPCWSTR ptr, LPBYTE lpstopbits)
Definition: comm.c:145
DWORD BaudRate
Definition: winbase.h:625
Definition: devices.h:37
#define DTR_CONTROL_ENABLE
Definition: winbase.h:515
BYTE ByteSize
Definition: winbase.h:643
WINE_UNICODE_INLINE WCHAR toupperW(WCHAR ch)
Definition: unicode.h:141
__wchar_t WCHAR
Definition: xmlstorage.h:180
DWORD fOutX
Definition: winbase.h:633
DWORD fOutxDsrFlow
Definition: winbase.h:629
BYTE StopBits
Definition: winbase.h:645
#define DTR_CONTROL_HANDSHAKE
Definition: winbase.h:516
DWORD fDtrControl
Definition: winbase.h:630
DWORD fRtsControl
Definition: winbase.h:637
BYTE Parity
Definition: winbase.h:644

Referenced by BuildCommDCBAndTimeoutsW().

◆ COMM_ParseByteSize()

static LPCWSTR COMM_ParseByteSize ( LPCWSTR  ptr,
LPBYTE  lpbytesize 
)
static

Definition at line 129 of file comm.c.

130 {
131  DWORD temp;
132 
133  if(!(ptr = COMM_ParseNumber(ptr, &temp)))
134  return NULL;
135 
136  if(temp >= 5 && temp <= 8)
137  {
138  *lpbytesize = temp;
139  return ptr;
140  }
141  else
142  return NULL;
143 }
static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
Definition: comm.c:91
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
static calc_node_t temp
Definition: rpn_ieee.c:38

Referenced by COMM_BuildNewCommDCB(), and COMM_BuildOldCommDCB().

◆ COMM_ParseNumber()

static LPCWSTR COMM_ParseNumber ( LPCWSTR  ptr,
LPDWORD  lpnumber 
)
static

Definition at line 91 of file comm.c.

92 {
93  if(*ptr < '0' || *ptr > '9') return NULL;
94  *lpnumber = strtoulW(ptr, NULL, 10);
95  while(*ptr >= '0' && *ptr <= '9') ptr++;
96  return ptr;
97 }
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
#define strtoulW(s1, s2, b)
Definition: unicode.h:41

Referenced by COMM_BuildNewCommDCB(), COMM_BuildOldCommDCB(), COMM_ParseByteSize(), and COMM_ParseStopBits().

◆ COMM_ParseOnOff()

static LPCWSTR COMM_ParseOnOff ( LPCWSTR  ptr,
LPDWORD  lponoff 
)
static

Definition at line 171 of file comm.c.

172 {
173  static const WCHAR onW[] = {'o','n',0};
174  static const WCHAR offW[] = {'o','f','f',0};
175 
176  if(!strncmpiW(onW, ptr, 2))
177  {
178  ptr += 2;
179  *lponoff = 1;
180  }
181  else if(!strncmpiW(offW, ptr, 3))
182  {
183  ptr += 3;
184  *lponoff = 0;
185  }
186  else
187  return NULL;
188 
189  return ptr;
190 }
#define strncmpiW(s1, s2, n)
Definition: unicode.h:40
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
__wchar_t WCHAR
Definition: xmlstorage.h:180
static const WCHAR onW[]
Definition: lex.c:70

Referenced by COMM_BuildNewCommDCB().

◆ COMM_ParseParity()

static LPCWSTR COMM_ParseParity ( LPCWSTR  ptr,
LPBYTE  lpparity 
)
static

Definition at line 99 of file comm.c.

100 {
101  /* Contrary to what you might expect, Windows only sets the Parity
102  member of DCB and not fParity even when parity is specified in the
103  device control string */
104 
105  switch(toupperW(*ptr++))
106  {
107  case 'E':
108  *lpparity = EVENPARITY;
109  break;
110  case 'M':
111  *lpparity = MARKPARITY;
112  break;
113  case 'N':
114  *lpparity = NOPARITY;
115  break;
116  case 'O':
117  *lpparity = ODDPARITY;
118  break;
119  case 'S':
120  *lpparity = SPACEPARITY;
121  break;
122  default:
123  return NULL;
124  }
125 
126  return ptr;
127 }
#define MARKPARITY
Definition: winbase.h:437
#define EVENPARITY
Definition: winbase.h:436
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
#define NOPARITY
Definition: winbase.h:434
WINE_UNICODE_INLINE WCHAR toupperW(WCHAR ch)
Definition: unicode.h:141
#define ODDPARITY
Definition: winbase.h:435
#define SPACEPARITY
Definition: winbase.h:438

Referenced by COMM_BuildNewCommDCB(), and COMM_BuildOldCommDCB().

◆ COMM_ParseStart()

static LPCWSTR COMM_ParseStart ( LPCWSTR  ptr)
static

Definition at line 54 of file comm.c.

55 {
56  static const WCHAR comW[] = {'C','O','M',0};
57 
58  /* The device control string may optionally start with "COMx" followed
59  by an optional ':' and spaces. */
60  if(!strncmpiW(ptr, comW, 3))
61  {
62  ptr += 3;
63 
64  /* Allow any com port above 0 as Win 9x does (NT only allows
65  values for com ports which are actually present) */
66  if(*ptr < '1' || *ptr > '9')
67  return NULL;
68 
69  /* Advance pointer past port number */
70  while(*ptr >= '0' && *ptr <= '9') ptr++;
71 
72  /* The com port number must be followed by a ':' or ' ' */
73  if(*ptr != ':' && *ptr != ' ')
74  return NULL;
75 
76  /* Advance pointer to beginning of next parameter */
77  while(*ptr == ' ') ptr++;
78  if(*ptr == ':')
79  {
80  ptr++;
81  while(*ptr == ' ') ptr++;
82  }
83  }
84  /* The device control string must not start with a space. */
85  else if(*ptr == ' ')
86  return NULL;
87 
88  return ptr;
89 }
#define strncmpiW(s1, s2, n)
Definition: unicode.h:40
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
__wchar_t WCHAR
Definition: xmlstorage.h:180
static const WCHAR comW[]

Referenced by BuildCommDCBAndTimeoutsW().

◆ COMM_ParseStopBits()

static LPCWSTR COMM_ParseStopBits ( LPCWSTR  ptr,
LPBYTE  lpstopbits 
)
static

Definition at line 145 of file comm.c.

146 {
147  DWORD temp;
148  static const WCHAR stopbits15W[] = {'1','.','5',0};
149 
150  if(!strncmpW(stopbits15W, ptr, 3))
151  {
152  ptr += 3;
153  *lpstopbits = ONE5STOPBITS;
154  }
155  else
156  {
157  if(!(ptr = COMM_ParseNumber(ptr, &temp)))
158  return NULL;
159 
160  if(temp == 1)
161  *lpstopbits = ONESTOPBIT;
162  else if(temp == 2)
163  *lpstopbits = TWOSTOPBITS;
164  else
165  return NULL;
166  }
167 
168  return ptr;
169 }
static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
Definition: comm.c:91
#define TWOSTOPBITS
Definition: winbase.h:441
#define ONESTOPBIT
Definition: winbase.h:439
WINE_UNICODE_INLINE int strncmpW(const WCHAR *str1, const WCHAR *str2, int n)
Definition: unicode.h:235
#define ONE5STOPBITS
Definition: winbase.h:440
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
static calc_node_t temp
Definition: rpn_ieee.c:38

Referenced by COMM_BuildNewCommDCB(), and COMM_BuildOldCommDCB().

◆ CommConfigDialogA()

BOOL WINAPI CommConfigDialogA ( LPCSTR  lpszDevice,
HWND  hWnd,
LPCOMMCONFIG  lpCommConfig 
)

Definition at line 1212 of file comm.c.

1216 {
1217  LPWSTR lpDeviceW = NULL;
1218  DWORD len;
1219  BOOL r;
1220 
1221  TRACE("(%s, %p, %p)\n", debugstr_a(lpszDevice), hWnd, lpCommConfig);
1222 
1223  if (lpszDevice)
1224  {
1225  len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
1226  lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1227  MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
1228  }
1229  r = CommConfigDialogW(lpDeviceW, hWnd, lpCommConfig);
1230  HeapFree( GetProcessHeap(), 0, lpDeviceW );
1231  return r;
1232 }
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define CP_ACP
Definition: compat.h:99
HWND hWnd
Definition: settings.c:17
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum GLsizei len
Definition: glext.h:6722
#define MultiByteToWideChar
Definition: compat.h:100
BOOL WINAPI CommConfigDialogW(LPCWSTR lpszDevice, HWND hWnd, LPCOMMCONFIG lpCommConfig)
Definition: comm.c:1239
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define HeapFree(x, y, z)
Definition: compat.h:394

◆ CommConfigDialogW()

BOOL WINAPI CommConfigDialogW ( LPCWSTR  lpszDevice,
HWND  hWnd,
LPCOMMCONFIG  lpCommConfig 
)

Definition at line 1239 of file comm.c.

1243 {
1244  DWORD (WINAPI *pCommConfigDialog)(LPCWSTR, HWND, LPCOMMCONFIG);
1245  HMODULE hConfigModule;
1247 
1248  TRACE("(%s, %p, %p)\n", debugstr_w(lpszDevice), hWnd, lpCommConfig);
1249  hConfigModule = LoadLibraryW(lpszSerialUI);
1250 
1251  if (hConfigModule) {
1252  pCommConfigDialog = (void *)GetProcAddress(hConfigModule, "drvCommConfigDialogW");
1253  if (pCommConfigDialog) {
1254  res = pCommConfigDialog(lpszDevice, hWnd, lpCommConfig);
1255  }
1256  FreeLibrary(hConfigModule);
1257  }
1258 
1259  if (res) SetLastError(res);
1260  return (res == ERROR_SUCCESS);
1261 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
struct _COMM_CONFIG * LPCOMMCONFIG
Definition: confdlg.c:35
#define ERROR_SUCCESS
Definition: deptool.c:10
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
HWND hWnd
Definition: settings.c:17
HANDLE HWND
Definition: compat.h:13
static const WCHAR lpszSerialUI[]
Definition: comm.c:1191
#define DWORD
Definition: nt_native.h:44
#define debugstr_w
Definition: kernel32.h:32
#define LoadLibraryW(x)
Definition: compat.h:404
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:405
#define WINAPI
Definition: msvc.h:8
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
GLuint res
Definition: glext.h:9613
#define GetProcAddress(x, y)
Definition: compat.h:410

Referenced by CommConfigDialogA(), and dlg_configure_com().

◆ DEBUG_CHANNEL()

DEBUG_CHANNEL ( comm  )

◆ dump_dcb()

static void dump_dcb ( const DCB lpdcb)
static

Definition at line 776 of file comm.c.

777 {
778  TRACE("bytesize=%d baudrate=%d fParity=%d Parity=%d stopbits=%d\n",
779  lpdcb->ByteSize, lpdcb->BaudRate, lpdcb->fParity, lpdcb->Parity,
780  (lpdcb->StopBits == ONESTOPBIT) ? 1 :
781  (lpdcb->StopBits == TWOSTOPBITS) ? 2 : 0);
782  TRACE("%sIXON %sIXOFF\n", (lpdcb->fOutX) ? "" : "~", (lpdcb->fInX) ? "" : "~");
783  TRACE("fOutxCtsFlow=%d fRtsControl=%d\n", lpdcb->fOutxCtsFlow, lpdcb->fRtsControl);
784  TRACE("fOutxDsrFlow=%d fDtrControl=%d\n", lpdcb->fOutxDsrFlow, lpdcb->fDtrControl);
785  if (lpdcb->fOutxCtsFlow || lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE)
786  TRACE("CRTSCTS\n");
787  else
788  TRACE("~CRTSCTS\n");
789 }
#define RTS_CONTROL_HANDSHAKE
Definition: winbase.h:519
#define TWOSTOPBITS
Definition: winbase.h:441
#define ONESTOPBIT
Definition: winbase.h:439
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by GetCommState(), and SetCommState().

◆ EscapeCommFunction()

BOOL WINAPI EscapeCommFunction ( HANDLE  handle,
DWORD  func 
)

Definition at line 602 of file comm.c.

603 {
604  DWORD ioc;
605  DWORD dwBytesReturned;
606 
607  switch (func)
608  {
609  case CLRDTR: ioc = IOCTL_SERIAL_CLR_DTR; break;
610  case CLRRTS: ioc = IOCTL_SERIAL_CLR_RTS; break;
611  case SETDTR: ioc = IOCTL_SERIAL_SET_DTR; break;
612  case SETRTS: ioc = IOCTL_SERIAL_SET_RTS; break;
613  case SETXOFF: ioc = IOCTL_SERIAL_SET_XOFF; break;
614  case SETXON: ioc = IOCTL_SERIAL_SET_XON; break;
615  case SETBREAK: ioc = IOCTL_SERIAL_SET_BREAK_ON; break;
616  case CLRBREAK: ioc = IOCTL_SERIAL_SET_BREAK_OFF; break;
617  case RESETDEV: ioc = IOCTL_SERIAL_RESET_DEVICE; break;
618  default:
619  ERR("Unknown function code (%u)\n", func);
621  return FALSE;
622  }
623  return DeviceIoControl(handle, ioc, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
624 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
GLenum func
Definition: glext.h:6028
#define IOCTL_SERIAL_RESET_DEVICE
Definition: ntddser.h:80
#define SETXON
Definition: winbase.h:226
#define IOCTL_SERIAL_CLR_RTS
Definition: ntddser.h:46
#define CLRRTS
Definition: winbase.h:222
#define IOCTL_SERIAL_SET_DTR
Definition: ntddser.h:90
#define SETXOFF
Definition: winbase.h:225
#define SETBREAK
Definition: winbase.h:228
#define IOCTL_SERIAL_SET_BREAK_ON
Definition: ntddser.h:84
smooth NULL
Definition: ftsmooth.c:416
#define IOCTL_SERIAL_SET_XOFF
Definition: ntddser.h:108
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
#define IOCTL_SERIAL_SET_XON
Definition: ntddser.h:110
#define ERR(fmt,...)
Definition: debug.h:109
#define CLRDTR
Definition: winbase.h:221
#define IOCTL_SERIAL_CLR_DTR
Definition: ntddser.h:44
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
#define RESETDEV
Definition: winbase.h:227
#define CLRBREAK
Definition: winbase.h:229
#define SETDTR
Definition: winbase.h:223
#define SETRTS
Definition: winbase.h:224
#define IOCTL_SERIAL_SET_RTS
Definition: ntddser.h:102
#define IOCTL_SERIAL_SET_BREAK_OFF
Definition: ntddser.h:86

Referenced by main(), test_LoopbackCtsRts(), test_LoopbackDtrDcd(), test_LoopbackDtrDsr(), test_LoopbackDtrRing(), and toggle_ctlLine().

◆ GetCommConfig()

BOOL WINAPI GetCommConfig ( HANDLE  hFile,
LPCOMMCONFIG  lpCommConfig,
LPDWORD  lpdwSize 
)

Definition at line 1276 of file comm.c.

1282 {
1283  BOOL r;
1284 
1285  TRACE("(%p, %p, %p) *lpdwSize: %u\n", hFile, lpCommConfig, lpdwSize, lpdwSize ? *lpdwSize : 0 );
1286 
1287  if(lpCommConfig == NULL)
1288  return FALSE;
1289  r = *lpdwSize < sizeof(COMMCONFIG); /* TRUE if not enough space */
1290  *lpdwSize = sizeof(COMMCONFIG);
1291  if(r)
1292  return FALSE;
1293 
1294  lpCommConfig->dwSize = sizeof(COMMCONFIG);
1295  lpCommConfig->wVersion = 1;
1296  lpCommConfig->wReserved = 0;
1297  r = GetCommState(hFile,&lpCommConfig->dcb);
1298  lpCommConfig->dwProviderSubType = PST_RS232;
1299  lpCommConfig->dwProviderOffset = 0;
1300  lpCommConfig->dwProviderSize = 0;
1301 
1302  return r;
1303 }
DWORD dwProviderOffset
Definition: winbase.h:660
struct _COMM_CONFIG COMMCONFIG
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI GetCommState(HANDLE handle, LPDCB lpdcb)
Definition: comm.c:902
#define TRACE(s)
Definition: solgame.cpp:4
DWORD dwSize
Definition: winbase.h:655
_In_ HANDLE hFile
Definition: mswsock.h:90
static DWORD LPSTR PDWORD lpdwSize
Definition: process.c:72
DWORD dwProviderSize
Definition: winbase.h:661
DWORD dwProviderSubType
Definition: winbase.h:659
#define PST_RS232
Definition: serial.h:17
WORD wVersion
Definition: winbase.h:656
WORD wReserved
Definition: winbase.h:657

◆ GetCommMask()

BOOL WINAPI GetCommMask ( HANDLE  handle,
LPDWORD  evtmask 
)

Definition at line 744 of file comm.c.

745 {
746  DWORD dwBytesReturned;
747  TRACE("handle %p, mask %p\n", handle, evtmask);
749  NULL, 0, evtmask, sizeof(*evtmask), &dwBytesReturned, NULL);
750 }
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define IOCTL_SERIAL_GET_WAIT_MASK
Definition: ntddser.h:72
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136

◆ GetCommModemStatus()

BOOL WINAPI GetCommModemStatus ( HANDLE  hFile,
LPDWORD  lpModemStat 
)

Definition at line 1097 of file comm.c.

1098 {
1099  DWORD dwBytesReturned;
1101  NULL, 0, lpModemStat, sizeof(DWORD), &dwBytesReturned, NULL);
1102 }
#define IOCTL_SERIAL_GET_MODEMSTATUS
Definition: ntddser.h:64
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ HANDLE hFile
Definition: mswsock.h:90
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136

Referenced by test_AbortWaitCts(), test_GetModemStatus(), test_LoopbackCtsRts(), test_LoopbackDtrDcd(), test_LoopbackDtrDsr(), test_LoopbackDtrRing(), test_WaitBreak(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), and test_WaitRing().

◆ GetCommProperties()

BOOL WINAPI GetCommProperties ( HANDLE  hFile,
LPCOMMPROP  lpCommProp 
)

Definition at line 1142 of file comm.c.

1145 {
1146  TRACE("(%p %p)\n",hFile,lpCommProp);
1147  if(!lpCommProp)
1148  return FALSE;
1149 
1150  /*
1151  * These values should be valid for LINUX's serial driver
1152  * FIXME: Perhaps they deserve an #ifdef LINUX
1153  */
1154  memset(lpCommProp,0,sizeof(COMMPROP));
1155  lpCommProp->wPacketLength = 1;
1156  lpCommProp->wPacketVersion = 1;
1157  lpCommProp->dwServiceMask = SP_SERIALCOMM;
1158  lpCommProp->dwMaxTxQueue = 4096;
1159  lpCommProp->dwMaxRxQueue = 4096;
1160  lpCommProp->dwMaxBaud = BAUD_115200;
1161  lpCommProp->dwProvSubType = PST_RS232;
1165  lpCommProp->dwSettableBaud = BAUD_075 | BAUD_110 | BAUD_134_5 | BAUD_150 |
1171  lpCommProp->dwCurrentTxQueue = lpCommProp->dwMaxTxQueue;
1172  lpCommProp->dwCurrentRxQueue = lpCommProp->dwMaxRxQueue;
1173 
1174  return TRUE;
1175 }
#define PARITY_MARK
Definition: winbase.h:100
#define BAUD_1200
Definition: winbase.h:57
DWORD dwMaxRxQueue
Definition: winbase.h:671
#define SP_BAUD
Definition: winbase.h:82
#define TRUE
Definition: types.h:120
#define SP_STOPBITS
Definition: winbase.h:84
#define BAUD_115200
Definition: winbase.h:68
#define SP_PARITY
Definition: winbase.h:81
#define PARITY_SPACE
Definition: winbase.h:101
DWORD dwSettableParams
Definition: winbase.h:675
#define DATABITS_7
Definition: winbase.h:90
#define BAUD_075
Definition: winbase.h:51
DWORD dwProvSubType
Definition: winbase.h:673
#define PARITY_NONE
Definition: winbase.h:97
#define BAUD_600
Definition: winbase.h:56
#define STOPBITS_15
Definition: winbase.h:95
#define SP_DATABITS
Definition: winbase.h:83
#define STOPBITS_10
Definition: winbase.h:94
#define PCF_PARITY_CHECK
Definition: winbase.h:74
DWORD dwSettableBaud
Definition: winbase.h:676
#define PARITY_ODD
Definition: winbase.h:98
#define STOPBITS_20
Definition: winbase.h:96
#define PCF_DTRDSR
Definition: winbase.h:71
#define BAUD_19200
Definition: winbase.h:64
#define BAUD_1800
Definition: winbase.h:58
#define SP_SERIALCOMM
Definition: winbase.h:37
DWORD dwProvCapabilities
Definition: winbase.h:674
#define TRACE(s)
Definition: solgame.cpp:4
WORD wSettableData
Definition: winbase.h:677
#define DATABITS_5
Definition: winbase.h:88
#define BAUD_4800
Definition: winbase.h:60
#define PCF_TOTALTIMEOUTS
Definition: winbase.h:77
DWORD dwCurrentTxQueue
Definition: winbase.h:679
#define SP_HANDSHAKING
Definition: winbase.h:85
#define DATABITS_8
Definition: winbase.h:91
WORD wPacketVersion
Definition: winbase.h:667
#define BAUD_2400
Definition: winbase.h:59
WORD wPacketLength
Definition: winbase.h:666
_In_ HANDLE hFile
Definition: mswsock.h:90
DWORD dwCurrentRxQueue
Definition: winbase.h:680
#define SP_PARITY_CHECK
Definition: winbase.h:86
#define DATABITS_6
Definition: winbase.h:89
#define BAUD_150
Definition: winbase.h:54
WORD wSettableStopParity
Definition: winbase.h:678
#define BAUD_110
Definition: winbase.h:52
#define PST_RS232
Definition: serial.h:17
#define PCF_RTSCTS
Definition: winbase.h:72
#define PARITY_EVEN
Definition: winbase.h:99
DWORD dwServiceMask
Definition: winbase.h:668
#define BAUD_57600
Definition: winbase.h:69
#define BAUD_134_5
Definition: winbase.h:53
#define BAUD_9600
Definition: winbase.h:62
DWORD dwMaxBaud
Definition: winbase.h:672
#define BAUD_300
Definition: winbase.h:55
#define memset(x, y, z)
Definition: compat.h:39
#define BAUD_38400
Definition: winbase.h:65
DWORD dwMaxTxQueue
Definition: winbase.h:670

◆ GetCommState()

BOOL WINAPI GetCommState ( HANDLE  handle,
LPDCB  lpdcb 
)

Definition at line 902 of file comm.c.

903 {
904  SERIAL_BAUD_RATE sbr;
906  SERIAL_HANDFLOW shf;
907  SERIAL_CHARS sc;
908  DWORD dwBytesReturned;
909 
910  TRACE("handle %p, ptr %p\n", handle, lpdcb);
911 
912  if (!lpdcb)
913  {
915  return FALSE;
916  }
917 
919  NULL, 0, &sbr, sizeof(sbr), &dwBytesReturned, NULL) ||
921  NULL, 0, &slc, sizeof(slc), &dwBytesReturned, NULL) ||
923  NULL, 0, &shf, sizeof(shf), &dwBytesReturned, NULL) ||
925  NULL, 0, &sc, sizeof(sc), &dwBytesReturned, NULL))
926  return FALSE;
927 
928  memset(lpdcb, 0, sizeof(*lpdcb));
929  lpdcb->DCBlength = sizeof(*lpdcb);
930 
931  /* yes, they seem no never be (re)set on NT */
932  lpdcb->fBinary = 1;
933  lpdcb->fParity = 0;
934 
935  lpdcb->BaudRate = sbr.BaudRate;
936 
937  lpdcb->StopBits = slc.StopBits;
938  lpdcb->Parity = slc.Parity;
939  lpdcb->ByteSize = slc.WordLength;
940 
941  if (shf.ControlHandShake & SERIAL_CTS_HANDSHAKE) lpdcb->fOutxCtsFlow = 1;
942  if (shf.ControlHandShake & SERIAL_DSR_HANDSHAKE) lpdcb->fOutxDsrFlow = 1;
944  {
945  case 0: lpdcb->fDtrControl = DTR_CONTROL_DISABLE; break;
946  case SERIAL_DTR_CONTROL: lpdcb->fDtrControl = DTR_CONTROL_ENABLE; break;
948  }
950  {
951  case 0: lpdcb->fRtsControl = RTS_CONTROL_DISABLE; break;
952  case SERIAL_RTS_CONTROL: lpdcb->fRtsControl = RTS_CONTROL_ENABLE; break;
955  lpdcb->fRtsControl = RTS_CONTROL_TOGGLE; break;
956  }
958  if (shf.ControlHandShake & SERIAL_ERROR_ABORT) lpdcb->fAbortOnError = 1;
959  if (shf.FlowReplace & SERIAL_ERROR_CHAR) lpdcb->fErrorChar = 1;
960  if (shf.FlowReplace & SERIAL_NULL_STRIPPING) lpdcb->fNull = 1;
961  if (shf.FlowReplace & SERIAL_XOFF_CONTINUE) lpdcb->fTXContinueOnXoff = 1;
962  lpdcb->XonLim = shf.XonLimit;
963  lpdcb->XoffLim = shf.XoffLimit;
964 
965  if (shf.FlowReplace & SERIAL_AUTO_TRANSMIT) lpdcb->fOutX = 1;
966  if (shf.FlowReplace & SERIAL_AUTO_RECEIVE) lpdcb->fInX = 1;
967 
968  lpdcb->EofChar = sc.EofChar;
969  lpdcb->ErrorChar = sc.ErrorChar;
970  lpdcb->EvtChar = sc.EventChar;
971  lpdcb->XonChar = sc.XonChar;
972  lpdcb->XoffChar = sc.XoffChar;
973 
974  TRACE("OK\n");
975  dump_dcb(lpdcb);
976 
977  return TRUE;
978 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
char XoffChar
Definition: winbase.h:647
DWORD fDsrSensitivity
Definition: winbase.h:631
UCHAR ErrorChar
Definition: ntddser.h:163
#define TRUE
Definition: types.h:120
DWORD fNull
Definition: winbase.h:636
#define RTS_CONTROL_ENABLE
Definition: winbase.h:518
#define SERIAL_XOFF_CONTINUE
Definition: ntddser.h:205
#define DTR_CONTROL_DISABLE
Definition: winbase.h:514
UCHAR XoffChar
Definition: ntddser.h:167
#define RTS_CONTROL_HANDSHAKE
Definition: winbase.h:519
DWORD fOutxCtsFlow
Definition: winbase.h:628
char EofChar
Definition: winbase.h:649
UCHAR EventChar
Definition: ntddser.h:165
DWORD fBinary
Definition: winbase.h:626
DWORD fInX
Definition: winbase.h:634
#define RTS_CONTROL_DISABLE
Definition: winbase.h:517
ULONG FlowReplace
Definition: ntddser.h:181
WORD XonLim
Definition: winbase.h:641
#define SERIAL_DSR_SENSITIVITY
Definition: serial.c:128
#define IOCTL_SERIAL_GET_LINE_CONTROL
Definition: ntddser.h:60
DWORD BaudRate
Definition: winbase.h:625
#define DTR_CONTROL_ENABLE
Definition: winbase.h:515
DWORD fErrorChar
Definition: winbase.h:635
#define SERIAL_DSR_HANDSHAKE
Definition: ntddser.h:190
#define SERIAL_NULL_STRIPPING
Definition: ntddser.h:199
BYTE ByteSize
Definition: winbase.h:643
smooth NULL
Definition: ftsmooth.c:416
#define SERIAL_ERROR_CHAR
Definition: ntddser.h:198
#define SERIAL_DTR_CONTROL
Definition: serial.c:122
char EvtChar
Definition: winbase.h:650
#define TRACE(s)
Definition: solgame.cpp:4
#define SERIAL_DTR_HANDSHAKE
Definition: ntddser.h:188
char XonChar
Definition: winbase.h:646
static void dump_dcb(const DCB *lpdcb)
Definition: comm.c:776
DWORD fOutX
Definition: winbase.h:633
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
#define SERIAL_RTS_HANDSHAKE
Definition: ntddser.h:203
#define SERIAL_RTS_CONTROL
Definition: ntddser.h:202
DWORD fTXContinueOnXoff
Definition: winbase.h:632
DWORD DCBlength
Definition: winbase.h:624
DWORD fAbortOnError
Definition: winbase.h:638
UCHAR XonChar
Definition: ntddser.h:166
DWORD fOutxDsrFlow
Definition: winbase.h:629
BYTE StopBits
Definition: winbase.h:645
#define IOCTL_SERIAL_GET_CHARS
Definition: ntddser.h:52
#define SERIAL_ERROR_ABORT
Definition: serial.c:124
UCHAR EofChar
Definition: ntddser.h:162
#define IOCTL_SERIAL_GET_HANDFLOW
Definition: ntddser.h:58
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
#define RTS_CONTROL_TOGGLE
Definition: winbase.h:520
#define DTR_CONTROL_HANDSHAKE
Definition: winbase.h:516
DWORD fDtrControl
Definition: winbase.h:630
#define SERIAL_AUTO_TRANSMIT
Definition: ntddser.h:196
#define SERIAL_CTS_HANDSHAKE
Definition: serial.c:123
DWORD fParity
Definition: winbase.h:627
DWORD fRtsControl
Definition: winbase.h:637
BYTE Parity
Definition: winbase.h:644
char ErrorChar
Definition: winbase.h:648
#define SERIAL_AUTO_RECEIVE
Definition: ntddser.h:197
#define memset(x, y, z)
Definition: compat.h:39
#define IOCTL_SERIAL_GET_BAUD_RATE
Definition: ntddser.h:50
WORD XoffLim
Definition: winbase.h:642
ULONG ControlHandShake
Definition: ntddser.h:180

Referenced by GetCommConfig(), main(), SerialPortQuery(), test_AbortWaitCts(), test_LoopbackCtsRts(), test_LoopbackDtrDcd(), test_LoopbackDtrDsr(), test_LoopbackDtrRing(), test_LoopbackRead(), test_non_pending_errors(), test_read_write(), test_ReadTimeOut(), test_stdio(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), test_WaitRing(), and test_waittxempty().

◆ GetCommTimeouts()

BOOL WINAPI GetCommTimeouts ( HANDLE  hComm,
LPCOMMTIMEOUTS  lptimeouts 
)

Definition at line 1018 of file comm.c.

1019 {
1020  SERIAL_TIMEOUTS st;
1021  DWORD dwBytesReturned;
1022 
1023  TRACE("(%p, %p)\n", hComm, lptimeouts);
1024  if (!lptimeouts)
1025  {
1027  return FALSE;
1028  }
1030  NULL, 0, &st, sizeof(st), &dwBytesReturned, NULL))
1031  return FALSE;
1032  lptimeouts->ReadIntervalTimeout = st.ReadIntervalTimeout;
1037  return TRUE;
1038 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define TRUE
Definition: types.h:120
ULONG WriteTotalTimeoutConstant
Definition: ntddser.h:307
ULONG ReadTotalTimeoutConstant
Definition: ntddser.h:305
DWORD WriteTotalTimeoutMultiplier
Definition: winbase.h:690
ULONG ReadTotalTimeoutMultiplier
Definition: ntddser.h:304
smooth NULL
Definition: ftsmooth.c:416
ULONG WriteTotalTimeoutMultiplier
Definition: ntddser.h:306
#define TRACE(s)
Definition: solgame.cpp:4
ULONG ReadIntervalTimeout
Definition: ntddser.h:303
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD ReadTotalTimeoutConstant
Definition: winbase.h:689
#define SetLastError(x)
Definition: compat.h:409
DWORD ReadIntervalTimeout
Definition: winbase.h:687
#define IOCTL_SERIAL_GET_TIMEOUTS
Definition: ntddser.h:70
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
DWORD ReadTotalTimeoutMultiplier
Definition: winbase.h:688
DWORD WriteTotalTimeoutConstant
Definition: winbase.h:691

Referenced by _SetTransmissionRetryTimeout(), Rs232SetCommunicationTimeoutsWin32(), and SerialPortQuery().

◆ GetDefaultCommConfigA()

BOOL WINAPI GetDefaultCommConfigA ( LPCSTR  lpszName,
LPCOMMCONFIG  lpCC,
LPDWORD  lpdwSize 
)

Definition at line 1434 of file comm.c.

1440 {
1441  BOOL ret = FALSE;
1442  UNICODE_STRING lpszNameW;
1443 
1444  TRACE("(%s, %p, %p) *lpdwSize: %u\n", debugstr_a(lpszName), lpCC, lpdwSize, lpdwSize ? *lpdwSize : 0 );
1445  if(lpszName) RtlCreateUnicodeStringFromAsciiz(&lpszNameW,lpszName);
1446  else lpszNameW.Buffer = NULL;
1447 
1449 
1450  RtlFreeUnicodeString(&lpszNameW);
1451  return ret;
1452 }
_Out_writes_bytes_opt_ lpdwSize LPCOMMCONFIG lpCC
Definition: winbase.h:2016
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
#define TRACE(s)
Definition: solgame.cpp:4
BOOL WINAPI GetDefaultCommConfigW(LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize)
Definition: comm.c:1398
#define debugstr_a
Definition: kernel32.h:31
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
int ret
static DWORD LPSTR PDWORD lpdwSize
Definition: process.c:72

Referenced by test_BuildCommDCB().

◆ GetDefaultCommConfigW()

BOOL WINAPI GetDefaultCommConfigW ( LPCWSTR  lpszName,
LPCOMMCONFIG  lpCC,
LPDWORD  lpdwSize 
)

Definition at line 1398 of file comm.c.

1404 {
1405  DWORD (WINAPI *pGetDefaultCommConfig)(LPCWSTR, LPCOMMCONFIG, LPDWORD);
1406  HMODULE hConfigModule;
1408 
1409  TRACE("(%s, %p, %p) *lpdwSize: %u\n", debugstr_w(lpszName), lpCC, lpdwSize, lpdwSize ? *lpdwSize : 0 );
1410  hConfigModule = LoadLibraryW(lpszSerialUI);
1411 
1412  if (hConfigModule) {
1413  pGetDefaultCommConfig = (void *)GetProcAddress(hConfigModule, "drvGetDefaultCommConfigW");
1414  if (pGetDefaultCommConfig) {
1415  res = pGetDefaultCommConfig(lpszName, lpCC, lpdwSize);
1416  }
1417  FreeLibrary(hConfigModule);
1418  }
1419 
1420  if (res) SetLastError(res);
1421  return (res == ERROR_SUCCESS);
1422 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
_Out_writes_bytes_opt_ lpdwSize LPCOMMCONFIG lpCC
Definition: winbase.h:2016
struct _COMM_CONFIG * LPCOMMCONFIG
Definition: confdlg.c:35
#define ERROR_SUCCESS
Definition: deptool.c:10
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
static const WCHAR lpszSerialUI[]
Definition: comm.c:1191
#define DWORD
Definition: nt_native.h:44
#define debugstr_w
Definition: kernel32.h:32
#define LoadLibraryW(x)
Definition: compat.h:404
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:405
#define WINAPI
Definition: msvc.h:8
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
#define LPDWORD
Definition: nt_native.h:46
static DWORD LPSTR PDWORD lpdwSize
Definition: process.c:72
GLuint res
Definition: glext.h:9613
#define GetProcAddress(x, y)
Definition: compat.h:410

Referenced by _HandleGetDefaultCommConfig(), and GetDefaultCommConfigA().

◆ PurgeComm()

BOOL WINAPI PurgeComm ( HANDLE  handle,
DWORD  flags 
)

Definition at line 641 of file comm.c.

642 {
643  DWORD dwBytesReturned;
645  NULL, 0, &dwBytesReturned, NULL);
646 }
#define IOCTL_SERIAL_PURGE
Definition: ntddser.h:78
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
GLbitfield flags
Definition: glext.h:7161
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136

◆ SetCommBreak()

BOOL WINAPI SetCommBreak ( HANDLE  handle)

Definition at line 557 of file comm.c.

558 {
559  DWORD dwBytesReturned;
560  return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_ON, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
561 }
#define IOCTL_SERIAL_SET_BREAK_ON
Definition: ntddser.h:84
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136

Referenced by set_CommBreak().

◆ SetCommConfig()

BOOL WINAPI SetCommConfig ( HANDLE  hFile,
LPCOMMCONFIG  lpCommConfig,
DWORD  dwSize 
)

Definition at line 1314 of file comm.c.

1318 {
1319  TRACE("(%p, %p, %u)\n", hFile, lpCommConfig, dwSize);
1320  return SetCommState(hFile,&lpCommConfig->dcb);
1321 }
BOOL WINAPI SetCommState(HANDLE handle, LPDCB lpdcb)
Definition: comm.c:807
#define TRACE(s)
Definition: solgame.cpp:4
_In_ HANDLE hFile
Definition: mswsock.h:90
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54

◆ SetCommMask()

BOOL WINAPI SetCommMask ( HANDLE  handle,
DWORD  evtmask 
)

Definition at line 768 of file comm.c.

769 {
770  DWORD dwBytesReturned;
771  TRACE("handle %p, mask %x\n", handle, evtmask);
773  &evtmask, sizeof(evtmask), NULL, 0, &dwBytesReturned, NULL);
774 }
#define IOCTL_SERIAL_SET_WAIT_MASK
Definition: ntddser.h:106
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136

Referenced by reset_CommMask(), test_AbortWaitCts(), test_LoopbackRead(), test_read_write(), test_WaitBreak(), test_WaitCommEvent(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), test_WaitRing(), test_WaitRx(), and test_waittxempty().

◆ SetCommState()

BOOL WINAPI SetCommState ( HANDLE  handle,
LPDCB  lpdcb 
)

Definition at line 807 of file comm.c.

808 {
809  SERIAL_BAUD_RATE sbr;
811  SERIAL_HANDFLOW shf;
812  SERIAL_CHARS sc;
813  DWORD dwBytesReturned;
814 
815  if (lpdcb == NULL)
816  {
818  return FALSE;
819  }
820  dump_dcb(lpdcb);
821 
822  sbr.BaudRate = lpdcb->BaudRate;
823 
824  slc.StopBits = lpdcb->StopBits;
825  slc.Parity = lpdcb->Parity;
826  slc.WordLength = lpdcb->ByteSize;
827 
828  shf.ControlHandShake = 0;
829  shf.FlowReplace = 0;
832  switch (lpdcb->fDtrControl)
833  {
834  case DTR_CONTROL_DISABLE: break;
837  default:
839  return FALSE;
840  }
841  switch (lpdcb->fRtsControl)
842  {
843  case RTS_CONTROL_DISABLE: break;
847  SERIAL_RTS_HANDSHAKE; break;
848  default:
850  return FALSE;
851  }
854 
855  if (lpdcb->fErrorChar) shf.FlowReplace |= SERIAL_ERROR_CHAR;
856  if (lpdcb->fNull) shf.FlowReplace |= SERIAL_NULL_STRIPPING;
858  if (lpdcb->fOutX) shf.FlowReplace |= SERIAL_AUTO_TRANSMIT;
859  if (lpdcb->fInX) shf.FlowReplace |= SERIAL_AUTO_RECEIVE;
860 
861  shf.XonLimit = lpdcb->XonLim;
862  shf.XoffLimit = lpdcb->XoffLim;
863 
864  sc.EofChar = lpdcb->EofChar;
865  sc.ErrorChar = lpdcb->ErrorChar;
866  sc.BreakChar = 0;
867  sc.EventChar = lpdcb->EvtChar;
868  sc.XonChar = lpdcb->XonChar;
869  sc.XoffChar = lpdcb->XoffChar;
870 
871  /* note: change DTR/RTS lines after setting the comm attributes,
872  * so flow control does not interfere.
873  */
875  &sbr, sizeof(sbr), NULL, 0, &dwBytesReturned, NULL) &&
877  &slc, sizeof(slc), NULL, 0, &dwBytesReturned, NULL) &&
879  &shf, sizeof(shf), NULL, 0, &dwBytesReturned, NULL) &&
881  &sc, sizeof(sc), NULL, 0, &dwBytesReturned, NULL));
882 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
char XoffChar
Definition: winbase.h:647
DWORD fDsrSensitivity
Definition: winbase.h:631
UCHAR ErrorChar
Definition: ntddser.h:163
UCHAR BreakChar
Definition: ntddser.h:164
DWORD fNull
Definition: winbase.h:636
#define RTS_CONTROL_ENABLE
Definition: winbase.h:518
#define IOCTL_SERIAL_SET_BAUD_RATE
Definition: ntddser.h:82
#define SERIAL_XOFF_CONTINUE
Definition: ntddser.h:205
#define DTR_CONTROL_DISABLE
Definition: winbase.h:514
UCHAR XoffChar
Definition: ntddser.h:167
#define RTS_CONTROL_HANDSHAKE
Definition: winbase.h:519
DWORD fOutxCtsFlow
Definition: winbase.h:628
char EofChar
Definition: winbase.h:649
UCHAR EventChar
Definition: ntddser.h:165
DWORD fInX
Definition: winbase.h:634
#define RTS_CONTROL_DISABLE
Definition: winbase.h:517
ULONG FlowReplace
Definition: ntddser.h:181
#define IOCTL_SERIAL_SET_LINE_CONTROL
Definition: ntddser.h:96
WORD XonLim
Definition: winbase.h:641
#define SERIAL_DSR_SENSITIVITY
Definition: serial.c:128
DWORD BaudRate
Definition: winbase.h:625
#define DTR_CONTROL_ENABLE
Definition: winbase.h:515
DWORD fErrorChar
Definition: winbase.h:635
#define SERIAL_DSR_HANDSHAKE
Definition: ntddser.h:190
#define SERIAL_NULL_STRIPPING
Definition: ntddser.h:199
BYTE ByteSize
Definition: winbase.h:643
smooth NULL
Definition: ftsmooth.c:416
#define SERIAL_ERROR_CHAR
Definition: ntddser.h:198
#define SERIAL_DTR_CONTROL
Definition: serial.c:122
char EvtChar
Definition: winbase.h:650
#define SERIAL_DTR_HANDSHAKE
Definition: ntddser.h:188
char XonChar
Definition: winbase.h:646
static void dump_dcb(const DCB *lpdcb)
Definition: comm.c:776
DWORD fOutX
Definition: winbase.h:633
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
#define SERIAL_RTS_HANDSHAKE
Definition: ntddser.h:203
#define SERIAL_RTS_CONTROL
Definition: ntddser.h:202
DWORD fTXContinueOnXoff
Definition: winbase.h:632
DWORD fAbortOnError
Definition: winbase.h:638
UCHAR XonChar
Definition: ntddser.h:166
DWORD fOutxDsrFlow
Definition: winbase.h:629
BYTE StopBits
Definition: winbase.h:645
#define SERIAL_ERROR_ABORT
Definition: serial.c:124
#define IOCTL_SERIAL_SET_CHARS
Definition: ntddser.h:88
UCHAR EofChar
Definition: ntddser.h:162
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
#define RTS_CONTROL_TOGGLE
Definition: winbase.h:520
#define DTR_CONTROL_HANDSHAKE
Definition: winbase.h:516
#define IOCTL_SERIAL_SET_HANDFLOW
Definition: ntddser.h:94
DWORD fDtrControl
Definition: winbase.h:630
#define SERIAL_AUTO_TRANSMIT
Definition: ntddser.h:196
#define SERIAL_CTS_HANDSHAKE
Definition: serial.c:123
DWORD fRtsControl
Definition: winbase.h:637
BYTE Parity
Definition: winbase.h:644
char ErrorChar
Definition: winbase.h:648
#define SERIAL_AUTO_RECEIVE
Definition: ntddser.h:197
WORD XoffLim
Definition: winbase.h:642
ULONG ControlHandShake
Definition: ntddser.h:180

Referenced by main(), Rs232ConfigurePortWin32(), SerialPortQuery(), SetCommConfig(), test_LoopbackRead(), test_non_pending_errors(), test_read_write(), test_ReadTimeOut(), test_WaitCts(), and test_waittxempty().

◆ SetCommTimeouts()

BOOL WINAPI SetCommTimeouts ( HANDLE  hComm,
LPCOMMTIMEOUTS  lptimeouts 
)

Definition at line 1060 of file comm.c.

1061 {
1062  SERIAL_TIMEOUTS st;
1063  DWORD dwBytesReturned;
1064 
1065  TRACE("(%p, %p)\n", hComm, lptimeouts);
1066 
1067  if (lptimeouts == NULL)
1068  {
1070  return FALSE;
1071  }
1072  st.ReadIntervalTimeout = lptimeouts->ReadIntervalTimeout;
1077 
1079  &st, sizeof(st), NULL, 0, &dwBytesReturned, NULL);
1080 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
ULONG WriteTotalTimeoutConstant
Definition: ntddser.h:307
ULONG ReadTotalTimeoutConstant
Definition: ntddser.h:305
DWORD WriteTotalTimeoutMultiplier
Definition: winbase.h:690
ULONG ReadTotalTimeoutMultiplier
Definition: ntddser.h:304
smooth NULL
Definition: ftsmooth.c:416
ULONG WriteTotalTimeoutMultiplier
Definition: ntddser.h:306
#define TRACE(s)
Definition: solgame.cpp:4
ULONG ReadIntervalTimeout
Definition: ntddser.h:303
unsigned long DWORD
Definition: ntddk_ex.h:95
DWORD ReadTotalTimeoutConstant
Definition: winbase.h:689
#define SetLastError(x)
Definition: compat.h:409
DWORD ReadIntervalTimeout
Definition: winbase.h:687
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
DWORD ReadTotalTimeoutMultiplier
Definition: winbase.h:688
DWORD WriteTotalTimeoutConstant
Definition: winbase.h:691
#define IOCTL_SERIAL_SET_TIMEOUTS
Definition: ntddser.h:104

Referenced by _SetTransmissionRetryTimeout(), LocalmonSetPortTimeOuts(), Rs232SetCommunicationTimeoutsWin32(), SerialPortQuery(), test_LoopbackRead(), test_read_write(), test_ReadTimeOut(), and test_waittxempty().

◆ SetDefaultCommConfigA()

BOOL WINAPI SetDefaultCommConfigA ( LPCSTR  lpszDevice,
LPCOMMCONFIG  lpCommConfig,
DWORD  dwSize 
)

Definition at line 1368 of file comm.c.

1369 {
1370  BOOL r;
1371  LPWSTR lpDeviceW = NULL;
1372  DWORD len;
1373 
1374  TRACE("(%s, %p, %u)\n", debugstr_a(lpszDevice), lpCommConfig, dwSize);
1375 
1376  if (lpszDevice)
1377  {
1378  len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
1379  lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1380  MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
1381  }
1382  r = SetDefaultCommConfigW(lpDeviceW,lpCommConfig,dwSize);
1383  HeapFree( GetProcessHeap(), 0, lpDeviceW );
1384  return r;
1385 }
BOOL WINAPI SetDefaultCommConfigW(LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
Definition: comm.c:1338
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define CP_ACP
Definition: compat.h:99
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum GLsizei len
Definition: glext.h:6722
#define MultiByteToWideChar
Definition: compat.h:100
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define HeapFree(x, y, z)
Definition: compat.h:394
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54

◆ SetDefaultCommConfigW()

BOOL WINAPI SetDefaultCommConfigW ( LPCWSTR  lpszDevice,
LPCOMMCONFIG  lpCommConfig,
DWORD  dwSize 
)

Definition at line 1338 of file comm.c.

1339 {
1340  BOOL (WINAPI *lpfnSetDefaultCommConfig)(LPCWSTR, LPCOMMCONFIG, DWORD);
1341  HMODULE hConfigModule;
1342  BOOL r = FALSE;
1343 
1344  TRACE("(%s, %p, %u)\n", debugstr_w(lpszDevice), lpCommConfig, dwSize);
1345 
1346  hConfigModule = LoadLibraryW(lpszSerialUI);
1347  if(!hConfigModule)
1348  return r;
1349 
1350  lpfnSetDefaultCommConfig = (void *)GetProcAddress(hConfigModule, "drvSetDefaultCommConfigW");
1351  if (lpfnSetDefaultCommConfig)
1352  r = lpfnSetDefaultCommConfig(lpszDevice, lpCommConfig, dwSize);
1353 
1354  FreeLibrary(hConfigModule);
1355 
1356  return r;
1357 }
struct _COMM_CONFIG * LPCOMMCONFIG
Definition: confdlg.c:35
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
static const WCHAR lpszSerialUI[]
Definition: comm.c:1191
#define BOOL
Definition: nt_native.h:43
#define DWORD
Definition: nt_native.h:44
unsigned int BOOL
Definition: ntddk_ex.h:94
#define debugstr_w
Definition: kernel32.h:32
#define LoadLibraryW(x)
Definition: compat.h:404
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:405
#define WINAPI
Definition: msvc.h:8
#define GetProcAddress(x, y)
Definition: compat.h:410
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54

Referenced by _HandleSetDefaultCommConfig(), and SetDefaultCommConfigA().

◆ SetupComm()

BOOL WINAPI SetupComm ( HANDLE  handle,
DWORD  insize,
DWORD  outsize 
)

Definition at line 718 of file comm.c.

719 {
720  SERIAL_QUEUE_SIZE sqs;
721  DWORD dwBytesReturned;
722 
723  sqs.InSize = insize;
724  sqs.OutSize = outsize;
726  &sqs, sizeof(sqs), NULL, 0, &dwBytesReturned, NULL);
727 }
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char unsigned long * outsize
Definition: jpeglib.h:979
const unsigned char unsigned long insize
Definition: jpeglib.h:982
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
#define IOCTL_SERIAL_SET_QUEUE_SIZE
Definition: ntddser.h:100

Referenced by test_read_write(), and test_waittxempty().

◆ TransmitCommChar()

BOOL WINAPI TransmitCommChar ( HANDLE  hComm,
CHAR  chTransmit 
)

Definition at line 996 of file comm.c.

997 {
998  DWORD dwBytesReturned;
1000  &chTransmit, sizeof(chTransmit), NULL, 0, &dwBytesReturned, NULL);
1001 }
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
#define IOCTL_SERIAL_IMMEDIATE_CHAR
Definition: ntddser.h:74
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136

◆ WaitCommEvent()

BOOL WINAPI WaitCommEvent ( HANDLE  hFile,
LPDWORD  lpdwEvents,
LPOVERLAPPED  lpOverlapped 
)

Definition at line 1121 of file comm.c.

1125 {
1127  lpdwEvents, sizeof(DWORD), NULL, lpOverlapped);
1128 }
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ HANDLE hFile
Definition: mswsock.h:90
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED lpOverlapped
Definition: mswsock.h:90
#define IOCTL_SERIAL_WAIT_ON_MASK
Definition: ntddser.h:112

Referenced by test_AbortWaitCts(), test_LoopbackRead(), test_read_write(), test_WaitBreak(), test_WaitCommEvent(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), test_WaitRing(), test_WaitRx(), and test_waittxempty().

Variable Documentation

◆ lpszSerialUI

const WCHAR lpszSerialUI[]
static
Initial value:
= {
's','e','r','i','a','l','u','i','.','d','l','l',0 }

Definition at line 1191 of file comm.c.

Referenced by CommConfigDialogW(), GetDefaultCommConfigW(), and SetDefaultCommConfigW().