?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Stub implementation for ReadDirectoryChangesW.
[wine/dcerpc.git] / dlls / kernel / comm.c
blob9c5dd6d2fe0585c527cfc0004524cbc7ad613365
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * History:
21 *
22 * Apr 3, 1999. Lawson Whitney <lawson_whitney@juno.com>
23 * - Fixed the modem control part of EscapeCommFunction16.
24 *
25 * Mar 31, 1999. Ove Kåven <ovek@arcticnet.no>
26 * - Implemented buffers and EnableCommNotification.
27 *
28 * Mar 3, 1999. Ove Kåven <ovek@arcticnet.no>
29 * - Use port indices instead of unixfds for win16
30 * - Moved things around (separated win16 and win32 routines)
31 * - Added some hints on how to implement buffers and EnableCommNotification.
32 *
33 * Oktober 98, Rein Klazes [RHK]
34 * A program that wants to monitor the modem status line (RLSD/DCD) may
35 * poll the modem status register in the commMask structure. I update the bit
36 * in GetCommError, waiting for an implementation of communication events.
37 *
38 * July 6, 1998. Fixes and comments by Valentijn Sessink
39 * <vsessink@ic.uva.nl> [V]
40 *
41 * August 12, 1997. Take a bash at SetCommEventMask - Lawson Whitney
42 * <lawson_whitney@juno.com>
43 *
44 * May 26, 1997. Fixes and comments by Rick Richardson <rick@dgii.com> [RER]
45 * - ptr->fd wasn't getting cleared on close.
46 * - GetCommEventMask() and GetCommError() didn't do much of anything.
47 * IMHO, they are still wrong, but they at least implement the RXCHAR
48 * event and return I/O queue sizes, which makes the app I'm interested
49 * in (analog devices EZKIT DSP development system) work.
50 */
51
52 #include "config.h"
53 #include "wine/port.h"
54
55 #include <stdlib.h>
56 #include <stdarg.h>
57 #include <stdio.h>
58 #ifdef HAVE_TERMIOS_H
59 #include <termios.h>
60 #endif
61 #include <fcntl.h>
62 #include <string.h>
63 #ifdef HAVE_STRINGS_H
64 # include <strings.h>
65 #endif
66 #include <errno.h>
67 #include <ctype.h>
68 #include <sys/stat.h>
69 #ifdef HAVE_SYS_FILIO_H
70 # include <sys/filio.h>
71 #endif
72 #ifdef HAVE_SYS_IOCTL_H
73 #include <sys/ioctl.h>
74 #endif
75 #ifdef HAVE_UNISTD_H
76 # include <unistd.h>
77 #endif
78 #ifdef HAVE_SYS_POLL_H
79 # include <sys/poll.h>
80 #endif
81 #ifdef HAVE_SYS_MODEM_H
82 # include <sys/modem.h>
83 #endif
84 #ifdef HAVE_SYS_STRTIO_H
85 # include <sys/strtio.h>
86 #endif
87
88 #define NONAMELESSUNION
89 #define NONAMELESSSTRUCT
90 #include "ntstatus.h"
91 #include "windef.h"
92 #include "winbase.h"
93 #include "winerror.h"
94
95 #include "wine/server.h"
96 #include "wine/unicode.h"
97 #include "thread.h"
98
99 #include "wine/debug.h"
100
101 #ifdef HAVE_LINUX_SERIAL_H
102 #include <linux/serial.h>
103 #endif
104
105 WINE_DEFAULT_DEBUG_CHANNEL(comm);
106
107 /* retrieve the Unix handle corresponding to a comm handle */
108 static int get_comm_fd( HANDLE handle, DWORD access )
109 {
110 int fd, ret;
111
112 ret = wine_server_handle_to_fd( handle, access, &fd, NULL );
113 if (ret) SetLastError( RtlNtStatusToDosError(ret) );
114 return fd;
115 }
116
117 /* release the Unix handle returned by get_comm_fd */
118 static inline void release_comm_fd( HANDLE handle, int fd )
119 {
120 wine_server_release_fd( handle, fd );
121 }
122
123
124 /***********************************************************************
125 * Asynchronous I/O for asynchronous wait requests *
126 */
127
128 typedef struct async_commio
129 {
130 HANDLE handle;
131 PIO_APC_ROUTINE apc_internal;
132 int type;
133 char* buffer;
134 int fd;
135 } async_commio;
136
137 /***********************************************************************/
138
139 #if !defined(TIOCINQ) && defined(FIONREAD)
140 #define TIOCINQ FIONREAD
141 #endif
142
143 static int COMM_WhackModem(int fd, unsigned int andy, unsigned int orrie)
144 {
145 #ifdef TIOCMGET
146 unsigned int mstat, okay;
147 okay = ioctl(fd, TIOCMGET, &mstat);
148 if (okay) return okay;
149 if (andy) mstat &= andy;
150 mstat |= orrie;
151 return ioctl(fd, TIOCMSET, &mstat);
152 #else
153 return 0;
154 #endif
155 }
156
157 /***********************************************************************
158 * COMM_Parse* (Internal)
159 *
160 * The following COMM_Parse* functions are used by the BuildCommDCB
161 * functions to help parse the various parts of the device control string.
162 */
163 static LPCWSTR COMM_ParseStart(LPCWSTR ptr)
164 {
165 static const WCHAR comW[] = {'C','O','M',0};
166
167 /* The device control string may optionally start with "COMx" followed
168 by an optional ':' and spaces. */
169 if(!strncmpiW(ptr, comW, 3))
170 {
171 ptr += 3;
172
173 /* Allow any com port above 0 as Win 9x does (NT only allows
174 values for com ports which are actually present) */
175 if(*ptr < '1' || *ptr > '9')
176 return NULL;
177
178 /* Advance pointer past port number */
179 while(*ptr >= '0' && *ptr <= '9') ptr++;
180
181 /* The com port number must be followed by a ':' or ' ' */
182 if(*ptr != ':' && *ptr != ' ')
183 return NULL;
184
185 /* Advance pointer to beginning of next parameter */
186 while(*ptr == ' ') ptr++;
187 if(*ptr == ':')
188 {
189 ptr++;
190 while(*ptr == ' ') ptr++;
191 }
192 }
193 /* The device control string must not start with a space. */
194 else if(*ptr == ' ')
195 return NULL;
196
197 return ptr;
198 }
199
200 static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
201 {
202 if(*ptr < '0' || *ptr > '9') return NULL;
203 *lpnumber = strtoulW(ptr, NULL, 10);
204 while(*ptr >= '0' && *ptr <= '9') ptr++;
205 return ptr;
206 }
207
208 static LPCWSTR COMM_ParseParity(LPCWSTR ptr, LPBYTE lpparity)
209 {
210 /* Contrary to what you might expect, Windows only sets the Parity
211 member of DCB and not fParity even when parity is specified in the
212 device control string */
213
214 switch(toupperW(*ptr++))
215 {
216 case 'E':
217 *lpparity = EVENPARITY;
218 break;
219 case 'M':
220 *lpparity = MARKPARITY;
221 break;
222 case 'N':
223 *lpparity = NOPARITY;
224 break;
225 case 'O':
226 *lpparity = ODDPARITY;
227 break;
228 case 'S':
229 *lpparity = SPACEPARITY;
230 break;
231 default:
232 return NULL;
233 }
234
235 return ptr;
236 }
237
238 static LPCWSTR COMM_ParseByteSize(LPCWSTR ptr, LPBYTE lpbytesize)
239 {
240 DWORD temp;
241
242 if(!(ptr = COMM_ParseNumber(ptr, &temp)))
243 return NULL;
244
245 if(temp >= 5 && temp <= 8)
246 {
247 *lpbytesize = temp;
248 return ptr;
249 }
250 else
251 return NULL;
252 }
253
254 static LPCWSTR COMM_ParseStopBits(LPCWSTR ptr, LPBYTE lpstopbits)
255 {
256 DWORD temp;
257 static const WCHAR stopbits15W[] = {'1','.','5',0};
258
259 if(!strncmpW(stopbits15W, ptr, 3))
260 {
261 ptr += 3;
262 *lpstopbits = ONE5STOPBITS;
263 }
264 else
265 {
266 if(!(ptr = COMM_ParseNumber(ptr, &temp)))
267 return NULL;
268
269 if(temp == 1)
270 *lpstopbits = ONESTOPBIT;
271 else if(temp == 2)
272 *lpstopbits = TWOSTOPBITS;
273 else
274 return NULL;
275 }
276
277 return ptr;
278 }
279
280 static LPCWSTR COMM_ParseOnOff(LPCWSTR ptr, LPDWORD lponoff)
281 {
282 static const WCHAR onW[] = {'o','n',0};
283 static const WCHAR offW[] = {'o','f','f',0};
284
285 if(!strncmpiW(onW, ptr, 2))
286 {
287 ptr += 2;
288 *lponoff = 1;
289 }
290 else if(!strncmpiW(offW, ptr, 3))
291 {
292 ptr += 3;
293 *lponoff = 0;
294 }
295 else
296 return NULL;
297
298 return ptr;
299 }
300
301 /***********************************************************************
302 * COMM_BuildOldCommDCB (Internal)
303 *
304 * Build a DCB using the old style settings string eg: "96,n,8,1"
305 */
306 static BOOL COMM_BuildOldCommDCB(LPCWSTR device, LPDCB lpdcb)
307 {
308 WCHAR last = 0;
309
310 if(!(device = COMM_ParseNumber(device, &lpdcb->BaudRate)))
311 return FALSE;
312
313 switch(lpdcb->BaudRate)
314 {
315 case 11:
316 case 30:
317 case 60:
318 lpdcb->BaudRate *= 10;
319 break;
320 case 12:
321 case 24:
322 case 48:
323 case 96:
324 lpdcb->BaudRate *= 100;
325 break;
326 case 19:
327 lpdcb->BaudRate = 19200;
328 break;
329 }
330
331 while(*device == ' ') device++;
332 if(*device++ != ',') return FALSE;
333 while(*device == ' ') device++;
334
335 if(!(device = COMM_ParseParity(device, &lpdcb->Parity)))
336 return FALSE;
337
338 while(*device == ' ') device++;
339 if(*device++ != ',') return FALSE;
340 while(*device == ' ') device++;
341
342 if(!(device = COMM_ParseByteSize(device, &lpdcb->ByteSize)))
343 return FALSE;
344
345 while(*device == ' ') device++;
346 if(*device++ != ',') return FALSE;
347 while(*device == ' ') device++;
348
349 if(!(device = COMM_ParseStopBits(device, &lpdcb->StopBits)))
350 return FALSE;
351
352 /* The last parameter for flow control is optional. */
353 while(*device == ' ') device++;
354 if(*device == ',')
355 {
356 device++;
357 while(*device == ' ') device++;
358 if(*device) last = toupperW(*device++);
359 while(*device == ' ') device++;
360 }
361
362 /* Win NT sets the flow control members based on (or lack of) the last
363 parameter. Win 9x does not set these members. */
364 switch(last)
365 {
366 case 0:
367 lpdcb->fInX = FALSE;
368 lpdcb->fOutX = FALSE;
369 lpdcb->fOutxCtsFlow = FALSE;
370 lpdcb->fOutxDsrFlow = FALSE;
371 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
372 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
373 break;
374 case 'X':
375 lpdcb->fInX = TRUE;
376 lpdcb->fOutX = TRUE;
377 lpdcb->fOutxCtsFlow = FALSE;
378 lpdcb->fOutxDsrFlow = FALSE;
379 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
380 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
381 break;
382 case 'P':
383 lpdcb->fInX = FALSE;
384 lpdcb->fOutX = FALSE;
385 lpdcb->fOutxCtsFlow = TRUE;
386 lpdcb->fOutxDsrFlow = TRUE;
387 lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE;
388 lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
389 break;
390 default:
391 return FALSE;
392 }
393
394 /* This should be the end of the string. */
395 if(*device) return FALSE;
396
397 return TRUE;
398 }
399
400 /***********************************************************************
401 * COMM_BuildNewCommDCB (Internal)
402 *
403 * Build a DCB using the new style settings string.
404 * eg: "baud=9600 parity=n data=8 stop=1 xon=on to=on"
405 */
406 static BOOL COMM_BuildNewCommDCB(LPCWSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
407 {
408 DWORD temp;
409 BOOL baud = FALSE, stop = FALSE;
410 static const WCHAR baudW[] = {'b','a','u','d','=',0};
411 static const WCHAR parityW[] = {'p','a','r','i','t','y','=',0};
412 static const WCHAR dataW[] = {'d','a','t','a','=',0};
413 static const WCHAR stopW[] = {'s','t','o','p','=',0};
414 static const WCHAR toW[] = {'t','o','=',0};
415 static const WCHAR xonW[] = {'x','o','n','=',0};
416 static const WCHAR odsrW[] = {'o','d','s','r','=',0};
417 static const WCHAR octsW[] = {'o','c','t','s','=',0};
418 static const WCHAR dtrW[] = {'d','t','r','=',0};
419 static const WCHAR rtsW[] = {'r','t','s','=',0};
420 static const WCHAR idsrW[] = {'i','d','s','r','=',0};
421
422 while(*device)
423 {
424 while(*device == ' ') device++;
425
426 if(!strncmpiW(baudW, device, 5))
427 {
428 baud = TRUE;
429
430 if(!(device = COMM_ParseNumber(device + 5, &lpdcb->BaudRate)))
431 return FALSE;
432 }
433 else if(!strncmpiW(parityW, device, 7))
434 {
435 if(!(device = COMM_ParseParity(device + 7, &lpdcb->Parity)))
436 return FALSE;
437 }
438 else if(!strncmpiW(dataW, device, 5))
439 {
440 if(!(device = COMM_ParseByteSize(device + 5, &lpdcb->ByteSize)))
441 return FALSE;
442 }
443 else if(!strncmpiW(stopW, device, 5))
444 {
445 stop = TRUE;
446
447 if(!(device = COMM_ParseStopBits(device + 5, &lpdcb->StopBits)))
448 return FALSE;
449 }
450 else if(!strncmpiW(toW, device, 3))
451 {
452 if(!(device = COMM_ParseOnOff(device + 3, &temp)))
453 return FALSE;
454
455 lptimeouts->ReadIntervalTimeout = 0;
456 lptimeouts->ReadTotalTimeoutMultiplier = 0;
457 lptimeouts->ReadTotalTimeoutConstant = 0;
458 lptimeouts->WriteTotalTimeoutMultiplier = 0;
459 lptimeouts->WriteTotalTimeoutConstant = temp ? 60000 : 0;
460 }
461 else if(!strncmpiW(xonW, device, 4))
462 {
463 if(!(device = COMM_ParseOnOff(device + 4, &temp)))
464 return FALSE;
465
466 lpdcb->fOutX = temp;
467 lpdcb->fInX = temp;
468 }
469 else if(!strncmpiW(odsrW, device, 5))
470 {
471 if(!(device = COMM_ParseOnOff(device + 5, &temp)))
472 return FALSE;
473
474 lpdcb->fOutxDsrFlow = temp;
475 }
476 else if(!strncmpiW(octsW, device, 5))
477 {
478 if(!(device = COMM_ParseOnOff(device + 5, &temp)))
479 return FALSE;
480
481 lpdcb->fOutxCtsFlow = temp;
482 }
483 else if(!strncmpiW(dtrW, device, 4))
484 {
485 if(!(device = COMM_ParseOnOff(device + 4, &temp)))
486 return FALSE;
487
488 lpdcb->fDtrControl = temp;
489 }
490 else if(!strncmpiW(rtsW, device, 4))
491 {
492 if(!(device = COMM_ParseOnOff(device + 4, &temp)))
493 return FALSE;
494
495 lpdcb->fRtsControl = temp;
496 }
497 else if(!strncmpiW(idsrW, device, 5))
498 {
499 if(!(device = COMM_ParseOnOff(device + 5, &temp)))
500 return FALSE;
501
502 /* Win NT sets the fDsrSensitivity member based on the
503 idsr parameter. Win 9x sets fOutxDsrFlow instead. */
504 lpdcb->fDsrSensitivity = temp;
505 }
506 else
507 return FALSE;
508
509 /* After the above parsing, the next character (if not the end of
510 the string) should be a space */
511 if(*device && *device != ' ')
512 return FALSE;
513 }
514
515 /* If stop bits were not specified, a default is always supplied. */
516 if(!stop)
517 {
518 if(baud && lpdcb->BaudRate == 110)
519 lpdcb->StopBits = TWOSTOPBITS;
520 else
521 lpdcb->StopBits = ONESTOPBIT;
522 }
523
524 return TRUE;
525 }
526
527 /**************************************************************************
528 * BuildCommDCBA (KERNEL32.@)
529 *
530 * Updates a device control block data structure with values from an
531 * ascii device control string. The device control string has two forms
532 * normal and extended, it must be exclusively in one or the other form.
533 *
534 * RETURNS
535 *
536 * True on success, false on a malformed control string.
537 */
538 BOOL WINAPI BuildCommDCBA(
539 LPCSTR device, /* [in] The ascii device control string used to update the DCB. */
540 LPDCB lpdcb) /* [out] The device control block to be updated. */
541 {
542 return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
543 }
544
545 /**************************************************************************
546 * BuildCommDCBAndTimeoutsA (KERNEL32.@)
547 *
548 * Updates a device control block data structure with values from an
549 * ascii device control string. Taking timeout values from a timeouts
550 * struct if desired by the control string.
551 *
552 * RETURNS
553 *
554 * True on success, false bad handles etc.
555 */
556 BOOL WINAPI BuildCommDCBAndTimeoutsA(
557 LPCSTR device, /* [in] The ascii device control string. */
558 LPDCB lpdcb, /* [out] The device control block to be updated. */
559 LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
560 {
561 BOOL ret = FALSE;
562 UNICODE_STRING deviceW;
563
564 TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
565 if(device) RtlCreateUnicodeStringFromAsciiz(&deviceW,device);
566 else deviceW.Buffer = NULL;
567
568 if(deviceW.Buffer) ret = BuildCommDCBAndTimeoutsW(deviceW.Buffer,lpdcb,lptimeouts);
569
570 RtlFreeUnicodeString(&deviceW);
571 return ret;
572 }
573
574 /**************************************************************************
575 * BuildCommDCBAndTimeoutsW (KERNEL32.@)
576 *
577 * Updates a device control block data structure with values from a
578 * unicode device control string. Taking timeout values from a timeouts
579 * struct if desired by the control string.
580 *
581 * RETURNS
582 *
583 * True on success, false bad handles etc
584 */
585 BOOL WINAPI BuildCommDCBAndTimeoutsW(
586 LPCWSTR devid, /* [in] The unicode device control string. */
587 LPDCB lpdcb, /* [out] The device control block to be updated. */
588 LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
589 {
590 DCB dcb;
591 COMMTIMEOUTS timeouts;
592 BOOL result;
593 LPCWSTR ptr = devid;
594
595 TRACE("(%s,%p,%p)\n",debugstr_w(devid),lpdcb,lptimeouts);
596
597 /* Set DCBlength. (Windows NT does not do this, but 9x does) */
598 lpdcb->DCBlength = sizeof(DCB);
599
600 /* Make a copy of the original data structures to work with since if
601 if there is an error in the device control string the originals
602 should not be modified (except possibly DCBlength) */
603 memcpy(&dcb, lpdcb, sizeof(DCB));
604 if(lptimeouts) memcpy(&timeouts, lptimeouts, sizeof(COMMTIMEOUTS));
605
606 ptr = COMM_ParseStart(ptr);
607
608 if(ptr == NULL)
609 result = FALSE;
610 else if(strchrW(ptr, ','))
611 result = COMM_BuildOldCommDCB(ptr, &dcb);
612 else
613 result = COMM_BuildNewCommDCB(ptr, &dcb, &timeouts);
614
615 if(result)
616 {
617 memcpy(lpdcb, &dcb, sizeof(DCB));
618 if(lptimeouts) memcpy(lptimeouts, &timeouts, sizeof(COMMTIMEOUTS));
619 return TRUE;
620 }
621 else
622 {
623 WARN("Invalid device control string: %s\n", debugstr_w(devid));
624 SetLastError(ERROR_INVALID_PARAMETER);
625 return FALSE;
626 }
627 }
628
629 /**************************************************************************
630 * BuildCommDCBW (KERNEL32.@)
631 *
632 * Updates a device control block structure with values from an
633 * unicode device control string. The device control string has two forms
634 * normal and extended, it must be exclusively in one or the other form.
635 *
636 * RETURNS
637 *
638 * True on success, false on an malformed control string.
639 */
640 BOOL WINAPI BuildCommDCBW(
641 LPCWSTR devid, /* [in] The unicode device control string. */
642 LPDCB lpdcb) /* [out] The device control block to be updated. */
643 {
644 return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
645 }
646
647 static BOOL COMM_SetCommError(HANDLE handle, DWORD error)
648 {
649 DWORD ret;
650
651 SERVER_START_REQ( set_serial_info )
652 {
653 req->handle = handle;
654 req->flags = SERIALINFO_SET_ERROR;
655 req->commerror = error;
656 ret = !wine_server_call_err( req );
657 }
658 SERVER_END_REQ;
659 return ret;
660 }
661
662 static BOOL COMM_GetCommError(HANDLE handle, LPDWORD lperror)
663 {
664 DWORD ret;
665
666 if(!lperror)
667 return FALSE;
668
669 SERVER_START_REQ( get_serial_info )
670 {
671 req->handle = handle;
672 ret = !wine_server_call_err( req );
673 *lperror = reply->commerror;
674 }
675 SERVER_END_REQ;
676
677 return ret;
678 }
679
680 /*****************************************************************************
681 * SetCommBreak (KERNEL32.@)
682 *
683 * Halts the transmission of characters to a communications device.
684 *
685 * RETURNS
686 *
687 * True on success, and false if the communications device could not be found,
688 * the control is not supported.
689 *
690 * BUGS
691 *
692 * Only TIOCSBRK and TIOCCBRK are supported.
693 */
694 BOOL WINAPI SetCommBreak(
695 HANDLE handle) /* [in] The communictions device to suspend. */
696 {
697 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
698 int fd,result;
699
700 fd = get_comm_fd( handle, GENERIC_READ );
701 if(fd<0) return FALSE;
702 result = ioctl(fd,TIOCSBRK,0);
703 release_comm_fd( handle, fd );
704 if (result ==-1)
705 {
706 TRACE("ioctl failed\n");
707 SetLastError(ERROR_NOT_SUPPORTED);
708 return FALSE;
709 }
710 return TRUE;
711 #else
712 FIXME("ioctl not available\n");
713 SetLastError(ERROR_NOT_SUPPORTED);
714 return FALSE;
715 #endif
716 }
717
718 /*****************************************************************************
719 * ClearCommBreak (KERNEL32.@)
720 *
721 * Resumes character transmission from a communication device.
722 *
723 * RETURNS
724 *
725 * True on success and false if the communications device could not be found.
726 *
727 * BUGS
728 *
729 * Only TIOCSBRK and TIOCCBRK are supported.
730 */
731 BOOL WINAPI ClearCommBreak(
732 HANDLE handle) /* [in] The halted communication device whose character transmission is to be resumed. */
733 {
734 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
735 int fd,result;
736
737 fd = get_comm_fd( handle, GENERIC_READ );
738 if(fd<0) return FALSE;
739 result = ioctl(fd,TIOCCBRK,0);
740 release_comm_fd( handle, fd );
741 if (result ==-1)
742 {
743 TRACE("ioctl failed\n");
744 SetLastError(ERROR_NOT_SUPPORTED);
745 return FALSE;
746 }
747 return TRUE;
748 #else
749 FIXME("ioctl not available\n");
750 SetLastError(ERROR_NOT_SUPPORTED);
751 return FALSE;
752 #endif
753 }
754
755 /*****************************************************************************
756 * EscapeCommFunction (KERNEL32.@)
757 *
758 * Directs a communication device to perform an extended function.
759 *
760 * RETURNS
761 *
762 * True or requested data on successful completion of the command,
763 * false if the device is not present cannot execute the command
764 * or the command failed.
765 */
766 BOOL WINAPI EscapeCommFunction(
767 HANDLE handle, /* [in] The communication device to perform the extended function. */
768 UINT nFunction) /* [in] The extended function to be performed. */
769 {
770 int fd,direct=FALSE,result=FALSE;
771 struct termios port;
772
773 TRACE("handle %p, function=%d\n", handle, nFunction);
774 fd = get_comm_fd( handle, GENERIC_READ );
775 if(fd<0) return FALSE;
776
777 if (tcgetattr(fd,&port) == -1) {
778 COMM_SetCommError(handle,CE_IOE);
779 release_comm_fd( handle, fd );
780 return FALSE;
781 }
782
783 switch (nFunction) {
784 case RESETDEV:
785 TRACE("\n");
786 break;
787
788 case CLRDTR:
789 TRACE("CLRDTR\n");
790 #ifdef TIOCM_DTR
791 direct=TRUE;
792 result= COMM_WhackModem(fd, ~TIOCM_DTR, 0);
793 break;
794 #endif
795
796 case CLRRTS:
797 TRACE("CLRRTS\n");
798 #ifdef TIOCM_RTS
799 direct=TRUE;
800 result= COMM_WhackModem(fd, ~TIOCM_RTS, 0);
801 break;
802 #endif
803
804 case SETDTR:
805 TRACE("SETDTR\n");
806 #ifdef TIOCM_DTR
807 direct=TRUE;
808 result= COMM_WhackModem(fd, 0, TIOCM_DTR);
809 break;
810 #endif
811
812 case SETRTS:
813 TRACE("SETRTS\n");
814 #ifdef TIOCM_RTS
815 direct=TRUE;
816 result= COMM_WhackModem(fd, 0, TIOCM_RTS);
817 break;
818 #endif
819
820 case SETXOFF:
821 TRACE("SETXOFF\n");
822 port.c_iflag |= IXOFF;
823 break;
824
825 case SETXON:
826 TRACE("SETXON\n");
827 port.c_iflag |= IXON;
828 break;
829 case SETBREAK:
830 TRACE("setbreak\n");
831 #ifdef TIOCSBRK
832 direct=TRUE;
833 result = ioctl(fd,TIOCSBRK,0);
834 break;
835 #endif
836 case CLRBREAK:
837 TRACE("clrbreak\n");
838 #ifdef TIOCSBRK
839 direct=TRUE;
840 result = ioctl(fd,TIOCCBRK,0);
841 break;
842 #endif
843 default:
844 WARN("(handle=%p,nFunction=%d): Unknown function\n",
845 handle, nFunction);
846 break;
847 }
848
849 if (!direct)
850 if (tcsetattr(fd, TCSADRAIN, &port) == -1) {
851 release_comm_fd( handle, fd );
852 COMM_SetCommError(handle,CE_IOE);
853 return FALSE;
854 } else
855 result= TRUE;
856 else
857 {
858 if (result == -1)
859 {
860 result= FALSE;
861 COMM_SetCommError(handle,CE_IOE);
862 }
863 else
864 result = TRUE;
865 }
866 release_comm_fd( handle, fd );
867 return result;
868 }
869
870 /********************************************************************
871 * PurgeComm (KERNEL32.@)
872 *
873 * Terminates pending operations and/or discards buffers on a
874 * communication resource.
875 *
876 * RETURNS
877 *
878 * True on success and false if the communications handle is bad.
879 */
880 BOOL WINAPI PurgeComm(
881 HANDLE handle, /* [in] The communication resource to be purged. */
882 DWORD flags) /* [in] Flags for clear pending/buffer on input/output. */
883 {
884 int fd;
885
886 TRACE("handle %p, flags %lx\n", handle, flags);
887
888 fd = get_comm_fd( handle, GENERIC_READ );
889 if(fd<0) return FALSE;
890
891 /*
892 ** not exactly sure how these are different
893 ** Perhaps if we had our own internal queues, one flushes them
894 ** and the other flushes the kernel's buffers.
895 */
896 if(flags&PURGE_TXABORT)
897 tcflush(fd,TCOFLUSH);
898 if(flags&PURGE_RXABORT)
899 tcflush(fd,TCIFLUSH);
900 if(flags&PURGE_TXCLEAR)
901 tcflush(fd,TCOFLUSH);
902 if(flags&PURGE_RXCLEAR)
903 tcflush(fd,TCIFLUSH);
904 release_comm_fd( handle, fd );
905
906 return 1;
907 }
908
909 /*****************************************************************************
910 * ClearCommError (KERNEL32.@)
911 *
912 * Enables further I/O operations on a communications resource after
913 * supplying error and current status information.
914 *
915 * RETURNS
916 *
917 * True on success, false if the communication resource handle is bad.
918 */
919 BOOL WINAPI ClearCommError(
920 HANDLE handle, /* [in] The communication resource with the error. */
921 LPDWORD errors, /* [out] Flags indicating error the resource experienced. */
922 LPCOMSTAT lpStat) /* [out] The status of the communication resource. */
923 {
924 int fd;
925
926 fd=get_comm_fd( handle, GENERIC_READ );
927 if(0>fd) return FALSE;
928
929 if (lpStat)
930 {
931 lpStat->fCtsHold = 0;
932 lpStat->fDsrHold = 0;
933 lpStat->fRlsdHold = 0;
934 lpStat->fXoffHold = 0;
935 lpStat->fXoffSent = 0;
936 lpStat->fEof = 0;
937 lpStat->fTxim = 0;
938 lpStat->fReserved = 0;
939
940 #ifdef TIOCOUTQ
941 if(ioctl(fd, TIOCOUTQ, &lpStat->cbOutQue))
942 WARN("ioctl returned error\n");
943 #else
944 lpStat->cbOutQue = 0; /* FIXME: find a different way to find out */
945 #endif
946
947 #ifdef TIOCINQ
948 if(ioctl(fd, TIOCINQ, &lpStat->cbInQue))
949 WARN("ioctl returned error\n");
950 #endif
951
952 TRACE("handle %p cbInQue = %ld cbOutQue = %ld\n",
953 handle, lpStat->cbInQue, lpStat->cbOutQue);
954 }
955
956 release_comm_fd( handle, fd );
957
958 COMM_GetCommError(handle, errors);
959 COMM_SetCommError(handle, 0);
960
961 return TRUE;
962 }
963
964 /*****************************************************************************
965 * SetupComm (KERNEL32.@)
966 *
967 * Called after CreateFile to hint to the communication resource to use
968 * specified sizes for input and output buffers rather than the default values.
969 *
970 * RETURNS
971 *
972 * True if successful, false if the communications resource handle is bad.
973 *
974 * BUGS
975 *
976 * Stub.
977 */
978 BOOL WINAPI SetupComm(
979 HANDLE handle, /* [in] The just created communication resource handle. */
980 DWORD insize, /* [in] The suggested size of the communication resources input buffer in bytes. */
981 DWORD outsize) /* [in] The suggested size of the communication resources output buffer in bytes. */
982 {
983 int fd;
984
985 FIXME("insize %ld outsize %ld unimplemented stub\n", insize, outsize);
986 fd=get_comm_fd( handle, GENERIC_READ );
987 if(0>fd) return FALSE;
988 release_comm_fd( handle, fd );
989 return TRUE;
990 }
991
992 /*****************************************************************************
993 * GetCommMask (KERNEL32.@)
994 *
995 * Obtain the events associated with a communication device that will cause
996 * a call WaitCommEvent to return.
997 *
998 * RETURNS
999 *
1000 * True on success, fail on bad device handle etc.
1001 */
1002 BOOL WINAPI GetCommMask(
1003 HANDLE handle, /* [in] The communications device. */
1004 LPDWORD evtmask) /* [out] The events which cause WaitCommEvent to return. */
1005 {
1006 BOOL ret;
1007
1008 TRACE("handle %p, mask %p\n", handle, evtmask);
1009
1010 SERVER_START_REQ( get_serial_info )
1011 {
1012 req->handle = handle;
1013 if ((ret = !wine_server_call_err( req )))
1014 {
1015 if (evtmask) *evtmask = reply->eventmask;
1016 }
1017 }
1018 SERVER_END_REQ;
1019 return ret;
1020 }
1021
1022 /*****************************************************************************
1023 * SetCommMask (KERNEL32.@)
1024 *
1025 * There be some things we need to hear about yon there communications device.
1026 * (Set which events associated with a communication device should cause
1027 * a call WaitCommEvent to return.)
1028 *
1029 * RETURNS
1030 *
1031 * True on success, false on bad handle etc.
1032 */
1033 BOOL WINAPI SetCommMask(
1034 HANDLE handle, /* [in] The communications device. */
1035 DWORD evtmask) /* [in] The events that are to be monitored. */
1036 {
1037 BOOL ret;
1038
1039 TRACE("handle %p, mask %lx\n", handle, evtmask);
1040
1041 SERVER_START_REQ( set_serial_info )
1042 {
1043 req->handle = handle;
1044 req->flags = SERIALINFO_SET_MASK;
1045 req->eventmask = evtmask;
1046 ret = !wine_server_call_err( req );
1047 }
1048 SERVER_END_REQ;
1049 return ret;
1050 }
1051
1052 /*****************************************************************************
1053 * SetCommState (KERNEL32.@)
1054 *
1055 * Re-initializes all hardware and control settings of a communications device,
1056 * with values from a device control block without effecting the input and output
1057 * queues.
1058 *
1059 * RETURNS
1060 *
1061 * True on success, false on failure eg if the XonChar is equal to the XoffChar.
1062 */
1063 BOOL WINAPI SetCommState(
1064 HANDLE handle, /* [in] The communications device. */
1065 LPDCB lpdcb) /* [out] The device control block. */
1066 {
1067 struct termios port;
1068 int fd, bytesize, stopbits;
1069 BOOL ret;
1070
1071 TRACE("handle %p, ptr %p\n", handle, lpdcb);
1072 TRACE("bytesize %d baudrate %ld fParity %d Parity %d stopbits %d\n",
1073 lpdcb->ByteSize,lpdcb->BaudRate,lpdcb->fParity, lpdcb->Parity,
1074 (lpdcb->StopBits == ONESTOPBIT)?1:
1075 (lpdcb->StopBits == TWOSTOPBITS)?2:0);
1076 TRACE("%s %s\n",(lpdcb->fInX)?"IXON":"~IXON",
1077 (lpdcb->fOutX)?"IXOFF":"~IXOFF");
1078 TRACE("fOutxCtsFlow %d fRtsControl %d\n", lpdcb->fOutxCtsFlow,
1079 lpdcb->fRtsControl);
1080 TRACE("fOutxDsrFlow %d fDtrControl%d\n", lpdcb->fOutxDsrFlow,
1081 lpdcb->fDtrControl);
1082
1083
1084 fd = get_comm_fd( handle, GENERIC_READ );
1085 if (fd < 0) return FALSE;
1086
1087 if ((tcgetattr(fd,&port)) == -1) {
1088 int save_error = errno;
1089 COMM_SetCommError(handle,CE_IOE);
1090 release_comm_fd( handle, fd );
1091 ERR("tcgetattr error '%s'\n", strerror(save_error));
1092 return FALSE;
1093 }
1094
1095 port.c_cc[VMIN] = 0;
1096 port.c_cc[VTIME] = 1;
1097
1098 #ifdef IMAXBEL
1099 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
1100 #else
1101 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
1102 #endif
1103 port.c_iflag |= (IGNBRK);
1104
1105 port.c_oflag &= ~(OPOST);
1106
1107 port.c_cflag &= ~(HUPCL);
1108 port.c_cflag |= CLOCAL | CREAD;
1109
1110 port.c_lflag &= ~(ICANON|ECHO|ISIG);
1111 port.c_lflag |= NOFLSH;
1112
1113 #ifdef CBAUD
1114 port.c_cflag &= ~CBAUD;
1115 switch (lpdcb->BaudRate) {
1116 case 0:
1117 port.c_cflag |= B0;
1118 break;
1119 case 50:
1120 port.c_cflag |= B50;
1121 break;
1122 case 75:
1123 port.c_cflag |= B75;
1124 break;
1125 case 110:
1126 case CBR_110:
1127 port.c_cflag |= B110;
1128 break;
1129 case 134:
1130 port.c_cflag |= B134;
1131 break;
1132 case 150:
1133 port.c_cflag |= B150;
1134 break;
1135 case 200:
1136 port.c_cflag |= B200;
1137 break;
1138 case 300:
1139 case CBR_300:
1140 port.c_cflag |= B300;
1141 break;
1142 case 600:
1143 case CBR_600:
1144 port.c_cflag |= B600;
1145 break;
1146 case 1200:
1147 case CBR_1200:
1148 port.c_cflag |= B1200;
1149 break;
1150 case 1800:
1151 port.c_cflag |= B1800;
1152 break;
1153 case 2400:
1154 case CBR_2400:
1155 port.c_cflag |= B2400;
1156 break;
1157 case 4800:
1158 case CBR_4800:
1159 port.c_cflag |= B4800;
1160 break;
1161 case 9600:
1162 case CBR_9600:
1163 port.c_cflag |= B9600;
1164 break;
1165 case 19200:
1166 case CBR_19200:
1167 port.c_cflag |= B19200;
1168 break;
1169 case 38400:
1170 case CBR_38400:
1171 port.c_cflag |= B38400;
1172 break;
1173 #ifdef B57600
1174 case 57600:
1175 port.c_cflag |= B57600;
1176 break;
1177 #endif
1178 #ifdef B115200
1179 case 115200:
1180 port.c_cflag |= B115200;
1181 break;
1182 #endif
1183 #ifdef B230400
1184 case 230400:
1185 port.c_cflag |= B230400;
1186 break;
1187 #endif
1188 #ifdef B460800
1189 case 460800:
1190 port.c_cflag |= B460800;
1191 break;
1192 #endif
1193 default:
1194 #if defined (HAVE_LINUX_SERIAL_H) && defined (TIOCSSERIAL)
1195 { struct serial_struct nuts;
1196 int arby;
1197 ioctl(fd, TIOCGSERIAL, &nuts);
1198 nuts.custom_divisor = nuts.baud_base / lpdcb->BaudRate;
1199 if (!(nuts.custom_divisor)) nuts.custom_divisor = 1;
1200 arby = nuts.baud_base / nuts.custom_divisor;
1201 nuts.flags &= ~ASYNC_SPD_MASK;
1202 nuts.flags |= ASYNC_SPD_CUST;
1203 WARN("You (or a program acting at your behest) have specified\n"
1204 "a non-standard baud rate %ld. Wine will set the rate to %d,\n"
1205 "which is as close as we can get by our present understanding of your\n"
1206 "hardware. I hope you know what you are doing. Any disruption Wine\n"
1207 "has caused to your linux system can be undone with setserial \n"
1208 "(see man setserial). If you have incapacitated a Hayes type modem,\n"
1209 "reset it and it will probably recover.\n", lpdcb->BaudRate, arby);
1210 ioctl(fd, TIOCSSERIAL, &nuts);
1211 port.c_cflag |= B38400;
1212 }
1213 break;
1214 #endif /* Don't have linux/serial.h or lack TIOCSSERIAL */
1215
1216
1217 COMM_SetCommError(handle,IE_BAUDRATE);
1218 release_comm_fd( handle, fd );
1219 ERR("baudrate %ld\n",lpdcb->BaudRate);
1220 return FALSE;
1221 }
1222 #elif !defined(__EMX__)
1223 switch (lpdcb->BaudRate) {
1224 case 0:
1225 port.c_ospeed = B0;
1226 break;
1227 case 50:
1228 port.c_ospeed = B50;
1229 break;
1230 case 75:
1231 port.c_ospeed = B75;
1232 break;
1233 case 110:
1234 case CBR_110:
1235 port.c_ospeed = B110;
1236 break;
1237 case 134:
1238 port.c_ospeed = B134;
1239 break;
1240 case 150:
1241 port.c_ospeed = B150;
1242 break;
1243 case 200:
1244 port.c_ospeed = B200;
1245 break;
1246 case 300:
1247 case CBR_300:
1248 port.c_ospeed = B300;
1249 break;
1250 case 600:
1251 case CBR_600:
1252 port.c_ospeed = B600;
1253 break;
1254 case 1200:
1255 case CBR_1200:
1256 port.c_ospeed = B1200;
1257 break;
1258 case 1800:
1259 port.c_ospeed = B1800;
1260 break;
1261 case 2400:
1262 case CBR_2400:
1263 port.c_ospeed = B2400;
1264 break;
1265 case 4800:
1266 case CBR_4800:
1267 port.c_ospeed = B4800;
1268 break;
1269 case 9600:
1270 case CBR_9600:
1271 port.c_ospeed = B9600;
1272 break;
1273 case 19200:
1274 case CBR_19200:
1275 port.c_ospeed = B19200;
1276 break;
1277 case 38400:
1278 case CBR_38400:
1279 port.c_ospeed = B38400;
1280 break;
1281 #ifdef B57600
1282 case 57600:
1283 case CBR_57600:
1284 port.c_cflag |= B57600;
1285 break;
1286 #endif
1287 #ifdef B115200
1288 case 115200:
1289 case CBR_115200:
1290 port.c_cflag |= B115200;
1291 break;
1292 #endif
1293 #ifdef B230400
1294 case 230400:
1295 port.c_cflag |= B230400;
1296 break;
1297 #endif
1298 #ifdef B460800
1299 case 460800:
1300 port.c_cflag |= B460800;
1301 break;
1302 #endif
1303 default:
1304 COMM_SetCommError(handle,IE_BAUDRATE);
1305 release_comm_fd( handle, fd );
1306 ERR("baudrate %ld\n",lpdcb->BaudRate);
1307 return FALSE;
1308 }
1309 port.c_ispeed = port.c_ospeed;
1310 #endif
1311 bytesize=lpdcb->ByteSize;
1312 stopbits=lpdcb->StopBits;
1313
1314 #ifdef CMSPAR
1315 port.c_cflag &= ~(PARENB | PARODD | CMSPAR);
1316 #else
1317 port.c_cflag &= ~(PARENB | PARODD);
1318 #endif
1319 if (lpdcb->fParity)
1320 port.c_iflag |= INPCK;
1321 else
1322 port.c_iflag &= ~INPCK;
1323 switch (lpdcb->Parity) {
1324 case NOPARITY:
1325 break;
1326 case ODDPARITY:
1327 port.c_cflag |= (PARENB | PARODD);
1328 break;
1329 case EVENPARITY:
1330 port.c_cflag |= PARENB;
1331 break;
1332 #ifdef CMSPAR
1333 /* Linux defines mark/space (stick) parity */
1334 case MARKPARITY:
1335 port.c_cflag |= (PARENB | CMSPAR);
1336 break;
1337 case SPACEPARITY:
1338 port.c_cflag |= (PARENB | PARODD | CMSPAR);
1339 break;
1340 #else
1341 /* try the POSIX way */
1342 case MARKPARITY:
1343 if( stopbits == ONESTOPBIT) {
1344 stopbits = TWOSTOPBITS;
1345 port.c_iflag &= ~INPCK;
1346 } else {
1347 COMM_SetCommError(handle,IE_BYTESIZE);
1348 release_comm_fd( handle, fd );
1349 ERR("Cannot set MARK Parity\n");
1350 return FALSE;
1351 }
1352 break;
1353 case SPACEPARITY:
1354 if( bytesize < 8) {
1355 bytesize +=1;
1356 port.c_iflag &= ~INPCK;
1357 } else {
1358 COMM_SetCommError(handle,IE_BYTESIZE);
1359 release_comm_fd( handle, fd );
1360 ERR("Cannot set SPACE Parity\n");
1361 return FALSE;
1362 }
1363 break;
1364 #endif
1365 default:
1366 COMM_SetCommError(handle,IE_BYTESIZE);
1367 release_comm_fd( handle, fd );
1368 ERR("Parity\n");
1369 return FALSE;
1370 }
1371
1372
1373 port.c_cflag &= ~CSIZE;
1374 switch (bytesize) {
1375 case 5:
1376 port.c_cflag |= CS5;
1377 break;
1378 case 6:
1379 port.c_cflag |= CS6;
1380 break;
1381 case 7:
1382 port.c_cflag |= CS7;
1383 break;
1384 case 8:
1385 port.c_cflag |= CS8;
1386 break;
1387 default:
1388 COMM_SetCommError(handle,IE_BYTESIZE);
1389 release_comm_fd( handle, fd );
1390 ERR("ByteSize\n");
1391 return FALSE;
1392 }
1393
1394 switch (stopbits) {
1395 case ONESTOPBIT:
1396 port.c_cflag &= ~CSTOPB;
1397 break;
1398 case ONE5STOPBITS: /* wil be selected if bytesize is 5 */
1399 case TWOSTOPBITS:
1400 port.c_cflag |= CSTOPB;
1401 break;
1402 default:
1403 COMM_SetCommError(handle,IE_BYTESIZE);
1404 release_comm_fd( handle, fd );
1405 ERR("StopBits\n");
1406 return FALSE;
1407 }
1408 #ifdef CRTSCTS
1409 if ( lpdcb->fOutxCtsFlow ||
1410 lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE
1411 )
1412 {
1413 port.c_cflag |= CRTSCTS;
1414 TRACE("CRTSCTS\n");
1415 }
1416 #endif
1417
1418 if (lpdcb->fInX)
1419 port.c_iflag |= IXON;
1420 else
1421 port.c_iflag &= ~IXON;
1422 if (lpdcb->fOutX)
1423 port.c_iflag |= IXOFF;
1424 else
1425 port.c_iflag &= ~IXOFF;
1426
1427 if (tcsetattr(fd,TCSANOW,&port)==-1) { /* otherwise it hangs with pending input*/
1428 ERR("tcsetattr error '%s'\n", strerror(errno));
1429 COMM_SetCommError(handle,CE_IOE);
1430 ret = FALSE;
1431 } else {
1432 COMM_SetCommError(handle,0);
1433 ret = TRUE;
1434 }
1435
1436 /* note: change DTR/RTS lines after setting the comm attributes,
1437 * so flow control does not interfere. */
1438 #ifdef TIOCM_DTR
1439 if (lpdcb->fDtrControl == DTR_CONTROL_HANDSHAKE)
1440 {
1441 WARN("DSR/DTR flow control not supported\n");
1442 } else if(lpdcb->fDtrControl == DTR_CONTROL_DISABLE)
1443 COMM_WhackModem(fd, ~TIOCM_DTR, 0);
1444 else
1445 COMM_WhackModem(fd, 0, TIOCM_DTR);
1446 #endif
1447 #ifdef TIOCM_RTS
1448 if(!lpdcb->fOutxCtsFlow )
1449 {
1450 if(lpdcb->fRtsControl == RTS_CONTROL_DISABLE)
1451 COMM_WhackModem(fd, ~TIOCM_RTS, 0);
1452 else
1453 COMM_WhackModem(fd, 0, TIOCM_RTS);
1454 }
1455 #endif
1456 if(lpdcb->fRtsControl == RTS_CONTROL_TOGGLE)
1457 FIXME("RTS_CONTROL_TOGGLE is not supported.\n");
1458 release_comm_fd( handle, fd );
1459 return ret;
1460
1461 }
1462
1463
1464 /*****************************************************************************
1465 * GetCommState (KERNEL32.@)
1466 *
1467 * Fills in a device control block with information from a communications device.
1468 *
1469 * RETURNS
1470 *
1471 * True on success, false if the communication device handle is bad etc
1472 *
1473 * BUGS
1474 *
1475 * XonChar and XoffChar are not set.
1476 */
1477 BOOL WINAPI GetCommState(
1478 HANDLE handle, /* [in] The communications device. */
1479 LPDCB lpdcb) /* [out] The device control block. */
1480 {
1481 struct termios port;
1482 int fd,speed;
1483 int stat = DTR_CONTROL_ENABLE | RTS_CONTROL_ENABLE;
1484
1485 TRACE("handle %p, ptr %p\n", handle, lpdcb);
1486
1487 fd = get_comm_fd( handle, GENERIC_READ );
1488 if (fd < 0) return FALSE;
1489 if (tcgetattr(fd, &port) == -1
1490 #ifdef TIOCMGET
1491 || ioctl(fd, TIOCMGET, &stat) == -1
1492 #endif
1493 ) {
1494 int save_error=errno;
1495 ERR("tcgetattr or ioctl error '%s'\n", strerror(save_error));
1496 COMM_SetCommError(handle,CE_IOE);
1497 release_comm_fd( handle, fd );
1498 return FALSE;
1499 }
1500 release_comm_fd( handle, fd );
1501 #ifndef __EMX__
1502 #ifdef CBAUD
1503 speed= (port.c_cflag & CBAUD);
1504 #else
1505 speed= (cfgetospeed(&port));
1506 #endif
1507 switch (speed) {
1508 case B0:
1509 lpdcb->BaudRate = 0;
1510 break;
1511 case B50:
1512 lpdcb->BaudRate = 50;
1513 break;
1514 case B75:
1515 lpdcb->BaudRate = 75;
1516 break;
1517 case B110:
1518 lpdcb->BaudRate = 110;
1519 break;
1520 case B134:
1521 lpdcb->BaudRate = 134;
1522 break;
1523 case B150:
1524 lpdcb->BaudRate = 150;
1525 break;
1526 case B200:
1527 lpdcb->BaudRate = 200;
1528 break;
1529 case B300:
1530 lpdcb->BaudRate = 300;
1531 break;
1532 case B600:
1533 lpdcb->BaudRate = 600;
1534 break;
1535 case B1200:
1536 lpdcb->BaudRate = 1200;
1537 break;
1538 case B1800:
1539 lpdcb->BaudRate = 1800;
1540 break;
1541 case B2400:
1542 lpdcb->BaudRate = 2400;
1543 break;
1544 case B4800:
1545 lpdcb->BaudRate = 4800;
1546 break;
1547 case B9600:
1548 lpdcb->BaudRate = 9600;
1549 break;
1550 case B19200:
1551 lpdcb->BaudRate = 19200;
1552 break;
1553 case B38400:
1554 lpdcb->BaudRate = 38400;
1555 break;
1556 #ifdef B57600
1557 case B57600:
1558 lpdcb->BaudRate = 57600;
1559 break;
1560 #endif
1561 #ifdef B115200
1562 case B115200:
1563 lpdcb->BaudRate = 115200;
1564 break;
1565 #endif
1566 #ifdef B230400
1567 case B230400:
1568 lpdcb->BaudRate = 230400;
1569 break;
1570 #endif
1571 #ifdef B460800
1572 case B460800:
1573 lpdcb->BaudRate = 460800;
1574 break;
1575 #endif
1576 default:
1577 ERR("unknown speed %x \n",speed);
1578 }
1579 #endif
1580 switch (port.c_cflag & CSIZE) {
1581 case CS5:
1582 lpdcb->ByteSize = 5;
1583 break;
1584 case CS6:
1585 lpdcb->ByteSize = 6;
1586 break;
1587 case CS7:
1588 lpdcb->ByteSize = 7;
1589 break;
1590 case CS8:
1591 lpdcb->ByteSize = 8;
1592 break;
1593 default:
1594 ERR("unknown size %x \n",port.c_cflag & CSIZE);
1595 }
1596
1597 if(port.c_iflag & INPCK)
1598 lpdcb->fParity = TRUE;
1599 else
1600 lpdcb->fParity = FALSE;
1601 #ifdef CMSPAR
1602 switch (port.c_cflag & (PARENB | PARODD | CMSPAR))
1603 #else
1604 switch (port.c_cflag & (PARENB | PARODD))
1605 #endif
1606 {
1607 case 0:
1608 lpdcb->Parity = NOPARITY;
1609 break;
1610 case PARENB:
1611 lpdcb->Parity = EVENPARITY;
1612 break;
1613 case (PARENB | PARODD):
1614 lpdcb->Parity = ODDPARITY;
1615 break;
1616 #ifdef CMSPAR
1617 case (PARENB | CMSPAR):
1618 lpdcb->Parity = MARKPARITY;
1619 break;
1620 case (PARENB | PARODD | CMSPAR):
1621 lpdcb->Parity = SPACEPARITY;
1622 break;
1623 #endif
1624 }
1625
1626 if (port.c_cflag & CSTOPB)
1627 if(lpdcb->ByteSize == 5)
1628 lpdcb->StopBits = ONE5STOPBITS;
1629 else
1630 lpdcb->StopBits = TWOSTOPBITS;
1631 else
1632 lpdcb->StopBits = ONESTOPBIT;
1633
1634 lpdcb->fNull = 0;
1635 lpdcb->fBinary = 1;
1636
1637 /* termios does not support DTR/DSR flow control */
1638 lpdcb->fOutxDsrFlow = 0;
1639 lpdcb->fDtrControl =
1640 #ifdef TIOCM_DTR
1641 !(stat & TIOCM_DTR) ? DTR_CONTROL_DISABLE:
1642 #endif
1643 DTR_CONTROL_ENABLE ;
1644
1645 #ifdef CRTSCTS
1646
1647 if (port.c_cflag & CRTSCTS) {
1648 lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
1649 lpdcb->fOutxCtsFlow = 1;
1650 } else
1651 #endif
1652 {
1653 lpdcb->fRtsControl =
1654 #ifdef TIOCM_RTS
1655 !(stat & TIOCM_RTS) ? RTS_CONTROL_DISABLE :
1656 #endif
1657 RTS_CONTROL_ENABLE ;
1658 lpdcb->fOutxCtsFlow = 0;
1659 }
1660 if (port.c_iflag & IXON)
1661 lpdcb->fInX = 1;
1662 else
1663 lpdcb->fInX = 0;
1664
1665 if (port.c_iflag & IXOFF)
1666 lpdcb->fOutX = 1;
1667 else
1668 lpdcb->fOutX = 0;
1669 /*
1670 lpdcb->XonChar =
1671 lpdcb->XoffChar =
1672 */
1673 lpdcb->XonLim = 10;
1674 lpdcb->XoffLim = 10;
1675
1676 COMM_SetCommError(handle,0);
1677
1678 TRACE("OK\n");
1679
1680 TRACE("bytesize %d baudrate %ld fParity %d Parity %d stopbits %d\n",
1681 lpdcb->ByteSize,lpdcb->BaudRate,lpdcb->fParity, lpdcb->Parity,
1682 (lpdcb->StopBits == ONESTOPBIT)?1:
1683 (lpdcb->StopBits == TWOSTOPBITS)?2:0);
1684 TRACE("%s %s\n",(lpdcb->fInX)?"IXON":"~IXON",
1685 (lpdcb->fOutX)?"IXOFF":"~IXOFF");
1686 TRACE("fOutxCtsFlow %d fRtsControl %d\n", lpdcb->fOutxCtsFlow,
1687 lpdcb->fRtsControl);
1688 TRACE("fOutxDsrFlow %d fDtrControl%d\n", lpdcb->fOutxDsrFlow,
1689 lpdcb->fDtrControl);
1690 #ifdef CRTSCTS
1691 if ( lpdcb->fOutxCtsFlow ||
1692 lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE
1693 )
1694 TRACE("CRTSCTS\n");
1695 else
1696
1697 TRACE("~CRTSCTS\n");
1698 #endif
1699 return TRUE;
1700 }
1701
1702 /*****************************************************************************
1703 * TransmitCommChar (KERNEL32.@)
1704 *
1705 * Transmits a single character in front of any pending characters in the
1706 * output buffer. Usually used to send an interrupt character to a host.
1707 *
1708 * RETURNS
1709 *
1710 * True if the call succeeded, false if the previous command character to the
1711 * same device has not been sent yet the handle is bad etc.
1712 *
1713 * BUGS
1714 *
1715 * Stub.
1716 */
1717 BOOL WINAPI TransmitCommChar(
1718 HANDLE hComm, /* [in] The communication device in need of a command character. */
1719 CHAR chTransmit) /* [in] The character to transmit. */
1720 {
1721 DWORD w;
1722 WARN("(%p,'%c') not perfect!\n",hComm,chTransmit);
1723
1724 return WriteFile( hComm, &chTransmit, 1, &w, NULL );
1725 }
1726
1727
1728 /*****************************************************************************
1729 * GetCommTimeouts (KERNEL32.@)
1730 *
1731 * Obtains the request timeout values for the communications device.
1732 *
1733 * RETURNS
1734 *
1735 * True on success, false if communications device handle is bad
1736 * or the target structure is null.
1737 */
1738 BOOL WINAPI GetCommTimeouts(
1739 HANDLE hComm, /* [in] The communications device. */
1740 LPCOMMTIMEOUTS lptimeouts) /* [out] The struct of request timeouts. */
1741 {
1742 BOOL ret;
1743
1744 TRACE("(%p,%p)\n",hComm,lptimeouts);
1745
1746 if(!lptimeouts)
1747 {
1748 SetLastError(ERROR_INVALID_PARAMETER);
1749 return FALSE;
1750 }
1751
1752 SERVER_START_REQ( get_serial_info )
1753 {
1754 req->handle = hComm;
1755 if ((ret = !wine_server_call_err( req )))
1756 {
1757 lptimeouts->ReadIntervalTimeout = reply->readinterval;
1758 lptimeouts->ReadTotalTimeoutMultiplier = reply->readmult;
1759 lptimeouts->ReadTotalTimeoutConstant = reply->readconst;
1760 lptimeouts->WriteTotalTimeoutMultiplier = reply->writemult;
1761 lptimeouts->WriteTotalTimeoutConstant = reply->writeconst;
1762 }
1763 }
1764 SERVER_END_REQ;
1765 return ret;
1766 }
1767
1768 /*****************************************************************************
1769 * SetCommTimeouts (KERNEL32.@)
1770 *
1771 * Sets the timeouts used when reading and writing data to/from COMM ports.
1772 *
1773 * ReadIntervalTimeout
1774 * - converted and passes to linux kernel as c_cc[VTIME]
1775 * ReadTotalTimeoutMultiplier, ReadTotalTimeoutConstant
1776 * - used in ReadFile to calculate GetOverlappedResult's timeout
1777 * WriteTotalTimeoutMultiplier, WriteTotalTimeoutConstant
1778 * - used in WriteFile to calculate GetOverlappedResult's timeout
1779 *
1780 * RETURNS
1781 *
1782 * True if the timeouts were set, false otherwise.
1783 */
1784 BOOL WINAPI SetCommTimeouts(
1785 HANDLE hComm, /* [in] handle of COMM device */
1786 LPCOMMTIMEOUTS lptimeouts) /* [in] pointer to COMMTIMEOUTS structure */
1787 {
1788 BOOL ret;
1789 int fd;
1790 struct termios tios;
1791
1792 TRACE("(%p,%p)\n",hComm,lptimeouts);
1793
1794 if(!lptimeouts)
1795 {
1796 SetLastError(ERROR_INVALID_PARAMETER);
1797 return FALSE;
1798 }
1799
1800 SERVER_START_REQ( set_serial_info )
1801 {
1802 req->handle = hComm;
1803 req->flags = SERIALINFO_SET_TIMEOUTS;
1804 req->readinterval = lptimeouts->ReadIntervalTimeout ;
1805 req->readmult = lptimeouts->ReadTotalTimeoutMultiplier ;
1806 req->readconst = lptimeouts->ReadTotalTimeoutConstant ;
1807 req->writemult = lptimeouts->WriteTotalTimeoutMultiplier ;
1808 req->writeconst = lptimeouts->WriteTotalTimeoutConstant ;
1809 ret = !wine_server_call_err( req );
1810 }
1811 SERVER_END_REQ;
1812 if (!ret) return FALSE;
1813
1814 /* FIXME: move this stuff to the server */
1815 fd = get_comm_fd( hComm, GENERIC_READ );
1816 if (fd < 0) return FALSE;
1817
1818 if (-1==tcgetattr(fd,&tios)) {
1819 FIXME("tcgetattr on fd %d failed!\n",fd);
1820 release_comm_fd( hComm, fd );
1821 return FALSE;
1822 }
1823
1824 /* VTIME is in 1/10 seconds */
1825 {
1826 unsigned int ux_timeout;
1827
1828 if(lptimeouts->ReadIntervalTimeout == 0) /* 0 means no timeout */
1829 {
1830 ux_timeout = 0;
1831 }
1832 else
1833 {
1834 ux_timeout = (lptimeouts->ReadIntervalTimeout+99)/100;
1835 if(ux_timeout == 0)
1836 {
1837 ux_timeout = 1; /* must be at least some timeout */
1838 }
1839 }
1840 tios.c_cc[VTIME] = ux_timeout;
1841 }
1842
1843 if (-1==tcsetattr(fd,0,&tios)) {
1844 FIXME("tcsetattr on fd %d failed!\n",fd);
1845 release_comm_fd( hComm, fd );
1846 return FALSE;
1847 }
1848 release_comm_fd( hComm, fd );
1849 return TRUE;
1850 }
1851
1852 /***********************************************************************
1853 * GetCommModemStatus (KERNEL32.@)
1854 *
1855 * Obtains the four control register bits if supported by the hardware.
1856 *
1857 * RETURNS
1858 *
1859 * True if the communications handle was good and for hardware that
1860 * control register access, false otherwise.
1861 */
1862 BOOL WINAPI GetCommModemStatus(
1863 HANDLE hFile, /* [in] The communications device. */
1864 LPDWORD lpModemStat) /* [out] The control register bits. */
1865 {
1866 int fd,mstat, result=FALSE;
1867
1868 *lpModemStat=0;
1869 #ifdef TIOCMGET
1870 fd = get_comm_fd( hFile, GENERIC_READ );
1871 if(fd<0)
1872 return FALSE;
1873 result = ioctl(fd, TIOCMGET, &mstat);
1874 release_comm_fd( hFile, fd );
1875 if (result == -1)
1876 {
1877 WARN("ioctl failed\n");
1878 return FALSE;
1879 }
1880 #ifdef TIOCM_CTS
1881 if (mstat & TIOCM_CTS)
1882 *lpModemStat |= MS_CTS_ON;
1883 #endif
1884 #ifdef TIOCM_DSR
1885 if (mstat & TIOCM_DSR)
1886 *lpModemStat |= MS_DSR_ON;
1887 #endif
1888 #ifdef TIOCM_RNG
1889 if (mstat & TIOCM_RNG)
1890 *lpModemStat |= MS_RING_ON;
1891 #endif
1892 #ifdef TIOCM_CAR
1893 /*FIXME: Not really sure about RLSD UB 990810*/
1894 if (mstat & TIOCM_CAR)
1895 *lpModemStat |= MS_RLSD_ON;
1896 #endif
1897 TRACE("%04x -> %s%s%s%s\n", mstat,
1898 (*lpModemStat &MS_RLSD_ON)?"MS_RLSD_ON ":"",
1899 (*lpModemStat &MS_RING_ON)?"MS_RING_ON ":"",
1900 (*lpModemStat &MS_DSR_ON)?"MS_DSR_ON ":"",
1901 (*lpModemStat &MS_CTS_ON)?"MS_CTS_ON ":"");
1902 return TRUE;
1903 #else
1904 return FALSE;
1905 #endif
1906 }
1907
1908 /***********************************************************************
1909 * COMM_WaitCommEventService (INTERNAL)
1910 *
1911 * This function is called while the client is waiting on the
1912 * server, so we can't make any server calls here.
1913 */
1914 static void WINAPI COMM_WaitCommEventService(void* ovp, IO_STATUS_BLOCK* iosb, ULONG status)
1915 {
1916 async_commio *commio = (async_commio*) ovp;
1917
1918 TRACE("iosb %p\n", iosb);
1919
1920 switch (status)
1921 {
1922 case STATUS_ALERTED: /* got some new stuff */
1923 /* FIXME: detect other events */
1924 *commio->buffer = EV_RXCHAR;
1925 iosb->u.Status = STATUS_SUCCESS;
1926 break;
1927 default:
1928 iosb->u.Status = status;
1929 break;
1930 }
1931 wine_server_release_fd( commio->handle, commio->fd );
1932 if ( ((LPOVERLAPPED)iosb)->hEvent != INVALID_HANDLE_VALUE )
1933 NtSetEvent( ((LPOVERLAPPED)iosb)->hEvent, NULL );
1934 HeapFree(GetProcessHeap(), 0, commio );
1935 }
1936
1937
1938 /***********************************************************************
1939 * COMM_WaitCommEvent (INTERNAL)
1940 *
1941 * This function must have an lpOverlapped.
1942 */
1943 static BOOL COMM_WaitCommEvent(
1944 HANDLE hFile, /* [in] handle of comm port to wait for */
1945 LPDWORD lpdwEvents, /* [out] event(s) that were detected */
1946 LPOVERLAPPED lpOverlapped) /* [in/out] for Asynchronous waiting */
1947 {
1948 int fd;
1949 async_commio* commio;
1950 NTSTATUS status;
1951
1952 if (!lpOverlapped)
1953 {
1954 SetLastError(ERROR_INVALID_PARAMETER);
1955 return FALSE;
1956 }
1957
1958 if (NtResetEvent(lpOverlapped->hEvent,NULL))
1959 return FALSE;
1960
1961 fd = get_comm_fd( hFile, GENERIC_WRITE );
1962 if (fd < 0) return FALSE;
1963
1964 commio = (async_commio*) HeapAlloc(GetProcessHeap(), 0, sizeof (async_commio));
1965 if (!commio)
1966 {
1967 release_comm_fd( hFile, fd );
1968 return FALSE;
1969 }
1970
1971 commio->handle = hFile;
1972 commio->type = ASYNC_TYPE_WAIT;
1973 commio->apc_internal = COMM_WaitCommEventService;
1974 commio->buffer = (char *)lpdwEvents;
1975 commio->fd = fd; /* FIXME */
1976
1977 lpOverlapped->InternalHigh = 0;
1978 lpOverlapped->Offset = 0;
1979 lpOverlapped->OffsetHigh = 0;
1980
1981 SERVER_START_REQ( register_async )
1982 {
1983 req->handle = hFile;
1984 req->io_apc = COMM_WaitCommEventService;
1985 req->io_user = commio;
1986 req->io_sb = (IO_STATUS_BLOCK*)lpOverlapped;
1987 req->count = 0;
1988 status = wine_server_call( req );
1989 }
1990 SERVER_END_REQ;
1991
1992 if ( status ) SetLastError( RtlNtStatusToDosError(status) );
1993 else NtCurrentTeb()->num_async_io++;
1994
1995 return FALSE;
1996 }
1997
1998 /***********************************************************************
1999 * WaitCommEvent (KERNEL32.@)
2000 *
2001 * Wait until something interesting happens on a COMM port.
2002 * Interesting things (events) are set by calling SetCommMask before
2003 * this function is called.
2004 *
2005 * RETURNS:
2006 * TRUE if successful
2007 * FALSE if failure
2008 *
2009 * The set of detected events will be written to *lpdwEventMask
2010 * ERROR_IO_PENDING will be returned the overlapped structure was passed
2011 *
2012 * BUGS:
2013 * Only supports EV_RXCHAR and EV_TXEMPTY
2014 */
2015 BOOL WINAPI WaitCommEvent(
2016 HANDLE hFile, /* [in] handle of comm port to wait for */
2017 LPDWORD lpdwEvents, /* [out] event(s) that were detected */
2018 LPOVERLAPPED lpOverlapped) /* [in/out] for Asynchronous waiting */
2019 {
2020 OVERLAPPED ov;
2021 int ret;
2022
2023 TRACE("(%p %p %p )\n",hFile, lpdwEvents,lpOverlapped);
2024
2025 if(lpOverlapped)
2026 return COMM_WaitCommEvent(hFile, lpdwEvents, lpOverlapped);
2027
2028 /* if there is no overlapped structure, create our own */
2029 ov.hEvent = CreateEventW(NULL,FALSE,FALSE,NULL);
2030
2031 COMM_WaitCommEvent(hFile, lpdwEvents, &ov);
2032
2033 /* wait for the overlapped to complete */
2034 ret = GetOverlappedResult(hFile, &ov, NULL, TRUE);
2035 CloseHandle(ov.hEvent);
2036
2037 return ret;
2038 }
2039
2040 /***********************************************************************
2041 * GetCommProperties (KERNEL32.@)
2042 *
2043 * This function fills in a structure with the capabilities of the
2044 * communications port driver.
2045 *
2046 * RETURNS
2047 *
2048 * TRUE on success, FALSE on failure
2049 * If successful, the lpCommProp structure be filled in with
2050 * properties of the comm port.
2051 */
2052 BOOL WINAPI GetCommProperties(
2053 HANDLE hFile, /* [in] handle of the comm port */
2054 LPCOMMPROP lpCommProp) /* [out] pointer to struct to be filled */
2055 {
2056 FIXME("(%p %p )\n",hFile,lpCommProp);
2057 if(!lpCommProp)
2058 return FALSE;
2059
2060 /*
2061 * These values should be valid for LINUX's serial driver
2062 * FIXME: Perhaps they deserve an #ifdef LINUX
2063 */
2064 memset(lpCommProp,0,sizeof(COMMPROP));
2065 lpCommProp->wPacketLength = 1;
2066 lpCommProp->wPacketVersion = 1;
2067 lpCommProp->dwServiceMask = SP_SERIALCOMM;
2068 lpCommProp->dwReserved1 = 0;
2069 lpCommProp->dwMaxTxQueue = 4096;
2070 lpCommProp->dwMaxRxQueue = 4096;
2071 lpCommProp->dwMaxBaud = BAUD_115200;
2072 lpCommProp->dwProvSubType = PST_RS232;
2073 lpCommProp->dwProvCapabilities = PCF_DTRDSR | PCF_PARITY_CHECK | PCF_RTSCTS | PCF_TOTALTIMEOUTS;
2074 lpCommProp->dwSettableParams = SP_BAUD | SP_DATABITS | SP_HANDSHAKING |
2075 SP_PARITY | SP_PARITY_CHECK | SP_STOPBITS ;
2076 lpCommProp->dwSettableBaud = BAUD_075 | BAUD_110 | BAUD_134_5 | BAUD_150 |
2077 BAUD_300 | BAUD_600 | BAUD_1200 | BAUD_1800 | BAUD_2400 | BAUD_4800 |
2078 BAUD_9600 | BAUD_19200 | BAUD_38400 | BAUD_57600 | BAUD_115200 ;
2079 lpCommProp->wSettableData = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8 ;
2080 lpCommProp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
2081 PARITY_NONE | PARITY_ODD |PARITY_EVEN | PARITY_MARK | PARITY_SPACE;
2082 lpCommProp->dwCurrentTxQueue = lpCommProp->dwMaxTxQueue;
2083 lpCommProp->dwCurrentRxQueue = lpCommProp->dwMaxRxQueue;
2084
2085 return TRUE;
2086 }
2087
2088 /***********************************************************************
2089 * FIXME:
2090 * The functionality of CommConfigDialogA, GetDefaultCommConfig and
2091 * SetDefaultCommConfig is implemented in a DLL (usually SERIALUI.DLL).
2092 * This is dependent on the type of COMM port, but since it is doubtful
2093 * anybody will get around to implementing support for fancy serial
2094 * ports in WINE, this is hardcoded for the time being. The name of
2095 * this DLL should be stored in and read from the system registry in
2096 * the hive HKEY_LOCAL_MACHINE, key
2097 * System\\CurrentControlSet\\Services\\Class\\Ports\\????
2098 * where ???? is the port number... that is determined by PNP
2099 * The DLL should be loaded when the COMM port is opened, and closed
2100 * when the COMM port is closed. - MJM 20 June 2000
2101 ***********************************************************************/
2102 static WCHAR lpszSerialUI[] = {
2103 's','e','r','i','a','l','u','i','.','d','l','l',0 };
2104
2105
2106 /***********************************************************************
2107 * CommConfigDialogA (KERNEL32.@)
2108 *
2109 * Raises a dialog that allows the user to configure a comm port.
2110 * Fills the COMMCONFIG struct with information specified by the user.
2111 * This function should call a similar routine in the COMM driver...
2112 *
2113 * RETURNS
2114 *
2115 * TRUE on success, FALSE on failure
2116 * If successful, the lpCommConfig structure will contain a new
2117 * configuration for the comm port, as specified by the user.
2118 *
2119 * BUGS
2120 * The library with the CommConfigDialog code is never unloaded.
2121 * Perhaps this should be done when the comm port is closed?
2122 */
2123 BOOL WINAPI CommConfigDialogA(
2124 LPCSTR lpszDevice, /* [in] name of communications device */
2125 HANDLE hWnd, /* [in] parent window for the dialog */
2126 LPCOMMCONFIG lpCommConfig) /* [out] pointer to struct to fill */
2127 {
2128 FARPROC lpfnCommDialog;
2129 HMODULE hConfigModule;
2130 BOOL r = FALSE;
2131
2132 TRACE("(%p %p %p)\n",lpszDevice, hWnd, lpCommConfig);
2133
2134 hConfigModule = LoadLibraryW(lpszSerialUI);
2135 if(!hConfigModule)
2136 return FALSE;
2137
2138 lpfnCommDialog = GetProcAddress(hConfigModule, "drvCommConfigDialogA");
2139
2140 if(lpfnCommDialog)
2141 r = lpfnCommDialog(lpszDevice,hWnd,lpCommConfig);
2142
2143 FreeLibrary(hConfigModule);
2144
2145 return r;
2146 }
2147
2148 /***********************************************************************
2149 * CommConfigDialogW (KERNEL32.@)
2150 *
2151 * see CommConfigDialogA for more info
2152 */
2153 BOOL WINAPI CommConfigDialogW(
2154 LPCWSTR lpszDevice, /* [in] name of communications device */
2155 HANDLE hWnd, /* [in] parent window for the dialog */
2156 LPCOMMCONFIG lpCommConfig) /* [out] pointer to struct to fill */
2157 {
2158 FARPROC lpfnCommDialog;
2159 HMODULE hConfigModule;
2160 BOOL r = FALSE;
2161
2162 TRACE("(%p %p %p)\n",lpszDevice, hWnd, lpCommConfig);
2163
2164 hConfigModule = LoadLibraryW(lpszSerialUI);
2165 if(!hConfigModule)
2166 return FALSE;
2167
2168 lpfnCommDialog = GetProcAddress(hConfigModule, "drvCommConfigDialogW");
2169
2170 if(lpfnCommDialog)
2171 r = lpfnCommDialog(lpszDevice,hWnd,lpCommConfig);
2172
2173 FreeLibrary(hConfigModule);
2174
2175 return r;
2176 }
2177
2178 /***********************************************************************
2179 * GetCommConfig (KERNEL32.@)
2180 *
2181 * Fill in the COMMCONFIG structure for the comm port hFile
2182 *
2183 * RETURNS
2184 *
2185 * TRUE on success, FALSE on failure
2186 * If successful, lpCommConfig contains the comm port configuration.
2187 *
2188 * BUGS
2189 *
2190 */
2191 BOOL WINAPI GetCommConfig(
2192 HANDLE hFile, /* [in] The communications device. */
2193 LPCOMMCONFIG lpCommConfig, /* [out] The communications configuration of the device (if it fits). */
2194 LPDWORD lpdwSize) /* [in/out] Initially the size of the configuration buffer/structure,
2195 afterwards the number of bytes copied to the buffer or
2196 the needed size of the buffer. */
2197 {
2198 BOOL r;
2199
2200 TRACE("(%p %p)\n",hFile,lpCommConfig);
2201
2202 if(lpCommConfig == NULL)
2203 return FALSE;
2204 r = *lpdwSize < sizeof(COMMCONFIG); /* TRUE if not enough space */
2205 *lpdwSize = sizeof(COMMCONFIG);
2206 if(r)
2207 return FALSE;
2208
2209 lpCommConfig->dwSize = sizeof(COMMCONFIG);
2210 lpCommConfig->wVersion = 1;
2211 lpCommConfig->wReserved = 0;
2212 r = GetCommState(hFile,&lpCommConfig->dcb);
2213 lpCommConfig->dwProviderSubType = PST_RS232;
2214 lpCommConfig->dwProviderOffset = 0;
2215 lpCommConfig->dwProviderSize = 0;
2216
2217 return r;
2218 }
2219
2220 /***********************************************************************
2221 * SetCommConfig (KERNEL32.@)
2222 *
2223 * Sets the configuration of the communications device.
2224 *
2225 * RETURNS
2226 *
2227 * True on success, false if the handle was bad is not a communications device.
2228 */
2229 BOOL WINAPI SetCommConfig(
2230 HANDLE hFile, /* [in] The communications device. */
2231 LPCOMMCONFIG lpCommConfig, /* [in] The desired configuration. */
2232 DWORD dwSize) /* [in] size of the lpCommConfig struct */
2233 {
2234 TRACE("(%p %p)\n",hFile,lpCommConfig);
2235 return SetCommState(hFile,&lpCommConfig->dcb);
2236 }
2237
2238 /***********************************************************************
2239 * SetDefaultCommConfigA (KERNEL32.@)
2240 *
2241 * Initializes the default configuration for the specified communication
2242 * device. (ascii)
2243 *
2244 * RETURNS
2245 *
2246 * True if the device was found and the defaults set, false otherwise
2247 */
2248 BOOL WINAPI SetDefaultCommConfigW(
2249 LPCWSTR lpszDevice, /* [in] The ascii name of the device targeted for configuration. */
2250 LPCOMMCONFIG lpCommConfig, /* [in] The default configuration for the device. */
2251 DWORD dwSize) /* [in] The number of bytes in the configuration structure. */
2252 {
2253 FARPROC lpfnSetDefaultCommConfig;
2254 HMODULE hConfigModule;
2255 BOOL r = FALSE;
2256
2257 TRACE("(%p %p %lx)\n",lpszDevice, lpCommConfig, dwSize);
2258
2259 hConfigModule = LoadLibraryW(lpszSerialUI);
2260 if(!hConfigModule)
2261 return r;
2262
2263 lpfnSetDefaultCommConfig = GetProcAddress(hConfigModule, "drvSetDefaultCommConfigW");
2264 if (lpfnSetDefaultCommConfig)
2265 r = lpfnSetDefaultCommConfig(lpszDevice, lpCommConfig, dwSize);
2266
2267 FreeLibrary(hConfigModule);
2268
2269 return r;
2270 }
2271
2272
2273 /***********************************************************************
2274 * SetDefaultCommConfigW (KERNEL32.@)
2275 *
2276 * Initializes the default configuration for the specified
2277 * communication device. (unicode)
2278 *
2279 * RETURNS
2280 *
2281 */
2282 BOOL WINAPI SetDefaultCommConfigA(
2283 LPCSTR lpszDevice, /* [in] The unicode name of the device targeted for configuration. */
2284 LPCOMMCONFIG lpCommConfig, /* [in] The default configuration for the device. */
2285 DWORD dwSize) /* [in] The number of bytes in the configuration structure. */
2286 {
2287 BOOL r;
2288 LPWSTR lpDeviceW = NULL;
2289 DWORD len;
2290
2291 TRACE("(%s %p %lx)\n",debugstr_a(lpszDevice),lpCommConfig,dwSize);
2292
2293 if (lpszDevice)
2294 {
2295 len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
2296 lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
2297 MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
2298 }
2299 r = SetDefaultCommConfigW(lpDeviceW,lpCommConfig,dwSize);
2300 HeapFree( GetProcessHeap(), 0, lpDeviceW );
2301 return r;
2302 }
2303
2304
2305 /***********************************************************************
2306 * GetDefaultCommConfigW (KERNEL32.@)
2307 *
2308 * Acquires the default configuration of the specified communication device. (unicode)
2309 *
2310 * RETURNS
2311 *
2312 * True on successful reading of the default configuration,
2313 * if the device is not found or the buffer is too small.
2314 */
2315 BOOL WINAPI GetDefaultCommConfigW(
2316 LPCWSTR lpszName, /* [in] The unicode name of the device targeted for configuration. */
2317 LPCOMMCONFIG lpCC, /* [out] The default configuration for the device. */
2318 LPDWORD lpdwSize) /* [in/out] Initially the size of the default configuration buffer,
2319 afterwards the number of bytes copied to the buffer or
2320 the needed size of the buffer. */
2321 {
2322 LPDCB lpdcb = &(lpCC->dcb);
2323 WCHAR temp[40];
2324 static const WCHAR comW[] = {'C','O','M',0};
2325 static const WCHAR formatW[] = {'C','O','M','%','c',':','3','8','4','0','0',',','n',',','8',',','1',0};
2326
2327 if (strncmpiW(lpszName,comW,3)) {
2328 ERR("not implemented for <%s>\n", debugstr_w(lpszName));
2329 return FALSE;
2330 }
2331
2332 TRACE("(%s %p %ld)\n", debugstr_w(lpszName), lpCC, *lpdwSize );
2333 if (*lpdwSize < sizeof(COMMCONFIG)) {
2334 *lpdwSize = sizeof(COMMCONFIG);
2335 return FALSE;
2336 }
2337
2338 *lpdwSize = sizeof(COMMCONFIG);
2339
2340 lpCC->dwSize = sizeof(COMMCONFIG);
2341 lpCC->wVersion = 1;
2342 lpCC->dwProviderSubType = PST_RS232;
2343 lpCC->dwProviderOffset = 0L;
2344 lpCC->dwProviderSize = 0L;
2345
2346 sprintfW( temp, formatW, lpszName[3]);
2347 FIXME("setting %s as default\n", debugstr_w(temp));
2348
2349 return BuildCommDCBW( temp, lpdcb);
2350 }
2351
2352 /**************************************************************************
2353 * GetDefaultCommConfigA (KERNEL32.@)
2354 *
2355 * Acquires the default configuration of the specified communication device. (ascii)
2356 *
2357 * RETURNS
2358 *
2359 * True on successful reading of the default configuration,
2360 * if the device is not found or the buffer is too small.
2361 */
2362 BOOL WINAPI GetDefaultCommConfigA(
2363 LPCSTR lpszName, /* [in] The ascii name of the device targeted for configuration. */
2364 LPCOMMCONFIG lpCC, /* [out] The default configuration for the device. */
2365 LPDWORD lpdwSize) /* [in/out] Initially the size of the default configuration buffer,
2366 afterwards the number of bytes copied to the buffer or
2367 the needed size of the buffer. */
2368 {
2369 BOOL ret = FALSE;
2370 UNICODE_STRING lpszNameW;
2371
2372 TRACE("(%s,%p,%ld)\n",lpszName,lpCC,*lpdwSize);
2373 if(lpszName) RtlCreateUnicodeStringFromAsciiz(&lpszNameW,lpszName);
2374 else lpszNameW.Buffer = NULL;
2375
2376 if(lpszNameW.Buffer) ret = GetDefaultCommConfigW(lpszNameW.Buffer,lpCC,lpdwSize);
2377
2378 RtlFreeUnicodeString(&lpszNameW);
2379 return ret;
2380 }
widl and rpcrt4 development