bldrsup.c File Reference

#include "precomp.h"
#include "bldrsup.h"
#include "filesup.h"
#include "inicache.h"
#include <debug.h>

Include dependency graph for bldrsup.c:

Go to the source code of this file.

Classes
struct	_NTOS_BOOT_LOADER_FILES
struct	_BOOT_STORE_CONTEXT
struct	_BOOT_STORE_INI_CONTEXT
struct	_BOOT_STORE_BCDREG_CONTEXT

Macros
#define	NDEBUG

Typedefs
typedef NTSTATUS(*	POPEN_BOOT_STORE) (_Out_ PVOID *Handle, _In_ HANDLE PartitionDirectoryHandle, _In_ BOOT_STORE_TYPE Type, _In_ BOOT_STORE_OPENMODE OpenMode, _In_ BOOT_STORE_ACCESS Access)
typedef NTSTATUS(*	PCLOSE_BOOT_STORE) (_In_ PVOID Handle)
typedef NTSTATUS(*	PENUM_BOOT_STORE_ENTRIES) (IN PVOID Handle, IN PENUM_BOOT_ENTRIES_ROUTINE EnumBootEntriesRoutine, IN PVOID Parameter OPTIONAL)
typedef struct _NTOS_BOOT_LOADER_FILES	NTOS_BOOT_LOADER_FILES
typedef struct _NTOS_BOOT_LOADER_FILES *	PNTOS_BOOT_LOADER_FILES
typedef struct _BOOT_STORE_CONTEXT	BOOT_STORE_CONTEXT
typedef struct _BOOT_STORE_CONTEXT *	PBOOT_STORE_CONTEXT
typedef struct _BOOT_STORE_INI_CONTEXT	BOOT_STORE_INI_CONTEXT
typedef struct _BOOT_STORE_INI_CONTEXT *	PBOOT_STORE_INI_CONTEXT
typedef struct _BOOT_STORE_BCDREG_CONTEXT	BOOT_STORE_BCDREG_CONTEXT
typedef struct _BOOT_STORE_BCDREG_CONTEXT *	PBOOT_STORE_BCDREG_CONTEXT

Enumerations
enum	BOOT_OPTION { BO_TimeOut , BO_DefaultOS }

Functions
static NTSTATUS	OpenIniBootLoaderStore (_Out_ PVOID *Handle, _In_ HANDLE PartitionDirectoryHandle, _In_ BOOT_STORE_TYPE Type, _In_ BOOT_STORE_OPENMODE OpenMode, _In_ BOOT_STORE_ACCESS Access)
static NTSTATUS	CloseIniBootLoaderStore (_In_ PVOID Handle)
static NTSTATUS	FreeLdrEnumerateBootEntries (IN PBOOT_STORE_INI_CONTEXT BootStore, IN PENUM_BOOT_ENTRIES_ROUTINE EnumBootEntriesRoutine, IN PVOID Parameter OPTIONAL)
static NTSTATUS	NtLdrEnumerateBootEntries (IN PBOOT_STORE_INI_CONTEXT BootStore, IN PENUM_BOOT_ENTRIES_ROUTINE EnumBootEntriesRoutine, IN PVOID Parameter OPTIONAL)
	C_ASSERT (_countof(NtosBootLoaders)==BldrTypeMax)
NTSTATUS	FindBootStore (IN HANDLE PartitionDirectoryHandle, IN BOOT_STORE_TYPE Type, OUT PULONG VersionNumber OPTIONAL)
static VOID	FreeLdrMigrateBootDrivePartWorker (_In_ PINI_SECTION OsIniSection)
static VOID	FreeLdrMigrateBootDrivePart (_In_ PBOOT_STORE_INI_CONTEXT BootStore)
static VOID	CreateCommonFreeLdrSections (IN OUT PBOOT_STORE_INI_CONTEXT BootStore)
static NTSTATUS	ProtectFile (_In_ HANDLE FileHandle, _In_ ULONG MaskAttributes, _Inout_ PULONG Attributes)
	Selectively changes the attributes of a file.
NTSTATUS	OpenBootStoreByHandle (_Out_ PVOID *Handle, _In_ HANDLE PartitionDirectoryHandle, _In_ BOOT_STORE_TYPE Type, _In_ BOOT_STORE_OPENMODE OpenMode, _In_ BOOT_STORE_ACCESS Access)
NTSTATUS	OpenBootStore_UStr (_Out_ PVOID *Handle, _In_ PUNICODE_STRING SystemPartitionPath, _In_ BOOT_STORE_TYPE Type, _In_ BOOT_STORE_OPENMODE OpenMode, _In_ BOOT_STORE_ACCESS Access)
NTSTATUS	OpenBootStore (_Out_ PVOID *Handle, _In_ PCWSTR SystemPartition, _In_ BOOT_STORE_TYPE Type, _In_ BOOT_STORE_OPENMODE OpenMode, _In_ BOOT_STORE_ACCESS Access)
NTSTATUS	CloseBootStore (_In_ PVOID Handle)
static NTSTATUS	CreateNTOSEntry (IN PBOOT_STORE_INI_CONTEXT BootStore, IN ULONG_PTR BootEntryKey, IN PBOOT_STORE_ENTRY BootEntry)
NTSTATUS	AddBootStoreEntry (IN PVOID Handle, IN PBOOT_STORE_ENTRY BootEntry, IN ULONG_PTR BootEntryKey)
NTSTATUS	DeleteBootStoreEntry (IN PVOID Handle, IN ULONG_PTR BootEntryKey)
NTSTATUS	ModifyBootStoreEntry (IN PVOID Handle, IN PBOOT_STORE_ENTRY BootEntry)
NTSTATUS	QueryBootStoreEntry (IN PVOID Handle, IN ULONG_PTR BootEntryKey, OUT PBOOT_STORE_ENTRY BootEntry)
NTSTATUS	QueryBootStoreOptions (IN PVOID Handle, IN OUT PBOOT_STORE_OPTIONS BootOptions)
NTSTATUS	SetBootStoreOptions (IN PVOID Handle, IN PBOOT_STORE_OPTIONS BootOptions, IN ULONG FieldsToChange)
NTSTATUS	EnumerateBootStoreEntries (IN PVOID Handle, IN PENUM_BOOT_ENTRIES_ROUTINE EnumBootEntriesRoutine, IN PVOID Parameter OPTIONAL)

Variables
NTOS_BOOT_LOADER_FILES	NtosBootLoaders []
static const PCWSTR	BootOptionNames [][2]

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 19 of file bldrsup.c.

Typedef Documentation

BOOT_STORE_BCDREG_CONTEXT

typedef struct _BOOT_STORE_BCDREG_CONTEXT BOOT_STORE_BCDREG_CONTEXT

BOOT_STORE_CONTEXT

typedef struct _BOOT_STORE_CONTEXT BOOT_STORE_CONTEXT

BOOT_STORE_INI_CONTEXT

typedef struct _BOOT_STORE_INI_CONTEXT BOOT_STORE_INI_CONTEXT

NTOS_BOOT_LOADER_FILES

typedef struct _NTOS_BOOT_LOADER_FILES NTOS_BOOT_LOADER_FILES

PBOOT_STORE_BCDREG_CONTEXT

typedef struct _BOOT_STORE_BCDREG_CONTEXT * PBOOT_STORE_BCDREG_CONTEXT

PBOOT_STORE_CONTEXT

typedef struct _BOOT_STORE_CONTEXT * PBOOT_STORE_CONTEXT

PBOOT_STORE_INI_CONTEXT

typedef struct _BOOT_STORE_INI_CONTEXT * PBOOT_STORE_INI_CONTEXT

PCLOSE_BOOT_STORE

typedef NTSTATUS(* PCLOSE_BOOT_STORE) (_In_ PVOID Handle)

Definition at line 33 of file bldrsup.c.

PENUM_BOOT_STORE_ENTRIES

typedef NTSTATUS(* PENUM_BOOT_STORE_ENTRIES) (IN PVOID Handle, IN PENUM_BOOT_ENTRIES_ROUTINE EnumBootEntriesRoutine, IN PVOID Parameter OPTIONAL)

Definition at line 37 of file bldrsup.c.

PNTOS_BOOT_LOADER_FILES

typedef struct _NTOS_BOOT_LOADER_FILES * PNTOS_BOOT_LOADER_FILES

POPEN_BOOT_STORE

