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	_BOOTSECTOR_OPTIONS

Macros
#define	BOOT_OPTIONS_TIMEOUT   1
#define	BOOT_OPTIONS_NEXT_BOOTENTRY_KEY   2
#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	BOOTSECTOR_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 _BOOTSECTOR_OPTIONS	BOOTSECTOR_OPTIONS
typedef struct _BOOTSECTOR_OPTIONS *	PBOOTSECTOR_OPTIONS
typedef NTSTATUS(NTAPI *	PENUM_BOOT_ENTRIES_ROUTINE) (IN BOOT_STORE_TYPE Type, IN PBOOT_STORE_ENTRY BootEntry, IN PVOID Parameter OPTIONAL)
typedef enum _BOOT_STORE_OPENMODE	BOOT_STORE_OPENMODE
typedef enum _BOOT_STORE_ACCESS	BOOT_STORE_ACCESS

Enumerations
enum	_BOOT_STORE_TYPE { FreeLdr , NtLdr , BldrTypeMax }
enum	_BOOT_STORE_OPENMODE {   BS_CheckExisting = 0 , BS_CreateNew = 1 , BS_OpenExisting = 2 , BS_OpenAlways = 3 ,   BS_RecreateExisting = 4 , BS_CreateAlways = 5 }
enum	_BOOT_STORE_ACCESS { BS_ReadAccess = 1 , BS_WriteAccess = 2 , BS_ReadWriteAccess = (BS_ReadAccess | BS_WriteAccess) }

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_ 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)
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_OPTIONS_NEXT_BOOTENTRY_KEY

#define BOOT_OPTIONS_NEXT_BOOTENTRY_KEY   2

Definition at line 42 of file bldrsup.h.

BOOT_OPTIONS_TIMEOUT

#define BOOT_OPTIONS_TIMEOUT   1

Definition at line 41 of file bldrsup.h.

BOOTSECTOR_OPTIONS_SIGNATURE

#define BOOTSECTOR_OPTIONS_SIGNATURE   "BootSect"

Definition at line 114 of file bldrsup.h.

IS_INTKEY

#define IS_INTKEY

(

i

)

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

Definition at line 60 of file bldrsup.h.

MAKEINTKEY

#define MAKEINTKEY

(

i

)

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

Definition at line 59 of file bldrsup.h.

MAKESTRKEY

#define MAKESTRKEY

(

i

)

((ULONG_PTR)(i))

Definition at line 58 of file bldrsup.h.

NTOS_OPTIONS_SIGNATURE

#define NTOS_OPTIONS_SIGNATURE   "NTOS_5\0\0"

Definition at line 102 of file bldrsup.h.

Typedef Documentation

BOOT_STORE_ACCESS

typedef enum _BOOT_STORE_ACCESS BOOT_STORE_ACCESS

BOOT_STORE_ENTRY

typedef struct _BOOT_STORE_ENTRY BOOT_STORE_ENTRY

BOOT_STORE_OPENMODE

typedef enum _BOOT_STORE_OPENMODE BOOT_STORE_OPENMODE

BOOT_STORE_OPTIONS

typedef struct _BOOT_STORE_OPTIONS BOOT_STORE_OPTIONS

BOOT_STORE_TYPE

typedef enum _BOOT_STORE_TYPE BOOT_STORE_TYPE

BOOTSECTOR_OPTIONS

typedef struct _BOOTSECTOR_OPTIONS BOOTSECTOR_OPTIONS

NTOS_OPTIONS

typedef struct _NTOS_OPTIONS NTOS_OPTIONS

PBOOT_STORE_ENTRY

typedef struct _BOOT_STORE_ENTRY * PBOOT_STORE_ENTRY

PBOOT_STORE_OPTIONS

typedef struct _BOOT_STORE_OPTIONS * PBOOT_STORE_OPTIONS

PBOOTSECTOR_OPTIONS

typedef struct _BOOTSECTOR_OPTIONS * PBOOTSECTOR_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 117 of file bldrsup.h.

PNTOS_OPTIONS

typedef struct _NTOS_OPTIONS * PNTOS_OPTIONS

Enumeration Type Documentation

_BOOT_STORE_ACCESS

enum _BOOT_STORE_ACCESS

Enumerator
BS_ReadAccess
BS_WriteAccess
BS_ReadWriteAccess

Definition at line 141 of file bldrsup.h.

{
    // BS_NoAccess = 0,
    BS_ReadAccess  = 1,
    BS_WriteAccess = 2,
    BS_ReadWriteAccess = (BS_ReadAccess | BS_WriteAccess)
} BOOT_STORE_ACCESS;

_BOOT_STORE_OPENMODE

enum _BOOT_STORE_OPENMODE

Enumerator
BS_CheckExisting
BS_CreateNew
BS_OpenExisting
BS_OpenAlways
BS_RecreateExisting
BS_CreateAlways

Definition at line 131 of file bldrsup.h.

{
    BS_CheckExisting = 0, // See FindBootStore()
    BS_CreateNew     = 1, // BS_CreateOnly
    BS_OpenExisting  = 2, // BS_OpenOnly
    BS_OpenAlways    = 3,
    BS_RecreateExisting = 4, // BS_RecreateOnly
    BS_CreateAlways  = 5,
} BOOT_STORE_OPENMODE;

_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 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().

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().

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().

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;
}

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().

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().