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     TCHAR szFreeldrIni[MAX_PATH + 15];
  16     TCHAR szDumpFile[MAX_PATH];
  17     TCHAR 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     SendDlgItemMessage(hwndDlg, IDC_STRRECLISTUPDWN, UDM_SETRANGE, (WPARAM) 0, (LPARAM) MAKELONG((short) 999, 0));
  37     SendDlgItemMessage(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     SendDlgItemMessage(hwndDlg, IDC_STRRECRECUPDWN, UDM_SETRANGE, (WPARAM) 0, (LPARAM) MAKELONG((short) 999, 0));
  54     SendDlgItemMessage(hwndDlg, IDC_STRRECRECUPDWN, UDM_SETPOS, (WPARAM) 0, (LPARAM) MAKELONG((short) Timeout, 0));
  55 }
  56
  57
  58 static DWORD
  59 GetSystemDrive(TCHAR **szSystemDrive)
  60 {
  61     DWORD dwBufSize;
  62
  63     /* get Path to freeldr.ini or boot.ini */
  64     *szSystemDrive = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(TCHAR));
  65     if (szSystemDrive != NULL)
  66     {
  67         dwBufSize = GetEnvironmentVariable(_T("SystemDrive"), *szSystemDrive, MAX_PATH);
  68         if (dwBufSize > MAX_PATH)
  69         {
  70             TCHAR *szTmp;
  71             DWORD dwBufSize2;
  72
  73             szTmp = HeapReAlloc(GetProcessHeap(), 0, *szSystemDrive, dwBufSize * sizeof(TCHAR));
  74             if (szTmp == NULL)
  75                 goto FailGetSysDrive;
  76
  77             *szSystemDrive = szTmp;
  78
  79             dwBufSize2 = GetEnvironmentVariable(_T("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 FALSE;
  89         }
  90
  91         return dwBufSize;
  92     }
  93
  94     return FALSE;
  95 }
  96
  97 static PBOOTRECORD
  98 ReadFreeldrSection(HINF hInf, TCHAR *szSectionName)
  99 {
 100     PBOOTRECORD pRecord;
 101     INFCONTEXT InfContext;
 102     TCHAR szName[MAX_PATH];
 103     TCHAR szValue[MAX_PATH];
 104     DWORD LineLength;
 105
 106     if (!SetupFindFirstLine(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     _tcscpy(pRecord->szSectionName, szSectionName);
 122
 123     do
 124     {
 125         if (!SetupGetStringField(&InfContext,
 126                                   0,
 127                                   szName,
 128                                   sizeof(szName) / sizeof(TCHAR),
 129                                   &LineLength))
 130         {
 131             break;
 132         }
 133
 134         if (!SetupGetStringField(&InfContext,
 135                                   1,
 136                                   szValue,
 137                                   sizeof(szValue) / sizeof(TCHAR),
 138                                   &LineLength))
 139         {
 140             break;
 141         }
 142
 143         if (!_tcsnicmp(szName, _T("BootType"), 8))
 144         {
 145             if (!_tcsnicmp(szValue, _T("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 (!_tcsnicmp(szName, _T("SystemPath"), 10))
 156         {
 157             _tcscpy(pRecord->szBootPath, szValue);
 158         }
 159         else if (!_tcsnicmp(szName, _T("Options"), 7))
 160         {
 161             //FIXME store flags as values
 162             _tcscpy(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     TCHAR szDefaultOs[MAX_PATH];
 178     TCHAR szName[MAX_PATH];
 179     TCHAR szValue[MAX_PATH];
 180     DWORD LineLength;
 181     DWORD TimeOut;
 182     LRESULT lResult;
 183
 184     if (!SetupFindFirstLine(hInf,
 185                            _T("FREELOADER"),
 186                            _T("DefaultOS"),
 187                            &InfContext))
 188     {
 189         /* failed to find default os */
 190         return FALSE;
 191     }
 192
 193     if (!SetupGetStringField(&InfContext,
 194                              1,
 195                              szDefaultOs,
 196                              sizeof(szDefaultOs) / sizeof(TCHAR),
 197                              &LineLength))
 198     {
 199         /* no key */
 200         return FALSE;
 201     }
 202
 203     if (!SetupFindFirstLine(hInf,
 204                            _T("FREELOADER"),
 205                            _T("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 (!SetupFindFirstLine(hInf,
 222                            _T("Operating Systems"),
 223                            NULL,
 224                            &InfContext))
 225     {
 226        /* expected list of operating systems */
 227        return FALSE;
 228     }
 229
 230     do
 231     {
 232         if (!SetupGetStringField(&InfContext,
 233                                  0,
 234                                  szName,
 235                                  sizeof(szName) / sizeof(TCHAR),
 236                                  &LineLength))
 237         {
 238             /* the ini file is messed up */
 239             return FALSE;
 240         }
 241
 242         if (!SetupGetStringField(&InfContext,
 243                                  1,
 244                                  szValue,
 245                                  sizeof(szValue) / sizeof(TCHAR),
 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 = SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM)szValue);
 256             if (lResult != CB_ERR)
 257             {
 258                 SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_SETITEMDATA, (WPARAM)lResult, (LPARAM)pRecord);
 259                 if (!_tcscmp(szDefaultOs, szName))
 260                 {
 261                     /* we store the friendly name as key */
 262                     _tcscpy(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 = SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_FINDSTRING, (WPARAM)-1, (LPARAM)szDefaultOs);
 275     if (lResult != CB_ERR)
 276     {
 277        /* set cur sel */
 278        SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0);
 279     }
 280
 281     if(TimeOut)
 282     {
 283         SendDlgItemMessage(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     TCHAR szName[MAX_PATH];
 296     TCHAR szValue[MAX_PATH];
 297     DWORD LineLength;
 298     DWORD TimeOut = 0;
 299     TCHAR szDefaultOS[MAX_PATH];
 300     TCHAR szOptions[MAX_PATH];
 301     PBOOTRECORD pRecord;
 302     LRESULT lResult;
 303
 304     if(!SetupFindFirstLine(hInf,
 305                            _T("boot loader"),
 306                            NULL,
 307                            &InfContext))
 308     {
 309         return FALSE;
 310     }
 311
 312     do
 313     {
 314         if (!SetupGetStringField(&InfContext,
 315                                  0,
 316                                  szName,
 317                                  sizeof(szName) / sizeof(TCHAR),
 318                                  &LineLength))
 319         {
 320             return FALSE;
 321         }
 322
 323         if (!SetupGetStringField(&InfContext,
 324                                  1,
 325                                  szValue,
 326                                  sizeof(szValue) / sizeof(TCHAR),
 327                                  &LineLength))
 328         {
 329             return FALSE;
 330         }
 331
 332         if (!_tcsnicmp(szName, _T("timeout"), 7))
 333         {
 334             TimeOut = _ttoi(szValue);
 335         }
 336
 337         if (!_tcsnicmp(szName, _T("default"), 7))
 338         {
 339             _tcscpy(szDefaultOS, szValue);
 340         }
 341
 342     }
 343     while (SetupFindNextLine(&InfContext, &InfContext));
 344
 345     if (!SetupFindFirstLine(hInf,
 346                             _T("operating systems"),
 347                             NULL,
 348                             &InfContext))
 349     {
 350         /* failed to find operating systems section */
 351         return FALSE;
 352     }
 353
 354     do
 355     {
 356         if (!SetupGetStringField(&InfContext,
 357                                  0,
 358                                  szName,
 359                                  sizeof(szName) / sizeof(TCHAR),
 360                                  &LineLength))
 361         {
 362             return FALSE;
 363         }
 364
 365         if (!SetupGetStringField(&InfContext,
 366                                  1,
 367                                  szValue,
 368                                  sizeof(szValue) / sizeof(TCHAR),
 369                                  &LineLength))
 370         {
 371             return FALSE;
 372         }
 373
 374         SetupGetStringField(&InfContext,
 375                             2,
 376                             szOptions,
 377                             sizeof(szOptions) / sizeof(TCHAR),
 378                             &LineLength);
 379
 380         pRecord = (PBOOTRECORD) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BOOTRECORD));
 381         if (pRecord)
 382         {
 383             pRecord->BootType = 0;
 384             _tcscpy(pRecord->szBootPath, szName);
 385             _tcscpy(pRecord->szSectionName, szValue);
 386             _tcscpy(pRecord->szOptions, szOptions);
 387
 388             if (!_tcscmp(szName, szDefaultOS))
 389             {
 390                 /* ms boot ini stores the path not the friendly name */
 391                 _tcscpy(szDefaultOS, szValue);
 392             }
 393
 394             lResult = SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM)szValue);
 395             if (lResult != CB_ERR)
 396             {
 397                 SendDlgItemMessage(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 = SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_FINDSTRING, (WPARAM)0, (LPARAM)szDefaultOS);
 410     if (lResult != CB_ERR)
 411     {
 412        /* set cur sel */
 413        SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_SETCURSEL, (WPARAM)lResult, (LPARAM)0);
 414     }
 415
 416     if(TimeOut)
 417     {
 418         SendDlgItemMessage(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 = SendDlgItemMessage(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) SendDlgItemMessage(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     SendDlgItemMessage(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     TCHAR *szSystemDrive;
 454     HINF hInf;
 455
 456     dwBufSize = GetSystemDrive(&szSystemDrive);
 457     if (!dwBufSize)
 458         return FALSE;
 459
 460     _tcscpy(pStartInfo->szFreeldrIni, szSystemDrive);
 461     _tcscat(pStartInfo->szFreeldrIni, _T("\\freeldr.ini"));
 462
 463     if (PathFileExists(pStartInfo->szFreeldrIni))
 464     {
 465         /* freeldr.ini exists */
 466         hInf = SetupOpenInfFile(pStartInfo->szFreeldrIni,
 467                                 NULL,
 468                                 INF_STYLE_OLDNT,
 469                                 NULL);
 470
 471         if (hInf != INVALID_HANDLE_VALUE)
 472         {
 473             LoadFreeldrSettings(hInf, hwndDlg);
 474             SetupCloseInfFile(hInf);
 475             pStartInfo->iFreeLdrIni = 1;
 476             return TRUE;
 477         }
 478         return FALSE;
 479     }
 480
 481     /* try load boot.ini settings */
 482     _tcscpy(pStartInfo->szFreeldrIni, szSystemDrive);
 483     _tcscat(pStartInfo->szFreeldrIni, _T("\\boot.ini"));
 484
 485     if (PathFileExists(pStartInfo->szFreeldrIni))
 486     {
 487         /* load boot.ini settings */
 488         hInf = SetupOpenInfFile(pStartInfo->szFreeldrIni,
 489                                 NULL,
 490                                 INF_STYLE_OLDNT,
 491                                 NULL);
 492
 493         if (hInf != INVALID_HANDLE_VALUE)
 494         {
 495             LoadBootSettings(hInf, hwndDlg);
 496             SetupCloseInfFile(hInf);
 497             pStartInfo->iFreeLdrIni = 2;
 498             return TRUE;
 499         }
 500
 501         return FALSE;
 502     }
 503
 504     return FALSE;
 505 }
 506
 507 static VOID
 508 SetCrashDlgItems(HWND hwnd, PSTARTINFO pStartInfo)
 509 {
 510     if (pStartInfo->dwCrashDumpEnabled == 0)
 511     {
 512         /* no crash information required */
 513         EnableWindow(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), FALSE);
 514         EnableWindow(GetDlgItem(hwnd, IDC_STRRECOVERWRITE), FALSE);
 515     }
 516     else if (pStartInfo->dwCrashDumpEnabled == 3)
 517     {
 518         /* minidump type */
 519         EnableWindow(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), TRUE);
 520         EnableWindow(GetDlgItem(hwnd, IDC_STRRECOVERWRITE), FALSE);
 521         SendMessage(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), WM_SETTEXT, (WPARAM)0, (LPARAM)pStartInfo->szMinidumpDir);
 522     }
 523     else if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
 524     {
 525         /* kernel or complete dump */
 526         EnableWindow(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), TRUE);
 527         EnableWindow(GetDlgItem(hwnd, IDC_STRRECOVERWRITE), TRUE);
 528         SendMessage(GetDlgItem(hwnd, IDC_STRRECDUMPFILE), WM_SETTEXT, (WPARAM)0, (LPARAM)pStartInfo->szDumpFile);
 529     }
 530     SendDlgItemMessage(hwnd, IDC_STRRECDEBUGCOMBO, CB_SETCURSEL, (WPARAM)pStartInfo->dwCrashDumpEnabled, (LPARAM)0);
 531 }
 532
 533 static VOID
 534 WriteStartupRecoveryOptions(HWND hwndDlg, PSTARTINFO pStartInfo)
 535 {
 536     HKEY hKey;
 537     DWORD lResult;
 538
 539     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
 540                      _T("System\\CurrentControlSet\\Control\\CrashControl"),
 541                      0,
 542                      KEY_WRITE,
 543                      &hKey) != ERROR_SUCCESS)
 544     {
 545         /* failed to open key */
 546         return;
 547     }
 548
 549     lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECWRITEEVENT, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
 550     RegSetValueEx(hKey, _T("LogEvent"), 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
 551
 552     lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECSENDALERT, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
 553     RegSetValueEx(hKey, _T("SendAlert"), 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
 554
 555     lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECRESTART, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
 556     RegSetValueEx(hKey, _T("AutoReboot"), 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
 557
 558     lResult = (DWORD) SendDlgItemMessage(hwndDlg, IDC_STRRECOVERWRITE, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
 559     RegSetValueEx(hKey, _T("Overwrite"), 0, REG_DWORD, (LPBYTE)&lResult, sizeof(lResult));
 560
 561
 562     if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
 563     {
 564         SendDlgItemMessage(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(TCHAR), (LPARAM)pStartInfo->szDumpFile);
 565         RegSetValueEx(hKey, _T("DumpFile"), 0, REG_EXPAND_SZ, (LPBYTE)pStartInfo->szDumpFile, (_tcslen(pStartInfo->szDumpFile) + 1) * sizeof(TCHAR));
 566     }
 567     else if (pStartInfo->dwCrashDumpEnabled == 3)
 568     {
 569         SendDlgItemMessage(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(TCHAR), (LPARAM)pStartInfo->szDumpFile);
 570         RegSetValueEx(hKey, _T("MinidumpDir"), 0, REG_EXPAND_SZ, (LPBYTE)pStartInfo->szDumpFile, (_tcslen(pStartInfo->szDumpFile) + 1) * sizeof(TCHAR));
 571     }
 572
 573     RegSetValueEx(hKey, _T("CrashDumpEnabled"), 0, REG_DWORD, (LPBYTE)(DWORD_PTR)pStartInfo->dwCrashDumpEnabled, sizeof(pStartInfo->dwCrashDumpEnabled));
 574     RegCloseKey(hKey);
 575 }
 576
 577 static VOID
 578 LoadRecoveryOptions(HWND hwndDlg, PSTARTINFO pStartInfo)
 579 {
 580     HKEY hKey;
 581     DWORD dwValues;
 582     TCHAR szName[MAX_PATH];
 583     TCHAR szValue[MAX_PATH];
 584     DWORD i, dwName, dwValue, dwValueLength, dwType;
 585
 586     if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
 587                      _T("System\\CurrentControlSet\\Control\\CrashControl"),
 588                      0,
 589                      KEY_READ,
 590                      &hKey) != ERROR_SUCCESS)
 591     {
 592         /* failed to open key */
 593         return;
 594     }
 595
 596     if (RegQueryInfoKey(hKey,
 597                         NULL,
 598                         NULL,
 599                         NULL,
 600                         NULL,
 601                         NULL,
 602                         NULL,
 603                         &dwValues,
 604                         NULL,
 605                         NULL,
 606                         NULL,
 607                         NULL) != ERROR_SUCCESS)
 608     {
 609         RegCloseKey(hKey);
 610         return;
 611     }
 612
 613     for (i = 0; i < dwValues; i++)
 614     {
 615         dwName = sizeof(szName) / sizeof(TCHAR);
 616
 617         RegEnumValue(hKey, i, szName, &dwName, NULL, &dwType, NULL, NULL);
 618         if (dwType == REG_DWORD)
 619         {
 620             dwValueLength = sizeof(dwValue);
 621             dwName = sizeof(szName) / sizeof(TCHAR);
 622             if (RegEnumValue(hKey, i, szName, &dwName, NULL, &dwType, (LPBYTE)&dwValue, &dwValueLength) != ERROR_SUCCESS)
 623                 continue;
 624         }
 625         else
 626         {
 627             dwValueLength = sizeof(szValue);
 628             dwName = sizeof(szName) / sizeof(TCHAR);
 629             if (RegEnumValue(hKey, i, szName, &dwName, NULL, &dwType, (LPBYTE)&szValue, &dwValueLength) != ERROR_SUCCESS)
 630                 continue;
 631         }
 632
 633         if (!_tcscmp(szName, _T("LogEvent")))
 634         {
 635             if (dwValue)
 636                 SendDlgItemMessage(hwndDlg, IDC_STRRECWRITEEVENT, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 637         }
 638         else if (!_tcscmp(szName, _T("SendAlert")))
 639         {
 640             if (dwValue)
 641                 SendDlgItemMessage(hwndDlg, IDC_STRRECSENDALERT, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 642         }
 643         else if (!_tcscmp(szName, _T("AutoReboot")))
 644         {
 645             if (dwValue)
 646                 SendDlgItemMessage(hwndDlg, IDC_STRRECRESTART, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 647         }
 648         else if (!_tcscmp(szName, _T("Overwrite")))
 649         {
 650             if (dwValue)
 651                 SendDlgItemMessage(hwndDlg, IDC_STRRECOVERWRITE, BM_SETCHECK, (WPARAM)BST_CHECKED, (LPARAM)0);
 652         }
 653         else if (!_tcscmp(szName, _T("DumpFile")))
 654         {
 655             _tcscpy(pStartInfo->szDumpFile, szValue);
 656         }
 657         else if (!_tcscmp(szName, _T("MinidumpDir")))
 658         {
 659             _tcscpy(pStartInfo->szMinidumpDir, szValue);
 660         }
 661         else if (!_tcscmp(szName, _T("CrashDumpEnabled")))
 662         {
 663             pStartInfo->dwCrashDumpEnabled = dwValue;
 664         }
 665     }
 666
 667     if (LoadString(hApplet, IDS_NO_DUMP, szValue, sizeof(szValue) / sizeof(TCHAR)) < sizeof(szValue) / sizeof(TCHAR))
 668         SendDlgItemMessage(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szValue);
 669
 670     if (LoadString(hApplet, IDS_FULL_DUMP, szValue, sizeof(szValue) / sizeof(TCHAR)) < sizeof(szValue) / sizeof(TCHAR))
 671         SendDlgItemMessage(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szValue);
 672
 673     if (LoadString(hApplet, IDS_KERNEL_DUMP, szValue, sizeof(szValue) / sizeof(TCHAR)) < sizeof(szValue) / sizeof(TCHAR))
 674         SendDlgItemMessage(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szValue);
 675
 676     if (LoadString(hApplet, IDS_MINI_DUMP, szValue, sizeof(szValue) / sizeof(TCHAR)) < sizeof(szValue) / sizeof(TCHAR))
 677         SendDlgItemMessage(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_ADDSTRING, (WPARAM)0, (LPARAM) szValue);
 678
 679     SetCrashDlgItems(hwndDlg, pStartInfo);
 680     RegCloseKey(hKey);
 681 }
 682
 683
 684 /* Property page dialog callback */
 685 INT_PTR CALLBACK
 686 StartRecDlgProc(HWND hwndDlg,
 687                 UINT uMsg,
 688                 WPARAM wParam,
 689                 LPARAM lParam)
 690 {
 691     PSTARTINFO pStartInfo;
 692     PBOOTRECORD pRecord;
 693     int iTimeout;
 694     LRESULT lResult;
 695     TCHAR szTimeout[10];
 696
 697     UNREFERENCED_PARAMETER(lParam);
 698
 699     pStartInfo = (PSTARTINFO)GetWindowLongPtr(hwndDlg, DWLP_USER);
 700
 701     switch(uMsg)
 702     {
 703         case WM_INITDIALOG:
 704             pStartInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STARTINFO));
 705             SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pStartInfo);
 706
 707             LoadRecoveryOptions(hwndDlg, pStartInfo);
 708             SetRecoveryTimeout(hwndDlg, 0);
 709             return LoadOSList(hwndDlg, pStartInfo);
 710
 711         case WM_DESTROY:
 712             DeleteBootRecords(hwndDlg);
 713             HeapFree(GetProcessHeap(), 0, pStartInfo);
 714             break;
 715
 716         case WM_COMMAND:
 717             switch(LOWORD(wParam))
 718             {
 719                 case IDC_STRRECEDIT:
 720                     ShellExecute(0, _T("open"), _T("notepad"), pStartInfo->szFreeldrIni, NULL, SW_SHOWNORMAL);
 721                     // FIXME use CreateProcess and wait untill finished
 722                     //  DeleteBootRecords(hwndDlg);
 723                     //  LoadOSList(hwndDlg);
 724                     break;
 725
 726                 case IDOK:
 727                     /* save timeout */
 728                     if (SendDlgItemMessage(hwndDlg, IDC_STRECLIST, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
 729                         iTimeout = SendDlgItemMessage(hwndDlg, IDC_STRRECLISTUPDWN, UDM_GETPOS, (WPARAM)0, (LPARAM)0);
 730                     else
 731                         iTimeout = 0;
 732                     _stprintf(szTimeout, _T("%i"), iTimeout);
 733
 734                     lResult = SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
 735                     if (lResult == CB_ERR)
 736                     {
 737                         /* ? */
 738                         DeleteBootRecords(hwndDlg);
 739                         return TRUE;
 740                     }
 741
 742                     pRecord = (PBOOTRECORD) SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_GETITEMDATA, (WPARAM)lResult, (LPARAM)0);
 743
 744                     if ((INT_PTR)pRecord != CB_ERR)
 745                     {
 746                         if (pStartInfo->iFreeLdrIni == 1) // FreeLdrIni style
 747                         {
 748                             /* set default timeout */
 749                             WritePrivateProfileString(_T("FREELOADER"),
 750                                                       _T("TimeOut"),
 751                                                       szTimeout,
 752                                                       pStartInfo->szFreeldrIni);
 753                             /* set default os */
 754                             WritePrivateProfileString(_T("FREELOADER"),
 755                                                       _T("DefaultOS"),
 756                                                       pRecord->szSectionName,
 757                                                       pStartInfo->szFreeldrIni);
 758
 759                         }
 760                         else if (pStartInfo->iFreeLdrIni == 2) // BootIni style
 761                         {
 762                             /* set default timeout */
 763                             WritePrivateProfileString(_T("boot loader"),
 764                                                       _T("timeout"),
 765                                                       szTimeout,
 766                                                       pStartInfo->szFreeldrIni);
 767                             /* set default os */
 768                             WritePrivateProfileString(_T("boot loader"),
 769                                                       _T("default"),
 770                                                       pRecord->szBootPath,
 771                                                       pStartInfo->szFreeldrIni);
 772
 773                         }
 774                     }
 775
 776                     WriteStartupRecoveryOptions(hwndDlg, pStartInfo);
 777                     EndDialog(hwndDlg,
 778                               LOWORD(wParam));
 779                     return TRUE;
 780
 781                 case IDCANCEL:
 782                     EndDialog(hwndDlg,
 783                               LOWORD(wParam));
 784                     return TRUE;
 785
 786                 case IDC_STRECLIST:
 787                     if (SendDlgItemMessage(hwndDlg, IDC_STRECLIST, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
 788                         SetTimeout(hwndDlg, 30);
 789                     else
 790                         SetTimeout(hwndDlg, 0);
 791                     break;
 792
 793                 case IDC_STRRECREC:
 794                     if (SendDlgItemMessage(hwndDlg, IDC_STRRECREC, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
 795                         SetRecoveryTimeout(hwndDlg, 30);
 796                     else
 797                         SetRecoveryTimeout(hwndDlg, 0);
 798                     break;
 799
 800                 case IDC_STRRECDEBUGCOMBO:
 801                     if (HIWORD(wParam) == CBN_SELCHANGE)
 802                     {
 803                         LRESULT lResult;
 804
 805                         lResult = SendDlgItemMessage(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
 806                         if (lResult != CB_ERR && lResult != pStartInfo->dwCrashDumpEnabled)
 807                         {
 808                             if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
 809                             {
 810                                 SendDlgItemMessage(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(TCHAR), (LPARAM)pStartInfo->szDumpFile);
 811                             }
 812                             else if (pStartInfo->dwCrashDumpEnabled == 3)
 813                             {
 814                                 SendDlgItemMessage(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szMinidumpDir) / sizeof(TCHAR), (LPARAM)pStartInfo->szMinidumpDir);
 815                             }
 816
 817                             pStartInfo->dwCrashDumpEnabled = lResult;
 818                             SetCrashDlgItems(hwndDlg, pStartInfo);
 819                         }
 820                     }
 821                     break;
 822             }
 823             break;
 824     }
 825
 826     return FALSE;
 827 }