typedef NTSTATUS(* POPEN_BOOT_STORE) (_Out_ PVOID *Handle, _In_ HANDLE PartitionDirectoryHandle, _In_ BOOT_STORE_TYPE Type, _In_ BOOT_STORE_OPENMODE OpenMode, _In_ BOOT_STORE_ACCESS Access)

Definition at line 25 of file bldrsup.c.

Enumeration Type Documentation

BOOT_OPTION

enum BOOT_OPTION

Enumerator
BO_TimeOut
BO_DefaultOS

Definition at line 136 of file bldrsup.c.

{
    BO_TimeOut,
    BO_DefaultOS,
};

Function Documentation

AddBootStoreEntry()

NTSTATUS AddBootStoreEntry	(	IN PVOID	Handle,
		IN PBOOT_STORE_ENTRY	BootEntry,
		IN ULONG_PTR	BootEntryKey
	)

Definition at line 1094 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
 
    if (!BootStore || !BootEntry)
        return STATUS_INVALID_PARAMETER;
 
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    //
    // FIXME!!
    //
 
    // if (BootStore->Type >= BldrTypeMax || NtosBootLoaders[BootStore->Type].Type >= BldrTypeMax)
 
    if (BootStore->Type == FreeLdr)
    {
        if (BootEntry->Version != FreeLdr)
            return STATUS_INVALID_PARAMETER;
 
        return CreateNTOSEntry((PBOOT_STORE_INI_CONTEXT)BootStore,
                               BootEntryKey, BootEntry);
    }
    else
    if (BootStore->Type == NtLdr)
    {
        PNTOS_OPTIONS Options = (PNTOS_OPTIONS)&BootEntry->OsOptions;
        PWCHAR Buffer;
        ULONG BufferLength;
        PCWSTR InstallName, OsOptions;
        // ULONG InstallNameLength, OsOptionsLength;
        BOOLEAN IsNameNotQuoted;
 
        if (BootEntry->Version != NtLdr)
            return STATUS_INVALID_PARAMETER;
 
        if (BootEntry->OsOptionsLength < sizeof(NTOS_OPTIONS) ||
            RtlCompareMemory(&BootEntry->OsOptions /* Signature */,
                             NTOS_OPTIONS_SIGNATURE,
                             RTL_FIELD_SIZE(NTOS_OPTIONS, Signature)) !=
                             RTL_FIELD_SIZE(NTOS_OPTIONS, Signature))
        {
            // DPRINT1("Unsupported BootType '%S'\n", BootEntry->Version);
            DPRINT1("Unsupported BootType %lu\n", BootEntry->OsOptionsLength);
            return STATUS_SUCCESS; // STATUS_NOT_SUPPORTED;
        }
 
        InstallName = BootEntry->FriendlyName;
        OsOptions = Options->OsLoadOptions;
 
        // if (InstallNameLength == 0) InstallName = NULL;
        // if (OsOptionsLength == 0) OsOptions = NULL;
 
        IsNameNotQuoted = (InstallName[0] != L'\"' || InstallName[wcslen(InstallName)-1] != L'\"');
 
        BufferLength = (IsNameNotQuoted ? 2 /* Quotes for FriendlyName*/ : 0) + wcslen(InstallName);
        if (OsOptions)
            BufferLength += 1 /* Space between FriendlyName and options */ + wcslen(OsOptions);
        BufferLength++; /* NULL-termination */
 
        Buffer = RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, BufferLength * sizeof(WCHAR));
        if (!Buffer)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        *Buffer = UNICODE_NULL;
        if (IsNameNotQuoted) RtlStringCchCatW(Buffer, BufferLength, L"\"");
        RtlStringCchCatW(Buffer, BufferLength, InstallName);
        if (IsNameNotQuoted) RtlStringCchCatW(Buffer, BufferLength, L"\"");
        if (OsOptions)
        {
            RtlStringCchCatW(Buffer, BufferLength, L" ");
            RtlStringCchCatW(Buffer, BufferLength, OsOptions);
        }
 
        /* Insert the entry into the "Operating Systems" section */
        IniAddKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OsIniSection,
                  Options->OsLoadPath, Buffer);
 
        RtlFreeHeap(ProcessHeap, 0, Buffer);
        return STATUS_SUCCESS;
    }
    else
    {
        DPRINT1("Loader type %d is currently unsupported!\n", BootStore->Type);
        return STATUS_NOT_SUPPORTED;
    }
}

Referenced by CreateFreeLoaderIniForReactOSAndBootSector(), CreateFreeLoaderReactOSEntries(), UpdateBootIni(), and UpdateFreeLoaderIni().

C_ASSERT()

C_ASSERT

(

_countof(NtosBootLoaders)

= =BldrTypeMax

)

CloseBootStore()

NTSTATUS CloseBootStore

(

_In_ PVOID

Handle

)

Definition at line 1014 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
 
    if (!BootStore)
        return STATUS_INVALID_PARAMETER;
 
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    if (BootStore->Type >= BldrTypeMax || NtosBootLoaders[BootStore->Type].Type >= BldrTypeMax)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[BootStore->Type].Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    return NtosBootLoaders[BootStore->Type].CloseBootStore(Handle /* BootStore */);
}

Referenced by CreateFreeLoaderIniForReactOS(), CreateFreeLoaderIniForReactOSAndBootSector(), FindNTOSInstallations(), UpdateBootIni(), and UpdateFreeLoaderIni().

CloseIniBootLoaderStore()

static NTSTATUS CloseIniBootLoaderStore ( _In_ PVOID  Handle )

static

Definition at line 830 of file bldrsup.c.

{
    /* Set or remove SYSTEM, HIDDEN and READONLY attributes */
    static const ULONG ProtectAttribs =
        (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY);
 
    PBOOT_STORE_INI_CONTEXT BootStore = (PBOOT_STORE_INI_CONTEXT)Handle;
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG FileAttribs;
 
    ASSERT(BootStore);
 
    /* If the INI file was opened in read-only mode, skip saving */
    if (BootStore->Header.ReadOnly)
        goto Quit;
 
    /* If the INI file was already opened because it already existed, unprotect it */
    if (BootStore->SectionHandle)
    {
        FileAttribs = 0;
        Status = ProtectFile(BootStore->FileHandle, ProtectAttribs, &FileAttribs);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Could not unprotect INI boot store (Status 0x%08lx)\n", Status);
            goto Quit;
        }
    }
 
    IniCacheSaveByHandle(BootStore->IniCache, BootStore->FileHandle);
 
    /* Re-protect the INI file */
    FileAttribs = ProtectAttribs;
    if (BootStore->Header.Type == FreeLdr)
    {
        // NOTE: CORE-19575: For the time being, don't add READONLY for ease
        // of testing and modifying files, but it won't always stay this way.
    FileAttribs &= ~FILE_ATTRIBUTE_READONLY;
    }
    /*Status =*/ ProtectFile(BootStore->FileHandle, FileAttribs, &FileAttribs);
    Status = STATUS_SUCCESS; // Ignore the status and just succeed.
 
Quit:
    IniCacheDestroy(BootStore->IniCache);
 
#if 0
    if (BootStore->SectionHandle)
    {
        /* Finally, unmap and close the file */
        UnMapAndCloseFile(BootStore->FileHandle,
                          BootStore->SectionHandle,
                          BootStore->ViewBase);
    }
    else // if (BootStore->FileHandle)
#endif
    {
        /* Just close the file we have opened for creation */
        NtClose(BootStore->FileHandle);
    }
 
    /* Finally, free the boot store structure */
    RtlFreeHeap(ProcessHeap, 0, BootStore);
    return Status;
}

CreateCommonFreeLdrSections()

static VOID CreateCommonFreeLdrSections ( IN OUT PBOOT_STORE_INI_CONTEXT  BootStore )

static

Definition at line 372 of file bldrsup.c.

