ntdll/tests: Replace malloc() with HeapAlloc().
[wine] / dlls / ntdll / serial.c
1 /* Main file for COMM support
2  *
3  * DEC 93 Erik Bos <erik@xs4all.nl>
4  * Copyright 1996 Marcus Meissner
5  * Copyright 2005,2006 Eric Pouech
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <errno.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #ifdef HAVE_STRINGS_H
31 # include <strings.h>
32 #endif
33 #ifdef HAVE_TERMIOS_H
34 #include <termios.h>
35 #endif
36 #ifdef HAVE_IO_H
37 # include <io.h>
38 #endif
39 #ifdef HAVE_UNISTD_H
40 # include <unistd.h>
41 #endif
42 #include <fcntl.h>
43 #ifdef HAVE_SYS_STAT_H
44 # include <sys/stat.h>
45 #endif
46 #include <sys/types.h>
47 #ifdef HAVE_SYS_FILIO_H
48 # include <sys/filio.h>
49 #endif
50 #ifdef HAVE_SYS_IOCTL_H
51 #include <sys/ioctl.h>
52 #endif
53 #ifdef HAVE_SYS_POLL_H
54 # include <sys/poll.h>
55 #endif
56 #ifdef HAVE_SYS_MODEM_H
57 # include <sys/modem.h>
58 #endif
59 #ifdef HAVE_SYS_STRTIO_H
60 # include <sys/strtio.h>
61 #endif
62
63 #define NONAMELESSUNION
64 #define NONAMELESSSTRUCT
65 #include "ntstatus.h"
66 #define WIN32_NO_STATUS
67 #include "windef.h"
68 #include "winternl.h"
69 #include "winioctl.h"
70 #include "ddk/ntddser.h"
71 #include "ntdll_misc.h"
72 #include "wine/server.h"
73 #include "wine/library.h"
74 #include "wine/debug.h"
75
76 #ifdef HAVE_LINUX_SERIAL_H
77 #ifdef HAVE_ASM_TYPES_H
78 #include <asm/types.h>
79 #endif
80 #include <linux/serial.h>
81 #endif
82
83 #if !defined(TIOCINQ) && defined(FIONREAD)
84 #define TIOCINQ FIONREAD
85 #endif
86
87 WINE_DEFAULT_DEBUG_CHANNEL(comm);
88
89 static const char* iocode2str(DWORD ioc)
90 {
91     switch (ioc)
92     {
93 #define X(x)    case (x): return #x
94         X(IOCTL_SERIAL_CLEAR_STATS);
95         X(IOCTL_SERIAL_CLR_DTR);
96         X(IOCTL_SERIAL_CLR_RTS);
97         X(IOCTL_SERIAL_CONFIG_SIZE);
98         X(IOCTL_SERIAL_GET_BAUD_RATE);
99         X(IOCTL_SERIAL_GET_CHARS);
100         X(IOCTL_SERIAL_GET_COMMSTATUS);
101         X(IOCTL_SERIAL_GET_DTRRTS);
102         X(IOCTL_SERIAL_GET_HANDFLOW);
103         X(IOCTL_SERIAL_GET_LINE_CONTROL);
104         X(IOCTL_SERIAL_GET_MODEM_CONTROL);
105         X(IOCTL_SERIAL_GET_MODEMSTATUS);
106         X(IOCTL_SERIAL_GET_PROPERTIES);
107         X(IOCTL_SERIAL_GET_STATS);
108         X(IOCTL_SERIAL_GET_TIMEOUTS);
109         X(IOCTL_SERIAL_GET_WAIT_MASK);
110         X(IOCTL_SERIAL_IMMEDIATE_CHAR);
111         X(IOCTL_SERIAL_LSRMST_INSERT);
112         X(IOCTL_SERIAL_PURGE);
113         X(IOCTL_SERIAL_RESET_DEVICE);
114         X(IOCTL_SERIAL_SET_BAUD_RATE);
115         X(IOCTL_SERIAL_SET_BREAK_ON);
116         X(IOCTL_SERIAL_SET_BREAK_OFF);
117         X(IOCTL_SERIAL_SET_CHARS);
118         X(IOCTL_SERIAL_SET_DTR);
119         X(IOCTL_SERIAL_SET_FIFO_CONTROL);
120         X(IOCTL_SERIAL_SET_HANDFLOW);
121         X(IOCTL_SERIAL_SET_LINE_CONTROL);
122         X(IOCTL_SERIAL_SET_MODEM_CONTROL);
123         X(IOCTL_SERIAL_SET_QUEUE_SIZE);
124         X(IOCTL_SERIAL_SET_RTS);
125         X(IOCTL_SERIAL_SET_TIMEOUTS);
126         X(IOCTL_SERIAL_SET_WAIT_MASK);
127         X(IOCTL_SERIAL_SET_XOFF);
128         X(IOCTL_SERIAL_SET_XON);
129         X(IOCTL_SERIAL_WAIT_ON_MASK);
130         X(IOCTL_SERIAL_XOFF_COUNTER);
131 #undef X
132     default: { static char tmp[32]; sprintf(tmp, "IOCTL_SERIAL_%d\n", ioc); return tmp; }
133     }
134 }
135
136 static NTSTATUS get_baud_rate(int fd, SERIAL_BAUD_RATE* sbr)
137 {
138     struct termios port;
139     int speed;
140     
141     if (tcgetattr(fd, &port) == -1)
142     {
143         ERR("tcgetattr error '%s'\n", strerror(errno));
144         return FILE_GetNtStatus();
145     }
146 #ifndef __EMX__
147 #ifdef CBAUD
148     speed = port.c_cflag & CBAUD;
149 #else
150     speed = cfgetospeed(&port);
151 #endif
152     switch (speed)
153     {
154     case B0:            sbr->BaudRate = 0;      break;
155     case B50:           sbr->BaudRate = 50;     break;
156     case B75:           sbr->BaudRate = 75;     break;
157     case B110:          sbr->BaudRate = 110;    break;
158     case B134:          sbr->BaudRate = 134;    break;
159     case B150:          sbr->BaudRate = 150;    break;
160     case B200:          sbr->BaudRate = 200;    break;
161     case B300:          sbr->BaudRate = 300;    break;
162     case B600:          sbr->BaudRate = 600;    break;
163     case B1200:         sbr->BaudRate = 1200;   break;
164     case B1800:         sbr->BaudRate = 1800;   break;
165     case B2400:         sbr->BaudRate = 2400;   break;
166     case B4800:         sbr->BaudRate = 4800;   break;
167     case B9600:         sbr->BaudRate = 9600;   break;
168     case B19200:        sbr->BaudRate = 19200;  break;
169     case B38400:        sbr->BaudRate = 38400;  break;
170 #ifdef B57600
171     case B57600:        sbr->BaudRate = 57600;  break;
172 #endif
173 #ifdef B115200
174     case B115200:       sbr->BaudRate = 115200; break;
175 #endif
176 #ifdef B230400
177     case B230400:       sbr->BaudRate = 230400; break;
178 #endif
179 #ifdef B460800
180     case B460800:       sbr->BaudRate = 460800; break;
181 #endif
182     default:
183         ERR("unknown speed %x\n", speed);
184         return STATUS_INVALID_PARAMETER;
185     }
186 #else
187     return STATUS_INVALID_PARAMETER;
188 #endif
189     return STATUS_SUCCESS;
190 }
191
192 static NTSTATUS get_hand_flow(int fd, SERIAL_HANDFLOW* shf)
193 {
194     int stat = 0;
195     struct termios port;
196
197     if (tcgetattr(fd, &port) == -1)
198     {
199         ERR("tcgetattr error '%s'\n", strerror(errno));
200         return FILE_GetNtStatus();
201     }
202     /* termios does not support DTR/DSR flow control */
203     shf->ControlHandShake = 0;
204     shf->FlowReplace = 0;
205 #ifdef TIOCMGET
206     if (ioctl(fd, TIOCMGET, &stat) == -1)
207     {
208         WARN("ioctl error '%s'\n", strerror(errno));
209         shf->ControlHandShake |= SERIAL_DTR_CONTROL;
210         shf->FlowReplace |= SERIAL_RTS_CONTROL;
211     }
212 #else
213     WARN("Setting DTR/RTS to enabled by default\n");
214     shf->ControlHandShake |= SERIAL_DTR_CONTROL;
215     shf->FlowReplace |= SERIAL_RTS_CONTROL;
216 #endif
217 #ifdef TIOCM_DTR
218     if (stat & TIOCM_DTR)
219 #endif
220         shf->ControlHandShake |= SERIAL_DTR_CONTROL;
221 #ifdef CRTSCTS
222     if (port.c_cflag & CRTSCTS)
223     {
224         shf->FlowReplace |= SERIAL_RTS_CONTROL;
225         shf->ControlHandShake |= SERIAL_CTS_HANDSHAKE;
226     }
227     else
228 #endif
229     {
230 #ifdef TIOCM_RTS
231         if (stat & TIOCM_RTS)
232 #endif
233             shf->FlowReplace |= SERIAL_RTS_CONTROL;
234     }
235     if (port.c_iflag & IXOFF)
236         shf->FlowReplace |= SERIAL_AUTO_RECEIVE;
237     if (port.c_iflag & IXON)
238         shf->FlowReplace |= SERIAL_AUTO_TRANSMIT;
239
240     shf->XonLimit = 10;
241     shf->XoffLimit = 10;
242     return STATUS_SUCCESS;
243 }
244
245 static NTSTATUS get_line_control(int fd, SERIAL_LINE_CONTROL* slc)
246 {
247     struct termios port;
248     
249     if (tcgetattr(fd, &port) == -1)
250     {
251         ERR("tcgetattr error '%s'\n", strerror(errno));
252         return FILE_GetNtStatus();
253     }
254     
255 #ifdef CMSPAR
256     switch (port.c_cflag & (PARENB | PARODD | CMSPAR))
257 #else
258     switch (port.c_cflag & (PARENB | PARODD))
259 #endif
260     {
261     case 0:                     slc->Parity = NOPARITY;         break;
262     case PARENB:                slc->Parity = EVENPARITY;       break;
263     case PARENB|PARODD:         slc->Parity = ODDPARITY;        break;
264 #ifdef CMSPAR
265     case PARENB|CMSPAR:         slc->Parity = MARKPARITY;       break;
266     case PARENB|PARODD|CMSPAR:  slc->Parity = SPACEPARITY;      break;
267 #endif
268     }
269     switch (port.c_cflag & CSIZE)
270     {
271     case CS5:   slc->WordLength = 5;    break;
272     case CS6:   slc->WordLength = 6;    break;
273     case CS7:   slc->WordLength = 7;    break;
274     case CS8:   slc->WordLength = 8;    break;
275     default: ERR("unknown size %x\n", (UINT)(port.c_cflag & CSIZE));
276     }
277
278     if (port.c_cflag & CSTOPB)
279     {
280         if (slc->WordLength == 5)
281             slc->StopBits = ONE5STOPBITS;
282         else
283             slc->StopBits = TWOSTOPBITS;
284     }
285     else
286         slc->StopBits = ONESTOPBIT;
287
288     return STATUS_SUCCESS;
289 }
290
291 static NTSTATUS get_modem_status(int fd, DWORD* lpModemStat)
292 {
293     NTSTATUS    status = STATUS_NOT_SUPPORTED;
294     int         mstat;
295
296     *lpModemStat = 0;
297 #ifdef TIOCMGET
298     if (!ioctl(fd, TIOCMGET, &mstat))
299     {
300 #ifdef TIOCM_CTS
301         if (mstat & TIOCM_CTS)  *lpModemStat |= MS_CTS_ON;
302 #endif
303 #ifdef TIOCM_DSR
304         if (mstat & TIOCM_DSR)  *lpModemStat |= MS_DSR_ON;
305 #endif
306 #ifdef TIOCM_RNG
307         if (mstat & TIOCM_RNG)  *lpModemStat |= MS_RING_ON;
308 #endif
309 #ifdef TIOCM_CAR
310         /* FIXME: Not really sure about RLSD UB 990810 */
311         if (mstat & TIOCM_CAR)  *lpModemStat |= MS_RLSD_ON;
312 #endif
313         TRACE("%04x -> %s%s%s%s\n", mstat,
314               (*lpModemStat & MS_RLSD_ON) ? "MS_RLSD_ON " : "",
315               (*lpModemStat & MS_RING_ON) ? "MS_RING_ON " : "",
316               (*lpModemStat & MS_DSR_ON)  ? "MS_DSR_ON  " : "",
317               (*lpModemStat & MS_CTS_ON)  ? "MS_CTS_ON  " : "");
318         return STATUS_SUCCESS;
319     }
320     WARN("ioctl failed\n");
321     status = FILE_GetNtStatus();
322 #endif
323     return status;
324 }
325
326 static NTSTATUS get_special_chars(int fd, SERIAL_CHARS* sc)
327 {
328     struct termios port;
329     
330     if (tcgetattr(fd, &port) == -1)
331     {
332         ERR("tcgetattr error '%s'\n", strerror(errno));
333         return FILE_GetNtStatus();
334     }
335     sc->EofChar   = port.c_cc[VEOF];
336     sc->ErrorChar = 0xFF;
337     sc->BreakChar = 0; /* FIXME */
338     sc->EventChar = 0; /* FIXME */
339     sc->XonChar   = port.c_cc[VSTART];
340     sc->XoffChar  = port.c_cc[VSTOP];
341
342     return STATUS_SUCCESS;
343 }
344
345 static NTSTATUS get_status(int fd, SERIAL_STATUS* ss)
346 {
347     NTSTATUS    status = STATUS_SUCCESS;
348
349     ss->Errors = 0;
350     ss->HoldReasons = 0;
351     ss->EofReceived = FALSE;
352     ss->WaitForImmediate = FALSE;
353 #ifdef TIOCOUTQ
354     if (ioctl(fd, TIOCOUTQ, &ss->AmountInOutQueue) == -1)
355     {
356         WARN("ioctl returned error\n");
357         status = FILE_GetNtStatus();
358     }
359 #else
360     ss->AmountInOutQueue = 0; /* FIXME: find a different way to find out */
361 #endif
362
363 #ifdef TIOCINQ
364     if (ioctl(fd, TIOCINQ, &ss->AmountInInQueue))
365     {
366         WARN("ioctl returned error\n");
367         status = FILE_GetNtStatus();
368     }
369 #else
370     ss->AmountInInQueue = 0; /* FIXME: find a different way to find out */
371 #endif
372     return status;
373 }
374
375 static NTSTATUS get_timeouts(HANDLE handle, SERIAL_TIMEOUTS* st)
376 {
377     NTSTATUS    status;
378     SERVER_START_REQ( get_serial_info )
379     {
380         req->handle = wine_server_obj_handle( handle );
381         if (!(status = wine_server_call( req )))
382         {
383             st->ReadIntervalTimeout         = reply->readinterval;
384             st->ReadTotalTimeoutMultiplier  = reply->readmult;
385             st->ReadTotalTimeoutConstant    = reply->readconst;
386             st->WriteTotalTimeoutMultiplier = reply->writemult;
387             st->WriteTotalTimeoutConstant   = reply->writeconst;
388         }
389     }
390     SERVER_END_REQ;
391     return status;
392 }
393
394 static NTSTATUS get_wait_mask(HANDLE hDevice, DWORD* mask)
395 {
396     NTSTATUS    status;
397
398     SERVER_START_REQ( get_serial_info )
399     {
400         req->handle = wine_server_obj_handle( hDevice );
401         if (!(status = wine_server_call( req )))
402             *mask = reply->eventmask;
403     }
404     SERVER_END_REQ;
405     return status;
406 }
407
408 static NTSTATUS purge(int fd, DWORD flags)
409 {
410     /*
411     ** not exactly sure how these are different
412     ** Perhaps if we had our own internal queues, one flushes them
413     ** and the other flushes the kernel's buffers.
414     */
415     if (flags & PURGE_TXABORT) tcflush(fd, TCOFLUSH);
416     if (flags & PURGE_RXABORT) tcflush(fd, TCIFLUSH);
417     if (flags & PURGE_TXCLEAR) tcflush(fd, TCOFLUSH);
418     if (flags & PURGE_RXCLEAR) tcflush(fd, TCIFLUSH);
419     return STATUS_SUCCESS;
420 }
421
422 static NTSTATUS set_baud_rate(int fd, const SERIAL_BAUD_RATE* sbr)
423 {
424     struct termios port;
425
426     if (tcgetattr(fd, &port) == -1)
427     {
428         ERR("tcgetattr error '%s'\n", strerror(errno));
429         return FILE_GetNtStatus();
430     }
431
432 #ifdef CBAUD
433     port.c_cflag &= ~CBAUD;
434     switch (sbr->BaudRate)
435     {
436     case 0:             port.c_cflag |= B0;     break;
437     case 50:            port.c_cflag |= B50;    break;
438     case 75:            port.c_cflag |= B75;    break;
439     case 110:   
440     case CBR_110:       port.c_cflag |= B110;   break;
441     case 134:           port.c_cflag |= B134;   break;
442     case 150:           port.c_cflag |= B150;   break;
443     case 200:           port.c_cflag |= B200;   break;
444     case 300:           
445     case CBR_300:       port.c_cflag |= B300;   break;
446     case 600:
447     case CBR_600:       port.c_cflag |= B600;   break;
448     case 1200:
449     case CBR_1200:      port.c_cflag |= B1200;  break;
450     case 1800:          port.c_cflag |= B1800;  break;
451     case 2400:
452     case CBR_2400:      port.c_cflag |= B2400;  break;
453     case 4800:
454     case CBR_4800:      port.c_cflag |= B4800;  break;
455     case 9600:
456     case CBR_9600:      port.c_cflag |= B9600;  break;
457     case 19200:
458     case CBR_19200:     port.c_cflag |= B19200; break;
459     case 38400:
460     case CBR_38400:     port.c_cflag |= B38400; break;
461 #ifdef B57600
462     case 57600:         port.c_cflag |= B57600; break;
463 #endif
464 #ifdef B115200
465     case 115200:        port.c_cflag |= B115200;break;
466 #endif
467 #ifdef B230400
468     case 230400:        port.c_cflag |= B230400;break;
469 #endif
470 #ifdef B460800
471     case 460800:        port.c_cflag |= B460800;break;
472 #endif
473     default:
474 #if defined (HAVE_LINUX_SERIAL_H) && defined (TIOCSSERIAL)
475         {
476             struct serial_struct nuts;
477             int arby;
478         
479             ioctl(fd, TIOCGSERIAL, &nuts);
480             nuts.custom_divisor = nuts.baud_base / sbr->BaudRate;
481             if (!(nuts.custom_divisor)) nuts.custom_divisor = 1;
482             arby = nuts.baud_base / nuts.custom_divisor;
483             nuts.flags &= ~ASYNC_SPD_MASK;
484             nuts.flags |= ASYNC_SPD_CUST;
485             WARN("You (or a program acting at your behest) have specified\n"
486                  "a non-standard baud rate %d.  Wine will set the rate to %d,\n"
487                  "which is as close as we can get by our present understanding of your\n"
488                  "hardware. I hope you know what you are doing.  Any disruption Wine\n"
489                  "has caused to your linux system can be undone with setserial\n"
490                  "(see man setserial). If you have incapacitated a Hayes type modem,\n"
491                  "reset it and it will probably recover.\n", sbr->BaudRate, arby);
492             ioctl(fd, TIOCSSERIAL, &nuts);
493             port.c_cflag |= B38400;
494         }
495         break;
496 #else     /* Don't have linux/serial.h or lack TIOCSSERIAL */
497         ERR("baudrate %d\n", sbr->BaudRate);
498         return STATUS_NOT_SUPPORTED;
499 #endif    /* Don't have linux/serial.h or lack TIOCSSERIAL */
500     }
501 #elif !defined(__EMX__)
502     switch (sbr->BaudRate)
503     {
504     case 0:             port.c_ospeed = B0;     break;
505     case 50:            port.c_ospeed = B50;    break;
506     case 75:            port.c_ospeed = B75;    break;
507     case 110:
508     case CBR_110:       port.c_ospeed = B110;   break;
509     case 134:           port.c_ospeed = B134;   break;
510     case 150:           port.c_ospeed = B150;   break;
511     case 200:           port.c_ospeed = B200;   break;
512     case 300:
513     case CBR_300:       port.c_ospeed = B300;   break;
514     case 600:
515     case CBR_600:       port.c_ospeed = B600;   break;
516     case 1200:
517     case CBR_1200:      port.c_ospeed = B1200;  break;
518     case 1800:          port.c_ospeed = B1800;  break;
519     case 2400:
520     case CBR_2400:      port.c_ospeed = B2400;  break;
521     case 4800:
522     case CBR_4800:      port.c_ospeed = B4800;  break;
523     case 9600:
524     case CBR_9600:      port.c_ospeed = B9600;  break;
525     case 19200:
526     case CBR_19200:     port.c_ospeed = B19200; break;
527     case 38400:
528     case CBR_38400:     port.c_ospeed = B38400; break;
529 #ifdef B57600
530     case 57600:
531     case CBR_57600:     port.c_cflag |= B57600; break;
532 #endif
533 #ifdef B115200
534     case 115200:
535     case CBR_115200:    port.c_cflag |= B115200;break;
536 #endif
537 #ifdef B230400
538     case 230400:        port.c_cflag |= B230400;break;
539 #endif
540 #ifdef B460800
541     case 460800:        port.c_cflag |= B460800;break;
542 #endif
543     default:
544         ERR("baudrate %d\n", sbr->BaudRate);
545         return STATUS_NOT_SUPPORTED;
546     }
547     port.c_ispeed = port.c_ospeed;
548 #endif
549     if (tcsetattr(fd, TCSANOW, &port) == -1)
550     {
551         ERR("tcsetattr error '%s'\n", strerror(errno));
552         return FILE_GetNtStatus();
553     }
554     return STATUS_SUCCESS;
555 }
556
557 static int whack_modem(int fd, unsigned int andy, unsigned int orrie)
558 {
559 #ifdef TIOCMGET
560     unsigned int mstat, okay;
561     okay = ioctl(fd, TIOCMGET, &mstat);
562     if (okay) return okay;
563     if (andy) mstat &= andy;
564     mstat |= orrie;
565     return ioctl(fd, TIOCMSET, &mstat);
566 #else
567     return 0;
568 #endif
569 }
570
571 static NTSTATUS set_handflow(int fd, const SERIAL_HANDFLOW* shf)
572 {
573     struct termios port;
574
575     if ((shf->FlowReplace & (SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE)) == 
576         (SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE))
577         return STATUS_NOT_SUPPORTED;
578
579     if (tcgetattr(fd, &port) == -1)
580     {
581         ERR("tcgetattr error '%s'\n", strerror(errno));
582         return FILE_GetNtStatus();
583     }
584     
585 #ifdef CRTSCTS
586     if ((shf->ControlHandShake & SERIAL_CTS_HANDSHAKE) ||
587         (shf->FlowReplace & SERIAL_RTS_HANDSHAKE))
588     {
589         port.c_cflag |= CRTSCTS;
590         TRACE("CRTSCTS\n");
591     }
592     else
593         port.c_cflag &= ~CRTSCTS;
594 #endif
595 #ifdef TIOCM_DTR
596     if (shf->ControlHandShake & SERIAL_DTR_HANDSHAKE)
597     {
598         WARN("DSR/DTR flow control not supported\n");
599     } else if (!(shf->ControlHandShake & SERIAL_DTR_CONTROL))
600         whack_modem(fd, ~TIOCM_DTR, 0);
601     else
602         whack_modem(fd, 0, TIOCM_DTR);
603 #endif
604 #ifdef TIOCM_RTS
605     if (!(shf->ControlHandShake & SERIAL_CTS_HANDSHAKE))
606     {
607         if ((shf->FlowReplace & (SERIAL_RTS_CONTROL|SERIAL_RTS_HANDSHAKE)) == 0)
608             whack_modem(fd, ~TIOCM_RTS, 0);
609         else    
610             whack_modem(fd, 0, TIOCM_RTS);
611     }
612 #endif
613
614     if (shf->FlowReplace & SERIAL_AUTO_RECEIVE)
615         port.c_iflag |= IXOFF;
616     else
617         port.c_iflag &= ~IXOFF;
618     if (shf->FlowReplace & SERIAL_AUTO_TRANSMIT)
619         port.c_iflag |= IXON;
620     else
621         port.c_iflag &= ~IXON;
622     if (tcsetattr(fd, TCSANOW, &port) == -1)
623     {
624         ERR("tcsetattr error '%s'\n", strerror(errno));
625         return FILE_GetNtStatus();
626     }
627
628     return STATUS_SUCCESS;
629 }
630
631 static NTSTATUS set_line_control(int fd, const SERIAL_LINE_CONTROL* slc)
632 {
633     struct termios port;
634     unsigned bytesize, stopbits;
635     
636     if (tcgetattr(fd, &port) == -1)
637     {
638         ERR("tcgetattr error '%s'\n", strerror(errno));
639         return FILE_GetNtStatus();
640     }
641     
642 #ifdef IMAXBEL
643     port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|PARMRK|IMAXBEL);
644 #else
645     port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|PARMRK);
646 #endif
647     port.c_iflag |= IGNBRK | INPCK;
648     
649     port.c_oflag &= ~(OPOST);
650     
651     port.c_cflag &= ~(HUPCL);
652     port.c_cflag |= CLOCAL | CREAD;
653     
654     /*
655      * on FreeBSD, turning off ICANON does not disable IEXTEN,
656      * so we must turn it off explicitly. No harm done on Linux.
657      */
658     port.c_lflag &= ~(ICANON|ECHO|ISIG|IEXTEN);
659     port.c_lflag |= NOFLSH;
660     
661     bytesize = slc->WordLength;
662     stopbits = slc->StopBits;
663     
664 #ifdef CMSPAR
665     port.c_cflag &= ~(PARENB | PARODD | CMSPAR);
666 #else
667     port.c_cflag &= ~(PARENB | PARODD);
668 #endif
669
670     /* make sure that reads don't block */
671     port.c_cc[VMIN] = 0;
672     port.c_cc[VTIME] = 0;
673
674     switch (slc->Parity)
675     {
676     case NOPARITY:      port.c_iflag &= ~INPCK;                         break;
677     case ODDPARITY:     port.c_cflag |= PARENB | PARODD;                break;
678     case EVENPARITY:    port.c_cflag |= PARENB;                         break;
679 #ifdef CMSPAR
680         /* Linux defines mark/space (stick) parity */
681     case MARKPARITY:    port.c_cflag |= PARENB | CMSPAR;                break;
682     case SPACEPARITY:   port.c_cflag |= PARENB | PARODD |  CMSPAR;      break;
683 #else
684         /* try the POSIX way */
685     case MARKPARITY:
686         if (slc->StopBits == ONESTOPBIT)
687         {
688             stopbits = TWOSTOPBITS;
689             port.c_iflag &= ~INPCK;
690         }
691         else
692         {
693             ERR("Cannot set MARK Parity\n");
694             return STATUS_NOT_SUPPORTED;
695         }
696         break;
697     case SPACEPARITY:
698         if (slc->WordLength < 8)
699         {
700             bytesize +=1;
701             port.c_iflag &= ~INPCK;
702         }
703         else
704         {
705             ERR("Cannot set SPACE Parity\n");
706             return STATUS_NOT_SUPPORTED;
707         }
708         break;
709 #endif
710     default:
711         ERR("Parity\n");
712         return STATUS_NOT_SUPPORTED;
713     }
714     
715     port.c_cflag &= ~CSIZE;
716     switch (bytesize)
717     {
718     case 5:     port.c_cflag |= CS5;    break;
719     case 6:     port.c_cflag |= CS6;    break;
720     case 7:     port.c_cflag |= CS7;    break;
721     case 8:     port.c_cflag |= CS8;    break;
722     default:
723         ERR("ByteSize\n");
724         return STATUS_NOT_SUPPORTED;
725     }
726     
727     switch (stopbits)
728     {
729     case ONESTOPBIT:    port.c_cflag &= ~CSTOPB;        break;
730     case ONE5STOPBITS: /* will be selected if bytesize is 5 */
731     case TWOSTOPBITS:   port.c_cflag |= CSTOPB;         break;
732     default:
733         ERR("StopBits\n");
734         return STATUS_NOT_SUPPORTED;
735     }
736     /* otherwise it hangs with pending input*/
737     if (tcsetattr(fd, TCSANOW, &port) == -1)
738     {
739         ERR("tcsetattr error '%s'\n", strerror(errno));
740         return FILE_GetNtStatus();
741     }
742     return STATUS_SUCCESS;
743 }
744
745 static NTSTATUS set_queue_size(int fd, const SERIAL_QUEUE_SIZE* sqs)
746 {
747     FIXME("insize %d outsize %d unimplemented stub\n", sqs->InSize, sqs->OutSize);
748     return STATUS_SUCCESS;
749 }
750
751 static NTSTATUS set_special_chars(int fd, const SERIAL_CHARS* sc)
752 {
753     struct termios port;
754     
755     if (tcgetattr(fd, &port) == -1)
756     {
757         ERR("tcgetattr error '%s'\n", strerror(errno));
758         return FILE_GetNtStatus();
759     }
760     
761     port.c_cc[VEOF  ] = sc->EofChar;
762     /* FIXME: sc->ErrorChar is not supported */
763     /* FIXME: sc->BreakChar is not supported */
764     /* FIXME: sc->EventChar is not supported */
765     port.c_cc[VSTART] = sc->XonChar;
766     port.c_cc[VSTOP ] = sc->XoffChar;
767     
768     if (tcsetattr(fd, TCSANOW, &port) == -1)
769     {
770         ERR("tcsetattr error '%s'\n", strerror(errno));
771         return FILE_GetNtStatus();
772     }
773     return STATUS_SUCCESS;
774 }
775
776 static NTSTATUS set_timeouts(HANDLE handle, const SERIAL_TIMEOUTS* st)
777 {
778     NTSTATUS            status;
779
780     SERVER_START_REQ( set_serial_info )
781     {
782         req->handle       = wine_server_obj_handle( handle );
783         req->flags        = SERIALINFO_SET_TIMEOUTS;
784         req->readinterval = st->ReadIntervalTimeout ;
785         req->readmult     = st->ReadTotalTimeoutMultiplier ;
786         req->readconst    = st->ReadTotalTimeoutConstant ;
787         req->writemult    = st->WriteTotalTimeoutMultiplier ;
788         req->writeconst   = st->WriteTotalTimeoutConstant ;
789         status = wine_server_call( req );
790     }
791     SERVER_END_REQ;
792     return status;
793 }
794
795 static NTSTATUS set_wait_mask(HANDLE hDevice, DWORD mask)
796 {
797     NTSTATUS status;
798
799     SERVER_START_REQ( set_serial_info )
800     {
801         req->handle    = wine_server_obj_handle( hDevice );
802         req->flags     = SERIALINFO_SET_MASK;
803         req->eventmask = mask;
804         status = wine_server_call( req );
805     }
806     SERVER_END_REQ;
807     return status;
808 }
809
810 /*
811  * does not change IXOFF but simulates that IXOFF has been received:
812  */
813 static NTSTATUS set_XOff(int fd)
814 {
815     if (tcflow(fd, TCOOFF))
816     {
817         return FILE_GetNtStatus();
818     }
819     return STATUS_SUCCESS;
820 }
821
822 /*
823  * does not change IXON but simulates that IXON has been received:
824  */
825 static NTSTATUS set_XOn(int fd)
826 {
827     if (tcflow(fd, TCOON))
828     {
829         return FILE_GetNtStatus();
830     }
831     return STATUS_SUCCESS;
832 }
833
834 /*             serial_irq_info
835  * local structure holding the irq values we need for WaitCommEvent()
836  *
837  * Stripped down from struct serial_icounter_struct, which may not be available on some systems
838  * As the modem line interrupts (cts, dsr, rng, dcd) only get updated with TIOCMIWAIT active,
839  * no need to carry them in the internal structure
840  *
841  */
842 typedef struct serial_irq_info
843 {
844     int rx , tx, frame, overrun, parity, brk, buf_overrun;
845 }serial_irq_info;
846
847 /***********************************************************************
848  * Data needed by the thread polling for the changing CommEvent
849  */
850 typedef struct async_commio
851 {
852     HANDLE              hDevice;
853     DWORD*              events;
854     HANDLE              hEvent;
855     DWORD               evtmask;
856     DWORD               mstat;
857     serial_irq_info     irq_info;
858 } async_commio;
859
860 /***********************************************************************
861  *   Get extended interrupt count info, needed for wait_on
862  */
863 static NTSTATUS get_irq_info(int fd, serial_irq_info *irq_info)
864 {
865     NTSTATUS status = STATUS_NOT_IMPLEMENTED;
866 #ifdef TIOCGICOUNT
867     struct serial_icounter_struct einfo;
868     if (!ioctl(fd, TIOCGICOUNT, &einfo))
869     {
870         irq_info->rx          = einfo.rx;
871         irq_info->tx          = einfo.tx;
872         irq_info->frame       = einfo.frame;
873         irq_info->overrun     = einfo.overrun;
874         irq_info->parity      = einfo.parity;
875         irq_info->brk         = einfo.brk;
876         irq_info->buf_overrun = einfo.buf_overrun;
877         return STATUS_SUCCESS;
878     }
879     TRACE("TIOCGICOUNT err %s\n", strerror(errno));
880     status = FILE_GetNtStatus();
881 #endif
882     memset(irq_info,0, sizeof(serial_irq_info));
883     return status;
884 }
885
886
887 static DWORD check_events(int fd, DWORD mask,
888                           const serial_irq_info *new,
889                           const serial_irq_info *old,
890                           DWORD new_mstat, DWORD old_mstat)
891 {
892     DWORD ret = 0, queue;
893
894     TRACE("mask 0x%08x\n", mask);
895     TRACE("old->rx          0x%08x vs. new->rx          0x%08x\n", old->rx, new->rx);
896     TRACE("old->tx          0x%08x vs. new->tx          0x%08x\n", old->tx, new->tx);
897     TRACE("old->frame       0x%08x vs. new->frame       0x%08x\n", old->frame, new->frame);
898     TRACE("old->overrun     0x%08x vs. new->overrun     0x%08x\n", old->overrun, new->overrun);
899     TRACE("old->parity      0x%08x vs. new->parity      0x%08x\n", old->parity, new->parity);
900     TRACE("old->brk         0x%08x vs. new->brk         0x%08x\n", old->brk, new->brk);
901     TRACE("old->buf_overrun 0x%08x vs. new->buf_overrun 0x%08x\n", old->buf_overrun, new->buf_overrun);
902
903     if (old->brk != new->brk) ret |= EV_BREAK;
904     if ((old_mstat & MS_CTS_ON ) != (new_mstat & MS_CTS_ON )) ret |= EV_CTS;
905     if ((old_mstat & MS_DSR_ON ) != (new_mstat & MS_DSR_ON )) ret |= EV_DSR;
906     if ((old_mstat & MS_RING_ON) != (new_mstat & MS_RING_ON)) ret |= EV_RING;
907     if ((old_mstat & MS_RLSD_ON) != (new_mstat & MS_RLSD_ON)) ret |= EV_RLSD;
908     if (old->frame != new->frame || old->overrun != new->overrun || old->parity != new->parity) ret |= EV_ERR;
909     if (mask & EV_RXCHAR)
910     {
911         queue = 0;
912 #ifdef TIOCINQ
913         if (ioctl(fd, TIOCINQ, &queue))
914             WARN("TIOCINQ returned error\n");
915 #endif
916         if (queue)
917             ret |= EV_RXCHAR;
918     }
919     if (mask & EV_TXEMPTY)
920     {
921         queue = 0;
922 /* We really want to know when all characters have gone out of the transmitter */
923 #if defined(TIOCSERGETLSR) 
924         if (ioctl(fd, TIOCSERGETLSR, &queue))
925             WARN("TIOCSERGETLSR returned error\n");
926         if (queue)
927 /* TIOCOUTQ only checks for an empty buffer */
928 #elif defined(TIOCOUTQ)
929         if (ioctl(fd, TIOCOUTQ, &queue))
930             WARN("TIOCOUTQ returned error\n");
931         if (!queue)
932 #endif
933            ret |= EV_TXEMPTY;
934         TRACE("OUTQUEUE %d, Transmitter %sempty\n",
935               queue, (ret & EV_TXEMPTY) ? "" : "not ");
936     }
937     return ret & mask;
938 }
939
940 /***********************************************************************
941  *             wait_for_event      (INTERNAL)
942  *
943  *  We need to poll for what is interesting
944  *  TIOCMIWAIT only checks modem status line and may not be aborted by a changing mask
945  *
946  */
947 static DWORD CALLBACK wait_for_event(LPVOID arg)
948 {
949     async_commio *commio = arg;
950     int fd, needs_close;
951
952     if (!server_get_unix_fd( commio->hDevice, FILE_READ_DATA | FILE_WRITE_DATA, &fd, &needs_close, NULL, NULL ))
953     {
954         serial_irq_info new_irq_info;
955         DWORD new_mstat, new_evtmask;
956         LARGE_INTEGER time;
957         
958         TRACE("device=%p fd=0x%08x mask=0x%08x buffer=%p event=%p irq_info=%p\n", 
959               commio->hDevice, fd, commio->evtmask, commio->events, commio->hEvent, &commio->irq_info);
960
961         time.QuadPart = (ULONGLONG)10000;
962         time.QuadPart = -time.QuadPart;
963         for (;;)
964         {
965             /*
966              * TIOCMIWAIT is not adequate
967              *
968              * FIXME:
969              * We don't handle the EV_RXFLAG (the eventchar)
970              */
971             NtDelayExecution(FALSE, &time);
972             get_irq_info(fd, &new_irq_info);
973             if (get_modem_status(fd, &new_mstat))
974                 TRACE("get_modem_status failed\n");
975             *commio->events = check_events(fd, commio->evtmask,
976                                            &new_irq_info, &commio->irq_info,
977                                            new_mstat, commio->mstat);
978             if (*commio->events) break;
979             get_wait_mask(commio->hDevice, &new_evtmask);
980             if (commio->evtmask != new_evtmask)
981             {
982                 *commio->events = 0;
983                 break;
984             }
985         }
986         if (needs_close) close( fd );
987     }
988     if (commio->hEvent) NtSetEvent(commio->hEvent, NULL);
989     RtlFreeHeap(GetProcessHeap(), 0, commio);
990     return 0;
991 }
992
993 static NTSTATUS wait_on(HANDLE hDevice, int fd, HANDLE hEvent, DWORD* events)
994 {
995     async_commio*       commio;
996     NTSTATUS            status;
997
998     if ((status = NtResetEvent(hEvent, NULL)))
999         return status;
1000
1001     commio = RtlAllocateHeap(GetProcessHeap(), 0, sizeof (async_commio));
1002     if (!commio) return STATUS_NO_MEMORY;
1003
1004     commio->hDevice = hDevice;
1005     commio->events  = events;
1006     commio->hEvent  = hEvent;
1007     get_wait_mask(commio->hDevice, &commio->evtmask);
1008
1009 /* We may never return, if some capabilities miss
1010  * Return error in that case
1011  */
1012 #if !defined(TIOCINQ)
1013     if (commio->evtmask & EV_RXCHAR)
1014         goto error_caps;
1015 #endif
1016 #if !(defined(TIOCSERGETLSR) && defined(TIOCSER_TEMT)) || !defined(TIOCINQ)
1017     if (commio->evtmask & EV_TXEMPTY)
1018         goto error_caps;
1019 #endif
1020 #if !defined(TIOCMGET)
1021     if (commio->evtmask & (EV_CTS | EV_DSR| EV_RING| EV_RLSD))
1022         goto error_caps;
1023 #endif
1024 #if !defined(TIOCM_CTS)
1025     if (commio->evtmask & EV_CTS)
1026         goto error_caps;
1027 #endif
1028 #if !defined(TIOCM_DSR)
1029     if (commio->evtmask & EV_DSR)
1030         goto error_caps;
1031 #endif
1032 #if !defined(TIOCM_RNG)
1033     if (commio->evtmask & EV_RING)
1034         goto error_caps;
1035 #endif
1036 #if !defined(TIOCM_CAR)
1037     if (commio->evtmask & EV_RLSD)
1038         goto error_caps;
1039 #endif
1040     if (commio->evtmask & EV_RXFLAG)
1041         FIXME("EV_RXFLAG not handled\n");
1042
1043     if ((status = get_irq_info(fd, &commio->irq_info)) &&
1044         (commio->evtmask & (EV_BREAK | EV_ERR)))
1045         goto out_now;
1046
1047     if ((status = get_modem_status(fd, &commio->mstat)) &&
1048         (commio->evtmask & (EV_CTS | EV_DSR| EV_RING| EV_RLSD)))
1049         goto out_now;
1050
1051     /* We might have received something or the TX buffer is delivered */
1052     *events = check_events(fd, commio->evtmask,
1053                                &commio->irq_info, &commio->irq_info,
1054                                commio->mstat, commio->mstat);
1055     if (*events)
1056     {
1057         status = STATUS_SUCCESS;
1058         goto out_now;
1059     }
1060
1061     /* create the worker for the task */
1062     status = RtlQueueWorkItem(wait_for_event, commio, 0 /* FIXME */);
1063     if (status != STATUS_SUCCESS) goto out_now;
1064     return STATUS_PENDING;
1065
1066 #if !defined(TIOCINQ) || (!(defined(TIOCSERGETLSR) && defined(TIOCSER_TEMT)) || !defined(TIOCINQ)) || !defined(TIOCMGET) || !defined(TIOCM_CTS) ||!defined(TIOCM_DSR) || !defined(TIOCM_RNG) || !defined(TIOCM_CAR)
1067 error_caps:
1068     FIXME("Returning error because of missing capabilities\n");
1069     status = STATUS_INVALID_PARAMETER;
1070 #endif
1071 out_now:
1072     RtlFreeHeap(GetProcessHeap(), 0, commio);
1073     return status;
1074 }
1075
1076 static NTSTATUS xmit_immediate(HANDLE hDevice, int fd, const char* ptr)
1077 {
1078     /* FIXME: not perfect as it should bypass the in-queue */
1079     WARN("(%p,'%c') not perfect!\n", hDevice, *ptr);
1080     if (write(fd, ptr, 1) != 1)
1081         return FILE_GetNtStatus();
1082     return STATUS_SUCCESS;
1083 }
1084
1085 /******************************************************************
1086  *              COMM_DeviceIoControl
1087  *
1088  *
1089  */
1090 static inline NTSTATUS io_control(HANDLE hDevice, 
1091                                   HANDLE hEvent, PIO_APC_ROUTINE UserApcRoutine,
1092                                   PVOID UserApcContext, 
1093                                   PIO_STATUS_BLOCK piosb, 
1094                                   ULONG dwIoControlCode,
1095                                   LPVOID lpInBuffer, DWORD nInBufferSize,
1096                                   LPVOID lpOutBuffer, DWORD nOutBufferSize)
1097 {
1098     DWORD       sz = 0, access = FILE_READ_DATA;
1099     NTSTATUS    status = STATUS_SUCCESS;
1100     int         fd = -1, needs_close = 0;
1101
1102     TRACE("%p %s %p %d %p %d %p\n",
1103           hDevice, iocode2str(dwIoControlCode), lpInBuffer, nInBufferSize,
1104           lpOutBuffer, nOutBufferSize, piosb);
1105
1106     piosb->Information = 0;
1107
1108     if (dwIoControlCode != IOCTL_SERIAL_GET_TIMEOUTS &&
1109         dwIoControlCode != IOCTL_SERIAL_SET_TIMEOUTS)
1110         if ((status = server_get_unix_fd( hDevice, access, &fd, &needs_close, NULL, NULL )))
1111             goto error;
1112
1113     switch (dwIoControlCode)
1114     {
1115     case IOCTL_SERIAL_CLR_DTR:
1116 #ifdef TIOCM_DTR
1117         if (whack_modem(fd, ~TIOCM_DTR, 0) == -1) status = FILE_GetNtStatus();
1118 #else
1119         status = STATUS_NOT_SUPPORTED;
1120 #endif
1121         break;
1122     case IOCTL_SERIAL_CLR_RTS:
1123 #ifdef TIOCM_RTS
1124         if (whack_modem(fd, ~TIOCM_RTS, 0) == -1) status = FILE_GetNtStatus();
1125 #else
1126         status = STATUS_NOT_SUPPORTED;
1127 #endif
1128         break;
1129     case IOCTL_SERIAL_GET_BAUD_RATE:
1130         if (lpOutBuffer && nOutBufferSize == sizeof(SERIAL_BAUD_RATE))
1131         {
1132             if (!(status = get_baud_rate(fd, lpOutBuffer)))
1133                 sz = sizeof(SERIAL_BAUD_RATE);
1134         }
1135         else
1136             status = STATUS_INVALID_PARAMETER;
1137         break;
1138     case IOCTL_SERIAL_GET_CHARS:
1139         if (lpOutBuffer && nOutBufferSize == sizeof(SERIAL_CHARS))
1140         {
1141             if (!(status = get_special_chars(fd, lpOutBuffer)))
1142                 sz = sizeof(SERIAL_CHARS);
1143         }
1144         else
1145             status = STATUS_INVALID_PARAMETER;
1146         break;
1147      case IOCTL_SERIAL_GET_COMMSTATUS:
1148         if (lpOutBuffer && nOutBufferSize == sizeof(SERIAL_STATUS))
1149         {
1150             if (!(status = get_status(fd, lpOutBuffer)))
1151                 sz = sizeof(SERIAL_STATUS);
1152         }
1153         else status = STATUS_INVALID_PARAMETER;
1154         break;
1155     case IOCTL_SERIAL_GET_HANDFLOW:
1156         if (lpOutBuffer && nOutBufferSize == sizeof(SERIAL_HANDFLOW))
1157         {
1158             if (!(status = get_hand_flow(fd, lpOutBuffer)))
1159                 sz = sizeof(SERIAL_HANDFLOW);
1160         }
1161         else
1162             status = STATUS_INVALID_PARAMETER;
1163         break;
1164     case IOCTL_SERIAL_GET_LINE_CONTROL:
1165         if (lpOutBuffer && nOutBufferSize == sizeof(SERIAL_LINE_CONTROL))
1166         {
1167             if (!(status = get_line_control(fd, lpOutBuffer)))
1168                 sz = sizeof(SERIAL_LINE_CONTROL);
1169         }
1170         else
1171             status = STATUS_INVALID_PARAMETER;
1172         break;
1173     case IOCTL_SERIAL_GET_MODEMSTATUS:
1174         if (lpOutBuffer && nOutBufferSize == sizeof(DWORD))
1175         {
1176             if (!(status = get_modem_status(fd, lpOutBuffer)))
1177                 sz = sizeof(DWORD);
1178         }
1179         else status = STATUS_INVALID_PARAMETER;
1180         break;
1181     case IOCTL_SERIAL_GET_TIMEOUTS:
1182         if (lpOutBuffer && nOutBufferSize == sizeof(SERIAL_TIMEOUTS))
1183         {
1184             if (!(status = get_timeouts(hDevice, lpOutBuffer)))
1185                 sz = sizeof(SERIAL_TIMEOUTS);
1186         }
1187         else
1188             status = STATUS_INVALID_PARAMETER;
1189         break;
1190     case IOCTL_SERIAL_GET_WAIT_MASK:
1191         if (lpOutBuffer && nOutBufferSize == sizeof(DWORD))
1192         {
1193             if (!(status = get_wait_mask(hDevice, lpOutBuffer)))
1194                 sz = sizeof(DWORD);
1195         }
1196         else
1197             status = STATUS_INVALID_PARAMETER;
1198         break;
1199     case IOCTL_SERIAL_IMMEDIATE_CHAR:
1200         if (lpInBuffer && nInBufferSize == sizeof(CHAR))
1201             status = xmit_immediate(hDevice, fd, lpInBuffer);
1202         else
1203             status = STATUS_INVALID_PARAMETER;
1204         break;
1205     case IOCTL_SERIAL_PURGE:
1206         if (lpInBuffer && nInBufferSize == sizeof(DWORD))
1207             status = purge(fd, *(DWORD*)lpInBuffer);
1208         else
1209             status = STATUS_INVALID_PARAMETER;
1210         break;
1211     case IOCTL_SERIAL_RESET_DEVICE:
1212         FIXME("Unsupported\n");
1213         break;
1214     case IOCTL_SERIAL_SET_BAUD_RATE:
1215         if (lpInBuffer && nInBufferSize == sizeof(SERIAL_BAUD_RATE))
1216             status = set_baud_rate(fd, lpInBuffer);
1217         else
1218             status = STATUS_INVALID_PARAMETER;
1219         break;
1220     case IOCTL_SERIAL_SET_BREAK_OFF:
1221 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
1222         if (ioctl(fd, TIOCCBRK, 0) == -1)
1223         {
1224             TRACE("ioctl failed\n");
1225             status = FILE_GetNtStatus();
1226         }
1227 #else
1228         FIXME("ioctl not available\n");
1229         status = STATUS_NOT_SUPPORTED;
1230 #endif
1231         break;
1232     case IOCTL_SERIAL_SET_BREAK_ON:
1233 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
1234         if (ioctl(fd, TIOCSBRK, 0) == -1)
1235         {
1236             TRACE("ioctl failed\n");
1237             status = FILE_GetNtStatus();
1238         }
1239 #else
1240         FIXME("ioctl not available\n");
1241         status = STATUS_NOT_SUPPORTED;
1242 #endif
1243         break;
1244     case IOCTL_SERIAL_SET_CHARS:
1245         if (lpInBuffer && nInBufferSize == sizeof(SERIAL_CHARS))
1246             status = set_special_chars(fd, lpInBuffer);
1247         else
1248             status = STATUS_INVALID_PARAMETER;
1249         break;
1250     case IOCTL_SERIAL_SET_DTR:
1251 #ifdef TIOCM_DTR
1252         if (whack_modem(fd, 0, TIOCM_DTR) == -1) status = FILE_GetNtStatus();
1253 #else
1254         status = STATUS_NOT_SUPPORTED;
1255 #endif
1256         break;
1257     case IOCTL_SERIAL_SET_HANDFLOW:
1258         if (lpInBuffer && nInBufferSize == sizeof(SERIAL_HANDFLOW))
1259             status = set_handflow(fd, lpInBuffer);
1260         else
1261             status = STATUS_INVALID_PARAMETER;
1262         break;
1263     case IOCTL_SERIAL_SET_LINE_CONTROL:
1264         if (lpInBuffer && nInBufferSize == sizeof(SERIAL_LINE_CONTROL))
1265             status = set_line_control(fd, lpInBuffer);
1266         else
1267             status = STATUS_INVALID_PARAMETER;
1268         break;
1269     case IOCTL_SERIAL_SET_QUEUE_SIZE:
1270         if (lpInBuffer && nInBufferSize == sizeof(SERIAL_QUEUE_SIZE))
1271             status = set_queue_size(fd, lpInBuffer);
1272         else
1273             status = STATUS_INVALID_PARAMETER;
1274         break;
1275     case IOCTL_SERIAL_SET_RTS:
1276 #ifdef TIOCM_RTS
1277         if (whack_modem(fd, 0, TIOCM_RTS) == -1) status = FILE_GetNtStatus();
1278 #else
1279         status = STATUS_NOT_SUPPORTED;
1280 #endif
1281         break;
1282     case IOCTL_SERIAL_SET_TIMEOUTS:
1283         if (lpInBuffer && nInBufferSize == sizeof(SERIAL_TIMEOUTS))
1284             status = set_timeouts(hDevice, lpInBuffer);
1285         else
1286             status = STATUS_INVALID_PARAMETER;
1287         break;
1288     case IOCTL_SERIAL_SET_WAIT_MASK:
1289         if (lpInBuffer && nInBufferSize == sizeof(DWORD))
1290         {
1291             status = set_wait_mask(hDevice, *(DWORD*)lpInBuffer);
1292         }
1293         else status = STATUS_INVALID_PARAMETER;
1294         break;
1295     case IOCTL_SERIAL_SET_XOFF:
1296         status = set_XOff(fd);
1297         break;
1298     case IOCTL_SERIAL_SET_XON:
1299         status = set_XOn(fd);
1300         break;
1301     case IOCTL_SERIAL_WAIT_ON_MASK:
1302         if (lpOutBuffer && nOutBufferSize == sizeof(DWORD))
1303         {
1304             if (!(status = wait_on(hDevice, fd, hEvent, lpOutBuffer)))
1305                 sz = sizeof(DWORD);
1306         }
1307         else
1308             status = STATUS_INVALID_PARAMETER;
1309         break;
1310     default:
1311         FIXME("Unsupported IOCTL %x (type=%x access=%x func=%x meth=%x)\n", 
1312               dwIoControlCode, dwIoControlCode >> 16, (dwIoControlCode >> 14) & 3,
1313               (dwIoControlCode >> 2) & 0xFFF, dwIoControlCode & 3);
1314         sz = 0;
1315         status = STATUS_INVALID_PARAMETER;
1316         break;
1317     }
1318     if (needs_close) close( fd );
1319  error:
1320     piosb->u.Status = status;
1321     piosb->Information = sz;
1322     if (hEvent && status != STATUS_PENDING) NtSetEvent(hEvent, NULL);
1323     return status;
1324 }
1325
1326 NTSTATUS COMM_DeviceIoControl(HANDLE hDevice, 
1327                               HANDLE hEvent, PIO_APC_ROUTINE UserApcRoutine,
1328                               PVOID UserApcContext, 
1329                               PIO_STATUS_BLOCK piosb, 
1330                               ULONG dwIoControlCode,
1331                               LPVOID lpInBuffer, DWORD nInBufferSize,
1332                               LPVOID lpOutBuffer, DWORD nOutBufferSize)
1333 {
1334     NTSTATUS    status;
1335
1336     if (dwIoControlCode == IOCTL_SERIAL_WAIT_ON_MASK)
1337     {
1338         HANDLE          hev = hEvent;
1339
1340         /* this is an ioctl we implement in a non blocking way if hEvent is not
1341          * null
1342          * so we have to explicitly wait if no hEvent is provided
1343          */
1344         if (!hev)
1345         {
1346             OBJECT_ATTRIBUTES   attr;
1347             
1348             attr.Length                   = sizeof(attr);
1349             attr.RootDirectory            = 0;
1350             attr.ObjectName               = NULL;
1351             attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1352             attr.SecurityDescriptor       = NULL;
1353             attr.SecurityQualityOfService = NULL;
1354             status = NtCreateEvent(&hev, EVENT_ALL_ACCESS, &attr, FALSE, FALSE);
1355
1356             if (status) goto done;
1357         }
1358         status = io_control(hDevice, hev, UserApcRoutine, UserApcContext,
1359                             piosb, dwIoControlCode, lpInBuffer, nInBufferSize,
1360                             lpOutBuffer, nOutBufferSize);
1361         if (hev != hEvent)
1362         {
1363             if (status == STATUS_PENDING)
1364             {
1365                 NtWaitForSingleObject(hev, FALSE, NULL);
1366                 status = STATUS_SUCCESS;
1367             }
1368             NtClose(hev);
1369         }
1370     }
1371     else status = io_control(hDevice, hEvent, UserApcRoutine, UserApcContext,
1372                              piosb, dwIoControlCode, lpInBuffer, nInBufferSize,
1373                              lpOutBuffer, nOutBufferSize);
1374 done:
1375     return status;
1376 }