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