{
    PINI_SECTION IniSection;
 
    /*
     * Cache the "FREELOADER" section for our future usage.
     */
 
    /* Create the "FREELOADER" section */
    IniSection = IniAddSection(BootStore->IniCache, L"FREELOADER");
    if (!IniSection)
        DPRINT1("CreateCommonFreeLdrSections: Failed to create 'FREELOADER' section!\n");
 
    BootStore->OptionsIniSection = IniSection;
 
    /* TimeOut */
    IniAddKey(BootStore->OptionsIniSection, L"TimeOut", L"0");
 
    /* Create "Display" section */
    IniSection = IniAddSection(BootStore->IniCache, L"Display");
 
    /* TitleText and MinimalUI */
    IniAddKey(IniSection, L"TitleText", L"ReactOS Boot Manager");
    IniAddKey(IniSection, L"MinimalUI", L"Yes");
 
    /*
     * Cache the "Operating Systems" section for our future usage.
     */
 
    /* Create the "Operating Systems" section */
    IniSection = IniAddSection(BootStore->IniCache, L"Operating Systems");
    if (!IniSection)
        DPRINT1("CreateCommonFreeLdrSections: Failed to create 'Operating Systems' section!\n");
 
    BootStore->OsIniSection = IniSection;
}

Referenced by OpenIniBootLoaderStore().

CreateNTOSEntry()

static NTSTATUS CreateNTOSEntry ( IN PBOOT_STORE_INI_CONTEXT  BootStore, IN ULONG_PTR  BootEntryKey, IN PBOOT_STORE_ENTRY  BootEntry  )

static

Definition at line 1042 of file bldrsup.c.

{
    PINI_SECTION IniSection;
    PCWSTR Section = (PCWSTR)BootEntryKey;
 
    /* Insert the entry into the "Operating Systems" section */
    IniAddKey(BootStore->OsIniSection, Section, BootEntry->FriendlyName);
 
    /* Create a new section */
    IniSection = IniAddSection(BootStore->IniCache, Section);
 
    if (BootEntry->OsOptionsLength >= sizeof(NTOS_OPTIONS) &&
        RtlCompareMemory(&BootEntry->OsOptions /* Signature */,
                         NTOS_OPTIONS_SIGNATURE,
                         RTL_FIELD_SIZE(NTOS_OPTIONS, Signature)) ==
                         RTL_FIELD_SIZE(NTOS_OPTIONS, Signature))
    {
        PNTOS_OPTIONS Options = (PNTOS_OPTIONS)&BootEntry->OsOptions;
 
        /* BootType, SystemPath and Options */
        IniAddKey(IniSection, L"BootType", L"Windows2003");
        IniAddKey(IniSection, L"SystemPath", Options->OsLoadPath);
        IniAddKey(IniSection, L"Options", Options->OsLoadOptions);
    }
    else
    if (BootEntry->OsOptionsLength >= sizeof(BOOTSECTOR_OPTIONS) &&
        RtlCompareMemory(&BootEntry->OsOptions /* Signature */,
                         BOOTSECTOR_OPTIONS_SIGNATURE,
                         RTL_FIELD_SIZE(BOOTSECTOR_OPTIONS, Signature)) ==
                         RTL_FIELD_SIZE(BOOTSECTOR_OPTIONS, Signature))
    {
        PBOOTSECTOR_OPTIONS Options = (PBOOTSECTOR_OPTIONS)&BootEntry->OsOptions;
 
        /* BootType, BootPath and BootSector */
        IniAddKey(IniSection, L"BootType", L"BootSector");
        IniAddKey(IniSection, L"BootPath", Options->BootPath);
        IniAddKey(IniSection, L"BootSectorFile", Options->FileName);
    }
    else
    {
        // DPRINT1("Unsupported BootType %lu/'%*.s'\n",
                // BootEntry->OsOptionsLength, 8, &BootEntry->OsOptions);
        DPRINT1("Unsupported BootType %lu\n", BootEntry->OsOptionsLength);
    }
 
    return STATUS_SUCCESS;
}

Referenced by AddBootStoreEntry().

DeleteBootStoreEntry()

NTSTATUS DeleteBootStoreEntry	(	IN PVOID	Handle,
		IN ULONG_PTR	BootEntryKey
	)

Definition at line 1192 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
 
    if (!BootStore)
        return STATUS_INVALID_PARAMETER;
 
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    //
    // FIXME!!
    //
 
    // if (BootStore->Type >= BldrTypeMax || NtosBootLoaders[BootStore->Type].Type >= BldrTypeMax)
    if (BootStore->Type != FreeLdr)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[BootStore->Type].Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    // FIXME! This function needs my INI library rewrite to be implemented!!
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

EnumerateBootStoreEntries()

NTSTATUS EnumerateBootStoreEntries	(	IN PVOID	Handle,
		IN PENUM_BOOT_ENTRIES_ROUTINE	EnumBootEntriesRoutine,
		IN PVOID Parameter	OPTIONAL
	)

Definition at line 1703 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
 
    if (!BootStore)
        return STATUS_INVALID_PARAMETER;
 
    if (BootStore->Type >= BldrTypeMax || NtosBootLoaders[BootStore->Type].Type >= BldrTypeMax)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[BootStore->Type].Type);
        return STATUS_SUCCESS;
        // return STATUS_INVALID_PARAMETER;
    }
 
    return NtosBootLoaders[BootStore->Type].EnumBootStoreEntries(
                (PBOOT_STORE_INI_CONTEXT)BootStore, // Flags,
                EnumBootEntriesRoutine, Parameter);
}

Referenced by FindNTOSInstallations(), UpdateBootIni(), and UpdateFreeLoaderIni().

FindBootStore()

NTSTATUS FindBootStore	(	IN HANDLE	PartitionDirectoryHandle,
		IN BOOT_STORE_TYPE	Type,
		OUT PULONG VersionNumber	OPTIONAL
	)

Definition at line 151 of file bldrsup.c.

{
    PCWSTR LoaderExecutable;
    // UINT i;
 
    if (Type >= BldrTypeMax)
        return STATUS_INVALID_PARAMETER;
 
    if (VersionNumber)
        *VersionNumber = 0;
 
    /* Check whether any of the loader executables exist */
    LoaderExecutable = NtosBootLoaders[Type].LoaderExecutables;
    while (*LoaderExecutable)
    {
        if (DoesFileExist(PartitionDirectoryHandle, LoaderExecutable))
        {
            /* A loader was found, stop there */
            DPRINT("Found loader executable '%S'\n", LoaderExecutable);
            break;
        }
 
        /* The loader does not exist, continue with another one */
        DPRINT("Loader executable '%S' does not exist, continue with another one...\n", LoaderExecutable);
        LoaderExecutable += wcslen(LoaderExecutable) + 1;
    }
    if (!*LoaderExecutable)
    {
        /* No loader was found */
        DPRINT("No loader executable was found\n");
        return STATUS_NOT_FOUND;
    }
 
    /* Check for loader version if needed */
    if (VersionNumber)
    {
        *VersionNumber = 0;
        // TODO: Check for BLDR version!
    }
 
    /* Check whether the loader configuration file exists */
#if 0
    Status = OpenAndMapFile(PartitionDirectoryHandle, NtosBootLoaders[Type].LoaderConfigurationFile,
                            &FileHandle, &FileSize, &SectionHandle, &ViewBase, FALSE);
    if (!NT_SUCCESS(Status))
#else
    if (!DoesFileExist(PartitionDirectoryHandle, NtosBootLoaders[Type].LoaderConfigurationFile))
#endif
    {
        /* The loader does not exist, continue with another one */
        // FIXME: Consider it might be optional??
        DPRINT1("Loader configuration file '%S' does not exist\n", NtosBootLoaders[Type].LoaderConfigurationFile);
        return STATUS_NOT_FOUND;
    }
 
    return STATUS_SUCCESS;
}

Referenced by FindNTOSInstallations().

FreeLdrEnumerateBootEntries()

static NTSTATUS FreeLdrEnumerateBootEntries ( IN PBOOT_STORE_INI_CONTEXT  BootStore, IN PENUM_BOOT_ENTRIES_ROUTINE  EnumBootEntriesRoutine, IN PVOID Parameter  OPTIONAL  )

static

