dlls/kernel32/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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "winioctl.h"
  32 #include "ddk/ntddser.h"
  33
  34 #include "wine/server.h"
  35 #include "wine/unicode.h"
  36
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(comm);
  40
  41 /***********************************************************************
  42  *           COMM_Parse*   (Internal)
  43  *
  44  *  The following COMM_Parse* functions are used by the BuildCommDCB
  45  *  functions to help parse the various parts of the device control string.
  46  */
  47 static LPCWSTR COMM_ParseStart(LPCWSTR ptr)
  48 {
  49         static const WCHAR comW[] = {'C','O','M',0};
  50
  51         /* The device control string may optionally start with "COMx" followed
  52            by an optional ':' and spaces. */
  53         if(!strncmpiW(ptr, comW, 3))
  54         {
  55                 ptr += 3;
  56
  57                 /* Allow any com port above 0 as Win 9x does (NT only allows
  58                    values for com ports which are actually present) */
  59                 if(*ptr < '1' || *ptr > '9')
  60                         return NULL;
  61
  62                 /* Advance pointer past port number */
  63                 while(*ptr >= '0' && *ptr <= '9') ptr++;
  64
  65                 /* The com port number must be followed by a ':' or ' ' */
  66                 if(*ptr != ':' && *ptr != ' ')
  67                         return NULL;
  68
  69                 /* Advance pointer to beginning of next parameter */
  70                 while(*ptr == ' ') ptr++;
  71                 if(*ptr == ':')
  72                 {
  73                         ptr++;
  74                         while(*ptr == ' ') ptr++;
  75                 }
  76         }
  77         /* The device control string must not start with a space. */
  78         else if(*ptr == ' ')
  79                 return NULL;
  80
  81         return ptr;
  82 }
  83
  84 static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
  85 {
  86         if(*ptr < '0' || *ptr > '9') return NULL;
  87         *lpnumber = strtoulW(ptr, NULL, 10);
  88         while(*ptr >= '0' && *ptr <= '9') ptr++;
  89         return ptr;
  90 }
  91
  92 static LPCWSTR COMM_ParseParity(LPCWSTR ptr, LPBYTE lpparity)
  93 {
  94         /* Contrary to what you might expect, Windows only sets the Parity
  95            member of DCB and not fParity even when parity is specified in the
  96            device control string */
  97
  98         switch(toupperW(*ptr++))
  99         {
 100         case 'E':
 101                 *lpparity = EVENPARITY;
 102                 break;
 103         case 'M':
 104                 *lpparity = MARKPARITY;
 105                 break;
 106         case 'N':
 107                 *lpparity = NOPARITY;
 108                 break;
 109         case 'O':
 110                 *lpparity = ODDPARITY;
 111                 break;
 112         case 'S':
 113                 *lpparity = SPACEPARITY;
 114                 break;
 115         default:
 116                 return NULL;
 117         }
 118
 119         return ptr;
 120 }
 121
 122 static LPCWSTR COMM_ParseByteSize(LPCWSTR ptr, LPBYTE lpbytesize)
 123 {
 124         DWORD temp;
 125
 126         if(!(ptr = COMM_ParseNumber(ptr, &temp)))
 127                 return NULL;
 128
 129         if(temp >= 5 && temp <= 8)
 130         {
 131                 *lpbytesize = temp;
 132                 return ptr;
 133         }
 134         else
 135                 return NULL;
 136 }
 137
 138 static LPCWSTR COMM_ParseStopBits(LPCWSTR ptr, LPBYTE lpstopbits)
 139 {
 140         DWORD temp;
 141         static const WCHAR stopbits15W[] = {'1','.','5',0};
 142
 143         if(!strncmpW(stopbits15W, ptr, 3))
 144         {
 145                 ptr += 3;
 146                 *lpstopbits = ONE5STOPBITS;
 147         }
 148         else
 149         {
 150                 if(!(ptr = COMM_ParseNumber(ptr, &temp)))
 151                         return NULL;
 152
 153                 if(temp == 1)
 154                         *lpstopbits = ONESTOPBIT;
 155                 else if(temp == 2)
 156                         *lpstopbits = TWOSTOPBITS;
 157                 else
 158                         return NULL;
 159         }
 160
 161         return ptr;
 162 }
 163
 164 static LPCWSTR COMM_ParseOnOff(LPCWSTR ptr, LPDWORD lponoff)
 165 {
 166         static const WCHAR onW[] = {'o','n',0};
 167         static const WCHAR offW[] = {'o','f','f',0};
 168
 169         if(!strncmpiW(onW, ptr, 2))
 170         {
 171                 ptr += 2;
 172                 *lponoff = 1;
 173         }
 174         else if(!strncmpiW(offW, ptr, 3))
 175         {
 176                 ptr += 3;
 177                 *lponoff = 0;
 178         }
 179         else
 180                 return NULL;
 181
 182         return ptr;
 183 }
 184
 185 /***********************************************************************
 186  *           COMM_BuildOldCommDCB   (Internal)
 187  *
 188  *  Build a DCB using the old style settings string eg: "96,n,8,1"
 189  */
 190 static BOOL COMM_BuildOldCommDCB(LPCWSTR device, LPDCB lpdcb)
 191 {
 192         WCHAR last = 0;
 193
 194         if(!(device = COMM_ParseNumber(device, &lpdcb->BaudRate)))
 195                 return FALSE;
 196
 197         switch(lpdcb->BaudRate)
 198         {
 199         case 11:
 200         case 30:
 201         case 60:
 202                 lpdcb->BaudRate *= 10;
 203                 break;
 204         case 12:
 205         case 24:
 206         case 48:
 207         case 96:
 208                 lpdcb->BaudRate *= 100;
 209                 break;
 210         case 19:
 211                 lpdcb->BaudRate = 19200;
 212                 break;
 213         }
 214
 215         while(*device == ' ') device++;
 216         if(*device++ != ',') return FALSE;
 217         while(*device == ' ') device++;
 218
 219         if(!(device = COMM_ParseParity(device, &lpdcb->Parity)))
 220                 return FALSE;
 221
 222         while(*device == ' ') device++;
 223         if(*device++ != ',') return FALSE;
 224         while(*device == ' ') device++;
 225
 226         if(!(device = COMM_ParseByteSize(device, &lpdcb->ByteSize)))
 227                 return FALSE;
 228
 229         while(*device == ' ') device++;
 230         if(*device++ != ',') return FALSE;
 231         while(*device == ' ') device++;
 232
 233         if(!(device = COMM_ParseStopBits(device, &lpdcb->StopBits)))
 234                 return FALSE;
 235
 236         /* The last parameter for flow control is optional. */
 237         while(*device == ' ') device++;
 238         if(*device == ',')
 239         {
 240                 device++;
 241                 while(*device == ' ') device++;
 242                 if(*device) last = toupperW(*device++);
 243                 while(*device == ' ') device++;
 244         }
 245
 246         /* Win NT sets the flow control members based on (or lack of) the last
 247            parameter.  Win 9x does not set these members. */
 248         switch(last)
 249         {
 250         case 0:
 251                 lpdcb->fInX = FALSE;
 252                 lpdcb->fOutX = FALSE;
 253                 lpdcb->fOutxCtsFlow = FALSE;
 254                 lpdcb->fOutxDsrFlow = FALSE;
 255                 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
 256                 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
 257                 break;
 258         case 'X':
 259                 lpdcb->fInX = TRUE;
 260                 lpdcb->fOutX = TRUE;
 261                 lpdcb->fOutxCtsFlow = FALSE;
 262                 lpdcb->fOutxDsrFlow = FALSE;
 263                 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
 264                 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
 265                 break;
 266         case 'P':
 267                 lpdcb->fInX = FALSE;
 268                 lpdcb->fOutX = FALSE;
 269                 lpdcb->fOutxCtsFlow = TRUE;
 270                 lpdcb->fOutxDsrFlow = TRUE;
 271                 lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE;
 272                 lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
 273                 break;
 274         default:
 275                 return FALSE;
 276         }
 277
 278         /* This should be the end of the string. */
 279         if(*device) return FALSE;
 280
 281         return TRUE;
 282 }
 283
 284 /***********************************************************************
 285  *           COMM_BuildNewCommDCB   (Internal)
 286  *
 287  *  Build a DCB using the new style settings string.
 288  *   eg: "baud=9600 parity=n data=8 stop=1 xon=on to=on"
 289  */
 290 static BOOL COMM_BuildNewCommDCB(LPCWSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
 291 {
 292         DWORD temp;
 293         BOOL baud = FALSE, stop = FALSE;
 294         static const WCHAR baudW[] = {'b','a','u','d','=',0};
 295         static const WCHAR parityW[] = {'p','a','r','i','t','y','=',0};
 296         static const WCHAR dataW[] = {'d','a','t','a','=',0};
 297         static const WCHAR stopW[] = {'s','t','o','p','=',0};
 298         static const WCHAR toW[] = {'t','o','=',0};
 299         static const WCHAR xonW[] = {'x','o','n','=',0};
 300         static const WCHAR odsrW[] = {'o','d','s','r','=',0};
 301         static const WCHAR octsW[] = {'o','c','t','s','=',0};
 302         static const WCHAR dtrW[] = {'d','t','r','=',0};
 303         static const WCHAR rtsW[] = {'r','t','s','=',0};
 304         static const WCHAR idsrW[] = {'i','d','s','r','=',0};
 305
 306         while(*device)
 307         {
 308                 while(*device == ' ') device++;
 309
 310                 if(!strncmpiW(baudW, device, 5))
 311                 {
 312                         baud = TRUE;
 313
 314                         if(!(device = COMM_ParseNumber(device + 5, &lpdcb->BaudRate)))
 315                                 return FALSE;
 316                 }
 317                 else if(!strncmpiW(parityW, device, 7))
 318                 {
 319                         if(!(device = COMM_ParseParity(device + 7, &lpdcb->Parity)))
 320                                 return FALSE;
 321                 }
 322                 else if(!strncmpiW(dataW, device, 5))
 323                 {
 324                         if(!(device = COMM_ParseByteSize(device + 5, &lpdcb->ByteSize)))
 325                                 return FALSE;
 326                 }
 327                 else if(!strncmpiW(stopW, device, 5))
 328                 {
 329                         stop = TRUE;
 330
 331                         if(!(device = COMM_ParseStopBits(device + 5, &lpdcb->StopBits)))
 332                                 return FALSE;
 333                 }
 334                 else if(!strncmpiW(toW, device, 3))
 335                 {
 336                         if(!(device = COMM_ParseOnOff(device + 3, &temp)))
 337                                 return FALSE;
 338
 339                         lptimeouts->ReadIntervalTimeout = 0;
 340                         lptimeouts->ReadTotalTimeoutMultiplier = 0;
 341                         lptimeouts->ReadTotalTimeoutConstant = 0;
 342                         lptimeouts->WriteTotalTimeoutMultiplier = 0;
 343                         lptimeouts->WriteTotalTimeoutConstant = temp ? 60000 : 0;
 344                 }
 345                 else if(!strncmpiW(xonW, device, 4))
 346                 {
 347                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 348                                 return FALSE;
 349
 350                         lpdcb->fOutX = temp;
 351                         lpdcb->fInX = temp;
 352                 }
 353                 else if(!strncmpiW(odsrW, device, 5))
 354                 {
 355                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 356                                 return FALSE;
 357
 358                         lpdcb->fOutxDsrFlow = temp;
 359                 }
 360                 else if(!strncmpiW(octsW, device, 5))
 361                 {
 362                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 363                                 return FALSE;
 364
 365                         lpdcb->fOutxCtsFlow = temp;
 366                 }
 367                 else if(!strncmpiW(dtrW, device, 4))
 368                 {
 369                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 370                                 return FALSE;
 371
 372                         lpdcb->fDtrControl = temp;
 373                 }
 374                 else if(!strncmpiW(rtsW, device, 4))
 375                 {
 376                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 377                                 return FALSE;
 378
 379                         lpdcb->fRtsControl = temp;
 380                 }
 381                 else if(!strncmpiW(idsrW, device, 5))
 382                 {
 383                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 384                                 return FALSE;
 385
 386                         /* Win NT sets the fDsrSensitivity member based on the
 387                            idsr parameter.  Win 9x sets fOutxDsrFlow instead. */
 388                         lpdcb->fDsrSensitivity = temp;
 389                 }
 390                 else
 391                         return FALSE;
 392
 393                 /* After the above parsing, the next character (if not the end of
 394                    the string) should be a space */
 395                 if(*device && *device != ' ')
 396                         return FALSE;
 397         }
 398
 399         /* If stop bits were not specified, a default is always supplied. */
 400         if(!stop)
 401         {
 402                 if(baud && lpdcb->BaudRate == 110)
 403                         lpdcb->StopBits = TWOSTOPBITS;
 404                 else
 405                         lpdcb->StopBits = ONESTOPBIT;
 406         }
 407
 408         return TRUE;
 409 }
 410
 411 /**************************************************************************
 412  *         BuildCommDCBA                (KERNEL32.@)
 413  *
 414  *  Updates a device control block data structure with values from an
 415  *  ascii device control string.  The device control string has two forms
 416  *  normal and extended, it must be exclusively in one or the other form.
 417  *
 418  * RETURNS
 419  *
 420  *  True on success, false on a malformed control string.
 421  */
 422 BOOL WINAPI BuildCommDCBA(
 423     LPCSTR device, /* [in] The ascii device control string used to update the DCB. */
 424     LPDCB  lpdcb)  /* [out] The device control block to be updated. */
 425 {
 426         return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
 427 }
 428
 429 /**************************************************************************
 430  *         BuildCommDCBAndTimeoutsA             (KERNEL32.@)
 431  *
 432  *  Updates a device control block data structure with values from an
 433  *  ascii device control string.  Taking timeout values from a timeouts
 434  *  struct if desired by the control string.
 435  *
 436  * RETURNS
 437  *
 438  *  True on success, false bad handles etc.
 439  */
 440 BOOL WINAPI BuildCommDCBAndTimeoutsA(
 441     LPCSTR         device,     /* [in] The ascii device control string. */
 442     LPDCB          lpdcb,      /* [out] The device control block to be updated. */
 443     LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
 444 {
 445         BOOL ret = FALSE;
 446         UNICODE_STRING deviceW;
 447
 448         TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
 449         if(device) RtlCreateUnicodeStringFromAsciiz(&deviceW,device);
 450         else deviceW.Buffer = NULL;
 451
 452         if(deviceW.Buffer) ret = BuildCommDCBAndTimeoutsW(deviceW.Buffer,lpdcb,lptimeouts);
 453
 454         RtlFreeUnicodeString(&deviceW);
 455         return ret;
 456 }
 457
 458 /**************************************************************************
 459  *         BuildCommDCBAndTimeoutsW     (KERNEL32.@)
 460  *
 461  *  Updates a device control block data structure with values from a
 462  *  unicode device control string.  Taking timeout values from a timeouts
 463  *  struct if desired by the control string.
 464  *
 465  * RETURNS
 466  *
 467  *  True on success, false bad handles etc
 468  */
 469 BOOL WINAPI BuildCommDCBAndTimeoutsW(
 470     LPCWSTR        devid,      /* [in] The unicode device control string. */
 471     LPDCB          lpdcb,      /* [out] The device control block to be updated. */
 472     LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
 473 {
 474         DCB dcb;
 475         COMMTIMEOUTS timeouts;
 476         BOOL result;
 477         LPCWSTR ptr = devid;
 478
 479         TRACE("(%s,%p,%p)\n",debugstr_w(devid),lpdcb,lptimeouts);
 480
 481         memset(&timeouts, 0, sizeof timeouts);
 482
 483         /* Set DCBlength. (Windows NT does not do this, but 9x does) */
 484         lpdcb->DCBlength = sizeof(DCB);
 485
 486         /* Make a copy of the original data structures to work with since if
 487            if there is an error in the device control string the originals
 488            should not be modified (except possibly DCBlength) */
 489         dcb = *lpdcb;
 490         if(lptimeouts) timeouts = *lptimeouts;
 491
 492         ptr = COMM_ParseStart(ptr);
 493
 494         if(ptr == NULL)
 495                 result = FALSE;
 496         else if(strchrW(ptr, ','))
 497                 result = COMM_BuildOldCommDCB(ptr, &dcb);
 498         else
 499                 result = COMM_BuildNewCommDCB(ptr, &dcb, &timeouts);
 500
 501         if(result)
 502         {
 503                 *lpdcb = dcb;
 504                 if(lptimeouts) *lptimeouts = timeouts;
 505                 return TRUE;
 506         }
 507         else
 508         {
 509                 WARN("Invalid device control string: %s\n", debugstr_w(devid));
 510                 SetLastError(ERROR_INVALID_PARAMETER);
 511                 return FALSE;
 512         }
 513 }
 514
 515 /**************************************************************************
 516  *         BuildCommDCBW                (KERNEL32.@)
 517  *
 518  *  Updates a device control block structure with values from an
 519  *  unicode device control string.  The device control string has two forms
 520  *  normal and extended, it must be exclusively in one or the other form.
 521  *
 522  * RETURNS
 523  *
 524  *  True on success, false on a malformed control string.
 525  */
 526 BOOL WINAPI BuildCommDCBW(
 527     LPCWSTR devid, /* [in] The unicode device control string. */
 528     LPDCB   lpdcb) /* [out] The device control block to be updated. */
 529 {
 530         return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
 531 }
 532
 533 /*****************************************************************************
 534  *      SetCommBreak            (KERNEL32.@)
 535  *
 536  *  Halts the transmission of characters to a communications device.
 537  *
 538  * PARAMS
 539  *      handle  [in] The communications device to suspend
 540  *
 541  * RETURNS
 542  *
 543  *  True on success, and false if the communications device could not be found,
 544  *  the control is not supported.
 545  *
 546  * BUGS
 547  *
 548  *  Only TIOCSBRK and TIOCCBRK are supported.
 549  */
 550 BOOL WINAPI SetCommBreak(HANDLE handle)
 551 {
 552     DWORD dwBytesReturned;
 553     return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_ON, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
 554 }
 555
 556 /*****************************************************************************
 557  *      ClearCommBreak          (KERNEL32.@)
 558  *
 559  *  Resumes character transmission from a communication device.
 560  *
 561  * PARAMS
 562  *
 563  *      handle [in] The halted communication device whose character transmission is to be resumed
 564  *
 565  * RETURNS
 566  *
 567  *  True on success and false if the communications device could not be found.
 568  *
 569  * BUGS
 570  *
 571  *  Only TIOCSBRK and TIOCCBRK are supported.
 572  */
 573 BOOL WINAPI ClearCommBreak(HANDLE handle)
 574 {
 575     DWORD dwBytesReturned;
 576     return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_OFF, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
 577 }
 578
 579 /*****************************************************************************
 580  *      EscapeCommFunction      (KERNEL32.@)
 581  *
 582  *  Directs a communication device to perform an extended function.
 583  *
 584  * PARAMS
 585  *
 586  *      handle          [in] The communication device to perform the extended function
 587  *      nFunction       [in] The extended function to be performed
 588  *
 589  * RETURNS
 590  *
 591  *  True or requested data on successful completion of the command,
 592  *  false if the device is not present cannot execute the command
 593  *  or the command failed.
 594  */
 595 BOOL WINAPI EscapeCommFunction(HANDLE handle, DWORD func)
 596 {
 597     DWORD       ioc;
 598     DWORD dwBytesReturned;
 599
 600     switch (func)
 601     {
 602     case CLRDTR:        ioc = IOCTL_SERIAL_CLR_DTR;             break;
 603     case CLRRTS:        ioc = IOCTL_SERIAL_CLR_RTS;             break;
 604     case SETDTR:        ioc = IOCTL_SERIAL_SET_DTR;             break;
 605     case SETRTS:        ioc = IOCTL_SERIAL_SET_RTS;             break;
 606     case SETXOFF:       ioc = IOCTL_SERIAL_SET_XOFF;            break;
 607     case SETXON:        ioc = IOCTL_SERIAL_SET_XON;             break;
 608     case SETBREAK:      ioc = IOCTL_SERIAL_SET_BREAK_ON;        break;
 609     case CLRBREAK:      ioc = IOCTL_SERIAL_SET_BREAK_OFF;       break;
 610     case RESETDEV:      ioc = IOCTL_SERIAL_RESET_DEVICE;        break;
 611     default:
 612         ERR("Unknown function code (%u)\n", func);
 613         SetLastError(ERROR_INVALID_PARAMETER);
 614         return FALSE;
 615     }
 616     return DeviceIoControl(handle, ioc, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
 617 }
 618
 619 /********************************************************************
 620  *      PurgeComm        (KERNEL32.@)
 621  *
 622  *  Terminates pending operations and/or discards buffers on a
 623  *  communication resource.
 624  *
 625  * PARAMS
 626  *
 627  *      handle  [in] The communication resource to be purged
 628  *      flags   [in] Flags for clear pending/buffer on input/output
 629  *
 630  * RETURNS
 631  *
 632  *  True on success and false if the communications handle is bad.
 633  */
 634 BOOL WINAPI PurgeComm(HANDLE handle, DWORD flags)
 635 {
 636     DWORD dwBytesReturned;
 637     return DeviceIoControl(handle, IOCTL_SERIAL_PURGE, &flags, sizeof(flags),
 638                            NULL, 0, &dwBytesReturned, NULL);
 639 }
 640
 641 /*****************************************************************************
 642  *      ClearCommError  (KERNEL32.@)
 643  *
 644  *  Enables further I/O operations on a communications resource after
 645  *  supplying error and current status information.
 646  *
 647  * PARAMS
 648  *
 649  *      handle  [in]    The communication resource with the error
 650  *      errors  [out]   Flags indicating error the resource experienced
 651  *      lpStat  [out] The status of the communication resource
 652  * RETURNS
 653  *
 654  *  True on success, false if the communication resource handle is bad.
 655  */
 656 BOOL WINAPI ClearCommError(HANDLE handle, LPDWORD errors, LPCOMSTAT lpStat)
 657 {
 658     SERIAL_STATUS       ss;
 659     DWORD dwBytesReturned;
 660
 661     if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_COMMSTATUS, NULL, 0,
 662                          &ss, sizeof(ss), &dwBytesReturned, NULL))
 663         return FALSE;
 664
 665     TRACE("=> status %#x,%#x, in %u, out %u, eof %d, wait %d\n", ss.Errors, ss.HoldReasons,
 666           ss.AmountInInQueue, ss.AmountInOutQueue, ss.EofReceived, ss.WaitForImmediate);
 667
 668     if (errors)
 669     {
 670         *errors = 0;
 671         if (ss.Errors & SERIAL_ERROR_BREAK)             *errors |= CE_BREAK;
 672         if (ss.Errors & SERIAL_ERROR_FRAMING)           *errors |= CE_FRAME;
 673         if (ss.Errors & SERIAL_ERROR_OVERRUN)           *errors |= CE_OVERRUN;
 674         if (ss.Errors & SERIAL_ERROR_QUEUEOVERRUN)      *errors |= CE_RXOVER;
 675         if (ss.Errors & SERIAL_ERROR_PARITY)            *errors |= CE_RXPARITY;
 676     }
 677
 678     if (lpStat)
 679     {
 680         memset(lpStat, 0, sizeof(*lpStat));
 681
 682         if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_CTS)         lpStat->fCtsHold = TRUE;
 683         if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DSR)         lpStat->fDsrHold = TRUE;
 684         if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DCD)         lpStat->fRlsdHold = TRUE;
 685         if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_XON)         lpStat->fXoffHold = TRUE;
 686         if (ss.HoldReasons & SERIAL_TX_WAITING_XOFF_SENT)       lpStat->fXoffSent = TRUE;
 687         if (ss.EofReceived)                                     lpStat->fEof = TRUE;
 688         if (ss.WaitForImmediate)                                lpStat->fTxim = TRUE;
 689         lpStat->cbInQue = ss.AmountInInQueue;
 690         lpStat->cbOutQue = ss.AmountInOutQueue;
 691     }
 692     return TRUE;
 693 }
 694
 695 /*****************************************************************************
 696  *      SetupComm       (KERNEL32.@)
 697  *
 698  *  Called after CreateFile to hint to the communication resource to use
 699  *  specified sizes for input and output buffers rather than the default values.
 700  *
 701  * PARAMS
 702  *      handle  [in]    The just created communication resource handle
 703  *      insize  [in]    The suggested size of the communication resources input buffer in bytes
 704  *      outsize [in]    The suggested size of the communication resources output buffer in bytes
 705  *
 706  * RETURNS
 707  *
 708  *  True if successful, false if the communications resource handle is bad.
 709  *
 710  * BUGS
 711  *
 712  *  Stub.
 713  */
 714 BOOL WINAPI SetupComm(HANDLE handle, DWORD insize, DWORD outsize)
 715 {
 716     SERIAL_QUEUE_SIZE   sqs;
 717     DWORD dwBytesReturned;
 718
 719     sqs.InSize = insize;
 720     sqs.OutSize = outsize;
 721     return DeviceIoControl(handle, IOCTL_SERIAL_SET_QUEUE_SIZE,
 722                            &sqs, sizeof(sqs), NULL, 0, &dwBytesReturned, NULL);
 723 }
 724
 725 /*****************************************************************************
 726  *      GetCommMask     (KERNEL32.@)
 727  *
 728  *  Obtain the events associated with a communication device that will cause
 729  *  a call WaitCommEvent to return.
 730  *
 731  *  PARAMS
 732  *
 733  *      handle  [in]    The communications device
 734  *      evtmask [out]   The events which cause WaitCommEvent to return
 735  *
 736  *  RETURNS
 737  *
 738  *   True on success, fail on bad device handle etc.
 739  */
 740 BOOL WINAPI GetCommMask(HANDLE handle, LPDWORD evtmask)
 741 {
 742     DWORD dwBytesReturned;
 743     TRACE("handle %p, mask %p\n", handle, evtmask);
 744     return DeviceIoControl(handle, IOCTL_SERIAL_GET_WAIT_MASK,
 745                            NULL, 0, evtmask, sizeof(*evtmask), &dwBytesReturned, NULL);
 746 }
 747
 748 /*****************************************************************************
 749  *      SetCommMask     (KERNEL32.@)
 750  *
 751  *  There be some things we need to hear about yon there communications device.
 752  *  (Set which events associated with a communication device should cause
 753  *  a call WaitCommEvent to return.)
 754  *
 755  * PARAMS
 756  *
 757  *      handle  [in]    The communications device
 758  *      evtmask [in]    The events that are to be monitored
 759  *
 760  * RETURNS
 761  *
 762  *  True on success, false on bad handle etc.
 763  */
 764 BOOL WINAPI SetCommMask(HANDLE handle, DWORD evtmask)
 765 {
 766     DWORD dwBytesReturned;
 767     TRACE("handle %p, mask %x\n", handle, evtmask);
 768     return DeviceIoControl(handle, IOCTL_SERIAL_SET_WAIT_MASK,
 769                            &evtmask, sizeof(evtmask), NULL, 0, &dwBytesReturned, NULL);
 770 }
 771
 772 static void dump_dcb(const DCB* lpdcb)
 773 {
 774     TRACE("bytesize=%d baudrate=%d fParity=%d Parity=%d stopbits=%d\n",
 775           lpdcb->ByteSize, lpdcb->BaudRate, lpdcb->fParity, lpdcb->Parity,
 776           (lpdcb->StopBits == ONESTOPBIT) ? 1 :
 777           (lpdcb->StopBits == TWOSTOPBITS) ? 2 : 0);
 778     TRACE("%sIXON %sIXOFF\n", (lpdcb->fOutX) ? "" : "~", (lpdcb->fInX) ? "" : "~");
 779     TRACE("fOutxCtsFlow=%d fRtsControl=%d\n", lpdcb->fOutxCtsFlow, lpdcb->fRtsControl);
 780     TRACE("fOutxDsrFlow=%d fDtrControl=%d\n", lpdcb->fOutxDsrFlow, lpdcb->fDtrControl);
 781     if (lpdcb->fOutxCtsFlow || lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE)
 782         TRACE("CRTSCTS\n");
 783     else
 784         TRACE("~CRTSCTS\n");
 785 }
 786
 787 /*****************************************************************************
 788  *      SetCommState    (KERNEL32.@)
 789  *
 790  *  Re-initializes all hardware and control settings of a communications device,
 791  *  with values from a device control block without affecting the input and output
 792  *  queues.
 793  *
 794  * PARAMS
 795  *
 796  *      handle  [in]    The communications device
 797  *      lpdcb   [out]   The device control block
 798  *
 799  * RETURNS
 800  *
 801  *  True on success, false on failure, e.g., if the XonChar is equal to the XoffChar.
 802  */
 803 BOOL WINAPI SetCommState( HANDLE handle, LPDCB lpdcb)
 804 {
 805     SERIAL_BAUD_RATE           sbr;
 806     SERIAL_LINE_CONTROL        slc;
 807     SERIAL_HANDFLOW            shf;
 808     SERIAL_CHARS               sc;
 809     DWORD dwBytesReturned;
 810
 811     TRACE("handle %p, ptr %p\n", handle, lpdcb);
 812
 813     if (lpdcb == NULL)
 814     {
 815         SetLastError(ERROR_INVALID_PARAMETER);
 816         return FALSE;
 817     }
 818     dump_dcb(lpdcb);
 819
 820     sbr.BaudRate = lpdcb->BaudRate;
 821
 822     slc.StopBits = lpdcb->StopBits;
 823     slc.Parity = lpdcb->Parity;
 824     slc.WordLength = lpdcb->ByteSize;
 825
 826     shf.ControlHandShake = 0;
 827     shf.FlowReplace = 0;
 828     if (lpdcb->fOutxCtsFlow)      shf.ControlHandShake |= SERIAL_CTS_HANDSHAKE;
 829     if (lpdcb->fOutxDsrFlow)      shf.ControlHandShake |= SERIAL_DSR_HANDSHAKE;
 830     switch (lpdcb->fDtrControl)
 831     {
 832     case DTR_CONTROL_DISABLE:                                                  break;
 833     case DTR_CONTROL_ENABLE:      shf.ControlHandShake |= SERIAL_DTR_CONTROL;  break;
 834     case DTR_CONTROL_HANDSHAKE:   shf.ControlHandShake |= SERIAL_DTR_HANDSHAKE;break;
 835     default:
 836         SetLastError(ERROR_INVALID_PARAMETER);
 837         return FALSE;
 838     }
 839     switch (lpdcb->fRtsControl)
 840     {
 841     case RTS_CONTROL_DISABLE:                                                  break;
 842     case RTS_CONTROL_ENABLE:      shf.FlowReplace |= SERIAL_RTS_CONTROL;       break;
 843     case RTS_CONTROL_HANDSHAKE:   shf.FlowReplace |= SERIAL_RTS_HANDSHAKE;     break;
 844     case RTS_CONTROL_TOGGLE:      shf.FlowReplace |= SERIAL_RTS_CONTROL |
 845                                                      SERIAL_RTS_HANDSHAKE;     break;
 846     default:
 847         SetLastError(ERROR_INVALID_PARAMETER);
 848         return FALSE;
 849     }
 850     if (lpdcb->fDsrSensitivity)   shf.ControlHandShake |= SERIAL_DSR_SENSITIVITY;
 851     if (lpdcb->fAbortOnError)     shf.ControlHandShake |= SERIAL_ERROR_ABORT;
 852
 853     if (lpdcb->fErrorChar)        shf.FlowReplace |= SERIAL_ERROR_CHAR;
 854     if (lpdcb->fNull)             shf.FlowReplace |= SERIAL_NULL_STRIPPING;
 855     if (lpdcb->fTXContinueOnXoff) shf.FlowReplace |= SERIAL_XOFF_CONTINUE;
 856     if (lpdcb->fOutX)             shf.FlowReplace |= SERIAL_AUTO_TRANSMIT;
 857     if (lpdcb->fInX)              shf.FlowReplace |= SERIAL_AUTO_RECEIVE;
 858
 859     shf.XonLimit = lpdcb->XonLim;
 860     shf.XoffLimit = lpdcb->XoffLim;
 861
 862     sc.EofChar = lpdcb->EofChar;
 863     sc.ErrorChar = lpdcb->ErrorChar;
 864     sc.BreakChar = 0;
 865     sc.EventChar = lpdcb->EvtChar;
 866     sc.XonChar = lpdcb->XonChar;
 867     sc.XoffChar = lpdcb->XoffChar;
 868
 869     /* note: change DTR/RTS lines after setting the comm attributes,
 870      * so flow control does not interfere.
 871      */
 872     return (DeviceIoControl(handle, IOCTL_SERIAL_SET_BAUD_RATE,
 873                             &sbr, sizeof(sbr), NULL, 0, &dwBytesReturned, NULL) &&
 874             DeviceIoControl(handle, IOCTL_SERIAL_SET_LINE_CONTROL,
 875                             &slc, sizeof(slc), NULL, 0, &dwBytesReturned, NULL) &&
 876             DeviceIoControl(handle, IOCTL_SERIAL_SET_HANDFLOW,
 877                             &shf, sizeof(shf), NULL, 0, &dwBytesReturned, NULL) &&
 878             DeviceIoControl(handle, IOCTL_SERIAL_SET_CHARS,
 879                             &sc, sizeof(sc), NULL, 0, &dwBytesReturned, NULL));
 880 }
 881
 882
 883 /*****************************************************************************
 884  *      GetCommState    (KERNEL32.@)
 885  *
 886  *  Fills in a device control block with information from a communications device.
 887  *
 888  * PARAMS
 889  *      handle          [in]    The communications device
 890  *      lpdcb           [out]   The device control block
 891  *
 892  * RETURNS
 893  *
 894  *  True on success, false if the communication device handle is bad etc
 895  *
 896  * BUGS
 897  *
 898  *  XonChar and XoffChar are not set.
 899  */
 900 BOOL WINAPI GetCommState(HANDLE handle, LPDCB lpdcb)
 901 {
 902     SERIAL_BAUD_RATE    sbr;
 903     SERIAL_LINE_CONTROL slc;
 904     SERIAL_HANDFLOW     shf;
 905     SERIAL_CHARS        sc;
 906     DWORD dwBytesReturned;
 907
 908     TRACE("handle %p, ptr %p\n", handle, lpdcb);
 909
 910     if (!lpdcb)
 911     {
 912         SetLastError(ERROR_INVALID_PARAMETER);
 913         return FALSE;
 914     }
 915
 916     if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_BAUD_RATE,
 917                          NULL, 0, &sbr, sizeof(sbr), &dwBytesReturned, NULL) ||
 918         !DeviceIoControl(handle, IOCTL_SERIAL_GET_LINE_CONTROL,
 919                          NULL, 0, &slc, sizeof(slc), &dwBytesReturned, NULL) ||
 920         !DeviceIoControl(handle, IOCTL_SERIAL_GET_HANDFLOW,
 921                          NULL, 0, &shf, sizeof(shf), &dwBytesReturned, NULL) ||
 922         !DeviceIoControl(handle, IOCTL_SERIAL_GET_CHARS,
 923                          NULL, 0, &sc, sizeof(sc), &dwBytesReturned, NULL))
 924         return FALSE;
 925
 926     memset(lpdcb, 0, sizeof(*lpdcb));
 927     lpdcb->DCBlength = sizeof(*lpdcb);
 928
 929     /* yes, they seem no never be (re)set on NT */
 930     lpdcb->fBinary = 1;
 931     lpdcb->fParity = 0;
 932
 933     lpdcb->BaudRate = sbr.BaudRate;
 934
 935     lpdcb->StopBits = slc.StopBits;
 936     lpdcb->Parity = slc.Parity;
 937     lpdcb->ByteSize = slc.WordLength;
 938
 939     if (shf.ControlHandShake & SERIAL_CTS_HANDSHAKE)    lpdcb->fOutxCtsFlow = 1;
 940     if (shf.ControlHandShake & SERIAL_DSR_HANDSHAKE)    lpdcb->fOutxDsrFlow = 1;
 941     switch (shf.ControlHandShake & (SERIAL_DTR_CONTROL | SERIAL_DTR_HANDSHAKE))
 942     {
 943     case 0:                     lpdcb->fDtrControl = DTR_CONTROL_DISABLE; break;
 944     case SERIAL_DTR_CONTROL:    lpdcb->fDtrControl = DTR_CONTROL_ENABLE; break;
 945     case SERIAL_DTR_HANDSHAKE:  lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE; break;
 946     }
 947     switch (shf.FlowReplace & (SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE))
 948     {
 949     case 0:                     lpdcb->fRtsControl = RTS_CONTROL_DISABLE; break;
 950     case SERIAL_RTS_CONTROL:    lpdcb->fRtsControl = RTS_CONTROL_ENABLE; break;
 951     case SERIAL_RTS_HANDSHAKE:  lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE; break;
 952     case SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE:
 953                                 lpdcb->fRtsControl = RTS_CONTROL_TOGGLE; break;
 954     }
 955     if (shf.ControlHandShake & SERIAL_DSR_SENSITIVITY)  lpdcb->fDsrSensitivity = 1;
 956     if (shf.ControlHandShake & SERIAL_ERROR_ABORT)      lpdcb->fAbortOnError = 1;
 957     if (shf.FlowReplace & SERIAL_ERROR_CHAR)            lpdcb->fErrorChar = 1;
 958     if (shf.FlowReplace & SERIAL_NULL_STRIPPING)        lpdcb->fNull = 1;
 959     if (shf.FlowReplace & SERIAL_XOFF_CONTINUE)         lpdcb->fTXContinueOnXoff = 1;
 960     lpdcb->XonLim = shf.XonLimit;
 961     lpdcb->XoffLim = shf.XoffLimit;
 962
 963     if (shf.FlowReplace & SERIAL_AUTO_TRANSMIT) lpdcb->fOutX = 1;
 964     if (shf.FlowReplace & SERIAL_AUTO_RECEIVE)  lpdcb->fInX = 1;
 965
 966     lpdcb->EofChar = sc.EofChar;
 967     lpdcb->ErrorChar = sc.ErrorChar;
 968     lpdcb->EvtChar = sc.EventChar;
 969     lpdcb->XonChar = sc.XonChar;
 970     lpdcb->XoffChar = sc.XoffChar;
 971
 972     TRACE("OK\n");
 973     dump_dcb(lpdcb);
 974
 975     return TRUE;
 976 }
 977
 978 /*****************************************************************************
 979  *      TransmitCommChar        (KERNEL32.@)
 980  *
 981  *  Transmits a single character in front of any pending characters in the
 982  *  output buffer.  Usually used to send an interrupt character to a host.
 983  *
 984  * PARAMS
 985  *      hComm           [in]    The communication device in need of a command character
 986  *      chTransmit      [in]    The character to transmit
 987  *
 988  * RETURNS
 989  *
 990  *  True if the call succeeded, false if the previous command character to the
 991  *  same device has not been sent yet the handle is bad etc.
 992  *
 993  */
 994 BOOL WINAPI TransmitCommChar(HANDLE hComm, CHAR chTransmit)
 995 {
 996     DWORD dwBytesReturned;
 997     return DeviceIoControl(hComm, IOCTL_SERIAL_IMMEDIATE_CHAR,
 998                            &chTransmit, sizeof(chTransmit), NULL, 0, &dwBytesReturned, NULL);
 999 }
