dlls/kernel/comm.c

   1 /*
   2  * DEC 93 Erik Bos <erik@xs4all.nl>
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdlib.h>
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #ifdef HAVE_TERMIOS_H
  28 #include <termios.h>
  29 #endif
  30 #include <fcntl.h>
  31 #include <string.h>
  32 #ifdef HAVE_STRINGS_H
  33 # include <strings.h>
  34 #endif
  35 #include <errno.h>
  36 #include <ctype.h>
  37 #ifdef HAVE_SYS_STAT_H
  38 # include <sys/stat.h>
  39 #endif
  40 #ifdef HAVE_SYS_FILIO_H
  41 # include <sys/filio.h>
  42 #endif
  43 #ifdef HAVE_SYS_IOCTL_H
  44 #include <sys/ioctl.h>
  45 #endif
  46 #ifdef HAVE_UNISTD_H
  47 # include <unistd.h>
  48 #endif
  49 #ifdef HAVE_SYS_POLL_H
  50 # include <sys/poll.h>
  51 #endif
  52 #ifdef HAVE_SYS_MODEM_H
  53 # include <sys/modem.h>
  54 #endif
  55 #ifdef HAVE_SYS_STRTIO_H
  56 # include <sys/strtio.h>
  57 #endif
  58
  59 #define NONAMELESSUNION
  60 #define NONAMELESSSTRUCT
  61 #include "windef.h"
  62 #include "winbase.h"
  63 #include "winerror.h"
  64 #include "winioctl.h"
  65 #include "ddk/ntddser.h"
  66
  67 #include "wine/server.h"
  68 #include "wine/unicode.h"
  69
  70 #include "wine/debug.h"
  71
  72 #ifdef HAVE_LINUX_SERIAL_H
  73 #include <linux/serial.h>
  74 #endif
  75
  76 WINE_DEFAULT_DEBUG_CHANNEL(comm);
  77
  78 /* retrieve the Unix handle corresponding to a comm handle */
  79 static int get_comm_fd( HANDLE handle, DWORD access )
  80 {
  81     int fd, ret;
  82
  83     ret = wine_server_handle_to_fd( handle, access, &fd, NULL );
  84     if (ret) SetLastError( RtlNtStatusToDosError(ret) );
  85     return fd;
  86 }
  87
  88 /* release the Unix handle returned by get_comm_fd */
  89 static inline void release_comm_fd( HANDLE handle, int fd )
  90 {
  91     wine_server_release_fd( handle, fd );
  92 }
  93
  94 /*             serial_irq_info
  95  * local structure holding the irq values we need for WaitCommEvent()
  96  *
  97  * Stripped down from struct serial_icounter_struct, which may not be available on some systems
  98  * As the modem line interrupts (cts, dsr, rng, dcd) only get updated with TIOCMIWAIT active,
  99  * no need to carry them in the internal structure
 100  *
 101  */
 102 typedef struct serial_irq_info
 103 {
 104     int rx , tx, frame, overrun, parity, brk, buf_overrun;
 105 }serial_irq_info;
 106
 107 /***********************************************************************
 108  * Data needed by the thread polling for the changing CommEvent
 109  */
 110 typedef struct async_commio
 111 {
 112     HANDLE              handle;
 113     char*               buffer;
 114     HANDLE              hEvent;
 115     DWORD               evtmask;
 116     DWORD               mstat;
 117     serial_irq_info     irq_info;
 118 } async_commio;
 119
 120 /***********************************************************************/
 121
 122 #if !defined(TIOCINQ) && defined(FIONREAD)
 123 #define TIOCINQ FIONREAD
 124 #endif
 125
 126 /***********************************************************************
 127  *   Get extended interrupt count info, needed for WaitCommEvent
 128  */
 129 static int COMM_GetEInfo(int fd, serial_irq_info *irq_info)
 130 {
 131 #ifdef TIOCGICOUNT
 132     struct serial_icounter_struct einfo;
 133     if (!ioctl(fd,TIOCGICOUNT, &einfo))
 134     {
 135         irq_info->rx          = einfo.rx;
 136         irq_info->tx          = einfo.tx;
 137         irq_info->frame       = einfo.frame;
 138         irq_info->overrun     = einfo.overrun;
 139         irq_info->parity      = einfo.parity;
 140         irq_info->brk         = einfo.brk;
 141         irq_info->buf_overrun = einfo.buf_overrun;
 142         return 0;
 143     }
 144 #endif
 145     memset(irq_info,0, sizeof(serial_irq_info));
 146     return -1;
 147 }
 148
 149 static int COMM_WhackModem(int fd, unsigned int andy, unsigned int orrie)
 150 {
 151 #ifdef TIOCMGET
 152     unsigned int mstat, okay;
 153     okay = ioctl(fd, TIOCMGET, &mstat);
 154     if (okay) return okay;
 155     if (andy) mstat &= andy;
 156     mstat |= orrie;
 157     return ioctl(fd, TIOCMSET, &mstat);
 158 #else
 159     return 0;
 160 #endif
 161 }
 162
 163 /***********************************************************************
 164  *           COMM_Parse*   (Internal)
 165  *
 166  *  The following COMM_Parse* functions are used by the BuildCommDCB
 167  *  functions to help parse the various parts of the device control string.
 168  */
 169 static LPCWSTR COMM_ParseStart(LPCWSTR ptr)
 170 {
 171         static const WCHAR comW[] = {'C','O','M',0};
 172
 173         /* The device control string may optionally start with "COMx" followed
 174            by an optional ':' and spaces. */
 175         if(!strncmpiW(ptr, comW, 3))
 176         {
 177                 ptr += 3;
 178
 179                 /* Allow any com port above 0 as Win 9x does (NT only allows
 180                    values for com ports which are actually present) */
 181                 if(*ptr < '1' || *ptr > '9')
 182                         return NULL;
 183
 184                 /* Advance pointer past port number */
 185                 while(*ptr >= '0' && *ptr <= '9') ptr++;
 186
 187                 /* The com port number must be followed by a ':' or ' ' */
 188                 if(*ptr != ':' && *ptr != ' ')
 189                         return NULL;
 190
 191                 /* Advance pointer to beginning of next parameter */
 192                 while(*ptr == ' ') ptr++;
 193                 if(*ptr == ':')
 194                 {
 195                         ptr++;
 196                         while(*ptr == ' ') ptr++;
 197                 }
 198         }
 199         /* The device control string must not start with a space. */
 200         else if(*ptr == ' ')
 201                 return NULL;
 202
 203         return ptr;
 204 }
 205
 206 static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
 207 {
 208         if(*ptr < '0' || *ptr > '9') return NULL;
 209         *lpnumber = strtoulW(ptr, NULL, 10);
 210         while(*ptr >= '0' && *ptr <= '9') ptr++;
 211         return ptr;
 212 }
 213
 214 static LPCWSTR COMM_ParseParity(LPCWSTR ptr, LPBYTE lpparity)
 215 {
 216         /* Contrary to what you might expect, Windows only sets the Parity
 217            member of DCB and not fParity even when parity is specified in the
 218            device control string */
 219
 220         switch(toupperW(*ptr++))
 221         {
 222         case 'E':
 223                 *lpparity = EVENPARITY;
 224                 break;
 225         case 'M':
 226                 *lpparity = MARKPARITY;
 227                 break;
 228         case 'N':
 229                 *lpparity = NOPARITY;
 230                 break;
 231         case 'O':
 232                 *lpparity = ODDPARITY;
 233                 break;
 234         case 'S':
 235                 *lpparity = SPACEPARITY;
 236                 break;
 237         default:
 238                 return NULL;
 239         }
 240
 241         return ptr;
 242 }
 243
 244 static LPCWSTR COMM_ParseByteSize(LPCWSTR ptr, LPBYTE lpbytesize)
 245 {
 246         DWORD temp;
 247
 248         if(!(ptr = COMM_ParseNumber(ptr, &temp)))
 249                 return NULL;
 250
 251         if(temp >= 5 && temp <= 8)
 252         {
 253                 *lpbytesize = temp;
 254                 return ptr;
 255         }
 256         else
 257                 return NULL;
 258 }
 259
 260 static LPCWSTR COMM_ParseStopBits(LPCWSTR ptr, LPBYTE lpstopbits)
 261 {
 262         DWORD temp;
 263         static const WCHAR stopbits15W[] = {'1','.','5',0};
 264
 265         if(!strncmpW(stopbits15W, ptr, 3))
 266         {
 267                 ptr += 3;
 268                 *lpstopbits = ONE5STOPBITS;
 269         }
 270         else
 271         {
 272                 if(!(ptr = COMM_ParseNumber(ptr, &temp)))
 273                         return NULL;
 274
 275                 if(temp == 1)
 276                         *lpstopbits = ONESTOPBIT;
 277                 else if(temp == 2)
 278                         *lpstopbits = TWOSTOPBITS;
 279                 else
 280                         return NULL;
 281         }
 282
 283         return ptr;
 284 }
 285
 286 static LPCWSTR COMM_ParseOnOff(LPCWSTR ptr, LPDWORD lponoff)
 287 {
 288         static const WCHAR onW[] = {'o','n',0};
 289         static const WCHAR offW[] = {'o','f','f',0};
 290
 291         if(!strncmpiW(onW, ptr, 2))
 292         {
 293                 ptr += 2;
 294                 *lponoff = 1;
 295         }
 296         else if(!strncmpiW(offW, ptr, 3))
 297         {
 298                 ptr += 3;
 299                 *lponoff = 0;
 300         }
 301         else
 302                 return NULL;
 303
 304         return ptr;
 305 }
 306
 307 /***********************************************************************
 308  *           COMM_BuildOldCommDCB   (Internal)
 309  *
 310  *  Build a DCB using the old style settings string eg: "96,n,8,1"
 311  */
 312 static BOOL COMM_BuildOldCommDCB(LPCWSTR device, LPDCB lpdcb)
 313 {
 314         WCHAR last = 0;
 315
 316         if(!(device = COMM_ParseNumber(device, &lpdcb->BaudRate)))
 317                 return FALSE;
 318
 319         switch(lpdcb->BaudRate)
 320         {
 321         case 11:
 322         case 30:
 323         case 60:
 324                 lpdcb->BaudRate *= 10;
 325                 break;
 326         case 12:
 327         case 24:
 328         case 48:
 329         case 96:
 330                 lpdcb->BaudRate *= 100;
 331                 break;
 332         case 19:
 333                 lpdcb->BaudRate = 19200;
 334                 break;
 335         }
 336
 337         while(*device == ' ') device++;
 338         if(*device++ != ',') return FALSE;
 339         while(*device == ' ') device++;
 340
 341         if(!(device = COMM_ParseParity(device, &lpdcb->Parity)))
 342                 return FALSE;
 343
 344         while(*device == ' ') device++;
 345         if(*device++ != ',') return FALSE;
 346         while(*device == ' ') device++;
 347
 348         if(!(device = COMM_ParseByteSize(device, &lpdcb->ByteSize)))
 349                 return FALSE;
 350
 351         while(*device == ' ') device++;
 352         if(*device++ != ',') return FALSE;
 353         while(*device == ' ') device++;
 354
 355         if(!(device = COMM_ParseStopBits(device, &lpdcb->StopBits)))
 356                 return FALSE;
 357
 358         /* The last parameter for flow control is optional. */
 359         while(*device == ' ') device++;
 360         if(*device == ',')
 361         {
 362                 device++;
 363                 while(*device == ' ') device++;
 364                 if(*device) last = toupperW(*device++);
 365                 while(*device == ' ') device++;
 366         }
 367
 368         /* Win NT sets the flow control members based on (or lack of) the last
 369            parameter.  Win 9x does not set these members. */
 370         switch(last)
 371         {
 372         case 0:
 373                 lpdcb->fInX = FALSE;
 374                 lpdcb->fOutX = FALSE;
 375                 lpdcb->fOutxCtsFlow = FALSE;
 376                 lpdcb->fOutxDsrFlow = FALSE;
 377                 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
 378                 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
 379                 break;
 380         case 'X':
 381                 lpdcb->fInX = TRUE;
 382                 lpdcb->fOutX = TRUE;
 383                 lpdcb->fOutxCtsFlow = FALSE;
 384                 lpdcb->fOutxDsrFlow = FALSE;
 385                 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
 386                 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
 387                 break;
 388         case 'P':
 389                 lpdcb->fInX = FALSE;
 390                 lpdcb->fOutX = FALSE;
 391                 lpdcb->fOutxCtsFlow = TRUE;
 392                 lpdcb->fOutxDsrFlow = TRUE;
 393                 lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE;
 394                 lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
 395                 break;
 396         default:
 397                 return FALSE;
 398         }
 399
 400         /* This should be the end of the string. */
 401         if(*device) return FALSE;
 402
 403         return TRUE;
 404 }
 405
 406 /***********************************************************************
 407  *           COMM_BuildNewCommDCB   (Internal)
 408  *
 409  *  Build a DCB using the new style settings string.
 410  *   eg: "baud=9600 parity=n data=8 stop=1 xon=on to=on"
 411  */
 412 static BOOL COMM_BuildNewCommDCB(LPCWSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
 413 {
 414         DWORD temp;
 415         BOOL baud = FALSE, stop = FALSE;
 416         static const WCHAR baudW[] = {'b','a','u','d','=',0};
 417         static const WCHAR parityW[] = {'p','a','r','i','t','y','=',0};
 418         static const WCHAR dataW[] = {'d','a','t','a','=',0};
 419         static const WCHAR stopW[] = {'s','t','o','p','=',0};
 420         static const WCHAR toW[] = {'t','o','=',0};
 421         static const WCHAR xonW[] = {'x','o','n','=',0};
 422         static const WCHAR odsrW[] = {'o','d','s','r','=',0};
 423         static const WCHAR octsW[] = {'o','c','t','s','=',0};
 424         static const WCHAR dtrW[] = {'d','t','r','=',0};
 425         static const WCHAR rtsW[] = {'r','t','s','=',0};
 426         static const WCHAR idsrW[] = {'i','d','s','r','=',0};
 427
 428         while(*device)
 429         {
 430                 while(*device == ' ') device++;
 431
 432                 if(!strncmpiW(baudW, device, 5))
 433                 {
 434                         baud = TRUE;
 435
 436                         if(!(device = COMM_ParseNumber(device + 5, &lpdcb->BaudRate)))
 437                                 return FALSE;
 438                 }
 439                 else if(!strncmpiW(parityW, device, 7))
 440                 {
 441                         if(!(device = COMM_ParseParity(device + 7, &lpdcb->Parity)))
 442                                 return FALSE;
 443                 }
 444                 else if(!strncmpiW(dataW, device, 5))
 445                 {
 446                         if(!(device = COMM_ParseByteSize(device + 5, &lpdcb->ByteSize)))
 447                                 return FALSE;
 448                 }
 449                 else if(!strncmpiW(stopW, device, 5))
 450                 {
 451                         stop = TRUE;
 452
 453                         if(!(device = COMM_ParseStopBits(device + 5, &lpdcb->StopBits)))
 454                                 return FALSE;
 455                 }
 456                 else if(!strncmpiW(toW, device, 3))
 457                 {
 458                         if(!(device = COMM_ParseOnOff(device + 3, &temp)))
 459                                 return FALSE;
 460
 461                         lptimeouts->ReadIntervalTimeout = 0;
 462                         lptimeouts->ReadTotalTimeoutMultiplier = 0;
 463                         lptimeouts->ReadTotalTimeoutConstant = 0;
 464                         lptimeouts->WriteTotalTimeoutMultiplier = 0;
 465                         lptimeouts->WriteTotalTimeoutConstant = temp ? 60000 : 0;
 466                 }
 467                 else if(!strncmpiW(xonW, device, 4))
 468                 {
 469                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 470                                 return FALSE;
 471
 472                         lpdcb->fOutX = temp;
 473                         lpdcb->fInX = temp;
 474                 }
 475                 else if(!strncmpiW(odsrW, device, 5))
 476                 {
 477                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 478                                 return FALSE;
 479
 480                         lpdcb->fOutxDsrFlow = temp;
 481                 }
 482                 else if(!strncmpiW(octsW, device, 5))
 483                 {
 484                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 485                                 return FALSE;
 486
 487                         lpdcb->fOutxCtsFlow = temp;
 488                 }
 489                 else if(!strncmpiW(dtrW, device, 4))
 490                 {
 491                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 492                                 return FALSE;
 493
 494                         lpdcb->fDtrControl = temp;
 495                 }
 496                 else if(!strncmpiW(rtsW, device, 4))
 497                 {
 498                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 499                                 return FALSE;
 500
 501                         lpdcb->fRtsControl = temp;
 502                 }
 503                 else if(!strncmpiW(idsrW, device, 5))
 504                 {
 505                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 506                                 return FALSE;
 507
 508                         /* Win NT sets the fDsrSensitivity member based on the
 509                            idsr parameter.  Win 9x sets fOutxDsrFlow instead. */
 510                         lpdcb->fDsrSensitivity = temp;
 511                 }
 512                 else
 513                         return FALSE;
 514
 515                 /* After the above parsing, the next character (if not the end of
 516                    the string) should be a space */
 517                 if(*device && *device != ' ')
 518                         return FALSE;
 519         }
 520
 521         /* If stop bits were not specified, a default is always supplied. */
 522         if(!stop)
 523         {
 524                 if(baud && lpdcb->BaudRate == 110)
 525                         lpdcb->StopBits = TWOSTOPBITS;
 526                 else
 527                         lpdcb->StopBits = ONESTOPBIT;
 528         }
 529
 530         return TRUE;
 531 }
 532
 533 /**************************************************************************
 534  *         BuildCommDCBA                (KERNEL32.@)
 535  *
 536  *  Updates a device control block data structure with values from an
 537  *  ascii device control string.  The device control string has two forms
 538  *  normal and extended, it must be exclusively in one or the other form.
 539  *
 540  * RETURNS
 541  *
 542  *  True on success, false on a malformed control string.
 543  */
 544 BOOL WINAPI BuildCommDCBA(
 545     LPCSTR device, /* [in] The ascii device control string used to update the DCB. */
 546     LPDCB  lpdcb)  /* [out] The device control block to be updated. */
 547 {
 548         return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
 549 }
 550
 551 /**************************************************************************
 552  *         BuildCommDCBAndTimeoutsA             (KERNEL32.@)
 553  *
 554  *  Updates a device control block data structure with values from an
 555  *  ascii device control string.  Taking timeout values from a timeouts
 556  *  struct if desired by the control string.
 557  *
 558  * RETURNS
 559  *
 560  *  True on success, false bad handles etc.
 561  */
 562 BOOL WINAPI BuildCommDCBAndTimeoutsA(
 563     LPCSTR         device,     /* [in] The ascii device control string. */
 564     LPDCB          lpdcb,      /* [out] The device control block to be updated. */
 565     LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
 566 {
 567         BOOL ret = FALSE;
 568         UNICODE_STRING deviceW;
 569
 570         TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
 571         if(device) RtlCreateUnicodeStringFromAsciiz(&deviceW,device);
 572         else deviceW.Buffer = NULL;
 573
 574         if(deviceW.Buffer) ret = BuildCommDCBAndTimeoutsW(deviceW.Buffer,lpdcb,lptimeouts);
 575
 576         RtlFreeUnicodeString(&deviceW);
 577         return ret;
 578 }
 579
 580 /**************************************************************************
 581  *         BuildCommDCBAndTimeoutsW     (KERNEL32.@)
 582  *
 583  *  Updates a device control block data structure with values from a
 584  *  unicode device control string.  Taking timeout values from a timeouts
 585  *  struct if desired by the control string.
 586  *
 587  * RETURNS
 588  *
 589  *  True on success, false bad handles etc
 590  */
 591 BOOL WINAPI BuildCommDCBAndTimeoutsW(
 592     LPCWSTR        devid,      /* [in] The unicode device control string. */
 593     LPDCB          lpdcb,      /* [out] The device control block to be updated. */
 594     LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
 595 {
 596         DCB dcb;
 597         COMMTIMEOUTS timeouts;
 598         BOOL result;
 599         LPCWSTR ptr = devid;
 600
 601         TRACE("(%s,%p,%p)\n",debugstr_w(devid),lpdcb,lptimeouts);
 602
 603         /* Set DCBlength. (Windows NT does not do this, but 9x does) */
 604         lpdcb->DCBlength = sizeof(DCB);
 605
 606         /* Make a copy of the original data structures to work with since if
 607            if there is an error in the device control string the originals
 608            should not be modified (except possibly DCBlength) */
 609         memcpy(&dcb, lpdcb, sizeof(DCB));
 610         if(lptimeouts) memcpy(&timeouts, lptimeouts, sizeof(COMMTIMEOUTS));
 611
 612         ptr = COMM_ParseStart(ptr);
 613
 614         if(ptr == NULL)
 615                 result = FALSE;
 616         else if(strchrW(ptr, ','))
 617                 result = COMM_BuildOldCommDCB(ptr, &dcb);
 618         else
 619                 result = COMM_BuildNewCommDCB(ptr, &dcb, &timeouts);
 620
 621         if(result)
 622         {
 623                 memcpy(lpdcb, &dcb, sizeof(DCB));
 624                 if(lptimeouts) memcpy(lptimeouts, &timeouts, sizeof(COMMTIMEOUTS));
 625                 return TRUE;
 626         }
 627         else
 628         {
 629                 WARN("Invalid device control string: %s\n", debugstr_w(devid));
 630                 SetLastError(ERROR_INVALID_PARAMETER);
 631                 return FALSE;
 632         }
 633 }
 634
 635 /**************************************************************************
 636  *         BuildCommDCBW                (KERNEL32.@)
 637  *
 638  *  Updates a device control block structure with values from an
 639  *  unicode device control string.  The device control string has two forms
 640  *  normal and extended, it must be exclusively in one or the other form.
 641  *
 642  * RETURNS
 643  *
 644  *  True on success, false on a malformed control string.
 645  */
 646 BOOL WINAPI BuildCommDCBW(
 647     LPCWSTR devid, /* [in] The unicode device control string. */
 648     LPDCB   lpdcb) /* [out] The device control block to be updated. */
 649 {
 650         return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
 651 }
 652
 653 /*****************************************************************************
 654  *      SetCommBreak            (KERNEL32.@)
 655  *
 656  *  Halts the transmission of characters to a communications device.
 657  *
 658  * PARAMS
 659  *      handle  [in] The communications device to suspend
 660  *
 661  * RETURNS
 662  *
 663  *  True on success, and false if the communications device could not be found,
 664  *  the control is not supported.
 665  *
 666  * BUGS
 667  *
 668  *  Only TIOCSBRK and TIOCCBRK are supported.
 669  */
 670 BOOL WINAPI SetCommBreak(HANDLE handle)
 671 {
 672     return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_ON, NULL, 0, NULL, 0, NULL, NULL);
 673 }
 674
 675 /*****************************************************************************
 676  *      ClearCommBreak          (KERNEL32.@)
 677  *
 678  *  Resumes character transmission from a communication device.
 679  *
 680  * PARAMS
 681  *
 682  *      handle [in] The halted communication device whose character transmission is to be resumed
 683  *
 684  * RETURNS
 685  *
 686  *  True on success and false if the communications device could not be found.
 687  *
 688  * BUGS
 689  *
 690  *  Only TIOCSBRK and TIOCCBRK are supported.
 691  */
 692 BOOL WINAPI ClearCommBreak(HANDLE handle)
 693 {
 694     return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_OFF, NULL, 0, NULL, 0, NULL, NULL);
 695 }
 696
 697 /*****************************************************************************
 698  *      EscapeCommFunction      (KERNEL32.@)
 699  *
 700  *  Directs a communication device to perform an extended function.
 701  *
 702  * RETURNS
 703  *
 704  *  True or requested data on successful completion of the command,
 705  *  false if the device is not present cannot execute the command
 706  *  or the command failed.
 707  */
 708 BOOL WINAPI EscapeCommFunction(
 709     HANDLE handle,    /* [in] The communication device to perform the extended function. */
 710     UINT   nFunction) /* [in] The extended function to be performed. */
 711 {
 712         int fd,direct=FALSE,result=FALSE;
 713         struct termios  port;
 714
 715         TRACE("handle %p, function=%d\n", handle, nFunction);
 716         fd = get_comm_fd( handle, FILE_READ_DATA );
 717         if(fd<0) return FALSE;
 718
 719         if (tcgetattr(fd,&port) == -1) {
 720                 release_comm_fd( handle, fd );
 721                 return FALSE;
 722         }
 723
 724         switch (nFunction) {
 725                 case RESETDEV:
 726                         TRACE("\n");
 727                         break;
 728
 729                 case CLRDTR:
 730                         TRACE("CLRDTR\n");
 731 #ifdef TIOCM_DTR
 732                         direct=TRUE;
 733                         result= COMM_WhackModem(fd, ~TIOCM_DTR, 0);
 734                         break;
 735 #endif
 736
 737                 case CLRRTS:
 738                         TRACE("CLRRTS\n");
 739 #ifdef TIOCM_RTS
 740                         direct=TRUE;
 741                         result= COMM_WhackModem(fd, ~TIOCM_RTS, 0);
 742                         break;
 743 #endif
 744
 745                 case SETDTR:
 746                         TRACE("SETDTR\n");
 747 #ifdef TIOCM_DTR
 748                         direct=TRUE;
 749                         result= COMM_WhackModem(fd, 0, TIOCM_DTR);
 750                         break;
 751 #endif
 752
 753                 case SETRTS:
 754                         TRACE("SETRTS\n");
 755 #ifdef TIOCM_RTS
 756                         direct=TRUE;
 757                         result= COMM_WhackModem(fd, 0, TIOCM_RTS);
 758                         break;
 759 #endif
 760
 761                 case SETXOFF:
 762                         TRACE("SETXOFF\n");
 763                         port.c_iflag |= IXOFF;
 764                         break;
 765
 766                 case SETXON:
 767                         TRACE("SETXON\n");
 768                         port.c_iflag |= IXON;
 769                         break;
 770                 case SETBREAK:
 771                         TRACE("setbreak\n");
 772 #ifdef  TIOCSBRK
 773                         direct=TRUE;
 774                         result = ioctl(fd,TIOCSBRK,0);
 775                         break;
 776 #endif
 777                 case CLRBREAK:
 778                         TRACE("clrbreak\n");
 779 #ifdef  TIOCSBRK
 780                         direct=TRUE;
 781                         result = ioctl(fd,TIOCCBRK,0);
 782                         break;
 783 #endif
 784                 default:
 785                         WARN("(handle=%p,nFunction=%d): Unknown function\n",
 786                         handle, nFunction);
 787                         break;
 788         }
 789
 790         if (!direct)
 791           if (tcsetattr(fd, TCSADRAIN, &port) == -1) {
 792                 release_comm_fd( handle, fd );
 793                 return FALSE;
 794           } else
 795                 result= TRUE;
 796         else
 797           {
 798             if (result == -1)
 799               {
 800                 result= FALSE;
 801               }
 802             else
 803               result = TRUE;
 804           }
 805         release_comm_fd( handle, fd );
 806         return result;
 807 }
 808
 809 /********************************************************************
 810  *      PurgeComm        (KERNEL32.@)
 811  *
 812  *  Terminates pending operations and/or discards buffers on a
 813  *  communication resource.
 814  *
 815  * PARAMS
 816  *
 817  *      handle  [in] The communication resource to be purged
 818  *      flags   [in] Flags for clear pending/buffer on input/output
 819  *
 820  * RETURNS
 821  *
 822  *  True on success and false if the communications handle is bad.
 823  */
 824 BOOL WINAPI PurgeComm(HANDLE handle, DWORD flags)
 825 {
 826     return DeviceIoControl(handle, IOCTL_SERIAL_PURGE, &flags, sizeof(flags),
 827                            NULL, 0, NULL, NULL);
 828 }
 829
 830 /*****************************************************************************
 831  *      ClearCommError  (KERNEL32.@)
 832  *
 833  *  Enables further I/O operations on a communications resource after
 834  *  supplying error and current status information.
 835  *
 836  * PARAMS
 837  *
 838  *      handle  [in]    The communication resource with the error
 839  *      errors  [out]   Flags indicating error the resource experienced
 840  *      lpStat  [out] The status of the communication resource
 841  * RETURNS
 842  *
 843  *  True on success, false if the communication resource handle is bad.
 844  */
 845 BOOL WINAPI ClearCommError(HANDLE handle, LPDWORD errors, LPCOMSTAT lpStat)
 846 {
 847     SERIAL_STATUS       ss;
 848
 849     if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_COMMSTATUS, NULL, 0,
 850                          &ss, sizeof(ss), NULL, NULL))
 851         return FALSE;
 852
 853     if (errors)
 854     {
 855         *errors = 0;
 856         if (ss.Errors & SERIAL_ERROR_BREAK)             *errors |= CE_BREAK;
 857         if (ss.Errors & SERIAL_ERROR_FRAMING)           *errors |= CE_FRAME;
 858         if (ss.Errors & SERIAL_ERROR_OVERRUN)           *errors |= CE_OVERRUN;
 859         if (ss.Errors & SERIAL_ERROR_QUEUEOVERRUN)      *errors |= CE_RXOVER;
 860         if (ss.Errors & SERIAL_ERROR_PARITY)            *errors |= CE_RXPARITY;
 861     }
 862
 863     if (lpStat)
 864     {
 865         memset(lpStat, 0, sizeof(*lpStat));
 866
 867         if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_CTS)         lpStat->fCtsHold = TRUE;
 868         if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DSR)         lpStat->fDsrHold = TRUE;
 869         if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DCD)         lpStat->fRlsdHold = TRUE;
 870         if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_XON)         lpStat->fXoffHold = TRUE;
 871         if (ss.HoldReasons & SERIAL_TX_WAITING_XOFF_SENT)       lpStat->fXoffSent = TRUE;
 872         if (ss.EofReceived)                                     lpStat->fEof = TRUE;
 873         if (ss.WaitForImmediate)                                lpStat->fTxim = TRUE;
 874         lpStat->cbInQue = ss.AmountInInQueue;
 875         lpStat->cbOutQue = ss.AmountInOutQueue;
 876     }
 877     return TRUE;
 878 }
 879
 880 /*****************************************************************************
 881  *      SetupComm       (KERNEL32.@)
 882  *
 883  *  Called after CreateFile to hint to the communication resource to use
 884  *  specified sizes for input and output buffers rather than the default values.
 885  *
 886  * RETURNS
 887  *
 888  *  True if successful, false if the communications resource handle is bad.
 889  *
 890  * BUGS
 891  *
 892  *  Stub.
 893  */
 894 BOOL WINAPI SetupComm(
 895     HANDLE handle,  /* [in] The just created communication resource handle. */
 896     DWORD  insize,  /* [in] The suggested size of the communication resources input buffer in bytes. */
 897     DWORD  outsize) /* [in] The suggested size of the communication resources output buffer in bytes. */
 898 {
 899     int fd;
 900
 901     FIXME("insize %ld outsize %ld unimplemented stub\n", insize, outsize);
 902     fd=get_comm_fd( handle, FILE_READ_DATA );
 903     if(0>fd) return FALSE;
 904     release_comm_fd( handle, fd );
 905     return TRUE;
 906 }
 907
 908 /*****************************************************************************
 909  *      GetCommMask     (KERNEL32.@)
 910  *
 911  *  Obtain the events associated with a communication device that will cause
 912  *  a call WaitCommEvent to return.
 913  *
 914  *  PARAMS
 915  *
 916  *      handle  [in]    The communications device
 917  *      evtmask [out]   The events which cause WaitCommEvent to return
 918  *
 919  *  RETURNS
 920  *
 921  *   True on success, fail on bad device handle etc.
 922  */
 923 BOOL WINAPI GetCommMask(HANDLE handle, LPDWORD evtmask)
 924 {
 925     TRACE("handle %p, mask %p\n", handle, evtmask);
 926     return DeviceIoControl(handle, IOCTL_SERIAL_GET_WAIT_MASK,
 927                            NULL, 0, evtmask, sizeof(*evtmask), NULL, NULL);
 928 }
 929
 930 /*****************************************************************************
 931  *      SetCommMask     (KERNEL32.@)
 932  *
 933  *  There be some things we need to hear about yon there communications device.
 934  *  (Set which events associated with a communication device should cause
 935  *  a call WaitCommEvent to return.)
 936  *
 937  * PARAMS
 938  *
 939  *      handle  [in]    The communications device
 940  *      evtmask [in]    The events that are to be monitored
 941  *
 942  * RETURNS
 943  *
 944  *  True on success, false on bad handle etc.
 945  */
 946 BOOL WINAPI SetCommMask(HANDLE handle, DWORD evtmask)
 947 {
 948     TRACE("handle %p, mask %lx\n", handle, evtmask);
 949     return DeviceIoControl(handle, IOCTL_SERIAL_SET_WAIT_MASK,
 950                            &evtmask, sizeof(evtmask), NULL, 0, NULL, NULL);
 951 }
 952
 953 static void dump_dcb(const DCB* lpdcb)
 954 {
 955     TRACE("bytesize=%d baudrate=%ld fParity=%d Parity=%d stopbits=%d\n",
 956           lpdcb->ByteSize, lpdcb->BaudRate, lpdcb->fParity, lpdcb->Parity,
 957           (lpdcb->StopBits == ONESTOPBIT) ? 1 :
 958           (lpdcb->StopBits == TWOSTOPBITS) ? 2 : 0);
 959     TRACE("%sIXON %sIXOFF\n", (lpdcb->fInX) ? "" : "~", (lpdcb->fOutX) ? "" : "~");
 960     TRACE("fOutxCtsFlow=%d fRtsControl=%d\n", lpdcb->fOutxCtsFlow, lpdcb->fRtsControl);
 961     TRACE("fOutxDsrFlow=%d fDtrControl=%d\n", lpdcb->fOutxDsrFlow, lpdcb->fDtrControl);
 962     if (lpdcb->fOutxCtsFlow || lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE)
 963         TRACE("CRTSCTS\n");
 964     else
 965         TRACE("~CRTSCTS\n");
 966 }
 967
 968 /*****************************************************************************
 969  *      SetCommState    (KERNEL32.@)
 970  *
 971  *  Re-initializes all hardware and control settings of a communications device,
 972  *  with values from a device control block without effecting the input and output
 973  *  queues.
 974  *
 975  * PARAMS
 976  *
 977  *      handle  [in]    The communications device
 978  *      lpdcb   [out]   The device control block
 979  *
 980  * RETURNS
 981  *
 982  *  True on success, false on failure eg if the XonChar is equal to the XoffChar.
 983  */
 984 BOOL WINAPI SetCommState( HANDLE handle, LPDCB lpdcb)
 985 {
 986     SERIAL_BAUD_RATE           sbr;
 987     SERIAL_LINE_CONTROL        slc;
 988     SERIAL_HANDFLOW            shf;
 989     SERIAL_CHARS               sc;
 990
 991     if (lpdcb == NULL)
 992     {
 993         SetLastError(ERROR_INVALID_PARAMETER);
 994         return FALSE;
 995     }
 996     dump_dcb(lpdcb);
 997
 998     sbr.BaudRate = lpdcb->BaudRate;
 999
1000     slc.StopBits = lpdcb->StopBits;
1001     slc.Parity = lpdcb->Parity;
1002     slc.WordLength = lpdcb->ByteSize;
1003
1004     shf.ControlHandShake = 0;
1005     shf.FlowReplace = 0;
1006     if (lpdcb->fOutxCtsFlow)      shf.ControlHandShake |= SERIAL_CTS_HANDSHAKE;
1007     if (lpdcb->fOutxDsrFlow)      shf.ControlHandShake |= SERIAL_DSR_HANDSHAKE;
1008     switch (lpdcb->fDtrControl)
1009     {
1010     case DTR_CONTROL_DISABLE:                                                  break;
1011     case DTR_CONTROL_ENABLE:      shf.ControlHandShake |= SERIAL_DTR_CONTROL;  break;
1012     case DTR_CONTROL_HANDSHAKE:   shf.ControlHandShake |= SERIAL_DTR_HANDSHAKE;break;
1013     default:
1014         SetLastError(ERROR_INVALID_PARAMETER);
1015         return FALSE;
1016     }
1017     switch (lpdcb->fDtrControl)
1018     {
1019     case RTS_CONTROL_DISABLE:                                                  break;
1020     case RTS_CONTROL_ENABLE:      shf.FlowReplace |= SERIAL_RTS_CONTROL;       break;
1021     case RTS_CONTROL_HANDSHAKE:   shf.FlowReplace |= SERIAL_RTS_HANDSHAKE;     break;
1022     case RTS_CONTROL_TOGGLE:      shf.FlowReplace |= SERIAL_RTS_CONTROL |
1023                                                      SERIAL_RTS_HANDSHAKE;     break;
1024     default:
1025         SetLastError(ERROR_INVALID_PARAMETER);
1026         return FALSE;
1027     }
1028     if (lpdcb->fDsrSensitivity)   shf.ControlHandShake |= SERIAL_DSR_SENSITIVITY;
1029     if (lpdcb->fAbortOnError)     shf.ControlHandShake |= SERIAL_ERROR_ABORT;
1030
1031     if (lpdcb->fErrorChar)        shf.FlowReplace |= SERIAL_ERROR_CHAR;
1032     if (lpdcb->fNull)             shf.FlowReplace |= SERIAL_NULL_STRIPPING;
1033     if (lpdcb->fTXContinueOnXoff) shf.FlowReplace |= SERIAL_XOFF_CONTINUE;
1034     if (lpdcb->fOutX)             shf.FlowReplace |= SERIAL_AUTO_TRANSMIT;
1035     if (lpdcb->fInX)              shf.FlowReplace |= SERIAL_AUTO_RECEIVE;
1036
1037     shf.XonLimit = lpdcb->XonLim;
1038     shf.XoffLimit = lpdcb->XoffLim;
1039
1040     sc.EofChar = lpdcb->EofChar;
1041     sc.ErrorChar = lpdcb->ErrorChar;
1042     sc.BreakChar = 0;
1043     sc.EventChar = lpdcb->EvtChar;
1044     sc.XonChar = lpdcb->XonChar;
1045     sc.XoffChar = lpdcb->XoffChar;
1046
1047     /* note: change DTR/RTS lines after setting the comm attributes,
1048      * so flow control does not interfere.
1049      */
1050     return (DeviceIoControl(handle, IOCTL_SERIAL_SET_BAUD_RATE,
1051                             &sbr, sizeof(sbr), NULL, 0, NULL, NULL) &&
1052             DeviceIoControl(handle, IOCTL_SERIAL_SET_LINE_CONTROL,
1053                             &slc, sizeof(slc), NULL, 0, NULL, NULL) &&
1054             DeviceIoControl(handle, IOCTL_SERIAL_SET_HANDFLOW,
1055                             &shf, sizeof(shf), NULL, 0, NULL, NULL) &&
1056             DeviceIoControl(handle, IOCTL_SERIAL_SET_CHARS,
1057                             &sc, sizeof(sc), NULL, 0, NULL, NULL));
1058 }
1059
1060
1061 /*****************************************************************************
1062  *      GetCommState    (KERNEL32.@)
1063  *
1064  *  Fills in a device control block with information from a communications device.
1065  *
1066  * PARAMS
1067  *      handle          [in]    The communications device
1068  *      lpdcb           [out]   The device control block
1069  *
1070  * RETURNS
1071  *
1072  *  True on success, false if the communication device handle is bad etc
1073  *
1074  * BUGS
1075  *
1076  *  XonChar and XoffChar are not set.
1077  */
1078 BOOL WINAPI GetCommState(HANDLE handle, LPDCB lpdcb)
1079 {
1080     SERIAL_BAUD_RATE    sbr;
1081     SERIAL_LINE_CONTROL slc;
1082     SERIAL_HANDFLOW     shf;
1083
1084     TRACE("handle %p, ptr %p\n", handle, lpdcb);
1085
1086     if (!lpdcb)
1087     {
1088         SetLastError(ERROR_INVALID_PARAMETER);
1089         return FALSE;
1090     }
1091
1092     if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_BAUD_RATE,
1093                          NULL, 0, &sbr, sizeof(sbr), NULL, NULL) ||
1094         !DeviceIoControl(handle, IOCTL_SERIAL_GET_LINE_CONTROL,
1095                          NULL, 0, &slc, sizeof(slc), NULL, NULL) ||
1096         !DeviceIoControl(handle, IOCTL_SERIAL_GET_HANDFLOW,
1097                          NULL, 0, &shf, sizeof(shf), NULL, NULL))
1098         return FALSE;
1099
1100     memset(lpdcb, 0, sizeof(*lpdcb));
1101     lpdcb->DCBlength = sizeof(*lpdcb);
1102
1103     /* yes, they seem no never be (re)set on NT */
1104     lpdcb->fBinary = 1;
1105     lpdcb->fParity = 0;
1106
1107     lpdcb->BaudRate = sbr.BaudRate;
1108
1109     lpdcb->StopBits = slc.StopBits;
1110     lpdcb->Parity = slc.Parity;
1111     lpdcb->ByteSize = slc.WordLength;
1112
1113     if (shf.ControlHandShake & SERIAL_CTS_HANDSHAKE)    lpdcb->fOutxCtsFlow = 1;
1114     if (shf.ControlHandShake & SERIAL_DSR_HANDSHAKE)    lpdcb->fOutxDsrFlow = 1;
1115     switch (shf.ControlHandShake & (SERIAL_DTR_CONTROL | SERIAL_DTR_HANDSHAKE))
1116     {
1117     case 0:                     lpdcb->fDtrControl = DTR_CONTROL_DISABLE; break;
1118     case SERIAL_DTR_CONTROL:    lpdcb->fDtrControl = DTR_CONTROL_ENABLE; break;
1119     case SERIAL_DTR_HANDSHAKE:  lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE; break;
1120     }
1121     switch (shf.FlowReplace & (SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE))
1122     {
1123     case 0:                     lpdcb->fRtsControl = RTS_CONTROL_DISABLE; break;
1124     case SERIAL_RTS_CONTROL:    lpdcb->fRtsControl = RTS_CONTROL_ENABLE; break;
1125     case SERIAL_RTS_HANDSHAKE:  lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE; break;
1126     case SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE:
1127                                 lpdcb->fRtsControl = RTS_CONTROL_TOGGLE; break;
1128     }
1129     if (shf.ControlHandShake & SERIAL_DSR_SENSITIVITY)  lpdcb->fDsrSensitivity = 1;
1130     if (shf.ControlHandShake & SERIAL_ERROR_ABORT)      lpdcb->fAbortOnError = 1;
1131     if (shf.FlowReplace & SERIAL_ERROR_CHAR)            lpdcb->fErrorChar = 1;
1132     if (shf.FlowReplace & SERIAL_NULL_STRIPPING)        lpdcb->fNull = 1;
1133     if (shf.FlowReplace & SERIAL_XOFF_CONTINUE)         lpdcb->fTXContinueOnXoff = 1;
1134     lpdcb->XonLim = shf.XonLimit;
1135     lpdcb->XoffLim = shf.XoffLimit;
1136
1137     if (shf.FlowReplace & SERIAL_AUTO_TRANSMIT) lpdcb->fOutX = 1;
1138     if (shf.FlowReplace & SERIAL_AUTO_RECEIVE)  lpdcb->fInX = 1;
1139
1140 /*
1141         lpdcb->XonChar =
1142         lpdcb->XoffChar =
1143  */
1144
1145     TRACE("OK\n");
1146     dump_dcb(lpdcb);
1147
1148     return TRUE;
1149 }
1150
1151 /*****************************************************************************
1152  *      TransmitCommChar        (KERNEL32.@)
1153  *
1154  *  Transmits a single character in front of any pending characters in the
1155  *  output buffer.  Usually used to send an interrupt character to a host.
1156  *
1157  * PARAMS
1158  *      hComm           [in]    The communication device in need of a command character
1159  *      chTransmit      [in]    The character to transmit
1160  *
1161  * RETURNS
1162  *
1163  *  True if the call succeeded, false if the previous command character to the
1164  *  same device has not been sent yet the handle is bad etc.
1165  *
1166  */
1167 BOOL WINAPI TransmitCommChar(HANDLE hComm, CHAR chTransmit)
1168 {
1169     return DeviceIoControl(hComm, IOCTL_SERIAL_IMMEDIATE_CHAR,
1170                            &chTransmit, sizeof(chTransmit), NULL, 0, NULL, NULL);
1171 }
1172
1173
1174 /*****************************************************************************
1175  *      GetCommTimeouts         (KERNEL32.@)
1176  *
1177  *  Obtains the request timeout values for the communications device.
1178  *
1179  * RETURNS
1180  *
1181  *  True on success, false if communications device handle is bad
1182  *  or the target structure is null.
1183  */
1184 BOOL WINAPI GetCommTimeouts(
1185     HANDLE         hComm,      /* [in] The communications device. */
1186     LPCOMMTIMEOUTS lptimeouts) /* [out] The struct of request timeouts. */
1187 {
1188     BOOL ret;
1189
1190     TRACE("(%p,%p)\n",hComm,lptimeouts);
1191
1192     if(!lptimeouts)
1193     {
1194         SetLastError(ERROR_INVALID_PARAMETER);
1195         return FALSE;
1196     }
1197
1198     SERVER_START_REQ( get_serial_info )
1199     {
1200         req->handle = hComm;
1201         if ((ret = !wine_server_call_err( req )))
1202         {
1203             lptimeouts->ReadIntervalTimeout         = reply->readinterval;
1204             lptimeouts->ReadTotalTimeoutMultiplier  = reply->readmult;
1205             lptimeouts->ReadTotalTimeoutConstant    = reply->readconst;
1206             lptimeouts->WriteTotalTimeoutMultiplier = reply->writemult;
1207             lptimeouts->WriteTotalTimeoutConstant   = reply->writeconst;
1208         }
1209     }
1210     SERVER_END_REQ;
1211     return ret;
1212 }
1213
1214 /*****************************************************************************
1215  *      SetCommTimeouts         (KERNEL32.@)
1216  *
1217  * Sets the timeouts used when reading and writing data to/from COMM ports.
1218  *
1219  * ReadIntervalTimeout
1220  *     - converted and passes to linux kernel as c_cc[VTIME]
1221  * ReadTotalTimeoutMultiplier, ReadTotalTimeoutConstant
1222  *     - used in ReadFile to calculate GetOverlappedResult's timeout
1223  * WriteTotalTimeoutMultiplier, WriteTotalTimeoutConstant
1224  *     - used in WriteFile to calculate GetOverlappedResult's timeout
1225  *
1226  * RETURNS
1227  *
1228  *  True if the timeouts were set, false otherwise.
1229  */
1230 BOOL WINAPI SetCommTimeouts(
1231     HANDLE hComm,              /* [in] handle of COMM device */
1232     LPCOMMTIMEOUTS lptimeouts) /* [in] pointer to COMMTIMEOUTS structure */
1233 {
1234     BOOL ret;
1235     int fd;
1236     struct termios tios;
1237
1238     TRACE("(%p,%p)\n",hComm,lptimeouts);
1239
1240     if(!lptimeouts)
1241     {
1242         SetLastError(ERROR_INVALID_PARAMETER);
1243         return FALSE;
1244     }
1245
1246     SERVER_START_REQ( set_serial_info )
1247     {
1248         req->handle       = hComm;
1249         req->flags        = SERIALINFO_SET_TIMEOUTS;
1250         req->readinterval = lptimeouts->ReadIntervalTimeout ;
1251         req->readmult     = lptimeouts->ReadTotalTimeoutMultiplier ;
1252         req->readconst    = lptimeouts->ReadTotalTimeoutConstant ;
1253         req->writemult    = lptimeouts->WriteTotalTimeoutMultiplier ;
1254         req->writeconst   = lptimeouts->WriteTotalTimeoutConstant ;
1255         ret = !wine_server_call_err( req );
1256     }
1257     SERVER_END_REQ;
1258     if (!ret) return FALSE;
1259
1260     /* FIXME: move this stuff to the server */
1261     fd = get_comm_fd( hComm, FILE_READ_DATA );
1262     if (fd < 0) return FALSE;
1263
1264     if (-1==tcgetattr(fd,&tios)) {
1265         FIXME("tcgetattr on fd %d failed!\n",fd);
1266         release_comm_fd( hComm, fd );
1267         return FALSE;
1268     }
1269
1270     /* VTIME is in 1/10 seconds */
1271         {
1272                 unsigned int ux_timeout;
1273
1274                 if(lptimeouts->ReadIntervalTimeout == 0) /* 0 means no timeout */
1275                 {
1276                         ux_timeout = 0;
1277                 }
1278                 else
1279                 {
1280                         ux_timeout = (lptimeouts->ReadIntervalTimeout+99)/100;
1281                         if(ux_timeout == 0)
1282                         {
1283                                 ux_timeout = 1; /* must be at least some timeout */
1284                         }
1285                 }
1286                 tios.c_cc[VTIME] = ux_timeout;
1287         }
1288
1289     if (-1==tcsetattr(fd,0,&tios)) {
1290         FIXME("tcsetattr on fd %d failed!\n",fd);
1291         release_comm_fd( hComm, fd );
1292         return FALSE;
1293     }
1294     release_comm_fd( hComm, fd );
1295     return TRUE;
1296 }
1297
1298 /***********************************************************************
1299  *           GetCommModemStatus   (KERNEL32.@)
1300  *
1301  *  Obtains the four control register bits if supported by the hardware.
1302  *
1303  * PARAMS
1304  *
1305  *      hFile           [in]    The communications device
1306  *      lpModemStat     [out]   The control register bits
1307  *
1308  * RETURNS
1309  *
1310  *  True if the communications handle was good and for hardware that
1311  *  control register access, false otherwise.
1312  */
1313 BOOL WINAPI GetCommModemStatus(HANDLE hFile, LPDWORD lpModemStat)
1314 {
1315     return DeviceIoControl(hFile, IOCTL_SERIAL_GET_MODEMSTATUS,
1316                            NULL, 0, lpModemStat, sizeof(DWORD), NULL, NULL);
1317 }
1318
1319 static DWORD WINAPI Comm_CheckEvents(int fd, DWORD mask, serial_irq_info *new, serial_irq_info *old, DWORD new_mstat, DWORD old_mstat)
1320 {
1321     DWORD ret = 0, queue;
1322
1323     TRACE("mask 0x%08lx\n", mask);
1324     TRACE("old->rx          0x%08x vs. new->rx          0x%08x\n", old->rx, new->rx);
1325     TRACE("old->tx          0x%08x vs. new->tx          0x%08x\n", old->tx, new->tx);
1326     TRACE("old->frame       0x%08x vs. new->frame       0x%08x\n", old->frame, new->frame);
1327     TRACE("old->overrun     0x%08x vs. new->overrun     0x%08x\n", old->overrun, new->overrun);
1328     TRACE("old->parity      0x%08x vs. new->parity      0x%08x\n", old->parity, new->parity);
1329     TRACE("old->brk         0x%08x vs. new->brk         0x%08x\n", old->brk, new->brk);
1330     TRACE("old->buf_overrun 0x%08x vs. new->buf_overrun 0x%08x\n", old->buf_overrun, new->buf_overrun);
1331
1332     ret |= ((mask & EV_BREAK) && ( old->brk != new->brk))?EV_BREAK:0;
1333     ret |= ((mask & EV_CTS  ) && ((old_mstat&MS_CTS_ON )!=(new_mstat&MS_CTS_ON )))?EV_CTS  :0;
1334     ret |= ((mask & EV_DSR  ) && ((old_mstat&MS_DSR_ON )!=(new_mstat&MS_DSR_ON )))?EV_DSR  :0;
1335     ret |= ((mask & EV_RING ) && ((old_mstat&MS_RING_ON)!=(new_mstat&MS_RING_ON)))?EV_RING :0;
1336     ret |= ((mask & EV_RLSD ) && ((old_mstat&MS_RLSD_ON)!=(new_mstat&MS_RLSD_ON)))?EV_RLSD :0;
1337     ret |= ((mask & EV_ERR  ) && (( old->frame != new->frame) ||(old->overrun != new->overrun)
1338                 || (old->parity != new->parity)) )?EV_ERR  :0;
1339     if (mask & EV_RXCHAR)
1340     {
1341         queue = 0;
1342 #ifdef TIOCINQ
1343         if(ioctl(fd, TIOCINQ, &queue))
1344             WARN("TIOCINQ returned error\n");
1345 #endif
1346         if (queue)
1347             ret |= EV_RXCHAR;
1348     }
1349     if (mask & EV_TXEMPTY)
1350     {
1351         queue = 0;
1352 /* We really want to know when all characters have gone out of the transmitter */
1353 #if defined(TIOCSERGETLSR)
1354         if(ioctl(fd, TIOCSERGETLSR, &queue))
1355             WARN("TIOCSERGETLSR returned error\n");
1356         if (queue)
1357 /* TIOCINQ only checks for an empty buffer */
1358 #elif defined(TIOCINQ)
1359         if(ioctl(fd, TIOCOUTQ, &queue))
1360             WARN("TIOCOUTQ returned error\n");
1361         if (!queue)
1362 #endif
1363            ret |= EV_TXEMPTY;
1364     }
1365     TRACE("OUTQUEUE %ld, Transmitter %sempty\n", queue, (ret & EV_TXEMPTY)?"":"not ");
1366     return ret;
1367
1368 }
1369
1370 /***********************************************************************
1371  *             COMM_WaitCommEventService      (INTERNAL)
1372  *
1373  *  We need to poll for what is interesting
1374  *  TIOCMIWAIT only checks modem status line and may not be aborted by a changing mask
1375  *
1376  */
1377 static DWORD WINAPI COMM_WaitCommEventService(LPVOID arg)
1378 {
1379     async_commio *commio = (async_commio*) arg;
1380     int waitmask = 0;
1381     int rc, fd, abort;
1382     serial_irq_info new_irq_info;
1383     DWORD new_mstat, new_evtmask;
1384
1385     fd=get_comm_fd( commio->handle, FILE_READ_DATA );
1386
1387     TRACE("handle %p fd 0x%08x, mask 0x%08lx buffer %p event %p irq_info %p waitmask 0x%08x\n",
1388           commio->handle, fd, commio->evtmask, commio->buffer, commio->hEvent, &commio->irq_info, waitmask);
1389     do
1390     {
1391         /*
1392          * TIOCMIWAIT is not adequate
1393          *
1394          * FIXME:
1395          * We don't handle the EV_RXFLAG (the eventchar)
1396          */
1397         Sleep(1);
1398         rc= COMM_GetEInfo(fd,&new_irq_info);
1399         if (rc)
1400             TRACE("TIOCGICOUNT err %s\n", strerror(errno));
1401         rc = GetCommModemStatus(commio->handle, &new_mstat);
1402         if (!rc)
1403             TRACE("GetCommModemStatus failed\n");
1404         rc = Comm_CheckEvents(fd, commio->evtmask,&new_irq_info,&commio->irq_info, new_mstat, commio->mstat);
1405         GetCommMask(commio->handle, &new_evtmask);
1406         abort = (commio->evtmask != new_evtmask);
1407         TRACE("resulting Eventmask 0x%08x\n", rc);
1408     } while (!rc && ! abort);
1409     if (abort) rc = 0;
1410     release_comm_fd( commio->handle, fd );
1411     *commio->buffer = rc;
1412     if (commio->hEvent != INVALID_HANDLE_VALUE )
1413         NtSetEvent( commio->hEvent, NULL );
1414     HeapFree(GetProcessHeap(), 0, commio );
1415     return 0;
1416 }
1417
1418
1419 /***********************************************************************
1420  *             COMM_WaitCommEvent         (INTERNAL)
1421  *
1422  *  This function must have an lpOverlapped.
1423  */
1424 static BOOL COMM_WaitCommEvent(
1425     HANDLE hFile,              /* [in] handle of comm port to wait for */
1426     LPDWORD lpdwEvents,        /* [out] event(s) that were detected */
1427     LPOVERLAPPED lpOverlapped) /* [in/out] for Asynchronous waiting */
1428 {
1429     int                 fd;
1430     async_commio*       commio;
1431     DWORD               result_mask;
1432     BOOL res;
1433
1434     if (!lpOverlapped)
1435     {
1436         SetLastError(ERROR_INVALID_PARAMETER);
1437         return FALSE;
1438     }
1439
1440     if (NtResetEvent(lpOverlapped->hEvent,NULL))
1441         return FALSE;
1442
1443     fd = get_comm_fd( hFile, FILE_WRITE_DATA );
1444     if (fd < 0) return FALSE;
1445
1446     commio = HeapAlloc(GetProcessHeap(), 0, sizeof (async_commio));
1447     if (!commio)
1448     {
1449         release_comm_fd( hFile, fd );
1450         return FALSE;
1451     }
1452
1453     commio->handle = hFile;
1454     commio->buffer = (char *)lpdwEvents;
1455     commio->hEvent = lpOverlapped->hEvent;
1456     GetCommMask(hFile, &commio->evtmask);
1457
1458 /* We may never return, if some capabilities miss
1459  * Return error in that case
1460  */
1461 #if !defined(TIOCINQ)
1462     if(commio->evtmask & EV_RXCHAR)
1463         goto error;
1464 #endif
1465 #if !(defined(TIOCSERGETLSR) && defined(TIOCSER_TEMT)) || !defined(TIOCINQ)
1466     if(commio->evtmask & EV_TXEMPTY)
1467         goto error;
1468 #endif
1469 #if !defined(TIOCMGET)
1470     if(commio->evtmask & (EV_CTS | EV_DSR| EV_RING| EV_RLSD))
1471         goto error;
1472 #endif
1473 #if !defined(TIOCM_CTS)
1474     if(commio->evtmask & EV_CTS)
1475         goto error;
1476 #endif
1477 #if !defined(TIOCM_DSR)
1478     if(commio->evtmask & EV_DSR)
1479         goto error;
1480 #endif
1481 #if !defined(TIOCM_RNG)
1482     if(commio->evtmask & EV_RING)
1483         goto error;
1484 #endif
1485 #if !defined(TIOCM_CAR)
1486     if(commio->evtmask & EV_RLSD)
1487         goto error;
1488 #endif
1489     if(commio->evtmask & EV_RXFLAG)
1490         FIXME("EV_RXFLAG not handled\n");
1491     COMM_GetEInfo(fd,&commio->irq_info);
1492     GetCommModemStatus(hFile, &commio->mstat);
1493     /* We might have received something or the TX bufffer is delivered*/
1494     result_mask = Comm_CheckEvents( fd, commio->evtmask, &commio->irq_info, &commio->irq_info,commio->mstat,commio->mstat);
1495     if (result_mask)
1496     {
1497         TRACE("Event already met\n");
1498         *lpdwEvents = result_mask;
1499         HeapFree(GetProcessHeap(), 0, commio );
1500         res = TRUE;
1501     }
1502     else
1503     {
1504         CreateThread(NULL, 0, COMM_WaitCommEventService, (LPVOID)commio, 0, NULL);
1505         SetLastError(ERROR_IO_PENDING);
1506         res = FALSE;
1507     }
1508     release_comm_fd( hFile, fd );
1509     return res;
1510 #if !defined(TIOCINQ) || (!(defined(TIOCSERGETLSR) && defined(TIOCSER_TEMT)) || !defined(TIOCINQ)) || !defined(TIOCMGET) || !defined(TIOCM_CTS) ||!defined(TIOCM_DSR) || !defined(TIOCM_RNG) || !defined(TIOCM_CAR)
1511  error:
1512     FIXME("Returning error because of missing capabilities\n");
1513     release_comm_fd( hFile, fd );
1514     HeapFree(GetProcessHeap(), 0, commio );
1515     SetLastError(ERROR_INVALID_PARAMETER);
1516     return FALSE;
1517 #endif
1518 }
1519 /***********************************************************************
1520  *           WaitCommEvent   (KERNEL32.@)
1521  *
1522  * Wait until something interesting happens on a COMM port.
1523  * Interesting things (events) are set by calling SetCommMask before
1524  * this function is called.
1525  *
1526  * RETURNS
1527  *   TRUE if successful
1528  *   FALSE if failure
1529  *
1530  *   The set of detected events will be written to *lpdwEventMask
1531  *   ERROR_IO_PENDING will be returned the overlapped structure was passed
1532  *
1533  * BUGS:
1534  *  Only supports EV_RXCHAR and EV_TXEMPTY
1535  */
1536 BOOL WINAPI WaitCommEvent(
1537     HANDLE hFile,              /* [in] handle of comm port to wait for */
1538     LPDWORD lpdwEvents,        /* [out] event(s) that were detected */
1539     LPOVERLAPPED lpOverlapped) /* [in/out] for Asynchronous waiting */
1540 {
1541     OVERLAPPED ov;
1542     int ret = 0;
1543     DWORD res, err;
1544
1545     TRACE("(%p %p %p )\n",hFile, lpdwEvents,lpOverlapped);
1546
1547     if(lpOverlapped)
1548         return COMM_WaitCommEvent(hFile, lpdwEvents, lpOverlapped);
1549
1550     /* if there is no overlapped structure, create our own */
1551     ov.hEvent = CreateEventW(NULL,FALSE,FALSE,NULL);
1552
1553     res = COMM_WaitCommEvent(hFile, lpdwEvents, &ov);
1554     err = GetLastError();
1555     if (!res)
1556     {
1557         if (err == ERROR_IO_PENDING)
1558         {
1559             do
1560             {
1561                 res = WaitForSingleObjectEx(ov.hEvent, INFINITE, FALSE);
1562             } while (res != WAIT_OBJECT_0);
1563             TRACE("Event met\n:");
1564             ret = TRUE;
1565         }
1566         else
1567         {
1568             FIXME("Unknown error 0x%08lx\n", err);
1569             ret = FALSE;
1570         }
1571     }
1572     else
1573         ret = TRUE;
1574     CloseHandle(ov.hEvent);
1575
1576     return ret;
1577 }
1578
1579 /***********************************************************************
1580  *           GetCommProperties   (KERNEL32.@)
1581  *
1582  * This function fills in a structure with the capabilities of the
1583  * communications port driver.
1584  *
1585  * RETURNS
1586  *
1587  *  TRUE on success, FALSE on failure
1588  *  If successful, the lpCommProp structure be filled in with
1589  *  properties of the comm port.
1590  */
1591 BOOL WINAPI GetCommProperties(
1592     HANDLE hFile,          /* [in] handle of the comm port */
1593     LPCOMMPROP lpCommProp) /* [out] pointer to struct to be filled */
1594 {
1595     FIXME("(%p %p )\n",hFile,lpCommProp);
1596     if(!lpCommProp)
1597         return FALSE;
1598
1599     /*
1600      * These values should be valid for LINUX's serial driver
1601      * FIXME: Perhaps they deserve an #ifdef LINUX
1602      */
1603     memset(lpCommProp,0,sizeof(COMMPROP));
1604     lpCommProp->wPacketLength       = 1;
1605     lpCommProp->wPacketVersion      = 1;
1606     lpCommProp->dwServiceMask       = SP_SERIALCOMM;
1607     lpCommProp->dwReserved1         = 0;
1608     lpCommProp->dwMaxTxQueue        = 4096;
1609     lpCommProp->dwMaxRxQueue        = 4096;
1610     lpCommProp->dwMaxBaud           = BAUD_115200;
1611     lpCommProp->dwProvSubType       = PST_RS232;
1612     lpCommProp->dwProvCapabilities  = PCF_DTRDSR | PCF_PARITY_CHECK | PCF_RTSCTS | PCF_TOTALTIMEOUTS;
1613     lpCommProp->dwSettableParams    = SP_BAUD | SP_DATABITS | SP_HANDSHAKING |
1614                                       SP_PARITY | SP_PARITY_CHECK | SP_STOPBITS ;
1615     lpCommProp->dwSettableBaud      = BAUD_075 | BAUD_110 | BAUD_134_5 | BAUD_150 |
1616                 BAUD_300 | BAUD_600 | BAUD_1200 | BAUD_1800 | BAUD_2400 | BAUD_4800 |
1617                 BAUD_9600 | BAUD_19200 | BAUD_38400 | BAUD_57600 | BAUD_115200 ;
1618     lpCommProp->wSettableData       = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8 ;
1619     lpCommProp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
1620                 PARITY_NONE | PARITY_ODD |PARITY_EVEN | PARITY_MARK | PARITY_SPACE;
1621     lpCommProp->dwCurrentTxQueue    = lpCommProp->dwMaxTxQueue;
1622     lpCommProp->dwCurrentRxQueue    = lpCommProp->dwMaxRxQueue;
1623
1624     return TRUE;
1625 }
1626
1627 /***********************************************************************
1628  * FIXME:
1629  * The functionality of CommConfigDialogA, GetDefaultCommConfig and
1630  * SetDefaultCommConfig is implemented in a DLL (usually SERIALUI.DLL).
1631  * This is dependent on the type of COMM port, but since it is doubtful
1632  * anybody will get around to implementing support for fancy serial
1633  * ports in WINE, this is hardcoded for the time being.  The name of
1634  * this DLL should be stored in and read from the system registry in
1635  * the hive HKEY_LOCAL_MACHINE, key
1636  * System\\CurrentControlSet\\Services\\Class\\Ports\\????
1637  * where ???? is the port number... that is determined by PNP
1638  * The DLL should be loaded when the COMM port is opened, and closed
1639  * when the COMM port is closed. - MJM 20 June 2000
1640  ***********************************************************************/
1641 static const WCHAR lpszSerialUI[] = {
1642    's','e','r','i','a','l','u','i','.','d','l','l',0 };
1643
1644
1645 /***********************************************************************
1646  *           CommConfigDialogA   (KERNEL32.@)
1647  *
1648  * Raises a dialog that allows the user to configure a comm port.
1649  * Fills the COMMCONFIG struct with information specified by the user.
1650  * This function should call a similar routine in the COMM driver...
1651  *
1652  * RETURNS
1653  *
1654  *  TRUE on success, FALSE on failure
1655  *  If successful, the lpCommConfig structure will contain a new
1656  *  configuration for the comm port, as specified by the user.
1657  *
1658  * BUGS
1659  *  The library with the CommConfigDialog code is never unloaded.
1660  * Perhaps this should be done when the comm port is closed?
1661  */
1662 BOOL WINAPI CommConfigDialogA(
1663     LPCSTR lpszDevice,         /* [in] name of communications device */
1664     HWND hWnd,                 /* [in] parent window for the dialog */
1665     LPCOMMCONFIG lpCommConfig) /* [out] pointer to struct to fill */
1666 {
1667     FARPROC lpfnCommDialog;
1668     HMODULE hConfigModule;
1669     BOOL r = FALSE;
1670
1671     TRACE("(%p %p %p)\n",lpszDevice, hWnd, lpCommConfig);
1672
1673     hConfigModule = LoadLibraryW(lpszSerialUI);
1674     if(!hConfigModule)
1675         return FALSE;
1676
1677     lpfnCommDialog = GetProcAddress(hConfigModule, "drvCommConfigDialogA");
1678
1679     if(lpfnCommDialog)
1680         r = lpfnCommDialog(lpszDevice,hWnd,lpCommConfig);
1681
1682     FreeLibrary(hConfigModule);
1683
1684     return r;
1685 }
1686
1687 /***********************************************************************
1688  *           CommConfigDialogW   (KERNEL32.@)
1689  *
1690  * See CommConfigDialogA.
1691  */
1692 BOOL WINAPI CommConfigDialogW(
1693     LPCWSTR lpszDevice,        /* [in] name of communications device */
1694     HWND hWnd,                 /* [in] parent window for the dialog */
1695     LPCOMMCONFIG lpCommConfig) /* [out] pointer to struct to fill */
1696 {
1697     FARPROC lpfnCommDialog;
1698     HMODULE hConfigModule;
1699     BOOL r = FALSE;
1700
1701     TRACE("(%p %p %p)\n",lpszDevice, hWnd, lpCommConfig);
1702
1703     hConfigModule = LoadLibraryW(lpszSerialUI);
1704     if(!hConfigModule)
1705         return FALSE;
1706
1707     lpfnCommDialog = GetProcAddress(hConfigModule, "drvCommConfigDialogW");
1708
1709     if(lpfnCommDialog)
1710         r = lpfnCommDialog(lpszDevice,hWnd,lpCommConfig);
1711
1712     FreeLibrary(hConfigModule);
1713
1714     return r;
1715 }
1716
1717 /***********************************************************************
1718  *           GetCommConfig     (KERNEL32.@)
1719  *
1720  * Fill in the COMMCONFIG structure for the comm port hFile
1721  *
1722  * RETURNS
1723  *
1724  *  TRUE on success, FALSE on failure
1725  *  If successful, lpCommConfig contains the comm port configuration.
1726  *
1727  * BUGS
1728  *
1729  */
1730 BOOL WINAPI GetCommConfig(
1731     HANDLE       hFile,        /* [in] The communications device. */
1732     LPCOMMCONFIG lpCommConfig, /* [out] The communications configuration of the device (if it fits). */
1733     LPDWORD      lpdwSize)     /* [in/out] Initially the size of the configuration buffer/structure,
1734                                   afterwards the number of bytes copied to the buffer or
1735                                   the needed size of the buffer. */
1736 {
1737     BOOL r;
1738
1739     TRACE("(%p %p)\n",hFile,lpCommConfig);
1740
1741     if(lpCommConfig == NULL)
1742         return FALSE;
1743     r = *lpdwSize < sizeof(COMMCONFIG); /* TRUE if not enough space */
1744     *lpdwSize = sizeof(COMMCONFIG);
1745     if(r)
1746         return FALSE;
1747
1748     lpCommConfig->dwSize = sizeof(COMMCONFIG);
1749     lpCommConfig->wVersion = 1;
1750     lpCommConfig->wReserved = 0;
1751     r = GetCommState(hFile,&lpCommConfig->dcb);
1752     lpCommConfig->dwProviderSubType = PST_RS232;
1753     lpCommConfig->dwProviderOffset = 0;
1754     lpCommConfig->dwProviderSize = 0;
1755
1756     return r;
1757 }
1758
1759 /***********************************************************************
1760  *           SetCommConfig     (KERNEL32.@)
1761  *
1762  *  Sets the configuration of the communications device.
1763  *
1764  * RETURNS
1765  *
1766  *  True on success, false if the handle was bad is not a communications device.
1767  */
1768 BOOL WINAPI SetCommConfig(
1769     HANDLE       hFile,         /* [in] The communications device. */
1770     LPCOMMCONFIG lpCommConfig,  /* [in] The desired configuration. */
1771     DWORD dwSize)               /* [in] size of the lpCommConfig struct */
1772 {
1773     TRACE("(%p %p)\n",hFile,lpCommConfig);
1774     return SetCommState(hFile,&lpCommConfig->dcb);
1775 }
1776
1777 /***********************************************************************
1778  *           SetDefaultCommConfigA   (KERNEL32.@)
1779  *
1780  *  Initializes the default configuration for the specified communication
1781  *  device. (ascii)
1782  *
1783  * RETURNS
1784  *
1785  *  True if the device was found and the defaults set, false otherwise
1786  */
1787 BOOL WINAPI SetDefaultCommConfigW(
1788     LPCWSTR       lpszDevice,  /* [in] The ascii name of the device targeted for configuration. */
1789     LPCOMMCONFIG lpCommConfig, /* [in] The default configuration for the device. */
1790     DWORD        dwSize)       /* [in] The number of bytes in the configuration structure. */
1791 {
1792     FARPROC lpfnSetDefaultCommConfig;
1793     HMODULE hConfigModule;
1794     BOOL r = FALSE;
1795
1796     TRACE("(%p %p %lx)\n",lpszDevice, lpCommConfig, dwSize);
1797
1798     hConfigModule = LoadLibraryW(lpszSerialUI);
1799     if(!hConfigModule)
1800         return r;
1801
1802     lpfnSetDefaultCommConfig = GetProcAddress(hConfigModule, "drvSetDefaultCommConfigW");
1803     if (lpfnSetDefaultCommConfig)
1804         r = lpfnSetDefaultCommConfig(lpszDevice, lpCommConfig, dwSize);
1805
1806     FreeLibrary(hConfigModule);
1807
1808     return r;
1809 }
1810
1811
1812 /***********************************************************************
1813  *           SetDefaultCommConfigW     (KERNEL32.@)
1814  *
1815  *  Initializes the default configuration for the specified
1816  *  communication device. (unicode)
1817  *
1818  * RETURNS
1819  *
1820  */
1821 BOOL WINAPI SetDefaultCommConfigA(
1822     LPCSTR      lpszDevice,    /* [in] The unicode name of the device targeted for configuration. */
1823     LPCOMMCONFIG lpCommConfig, /* [in] The default configuration for the device. */
1824     DWORD        dwSize)       /* [in] The number of bytes in the configuration structure. */
1825 {
1826     BOOL r;
1827     LPWSTR lpDeviceW = NULL;
1828     DWORD len;
1829
1830     TRACE("(%s %p %lx)\n",debugstr_a(lpszDevice),lpCommConfig,dwSize);
1831
1832     if (lpszDevice)
1833     {
1834         len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
1835         lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1836         MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
1837     }
1838     r = SetDefaultCommConfigW(lpDeviceW,lpCommConfig,dwSize);
1839     HeapFree( GetProcessHeap(), 0, lpDeviceW );
1840     return r;
1841 }
1842
1843
1844 /***********************************************************************
1845  *           GetDefaultCommConfigW   (KERNEL32.@)
1846  *
1847  *   Acquires the default configuration of the specified communication device. (unicode)
1848  *
1849  *  RETURNS
1850  *
1851  *   True on successful reading of the default configuration,
1852  *   if the device is not found or the buffer is too small.
1853  */
1854 BOOL WINAPI GetDefaultCommConfigW(
1855     LPCWSTR      lpszName, /* [in] The unicode name of the device targeted for configuration. */
1856     LPCOMMCONFIG lpCC,     /* [out] The default configuration for the device. */
1857     LPDWORD      lpdwSize) /* [in/out] Initially the size of the default configuration buffer,
1858                               afterwards the number of bytes copied to the buffer or
1859                               the needed size of the buffer. */
1860 {
1861      LPDCB lpdcb = &(lpCC->dcb);
1862      WCHAR temp[40];
1863      static const WCHAR comW[] = {'C','O','M',0};
1864      static const WCHAR formatW[] = {'C','O','M','%','c',':','3','8','4','0','0',',','n',',','8',',','1',0};
1865
1866      if (strncmpiW(lpszName,comW,3)) {
1867         ERR("not implemented for <%s>\n", debugstr_w(lpszName));
1868         return FALSE;
1869      }
1870
1871      TRACE("(%s %p %ld)\n", debugstr_w(lpszName), lpCC, *lpdwSize );
1872      if (*lpdwSize < sizeof(COMMCONFIG)) {
1873          *lpdwSize = sizeof(COMMCONFIG);
1874          return FALSE;
1875        }
1876
1877      *lpdwSize = sizeof(COMMCONFIG);
1878
1879      lpCC->dwSize = sizeof(COMMCONFIG);
1880      lpCC->wVersion = 1;
1881      lpCC->dwProviderSubType = PST_RS232;
1882      lpCC->dwProviderOffset = 0L;
1883      lpCC->dwProviderSize = 0L;
1884
1885      sprintfW( temp, formatW, lpszName[3]);
1886      FIXME("setting %s as default\n", debugstr_w(temp));
1887
1888      return BuildCommDCBW( temp, lpdcb);
1889 }
1890
1891 /**************************************************************************
1892  *         GetDefaultCommConfigA                (KERNEL32.@)
1893  *
1894  *   Acquires the default configuration of the specified communication device. (ascii)
1895  *
1896  *  RETURNS
1897  *
1898  *   True on successful reading of the default configuration,
1899  *   if the device is not found or the buffer is too small.
1900  */
1901 BOOL WINAPI GetDefaultCommConfigA(
1902     LPCSTR       lpszName, /* [in] The ascii name of the device targeted for configuration. */
1903     LPCOMMCONFIG lpCC,     /* [out] The default configuration for the device. */
1904     LPDWORD      lpdwSize) /* [in/out] Initially the size of the default configuration buffer,
1905                               afterwards the number of bytes copied to the buffer or
1906                               the needed size of the buffer. */
1907 {
1908         BOOL ret = FALSE;
1909         UNICODE_STRING lpszNameW;
1910
1911         TRACE("(%s,%p,%ld)\n",lpszName,lpCC,*lpdwSize);
1912         if(lpszName) RtlCreateUnicodeStringFromAsciiz(&lpszNameW,lpszName);
1913         else lpszNameW.Buffer = NULL;
1914
1915         if(lpszNameW.Buffer) ret = GetDefaultCommConfigW(lpszNameW.Buffer,lpCC,lpdwSize);
1916
1917         RtlFreeUnicodeString(&lpszNameW);
1918         return ret;
1919 }