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