base/setup/lib/bootsup.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Setup Library
   4  * FILE:            base/setup/lib/bootsup.c
   5  * PURPOSE:         Bootloader support functions
   6  * PROGRAMMERS:     ...
   7  *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   8  */
   9
  10 /* INCLUDES *****************************************************************/
  11
  12 #include "precomp.h"
  13
  14 #include "bldrsup.h"
  15 #include "filesup.h"
  16 #include "partlist.h"
  17 #include "bootcode.h"
  18 #include "fsutil.h"
  19
  20 #include "setuplib.h" // HAXX for IsUnattendedSetup!!
  21
  22 #include "bootsup.h"
  23
  24 #define NDEBUG
  25 #include <debug.h>
  26
  27 /*
  28  * BIG FIXME!!
  29  * ===========
  30  *
  31  * bootsup.c can deal with MBR code (actually it'll have at some point
  32  * to share or give it to partlist.c, because when we'll support GPT disks,
  33  * things will change a bit).
  34  * And, bootsup.c can manage initializing / adding boot entries into NTLDR
  35  * and FREELDR, and installing the latter, and saving the old MBR / boot
  36  * sectors in files.
  37  */
  38
  39 /* FUNCTIONS ****************************************************************/
  40
  41 static VOID
  42 TrimTrailingPathSeparators_UStr(
  43     IN OUT PUNICODE_STRING UnicodeString)
  44 {
  45     while (UnicodeString->Length >= sizeof(WCHAR) &&
  46            UnicodeString->Buffer[UnicodeString->Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
  47     {
  48         UnicodeString->Length -= sizeof(WCHAR);
  49     }
  50 }
  51
  52
  53 static VOID
  54 CreateFreeLoaderReactOSEntries(
  55     IN PVOID BootStoreHandle,
  56     IN PCWSTR ArcPath)
  57 {
  58     UCHAR xxBootEntry[FIELD_OFFSET(BOOT_STORE_ENTRY, OsOptions) + sizeof(NTOS_OPTIONS)];
  59     PBOOT_STORE_ENTRY BootEntry = (PBOOT_STORE_ENTRY)&xxBootEntry;
  60     PNTOS_OPTIONS Options = (PNTOS_OPTIONS)&BootEntry->OsOptions;
  61     BOOT_STORE_OPTIONS BootOptions;
  62
  63     BootEntry->Version = FreeLdr;
  64     BootEntry->BootFilePath = NULL;
  65
  66     BootEntry->OsOptionsLength = sizeof(NTOS_OPTIONS);
  67     RtlCopyMemory(Options->Signature,
  68                   NTOS_OPTIONS_SIGNATURE,
  69                   RTL_FIELD_SIZE(NTOS_OPTIONS, Signature));
  70
  71     Options->OsLoadPath = ArcPath;
  72
  73     /* ReactOS */
  74     // BootEntry->BootEntryKey = MAKESTRKEY(L"ReactOS");
  75     BootEntry->FriendlyName = L"\"ReactOS\"";
  76     Options->OsLoadOptions  = NULL; // L"";
  77     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(L"ReactOS"));
  78
  79     /* ReactOS_Debug */
  80     // BootEntry->BootEntryKey = MAKESTRKEY(L"ReactOS_Debug");
  81     BootEntry->FriendlyName = L"\"ReactOS (Debug)\"";
  82     Options->OsLoadOptions  = L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS";
  83     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(L"ReactOS_Debug"));
  84
  85 #ifdef _WINKD_
  86     /* ReactOS_VBoxDebug */
  87     // BootEntry->BootEntryKey = MAKESTRKEY(L"ReactOS_VBoxDebug");
  88     BootEntry->FriendlyName = L"\"ReactOS (VBox Debug)\"";
  89     Options->OsLoadOptions  = L"/DEBUG /DEBUGPORT=VBOX /SOS";
  90     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(L"ReactOS_VBoxDebug"));
  91 #endif
  92 #if DBG
  93 #ifndef _WINKD_
  94     /* ReactOS_KdSerial */
  95     // BootEntry->BootEntryKey = MAKESTRKEY(L"ReactOS_KdSerial");
  96     BootEntry->FriendlyName = L"\"ReactOS (RosDbg)\"";
  97     Options->OsLoadOptions  = L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS /KDSERIAL";
  98     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(L"ReactOS_KdSerial"));
  99 #endif
 100
 101     /* ReactOS_Screen */
 102     // BootEntry->BootEntryKey = MAKESTRKEY(L"ReactOS_Screen");
 103     BootEntry->FriendlyName = L"\"ReactOS (Screen)\"";
 104     Options->OsLoadOptions  = L"/DEBUG /DEBUGPORT=SCREEN /SOS";
 105     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(L"ReactOS_Screen"));
 106
 107     /* ReactOS_LogFile */
 108     // BootEntry->BootEntryKey = MAKESTRKEY(L"ReactOS_LogFile");
 109     BootEntry->FriendlyName = L"\"ReactOS (Log file)\"";
 110     Options->OsLoadOptions  = L"/DEBUG /DEBUGPORT=FILE /SOS";
 111     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(L"ReactOS_LogFile"));
 112
 113     /* ReactOS_Ram */
 114     // BootEntry->BootEntryKey = MAKESTRKEY(L"ReactOS_Ram");
 115     BootEntry->FriendlyName = L"\"ReactOS (RAM Disk)\"";
 116     Options->OsLoadPath     = L"ramdisk(0)\\ReactOS";
 117     Options->OsLoadOptions  = L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS /RDPATH=reactos.img /RDIMAGEOFFSET=32256";
 118     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(L"ReactOS_Ram"));
 119
 120     /* ReactOS_EMS */
 121     // BootEntry->BootEntryKey = MAKESTRKEY(L"ReactOS_EMS");
 122     BootEntry->FriendlyName = L"\"ReactOS (Emergency Management Services)\"";
 123     Options->OsLoadPath     = ArcPath;
 124     Options->OsLoadOptions  = L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS /redirect=com2 /redirectbaudrate=115200";
 125     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(L"ReactOS_EMS"));
 126 #endif
 127
 128
 129     /* DefaultOS=ReactOS */
 130 #if DBG && !defined(_WINKD_)
 131     if (IsUnattendedSetup)
 132     {
 133         BootOptions.CurrentBootEntryKey = MAKESTRKEY(L"ReactOS_KdSerial");
 134     }
 135     else
 136 #endif
 137     {
 138 #if DBG
 139         BootOptions.CurrentBootEntryKey = MAKESTRKEY(L"ReactOS_Debug");
 140 #else
 141         BootOptions.CurrentBootEntryKey = MAKESTRKEY(L"ReactOS");
 142 #endif
 143     }
 144
 145 #if DBG
 146     if (IsUnattendedSetup)
 147 #endif
 148     {
 149         /* Timeout=0 for unattended or non debug */
 150         BootOptions.Timeout = 0;
 151     }
 152 #if DBG
 153     else
 154     {
 155         /* Timeout=10 */
 156         BootOptions.Timeout = 10;
 157     }
 158 #endif
 159
 160     BootOptions.Version = FreeLdr;
 161     SetBootStoreOptions(BootStoreHandle, &BootOptions, 2 | 1);
 162 }
 163
 164 static NTSTATUS
 165 CreateFreeLoaderIniForReactOS(
 166     IN PCWSTR IniPath,
 167     IN PCWSTR ArcPath)
 168 {
 169     NTSTATUS Status;
 170     PVOID BootStoreHandle;
 171
 172     /* Initialize the INI file and create the common FreeLdr sections */
 173     Status = OpenBootStore(&BootStoreHandle, IniPath, FreeLdr, TRUE);
 174     if (!NT_SUCCESS(Status))
 175         return Status;
 176
 177     /* Add the ReactOS entries */
 178     CreateFreeLoaderReactOSEntries(BootStoreHandle, ArcPath);
 179
 180     /* Close the INI file */
 181     CloseBootStore(BootStoreHandle);
 182     return STATUS_SUCCESS;
 183 }
 184
 185 static NTSTATUS
 186 CreateFreeLoaderIniForReactOSAndBootSector(
 187     IN PCWSTR IniPath,
 188     IN PCWSTR ArcPath,
 189     IN PCWSTR Section,
 190     IN PCWSTR Description,
 191     IN PCWSTR BootDrive,
 192     IN PCWSTR BootPartition,
 193     IN PCWSTR BootSector)
 194 {
 195     NTSTATUS Status;
 196     PVOID BootStoreHandle;
 197     UCHAR xxBootEntry[FIELD_OFFSET(BOOT_STORE_ENTRY, OsOptions) + sizeof(BOOT_SECTOR_OPTIONS)];
 198     PBOOT_STORE_ENTRY BootEntry = (PBOOT_STORE_ENTRY)&xxBootEntry;
 199     PBOOT_SECTOR_OPTIONS Options = (PBOOT_SECTOR_OPTIONS)&BootEntry->OsOptions;
 200
 201     /* Initialize the INI file and create the common FreeLdr sections */
 202     Status = OpenBootStore(&BootStoreHandle, IniPath, FreeLdr, TRUE);
 203     if (!NT_SUCCESS(Status))
 204         return Status;
 205
 206     /* Add the ReactOS entries */
 207     CreateFreeLoaderReactOSEntries(BootStoreHandle, ArcPath);
 208
 209     BootEntry->Version = FreeLdr;
 210     BootEntry->BootFilePath = NULL;
 211
 212     BootEntry->OsOptionsLength = sizeof(BOOT_SECTOR_OPTIONS);
 213     RtlCopyMemory(Options->Signature,
 214                   BOOT_SECTOR_OPTIONS_SIGNATURE,
 215                   RTL_FIELD_SIZE(BOOT_SECTOR_OPTIONS, Signature));
 216
 217     Options->Drive = BootDrive;
 218     Options->Partition = BootPartition;
 219     Options->BootSectorFileName = BootSector;
 220
 221     // BootEntry->BootEntryKey = MAKESTRKEY(Section);
 222     BootEntry->FriendlyName = Description;
 223     AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(Section));
 224
 225     /* Close the INI file */
 226     CloseBootStore(BootStoreHandle);
 227     return STATUS_SUCCESS;
 228 }
 229
 230 //
 231 // I think this function can be generalizable as:
 232 // "find the corresponding 'ReactOS' boot entry in this loader config file
 233 // (here abstraction comes there), and if none, add a new one".
 234 //
 235
 236 typedef struct _ENUM_REACTOS_ENTRIES_DATA
 237 {
 238     ULONG i;
 239     BOOLEAN UseExistingEntry;
 240     PCWSTR ArcPath;
 241     WCHAR SectionName[80];
 242     WCHAR OsName[80];
 243 } ENUM_REACTOS_ENTRIES_DATA, *PENUM_REACTOS_ENTRIES_DATA;
 244
 245 // PENUM_BOOT_ENTRIES_ROUTINE
 246 static NTSTATUS
 247 NTAPI
 248 EnumerateReactOSEntries(
 249     IN BOOT_STORE_TYPE Type,
 250     IN PBOOT_STORE_ENTRY BootEntry,
 251     IN PVOID Parameter OPTIONAL)
 252 {
 253     NTSTATUS Status;
 254     PENUM_REACTOS_ENTRIES_DATA Data = (PENUM_REACTOS_ENTRIES_DATA)Parameter;
 255     PNTOS_OPTIONS Options = (PNTOS_OPTIONS)&BootEntry->OsOptions;
 256     WCHAR SystemPath[MAX_PATH];
 257
 258     /* We have a boot entry */
 259
 260     /* Check for supported boot type "Windows2003" */
 261     if (BootEntry->OsOptionsLength < sizeof(NTOS_OPTIONS) ||
 262         RtlCompareMemory(&BootEntry->OsOptions /* Signature */,
 263                          NTOS_OPTIONS_SIGNATURE,
 264                          RTL_FIELD_SIZE(NTOS_OPTIONS, Signature)) !=
 265                          RTL_FIELD_SIZE(NTOS_OPTIONS, Signature))
 266     {
 267         /* This is not a ReactOS entry */
 268         // DPRINT("    An installation '%S' of unsupported type '%S'\n",
 269                // BootEntry->FriendlyName, BootEntry->Version ? BootEntry->Version : L"n/a");
 270         DPRINT("    An installation '%S' of unsupported type %lu\n",
 271                BootEntry->FriendlyName, BootEntry->OsOptionsLength);
 272         /* Continue the enumeration */
 273         goto SkipThisEntry;
 274     }
 275
 276     /* BootType is Windows2003, now check OsLoadPath */
 277     if (!Options->OsLoadPath || !*Options->OsLoadPath)
 278     {
 279         /* Certainly not a ReactOS installation */
 280         DPRINT1("    A Win2k3 install '%S' without an ARC path?!\n", BootEntry->FriendlyName);
 281         /* Continue the enumeration */
 282         goto SkipThisEntry;
 283     }
 284
 285     if (_wcsicmp(Options->OsLoadPath, Data->ArcPath) != 0)
 286     {
 287         /* Not found, retry with a quoted path */
 288         Status = RtlStringCchPrintfW(SystemPath, ARRAYSIZE(SystemPath), L"\"%s\"", Data->ArcPath);
 289         if (!NT_SUCCESS(Status) || _wcsicmp(Options->OsLoadPath, SystemPath) != 0)
 290         {
 291             /*
 292              * This entry is a ReactOS entry, but the SystemRoot
 293              * does not match the one we are looking for.
 294              */
 295             /* Continue the enumeration */
 296             goto SkipThisEntry;
 297         }
 298     }
 299
 300     DPRINT("    Found a candidate Win2k3 install '%S' with ARC path '%S'\n",
 301            BootEntry->FriendlyName, Options->OsLoadPath);
 302     // DPRINT("    Found a Win2k3 install '%S' with ARC path '%S'\n",
 303            // BootEntry->FriendlyName, Options->OsLoadPath);
 304
 305     DPRINT("EnumerateReactOSEntries: OsLoadPath: '%S'\n", Options->OsLoadPath);
 306
 307     Data->UseExistingEntry = TRUE;
 308     RtlStringCchCopyW(Data->OsName, ARRAYSIZE(Data->OsName), BootEntry->FriendlyName);
 309
 310     /* We have found our entry, stop the enumeration now! */
 311     return STATUS_NO_MORE_ENTRIES;
 312
 313 SkipThisEntry:
 314     Data->UseExistingEntry = FALSE;
 315     if (Type == FreeLdr && wcscmp(Data->SectionName, (PWSTR)BootEntry->BootEntryKey)== 0)
 316     {
 317         RtlStringCchPrintfW(Data->SectionName, ARRAYSIZE(Data->SectionName),
 318                             L"ReactOS_%lu", Data->i);
 319         RtlStringCchPrintfW(Data->OsName, ARRAYSIZE(Data->OsName),
 320                             L"\"ReactOS %lu\"", Data->i);
 321         Data->i++;
 322     }
 323     return STATUS_SUCCESS;
 324 }
 325
 326 static
 327 NTSTATUS
 328 UpdateFreeLoaderIni(
 329     IN PCWSTR IniPath,
 330     IN PCWSTR ArcPath)
 331 {
 332     NTSTATUS Status;
 333     PVOID BootStoreHandle;
 334     ENUM_REACTOS_ENTRIES_DATA Data;
 335     UCHAR xxBootEntry[FIELD_OFFSET(BOOT_STORE_ENTRY, OsOptions) + sizeof(NTOS_OPTIONS)];
 336     PBOOT_STORE_ENTRY BootEntry = (PBOOT_STORE_ENTRY)&xxBootEntry;
 337     PNTOS_OPTIONS Options = (PNTOS_OPTIONS)&BootEntry->OsOptions;
 338
 339     /* Open the INI file */
 340     Status = OpenBootStore(&BootStoreHandle, IniPath, FreeLdr, /*TRUE*/ FALSE);
 341     if (!NT_SUCCESS(Status))
 342         return Status;
 343
 344     /* Find an existing usable or an unused section name */
 345     Data.UseExistingEntry = TRUE;
 346     Data.i = 1;
 347     Data.ArcPath = ArcPath;
 348     RtlStringCchCopyW(Data.SectionName, ARRAYSIZE(Data.SectionName), L"ReactOS");
 349     RtlStringCchCopyW(Data.OsName, ARRAYSIZE(Data.OsName), L"\"ReactOS\"");
 350
 351     //
 352     // FIXME: We temporarily use EnumerateBootStoreEntries, until
 353     // both QueryBootStoreEntry and ModifyBootStoreEntry get implemented.
 354     //
 355     Status = EnumerateBootStoreEntries(BootStoreHandle, EnumerateReactOSEntries, &Data);
 356
 357     /* Create a new "ReactOS" entry if there is none already existing that suits us */
 358     if (!Data.UseExistingEntry)
 359     {
 360         // RtlStringCchPrintfW(Data.SectionName, ARRAYSIZE(Data.SectionName), L"ReactOS_%lu", Data.i);
 361         // RtlStringCchPrintfW(Data.OsName, ARRAYSIZE(Data.OsName), L"\"ReactOS %lu\"", Data.i);
 362
 363         BootEntry->Version = FreeLdr;
 364         BootEntry->BootFilePath = NULL;
 365
 366         BootEntry->OsOptionsLength = sizeof(NTOS_OPTIONS);
 367         RtlCopyMemory(Options->Signature,
 368                       NTOS_OPTIONS_SIGNATURE,
 369                       RTL_FIELD_SIZE(NTOS_OPTIONS, Signature));
 370
 371         Options->OsLoadPath = ArcPath;
 372
 373         // BootEntry->BootEntryKey = MAKESTRKEY(Data.SectionName);
 374         BootEntry->FriendlyName = Data.OsName;
 375         Options->OsLoadOptions  = NULL; // L"";
 376         AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(Data.SectionName));
 377     }
 378
 379     /* Close the INI file */
 380     CloseBootStore(BootStoreHandle);
 381     return STATUS_SUCCESS;
 382 }
 383
 384 static
 385 NTSTATUS
 386 UpdateBootIni(
 387     IN PCWSTR IniPath,
 388     IN PCWSTR EntryName,    // ~= ArcPath
 389     IN PCWSTR EntryValue)
 390 {
 391     NTSTATUS Status;
 392     PVOID BootStoreHandle;
 393     ENUM_REACTOS_ENTRIES_DATA Data;
 394
 395     // NOTE: Technically it would be "BootSector"...
 396     UCHAR xxBootEntry[FIELD_OFFSET(BOOT_STORE_ENTRY, OsOptions) + sizeof(NTOS_OPTIONS)];
 397     PBOOT_STORE_ENTRY BootEntry = (PBOOT_STORE_ENTRY)&xxBootEntry;
 398     PNTOS_OPTIONS Options = (PNTOS_OPTIONS)&BootEntry->OsOptions;
 399
 400     /* Open the INI file */
 401     Status = OpenBootStore(&BootStoreHandle, IniPath, NtLdr, FALSE);
 402     if (!NT_SUCCESS(Status))
 403         return Status;
 404
 405     /* Find an existing usable or an unused section name */
 406     Data.UseExistingEntry = TRUE;
 407     // Data.i = 1;
 408     Data.ArcPath = EntryName;
 409     // RtlStringCchCopyW(Data.SectionName, ARRAYSIZE(Data.SectionName), L"ReactOS");
 410     RtlStringCchCopyW(Data.OsName, ARRAYSIZE(Data.OsName), L"\"ReactOS\"");
 411
 412     //
 413     // FIXME: We temporarily use EnumerateBootStoreEntries, until
 414     // both QueryBootStoreEntry and ModifyBootStoreEntry get implemented.
 415     //
 416     Status = EnumerateBootStoreEntries(BootStoreHandle, EnumerateReactOSEntries, &Data);
 417
 418     /* If either the key was not found, or contains something else, add a new one */
 419     if (!Data.UseExistingEntry /* ||
 420         ( (Status == STATUS_NO_MORE_ENTRIES) && wcscmp(Data.OsName, EntryValue) ) */)
 421     {
 422         BootEntry->Version = NtLdr;
 423         BootEntry->BootFilePath = NULL;
 424
 425         BootEntry->OsOptionsLength = sizeof(NTOS_OPTIONS);
 426         RtlCopyMemory(Options->Signature,
 427                       NTOS_OPTIONS_SIGNATURE,
 428                       RTL_FIELD_SIZE(NTOS_OPTIONS, Signature));
 429
 430         Options->OsLoadPath = EntryName;
 431
 432         // BootEntry->BootEntryKey = MAKESTRKEY(Data.SectionName);
 433         // BootEntry->FriendlyName = Data.OsName;
 434         BootEntry->FriendlyName = EntryValue;
 435         Options->OsLoadOptions  = NULL; // L"";
 436         AddBootStoreEntry(BootStoreHandle, BootEntry, MAKESTRKEY(0 /*Data.SectionName*/));
 437     }
 438
 439     /* Close the INI file */
 440     CloseBootStore(BootStoreHandle);
 441     return STATUS_SUCCESS; // Status;
 442 }
 443
 444
 445 static
 446 BOOLEAN
 447 IsThereAValidBootSector(
 448     IN PCWSTR RootPath)
 449 {
 450     /*
 451      * We first demand that the bootsector has a valid signature at its end.
 452      * We then check the first 3 bytes (as a ULONG) of the bootsector for a
 453      * potential "valid" instruction (the BIOS starts execution of the bootsector
 454      * at its beginning). Currently this criterium is that this ULONG must be
 455      * non-zero. If both these tests pass, then the bootsector is valid; otherwise
 456      * it is invalid and certainly needs to be overwritten.
 457      */
 458
 459     BOOLEAN IsValid = FALSE;
 460     NTSTATUS Status;
 461     UNICODE_STRING RootPartition;
 462     BOOTCODE BootSector = {0};
 463
 464     /* Allocate and read the root partition bootsector.
 465      * Remove any trailing backslash if needed. */
 466     RtlInitUnicodeString(&RootPartition, RootPath);
 467     TrimTrailingPathSeparators_UStr(&RootPartition);
 468     Status = ReadBootCodeFromFile(&BootSector, &RootPartition, SECTORSIZE);
 469     if (!NT_SUCCESS(Status))
 470         return FALSE;
 471
 472     /* Check for the existence of the bootsector signature */
 473     IsValid = (*(PUSHORT)((PUCHAR)BootSector.BootCode + 0x1FE) == 0xAA55);
 474     if (IsValid)
 475     {
 476         /* Check for the first instruction encoded on three bytes */
 477         IsValid = (((*(PULONG)BootSector.BootCode) & 0x00FFFFFF) != 0x00000000);
 478     }
 479
 480     /* Free the bootsector and return */
 481     FreeBootCode(&BootSector);
 482     return IsValid;
 483 }
 484
 485 static
 486 NTSTATUS
 487 SaveBootSector(
 488     IN PCWSTR RootPath,
 489     IN PCWSTR DstPath,
 490     IN ULONG Length)
 491 {
 492     NTSTATUS Status;
 493     UNICODE_STRING Name;
 494     OBJECT_ATTRIBUTES ObjectAttributes;
 495     IO_STATUS_BLOCK IoStatusBlock;
 496     HANDLE FileHandle;
 497     // LARGE_INTEGER FileOffset;
 498     BOOTCODE BootSector = {0};
 499
 500     /* Allocate and read the root partition bootsector.
 501      * Remove any trailing backslash if needed. */
 502     RtlInitUnicodeString(&Name, RootPath);
 503     TrimTrailingPathSeparators_UStr(&Name);
 504     Status = ReadBootCodeFromFile(&BootSector, &Name, Length);
 505     if (!NT_SUCCESS(Status))
 506         return Status;
 507
 508     /* Write the bootsector to DstPath */
 509     RtlInitUnicodeString(&Name, DstPath);
 510     InitializeObjectAttributes(&ObjectAttributes,
 511                                &Name,
 512                                OBJ_CASE_INSENSITIVE,
 513                                NULL,
 514                                NULL);
 515
 516     Status = NtCreateFile(&FileHandle,
 517                           GENERIC_WRITE | SYNCHRONIZE,
 518                           &ObjectAttributes,
 519                           &IoStatusBlock,
 520                           NULL,
 521                           FILE_ATTRIBUTE_NORMAL,
 522                           0,
 523                           FILE_SUPERSEDE,
 524                           FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY,
 525                           NULL,
 526                           0);
 527     if (!NT_SUCCESS(Status))
 528     {
 529         FreeBootCode(&BootSector);
 530         return Status;
 531     }
 532
 533     Status = NtWriteFile(FileHandle,
 534                          NULL,
 535                          NULL,
 536                          NULL,
 537                          &IoStatusBlock,
 538                          BootSector.BootCode,
 539                          BootSector.Length,
 540                          NULL,
 541                          NULL);
 542     NtClose(FileHandle);
 543
 544     /* Free the bootsector and return */
 545     FreeBootCode(&BootSector);
 546     return Status;
 547 }
 548
 549
 550 static
 551 NTSTATUS
 552 InstallBootCodeToDisk(
 553     IN PCWSTR SrcPath,
 554     IN PCWSTR RootPath,
 555     IN PFS_INSTALL_BOOTCODE InstallBootCode)
 556 {
 557     NTSTATUS Status, LockStatus;
 558     UNICODE_STRING Name;
 559     OBJECT_ATTRIBUTES ObjectAttributes;
 560     IO_STATUS_BLOCK IoStatusBlock;
 561     HANDLE PartitionHandle;
 562
 563     /*
 564      * Open the root partition from which the bootcode (MBR, VBR) parameters
 565      * will be obtained; this is also where we will write the updated bootcode.
 566      * Remove any trailing backslash if needed.
 567      */
 568     RtlInitUnicodeString(&Name, RootPath);
 569     TrimTrailingPathSeparators_UStr(&Name);
 570
 571     InitializeObjectAttributes(&ObjectAttributes,
 572                                &Name,
 573                                OBJ_CASE_INSENSITIVE,
 574                                NULL,
 575                                NULL);
 576
 577     Status = NtOpenFile(&PartitionHandle,
 578                         GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
 579                         &ObjectAttributes,
 580                         &IoStatusBlock,
 581                         FILE_SHARE_READ | FILE_SHARE_WRITE,
 582                         FILE_SYNCHRONOUS_IO_NONALERT /* | FILE_SEQUENTIAL_ONLY */);
 583     if (!NT_SUCCESS(Status))
 584         return Status;
 585
 586     /* Lock the volume */
 587     LockStatus = NtFsControlFile(PartitionHandle, NULL, NULL, NULL, &IoStatusBlock, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0);
 588     if (!NT_SUCCESS(LockStatus))
 589     {
 590         DPRINT1("Unable to lock the volume before installing boot code. Status 0x%08x. Expect problems.\n", LockStatus);
 591     }
 592
 593     /* Install the bootcode (MBR, VBR) */
 594     Status = InstallBootCode(SrcPath, PartitionHandle, PartitionHandle);
 595
 596     /* dismount & Unlock the volume */
 597     if (NT_SUCCESS(LockStatus))
 598     {
 599         LockStatus = NtFsControlFile(PartitionHandle, NULL, NULL, NULL, &IoStatusBlock, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0);
 600         if (!NT_SUCCESS(LockStatus))
 601         {
 602             DPRINT1("Unable to dismount the volume after installing boot code. Status 0x%08x. Expect problems.\n", LockStatus);
 603         }
 604
 605         LockStatus = NtFsControlFile(PartitionHandle, NULL, NULL, NULL, &IoStatusBlock, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0);
 606         if (!NT_SUCCESS(LockStatus))
 607         {
 608             DPRINT1("Unable to unlock the volume after installing boot code. Status 0x%08x. Expect problems.\n", LockStatus);
 609         }
 610     }
 611
 612     /* Close the partition */
 613     NtClose(PartitionHandle);
 614
 615     return Status;
 616 }
 617
 618 static
 619 NTSTATUS
 620 InstallBootCodeToFile(
 621     IN PCWSTR SrcPath,
 622     IN PCWSTR DstPath,
 623     IN PCWSTR RootPath,
 624     IN PFS_INSTALL_BOOTCODE InstallBootCode)
 625 {
 626     NTSTATUS Status;
 627     UNICODE_STRING Name;
 628     OBJECT_ATTRIBUTES ObjectAttributes;
 629     IO_STATUS_BLOCK IoStatusBlock;
 630     HANDLE PartitionHandle, FileHandle;
 631
 632     /*
 633      * Open the root partition from which the bootcode (MBR, VBR)
 634      * parameters will be obtained.
 635      *
 636      * FIXME? It might be possible that we need to also open it for writing
 637      * access in case we really need to still write the second portion of
 638      * the boot sector ????
 639      *
 640      * Remove any trailing backslash if needed.
 641      */
 642     RtlInitUnicodeString(&Name, RootPath);
 643     TrimTrailingPathSeparators_UStr(&Name);
 644
 645     InitializeObjectAttributes(&ObjectAttributes,
 646                                &Name,
 647                                OBJ_CASE_INSENSITIVE,
 648                                NULL,
 649                                NULL);
 650
 651     Status = NtOpenFile(&PartitionHandle,
 652                         GENERIC_READ | SYNCHRONIZE,
 653                         &ObjectAttributes,
 654                         &IoStatusBlock,
 655                         FILE_SHARE_READ | FILE_SHARE_WRITE,
 656                         FILE_SYNCHRONOUS_IO_NONALERT /* | FILE_SEQUENTIAL_ONLY */);
 657     if (!NT_SUCCESS(Status))
 658         return Status;
 659
 660     /* Open or create the file where the new bootsector will be saved */
 661     RtlInitUnicodeString(&Name, DstPath);
 662     InitializeObjectAttributes(&ObjectAttributes,
 663                                &Name,
 664                                OBJ_CASE_INSENSITIVE,
 665                                NULL,
 666                                NULL);
 667
 668     Status = NtCreateFile(&FileHandle,
 669                           GENERIC_WRITE | SYNCHRONIZE,
 670                           &ObjectAttributes,
 671                           &IoStatusBlock,
 672                           NULL,
 673                           FILE_ATTRIBUTE_NORMAL,
 674                           0,
 675                           FILE_SUPERSEDE, // FILE_OVERWRITE_IF
 676                           FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY,
 677                           NULL,
 678                           0);
 679     if (!NT_SUCCESS(Status))
 680     {
 681         DPRINT1("NtCreateFile() failed (Status %lx)\n", Status);
 682         NtClose(PartitionHandle);
 683         return Status;
 684     }
 685
 686     /* Install the bootcode (MBR, VBR) */
 687     Status = InstallBootCode(SrcPath, FileHandle, PartitionHandle);
 688
 689     /* Close the file and the partition */
 690     NtClose(FileHandle);
 691     NtClose(PartitionHandle);
 692
 693     return Status;
 694 }
 695
 696
 697 static
 698 NTSTATUS
 699 InstallMbrBootCode(
 700     IN PCWSTR SrcPath,      // MBR source file (on the installation medium)
 701     IN HANDLE DstPath,      // Where to save the bootsector built from the source + disk information
 702     IN HANDLE DiskHandle)   // Disk holding the (old) MBR information
 703 {
 704     NTSTATUS Status;
 705     UNICODE_STRING Name;
 706     IO_STATUS_BLOCK IoStatusBlock;
 707     LARGE_INTEGER FileOffset;
 708     BOOTCODE OrigBootSector = {0};
 709     BOOTCODE NewBootSector  = {0};
 710
 711 C_ASSERT(sizeof(PARTITION_SECTOR) == SECTORSIZE);
 712
 713     /* Allocate and read the current original MBR bootsector */
 714     Status = ReadBootCodeByHandle(&OrigBootSector,
 715                                   DiskHandle,
 716                                   sizeof(PARTITION_SECTOR));
 717     if (!NT_SUCCESS(Status))
 718         return Status;
 719
 720     /* Allocate and read the new bootsector from SrcPath */
 721     RtlInitUnicodeString(&Name, SrcPath);
 722     Status = ReadBootCodeFromFile(&NewBootSector,
 723                                   &Name,
 724                                   sizeof(PARTITION_SECTOR));
 725     if (!NT_SUCCESS(Status))
 726     {
 727         FreeBootCode(&OrigBootSector);
 728         return Status;
 729     }
 730
 731     /*
 732      * Copy the disk signature, the reserved fields and
 733      * the partition table from the old MBR to the new one.
 734      */
 735     RtlCopyMemory(&((PPARTITION_SECTOR)NewBootSector.BootCode)->Signature,
 736                   &((PPARTITION_SECTOR)OrigBootSector.BootCode)->Signature,
 737                   sizeof(PARTITION_SECTOR) -
 738                   FIELD_OFFSET(PARTITION_SECTOR, Signature)
 739                   /* Length of partition table */);
 740
 741     /* Free the original bootsector */
 742     FreeBootCode(&OrigBootSector);
 743
 744     /* Write the new bootsector to DstPath */
 745     FileOffset.QuadPart = 0ULL;
 746     Status = NtWriteFile(DstPath,
 747                          NULL,
 748                          NULL,
 749                          NULL,
 750                          &IoStatusBlock,
 751                          NewBootSector.BootCode,
 752                          NewBootSector.Length,
 753                          &FileOffset,
 754                          NULL);
 755
 756     /* Free the new bootsector */
 757     FreeBootCode(&NewBootSector);
 758
 759     return Status;
 760 }
 761
 762 NTSTATUS
 763 InstallMbrBootCodeToDisk(
 764     IN PUNICODE_STRING SystemRootPath,
 765     IN PUNICODE_STRING SourceRootPath,
 766     IN PCWSTR DestinationDevicePathBuffer)
 767 {
 768     NTSTATUS Status;
 769     WCHAR SourceMbrPathBuffer[MAX_PATH];
 770     WCHAR DstPath[MAX_PATH];
 771
 772 #if 0
 773     /*
 774      * The DestinationDevicePathBuffer parameter has been built with
 775      * the following instruction by the caller; I'm not yet sure whether
 776      * I actually want this function to build the path instead, hence
 777      * I keep this code here but disabled for now...
 778      */
 779     WCHAR DestinationDevicePathBuffer[MAX_PATH];
 780     RtlStringCchPrintfW(DestinationDevicePathBuffer, ARRAYSIZE(DestinationDevicePathBuffer),
 781                         L"\\Device\\Harddisk%d\\Partition0",
 782                         DiskNumber);
 783 #endif
 784
 785     CombinePaths(SourceMbrPathBuffer, ARRAYSIZE(SourceMbrPathBuffer), 2,
 786                  SourceRootPath->Buffer, L"\\loader\\dosmbr.bin");
 787
 788     if (IsThereAValidBootSector(DestinationDevicePathBuffer))
 789     {
 790         /* Save current MBR */
 791         CombinePaths(DstPath, ARRAYSIZE(DstPath), 2,
 792                      SystemRootPath->Buffer, L"mbr.old");
 793
 794         DPRINT1("Save MBR: %S ==> %S\n", DestinationDevicePathBuffer, DstPath);
 795         Status = SaveBootSector(DestinationDevicePathBuffer, DstPath, sizeof(PARTITION_SECTOR));
 796         if (!NT_SUCCESS(Status))
 797         {
 798             DPRINT1("SaveBootSector() failed (Status %lx)\n", Status);
 799             // Don't care if we succeeded or not saving the old MBR, just go ahead.
 800         }
 801     }
 802
 803     DPRINT1("Install MBR bootcode: %S ==> %S\n",
 804             SourceMbrPathBuffer, DestinationDevicePathBuffer);
 805
 806     /* Install the MBR */
 807     return InstallBootCodeToDisk(SourceMbrPathBuffer,
 808                                  DestinationDevicePathBuffer,
 809                                  InstallMbrBootCode);
 810 }
 811
 812
 813 static
 814 NTSTATUS
 815 InstallFatBootcodeToPartition(
 816     IN PUNICODE_STRING SystemRootPath,
 817     IN PUNICODE_STRING SourceRootPath,
 818     IN PUNICODE_STRING DestinationArcPath,
 819     IN PCWSTR FileSystemName)
 820 {
 821     NTSTATUS Status;
 822     BOOLEAN DoesFreeLdrExist;
 823     WCHAR SrcPath[MAX_PATH];
 824     WCHAR DstPath[MAX_PATH];
 825
 826     /* FAT or FAT32 partition */
 827     DPRINT("System path: '%wZ'\n", SystemRootPath);
 828
 829     /* Copy FreeLoader to the system partition, always overwriting the older version */
 830     CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\freeldr.sys");
 831     CombinePaths(DstPath, ARRAYSIZE(DstPath), 2, SystemRootPath->Buffer, L"freeldr.sys");
 832
 833     DPRINT("Copy: %S ==> %S\n", SrcPath, DstPath);
 834     Status = SetupCopyFile(SrcPath, DstPath, FALSE);
 835     if (!NT_SUCCESS(Status))
 836     {
 837         DPRINT1("SetupCopyFile() failed (Status %lx)\n", Status);
 838         return Status;
 839     }
 840
 841     /* Prepare for possibly updating 'freeldr.ini' */
 842     DoesFreeLdrExist = DoesFileExist_2(SystemRootPath->Buffer, L"freeldr.ini");
 843     if (DoesFreeLdrExist)
 844     {
 845         /* Update existing 'freeldr.ini' */
 846         DPRINT1("Update existing 'freeldr.ini'\n");
 847         Status = UpdateFreeLoaderIni(SystemRootPath->Buffer, DestinationArcPath->Buffer);
 848         if (!NT_SUCCESS(Status))
 849         {
 850             DPRINT1("UpdateFreeLoaderIni() failed (Status %lx)\n", Status);
 851             return Status;
 852         }
 853     }
 854
 855     /* Check for NT and other bootloaders */
 856
 857     // FIXME: Check for Vista+ bootloader!
 858     /*** Status = FindBootStore(PartitionHandle, NtLdr, &Version); ***/
 859     /*** Status = FindBootStore(PartitionHandle, BootMgr, &Version); ***/
 860     if (DoesFileExist_2(SystemRootPath->Buffer, L"NTLDR") == TRUE ||
 861         DoesFileExist_2(SystemRootPath->Buffer, L"BOOT.INI") == TRUE)
 862     {
 863         /* Search root directory for 'NTLDR' and 'BOOT.INI' */
 864         DPRINT1("Found Microsoft Windows NT/2000/XP boot loader\n");
 865
 866         /* Create or update 'freeldr.ini' */
 867         if (DoesFreeLdrExist == FALSE)
 868         {
 869             /* Create new 'freeldr.ini' */
 870             DPRINT1("Create new 'freeldr.ini'\n");
 871             Status = CreateFreeLoaderIniForReactOS(SystemRootPath->Buffer, DestinationArcPath->Buffer);
 872             if (!NT_SUCCESS(Status))
 873             {
 874                 DPRINT1("CreateFreeLoaderIniForReactOS() failed (Status %lx)\n", Status);
 875                 return Status;
 876             }
 877
 878             /* Install new bootcode into a file */
 879             CombinePaths(DstPath, ARRAYSIZE(DstPath), 2, SystemRootPath->Buffer, L"bootsect.ros");
 880
 881             if (wcsicmp(FileSystemName, L"FAT32") == 0)
 882             {
 883                 /* Install FAT32 bootcode */
 884                 CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\fat32.bin");
 885
 886                 DPRINT1("Install FAT32 bootcode: %S ==> %S\n", SrcPath, DstPath);
 887                 Status = InstallBootCodeToFile(SrcPath, DstPath,
 888                                                SystemRootPath->Buffer,
 889                                                InstallFat32BootCode);
 890                 if (!NT_SUCCESS(Status))
 891                 {
 892                     DPRINT1("InstallBootCodeToFile(FAT32) failed (Status %lx)\n", Status);
 893                     return Status;
 894                 }
 895             }
 896             else // if (wcsicmp(FileSystemName, L"FAT") == 0)
 897             {
 898                 /* Install FAT16 bootcode */
 899                 CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\fat.bin");
 900
 901                 DPRINT1("Install FAT16 bootcode: %S ==> %S\n", SrcPath, DstPath);
 902                 Status = InstallBootCodeToFile(SrcPath, DstPath,
 903                                                SystemRootPath->Buffer,
 904                                                InstallFat16BootCode);
 905                 if (!NT_SUCCESS(Status))
 906                 {
 907                     DPRINT1("InstallBootCodeToFile(FAT16) failed (Status %lx)\n", Status);
 908                     return Status;
 909                 }
 910             }
 911         }
 912
 913         /* Update 'boot.ini' */
 914         /* Windows' NTLDR loads an external bootsector file when the specified drive
 915            letter is C:, otherwise it will interpret it as a boot DOS path specifier. */
 916         DPRINT1("Update 'boot.ini'\n");
 917         Status = UpdateBootIni(SystemRootPath->Buffer,
 918                                L"C:\\bootsect.ros",
 919                                L"\"ReactOS\"");
 920         if (!NT_SUCCESS(Status))
 921         {
 922             DPRINT1("UpdateBootIni() failed (Status %lx)\n", Status);
 923             return Status;
 924         }
 925     }
 926     else
 927     {
 928         /* Non-NT bootloaders: install our own bootloader */
 929
 930         PCWSTR Section;
 931         PCWSTR Description;
 932         PCWSTR BootDrive;
 933         PCWSTR BootPartition;
 934         PCWSTR BootSector;
 935
 936         /* Search for COMPAQ MS-DOS 1.x (1.11, 1.12, based on MS-DOS 1.25) boot loader */
 937         if (DoesFileExist_2(SystemRootPath->Buffer, L"IOSYS.COM") == TRUE ||
 938             DoesFileExist_2(SystemRootPath->Buffer, L"MSDOS.COM") == TRUE)
 939         {
 940             DPRINT1("Found COMPAQ MS-DOS 1.x (1.11, 1.12) / MS-DOS 1.25 boot loader\n");
 941
 942             Section       = L"CPQDOS";
 943             Description   = L"\"COMPAQ MS-DOS 1.x / MS-DOS 1.25\"";
 944             BootDrive     = L"hd0";
 945             BootPartition = L"1";
 946             BootSector    = L"BOOTSECT.DOS";
 947         }
 948         else
 949         /* Search for Microsoft DOS or Windows 9x boot loader */
 950         if (DoesFileExist_2(SystemRootPath->Buffer, L"IO.SYS") == TRUE ||
 951             DoesFileExist_2(SystemRootPath->Buffer, L"MSDOS.SYS") == TRUE)
 952             // WINBOOT.SYS
 953         {
 954             DPRINT1("Found Microsoft DOS or Windows 9x boot loader\n");
 955
 956             Section       = L"MSDOS";
 957             Description   = L"\"MS-DOS/Windows\"";
 958             BootDrive     = L"hd0";
 959             BootPartition = L"1";
 960             BootSector    = L"BOOTSECT.DOS";
 961         }
 962         else
 963         /* Search for IBM PC-DOS or DR-DOS 5.x boot loader */
 964         if (DoesFileExist_2(SystemRootPath->Buffer, L"IBMIO.COM" ) == TRUE || // Some people refer to this file instead of IBMBIO.COM...
 965             DoesFileExist_2(SystemRootPath->Buffer, L"IBMBIO.COM") == TRUE ||
 966             DoesFileExist_2(SystemRootPath->Buffer, L"IBMDOS.COM") == TRUE)
 967         {
 968             DPRINT1("Found IBM PC-DOS or DR-DOS 5.x or IBM OS/2 1.0\n");
 969
 970             Section       = L"IBMDOS";
 971             Description   = L"\"IBM PC-DOS or DR-DOS 5.x or IBM OS/2 1.0\"";
 972             BootDrive     = L"hd0";
 973             BootPartition = L"1";
 974             BootSector    = L"BOOTSECT.DOS";
 975         }
 976         else
 977         /* Search for DR-DOS 3.x boot loader */
 978         if (DoesFileExist_2(SystemRootPath->Buffer, L"DRBIOS.SYS") == TRUE ||
 979             DoesFileExist_2(SystemRootPath->Buffer, L"DRBDOS.SYS") == TRUE)
 980         {
 981             DPRINT1("Found DR-DOS 3.x\n");
 982
 983             Section       = L"DRDOS";
 984             Description   = L"\"DR-DOS 3.x\"";
 985             BootDrive     = L"hd0";
 986             BootPartition = L"1";
 987             BootSector    = L"BOOTSECT.DOS";
 988         }
 989         else
 990         /* Search for Dell Real-Mode Kernel (DRMK) OS */
 991         if (DoesFileExist_2(SystemRootPath->Buffer, L"DELLBIO.BIN") == TRUE ||
 992             DoesFileExist_2(SystemRootPath->Buffer, L"DELLRMK.BIN") == TRUE)
 993         {
 994             DPRINT1("Found Dell Real-Mode Kernel OS\n");
 995
 996             Section       = L"DRMK";
 997             Description   = L"\"Dell Real-Mode Kernel OS\"";
 998             BootDrive     = L"hd0";
 999             BootPartition = L"1";
1000             BootSector    = L"BOOTSECT.DOS";
1001         }
1002         else
1003         /* Search for MS OS/2 1.x */
1004         if (DoesFileExist_2(SystemRootPath->Buffer, L"OS2BOOT.COM") == TRUE ||
1005             DoesFileExist_2(SystemRootPath->Buffer, L"OS2BIO.COM" ) == TRUE ||
1006             DoesFileExist_2(SystemRootPath->Buffer, L"OS2DOS.COM" ) == TRUE)
1007         {
1008             DPRINT1("Found MS OS/2 1.x\n");
1009
1010             Section       = L"MSOS2";
1011             Description   = L"\"MS OS/2 1.x\"";
1012             BootDrive     = L"hd0";
1013             BootPartition = L"1";
1014             BootSector    = L"BOOTSECT.OS2";
1015         }
1016         else
1017         /* Search for MS or IBM OS/2 */
1018         if (DoesFileExist_2(SystemRootPath->Buffer, L"OS2BOOT") == TRUE ||
1019             DoesFileExist_2(SystemRootPath->Buffer, L"OS2LDR" ) == TRUE ||
1020             DoesFileExist_2(SystemRootPath->Buffer, L"OS2KRNL") == TRUE)
1021         {
1022             DPRINT1("Found MS/IBM OS/2\n");
1023
1024             Section       = L"IBMOS2";
1025             Description   = L"\"MS/IBM OS/2\"";
1026             BootDrive     = L"hd0";
1027             BootPartition = L"1";
1028             BootSector    = L"BOOTSECT.OS2";
1029         }
1030         else
1031         /* Search for FreeDOS boot loader */
1032         if (DoesFileExist_2(SystemRootPath->Buffer, L"kernel.sys") == TRUE)
1033         {
1034             DPRINT1("Found FreeDOS boot loader\n");
1035
1036             Section       = L"FDOS";
1037             Description   = L"\"FreeDOS\"";
1038             BootDrive     = L"hd0";
1039             BootPartition = L"1";
1040             BootSector    = L"BOOTSECT.DOS";
1041         }
1042         else
1043         {
1044             /* No or unknown boot loader */
1045             DPRINT1("No or unknown boot loader found\n");
1046
1047             Section       = L"Unknown";
1048             Description   = L"\"Unknown Operating System\"";
1049             BootDrive     = L"hd0";
1050             BootPartition = L"1";
1051             BootSector    = L"BOOTSECT.OLD";
1052         }
1053
1054         /* Create or update 'freeldr.ini' */
1055         if (DoesFreeLdrExist == FALSE)
1056         {
1057             /* Create new 'freeldr.ini' */
1058             DPRINT1("Create new 'freeldr.ini'\n");
1059
1060             if (IsThereAValidBootSector(SystemRootPath->Buffer))
1061             {
1062                 Status = CreateFreeLoaderIniForReactOSAndBootSector(
1063                              SystemRootPath->Buffer, DestinationArcPath->Buffer,
1064                              Section, Description,
1065                              BootDrive, BootPartition, BootSector);
1066                 if (!NT_SUCCESS(Status))
1067                 {
1068                     DPRINT1("CreateFreeLoaderIniForReactOSAndBootSector() failed (Status %lx)\n", Status);
1069                     return Status;
1070                 }
1071
1072                 /* Save current bootsector */
1073                 CombinePaths(DstPath, ARRAYSIZE(DstPath), 2, SystemRootPath->Buffer, BootSector);
1074
1075                 DPRINT1("Save bootsector: %S ==> %S\n", SystemRootPath->Buffer, DstPath);
1076                 Status = SaveBootSector(SystemRootPath->Buffer, DstPath, SECTORSIZE);
1077                 if (!NT_SUCCESS(Status))
1078                 {
1079                     DPRINT1("SaveBootSector() failed (Status %lx)\n", Status);
1080                     return Status;
1081                 }
1082             }
1083             else
1084             {
1085                 Status = CreateFreeLoaderIniForReactOS(SystemRootPath->Buffer, DestinationArcPath->Buffer);
1086                 if (!NT_SUCCESS(Status))
1087                 {
1088                     DPRINT1("CreateFreeLoaderIniForReactOS() failed (Status %lx)\n", Status);
1089                     return Status;
1090                 }
1091             }
1092
1093             /* Install new bootsector on the disk */
1094             if (wcsicmp(FileSystemName, L"FAT32") == 0)
1095             {
1096                 /* Install FAT32 bootcode */
1097                 CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\fat32.bin");
1098
1099                 DPRINT1("Install FAT32 bootcode: %S ==> %S\n", SrcPath, SystemRootPath->Buffer);
1100                 Status = InstallBootCodeToDisk(SrcPath, SystemRootPath->Buffer, InstallFat32BootCode);
1101                 DPRINT1("Status: 0x%08X\n", Status);
1102                 if (!NT_SUCCESS(Status))
1103                 {
1104                     DPRINT1("InstallBootCodeToDisk(FAT32) failed (Status %lx)\n", Status);
1105                     return Status;
1106                 }
1107             }
1108             else // if (wcsicmp(FileSystemName, L"FAT") == 0)
1109             {
1110                 /* Install FAT16 bootcode */
1111                 CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\fat.bin");
1112
1113                 DPRINT1("Install FAT16 bootcode: %S ==> %S\n", SrcPath, SystemRootPath->Buffer);
1114                 Status = InstallBootCodeToDisk(SrcPath, SystemRootPath->Buffer, InstallFat16BootCode);
1115                 if (!NT_SUCCESS(Status))
1116                 {
1117                     DPRINT1("InstallBootCodeToDisk(FAT16) failed (Status %lx)\n", Status);
1118                     return Status;
1119                 }
1120             }
1121         }
1122     }
1123
1124     return STATUS_SUCCESS;
1125 }
1126
1127 static
1128 NTSTATUS
1129 InstallBtrfsBootcodeToPartition(
1130     IN PUNICODE_STRING SystemRootPath,
1131     IN PUNICODE_STRING SourceRootPath,
1132     IN PUNICODE_STRING DestinationArcPath)
1133 {
1134     NTSTATUS Status;
1135     BOOLEAN DoesFreeLdrExist;
1136     WCHAR SrcPath[MAX_PATH];
1137     WCHAR DstPath[MAX_PATH];
1138
1139     /* BTRFS partition */
1140     DPRINT("System path: '%wZ'\n", SystemRootPath);
1141
1142     /* Copy FreeLoader to the system partition, always overwriting the older version */
1143     CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\freeldr.sys");
1144     CombinePaths(DstPath, ARRAYSIZE(DstPath), 2, SystemRootPath->Buffer, L"freeldr.sys");
1145
1146     DPRINT("Copy: %S ==> %S\n", SrcPath, DstPath);
1147     Status = SetupCopyFile(SrcPath, DstPath, FALSE);
1148     if (!NT_SUCCESS(Status))
1149     {
1150         DPRINT1("SetupCopyFile() failed (Status %lx)\n", Status);
1151         return Status;
1152     }
1153
1154     /* Prepare for possibly updating 'freeldr.ini' */
1155     DoesFreeLdrExist = DoesFileExist_2(SystemRootPath->Buffer, L"freeldr.ini");
1156     if (DoesFreeLdrExist)
1157     {
1158         /* Update existing 'freeldr.ini' */
1159         DPRINT1("Update existing 'freeldr.ini'\n");
1160         Status = UpdateFreeLoaderIni(SystemRootPath->Buffer, DestinationArcPath->Buffer);
1161         if (!NT_SUCCESS(Status))
1162         {
1163             DPRINT1("UpdateFreeLoaderIni() failed (Status %lx)\n", Status);
1164             return Status;
1165         }
1166     }
1167
1168     /* Check for *nix bootloaders */
1169
1170     /* Create or update 'freeldr.ini' */
1171     if (DoesFreeLdrExist == FALSE)
1172     {
1173         /* Create new 'freeldr.ini' */
1174         DPRINT1("Create new 'freeldr.ini'\n");
1175
1176         /* Certainly SysLinux, GRUB, LILO... or an unknown boot loader */
1177         DPRINT1("*nix or unknown boot loader found\n");
1178
1179         if (IsThereAValidBootSector(SystemRootPath->Buffer))
1180         {
1181             PCWSTR BootSector = L"BOOTSECT.OLD";
1182
1183             Status = CreateFreeLoaderIniForReactOSAndBootSector(
1184                          SystemRootPath->Buffer, DestinationArcPath->Buffer,
1185                          L"Linux", L"\"Linux\"",
1186                          L"hd0", L"1", BootSector);
1187             if (!NT_SUCCESS(Status))
1188             {
1189                 DPRINT1("CreateFreeLoaderIniForReactOSAndBootSector() failed (Status %lx)\n", Status);
1190                 return Status;
1191             }
1192
1193             /* Save current bootsector */
1194             CombinePaths(DstPath, ARRAYSIZE(DstPath), 2, SystemRootPath->Buffer, BootSector);
1195
1196             DPRINT1("Save bootsector: %S ==> %S\n", SystemRootPath->Buffer, DstPath);
1197             Status = SaveBootSector(SystemRootPath->Buffer, DstPath, BTRFS_BOOTSECTOR_SIZE);
1198             if (!NT_SUCCESS(Status))
1199             {
1200                 DPRINT1("SaveBootSector() failed (Status %lx)\n", Status);
1201                 return Status;
1202             }
1203         }
1204         else
1205         {
1206             Status = CreateFreeLoaderIniForReactOS(SystemRootPath->Buffer, DestinationArcPath->Buffer);
1207             if (!NT_SUCCESS(Status))
1208             {
1209                 DPRINT1("CreateFreeLoaderIniForReactOS() failed (Status %lx)\n", Status);
1210                 return Status;
1211             }
1212         }
1213
1214         /* Install new bootsector on the disk */
1215         /* Install BTRFS bootcode */
1216         CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\btrfs.bin");
1217
1218         DPRINT1("Install BTRFS bootcode: %S ==> %S\n", SrcPath, SystemRootPath->Buffer);
1219         Status = InstallBootCodeToDisk(SrcPath, SystemRootPath->Buffer, InstallBtrfsBootCode);
1220         if (!NT_SUCCESS(Status))
1221         {
1222             DPRINT1("InstallBootCodeToDisk(BTRFS) failed (Status %lx)\n", Status);
1223             return Status;
1224         }
1225     }
1226
1227     return STATUS_SUCCESS;
1228 }
1229
1230
1231 NTSTATUS
1232 InstallVBRToPartition(
1233     IN PUNICODE_STRING SystemRootPath,
1234     IN PUNICODE_STRING SourceRootPath,
1235     IN PUNICODE_STRING DestinationArcPath,
1236     IN PCWSTR FileSystemName)
1237 {
1238     if (wcsicmp(FileSystemName, L"FAT")   == 0 ||
1239         wcsicmp(FileSystemName, L"FAT32") == 0)
1240     {
1241         return InstallFatBootcodeToPartition(SystemRootPath,
1242                                              SourceRootPath,
1243                                              DestinationArcPath,
1244                                              FileSystemName);
1245     }
1246     /*
1247     else if (wcsicmp(FileSystemName, L"NTFS") == 0)
1248     {
1249         DPRINT1("Partitions of type NTFS or HPFS are not supported yet!\n");
1250         return STATUS_NOT_SUPPORTED;
1251     }
1252     */
1253     else if (wcsicmp(FileSystemName, L"BTRFS") == 0)
1254     {
1255         return InstallBtrfsBootcodeToPartition(SystemRootPath,
1256                                                SourceRootPath,
1257                                                DestinationArcPath);
1258     }
1259     /*
1260     else if (wcsicmp(FileSystemName, L"EXT2")  == 0 ||
1261              wcsicmp(FileSystemName, L"EXT3")  == 0 ||
1262              wcsicmp(FileSystemName, L"EXT4")  == 0)
1263     {
1264         return STATUS_NOT_SUPPORTED;
1265     }
1266     */
1267     else
1268     {
1269         /* Unknown file system */
1270         DPRINT1("Unknown file system '%S'\n", FileSystemName);
1271     }
1272
1273     return STATUS_NOT_SUPPORTED;
1274 }
1275
1276
1277 NTSTATUS
1278 InstallFatBootcodeToFloppy(
1279     IN PUNICODE_STRING SourceRootPath,
1280     IN PUNICODE_STRING DestinationArcPath)
1281 {
1282     static const PCWSTR FloppyDevice = L"\\Device\\Floppy0\\";
1283
1284     NTSTATUS Status;
1285     WCHAR SrcPath[MAX_PATH];
1286     WCHAR DstPath[MAX_PATH];
1287
1288     /* Verify that the floppy disk is accessible */
1289     if (DoesDirExist(NULL, FloppyDevice) == FALSE)
1290         return STATUS_DEVICE_NOT_READY;
1291
1292     /* Format the floppy disk */
1293     // FormatPartition(...)
1294     Status = FormatFileSystem(FloppyDevice,
1295                               L"FAT",
1296                               FMIFS_FLOPPY,
1297                               NULL,
1298                               TRUE,
1299                               0,
1300                               NULL);
1301     if (!NT_SUCCESS(Status))
1302     {
1303         if (Status == STATUS_NOT_SUPPORTED)
1304             DPRINT1("FAT FS non existent on this system?!\n");
1305         else
1306             DPRINT1("VfatFormat() failed (Status %lx)\n", Status);
1307
1308         return Status;
1309     }
1310
1311     /* Copy FreeLoader to the boot partition */
1312     CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\freeldr.sys");
1313     CombinePaths(DstPath, ARRAYSIZE(DstPath), 2, FloppyDevice, L"freeldr.sys");
1314
1315     DPRINT("Copy: %S ==> %S\n", SrcPath, DstPath);
1316     Status = SetupCopyFile(SrcPath, DstPath, FALSE);
1317     if (!NT_SUCCESS(Status))
1318     {
1319         DPRINT1("SetupCopyFile() failed (Status %lx)\n", Status);
1320         return Status;
1321     }
1322
1323     /* Create new 'freeldr.ini' */
1324     DPRINT("Create new 'freeldr.ini'\n");
1325     Status = CreateFreeLoaderIniForReactOS(FloppyDevice, DestinationArcPath->Buffer);
1326     if (!NT_SUCCESS(Status))
1327     {
1328         DPRINT1("CreateFreeLoaderIniForReactOS() failed (Status %lx)\n", Status);
1329         return Status;
1330     }
1331
1332     /* Install FAT12 boosector */
1333     CombinePaths(SrcPath, ARRAYSIZE(SrcPath), 2, SourceRootPath->Buffer, L"\\loader\\fat.bin");
1334     CombinePaths(DstPath, ARRAYSIZE(DstPath), 1, FloppyDevice);
1335
1336     DPRINT("Install FAT12 bootcode: %S ==> %S\n", SrcPath, DstPath);
1337     Status = InstallBootCodeToDisk(SrcPath, DstPath, InstallFat12BootCode);
1338     if (!NT_SUCCESS(Status))
1339     {
1340         DPRINT1("InstallBootCodeToDisk(FAT12) failed (Status %lx)\n", Status);
1341         return Status;
1342     }
1343
1344     return STATUS_SUCCESS;
1345 }
1346
1347 /* EOF */