Definition at line 1408 of file bldrsup.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PINICACHEITERATOR Iterator;
    PINI_SECTION OsIniSection;
    PCWSTR SectionName, KeyData;
    UCHAR xxBootEntry[FIELD_OFFSET(BOOT_STORE_ENTRY, OsOptions) +
                      max(sizeof(NTOS_OPTIONS), sizeof(BOOTSECTOR_OPTIONS))];
    PBOOT_STORE_ENTRY BootEntry = (PBOOT_STORE_ENTRY)&xxBootEntry;
    PWCHAR Buffer;
 
    /* Enumerate all the valid installations listed in the "Operating Systems" section */
    Iterator = IniFindFirstValue(BootStore->OsIniSection, &SectionName, &KeyData);
    if (!Iterator) return STATUS_SUCCESS;
    do
    {
        PCWSTR InstallName;
        ULONG InstallNameLength;
 
        /* Poor-man quotes removal (improvement over bootsup.c:UpdateFreeLoaderIni) */
        if (*KeyData == L'"')
        {
            /* Quoted name, copy up to the closing quote */
            PWCHAR End = wcschr(KeyData + 1, L'"');
 
            if (End)
            {
                /* Skip the first quote */
                InstallName = KeyData + 1;
                InstallNameLength = End - InstallName;
            }
            else // if (!End)
            {
                /* No corresponding closing quote, so we include the first one in the InstallName */
                InstallName = KeyData;
                InstallNameLength = wcslen(InstallName);
            }
            if (InstallNameLength == 0) InstallName = NULL;
        }
        else
        {
            /* Non-quoted name, copy everything */
            InstallName = KeyData;
            InstallNameLength = wcslen(InstallName);
            if (InstallNameLength == 0) InstallName = NULL;
        }
 
        /* Allocate the temporary buffer */
        Buffer = NULL;
        if (InstallNameLength)
            Buffer = RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, (InstallNameLength + 1) * sizeof(WCHAR));
        if (Buffer)
        {
            RtlCopyMemory(Buffer, InstallName, InstallNameLength * sizeof(WCHAR));
            Buffer[InstallNameLength] = UNICODE_NULL;
            InstallName = Buffer;
        }
 
        DPRINT("Boot entry '%S' in OS section '%S'\n", InstallName, SectionName);
 
        BootEntry->Version = FreeLdr;
        BootEntry->BootEntryKey = MAKESTRKEY(SectionName);
        BootEntry->FriendlyName = InstallName;
        BootEntry->BootFilePath = NULL;
        BootEntry->OsOptionsLength = 0;
 
        /* Search for an existing boot entry section */
        OsIniSection = IniGetSection(BootStore->IniCache, SectionName);
        if (!OsIniSection)
            goto DoEnum;
 
        /* Check for supported boot type */
        if (!IniGetKey(OsIniSection, L"BootType", &KeyData) || !KeyData)
        {
            /* Certainly not a ReactOS installation */
            DPRINT1("No BootType value present\n");
            goto DoEnum;
        }
 
        // TODO: What to do with "Windows" ; "WindowsNT40" ; "ReactOSSetup" ?
        if ((_wcsicmp(KeyData, L"Windows2003")     == 0) ||
            (_wcsicmp(KeyData, L"\"Windows2003\"") == 0))
        {
            /* BootType is Windows2003 */
            PNTOS_OPTIONS Options = (PNTOS_OPTIONS)&BootEntry->OsOptions;
 
            DPRINT("This is a '%S' boot entry\n", KeyData);
 
            BootEntry->OsOptionsLength = sizeof(NTOS_OPTIONS);
            RtlCopyMemory(Options->Signature,
                          NTOS_OPTIONS_SIGNATURE,
                          RTL_FIELD_SIZE(NTOS_OPTIONS, Signature));
 
            // BootEntry->BootFilePath = NULL;
 
            /* Check its SystemPath */
            Options->OsLoadPath = NULL;
            if (IniGetKey(OsIniSection, L"SystemPath", &KeyData))
                Options->OsLoadPath = KeyData;
            // KeyData == SystemRoot;
 
            /* Check the optional Options */
            Options->OsLoadOptions = NULL;
            if (IniGetKey(OsIniSection, L"Options", &KeyData))
                Options->OsLoadOptions = KeyData;
        }
        else
        if ((_wcsicmp(KeyData, L"BootSector")     == 0) ||
            (_wcsicmp(KeyData, L"\"BootSector\"") == 0))
        {
            /* BootType is BootSector */
            PBOOTSECTOR_OPTIONS Options = (PBOOTSECTOR_OPTIONS)&BootEntry->OsOptions;
 
            DPRINT("This is a '%S' boot entry\n", KeyData);
 
            BootEntry->OsOptionsLength = sizeof(BOOTSECTOR_OPTIONS);
            RtlCopyMemory(Options->Signature,
                          BOOTSECTOR_OPTIONS_SIGNATURE,
                          RTL_FIELD_SIZE(BOOTSECTOR_OPTIONS, Signature));
 
            // BootEntry->BootFilePath = NULL;
 
            /* Check its BootPath */
            Options->BootPath = NULL;
            if (IniGetKey(OsIniSection, L"BootPath", &KeyData))
                Options->BootPath = KeyData;
 
            /* Check its BootSector */
            Options->FileName = NULL;
            if (IniGetKey(OsIniSection, L"BootSectorFile", &KeyData))
                Options->FileName = KeyData;
        }
        else
        {
            DPRINT1("Unrecognized BootType value '%S'\n", KeyData);
            // goto DoEnum;
        }
 
DoEnum:
        /* Call the user enumeration routine callback */
        Status = EnumBootEntriesRoutine(FreeLdr, BootEntry, Parameter);
 
        /* Free temporary buffers */
        if (Buffer)
            RtlFreeHeap(ProcessHeap, 0, Buffer);
 
        /* Stop the enumeration if needed */
        if (!NT_SUCCESS(Status))
            break;
    }
    while (IniFindNextValue(Iterator, &SectionName, &KeyData));
 
    IniFindClose(Iterator);
    return Status;
}

FreeLdrMigrateBootDrivePart()

static VOID FreeLdrMigrateBootDrivePart ( _In_ PBOOT_STORE_INI_CONTEXT  BootStore )

static

Definition at line 323 of file bldrsup.c.

{
    PINICACHEITERATOR Iterator;
    PINI_SECTION OsIniSection;
    PCWSTR SectionName, KeyData;
 
    /* Enumerate all the valid entries in the "Operating Systems" section */
    Iterator = IniFindFirstValue(BootStore->OsIniSection, &SectionName, &KeyData);
    if (!Iterator) return;
    do
    {
        /* Search for an existing boot entry section */
        OsIniSection = IniGetSection(BootStore->IniCache, SectionName);
        if (!OsIniSection)
            continue;
 
        /* Check for boot type to migrate */
        if (!IniGetKey(OsIniSection, L"BootType", &KeyData) || !KeyData)
        {
            /* Certainly not a ReactOS installation */
            DPRINT1("No BootType value present\n");
            continue;
        }
        if ((_wcsicmp(KeyData, L"Drive")     == 0) ||
            (_wcsicmp(KeyData, L"\"Drive\"") == 0) ||
            (_wcsicmp(KeyData, L"Partition")     == 0) ||
            (_wcsicmp(KeyData, L"\"Partition\"") == 0))
        {
            /* Modify the BootPath value */
            IniAddKey(OsIniSection, L"BootType", L"BootSector");
            goto migrate_drivepart;
        }
        if ((_wcsicmp(KeyData, L"BootSector")     == 0) ||
            (_wcsicmp(KeyData, L"\"BootSector\"") == 0))
        {
migrate_drivepart:
            DPRINT("This is a '%S' boot entry\n", KeyData);
            FreeLdrMigrateBootDrivePartWorker(OsIniSection);
        }
    }
    while (IniFindNextValue(Iterator, &SectionName, &KeyData));
 
    IniFindClose(Iterator);
}

Referenced by OpenIniBootLoaderStore().

FreeLdrMigrateBootDrivePartWorker()

static VOID FreeLdrMigrateBootDrivePartWorker ( _In_ PINI_SECTION  OsIniSection )

static

Definition at line 222 of file bldrsup.c.

