bldrsup.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_BOOT_STORE_OPTIONS
struct	_BOOT_STORE_ENTRY
struct	_NTOS_OPTIONS
struct	_BOOT_SECTOR_OPTIONS

Macros
#define	MAKESTRKEY(i)   ((ULONG_PTR)(i))
#define	MAKEINTKEY(i)   ((ULONG_PTR)((USHORT)(i)))
#define	IS_INTKEY(i)   (((ULONG_PTR)(i) >> 16) == 0)
#define	NTOS_OPTIONS_SIGNATURE   "NTOS_5\0\0"
#define	BOOT_SECTOR_OPTIONS_SIGNATURE   "BootSect"

Typedefs
typedef enum _BOOT_STORE_TYPE	BOOT_STORE_TYPE
typedef struct _BOOT_STORE_OPTIONS	BOOT_STORE_OPTIONS
typedef struct _BOOT_STORE_OPTIONS *	PBOOT_STORE_OPTIONS
typedef struct _BOOT_STORE_ENTRY	BOOT_STORE_ENTRY
typedef struct _BOOT_STORE_ENTRY *	PBOOT_STORE_ENTRY
typedef struct _NTOS_OPTIONS	NTOS_OPTIONS
typedef struct _NTOS_OPTIONS *	PNTOS_OPTIONS
typedef struct _BOOT_SECTOR_OPTIONS	BOOT_SECTOR_OPTIONS
typedef struct _BOOT_SECTOR_OPTIONS *	PBOOT_SECTOR_OPTIONS
typedef NTSTATUS(NTAPI *	PENUM_BOOT_ENTRIES_ROUTINE) (IN BOOT_STORE_TYPE Type, IN PBOOT_STORE_ENTRY BootEntry, IN PVOID Parameter OPTIONAL)

Enumerations
enum	_BOOT_STORE_TYPE { FreeLdr , NtLdr , BldrTypeMax }

Functions
NTSTATUS	FindBootStore (IN HANDLE PartitionDirectoryHandle, IN BOOT_STORE_TYPE Type, OUT PULONG VersionNumber OPTIONAL)
NTSTATUS	OpenBootStoreByHandle (OUT PVOID *Handle, IN HANDLE PartitionDirectoryHandle, IN BOOT_STORE_TYPE Type, IN BOOLEAN CreateNew)
NTSTATUS	OpenBootStore_UStr (OUT PVOID *Handle, IN PUNICODE_STRING SystemPartitionPath, IN BOOT_STORE_TYPE Type, IN BOOLEAN CreateNew)
NTSTATUS	OpenBootStore (OUT PVOID *Handle, IN PCWSTR SystemPartition, IN BOOT_STORE_TYPE Type, IN BOOLEAN CreateNew)
NTSTATUS	CloseBootStore (IN PVOID Handle)
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)

Macro Definition Documentation

BOOT_SECTOR_OPTIONS_SIGNATURE

#define BOOT_SECTOR_OPTIONS_SIGNATURE   "BootSect"

Definition at line 111 of file bldrsup.h.

IS_INTKEY

#define IS_INTKEY

(

i

)

(((ULONG_PTR)(i) >> 16) == 0)

Definition at line 56 of file bldrsup.h.

MAKEINTKEY

#define MAKEINTKEY

(

i

)

((ULONG_PTR)((USHORT)(i)))

Definition at line 55 of file bldrsup.h.

MAKESTRKEY

#define MAKESTRKEY

(

i

)

((ULONG_PTR)(i))

Definition at line 54 of file bldrsup.h.

NTOS_OPTIONS_SIGNATURE

#define NTOS_OPTIONS_SIGNATURE   "NTOS_5\0\0"

Definition at line 98 of file bldrsup.h.

Typedef Documentation

BOOT_SECTOR_OPTIONS

typedef struct _BOOT_SECTOR_OPTIONS BOOT_SECTOR_OPTIONS

BOOT_STORE_ENTRY

typedef struct _BOOT_STORE_ENTRY BOOT_STORE_ENTRY

BOOT_STORE_OPTIONS

typedef struct _BOOT_STORE_OPTIONS BOOT_STORE_OPTIONS

BOOT_STORE_TYPE

typedef enum _BOOT_STORE_TYPE BOOT_STORE_TYPE

NTOS_OPTIONS

typedef struct _NTOS_OPTIONS NTOS_OPTIONS

PBOOT_SECTOR_OPTIONS

typedef struct _BOOT_SECTOR_OPTIONS * PBOOT_SECTOR_OPTIONS

PBOOT_STORE_ENTRY

typedef struct _BOOT_STORE_ENTRY * PBOOT_STORE_ENTRY

PBOOT_STORE_OPTIONS

typedef struct _BOOT_STORE_OPTIONS * PBOOT_STORE_OPTIONS

PENUM_BOOT_ENTRIES_ROUTINE

typedef NTSTATUS(NTAPI * PENUM_BOOT_ENTRIES_ROUTINE) (IN BOOT_STORE_TYPE Type, IN PBOOT_STORE_ENTRY BootEntry, IN PVOID Parameter OPTIONAL)

Definition at line 114 of file bldrsup.h.

PNTOS_OPTIONS

typedef struct _NTOS_OPTIONS * PNTOS_OPTIONS

Enumeration Type Documentation

_BOOT_STORE_TYPE

enum _BOOT_STORE_TYPE

Enumerator
FreeLdr
NtLdr
BldrTypeMax

Definition at line 13 of file bldrsup.h.

