git.oblomov.eu Git - wine/blob - 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 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #ifdef HAVE_TERMIOS_H
  43 #include <termios.h>
  44 #endif
  45 #include <fcntl.h>
  46 #ifdef HAVE_SYS_STAT_H
  47 # include <sys/stat.h>
  48 #endif
  49 #include <sys/types.h>
  50 #ifdef HAVE_SYS_FILIO_H
  51 # include <sys/filio.h>
  52 #endif
  53 #ifdef HAVE_SYS_IOCTL_H
  54 #include <sys/ioctl.h>
  55 #endif
  56 #ifdef HAVE_SYS_POLL_H
  57 # include <sys/poll.h>
  58 #endif
  59 #ifdef HAVE_SYS_MODEM_H
  60 # include <sys/modem.h>
  61 #endif
  62 #ifdef HAVE_SYS_STRTIO_H
  63 # include <sys/strtio.h>
  64 #endif
  65
  66 #define NONAMELESSUNION
  67 #define NONAMELESSSTRUCT
  68 #include "ntstatus.h"
  69 #define WIN32_NO_STATUS
  70 #include "windef.h"
  71 #include "winternl.h"
  72 #include "winioctl.h"
  73 #include "ddk/ntddser.h"
  74 #include "ntdll_misc.h"
  75 #include "wine/server.h"
  76 #include "wine/library.h"
  77 #include "wine/debug.h"
  78
  79 #ifdef HAVE_LINUX_SERIAL_H
  80 #include <linux/serial.h>
  81 #endif
  82
  83 WINE_DEFAULT_DEBUG_CHANNEL(comm);
  84
  85 static const char* iocode2str(DWORD ioc)
  86 {
  87     switch (ioc)
  88     {
  89 #define X(x)    case (x): return #x;
  90         X(IOCTL_SERIAL_CLEAR_STATS);
  91         X(IOCTL_SERIAL_CLR_DTR);
  92         X(IOCTL_SERIAL_CLR_RTS);
  93         X(IOCTL_SERIAL_CONFIG_SIZE);
  94         X(IOCTL_SERIAL_GET_BAUD_RATE);
  95         X(IOCTL_SERIAL_GET_CHARS);
  96         X(IOCTL_SERIAL_GET_COMMSTATUS);
  97         X(IOCTL_SERIAL_GET_DTRRTS);
  98         X(IOCTL_SERIAL_GET_HANDFLOW);
  99         X(IOCTL_SERIAL_GET_LINE_CONTROL);
 100         X(IOCTL_SERIAL_GET_MODEM_CONTROL);
 101         X(IOCTL_SERIAL_GET_MODEMSTATUS);
 102         X(IOCTL_SERIAL_GET_PROPERTIES);
 103         X(IOCTL_SERIAL_GET_STATS);
 104         X(IOCTL_SERIAL_GET_TIMEOUTS);
 105         X(IOCTL_SERIAL_GET_WAIT_MASK);
 106         X(IOCTL_SERIAL_IMMEDIATE_CHAR);
 107         X(IOCTL_SERIAL_LSRMST_INSERT);
 108         X(IOCTL_SERIAL_PURGE);
 109         X(IOCTL_SERIAL_RESET_DEVICE);
 110         X(IOCTL_SERIAL_SET_BAUD_RATE);
 111         X(IOCTL_SERIAL_SET_BREAK_ON);
 112         X(IOCTL_SERIAL_SET_BREAK_OFF);
 113         X(IOCTL_SERIAL_SET_CHARS);
 114         X(IOCTL_SERIAL_SET_DTR);
 115         X(IOCTL_SERIAL_SET_FIFO_CONTROL);
 116         X(IOCTL_SERIAL_SET_HANDFLOW);
 117         X(IOCTL_SERIAL_SET_LINE_CONTROL);
 118         X(IOCTL_SERIAL_SET_MODEM_CONTROL);
 119         X(IOCTL_SERIAL_SET_QUEUE_SIZE);
 120         X(IOCTL_SERIAL_SET_RTS);
 121         X(IOCTL_SERIAL_SET_TIMEOUTS);
 122         X(IOCTL_SERIAL_SET_WAIT_MASK);
 123         X(IOCTL_SERIAL_SET_XOFF);
 124         X(IOCTL_SERIAL_SET_XON);
 125         X(IOCTL_SERIAL_WAIT_ON_MASK);
 126         X(IOCTL_SERIAL_XOFF_COUNTER);
 127 #undef X
 128     default: { static char tmp[32]; sprintf(tmp, "IOCTL_SERIAL_%ld\n", ioc); return tmp; }
 129     }
 130 }
 131
 132 static NTSTATUS get_modem_status(int fd, DWORD* lpModemStat)
 133 {
 134     NTSTATUS    status = STATUS_SUCCESS;
 135     int         mstat;
 136
 137 #ifdef TIOCMGET
 138     if (ioctl(fd, TIOCMGET, &mstat) == -1)
 139     {
 140         WARN("ioctl failed\n");
 141         status = FILE_GetNtStatus();
 142     }
 143     else
 144     {
 145         *lpModemStat = 0;
 146 #ifdef TIOCM_CTS
 147         if (mstat & TIOCM_CTS)  *lpModemStat |= MS_CTS_ON;
 148 #endif
 149 #ifdef TIOCM_DSR
 150         if (mstat & TIOCM_DSR)  *lpModemStat |= MS_DSR_ON;
 151 #endif
 152 #ifdef TIOCM_RNG
 153         if (mstat & TIOCM_RNG)  *lpModemStat |= MS_RING_ON;
 154 #endif
 155 #ifdef TIOCM_CAR
 156         /* FIXME: Not really sure about RLSD UB 990810 */
 157         if (mstat & TIOCM_CAR)  *lpModemStat |= MS_RLSD_ON;
 158 #endif
 159         TRACE("%04x -> %s%s%s%s\n", mstat,
 160               (*lpModemStat & MS_RLSD_ON) ? "MS_RLSD_ON " : "",
 161               (*lpModemStat & MS_RING_ON) ? "MS_RING_ON " : "",
 162               (*lpModemStat & MS_DSR_ON)  ? "MS_DSR_ON  " : "",
 163               (*lpModemStat & MS_CTS_ON)  ? "MS_CTS_ON  " : "");
 164     }
 165 #else
 166     status = STATUS_NOT_SUPPORTED;
 167 #endif
 168     return status;
 169 }
 170
 171 static NTSTATUS get_status(int fd, SERIAL_STATUS* ss)
 172 {
 173     NTSTATUS    status = STATUS_SUCCESS;
 174
 175     ss->Errors = 0;
 176     ss->HoldReasons = 0;
 177     ss->EofReceived = FALSE;
 178     ss->WaitForImmediate = FALSE;
 179 #ifdef TIOCOUTQ
 180     if (ioctl(fd, TIOCOUTQ, &ss->AmountInOutQueue) == -1)
 181     {
 182         WARN("ioctl returned error\n");
 183         status = FILE_GetNtStatus();
 184     }
 185 #else
 186     ss->AmountInOutQueue = 0; /* FIXME: find a different way to find out */
 187 #endif
 188
 189 #ifdef TIOCINQ
 190     if (ioctl(fd, TIOCINQ, &ss->AmountInInQueue))
 191     {
 192         WARN("ioctl returned error\n");
 193         status = FILE_GetNtStatus();
 194     }
 195 #else
 196     ss->AmountInInQueue = 0; /* FIXME: find a different way to find out */
 197 #endif
 198     return status;
 199 }
 200
 201 static NTSTATUS get_wait_mask(HANDLE hDevice, DWORD* mask)
 202 {
 203     NTSTATUS    status;
 204
 205     SERVER_START_REQ( get_serial_info )
 206     {
 207         req->handle = hDevice;
 208         if (!(status = wine_server_call( req )))
 209             *mask = reply->eventmask;
 210     }
 211     SERVER_END_REQ;
 212     return status;
 213 }
 214
 215 static NTSTATUS purge(int fd, DWORD flags)
 216 {
 217     /*
 218     ** not exactly sure how these are different
 219     ** Perhaps if we had our own internal queues, one flushes them
 220     ** and the other flushes the kernel's buffers.
 221     */
 222     if (flags & PURGE_TXABORT) tcflush(fd, TCOFLUSH);
 223     if (flags & PURGE_RXABORT) tcflush(fd, TCIFLUSH);
 224     if (flags & PURGE_TXCLEAR) tcflush(fd, TCOFLUSH);
 225     if (flags & PURGE_RXCLEAR) tcflush(fd, TCIFLUSH);
 226     return STATUS_SUCCESS;
 227 }
 228
 229 static NTSTATUS set_wait_mask(HANDLE hDevice, DWORD mask)
 230 {
 231     NTSTATUS status;
 232
 233     SERVER_START_REQ( set_serial_info )
 234     {
 235         req->handle    = hDevice;
 236         req->flags     = SERIALINFO_SET_MASK;
 237         req->eventmask = mask;
 238         status = wine_server_call( req );
 239     }
 240     SERVER_END_REQ;
 241     return status;
 242 }
 243
 244 static NTSTATUS xmit_immediate(HANDLE hDevice, int fd, char* ptr)
 245 {
 246     /* FIXME: not perfect as it should bypass the in-queue */
 247     WARN("(%p,'%c') not perfect!\n", hDevice, *ptr);
 248     if (write(fd, ptr, 1) != 1)
 249         return FILE_GetNtStatus();
 250     return STATUS_SUCCESS;
 251 }
 252
 253 /******************************************************************
 254  *              COMM_DeviceIoControl
 255  *
 256  *
 257  */
 258 NTSTATUS COMM_DeviceIoControl(HANDLE hDevice,
 259                               HANDLE hEvent, PIO_APC_ROUTINE UserApcRoutine,
 260                               PVOID UserApcContext,
 261                               PIO_STATUS_BLOCK piosb,
 262                               ULONG dwIoControlCode,
 263                               LPVOID lpInBuffer, DWORD nInBufferSize,
 264                               LPVOID lpOutBuffer, DWORD nOutBufferSize)
 265 {
 266     DWORD       sz = 0, access = FILE_READ_DATA;
 267     NTSTATUS    status = STATUS_SUCCESS;
 268     int         fd;
 269
 270     TRACE("%p %s %p %ld %p %ld %p\n",
 271           hDevice, iocode2str(dwIoControlCode), lpInBuffer, nInBufferSize,
 272           lpOutBuffer, nOutBufferSize, piosb);
 273
 274     piosb->Information = 0;
 275
 276     if ((status = wine_server_handle_to_fd( hDevice, access, &fd, NULL ))) goto error;
 277
 278     switch (dwIoControlCode)
 279     {
 280     case IOCTL_SERIAL_GET_COMMSTATUS:
 281         if (lpOutBuffer && nOutBufferSize == sizeof(SERIAL_STATUS))
 282         {
 283             if (!(status = get_status(fd, (SERIAL_STATUS*)lpOutBuffer)))
 284                 sz = sizeof(SERIAL_STATUS);
 285         }
 286         else status = STATUS_INVALID_PARAMETER;
 287         break;
 288     case IOCTL_SERIAL_GET_MODEMSTATUS:
 289         if (lpOutBuffer && nOutBufferSize == sizeof(DWORD))
 290         {
 291             if (!(status = get_modem_status(fd, (DWORD*)lpOutBuffer)))
 292                 sz = sizeof(DWORD);
 293         }
 294         else status = STATUS_INVALID_PARAMETER;
 295         break;
 296     case IOCTL_SERIAL_GET_WAIT_MASK:
 297         if (lpOutBuffer && nOutBufferSize == sizeof(DWORD))
 298         {
 299             if (!(status = get_wait_mask(hDevice, (DWORD*)lpOutBuffer)))
 300                 sz = sizeof(DWORD);
 301         }
 302         else
 303             status = STATUS_INVALID_PARAMETER;
 304         break;
 305     case IOCTL_SERIAL_IMMEDIATE_CHAR:
 306         if (lpInBuffer && nInBufferSize == sizeof(CHAR))
 307             status = xmit_immediate(hDevice, fd, lpInBuffer);
 308         else
 309             status = STATUS_INVALID_PARAMETER;
 310         break;
 311     case IOCTL_SERIAL_PURGE:
 312         if (lpInBuffer && nInBufferSize == sizeof(DWORD))
 313             status = purge(fd, *(DWORD*)lpInBuffer);
 314         else
 315             status = STATUS_INVALID_PARAMETER;
 316         break;
 317     case IOCTL_SERIAL_SET_BREAK_OFF:
 318 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
 319         if (ioctl(fd, TIOCCBRK, 0) == -1)
 320         {
 321             TRACE("ioctl failed\n");
 322             status = FILE_GetNtStatus();
 323         }
 324 #else
 325         FIXME("ioctl not available\n");
 326         status = STATUS_NOT_SUPPORTED;
 327 #endif
 328         break;
 329     case IOCTL_SERIAL_SET_BREAK_ON:
 330 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
 331         if (ioctl(fd, TIOCSBRK, 0) == -1)
 332         {
 333             TRACE("ioctl failed\n");
 334             status = FILE_GetNtStatus();
 335         }
 336 #else
 337         FIXME("ioctl not available\n");
 338         status = STATUS_NOT_SUPPORTED;
 339 #endif
 340         break;
 341     case IOCTL_SERIAL_SET_WAIT_MASK:
 342         if (lpInBuffer && nInBufferSize == sizeof(DWORD))
 343         {
 344             status = set_wait_mask(hDevice, *(DWORD*)lpInBuffer);
 345         }
 346         else status = STATUS_INVALID_PARAMETER;
 347         break;
 348     default:
 349         FIXME("Unsupported IOCTL %lx (type=%lx access=%lx func=%lx meth=%lx)\n",
 350               dwIoControlCode, dwIoControlCode >> 16, (dwIoControlCode >> 14) & 3,
 351               (dwIoControlCode >> 2) & 0xFFF, dwIoControlCode & 3);
 352         sz = 0;
 353         status = STATUS_INVALID_PARAMETER;
 354         break;
 355     }
 356     wine_server_release_fd( hDevice, fd );
 357  error:
 358     piosb->u.Status = status;
 359     piosb->Information = sz;
 360     if (hEvent) NtSetEvent(hEvent, NULL);
 361     return status;
 362 }