{
    PCWSTR KeyData;
    PINI_KEYWORD OldKey;
 
    /*
     * Check whether we have a "BootPath" value (takes precedence
     * over both "BootDrive" and "BootPartition").
     */
    if (IniGetKey(OsIniSection, L"BootPath", &KeyData) && KeyData && *KeyData)
    {
        /* We already have a BootPath value, do nothing more */
        return;
    }
 
    /* We don't have one: retrieve the BIOS drive and
     * partition and convert them to a valid ARC path */
 
    /* Retrieve the boot drive */
    OldKey = IniGetKey(OsIniSection, L"BootDrive", &KeyData);
    if (OldKey)
    {
        PCWSTR OldDrive = KeyData;
        ULONG DriveNumber = 0;
        ULONG PartitionNumber = 0;
        UCHAR DriveType = 0;
        WCHAR BufferBootPath[80]; // 80 chars is enough for "multi(0)disk(0)rdisk(x)partition(y)", with (x,y) == MAXULONG
 
        /* If a number string is given, then just
         * convert it to decimal (BIOS HW only) */
        PCWCH p = KeyData;
        if (p[0] >= L'0' && p[0] <= L'9')
        {
            DriveNumber = wcstoul(p, (PWCHAR*)&p, 0);
            if (DriveNumber >= 0x80)
            {
                /* It's quite probably a hard disk */
                DriveNumber -= 0x80;
                DriveType = L'h';
            }
            else
            {
                /* It's quite probably a floppy */
                DriveType = L'f';
            }
        }
        else if (p[0] && towlower(p[1]) == L'd')
        {
            /* Convert the drive number string into a number: 'hd1' = 1 */
            DriveType = tolower(p[0]);
            DriveNumber = _wtoi(&p[2]);
        }
 
        /* Retrieve the boot partition (optional, fall back to zero otherwise) */
        if (IniGetKey(OsIniSection, L"BootPartition", &KeyData))
            PartitionNumber = _wtoi(KeyData);
 
        if (DriveType == L'f')
        {
            /* Floppy disk path: multi(0)disk(0)fdisk(x) */
            RtlStringCchPrintfW(BufferBootPath, _countof(BufferBootPath),
                                L"multi(0)disk(0)fdisk(%lu)", DriveNumber);
        }
        else if (DriveType == L'h')
        {
            /* Hard disk path: multi(0)disk(0)rdisk(x)partition(y) */
            RtlStringCchPrintfW(BufferBootPath, _countof(BufferBootPath),
                                L"multi(0)disk(0)rdisk(%lu)partition(%lu)",
                                DriveNumber, PartitionNumber);
        }
        else if (DriveType == L'c')
        {
            /* CD-ROM disk path: multi(0)disk(0)cdrom(x) */
            RtlStringCchPrintfW(BufferBootPath, _countof(BufferBootPath),
                                L"multi(0)disk(0)cdrom(%lu)", DriveNumber);
        }
        else
        {
            /* This case should rarely happen, if ever */
            DPRINT1("Unrecognized BootDrive type '%C'\n", DriveType ? DriveType : L'?');
 
            /* Build the boot path in the form: hdX,Y */
            RtlStringCchCopyW(BufferBootPath, _countof(BufferBootPath), OldDrive);
            if (KeyData && *KeyData)
            {
                RtlStringCchCatW(BufferBootPath, _countof(BufferBootPath), L",");
                RtlStringCchCatW(BufferBootPath, _countof(BufferBootPath), KeyData);
            }
        }
 
        /* Add the new BootPath value */
        IniInsertKey(OsIniSection, OldKey, INSERT_BEFORE, L"BootPath", BufferBootPath);
    }
 
    /* Delete the deprecated BootDrive and BootPartition values */
    IniRemoveKeyByName(OsIniSection, L"BootDrive");
    IniRemoveKeyByName(OsIniSection, L"BootPartition");
}

Referenced by FreeLdrMigrateBootDrivePart().

ModifyBootStoreEntry()

NTSTATUS ModifyBootStoreEntry	(	IN PVOID	Handle,
		IN PBOOT_STORE_ENTRY	BootEntry
	)

Definition at line 1226 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
 
    if (!BootStore || !BootEntry)
        return STATUS_INVALID_PARAMETER;
 
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    //
    // FIXME!!
    //
 
    // if (BootStore->Type >= BldrTypeMax || NtosBootLoaders[BootStore->Type].Type >= BldrTypeMax)
    if (BootStore->Type != FreeLdr)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[BootStore->Type].Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    // FIXME! This function needs my INI library rewrite to operate properly!!
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

NtLdrEnumerateBootEntries()

static NTSTATUS NtLdrEnumerateBootEntries ( IN PBOOT_STORE_INI_CONTEXT  BootStore, IN PENUM_BOOT_ENTRIES_ROUTINE  EnumBootEntriesRoutine, IN PVOID Parameter  OPTIONAL  )

static

Definition at line 1569 of file bldrsup.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PINICACHEITERATOR Iterator;
    PCWSTR SectionName, KeyData;
    UCHAR xxBootEntry[FIELD_OFFSET(BOOT_STORE_ENTRY, OsOptions) + sizeof(NTOS_OPTIONS)];
    PBOOT_STORE_ENTRY BootEntry = (PBOOT_STORE_ENTRY)&xxBootEntry;
    PNTOS_OPTIONS Options = (PNTOS_OPTIONS)&BootEntry->OsOptions;
    PWCHAR Buffer;
    ULONG BufferLength;
 
    /* Enumerate all the valid installations */
    Iterator = IniFindFirstValue(BootStore->OsIniSection, &SectionName, &KeyData);
    if (!Iterator) return STATUS_SUCCESS;
    do
    {
        PCWSTR InstallName, OsOptions;
        ULONG InstallNameLength, OsOptionsLength;
 
        /* Poor-man quotes removal (improvement over bootsup.c:UpdateFreeLoaderIni) */
        if (*KeyData == L'"')
        {
            /* Quoted name, copy up to the closing quote */
            OsOptions = wcschr(KeyData + 1, L'"');
 
            /* Retrieve the starting point of the installation name and the OS options */
            if (OsOptions)
            {
                /* Skip the first quote */
                InstallName = KeyData + 1;
                InstallNameLength = OsOptions - InstallName;
                if (InstallNameLength == 0) InstallName = NULL;
 
                /* Skip the ending quote (if found) */
                ++OsOptions;
 
                /* Skip any whitespace */
                while (iswspace(*OsOptions)) ++OsOptions;
                /* Get its final length */
                OsOptionsLength = wcslen(OsOptions);
                if (OsOptionsLength == 0) OsOptions = NULL;
            }
            else
            {
                /* No corresponding closing quote, so we include the first one in the InstallName */
                InstallName = KeyData;
                InstallNameLength = wcslen(InstallName);
                if (InstallNameLength == 0) InstallName = NULL;
 
                /* There are no OS options */
                // OsOptions = NULL;
                OsOptionsLength = 0;
            }
        }
        else
        {
            /* Non-quoted name, copy everything */
 
            /* Retrieve the starting point of the installation name */
            InstallName = KeyData;
            InstallNameLength = wcslen(InstallName);
            if (InstallNameLength == 0) InstallName = NULL;
 
            /* There are no OS options */
            OsOptions = NULL;
            OsOptionsLength = 0;
        }
 
        /* Allocate the temporary buffer */
        Buffer = NULL;
        BufferLength = (InstallNameLength + OsOptionsLength) * sizeof(WCHAR);
        if (BufferLength)
            Buffer = RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, BufferLength + 2*sizeof(UNICODE_NULL));
        if (Buffer)
        {
            PWCHAR ptr;
 
            /* Copy the installation name, and make InstallName point into the buffer */
            if (InstallName && InstallNameLength)
            {
                ptr = Buffer;
                RtlCopyMemory(ptr, InstallName, InstallNameLength * sizeof(WCHAR));
                ptr[InstallNameLength] = UNICODE_NULL;
                InstallName = ptr;
            }
 
            /* Copy the OS options, and make OsOptions point into the buffer */
            if (OsOptions && OsOptionsLength)
            {
                ptr = Buffer + InstallNameLength + 1;
                RtlCopyMemory(ptr, OsOptions, OsOptionsLength * sizeof(WCHAR));
                ptr[OsOptionsLength] = UNICODE_NULL;
                OsOptions = ptr;
            }
        }
 
        DPRINT1("Boot entry '%S' in OS section (path) '%S'\n", InstallName, SectionName);
        // SectionName == SystemRoot;
 
        BootEntry->Version = NtLdr;
        BootEntry->BootEntryKey = 0; // FIXME??
        BootEntry->FriendlyName = InstallName;
        BootEntry->BootFilePath = NULL;
 
        BootEntry->OsOptionsLength = sizeof(NTOS_OPTIONS);
        RtlCopyMemory(Options->Signature,
                      NTOS_OPTIONS_SIGNATURE,
                      RTL_FIELD_SIZE(NTOS_OPTIONS, Signature));
 
        Options->OsLoadPath    = SectionName;
        Options->OsLoadOptions = OsOptions;
 
        /* Call the user enumeration routine callback */
        Status = EnumBootEntriesRoutine(NtLdr, BootEntry, Parameter);
 
        /* Free temporary buffers */
        if (Buffer)
            RtlFreeHeap(ProcessHeap, 0, Buffer);
 
        /* Stop the enumeration if needed */
        if (!NT_SUCCESS(Status))
            break;
    }
    while (IniFindNextValue(Iterator, &SectionName, &KeyData));
 
    IniFindClose(Iterator);
    return Status;
}

