bcd.h

#pragma once

#pragma pack(push)
#pragma pack(4)
typedef struct _BCDE_DEVICE_QUALIFIED_PARTITION
{
	unsigned int PartitionStyle;
	unsigned int Reserved;
	union {
		struct {
			unsigned int DiskSignature;
			ULONG64 PartitionOffset;
		} Mbr;
		struct {
			GUID DiskSignature;
			GUID PartitionSignature;
		} Gpt;
	};
} BCDE_DEVICE_QUALIFIED_PARTITION, *PBCDE_DEVICE_QUALIFIED_PARTITION;


typedef union _BCDE_DEVICE_BODY {
	struct {
		unsigned int ParentOffset;
		wchar_t Path[1];
	} File;
	struct {
		wchar_t Path[1];
	} Partition;
	struct {
		DWORD Type;
		unsigned int ParentOffset;
		unsigned int ElementType;
		wchar_t Path[1];
	} Locate;
	struct {
		GUID InterfaceInstance;
	} Vmbus;
	struct {
		BYTE Data[1];
	} Unknown;
	BCDE_DEVICE_QUALIFIED_PARTITION QualifiedPartition;
} BCDE_DEVICE_BODY, *PBCDE_DEVICE_BODY;


typedef struct _BCDE_DEVICE
{
	unsigned int DeviceType;
	GUID AdditionalOptions;
	BCDE_DEVICE_BODY Body;
} BCDE_DEVICE, * PBCDE_DEVICE;

typedef struct _FILE_PATH_RAW {
	DWORD Version;
	DWORD Length;
	DWORD Type;
	BYTE FilePath[1];
} FILE_PATH, *PFILE_PATH;

typedef struct _HARD_DISK_IDENTIFIER {
	DWORD PartitionType;
	union {
		struct {
			DWORD Signature;
		} Mbr;
		struct {
			GUID Signature;
		} Gpt;
		struct {
			DWORD DiskNumber;
		} Raw;
	};
} HARD_DISK_IDENTIFIER, * PHARD_DISK_IDENTIFIER;

typedef struct _BOOT_ENVIRONMENT_DEVICE_HEADER
{
	DWORD DeviceType;
	DWORD Flags;
	DWORD Size;
	DWORD Pad;
} BOOT_ENVIRONMENT_DEVICE_HEADER, * PBOOT_ENVIRONMENT_DEVICE_HEADER;

typedef struct _VHD_IDENTIFIER {
	HARD_DISK_IDENTIFIER HardDisk;
	BOOT_ENVIRONMENT_DEVICE_HEADER BaseDevice;
} VHD_IDENTIFIER, *PVHD_IDENTIFIER;

typedef struct _REMOVABLE_DISK_IDENTIFIER {
	DWORD DriveNumber;
} REMOVABLE_DISK_IDENTIFIER, * PREMOVABLE_DISK_IDENTIFIER;

typedef struct _OPTICAL_DISC_IDENTIFIER {
	DWORD DiscNumber;
} OPTICAL_DISC_IDENTIFIER, *POPTICAL_DISC_IDENTIFIER;

typedef struct _FILE_IDENTIFIER {
	FILE_PATH SourcePath;
} FILE_IDENTIFIER, *PFILE_IDENTIFIER;

typedef struct _RAM_DISK_IDENTIFIER {
	LARGE_INTEGER ImageBase;
	ULONG64 ImageSize;
	DWORD ImageOffset;
	FILE_IDENTIFIER Source;
} RAM_DISK_IDENTIFIER, *PRAM_DISK_IDENTIFIER;

typedef struct _MEM_DISK_IDENTIFIER {
	LARGE_INTEGER ImageBase;
	ULONG64 ImageSize;
	ULONG SectorSize;
	BOOT_ENVIRONMENT_DEVICE_HEADER BaseDevice;
} MEM_DISK_IDENTIFIER, *PMEM_DISK_IDENTIFIER;

