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