OpenBootStore()

NTSTATUS OpenBootStore	(	_Out_ PVOID *	Handle,
		_In_ PCWSTR	SystemPartition,
		_In_ BOOT_STORE_TYPE	Type,
		_In_ BOOT_STORE_OPENMODE	OpenMode,
		_In_ BOOT_STORE_ACCESS	Access
	)

Definition at line 997 of file bldrsup.c.

{
    UNICODE_STRING SystemPartitionPath;
    RtlInitUnicodeString(&SystemPartitionPath, SystemPartition);
    return OpenBootStore_UStr(Handle,
                              &SystemPartitionPath,
                              Type,
                              OpenMode,
                              Access);
}

Referenced by CreateFreeLoaderIniForReactOS(), CreateFreeLoaderIniForReactOSAndBootSector(), UpdateBootIni(), and UpdateFreeLoaderIni().

OpenBootStore_UStr()

NTSTATUS OpenBootStore_UStr	(	_Out_ PVOID *	Handle,
		_In_ PUNICODE_STRING	SystemPartitionPath,
		_In_ BOOT_STORE_TYPE	Type,
		_In_ BOOT_STORE_OPENMODE	OpenMode,
		_In_ BOOT_STORE_ACCESS	Access
	)

Definition at line 940 of file bldrsup.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE PartitionDirectoryHandle;
 
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    if (Type >= BldrTypeMax || NtosBootLoaders[Type].Type >= BldrTypeMax)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[Type].Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    /* Open SystemPartition */
    InitializeObjectAttributes(&ObjectAttributes,
                               SystemPartitionPath,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = NtOpenFile(&PartitionDirectoryHandle,
                        FILE_LIST_DIRECTORY | FILE_ADD_FILE /* | FILE_ADD_SUBDIRECTORY | FILE_TRAVERSE*/ | SYNCHRONIZE,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                        FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE /* | FILE_OPEN_FOR_BACKUP_INTENT */);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to open SystemPartition '%wZ' (Status 0x%08lx)\n",
                SystemPartitionPath, Status);
        return Status;
    }
 
    Status = OpenBootStoreByHandle(Handle,
                                   PartitionDirectoryHandle,
                                   Type,
                                   OpenMode,
                                   Access);
 
    /* Done! */
    NtClose(PartitionDirectoryHandle);
    return Status;
}

Referenced by OpenBootStore().

OpenBootStoreByHandle()

NTSTATUS OpenBootStoreByHandle	(	_Out_ PVOID *	Handle,
		_In_ HANDLE	PartitionDirectoryHandle,
		_In_ BOOT_STORE_TYPE	Type,
		_In_ BOOT_STORE_OPENMODE	OpenMode,
		_In_ BOOT_STORE_ACCESS	Access
	)

Definition at line 897 of file bldrsup.c.

{
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    if (Type >= BldrTypeMax || NtosBootLoaders[Type].Type >= BldrTypeMax)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[Type].Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    /*
     * Verify the access modes to perform the open actions.
     * The operating system may allow e.g. file creation even with
     * read-only access, but we do not allow this because we want
     * to protect any existing boot store file in case the caller
     * specified such an open mode.
     */
    // if ((OpenMode == BS_CheckExisting) && !(Access & BS_ReadAccess))
    //     return STATUS_ACCESS_DENIED;
    if ((OpenMode == BS_CreateNew || OpenMode == BS_CreateAlways || OpenMode == BS_RecreateExisting) && !(Access & BS_WriteAccess))
        return STATUS_ACCESS_DENIED;
    if ((OpenMode == BS_OpenExisting || OpenMode == BS_OpenAlways) && !(Access & BS_ReadWriteAccess))
        return STATUS_ACCESS_DENIED;
 
    return NtosBootLoaders[Type].OpenBootStore(Handle,
                                               PartitionDirectoryHandle,
                                               Type,
                                               OpenMode,
                                               Access);
}

Referenced by FindNTOSInstallations(), and OpenBootStore_UStr().

OpenIniBootLoaderStore()

static NTSTATUS OpenIniBootLoaderStore ( _Out_ PVOID *  Handle, _In_ HANDLE  PartitionDirectoryHandle, _In_ BOOT_STORE_TYPE  Type, _In_ BOOT_STORE_OPENMODE  OpenMode, _In_ BOOT_STORE_ACCESS  Access  )

static

Definition at line 411 of file bldrsup.c.

