reactos/dll/cpl/sysdm/startrec.c

   1 /*
   2  * PROJECT:     ReactOS System Control Panel Applet
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        dll/cpl/sysdm/startrec.c
   5  * PURPOSE:     Computer settings for startup and recovery
   6  * COPYRIGHT:   Copyright 2006 Ged Murphy <gedmurphy@gmail.com>
   7  *              Copyright 2006 Christoph von Wittich <Christoph@ApiViewer.de>
   8  *              Copyright 2007 Johannes Anderwald <johannes dot anderwald at student dot tugraz dot at>
   9  */
  10
  11 #include "precomp.h"
  12
  13 typedef struct _STARTINFO
  14 {
  15     WCHAR szFreeldrIni[MAX_PATH + 15];
  16     WCHAR szDumpFile[MAX_PATH];
  17     WCHAR szMinidumpDir[MAX_PATH];
  18     DWORD dwCrashDumpEnabled;
  19     INT iFreeLdrIni;
  20 } STARTINFO, *PSTARTINFO;
  21
  22
  23 static VOID
  24 SetTimeout(HWND hwndDlg, INT Timeout)
  25 {
  26     if (Timeout == 0)
  27     {
  28         EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECLISTUPDWN), FALSE);
  29         EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECLISTEDIT), FALSE);
  30     }
  31     else
  32     {
  33         EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECLISTUPDWN), TRUE);
  34         EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECLISTEDIT), TRUE);
  35     }
  36     SendDlgItemMessageW(hwndDlg, IDC_STRRECLISTUPDWN, UDM_SETRANGE, (WPARAM) 0, (LPARAM) MAKELONG((short) 999, 0));
  37     SendDlgItemMessageW(hwndDlg, IDC_STRRECLISTUPDWN, UDM_SETPOS, (WPARAM) 0, (LPARAM) MAKELONG((short) Timeout, 0));
  38 }
  39
  40 static VOID
  41 SetRecoveryTimeout(HWND hwndDlg, INT Timeout)
  42 {
  43     if (Timeout == 0)
  44     {
  45         EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECRECUPDWN), FALSE);
  46         EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECRECEDIT), FALSE);
  47     }
  48     else
  49     {
  50         EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECRECUPDWN), TRUE);
  51         EnableWindow(GetDlgItem(hwndDlg, IDC_STRRECRECEDIT), TRUE);
  52     }
  53     SendDlgItemMessageW(hwndDlg, IDC_STRRECRECUPDWN, UDM_SETRANGE, (WPARAM) 0, (LPARAM) MAKELONG((short) 999, 0));
  54     SendDlgItemMessageW(hwndDlg, IDC_STRRECRECUPDWN, UDM_SETPOS, (WPARAM) 0, (LPARAM) MAKELONG((short) Timeout, 0));
  55 }
  56
  57
  58 static DWORD
  59 GetSystemDrive(WCHAR **szSystemDrive)
  60 {
  61     DWORD dwBufSize;
  62
  63     /* get Path to freeldr.ini or boot.ini */
  64     *szSystemDrive = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
  65     if (*szSystemDrive != NULL)
  66     {
  67         dwBufSize = GetEnvironmentVariableW(L"SystemDrive", *szSystemDrive, MAX_PATH);
  68         if (dwBufSize > MAX_PATH)
  69         {
  70             WCHAR *szTmp;
  71             DWORD dwBufSize2;
  72
  73             szTmp = HeapReAlloc(GetProcessHeap(), 0, *szSystemDrive, dwBufSize * sizeof(WCHAR));
  74             if (szTmp == NULL)
  75                 goto FailGetSysDrive;
  76
  77             *szSystemDrive = szTmp;
  78
  79             dwBufSize2 = GetEnvironmentVariableW(L"SystemDrive", *szSystemDrive, dwBufSize);
  80             if (dwBufSize2 > dwBufSize || dwBufSize2 == 0)
  81                 goto FailGetSysDrive;
  82         }
  83         else if (dwBufSize == 0)
  84         {
  85 FailGetSysDrive:
  86             HeapFree(GetProcessHeap(), 0, *szSystemDrive);
  87             *szSystemDrive = NULL;
  88             return 0;
  89         }
  90
  91         return dwBufSize;
  92     }
  93
  94     return 0;
  95 }
  96
  97 static PBOOTRECORD
  98 ReadFreeldrSection(HINF hInf, WCHAR *szSectionName)
  99 {
 100     PBOOTRECORD pRecord;
 101     INFCONTEXT InfContext;
 102     WCHAR szName[MAX_PATH];
 103     WCHAR szValue[MAX_PATH];
 104     DWORD LineLength;
 105
 106     if (!SetupFindFirstLineW(hInf,
 107                             szSectionName,
 108                             NULL,
 109                             &InfContext))
 110     {
 111         /* failed to find section */
 112         return NULL;
 113     }
 114
 115     pRecord = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOTRECORD));
 116     if (pRecord == NULL)
 117     {
 118         return NULL;
 119     }
 120
 121     wcscpy(pRecord->szSectionName, szSectionName);
 122
 123     do
 124     {
 125         if (!SetupGetStringFieldW(&InfContext,
 126                                   0,
 127                                   szName,
 128                                   sizeof(szName) / sizeof(WCHAR),
 129                                   &LineLength))
 130         {
 131             break;
 132         }
 133
 134         if (!SetupGetStringFieldW(&InfContext,
 135                                   1,
 136                                   szValue,
 137                                   sizeof(szValue) / sizeof(WCHAR),
 138                                   &LineLength))
 139         {
 140             break;
 141         }
 142
 143         if (!_wcsnicmp(szName, L"BootType", 8))
 144         {
 145             if (!_wcsnicmp(szValue, L"ReactOS", 7))
 146             {
 147                 //FIXME store as enum
 148                 pRecord->BootType = 1;
 149             }
 150             else
 151             {
 152                 pRecord->BootType = 0;
 153             }
 154         }
 155         else if (!_wcsnicmp(szName, L"SystemPath", 10))
 156         {
 157             wcscpy(pRecord->szBootPath, szValue);
 158         }
 159         else if (!_wcsnicmp(szName, L"Options", 7))
 160         {
 161             //FIXME store flags as values
 162             wcscpy(pRecord->szOptions, szValue);
 163         }
 164
 165     }
 166     while (SetupFindNextLine(&InfContext, &InfContext));
 167
 168     return pRecord;
 169 }
 170
 171
 172 static INT
 173 LoadFreeldrSettings(HINF hInf, HWND hwndDlg)
 174 {
 175     INFCONTEXT InfContext;
 176     PBOOTRECORD pRecord;
 177     WCHAR szDefaultOs[MAX_PATH];
 178     WCHAR szName[MAX_PATH];
 179     WCHAR szValue[MAX_PATH];
 180     DWORD LineLength;
 181     DWORD TimeOut;
 182     LRESULT lResult;
 183
 184     if (!SetupFindFirstLineW(hInf,
 185                            L"FREELOADER",
 186                            L"DefaultOS",
 187                            &InfContext))
 188     {
 189         /* failed to find default os */
 190         return FALSE;
 191     }
 192
 193     if (!SetupGetStringFieldW(&InfContext,
 194                              1,
 195                              szDefaultOs,
 196                              sizeof(szDefaultOs) / sizeof(WCHAR),
 197                              &LineLength))
 198     {
 199         /* no key */
 200         return FALSE;
 201     }
 202
 203     if (!SetupFindFirstLineW(hInf,
 204                            L"FREELOADER",
 205                            L"TimeOut",
 206                            &InfContext))
 207     {
 208         /* expected to find timeout value */
 209         return FALSE;
 210     }
 211
 212
 213     if (!SetupGetIntField(&InfContext,
 214                           1,
 215                           (PINT)&TimeOut))
 216     {
 217         /* failed to retrieve timeout */
 218         return FALSE;
 219     }
 220
 221     if (!SetupFindFirstLineW(hInf,
 222                            L"Operating Systems",
 223                            NULL,
 224                            &InfContext))
 225     {
 226        /* expected list of operating systems */
 227        return FALSE;
 228     }
 229
 230     do
 231     {
 232         if (!SetupGetStringFieldW(&InfContext,
 233                                  0,
 234                                  szName,
 235                                  sizeof(szName) / sizeof(WCHAR),
 236                                  &LineLength))
 237         {
 238             /* the ini file is messed up */
 239             return FALSE;
 240         }
 241
 242         if (!SetupGetStringFieldW(&InfContext,
 243                                  1,
 244                                  szValue,
 245                                  sizeof(szValue) / sizeof(WCHAR),
 246                                  &LineLength))
 247         {
 248             /* the ini file is messed up */
 249             return FALSE;
 250         }
 251
 252         pRecord = ReadFreeldrSection(hInf, szName);
 253         if (pRecord)
 254         {
 255             lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM)szValue);
 256             if (lResult != CB_ERR)
 257             {
 258                 SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_SETITEMDATA, (WPARAM)lResult, (LPARAM)pRecord);
 259                 if (!wcscmp(szDefaultOs, szName))
 260                 {
 261                     /* we store the friendly name as key */
 262                     wcscpy(szDefaultOs, szValue);
 263                 }
 264             }
 265             else
 266             {
 267                HeapFree(GetProcessHeap(), 0, pRecord);
 268             }
 269         }
 270     }
 271     while (SetupFindNextLine(&InfContext, &InfContext));
 272
 273     /* find default os in list */
 274     lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_FINDSTRING, (WPARAM)-1, (LPARAM)szDefaultOs);
 275     if (lResult != CB_ERR)
 276     {
 277        /* set cur sel */
 278        SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0);
 279     }
 280
 281     if(TimeOut)
 282     {
 283         SendDlgItemMessageW(hwndDlg, IDC_STRECLIST, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 284     }
 285
 286     SetTimeout(hwndDlg, TimeOut);
 287
 288     return TRUE;
 289 }
 290
 291 static INT
 292 LoadBootSettings(HINF hInf, HWND hwndDlg)
 293 {
 294     INFCONTEXT InfContext;
 295     WCHAR szName[MAX_PATH];
 296     WCHAR szValue[MAX_PATH];
 297     DWORD LineLength;
 298     DWORD TimeOut = 0;
 299     WCHAR szDefaultOS[MAX_PATH];
 300     WCHAR szOptions[MAX_PATH];
 301     PBOOTRECORD pRecord;
 302     LRESULT lResult;
 303
 304     if(!SetupFindFirstLineW(hInf,
 305                            L"boot loader",
 306                            NULL,
 307                            &InfContext))
 308     {
 309         return FALSE;
 310     }
 311
 312     do
 313     {
 314         if (!SetupGetStringFieldW(&InfContext,
 315                                  0,
 316                                  szName,
 317                                  sizeof(szName) / sizeof(WCHAR),
 318                                  &LineLength))
 319         {
 320             return FALSE;
 321         }
 322
 323         if (!SetupGetStringFieldW(&InfContext,
 324                                  1,
 325                                  szValue,
 326                                  sizeof(szValue) / sizeof(WCHAR),
 327                                  &LineLength))
 328         {
 329             return FALSE;
 330         }
 331
 332         if (!_wcsnicmp(szName, L"timeout", 7))
 333         {
 334             TimeOut = _wtoi(szValue);
 335         }
 336
 337         if (!_wcsnicmp(szName, L"default", 7))
 338         {
 339             wcscpy(szDefaultOS, szValue);
 340         }
 341
 342     }
 343     while (SetupFindNextLine(&InfContext, &InfContext));
 344
 345     if (!SetupFindFirstLineW(hInf,
 346                             L"operating systems",
 347                             NULL,
 348                             &InfContext))
 349     {
 350         /* failed to find operating systems section */
 351         return FALSE;
 352     }
 353
 354     do
 355     {
 356         if (!SetupGetStringFieldW(&InfContext,
 357                                  0,
 358                                  szName,
 359                                  sizeof(szName) / sizeof(WCHAR),
 360                                  &LineLength))
 361         {
 362             return FALSE;
 363         }
 364
 365         if (!SetupGetStringFieldW(&InfContext,
 366                                  1,
 367                                  szValue,
 368                                  sizeof(szValue) / sizeof(WCHAR),
 369                                  &LineLength))
 370         {
 371             return FALSE;
 372         }
 373
 374         SetupGetStringFieldW(&InfContext,
 375                             2,
 376                             szOptions,
 377                             sizeof(szOptions) / sizeof(WCHAR),
 378                             &LineLength);
 379
 380         pRecord = (PBOOTRECORD) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOTRECORD));
 381         if (pRecord)
 382         {
 383             pRecord->BootType = 0;
 384             wcscpy(pRecord->szBootPath, szName);
 385             wcscpy(pRecord->szSectionName, szValue);
 386             wcscpy(pRecord->szOptions, szOptions);
 387
 388             if (!wcscmp(szName, szDefaultOS))
 389             {
 390                 /* ms boot ini stores the path not the friendly name */
 391                 wcscpy(szDefaultOS, szValue);
 392             }
 393
 394             lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM)szValue);
 395             if (lResult != CB_ERR)
 396             {
 397                 SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_SETITEMDATA, (WPARAM)lResult, (LPARAM)pRecord);
 398             }
 399             else
 400             {
 401                HeapFree(GetProcessHeap(), 0, pRecord);
 402             }
 403         }
 404
 405     }
 406     while (SetupFindNextLine(&InfContext, &InfContext));
 407
 408     /* find default os in list */
 409     lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_FINDSTRING, (WPARAM)0, (LPARAM)szDefaultOS);
 410     if (lResult != CB_ERR)
 411     {
 412        /* set cur sel */
 413        SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0);
 414     }
 415
 416     if(TimeOut)
 417     {
 418         SendDlgItemMessageW(hwndDlg, IDC_STRECLIST, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 419     }
 420
 421     SetTimeout(hwndDlg, TimeOut);
 422
 423     return TRUE;
 424 }
 425
 426 static VOID
 427 DeleteBootRecords(HWND hwndDlg)
 428 {
 429     LRESULT lIndex;
 430     LONG index;
 431     PBOOTRECORD pRecord;
 432
 433     lIndex = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_GETCOUNT, (WPARAM)0, (LPARAM)0);
 434     if (lIndex == CB_ERR)
 435         return;
 436
 437     for (index = 0; index <lIndex; index++)
 438     {
 439         pRecord = (PBOOTRECORD) SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_GETITEMDATA, (WPARAM)index, (LPARAM)0);
 440         if ((INT_PTR)pRecord != CB_ERR)
 441         {
 442             HeapFree(GetProcessHeap(), 0, pRecord);
 443         }
 444     }
 445
 446     SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
 447 }
 448
 449 static LRESULT
 450 LoadOSList(HWND hwndDlg, PSTARTINFO pStartInfo)
 451 {
 452     DWORD dwBufSize;
 453     WCHAR *szSystemDrive;
 454     HINF hInf;
 455
 456     dwBufSize = GetSystemDrive(&szSystemDrive);
 457     if (dwBufSize == 0)
 458         return FALSE;
 459
 460     wcscpy(pStartInfo->szFreeldrIni, szSystemDrive);
 461     wcscat(pStartInfo->szFreeldrIni, L"\\freeldr.ini");
 462
 463     if (PathFileExistsW(pStartInfo->szFreeldrIni))
 464     {
 465         /* free resource previously allocated by GetSystemDrive() */
 466         HeapFree(GetProcessHeap(), 0, szSystemDrive);
 467         /* freeldr.ini exists */
 468         hInf = SetupOpenInfFileW(pStartInfo->szFreeldrIni,
 469                                 NULL,
 470                                 INF_STYLE_OLDNT,
 471                                 NULL);
 472
 473         if (hInf != INVALID_HANDLE_VALUE)
 474         {
 475             LoadFreeldrSettings(hInf, hwndDlg);
 476             SetupCloseInfFile(hInf);
 477             pStartInfo->iFreeLdrIni = 1;
 478             return TRUE;
 479         }
 480         return FALSE;
 481     }
 482
 483     /* try load boot.ini settings */
 484     wcscpy(pStartInfo->szFreeldrIni, szSystemDrive);
 485     wcscat(pStartInfo->szFreeldrIni, L"\\boot.ini");
 486
 487     /* free resource previously allocated by GetSystemDrive() */
 488     HeapFree(GetProcessHeap(), 0, szSystemDrive);
 489
 490     if (PathFileExistsW(pStartInfo->szFreeldrIni))
 491     {
 492         /* load boot.ini settings */
 493         hInf = SetupOpenInfFileW(pStartInfo->szFreeldrIni,
 494                                 NULL,
 495                                 INF_STYLE_OLDNT,
 496                                 NULL);
 497
 498         if (hInf != INVALID_HANDLE_VALUE)
 499         {
 500             LoadBootSettings(hInf, hwndDlg);
 501             SetupCloseInfFile(hInf);
 502             pStartInfo->iFreeLdrIni = 2;
 503             return TRUE;
 504         }
 505
 506         return FALSE;
 507     }
 508
 509     return FALSE;
 510 }
 511
 512 static VOID
 513 SetCrashDlgItems(HWND hwnd, PSTARTINFO pStartInfo)
 514 {
 515     if (pStartInfo->dwCrashDumpEnabled == 0)
 516     {
 517         /* no crash information required */
 518         EnableWindow(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), FALSE);
 519         EnableWindow(GetDlgItem(hwnd, IDC_STRRECOVERWRITE), FALSE);
 520     }
 521     else if (pStartInfo->dwCrashDumpEnabled == 3)
 522     {
 523         /* minidump type */
 524         EnableWindow(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), TRUE);
 525         EnableWindow(GetDlgItem(hwnd, IDC_STRRECOVERWRITE), FALSE);
 526         SendMessageW(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), WM_SETTEXT, (WPARAM)0, (LPARAM)pStartInfo->szMinidumpDir);
 527     }
 528     else if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
 529     {
 530         /* kernel or complete dump */
 531         EnableWindow(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), TRUE);
 532         EnableWindow(GetDlgItem(hwnd, IDC_STRRECOVERWRITE), TRUE);
 533         SendMessageW(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), WM_SETTEXT, (WPARAM)0, (LPARAM)pStartInfo->szDumpFile);
 534     }
 535     SendDlgItemMessageW(hwnd, IDC_STRRECDEBUGCOMBO, CB_SETCURSEL, (WPARAM)pStartInfo->dwCrashDumpEnabled, (LPARAM)0);
 536 }
 537
 538 static VOID
 539 WriteStartupRecoveryOptions(HWND hwndDlg, PSTARTINFO pStartInfo)
 540 {
 541     HKEY hKey;
 542     DWORD lResult;
 543
 544     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
 545                      L"System\\CurrentControlSet\\Control\\CrashControl",
 546                      0,
 547                      KEY_WRITE,
 548                      &hKey) != ERROR_SUCCESS)
 549     {
 550         /* failed to open key */
 551         return;
 552     }
 553
 554     lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECWRITEEVENT, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
 555     RegSetValueExW(hKey, L"LogEvent", 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
 556
 557     lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECSENDALERT, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
 558     RegSetValueExW(hKey, L"SendAlert", 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
 559
 560     lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECRESTART, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
 561     RegSetValueExW(hKey, L"AutoReboot", 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
 562
 563     lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECOVERWRITE, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
 564     RegSetValueExW(hKey, L"Overwrite", 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
 565
 566
 567     if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
 568     {
 569         SendDlgItemMessage(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(WCHAR), (LPARAM)pStartInfo->szDumpFile);
 570         RegSetValueExW(hKey, L"DumpFile", 0, REG_EXPAND_SZ, (LPBYTE)pStartInfo->szDumpFile, (wcslen(pStartInfo->szDumpFile) + 1) * sizeof(WCHAR));
 571     }
 572     else if (pStartInfo->dwCrashDumpEnabled == 3)
 573     {
 574         SendDlgItemMessage(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(WCHAR), (LPARAM)pStartInfo->szDumpFile);
 575         RegSetValueExW(hKey, L"MinidumpDir", 0, REG_EXPAND_SZ, (LPBYTE)pStartInfo->szDumpFile, (wcslen(pStartInfo->szDumpFile) + 1) * sizeof(WCHAR));
 576     }
 577
 578     RegSetValueExW(hKey, L"CrashDumpEnabled", 0, REG_DWORD, (LPBYTE)&pStartInfo->dwCrashDumpEnabled, sizeof(pStartInfo->dwCrashDumpEnabled));
 579     RegCloseKey(hKey);
 580 }
 581
 582 static VOID
 583 LoadRecoveryOptions(HWND hwndDlg, PSTARTINFO pStartInfo)
 584 {
 585     HKEY hKey;
 586     WCHAR szName[MAX_PATH];
 587     DWORD dwValue, dwValueLength, dwType;
 588
 589     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
 590                      L"System\\CurrentControlSet\\Control\\CrashControl",
 591                      0,
 592                      KEY_READ,
 593                      &hKey) != ERROR_SUCCESS)
 594     {
 595         /* failed to open key */
 596         return;
 597     }
 598
 599     dwValueLength = sizeof(DWORD);
 600     if (RegQueryValueExW(hKey, L"LogEvent", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
 601         SendDlgItemMessageW(hwndDlg, IDC_STRRECWRITEEVENT, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 602
 603     dwValueLength = sizeof(DWORD);
 604     if (RegQueryValueExW(hKey, L"SendAlert", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
 605         SendDlgItemMessageW(hwndDlg, IDC_STRRECSENDALERT, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 606
 607     dwValueLength = sizeof(DWORD);
 608     if (RegQueryValueExW(hKey, L"AutoReboot", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
 609         SendDlgItemMessageW(hwndDlg, IDC_STRRECRESTART, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 610
 611     dwValueLength = sizeof(DWORD);
 612     if (RegQueryValueExW(hKey, L"Overwrite", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
 613         SendDlgItemMessageW(hwndDlg, IDC_STRRECOVERWRITE, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 614
 615     dwValueLength = sizeof(DWORD);
 616     if (RegQueryValueExW(hKey, L"CrashDumpEnabled", NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) == ERROR_SUCCESS && dwType == REG_DWORD && dwValue)
 617         pStartInfo->dwCrashDumpEnabled = dwValue;
 618
 619    dwValueLength = sizeof(pStartInfo->szDumpFile);
 620    if (RegQueryValueExW(hKey, L"DumpFile", NULL, &dwType, (LPBYTE)pStartInfo->szDumpFile, &dwValueLength) != ERROR_SUCCESS)
 621        pStartInfo->szDumpFile[0] = L'\0';
 622
 623     dwValueLength = sizeof(pStartInfo->szMinidumpDir);
 624     if (RegQueryValueExW(hKey, L"MinidumpDir", NULL, &dwType, (LPBYTE)pStartInfo->szMinidumpDir, &dwValueLength) != ERROR_SUCCESS)
 625         pStartInfo->szMinidumpDir[0] = L'\0';
 626
 627     if (LoadStringW(hApplet, IDS_NO_DUMP, szName, sizeof(szName) / sizeof(WCHAR)))
 628     {
 629         szName[(sizeof(szName)/sizeof(WCHAR))-1] = L'\0';
 630         SendDlgItemMessageW(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szName);
 631     }
 632
 633     if (LoadString(hApplet, IDS_FULL_DUMP, szName, sizeof(szName) / sizeof(WCHAR)))
 634     {
 635         szName[(sizeof(szName)/sizeof(WCHAR))-1] = L'\0';
 636         SendDlgItemMessageW(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szName);
 637     }
 638
 639     if (LoadStringW(hApplet, IDS_KERNEL_DUMP, szName, sizeof(szName) / sizeof(WCHAR)))
 640     {
 641         szName[(sizeof(szName)/sizeof(WCHAR))-1] = L'\0';
 642         SendDlgItemMessageW(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szName);
 643     }
 644
 645     if (LoadStringW(hApplet, IDS_MINI_DUMP, szName, sizeof(szName) / sizeof(WCHAR)))
 646     {
 647         szName[(sizeof(szName)/sizeof(WCHAR))-1] = L'\0';
 648         SendDlgItemMessageW(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szName);
 649     }
 650
 651     SetCrashDlgItems(hwndDlg, pStartInfo);
 652     RegCloseKey(hKey);
 653 }
 654
 655
 656 /* Property page dialog callback */
 657 INT_PTR CALLBACK
 658 StartRecDlgProc(HWND hwndDlg,
 659                 UINT uMsg,
 660                 WPARAM wParam,
 661                 LPARAM lParam)
 662 {
 663     PSTARTINFO pStartInfo;
 664     PBOOTRECORD pRecord;
 665     int iTimeout;
 666     LRESULT lResult;
 667     WCHAR szTimeout[10];
 668
 669     UNREFERENCED_PARAMETER(lParam);
 670
 671     pStartInfo = (PSTARTINFO)GetWindowLongPtr(hwndDlg, DWLP_USER);
 672
 673     switch(uMsg)
 674     {
 675         case WM_INITDIALOG:
 676             pStartInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STARTINFO));
 677             SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pStartInfo);
 678
 679             LoadRecoveryOptions(hwndDlg, pStartInfo);
 680             SetRecoveryTimeout(hwndDlg, 0);
 681             return LoadOSList(hwndDlg, pStartInfo);
 682
 683         case WM_DESTROY:
 684             DeleteBootRecords(hwndDlg);
 685             HeapFree(GetProcessHeap(), 0, pStartInfo);
 686             break;
 687
 688         case WM_COMMAND:
 689             switch(LOWORD(wParam))
 690             {
 691                 case IDC_STRRECEDIT:
 692                     ShellExecuteW(0, L"open", L"notepad", pStartInfo->szFreeldrIni, NULL, SW_SHOWNORMAL);
 693                     // FIXME use CreateProcess and wait untill finished
 694                     //  DeleteBootRecords(hwndDlg);
 695                     //  LoadOSList(hwndDlg);
 696                     break;
 697
 698                 case IDOK:
 699                     /* save timeout */
 700                     if (SendDlgItemMessage(hwndDlg, IDC_STRECLIST, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
 701                         iTimeout = SendDlgItemMessage(hwndDlg, IDC_STRRECLISTUPDWN, UDM_GETPOS, (WPARAM)0, (LPARAM)0);
 702                     else
 703                         iTimeout = 0;
 704                     swprintf(szTimeout, L"%i", iTimeout);
 705
 706                     lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
 707                     if (lResult == CB_ERR)
 708                     {
 709                         /* ? */
 710                         DeleteBootRecords(hwndDlg);
 711                         return TRUE;
 712                     }
 713
 714                     pRecord = (PBOOTRECORD) SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_GETITEMDATA, (WPARAM)lResult, (LPARAM)0);
 715
 716                     if ((INT_PTR)pRecord != CB_ERR)
 717                     {
 718                         if (pStartInfo->iFreeLdrIni == 1) // FreeLdrIni style
 719                         {
 720                             /* set default timeout */
 721                             WritePrivateProfileStringW(L"FREELOADER",
 722                                                       L"TimeOut",
 723                                                       szTimeout,
 724                                                       pStartInfo->szFreeldrIni);
 725                             /* set default os */
 726                             WritePrivateProfileStringW(L"FREELOADER",
 727                                                       L"DefaultOS",
 728                                                       pRecord->szSectionName,
 729                                                       pStartInfo->szFreeldrIni);
 730
 731                         }
 732                         else if (pStartInfo->iFreeLdrIni == 2) // BootIni style
 733                         {
 734                             /* set default timeout */
 735                             WritePrivateProfileStringW(L"boot loader",
 736                                                       L"timeout",
 737                                                       szTimeout,
 738                                                       pStartInfo->szFreeldrIni);
 739                             /* set default os */
 740                             WritePrivateProfileStringW(L"boot loader",
 741                                                       L"default",
 742                                                       pRecord->szBootPath,
 743                                                       pStartInfo->szFreeldrIni);
 744
 745                         }
 746                     }
 747
 748                     WriteStartupRecoveryOptions(hwndDlg, pStartInfo);
 749                     EndDialog(hwndDlg,
 750                               LOWORD(wParam));
 751                     return TRUE;
 752
 753                 case IDCANCEL:
 754                     EndDialog(hwndDlg,
 755                               LOWORD(wParam));
 756                     return TRUE;
 757
 758                 case IDC_STRECLIST:
 759                     if (SendDlgItemMessage(hwndDlg, IDC_STRECLIST, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
 760                         SetTimeout(hwndDlg, 30);
 761                     else
 762                         SetTimeout(hwndDlg, 0);
 763                     break;
 764
 765                 case IDC_STRRECREC:
 766                     if (SendDlgItemMessage(hwndDlg, IDC_STRRECREC, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
 767                         SetRecoveryTimeout(hwndDlg, 30);
 768                     else
 769                         SetRecoveryTimeout(hwndDlg, 0);
 770                     break;
 771
 772                 case IDC_STRRECDEBUGCOMBO:
 773                     if (HIWORD(wParam) == CBN_SELCHANGE)
 774                     {
 775                         LRESULT lResult;
 776
 777                         lResult = SendDlgItemMessage(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
 778                         if (lResult != CB_ERR && lResult != (LRESULT)pStartInfo->dwCrashDumpEnabled)
 779                         {
 780                             if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
 781                             {
 782                                 SendDlgItemMessageW(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(WCHAR), (LPARAM)pStartInfo->szDumpFile);
 783                             }
 784                             else if (pStartInfo->dwCrashDumpEnabled == 3)
 785                             {
 786                                 SendDlgItemMessageW(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szMinidumpDir) / sizeof(WCHAR), (LPARAM)pStartInfo->szMinidumpDir);
 787                             }
 788
 789                             pStartInfo->dwCrashDumpEnabled = (DWORD)lResult;
 790                             SetCrashDlgItems(hwndDlg, pStartInfo);
 791                         }
 792                     }
 793                     break;
 794             }
 795             break;
 796     }
 797
 798     return FALSE;
 799 }