1 /*
2 * DEC 93 Erik Bos <erik@xs4all.nl>
3 *
4 * Copyright 1996 Marcus Meissner
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winerror.h"
33 #include "winioctl.h"
34 #include "ddk/ntddser.h"
35
36 #include "wine/server.h"
37 #include "wine/unicode.h"
38
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(comm);
42
43 /***********************************************************************
44 * COMM_Parse* (Internal)
45 *
46 * The following COMM_Parse* functions are used by the BuildCommDCB
47 * functions to help parse the various parts of the device control string.
48 */
49 static LPCWSTR COMM_ParseStart(LPCWSTR ptr)
50 {
51 static const WCHAR comW[] = {'C','O','M',0};
52
53 /* The device control string may optionally start with "COMx" followed
54 by an optional ':' and spaces. */
55 if(!strncmpiW(ptr, comW, 3))
56 {
57 ptr += 3;
58
59 /* Allow any com port above 0 as Win 9x does (NT only allows
60 values for com ports which are actually present) */
61 if(*ptr < '1' || *ptr > '9')
62 return NULL;
63
64 /* Advance pointer past port number */
65 while(*ptr >= '' && *ptr <= '9') ptr++;
66
67 /* The com port number must be followed by a ':' or ' ' */
68 if(*ptr != ':' && *ptr != ' ')
69 return NULL;
70
71 /* Advance pointer to beginning of next parameter */
72 while(*ptr == ' ') ptr++;
73 if(*ptr == ':')
74 {
75 ptr++;
76 while(*ptr == ' ') ptr++;
77 }
78 }
79 /* The device control string must not start with a space. */
80 else if(*ptr == ' ')
81 return NULL;
82
83 return ptr;
84 }
85
86 static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
87 {
88 if(*ptr < '' || *ptr > '9') return NULL;
89 *lpnumber = strtoulW(ptr, NULL, 10);
90 while(*ptr >= '' && *ptr <= '9') ptr++;
91 return ptr;
92 }
93
94 static LPCWSTR COMM_ParseParity(LPCWSTR ptr, LPBYTE lpparity)
95 {
96 /* Contrary to what you might expect, Windows only sets the Parity
97 member of DCB and not fParity even when parity is specified in the
98 device control string */
99
100 switch(toupperW(*ptr++))
101 {
102 case 'E':
103 *lpparity = EVENPARITY;
104 break;
105 case 'M':
106 *lpparity = MARKPARITY;
107 break;
108 case 'N':
109 *lpparity = NOPARITY;
110 break;
111 case 'O':
112 *lpparity = ODDPARITY;
113 break;
114 case 'S':
115 *lpparity = SPACEPARITY;
116 break;
117 default:
118 return NULL;
119 }
120
121 return ptr;
122 }
123
124 static LPCWSTR COMM_ParseByteSize(LPCWSTR ptr, LPBYTE lpbytesize)
125 {
126 DWORD temp;
127
128 if(!(ptr = COMM_ParseNumber(ptr, &temp)))
129 return NULL;
130
131 if(temp >= 5 && temp <= 8)
132 {
133 *lpbytesize = temp;
134 return ptr;
135 }
136 else
137 return NULL;
138 }
139
140 static LPCWSTR COMM_ParseStopBits(LPCWSTR ptr, LPBYTE lpstopbits)
141 {
142 DWORD temp;
143 static const WCHAR stopbits15W[] = {'1','.','5',0};
144
145 if(!strncmpW(stopbits15W, ptr, 3))
146 {
147 ptr += 3;
148 *lpstopbits = ONE5STOPBITS;
149 }
150 else
151 {
152 if(!(ptr = COMM_ParseNumber(ptr, &temp)))
153 return NULL;
154
155 if(temp == 1)
156 *lpstopbits = ONESTOPBIT;
157 else if(temp == 2)
158 *lpstopbits = TWOSTOPBITS;
159 else
160 return NULL;
161 }
162
163 return ptr;
164 }
165
166 static LPCWSTR COMM_ParseOnOff(LPCWSTR ptr, LPDWORD lponoff)
167 {
168 static const WCHAR onW[] = {'o','n',0};
169 static const WCHAR offW[] = {'o','f','f',0};
170
171 if(!strncmpiW(onW, ptr, 2))
172 {
173 ptr += 2;
174 *lponoff = 1;
175 }
176 else if(!strncmpiW(offW, ptr, 3))
177 {
178 ptr += 3;
179 *lponoff = 0;
180 }
181 else
182 return NULL;
183
184 return ptr;
185 }
186
187 /***********************************************************************
188 * COMM_BuildOldCommDCB (Internal)
189 *
190 * Build a DCB using the old style settings string eg: "96,n,8,1"
191 */
192 static BOOL COMM_BuildOldCommDCB(LPCWSTR device, LPDCB lpdcb)
193 {
194 WCHAR last = 0;
195
196 if(!(device = COMM_ParseNumber(device, &lpdcb->BaudRate)))
197 return FALSE;
198
199 switch(lpdcb->BaudRate)
200 {
201 case 11:
202 case 30:
203 case 60:
204 lpdcb->BaudRate *= 10;
205 break;
206 case 12:
207 case 24:
208 case 48:
209 case 96:
210 lpdcb->BaudRate *= 100;
211 break;
212 case 19:
213 lpdcb->BaudRate = 19200;
214 break;
215 }
216
217 while(*device == ' ') device++;
218 if(*device++ != ',') return FALSE;
219 while(*device == ' ') device++;
220
221 if(!(device = COMM_ParseParity(device, &lpdcb->Parity)))
222 return FALSE;
223
224 while(*device == ' ') device++;
225 if(*device++ != ',') return FALSE;
226 while(*device == ' ') device++;
227
228 if(!(device = COMM_ParseByteSize(device, &lpdcb->ByteSize)))
229 return FALSE;
230
231 while(*device == ' ') device++;
232 if(*device++ != ',') return FALSE;
233 while(*device == ' ') device++;
234
235 if(!(device = COMM_ParseStopBits(device, &lpdcb->StopBits)))
236 return FALSE;
237
238 /* The last parameter for flow control is optional. */
239 while(*device == ' ') device++;
240 if(*device == ',')
241 {
242 device++;
243 while(*device == ' ') device++;
244 if(*device) last = toupperW(*device++);
245 while(*device == ' ') device++;
246 }
247
248 /* Win NT sets the flow control members based on (or lack of) the last
249 parameter. Win 9x does not set these members. */
250 switch(last)
251 {
252 case 0:
253 lpdcb->fInX = FALSE;
254 lpdcb->fOutX = FALSE;
255 lpdcb->fOutxCtsFlow = FALSE;
256 lpdcb->fOutxDsrFlow = FALSE;
257 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
258 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
259 break;
260 case 'X':
261 lpdcb->fInX = TRUE;
262 lpdcb->fOutX = TRUE;
263 lpdcb->fOutxCtsFlow = FALSE;
264 lpdcb->fOutxDsrFlow = FALSE;
265 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
266 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
267 break;
268 case 'P':
269 lpdcb->fInX = FALSE;
270 lpdcb->fOutX = FALSE;
271 lpdcb->fOutxCtsFlow = TRUE;
272 lpdcb->fOutxDsrFlow = TRUE;
273 lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE;
274 lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
275 break;
276 default:
277 return FALSE;
278 }
279
280 /* This should be the end of the string. */
281 if(*device) return FALSE;
282
283 return TRUE;
284 }
285
286 /***********************************************************************
287 * COMM_BuildNewCommDCB (Internal)
288 *
289 * Build a DCB using the new style settings string.
290 * eg: "baud=9600 parity=n data=8 stop=1 xon=on to=on"
291 */
292 static BOOL COMM_BuildNewCommDCB(LPCWSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
293 {
294 DWORD temp;
295 BOOL baud = FALSE, stop = FALSE;
296 static const WCHAR baudW[] = {'b','a','u','d','=',0};
297 static const WCHAR parityW[] = {'p','a','r','i','t','y','=',0};
298 static const WCHAR dataW[] = {'d','a','t','a','=',0};
299 static const WCHAR stopW[] = {'s','t','o','p','=',0};
300 static const WCHAR toW[] = {'t','o','=',0};
301 static const WCHAR xonW[] = {'x','o','n','=',0};
302 static const WCHAR odsrW[] = {'o','d','s','r','=',0};
303 static const WCHAR octsW[] = {'o','c','t','s','=',0};
304 static const WCHAR dtrW[] = {'d','t','r','=',0};
305 static const WCHAR rtsW[] = {'r','t','s','=',0};
306 static const WCHAR idsrW[] = {'i','d','s','r','=',0};
307
308 while(*device)
309 {
310 while(*device == ' ') device++;
311
312 if(!strncmpiW(baudW, device, 5))
313 {
314 baud = TRUE;
315
316 if(!(device = COMM_ParseNumber(device + 5, &lpdcb->BaudRate)))
317 return FALSE;
318 }
319 else if(!strncmpiW(parityW, device, 7))
320 {
321 if(!(device = COMM_ParseParity(device + 7, &lpdcb->Parity)))
322 return FALSE;
323 }
324 else if(!strncmpiW(dataW, device, 5))
325 {
326 if(!(device = COMM_ParseByteSize(device + 5, &lpdcb->ByteSize)))
327 return FALSE;
328 }
329 else if(!strncmpiW(stopW, device, 5))
330 {
331 stop = TRUE;
332
333 if(!(device = COMM_ParseStopBits(device + 5, &lpdcb->StopBits)))
334 return FALSE;
335 }
336 else if(!strncmpiW(toW, device, 3))
337 {
338 if(!(device = COMM_ParseOnOff(device + 3, &temp)))
339 return FALSE;
340
341 lptimeouts->ReadIntervalTimeout = 0;
342 lptimeouts->ReadTotalTimeoutMultiplier = 0;
343 lptimeouts->ReadTotalTimeoutConstant = 0;
344 lptimeouts->WriteTotalTimeoutMultiplier = 0;
345 lptimeouts->WriteTotalTimeoutConstant = temp ? 60000 : 0;
346 }
347 else if(!strncmpiW(xonW, device, 4))
348 {
349 if(!(device = COMM_ParseOnOff(device + 4, &temp)))
350 return FALSE;
351
352 lpdcb->fOutX = temp;
353 lpdcb->fInX = temp;
354 }
355 else if(!strncmpiW(odsrW, device, 5))
356 {
357 if(!(device = COMM_ParseOnOff(device + 5, &temp)))
358 return FALSE;
359
360 lpdcb->fOutxDsrFlow = temp;
361 }
362 else if(!strncmpiW(octsW, device, 5))
363 {
364 if(!(device = COMM_ParseOnOff(device + 5, &temp)))
365 return FALSE;
366
367 lpdcb->fOutxCtsFlow = temp;
368 }
369 else if(!strncmpiW(dtrW, device, 4))
370 {
371 if(!(device = COMM_ParseOnOff(device + 4, &temp)))
372 return FALSE;
373
374 lpdcb->fDtrControl = temp;
375 }
376 else if(!strncmpiW(rtsW, device, 4))
377 {
378 if(!(device = COMM_ParseOnOff(device + 4, &temp)))
379 return FALSE;
380
381 lpdcb->fRtsControl = temp;
382 }
383 else if(!strncmpiW(idsrW, device, 5))
384 {
385 if(!(device = COMM_ParseOnOff(device + 5, &temp)))
386 return FALSE;
387
388 /* Win NT sets the fDsrSensitivity member based on the
389 idsr parameter. Win 9x sets fOutxDsrFlow instead. */
390 lpdcb->fDsrSensitivity = temp;
391 }
392 else
393 return FALSE;
394
395 /* After the above parsing, the next character (if not the end of
396 the string) should be a space */
397 if(*device && *device != ' ')
398 return FALSE;
399 }
400
401 /* If stop bits were not specified, a default is always supplied. */
402 if(!stop)
403 {
404 if(baud && lpdcb->BaudRate == 110)
405 lpdcb->StopBits = TWOSTOPBITS;
406 else
407 lpdcb->StopBits = ONESTOPBIT;
408 }
409
410 return TRUE;
411 }
412
413 /**************************************************************************
414 * BuildCommDCBA (KERNEL32.@)
415 *
416 * Updates a device control block data structure with values from an
417 * ascii device control string. The device control string has two forms
418 * normal and extended, it must be exclusively in one or the other form.
419 *
420 * RETURNS
421 *
422 * True on success, false on a malformed control string.
423 */
424 BOOL WINAPI BuildCommDCBA(
425 LPCSTR device, /* [in] The ascii device control string used to update the DCB. */
426 LPDCB lpdcb) /* [out] The device control block to be updated. */
427 {
428 return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
429 }
430
431 /**************************************************************************
432 * BuildCommDCBAndTimeoutsA (KERNEL32.@)
433 *
434 * Updates a device control block data structure with values from an
435 * ascii device control string. Taking timeout values from a timeouts
436 * struct if desired by the control string.
437 *
438 * RETURNS
439 *
440 * True on success, false bad handles etc.
441 */
442 BOOL WINAPI BuildCommDCBAndTimeoutsA(
443 LPCSTR device, /* [in] The ascii device control string. */
444 LPDCB lpdcb, /* [out] The device control block to be updated. */
445 LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
446 {
447 BOOL ret = FALSE;
448 UNICODE_STRING deviceW;
449
450 TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
451 if(device) RtlCreateUnicodeStringFromAsciiz(&deviceW,device);
452 else deviceW.Buffer = NULL;
453
454 if(deviceW.Buffer) ret = BuildCommDCBAndTimeoutsW(deviceW.Buffer,lpdcb,lptimeouts);
455
456 RtlFreeUnicodeString(&deviceW);
457 return ret;
458 }
459
460 /**************************************************************************
461 * BuildCommDCBAndTimeoutsW (KERNEL32.@)
462 *
463 * Updates a device control block data structure with values from a
464 * unicode device control string. Taking timeout values from a timeouts
465 * struct if desired by the control string.
466 *
467 * RETURNS
468 *
469 * True on success, false bad handles etc
470 */
471 BOOL WINAPI BuildCommDCBAndTimeoutsW(
472 LPCWSTR devid, /* [in] The unicode device control string. */
473 LPDCB lpdcb, /* [out] The device control block to be updated. */
474 LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
475 {
476 DCB dcb;
477 COMMTIMEOUTS timeouts;
478 BOOL result;
479 LPCWSTR ptr = devid;
480
481 TRACE("(%s,%p,%p)\n",debugstr_w(devid),lpdcb,lptimeouts);
482
483 memset(&timeouts, 0, sizeof timeouts);
484
485 /* Set DCBlength. (Windows NT does not do this, but 9x does) */
486 lpdcb->DCBlength = sizeof(DCB);
487
488 /* Make a copy of the original data structures to work with since if
489 if there is an error in the device control string the originals
490 should not be modified (except possibly DCBlength) */
491 dcb = *lpdcb;
492 if(lptimeouts) timeouts = *lptimeouts;
493
494 ptr = COMM_ParseStart(ptr);
495
496 if(ptr == NULL)
497 result = FALSE;
498 else if(strchrW(ptr, ','))
499 result = COMM_BuildOldCommDCB(ptr, &dcb);
500 else
501 result = COMM_BuildNewCommDCB(ptr, &dcb, &timeouts);
502
503 if(result)
504 {
505 *lpdcb = dcb;
506 if(lptimeouts) *lptimeouts = timeouts;
507 return TRUE;
508 }
509 else
510 {
511 WARN("Invalid device control string: %s\n", debugstr_w(devid));
512 SetLastError(ERROR_INVALID_PARAMETER);
513 return FALSE;
514 }
515 }
516
517 /**************************************************************************
518 * BuildCommDCBW (KERNEL32.@)
519 *
520 * Updates a device control block structure with values from an
521 * unicode device control string. The device control string has two forms
522 * normal and extended, it must be exclusively in one or the other form.
523 *
524 * RETURNS
525 *
526 * True on success, false on a malformed control string.
527 */
528 BOOL WINAPI BuildCommDCBW(
529 LPCWSTR devid, /* [in] The unicode device control string. */
530 LPDCB lpdcb) /* [out] The device control block to be updated. */
531 {
532 return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
533 }
534
535 /*****************************************************************************
536 * SetCommBreak (KERNEL32.@)
537 *
538 * Halts the transmission of characters to a communications device.
539 *
540 * PARAMS
541 * handle [in] The communications device to suspend
542 *
543 * RETURNS
544 *
545 * True on success, and false if the communications device could not be found,
546 * the control is not supported.
547 *
548 * BUGS
549 *
550 * Only TIOCSBRK and TIOCCBRK are supported.
551 */
552 BOOL WINAPI SetCommBreak(HANDLE handle)
553 {
554 return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_ON, NULL, 0, NULL, 0, NULL, NULL);
555 }
556
557 /*****************************************************************************
558 * ClearCommBreak (KERNEL32.@)
559 *
560 * Resumes character transmission from a communication device.
561 *
562 * PARAMS
563 *
564 * handle [in] The halted communication device whose character transmission is to be resumed
565 *
566 * RETURNS
567 *
568 * True on success and false if the communications device could not be found.
569 *
570 * BUGS
571 *
572 * Only TIOCSBRK and TIOCCBRK are supported.
573 */
574 BOOL WINAPI ClearCommBreak(HANDLE handle)
575 {
576 return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_OFF, NULL, 0, NULL, 0, NULL, NULL);
577 }
578
579 /*****************************************************************************
580 * EscapeCommFunction (KERNEL32.@)
581 *
582 * Directs a communication device to perform an extended function.
583 *
584 * PARAMS
585 *
586 * handle [in] The communication device to perform the extended function
587 * nFunction [in] The extended function to be performed
588 *
589 * RETURNS
590 *
591 * True or requested data on successful completion of the command,
592 * false if the device is not present cannot execute the command
593 * or the command failed.
594 */
595 BOOL WINAPI EscapeCommFunction(HANDLE handle, UINT func)
596 {
597 DWORD ioc;
598
599 switch (func)
600 {
601 case CLRDTR: ioc = IOCTL_SERIAL_CLR_DTR; break;
602 case CLRRTS: ioc = IOCTL_SERIAL_CLR_RTS; break;
603 case SETDTR: ioc = IOCTL_SERIAL_SET_DTR; break;
604 case SETRTS: ioc = IOCTL_SERIAL_SET_RTS; break;
605 case SETXOFF: ioc = IOCTL_SERIAL_SET_XOFF; break;
606 case SETXON: ioc = IOCTL_SERIAL_SET_XON; break;
607 case SETBREAK: ioc = IOCTL_SERIAL_SET_BREAK_ON; break;
608 case CLRBREAK: ioc = IOCTL_SERIAL_SET_BREAK_OFF; break;
609 case RESETDEV: ioc = IOCTL_SERIAL_RESET_DEVICE; break;
610 default:
611 ERR("Unknown function code (%u)\n", func);
612 SetLastError(ERROR_INVALID_PARAMETER);
613 return FALSE;
614 }
615 return DeviceIoControl(handle, ioc, NULL, 0, NULL, 0, NULL, NULL);
616 }
617
618 /********************************************************************
619 * PurgeComm (KERNEL32.@)
620 *
621 * Terminates pending operations and/or discards buffers on a
622 * communication resource.
623 *
624 * PARAMS
625 *
626 * handle [in] The communication resource to be purged
627 * flags [in] Flags for clear pending/buffer on input/output
628 *
629 * RETURNS
630 *
631 * True on success and false if the communications handle is bad.
632 */
633 BOOL WINAPI PurgeComm(HANDLE handle, DWORD flags)
634 {
635 return DeviceIoControl(handle, IOCTL_SERIAL_PURGE, &flags, sizeof(flags),
636 NULL, 0, NULL, NULL);
637 }
638
639 /*****************************************************************************
640 * ClearCommError (KERNEL32.@)
641 *
642 * Enables further I/O operations on a communications resource after
643 * supplying error and current status information.
644 *
645 * PARAMS
646 *
647 * handle [in] The communication resource with the error
648 * errors [out] Flags indicating error the resource experienced
649 * lpStat [out] The status of the communication resource
650 * RETURNS
651 *
652 * True on success, false if the communication resource handle is bad.
653 */
654 BOOL WINAPI ClearCommError(HANDLE handle, LPDWORD errors, LPCOMSTAT lpStat)
655 {
656 SERIAL_STATUS ss;
657
658 if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_COMMSTATUS, NULL, 0,
659 &ss, sizeof(ss), NULL, NULL))
660 return FALSE;
661
662 if (errors)
663 {
664 *errors = 0;
665 if (ss.Errors & SERIAL_ERROR_BREAK) *errors |= CE_BREAK;
666 if (ss.Errors & SERIAL_ERROR_FRAMING) *errors |= CE_FRAME;
667 if (ss.Errors & SERIAL_ERROR_OVERRUN) *errors |= CE_OVERRUN;
668 if (ss.Errors & SERIAL_ERROR_QUEUEOVERRUN) *errors |= CE_RXOVER;
669 if (ss.Errors & SERIAL_ERROR_PARITY) *errors |= CE_RXPARITY;
670 }
671
672 if (lpStat)
673 {
674 memset(lpStat, 0, sizeof(*lpStat));
675
676 if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_CTS) lpStat->fCtsHold = TRUE;
677 if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DSR) lpStat->fDsrHold = TRUE;
678 if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DCD) lpStat->fRlsdHold = TRUE;
679 if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_XON) lpStat->fXoffHold = TRUE;
680 if (ss.HoldReasons & SERIAL_TX_WAITING_XOFF_SENT) lpStat->fXoffSent = TRUE;
681 if (ss.EofReceived) lpStat->fEof = TRUE;
682 if (ss.WaitForImmediate) lpStat->fTxim = TRUE;
683 lpStat->cbInQue = ss.AmountInInQueue;
684 lpStat->cbOutQue = ss.AmountInOutQueue;
685 }
686 return TRUE;
687 }
688
689 /*****************************************************************************
690 * SetupComm (KERNEL32.@)
691 *
692 * Called after CreateFile to hint to the communication resource to use
693 * specified sizes for input and output buffers rather than the default values.
694 *
695 * PARAMS
696 * handle [in] The just created communication resource handle
697 * insize [in] The suggested size of the communication resources input buffer in bytes
698 * outsize [in] The suggested size of the communication resources output buffer in bytes
699 *
700 * RETURNS
701 *
702 * True if successful, false if the communications resource handle is bad.
703 *
704 * BUGS
705 *
706 * Stub.
707 */
708 BOOL WINAPI SetupComm(HANDLE handle, DWORD insize, DWORD outsize)
709 {
710 SERIAL_QUEUE_SIZE sqs;
711
712 sqs.InSize = insize;
713 sqs.OutSize = outsize;
714 return DeviceIoControl(handle, IOCTL_SERIAL_SET_QUEUE_SIZE,
715 &sqs, sizeof(sqs), NULL, 0, NULL, NULL);
716 }
717
718 /*****************************************************************************
719 * GetCommMask (KERNEL32.@)
720 *
721 * Obtain the events associated with a communication device that will cause
722 * a call WaitCommEvent to return.
723 *
724 * PARAMS
725 *
726 * handle [in] The communications device
727 * evtmask [out] The events which cause WaitCommEvent to return
728 *
729 * RETURNS
730 *
731 * True on success, fail on bad device handle etc.
732 */
733 BOOL WINAPI GetCommMask(HANDLE handle, LPDWORD evtmask)
734 {
735 TRACE("handle %p, mask %p\n", handle, evtmask);
736 return DeviceIoControl(handle, IOCTL_SERIAL_GET_WAIT_MASK,
737 NULL, 0, evtmask, sizeof(*evtmask), NULL, NULL);
738 }
739
740 /*****************************************************************************
741 * SetCommMask (KERNEL32.@)
742 *
743 * There be some things we need to hear about yon there communications device.
744 * (Set which events associated with a communication device should cause
745 * a call WaitCommEvent to return.)
746 *
747 * PARAMS
748 *
749 * handle [in] The communications device
750 * evtmask [in] The events that are to be monitored
751 *
752 * RETURNS
753 *
754 * True on success, false on bad handle etc.
755 */
756 BOOL WINAPI SetCommMask(HANDLE handle, DWORD evtmask)
757 {
758 TRACE("handle %p, mask %x\n", handle, evtmask);
759 return DeviceIoControl(handle, IOCTL_SERIAL_SET_WAIT_MASK,
760 &evtmask, sizeof(evtmask), NULL, 0, NULL, NULL);
761 }
762
763 static void dump_dcb(const DCB* lpdcb)
764 {
765 TRACE("bytesize=%d baudrate=%d fParity=%d Parity=%d stopbits=%d\n",
766 lpdcb->ByteSize, lpdcb->BaudRate, lpdcb->fParity, lpdcb->Parity,
767 (lpdcb->StopBits == ONESTOPBIT) ? 1 :
768 (lpdcb->StopBits == TWOSTOPBITS) ? 2 : 0);
769 TRACE("%sIXON %sIXOFF\n", (lpdcb->fInX) ? "" : "~", (lpdcb->fOutX) ? "" : "~");
770 TRACE("fOutxCtsFlow=%d fRtsControl=%d\n", lpdcb->fOutxCtsFlow, lpdcb->fRtsControl);
771 TRACE("fOutxDsrFlow=%d fDtrControl=%d\n", lpdcb->fOutxDsrFlow, lpdcb->fDtrControl);
772 if (lpdcb->fOutxCtsFlow || lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE)
773 TRACE("CRTSCTS\n");
774 else
775 TRACE("~CRTSCTS\n");
776 }
777
778 /*****************************************************************************
779 * SetCommState (KERNEL32.@)
780 *
781 * Re-initializes all hardware and control settings of a communications device,
782 * with values from a device control block without affecting the input and output
783 * queues.
784 *
785 * PARAMS
786 *
787 * handle [in] The communications device
788 * lpdcb [out] The device control block
789 *
790 * RETURNS
791 *
792 * True on success, false on failure, e.g., if the XonChar is equal to the XoffChar.
793 */
794 BOOL WINAPI SetCommState( HANDLE handle, LPDCB lpdcb)
795 {
796 SERIAL_BAUD_RATE sbr;
797 SERIAL_LINE_CONTROL slc;
798 SERIAL_HANDFLOW shf;
799 SERIAL_CHARS sc;
800
801 if (lpdcb == NULL)
802 {
803 SetLastError(ERROR_INVALID_PARAMETER);
804 return FALSE;
805 }
806 dump_dcb(lpdcb);
807
808 sbr.BaudRate = lpdcb->BaudRate;
809
810 slc.StopBits = lpdcb->StopBits;
811 slc.Parity = lpdcb->Parity;
812 slc.WordLength = lpdcb->ByteSize;
813
814 shf.ControlHandShake = 0;
815 shf.FlowReplace = 0;
816 if (lpdcb->fOutxCtsFlow) shf.ControlHandShake |= SERIAL_CTS_HANDSHAKE;
817 if (lpdcb->fOutxDsrFlow) shf.ControlHandShake |= SERIAL_DSR_HANDSHAKE;
818 switch (lpdcb->fDtrControl)
819 {
820 case DTR_CONTROL_DISABLE: break;
821 case DTR_CONTROL_ENABLE: shf.ControlHandShake |= SERIAL_DTR_CONTROL; break;
822 case DTR_CONTROL_HANDSHAKE: shf.ControlHandShake |= SERIAL_DTR_HANDSHAKE;break;
823 default:
824 SetLastError(ERROR_INVALID_PARAMETER);
825 return FALSE;
826 }
827 switch (lpdcb->fDtrControl)
828 {
829 case RTS_CONTROL_DISABLE: break;
830 case RTS_CONTROL_ENABLE: shf.FlowReplace |= SERIAL_RTS_CONTROL; break;
831 case RTS_CONTROL_HANDSHAKE: shf.FlowReplace |= SERIAL_RTS_HANDSHAKE; break;
832 case RTS_CONTROL_TOGGLE: shf.FlowReplace |= SERIAL_RTS_CONTROL |
833 SERIAL_RTS_HANDSHAKE; break;
834 default:
835 SetLastError(ERROR_INVALID_PARAMETER);
836 return FALSE;
837 }
838 if (lpdcb->fDsrSensitivity) shf.ControlHandShake |= SERIAL_DSR_SENSITIVITY;
839 if (lpdcb->fAbortOnError) shf.ControlHandShake |= SERIAL_ERROR_ABORT;
840
841 if (lpdcb->fErrorChar) shf.FlowReplace |= SERIAL_ERROR_CHAR;
842 if (lpdcb->fNull) shf.FlowReplace |= SERIAL_NULL_STRIPPING;
843 if (lpdcb->fTXContinueOnXoff) shf.FlowReplace |= SERIAL_XOFF_CONTINUE;
844 if (lpdcb->fOutX) shf.FlowReplace |= SERIAL_AUTO_TRANSMIT;
845 if (lpdcb->fInX) shf.FlowReplace |= SERIAL_AUTO_RECEIVE;
846
847 shf.XonLimit = lpdcb->XonLim;
848 shf.XoffLimit = lpdcb->XoffLim;
849
850 sc.EofChar = lpdcb->EofChar;
851 sc.ErrorChar = lpdcb->ErrorChar;
852 sc.BreakChar = 0;
853 sc.EventChar = lpdcb->EvtChar;
854 sc.XonChar = lpdcb->XonChar;
855 sc.XoffChar = lpdcb->XoffChar;
856
857 /* note: change DTR/RTS lines after setting the comm attributes,
858 * so flow control does not interfere.
859 */
860 return (DeviceIoControl(handle, IOCTL_SERIAL_SET_BAUD_RATE,
861 &sbr, sizeof(sbr), NULL, 0, NULL, NULL) &&
862 DeviceIoControl(handle, IOCTL_SERIAL_SET_LINE_CONTROL,
863 &slc, sizeof(slc), NULL, 0, NULL, NULL) &&
864 DeviceIoControl(handle, IOCTL_SERIAL_SET_HANDFLOW,
865 &shf, sizeof(shf), NULL, 0, NULL, NULL) &&
866 DeviceIoControl(handle, IOCTL_SERIAL_SET_CHARS,
867 &sc, sizeof(sc), NULL, 0, NULL, NULL));
868 }
869
870
871 /*****************************************************************************
872 * GetCommState (KERNEL32.@)
873 *
874 * Fills in a device control block with information from a communications device.
875 *
876 * PARAMS
877 * handle [in] The communications device
878 * lpdcb [out] The device control block
879 *
880 * RETURNS
881 *
882 * True on success, false if the communication device handle is bad etc
883 *
884 * BUGS
885 *
886 * XonChar and XoffChar are not set.
887 */
888 BOOL WINAPI GetCommState(HANDLE handle, LPDCB lpdcb)
889 {
890 SERIAL_BAUD_RATE sbr;
891 SERIAL_LINE_CONTROL slc;
892 SERIAL_HANDFLOW shf;
893 SERIAL_CHARS sc;
894
895 TRACE("handle %p, ptr %p\n", handle, lpdcb);
896
897 if (!lpdcb)
898 {
899 SetLastError(ERROR_INVALID_PARAMETER);
900 return FALSE;
901 }
902
903 if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_BAUD_RATE,
904 NULL, 0, &sbr, sizeof(sbr), NULL, NULL) ||
905 !DeviceIoControl(handle, IOCTL_SERIAL_GET_LINE_CONTROL,
906 NULL, 0, &slc, sizeof(slc), NULL, NULL) ||
907 !DeviceIoControl(handle, IOCTL_SERIAL_GET_HANDFLOW,
908 NULL, 0, &shf, sizeof(shf), NULL, NULL) ||
909 !DeviceIoControl(handle, IOCTL_SERIAL_GET_CHARS,
910 NULL, 0, &sc, sizeof(sc), NULL, NULL))
911 return FALSE;
912
913 memset(lpdcb, 0, sizeof(*lpdcb));
914 lpdcb->DCBlength = sizeof(*lpdcb);
915
916 /* yes, they seem no never be (re)set on NT */
917 lpdcb->fBinary = 1;
918 lpdcb->fParity = 0;
919
920 lpdcb->BaudRate = sbr.BaudRate;
921
922 lpdcb->StopBits = slc.StopBits;
923 lpdcb->Parity = slc.Parity;
924 lpdcb->ByteSize = slc.WordLength;
925
926 if (shf.ControlHandShake & SERIAL_CTS_HANDSHAKE) lpdcb->fOutxCtsFlow = 1;
927 if (shf.ControlHandShake & SERIAL_DSR_HANDSHAKE) lpdcb->fOutxDsrFlow = 1;
928 switch (shf.ControlHandShake & (SERIAL_DTR_CONTROL | SERIAL_DTR_HANDSHAKE))
929 {
930 case 0: lpdcb->fDtrControl = DTR_CONTROL_DISABLE; break;
931 case SERIAL_DTR_CONTROL: lpdcb->fDtrControl = DTR_CONTROL_ENABLE; break;
932 case SERIAL_DTR_HANDSHAKE: lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE; break;
933 }
934 switch (shf.FlowReplace & (SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE))
935 {
936 case 0: lpdcb->fRtsControl = RTS_CONTROL_DISABLE; break;
937 case SERIAL_RTS_CONTROL: lpdcb->fRtsControl = RTS_CONTROL_ENABLE; break;
938 case SERIAL_RTS_HANDSHAKE: lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE; break;
939 case SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE:
940 lpdcb->fRtsControl = RTS_CONTROL_TOGGLE; break;
941 }
942 if (shf.ControlHandShake & SERIAL_DSR_SENSITIVITY) lpdcb->fDsrSensitivity = 1;
943 if (shf.ControlHandShake & SERIAL_ERROR_ABORT) lpdcb->fAbortOnError = 1;
944 if (shf.FlowReplace & SERIAL_ERROR_CHAR) lpdcb->fErrorChar = 1;
945 if (shf.FlowReplace & SERIAL_NULL_STRIPPING) lpdcb->fNull = 1;
946 if (shf.FlowReplace & SERIAL_XOFF_CONTINUE) lpdcb->fTXContinueOnXoff = 1;
947 lpdcb->XonLim = shf.XonLimit;
948 lpdcb->XoffLim = shf.XoffLimit;
949
950 if (shf.FlowReplace & SERIAL_AUTO_TRANSMIT) lpdcb->fOutX = 1;
951 if (shf.FlowReplace & SERIAL_AUTO_RECEIVE) lpdcb->fInX = 1;
952
953 lpdcb->EofChar = sc.EofChar;
954 lpdcb->ErrorChar = sc.ErrorChar;
955 lpdcb->EvtChar = sc.EventChar;
956 lpdcb->XonChar = sc.XonChar;
957 lpdcb->XoffChar = sc.XoffChar;
958
959 TRACE("OK\n");
960 dump_dcb(lpdcb);
961
962 return TRUE;
963 }
964
965 /*****************************************************************************
966 * TransmitCommChar (KERNEL32.@)
967 *
968 * Transmits a single character in front of any pending characters in the
969 * output buffer. Usually used to send an interrupt character to a host.
970 *
971 * PARAMS
972 * hComm [in] The communication device in need of a command character
973 * chTransmit [in] The character to transmit
974 *
975 * RETURNS
976 *
977 * True if the call succeeded, false if the previous command character to the
978 * same device has not been sent yet the handle is bad etc.
979 *
980 */
981 BOOL WINAPI TransmitCommChar(HANDLE hComm, CHAR chTransmit)
982 {
983 return DeviceIoControl(hComm, IOCTL_SERIAL_IM