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 <stdlib.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winnls.h"
  28 #include "winerror.h"
  29 #include "winioctl.h"
  30 #include "ddk/ntddser.h"
  31
  32 #include "wine/server.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(comm);
  37
  38 /***********************************************************************
  39  *           COMM_Parse*   (Internal)
  40  *
  41  *  The following COMM_Parse* functions are used by the BuildCommDCB
  42  *  functions to help parse the various parts of the device control string.
  43  */
  44 static LPCWSTR COMM_ParseStart(LPCWSTR ptr)
  45 {
  46         /* The device control string may optionally start with "COMx" followed
  47            by an optional ':' and spaces. */
  48         if(!wcsnicmp(ptr, L"COM", 3))
  49         {
  50                 ptr += 3;
  51
  52                 /* Allow any com port above 0 as Win 9x does (NT only allows
  53                    values for com ports which are actually present) */
  54                 if(*ptr < '1' || *ptr > '9')
  55                         return NULL;
  56
  57                 /* Advance pointer past port number */
  58                 while(*ptr >= '0' && *ptr <= '9') ptr++;
  59
  60                 /* The com port number must be followed by a ':' or ' ' */
  61                 if(*ptr != ':' && *ptr != ' ')
  62                         return NULL;
  63
  64                 /* Advance pointer to beginning of next parameter */
  65                 while(*ptr == ' ') ptr++;
  66                 if(*ptr == ':')
  67                 {
  68                         ptr++;
  69                         while(*ptr == ' ') ptr++;
  70                 }
  71         }
  72         /* The device control string must not start with a space. */
  73         else if(*ptr == ' ')
  74                 return NULL;
  75
  76         return ptr;
  77 }
  78
  79 static LPCWSTR COMM_ParseNumber(LPCWSTR ptr, LPDWORD lpnumber)
  80 {
  81         if(*ptr < '0' || *ptr > '9') return NULL;
  82         *lpnumber = wcstoul(ptr, NULL, 10);
  83         while(*ptr >= '0' && *ptr <= '9') ptr++;
  84         return ptr;
  85 }
  86
  87 static LPCWSTR COMM_ParseParity(LPCWSTR ptr, LPBYTE lpparity)
  88 {
  89         /* Contrary to what you might expect, Windows only sets the Parity
  90            member of DCB and not fParity even when parity is specified in the
  91            device control string */
  92
  93         switch(*ptr++)
  94         {
  95         case 'e':
  96         case 'E':
  97                 *lpparity = EVENPARITY;
  98                 break;
  99         case 'm':
 100         case 'M':
 101                 *lpparity = MARKPARITY;
 102                 break;
 103         case 'n':
 104         case 'N':
 105                 *lpparity = NOPARITY;
 106                 break;
 107         case 'o':
 108         case 'O':
 109                 *lpparity = ODDPARITY;
 110                 break;
 111         case 's':
 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
 142         if(!wcsncmp(L"1.5", ptr, 3))
 143         {
 144                 ptr += 3;
 145                 *lpstopbits = ONE5STOPBITS;
 146         }
 147         else
 148         {
 149                 if(!(ptr = COMM_ParseNumber(ptr, &temp)))
 150                         return NULL;
 151
 152                 if(temp == 1)
 153                         *lpstopbits = ONESTOPBIT;
 154                 else if(temp == 2)
 155                         *lpstopbits = TWOSTOPBITS;
 156                 else
 157                         return NULL;
 158         }
 159
 160         return ptr;
 161 }
 162
 163 static LPCWSTR COMM_ParseOnOff(LPCWSTR ptr, LPDWORD lponoff)
 164 {
 165         if(!wcsnicmp(L"on", ptr, 2))
 166         {
 167                 ptr += 2;
 168                 *lponoff = 1;
 169         }
 170         else if(!wcsnicmp(L"off", ptr, 3))
 171         {
 172                 ptr += 3;
 173                 *lponoff = 0;
 174         }
 175         else
 176                 return NULL;
 177
 178         return ptr;
 179 }
 180
 181 /***********************************************************************
 182  *           COMM_BuildOldCommDCB   (Internal)
 183  *
 184  *  Build a DCB using the old style settings string eg: "96,n,8,1"
 185  */
 186 static BOOL COMM_BuildOldCommDCB(LPCWSTR device, LPDCB lpdcb)
 187 {
 188         WCHAR last = 0;
 189
 190         if(!(device = COMM_ParseNumber(device, &lpdcb->BaudRate)))
 191                 return FALSE;
 192
 193         switch(lpdcb->BaudRate)
 194         {
 195         case 11:
 196         case 30:
 197         case 60:
 198                 lpdcb->BaudRate *= 10;
 199                 break;
 200         case 12:
 201         case 24:
 202         case 48:
 203         case 96:
 204                 lpdcb->BaudRate *= 100;
 205                 break;
 206         case 19:
 207                 lpdcb->BaudRate = 19200;
 208                 break;
 209         }
 210
 211         while(*device == ' ') device++;
 212         if(*device++ != ',') return FALSE;
 213         while(*device == ' ') device++;
 214
 215         if(!(device = COMM_ParseParity(device, &lpdcb->Parity)))
 216                 return FALSE;
 217
 218         while(*device == ' ') device++;
 219         if(*device++ != ',') return FALSE;
 220         while(*device == ' ') device++;
 221
 222         if(!(device = COMM_ParseByteSize(device, &lpdcb->ByteSize)))
 223                 return FALSE;
 224
 225         while(*device == ' ') device++;
 226         if(*device++ != ',') return FALSE;
 227         while(*device == ' ') device++;
 228
 229         if(!(device = COMM_ParseStopBits(device, &lpdcb->StopBits)))
 230                 return FALSE;
 231
 232         /* The last parameter for flow control is optional. */
 233         while(*device == ' ') device++;
 234         if(*device == ',')
 235         {
 236                 device++;
 237                 while(*device == ' ') device++;
 238                 if(*device) last = *device++;
 239                 while(*device == ' ') device++;
 240         }
 241
 242         /* Win NT sets the flow control members based on (or lack of) the last
 243            parameter.  Win 9x does not set these members. */
 244         switch(last)
 245         {
 246         case 0:
 247                 lpdcb->fInX = FALSE;
 248                 lpdcb->fOutX = FALSE;
 249                 lpdcb->fOutxCtsFlow = FALSE;
 250                 lpdcb->fOutxDsrFlow = FALSE;
 251                 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
 252                 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
 253                 break;
 254         case 'x':
 255         case 'X':
 256                 lpdcb->fInX = TRUE;
 257                 lpdcb->fOutX = TRUE;
 258                 lpdcb->fOutxCtsFlow = FALSE;
 259                 lpdcb->fOutxDsrFlow = FALSE;
 260                 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
 261                 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
 262                 break;
 263         case 'p':
 264         case 'P':
 265                 lpdcb->fInX = FALSE;
 266                 lpdcb->fOutX = FALSE;
 267                 lpdcb->fOutxCtsFlow = TRUE;
 268                 lpdcb->fOutxDsrFlow = TRUE;
 269                 lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE;
 270                 lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
 271                 break;
 272         default:
 273                 return FALSE;
 274         }
 275
 276         /* This should be the end of the string. */
 277         if(*device) return FALSE;
 278
 279         return TRUE;
 280 }
 281
 282 /***********************************************************************
 283  *           COMM_BuildNewCommDCB   (Internal)
 284  *
 285  *  Build a DCB using the new style settings string.
 286  *   eg: "baud=9600 parity=n data=8 stop=1 xon=on to=on"
 287  */
 288 static BOOL COMM_BuildNewCommDCB(LPCWSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
 289 {
 290         DWORD temp;
 291         BOOL baud = FALSE, stop = FALSE;
 292
 293         while(*device)
 294         {
 295                 while(*device == ' ') device++;
 296
 297                 if(!wcsnicmp(L"baud=", device, 5))
 298                 {
 299                         baud = TRUE;
 300
 301                         if(!(device = COMM_ParseNumber(device + 5, &lpdcb->BaudRate)))
 302                                 return FALSE;
 303                 }
 304                 else if(!wcsnicmp(L"parity=", device, 7))
 305                 {
 306                         if(!(device = COMM_ParseParity(device + 7, &lpdcb->Parity)))
 307                                 return FALSE;
 308                 }
 309                 else if(!wcsnicmp(L"data=", device, 5))
 310                 {
 311                         if(!(device = COMM_ParseByteSize(device + 5, &lpdcb->ByteSize)))
 312                                 return FALSE;
 313                 }
 314                 else if(!wcsnicmp(L"stop=", device, 5))
 315                 {
 316                         stop = TRUE;
 317
 318                         if(!(device = COMM_ParseStopBits(device + 5, &lpdcb->StopBits)))
 319                                 return FALSE;
 320                 }
 321                 else if(!wcsnicmp(L"to=", device, 3))
 322                 {
 323                         if(!(device = COMM_ParseOnOff(device + 3, &temp)))
 324                                 return FALSE;
 325
 326                         lptimeouts->ReadIntervalTimeout = 0;
 327                         lptimeouts->ReadTotalTimeoutMultiplier = 0;
 328                         lptimeouts->ReadTotalTimeoutConstant = 0;
 329                         lptimeouts->WriteTotalTimeoutMultiplier = 0;
 330                         lptimeouts->WriteTotalTimeoutConstant = temp ? 60000 : 0;
 331                 }
 332                 else if(!wcsnicmp(L"xon=", device, 4))
 333                 {
 334                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 335                                 return FALSE;
 336
 337                         lpdcb->fOutX = temp;
 338                         lpdcb->fInX = temp;
 339                 }
 340                 else if(!wcsnicmp(L"odsr=", device, 5))
 341                 {
 342                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 343                                 return FALSE;
 344
 345                         lpdcb->fOutxDsrFlow = temp;
 346                 }
 347                 else if(!wcsnicmp(L"octs=", device, 5))
 348                 {
 349                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 350                                 return FALSE;
 351
 352                         lpdcb->fOutxCtsFlow = temp;
 353                 }
 354                 else if(!wcsnicmp(L"dtr=", device, 4))
 355                 {
 356                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 357                                 return FALSE;
 358
 359                         lpdcb->fDtrControl = temp;
 360                 }
 361                 else if(!wcsnicmp(L"rts=", device, 4))
 362                 {
 363                         if(!(device = COMM_ParseOnOff(device + 4, &temp)))
 364                                 return FALSE;
 365
 366                         lpdcb->fRtsControl = temp;
 367                 }
 368                 else if(!wcsnicmp(L"idsr=", device, 5))
 369                 {
 370                         if(!(device = COMM_ParseOnOff(device + 5, &temp)))
 371                                 return FALSE;
 372
 373                         /* Win NT sets the fDsrSensitivity member based on the
 374                            idsr parameter.  Win 9x sets fOutxDsrFlow instead. */
 375                         lpdcb->fDsrSensitivity = temp;
 376                 }
 377                 else
 378                         return FALSE;
 379
 380                 /* After the above parsing, the next character (if not the end of
 381                    the string) should be a space */
 382                 if(*device && *device != ' ')
 383                         return FALSE;
 384         }
 385
 386         /* If stop bits were not specified, a default is always supplied. */
 387         if(!stop)
 388         {
 389                 if(baud && lpdcb->BaudRate == 110)
 390                         lpdcb->StopBits = TWOSTOPBITS;
 391                 else
 392                         lpdcb->StopBits = ONESTOPBIT;
 393         }
 394
 395         return TRUE;
 396 }
 397
 398 /**************************************************************************
 399  *         BuildCommDCBA                (KERNEL32.@)
 400  *
 401  *  Updates a device control block data structure with values from an
 402  *  ascii device control string.  The device control string has two forms
 403  *  normal and extended, it must be exclusively in one or the other form.
 404  *
 405  * RETURNS
 406  *
 407  *  True on success, false on a malformed control string.
 408  */
 409 BOOL WINAPI BuildCommDCBA(
 410     LPCSTR device, /* [in] The ascii device control string used to update the DCB. */
 411     LPDCB  lpdcb)  /* [out] The device control block to be updated. */
 412 {
 413         return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
 414 }
 415
 416 /**************************************************************************
 417  *         BuildCommDCBAndTimeoutsA             (KERNEL32.@)
 418  *
 419  *  Updates a device control block data structure with values from an
 420  *  ascii device control string.  Taking timeout values from a timeouts
 421  *  struct if desired by the control string.
 422  *
 423  * RETURNS
 424  *
 425  *  True on success, false bad handles etc.
 426  */
 427 BOOL WINAPI BuildCommDCBAndTimeoutsA(
 428     LPCSTR         device,     /* [in] The ascii device control string. */
 429     LPDCB          lpdcb,      /* [out] The device control block to be updated. */
 430     LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
 431 {
 432         BOOL ret = FALSE;
 433         UNICODE_STRING deviceW;
 434
 435         TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
 436         if(device) RtlCreateUnicodeStringFromAsciiz(&deviceW,device);
 437         else deviceW.Buffer = NULL;
 438
 439         if(deviceW.Buffer) ret = BuildCommDCBAndTimeoutsW(deviceW.Buffer,lpdcb,lptimeouts);
 440
 441         RtlFreeUnicodeString(&deviceW);
 442         return ret;
 443 }
 444
 445 /**************************************************************************
 446  *         BuildCommDCBAndTimeoutsW     (KERNEL32.@)
 447  *
 448  *  Updates a device control block data structure with values from a
 449  *  unicode device control string.  Taking timeout values from a timeouts
 450  *  struct if desired by the control string.
 451  *
 452  * RETURNS
 453  *
 454  *  True on success, false bad handles etc
 455  */
 456 BOOL WINAPI BuildCommDCBAndTimeoutsW(
 457     LPCWSTR        devid,      /* [in] The unicode device control string. */
 458     LPDCB          lpdcb,      /* [out] The device control block to be updated. */
 459     LPCOMMTIMEOUTS lptimeouts) /* [in] The COMMTIMEOUTS structure to be updated. */
 460 {
 461         DCB dcb;
 462         COMMTIMEOUTS timeouts;
 463         BOOL result;
 464         LPCWSTR ptr = devid;
 465
 466         TRACE("(%s,%p,%p)\n",debugstr_w(devid),lpdcb,lptimeouts);
 467
 468         memset(&timeouts, 0, sizeof timeouts);
 469
 470         /* Set DCBlength. (Windows NT does not do this, but 9x does) */
 471         lpdcb->DCBlength = sizeof(DCB);
 472
 473         /* Make a copy of the original data structures to work with since if
 474            if there is an error in the device control string the originals
 475            should not be modified (except possibly DCBlength) */
 476         dcb = *lpdcb;
 477         if(lptimeouts) timeouts = *lptimeouts;
 478
 479         ptr = COMM_ParseStart(ptr);
 480
 481         if(ptr == NULL)
 482                 result = FALSE;
 483         else if(wcschr(ptr, ','))
 484                 result = COMM_BuildOldCommDCB(ptr, &dcb);
 485         else
 486                 result = COMM_BuildNewCommDCB(ptr, &dcb, &timeouts);
 487
 488         if(result)
 489         {
 490                 *lpdcb = dcb;
 491                 if(lptimeouts) *lptimeouts = timeouts;
 492                 return TRUE;
 493         }
 494         else
 495         {
 496                 WARN("Invalid device control string: %s\n", debugstr_w(devid));
 497                 SetLastError(ERROR_INVALID_PARAMETER);
 498                 return FALSE;
 499         }
 500 }
 501
 502 /**************************************************************************
 503  *         BuildCommDCBW                (KERNEL32.@)
 504  *
 505  *  Updates a device control block structure with values from an
 506  *  unicode device control string.  The device control string has two forms
 507  *  normal and extended, it must be exclusively in one or the other form.
 508  *
 509  * RETURNS
 510  *
 511  *  True on success, false on a malformed control string.
 512  */
 513 BOOL WINAPI BuildCommDCBW(
 514     LPCWSTR devid, /* [in] The unicode device control string. */
 515     LPDCB   lpdcb) /* [out] The device control block to be updated. */
 516 {
 517         return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
 518 }
 519
 520 /***********************************************************************
 521  * FIXME:
 522  * The functionality of CommConfigDialogA, GetDefaultCommConfig and
 523  * SetDefaultCommConfig is implemented in a DLL (usually SERIALUI.DLL).
 524  * This is dependent on the type of COMM port, but since it is doubtful
 525  * anybody will get around to implementing support for fancy serial
 526  * ports in WINE, this is hardcoded for the time being.  The name of
 527  * this DLL should be stored in and read from the system registry in
 528  * the hive HKEY_LOCAL_MACHINE, key
 529  * System\\CurrentControlSet\\Services\\Class\\Ports\\????
 530  * where ???? is the port number... that is determined by PNP
 531  * The DLL should be loaded when the COMM port is opened, and closed
 532  * when the COMM port is closed. - MJM 20 June 2000
 533  ***********************************************************************/
 534 static const WCHAR lpszSerialUI[] = L"serialui.dll";
 535
 536
 537 /***********************************************************************
 538  *           CommConfigDialogA   (KERNEL32.@)
 539  *
 540  * Raises a dialog that allows the user to configure a comm port.
 541  * Fills the COMMCONFIG struct with information specified by the user.
 542  * This function should call a similar routine in the COMM driver...
 543  *
 544  * RETURNS
 545  *
 546  *  TRUE on success, FALSE on failure
 547  *  If successful, the lpCommConfig structure will contain a new
 548  *  configuration for the comm port, as specified by the user.
 549  *
 550  * BUGS
 551  *  The library with the CommConfigDialog code is never unloaded.
 552  * Perhaps this should be done when the comm port is closed?
 553  */
 554 BOOL WINAPI CommConfigDialogA(
 555     LPCSTR lpszDevice,         /* [in] name of communications device */
 556     HWND hWnd,                 /* [in] parent window for the dialog */
 557     LPCOMMCONFIG lpCommConfig) /* [out] pointer to struct to fill */
 558 {
 559     LPWSTR  lpDeviceW = NULL;
 560     DWORD   len;
 561     BOOL    r;
 562
 563     TRACE("(%s, %p, %p)\n", debugstr_a(lpszDevice), hWnd, lpCommConfig);
 564
 565     if (lpszDevice)
 566     {
 567         len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
 568         lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 569         MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
 570     }
 571     r = CommConfigDialogW(lpDeviceW, hWnd, lpCommConfig);
 572     HeapFree( GetProcessHeap(), 0, lpDeviceW );
 573     return r;
 574 }
 575
 576 /***********************************************************************
 577  *           CommConfigDialogW   (KERNEL32.@)
 578  *
 579  * See CommConfigDialogA.
 580  */
 581 BOOL WINAPI CommConfigDialogW(
 582     LPCWSTR lpszDevice,        /* [in] name of communications device */
 583     HWND hWnd,                 /* [in] parent window for the dialog */
 584     LPCOMMCONFIG lpCommConfig) /* [out] pointer to struct to fill */
 585 {
 586     DWORD (WINAPI *pCommConfigDialog)(LPCWSTR, HWND, LPCOMMCONFIG);
 587     HMODULE hConfigModule;
 588     DWORD   res = ERROR_INVALID_PARAMETER;
 589
 590     TRACE("(%s, %p, %p)\n", debugstr_w(lpszDevice), hWnd, lpCommConfig);
 591     hConfigModule = LoadLibraryW(lpszSerialUI);
 592
 593     if (hConfigModule) {
 594         pCommConfigDialog = (void *)GetProcAddress(hConfigModule, "drvCommConfigDialogW");
 595         if (pCommConfigDialog) {
 596             res = pCommConfigDialog(lpszDevice, hWnd, lpCommConfig);
 597         }
 598         FreeLibrary(hConfigModule);
 599     }
 600
 601     if (res) SetLastError(res);
 602     return (res == ERROR_SUCCESS);
 603 }
 604
 605 /***********************************************************************
 606  *           SetDefaultCommConfigW  (KERNEL32.@)
 607  *
 608  * Initializes the default configuration for a communication device.
 609  *
 610  * PARAMS
 611  *  lpszDevice   [I] Name of the device targeted for configuration
 612  *  lpCommConfig [I] PTR to a buffer with the configuration for the device
 613  *  dwSize       [I] Number of bytes in the buffer
 614  *
 615  * RETURNS
 616  *  Failure: FALSE
 617  *  Success: TRUE, and default configuration saved
 618  *
 619  */
 620 BOOL WINAPI SetDefaultCommConfigW(LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
 621 {
 622     BOOL (WINAPI *lpfnSetDefaultCommConfig)(LPCWSTR, LPCOMMCONFIG, DWORD);
 623     HMODULE hConfigModule;
 624     BOOL r = FALSE;
 625
 626     TRACE("(%s, %p, %u)\n", debugstr_w(lpszDevice), lpCommConfig, dwSize);
 627
 628     hConfigModule = LoadLibraryW(lpszSerialUI);
 629     if(!hConfigModule)
 630         return r;
 631
 632     lpfnSetDefaultCommConfig = (void *)GetProcAddress(hConfigModule, "drvSetDefaultCommConfigW");
 633     if (lpfnSetDefaultCommConfig)
 634         r = lpfnSetDefaultCommConfig(lpszDevice, lpCommConfig, dwSize);
 635
 636     FreeLibrary(hConfigModule);
 637
 638     return r;
 639 }
 640
 641
 642 /***********************************************************************
 643  *           SetDefaultCommConfigA     (KERNEL32.@)
 644  *
 645  * Initializes the default configuration for a communication device.
 646  *
 647  * See SetDefaultCommConfigW.
 648  *
 649  */
 650 BOOL WINAPI SetDefaultCommConfigA(LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
 651 {
 652     BOOL r;
 653     LPWSTR lpDeviceW = NULL;
 654     DWORD len;
 655
 656     TRACE("(%s, %p, %u)\n", debugstr_a(lpszDevice), lpCommConfig, dwSize);
 657
 658     if (lpszDevice)
 659     {
 660         len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
 661         lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 662         MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
 663     }
 664     r = SetDefaultCommConfigW(lpDeviceW,lpCommConfig,dwSize);
 665     HeapFree( GetProcessHeap(), 0, lpDeviceW );
 666     return r;
 667 }
 668
 669
 670 /***********************************************************************
 671  *           GetDefaultCommConfigW   (KERNEL32.@)
 672  *
 673  *   Acquires the default configuration of the specified communication device. (unicode)
 674  *
 675  *  RETURNS
 676  *
 677  *   True on successful reading of the default configuration,
 678  *   if the device is not found or the buffer is too small.
 679  */
 680 BOOL WINAPI GetDefaultCommConfigW(
 681     LPCWSTR      lpszName, /* [in] The unicode name of the device targeted for configuration. */
 682     LPCOMMCONFIG lpCC,     /* [out] The default configuration for the device. */
 683     LPDWORD      lpdwSize) /* [in/out] Initially the size of the default configuration buffer,
 684                               afterwards the number of bytes copied to the buffer or
 685                               the needed size of the buffer. */
 686 {
 687     DWORD (WINAPI *pGetDefaultCommConfig)(LPCWSTR, LPCOMMCONFIG, LPDWORD);
 688     HMODULE hConfigModule;
 689     DWORD   res = ERROR_INVALID_PARAMETER;
 690
 691     TRACE("(%s, %p, %p)  *lpdwSize: %u\n", debugstr_w(lpszName), lpCC, lpdwSize, lpdwSize ? *lpdwSize : 0 );
 692     hConfigModule = LoadLibraryW(lpszSerialUI);
 693
 694     if (hConfigModule) {
 695         pGetDefaultCommConfig = (void *)GetProcAddress(hConfigModule, "drvGetDefaultCommConfigW");
 696         if (pGetDefaultCommConfig) {
 697             res = pGetDefaultCommConfig(lpszName, lpCC, lpdwSize);
 698         }
 699         FreeLibrary(hConfigModule);
 700     }
 701
 702     if (res) SetLastError(res);
 703     return (res == ERROR_SUCCESS);
 704 }
 705
 706 /**************************************************************************
 707  *         GetDefaultCommConfigA                (KERNEL32.@)
 708  *
 709  *   Acquires the default configuration of the specified communication device. (ascii)
 710  *
 711  *  RETURNS
 712  *
 713  *   True on successful reading of the default configuration,
 714  *   if the device is not found or the buffer is too small.
 715  */
 716 BOOL WINAPI GetDefaultCommConfigA(
 717     LPCSTR       lpszName, /* [in] The ascii name of the device targeted for configuration. */
 718     LPCOMMCONFIG lpCC,     /* [out] The default configuration for the device. */
 719     LPDWORD      lpdwSize) /* [in/out] Initially the size of the default configuration buffer,
 720                               afterwards the number of bytes copied to the buffer or
 721                               the needed size of the buffer. */
 722 {
 723         BOOL ret = FALSE;
 724         UNICODE_STRING lpszNameW;
 725
 726         TRACE("(%s, %p, %p)  *lpdwSize: %u\n", debugstr_a(lpszName), lpCC, lpdwSize, lpdwSize ? *lpdwSize : 0 );
 727         if(lpszName) RtlCreateUnicodeStringFromAsciiz(&lpszNameW,lpszName);
 728         else lpszNameW.Buffer = NULL;
 729
 730         ret = GetDefaultCommConfigW(lpszNameW.Buffer,lpCC,lpdwSize);
 731
 732         RtlFreeUnicodeString(&lpszNameW);
 733         return ret;
 734 }