misc/comm.c

   1  /*
   2  * DEC 93 Erik Bos <erik@xs4all.nl>
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  * FIXME: use HFILEs instead of unixfds
   6  *        the win32 functions here get HFILEs already.
   7  *
   8  * May 26, 1997.  Fixes and comments by Rick Richardson <rick@dgii.com> [RER]
   9  * - ptr->fd wasn't getting cleared on close.
  10  * - GetCommEventMask() and GetCommError() didn't do much of anything.
  11  *   IMHO, they are still wrong, but they at least implement the RXCHAR
  12  *   event and return I/O queue sizes, which makes the app I'm interested
  13  *   in (analog devices EZKIT DSP development system) work.
  14  *
  15  * August 12, 1997.  Take a bash at SetCommEventMask - Lawson Whitney
  16  *                                     <lawson_whitney@juno.com>
  17  * July 6, 1998. Fixes and comments by Valentijn Sessink
  18  *                                     <vsessink@ic.uva.nl> [V]
  19  *  I only quick-fixed an error for the output buffers. The thing is this: if a
  20  * WinApp starts using serial ports, it calls OpenComm, asking it to open two
  21  * buffers, cbInQueue and cbOutQueue size, to hold data to/from the serial
  22  * ports. Wine OpenComm only returns "OK". Now the kernel buffer size for
  23  * serial communication is only 4096 bytes large. Error: (App asks for
  24  * a 104,000 bytes size buffer, Wine returns "OK", App asks "How many char's
  25  * are in the buffer", Wine returns "4000" and App thinks "OK, another
  26  * 100,000 chars left, good!")
  27  * The solution below is a bad but working quickfix for the transmit buffer:
  28  * the cbInQueue is saved in a variable; when the program asks how many chars
  29  * there are in the buffer, GetCommError returns # in buffer PLUS
  30  * the additional (cbOutQeueu - 4096), which leaves the application thinking
  31  * "wow, almost full".
  32  * Sorry for the rather chatty explanation - but I think comm.c needs to be
  33  * redefined with real working buffers make it work; maybe these comments are
  34  * of help.
  35  * Oktober 98, Rein Klazes [RHK]
  36  * A program that wants to monitor the modem status line (RLSD/DCD) may
  37  * poll the modem status register in the commMask structure. I update the bit
  38  * in GetCommError, waiting for an implementation of communication events.
  39  *
  40  */
  41
  42 #include "config.h"
  43
  44 #include <stdlib.h>
  45 #include <termios.h>
  46 #include <fcntl.h>
  47 #include <string.h>
  48 #ifdef HAVE_STRINGS_H
  49 # include <strings.h>
  50 #endif
  51 #include <errno.h>
  52 #include <ctype.h>
  53 #include <sys/stat.h>
  54 #ifdef HAVE_SYS_FILIO_H
  55 # include <sys/filio.h>
  56 #endif
  57 #include <sys/ioctl.h>
  58 #include <unistd.h>
  59
  60 #include "windows.h"
  61 #include "comm.h"
  62 #ifdef HAVE_SYS_MODEM_H
  63 # include <sys/modem.h>
  64 #endif
  65 #ifdef HAVE_SYS_STRTIO_H
  66 # include <sys/strtio.h>
  67 #endif
  68 #include "heap.h"
  69 #include "options.h"
  70 #include "debug.h"
  71
  72 #ifndef TIOCINQ
  73 #define TIOCINQ FIONREAD
  74 #endif
  75 #define COMM_MSR_OFFSET  35       /* see knowledge base Q101417 */
  76 /*
  77  * [RER] These are globals are wrong.  They should be in DosDeviceStruct
  78  * on a per port basis.
  79  */
  80 int commerror = 0, eventmask = 0;
  81
  82 /*
  83  * [V] If above globals are wrong, the one below will be wrong as well. It
  84  * should probably be in the DosDeviceStruct on per port basis too.
  85 */
  86 int iGlobalOutQueueFiller;
  87
  88 #define SERIAL_XMIT_SIZE 4096
  89
  90 struct DosDeviceStruct COM[MAX_PORTS];
  91 struct DosDeviceStruct LPT[MAX_PORTS];
  92 /* pointers to unknown(==undocumented) comm structure */
  93 LPCVOID *unknown[MAX_PORTS];
  94 /* save terminal states */
  95 static struct termios m_stat[MAX_PORTS];
  96
  97 void COMM_Init(void)
  98 {
  99         int x;
 100         char option[10], temp[256], *btemp;
 101         struct stat st;
 102
 103         for (x=0; x!=MAX_PORTS; x++) {
 104                 strcpy(option,"COMx");
 105                 option[3] = '1' + x;
 106                 option[4] = '\0';
 107
 108                 PROFILE_GetWineIniString( "serialports", option, "*",
 109                                           temp, sizeof(temp) );
 110                 if (!strcmp(temp, "*") || *temp == '\0')
 111                         COM[x].devicename = NULL;
 112                 else {
 113                         btemp = strchr(temp,',');
 114                         if (btemp != NULL) {
 115                                 *btemp++ = '\0';
 116                                 COM[x].baudrate = atoi(btemp);
 117                         } else {
 118                                 COM[x].baudrate = -1;
 119                         }
 120                         stat(temp, &st);
 121                         if (!S_ISCHR(st.st_mode))
 122                                 WARN(comm,"Can't use `%s' as %s !\n", temp, option);
 123                         else
 124                                 if ((COM[x].devicename = malloc(strlen(temp)+1)) == NULL)
 125                                         WARN(comm,"Can't malloc for device info!\n");
 126                                 else {
 127                                         COM[x].fd = 0;
 128                                         strcpy(COM[x].devicename, temp);
 129                                 }
 130                 TRACE(comm, "%s = %s\n", option, COM[x].devicename);
 131                 }
 132
 133                 strcpy(option, "LPTx");
 134                 option[3] = '1' + x;
 135                 option[4] = '\0';
 136
 137                 PROFILE_GetWineIniString( "parallelports", option, "*",
 138                                           temp, sizeof(temp) );
 139                 if (!strcmp(temp, "*") || *temp == '\0')
 140                         LPT[x].devicename = NULL;
 141                 else {
 142                         stat(temp, &st);
 143                         if (!S_ISCHR(st.st_mode))
 144                                 WARN(comm,"Can't use `%s' as %s !\n", temp, option);
 145                         else
 146                                 if ((LPT[x].devicename = malloc(strlen(temp)+1)) == NULL)
 147                                         WARN(comm,"Can't malloc for device info!\n");
 148                                 else {
 149                                         LPT[x].fd = 0;
 150                                         strcpy(LPT[x].devicename, temp);
 151                                 }
 152                 TRACE(comm, "%s = %s\n", option, LPT[x].devicename);
 153                 }
 154
 155         }
 156 }
 157
 158
 159 struct DosDeviceStruct *GetDeviceStruct(int fd)
 160 {
 161         int x;
 162
 163         for (x=0; x!=MAX_PORTS; x++) {
 164             if (COM[x].fd == fd)
 165                 return &COM[x];
 166             if (LPT[x].fd == fd)
 167                 return &LPT[x];
 168         }
 169
 170         return NULL;
 171 }
 172
 173 int    GetCommPort(int fd)
 174 {
 175         int x;
 176
 177         for (x=0; x<MAX_PORTS; x++) {
 178              if (COM[x].fd == fd)
 179                  return x;
 180        }
 181
 182        return -1;
 183 }
 184
 185 int ValidCOMPort(int x)
 186 {
 187         return(x < MAX_PORTS ? (int) COM[x].devicename : 0);
 188 }
 189
 190 int ValidLPTPort(int x)
 191 {
 192         return(x < MAX_PORTS ? (int) LPT[x].devicename : 0);
 193 }
 194
 195 int WinError(void)
 196 {
 197         TRACE(comm, "errno = %d\n", errno);
 198         switch (errno) {
 199                 default:
 200                         return CE_IOE;
 201                 }
 202 }
 203
 204 /**************************************************************************
 205  *         BuildCommDCB         (USER.213)
 206  */
 207 BOOL16 WINAPI BuildCommDCB16(LPCSTR device, LPDCB16 lpdcb)
 208 {
 209         /* "COM1:9600,n,8,1"    */
 210         /*  012345              */
 211         int port;
 212         char *ptr, temp[256];
 213
 214         TRACE(comm, "(%s), ptr %p\n", device, lpdcb);
 215         commerror = 0;
 216
 217         if (!lstrncmpi32A(device,"COM",3)) {
 218                 port = device[3] - '0';
 219
 220
 221                 if (port-- == 0) {
 222                         ERR(comm, "BUG ! COM0 can't exists!.\n");
 223                         commerror = IE_BADID;
 224                 }
 225
 226                 if (!ValidCOMPort(port)) {
 227                         commerror = IE_BADID;
 228                         return -1;
 229                 }
 230
 231                 memset(lpdcb, 0, sizeof(DCB16)); /* initialize */
 232
 233                 if (!COM[port].fd) {
 234                     OpenComm(device, 0, 0);
 235                 }
 236                 lpdcb->Id = COM[port].fd;
 237
 238                 if (!*(device+4))
 239                         return 0;
 240
 241                 if (*(device+4) != ':')
 242                         return -1;
 243
 244                 strcpy(temp,device+5);
 245                 ptr = strtok(temp, ", ");
 246
 247                 if (COM[port].baudrate > 0)
 248                         lpdcb->BaudRate = COM[port].baudrate;
 249                 else
 250                         lpdcb->BaudRate = atoi(ptr);
 251                 TRACE(comm,"baudrate (%d)\n", lpdcb->BaudRate);
 252
 253                 ptr = strtok(NULL, ", ");
 254                 if (islower(*ptr))
 255                         *ptr = toupper(*ptr);
 256
 257                 TRACE(comm,"parity (%c)\n", *ptr);
 258                 lpdcb->fParity = TRUE;
 259                 switch (*ptr) {
 260                         case 'N':
 261                                 lpdcb->Parity = NOPARITY;
 262                                 lpdcb->fParity = FALSE;
 263                                 break;
 264                         case 'E':
 265                                 lpdcb->Parity = EVENPARITY;
 266                                 break;
 267                         case 'M':
 268                                 lpdcb->Parity = MARKPARITY;
 269                                 break;
 270                         case 'O':
 271                                 lpdcb->Parity = ODDPARITY;
 272                                 break;
 273                         default:
 274                                 WARN(comm,"Unknown parity `%c'!\n", *ptr);
 275                                 return -1;
 276                 }
 277
 278                 ptr = strtok(NULL, ", ");
 279                 TRACE(comm, "charsize (%c)\n", *ptr);
 280                 lpdcb->ByteSize = *ptr - '0';
 281
 282                 ptr = strtok(NULL, ", ");
 283                 TRACE(comm, "stopbits (%c)\n", *ptr);
 284                 switch (*ptr) {
 285                         case '1':
 286                                 lpdcb->StopBits = ONESTOPBIT;
 287                                 break;
 288                         case '2':
 289                                 lpdcb->StopBits = TWOSTOPBITS;
 290                                 break;
 291                         default:
 292                                 WARN(comm,"Unknown # of stopbits `%c'!\n", *ptr);
 293                                 return -1;
 294                 }
 295         }
 296
 297         return 0;
 298 }
 299
 300 /**************************************************************************
 301  *         BuildCommDCBA                (KERNEL32.14)
 302  */
 303 BOOL32 WINAPI BuildCommDCB32A(LPCSTR device,LPDCB32 lpdcb)
 304 {
 305         return BuildCommDCBAndTimeouts32A(device,lpdcb,NULL);
 306 }
 307
 308 /**************************************************************************
 309  *         BuildCommDCBAndTimeoutsA     (KERNEL32.15)
 310  */
 311 BOOL32 WINAPI BuildCommDCBAndTimeouts32A(LPCSTR device, LPDCB32 lpdcb,
 312                                          LPCOMMTIMEOUTS lptimeouts)
 313 {
 314         int     port;
 315         char    *ptr,*temp;
 316
 317         TRACE(comm,"(%s,%p,%p)\n",device,lpdcb,lptimeouts);
 318         commerror = 0;
 319
 320         if (!lstrncmpi32A(device,"COM",3)) {
 321                 port=device[3]-'0';
 322                 if (port--==0) {
 323                         ERR(comm,"BUG! COM0 can't exists!.\n");
 324                         return FALSE;
 325                 }
 326                 if (!ValidCOMPort(port))
 327                         return FALSE;
 328                 if (*(device+4)!=':')
 329                         return FALSE;
 330                 temp=(LPSTR)(device+5);
 331         } else
 332                 temp=(LPSTR)device;
 333
 334         memset(lpdcb, 0, sizeof(DCB32)); /* initialize */
 335
 336         lpdcb->DCBlength        = sizeof(DCB32);
 337         if (strchr(temp,',')) { /* old style */
 338                 DCB16   dcb16;
 339                 BOOL16  ret;
 340                 char    last=temp[strlen(temp)-1];
 341
 342                 ret=BuildCommDCB16(device,&dcb16);
 343                 if (!ret)
 344                         return FALSE;
 345                 lpdcb->BaudRate         = dcb16.BaudRate;
 346                 lpdcb->ByteSize         = dcb16.ByteSize;
 347                 lpdcb->fBinary          = dcb16.fBinary;
 348                 lpdcb->Parity           = dcb16.Parity;
 349                 lpdcb->fParity          = dcb16.fParity;
 350                 lpdcb->fNull            = dcb16.fNull;
 351                 lpdcb->StopBits         = dcb16.StopBits;
 352                 if (last == 'x') {
 353                         lpdcb->fInX             = TRUE;
 354                         lpdcb->fOutX            = TRUE;
 355                         lpdcb->fOutxCtsFlow     = FALSE;
 356                         lpdcb->fOutxDsrFlow     = FALSE;
 357                         lpdcb->fDtrControl      = DTR_CONTROL_ENABLE;
 358                         lpdcb->fRtsControl      = RTS_CONTROL_ENABLE;
 359                 } else if (last=='p') {
 360                         lpdcb->fInX             = FALSE;
 361                         lpdcb->fOutX            = FALSE;
 362                         lpdcb->fOutxCtsFlow     = TRUE;
 363                         lpdcb->fOutxDsrFlow     = TRUE;
 364                         lpdcb->fDtrControl      = DTR_CONTROL_HANDSHAKE;
 365                         lpdcb->fRtsControl      = RTS_CONTROL_HANDSHAKE;
 366                 } else {
 367                         lpdcb->fInX             = FALSE;
 368                         lpdcb->fOutX            = FALSE;
 369                         lpdcb->fOutxCtsFlow     = FALSE;
 370                         lpdcb->fOutxDsrFlow     = FALSE;
 371                         lpdcb->fDtrControl      = DTR_CONTROL_ENABLE;
 372                         lpdcb->fRtsControl      = RTS_CONTROL_ENABLE;
 373                 }
 374                 lpdcb->XonChar  = dcb16.XonChar;
 375                 lpdcb->XoffChar = dcb16.XoffChar;
 376                 lpdcb->ErrorChar= dcb16.PeChar;
 377                 lpdcb->fErrorChar= dcb16.fPeChar;
 378                 lpdcb->EofChar  = dcb16.EofChar;
 379                 lpdcb->EvtChar  = dcb16.EvtChar;
 380                 lpdcb->XonLim   = dcb16.XonLim;
 381                 lpdcb->XoffLim  = dcb16.XoffLim;
 382                 return TRUE;
 383         }
 384         ptr=strtok(temp," ");
 385         while (ptr) {
 386                 DWORD   flag,x;
 387
 388                 flag=0;
 389                 if (!strncmp("baud=",ptr,5)) {
 390                         if (!sscanf(ptr+5,"%ld",&x))
 391                                 WARN(comm,"Couldn't parse %s\n",ptr);
 392                         lpdcb->BaudRate = x;
 393                         flag=1;
 394                 }
 395                 if (!strncmp("stop=",ptr,5)) {
 396                         if (!sscanf(ptr+5,"%ld",&x))
 397                                 WARN(comm,"Couldn't parse %s\n",ptr);
 398                         lpdcb->StopBits = x;
 399                         flag=1;
 400                 }
 401                 if (!strncmp("data=",ptr,5)) {
 402                         if (!sscanf(ptr+5,"%ld",&x))
 403                                 WARN(comm,"Couldn't parse %s\n",ptr);
 404                         lpdcb->ByteSize = x;
 405                         flag=1;
 406                 }
 407                 if (!strncmp("parity=",ptr,7)) {
 408                         lpdcb->fParity  = TRUE;
 409                         switch (ptr[8]) {
 410                         case 'N':case 'n':
 411                                 lpdcb->fParity  = FALSE;
 412                                 lpdcb->Parity   = NOPARITY;
 413                                 break;
 414                         case 'E':case 'e':
 415                                 lpdcb->Parity   = EVENPARITY;
 416                                 break;
 417                         case 'O':case 'o':
 418                                 lpdcb->Parity   = ODDPARITY;
 419                                 break;
 420                         case 'M':case 'm':
 421                                 lpdcb->Parity   = MARKPARITY;
 422                                 break;
 423                         }
 424                         flag=1;
 425                 }
 426                 if (!flag)
 427                         ERR(comm,"Unhandled specifier '%s', please report.\n",ptr);
 428                 ptr=strtok(NULL," ");
 429         }
 430         if (lpdcb->BaudRate==110)
 431                 lpdcb->StopBits = 2;
 432         return TRUE;
 433 }
 434
 435 /**************************************************************************
 436  *         BuildCommDCBAndTimeoutsW             (KERNEL32.16)
 437  */
 438 BOOL32 WINAPI BuildCommDCBAndTimeouts32W( LPCWSTR devid, LPDCB32 lpdcb,
 439                                           LPCOMMTIMEOUTS lptimeouts )
 440 {
 441         LPSTR   devidA;
 442         BOOL32  ret;
 443
 444         TRACE(comm,"(%p,%p,%p)\n",devid,lpdcb,lptimeouts);
 445         devidA = HEAP_strdupWtoA( GetProcessHeap(), 0, devid );
 446         ret=BuildCommDCBAndTimeouts32A(devidA,lpdcb,lptimeouts);
 447         HeapFree( GetProcessHeap(), 0, devidA );
 448         return ret;
 449 }
 450
 451 /**************************************************************************
 452  *         BuildCommDCBW                (KERNEL32.17)
 453  */
 454 BOOL32 WINAPI BuildCommDCB32W(LPCWSTR devid,LPDCB32 lpdcb)
 455 {
 456         return BuildCommDCBAndTimeouts32W(devid,lpdcb,NULL);
 457 }
 458
 459 /*****************************************************************************
 460  *      OpenComm                (USER.200)
 461  */
 462 INT16 WINAPI OpenComm(LPCSTR device,UINT16 cbInQueue,UINT16 cbOutQueue)
 463 {
 464         int port,fd;
 465
 466         TRACE(comm, "%s, %d, %d\n", device, cbInQueue, cbOutQueue);
 467         commerror = 0;
 468
 469         if (!lstrncmpi32A(device,"COM",3)) {
 470                 port = device[3] - '0';
 471
 472                 if (port-- == 0) {
 473                         ERR(comm, "BUG ! COM0 doesn't exist !\n");
 474                         commerror = IE_BADID;
 475                 }
 476
 477                 /* to help GetCommError return left buffsize [V] */
 478                 iGlobalOutQueueFiller = (cbOutQueue - SERIAL_XMIT_SIZE);
 479                 if (iGlobalOutQueueFiller < 0) iGlobalOutQueueFiller = 0;
 480
 481                 TRACE(comm, "%s = %s\n", device, COM[port].devicename);
 482
 483                 if (!ValidCOMPort(port)) {
 484                         commerror = IE_BADID;
 485                         return -1;
 486                 }
 487                 if (COM[port].fd) {
 488                         return COM[port].fd;
 489                 }
 490
 491                 fd = open(COM[port].devicename, O_RDWR | O_NONBLOCK);
 492                 if (fd == -1) {
 493                         commerror = WinError();
 494                         return -1;
 495                 } else {
 496                         unknown[port] = SEGPTR_ALLOC(40);
 497                         bzero(unknown[port],40);
 498                         COM[port].fd = fd;
 499                         /* save terminal state */
 500                         tcgetattr(fd,&m_stat[port]);
 501                         return fd;
 502                 }
 503         }
 504         else
 505         if (!lstrncmpi32A(device,"LPT",3)) {
 506                 port = device[3] - '0';
 507
 508                 if (!ValidLPTPort(port)) {
 509                         commerror = IE_BADID;
 510                         return -1;
 511                 }
 512                 if (LPT[port].fd) {
 513                         commerror = IE_OPEN;
 514                         return -1;
 515                 }
 516
 517                 fd = open(LPT[port].devicename, O_RDWR | O_NONBLOCK, 0);
 518                 if (fd == -1) {
 519                         commerror = WinError();
 520                         return -1;
 521                 } else {
 522                         LPT[port].fd = fd;
 523                         return fd;
 524                 }
 525         }
 526         return 0;
 527 }
 528
 529 /*****************************************************************************
 530  *      CloseComm               (USER.207)
 531  */
 532 INT16 WINAPI CloseComm(INT16 fd)
 533 {
 534         int port;
 535
 536         TRACE(comm,"fd %d\n", fd);
 537         if ((port = GetCommPort(fd)) !=-1) {  /* [LW]       */
 538                 SEGPTR_FREE(unknown[port]);
 539                 COM[port].fd = 0;       /*  my adaptation of RER's fix   */
 540         }  else {
 541                 commerror = IE_BADID;
 542                 return -1;
 543         }
 544
 545         /* reset modem lines */
 546         tcsetattr(fd,TCSANOW,&m_stat[port]);
 547
 548         if (close(fd) == -1) {
 549                 commerror = WinError();
 550                 return -1;
 551         } else {
 552                 commerror = 0;
 553                 return 0;
 554         }
 555 }
 556
 557 /*****************************************************************************
 558  *      SetCommBreak            (USER.210)
 559  */
 560 INT16 WINAPI SetCommBreak16(INT16 fd)
 561 {
 562         struct DosDeviceStruct *ptr;
 563
 564         TRACE(comm,"fd=%d\n", fd);
 565         if ((ptr = GetDeviceStruct(fd)) == NULL) {
 566                 commerror = IE_BADID;
 567                 return -1;
 568         }
 569
 570         ptr->suspended = 1;
 571         commerror = 0;
 572         return 0;
 573 }
 574
 575 /*****************************************************************************
 576  *      SetCommBreak            (KERNEL32.449)
 577  */
 578 BOOL32 WINAPI SetCommBreak32(INT32 fd)
 579 {
 580
 581         struct DosDeviceStruct *ptr;
 582
 583         TRACE(comm,"fd=%d\n", fd);
 584         if ((ptr = GetDeviceStruct(fd)) == NULL) {
 585                 commerror = IE_BADID;
 586                 return FALSE;
 587         }
 588
 589         ptr->suspended = 1;
 590         commerror = 0;
 591         return TRUE;
 592 }
 593
 594 /*****************************************************************************
 595  *      ClearCommBreak          (USER.211)
 596  */
 597 INT16 WINAPI ClearCommBreak16(INT16 fd)
 598 {
 599         struct DosDeviceStruct *ptr;
 600
 601         TRACE(comm,"fd=%d\n", fd);
 602         if ((ptr = GetDeviceStruct(fd)) == NULL) {
 603                 commerror = IE_BADID;
 604                 return -1;
 605         }
 606
 607         ptr->suspended = 0;
 608         commerror = 0;
 609         return 0;
 610 }
 611
 612 /*****************************************************************************
 613  *      ClearCommBreak          (KERNEL32.20)
 614  */
 615 BOOL32 WINAPI ClearCommBreak32(INT32 fd)
 616 {
 617         struct DosDeviceStruct *ptr;
 618
 619         TRACE(comm,"fd=%d\n", fd);
 620         if ((ptr = GetDeviceStruct(fd)) == NULL) {
 621                 commerror = IE_BADID;
 622                 return FALSE;
 623         }
 624
 625         ptr->suspended = 0;
 626         commerror = 0;
 627         return TRUE;
 628 }
 629
 630 /*****************************************************************************
 631  *      EscapeCommFunction      (USER.214)
 632  */
 633 LONG WINAPI EscapeCommFunction16(UINT16 fd,UINT16 nFunction)
 634 {
 635         int     max;
 636         struct termios port;
 637
 638         TRACE(comm,"fd=%d, function=%d\n", fd, nFunction);
 639         if (tcgetattr(fd,&port) == -1) {
 640                 commerror=WinError();
 641                 return -1;
 642         }
 643
 644         switch (nFunction) {
 645                 case RESETDEV:
 646                         break;
 647
 648                 case GETMAXCOM:
 649                         for (max = MAX_PORTS;!COM[max].devicename;max--)
 650                                 ;
 651                         return max;
 652                         break;
 653
 654                 case GETMAXLPT:
 655                         for (max = MAX_PORTS;!LPT[max].devicename;max--)
 656                                 ;
 657                         return 0x80 + max;
 658                         break;
 659
 660 #ifdef TIOCM_DTR
 661                 case CLRDTR:
 662                         port.c_cflag &= TIOCM_DTR;
 663                         break;
 664 #endif
 665
 666 #ifdef TIOCM_RTS
 667                 case CLRRTS:
 668                         port.c_cflag &= TIOCM_RTS;
 669                         break;
 670 #endif
 671
 672 #ifdef CRTSCTS
 673                 case SETDTR:
 674                         port.c_cflag |= CRTSCTS;
 675                         break;
 676
 677                 case SETRTS:
 678                         port.c_cflag |= CRTSCTS;
 679                         break;
 680 #endif
 681
 682                 case SETXOFF:
 683                         port.c_iflag |= IXOFF;
 684                         break;
 685
 686                 case SETXON:
 687                         port.c_iflag |= IXON;
 688                         break;
 689
 690                 default:
 691                         WARN(comm,"(fd=%d,nFunction=%d): Unknown function\n",
 692                         fd, nFunction);
 693                         break;
 694         }
 695
 696         if (tcsetattr(fd, TCSADRAIN, &port) == -1) {
 697                 commerror = WinError();
 698                 return -1;
 699         } else {
 700                 commerror = 0;
 701                 return 0;
 702         }
 703 }
 704
 705 /*****************************************************************************
 706  *      EscapeCommFunction      (KERNEL32.214)
 707  */
 708 BOOL32 WINAPI EscapeCommFunction32(INT32 fd,UINT32 nFunction)
 709 {
 710         struct termios  port;
 711         struct DosDeviceStruct *ptr;
 712
 713         TRACE(comm,"fd=%d, function=%d\n", fd, nFunction);
 714         if (tcgetattr(fd,&port) == -1) {
 715                 commerror=WinError();
 716                 return FALSE;
 717         }
 718         if ((ptr = GetDeviceStruct(fd)) == NULL) {
 719                 commerror = IE_BADID;
 720                 return FALSE;
 721         }
 722
 723         switch (nFunction) {
 724                 case RESETDEV:
 725                         break;
 726
 727 #ifdef TIOCM_DTR
 728                 case CLRDTR:
 729                         port.c_cflag &= TIOCM_DTR;
 730                         break;
 731 #endif
 732
 733 #ifdef TIOCM_RTS
 734                 case CLRRTS:
 735                         port.c_cflag &= TIOCM_RTS;
 736                         break;
 737 #endif
 738
 739 #ifdef CRTSCTS
 740                 case SETDTR:
 741                         port.c_cflag |= CRTSCTS;
 742                         break;
 743
 744                 case SETRTS:
 745                         port.c_cflag |= CRTSCTS;
 746                         break;
 747 #endif
 748
 749                 case SETXOFF:
 750                         port.c_iflag |= IXOFF;
 751                         break;
 752
 753                 case SETXON:
 754                         port.c_iflag |= IXON;
 755                         break;
 756                 case SETBREAK:
 757                         ptr->suspended = 1;
 758                         break;
 759                 case CLRBREAK:
 760                         ptr->suspended = 0;
 761                         break;
 762                 default:
 763                         WARN(comm,"(fd=%d,nFunction=%d): Unknown function\n",
 764                         fd, nFunction);
 765                         break;
 766         }
 767
 768         if (tcsetattr(fd, TCSADRAIN, &port) == -1) {
 769                 commerror = WinError();
 770                 return FALSE;
 771         } else {
 772                 commerror = 0;
 773                 return TRUE;
 774         }
 775 }
 776
 777 /*****************************************************************************
 778  *      FlushComm       (USER.215)
 779  */
 780 INT16 WINAPI FlushComm(INT16 fd,INT16 fnQueue)
 781 {
 782         int queue;
 783
 784         TRACE(comm,"fd=%d, queue=%d\n", fd, fnQueue);
 785         switch (fnQueue) {
 786                 case 0: queue = TCOFLUSH;
 787                         break;
 788                 case 1: queue = TCIFLUSH;
 789                         break;
 790                 default:WARN(comm,"(fd=%d,fnQueue=%d):Unknown queue\n",
 791                                 fd, fnQueue);
 792                         return -1;
 793                 }
 794         if (tcflush(fd, queue)) {
 795                 commerror = WinError();
 796                 return -1;
 797         } else {
 798                 commerror = 0;
 799                 return 0;
 800         }
 801 }
 802
 803 /********************************************************************
 804  *      PurgeComm        (KERNEL32.557)
 805  */
 806 BOOL32 WINAPI PurgeComm( HANDLE32 hFile, DWORD flags)
 807 {
 808     FIXME(comm, "(%08x %08lx) unimplemented stub\n",
 809                  hFile, flags);
 810     return 0;
 811 }
 812
 813 /********************************************************************
 814  *      GetCommError    (USER.203)
 815  */
 816 INT16 WINAPI GetCommError(INT16 fd,LPCOMSTAT lpStat)
 817 {
 818         int             temperror;
 819         unsigned long   cnt;
 820         int             rc;
 821
 822         unsigned char *stol;
 823         int act;
 824         unsigned int mstat;
 825         if ((act = GetCommPort(fd)) == -1) {
 826             WARN(comm," fd %d not comm port\n",act);
 827             return CE_MODE;
 828         }
 829         stol = (unsigned char *)unknown[act] + COMM_MSR_OFFSET;
 830         ioctl(fd,TIOCMGET,&mstat);
 831         if( mstat&TIOCM_CAR )
 832             *stol |= 0x80;
 833         else
 834             *stol &=0x7f;
 835
 836         if (lpStat) {
 837                 lpStat->status = 0;
 838
 839                 rc = ioctl(fd, TIOCOUTQ, &cnt);
 840                 if (rc) WARN(comm, "Error !\n");
 841                 lpStat->cbOutQue = cnt + iGlobalOutQueueFiller;
 842
 843                 rc = ioctl(fd, TIOCINQ, &cnt);
 844                 if (rc) WARN(comm, "Error !\n");
 845                 lpStat->cbInQue = cnt;
 846
 847                 TRACE(comm, "fd %d, error %d, lpStat %d %d %d stol %x\n",
 848                              fd, commerror, lpStat->status, lpStat->cbInQue,
 849                              lpStat->cbOutQue, *stol);
 850         }
 851         else
 852                 TRACE(comm, "fd %d, error %d, lpStat NULL stol %x\n",
 853                              fd, commerror, *stol);
 854
 855         /*
 856          * [RER] I have no idea what the following is trying to accomplish.
 857          * [RER] It is certainly not what the reference manual suggests.
 858          */
 859         temperror = commerror;
 860         commerror = 0;
 861         return(temperror);
 862 }
 863
 864 /*****************************************************************************
 865  *      ClearCommError  (KERNEL32.21)
 866  */
 867 BOOL32 WINAPI ClearCommError(INT32 fd,LPDWORD errors,LPCOMSTAT lpStat)
 868 {
 869         int temperror;
 870
 871         TRACE(comm, "fd %d (current error %d)\n",
 872                fd, commerror);
 873         temperror = commerror;
 874         commerror = 0;
 875         return TRUE;
 876 }
 877
 878 /*****************************************************************************
 879  *      SetCommEventMask        (USER.208)
 880  */
 881 SEGPTR WINAPI SetCommEventMask(INT16 fd,UINT16 fuEvtMask)
 882 {
 883         unsigned char *stol;
 884         int act;
 885         int repid;
 886         unsigned int mstat;
 887         TRACE(comm,"fd %d,mask %d\n",fd,fuEvtMask);
 888         eventmask |= fuEvtMask;
 889         if ((act = GetCommPort(fd)) == -1) {
 890             WARN(comm," fd %d not comm port\n",act);
 891             return SEGPTR_GET(NULL);
 892         }
 893         stol = (unsigned char *)unknown[act];
 894         stol += COMM_MSR_OFFSET;
 895         repid = ioctl(fd,TIOCMGET,&mstat);
 896         TRACE(comm, " ioctl  %d, msr %x at %p %p\n",repid,mstat,stol,unknown[act]);
 897         if ((mstat&TIOCM_CAR)) {*stol |= 0x80;}
 898              else {*stol &=0x7f;}
 899         TRACE(comm," modem dcd construct %x\n",*stol);
 900         return SEGPTR_GET(unknown[act]);
 901 }
 902
 903 /*****************************************************************************
 904  *      GetCommEventMask        (USER.209)
 905  */
 906 UINT16 WINAPI GetCommEventMask(INT16 fd,UINT16 fnEvtClear)
 907 {
 908         int     events = 0;
 909
 910         TRACE(comm, "fd %d, mask %d\n", fd, fnEvtClear);
 911
 912         /*
 913          *      Determine if any characters are available
 914          */
 915         if (fnEvtClear & EV_RXCHAR)
 916         {
 917                 int             rc;
 918                 unsigned long   cnt;
 919
 920                 rc = ioctl(fd, TIOCINQ, &cnt);
 921                 if (cnt) events |= EV_RXCHAR;
 922
 923                 TRACE(comm, "rxchar %ld\n", cnt);
 924         }
 925
 926         /*
 927          *      There are other events that need to be checked for
 928          */
 929         /* TODO */
 930
 931         TRACE(comm, "return events %d\n", events);
 932         return events;
 933
 934         /*
 935          * [RER] The following was gibberish
 936          */
 937 #if 0
 938         tempmask = eventmask;
 939         eventmask &= ~fnEvtClear;
 940         return eventmask;
 941 #endif
 942 }
 943
 944 /*****************************************************************************
 945  *      SetupComm       (KERNEL32.676)
 946  */
 947 BOOL32 WINAPI SetupComm( HANDLE32 hFile, DWORD insize, DWORD outsize)
 948 {
 949         FIXME(comm, "insize %ld outsize %ld unimplemented stub\n", insize, outsize);
 950        return FALSE;
 951 }
 952
 953 /*****************************************************************************
 954  *      GetCommMask     (KERNEL32.156)
 955  */
 956 BOOL32 WINAPI GetCommMask(HANDLE32 fd,LPDWORD evtmask)
 957 {
 958         TRACE(comm, "fd %d, mask %p\n", fd, evtmask);
 959         *evtmask = eventmask;
 960         return TRUE;
 961 }
 962
 963 /*****************************************************************************
 964  *      SetCommMask     (KERNEL32.451)
 965  */
 966 BOOL32 WINAPI SetCommMask(INT32 fd,DWORD evtmask)
 967 {
 968         TRACE(comm, "fd %d, mask %lx\n", fd, evtmask);
 969         eventmask = evtmask;
 970         return TRUE;
 971 }
 972
 973 /*****************************************************************************
 974  *      SetCommState16  (USER.201)
 975  */
 976 INT16 WINAPI SetCommState16(LPDCB16 lpdcb)
 977 {
 978         struct termios port;
 979         struct DosDeviceStruct *ptr;
 980
 981         TRACE(comm, "fd %d, ptr %p\n", lpdcb->Id, lpdcb);
 982         if (tcgetattr(lpdcb->Id, &port) == -1) {
 983                 commerror = WinError();
 984                 return -1;
 985         }
 986
 987         port.c_cc[VMIN] = 0;
 988         port.c_cc[VTIME] = 1;
 989
 990 #ifdef IMAXBEL
 991         port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
 992 #else
 993         port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
 994 #endif
 995         port.c_iflag |= (IGNBRK);
 996
 997         port.c_oflag &= ~(OPOST);
 998
 999         port.c_cflag &= ~(HUPCL);
1000         port.c_cflag |= CLOCAL | CREAD;
1001
1002         port.c_lflag &= ~(ICANON|ECHO|ISIG);
1003         port.c_lflag |= NOFLSH;
1004
1005         if ((ptr = GetDeviceStruct(lpdcb->Id)) == NULL) {
1006                 commerror = IE_BADID;
1007                 return -1;
1008         }
1009         if (ptr->baudrate > 0)
1010                 lpdcb->BaudRate = ptr->baudrate;
1011         TRACE(comm,"baudrate %d\n",lpdcb->BaudRate);
1012 #ifdef CBAUD
1013         port.c_cflag &= ~CBAUD;
1014         switch (lpdcb->BaudRate) {
1015                 case 110:
1016                 case CBR_110:
1017                         port.c_cflag |= B110;
1018                         break;
1019                 case 300:
1020                 case CBR_300:
1021                         port.c_cflag |= B300;
1022                         break;
1023                 case 600:
1024                 case CBR_600:
1025                         port.c_cflag |= B600;
1026                         break;
1027                 case 1200:
1028                 case CBR_1200:
1029                         port.c_cflag |= B1200;
1030                         break;
1031                 case 2400:
1032                 case CBR_2400:
1033                         port.c_cflag |= B2400;
1034                         break;
1035                 case 4800:
1036                 case CBR_4800:
1037                         port.c_cflag |= B4800;
1038                         break;
1039                 case 9600:
1040                 case CBR_9600:
1041                         port.c_cflag |= B9600;
1042                         break;
1043                 case 19200:
1044                 case CBR_19200:
1045                         port.c_cflag |= B19200;
1046                         break;
1047                 case 38400:
1048                 case CBR_38400:
1049                         port.c_cflag |= B38400;
1050                         break;
1051                 case 57600:
1052                         port.c_cflag |= B57600;
1053                         break;
1054                 case 57601:
1055                         port.c_cflag |= B115200;
1056                         break;
1057                 default:
1058                         commerror = IE_BAUDRATE;
1059                         return -1;
1060         }
1061 #elif !defined(__EMX__)
1062         switch (lpdcb->BaudRate) {
1063                 case 110:
1064                 case CBR_110:
1065                         port.c_ospeed = B110;
1066                         break;
1067                 case 300:
1068                 case CBR_300:
1069                         port.c_ospeed = B300;
1070                         break;
1071                 case 600:
1072                 case CBR_600:
1073                         port.c_ospeed = B600;
1074                         break;
1075                 case 1200:
1076                 case CBR_1200:
1077                         port.c_ospeed = B1200;
1078                         break;
1079                 case 2400:
1080                 case CBR_2400:
1081                         port.c_ospeed = B2400;
1082                         break;
1083                 case 4800:
1084                 case CBR_4800:
1085                         port.c_ospeed = B4800;
1086                         break;
1087                 case 9600:
1088                 case CBR_9600:
1089                         port.c_ospeed = B9600;
1090                         break;
1091                 case 19200:
1092                 case CBR_19200:
1093                         port.c_ospeed = B19200;
1094                         break;
1095                 case 38400:
1096                 case CBR_38400:
1097                         port.c_ospeed = B38400;
1098                         break;
1099                 default:
1100                         commerror = IE_BAUDRATE;
1101                         return -1;
1102         }
1103         port.c_ispeed = port.c_ospeed;
1104 #endif
1105         TRACE(comm,"bytesize %d\n",lpdcb->ByteSize);
1106         port.c_cflag &= ~CSIZE;
1107         switch (lpdcb->ByteSize) {
1108                 case 5:
1109                         port.c_cflag |= CS5;
1110                         break;
1111                 case 6:
1112                         port.c_cflag |= CS6;
1113                         break;
1114                 case 7:
1115                         port.c_cflag |= CS7;
1116                         break;
1117                 case 8:
1118                         port.c_cflag |= CS8;
1119                         break;
1120                 default:
1121                         commerror = IE_BYTESIZE;
1122                         return -1;
1123         }
1124
1125         TRACE(comm,"parity %d\n",lpdcb->Parity);
1126         port.c_cflag &= ~(PARENB | PARODD);
1127         if (lpdcb->fParity)
1128                 switch (lpdcb->Parity) {
1129                         case NOPARITY:
1130                                 port.c_iflag &= ~INPCK;
1131                                 break;
1132                         case ODDPARITY:
1133                                 port.c_cflag |= (PARENB | PARODD);
1134                                 port.c_iflag |= INPCK;
1135                                 break;
1136                         case EVENPARITY:
1137                                 port.c_cflag |= PARENB;
1138                                 port.c_iflag |= INPCK;
1139                                 break;
1140                         default:
1141                                 commerror = IE_BYTESIZE;
1142                                 return -1;
1143                 }
1144
1145
1146         TRACE(comm,"stopbits %d\n",lpdcb->StopBits);
1147
1148         switch (lpdcb->StopBits) {
1149                 case ONESTOPBIT:
1150                                 port.c_cflag &= ~CSTOPB;
1151                                 break;
1152                 case TWOSTOPBITS:
1153                                 port.c_cflag |= CSTOPB;
1154                                 break;
1155                 default:
1156                         commerror = IE_BYTESIZE;
1157                         return -1;
1158         }
1159 #ifdef CRTSCTS
1160
1161         if (lpdcb->fDtrflow || lpdcb->fRtsflow || lpdcb->fOutxCtsFlow)
1162                 port.c_cflag |= CRTSCTS;
1163
1164         if (lpdcb->fDtrDisable)
1165                 port.c_cflag &= ~CRTSCTS;
1166 #endif
1167         if (lpdcb->fInX)
1168                 port.c_iflag |= IXON;
1169         else
1170                 port.c_iflag &= ~IXON;
1171         if (lpdcb->fOutX)
1172                 port.c_iflag |= IXOFF;
1173         else
1174                 port.c_iflag &= ~IXOFF;
1175
1176         if (tcsetattr(lpdcb->Id, TCSADRAIN, &port) == -1) {
1177                 commerror = WinError();
1178                 return FALSE;
1179         } else {
1180                 commerror = 0;
1181                 return 0;
1182         }
1183 }
1184
1185 /*****************************************************************************
1186  *      SetCommState32  (KERNEL32.452)
1187  */
1188 BOOL32 WINAPI SetCommState32(INT32 fd,LPDCB32 lpdcb)
1189 {
1190         struct termios port;
1191         struct DosDeviceStruct *ptr;
1192
1193         TRACE(comm,"fd %d, ptr %p\n",fd,lpdcb);
1194         if (tcgetattr(fd,&port) == -1) {
1195                 commerror = WinError();
1196                 return FALSE;
1197         }
1198
1199         port.c_cc[VMIN] = 0;
1200         port.c_cc[VTIME] = 1;
1201
1202 #ifdef IMAXBEL
1203         port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
1204 #else
1205         port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
1206 #endif
1207         port.c_iflag |= (IGNBRK);
1208
1209         port.c_oflag &= ~(OPOST);
1210
1211         port.c_cflag &= ~(HUPCL);
1212         port.c_cflag |= CLOCAL | CREAD;
1213
1214         port.c_lflag &= ~(ICANON|ECHO|ISIG);
1215         port.c_lflag |= NOFLSH;
1216
1217         if ((ptr = GetDeviceStruct(fd)) == NULL) {
1218                 commerror = IE_BADID;
1219                 return FALSE;
1220         }
1221         if (ptr->baudrate > 0)
1222                 lpdcb->BaudRate = ptr->baudrate;
1223         TRACE(comm,"baudrate %ld\n",lpdcb->BaudRate);
1224 #ifdef CBAUD
1225         port.c_cflag &= ~CBAUD;
1226         switch (lpdcb->BaudRate) {
1227                 case 110:
1228                 case CBR_110:
1229                         port.c_cflag |= B110;
1230                         break;
1231                 case 300:
1232                 case CBR_300:
1233                         port.c_cflag |= B300;
1234                         break;
1235                 case 600:
1236                 case CBR_600:
1237                         port.c_cflag |= B600;
1238                         break;
1239                 case 1200:
1240                 case CBR_1200:
1241                         port.c_cflag |= B1200;
1242                         break;
1243                 case 2400:
1244                 case CBR_2400:
1245                         port.c_cflag |= B2400;
1246                         break;
1247                 case 4800:
1248                 case CBR_4800:
1249                         port.c_cflag |= B4800;
1250                         break;
1251                 case 9600:
1252                 case CBR_9600:
1253                         port.c_cflag |= B9600;
1254                         break;
1255                 case 19200:
1256                 case CBR_19200:
1257                         port.c_cflag |= B19200;
1258                         break;
1259                 case 38400:
1260                 case CBR_38400:
1261                         port.c_cflag |= B38400;
1262                         break;
1263                 default:
1264                         commerror = IE_BAUDRATE;
1265                         return FALSE;
1266         }
1267 #elif !defined(__EMX__)
1268         switch (lpdcb->BaudRate) {
1269                 case 110:
1270                 case CBR_110:
1271                         port.c_ospeed = B110;
1272                         break;
1273                 case 300:
1274                 case CBR_300:
1275                         port.c_ospeed = B300;
1276                         break;
1277                 case 600:
1278                 case CBR_600:
1279                         port.c_ospeed = B600;
1280                         break;
1281                 case 1200:
1282                 case CBR_1200:
1283                         port.c_ospeed = B1200;
1284                         break;
1285                 case 2400:
1286                 case CBR_2400:
1287                         port.c_ospeed = B2400;
1288                         break;
1289                 case 4800:
1290                 case CBR_4800:
1291                         port.c_ospeed = B4800;
1292                         break;
1293                 case 9600:
1294                 case CBR_9600:
1295                         port.c_ospeed = B9600;
1296                         break;
1297                 case 19200:
1298                 case CBR_19200:
1299                         port.c_ospeed = B19200;
1300                         break;
1301                 case 38400:
1302                 case CBR_38400:
1303                         port.c_ospeed = B38400;
1304                         break;
1305                 default:
1306                         commerror = IE_BAUDRATE;
1307                         return FALSE;
1308         }
1309         port.c_ispeed = port.c_ospeed;
1310 #endif
1311         TRACE(comm,"bytesize %d\n",lpdcb->ByteSize);
1312         port.c_cflag &= ~CSIZE;
1313         switch (lpdcb->ByteSize) {
1314                 case 5:
1315                         port.c_cflag |= CS5;
1316                         break;
1317                 case 6:
1318                         port.c_cflag |= CS6;
1319                         break;
1320                 case 7:
1321                         port.c_cflag |= CS7;
1322                         break;
1323                 case 8:
1324                         port.c_cflag |= CS8;
1325                         break;
1326                 default:
1327                         commerror = IE_BYTESIZE;
1328                         return FALSE;
1329         }
1330
1331         TRACE(comm,"parity %d\n",lpdcb->Parity);
1332         port.c_cflag &= ~(PARENB | PARODD);
1333         if (lpdcb->fParity)
1334                 switch (lpdcb->Parity) {
1335                         case NOPARITY:
1336                                 port.c_iflag &= ~INPCK;
1337                                 break;
1338                         case ODDPARITY:
1339                                 port.c_cflag |= (PARENB | PARODD);
1340                                 port.c_iflag |= INPCK;
1341                                 break;
1342                         case EVENPARITY:
1343                                 port.c_cflag |= PARENB;
1344                                 port.c_iflag |= INPCK;
1345                                 break;
1346                         default:
1347                                 commerror = IE_BYTESIZE;
1348                                 return FALSE;
1349                 }
1350
1351
1352         TRACE(comm,"stopbits %d\n",lpdcb->StopBits);
1353         switch (lpdcb->StopBits) {
1354                 case ONESTOPBIT:
1355                                 port.c_cflag &= ~CSTOPB;
1356                                 break;
1357                 case TWOSTOPBITS:
1358                                 port.c_cflag |= CSTOPB;
1359                                 break;
1360                 default:
1361                         commerror = IE_BYTESIZE;
1362                         return FALSE;
1363         }
1364 #ifdef CRTSCTS
1365         if (    lpdcb->fOutxCtsFlow                     ||
1366                 lpdcb->fDtrControl == DTR_CONTROL_ENABLE||
1367                 lpdcb->fRtsControl == RTS_CONTROL_ENABLE
1368         )
1369                 port.c_cflag |= CRTSCTS;
1370         if (lpdcb->fDtrControl == DTR_CONTROL_DISABLE)
1371                 port.c_cflag &= ~CRTSCTS;
1372
1373 #endif
1374         if (lpdcb->fInX)
1375                 port.c_iflag |= IXON;
1376         else
1377                 port.c_iflag &= ~IXON;
1378         if (lpdcb->fOutX)
1379                 port.c_iflag |= IXOFF;
1380         else
1381                 port.c_iflag &= ~IXOFF;
1382
1383         if (tcsetattr(fd,TCSADRAIN,&port)==-1) {
1384                 commerror = WinError();
1385                 return FALSE;
1386         } else {
1387                 commerror = 0;
1388                 return TRUE;
1389         }
1390 }
1391
1392
1393 /*****************************************************************************
1394  *      GetCommState    (USER.202)
1395  */
1396 INT16 WINAPI GetCommState16(INT16 fd, LPDCB16 lpdcb)
1397 {
1398         struct termios port;
1399
1400         TRACE(comm,"fd %d, ptr %p\n", fd, lpdcb);
1401         if (tcgetattr(fd, &port) == -1) {
1402                 commerror = WinError();
1403                 return -1;
1404         }
1405         lpdcb->Id = fd;
1406 #ifndef __EMX__
1407 #ifdef CBAUD
1408         switch (port.c_cflag & CBAUD) {
1409 #else
1410         switch (port.c_ospeed) {
1411 #endif
1412                 case B110:
1413                         lpdcb->BaudRate = 110;
1414                         break;
1415                 case B300:
1416                         lpdcb->BaudRate = 300;
1417                         break;
1418                 case B600:
1419                         lpdcb->BaudRate = 600;
1420                         break;
1421                 case B1200:
1422                         lpdcb->BaudRate = 1200;
1423                         break;
1424                 case B2400:
1425                         lpdcb->BaudRate = 2400;
1426                         break;
1427                 case B4800:
1428                         lpdcb->BaudRate = 4800;
1429                         break;
1430                 case B9600:
1431                         lpdcb->BaudRate = 9600;
1432                         break;
1433                 case B19200:
1434                         lpdcb->BaudRate = 19200;
1435                         break;
1436                 case B38400:
1437                         lpdcb->BaudRate = 38400;
1438                         break;
1439                 case B57600:
1440                         lpdcb->BaudRate = 57600;
1441                         break;
1442                 case B115200:
1443                         lpdcb->BaudRate = 57601;
1444                         break;
1445         }
1446 #endif
1447         switch (port.c_cflag & CSIZE) {
1448                 case CS5:
1449                         lpdcb->ByteSize = 5;
1450                         break;
1451                 case CS6:
1452                         lpdcb->ByteSize = 6;
1453                         break;
1454                 case CS7:
1455                         lpdcb->ByteSize = 7;
1456                         break;
1457                 case CS8:
1458                         lpdcb->ByteSize = 8;
1459                         break;
1460         }
1461
1462         switch (port.c_cflag & (PARENB | PARODD)) {
1463                 case 0:
1464                         lpdcb->fParity = FALSE;
1465                         lpdcb->Parity = NOPARITY;
1466                         break;
1467                 case PARENB:
1468                         lpdcb->fParity = TRUE;
1469                         lpdcb->Parity = EVENPARITY;
1470                         break;
1471                 case (PARENB | PARODD):
1472                         lpdcb->fParity = TRUE;
1473                         lpdcb->Parity = ODDPARITY;
1474                         break;
1475         }
1476
1477         if (port.c_cflag & CSTOPB)
1478                 lpdcb->StopBits = TWOSTOPBITS;
1479         else
1480                 lpdcb->StopBits = ONESTOPBIT;
1481
1482         lpdcb->RlsTimeout = 50;
1483         lpdcb->CtsTimeout = 50;
1484         lpdcb->DsrTimeout = 50;
1485         lpdcb->fNull = 0;
1486         lpdcb->fChEvt = 0;
1487         lpdcb->fBinary = 1;
1488         lpdcb->fDtrDisable = 0;
1489
1490 #ifdef CRTSCTS
1491
1492         if (port.c_cflag & CRTSCTS) {
1493                 lpdcb->fDtrflow = 1;
1494                 lpdcb->fRtsflow = 1;
1495                 lpdcb->fOutxCtsFlow = 1;
1496                 lpdcb->fOutxDsrFlow = 1;
1497         } else
1498 #endif
1499                 lpdcb->fDtrDisable = 1;
1500
1501         if (port.c_iflag & IXON)
1502                 lpdcb->fInX = 1;
1503         else
1504                 lpdcb->fInX = 0;
1505
1506         if (port.c_iflag & IXOFF)
1507                 lpdcb->fOutX = 1;
1508         else
1509                 lpdcb->fOutX = 0;
1510 /*
1511         lpdcb->XonChar =
1512         lpdcb->XoffChar =
1513  */
1514         lpdcb->XonLim = 10;
1515         lpdcb->XoffLim = 10;
1516
1517         commerror = 0;
1518         return 0;
1519 }
1520
1521 /*****************************************************************************
1522  *      GetCommState    (KERNEL32.159)
1523  */
1524 BOOL32 WINAPI GetCommState32(INT32 fd, LPDCB32 lpdcb)
1525 {
1526         struct termios  port;
1527
1528         TRACE(comm,"fd %d, ptr %p\n", fd, lpdcb);
1529         if (GetDeviceStruct(fd) == NULL) return FALSE;
1530         if (tcgetattr(fd, &port) == -1) {
1531                 commerror = WinError();
1532                 return FALSE;
1533         }
1534 #ifndef __EMX__
1535 #ifdef CBAUD
1536         switch (port.c_cflag & CBAUD) {
1537 #else
1538         switch (port.c_ospeed) {
1539 #endif
1540                 case B110:
1541                         lpdcb->BaudRate = 110;
1542                         break;
1543                 case B300:
1544                         lpdcb->BaudRate = 300;
1545                         break;
1546                 case B600:
1547                         lpdcb->BaudRate = 600;
1548                         break;
1549                 case B1200:
1550                         lpdcb->BaudRate = 1200;
1551                         break;
1552                 case B2400:
1553                         lpdcb->BaudRate = 2400;
1554                         break;
1555                 case B4800:
1556                         lpdcb->BaudRate = 4800;
1557                         break;
1558                 case B9600:
1559                         lpdcb->BaudRate = 9600;
1560                         break;
1561                 case B19200:
1562                         lpdcb->BaudRate = 19200;
1563                         break;
1564                 case B38400:
1565                         lpdcb->BaudRate = 38400;
1566                         break;
1567         }
1568 #endif
1569         switch (port.c_cflag & CSIZE) {
1570                 case CS5:
1571                         lpdcb->ByteSize = 5;
1572                         break;
1573                 case CS6:
1574                         lpdcb->ByteSize = 6;
1575                         break;
1576                 case CS7:
1577                         lpdcb->ByteSize = 7;
1578                         break;
1579                 case CS8:
1580                         lpdcb->ByteSize = 8;
1581                         break;
1582         }
1583
1584         switch (port.c_cflag & (PARENB | PARODD)) {
1585                 case 0:
1586                         lpdcb->fParity = FALSE;
1587                         lpdcb->Parity = NOPARITY;
1588                         break;
1589                 case PARENB:
1590                         lpdcb->fParity = TRUE;
1591                         lpdcb->Parity = EVENPARITY;
1592                         break;
1593                 case (PARENB | PARODD):
1594                         lpdcb->fParity = TRUE;
1595                         lpdcb->Parity = ODDPARITY;
1596                         break;
1597         }
1598
1599         if (port.c_cflag & CSTOPB)
1600                 lpdcb->StopBits = TWOSTOPBITS;
1601         else
1602                 lpdcb->StopBits = ONESTOPBIT;
1603
1604         lpdcb->fNull = 0;
1605         lpdcb->fBinary = 1;
1606
1607 #ifdef CRTSCTS
1608
1609         if (port.c_cflag & CRTSCTS) {
1610                 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
1611                 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
1612                 lpdcb->fOutxCtsFlow = 1;
1613                 lpdcb->fOutxDsrFlow = 1;
1614         } else
1615 #endif
1616         {
1617                 lpdcb->fDtrControl = DTR_CONTROL_DISABLE;
1618                 lpdcb->fRtsControl = RTS_CONTROL_DISABLE;
1619         }
1620         if (port.c_iflag & IXON)
1621                 lpdcb->fInX = 1;
1622         else
1623                 lpdcb->fInX = 0;
1624
1625         if (port.c_iflag & IXOFF)
1626                 lpdcb->fOutX = 1;
1627         else
1628                 lpdcb->fOutX = 0;
1629 /*
1630         lpdcb->XonChar =
1631         lpdcb->XoffChar =
1632  */
1633         lpdcb->XonLim = 10;
1634         lpdcb->XoffLim = 10;
1635
1636         commerror = 0;
1637         return TRUE;
1638 }
1639
1640 /*****************************************************************************
1641  *      TransmitCommChar        (USER.206)
1642  */
1643 INT16 WINAPI TransmitCommChar16(INT16 fd,CHAR chTransmit)
1644 {
1645         struct DosDeviceStruct *ptr;
1646
1647         TRACE(comm, "fd %d, data %d \n", fd, chTransmit);
1648         if ((ptr = GetDeviceStruct(fd)) == NULL) {
1649                 commerror = IE_BADID;
1650                 return -1;
1651         }
1652
1653         if (ptr->suspended) {
1654                 commerror = IE_HARDWARE;
1655                 return -1;
1656         }
1657
1658         if (write(fd, (void *) &chTransmit, 1) == -1) {
1659                 commerror = WinError();
1660                 return -1;
1661         }  else {
1662                 commerror = 0;
1663                 return 0;
1664         }
1665 }
1666
1667 /*****************************************************************************
1668  *      TransmitCommChar        (KERNEL32.535)
1669  */
1670 BOOL32 WINAPI TransmitCommChar32(INT32 fd,CHAR chTransmit)
1671 {
1672         struct DosDeviceStruct *ptr;
1673
1674         TRACE(comm,"(%d,'%c')\n",fd,chTransmit);
1675         if ((ptr = GetDeviceStruct(fd)) == NULL) {
1676                 commerror = IE_BADID;
1677                 return FALSE;
1678         }
1679
1680         if (ptr->suspended) {
1681                 commerror = IE_HARDWARE;
1682                 return FALSE;
1683         }
1684         if (write(fd, (void *) &chTransmit, 1) == -1) {
1685                 commerror = WinError();
1686                 return FALSE;
1687         }  else {
1688                 commerror = 0;
1689                 return TRUE;
1690         }
1691 }
1692
1693 /*****************************************************************************
1694  *      UngetCommChar   (USER.212)
1695  */
1696 INT16 WINAPI UngetCommChar(INT16 fd,CHAR chUnget)
1697 {
1698         struct DosDeviceStruct *ptr;
1699
1700         TRACE(comm,"fd %d (char %d)\n", fd, chUnget);
1701         if ((ptr = GetDeviceStruct(fd)) == NULL) {
1702                 commerror = IE_BADID;
1703                 return -1;
1704         }
1705
1706         if (ptr->suspended) {
1707                 commerror = IE_HARDWARE;
1708                 return -1;
1709         }
1710
1711         ptr->unget = 1;
1712         ptr->unget_byte = chUnget;
1713         commerror = 0;
1714         return 0;
1715 }
1716
1717 /*****************************************************************************
1718  *      ReadComm        (USER.204)
1719  */
1720 INT16 WINAPI ReadComm(INT16 fd,LPSTR lpvBuf,INT16 cbRead)
1721 {
1722         int status, length;
1723         struct DosDeviceStruct *ptr;
1724
1725         TRACE(comm, "fd %d, ptr %p, length %d\n", fd, lpvBuf, cbRead);
1726         if ((ptr = GetDeviceStruct(fd)) == NULL) {
1727                 commerror = IE_BADID;
1728                 return -1;
1729         }
1730
1731         if (ptr->suspended) {
1732                 commerror = IE_HARDWARE;
1733                 return -1;
1734         }
1735
1736         if (ptr->unget) {
1737                 *lpvBuf = ptr->unget_byte;
1738                 lpvBuf++;
1739                 ptr->unget = 0;
1740
1741                 length = 1;
1742         } else
1743                 length = 0;
1744
1745         status = read(fd, (void *) lpvBuf, cbRead);
1746
1747         if (status == -1) {
1748                 if (errno != EAGAIN) {
1749                        commerror = WinError();
1750                        return -1 - length;
1751                 } else {
1752                         commerror = 0;
1753                         return length;
1754                 }
1755         } else {
1756                 TRACE(comm,"%.*s\n", length+status, lpvBuf);
1757                 commerror = 0;
1758                 return length + status;
1759         }
1760 }
1761
1762 /*****************************************************************************
1763  *      WriteComm       (USER.205)
1764  */
1765 INT16 WINAPI WriteComm(INT16 fd, LPSTR lpvBuf, INT16 cbWrite)
1766 {
1767         int length;
1768         struct DosDeviceStruct *ptr;
1769
1770         TRACE(comm,"fd %d, ptr %p, length %d\n",
1771                 fd, lpvBuf, cbWrite);
1772         if ((ptr = GetDeviceStruct(fd)) == NULL) {
1773                 commerror = IE_BADID;
1774                 return -1;
1775         }
1776
1777         if (ptr->suspended) {
1778                 commerror = IE_HARDWARE;
1779                 return -1;
1780         }
1781
1782         TRACE(comm,"%.*s\n", cbWrite, lpvBuf );
1783         length = write(fd, (void *) lpvBuf, cbWrite);
1784
1785         if (length == -1) {
1786                 commerror = WinError();
1787                 return -1;
1788         } else {
1789                 commerror = 0;
1790                 return length;
1791         }
1792 }
1793
1794
1795 /*****************************************************************************
1796  *      GetCommTimeouts         (KERNEL32.160)
1797  */
1798 BOOL32 WINAPI GetCommTimeouts(INT32 fd,LPCOMMTIMEOUTS lptimeouts)
1799 {
1800         FIXME(comm,"(%x,%p):stub.\n",fd,lptimeouts);
1801         return TRUE;
1802 }
1803
1804 /*****************************************************************************
1805  *      SetCommTimeouts         (KERNEL32.453)
1806  */
1807 BOOL32 WINAPI SetCommTimeouts(INT32 fd,LPCOMMTIMEOUTS lptimeouts) {
1808         FIXME(comm,"(%x,%p):stub.\n",fd,lptimeouts);
1809         return TRUE;
1810 }
1811
1812 /***********************************************************************
1813  *           EnableCommNotification   (USER.246)
1814  */
1815 BOOL16 WINAPI EnableCommNotification( INT16 fd, HWND16 hwnd,
1816                                       INT16 cbWriteNotify, INT16 cbOutQueue )
1817 {
1818         FIXME(comm, "(%d, %x, %d, %d):stub.\n", fd, hwnd, cbWriteNotify, cbOutQueue);
1819         return TRUE;
1820 }
1821
1822 /***********************************************************************
1823  *           GetCommModemStatus   (KERNEL32.285)
1824  */
1825 BOOL32 WINAPI GetCommModemStatus(HANDLE32 hFile,LPDWORD lpModemStat )
1826 {
1827         FIXME(comm, "(%d %p)\n",hFile,lpModemStat );
1828         return TRUE;
1829 }
1830 /***********************************************************************
1831  *           WaitCommEvent   (KERNEL32.719)
1832  */
1833 BOOL32 WINAPI WaitCommEvent(HANDLE32 hFile,LPDWORD eventmask ,LPOVERLAPPED overlapped)
1834 {
1835         FIXME(comm, "(%d %p %p )\n",hFile, eventmask,overlapped);
1836         return TRUE;
1837 }
1838