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