typedef struct _BLOCK_IO_IDENTIFIER {
	unsigned int BlockIoType;
	union {
		HARD_DISK_IDENTIFIER HardDisk;
		REMOVABLE_DISK_IDENTIFIER RemovableDisk;
		OPTICAL_DISC_IDENTIFIER OpticalDisc;
		FILE_IDENTIFIER File;
		RAM_DISK_IDENTIFIER RamDisk;
		VHD_IDENTIFIER Vhd;
		MEM_DISK_IDENTIFIER MemDisk;
	};
} BLOCK_IO_IDENTIFIER, *PBLOCK_IO_IDENTIFIER;

typedef struct _GEN_ADDR
{
	BYTE AddressSpaceID;
	BYTE BitWidth;
	BYTE BitOffset;
	BYTE AccessSize;
	ULONG64 Address;
} GEN_ADDR, *PGEN_ADDR;

typedef struct _PARTITION_OPTICAL {
	unsigned int BootEntry;
} PARTITION_OPTICAL, *PPARTITION_OPTICAL;

typedef struct _PARTITION_GPT {
	GUID PartitionSignature;
} PARTITION_GPT, *PPARTITION_GPT;

typedef struct _PARTITION_IDENTIFIER {
	union {
		PARTITION_OPTICAL ElTorito;
		PARTITION_GPT Gpt;
		struct {
			DWORD PartitionNumber;
		} Mbr;
	};
	BLOCK_IO_IDENTIFIER ParentIdentifier;
} PARTITION_IDENTIFIER, *PPARTITION_IDENTIFIER;

typedef struct _PARTITION_IDENTIFIER_EX {
	union {
		PARTITION_OPTICAL ElTorito;
		PARTITION_GPT Gpt;
		struct {
			ULONG64 PartitionOffset;
		} Mbr;
	};
	BLOCK_IO_IDENTIFIER ParentIdentifier;
} PARTITION_IDENTIFIER_EX, * PPARTITION_IDENTIFIER_EX;

typedef struct _SERIAL_PORT_IDENTIFIER {
	unsigned int Type;
	union {
		unsigned int PortNumber;
		GEN_ADDR BaseAddress;
	};
} SERIAL_PORT_IDENTIFIER, *PSERIAL_PORT_IDENTIFIER;

typedef struct _UDP_IDENTIFIER {
	unsigned int HwType;
	BYTE HwAddress[16];
} UDP_IDENTIFIER, *PUDP_IDENTIFIER;

typedef struct _LOCATE_IDENTIFIER {
	unsigned int Type;
	unsigned int ElementType;
	unsigned int ParentOffset;
	wchar_t Path[1];
} LOCATE_IDENTIFIER, *PLOCATE_IDENTIFIER;

typedef struct _VMBUS_IDENTIFIER
{
	GUID InterfaceType;
	GUID InterfaceInstance;
} VMBUS_IDENTIFIER, *PVMBUS_IDENTIFIER;

typedef struct _URI_IDENTIFIER
{
	DWORD Length;
	char String[1];
} URI_IDENTIFIER, *PURI_IDENTIFIER;

typedef struct _COMPOSITE_IDENTIFIER {
	GUID InterfaceType;
	DWORD Unknown;
	DWORD PrimaryDeviceOffset;
	DWORD SecondaryDeviceOffset;

	BYTE Data[1]; // BOOT_ENVIRONMENT_DEVICE [2]
} COMPOSITE_IDENTIFIER, *PCOMPOSITE_IDENTIFIER;

typedef struct _CIMFS_IDENTIFIER {
	DWORD Version_maybe;
	GUID Guid;
} CIMFS_IDENTIFIER, *PCIMFS_IDENTIFIER;

typedef union _BOOT_ENVIRONMENT_DEVICE_BODY {
	BLOCK_IO_IDENTIFIER BlockIo;
	PARTITION_IDENTIFIER Partition;
	PARTITION_IDENTIFIER_EX PartitionEx;
	SERIAL_PORT_IDENTIFIER SerialPort;
	UDP_IDENTIFIER Udp;
	LOCATE_IDENTIFIER Locate;
	VMBUS_IDENTIFIER Vmbus;
	URI_IDENTIFIER Uri;
	COMPOSITE_IDENTIFIER Composite;
	CIMFS_IDENTIFIER Cimfs;
} BOOT_ENVIRONMENT_DEVICE_BODY, *PBOOT_ENVIRONMENT_DEVICE_BODY;

