git.oblomov.eu Git - wine/blob - misc/comm.c

   1  /*
   2  * DEC 93 Erik Bos <erik@xs4all.nl>
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  *
   6  * Mar 31, 1999. Ove Kåven <ovek@arcticnet.no>
   7  * - Implemented buffers and EnableCommNotification.
   8  *
   9  * Apr 3, 1999.  Lawson Whitney <lawson_whitney@juno.com>
  10  * - Fixed the modem control part of EscapeCommFunction16.
  11  *
  12  * Mar 3, 1999. Ove Kåven <ovek@arcticnet.no>
  13  * - Use port indices instead of unixfds for win16
  14  * - Moved things around (separated win16 and win32 routines)
  15  * - Added some hints on how to implement buffers and EnableCommNotification.
  16  *
  17  * May 26, 1997.  Fixes and comments by Rick Richardson <rick@dgii.com> [RER]
  18  * - ptr->fd wasn't getting cleared on close.
  19  * - GetCommEventMask() and GetCommError() didn't do much of anything.
  20  *   IMHO, they are still wrong, but they at least implement the RXCHAR
  21  *   event and return I/O queue sizes, which makes the app I'm interested
  22  *   in (analog devices EZKIT DSP development system) work.
  23  *
  24  * August 12, 1997.  Take a bash at SetCommEventMask - Lawson Whitney
  25  *                                     <lawson_whitney@juno.com>
  26  * July 6, 1998. Fixes and comments by Valentijn Sessink
  27  *                                     <vsessink@ic.uva.nl> [V]
  28  * Oktober 98, Rein Klazes [RHK]
  29  * A program that wants to monitor the modem status line (RLSD/DCD) may
  30  * poll the modem status register in the commMask structure. I update the bit
  31  * in GetCommError, waiting for an implementation of communication events.
  32  *
  33  */
  34
  35 #include "config.h"
  36
  37 #include <stdlib.h>
  38 #include <termios.h>
  39 #include <fcntl.h>
  40 #include <string.h>
  41 #ifdef HAVE_STRINGS_H
  42 # include <strings.h>
  43 #endif
  44 #include <errno.h>
  45 #include <ctype.h>
  46 #include <sys/stat.h>
  47 #ifdef HAVE_SYS_FILIO_H
  48 # include <sys/filio.h>
  49 #endif
  50 #include <sys/ioctl.h>
  51 #include <unistd.h>
  52
  53 #include "wine/winuser16.h"
  54 #include "comm.h"
  55 #ifdef HAVE_SYS_MODEM_H
  56 # include <sys/modem.h>
  57 #endif
  58 #ifdef HAVE_SYS_STRTIO_H
  59 # include <sys/strtio.h>
  60 #endif
  61 #include "heap.h"
  62 #include "options.h"
  63
  64 #include "server.h"
  65 #include "process.h"
  66 #include "winerror.h"
  67 #include "services.h"
  68 #include "file.h"
  69
  70 #include "debugtools.h"
  71
  72 DEFAULT_DEBUG_CHANNEL(comm)
  73
  74 #ifndef TIOCINQ
  75 #define TIOCINQ FIONREAD
  76 #endif
  77 #define COMM_MSR_OFFSET  35       /* see knowledge base Q101417 */
  78 #define FLAG_LPT 0x80
  79
  80 struct DosDeviceStruct COM[MAX_PORTS];
  81 struct DosDeviceStruct LPT[MAX_PORTS];
  82 /* pointers to unknown(==undocumented) comm structure */
  83 LPCVOID *unknown[MAX_PORTS];
  84 /* save terminal states */
  85 static struct termios m_stat[MAX_PORTS];
  86
  87 void COMM_Init(void)
  88 {
  89         int x;
  90         char option[10], temp[256], *btemp;
  91         struct stat st;
  92
  93         for (x=0; x!=MAX_PORTS; x++) {
  94                 strcpy(option,"COMx");
  95                 option[3] = '1' + x;
  96                 option[4] = '\0';
  97
  98                 PROFILE_GetWineIniString( "serialports", option, "*",
  99                                           temp, sizeof(temp) );
 100                 if (!strcmp(temp, "*") || *temp == '\0')
 101                         COM[x].devicename = NULL;
 102                 else {
 103                         btemp = strchr(temp,',');
 104                         if (btemp != NULL) {
 105                                 *btemp++ = '\0';
 106                                 COM[x].baudrate = atoi(btemp);
 107                         } else {
 108                                 COM[x].baudrate = -1;
 109                         }
 110                         stat(temp, &st);
 111                         if (!S_ISCHR(st.st_mode))
 112                                 WARN("Can't use `%s' as %s !\n", temp, option);
 113                         else
 114                                 if ((COM[x].devicename = malloc(strlen(temp)+1)) == NULL)
 115                                         WARN("Can't malloc for device info!\n");
 116                                 else {
 117                                         COM[x].fd = 0;
 118                                         strcpy(COM[x].devicename, temp);
 119                                 }
 120                 TRACE("%s = %s\n", option, COM[x].devicename);
 121                 }
 122
 123                 strcpy(option, "LPTx");
 124                 option[3] = '1' + x;
 125                 option[4] = '\0';
 126
 127                 PROFILE_GetWineIniString( "parallelports", option, "*",
 128                                           temp, sizeof(temp) );
 129                 if (!strcmp(temp, "*") || *temp == '\0')
 130                         LPT[x].devicename = NULL;
 131                 else {
 132                         stat(temp, &st);
 133                         if (!S_ISCHR(st.st_mode))
 134                                 WARN("Can't use `%s' as %s !\n", temp, option);
 135                         else
 136                                 if ((LPT[x].devicename = malloc(strlen(temp)+1)) == NULL)
 137                                         WARN("Can't malloc for device info!\n");
 138                                 else {
 139                                         LPT[x].fd = 0;
 140                                         strcpy(LPT[x].devicename, temp);
 141                                 }
 142                 TRACE("%s = %s\n", option, LPT[x].devicename);
 143                 }
 144
 145         }
 146 }
 147
 148
 149 static struct DosDeviceStruct *GetDeviceStruct(int fd)
 150 {
 151         if ((fd&0x7F)<=MAX_PORTS) {
 152             if (!(fd&FLAG_LPT)) {
 153                 if (COM[fd].fd)
 154                     return &COM[fd];
 155             } else {
 156                 if (LPT[fd].fd)
 157                     return &LPT[fd];
 158             }
 159         }
 160
 161         return NULL;
 162 }
 163
 164 static int    GetCommPort_fd(int fd)
 165 {
 166         int x;
 167
 168         for (x=0; x<MAX_PORTS; x++) {
 169              if (COM[x].fd == fd)
 170                  return x;
 171        }
 172
 173        return -1;
 174 }
 175
 176 static int ValidCOMPort(int x)
 177 {
 178         return(x < MAX_PORTS ? (int) COM[x].devicename : 0);
 179 }
 180
 181 static int ValidLPTPort(int x)
 182 {
 183         return(x < MAX_PORTS ? (int) LPT[x].devicename : 0);
 184 }
 185
 186 static int WinError(void)
 187 {
 188         TRACE("errno = %d\n", errno);
 189         switch (errno) {
 190                 default:
 191                         return CE_IOE;
 192                 }
 193 }
 194
 195 static unsigned comm_inbuf(struct DosDeviceStruct *ptr)
 196 {
 197   return ((ptr->ibuf_tail > ptr->ibuf_head) ? ptr->ibuf_size : 0)
 198     + ptr->ibuf_head - ptr->ibuf_tail;
 199 }
 200
 201 static unsigned comm_outbuf(struct DosDeviceStruct *ptr)
 202 {
 203   return ((ptr->obuf_tail > ptr->obuf_head) ? ptr->obuf_size : 0)
 204     + ptr->obuf_head - ptr->obuf_tail;
 205 }
 206
 207 static int COMM_WhackModem(int fd, unsigned int andy, unsigned int orrie)
 208 {
 209     unsigned int mstat, okay;
 210     okay = ioctl(fd, TIOCMGET, &mstat);
 211     if (okay) return okay;
 212     if (andy) mstat &= andy;
 213     mstat |= orrie;
 214     return ioctl(fd, TIOCMSET, &mstat);
 215 }
 216
 217 static void CALLBACK comm_notification( ULONG_PTR private )
 218 {
 219   struct DosDeviceStruct *ptr = (struct DosDeviceStruct *)private;
 220   int prev, bleft, len;
 221   WORD mask = 0;
 222   int cid = GetCommPort_fd(ptr->fd);
 223
 224   TRACE("async notification\n");
 225   /* read data from comm port */
 226   prev = comm_inbuf(ptr);
 227   do {
 228     bleft = ((ptr->ibuf_tail > ptr->ibuf_head) ? (ptr->ibuf_tail-1) : ptr->ibuf_size)
 229       - ptr->ibuf_head;
 230     len = read(ptr->fd, ptr->inbuf + ptr->ibuf_head, bleft?bleft:1);
 231     if (len > 0) {
 232       if (!bleft) {
 233         ptr->commerror = CE_RXOVER;
 234       } else {
 235         /* check for events */
 236         if ((ptr->eventmask & EV_RXFLAG) &&
 237             memchr(ptr->inbuf + ptr->ibuf_head, ptr->evtchar, len)) {
 238           *(WORD*)(unknown[cid]) |= EV_RXFLAG;
 239           mask |= CN_EVENT;
 240         }
 241         if (ptr->eventmask & EV_RXCHAR) {
 242           *(WORD*)(unknown[cid]) |= EV_RXCHAR;
 243           mask |= CN_EVENT;
 244         }
 245         /* advance buffer position */
 246         ptr->ibuf_head += len;
 247         if (ptr->ibuf_head >= ptr->ibuf_size)
 248           ptr->ibuf_head = 0;
 249       }
 250     }
 251   } while (len > 0);
 252   /* check for notification */
 253   if (ptr->wnd && (ptr->n_read>0) && (prev<ptr->n_read) &&
 254       (comm_inbuf(ptr)>=ptr->n_read)) {
 255     /* passed the receive notification threshold */
 256     mask |= CN_RECEIVE;
 257   }
 258
 259   /* write any TransmitCommChar character */
 260   if (ptr->xmit>=0) {
 261     len = write(ptr->fd, &(ptr->xmit), 1);
 262     if (len > 0) ptr->xmit = -1;
 263   }
 264   /* write from output queue */
 265   prev = comm_outbuf(ptr);
 266   do {
 267     bleft = ((ptr->obuf_tail <= ptr->obuf_head) ? ptr->obuf_head : ptr->obuf_size)
 268       - ptr->obuf_tail;
 269     len = bleft ? write(ptr->fd, ptr->outbuf + ptr->obuf_tail, bleft) : 0;
 270     if (len > 0) {
 271       ptr->obuf_tail += len;
 272       if (ptr->obuf_tail >= ptr->obuf_size)
 273         ptr->obuf_tail = 0;
 274       /* flag event */
 275       if (ptr->obuf_tail == ptr->obuf_head) {
 276         if (ptr->s_write) {
 277           SERVICE_Delete( ptr->s_write );
 278           ptr->s_write = INVALID_HANDLE_VALUE;
 279         }
 280         if (ptr->eventmask & EV_TXEMPTY) {
 281           *(WORD*)(unknown[cid]) |= EV_TXEMPTY;
 282           mask |= CN_EVENT;
 283         }
 284       }
 285     }
 286   } while (len > 0);
 287   /* check for notification */
 288   if (ptr->wnd && (ptr->n_write>0) && (prev>=ptr->n_write) &&
 289       (comm_outbuf(ptr)<ptr->n_write)) {
 290     /* passed the transmit notification threshold */
 291     mask |= CN_TRANSMIT;
 292   }
 293
 294   /* send notifications, if any */
 295   if (ptr->wnd && mask) {
 296     TRACE("notifying %04x: cid=%d, mask=%02x\n", ptr->wnd, cid, mask);
 297     PostMessage16(ptr->wnd, WM_COMMNOTIFY, cid, mask);
 298   }
 299 }
 300
 301 static void comm_waitread(struct DosDeviceStruct *ptr)
 302 {
 303   if (ptr->s_read != INVALID_HANDLE_VALUE) return;
 304   ptr->s_read = SERVICE_AddObject( FILE_DupUnixHandle( ptr->fd,
 305                                      GENERIC_READ | SYNCHRONIZE ),
 306                                     comm_notification,
 307                                     (ULONG_PTR)ptr );
 308 }
 309
 310 static void comm_waitwrite(struct DosDeviceStruct *ptr)
 311 {
 312   if (ptr->s_write != INVALID_HANDLE_VALUE) return;
 313   ptr->s_write = SERVICE_AddObject( FILE_DupUnixHandle( ptr->fd,
 314                                       GENERIC_WRITE | SYNCHRONIZE ),
 315                                      comm_notification,
 316                                      (ULONG_PTR)ptr );
 317 }
 318
 319 /**************************************************************************
 320  *         BuildCommDCB         (USER.213)
 321  */
 322 BOOL16 WINAPI BuildCommDCB16(LPCSTR device, LPDCB16 lpdcb)
 323 {
 324         /* "COM1:9600,n,8,1"    */
 325         /*  012345              */
 326         int port;
 327         char *ptr, temp[256];
 328
 329         TRACE("(%s), ptr %p\n", device, lpdcb);
 330
 331         if (!lstrncmpiA(device,"COM",3)) {
 332                 port = device[3] - '0';
 333
 334
 335                 if (port-- == 0) {
 336                         ERR("BUG ! COM0 can't exist!.\n");
 337                         return -1;
 338                 }
 339
 340                 if (!ValidCOMPort(port)) {
 341                         return -1;
 342                 }
 343
 344                 memset(lpdcb, 0, sizeof(DCB16)); /* initialize */
 345
 346                 lpdcb->Id = port;
 347
 348                 if (!*(device+4))
 349                         return 0;
 350
 351                 if (*(device+4) != ':')
 352                         return -1;
 353
 354                 strcpy(temp,device+5);
 355                 ptr = strtok(temp, ", ");
 356
 357                 if (COM[port].baudrate > 0)
 358                         lpdcb->BaudRate = COM[port].baudrate;
 359                 else
 360                         lpdcb->BaudRate = atoi(ptr);
 361                 TRACE("baudrate (%d)\n", lpdcb->BaudRate);
 362
 363                 ptr = strtok(NULL, ", ");
 364                 if (islower(*ptr))
 365                         *ptr = toupper(*ptr);
 366
 367                 TRACE("parity (%c)\n", *ptr);
 368                 lpdcb->fParity = TRUE;
 369                 switch (*ptr) {
 370                         case 'N':
 371                                 lpdcb->Parity = NOPARITY;
 372                                 lpdcb->fParity = FALSE;
 373                                 break;
 374                         case 'E':
 375                                 lpdcb->Parity = EVENPARITY;
 376                                 break;
 377                         case 'M':
 378                                 lpdcb->Parity = MARKPARITY;
 379                                 break;
 380                         case 'O':
 381                                 lpdcb->Parity = ODDPARITY;
 382                                 break;
 383                         default:
 384                                 WARN("Unknown parity `%c'!\n", *ptr);
 385                                 return -1;
 386                 }
 387
 388                 ptr = strtok(NULL, ", ");
 389                 TRACE("charsize (%c)\n", *ptr);
 390                 lpdcb->ByteSize = *ptr - '0';
 391
 392                 ptr = strtok(NULL, ", ");
 393                 TRACE("stopbits (%c)\n", *ptr);
 394                 switch (*ptr) {
 395                         case '1':
 396                                 lpdcb->StopBits = ONESTOPBIT;
 397                                 break;
 398                         case '2':
 399                                 lpdcb->StopBits = TWOSTOPBITS;
 400                                 break;
 401                         default:
 402                                 WARN("Unknown # of stopbits `%c'!\n", *ptr);
 403                                 return -1;
 404                 }
 405         }
 406
 407         return 0;
 408 }
 409
 410 /*****************************************************************************
 411  *      OpenComm                (USER.200)
 412  */
 413 INT16 WINAPI OpenComm16(LPCSTR device,UINT16 cbInQueue,UINT16 cbOutQueue)
 414 {
 415         int port,fd;
 416
 417         TRACE("%s, %d, %d\n", device, cbInQueue, cbOutQueue);
 418
 419         if (strlen(device) < 4)
 420            return IE_BADID;
 421
 422         port = device[3] - '0';
 423
 424         if (port-- == 0)
 425                 ERR("BUG ! COM0 or LPT0 don't exist !\n");
 426
 427         if (!lstrncmpiA(device,"COM",3)) {
 428
 429                 TRACE("%s = %s\n", device, COM[port].devicename);
 430
 431                 if (!ValidCOMPort(port))
 432                         return IE_BADID;
 433
 434                 if (COM[port].fd)
 435                         return IE_OPEN;
 436
 437                 fd = open(COM[port].devicename, O_RDWR | O_NONBLOCK);
 438                 if (fd == -1) {
 439                         ERR("error=%d\n", errno);
 440                         return IE_HARDWARE;
 441                 } else {
 442                         unknown[port] = SEGPTR_ALLOC(40);
 443                         bzero(unknown[port],40);
 444                         COM[port].fd = fd;
 445                         COM[port].commerror = 0;
 446                         COM[port].eventmask = 0;
 447                         COM[port].evtchar = 0; /* FIXME: default? */
 448                         /* save terminal state */
 449                         tcgetattr(fd,&m_stat[port]);
 450                         /* set default parameters */
 451                         if(COM[port].baudrate>-1){
 452                             DCB16 dcb;
 453                             GetCommState16(port, &dcb);
 454                             dcb.BaudRate=COM[port].baudrate;
 455                             /* more defaults:
 456                              * databits, parity, stopbits
 457                              */
 458                             SetCommState16( &dcb);
 459                         }
 460                         /* init priority characters */
 461                         COM[port].unget = -1;
 462                         COM[port].xmit = -1;
 463                         /* allocate buffers */
 464                         COM[port].ibuf_size = cbInQueue;
 465                         COM[port].ibuf_head = COM[port].ibuf_tail= 0;
 466                         COM[port].obuf_size = cbOutQueue;
 467                         COM[port].obuf_head = COM[port].obuf_tail = 0;
 468
 469                         COM[port].inbuf = malloc(cbInQueue);
 470                         if (COM[port].inbuf) {
 471                           COM[port].outbuf = malloc(cbOutQueue);
 472                           if (!COM[port].outbuf)
 473                             free(COM[port].inbuf);
 474                         } else COM[port].outbuf = NULL;
 475                         if (!COM[port].outbuf) {
 476                           /* not enough memory */
 477                           tcsetattr(COM[port].fd,TCSANOW,&m_stat[port]);
 478                           close(COM[port].fd);
 479                           ERR("out of memory");
 480                           return IE_MEMORY;
 481                         }
 482
 483                         COM[port].s_read = INVALID_HANDLE_VALUE;
 484                         COM[port].s_write = INVALID_HANDLE_VALUE;
 485                         comm_waitread( &COM[port] );
 486                         return port;
 487                 }
 488         }
 489         else
 490         if (!lstrncmpiA(device,"LPT",3)) {
 491
 492                 if (!ValidLPTPort(port))
 493                         return IE_BADID;
 494
 495                 if (LPT[port].fd)
 496                         return IE_OPEN;
 497
 498                 fd = open(LPT[port].devicename, O_RDWR | O_NONBLOCK, 0);
 499                 if (fd == -1) {
 500                         return IE_HARDWARE;
 501                 } else {
 502                         LPT[port].fd = fd;
 503                         LPT[port].commerror = 0;
 504                         LPT[port].eventmask = 0;
 505                         return port|FLAG_LPT;
 506                 }
 507         }
 508         return 0;
 509 }
 510
 511 /*****************************************************************************
 512  *      CloseComm               (USER.207)
 513  */
 514 INT16 WINAPI CloseComm16(INT16 cid)
 515 {
 516         struct DosDeviceStruct *ptr;
 517
 518         TRACE("cid=%d\n", cid);
 519         if ((ptr = GetDeviceStruct(cid)) == NULL) {
 520                 return -1;
 521         }
 522         if (!(cid&FLAG_LPT)) {
 523                 /* COM port */
 524                 SEGPTR_FREE(unknown[cid]); /* [LW] */
 525
 526                 SERVICE_Delete( COM[cid].s_write );
 527                 SERVICE_Delete( COM[cid].s_read );
 528                 /* free buffers */
 529                 free(ptr->outbuf);
 530                 free(ptr->inbuf);
 531
 532                 /* reset modem lines */
 533                 tcsetattr(ptr->fd,TCSANOW,&m_stat[cid]);
 534         }
 535
 536         if (close(ptr->fd) == -1) {
 537                 ptr->commerror = WinError();
 538                 /* FIXME: should we clear ptr->fd here? */
 539                 return -1;
 540         } else {
 541                 ptr->commerror = 0;
 542                 ptr->fd = 0;
 543                 return 0;
 544         }
 545 }
 546
 547 /*****************************************************************************
 548  *      SetCommBreak            (USER.210)
 549  */
 550 INT16 WINAPI SetCommBreak16(INT16 cid)
 551 {
 552         struct DosDeviceStruct *ptr;
 553
 554         TRACE("cid=%d\n", cid);
 555         if ((ptr = GetDeviceStruct(cid)) == NULL) {
 556                 return -1;
 557         }
 558
 559         ptr->suspended = 1;
 560         ptr->commerror = 0;
 561         return 0;
 562 }
 563
 564 /*****************************************************************************
 565  *      ClearCommBreak          (USER.211)
 566  */
 567 INT16 WINAPI ClearCommBreak16(INT16 cid)
 568 {
 569         struct DosDeviceStruct *ptr;
 570
 571         TRACE("cid=%d\n", cid);
 572         if ((ptr = GetDeviceStruct(cid)) == NULL) {
 573                 return -1;
 574         }
 575
 576         ptr->suspended = 0;
 577         ptr->commerror = 0;
 578         return 0;
 579 }
 580
 581 /*****************************************************************************
 582  *      EscapeCommFunction      (USER.214)
 583  */
 584 LONG WINAPI EscapeCommFunction16(UINT16 cid,UINT16 nFunction)
 585 {
 586         int     max;
 587         struct DosDeviceStruct *ptr;
 588         struct termios port;
 589
 590         TRACE("cid=%d, function=%d\n", cid, nFunction);
 591         if ((nFunction != GETMAXCOM) && (nFunction != GETMAXLPT)) {
 592                 if ((ptr = GetDeviceStruct(cid)) == NULL) {
 593                         TRACE("GetDeviceStruct failed\n");
 594                         return -1;
 595                 }
 596                 if (tcgetattr(ptr->fd,&port) == -1) {
 597                         TRACE("tcgetattr failed\n");
 598                         ptr->commerror=WinError();
 599                         return -1;
 600                 }
 601         } else ptr = NULL;
 602
 603         switch (nFunction) {
 604                 case RESETDEV:
 605                         TRACE("RESETDEV\n");
 606                         break;
 607
 608                 case GETMAXCOM:
 609                         TRACE("GETMAXCOM\n");
 610                         for (max = MAX_PORTS;!COM[max].devicename;max--)
 611                                 ;
 612                         return max;
 613                         break;
 614
 615                 case GETMAXLPT:
 616                         TRACE("GETMAXLPT\n");
 617                         for (max = MAX_PORTS;!LPT[max].devicename;max--)
 618                                 ;
 619                         return FLAG_LPT + max;
 620                         break;
 621
 622                 case GETBASEIRQ:
 623                         TRACE("GETBASEIRQ\n");
 624                         /* FIXME: use tables */
 625                         /* just fake something for now */
 626                         if (cid & FLAG_LPT) {
 627                                 /* LPT1: irq 7, LPT2: irq 5 */
 628                                 return (cid & 0x7f) ? 5 : 7;
 629                         } else {
 630                                 /* COM1: irq 4, COM2: irq 3,
 631                                    COM3: irq 4, COM4: irq 3 */
 632                                 return 4 - (cid & 1);
 633                         }
 634                         break;
 635
 636                 case CLRDTR:
 637                         TRACE("CLRDTR\n");
 638 #ifdef TIOCM_DTR
 639                         return COMM_WhackModem(ptr->fd, ~TIOCM_DTR, 0);
 640 #endif
 641                 case CLRRTS:
 642                         TRACE("CLRRTS\n");
 643 #ifdef TIOCM_RTS
 644                         return COMM_WhackModem(ptr->fd, ~TIOCM_RTS, 0);
 645 #endif
 646
 647                 case SETDTR:
 648                         TRACE("SETDTR\n");
 649 #ifdef TIOCM_DTR
 650                         return COMM_WhackModem(ptr->fd, 0, TIOCM_DTR);
 651 #endif
 652
 653                 case SETRTS:
 654                         TRACE("SETRTS\n");
 655 #ifdef TIOCM_RTS
 656                         return COMM_WhackModem(ptr->fd, 0, TIOCM_RTS);
 657 #endif
 658
 659                 case SETXOFF:
 660                         TRACE("SETXOFF\n");
 661                         port.c_iflag |= IXOFF;
 662                         break;
 663
 664                 case SETXON:
 665                         TRACE("SETXON\n");
 666                         port.c_iflag |= IXON;
 667                         break;
 668
 669                 default:
 670                         WARN("(cid=%d,nFunction=%d): Unknown function\n",
 671                         cid, nFunction);
 672                         break;
 673         }
 674
 675         if (tcsetattr(ptr->fd, TCSADRAIN, &port) == -1) {
 676                 ptr->commerror = WinError();
 677                 return -1;
 678         } else {
 679                 ptr->commerror = 0;
 680                 return 0;
 681         }
 682 }
 683
 684 /*****************************************************************************
 685  *      FlushComm       (USER.215)
 686  */
 687 INT16 WINAPI FlushComm16(INT16 cid,INT16 fnQueue)
 688 {
 689         int queue;
 690         struct DosDeviceStruct *ptr;
 691
 692         TRACE("cid=%d, queue=%d\n", cid, fnQueue);
 693         if ((ptr = GetDeviceStruct(cid)) == NULL) {
 694                 return -1;
 695         }
 696         switch (fnQueue) {
 697                 case 0:
 698                   queue = TCOFLUSH;
 699                   ptr->obuf_tail = ptr->obuf_head;
 700                   break;
 701                 case 1:
 702                   queue = TCIFLUSH;
 703                   ptr->ibuf_head = ptr->ibuf_tail;
 704                   break;
 705                 default:
 706                   WARN("(cid=%d,fnQueue=%d):Unknown queue\n",
 707                             cid, fnQueue);
 708                   return -1;
 709                 }
 710         if (tcflush(ptr->fd, queue)) {
 711                 ptr->commerror = WinError();
 712                 return -1;
 713         } else {
 714                 ptr->commerror = 0;
 715                 return 0;
 716         }
 717 }
 718
 719 /********************************************************************
 720  *      GetCommError    (USER.203)
 721  */
 722 INT16 WINAPI GetCommError16(INT16 cid,LPCOMSTAT16 lpStat)
 723 {
 724         int             temperror;
 725         struct DosDeviceStruct *ptr;
 726         unsigned char *stol;
 727         unsigned int mstat;
 728
 729         if ((ptr = GetDeviceStruct(cid)) == NULL) {
 730                 return -1;
 731         }
 732         if (cid&FLAG_LPT) {
 733             WARN(" cid %d not comm port\n",cid);
 734             return CE_MODE;
 735         }
 736         stol = (unsigned char *)unknown[cid] + COMM_MSR_OFFSET;
 737         ioctl(ptr->fd,TIOCMGET,&mstat);
 738         if( mstat&TIOCM_CAR )
 739             *stol |= 0x80;
 740         else
 741             *stol &=0x7f;
 742
 743         if (lpStat) {
 744                 lpStat->status = 0;
 745
 746                 lpStat->cbOutQue = comm_outbuf(ptr);
 747                 lpStat->cbInQue = comm_inbuf(ptr);
 748
 749                 TRACE("cid %d, error %d, lpStat %d %d %d stol %x\n",
 750                              cid, ptr->commerror, lpStat->status, lpStat->cbInQue,
 751                              lpStat->cbOutQue, *stol);
 752         }
 753         else
 754                 TRACE("cid %d, error %d, lpStat NULL stol %x\n",
 755                              cid, ptr->commerror, *stol);
 756
 757         /* Return any errors and clear it */
 758         temperror = ptr->commerror;
 759         ptr->commerror = 0;
 760         return(temperror);
 761 }
 762
 763 /*****************************************************************************
 764  *      SetCommEventMask        (USER.208)
 765  */
 766 SEGPTR WINAPI SetCommEventMask16(INT16 cid,UINT16 fuEvtMask)
 767 {
 768         struct DosDeviceStruct *ptr;
 769         unsigned char *stol;
 770         int repid;
 771         unsigned int mstat;
 772
 773         TRACE("cid %d,mask %d\n",cid,fuEvtMask);
 774         if ((ptr = GetDeviceStruct(cid)) == NULL)
 775             return (SEGPTR)NULL;
 776
 777         ptr->eventmask = fuEvtMask;
 778
 779         if ((cid&FLAG_LPT) || !ValidCOMPort(cid)) {
 780             WARN(" cid %d not comm port\n",cid);
 781             return (SEGPTR)NULL;
 782         }
 783         /* it's a COM port ? -> modify flags */
 784         stol = (unsigned char *)unknown[cid] + COMM_MSR_OFFSET;
 785         repid = ioctl(ptr->fd,TIOCMGET,&mstat);
 786         TRACE(" ioctl  %d, msr %x at %p %p\n",repid,mstat,stol,unknown[cid]);
 787         if ((mstat&TIOCM_CAR))
 788             *stol |= 0x80;
 789         else
 790             *stol &=0x7f;
 791
 792         TRACE(" modem dcd construct %x\n",*stol);
 793         return SEGPTR_GET(unknown[cid]);
 794 }
 795
 796 /*****************************************************************************
 797  *      GetCommEventMask        (USER.209)
 798  */
 799 UINT16 WINAPI GetCommEventMask16(INT16 cid,UINT16 fnEvtClear)
 800 {
 801         struct DosDeviceStruct *ptr;
 802         WORD events;
 803
 804         TRACE("cid %d, mask %d\n", cid, fnEvtClear);
 805         if ((ptr = GetDeviceStruct(cid)) == NULL)
 806             return 0;
 807
 808         if ((cid&FLAG_LPT) || !ValidCOMPort(cid)) {
 809             WARN(" cid %d not comm port\n",cid);
 810             return 0;
 811         }
 812
 813         events = *(WORD*)(unknown[cid]) & fnEvtClear;
 814         *(WORD*)(unknown[cid]) &= ~fnEvtClear;
 815         return events;
 816 }
 817
 818 /*****************************************************************************
 819  *      SetCommState16  (USER.201)
 820  */
 821 INT16 WINAPI SetCommState16(LPDCB16 lpdcb)
 822 {
 823         struct termios port;
 824         struct DosDeviceStruct *ptr;
 825
 826         TRACE("cid %d, ptr %p\n", lpdcb->Id, lpdcb);
 827         if ((ptr = GetDeviceStruct(lpdcb->Id)) == NULL) {
 828                 return -1;
 829         }
 830         if (tcgetattr(ptr->fd, &port) == -1) {
 831                 ptr->commerror = WinError();
 832                 return -1;
 833         }
 834
 835         port.c_cc[VMIN] = 0;
 836         port.c_cc[VTIME] = 1;
 837
 838 #ifdef IMAXBEL
 839         port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
 840 #else
 841         port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
 842 #endif
 843         port.c_iflag |= (IGNBRK);
 844
 845         port.c_oflag &= ~(OPOST);
 846
 847         port.c_cflag &= ~(HUPCL);
 848         port.c_cflag |= CLOCAL | CREAD;
 849
 850         port.c_lflag &= ~(ICANON|ECHO|ISIG);
 851         port.c_lflag |= NOFLSH;
 852
 853         TRACE("baudrate %d\n",lpdcb->BaudRate);
 854 #ifdef CBAUD
 855         port.c_cflag &= ~CBAUD;
 856         switch (lpdcb->BaudRate) {
 857                 case 110:
 858                 case CBR_110:
 859                         port.c_cflag |= B110;
 860                         break;
 861                 case 300:
 862                 case CBR_300:
 863                         port.c_cflag |= B300;
 864                         break;
 865                 case 600:
 866                 case CBR_600:
 867                         port.c_cflag |= B600;
 868                         break;
 869                 case 1200:
 870                 case CBR_1200:
 871                         port.c_cflag |= B1200;
 872                         break;
 873                 case 2400:
 874                 case CBR_2400:
 875                         port.c_cflag |= B2400;
 876                         break;
 877                 case 4800:
 878                 case CBR_4800:
 879                         port.c_cflag |= B4800;
 880                         break;
 881                 case 9600:
 882                 case CBR_9600:
 883                         port.c_cflag |= B9600;
 884                         break;
 885                 case 19200:
 886                 case CBR_19200:
 887                         port.c_cflag |= B19200;
 888                         break;
 889                 case 38400:
 890                 case CBR_38400:
 891                         port.c_cflag |= B38400;
 892                         break;
 893 #ifdef B57600
 894                 case 57600:
 895                         port.c_cflag |= B57600;
 896                         break;
 897 #endif
 898 #ifdef B115200
 899                 case 57601:
 900                         port.c_cflag |= B115200;
 901                         break;
 902 #endif
 903                 default:
 904                         ptr->commerror = IE_BAUDRATE;
 905                         return -1;
 906         }
 907 #elif !defined(__EMX__)
 908         switch (lpdcb->BaudRate) {
 909                 case 110:
 910                 case CBR_110:
 911                         port.c_ospeed = B110;
 912                         break;
 913                 case 300:
 914                 case CBR_300:
 915                         port.c_ospeed = B300;
 916                         break;
 917                 case 600:
 918                 case CBR_600:
 919                         port.c_ospeed = B600;
 920                         break;
 921                 case 1200:
 922                 case CBR_1200:
 923                         port.c_ospeed = B1200;
 924                         break;
 925                 case 2400:
 926                 case CBR_2400:
 927                         port.c_ospeed = B2400;
 928                         break;
 929                 case 4800:
 930                 case CBR_4800:
 931                         port.c_ospeed = B4800;
 932                         break;
 933                 case 9600:
 934                 case CBR_9600:
 935                         port.c_ospeed = B9600;
 936                         break;
 937                 case 19200:
 938                 case CBR_19200:
 939                         port.c_ospeed = B19200;
 940                         break;
 941                 case 38400:
 942                 case CBR_38400:
 943                         port.c_ospeed = B38400;
 944                         break;
 945                 default:
 946                         ptr->commerror = IE_BAUDRATE;
 947                         return -1;
 948         }
 949         port.c_ispeed = port.c_ospeed;
 950 #endif
 951         TRACE("bytesize %d\n",lpdcb->ByteSize);
 952         port.c_cflag &= ~CSIZE;
 953         switch (lpdcb->ByteSize) {
 954                 case 5:
 955                         port.c_cflag |= CS5;
 956                         break;
 957                 case 6:
 958                         port.c_cflag |= CS6;
 959                         break;
 960                 case 7:
 961                         port.c_cflag |= CS7;
 962                         break;
 963                 case 8:
 964                         port.c_cflag |= CS8;
 965                         break;
 966                 default:
 967                         ptr->commerror = IE_BYTESIZE;
 968                         return -1;
 969         }
 970
 971         TRACE("fParity %d Parity %d\n",lpdcb->fParity, lpdcb->Parity);
 972         port.c_cflag &= ~(PARENB | PARODD);
 973         if (lpdcb->fParity)
 974             port.c_iflag |= INPCK;
 975         else
 976             port.c_iflag &= ~INPCK;
 977         switch (lpdcb->Parity) {
 978                 case NOPARITY:
 979                         break;
 980                 case ODDPARITY:
 981                         port.c_cflag |= (PARENB | PARODD);
 982                         break;
 983                 case EVENPARITY:
 984                         port.c_cflag |= PARENB;
 985                         break;
 986                 default:
 987                         ptr->commerror = IE_BYTESIZE;
 988                         return -1;
 989         }
 990
 991
 992         TRACE("stopbits %d\n",lpdcb->StopBits);
 993
 994         switch (lpdcb->StopBits) {
 995                 case ONESTOPBIT:
 996                                 port.c_cflag &= ~CSTOPB;
 997                                 break;
 998                 case TWOSTOPBITS:
 999                                 port.c_cflag |= CSTOPB;
1000                                 break;
1001                 default:
1002                         ptr->commerror = IE_BYTESIZE;
1003                         return -1;
1004         }
1005 #ifdef CRTSCTS
1006
1007         if (lpdcb->fDtrflow || lpdcb->fRtsflow || lpdcb->fOutxCtsFlow)
1008                 port.c_cflag |= CRTSCTS;
1009
1010         if (lpdcb->fDtrDisable)
1011                 port.c_cflag &= ~CRTSCTS;
1012 #endif
1013         if (lpdcb->fInX)
1014                 port.c_iflag |= IXON;
1015         else
1016                 port.c_iflag &= ~IXON;
1017         if (lpdcb->fOutX)
1018                 port.c_iflag |= IXOFF;
1019         else
1020                 port.c_iflag &= ~IXOFF;
1021
1022         ptr->evtchar = lpdcb->EvtChar;
1023
1024         if (tcsetattr(ptr->fd, TCSADRAIN, &port) == -1) {
1025                 ptr->commerror = WinError();
1026                 return FALSE;
1027         } else {
1028                 ptr->commerror = 0;
1029                 return 0;
1030         }
1031 }
1032
1033 /*****************************************************************************
1034  *      GetCommState    (USER.202)
1035  */
1036 INT16 WINAPI GetCommState16(INT16 cid, LPDCB16 lpdcb)
1037 {
1038         int speed;
1039         struct DosDeviceStruct *ptr;
1040         struct termios port;
1041
1042         TRACE("cid %d, ptr %p\n", cid, lpdcb);
1043         if ((ptr = GetDeviceStruct(cid)) == NULL) {
1044                 return -1;
1045         }
1046         if (tcgetattr(ptr->fd, &port) == -1) {
1047                 ptr->commerror = WinError();
1048                 return -1;
1049         }
1050         lpdcb->Id = cid;
1051 #ifndef __EMX__
1052 #ifdef CBAUD
1053         speed = port.c_cflag & CBAUD;
1054 #else
1055         speed = port.c_ospeed;
1056 #endif
1057         switch(speed) {
1058                 case B110:
1059                         lpdcb->BaudRate = 110;
1060                         break;
1061                 case B300:
1062                         lpdcb->BaudRate = 300;
1063                         break;
1064                 case B600:
1065                         lpdcb->BaudRate = 600;
1066                         break;
1067                 case B1200:
1068                         lpdcb->BaudRate = 1200;
1069                         break;
1070                 case B2400:
1071                         lpdcb->BaudRate = 2400;
1072                         break;
1073                 case B4800:
1074                         lpdcb->BaudRate = 4800;
1075                         break;
1076                 case B9600:
1077                         lpdcb->BaudRate = 9600;
1078                         break;
1079                 case B19200:
1080                         lpdcb->BaudRate = 19200;
1081                         break;
1082                 case B38400:
1083                         lpdcb->BaudRate = 38400;
1084                         break;
1085 #ifdef B57600
1086                 case B57600:
1087                         lpdcb->BaudRate = 57600;
1088                         break;
1089 #endif
1090 #ifdef B115200
1091                 case B115200:
1092                         lpdcb->BaudRate = 57601;
1093                         break;
1094 #endif
1095         }
1096 #endif
1097         switch (port.c_cflag & CSIZE) {
1098                 case CS5:
1099                         lpdcb->ByteSize = 5;
1100                         break;
1101                 case CS6:
1102                         lpdcb->ByteSize = 6;
1103                         break;
1104                 case CS7:
1105                         lpdcb->ByteSize = 7;
1106                         break;
1107                 case CS8:
1108                         lpdcb->ByteSize = 8;
1109                         break;
1110         }
1111
1112         if(port.c_iflag & INPCK)
1113             lpdcb->fParity = TRUE;
1114         else
1115             lpdcb->fParity = FALSE;
1116         switch (port.c_cflag & (PARENB | PARODD)) {
1117                 case 0:
1118                         lpdcb->Parity = NOPARITY;
1119                         break;
1120                 case PARENB:
1121                         lpdcb->Parity = EVENPARITY;
1122                         break;
1123                 case (PARENB | PARODD):
1124                         lpdcb->Parity = ODDPARITY;
1125                         break;
1126         }
1127
1128         if (port.c_cflag & CSTOPB)
1129                 lpdcb->StopBits = TWOSTOPBITS;
1130         else
1131                 lpdcb->StopBits = ONESTOPBIT;
1132
1133         lpdcb->RlsTimeout = 50;
1134         lpdcb->CtsTimeout = 50;
1135         lpdcb->DsrTimeout = 50;
1136         lpdcb->fNull = 0;
1137         lpdcb->fChEvt = 0;
1138         lpdcb->fBinary = 1;
1139         lpdcb->fDtrDisable = 0;
1140
1141 #ifdef CRTSCTS
1142
1143         if (port.c_cflag & CRTSCTS) {
1144                 lpdcb->fDtrflow = 1;
1145                 lpdcb->fRtsflow = 1;
1146                 lpdcb->fOutxCtsFlow = 1;
1147                 lpdcb->fOutxDsrFlow = 1;
1148         } else
1149 #endif
1150                 lpdcb->fDtrDisable = 1;
1151
1152         if (port.c_iflag & IXON)
1153                 lpdcb->fInX = 1;
1154         else
1155                 lpdcb->fInX = 0;
1156
1157         if (port.c_iflag & IXOFF)
1158                 lpdcb->fOutX = 1;
1159         else
1160                 lpdcb->fOutX = 0;
1161 /*
1162         lpdcb->XonChar =
1163         lpdcb->XoffChar =
1164  */
1165         lpdcb->XonLim = 10;
1166         lpdcb->XoffLim = 10;
1167
1168         lpdcb->EvtChar = ptr->evtchar;
1169
1170         ptr->commerror = 0;
1171         return 0;
1172 }
1173
1174 /*****************************************************************************
1175  *      TransmitCommChar        (USER.206)
1176  */
1177 INT16 WINAPI TransmitCommChar16(INT16 cid,CHAR chTransmit)
1178 {
1179         struct DosDeviceStruct *ptr;
1180
1181         TRACE("cid %d, data %d \n", cid, chTransmit);
1182         if ((ptr = GetDeviceStruct(cid)) == NULL) {
1183                 return -1;
1184         }
1185
1186         if (ptr->suspended) {
1187                 ptr->commerror = IE_HARDWARE;
1188                 return -1;
1189         }
1190
1191         if (ptr->xmit >= 0) {
1192           /* character already queued */
1193           /* FIXME: which error would Windows return? */
1194           ptr->commerror = CE_TXFULL;
1195           return -1;
1196         }
1197
1198         if (ptr->obuf_head == ptr->obuf_tail) {
1199           /* transmit queue empty, try to transmit directly */
1200           if (write(ptr->fd, &chTransmit, 1) == -1) {
1201             /* didn't work, queue it */
1202             ptr->xmit = chTransmit;
1203             comm_waitwrite(ptr);
1204           }
1205         } else {
1206           /* data in queue, let this char be transmitted next */
1207           ptr->xmit = chTransmit;
1208           comm_waitwrite(ptr);
1209         }
1210
1211         ptr->commerror = 0;
1212         return 0;
1213 }
1214
1215 /*****************************************************************************
1216  *      UngetCommChar   (USER.212)
1217  */
1218 INT16 WINAPI UngetCommChar16(INT16 cid,CHAR chUnget)
1219 {
1220         struct DosDeviceStruct *ptr;
1221
1222         TRACE("cid %d (char %d)\n", cid, chUnget);
1223         if ((ptr = GetDeviceStruct(cid)) == NULL) {
1224                 return -1;
1225         }
1226
1227         if (ptr->suspended) {
1228                 ptr->commerror = IE_HARDWARE;
1229                 return -1;
1230         }
1231
1232         if (ptr->unget>=0) {
1233           /* character already queued */
1234           /* FIXME: which error would Windows return? */
1235           ptr->commerror = CE_RXOVER;
1236           return -1;
1237         }
1238
1239         ptr->unget = chUnget;
1240
1241         ptr->commerror = 0;
1242         return 0;
1243 }
1244
1245 /*****************************************************************************
1246  *      ReadComm        (USER.204)
1247  */
1248 INT16 WINAPI ReadComm16(INT16 cid,LPSTR lpvBuf,INT16 cbRead)
1249 {
1250         int status, length;
1251         struct DosDeviceStruct *ptr;
1252         LPSTR orgBuf = lpvBuf;
1253
1254         TRACE("cid %d, ptr %p, length %d\n", cid, lpvBuf, cbRead);
1255         if ((ptr = GetDeviceStruct(cid)) == NULL) {
1256                 return -1;
1257         }
1258
1259         if (ptr->suspended) {
1260                 ptr->commerror = IE_HARDWARE;
1261                 return -1;
1262         }
1263
1264         /* read unget character */
1265         if (ptr->unget>=0) {
1266                 *lpvBuf++ = ptr->unget;
1267                 ptr->unget = -1;
1268
1269                 length = 1;
1270         } else
1271                 length = 0;
1272
1273         /* read from receive buffer */
1274         while (length < cbRead) {
1275           status = ((ptr->ibuf_head < ptr->ibuf_tail) ?
1276                     ptr->ibuf_size : ptr->ibuf_head) - ptr->ibuf_tail;
1277           if (!status) break;
1278           if ((cbRead - length) < status)
1279             status = cbRead - length;
1280
1281           memcpy(lpvBuf, ptr->inbuf + ptr->ibuf_tail, status);
1282           ptr->ibuf_tail += status;
1283           if (ptr->ibuf_tail >= ptr->ibuf_size)
1284             ptr->ibuf_tail = 0;
1285           lpvBuf += status;
1286           length += status;
1287         }
1288
1289         TRACE("%.*s\n", length, orgBuf);
1290         ptr->commerror = 0;
1291         return length;
1292 }
1293
1294 /*****************************************************************************
1295  *      WriteComm       (USER.205)
1296  */
1297 INT16 WINAPI WriteComm16(INT16 cid, LPSTR lpvBuf, INT16 cbWrite)
1298 {
1299         int status, length;
1300         struct DosDeviceStruct *ptr;
1301
1302         TRACE("cid %d, ptr %p, length %d\n",
1303                 cid, lpvBuf, cbWrite);
1304         if ((ptr = GetDeviceStruct(cid)) == NULL) {
1305                 return -1;
1306         }
1307
1308         if (ptr->suspended) {
1309                 ptr->commerror = IE_HARDWARE;
1310                 return -1;
1311         }
1312
1313         TRACE("%.*s\n", cbWrite, lpvBuf );
1314
1315         length = 0;
1316         while (length < cbWrite) {
1317           if ((ptr->obuf_head == ptr->obuf_tail) && (ptr->xmit < 0)) {
1318             /* no data queued, try to write directly */
1319             status = write(ptr->fd, lpvBuf, cbWrite - length);
1320             if (status > 0) {
1321               lpvBuf += status;
1322               length += status;
1323               continue;
1324             }
1325           }
1326           /* can't write directly, put into transmit buffer */
1327           status = ((ptr->obuf_tail > ptr->obuf_head) ?
1328                     (ptr->obuf_tail-1) : ptr->obuf_size) - ptr->obuf_head;
1329           if (!status) break;
1330           if ((cbWrite - length) < status)
1331             status = cbWrite - length;
1332           memcpy(lpvBuf, ptr->outbuf + ptr->obuf_head, status);
1333           ptr->obuf_head += status;
1334           if (ptr->obuf_head >= ptr->obuf_size)
1335             ptr->obuf_head = 0;
1336           lpvBuf += status;
1337           length += status;
1338           comm_waitwrite(ptr);
1339         }
1340
1341         ptr->commerror = 0;
1342         return length;
1343 }
1344
1345 /***********************************************************************
1346  *           EnableCommNotification   (USER.246)
1347  */
1348 BOOL16 WINAPI EnableCommNotification16( INT16 cid, HWND16 hwnd,
1349                                       INT16 cbWriteNotify, INT16 cbOutQueue )
1350 {
1351         struct DosDeviceStruct *ptr;
1352
1353         TRACE("(%d, %x, %d, %d)\n", cid, hwnd, cbWriteNotify, cbOutQueue);
1354         if ((ptr = GetDeviceStruct(cid)) == NULL) {
1355                 ptr->commerror = IE_BADID;
1356                 return -1;
1357         }
1358         ptr->wnd = hwnd;
1359         ptr->n_read = cbWriteNotify;
1360         ptr->n_write = cbOutQueue;
1361         return TRUE;
1362 }
1363
1364
1365 /**************************************************************************
1366  *         BuildCommDCBA                (KERNEL32.14)
1367  */
1368 BOOL WINAPI BuildCommDCBA(LPCSTR device,LPDCB lpdcb)
1369 {
1370         return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
1371 }
1372
1373 /**************************************************************************
1374  *         BuildCommDCBAndTimeoutsA     (KERNEL32.15)
1375  */
1376 BOOL WINAPI BuildCommDCBAndTimeoutsA(LPCSTR device, LPDCB lpdcb,
1377                                          LPCOMMTIMEOUTS lptimeouts)
1378 {
1379         int     port;
1380         char    *ptr,*temp;
1381
1382         TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
1383
1384         if (!lstrncmpiA(device,"COM",3)) {
1385                 port=device[3]-'0';
1386                 if (port--==0) {
1387                         ERR("BUG! COM0 can't exists!.\n");
1388                         return FALSE;
1389                 }
1390                 if (!ValidCOMPort(port))
1391                         return FALSE;
1392                 if (*(device+4)!=':')
1393                         return FALSE;
1394                 temp=(LPSTR)(device+5);
1395         } else
1396                 temp=(LPSTR)device;
1397
1398         memset(lpdcb, 0, sizeof(DCB)); /* initialize */
1399
1400         lpdcb->DCBlength        = sizeof(DCB);
1401         if (strchr(temp,',')) { /* old style */
1402                 DCB16   dcb16;
1403                 BOOL16  ret;
1404                 char    last=temp[strlen(temp)-1];
1405
1406                 ret=BuildCommDCB16(device,&dcb16);
1407                 if (!ret)
1408                         return FALSE;
1409                 lpdcb->BaudRate         = dcb16.BaudRate;
1410                 lpdcb->ByteSize         = dcb16.ByteSize;
1411                 lpdcb->fBinary          = dcb16.fBinary;
1412                 lpdcb->Parity           = dcb16.Parity;
1413                 lpdcb->fParity          = dcb16.fParity;
1414                 lpdcb->fNull            = dcb16.fNull;
1415                 lpdcb->StopBits         = dcb16.StopBits;
1416                 if (last == 'x') {
1417                         lpdcb->fInX             = TRUE;
1418                         lpdcb->fOutX            = TRUE;
1419                         lpdcb->fOutxCtsFlow     = FALSE;
1420                         lpdcb->fOutxDsrFlow     = FALSE;
1421                         lpdcb->fDtrControl      = DTR_CONTROL_ENABLE;
1422                         lpdcb->fRtsControl      = RTS_CONTROL_ENABLE;
1423                 } else if (last=='p') {
1424                         lpdcb->fInX             = FALSE;
1425                         lpdcb->fOutX            = FALSE;
1426                         lpdcb->fOutxCtsFlow     = TRUE;
1427                         lpdcb->fOutxDsrFlow     = TRUE;
1428                         lpdcb->fDtrControl      = DTR_CONTROL_HANDSHAKE;
1429                         lpdcb->fRtsControl      = RTS_CONTROL_HANDSHAKE;
1430                 } else {
1431                         lpdcb->fInX             = FALSE;
1432                         lpdcb->fOutX            = FALSE;
1433                         lpdcb->fOutxCtsFlow     = FALSE;
1434                         lpdcb->fOutxDsrFlow     = FALSE;
1435                         lpdcb->fDtrControl      = DTR_CONTROL_ENABLE;
1436                         lpdcb->fRtsControl      = RTS_CONTROL_ENABLE;
1437                 }
1438                 lpdcb->XonChar  = dcb16.XonChar;
1439                 lpdcb->XoffChar = dcb16.XoffChar;
1440                 lpdcb->ErrorChar= dcb16.PeChar;
1441                 lpdcb->fErrorChar= dcb16.fPeChar;
1442                 lpdcb->EofChar  = dcb16.EofChar;
1443                 lpdcb->EvtChar  = dcb16.EvtChar;
1444                 lpdcb->XonLim   = dcb16.XonLim;
1445                 lpdcb->XoffLim  = dcb16.XoffLim;
1446                 return TRUE;
1447         }
1448         ptr=strtok(temp," ");
1449         while (ptr) {
1450                 DWORD   flag,x;
1451
1452                 flag=0;
1453                 if (!strncmp("baud=",ptr,5)) {
1454                         if (!sscanf(ptr+5,"%ld",&x))
1455                                 WARN("Couldn't parse %s\n",ptr);
1456                         lpdcb->BaudRate = x;
1457                         flag=1;
1458                 }
1459                 if (!strncmp("stop=",ptr,5)) {
1460                         if (!sscanf(ptr+5,"%ld",&x))
1461                                 WARN("Couldn't parse %s\n",ptr);
1462                         lpdcb->StopBits = x;
1463                         flag=1;
1464                 }
1465                 if (!strncmp("data=",ptr,5)) {
1466                         if (!sscanf(ptr+5,"%ld",&x))
1467                                 WARN("Couldn't parse %s\n",ptr);
1468                         lpdcb->ByteSize = x;
1469                         flag=1;
1470                 }
1471                 if (!strncmp("parity=",ptr,7)) {
1472                         lpdcb->fParity  = TRUE;
1473                         switch (ptr[8]) {
1474                         case 'N':case 'n':
1475                                 lpdcb->fParity  = FALSE;
1476                                 lpdcb->Parity   = NOPARITY;
1477                                 break;
1478                         case 'E':case 'e':
1479                                 lpdcb->Parity   = EVENPARITY;
1480                                 break;
1481                         case 'O':case 'o':
1482                                 lpdcb->Parity   = ODDPARITY;
1483                                 break;
1484                         case 'M':case 'm':
1485                                 lpdcb->Parity   = MARKPARITY;
1486                                 break;
1487                         }
1488                         flag=1;
1489                 }
1490                 if (!flag)
1491                         ERR("Unhandled specifier '%s', please report.\n",ptr);
1492                 ptr=strtok(NULL," ");
1493         }
1494         if (lpdcb->BaudRate==110)
1495                 lpdcb->StopBits = 2;
1496         return TRUE;
1497 }
1498
1499 /**************************************************************************
1500  *         BuildCommDCBAndTimeoutsW             (KERNEL32.16)
1501  */
1502 BOOL WINAPI BuildCommDCBAndTimeoutsW( LPCWSTR devid, LPDCB lpdcb,
1503                                           LPCOMMTIMEOUTS lptimeouts )
1504 {
1505         LPSTR   devidA;
1506         BOOL    ret;
1507
1508         TRACE("(%p,%p,%p)\n",devid,lpdcb,lptimeouts);
1509         devidA = HEAP_strdupWtoA( GetProcessHeap(), 0, devid );
1510         ret=BuildCommDCBAndTimeoutsA(devidA,lpdcb,lptimeouts);
1511         HeapFree( GetProcessHeap(), 0, devidA );
1512         return ret;
1513 }
1514
1515 /**************************************************************************
1516  *         BuildCommDCBW                (KERNEL32.17)
1517  */
1518 BOOL WINAPI BuildCommDCBW(LPCWSTR devid,LPDCB lpdcb)
1519 {
1520         return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
1521 }
1522
1523 /*****************************************************************************
1524  *      COMM_GetReadFd
1525  *  Returns a file descriptor for reading.
1526  *  Make sure to close the handle afterwards!
1527  */
1528 static int COMM_GetReadFd( HANDLE handle)
1529 {
1530     int fd;
1531     struct get_read_fd_request *req = get_req_buffer();
1532     req->handle = handle;
1533     server_call_fd( REQ_GET_READ_FD, -1, &fd );
1534     return fd;
1535 }
1536
1537 /*****************************************************************************
1538  *      COMM_GetWriteFd
1539  *  Returns a file descriptor for writing.
1540  *  Make sure to close the handle afterwards!
1541  */
1542 static int COMM_GetWriteFd( HANDLE handle)
1543 {
1544     int fd;
1545     struct get_write_fd_request *req = get_req_buffer();
1546     req->handle = handle;
1547     server_call_fd( REQ_GET_WRITE_FD, -1, &fd );
1548     return fd;
1549 }
1550
1551 /* FIXME: having these global for win32 for now */
1552 int commerror=0,eventmask=0;
1553
1554 /*****************************************************************************
1555  *      SetCommBreak            (KERNEL32.449)
1556  */
1557 BOOL WINAPI SetCommBreak(HANDLE handle)
1558 {
1559 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
1560         int fd,result;
1561
1562         fd = COMM_GetWriteFd(handle);
1563         if(fd<0) {
1564                 TRACE("COMM_GetWriteFd failed\n");
1565                 return FALSE;
1566         }
1567         result = ioctl(fd,TIOCSBRK,0);
1568         close(fd);
1569         if (result ==-1)
1570           {
1571                 TRACE("ioctl failed\n");
1572                 SetLastError(ERROR_NOT_SUPPORTED);
1573                 return FALSE;
1574           }
1575         return TRUE;
1576 #else
1577         FIXME("ioctl not available\n");
1578         SetLastError(ERROR_NOT_SUPPORTED);
1579         return FALSE;
1580 #endif
1581 }
1582
1583 /*****************************************************************************
1584  *      ClearCommBreak          (KERNEL32.20)
1585  */
1586 BOOL WINAPI ClearCommBreak(HANDLE handle)
1587 {
1588 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
1589         int fd,result;
1590
1591         fd = COMM_GetWriteFd(handle);
1592         if(fd<0) {
1593                 TRACE("COMM_GetWriteFd failed\n");
1594                 return FALSE;
1595         }
1596         result = ioctl(fd,TIOCCBRK,0);
1597         close(fd);
1598         if (result ==-1)
1599           {
1600                 TRACE("ioctl failed\n");
1601                 SetLastError(ERROR_NOT_SUPPORTED);
1602                 return FALSE;
1603           }
1604         return TRUE;
1605 #else
1606         FIXME("ioctl not available\n");
1607         SetLastError(ERROR_NOT_SUPPORTED);
1608         return FALSE;
1609 #endif
1610 }
1611
1612 /*****************************************************************************
1613  *      EscapeCommFunction      (KERNEL32.214)
1614  */
1615 BOOL WINAPI EscapeCommFunction(HANDLE handle,UINT nFunction)
1616 {
1617         int fd,direct=FALSE,result=FALSE;
1618         struct termios  port;
1619
1620         TRACE("handle %d, function=%d\n", handle, nFunction);
1621         fd = COMM_GetWriteFd(handle);
1622         if(fd<0)
1623                 return FALSE;
1624
1625         if (tcgetattr(fd,&port) == -1) {
1626                 commerror=WinError();
1627                 close(fd);
1628                 return FALSE;
1629         }
1630
1631         switch (nFunction) {
1632                 case RESETDEV:
1633                         TRACE("\n");
1634                         break;
1635
1636                 case CLRDTR:
1637                         TRACE("CLRDTR\n");
1638 #ifdef TIOCM_DTR
1639                         direct=TRUE;
1640                         result= COMM_WhackModem(fd, ~TIOCM_DTR, 0);
1641                         break;
1642 #endif
1643
1644                 case CLRRTS:
1645                         TRACE("CLRRTS\n");
1646 #ifdef TIOCM_RTS
1647                         direct=TRUE;
1648                         result= COMM_WhackModem(fd, ~TIOCM_RTS, 0);
1649                         break;
1650 #endif
1651
1652                 case SETDTR:
1653                         TRACE("SETDTR\n");
1654 #ifdef TIOCM_DTR
1655                         direct=TRUE;
1656                         result= COMM_WhackModem(fd, 0, TIOCM_DTR);
1657                         break;
1658 #endif
1659
1660                 case SETRTS:
1661                         TRACE("SETRTS\n");
1662 #ifdef TIOCM_DTR
1663                         direct=TRUE;
1664                         result= COMM_WhackModem(fd, 0, TIOCM_RTS);
1665                         break;
1666 #endif
1667
1668                 case SETXOFF:
1669                         TRACE("SETXOFF\n");
1670                         port.c_iflag |= IXOFF;
1671                         break;
1672
1673                 case SETXON:
1674                         TRACE("SETXON\n");
1675                         port.c_iflag |= IXON;
1676                         break;
1677                 case SETBREAK:
1678                         TRACE("setbreak\n");
1679 #ifdef  TIOCSBRK
1680                         direct=TRUE;
1681                         result = ioctl(fd,TIOCSBRK,0);
1682                         break;
1683 #endif
1684                 case CLRBREAK:
1685                         TRACE("clrbreak\n");
1686 #ifdef  TIOCSBRK
1687                         direct=TRUE;
1688                         result = ioctl(fd,TIOCCBRK,0);
1689                         break;
1690 #endif
1691                 default:
1692                         WARN("(handle=%d,nFunction=%d): Unknown function\n",
1693                         handle, nFunction);
1694                         break;
1695         }
1696
1697         if (!direct)
1698           if (tcsetattr(fd, TCSADRAIN, &port) == -1) {
1699                 commerror = WinError();
1700                 close(fd);
1701                 return FALSE;
1702           } else
1703                 result= TRUE;
1704         else
1705           {
1706             if (result == -1)
1707               {
1708                 result= FALSE;
1709                 commerror=WinError();
1710               }
1711             else
1712               result = TRUE;
1713           }
1714         close(fd);
1715         return result;
1716 }
1717
1718 /********************************************************************
1719  *      PurgeComm        (KERNEL32.557)
1720  */
1721 BOOL WINAPI PurgeComm( HANDLE handle, DWORD flags)
1722 {
1723      int fd;
1724
1725      TRACE("handle %d, flags %lx\n", handle, flags);
1726
1727      fd = COMM_GetWriteFd(handle);
1728      if(fd<0)
1729          return FALSE;
1730
1731      /*
1732      ** not exactly sure how these are different
1733      ** Perhaps if we had our own internal queues, one flushes them
1734      ** and the other flushes the kernel's buffers.
1735      */
1736      if(flags&PURGE_TXABORT)
1737      {
1738          tcflush(fd,TCOFLUSH);
1739      }
1740      if(flags&PURGE_RXABORT)
1741      {
1742          tcflush(fd,TCIFLUSH);
1743      }
1744      if(flags&PURGE_TXCLEAR)
1745      {
1746          tcflush(fd,TCOFLUSH);
1747      }
1748      if(flags&PURGE_RXCLEAR)
1749      {
1750          tcflush(fd,TCIFLUSH);
1751      }
1752      close(fd);
1753
1754      return 1;
1755 }
1756
1757 /*****************************************************************************
1758  *      ClearCommError  (KERNEL32.21)
1759  */
1760 BOOL WINAPI ClearCommError(INT handle,LPDWORD errors,LPCOMSTAT lpStat)
1761 {
1762     int fd;
1763
1764     fd=COMM_GetReadFd(handle);
1765     if(0>fd)
1766     {
1767         return FALSE;
1768     }
1769
1770     if (lpStat)
1771     {
1772         lpStat->status = 0;
1773
1774         if(ioctl(fd, TIOCOUTQ, &lpStat->cbOutQue))
1775             WARN("ioctl returned error\n");
1776
1777         if(ioctl(fd, TIOCINQ, &lpStat->cbInQue))
1778             WARN("ioctl returned error\n");
1779
1780         TRACE("handle %d cbInQue = %ld cbOutQue = %ld\n",
1781               handle, lpStat->cbInQue, lpStat->cbOutQue);
1782     }
1783
1784     close(fd);
1785
1786     if(errors)
1787         *errors = 0;
1788
1789     /*
1790     ** After an asynchronous write opperation, the
1791     ** app will call ClearCommError to see if the
1792     ** results are ready yet. It waits for ERROR_IO_PENDING
1793     */
1794     commerror = ERROR_IO_PENDING;
1795
1796     return TRUE;
1797 }
1798
1799 /*****************************************************************************
1800  *      SetupComm       (KERNEL32.676)
1801  */
1802 BOOL WINAPI SetupComm( HANDLE handle, DWORD insize, DWORD outsize)
1803 {
1804     int fd;
1805
1806     FIXME("insize %ld outsize %ld unimplemented stub\n", insize, outsize);
1807     fd=COMM_GetWriteFd(handle);
1808     if(0>fd)
1809     {
1810         return FALSE;
1811     }
1812     close(fd);
1813     return TRUE;
1814 }
1815
1816 /*****************************************************************************
1817  *      GetCommMask     (KERNEL32.156)
1818  */
1819 BOOL WINAPI GetCommMask(HANDLE handle,LPDWORD evtmask)
1820 {
1821     int fd;
1822
1823     TRACE("handle %d, mask %p\n", handle, evtmask);
1824     if(0>(fd=COMM_GetReadFd(handle)))
1825     {
1826         return FALSE;
1827     }
1828     close(fd);
1829     *evtmask = eventmask;
1830     TRACE("%s%s%s%s%s%s%s%s%s\n",
1831           (eventmask&EV_BREAK)?"EV_BREAK":"",
1832           (eventmask&EV_CTS)?"EV_CTS":"",
1833           (eventmask&EV_DSR)?"EV_DSR":"",
1834           (eventmask&EV_ERR)?"EV_ERR":"",
1835           (eventmask&EV_RING)?"EV_RING":"",
1836           (eventmask&EV_RLSD)?"EV_RLSD":"",
1837           (eventmask&EV_RXCHAR)?"EV_RXCHAR":"",
1838           (eventmask&EV_RXFLAG)?"EV_RXFLAG":"",
1839           (eventmask&EV_TXEMPTY)?"EV_TXEMPTY":"");
1840
1841     return TRUE;
1842 }
1843
1844 /*****************************************************************************
1845  *      SetCommMask     (KERNEL32.451)
1846  */
1847 BOOL WINAPI SetCommMask(INT handle,DWORD evtmask)
1848 {
1849     int fd;
1850
1851     TRACE("handle %d, mask %lx\n", handle, evtmask);
1852     TRACE("%s%s%s%s%s%s%s%s%s\n",
1853           (evtmask&EV_BREAK)?"EV_BREAK":"",
1854           (evtmask&EV_CTS)?"EV_CTS":"",
1855           (evtmask&EV_DSR)?"EV_DSR":"",
1856           (evtmask&EV_ERR)?"EV_ERR":"",
1857           (evtmask&EV_RING)?"EV_RING":"",
1858           (evtmask&EV_RLSD)?"EV_RLSD":"",
1859           (evtmask&EV_RXCHAR)?"EV_RXCHAR":"",
1860           (evtmask&EV_RXFLAG)?"EV_RXFLAG":"",
1861           (evtmask&EV_TXEMPTY)?"EV_TXEMPTY":"");
1862
1863     if(0>(fd=COMM_GetWriteFd(handle))) {
1864         return FALSE;
1865     }
1866     close(fd);
1867     eventmask = evtmask;
1868     return TRUE;
1869 }
1870
1871 /*****************************************************************************
1872  *      SetCommState    (KERNEL32.452)
1873  */
1874 BOOL WINAPI SetCommState(INT handle,LPDCB lpdcb)
1875 {
1876      struct termios port;
1877      int fd;
1878
1879      TRACE("handle %d, ptr %p\n", handle, lpdcb);
1880      TRACE("bytesize %d baudrate %ld fParity %d Parity %d stopbits %d\n",
1881            lpdcb->ByteSize,lpdcb->BaudRate,lpdcb->fParity, lpdcb->Parity,
1882            (lpdcb->StopBits == ONESTOPBIT)?1:
1883            (lpdcb->StopBits == TWOSTOPBITS)?2:0);
1884      TRACE("%s %s\n",(lpdcb->fInX)?"IXON":"~IXON",
1885            (lpdcb->fOutX)?"IXOFF":"~IXOFF");
1886
1887      if ((fd = COMM_GetWriteFd(handle)) < 0) return FALSE;
1888
1889      if ((tcgetattr(fd,&port)) == -1) {
1890          int save_error = errno;
1891          commerror = WinError();
1892          close( fd );
1893 #ifdef HAVE_STRERROR
1894          ERR("tcgetattr error '%s'\n", strerror(save_error));
1895 #else
1896          ERR("tcgetattr error %d\n", save_error);
1897 #endif
1898          return FALSE;
1899      }
1900
1901         port.c_cc[VMIN] = 0;
1902         port.c_cc[VTIME] = 1;
1903
1904 #ifdef IMAXBEL
1905         port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
1906 #else
1907         port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
1908 #endif
1909         port.c_iflag |= (IGNBRK);
1910
1911         port.c_oflag &= ~(OPOST);
1912
1913         port.c_cflag &= ~(HUPCL);
1914         port.c_cflag |= CLOCAL | CREAD;
1915
1916         port.c_lflag &= ~(ICANON|ECHO|ISIG);
1917         port.c_lflag |= NOFLSH;
1918
1919      /*
1920      ** MJM - removed default baudrate settings
1921      ** TRACE(comm,"baudrate %ld\n",lpdcb->BaudRate);
1922      */
1923 #ifdef CBAUD
1924         port.c_cflag &= ~CBAUD;
1925         switch (lpdcb->BaudRate) {
1926                 case 110:
1927                 case CBR_110:
1928                         port.c_cflag |= B110;
1929                         break;
1930                 case 300:
1931                 case CBR_300:
1932                         port.c_cflag |= B300;
1933                         break;
1934                 case 600:
1935                 case CBR_600:
1936                         port.c_cflag |= B600;
1937                         break;
1938                 case 1200:
1939                 case CBR_1200:
1940                         port.c_cflag |= B1200;
1941                         break;
1942                 case 2400:
1943                 case CBR_2400:
1944                         port.c_cflag |= B2400;
1945                         break;
1946                 case 4800:
1947                 case CBR_4800:
1948                         port.c_cflag |= B4800;
1949                         break;
1950                 case 9600:
1951                 case CBR_9600:
1952                         port.c_cflag |= B9600;
1953                         break;
1954                 case 19200:
1955                 case CBR_19200:
1956                         port.c_cflag |= B19200;
1957                         break;
1958                 case 38400:
1959                 case CBR_38400:
1960                         port.c_cflag |= B38400;
1961                         break;
1962 #ifdef B57600
1963                 case 57600:
1964                         port.c_cflag |= B57600;
1965                         break;
1966 #endif
1967 #ifdef B115200
1968                 case 115200:
1969                         port.c_cflag |= B115200;
1970                         break;
1971 #endif
1972 #ifdef B230400
1973                 case 230400:
1974                         port.c_cflag |= B230400;
1975                         break;
1976 #endif
1977 #ifdef B460800
1978                 case 460600:
1979                         port.c_cflag |= B460800;
1980                         break;
1981 #endif
1982                 default:
1983                         commerror = IE_BAUDRATE;
1984                         close( fd );
1985                         ERR("baudrate %ld\n",lpdcb->BaudRate);
1986                         return FALSE;
1987         }
1988 #elif !defined(__EMX__)
1989         switch (lpdcb->BaudRate) {
1990                 case 110:
1991                 case CBR_110:
1992                         port.c_ospeed = B110;
1993                         break;
1994                 case 300:
1995                 case CBR_300:
1996                         port.c_ospeed = B300;
1997                         break;
1998                 case 600:
1999                 case CBR_600:
2000                         port.c_ospeed = B600;
2001                         break;
2002                 case 1200:
2003                 case CBR_1200:
2004                         port.c_ospeed = B1200;
2005                         break;
2006                 case 2400:
2007                 case CBR_2400:
2008                         port.c_ospeed = B2400;
2009                         break;
2010                 case 4800:
2011                 case CBR_4800:
2012                         port.c_ospeed = B4800;
2013                         break;
2014                 case 9600:
2015                 case CBR_9600:
2016                         port.c_ospeed = B9600;
2017                         break;
2018                 case 19200:
2019                 case CBR_19200:
2020                         port.c_ospeed = B19200;
2021                         break;
2022                 case 38400:
2023                 case CBR_38400:
2024                         port.c_ospeed = B38400;
2025                         break;
2026                 default:
2027                         commerror = IE_BAUDRATE;
2028                         close( fd );
2029                         ERR("baudrate %d \n",lpdcb->BaudRate);
2030                         return FALSE;
2031         }
2032         port.c_ispeed = port.c_ospeed;
2033 #endif
2034         port.c_cflag &= ~CSIZE;
2035         switch (lpdcb->ByteSize) {
2036                 case 5:
2037                         port.c_cflag |= CS5;
2038                         break;
2039                 case 6:
2040                         port.c_cflag |= CS6;
2041                         break;
2042                 case 7:
2043                         port.c_cflag |= CS7;
2044                         break;
2045                 case 8:
2046                         port.c_cflag |= CS8;
2047                         break;
2048                 default:
2049                         commerror = IE_BYTESIZE;
2050                         close( fd );
2051                         ERR("ByteSize\n");
2052                         return FALSE;
2053         }
2054
2055         port.c_cflag &= ~(PARENB | PARODD);
2056         if (lpdcb->fParity)
2057             port.c_iflag |= INPCK;
2058         else
2059             port.c_iflag &= ~INPCK;
2060         switch (lpdcb->Parity) {
2061                 case NOPARITY:
2062                         break;
2063                 case ODDPARITY:
2064                         port.c_cflag |= (PARENB | PARODD);
2065                         break;
2066                 case EVENPARITY:
2067                         port.c_cflag |= PARENB;
2068                         break;
2069                 default:
2070                         commerror = IE_BYTESIZE;
2071                         close( fd );
2072                         ERR("Parity\n");
2073                         return FALSE;
2074         }
2075
2076
2077         switch (lpdcb->StopBits) {
2078                 case ONESTOPBIT:
2079                                 port.c_cflag &= ~CSTOPB;
2080                                 break;
2081                 case TWOSTOPBITS:
2082                                 port.c_cflag |= CSTOPB;
2083                                 break;
2084                 default:
2085                         commerror = IE_BYTESIZE;
2086                         close( fd );
2087                         ERR("StopBits\n");
2088                         return FALSE;
2089         }
2090 #ifdef CRTSCTS
2091         if (    lpdcb->fOutxCtsFlow                     ||
2092                 lpdcb->fDtrControl == DTR_CONTROL_ENABLE||
2093                 lpdcb->fRtsControl == RTS_CONTROL_ENABLE
2094         )
2095           {
2096             port.c_cflag |= CRTSCTS;
2097             TRACE("CRTSCTS\n");
2098           }
2099
2100         if (lpdcb->fDtrControl == DTR_CONTROL_DISABLE)
2101           {
2102             port.c_cflag &= ~CRTSCTS;
2103             TRACE("~CRTSCTS\n");
2104           }
2105
2106 #endif
2107         if (lpdcb->fInX)
2108                 port.c_iflag |= IXON;
2109         else
2110                 port.c_iflag &= ~IXON;
2111         if (lpdcb->fOutX)
2112                 port.c_iflag |= IXOFF;
2113         else
2114                 port.c_iflag &= ~IXOFF;
2115
2116         if (tcsetattr(fd,TCSANOW,&port)==-1) { /* otherwise it hangs with pending input*/
2117                 int save_error=errno;
2118                 commerror = WinError();
2119                 close( fd );
2120 #ifdef HAVE_STRERROR
2121                 ERR("tcgetattr error '%s'\n", strerror(save_error));
2122 #else
2123                 ERR("tcgetattr error %d\n", save_error);
2124 #endif
2125                 return FALSE;
2126         } else {
2127                 commerror = 0;
2128                 close( fd );
2129                 return TRUE;
2130         }
2131 }
2132
2133
2134 /*****************************************************************************
2135  *      GetCommState    (KERNEL32.159)
2136  */
2137 BOOL WINAPI GetCommState(INT handle, LPDCB lpdcb)
2138 {
2139      struct termios port;
2140      int fd,speed;
2141
2142      TRACE("handle %d, ptr %p\n", handle, lpdcb);
2143
2144      if ((fd = COMM_GetReadFd(handle)) < 0)
2145        {
2146          ERR("can't get COMM_GetReadFd\n");
2147          return FALSE;
2148        }
2149      if (tcgetattr(fd, &port) == -1) {
2150                 int save_error=errno;
2151 #ifdef HAVE_STRERROR
2152                 ERR("tcgetattr error '%s'\n", strerror(save_error));
2153 #else
2154                 ERR("tcgetattr error %d\n", save_error);
2155 #endif
2156                 commerror = WinError();
2157                 close( fd );
2158                 return FALSE;
2159         }
2160      close( fd );
2161 #ifndef __EMX__
2162 #ifdef CBAUD
2163      speed= (port.c_cflag & CBAUD);
2164 #else
2165      speed= (cfgetospeed(&port));
2166 #endif
2167      switch (speed) {
2168                 case B110:
2169                         lpdcb->BaudRate = 110;
2170                         break;
2171                 case B300:
2172                         lpdcb->BaudRate = 300;
2173                         break;
2174                 case B600:
2175                         lpdcb->BaudRate = 600;
2176                         break;
2177                 case B1200:
2178                         lpdcb->BaudRate = 1200;
2179                         break;
2180                 case B2400:
2181                         lpdcb->BaudRate = 2400;
2182                         break;
2183                 case B4800:
2184                         lpdcb->BaudRate = 4800;
2185                         break;
2186                 case B9600:
2187                         lpdcb->BaudRate = 9600;
2188                         break;
2189                 case B19200:
2190                         lpdcb->BaudRate = 19200;
2191                         break;
2192                 case B38400:
2193                         lpdcb->BaudRate = 38400;
2194                         break;
2195 #ifdef B57600
2196                 case B57600:
2197                         lpdcb->BaudRate = 57600;
2198                         break;
2199 #endif
2200 #ifdef B115200
2201                 case B115200:
2202                         lpdcb->BaudRate = 115200;
2203                         break;
2204 #endif
2205 #ifdef B230400
2206                 case B230400:
2207                         lpdcb->BaudRate = 230400;
2208                         break;
2209 #endif
2210 #ifdef B460800
2211                 case B460800:
2212                         lpdcb->BaudRate = 460800;
2213                         break;
2214 #endif
2215                 default:
2216                         ERR("unknown speed %x \n",speed);
2217         }
2218 #endif
2219         switch (port.c_cflag & CSIZE) {
2220                 case CS5:
2221                         lpdcb->ByteSize = 5;
2222                         break;
2223                 case CS6:
2224                         lpdcb->ByteSize = 6;
2225                         break;
2226                 case CS7:
2227                         lpdcb->ByteSize = 7;
2228                         break;
2229                 case CS8:
2230                         lpdcb->ByteSize = 8;
2231                         break;
2232                 default:
2233                         ERR("unknown size %x \n",port.c_cflag & CSIZE);
2234         }
2235
2236         if(port.c_iflag & INPCK)
2237             lpdcb->fParity = TRUE;
2238         else
2239             lpdcb->fParity = FALSE;
2240         switch (port.c_cflag & (PARENB | PARODD)) {
2241                 case 0:
2242                         lpdcb->Parity = NOPARITY;
2243                         break;
2244                 case PARENB:
2245                         lpdcb->Parity = EVENPARITY;
2246                         break;
2247                 case (PARENB | PARODD):
2248                         lpdcb->Parity = ODDPARITY;
2249                         break;
2250         }
2251
2252         if (port.c_cflag & CSTOPB)
2253                 lpdcb->StopBits = TWOSTOPBITS;
2254         else
2255                 lpdcb->StopBits = ONESTOPBIT;
2256
2257         lpdcb->fNull = 0;
2258         lpdcb->fBinary = 1;
2259
2260 #ifdef CRTSCTS
2261
2262         if (port.c_cflag & CRTSCTS) {
2263                 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
2264                 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
2265                 lpdcb->fOutxCtsFlow = 1;
2266                 lpdcb->fOutxDsrFlow = 1;
2267         } else
2268 #endif
2269         {
2270                 lpdcb->fDtrControl = DTR_CONTROL_DISABLE;
2271                 lpdcb->fRtsControl = RTS_CONTROL_DISABLE;
2272         }
2273         if (port.c_iflag & IXON)
2274                 lpdcb->fInX = 1;
2275         else
2276                 lpdcb->fInX = 0;
2277
2278         if (port.c_iflag & IXOFF)
2279                 lpdcb->fOutX = 1;
2280         else
2281                 lpdcb->fOutX = 0;
2282 /*
2283         lpdcb->XonChar =
2284         lpdcb->XoffChar =
2285  */
2286         lpdcb->XonLim = 10;
2287         lpdcb->XoffLim = 10;
2288
2289         commerror = 0;
2290
2291         TRACE("OK\n");
2292
2293         TRACE("bytesize %d baudrate %ld fParity %d Parity %d stopbits %d\n",
2294               lpdcb->ByteSize,lpdcb->BaudRate,lpdcb->fParity, lpdcb->Parity,
2295               (lpdcb->StopBits == ONESTOPBIT)?1:
2296               (lpdcb->StopBits == TWOSTOPBITS)?2:0);
2297         TRACE("%s %s\n",(lpdcb->fInX)?"IXON":"~IXON",
2298               (lpdcb->fOutX)?"IXOFF":"~IXOFF");
2299 #ifdef CRTSCTS
2300         if (    lpdcb->fOutxCtsFlow                     ||
2301                 lpdcb->fDtrControl == DTR_CONTROL_ENABLE||
2302                 lpdcb->fRtsControl == RTS_CONTROL_ENABLE
2303                 )
2304           TRACE("CRTSCTS\n");
2305
2306         if (lpdcb->fDtrControl == DTR_CONTROL_DISABLE)
2307           TRACE("~CRTSCTS\n");
2308
2309 #endif
2310         return TRUE;
2311 }
2312
2313 /*****************************************************************************
2314  *      TransmitCommChar        (KERNEL32.535)
2315  */
2316 BOOL WINAPI TransmitCommChar(INT cid,CHAR chTransmit)
2317 {
2318         struct DosDeviceStruct *ptr;
2319
2320         FIXME("(%d,'%c'), use win32 handle!\n",cid,chTransmit);
2321         if ((ptr = GetDeviceStruct(cid)) == NULL) {
2322                 return FALSE;
2323         }
2324
2325         if (ptr->suspended) {
2326                 ptr->commerror = IE_HARDWARE;
2327                 return FALSE;
2328         }
2329         if (write(ptr->fd, (void *) &chTransmit, 1) == -1) {
2330                 ptr->commerror = WinError();
2331                 return FALSE;
2332         }  else {
2333                 ptr->commerror = 0;
2334                 return TRUE;
2335         }
2336 }
2337
2338 /*****************************************************************************
2339  *      GetCommTimeouts         (KERNEL32.160)
2340  */
2341 BOOL WINAPI GetCommTimeouts(INT cid,LPCOMMTIMEOUTS lptimeouts)
2342 {
2343         FIXME("(%x,%p):stub.\n",cid,lptimeouts);
2344         return TRUE;
2345 }
2346
2347 /*****************************************************************************
2348  *      SetCommTimeouts         (KERNEL32.453)
2349  */
2350 BOOL WINAPI SetCommTimeouts(INT cid,LPCOMMTIMEOUTS lptimeouts) {
2351         FIXME("(%x,%p):stub.\n",cid,lptimeouts);
2352         TRACE("ReadIntervalTimeout %ld\n",lptimeouts->ReadIntervalTimeout);
2353         TRACE("ReadTotalTimeoutMultiplier %ld\n",
2354               lptimeouts->ReadTotalTimeoutMultiplier);
2355         TRACE("ReadTotalTimeoutConstant %ld\n",
2356               lptimeouts->ReadTotalTimeoutConstant);
2357         TRACE("WriteTotalTimeoutMultiplier %ld\n",
2358               lptimeouts->WriteTotalTimeoutMultiplier);
2359         TRACE("WriteTotalTimeoutConstant %ld\n",
2360               lptimeouts->WriteTotalTimeoutConstant);
2361         return TRUE;
2362 }
2363
2364 /***********************************************************************
2365  *           GetCommModemStatus   (KERNEL32.285)
2366  */
2367 BOOL WINAPI GetCommModemStatus(HANDLE hFile,LPDWORD lpModemStat )
2368 {
2369         int fd,mstat, result=FALSE;
2370
2371         *lpModemStat=0;
2372 #ifdef TIOCMGET
2373         fd = COMM_GetWriteFd(hFile);
2374         if(fd<0)
2375                 return FALSE;
2376         result = ioctl(fd, TIOCMGET, &mstat);
2377         close(fd);
2378         if (result == -1)
2379           {
2380             TRACE("ioctl failed\n");
2381             return FALSE;
2382           }
2383         if (mstat & TIOCM_CTS)
2384             *lpModemStat |= MS_CTS_ON;
2385         if (mstat & TIOCM_DSR)
2386           *lpModemStat |= MS_DSR_ON;
2387         if (mstat & TIOCM_RNG)
2388           *lpModemStat |= MS_RING_ON;
2389         /*FIXME:  Not really sure about RLSD  UB 990810*/
2390         if (mstat & TIOCM_CAR)
2391           *lpModemStat |= MS_RLSD_ON;
2392         TRACE("%s%s%s%s\n",
2393               (*lpModemStat &MS_RLSD_ON)?"MS_RLSD_ON ":"",
2394               (*lpModemStat &MS_RING_ON)?"MS_RING_ON ":"",
2395               (*lpModemStat &MS_DSR_ON)?"MS_DSR_ON ":"",
2396               (*lpModemStat &MS_CTS_ON)?"MS_CTS_ON ":"");
2397         return TRUE;
2398 #else
2399         return FALSE;
2400 #endif
2401 }
2402 /***********************************************************************
2403  *           WaitCommEvent   (KERNEL32.719)
2404  */
2405 BOOL WINAPI WaitCommEvent(HANDLE hFile,LPDWORD eventmask ,LPOVERLAPPED overlapped)
2406 {
2407         FIXME("(%d %p %p )\n",hFile, eventmask,overlapped);
2408         return TRUE;
2409 }
2410
2411 /***********************************************************************
2412  *           GetCommProperties   (KERNEL32.???)
2413  */
2414 BOOL WINAPI GetCommProperties(HANDLE hFile, LPDCB *dcb)
2415 {
2416     FIXME("(%d %p )\n",hFile,dcb);
2417     return TRUE;
2418 }
2419
2420 /***********************************************************************
2421  *           SetCommProperties   (KERNEL32.???)
2422  */
2423 BOOL WINAPI SetCommProperties(HANDLE hFile, LPDCB dcb)
2424 {
2425     FIXME("(%d %p )\n",hFile,dcb);
2426     return TRUE;
2427 }
2428