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