typedef struct _BOOT_ENVIRONMENT_DEVICE
{
	union {
		struct {
			unsigned int DeviceType;
			unsigned int Flags;
			unsigned int Size;
			unsigned int Pad;
		};
		BOOT_ENVIRONMENT_DEVICE_HEADER Header;
	};
	BOOT_ENVIRONMENT_DEVICE_BODY Body;
} BOOT_ENVIRONMENT_DEVICE, *PBOOT_ENVIRONMENT_DEVICE;

// WimOverlay.dat stuff

typedef enum : DWORD {
	WIMBOOT_NOT_OS = 0,
	WIMBOOT_OS = 1
} OVERLAY_INFO_WIM_TYPE;

// Overlay device entry.
typedef struct _OVERLAY_INFO_V0 {
	UINT64 DataSourceId; // this device is used if it matches the DataSourceId in the reparse data
	DWORD DeviceOffset; // to BOOT_ENVIRONMENT_DEVICE, from the base OVERLAY_CONFIG (not the OVERLAY_INFO_V0)
	DWORD DeviceSize; // must match Device->Size, must be at least offsetof(BOOT_ENVIRONMENT_DEVICE_HEADER, Pad)
	// following entries are not used in the boot environment
	// this is because the boot environment only uses the boot index of WIMs
	OVERLAY_INFO_WIM_TYPE WimType;
	DWORD WimIndex;
	GUID WimGuid; // from the WIM header
} OVERLAY_INFO_V0, *POVERLAY_INFO_V0;

#pragma warning(push)
#pragma warning(disable : 4200) // zero-sized array
typedef struct _OVERLAY_CONFIG {
	DWORD Signature; // must equal OVERLAY_SIGNATURE
	DWORD Version; // must equal OVERLAY_VERSION
	DWORD Size; // of one Info element, must be at least sizeof(OVERLAY_INFO_V0)
	DWORD Count; // of Info elements, must not be greater than 0x100
	ULONG64 NumberOfDataSources;
	OVERLAY_INFO_V0 Info[0];
} OVERLAY_CONFIG, *POVERLAY_CONFIG;
#pragma warning(pop)

// Wimboot reparse point structures.
typedef struct _WOF_EXTERNAL_INFO_REPARSE {
	ULONG Version;
	ULONG Provider;
} WOF_EXTERNAL_INFO_REPARSE, *PWOF_EXTERNAL_INFO_REPARSE;

enum {
	WIM_PROVIDER_ON_DISK_HASH_SIZE = 20, // sizeof(SHA1Hash)
	WIM_PROVIDER_ON_DISK_PADDING_SIZE = 4 // sizeof(DWORD)
};

typedef struct _WIM_PROVIDER_ON_DISK_EXTERNAL_INFO {
	DWORD Version;
	DWORD Flags;
	ULONG64 DataSourceId;
	BYTE Filename[WIM_PROVIDER_ON_DISK_HASH_SIZE + WIM_PROVIDER_ON_DISK_PADDING_SIZE];
} WIM_PROVIDER_ON_DISK_EXTERNAL_INFO, *PWIM_PROVIDER_ON_DISK_EXTERNAL_INFO;

typedef struct _OVERLAY_REPARSE_DATA {
	DWORD ReparseTag;
	WORD ReparseDataLength;
	WORD Reserved;
	WOF_EXTERNAL_INFO_REPARSE WofInfo;
	WIM_PROVIDER_ON_DISK_EXTERNAL_INFO WimProvider;
} OVERLAY_REPARSE_DATA, *POVERLAY_REPARSE_DATA;

// WimOverlay.dat structure:
// OVERLAY_CONFIG Header;
// OVERLAY_INFO_V0 Body[Header.Count]
// BOOT_ENVIRONMENT_DEVICE Devices[]
#pragma pack(pop)

