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