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