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