{
    FreeLdr,    // ReactOS' FreeLoader
    NtLdr,      // Windows <= 2k3 NT "FlexBoot" OS Loader NTLDR
//  BootMgr,    // Vista+ BCD-oriented BOOTMGR
    BldrTypeMax
} BOOT_STORE_TYPE;

Function Documentation

AddBootStoreEntry()

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

Definition at line 854 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 */
        IniCacheInsertKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OsIniSection, NULL, INSERT_LAST,
                          (PWSTR)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().

CloseBootStore()

NTSTATUS CloseBootStore

(

IN PVOID

Handle

)

Definition at line 754 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().

DeleteBootStoreEntry()

NTSTATUS DeleteBootStoreEntry	(	IN PVOID	Handle,
		IN ULONG_PTR	BootEntryKey
	)

Definition at line 952 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 1486 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 137 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 (!DoesFileExist(PartitionDirectoryHandle, NtosBootLoaders[Type].LoaderConfigurationFile))
    {
        /* 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;
    }
 
#if 0
    /* Check whether the loader configuration file exists */
    Status = OpenAndMapFile(PartitionDirectoryHandle, NtosBootLoaders[Type].LoaderConfigurationFile,
                            &FileHandle, &SectionHandle, &ViewBase, &FileSize, FALSE);
    if (!NT_SUCCESS(Status))
    {
        /* 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;
    }
#endif
 
    return STATUS_SUCCESS;
}

Referenced by FindNTOSInstallations().

ModifyBootStoreEntry()

NTSTATUS ModifyBootStoreEntry	(	IN PVOID	Handle,
		IN PBOOT_STORE_ENTRY	BootEntry
	)

Definition at line 986 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;
}

OpenBootStore()

NTSTATUS OpenBootStore	(	OUT PVOID *	Handle,
		IN PCWSTR	SystemPartition,
		IN BOOT_STORE_TYPE	Type,
		IN BOOLEAN	CreateNew
	)

Definition at line 742 of file bldrsup.c.

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

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 BOOLEAN	CreateNew
	)

Definition at line 691 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, CreateNew);
 
    /* Done! */
    NtClose(PartitionDirectoryHandle);
    return Status;
}

Referenced by OpenBootStore().

OpenBootStoreByHandle()

NTSTATUS OpenBootStoreByHandle	(	OUT PVOID *	Handle,
		IN HANDLE	PartitionDirectoryHandle,
		IN BOOT_STORE_TYPE	Type,
		IN BOOLEAN	CreateNew
	)

Definition at line 664 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;
    }
 
    return NtosBootLoaders[Type].OpenBootStore(Handle,
                                               PartitionDirectoryHandle,
                                               Type,
                                               CreateNew);
}

Referenced by FindNTOSInstallations(), and OpenBootStore_UStr().

QueryBootStoreEntry()

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

Definition at line 1020 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 1055 of file bldrsup.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
    PWCHAR 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;
    }
 
    if (BootStore->Type == FreeLdr)
    {
        BootOptions->Version = FreeLdr;
 
        Status = IniCacheGetKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                                L"DefaultOS", (PWCHAR*)&BootOptions->CurrentBootEntryKey);
        if (!NT_SUCCESS(Status))
            BootOptions->CurrentBootEntryKey = 0;
 
        Status = IniCacheGetKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                                L"TimeOut", &TimeoutStr);
        if (NT_SUCCESS(Status) && TimeoutStr)
            BootOptions->Timeout = _wtoi(TimeoutStr);
        else
            BootOptions->Timeout = 0;
    }
    else if (BootStore->Type == NtLdr)
    {
        BootOptions->Version = NtLdr;
 
        Status = IniCacheGetKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                                L"default", (PWCHAR*)&BootOptions->CurrentBootEntryKey);
        if (!NT_SUCCESS(Status))
            BootOptions->CurrentBootEntryKey = 0;
 
        Status = IniCacheGetKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                                L"timeout", &TimeoutStr);
        if (NT_SUCCESS(Status) && TimeoutStr)
            BootOptions->Timeout = _wtoi(TimeoutStr);
        else
            BootOptions->Timeout = 0;
    }
 
    return STATUS_SUCCESS; // FIXME: use Status; instead?
}

SetBootStoreOptions()

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

Definition at line 1123 of file bldrsup.c.

{
    PBOOT_STORE_CONTEXT BootStore = (PBOOT_STORE_CONTEXT)Handle;
    WCHAR TimeoutStr[15];
 
    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)
    {
        DPRINT1("Loader type %d is currently unsupported!\n", NtosBootLoaders[BootStore->Type].Type);
        return STATUS_NOT_SUPPORTED;
    }
 
    if (BootOptions->Version != FreeLdr)
        return STATUS_INVALID_PARAMETER;
 
    //
    // TODO: Depending on the flags set in 'FieldsToChange',
    // change either one or both these bootloader options.
    //
    IniCacheInsertKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                      NULL, INSERT_LAST,
                      L"DefaultOS", (PWCHAR)BootOptions->CurrentBootEntryKey);
 
    RtlStringCchPrintfW(TimeoutStr, ARRAYSIZE(TimeoutStr), L"%d", BootOptions->Timeout);
    IniCacheInsertKey(((PBOOT_STORE_INI_CONTEXT)BootStore)->OptionsIniSection,
                      NULL, INSERT_FIRST, // INSERT_LAST, // FIXME!! There is a bug in the INI parser where a given key can be inserted twice in the same section...
                      L"TimeOut", TimeoutStr);
 
    return STATUS_SUCCESS;
}

Referenced by CreateFreeLoaderReactOSEntries().