{
    NTSTATUS Status;
    PBOOT_STORE_INI_CONTEXT BootStore;
    UNICODE_STRING Name;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    ACCESS_MASK DesiredAccess;
    ULONG CreateDisposition;
 
    //
    // WARNING! We support the INI creation *ONLY* for FreeLdr, and not for NTLDR
    //
    if ((Type == NtLdr) && (OpenMode == BS_CreateNew || OpenMode == BS_CreateAlways || OpenMode == BS_RecreateExisting))
    {
        DPRINT1("OpenIniBootLoaderStore() unsupported for NTLDR\n");
        return STATUS_NOT_SUPPORTED;
    }
 
    /* Create a boot store structure */
    BootStore = RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, sizeof(*BootStore));
    if (!BootStore)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    BootStore->Header.Type = Type;
 
    /*
     * So far, we only use the INI cache. The file itself is not created or
     * opened yet, therefore FileHandle, SectionHandle, ViewBase and FileSize
     * are all NULL. We will use this fact to know that the INI file was indeed
     * created, and not just opened as an existing file.
     */
    // BootStore->FileHandle = NULL;
    BootStore->SectionHandle = NULL;
    BootStore->ViewBase = NULL;
    BootStore->FileSize = 0;
 
    /*
     * Create or open the loader configuration INI file as necessary.
     */
    RtlInitUnicodeString(&Name, NtosBootLoaders[Type].LoaderConfigurationFile);
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE,
                               PartitionDirectoryHandle,
                               NULL);
 
    DesiredAccess =
        ((Access & BS_ReadAccess ) ? FILE_GENERIC_READ  : 0) |
        ((Access & BS_WriteAccess) ? FILE_GENERIC_WRITE : 0);
 
    CreateDisposition = FILE_OPEN;
    switch (OpenMode)
    {
        case BS_CreateNew:
            CreateDisposition = FILE_CREATE;
            break;
        case BS_CheckExisting:
        case BS_OpenExisting:
            CreateDisposition = FILE_OPEN;
            break;
        case BS_OpenAlways:
            CreateDisposition = FILE_OPEN_IF;
            break;
        case BS_RecreateExisting:
            CreateDisposition = FILE_OVERWRITE;
            break;
        case BS_CreateAlways:
            CreateDisposition = FILE_OVERWRITE_IF;
            break;
        default:
            ASSERT(FALSE);
    }
 
    IoStatusBlock.Information = 0;
    Status = NtCreateFile(&BootStore->FileHandle,
                          DesiredAccess | SYNCHRONIZE,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          FILE_ATTRIBUTE_NORMAL,
                          FILE_SHARE_READ,
                          CreateDisposition,
                          FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY | FILE_NON_DIRECTORY_FILE,
                          NULL,
                          0);
 
    if (OpenMode == BS_CheckExisting)
    {
        /* We just want to check for file existence. If we either succeeded
         * opening the file, or we failed because it exists but we do not
         * currently have access to it, return success in either case. */
        BOOLEAN Success = (NT_SUCCESS(Status) || (Status == STATUS_ACCESS_DENIED));
        if (!Success)
        {
            DPRINT1("Couldn't find Loader configuration file '%S'\n",
                    NtosBootLoaders[Type].LoaderConfigurationFile);
        }
        if (BootStore->FileHandle)
            NtClose(BootStore->FileHandle);
        RtlFreeHeap(ProcessHeap, 0, BootStore);
        return (Success ? STATUS_SUCCESS : Status);
    }
 
    /*
     * If create/open failed because the file is in read-only mode,
     * change its attributes and re-attempt opening it.
     */
    if (Status == STATUS_ACCESS_DENIED) do
    {
        FILE_BASIC_INFORMATION FileInfo = {0};
 
        /* Reattempt to open it with limited access */
        Status = NtCreateFile(&BootStore->FileHandle,
                              FILE_WRITE_ATTRIBUTES | SYNCHRONIZE,
                              &ObjectAttributes,
                              &IoStatusBlock,
                              NULL,
                              FILE_ATTRIBUTE_NORMAL,
                              FILE_SHARE_READ,
                              FILE_OPEN,
                              FILE_NO_INTERMEDIATE_BUFFERING |
                              FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY | FILE_NON_DIRECTORY_FILE,
                              NULL,
                              0);
        /* Fail for real if we cannot open it that way */
        if (!NT_SUCCESS(Status))
            break;
 
        /* Reset attributes to normal, no read-only */
        FileInfo.FileAttributes = FILE_ATTRIBUTE_NORMAL;
        /*
         * We basically don't care about whether it succeeds:
         * if it didn't, later open will fail.
         */
        NtSetInformationFile(BootStore->FileHandle, &IoStatusBlock,
                             &FileInfo, sizeof(FileInfo),
                             FileBasicInformation);
 
        /* Close file */
        NtClose(BootStore->FileHandle);
 
        /* And re-attempt create/open */
        Status = NtCreateFile(&BootStore->FileHandle,
                              DesiredAccess | SYNCHRONIZE,
                              &ObjectAttributes,
                              &IoStatusBlock,
                              NULL,
                              FILE_ATTRIBUTE_NORMAL,
                              FILE_SHARE_READ,
                              CreateDisposition,
                              FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY | FILE_NON_DIRECTORY_FILE,
                              NULL,
                              0);
    } while (0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Couldn't open Loader configuration file '%S' (Status 0x%08lx)\n",
                NtosBootLoaders[Type].LoaderConfigurationFile, Status);
        RtlFreeHeap(ProcessHeap, 0, BootStore);
        return Status;
    }
 
    BootStore->Header.ReadOnly = !(Access & BS_WriteAccess);
 
    if (IoStatusBlock.Information == FILE_CREATED     || // with: FILE_CREATE, FILE_OVERWRITE_IF, FILE_OPEN_IF, FILE_SUPERSEDE
        IoStatusBlock.Information == FILE_OVERWRITTEN || // with: FILE_OVERWRITE, FILE_OVERWRITE_IF
        IoStatusBlock.Information == FILE_SUPERSEDED)    // with: FILE_SUPERSEDE
    {
        /*
         * The loader configuration INI file is (re)created
         * fresh new, initialize its cache and its contents.
         */
        BootStore->IniCache = IniCacheCreate();
        if (!BootStore->IniCache)
        {
            DPRINT1("IniCacheCreate() failed\n");
            NtClose(BootStore->FileHandle);
            RtlFreeHeap(ProcessHeap, 0, BootStore);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        if (Type == FreeLdr)
            CreateCommonFreeLdrSections(BootStore);
    }
    else // if (IoStatusBlock.Information == FILE_OPENED) // with: FILE_OPEN, FILE_OPEN_IF
    {
        PINI_SECTION IniSection;
 
        /*
         * The loader configuration INI file exists and is opened,
         * map its file contents into memory.
         */
#if 0
        // FIXME: &BootStore->FileSize
        Status = MapFile(BootStore->FileHandle,
                         &BootStore->SectionHandle,
                         &BootStore->ViewBase,
                         (Access & BS_WriteAccess));
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to map Loader configuration file '%S' (Status 0x%08lx)\n",
                    NtosBootLoaders[Type].LoaderConfigurationFile, Status);
            NtClose(BootStore->FileHandle);
            RtlFreeHeap(ProcessHeap, 0, BootStore);
            return Status;
        }
#else
        BootStore->SectionHandle = UlongToPtr(1); // Workaround for CloseIniBootLoaderStore
#endif
 
        /* Open an *existing* INI configuration file */
#if 0
        Status = IniCacheLoadFromMemory(&BootStore->IniCache,
                                        BootStore->ViewBase,
                                        BootStore->FileSize,
                                        FALSE);
#else
        Status = IniCacheLoadByHandle(&BootStore->IniCache, BootStore->FileHandle, FALSE);
#endif
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("IniCacheLoadFromMemory() failed (Status 0x%08lx)\n", Status);
#if 0
            /* Finally, unmap and close the file */
            UnMapAndCloseFile(BootStore->FileHandle,
                              BootStore->SectionHandle,
                              BootStore->ViewBase);
#else
            NtClose(BootStore->FileHandle);
#endif
            RtlFreeHeap(ProcessHeap, 0, BootStore);
            return Status;
        }
 
        if (Type == FreeLdr)
        {
            /*
             * Cache the "FREELOADER" section for our future usage.
             */
 
            /* Get or create the "FREELOADER" section */
            IniSection = IniAddSection(BootStore->IniCache, L"FREELOADER");
            if (!IniSection)
                DPRINT1("OpenIniBootLoaderStore: Failed to retrieve 'FREELOADER' section!\n");
 
            BootStore->OptionsIniSection = IniSection;
 
            /*
             * Cache the "Operating Systems" section for our future usage.
             */
 
            /* Get or create the "Operating Systems" section */
            IniSection = IniAddSection(BootStore->IniCache, L"Operating Systems");
            if (!IniSection)
                DPRINT1("OpenIniBootLoaderStore: Failed to retrieve 'Operating Systems' section!\n");
 
            BootStore->OsIniSection = IniSection;
 
            //
            // TEMPORARY: Migrate the DEPRECATED BootDrive and BootPartition
            // values of BootSector boot entries to the newer BootPath value.
            //
            FreeLdrMigrateBootDrivePart(BootStore);
        }
        else
        if (Type == NtLdr)
        {
            /*
             * Cache the "boot loader" section for our future usage.
             */
            /*
             * HISTORICAL NOTE:
             *
             * While the "operating systems" section acquired its definitive
             * name already when Windows NT was at its very early beta stage
             * (NT 3.1 October 1991 Beta, 10-16-1991), this was not the case
             * for its general settings section "boot loader".
             *
             * The following section names were successively introduced:
             *
             * - In NT 3.1 October 1991 Beta, 10-16-1991, using OS Loader V1.5,
             *   the section was named "multiboot".
             *
             * - In the next public beta version NT 3.10.340 Beta, 10-12-1992,
             *   using OS Loader V2.10, a new name was introduced: "flexboot".
             *   This is around this time that the NT OS Loader was also
             *   introduced as the "Windows NT FlexBoot" loader, as shown by
             *   the Windows NT FAQs that circulated around this time:
             *   http://cd.textfiles.com/cica9308/CIS_LIBS/WINNT/1/NTFAQ.TXT
             *   http://cd.textfiles.com/cica/cica9308/UNZIPPED/NT/NTFAQ/FTP/NEWS/NTFAQ1.TXT
             *   I can only hypothesize that the "FlexBoot" name was chosen
             *   as a marketing coup, possibly to emphasise its "flexibility"
             *   as a simple multiboot-aware boot manager.
             *
             * - A bit later, with NT 3.10.404 Beta, 3-7-1993, using an updated
             *   version of OS Loader V2.10, the final section name "boot loader"
             *   was introduced, and was kept since then.
             *
             * Due to the necessity to be able to boot and / or upgrade any
             * Windows NT version at any time, including its NT Loader and the
             * associated boot.ini file, all versions of NTLDR and the NT installer
             * understand and parse these three section names, the default one
             * being "boot loader", and if not present, they successively fall
             * back to "flexboot" and then to "multiboot".
             */
 
            /* Get the "boot loader" section */
            IniSection = IniGetSection(BootStore->IniCache, L"boot loader");
            if (!IniSection)
            {
                /* Fall back to "flexboot" */
                IniSection = IniGetSection(BootStore->IniCache, L"flexboot");
                if (!IniSection)
                {
                    /* Fall back to "multiboot" */
                    IniSection = IniGetSection(BootStore->IniCache, L"multiboot");
                }
            }
#if 0
            if (!IniSection)
            {
                /* It does not exist yet, so create it */
                IniSection = IniAddSection(BootStore->IniCache, L"boot loader");
            }
#endif
            if (!IniSection)
                DPRINT1("OpenIniBootLoaderStore: Failed to retrieve 'boot loader' section!\n");
 
            BootStore->OptionsIniSection = IniSection;
 
            /*
             * Cache the "Operating Systems" section for our future usage.
             */
 
            /* Get or create the "Operating Systems" section */
            IniSection = IniAddSection(BootStore->IniCache, L"operating systems");
            if (!IniSection)
                DPRINT1("OpenIniBootLoaderStore: Failed to retrieve 'operating systems' section!\n");
 
            BootStore->OsIniSection = IniSection;
        }
    }
 
    *Handle = BootStore;
    return STATUS_SUCCESS;
}