enum {
	OVERLAY_SIGNATURE = 0x66436F57, // "WoCf"
	OVERLAY_VERSION = 1,
	OVERLAY_EXTERNAL_VERSION = 1,
	OVERLAY_PROVIDER_WIM = 1,
	WIM_IO_REPARSE_TAG_WOF = 0x80000017
};

typedef enum {
	DEVICE_TYPE_BLOCK_IO,
	DEVICE_TYPE_UNKNOWN,
	DEVICE_TYPE_PARTITION,
	DEVICE_TYPE_SERIAL,
	DEVICE_TYPE_UDP,
	DEVICE_TYPE_BOOT,
	DEVICE_TYPE_PARTITION_EX,
	DEVICE_TYPE_VMBUS,
	DEVICE_TYPE_LOCATE,
	DEVICE_TYPE_URI,
	DEVICE_TYPE_COMPOSITE,
	DEVICE_TYPE_CIMFS
} BOOT_ENVIRONMENT_DEVICE_TYPE;

typedef enum {
	BCDE_TYPE_BLOCK_IO,
	BCDE_TYPE_BOOT,
	BCDE_TYPE_PARTITION,
	BCDE_TYPE_SERIAL,
	BCDE_TYPE_UDP,
	BCDE_TYPE_UNKNOWN,
	BCDE_TYPE_PARTITION_EX,
	BCDE_TYPE_VMBUS,
	BCDE_TYPE_LOCATE,
	BCDE_TYPE_URI,
	BCDE_TYPE_COMPOSITE,
	BCDE_TYPE_CIMFS
} BCDE_DEVICE_TYPE;

typedef enum {
	BLOCK_TYPE_HARD_DISK,
	BLOCK_TYPE_REMOVABLE_DISK,
	BLOCK_TYPE_OPTICAL_DISC,
	BLOCK_TYPE_RAM_DISK,
	BLOCK_TYPE_UNKNOWN,
	BLOCK_TYPE_FILE,
	BLOCK_TYPE_VHD,
	BLOCK_TYPE_MEM_DISK
} BLOCK_IO_DEVICE_TYPE;

typedef enum {
	PARTITION_TYPE_GPT,
	PARTITION_TYPE_MBR,
	PARTITION_TYPE_RAW
} PARTITION_TYPE;

typedef enum {
	SERIAL_PORT_NUMBER,
	SERIAL_GEN_ADDR,
	SERIAL_SPI_MAX311XE,
	SERIAL_PL011,
	SERIAL_Q8X60,
	SERIAL_NVIDIA,
	SERIAL_OMAP,
	SERIAL_UEFI_DBGPORT,
	SERIAL_APM88XXXX,
	SERIAL_Q8X74,
	SERIAL_SAM5250,
	SERIAL_USIF,
	SERIAL_MX6,
	SERIAL_SBSA32,
	SERIAL_SBSA,
	SERIAL_ARM_DCC,
	SERIAL_BCM2708, // original is BCM2835, let's use the real SoC here :)
	SERIAL_SDM845,
	SERIAL_MM16550,
	SERIAL_SDM845v2,
	SERIAL_IALPSS,

	SERIAL_PORT_TYPE_MAXIMUM
} SERIAL_PORT_TYPE;

typedef enum {
	LOCATE_TYPE_STRING_ELEMENT,
	LOCATE_TYPE_STRING
} LOCATE_TYPE;

typedef enum {
	DEVICE_NEEDS_CREATION = (1 << 0), ///!< If set, device needs to be created.
	DEVICE_PART_ENUM_HAS_BL = (1 << 1), ///!< If set, BitLocker encrypted partitions will be enumerated.
	DEVICE_PART_NO_PARENT = (1 << 2), ///!< If set, partition's parent device is unknown.
	DEVICE_IGNORE_CREATION = (1 << 3), ///!< If set, device is not created if it was possible; bit 0 will still force creation. (RS5+)
	DEVICE_BIT_4 = (1 << 4), ///!< Unknown.
	DEVICE_LOCATE_RESOLVE_WITHOUT_CREATION = (1 << 5), ///!< If set, when this locate device is loaded from BCD, it will be resolved into string-type locate from element-type without being created. (GE+)
} BOOT_ENVIRONMENT_DEVICE_FLAGS;