reactos/dll/cpl/sysdm/startrec.c

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