ProtectFile()

static NTSTATUS ProtectFile ( _In_ HANDLE  FileHandle, _In_ ULONG  MaskAttributes, _Inout_ PULONG  Attributes  )

static

Selectively changes the attributes of a file.

Parameters

[in]	FileHandle	Handle to an opened file for which to change its attributes.
[in]	MaskAttributes	A mask specifying which attributes to change; any other attributes will be maintained as they are. If this parameter is zero, all of the attributes in *Attributes will be changed.
[in,out]	Attributes	In input, specifies the new attributes to set. Attributes that are not set, but are specified in MaskAttributes, are removed. In output, receives the original attributes of the file.

Returns

STATUS_SUCCESS if the attributes were successfully changed, or a failure code if an error happened.

Definition at line 786 of file bldrsup.c.

{
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatusBlock;
    FILE_BASIC_INFORMATION FileInfo;
    ULONG OldAttributes;
 
    /* Retrieve the original file attributes */
    Status = NtQueryInformationFile(FileHandle,
                                    &IoStatusBlock,
                                    &FileInfo,
                                    sizeof(FileInfo),
                                    FileBasicInformation);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtQueryInformationFile() failed (Status 0x%08lx)\n", Status);
        return Status;
    }
    OldAttributes = FileInfo.FileAttributes;
 
    /* Modify the attributes and return the old ones */
    if (MaskAttributes)
        FileInfo.FileAttributes = (OldAttributes & ~MaskAttributes) | (*Attributes & MaskAttributes);
    else
        FileInfo.FileAttributes = *Attributes;
 
    *Attributes = OldAttributes;
 
    /* Set the new file attributes */
    Status = NtSetInformationFile(FileHandle,
                                  &IoStatusBlock,
                                  &FileInfo,
                                  sizeof(FileInfo),
                                  FileBasicInformation);
    if (!NT_SUCCESS(Status))
        DPRINT1("NtSetInformationFile() failed (Status 0x%08lx)\n", Status);
 
    return Status;
}

Referenced by CloseIniBootLoaderStore().

QueryBootStoreEntry()

NTSTATUS QueryBootStoreEntry	(	IN PVOID	Handle,
		IN ULONG_PTR	BootEntryKey,
		OUT PBOOT_STORE_ENTRY	BootEntry
	)

Definition at line 1260 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
 
    if (!BootStore)
        return STATUS_INVALID_PARAMETER;
 
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    //
    // FIXME!!
    //
 
    // if (BootStore->Type >= BldrTypeMax || NtosBootLoaders[BootStore->Type].Type >= BldrTypeMax)
    if (BootStore->Type != FreeLdr)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[BootStore->Type].Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    // FIXME! This function needs my INI library rewrite to be implemented!!
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

QueryBootStoreOptions()

NTSTATUS QueryBootStoreOptions	(	IN PVOID	Handle,
		IN OUT PBOOT_STORE_OPTIONS	BootOptions
	)

Definition at line 1295 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
    PCWSTR TimeoutStr;
 
    if (!BootStore || !BootOptions)
        return STATUS_INVALID_PARAMETER;
 
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    //
    // FIXME!!
    //
 
    // if (BootStore->Type >= BldrTypeMax || NtosBootLoaders[BootStore->Type].Type >= BldrTypeMax)
    if (BootStore->Type != FreeLdr && BootStore->Type != NtLdr)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", BootStore->Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    BootOptions->Timeout = 0;
    BootOptions->CurrentBootEntryKey = 0;
    BootOptions->NextBootEntryKey = 0;
 
    if (IniGetKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                  BootOptionNames[BootStore->Type][BO_TimeOut],
                  &TimeoutStr) && TimeoutStr)
    {
        BootOptions->Timeout = _wtoi(TimeoutStr);
    }
 
    IniGetKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
              BootOptionNames[BootStore->Type][BO_DefaultOS],
              (PCWSTR*)&BootOptions->NextBootEntryKey);
 
    /*
     * NOTE: BootOptions->CurrentBootEntryKey is an informative field only.
     * It indicates which boot entry has been selected for starting the
     * current OS instance. Such information is NOT stored in the INI file,
     * but has to be determined via other means. On UEFI the 'BootCurrent'
     * environment variable does that. Otherwise, one could heuristically
     * determine it by comparing the boot path and options of each entry
     * with those used by the current OS instance.
     * Since we currently do not need this information (and it can be costly
     * to determine), BootOptions->CurrentBootEntryKey is not evaluated.
     */
 
    return STATUS_SUCCESS;
}

SetBootStoreOptions()

NTSTATUS SetBootStoreOptions	(	IN PVOID	Handle,
		IN PBOOT_STORE_OPTIONS	BootOptions,
		IN ULONG	FieldsToChange
	)

Definition at line 1356 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
 
    if (!BootStore || !BootOptions)
        return STATUS_INVALID_PARAMETER;
 
    /*
     * NOTE: Currently we open & map the loader configuration file without
     * further tests. It's OK as long as we only deal with FreeLdr's freeldr.ini
     * and NTLDR's boot.ini files. But as soon as we'll implement support for
     * BOOTMGR detection, the "configuration file" will be the BCD registry
     * hive and then, we'll have instead to mount the hive & open it.
     */
 
    //
    // FIXME!!
    //
 
    // if (BootStore->Type >= BldrTypeMax || NtosBootLoaders[BootStore->Type].Type >= BldrTypeMax)
    if (BootStore->Type != FreeLdr && BootStore->Type != NtLdr)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[BootStore->Type].Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    // if (BootOptions->Length < sizeof(*BootOptions))
    //     return STATUS_INVALID_PARAMETER;
 
    if (FieldsToChange & BOOT_OPTIONS_TIMEOUT)
    {
        WCHAR TimeoutStr[15];
        RtlStringCchPrintfW(TimeoutStr, ARRAYSIZE(TimeoutStr), L"%d", BootOptions->Timeout);
        IniAddKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                  BootOptionNames[BootStore->Type][BO_TimeOut],
                  TimeoutStr);
    }
    if (FieldsToChange & BOOT_OPTIONS_NEXT_BOOTENTRY_KEY)
    {
        IniAddKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                  BootOptionNames[BootStore->Type][BO_DefaultOS],
                  (PCWSTR)BootOptions->NextBootEntryKey);
    }
 
    return STATUS_SUCCESS;
}

Referenced by CreateFreeLoaderReactOSEntries().

Variable Documentation

BootOptionNames

const PCWSTR BootOptionNames[][2]

static

Initial value:

=
{
    {L"TimeOut", L"DefaultOS"}, 
    {L"timeout", L"default"  }  
}

Definition at line 141 of file bldrsup.c.

Referenced by QueryBootStoreOptions(), and SetBootStoreOptions().

NtosBootLoaders

NTOS_BOOT_LOADER_FILES NtosBootLoaders[]

Initial value:

=
{
    {FreeLdr, L"freeldr.sys\0", L"freeldr.ini",
        OpenIniBootLoaderStore, CloseIniBootLoaderStore, (PENUM_BOOT_STORE_ENTRIES)FreeLdrEnumerateBootEntries},
    {NtLdr  , L"ntldr\0" L"osloader.exe\0", L"boot.ini",
        OpenIniBootLoaderStore, CloseIniBootLoaderStore, (PENUM_BOOT_STORE_ENTRIES)NtLdrEnumerateBootEntries  },
 
 
}

Definition at line 125 of file bldrsup.c.

Referenced by CloseBootStore(), DeleteBootStoreEntry(), EnumerateBootStoreEntries(), FindBootStore(), ModifyBootStoreEntry(), OpenBootStore_UStr(), OpenBootStoreByHandle(), OpenIniBootLoaderStore(), QueryBootStoreEntry(), and SetBootStoreOptions().