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