1000
1001
1002 /*****************************************************************************
1003  *      GetCommTimeouts         (KERNEL32.@)
1004  *
1005  *  Obtains the request timeout values for the communications device.
1006  *
1007  * PARAMS
1008  *      hComm           [in]    The communications device
1009  *      lptimeouts      [out]   The struct of request timeouts
1010  *
1011  * RETURNS
1012  *
1013  *  True on success, false if communications device handle is bad
1014  *  or the target structure is null.
1015  */
1016 BOOL WINAPI GetCommTimeouts(HANDLE hComm, LPCOMMTIMEOUTS lptimeouts)
1017 {
1018     SERIAL_TIMEOUTS     st;
1019     DWORD dwBytesReturned;
1020
1021     TRACE("(%p, %p)\n", hComm, lptimeouts);
1022     if (!lptimeouts)
1023     {
1024         SetLastError(ERROR_INVALID_PARAMETER);
1025         return FALSE;
1026     }
1027     if (!DeviceIoControl(hComm, IOCTL_SERIAL_GET_TIMEOUTS,
1028                          NULL, 0, &st, sizeof(st), &dwBytesReturned, NULL))
1029         return FALSE;
1030     lptimeouts->ReadIntervalTimeout         = st.ReadIntervalTimeout;
1031     lptimeouts->ReadTotalTimeoutMultiplier  = st.ReadTotalTimeoutMultiplier;
1032     lptimeouts->ReadTotalTimeoutConstant    = st.ReadTotalTimeoutConstant;
1033     lptimeouts->WriteTotalTimeoutMultiplier = st.WriteTotalTimeoutMultiplier;
1034     lptimeouts->WriteTotalTimeoutConstant   = st.WriteTotalTimeoutConstant;
1035     return TRUE;
1036 }
1037
1038 /*****************************************************************************
1039  *      SetCommTimeouts         (KERNEL32.@)
1040  *
1041  * Sets the timeouts used when reading and writing data to/from COMM ports.
1042  *
1043  * PARAMS
1044  *      hComm           [in]    handle of COMM device
1045  *      lptimeouts      [in]    pointer to COMMTIMEOUTS structure
1046  *
1047  * ReadIntervalTimeout
1048  *     - converted and passes to linux kernel as c_cc[VTIME]
1049  * ReadTotalTimeoutMultiplier, ReadTotalTimeoutConstant
1050  *     - used in ReadFile to calculate GetOverlappedResult's timeout
1051  * WriteTotalTimeoutMultiplier, WriteTotalTimeoutConstant
1052  *     - used in WriteFile to calculate GetOverlappedResult's timeout
1053  *
1054  * RETURNS
1055  *
1056  *  True if the timeouts were set, false otherwise.
1057  */
1058 BOOL WINAPI SetCommTimeouts(HANDLE hComm, LPCOMMTIMEOUTS lptimeouts)
1059 {
1060     SERIAL_TIMEOUTS     st;
1061     DWORD dwBytesReturned;
1062
1063     TRACE("(%p, %p)\n", hComm, lptimeouts);
1064
1065     if (lptimeouts == NULL)
1066     {
1067         SetLastError(ERROR_INVALID_PARAMETER);
1068         return FALSE;
1069     }
1070     st.ReadIntervalTimeout         = lptimeouts->ReadIntervalTimeout;
1071     st.ReadTotalTimeoutMultiplier  = lptimeouts->ReadTotalTimeoutMultiplier;
1072     st.ReadTotalTimeoutConstant    = lptimeouts->ReadTotalTimeoutConstant;
1073     st.WriteTotalTimeoutMultiplier = lptimeouts->WriteTotalTimeoutMultiplier;
1074     st.WriteTotalTimeoutConstant   = lptimeouts->WriteTotalTimeoutConstant;
1075
1076     return DeviceIoControl(hComm, IOCTL_SERIAL_SET_TIMEOUTS,
1077                            &st, sizeof(st), NULL, 0, &dwBytesReturned, NULL);
1078 }
1079
1080 /***********************************************************************
1081  *           GetCommModemStatus   (KERNEL32.@)
1082  *
1083  *  Obtains the four control register bits if supported by the hardware.
1084  *
1085  * PARAMS
1086  *
1087  *      hFile           [in]    The communications device
1088  *      lpModemStat     [out]   The control register bits
1089  *
1090  * RETURNS
1091  *
1092  *  True if the communications handle was good and for hardware that
1093  *  control register access, false otherwise.
1094  */
1095 BOOL WINAPI GetCommModemStatus(HANDLE hFile, LPDWORD lpModemStat)
1096 {
1097     DWORD dwBytesReturned;
1098     return DeviceIoControl(hFile, IOCTL_SERIAL_GET_MODEMSTATUS,
1099                            NULL, 0, lpModemStat, sizeof(DWORD), &dwBytesReturned, NULL);
1100 }
1101
1102 /***********************************************************************
1103  *           WaitCommEvent   (KERNEL32.@)
1104  *
1105  * Wait until something interesting happens on a COMM port.
1106  * Interesting things (events) are set by calling SetCommMask before
1107  * this function is called.
1108  *
1109  * RETURNS
1110  *   TRUE if successful
1111  *   FALSE if failure
1112  *
1113  *   The set of detected events will be written to *lpdwEventMask
1114  *   ERROR_IO_PENDING will be returned the overlapped structure was passed
1115  *
1116  * BUGS:
1117  *  Only supports EV_RXCHAR and EV_TXEMPTY
1118  */
1119 BOOL WINAPI WaitCommEvent(
1120     HANDLE hFile,              /* [in] handle of comm port to wait for */
1121     LPDWORD lpdwEvents,        /* [out] event(s) that were detected */
1122     LPOVERLAPPED lpOverlapped) /* [in/out] for Asynchronous waiting */
1123 {
1124     return DeviceIoControl(hFile, IOCTL_SERIAL_WAIT_ON_MASK, NULL, 0,
1125                            lpdwEvents, sizeof(DWORD), NULL, lpOverlapped);
1126 }
1127
1128 /***********************************************************************
1129  *           GetCommProperties   (KERNEL32.@)
1130  *
1131  * This function fills in a structure with the capabilities of the
1132  * communications port driver.
1133  *
1134  * RETURNS
1135  *
1136  *  TRUE on success, FALSE on failure
1137  *  If successful, the lpCommProp structure be filled in with
1138  *  properties of the comm port.
1139  */
1140 BOOL WINAPI GetCommProperties(
1141     HANDLE hFile,          /* [in] handle of the comm port */
1142     LPCOMMPROP lpCommProp) /* [out] pointer to struct to be filled */
1143 {
1144     TRACE("(%p %p)\n",hFile,lpCommProp);
1145     if(!lpCommProp)
1146         return FALSE;
1147
1148     /*
1149      * These values should be valid for LINUX's serial driver
1150      * FIXME: Perhaps they deserve an #ifdef LINUX
1151      */
1152     memset(lpCommProp,0,sizeof(COMMPROP));
1153     lpCommProp->wPacketLength       = 1;
1154     lpCommProp->wPacketVersion      = 1;
1155     lpCommProp->dwServiceMask       = SP_SERIALCOMM;
1156     lpCommProp->dwMaxTxQueue        = 4096;
1157     lpCommProp->dwMaxRxQueue        = 4096;
1158     lpCommProp->dwMaxBaud           = BAUD_115200;
1159     lpCommProp->dwProvSubType       = PST_RS232;
1160     lpCommProp->dwProvCapabilities  = PCF_DTRDSR | PCF_PARITY_CHECK | PCF_RTSCTS | PCF_TOTALTIMEOUTS | PCF_INTTIMEOUTS;
1161     lpCommProp->dwSettableParams    = SP_BAUD | SP_DATABITS | SP_HANDSHAKING |
1162                                       SP_PARITY | SP_PARITY_CHECK | SP_STOPBITS ;
1163     lpCommProp->dwSettableBaud      = BAUD_075 | BAUD_110 | BAUD_134_5 | BAUD_150 |
1164                 BAUD_300 | BAUD_600 | BAUD_1200 | BAUD_1800 | BAUD_2400 | BAUD_4800 |
1165                 BAUD_9600 | BAUD_19200 | BAUD_38400 | BAUD_57600 | BAUD_115200 ;
1166     lpCommProp->wSettableData       = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8 ;
1167     lpCommProp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
1168                 PARITY_NONE | PARITY_ODD |PARITY_EVEN | PARITY_MARK | PARITY_SPACE;
1169     lpCommProp->dwCurrentTxQueue    = lpCommProp->dwMaxTxQueue;
1170     lpCommProp->dwCurrentRxQueue    = lpCommProp->dwMaxRxQueue;
1171
1172     return TRUE;
1173 }
1174
1175 /***********************************************************************
1176  * FIXME:
1177  * The functionality of CommConfigDialogA, GetDefaultCommConfig and
1178  * SetDefaultCommConfig is implemented in a DLL (usually SERIALUI.DLL).
1179  * This is dependent on the type of COMM port, but since it is doubtful
1180  * anybody will get around to implementing support for fancy serial
1181  * ports in WINE, this is hardcoded for the time being.  The name of
1182  * this DLL should be stored in and read from the system registry in
1183  * the hive HKEY_LOCAL_MACHINE, key
1184  * System\\CurrentControlSet\\Services\\Class\\Ports\\????
1185  * where ???? is the port number... that is determined by PNP
1186  * The DLL should be loaded when the COMM port is opened, and closed
1187  * when the COMM port is closed. - MJM 20 June 2000
1188  ***********************************************************************/
1189 static const WCHAR lpszSerialUI[] = {
1190    's','e','r','i','a','l','u','i','.','d','l','l',0 };
1191
1192
1193 /***********************************************************************
1194  *           CommConfigDialogA   (KERNEL32.@)
1195  *
1196  * Raises a dialog that allows the user to configure a comm port.
1197  * Fills the COMMCONFIG struct with information specified by the user.
1198  * This function should call a similar routine in the COMM driver...
1199  *
1200  * RETURNS
1201  *
1202  *  TRUE on success, FALSE on failure
1203  *  If successful, the lpCommConfig structure will contain a new
1204  *  configuration for the comm port, as specified by the user.
1205  *
1206  * BUGS
1207  *  The library with the CommConfigDialog code is never unloaded.
1208  * Perhaps this should be done when the comm port is closed?
1209  */
1210 BOOL WINAPI CommConfigDialogA(
1211     LPCSTR lpszDevice,         /* [in] name of communications device */
1212     HWND hWnd,                 /* [in] parent window for the dialog */
1213     LPCOMMCONFIG lpCommConfig) /* [out] pointer to struct to fill */
1214 {
1215     LPWSTR  lpDeviceW = NULL;
1216     DWORD   len;
1217     BOOL    r;
1218
1219     TRACE("(%s, %p, %p)\n", debugstr_a(lpszDevice), hWnd, lpCommConfig);
1220
1221     if (lpszDevice)
1222     {
1223         len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
1224         lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1225         MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
1226     }
1227     r = CommConfigDialogW(lpDeviceW, hWnd, lpCommConfig);
1228     HeapFree( GetProcessHeap(), 0, lpDeviceW );
1229     return r;
1230 }
1231
1232 /***********************************************************************
1233  *           CommConfigDialogW   (KERNEL32.@)
1234  *
1235  * See CommConfigDialogA.
1236  */
1237 BOOL WINAPI CommConfigDialogW(
1238     LPCWSTR lpszDevice,        /* [in] name of communications device */
1239     HWND hWnd,                 /* [in] parent window for the dialog */
1240     LPCOMMCONFIG lpCommConfig) /* [out] pointer to struct to fill */
1241 {
1242     DWORD (WINAPI *pCommConfigDialog)(LPCWSTR, HWND, LPCOMMCONFIG);
1243     HMODULE hConfigModule;
1244     DWORD   res = ERROR_INVALID_PARAMETER;
1245
1246     TRACE("(%s, %p, %p)\n", debugstr_w(lpszDevice), hWnd, lpCommConfig);
1247     hConfigModule = LoadLibraryW(lpszSerialUI);
1248
1249     if (hConfigModule) {
1250         pCommConfigDialog = (void *)GetProcAddress(hConfigModule, "drvCommConfigDialogW");
1251         if (pCommConfigDialog) {
1252             res = pCommConfigDialog(lpszDevice, hWnd, lpCommConfig);
1253         }
1254         FreeLibrary(hConfigModule);
1255     }
1256
1257     if (res) SetLastError(res);
1258     return (res == ERROR_SUCCESS);
1259 }
1260
1261 /***********************************************************************
1262  *           GetCommConfig     (KERNEL32.@)
1263  *
1264  * Fill in the COMMCONFIG structure for the comm port hFile
1265  *
1266  * RETURNS
1267  *
1268  *  TRUE on success, FALSE on failure
1269  *  If successful, lpCommConfig contains the comm port configuration.
1270  *
1271  * BUGS
1272  *
1273  */
1274 BOOL WINAPI GetCommConfig(
1275     HANDLE       hFile,        /* [in] The communications device. */
1276     LPCOMMCONFIG lpCommConfig, /* [out] The communications configuration of the device (if it fits). */
1277     LPDWORD      lpdwSize)     /* [in/out] Initially the size of the configuration buffer/structure,
1278                                   afterwards the number of bytes copied to the buffer or
1279                                   the needed size of the buffer. */
1280 {
1281     BOOL r;
1282
1283     TRACE("(%p, %p, %p) *lpdwSize: %u\n", hFile, lpCommConfig, lpdwSize, lpdwSize ? *lpdwSize : 0 );
1284
1285     if(lpCommConfig == NULL)
1286         return FALSE;
1287     r = *lpdwSize < sizeof(COMMCONFIG); /* TRUE if not enough space */
1288     *lpdwSize = sizeof(COMMCONFIG);
1289     if(r)
1290         return FALSE;
1291
1292     lpCommConfig->dwSize = sizeof(COMMCONFIG);
1293     lpCommConfig->wVersion = 1;
1294     lpCommConfig->wReserved = 0;
1295     r = GetCommState(hFile,&lpCommConfig->dcb);
1296     lpCommConfig->dwProviderSubType = PST_RS232;
1297     lpCommConfig->dwProviderOffset = 0;
1298     lpCommConfig->dwProviderSize = 0;
1299
1300     return r;
1301 }
1302
1303 /***********************************************************************
1304  *           SetCommConfig     (KERNEL32.@)
1305  *
1306  *  Sets the configuration of the communications device.
1307  *
1308  * RETURNS
1309  *
1310  *  True on success, false if the handle was bad is not a communications device.
1311  */
1312 BOOL WINAPI SetCommConfig(
1313     HANDLE       hFile,         /* [in] The communications device. */
1314     LPCOMMCONFIG lpCommConfig,  /* [in] The desired configuration. */
1315     DWORD dwSize)               /* [in] size of the lpCommConfig struct */
1316 {
1317     TRACE("(%p, %p, %u)\n", hFile, lpCommConfig, dwSize);
1318     return SetCommState(hFile,&lpCommConfig->dcb);
1319 }
1320
1321 /***********************************************************************
1322  *           SetDefaultCommConfigW  (KERNEL32.@)
1323  *
1324  * Initializes the default configuration for a communication device.
1325  *
1326  * PARAMS
1327  *  lpszDevice   [I] Name of the device targeted for configuration
1328  *  lpCommConfig [I] PTR to a buffer with the configuration for the device
1329  *  dwSize       [I] Number of bytes in the buffer
1330  *
1331  * RETURNS
1332  *  Failure: FALSE
1333  *  Success: TRUE, and default configuration saved
1334  *
1335  */
1336 BOOL WINAPI SetDefaultCommConfigW(LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
1337 {
1338     BOOL (WINAPI *lpfnSetDefaultCommConfig)(LPCWSTR, LPCOMMCONFIG, DWORD);
1339     HMODULE hConfigModule;
1340     BOOL r = FALSE;
1341
1342     TRACE("(%s, %p, %u)\n", debugstr_w(lpszDevice), lpCommConfig, dwSize);
1343
1344     hConfigModule = LoadLibraryW(lpszSerialUI);
1345     if(!hConfigModule)
1346         return r;
1347
1348     lpfnSetDefaultCommConfig = (void *)GetProcAddress(hConfigModule, "drvSetDefaultCommConfigW");
1349     if (lpfnSetDefaultCommConfig)
1350         r = lpfnSetDefaultCommConfig(lpszDevice, lpCommConfig, dwSize);
1351
1352     FreeLibrary(hConfigModule);
1353
1354     return r;
1355 }
1356
1357
1358 /***********************************************************************
1359  *           SetDefaultCommConfigA     (KERNEL32.@)
1360  *
1361  * Initializes the default configuration for a communication device.
1362  *
1363  * See SetDefaultCommConfigW.
1364  *
1365  */
1366 BOOL WINAPI SetDefaultCommConfigA(LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
1367 {
1368     BOOL r;
1369     LPWSTR lpDeviceW = NULL;
1370     DWORD len;
1371
1372     TRACE("(%s, %p, %u)\n", debugstr_a(lpszDevice), lpCommConfig, dwSize);
1373
1374     if (lpszDevice)
1375     {
1376         len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
1377         lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1378         MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
1379     }
1380     r = SetDefaultCommConfigW(lpDeviceW,lpCommConfig,dwSize);
1381     HeapFree( GetProcessHeap(), 0, lpDeviceW );
1382     return r;
1383 }
1384
1385
1386 /***********************************************************************
1387  *           GetDefaultCommConfigW   (KERNEL32.@)
1388  *
1389  *   Acquires the default configuration of the specified communication device. (unicode)
1390  *
1391  *  RETURNS
1392  *
1393  *   True on successful reading of the default configuration,
1394  *   if the device is not found or the buffer is too small.
1395  */
1396 BOOL WINAPI GetDefaultCommConfigW(
1397     LPCWSTR      lpszName, /* [in] The unicode name of the device targeted for configuration. */
1398     LPCOMMCONFIG lpCC,     /* [out] The default configuration for the device. */
1399     LPDWORD      lpdwSize) /* [in/out] Initially the size of the default configuration buffer,
1400                               afterwards the number of bytes copied to the buffer or
1401                               the needed size of the buffer. */
1402 {
1403     DWORD (WINAPI *pGetDefaultCommConfig)(LPCWSTR, LPCOMMCONFIG, LPDWORD);
1404     HMODULE hConfigModule;
1405     DWORD   res = ERROR_INVALID_PARAMETER;
1406
1407     TRACE("(%s, %p, %p)  *lpdwSize: %u\n", debugstr_w(lpszName), lpCC, lpdwSize, lpdwSize ? *lpdwSize : 0 );
1408     hConfigModule = LoadLibraryW(lpszSerialUI);
1409
1410     if (hConfigModule) {
1411         pGetDefaultCommConfig = (void *)GetProcAddress(hConfigModule, "drvGetDefaultCommConfigW");
1412         if (pGetDefaultCommConfig) {
1413             res = pGetDefaultCommConfig(lpszName, lpCC, lpdwSize);
1414         }
1415         FreeLibrary(hConfigModule);
1416     }
1417
1418     if (res) SetLastError(res);
1419     return (res == ERROR_SUCCESS);
1420 }
1421
1422 /**************************************************************************
1423  *         GetDefaultCommConfigA                (KERNEL32.@)
1424  *
1425  *   Acquires the default configuration of the specified communication device. (ascii)
1426  *
1427  *  RETURNS
1428  *
1429  *   True on successful reading of the default configuration,
1430  *   if the device is not found or the buffer is too small.
1431  */
1432 BOOL WINAPI GetDefaultCommConfigA(
1433     LPCSTR       lpszName, /* [in] The ascii name of the device targeted for configuration. */
1434     LPCOMMCONFIG lpCC,     /* [out] The default configuration for the device. */
1435     LPDWORD      lpdwSize) /* [in/out] Initially the size of the default configuration buffer,
1436                               afterwards the number of bytes copied to the buffer or
1437                               the needed size of the buffer. */
1438 {
1439         BOOL ret = FALSE;
1440         UNICODE_STRING lpszNameW;
1441
1442         TRACE("(%s, %p, %p)  *lpdwSize: %u\n", debugstr_a(lpszName), lpCC, lpdwSize, lpdwSize ? *lpdwSize : 0 );
1443         if(lpszName) RtlCreateUnicodeStringFromAsciiz(&lpszNameW,lpszName);
1444         else lpszNameW.Buffer = NULL;
1445
1446         ret = GetDefaultCommConfigW(lpszNameW.Buffer,lpCC,lpdwSize);
1447
1448         RtlFreeUnicodeString(&lpszNameW);
1449         return ret;
1450 }