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