dlls/serialui/confdlg.c

   1 /*
   2  * This DLL contains the user interface for the serial driver.
   3  *    a dialog box to configure the specified COMM port
   4  *    an interface to the control panel (??)
   5  *    functions to load and save default configuration
   6  *
   7  * Eventually the 32 bit comm port driver could be moved into here
   8  * and interfaced to KERNEL32 using the WIN95 or WINNT comm driver interface.
   9  * This way, different driver DLLS could be written to support other
  10  * serial interfaces, such as X.25, etc.
  11  *
  12  * Basic structure copied from COMCTL32 code.
  13  *
  14  * Copyright 2000, 2004 Mike McCormack
  15  *
  16  * This library is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU Lesser General Public
  18  * License as published by the Free Software Foundation; either
  19  * version 2.1 of the License, or (at your option) any later version.
  20  *
  21  * This library is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  * Lesser General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU Lesser General Public
  27  * License along with this library; if not, write to the Free Software
  28  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  29  */
  30
  31 #include "config.h"
  32 #include "wine/port.h"
  33 #include "wine/unicode.h"
  34
  35 #include <string.h>
  36 #include <stdarg.h>
  37 #include <stdio.h>
  38
  39 #include "windef.h"
  40 #include "winbase.h"
  41 #include "winreg.h"
  42 #include "wingdi.h"
  43 #include "winuser.h"
  44 #include "wine/debug.h"
  45 #include "serialui.h"
  46 #include "winerror.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(comm);
  49
  50 static HMODULE SERIALUI_hModule;
  51
  52 static const WCHAR comW[] = {'c','o','m',0 };
  53
  54 /***********************************************************************
  55  * DllMain [Internal] Initializes the internal 'SERIALUI.DLL'.
  56  *
  57  * PARAMS
  58  *     hinstDLL    [I] handle to the DLL's instance
  59  *     fdwReason   [I]
  60  *     lpvReserved [I] reserved, must be NULL
  61  *
  62  * RETURNS
  63  *     Success: TRUE
  64  *     Failure: FALSE
  65  */
  66
  67 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  68 {
  69     TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
  70
  71     switch (fdwReason) {
  72         case DLL_PROCESS_ATTACH:
  73             DisableThreadLibraryCalls(hinstDLL);
  74             SERIALUI_hModule = hinstDLL;
  75             break;
  76         case DLL_PROCESS_DETACH:
  77             break;
  78     }
  79
  80     return TRUE;
  81 }
  82
  83
  84 /***********************************************************************
  85  * EnumPropPages (SERIALUI.2)
  86  *
  87  * Called by the device manager to add prop sheets in Control Panel ???
  88  * Pointed to in Win98 registry by
  89  * \System\CurrentControlSet\Services\Class\ports\0000\EnumPropPages =
  90  *  "serialui.dll,EnumPropPages"
  91  */
  92 typedef LPVOID LPDEVICE_INFO;
  93 typedef LPVOID LPFNADDPROPSHEETPAGE;
  94 BOOL WINAPI EnumPropPages(LPDEVICE_INFO pdi, LPFNADDPROPSHEETPAGE pfnAdd, LPARAM lParam )
  95 {
  96     FIXME("(%p %p %lx)\n",pdi,pfnAdd,lParam);
  97     return FALSE;
  98 }
  99
 100 /*
 101  * These data structures are convert from values used in fields of a DCB
 102  * to strings used in the CommConfigDialog.
 103  */
 104 typedef struct tagPARAM2STRDATA
 105 {
 106     DWORD        val;
 107     CONST CHAR  *name;
 108 } PARAM2STRDATA, *LPPARAM2STRDATA;
 109
 110 typedef struct tagPARAM2STR
 111 {
 112     DWORD         dwSize;
 113     LPPARAM2STRDATA data;
 114 } PARAM2STR, *LPPARAM2STR;
 115 typedef const PARAM2STR *LPCPARAM2STR;
 116
 117 #define SERIALUI_TABLESIZE(x) ((sizeof (x))/(sizeof (x[0])))
 118
 119 static PARAM2STRDATA SERIALUI_Baud2StrData[]={
 120   {110, "110"}, {300, "300"}, {600, "600"}, {1200, "1200"},
 121   {2400, "2400"}, {4800, "4800"}, {9600, "9600"}, {14400, "14400"},
 122   {19200, "19200"}, {38400L, "38400"}, {56000L, "56000"}, {57600L, "57600"},
 123   {115200L, "115200"}, {128000L, "128000"}, {256000L, "256000"}
 124 };
 125 static PARAM2STR SERIALUI_Baud2Str={ SERIALUI_TABLESIZE(SERIALUI_Baud2StrData),SERIALUI_Baud2StrData };
 126
 127 static PARAM2STRDATA SERIALUI_Parity2StrData[]={
 128   {NOPARITY,"None"}, {ODDPARITY,"Odd"}, {EVENPARITY,"Even"}, {MARKPARITY,"Mark"},
 129   {SPACEPARITY,"Space"}
 130 };
 131 static PARAM2STR SERIALUI_Parity2Str={ SERIALUI_TABLESIZE(SERIALUI_Parity2StrData),SERIALUI_Parity2StrData };
 132
 133 static PARAM2STRDATA SERIALUI_Stop2StrData[]={
 134   {ONESTOPBIT,"1"}, {ONE5STOPBITS,"1.5"}, {TWOSTOPBITS,"2"}
 135 };
 136 static PARAM2STR SERIALUI_Stop2Str={ SERIALUI_TABLESIZE(SERIALUI_Stop2StrData),SERIALUI_Stop2StrData };
 137
 138 static PARAM2STRDATA SERIALUI_Data2StrData[]={
 139   {5,"5"}, {6,"6"}, {7,"7"}, {8, "8"}, {16,"16"}
 140 };
 141 static PARAM2STR SERIALUI_Data2Str={ SERIALUI_TABLESIZE(SERIALUI_Data2StrData),SERIALUI_Data2StrData };
 142
 143 static PARAM2STRDATA SERIALUI_Flow2StrData[]={
 144   {0,"None"}, {1,"Hardware (RTS/CTS)"}, {2,"Software (XON/XOFF)"}
 145 };
 146 static PARAM2STR SERIALUI_Flow2Str={ SERIALUI_TABLESIZE(SERIALUI_Flow2StrData),SERIALUI_Flow2StrData };
 147
 148 /*
 149  * Add all the fields to a combo box and highlight the current value
 150  */
 151 static void SERIALUI_AddConfItems(HWND hDlg, DWORD id, LPCPARAM2STR table, DWORD dwVal)
 152 {
 153     unsigned int i;
 154     int n;
 155     HWND hControl = GetDlgItem(hDlg,id);
 156
 157     if(!hControl)
 158         return;
 159
 160     for(i=0; i<table->dwSize; i++)
 161     {
 162         n = SendMessageA(hControl, CB_ADDSTRING, 0L, (LPARAM)table->data[i].name);
 163         if(dwVal == table->data[i].val)
 164         {
 165             SendMessageA(hControl, CB_SETCURSEL, (WPARAM)n, (LPARAM)0);
 166         }
 167     }
 168 }
 169
 170 /*
 171  * Get the current selection of the given combo box and set a DCB field to
 172  * the value matching that selection.
 173  */
 174 static BOOL SERIALUI_GetConfItems(HWND hDlg, DWORD id, LPCPARAM2STR table, LPDWORD lpdwVal)
 175 {
 176     DWORD i;
 177     CHAR lpEntry[20];
 178     HWND hControl = GetDlgItem(hDlg,id);
 179
 180     if( (!hControl) || (!lpdwVal))
 181     {
 182         TRACE("Couldn't get window handle for item %x\n",id);
 183         return FALSE;
 184     }
 185
 186     if(!GetWindowTextA(hControl, &lpEntry[0], sizeof(lpEntry)))
 187     {
 188         TRACE("Couldn't get window text for item %x\n",id);
 189         return FALSE;
 190     }
 191     /* TRACE("%ld contains %s\n",id, lpEntry); */
 192
 193     for(i=0; i<table->dwSize; i++)
 194     {
 195         if(!lstrcmpA(table->data[i].name,lpEntry))
 196         {
 197             *lpdwVal = table->data[i].val;
 198             return TRUE;
 199         }
 200     }
 201
 202     return FALSE;
 203 }
 204
 205 /*
 206  * Both the enumerated values CBR_XXXX and integer baud rates are valid
 207  * dcb.BaudRate. This code is to convert back and forth between CBR_ style
 208  * and integers. The dialog box uses integer values.
 209  */
 210 static const DWORD SERIALUI_BaudConvertTable[] =  {
 211   CBR_110, 110, CBR_300, 300, CBR_600, 600, CBR_1200, 1200,
 212   CBR_2400, 2400, CBR_4800, 4800, CBR_9600, 9600, CBR_14400, 14400,
 213   CBR_19200, 19200, CBR_38400, 38400, CBR_56000, 56000, CBR_57600, 57600,
 214   CBR_115200, 115200, CBR_128000, 128000, CBR_256000, 256000
 215 };
 216
 217 static BOOL SERIALUI_MakeBaudDword(LPDWORD lpdwBaudRate)
 218 {
 219     unsigned int i;
 220
 221     for(i=0; i<(sizeof(SERIALUI_BaudConvertTable)/sizeof(DWORD)); i+=2)
 222     {
 223         if(*lpdwBaudRate == SERIALUI_BaudConvertTable[i])
 224         {
 225             *lpdwBaudRate = SERIALUI_BaudConvertTable[i+1];
 226             return TRUE;
 227         }
 228     }
 229     return FALSE;
 230 }
 231
 232 static BOOL SERIALUI_MakeBaudEnum(LPDWORD lpdwBaudRate)
 233 {
 234     unsigned int i;
 235
 236     for(i=0; i<(sizeof(SERIALUI_BaudConvertTable)/sizeof(DWORD)); i+=2)
 237     {
 238         if(*lpdwBaudRate == SERIALUI_BaudConvertTable[i+1])
 239         {
 240             *lpdwBaudRate = SERIALUI_BaudConvertTable[i];
 241             return TRUE;
 242         }
 243     }
 244     return FALSE;
 245 }
 246
 247 typedef struct tagSERIALUI_DialogInfo
 248 {
 249     LPCWSTR lpszDevice;
 250     LPCOMMCONFIG lpCommConfig;
 251     BOOL bConvert; /* baud rate was converted to a DWORD */
 252     DWORD dwFlowControl; /* old flow control */
 253 } SERIALUI_DialogInfo;
 254
 255 static void SERIALUI_DCBToDialogInfo(HWND hDlg, SERIALUI_DialogInfo *info)
 256 {
 257     DWORD dwBaudRate, dwStopBits, dwParity, dwByteSize, dwFlowControl;
 258     LPDCB lpdcb = &info->lpCommConfig->dcb;
 259
 260     /* pass integer pointers to SERIALUI_ dialog config fns */
 261     dwBaudRate    = lpdcb->BaudRate;
 262     dwStopBits    = lpdcb->StopBits;
 263     dwParity      = lpdcb->Parity;
 264     dwByteSize    = lpdcb->ByteSize;
 265
 266     /* map flow control state, if it looks normal */
 267     if((lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE) ||
 268        (lpdcb->fOutxCtsFlow)) {
 269         dwFlowControl = 1;
 270     } else if(lpdcb->fOutX || lpdcb->fInX) {
 271         dwFlowControl = 2;
 272     } else {
 273         dwFlowControl = 0;
 274     }
 275
 276     info->bConvert = SERIALUI_MakeBaudDword(&dwBaudRate);
 277
 278     SERIALUI_AddConfItems( hDlg, IDC_BAUD, &SERIALUI_Baud2Str ,dwBaudRate);
 279     SERIALUI_AddConfItems( hDlg, IDC_STOP, &SERIALUI_Stop2Str ,dwStopBits);
 280     SERIALUI_AddConfItems( hDlg, IDC_PARITY, &SERIALUI_Parity2Str ,dwParity);
 281     SERIALUI_AddConfItems( hDlg, IDC_DATA, &SERIALUI_Data2Str ,dwByteSize);
 282     SERIALUI_AddConfItems( hDlg, IDC_FLOW, &SERIALUI_Flow2Str, dwFlowControl );
 283
 284     info->dwFlowControl = dwFlowControl;
 285 }
 286
 287 static void SERIALUI_DialogInfoToDCB(HWND hDlg, SERIALUI_DialogInfo *info)
 288 {
 289     DWORD dwBaudRate, dwStopBits, dwParity, dwByteSize, dwFlowControl;
 290     LPDCB lpdcb = &info->lpCommConfig->dcb;
 291
 292     SERIALUI_GetConfItems( hDlg, IDC_BAUD, &SERIALUI_Baud2Str, &dwBaudRate);
 293     SERIALUI_GetConfItems( hDlg, IDC_STOP, &SERIALUI_Stop2Str, &dwStopBits);
 294     SERIALUI_GetConfItems( hDlg, IDC_PARITY, &SERIALUI_Parity2Str, &dwParity);
 295     SERIALUI_GetConfItems( hDlg, IDC_DATA, &SERIALUI_Data2Str, &dwByteSize);
 296     SERIALUI_GetConfItems( hDlg, IDC_FLOW, &SERIALUI_Flow2Str, &dwFlowControl );
 297
 298     TRACE("baud=%d stop=%d parity=%d data=%d flow=%d\n",
 299           dwBaudRate, dwStopBits, dwParity, dwByteSize, dwFlowControl);
 300
 301     lpdcb->BaudRate = dwBaudRate;
 302     lpdcb->StopBits = dwStopBits;
 303     lpdcb->Parity   = dwParity;
 304     lpdcb->ByteSize = dwByteSize;
 305
 306     /* try not to change flow control if the user didn't change it */
 307     if(info->dwFlowControl != dwFlowControl)
 308     {
 309         switch(dwFlowControl)
 310         {
 311         case 0:
 312             lpdcb->fOutxCtsFlow = FALSE;
 313             lpdcb->fOutxDsrFlow = FALSE;
 314             lpdcb->fDtrControl  = DTR_CONTROL_DISABLE;
 315             lpdcb->fOutX        = FALSE;
 316             lpdcb->fInX         = FALSE;
 317             lpdcb->fRtsControl  = RTS_CONTROL_DISABLE;
 318             break;
 319         case 1: /* CTS/RTS */
 320             lpdcb->fOutxCtsFlow = TRUE;
 321             lpdcb->fOutxDsrFlow = FALSE;
 322             lpdcb->fDtrControl  = DTR_CONTROL_DISABLE;
 323             lpdcb->fOutX        = FALSE;
 324             lpdcb->fInX         = FALSE;
 325             lpdcb->fRtsControl  = RTS_CONTROL_HANDSHAKE;
 326             break;
 327         case 2:
 328             lpdcb->fOutxCtsFlow = FALSE;
 329             lpdcb->fOutxDsrFlow = FALSE;
 330             lpdcb->fDtrControl  = DTR_CONTROL_DISABLE;
 331             lpdcb->fOutX        = TRUE;
 332             lpdcb->fInX         = TRUE;
 333             lpdcb->fRtsControl  = RTS_CONTROL_DISABLE;
 334             break;
 335         }
 336     }
 337
 338     if(info->bConvert)
 339         SERIALUI_MakeBaudEnum(&lpdcb->BaudRate);
 340 }
 341
 342 /***********************************************************************
 343  * SERIALUI_ConfigDialogProc
 344  *
 345  * Shows a dialog for configuring a COMM port
 346  */
 347 static INT_PTR CALLBACK SERIALUI_ConfigDialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 348 {
 349     static const WCHAR szSettings[] = {
 350         'S','e','t','t','i','n','g','s',' ','f','o','r',' ',0
 351     };
 352     WCHAR szTitle[40];
 353     SERIALUI_DialogInfo *info;
 354
 355     switch (uMsg)
 356     {
 357     case WM_INITDIALOG:
 358         info = (SERIALUI_DialogInfo*) lParam;
 359         if(!info)
 360             return FALSE;
 361         SetWindowLongPtrW(hWnd, DWLP_USER, lParam);
 362         strcpyW( szTitle, szSettings );
 363         strcatW( szTitle, info->lpszDevice );
 364         SetWindowTextW(hWnd, szTitle);
 365         SERIALUI_DCBToDialogInfo(hWnd, info);
 366         return TRUE;
 367
 368     case WM_COMMAND:
 369     {
 370         WORD wID = LOWORD(wParam);
 371
 372         info = (SERIALUI_DialogInfo *) GetWindowLongPtrW(hWnd, DWLP_USER);
 373         if(!info)
 374             EndDialog(hWnd,0);
 375         switch (wID)
 376         {
 377         case IDOK:
 378             SERIALUI_DialogInfoToDCB(hWnd,info);
 379             EndDialog(hWnd, ERROR_SUCCESS);
 380             return TRUE;
 381         case IDCANCEL:
 382             EndDialog(hWnd, ERROR_CANCELLED);
 383             return TRUE;
 384 /* test code for Get/SetDefaultCommConfig begins */
 385         case ID_GETDEFAULT:
 386             {
 387                 DWORD r,dwConfSize = sizeof (COMMCONFIG);
 388                 r = GetDefaultCommConfigW(info->lpszDevice,
 389                           info->lpCommConfig, &dwConfSize);
 390                 if(!r)
 391                     MessageBoxA(hWnd,"Failed","GetDefaultCommConfig",MB_OK);
 392             }
 393             SERIALUI_DCBToDialogInfo(hWnd, info);
 394             break;
 395         case ID_SETDEFAULT:
 396             {
 397                 DWORD r;
 398                 SERIALUI_DialogInfoToDCB(hWnd,info);
 399                 r = SetDefaultCommConfigW(info->lpszDevice,
 400                           info->lpCommConfig, sizeof (COMMCONFIG));
 401                 if(!r)
 402                     MessageBoxA(hWnd,"Failed","GetDefaultCommConfig",MB_OK);
 403             }
 404             break;
 405 /* test code for Get/SetDefaultCommConfig ends */
 406         }
 407     }
 408     default:
 409         return FALSE;
 410     }
 411 }
 412
 413 static LPWSTR SERIALUI_strdup( LPCSTR str )
 414 {
 415     DWORD len;
 416     LPWSTR strW;
 417
 418     if (!str)
 419         return NULL;
 420     len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 421     strW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
 422     MultiByteToWideChar( CP_ACP, 0, str, -1, strW, len );
 423     return strW;
 424 }
 425
 426 static VOID SERIALUI_strfree( LPWSTR strW )
 427 {
 428     HeapFree( GetProcessHeap(), 0, strW );
 429 }
 430
 431 /***********************************************************************
 432  * drvCommConfigDialogW (SERIALUI.@)
 433  *
 434  * Show a dialog for configuring a Serial Port.
 435  *
 436  */
 437 DWORD WINAPI drvCommConfigDialogW(LPCWSTR lpszName, HWND hWndParent, LPCOMMCONFIG lpCommConfig)
 438 {
 439     SERIALUI_DialogInfo info;
 440     INT res;
 441
 442     info.lpCommConfig  = lpCommConfig;
 443     info.lpszDevice    = lpszName;
 444     info.bConvert      = FALSE;
 445     info.dwFlowControl = 0;
 446
 447     if ((!lpCommConfig) || (!lpszName))
 448         return ERROR_INVALID_PARAMETER;
 449
 450     if (lpCommConfig->dwSize < sizeof(COMMCONFIG))
 451         return ERROR_INSUFFICIENT_BUFFER;
 452
 453     if (!lpszName[0])
 454         return ERROR_BADKEY;
 455
 456     res = DialogBoxParamW( SERIALUI_hModule,
 457                            MAKEINTRESOURCEW(IDD_SERIALUICONFIG),
 458                            hWndParent,
 459                            SERIALUI_ConfigDialogProc,
 460                            (LPARAM)&info);
 461
 462     return (res == -1) ? GetLastError() : res ;
 463 }
 464
 465 /***********************************************************************
 466  * drvCommConfigDialogA (SERIALUI.@)
 467  */
 468 DWORD WINAPI drvCommConfigDialogA(LPCSTR lpszName, HWND hWndParent, LPCOMMCONFIG lpCommConfig)
 469 {
 470     LPWSTR strW = SERIALUI_strdup( lpszName );
 471     DWORD r = drvCommConfigDialogW( strW, hWndParent, lpCommConfig );
 472     SERIALUI_strfree( strW );
 473     return r;
 474 }
 475
 476 static const WCHAR lpszCommKey[] = {
 477     'S','y','s','t','e','m','\\',
 478     'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 479     'S','e','r','v','i','c','e','s','\\',
 480     'C','l','a','s','s','\\','P','o','r','t','s',0
 481 };
 482 static const WCHAR lpszDCB[]     = {'D','C','B',0};
 483
 484 /***********************************************************************
 485  * drvSetDefaultCommConfigW (SERIALUI.@)
 486  *
 487  * Used by Win98 KERNEL to set the default config for a COMM port
 488  * FIXME: uses the wrong registry key... should use a digit, not
 489  *        the comm port name.
 490  */
 491 BOOL WINAPI drvSetDefaultCommConfigW(
 492         LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
 493 {
 494     HKEY hKeyReg=0, hKeyPort=0;
 495     WCHAR szKeyName[100];
 496     DWORD r,dwDCBSize;
 497     static const WCHAR fmt[] = {'%','s','\\','%','s',0 };
 498
 499     TRACE("%p %p %x\n",lpszDevice,lpCommConfig,dwSize);
 500
 501     if(!lpCommConfig)
 502         return FALSE;
 503
 504     if(dwSize < sizeof (COMMCONFIG))
 505         return FALSE;
 506
 507     r = RegConnectRegistryW(NULL, HKEY_LOCAL_MACHINE, &hKeyReg);
 508     if(r != ERROR_SUCCESS)
 509         return FALSE;
 510
 511     snprintfW(szKeyName, sizeof(szKeyName)/sizeof(WCHAR), fmt, lpszCommKey ,lpszDevice);
 512     r = RegCreateKeyW(hKeyReg, szKeyName, &hKeyPort);
 513     if(r == ERROR_SUCCESS)
 514     {
 515         dwDCBSize = sizeof (DCB);
 516         r = RegSetValueExW( hKeyPort, lpszDCB, 0, REG_BINARY,
 517                             (LPBYTE)&lpCommConfig->dcb,dwDCBSize);
 518         TRACE("write key r=%d\n",r);
 519         RegCloseKey(hKeyPort);
 520     }
 521
 522     RegCloseKey(hKeyReg);
 523
 524     return (r==ERROR_SUCCESS);
 525 }
 526
 527 /***********************************************************************
 528  * drvSetDefaultCommConfigA (SERIALUI.@)
 529  */
 530 BOOL WINAPI drvSetDefaultCommConfigA(
 531         LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
 532 {
 533     LPWSTR strW = SERIALUI_strdup( lpszDevice );
 534     BOOL r = drvSetDefaultCommConfigW( strW, lpCommConfig, dwSize );
 535     SERIALUI_strfree( strW );
 536     return r;
 537 }
 538
 539 /***********************************************************************
 540  * drvGetDefaultCommConfigW (SERIALUI.@)
 541  *
 542  * Used by Win9x KERNEL to get the default config for a COMM port
 543  * FIXME: uses the wrong registry key... should use a digit, not
 544  *        the comm port name.
 545  */
 546 DWORD WINAPI drvGetDefaultCommConfigW(
 547         LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, LPDWORD lpdwSize)
 548 {
 549     HKEY hKeyReg, hKeyPort;
 550     WCHAR szKeyName[100];
 551     DWORD r,dwSize,dwType;
 552     static const WCHAR fmt[] = {'%','s','\\','%','s',0 };
 553
 554     TRACE("(%s, %p, %p) *lpdwSize: %u\n", debugstr_w(lpszDevice), lpCommConfig, lpdwSize, lpdwSize ? *lpdwSize : 0);
 555
 556     if ((!lpszDevice) || (!lpCommConfig) || (!lpdwSize)) {
 557         return ERROR_INVALID_PARAMETER;
 558     }
 559
 560     if (*lpdwSize < sizeof (COMMCONFIG)) {
 561         *lpdwSize = sizeof (COMMCONFIG);
 562         return ERROR_INSUFFICIENT_BUFFER;
 563     }
 564
 565     /* only "com1" - "com9" is allowed */
 566     r = sizeof(comW) / sizeof(WCHAR);       /* len of "com\0" */
 567     lstrcpynW(szKeyName, lpszDevice, r);    /* simulate a lstrcmpnW */
 568     r--;
 569
 570     if( lstrcmpiW(szKeyName, comW) ||
 571         (lpszDevice[r] < '1') || (lpszDevice[r] > '9') || lpszDevice[r+1]) {
 572         return ERROR_BADKEY;
 573     }
 574
 575     *lpdwSize = sizeof (COMMCONFIG);
 576     memset(lpCommConfig, 0 , sizeof (COMMCONFIG));
 577     lpCommConfig->dwSize = sizeof (COMMCONFIG);
 578     lpCommConfig->wVersion = 1;
 579     lpCommConfig->dwProviderSubType = PST_RS232;
 580
 581     r = RegConnectRegistryW(NULL, HKEY_LOCAL_MACHINE, &hKeyReg);
 582     if(r != ERROR_SUCCESS) return r;
 583
 584     snprintfW(szKeyName, sizeof(szKeyName)/sizeof(WCHAR), fmt, lpszCommKey ,lpszDevice);
 585     r = RegOpenKeyW(hKeyReg, szKeyName, &hKeyPort);
 586     if(r == ERROR_SUCCESS)
 587     {
 588         dwSize = sizeof (DCB);
 589         dwType = 0;
 590         r = RegQueryValueExW( hKeyPort, lpszDCB, NULL,
 591                              &dwType, (LPBYTE)&lpCommConfig->dcb, &dwSize);
 592
 593         RegCloseKey(hKeyPort);
 594         if ((r!=ERROR_SUCCESS) || (dwType != REG_BINARY) || (dwSize != sizeof(DCB))) {
 595             RegCloseKey(hKeyReg);
 596             return ERROR_INVALID_PARAMETER;
 597         }
 598
 599     }
 600     else
 601     {
 602         /* FIXME: default to a hardcoded commconfig */
 603         lpCommConfig->dcb.DCBlength = sizeof(DCB);
 604         lpCommConfig->dcb.BaudRate = 9600;
 605         lpCommConfig->dcb.fBinary = TRUE;
 606         lpCommConfig->dcb.fParity = FALSE;
 607         lpCommConfig->dcb.ByteSize = 8;
 608         lpCommConfig->dcb.Parity = NOPARITY;
 609         lpCommConfig->dcb.StopBits = ONESTOPBIT;
 610         return ERROR_SUCCESS;
 611     }
 612
 613     RegCloseKey(hKeyReg);
 614
 615     return r;
 616 }
 617
 618 /***********************************************************************
 619  * drvGetDefaultCommConfigA (SERIALUI.@)
 620  */
 621 DWORD WINAPI drvGetDefaultCommConfigA(
 622         LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, LPDWORD lpdwSize)
 623 {
 624     LPWSTR strW = SERIALUI_strdup( lpszDevice );
 625     DWORD r = drvGetDefaultCommConfigW( strW, lpCommConfig, lpdwSize );
 626     SERIALUI_strfree( strW );
 627     return r;
 628 }