ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/pbcdedit/pbcdedit

Comparing pbcdedit/pbcdedit (file contents):
Revision 1.1 by root, Wed Aug 14 20:38:16 2019 UTC vs.
Revision 1.76 by root, Tue Aug 9 11:44:54 2022 UTC

1	#!/opt/bin/perl	1	#!/usr/bin/perl
2		2
3	#	3	#
4	# PBCDEDIT - Copyright 2019 Marc A. Lehmann <pbcbedit@schmorp.de>	4	# PBCDEDIT - Copyright 2019 Marc A. Lehmann <pbcbedit@schmorp.de>
5	#	5	#
6	# SPDX-License-Identifier: GPL-3.0-or-later	6	# SPDX-License-Identifier: GPL-3.0-or-later
…		…
17	#	17	#
18	# You should have received a copy of the GNU General Public License	18	# You should have received a copy of the GNU General Public License
19	# along with this program. If not, see <https://www.gnu.org/licenses/>.	19	# along with this program. If not, see <https://www.gnu.org/licenses/>.
20	#	20	#
21		21
22	use 5.014; # numerous features	22	use 5.016; # numerous features need 5.14, __SUB__ needs 5.16
23		23
24	our $VERSION = '1.0';	24	our $VERSION = '1.5';
25	our $JSON_VERSION = 1; # the versiobn of the json objects generated by this program	25	our $JSON_VERSION = 3; # the version of the json objects generated by this program
		26
		27	our $CHANGELOG = <<EOF;
		28
		29	1.5 Mon Nov 25 15:54:34 CET 2019
		30	- add "del" edit instruction.
		31	- work around lsblk bug sometimes giving "dos" pttype for gpt partitions.
		32	- bootmenupolicy in synopsis must be set to 0 to get the text menu.
		33	- minor doc fxes.
		34	- disable use of perldoc for help, doesn't work well.
		35
		36	1.4 Thu Aug 22 10:48:22 CEST 2019
		37	- new "create" subcommand.
		38	- "create" and "edit" try to save and restore ownership/permissions
		39	of bcd hives when writing the new file.
		40	- editorial fixes to the documentation.
		41	- add mininmal hive creation example.
		42
		43	1.3 Sat Aug 17 07:04:15 CEST 2019
		44	- output of pbcdedit elements --json has changed, as it didn't
		45	take the reorganisation by classes fully into account.
		46	- json schema bumped to 3.
		47	- new "bcd-device" and "bcd-legacy-device" subcommands.
		48	- implement --json option for lsblk.
		49
		50	1.2 Fri Aug 16 00:20:41 CEST 2019
		51	- bcd element names now depend on the bcd object type they are in,
		52	also affects "elements" output.
		53	- json schema bumped to 2.
		54	- new version command.
		55	- numerous minor bugfixes.
		56
		57	EOF
26		58
27	=head1 NAME	59	=head1 NAME
28		60
29	pbcdedit - portable boot configuration data (BCD) store editor	61	pbcdedit - portable boot configuration data (BCD) store editor
30		62
31	=head1 SYNOPSIS	63	=head1 SYNOPSIS
32		64
33	pbcdedit help # output manual page	65	pbcdedit help # output manual page
		66	pbcdedit version # output version and changelog
		67
34	pbcdedit export path/to/BCD # output BCD hive as JSON	68	pbcdedit export path/to/BCD # output BCD hive as JSON
35	pbcdedit import path/to/bcd # convert standard input to BCD hive	69	pbcdedit import path/to/BCD # convert standard input to BCD hive
36	pbcdedit edit path/to/BCD edit-instructions...	70	pbcdedit edit path/to/BCD edit-instructions...
37		71
38	pbcdedit objects # list all supported object aliases and types	72	pbcdedit objects # list all supported object aliases and types
39	pbcdedit elements # list all supported bcd element aliases	73	pbcdedit elements # list all supported bcd element aliases
40		74
		75	# Example: enable text-based boot menu.
		76	pbcdedit edit /my/BCD set '{default}' bootmenupolicy 0
		77
		78	# Example change system device to first partition containing winload.
		79	pbcdedit edit /my/BCD \
		80	set '{default}' device 'locate=<null>,element,path' \
		81	set '{default}' osdevice 'locate=<null>,element,path'
		82
		83
41	=head1 DESCRIPTION	84	=head1 DESCRIPTION
42		85
43	This program allows you to create, read and modify Boot Configuration Data	86	This program allows you to create, read and modify Boot Configuration Data
44	(BCD) stores used by Windows Vista and newer versions of Windows.	87	(BCD) stores used by Windows Vista and newer versions of Windows.
45		88
		89	At this point, it is in relatively early stages of development and has
		90	received little to no real-world testing.
		91
46	Compared to other BCD editing programs it offers the following unique	92	Compared to other BCD editing programs it offers the following unique
47	features:	93	features:
48		94
49	=over	95	=over
50		96
…		…
55		101
56	=item Does not rely on Windows	102	=item Does not rely on Windows
57		103
58	As the "portable" in the name implies, this program does not rely on	104	As the "portable" in the name implies, this program does not rely on
59	C<bcdedit> or other windows programs or libraries, it works on any system	105	C<bcdedit> or other windows programs or libraries, it works on any system
60	that supports at least perl version 5.14.	106	that supports at least perl version 5.16.
61		107
62	=item Decodes and encodes BCD device elements	108	=item Decodes and encodes BCD device elements
63		109
64	PBCDEDIT can concisely decode and encode BCD device element contents. This	110	PBCDEDIT can concisely decode and encode BCD device element contents. This
65	is pretty unique, and offers a lot of potential that can't be realised	111	is pretty unique, and offers a lot of potential that can't be realised
…		…
72	sensitive data.	118	sensitive data.
73		119
74	=back	120	=back
75		121
76	The target audience for this program is professionals and tinkerers who	122	The target audience for this program is professionals and tinkerers who
77	are rewady to invest time into learning how it works. It is not an easy	123	are ready to invest time into learning how it works. It is not an easy
78	program to use and requires patience and a good understanding of BCD data	124	program to use and requires patience and a good understanding of BCD
79	stores.	125	stores.
80		126
81		127
82	=head1 SUBCOMMANDS	128	=head1 SUBCOMMANDS
83		129
84	PCBEDIT expects a subcommand as first argument that tells it what to	130	PBCDEDIT expects a subcommand as first argument that tells it what to
85	do. The following subcommands exist:	131	do. The following subcommands exist:
86		132
87	=over	133	=over
88		134
89	=item help	135	=item C<help>
90		136
91	Displays the whole manuale page (this document).	137	Displays the whole manual page (this document).
92		138
		139	=item C<version>
		140
		141	This outputs the PBCDEDIT version, the JSON schema version it uses and the
		142	full log of changes.
		143
93	=item export F<path>	144	=item C<export> F<path>
94		145
95	Reads a BCD data store and writes a JSON representation of it to standard	146	Reads a BCD data store and writes a JSON representation of it to standard
96	output.	147	output.
97		148
98	The format of the data is explained later in this document.	149	The format of the data is explained later in this document.
99		150
100	Example: read a BCD store, modify it wiht an extenral program, write it again.	151	Example: read a BCD store, modify it with an external program, write it
		152	again.
101		153
102	pbcdedit export BCD | modify-json-somehow | pbcdedit import BCD	154	pbcdedit export BCD | modify-json-somehow | pbcdedit import BCD
103		155
104	=item import F<path>	156	=item C<import> F<path>
105		157
106	The reverse of C<export>: Reads a JSON representation of a BCD data store	158	The reverse of C<export>: Reads a JSON representation of a BCD data store
107	from standard input, and creates or replaces the given BCD data store.	159	from standard input, and creates or replaces the given BCD data store.
108		160
109	=item edit F<path> instructions...	161	=item C<edit> F<path> I<instructions...>
110		162
111	#TODO	163	Load a BCD data store, apply some instructions to it, and save it again.
112		164
113	=item lsblk	165	See the section L<EDITING BCD STORES>, below, for more info.
		166
		167	=item C<parse> F<path> I<instructions...>
		168
		169	Same as C<edit>, above, except it doesn't save the data store again. Can
		170	be useful to extract some data from it.
		171
		172	=item C<create> F<path> I<instructions...>
		173
		174	Same as C<edit>, above, except it creates a new data store from scratch if
		175	needed. An existing store will be emptied completely.
		176
		177	=item C<lsblk> [C<--json>]
114		178
115	On a GNU/Linux system, you can get a list of partition device descriptors	179	On a GNU/Linux system, you can get a list of partition device descriptors
116	using this command - the external C<lsblk> command is required, as well as	180	using this command - the external C<lsblk> command is required, as well as
117	a mounted C</sys> file system.	181	a mounted C</sys> file system.
118		182
119	The output will be a list of all partitions in the system and C<partition>	183	The output will be a list of all partitions in the system and C<partition>
120	descriptors for GPT and both C<legacypartition> and C<partition>	184	descriptors for GPT and both C<legacypartition> and C<partition>
121	descritpors for MBR partitions.	185	descriptors for MBR partitions.
122		186
		187	With C<--json> it will print similar information as C<lsblk --json>, but
		188	with extra C<bcd_device> and C<bcd_legacy_device> attributes.
		189
		190	=item C<bcd-device> F<path>
		191
		192	Tries to find the BCD device element for the given device, which currently
		193	must be a a partition of some kind. Prints the C<partition=> descriptor as
		194	a result, or nothing. Exit status will be true on success, and false on
		195	failure.
		196
		197	Like C<lsblk>, above, this likely only works on GNU/Linux systems.
		198
		199	Example: print the partition descriptor of tghe partition with label DATA.
		200
		201	$ pbcdedit bcd-device /dev/disk/by-label/DATA
		202	partition=<null>,harddisk,mbr,47cbc08a,213579202560
		203
		204	=item C<bcd-legacy-device> F<path>
		205
		206	Like above, but uses a C<legacypartition> descriptor instead.
		207
123	=item objects [--json]	208	=item C<objects> [C<--json>]
124		209
125	Outputs two tables: a table listing all type aliases with their hex bcd	210	Outputs two tables: a table listing all type aliases with their hex BCD
126	element ID, and all object name aliases with their GUID and default type	211	element ID, and all object name aliases with their GUID and default type
127	(if any).	212	(if any).
128		213
129	With C<--json> it prints similar information as a JSON object, for easier parsing.	214	With C<--json> it prints similar information as a JSON object, for easier parsing.
130		215
131	=item elements [--json]	216	=item C<elements> [C<--json>]
132		217
133	Outputs a table of known element aliases with their hex ID and the format	218	Outputs a table of known element aliases with their hex ID and the format
134	type.	219	type.
135		220
136	With C<--json> it prints similar information as a JSON object, for easier parsing.	221	With C<--json> it prints similar information as a JSON object, for easier parsing.
137		222
138	=item export-regf F<path>	223	=item C<export-regf> F<path>
139		224
140	This has nothing to do with BCD data stores - it takes a registry hive	225	This has nothing to do with BCD stores, but simply exposes PCBEDIT's
		226	internal registry hive reader - it takes a registry hive file as argument
141	file as argument and outputs a JSON representation of it to standard	227	and outputs a JSON representation of it to standard output.
142	output.
143		228
144	Hive versions 1.2 till 1.6 are supported.	229	Hive versions 1.2 till 1.6 are supported.
145		230
146	=item import-regf F<path>	231	=item C<import-regf> F<path>
147		232
148	The reverse of C<export-regf>: reads a JSON representation of a registry	233	The reverse of C<export-regf>: reads a JSON representation of a registry
149	hive from standard input and creates or replaces the registry hive file given as	234	hive from standard input and creates or replaces the registry hive file
150	argument.	235	given as argument.
151		236
152	The written hive will always be in a slightly modified version 1.3	237	The written hive will always be in a slightly modified version 1.3
153	format. It's not the format windows would generate, but it should be	238	format. It's not the format windows would generate, but it should be
154	understood by any conformant hive reader.	239	understood by any conformant hive reader.
155		240
156	Note that the representation chosen by PBCDEDIT currently throws away	241	Note that the representation chosen by PBCDEDIT currently throws away
157	clasname data (often used for feeble attemtps at hiding stuff by	242	classname data (often used for feeble attempts at hiding stuff by
158	Microsoft) and security descriptors, so if you write anything other than	243	Microsoft) and security descriptors, so if you write anything other than
159	a BCD hive you will most likely destroy it.	244	a BCD hive you will most likely destroy it.
160		245
161	=back	246	=back
162		247
163		248
164	=head1 BCD DATA STORE REPRESENTATION FORMAT	249	=head1 BCD STORE REPRESENTATION FORMAT
165		250
166	A BCD data store is represented as a JSON object with one special key,	251	A BCD data store is represented as a JSON object with one special key,
167	C<meta>, and one key per BCD object. That is, each BCD object becomes	252	C<meta>, and one key per BCD object. That is, each BCD object becomes
168	one key-value pair in the object, and an additional key called C<meta>	253	one key-value pair in the object, and an additional key called C<meta>
169	contains meta information.	254	contains meta information.
…		…
202	"hypervisordebugtype" : 0	287	"hypervisordebugtype" : 0
203	},	288	},
204	# ...	289	# ...
205	}	290	}
206		291
		292	=head2 Minimal BCD to boot windows
		293
		294	Experimentally I found the following BCD is the minimum required to
		295	successfully boot any post-XP version of Windows (assuming suitable
		296	C<device> and C<osdevice> values, of course, and assuming a BIOS boot -
		297	for UEFI, you should use F<winload.efi> instead of F<winload.exe>):
		298
		299	{
		300	"{bootmgr}" : {
		301	"default" : "{45b547a7-8ca6-4417-9eb0-a257b61f35b4}"
		302	},
		303
		304	"{45b547a7-8ca6-4417-9eb0-a257b61f35b1}" : {
		305	"type" : "application::osloader",
		306	"description" : "Windows Boot",
		307	"device" : "legacypartition=<null>,harddisk,mbr,47cbc08a,1",
		308	"osdevice" : "legacypartition=<null>,harddisk,mbr,47cbc08a,1",
		309	"path" : "\\Windows\\system32\\winload.exe",
		310	"systemroot" : "\\Windows"
		311	},
		312	}
		313
		314	Note that minimal doesn't mean recommended - Windows itself will add stuff
		315	to this during or after boot, and you might or might not run into issues
		316	when installing updates as it might not be able to find the F<bootmgr>.
		317
		318	This is how you would create a minimal hive with PBCDEDIT from within
		319	GNU/Linux, assuming F</dev/sdc3> is the windows partition, using
		320	a random GUID for the osloader and using C<partition> instead of
		321	C<legacypartition>:
		322
		323	osldr="{$(uuidgen)}"
		324	part=$(pbcdedit bcd-device /dev/sdc3)
		325	pbcdedit create minimal.bcd \
		326	set '{bootmgr}' default "$osldr" \
		327	set "$osldr" type application::osloader \
		328	set "$osldr" description 'Windows Boot' \
		329	set "$osldr" device "$part" \
		330	set "$osldr" osdevice "$part" \
		331	set "$osldr" path '\Windows\system32\winload.exe' \
		332	set "$osldr" systemroot '\Windows'
		333
207	=head2 The C<meta> key	334	=head2 The C<meta> key
208		335
209	The C<meta> key is not stored in the BCD data store but is used only	336	The C<meta> key is not stored in the BCD data store but is used only
210	by PBCDEDIT. It is always generated when exporting, and importing will	337	by PBCDEDIT. It is always generated when exporting, and importing will
211	be refused when it exists and the version stored inside doesn't store	338	be refused when it exists and the version stored inside doesn't match
212	the JSON schema version of PBCDEDIT. This ensures that differemt and	339	the JSON schema version of PBCDEDIT. This ensures that different and
213	incompatible versions of PBCDEDIT will not read and misinterüret each	340	incompatible versions of PBCDEDIT will not read and misinterpret each
214	others data.	341	others data.
215		342
216	=head2 The object keys	343	=head2 The object keys
217		344
218	Every other key is a BCD object. There is usually a BCD object for the	345	Every other key is a BCD object. There is usually a BCD object for the
219	boot manager, one for every boot option and a few others that store common	346	boot manager, one for every boot option and a few others that store common
220	settings inherited by these.	347	settings inherited by these.
221		348
222	Each BCD object is represented by a GUID wrapped in curly braces. These	349	Each BCD object is represented by a GUID wrapped in curly braces. These
223	are usually random GUIDs used only to distinguish bCD objects from each	350	are usually random GUIDs used only to distinguish BCD objects from each
224	other. When adding a new boot option, you can simply generate a new GUID.	351	other. When adding a new boot option, you can simply generate a new GUID.
225		352
226	Some of these GUIDs are fixed well known GUIDs which PBCDEDIT will decode	353	Some of these GUIDs are fixed well known GUIDs which PBCDEDIT will decode
227	into human-readable strings such as C<{globalsettings}>, which is the same	354	into human-readable strings such as C<{globalsettings}>, which is the same
228	as C<{7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}>.	355	as C<{7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}>.
229		356
230	Each BCD, object has an associated type. For example,	357	Each BCD object has an associated type. For example,
231	C<application::osloader> for objects loading Windows via F<winload.exe>,	358	C<application::osloader> for objects loading Windows via F<winload.exe>,
232	C<application::bootsector> for real mode applications and so on.	359	C<application::bootsector> for real mode applications and so on.
233		360
234	The type of a object is stored in the pseudo BCD element C<type> (see next	361	The type of a object is stored in the pseudo BCD element C<type> (see next
235	section).	362	section).
…		…
262	get a list of all BCD elements known to PBCDEDIT by running F<pbcdedit	389	get a list of all BCD elements known to PBCDEDIT by running F<pbcdedit
263	elements>.	390	elements>.
264		391
265	What was said about duplicate keys mapping to the same object is true for	392	What was said about duplicate keys mapping to the same object is true for
266	elements as well, so, again, you should always use the canonical name,	393	elements as well, so, again, you should always use the canonical name,
267	whcih is the human radable alias, if known.	394	which is the human readable alias, if known.
268		395
269	=head3 BCD element types	396	=head3 BCD element types
270		397
271	Each BCD element has a type such as I<string> or I<boolean>. This type	398	Each BCD element has a type such as I<string> or I<boolean>. This type
272	determines how the value is interpreted, and most of them are pretty easy	399	determines how the value is interpreted, and most of them are pretty easy
…		…
284	"description" : "Windows 10",	411	"description" : "Windows 10",
285	"systemroot" : "\\Windows",	412	"systemroot" : "\\Windows",
286		413
287	=item boolean	414	=item boolean
288		415
289	Almost as simnple are booleans, which represent I<true>/I<false>,	416	Almost as simple are booleans, which represent I<true>/I<false>,
290	I<on>/I<off> and similar values. In the JSON form, true is represented	417	I<on>/I<off> and similar values. In the JSON form, true is represented
291	by the number C<1>, and false is represented by the number C<0>. Other	418	by the number C<1>, and false is represented by the number C<0>. Other
292	values will be accepted, but PBCDEDIT doesn't guarantee how these are	419	values will be accepted, but PBCDEDIT doesn't guarantee how these are
293	interpreted.	420	interpreted.
294		421
…		…
298		425
299	"displaybootmenu" : 0,	426	"displaybootmenu" : 0,
300		427
301	=item integer	428	=item integer
302		429
303	Again, very simple, this is a 64 bit integer. IT can be either specified	430	Again, very simple, this is a 64 bit integer. It can be either specified
304	as a decimal number, as a hex number (by prefixing it with C<0x>) or as a	431	as a decimal number, as a hex number (by prefixing it with C<0x>) or as a
305	binatry number (prefix C<0b>).	432	binary number (prefix C<0b>).
306		433
307	For example, the boot C<timeout> is an integer, specifying the automatic	434	For example, the boot C<timeout> is an integer, specifying the automatic
308	boot delay in seconds:	435	boot delay in seconds:
309		436
310	"timeout" : 30,	437	"timeout" : 30,
311		438
312	=item integer list	439	=item integer list
313		440
314	This is a list of 64 bit integers separated by whitespace. It is not used	441	This is a list of 64 bit integers separated by whitespace. It is not used
315	much, so here is a somewhat artificial an untested exanmple of using	442	much, so here is a somewhat artificial and untested example of using
316	C<customactions> to specify a certain custom, eh, action to be executed	443	C<customactions> to specify a certain custom, eh, action to be executed
317	when pressing C<F10> at boot:	444	when pressing C<F10> at boot:
318		445
319	"customactions" : "0x1000044000001 0x54000001",	446	"customactions" : "0x1000044000001 0x54000001",
320		447
321	=item guid	448	=item guid
322		449
323	This represents a single GUID value wrqapped in curly braces. It is used a	450	This represents a single GUID value wrapped in curly braces. It is used a
324	lot to refer from one BCD object to other one.	451	lot to refer from one BCD object to other one.
325		452
326	For example, The C<{bootmgr}> object might refer to a resume boot option	453	For example, The C<{bootmgr}> object might refer to a resume boot option
327	using C<resumeobject>:	454	using C<default>:
328		455
329	"resumeobject" : "{7ae02178-821d-11e7-8813-1c872c5f5ab0}",	456	"default" : "{7ae02178-821d-11e7-8813-1c872c5f5ab0}",
330		457
331	Human readable aliases are used and allowed.	458	Human readable aliases are used and allowed.
332		459
333	=item guid list	460	=item guid list
334		461
335	Similar to te guid type, this represents a list of such GUIDs, separated	462	Similar to the GUID type, this represents a list of such GUIDs, separated
336	by whitespace from each other.	463	by whitespace from each other.
337		464
338	For example, many BCD objects can I<inherit> elements from other BCD	465	For example, many BCD objects can I<inherit> elements from other BCD
339	objects by specifying the GUIDs of those other objects ina GUID list	466	objects by specifying the GUIDs of those other objects in a GUID list
340	called surprisingly called C<inherit>:	467	called surprisingly called C<inherit>:
341		468
342	"inherit" : "{dbgsettings} {emssettings} {badmemory}",	469	"inherit" : "{dbgsettings} {emssettings} {badmemory}",
343		470
344	This example also shows how human readable aliases can be used.	471	This example also shows how human readable aliases can be used.
…		…
348	This type is why I write I<most> are easy to explain earlier: This type	475	This type is why I write I<most> are easy to explain earlier: This type
349	is the pinnacle of Microsoft-typical hacks layered on top of other	476	is the pinnacle of Microsoft-typical hacks layered on top of other
350	hacks. Understanding this type took more time than writing all the rest of	477	hacks. Understanding this type took more time than writing all the rest of
351	PBCDEDIT, and because it is so complex, this type has its own subsection	478	PBCDEDIT, and because it is so complex, this type has its own subsection
352	below.	479	below.
		480
353	=back	481	=back
354		482
355	=head4 The BCD "device" element type	483	=head3 The BCD "device" element type
356		484
357	Device elements specify, well, devices. They are used for such diverse	485	Device elements specify, well, devices. They are used for such diverse
358	purposes such as finding a TFTP network boot imagem serial ports or VMBUS	486	purposes such as finding a TFTP network boot image, serial ports or VMBUS
359	devices, but most commonly they are used to specify the disk (harddisk,	487	devices, but most commonly they are used to specify the disk (harddisk,
360	cdrom ramdisk, vhd...) to boot from.	488	cdrom, ramdisk, vhd...) to boot from.
361		489
362	The device element is kind of a mini-language in its own which is much	490	The device element is kind of a mini-language in its own which is much
363	more versatile then the limited windows interface to it - BCDEDIT -	491	more versatile then the limited windows interface to it - BCDEDIT -
364	reveals.	492	reveals.
365		493
…		…
368	element, so almost everything known about it had to be researched first	496	element, so almost everything known about it had to be researched first
369	in the process of writing this script, and consequently, support for BCD	497	in the process of writing this script, and consequently, support for BCD
370	device elements is partial only.	498	device elements is partial only.
371		499
372	On the other hand, the expressive power of PBCDEDIT in specifying devices	500	On the other hand, the expressive power of PBCDEDIT in specifying devices
373	is much bigger than BCDEDIT and therefore more cna be don with it. The	501	is much greater than BCDEDIT and therefore more can be done with it. The
374	downside is that BCD device elements are much more complicated than what	502	downside is that BCD device elements are much more complicated than what
375	you might think from reading the BCDEDIT documentation.	503	you might think from reading the BCDEDIT documentation.
376		504
377	In other words, simple things are complicated, and complicated things are	505	In other words, simple things are complicated, and complicated things are
378	possible.	506	possible.
379		507
380	Anyway, the general syntax of device elements is an optional GUID,	508	Anyway, the general syntax of device elements is an optional GUID,
381	followed by a device type, optionally followed by hexdecimal flags in	509	followed by a device type, optionally followed by hexadecimal flags in
382	angle brackets, optionally followed by C<=> and a comma-separated list of	510	angle brackets, optionally followed by C<=> and a comma-separated list of
383	arguments, some of which can be (and often are) in turn devices again.	511	arguments, some of which can be (and often are) in turn devices again.
384		512
385	[{GUID}]type[<flags>][=arg,arg...]	513	[{GUID}]type[<flags>][=arg,arg...]
386		514
387	Here are some examples:	515	Here are some examples:
388		516
389	boot	517	boot
390	{b097d29f-bc00-11e9-8a9a-525400123456}block=file,<boot>,\\EFI"	518	{b097d29f-bc00-11e9-8a9a-525400123456}block=file,<boot>,\EFI
391	locate=<null>,element,systemroot	519	locate=<null>,element,systemroot
392	partition=<null>,harddisk,mbr,47cbc08a,1048576	520	partition=<null>,harddisk,mbr,47cbc08a,1048576
393	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd	521	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd
394	block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,68720525312>,0,0,0,\Recovery\b097d29e-bc00-11e9-8a9a-525400123456\Winre.wim	522	block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,68720525312>,0,0,0,\Recovery\b097d29e-bc00-11e9-8a9a-525400123456\Winre.wim
395	block=file,<partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,ee3a393a-f0de-4057-9946-88584245ed48>,\	523	block=file,<partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,ee3a393a-f0de-4057-9946-88584245ed48>,\
…		…
412	The types understood and used by PBCDEDIT are as follows (keep in mind	540	The types understood and used by PBCDEDIT are as follows (keep in mind
413	that not of all the following is necessarily supported in PBCDEDIT):	541	that not of all the following is necessarily supported in PBCDEDIT):
414		542
415	=over	543	=over
416		544
417	=item binary=hex...	545	=item C<binary=>I<hex...>
418		546
419	This type isn't actually a real BCD element type, but a fallback for those	547	This type isn't actually a real BCD element type, but a fallback for those
420	cases where PBCDEDIT can't perfectly decode a device element (except for	548	cases where PBCDEDIT can't perfectly decode a device element (except for
421	the leading GUID, which it can always decode). In such cases, it will	549	the leading GUID, which it can always decode). In such cases, it will
422	convert the device into this type with a hexdump of the element data.	550	convert the device into this type with a hexdump of the element data.
423		551
424	=item null	552	=item C<null>
425		553
426	This is another special type - sometimes, a device all zero-filled, which	554	This is another special type - sometimes, a device is all zero-filled,
427	is not valid. This can mark the absence of a device or something PBCDEDIT	555	which is not valid. This can mark the absence of a device or something
428	does not understand, so it decodes it into this special "all zero" type	556	PBCDEDIT does not understand, so it decodes it into this special "all
429	called C<null>.	557	zero" type called C<null>.
430		558
431	It's most commonly found in devices that can use an optional parent	559	It's most commonly found in devices that can use an optional parent
432	device, when no parent device is used.	560	device, when no parent device is used.
433		561
434	=item boot	562	=item C<boot>
435		563
436	Another type without parameters, this refers to the device that was booted	564	Another type without parameters, this refers to the device that was booted
437	from (nowadays typically the EFI system partition).	565	from (nowadays typically the EFI system partition).
438		566
439	=item vmbus=interfacetype,interfaceinstance	567	=item C<vmbus=>I<interfacetype>,I<interfaceinstance>
440		568
441	This specifies a VMBUS device with the given interface type and interface	569	This specifies a VMBUS device with the given interface type and interface
442	instance, both of which are "naked" (no curly braces) GUIDs.	570	instance, both of which are "naked" (no curly braces) GUIDs.
443		571
444	Made-up example (couldn't find a single example on the web):	572	Made-up example (couldn't find a single example on the web):
445		573
446	vmbus=c376c1c3-d276-48d2-90a9-c04748072c60,12345678-a234-b234-c234-d2345678abcd	574	vmbus=c376c1c3-d276-48d2-90a9-c04748072c60,12345678-a234-b234-c234-d2345678abcd
447		575
448	=item partition=<parent>,devicetype,partitiontype,diskid,partitionid	576	=item C<partition=><I<parent>>,I<devicetype>,I<partitiontype>,I<diskid>,I<partitionid>
449		577
450	This designates a specific partition on a block device. C<< <parent>	578	This designates a specific partition on a block device. I<parent> is an
451	>> is an optional parent device on which to search on, and is often	579	optional parent device on which to search on, and is often C<null>. Note
452	C<null>. Note that the anfgle brackets are part of the syntax.	580	that the angle brackets around I<parent> are part of the syntax.
453		581
454	C<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,	582	I<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,
455	C<file> or C<vhd>, where the first three should be self-explaining,	583	C<file> or C<vhd>, where the first three should be self-explaining,
456	C<file> is usually used to locate a device by finding a magic file, and	584	C<file> is usually used to locate a file to be used as a disk image,
457	C<vhd> is used for virtual harddisks - F<.vhd> and F<-vhdx> files.	585	and C<vhd> is used to treat files as virtual harddisks, i.e. F<vhd> and
		586	F<vhdx> files.
458		587
459	The C<partitiontype> is either C<mbr>, C<gpt> or C<raw>, the latter being	588	The I<partitiontype> is either C<mbr>, C<gpt> or C<raw>, the latter being
460	used for devices without partitions, such as cdroms, where the "partition"	589	used for devices without partitions, such as cdroms, where the "partition"
461	is usually the whole device.	590	is usually the whole device.
462		591
463	The C<diskid> identifies the disk or device using a unique signature, and	592	The I<diskid> identifies the disk or device using a unique signature, and
464	the same is true for the C<partitionid>. How these are interpreted depends	593	the same is true for the I<partitionid>. How these are interpreted depends
465	on the C<partitiontype>:	594	on the I<partitiontype>:
466		595
467	=over	596	=over
468		597
469	=item mbr	598	=item C<mbr>
470		599
471	The C<diskid> is the 32 bit disk signature stored at offset 0x1b8 in the	600	The C<diskid> is the 32 bit disk signature stored at offset 0x1b8 in the
472	MBR, interpreted as a 32 bit unsigned little endian integer and written as	601	MBR, interpreted as a 32 bit unsigned little endian integer and written as
473	hex number. That is, the bytes C<01 02 03 04> would become C<04030201>.	602	hex number. That is, the bytes C<01 02 03 04> would become C<04030201>.
474		603
475	Diskpart (using the C<DETAIL> command) and the C<lsblk> comamnd typically	604	Diskpart (using the C<DETAIL> command) and the C<lsblk> command typically
476	found on GNU/Linux systems (using e.g. C<lsblk -o NAME,PARTUUID>) can	605	found on GNU/Linux systems (using e.g. C<lsblk -o NAME,PARTUUID>) can
477	display the disk id.	606	display the I<diskid>.
478		607
479	The C<partitionid> is the byte offset(!) of the partition counting from	608	The I<partitionid> is the byte offset(!) of the partition counting from
480	the beginning of the MBR.	609	the beginning of the MBR.
481		610
482	Example, use the partition on the harddisk with C<diskid> C<47cbc08a>	611	Example, use the partition on the harddisk with I<diskid> C<47cbc08a>
483	starting at sector C<2048> (= 1048576 / 512).	612	starting at sector C<2048> (= 1048576 / 512).
484		613
485	partition=<null>,harddisk,mbr,47cbc08a,1048576	614	partition=<null>,harddisk,mbr,47cbc08a,1048576
486		615
487	=item gpt	616	=item C<gpt>
488		617
489	The C<diskid> is the disk UUID/disk identifier GUID from the partition	618	The I<diskid> is the disk GUID/disk identifier GUID from the partition
490	table (as displayed e.g. by C<gdisk>), and the C<partitionid> is the	619	table (as displayed e.g. by F<gdisk>), and the I<partitionid> is the
491	partition unique GUID (displayed using e.g. the C<gdisk> C<i> command).	620	partition unique GUID (displayed using e.g. the F<gdisk> F<i> command).
492		621
493	Example: use the partition C<76d39e5f-ad1b-407e-9c05-c81eb83b57dd> on GPT	622	Example: use the partition C<76d39e5f-ad1b-407e-9c05-c81eb83b57dd> on GPT
494	disk C<9742e468-9206-48a0-b4e4-c4e9745a356a>.	623	disk C<9742e468-9206-48a0-b4e4-c4e9745a356a>.
495		624
496	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd	625	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd
497		626
498	=item raw	627	=item C<raw>
499		628
500	Instead of diskid and partitionid, this type only accepts a decimal disk	629	Instead of I<diskid> and I<partitionid>, this type only accepts a decimal
501	number and signifies the whole disk. BCDEDIT cannot display the resulting	630	disk number and signifies the whole disk. BCDEDIT cannot display the
502	device, and I am doubtful whether it has a useful effect.	631	resulting device, and I am doubtful whether it has a useful effect.
503		632
504	=back	633	=back
505		634
506	=item legacypartition=<parent>,devicetype,partitiontype,diskid,partitionid	635	=item C<legacypartition=><I<parent>>,I<devicetype>,I<partitiontype>,I<diskid>,I<partitionid>
507		636
508	This is exactly the same as the C<partition> type, except for a tiny	637	This is exactly the same as the C<partition> type, except for a tiny
509	detail: instead of using the partition start offset, this type uses the	638	detail: instead of using the partition start offset, this type uses the
510	partition number for MBR disks. Behaviour other partition types should be	639	partition number for MBR disks. Behaviour other partition types should be
511	the same.	640	the same.
512		641
513	The partition number starts at C<1> and skips unused partition, so if	642	The partition number starts at C<1> and skips unused partition, so if
514	there are two primary partitions and another partition inside the extended	643	there are two primary partitions and another partition inside the extended
515	partition, the primary partitions are number C<1> and C<2> and the	644	partition, the primary partitions are number C<1> and C<2> and the
516	partition inside the extended partition is number C<3>, rwegardless of any	645	partition inside the extended partition is number C<3>, regardless of any
517	gaps.	646	gaps.
518		647
519	=item locate=<parent>,locatetype,locatearg	648	=item C<locate=><I<parent>>,I<locatetype>,I<locatearg>
520		649
521	This device description will make the bootloader search for a partition	650	This device description will make the bootloader search for a partition
522	with a given path.	651	with a given path.
523		652
524	The C<< <parent> >> device is the device to search on (angle brackets are	653	The I<parent> device is the device to search on (angle brackets are
525	still part of the syntax!) If it is C<< <null> >>, then C<locate> will	654	still part of the syntax!) If it is C<null>, then C<locate> will
526	search all disks it can find.	655	search all disks it can find.
527		656
528	C<locatetype> is either C<element> or C<path>, and merely distinguishes	657	I<locatetype> is either C<element> or C<path>, and merely distinguishes
529	between two different ways to specify the path to search for: C<element>	658	between two different ways to specify the path to search for: C<element>
530	uses an element ID (either as hex or as name) as C<locatearg> and C<path>	659	uses an element ID (either as hex or as name) as I<locatearg> and C<path>
531	uses a relative path as C<locatearg>.	660	uses a relative path as I<locatearg>.
532		661
533	Example: find any partition which has the C<magicfile.xxx> path in the	662	Example: find any partition which has the F<magicfile.xxx> path in the
534	root.	663	root.
535		664
536	locate=<null>,path,\magicfile.xxx	665	locate=<null>,path,\magicfile.xxx
537		666
538	Example: find any partition which has the path specified in the	667	Example: find any partition which has the path specified in the
539	C<systemroot> element (typically C<\Windows>).	668	C<systemroot> element (typically F<\Windows>).
540		669
541	locate=<null>,element,systemroot	670	locate=<null>,element,systemroot
542		671
543	=item block=devicetype,args...	672	=item C<block=>I<devicetype>,I<args...>
544		673
545	Last not least, the most complex type, C<block>, which... specifies block	674	Last not least, the most complex type, C<block>, which... specifies block
546	devices (which could be inside a F<vhdx> file for example).	675	devices (which could be inside a F<vhdx> file for example).
547		676
548	C<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,	677	I<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,
549	C<file> or C<vhd> - the same as for C<partiion=>.	678	C<file> or C<vhd> - the same as for C<partition=>.
550		679
551	The remaining arguments change depending on the C<devicetype>:	680	The remaining arguments change depending on the I<devicetype>:
552		681
553	=over	682	=over
554		683
555	=item block=file,<parent>,path	684	=item C<block=file>,<I<parent>>,I<path>
556		685
557	Interprets the C<< <parent> >> device (typically a partition) as a	686	Interprets the I<parent> device (typically a partition) as a
558	filesystem and specifies a file path inside.	687	filesystem and specifies a file path inside.
559		688
560	=item block=vhd,<parent>	689	=item C<block=vhd>,<I<parent>>
561		690
562	Pretty much just changes the interpretation of C<< <parent> >>, which is	691	Pretty much just changes the interpretation of I<parent>, which is
563	usually a disk image (C<block=file,...)>) to be a F<vhd> or F<vhdx> file.	692	usually a disk image (C<block=file,...)>) to be a F<vhd> or F<vhdx> file.
564		693
565	=item block=ramdisk,<parent>,base,size,offset,path	694	=item C<block=ramdisk>,<I<parent>>,I<base>,I<size>,I<offset>,I<path>
566		695
567	Interprets the C<< <parent> >> device as RAM disk, using the (decimal)	696	Interprets the I<parent> device as RAM disk, using the (decimal)
568	base address, byte size and byte offset inside a file specified by	697	base address, byte size and byte offset inside a file specified by
569	C<path>. The numbers are usually all C<0> because they cna be extracted	698	I<path>. The numbers are usually all C<0> because they can be extracted
570	from the RAM disk image or other parameters.	699	from the RAM disk image or other parameters.
571		700
572	This is most commonly used to boot C<wim> images.	701	This is most commonly used to boot C<wim> images.
573		702
574	=item block=floppy,drivenum	703	=item C<block=floppy>,I<drivenum>
575		704
576	Refers to a removable drive identified by a number. BCDEDIT cannot display	705	Refers to a removable drive identified by a number. BCDEDIT cannot display
577	the resultinfg device, and it is not clear what effect it will have.	706	the resulting device, and it is not clear what effect it will have.
578		707
579	=item block=cdrom,drivenum	708	=item C<block=cdrom>,I<drivenum>
580		709
581	Pretty much the same as C<floppy> but for CD-ROMs.	710	Pretty much the same as C<floppy> but for CD-ROMs.
582		711
583	=item anything else	712	=item anything else
584		713
585	Probably not yet implemented. Tell me of your needs...	714	Probably not yet implemented. Tell me of your needs...
586		715
587	=back	716	=back
588		717
589	=back5 Examples	718	=back
		719
		720	=head4 Examples
590		721
591	This concludes the syntax overview for device elements, but probably	722	This concludes the syntax overview for device elements, but probably
592	leaves many questions open. I can't help with most of them, as I also ave	723	leaves many questions open. I can't help with most of them, as I also have
593	many questions, but I can walk you through some actual examples using mroe	724	many questions, but I can walk you through some actual examples using more
594	complex aspects.	725	complex aspects.
595		726
		727	=over
		728
596	=item locate=<block=vhd,<block=file,<locate=<null>,path,\disk.vhdx>,\disk.vhdx>>,element,path	729	=item C<< locate=<block=vhd,<block=file,<locate=<null>,path,\disk.vhdx>,\disk.vhdx>>,element,path >>
597		730
598	#todo	731	Just like with C declarations, you best treat device descriptors as
		732	instructions to find your device and work your way from the inside out:
599		733
		734	locate=<null>,path,\disk.vhdx
		735
		736	First, the innermost device descriptor searches all partitions on the
		737	system for a file called F<\disk.vhdx>:
		738
		739	block=file,<see above>,\disk.vhdx
		740
		741	Next, this takes the device locate has found and finds a file called
		742	F<\disk.vhdx> on it. This is the same file locate was using, but that is
		743	only because we find the device using the same path as finding the disk
		744	image, so this is purely incidental, although quite common.
		745
		746	Next, this file will be opened as a virtual disk:
		747
		748	block=vhd,<see above>
		749
		750	And finally, inside this disk, another C<locate> will look for a partition
		751	with a path as specified in the C<path> element, which most likely will be
		752	F<\Windows\system32\winload.exe>:
		753
		754	locate=<see above>,element,path
		755
		756	As a result, this will boot the first Windows it finds on the first
		757	F<disk.vhdx> disk image it can find anywhere.
		758
600	=item locate=<block=vhd,<block=file,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,\win10.vhdx>>,element,path	759	=item C<< locate=<block=vhd,<block=file,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,\win10.vhdx>>,element,path >>
601		760
602	#todo	761	Pretty much the same as the previous case, but with a bit of
		762	variance. First, look for a specific partition on an MBR-partitioned disk:
603		763
		764	partition=<null>,harddisk,mbr,47cbc08a,242643632128
		765
		766	Then open the file F<\win10.vhdx> on that partition:
		767
		768	block=file,<see above>,\win10.vhdx
		769
		770	Then, again, the file is opened as a virtual disk image:
		771
		772	block=vhd,<see above>
		773
		774	And again the windows loader (or whatever is in C<path>) will be searched:
		775
		776	locate=<see above>,element,path
		777
604	=item {b097d2b2-bc00-11e9-8a9a-525400123456}block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,0,0,0,\boot.wim	778	=item C<< {b097d2b2-bc00-11e9-8a9a-525400123456}block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,0,0,0,\boot.wim >>
605		779
606	#todo	780	This is quite different. First, it starts with a GUID. This GUID belongs
		781	to a BCD object of type C<device>, which has additional parameters:
		782
		783	"{b097d2b2-bc00-11e9-8a9a-525400123456}" : {
		784	"type" : "device",
		785	"description" : "sdi file for ramdisk",
		786	"ramdisksdidevice" : "partition=<null>,harddisk,mbr,47cbc08a,1048576",
		787	"ramdisksdipath" : "\boot.sdi"
		788	},
		789
		790	I will not go into many details, but this specifies a (presumably empty)
		791	template ramdisk image (F<\boot.sdi>) that is used to initialize the
		792	ramdisk. The F<\boot.wim> file is then extracted into it. As you can also
		793	see, this F<.sdi> file resides on a different C<partition>.
		794
		795	Continuing, as always, from the inside out, first this device descriptor
		796	finds a specific partition:
		797
		798	partition=<null>,harddisk,mbr,47cbc08a,242643632128
		799
		800	And then specifies a C<ramdisk> image on this partition:
		801
		802	block<1>=ramdisk,<see above>,0,0,0,\boot.wim
		803
		804	I don't know what the purpose of the C<< <1> >> flag value is, but it
		805	seems to be always there on this kind of entry.
		806
		807	If you have some good examples to add here, feel free to mail me.
		808
		809	=back
		810
		811
		812	=head1 EDITING BCD STORES
		813
		814	The C<edit> and C<parse> subcommands allow you to read a BCD data store
		815	and modify it or extract data from it. This is done by executing a series
		816	of "editing instructions" which are explained here.
		817
		818	=over
		819
		820	=item C<get> I<object> I<element>
		821
		822	Reads the BCD element I<element> from the BCD object I<object> and writes
		823	it to standard output, followed by a newline. The I<object> can be a GUID
		824	or a human-readable alias, or the special string C<{default}>, which will
		825	refer to the default BCD object.
		826
		827	Example: find description of the default BCD object.
		828
		829	pbcdedit parse BCD get "{default}" description
		830
		831	=item C<set> I<object> I<element> I<value>
		832
		833	Similar to C<get>, but sets the element to the given I<value> instead.
		834
		835	Example: change the bootmgr default too
		836	C<{b097d2ad-bc00-11e9-8a9a-525400123456}>:
		837
		838	pbcdedit edit BCD set "{bootmgr}" default "{b097d2ad-bc00-11e9-8a9a-525400123456}"
		839
		840	=item C<del> I<object> I<element>
		841
		842	Similar to C<get>, but removed the BCD element from the specified BCD object.
		843
		844	=item C<eval> I<perlcode>
		845
		846	This takes the next argument, interprets it as Perl code and
		847	evaluates it. This allows you to do more complicated modifications or
		848	extractions.
		849
		850	The following variables are predefined for your use:
		851
		852	=over
		853
		854	=item C<$PATH>
		855
		856	The path to the BCD data store, as given to C<edit> or C<parse>.
		857
		858	=item C<$BCD>
		859
		860	The decoded BCD data store.
		861
		862	=item C<$DEFAULT>
		863
		864	The default BCD object name.
		865
		866	=back
		867
		868	The example given for C<get>, above, could be expressed like this with
		869	C<eval>:
		870
		871	pbcdedit edit BCD eval 'say $BCD->{$DEFAULT}{description}'
		872
		873	The example given for C<set> could be expressed like this:
		874
		875	pbcdedit edit BCD eval '$BCD->{"{bootmgr}"{default} = "{b097d2ad-bc00-11e9-8a9a-525400123456}"'
		876
		877	=item C<do> I<path>
		878
		879	Similar to C<eval>, above, but instead of using the argument as perl code,
		880	it loads the perl code from the given file and executes it. This makes it
		881	easier to write more complicated or larger programs.
		882
		883	=back
607		884
608		885
609	=head1 SEE ALSO	886	=head1 SEE ALSO
610		887
611	For ideas on what you can do, and some introductory material, try	888	For ideas on what you can do with BCD stores in
		889	general, and some introductory material, try
612	L<http://www.mistyprojects.co.uk/documents/BCDEdit/index.html>.	890	L<http://www.mistyprojects.co.uk/documents/BCDEdit/index.html>.
613		891
614	For good reference on BCD objects and elements, see Geoff Chappels pages	892	For good reference on which BCD objects and
		893	elements exist, see Geoff Chappell's pages at
615	at L<http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm>.	894	L<http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm>.
616		895
617	=head1 AUTHOR	896	=head1 AUTHOR
618		897
619	Written by Marc A. Lehmann <pbcdedit@schmorp.de>.	898	Written by Marc A. Lehmann L<pbcdedit@schmorp.de>.
620		899
621	=head1 REPORTING BUGS	900	=head1 REPORTING BUGS
622		901
623	Bugs can be reported dorectly tt he author at L<pcbedit@schmorp.de>.	902	Bugs can be reported directly the author at L<pcbedit@schmorp.de>.
624		903
625	=head1 BUGS AND SHORTCOMINGS	904	=head1 BUGS AND SHORTCOMINGS
626		905
627	This should be a module. Of a series of modules, even.	906	This should be a module. Of a series of modules, even.
628		907
629	Registry code should preserve classname and security descriptor data, and	908	Registry code should preserve classname and security descriptor data, and
630	whatever else is necessary to read and write any registry hive file.	909	whatever else is necessary to read and write any registry hive file.
631		910
632	I am also not happy with device descriptors being strings rather than a	911	I am also not happy with device descriptors being strings rather than a
633	data structure, but strings are probably better for command line usage. In	912	data structure, but strings are probably better for command line usage. In
634	any case,. device descriptors could be converted by simply "splitting" at	913	any case, device descriptors could be converted by simply "splitting" at
635	"=" and "," into an array reference, recursively.	914	"=" and "," into an array reference, recursively.
636		915
637	=head1 HOMEPAGE	916	=head1 HOMEPAGE
638		917
639	Original versions of this program can be found at	918	Original versions of this program can be found at
…		…
646	free to change and redistribute it. There is NO WARRANTY, to the extent	925	free to change and redistribute it. There is NO WARRANTY, to the extent
647	permitted by law.	926	permitted by law.
648		927
649	=cut	928	=cut
650		929
651	BEGIN { require "common/sense.pm"; common::sense->import } # common sense is optional, but recommended	930	# common sense is optional, but recommended
		931	BEGIN { eval { require "common/sense.pm"; } && common::sense->import }
652		932
653	use Data::Dump;	933	no warnings 'portable'; # avoid 32 bit integer warnings
		934
654	use Encode ();	935	use Encode ();
655	use List::Util ();	936	use List::Util ();
656	use IO::Handle ();	937	use IO::Handle ();
657	use Time::HiRes ();	938	use Time::HiRes ();
658		939
…		…
669	sub xxd($$) {	950	sub xxd($$) {
670	open my $xxd, "| xxd | sed -e 's/^/\Q$_[0]\E: /'";	951	open my $xxd, "| xxd | sed -e 's/^/\Q$_[0]\E: /'";
671	syswrite $xxd, $_[1];	952	syswrite $xxd, $_[1];
672	}	953	}
673		954
		955	# get some meta info on a file (uid, gid, perms)
		956	sub stat_get($) {
		957	[(stat shift)[4, 5, 2]]
		958	}
		959
		960	# set stat info on a file
		961	sub stat_set($$) {
		962	my ($fh_or_path, $stat) = @_;
		963
		964	return unless $stat;
		965	chown $stat->[0], $stat->[1], $fh_or_path;
		966	chmod +($stat->[2] & 07777), $fh_or_path;
		967	}
		968
		969	sub file_load($) {
		970	my ($path) = @_;
		971
		972	open my $fh, "<:raw", $path
		973	or die "$path: $!\n";
		974	my $size = -s $fh;
		975	$size = read $fh, my $buf, $size
		976	or die "$path: short read\n";
		977
		978	$buf
		979	}
		980
		981	sub file_save($$;$) {
		982	my ($path, $data, $stat) = @_;
		983
		984	open my $fh, ">:raw", "$path~"
		985	or die "$path~: $!\n";
		986	print $fh $data
		987	or die "$path~: short write\n";
		988	stat_set $fh, $stat;
		989	$fh->sync;
		990	close $fh;
		991
		992	rename "$path~", $path;
		993	}
		994
674	# sources and resources used for this:	995	# sources and resources used for writing pbcdedit
		996	#
675	# registry:	997	# registry:
676	# https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md	998	# https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md
677	# http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/	999	# http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/
678	# bcd:	1000	# bcd:
679	# http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm	1001	# http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm
…		…
861	my ($rname, $root) = $decode_key->($rootcell);	1183	my ($rname, $root) = $decode_key->($rootcell);
862		1184
863	[$rname, $root]	1185	[$rname, $root]
864	}	1186	}
865		1187
866	# return a binary windows fILETIME struct	1188	# return a binary windows FILETIME struct
867	sub filetime_now {	1189	sub filetime_now {
868	my ($s, $ms) = Time::HiRes::gettimeofday;	1190	my ($s, $ms) = Time::HiRes::gettimeofday;
869		1191
870	pack "Q<", $s = ($s * 1_000_000 + $ms) * 10 + 116_444_736_000_000_000	1192	pack "Q<", ($s * 1_000_000 + $ms) * 10
		1193	+ 116_444_736_000_000_000 # 1970-01-01 00:00:00
871	}	1194	}
872		1195
873	# encode a registry hive	1196	# encode a registry hive
874	sub regf_encode($) {	1197	sub regf_encode($) {
875	my ($hive) = @_;	1198	my ($hive) = @_;
…		…
878		1201
879	# the filetime is apparently used to verify log file validity,	1202	# the filetime is apparently used to verify log file validity,
880	# so by generating a new timestamp the log files *should* automatically	1203	# so by generating a new timestamp the log files *should* automatically
881	# become invalidated and windows would "self-heal" them.	1204	# become invalidated and windows would "self-heal" them.
882	# (update: has been verified by reverse engineering)	1205	# (update: has been verified by reverse engineering)
883	# possibly the fact that the two sequence numbes match might also	1206	# possibly the fact that the two sequence numbers match might also
884	# make windows think that the hive is not dirty and ignore logs.	1207	# make windows think that the hive is not dirty and ignore logs.
885	# (update: has been verified by reverse engineering)	1208	# (update: has been verified by reverse engineering)
886		1209
887	my $now = filetime_now;	1210	my $now = filetime_now;
888		1211
…		…
1027	}	1350	}
1028		1351
1029	# load and parse registry from file	1352	# load and parse registry from file
1030	sub regf_load($) {	1353	sub regf_load($) {
1031	my ($path) = @_;	1354	my ($path) = @_;
1032	open my $regf, "<:raw", $path
1033	or die "$path: $!\n";
1034	my $size = -s $regf;
1035	$size = read $regf, my $buf, $size
1036	or die "$path: short read\n";
1037		1355
1038	regf_decode $buf	1356	regf_decode file_load $path
1039	}	1357	}
1040		1358
1041	# encode and save registry to file	1359	# encode and save registry to file
1042	sub regf_save {	1360	sub regf_save($$;$) {
1043	my ($path, $hive) = @_;	1361	my ($path, $hive, $stat) = @_;
1044		1362
1045	$hive = regf_encode $hive;	1363	$hive = regf_encode $hive;
1046		1364
1047	open my $regf, ">:raw", "$path~"	1365	file_save $path, $hive, $stat;
1048	or die "$path~: $!\n";
1049	print $regf $hive
1050	or die "$path~: short write\n";
1051	$regf->sync;
1052	close $regf;
1053
1054	rename "$path~", $path;
1055	}	1366	}
1056		1367
1057	#############################################################################	1368	#############################################################################
1058	# bcd stuff	1369	# bcd stuff
1059		1370
1060	# human-readable alises for GUID object identifiers	1371	# human-readable aliases for GUID object identifiers
1061	our %bcd_objects = (	1372	our %bcd_objects = (
1062	'{0ce4991b-e6b3-4b16-b23c-5e0d9250e5d9}' => '{emssettings}',	1373	'{0ce4991b-e6b3-4b16-b23c-5e0d9250e5d9}' => '{emssettings}',
1063	'{1afa9c49-16ab-4a5c-4a90-212802da9460}' => '{resumeloadersettings}',	1374	'{1afa9c49-16ab-4a5c-4a90-212802da9460}' => '{resumeloadersettings}',
1064	'{1cae1eb7-a0df-4d4d-9851-4860e34ef535}' => '{default}',	1375	'{1cae1eb7-a0df-4d4d-9851-4860e34ef535}' => '{default}',
1065	'{313e8eed-7098-4586-a9bf-309c61f8d449}' => '{kerneldbgsettings}',	1376	'{313e8eed-7098-4586-a9bf-309c61f8d449}' => '{kerneldbgsettings}',
…		…
1172	sub BCDE_FORMAT_GUID_LIST () { 0x04000000 }	1483	sub BCDE_FORMAT_GUID_LIST () { 0x04000000 }
1173	sub BCDE_FORMAT_INTEGER () { 0x05000000 }	1484	sub BCDE_FORMAT_INTEGER () { 0x05000000 }
1174	sub BCDE_FORMAT_BOOLEAN () { 0x06000000 }	1485	sub BCDE_FORMAT_BOOLEAN () { 0x06000000 }
1175	sub BCDE_FORMAT_INTEGER_LIST () { 0x07000000 }	1486	sub BCDE_FORMAT_INTEGER_LIST () { 0x07000000 }
1176		1487
1177	sub dec_device;
1178	sub enc_device;
1179
1180	sub enc_integer($) {	1488	sub enc_integer($) {
1181	no warnings 'portable'; # ugh
1182	my $value = shift;	1489	my $value = shift;
1183	$value = oct $value if $value =~ /^0[bBxX]/;	1490	$value = oct $value if $value =~ /^0[bBxX]/;
1184	unpack "H*", pack "Q<", $value	1491	unpack "H*", pack "Q<", $value
1185	}	1492	}
		1493
		1494	sub enc_device($$);
		1495	sub dec_device($$);
1186		1496
1187	our %bcde_dec = (	1497	our %bcde_dec = (
1188	BCDE_FORMAT_DEVICE , \&dec_device,	1498	BCDE_FORMAT_DEVICE , \&dec_device,
1189	# # for round-trip verification	1499	# # for round-trip verification
1190	# BCDE_FORMAT_DEVICE , sub {	1500	# BCDE_FORMAT_DEVICE , sub {
…		…
1196	BCDE_FORMAT_STRING , sub { shift },	1506	BCDE_FORMAT_STRING , sub { shift },
1197	BCDE_FORMAT_GUID , sub { dec_wguid enc_wguid shift },	1507	BCDE_FORMAT_GUID , sub { dec_wguid enc_wguid shift },
1198	BCDE_FORMAT_GUID_LIST , sub { join " ", map dec_wguid enc_wguid $_, @{+shift} },	1508	BCDE_FORMAT_GUID_LIST , sub { join " ", map dec_wguid enc_wguid $_, @{+shift} },
1199	BCDE_FORMAT_INTEGER , sub { unpack "Q", pack "a8", pack "H*", shift }, # integer might be 4 or 8 bytes - caused by ms coding bugs	1509	BCDE_FORMAT_INTEGER , sub { unpack "Q", pack "a8", pack "H*", shift }, # integer might be 4 or 8 bytes - caused by ms coding bugs
1200	BCDE_FORMAT_BOOLEAN , sub { shift eq "00" ? 0 : 1 },	1510	BCDE_FORMAT_BOOLEAN , sub { shift eq "00" ? 0 : 1 },
1201	BCDE_FORMAT_INTEGER_LIST, sub { join " ", unpack "Q*", pack "H*", shift }, # not sure if this cna be 4 bytes	1511	BCDE_FORMAT_INTEGER_LIST, sub { join " ", unpack "Q*", pack "H*", shift }, # not sure if this can be 4 bytes
1202	);	1512	);
1203		1513
1204	our %bcde_enc = (	1514	our %bcde_enc = (
1205	BCDE_FORMAT_DEVICE , sub { binary => enc_device shift },	1515	BCDE_FORMAT_DEVICE , sub { binary => enc_device $_[0], $_[1] },
1206	BCDE_FORMAT_STRING , sub { sz => shift },	1516	BCDE_FORMAT_STRING , sub { sz => shift },
1207	BCDE_FORMAT_GUID , sub { sz => "{" . (dec_guid enc_wguid shift) . "}" },	1517	BCDE_FORMAT_GUID , sub { sz => "{" . (dec_guid enc_wguid shift) . "}" },
1208	BCDE_FORMAT_GUID_LIST , sub { multi_sz => [map "{" . (dec_guid enc_wguid $_) . "}", split /\s+/, shift ] },	1518	BCDE_FORMAT_GUID_LIST , sub { multi_sz => [map "{" . (dec_guid enc_wguid $_) . "}", split /\s+/, shift ] },
1209	BCDE_FORMAT_INTEGER , sub { binary => enc_integer shift },	1519	BCDE_FORMAT_INTEGER , sub { binary => enc_integer shift },
1210	BCDE_FORMAT_BOOLEAN , sub { binary => shift ? "01" : "00" },	1520	BCDE_FORMAT_BOOLEAN , sub { binary => shift ? "01" : "00" },
1211	BCDE_FORMAT_INTEGER_LIST, sub { binary => join "", map enc_integer $_, split /\s+/, shift },	1521	BCDE_FORMAT_INTEGER_LIST, sub { binary => join "", map enc_integer $_, split /\s+/, shift },
1212	);	1522	);
1213		1523
1214	# BCD Elements	1524	# BCD Elements
1215	our %bcde = (	1525	our %bcde_byclass = (
		1526	any => {
1216	0x11000001 => 'device',	1527	0x11000001 => 'device',
1217	0x12000002 => 'path',	1528	0x12000002 => 'path',
1218	0x12000004 => 'description',	1529	0x12000004 => 'description',
1219	0x12000005 => 'locale',	1530	0x12000005 => 'locale',
1220	0x14000006 => 'inherit',	1531	0x14000006 => 'inherit',
1221	0x15000007 => 'truncatememory',	1532	0x15000007 => 'truncatememory',
1222	0x14000008 => 'recoverysequence',	1533	0x14000008 => 'recoverysequence',
1223	0x16000009 => 'recoveryenabled',	1534	0x16000009 => 'recoveryenabled',
1224	0x1700000a => 'badmemorylist',	1535	0x1700000a => 'badmemorylist',
1225	0x1600000b => 'badmemoryaccess',	1536	0x1600000b => 'badmemoryaccess',
1226	0x1500000c => 'firstmegabytepolicy',	1537	0x1500000c => 'firstmegabytepolicy',
1227	0x1500000d => 'relocatephysical',	1538	0x1500000d => 'relocatephysical',
1228	0x1500000e => 'avoidlowmemory',	1539	0x1500000e => 'avoidlowmemory',
1229	0x1600000f => 'traditionalkseg',	1540	0x1600000f => 'traditionalkseg',
1230	0x16000010 => 'bootdebug',	1541	0x16000010 => 'bootdebug',
1231	0x15000011 => 'debugtype',	1542	0x15000011 => 'debugtype',
1232	0x15000012 => 'debugaddress',	1543	0x15000012 => 'debugaddress',
1233	0x15000013 => 'debugport',	1544	0x15000013 => 'debugport',
1234	0x15000014 => 'baudrate',	1545	0x15000014 => 'baudrate',
1235	0x15000015 => 'channel',	1546	0x15000015 => 'channel',
1236	0x12000016 => 'targetname',	1547	0x12000016 => 'targetname',
1237	0x16000017 => 'noumex',	1548	0x16000017 => 'noumex',
1238	0x15000018 => 'debugstart',	1549	0x15000018 => 'debugstart',
1239	0x12000019 => 'busparams',	1550	0x12000019 => 'busparams',
1240	0x1500001a => 'hostip',	1551	0x1500001a => 'hostip',
1241	0x1500001b => 'port',	1552	0x1500001b => 'port',
1242	0x1600001c => 'dhcp',	1553	0x1600001c => 'dhcp',
1243	0x1200001d => 'key',	1554	0x1200001d => 'key',
1244	0x1600001e => 'vm',	1555	0x1600001e => 'vm',
1245	0x16000020 => 'bootems',	1556	0x16000020 => 'bootems',
1246	0x15000022 => 'emsport',	1557	0x15000022 => 'emsport',
1247	0x15000023 => 'emsbaudrate',	1558	0x15000023 => 'emsbaudrate',
1248	0x12000030 => 'loadoptions',	1559	0x12000030 => 'loadoptions',
1249	0x16000040 => 'advancedoptions',	1560	0x16000040 => 'advancedoptions',
1250	0x16000041 => 'optionsedit',	1561	0x16000041 => 'optionsedit',
1251	0x15000042 => 'keyringaddress',	1562	0x15000042 => 'keyringaddress',
1252	0x11000043 => 'bootstatdevice',	1563	0x11000043 => 'bootstatdevice',
1253	0x12000044 => 'bootstatfilepath',	1564	0x12000044 => 'bootstatfilepath',
1254	0x16000045 => 'preservebootstat',	1565	0x16000045 => 'preservebootstat',
1255	0x16000046 => 'graphicsmodedisabled',	1566	0x16000046 => 'graphicsmodedisabled',
1256	0x15000047 => 'configaccesspolicy',	1567	0x15000047 => 'configaccesspolicy',
1257	0x16000048 => 'nointegritychecks',	1568	0x16000048 => 'nointegritychecks',
1258	0x16000049 => 'testsigning',	1569	0x16000049 => 'testsigning',
1259	0x1200004a => 'fontpath',	1570	0x1200004a => 'fontpath',
1260	0x1500004b => 'integrityservices',	1571	0x1500004b => 'integrityservices',
1261	0x1500004c => 'volumebandid',	1572	0x1500004c => 'volumebandid',
1262	0x16000050 => 'extendedinput',	1573	0x16000050 => 'extendedinput',
1263	0x15000051 => 'initialconsoleinput',	1574	0x15000051 => 'initialconsoleinput',
1264	0x15000052 => 'graphicsresolution',	1575	0x15000052 => 'graphicsresolution',
1265	0x16000053 => 'restartonfailure',	1576	0x16000053 => 'restartonfailure',
1266	0x16000054 => 'highestmode',	1577	0x16000054 => 'highestmode',
1267	0x16000060 => 'isolatedcontext',	1578	0x16000060 => 'isolatedcontext',
1268	0x15000065 => 'displaymessage',	1579	0x15000065 => 'displaymessage',
1269	0x15000066 => 'displaymessageoverride',	1580	0x15000066 => 'displaymessageoverride',
1270	0x16000068 => 'nobootuxtext',	1581	0x16000068 => 'nobootuxtext',
1271	0x16000069 => 'nobootuxprogress',	1582	0x16000069 => 'nobootuxprogress',
1272	0x1600006a => 'nobootuxfade',	1583	0x1600006a => 'nobootuxfade',
1273	0x1600006b => 'bootuxreservepooldebug',	1584	0x1600006b => 'bootuxreservepooldebug',
1274	0x1600006c => 'bootuxdisabled',	1585	0x1600006c => 'bootuxdisabled',
1275	0x1500006d => 'bootuxfadeframes',	1586	0x1500006d => 'bootuxfadeframes',
1276	0x1600006e => 'bootuxdumpstats',	1587	0x1600006e => 'bootuxdumpstats',
1277	0x1600006f => 'bootuxshowstats',	1588	0x1600006f => 'bootuxshowstats',
1278	0x16000071 => 'multibootsystem',	1589	0x16000071 => 'multibootsystem',
1279	0x16000072 => 'nokeyboard',	1590	0x16000072 => 'nokeyboard',
1280	0x15000073 => 'aliaswindowskey',	1591	0x15000073 => 'aliaswindowskey',
1281	0x16000074 => 'bootshutdowndisabled',	1592	0x16000074 => 'bootshutdowndisabled',
1282	0x15000075 => 'performancefrequency',	1593	0x15000075 => 'performancefrequency',
1283	0x15000076 => 'securebootrawpolicy',	1594	0x15000076 => 'securebootrawpolicy',
1284	0x17000077 => 'allowedinmemorysettings',	1595	0x17000077 => 'allowedinmemorysettings',
1285	0x15000079 => 'bootuxtransitiontime',	1596	0x15000079 => 'bootuxtransitiontime',
1286	0x1600007a => 'mobilegraphics',	1597	0x1600007a => 'mobilegraphics',
1287	0x1600007b => 'forcefipscrypto',	1598	0x1600007b => 'forcefipscrypto',
1288	0x1500007d => 'booterrorux',	1599	0x1500007d => 'booterrorux',
1289	0x1600007e => 'flightsigning',	1600	0x1600007e => 'flightsigning',
1290	0x1500007f => 'measuredbootlogformat',	1601	0x1500007f => 'measuredbootlogformat',
1291	0x15000080 => 'displayrotation',	1602	0x15000080 => 'displayrotation',
1292	0x15000081 => 'logcontrol',	1603	0x15000081 => 'logcontrol',
1293	0x16000082 => 'nofirmwaresync',	1604	0x16000082 => 'nofirmwaresync',
1294	0x11000084 => 'windowssyspart',	1605	0x11000084 => 'windowssyspart',
1295	0x16000087 => 'numlock',	1606	0x16000087 => 'numlock',
1296	0x22000001 => 'bpbstring',	1607	0x26000202 => 'skipffumode',
		1608	0x26000203 => 'forceffumode',
		1609	0x25000510 => 'chargethreshold',
		1610	0x26000512 => 'offmodecharging',
		1611	0x25000aaa => 'bootflow',
		1612	0x45000001 => 'devicetype',
		1613	0x42000002 => 'applicationrelativepath',
		1614	0x42000003 => 'ramdiskdevicerelativepath',
		1615	0x46000004 => 'omitosloaderelements',
		1616	0x47000006 => 'elementstomigrate',
		1617	0x46000010 => 'recoveryos',
		1618	},
		1619	bootapp => {
		1620	0x26000145 => 'enablebootdebugpolicy',
		1621	0x26000146 => 'enablebootorderclean',
		1622	0x26000147 => 'enabledeviceid',
		1623	0x26000148 => 'enableffuloader',
		1624	0x26000149 => 'enableiuloader',
		1625	0x2600014a => 'enablemassstorage',
		1626	0x2600014b => 'enablerpmbprovisioning',
		1627	0x2600014c => 'enablesecurebootpolicy',
		1628	0x2600014d => 'enablestartcharge',
		1629	0x2600014e => 'enableresettpm',
		1630	},
		1631	bootmgr => {
1297	0x24000001 => 'displayorder',	1632	0x24000001 => 'displayorder',
1298	0x21000001 => 'filedevice',
1299	0x21000001 => 'osdevice',
1300	0x25000001 => 'passcount',
1301	0x26000001 => 'pxesoftreboot',
1302	0x22000002 => 'applicationname',
1303	0x24000002 => 'bootsequence',	1633	0x24000002 => 'bootsequence',
1304	0x22000002 => 'filepath',
1305	0x22000002 => 'systemroot',
1306	0x25000002 => 'testmix',
1307	0x26000003 => 'cacheenable',
1308	0x26000003 => 'customsettings',
1309	0x23000003 => 'default',	1634	0x23000003 => 'default',
1310	0x25000003 => 'failurecount',
1311	0x23000003 => 'resumeobject',
1312	0x26000004 => 'failuresenabled',
1313	0x26000004 => 'pae',
1314	0x26000004 => 'stampdisks',
1315	0x25000004 => 'testtofail',
1316	0x25000004 => 'timeout',	1635	0x25000004 => 'timeout',
1317	0x21000005 => 'associatedosdevice',
1318	0x26000005 => 'cacheenable',
1319	0x26000005 => 'resume',	1636	0x26000005 => 'resume',
1320	0x25000005 => 'stridefailcount',
1321	0x26000006 => 'debugoptionenabled',
1322	0x25000006 => 'invcfailcount',
1323	0x23000006 => 'resumeobject',	1637	0x23000006 => 'resumeobject',
1324	0x25000007 => 'bootux',
1325	0x25000007 => 'matsfailcount',
1326	0x24000007 => 'startupsequence',	1638	0x24000007 => 'startupsequence',
1327	0x25000008 => 'bootmenupolicy',
1328	0x25000008 => 'randfailcount',
1329	0x25000009 => 'chckrfailcount',
1330	0x26000010 => 'detecthal',
1331	0x24000010 => 'toolsdisplayorder',	1639	0x24000010 => 'toolsdisplayorder',
1332	0x22000011 => 'kernel',
1333	0x22000012 => 'hal',
1334	0x22000013 => 'dbgtransport',
1335	0x26000020 => 'displaybootmenu',	1640	0x26000020 => 'displaybootmenu',
1336	0x25000020 => 'nx',
1337	0x26000021 => 'noerrordisplay',	1641	0x26000021 => 'noerrordisplay',
1338	0x25000021 => 'pae',
1339	0x21000022 => 'bcddevice',	1642	0x21000022 => 'bcddevice',
1340	0x26000022 => 'winpe',
1341	0x22000023 => 'bcdfilepath',	1643	0x22000023 => 'bcdfilepath',
1342	0x26000024 => 'hormenabled',	1644	0x26000024 => 'hormenabled',
1343	0x26000024 => 'hormenabled',
1344	0x26000024 => 'nocrashautoreboot',
1345	0x26000025 => 'hiberboot',	1645	0x26000025 => 'hiberboot',
1346	0x26000025 => 'lastknowngood',
1347	0x26000026 => 'oslnointegritychecks',
1348	0x22000026 => 'passwordoverride',	1646	0x22000026 => 'passwordoverride',
1349	0x26000027 => 'osltestsigning',
1350	0x22000027 => 'pinpassphraseoverride',	1647	0x22000027 => 'pinpassphraseoverride',
1351	0x26000028 => 'processcustomactionsfirst',	1648	0x26000028 => 'processcustomactionsfirst',
1352	0x27000030 => 'customactions',	1649	0x27000030 => 'customactions',
1353	0x26000030 => 'nolowmem',
1354	0x26000031 => 'persistbootsequence',	1650	0x26000031 => 'persistbootsequence',
1355	0x25000031 => 'removememory',
1356	0x25000032 => 'increaseuserva',
1357	0x26000032 => 'skipstartupsequence',	1651	0x26000032 => 'skipstartupsequence',
1358	0x25000033 => 'perfmem',
1359	0x22000040 => 'fverecoveryurl',	1652	0x22000040 => 'fverecoveryurl',
1360	0x26000040 => 'vga',
1361	0x22000041 => 'fverecoverymessage',	1653	0x22000041 => 'fverecoverymessage',
		1654	},
		1655	device => {
		1656	0x35000001 => 'ramdiskimageoffset',
		1657	0x35000002 => 'ramdisktftpclientport',
		1658	0x31000003 => 'ramdisksdidevice',
		1659	0x32000004 => 'ramdisksdipath',
		1660	0x35000005 => 'ramdiskimagelength',
		1661	0x36000006 => 'exportascd',
		1662	0x35000007 => 'ramdisktftpblocksize',
		1663	0x35000008 => 'ramdisktftpwindowsize',
		1664	0x36000009 => 'ramdiskmcenabled',
		1665	0x3600000a => 'ramdiskmctftpfallback',
		1666	0x3600000b => 'ramdisktftpvarwindow',
		1667	},
		1668	memdiag => {
		1669	0x25000001 => 'passcount',
		1670	0x25000002 => 'testmix',
		1671	0x25000003 => 'failurecount',
		1672	0x26000003 => 'cacheenable',
		1673	0x25000004 => 'testtofail',
		1674	0x26000004 => 'failuresenabled',
		1675	0x25000005 => 'stridefailcount',
		1676	0x26000005 => 'cacheenable',
		1677	0x25000006 => 'invcfailcount',
		1678	0x25000007 => 'matsfailcount',
		1679	0x25000008 => 'randfailcount',
		1680	0x25000009 => 'chckrfailcount',
		1681	},
		1682	ntldr => {
		1683	0x22000001 => 'bpbstring',
		1684	},
		1685	osloader => {
		1686	0x21000001 => 'osdevice',
		1687	0x22000002 => 'systemroot',
		1688	0x23000003 => 'resumeobject',
		1689	0x26000004 => 'stampdisks',
		1690	0x26000010 => 'detecthal',
		1691	0x22000011 => 'kernel',
		1692	0x22000012 => 'hal',
		1693	0x22000013 => 'dbgtransport',
		1694	0x25000020 => 'nx',
		1695	0x25000021 => 'pae',
		1696	0x26000022 => 'winpe',
		1697	0x26000024 => 'nocrashautoreboot',
		1698	0x26000025 => 'lastknowngood',
		1699	0x26000026 => 'oslnointegritychecks',
		1700	0x26000027 => 'osltestsigning',
		1701	0x26000030 => 'nolowmem',
		1702	0x25000031 => 'removememory',
		1703	0x25000032 => 'increaseuserva',
		1704	0x25000033 => 'perfmem',
		1705	0x26000040 => 'vga',
1362	0x26000041 => 'quietboot',	1706	0x26000041 => 'quietboot',
1363	0x26000042 => 'novesa',	1707	0x26000042 => 'novesa',
1364	0x26000043 => 'novga',	1708	0x26000043 => 'novga',
1365	0x25000050 => 'clustermodeaddressing',	1709	0x25000050 => 'clustermodeaddressing',
1366	0x26000051 => 'usephysicaldestination',	1710	0x26000051 => 'usephysicaldestination',
1367	0x25000052 => 'restrictapiccluster',	1711	0x25000052 => 'restrictapiccluster',
1368	0x22000053 => 'evstore',	1712	0x22000053 => 'evstore',
1369	0x26000054 => 'uselegacyapicmode',	1713	0x26000054 => 'uselegacyapicmode',
1370	0x26000060 => 'onecpu',	1714	0x26000060 => 'onecpu',
1371	0x25000061 => 'numproc',	1715	0x25000061 => 'numproc',
1372	0x26000062 => 'maxproc',	1716	0x26000062 => 'maxproc',
1373	0x25000063 => 'configflags',	1717	0x25000063 => 'configflags',
1374	0x26000064 => 'maxgroup',	1718	0x26000064 => 'maxgroup',
1375	0x26000065 => 'groupaware',	1719	0x26000065 => 'groupaware',
1376	0x25000066 => 'groupsize',	1720	0x25000066 => 'groupsize',
1377	0x26000070 => 'usefirmwarepcisettings',	1721	0x26000070 => 'usefirmwarepcisettings',
1378	0x25000071 => 'msi',	1722	0x25000071 => 'msi',
1379	0x25000072 => 'pciexpress',	1723	0x25000072 => 'pciexpress',
1380	0x25000080 => 'safeboot',	1724	0x25000080 => 'safeboot',
1381	0x26000081 => 'safebootalternateshell',	1725	0x26000081 => 'safebootalternateshell',
1382	0x26000090 => 'bootlog',	1726	0x26000090 => 'bootlog',
1383	0x26000091 => 'sos',	1727	0x26000091 => 'sos',
1384	0x260000a0 => 'debug',	1728	0x260000a0 => 'debug',
1385	0x260000a1 => 'halbreakpoint',	1729	0x260000a1 => 'halbreakpoint',
1386	0x260000a2 => 'useplatformclock',	1730	0x260000a2 => 'useplatformclock',
1387	0x260000a3 => 'forcelegacyplatform',	1731	0x260000a3 => 'forcelegacyplatform',
1388	0x260000a4 => 'useplatformtick',	1732	0x260000a4 => 'useplatformtick',
1389	0x260000a5 => 'disabledynamictick',	1733	0x260000a5 => 'disabledynamictick',
1390	0x250000a6 => 'tscsyncpolicy',	1734	0x250000a6 => 'tscsyncpolicy',
1391	0x260000b0 => 'ems',	1735	0x260000b0 => 'ems',
1392	0x250000c0 => 'forcefailure',	1736	0x250000c0 => 'forcefailure',
1393	0x250000c1 => 'driverloadfailurepolicy',	1737	0x250000c1 => 'driverloadfailurepolicy',
1394	0x250000c2 => 'bootmenupolicy',	1738	0x250000c2 => 'bootmenupolicy',
1395	0x260000c3 => 'onetimeadvancedoptions',	1739	0x260000c3 => 'onetimeadvancedoptions',
1396	0x260000c4 => 'onetimeoptionsedit',	1740	0x260000c4 => 'onetimeoptionsedit',
1397	0x250000e0 => 'bootstatuspolicy',	1741	0x250000e0 => 'bootstatuspolicy',
1398	0x260000e1 => 'disableelamdrivers',	1742	0x260000e1 => 'disableelamdrivers',
1399	0x250000f0 => 'hypervisorlaunchtype',	1743	0x250000f0 => 'hypervisorlaunchtype',
1400	0x220000f1 => 'hypervisorpath',	1744	0x220000f1 => 'hypervisorpath',
1401	0x260000f2 => 'hypervisordebug',	1745	0x260000f2 => 'hypervisordebug',
1402	0x250000f3 => 'hypervisordebugtype',	1746	0x250000f3 => 'hypervisordebugtype',
1403	0x250000f4 => 'hypervisordebugport',	1747	0x250000f4 => 'hypervisordebugport',
1404	0x250000f5 => 'hypervisorbaudrate',	1748	0x250000f5 => 'hypervisorbaudrate',
1405	0x250000f6 => 'hypervisorchannel',	1749	0x250000f6 => 'hypervisorchannel',
1406	0x250000f7 => 'bootux',	1750	0x250000f7 => 'bootux',
1407	0x260000f8 => 'hypervisordisableslat',	1751	0x260000f8 => 'hypervisordisableslat',
1408	0x220000f9 => 'hypervisorbusparams',	1752	0x220000f9 => 'hypervisorbusparams',
1409	0x250000fa => 'hypervisornumproc',	1753	0x250000fa => 'hypervisornumproc',
1410	0x250000fb => 'hypervisorrootprocpernode',	1754	0x250000fb => 'hypervisorrootprocpernode',
1411	0x260000fc => 'hypervisoruselargevtlb',	1755	0x260000fc => 'hypervisoruselargevtlb',
1412	0x250000fd => 'hypervisorhostip',	1756	0x250000fd => 'hypervisorhostip',
1413	0x250000fe => 'hypervisorhostport',	1757	0x250000fe => 'hypervisorhostport',
1414	0x250000ff => 'hypervisordebugpages',	1758	0x250000ff => 'hypervisordebugpages',
1415	0x25000100 => 'tpmbootentropy',	1759	0x25000100 => 'tpmbootentropy',
1416	0x22000110 => 'hypervisorusekey',	1760	0x22000110 => 'hypervisorusekey',
1417	0x22000112 => 'hypervisorproductskutype',	1761	0x22000112 => 'hypervisorproductskutype',
1418	0x25000113 => 'hypervisorrootproc',	1762	0x25000113 => 'hypervisorrootproc',
1419	0x26000114 => 'hypervisordhcp',	1763	0x26000114 => 'hypervisordhcp',
1420	0x25000115 => 'hypervisoriommupolicy',	1764	0x25000115 => 'hypervisoriommupolicy',
1421	0x26000116 => 'hypervisorusevapic',	1765	0x26000116 => 'hypervisorusevapic',
1422	0x22000117 => 'hypervisorloadoptions',	1766	0x22000117 => 'hypervisorloadoptions',
1423	0x25000118 => 'hypervisormsrfilterpolicy',	1767	0x25000118 => 'hypervisormsrfilterpolicy',
1424	0x25000119 => 'hypervisormmionxpolicy',	1768	0x25000119 => 'hypervisormmionxpolicy',
1425	0x2500011a => 'hypervisorschedulertype',	1769	0x2500011a => 'hypervisorschedulertype',
1426	0x25000120 => 'xsavepolicy',	1770	0x25000120 => 'xsavepolicy',
1427	0x25000121 => 'xsaveaddfeature0',	1771	0x25000121 => 'xsaveaddfeature0',
1428	0x25000122 => 'xsaveaddfeature1',	1772	0x25000122 => 'xsaveaddfeature1',
1429	0x25000123 => 'xsaveaddfeature2',	1773	0x25000123 => 'xsaveaddfeature2',
1430	0x25000124 => 'xsaveaddfeature3',	1774	0x25000124 => 'xsaveaddfeature3',
1431	0x25000125 => 'xsaveaddfeature4',	1775	0x25000125 => 'xsaveaddfeature4',
1432	0x25000126 => 'xsaveaddfeature5',	1776	0x25000126 => 'xsaveaddfeature5',
1433	0x25000127 => 'xsaveaddfeature6',	1777	0x25000127 => 'xsaveaddfeature6',
1434	0x25000128 => 'xsaveaddfeature7',	1778	0x25000128 => 'xsaveaddfeature7',
1435	0x25000129 => 'xsaveremovefeature',	1779	0x25000129 => 'xsaveremovefeature',
1436	0x2500012a => 'xsaveprocessorsmask',	1780	0x2500012a => 'xsaveprocessorsmask',
1437	0x2500012b => 'xsavedisable',	1781	0x2500012b => 'xsavedisable',
1438	0x2500012c => 'kerneldebugtype',	1782	0x2500012c => 'kerneldebugtype',
1439	0x2200012d => 'kernelbusparams',	1783	0x2200012d => 'kernelbusparams',
1440	0x2500012e => 'kerneldebugaddress',	1784	0x2500012e => 'kerneldebugaddress',
1441	0x2500012f => 'kerneldebugport',	1785	0x2500012f => 'kerneldebugport',
1442	0x25000130 => 'claimedtpmcounter',	1786	0x25000130 => 'claimedtpmcounter',
1443	0x25000131 => 'kernelchannel',	1787	0x25000131 => 'kernelchannel',
1444	0x22000132 => 'kerneltargetname',	1788	0x22000132 => 'kerneltargetname',
1445	0x25000133 => 'kernelhostip',	1789	0x25000133 => 'kernelhostip',
1446	0x25000134 => 'kernelport',	1790	0x25000134 => 'kernelport',
1447	0x26000135 => 'kerneldhcp',	1791	0x26000135 => 'kerneldhcp',
1448	0x22000136 => 'kernelkey',	1792	0x22000136 => 'kernelkey',
1449	0x22000137 => 'imchivename',	1793	0x22000137 => 'imchivename',
1450	0x21000138 => 'imcdevice',	1794	0x21000138 => 'imcdevice',
1451	0x25000139 => 'kernelbaudrate',	1795	0x25000139 => 'kernelbaudrate',
1452	0x22000140 => 'mfgmode',	1796	0x22000140 => 'mfgmode',
1453	0x26000141 => 'event',	1797	0x26000141 => 'event',
1454	0x25000142 => 'vsmlaunchtype',	1798	0x25000142 => 'vsmlaunchtype',
1455	0x25000144 => 'hypervisorenforcedcodeintegrity',	1799	0x25000144 => 'hypervisorenforcedcodeintegrity',
1456	0x26000145 => 'enablebootdebugpolicy',
1457	0x26000146 => 'enablebootorderclean',
1458	0x26000147 => 'enabledeviceid',
1459	0x26000148 => 'enableffuloader',
1460	0x26000149 => 'enableiuloader',
1461	0x2600014a => 'enablemassstorage',
1462	0x2600014b => 'enablerpmbprovisioning',
1463	0x2600014c => 'enablesecurebootpolicy',
1464	0x2600014d => 'enablestartcharge',
1465	0x2600014e => 'enableresettpm',
1466	0x21000150 => 'systemdatadevice',	1800	0x21000150 => 'systemdatadevice',
1467	0x21000151 => 'osarcdevice',	1801	0x21000151 => 'osarcdevice',
1468	0x21000153 => 'osdatadevice',	1802	0x21000153 => 'osdatadevice',
1469	0x21000154 => 'bspdevice',	1803	0x21000154 => 'bspdevice',
1470	0x21000155 => 'bspfilepath',	1804	0x21000155 => 'bspfilepath',
1471	0x26000202 => 'skipffumode',	1805	},
1472	0x26000203 => 'forceffumode',	1806	resume => {
1473	0x25000510 => 'chargethreshold',
1474	0x26000512 => 'offmodecharging',
1475	0x25000aaa => 'bootflow',
1476	0x35000001 => 'ramdiskimageoffset',
1477	0x35000002 => 'ramdisktftpclientport',
1478	0x31000003 => 'ramdisksdidevice',
1479	0x32000004 => 'ramdisksdipath',
1480	0x35000005 => 'ramdiskimagelength',
1481	0x36000006 => 'exportascd',
1482	0x35000007 => 'ramdisktftpblocksize',
1483	0x35000008 => 'ramdisktftpwindowsize',
1484	0x36000009 => 'ramdiskmcenabled',
1485	0x3600000a => 'ramdiskmctftpfallback',
1486	0x3600000b => 'ramdisktftpvarwindow',
1487	0x45000001 => 'devicetype',	1807	0x21000001 => 'filedevice',
		1808	0x22000002 => 'filepath',
		1809	0x26000003 => 'customsettings',
		1810	0x26000004 => 'pae',
		1811	0x21000005 => 'associatedosdevice',
		1812	0x26000006 => 'debugoptionenabled',
		1813	0x25000007 => 'bootux',
		1814	0x25000008 => 'bootmenupolicy',
		1815	0x26000024 => 'hormenabled',
		1816	},
		1817	startup => {
		1818	0x26000001 => 'pxesoftreboot',
1488	0x42000002 => 'applicationrelativepath',	1819	0x22000002 => 'applicationname',
1489	0x42000003 => 'ramdiskdevicerelativepath',	1820	},
1490	0x46000004 => 'omitosloaderelements',
1491	0x47000006 => 'elementstomigrate',
1492	0x46000010 => 'recoveryos',
1493	);	1821	);
1494		1822
1495	our %rbcde = reverse %bcde;	1823	# mask, value => class
		1824	our @bcde_typeclass = (
		1825	[0x00000000, 0x00000000, 'any'],
		1826	[0xf00fffff, 0x1000000a, 'bootapp'],
		1827	[0xf0ffffff, 0x2020000a, 'bootapp'],
		1828	[0xf00fffff, 0x10000001, 'bootmgr'],
		1829	[0xf00fffff, 0x10000002, 'bootmgr'],
		1830	[0xf0ffffff, 0x20200001, 'bootmgr'],
		1831	[0xf0ffffff, 0x20200002, 'bootmgr'],
		1832	[0xf0f00000, 0x20300000, 'device'],
		1833	[0xf0000000, 0x30000000, 'device'],
		1834	[0xf00fffff, 0x10000005, 'memdiag'],
		1835	[0xf0ffffff, 0x20200005, 'memdiag'],
		1836	[0xf00fffff, 0x10000006, 'ntldr'],
		1837	[0xf00fffff, 0x10000007, 'ntldr'],
		1838	[0xf0ffffff, 0x20200006, 'ntldr'],
		1839	[0xf0ffffff, 0x20200007, 'ntldr'],
		1840	[0xf00fffff, 0x10000003, 'osloader'],
		1841	[0xf0ffffff, 0x20200003, 'osloader'],
		1842	[0xf00fffff, 0x10000004, 'resume'],
		1843	[0xf0ffffff, 0x20200004, 'resume'],
		1844	[0xf00fffff, 0x10000009, 'startup'],
		1845	[0xf0ffffff, 0x20200009, 'startup'],
		1846	);
1496		1847
		1848	our %rbcde_byclass;
		1849
		1850	while (my ($k, $v) = each %bcde_byclass) {
		1851	$rbcde_byclass{$k} = { reverse %$v };
		1852	}
		1853
		1854	# decodes (numerical elem, type) to name
1497	sub dec_bcde_id($) {	1855	sub dec_bcde_id($$) {
		1856	for my $class (@bcde_typeclass) {
		1857	if (($_[1] & $class->[0]) == $class->[1]) {
		1858	if (my $id = $bcde_byclass{$class->[2]}{$_[0]}) {
		1859	return $id;
		1860	}
		1861	}
		1862	}
		1863
1498	$bcde{$_[0]} // sprintf "custom:%08x", $_[0]	1864	sprintf "custom:%08x", $_[0]
1499	}	1865	}
1500		1866
		1867	# encodes (elem as name, type)
1501	sub enc_bcde_id($) {	1868	sub enc_bcde_id($$) {
1502	$_[0] =~ /^custom:([0-9a-fA-F]{8}$)/	1869	$_[0] =~ /^custom:(?:0x)?([0-9a-fA-F]{8}$)/
1503	? hex $1	1870	and return hex $1;
1504	: $rbcde{$_[0]}	1871
		1872	for my $class (@bcde_typeclass) {
		1873	if (($_[1] & $class->[0]) == $class->[1]) {
		1874	if (my $value = $rbcde_byclass{$class->[2]}{$_[0]}) {
		1875	return $value;
		1876	}
		1877	}
		1878	}
		1879
		1880	undef
1505	}	1881	}
1506		1882
1507	# decode/encode bcd device element - the horror, no documentaion	1883	# decode/encode bcd device element - the horror, no documentaion
1508	# whatsoever, supercomplex, superinconsistent.	1884	# whatsoever, supercomplex, superinconsistent.
1509		1885
…		…
1512	our @part_type = qw(gpt mbr raw);	1888	our @part_type = qw(gpt mbr raw);
1513		1889
1514	our $NULL_DEVICE = "\x00" x 16;	1890	our $NULL_DEVICE = "\x00" x 16;
1515		1891
1516	# biggest bitch to decode, ever	1892	# biggest bitch to decode, ever
1517	# this decoded a device portion after the GUID	1893	# this decodes a device portion after the GUID
1518	sub dec_device_($);	1894	sub dec_device_($$);
1519	sub dec_device_($) {	1895	sub dec_device_($$) {
1520	my ($device) = @_;	1896	my ($device, $type) = @_;
1521		1897
1522	my $res;	1898	my $res;
1523		1899
1524	my ($type, $flags, $length, $pad) = unpack "VVVV", substr $device, 0, 4 * 4, "";	1900	my ($type, $flags, $length, $pad) = unpack "VVVV", substr $device, 0, 4 * 4, "";
1525		1901
…		…
1554		1930
1555	$path	1931	$path
1556	};	1932	};
1557		1933
1558	if ($type eq "partition" or $type eq "legacypartition") {	1934	if ($type eq "partition" or $type eq "legacypartition") {
1559	$type eq "legacypartition"
1560	and die "legacypartition decocde support missing\n"; # different structure layout?
1561
1562	my $partdata = substr $device, 0, 16, "";	1935	my $partdata = substr $device, 0, 16, "";
1563	my ($blocktype, $parttype) = unpack "VV", substr $device, 0, 4 * 2, "";	1936	my ($blocktype, $parttype) = unpack "VV", substr $device, 0, 4 * 2, "";
1564		1937
1565	$blocktype = $block_type[$blocktype] // die "unknown block device type '$blocktype'\n";	1938	$blocktype = $block_type[$blocktype] // die "unknown block device type '$blocktype'\n";
1566	$parttype = $part_type[$parttype] // die "unknown partition type\n";	1939	$parttype = $part_type[$parttype] // die "unknown partition type\n";
…		…
1573		1946
1574	my $partid = $parttype eq "gpt" ? dec_guid $partdata	1947	my $partid = $parttype eq "gpt" ? dec_guid $partdata
1575	: $type eq "partition" ? unpack "Q<", $partdata # byte offset to partition start	1948	: $type eq "partition" ? unpack "Q<", $partdata # byte offset to partition start
1576	: unpack "L<", $partdata; # partition number, one-based	1949	: unpack "L<", $partdata; # partition number, one-based
1577		1950
1578	(my $parent, $device) = dec_device_ $device;	1951	(my $parent, $device) = dec_device_ $device, $type;
1579		1952
1580	$res .= "=";	1953	$res .= "=";
1581	$res .= "<$parent>";	1954	$res .= "<$parent>";
1582	$res .= ",$blocktype,$parttype,$diskid,$partid";	1955	$res .= ",$blocktype,$parttype,$diskid,$partid";
1583		1956
…		…
1603	or die "unsupported file descriptor version '$fver'\n";	1976	or die "unsupported file descriptor version '$fver'\n";
1604		1977
1605	$ftype == 5	1978	$ftype == 5
1606	or die "unsupported file descriptor path type '$type'\n";	1979	or die "unsupported file descriptor path type '$type'\n";
1607		1980
1608	(my $parent, $path) = dec_device_ $path;	1981	(my $parent, $path) = dec_device_ $path, $type;
1609		1982
1610	$path = $dec_path->($path, "file device without path");	1983	$path = $dec_path->($path, "file device without path");
1611		1984
1612	($parent, $path)	1985	($parent, $path)
1613	};	1986	};
…		…
1619		1992
1620	} elsif ($blocktype eq "vhd") {	1993	} elsif ($blocktype eq "vhd") {
1621	$device =~ s/^\x00{20}//s	1994	$device =~ s/^\x00{20}//s
1622	or die "virtualdisk has non-zero fields I don't understand\n";	1995	or die "virtualdisk has non-zero fields I don't understand\n";
1623		1996
1624	(my $parent, $device) = dec_device_ $device;	1997	(my $parent, $device) = dec_device_ $device, $type;
1625		1998
1626	$res .= "=vhd,<$parent>";	1999	$res .= "=vhd,<$parent>";
1627		2000
1628	} elsif ($blocktype eq "ramdisk") {	2001	} elsif ($blocktype eq "ramdisk") {
1629	my ($base, $size, $offset) = unpack "Q< Q< L<", substr $device, 0, 8 + 8 + 4, "";	2002	my ($base, $size, $offset) = unpack "Q< Q< L<", substr $device, 0, 8 + 8 + 4, "";
…		…
1642	my ($mode, $elem, $parent) = unpack "VVV", substr $device, 0, 4 * 3, "";	2015	my ($mode, $elem, $parent) = unpack "VVV", substr $device, 0, 4 * 3, "";
1643		2016
1644	if ($parent) {	2017	if ($parent) {
1645	# not sure why this is an offset - it must come after the path	2018	# not sure why this is an offset - it must come after the path
1646	$parent = substr $device, $parent - 4 * 3 - 4 * 4, 1e9, "";	2019	$parent = substr $device, $parent - 4 * 3 - 4 * 4, 1e9, "";
1647	($parent, my $tail) = dec_device_ $parent;	2020	($parent, my $tail) = dec_device_ $parent, $type;
1648	0 == length $tail	2021	0 == length $tail
1649	or die "trailing data after locate device parent\n";	2022	or die "trailing data after locate device parent\n";
1650	} else {	2023	} else {
1651	$parent = "null";	2024	$parent = "null";
1652	}	2025	}
…		…
1658		2031
1659	if ($mode == 0) { # "Element"	2032	if ($mode == 0) { # "Element"
1660	!length $path	2033	!length $path
1661	or die "device locate mode 0 having non-empty path ($mode, $elem, $path)\n";	2034	or die "device locate mode 0 having non-empty path ($mode, $elem, $path)\n";
1662		2035
1663	$elem = dec_bcde_id $elem;	2036	$elem = dec_bcde_id $elem, $type;
1664	$res .= "element,$elem";	2037	$res .= "element,$elem";
1665		2038
1666	} elsif ($mode == 1) { # "String"	2039	} elsif ($mode == 1) { # "String"
1667	!$elem	2040	!$elem
1668	or die "device locate mode 1 having non-zero element\n";	2041	or die "device locate mode 1 having non-zero element\n";
…		…
1693		2066
1694	($res, $tail)	2067	($res, $tail)
1695	}	2068	}
1696		2069
1697	# decode a full binary BCD device descriptor	2070	# decode a full binary BCD device descriptor
1698	sub dec_device($) {	2071	sub dec_device($$) {
1699	my ($device) = @_;	2072	my ($device, $type) = @_;
1700		2073
1701	$device = pack "H*", $device;	2074	$device = pack "H*", $device;
1702		2075
1703	my $guid = dec_guid substr $device, 0, 16, "";	2076	my $guid = dec_guid substr $device, 0, 16, "";
1704	$guid = $guid eq "00000000-0000-0000-0000-000000000000"	2077	$guid = $guid eq "00000000-0000-0000-0000-000000000000"
1705	? "" : "{$guid}";	2078	? "" : "{$guid}";
1706		2079
1707	eval {	2080	eval {
1708	my ($dev, $tail) = dec_device_ $device;	2081	my ($dev, $tail) = dec_device_ $device, $type;
1709		2082
1710	$tail eq ""	2083	$tail eq ""
1711	or die "unsupported trailing data after device descriptor\n";	2084	or die "unsupported trailing data after device descriptor\n";
1712		2085
1713	"$guid$dev"	2086	"$guid$dev"
…		…
1725		2098
1726	undef	2099	undef
1727	}	2100	}
1728		2101
1729	# encode the device portion after the GUID	2102	# encode the device portion after the GUID
1730	sub enc_device_;	2103	sub enc_device_($$);
1731	sub enc_device_ {	2104	sub enc_device_($$) {
1732	my ($device) = @_;	2105	my ($device, $type) = @_;
1733		2106
1734	my $enc_path = sub {	2107	my $enc_path = sub {
1735	my $path = shift;	2108	my $path = shift;
1736	$path =~ s/\//\\/g;	2109	$path =~ s/\//\\/g;
1737	(Encode::encode "UTF-16LE", $path) . "\x00\x00"	2110	(Encode::encode "UTF-16LE", $path) . "\x00\x00"
…		…
1755		2128
1756	my $parse_parent = sub {	2129	my $parse_parent = sub {
1757	my $parent;	2130	my $parent;
1758		2131
1759	if (s/^<//) {	2132	if (s/^<//) {
1760	($parent, $_) = enc_device_ $_;	2133	($parent, $_) = enc_device_ $_, $type;
1761	s/^>//	2134	s/^>//
1762	or die "$device: syntax error: parent device not followed by '>'\n";	2135	or die "$device: syntax error: parent device not followed by '>'\n";
1763	} else {	2136	} else {
1764	$parent = $NULL_DEVICE;	2137	$parent = $NULL_DEVICE;
1765	}	2138	}
…		…
1853		2226
1854	s/^,//	2227	s/^,//
1855	or die "$_: missing comma after locate parent device\n";	2228	or die "$_: missing comma after locate parent device\n";
1856		2229
1857	if (s/^element,//) {	2230	if (s/^element,//) {
1858	s/^([0-9a-z]+)//i	2231	s/^([0-9a-z:]+)//i
1859	or die "$_ locate element must be either name or 8-digit hex id\n";	2232	or die "$_ locate element must be either name or 8-digit hex id\n";
1860	$elem = enc_bcde_id $1;	2233	$elem = enc_bcde_id $1, $type;
1861	$mode = 0;	2234	$mode = 0;
1862	$path = $enc_path->("");	2235	$path = $enc_path->("");
1863		2236
1864	} elsif (s/^path,//) {	2237	} elsif (s/^path,//) {
1865	$mode = 1;	2238	$mode = 1;
…		…
1932	or die "$_: malformed or missing vmbus interface instance guid\n";	2305	or die "$_: malformed or missing vmbus interface instance guid\n";
1933	my $instance = enc_guid $1;	2306	my $instance = enc_guid $1;
1934		2307
1935	$payload = pack "a16a16x24", $type, $instance;	2308	$payload = pack "a16a16x24", $type, $instance;
1936		2309
		2310	# } elsif ($type eq "udp") {
		2311	# $payload = pack "Va16", 1, "12345678";
		2312
1937	} else {	2313	} else {
1938	die "$type: not a supported device type (binary, null, boot, legacypartition, partition, block, locate)\n";	2314	die "$type: not a supported device type (binary, null, boot, legacypartition, partition, block, locate)\n";
1939	}	2315	}
1940		2316
1941	return (	2317	return (
…		…
1944	);	2320	);
1945	}	2321	}
1946	}	2322	}
1947		2323
1948	# encode a full binary BCD device descriptor	2324	# encode a full binary BCD device descriptor
1949	sub enc_device {	2325	sub enc_device($$) {
1950	my ($device) = @_;	2326	my ($device, $type) = @_;
1951		2327
1952	my $guid = "\x00" x 16;	2328	my $guid = "\x00" x 16;
1953		2329
1954	if ($device =~ s/^\{([A-Za-z0-9\-]+)\}//) {	2330	if ($device =~ s/^\{([A-Za-z0-9\-]+)\}//) {
1955	$guid = enc_guid $1	2331	$guid = enc_guid $1
1956	or die "$device: does not start with valid guid\n";	2332	or die "$device: does not start with valid guid\n";
1957	}	2333	}
1958		2334
1959	my ($descriptor, $tail) = enc_device_ $device;	2335	my ($descriptor, $tail) = enc_device_ $device, $type;
1960		2336
1961	length $tail	2337	length $tail
1962	and die "$device: garbage after device descriptor\n";	2338	and die "$device: garbage after device descriptor\n";
1963		2339
1964	unpack "H*", $guid . $descriptor	2340	unpack "H*", $guid . $descriptor
…		…
1979	$k = $bcd_objects{$k} // $k;	2355	$k = $bcd_objects{$k} // $k;
1980		2356
1981	my $type = $v->{Description}[0]{Type}[1];	2357	my $type = $v->{Description}[0]{Type}[1];
1982		2358
1983	if ($type != $bcd_object_types{$k}) {	2359	if ($type != $bcd_object_types{$k}) {
1984	$type = $bcd_types{$type} // sprintf "0x%08x", $type;	2360	$kv{type} = $bcd_types{$type} // sprintf "0x%08x", $type;
1985	$kv{type} = $type;
1986	}	2361	}
1987		2362
1988	my $elems = $v->{Elements}[1];	2363	my $elems = $v->{Elements}[1];
1989		2364
1990	while (my ($k, $v) = each %$elems) {	2365	while (my ($k, $v) = each %$elems) {
1991	my $k = hex $k;	2366	my $k = hex $k;
1992		2367
1993	my $v = $bcde_dec{$k & BCDE_FORMAT}->($v->[0]{Element}[1]);	2368	my $v = $bcde_dec{$k & BCDE_FORMAT}->($v->[0]{Element}[1], $type);
1994	my $k = dec_bcde_id $k;	2369	my $k = dec_bcde_id $k, $type;
1995		2370
1996	$kv{$k} = $v;	2371	$kv{$k} = $v;
1997	}	2372	}
1998		2373
1999	$bcd{$k} = \%kv;	2374	$bcd{$k} = \%kv;
…		…
2040	my %elem;	2415	my %elem;
2041		2416
2042	while (my ($k, $v) = each %$v) {	2417	while (my ($k, $v) = each %$v) {
2043	next if $k eq "type";	2418	next if $k eq "type";
2044		2419
2045	$k = (enc_bcde_id $k) // die "$k: invalid bcde element name or id\n";	2420	$k = (enc_bcde_id $k, $type) // die "$k: invalid bcde element name or id\n";
2046	$elem{sprintf "%08x", $k} = [{	2421	$elem{sprintf "%08x", $k} = [{
2047	Element => [ ($bcde_enc{$k & BCDE_FORMAT} // die "$k: unable to encode unknown bcd element type}")->($v)]	2422	Element => [ ($bcde_enc{$k & BCDE_FORMAT} // die "$k: unable to encode unknown bcd element type}")->($v)]
2048	}];	2423	}];
2049	}	2424	}
2050		2425
…		…
2066	Objects => [undef, \%objects],	2441	Objects => [undef, \%objects],
2067	}]]	2442	}]]
2068	}	2443	}
2069		2444
2070	#############################################################################	2445	#############################################################################
		2446	# edit instructions
		2447
		2448	sub bcd_edit_eval {
		2449	package pbcdedit;
		2450
		2451	our ($PATH, $BCD, $DEFAULT);
		2452
		2453	eval shift;
		2454	die "$@" if $@;
		2455	}
		2456
		2457	sub bcd_edit {
		2458	my ($path, $bcd, @insns) = @_;
		2459
		2460	my $default = $bcd->{"{bootmgr}"}{default};
		2461
		2462	# prepare "officially visible" variables
		2463	local $pbcdedit::PATH = $path;
		2464	local $pbcdedit::BCD = $bcd;
		2465	local $pbcdedit::DEFAULT = $default;
		2466
		2467	while (@insns) {
		2468	my $insn = shift @insns;
		2469
		2470	if ($insn eq "get") {
		2471	my $object = shift @insns;
		2472	my $elem = shift @insns;
		2473
		2474	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
		2475
		2476	print $bcd->{$object}{$elem}, "\n";
		2477
		2478	} elsif ($insn eq "set") {
		2479	my $object = shift @insns;
		2480	my $elem = shift @insns;
		2481	my $value = shift @insns;
		2482
		2483	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
		2484
		2485	$bcd->{$object}{$elem} = $value;
		2486
		2487	} elsif ($insn eq "del") {
		2488	my $object = shift @insns;
		2489	my $elem = shift @insns;
		2490
		2491	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
		2492
		2493	delete $bcd->{$object}{$elem};
		2494
		2495	} elsif ($insn eq "eval") {
		2496	my $perl = shift @insns;
		2497	bcd_edit_eval "#line 1 'eval'\n$perl";
		2498
		2499	} elsif ($insn eq "do") {
		2500	my $path = shift @insns;
		2501	my $file = file_load $path;
		2502	bcd_edit_eval "#line 1 '$path'\n$file";
		2503
		2504	} else {
		2505	die "$insn: not a recognized instruction for create/edit/parse\n";
		2506	}
		2507	}
		2508
		2509	}
		2510
		2511	#############################################################################
		2512	# other utilities
2071		2513
2072	# json to stdout	2514	# json to stdout
2073	sub prjson($) {	2515	sub prjson($) {
2074	print $json_coder->encode ($_[0]);	2516	print $json_coder->encode ($_[0]);
2075	}	2517	}
…		…
2079	my $json;	2521	my $json;
2080	1 while read STDIN, $json, 65536, length $json;	2522	1 while read STDIN, $json, 65536, length $json;
2081	$json_coder->decode ($json)	2523	$json_coder->decode ($json)
2082	}	2524	}
2083		2525
2084	# all subcommands	2526	sub lsblk() {
		2527	my $lsblk = $json_coder->decode (scalar qx<lsblk --json -o PATH,KNAME,MAJ:MIN,TYPE,PTTYPE,PTUUID,PARTUUID,LABEL,FSTYPE>);
		2528
		2529	for my $dev (@{ $lsblk->{blockdevices} }) {
		2530	if ($dev->{type} eq "part") {
		2531
		2532	# lsblk sometimes gives a bogus pttype, so we recreate it here
		2533	$dev->{pttype} = $dev->{ptuuid} =~ /^$RE_GUID\z/
		2534	? "gpt" : "dos";
		2535
		2536	if ($dev->{pttype} eq "gpt") {
		2537	$dev->{bcd_device} = "partition=<null>,harddisk,gpt,$dev->{ptuuid},$dev->{partuuid}";
		2538	} elsif ($dev->{pttype} eq "dos") { # why not "mbr" :(
		2539	if ($dev->{partuuid} =~ /^([0-9a-f]{8})-([0-9a-f]{2})\z/i) {
		2540	my ($diskid, $partno) = ($1, hex $2);
		2541	$dev->{bcd_legacy_device} = "legacypartition=<null>,harddisk,mbr,$diskid,$partno";
		2542	if (open my $fh, "/sys/class/block/$dev->{kname}/start") {
		2543	my $start = 512 * readline $fh;
		2544	$dev->{bcd_device} = "partition=<null>,harddisk,mbr,$diskid,$start";
		2545	}
		2546	}
		2547	}
		2548	}
		2549	}
		2550
		2551	$lsblk->{blockdevices}
		2552	}
		2553
		2554	sub prdev($$) {
		2555	my ($path, $attribute) = @_;
		2556
		2557	# rather than stat'ing and guessing how devices are encoded, we use lsblk for this
		2558	my $mm = $json_coder->decode (scalar qx<lsblk -d -o MAJ:MIN -J \Q$path\E>)->{blockdevices}[0]{"maj:min"};
		2559
		2560	my $lsblk = lsblk;
		2561
		2562	for my $dev (@$lsblk) {
		2563	if ($dev->{"maj:min"} eq $mm && $dev->{$attribute}) {
		2564	say $dev->{$attribute};
		2565	exit 0;
		2566	}
		2567	}
		2568
		2569	exit 1;
		2570	}
		2571
		2572	#############################################################################
		2573	# command line parser
		2574
2085	our %CMD = (	2575	our %CMD = (
2086	help => sub {	2576	help => sub {
2087	require Pod::Usage;	2577	require Pod::Usage;
2088	Pod::Usage::pod2usage (-verbose => 2);	2578	Pod::Usage::pod2usage (-verbose => 2, -quotes => "none", -noperldoc => 1);
2089	},	2579	},
2090		2580
2091	objects => sub {	2581	objects => sub {
2092	my %rbcd_types = reverse %bcd_types;	2582	my %rbcd_types = reverse %bcd_types;
2093	$_ = sprintf "%08x", $_ for values %rbcd_types;	2583	$_ = sprintf "%08x", $_ for values %rbcd_types;
…		…
2114		2604
2115	print "\n";	2605	print "\n";
2116		2606
2117	printf "%-39s %-23s %s\n", "Object GUID", "Alias", "(Hex) Default Type";	2607	printf "%-39s %-23s %s\n", "Object GUID", "Alias", "(Hex) Default Type";
2118	for my $name (sort keys %rbcd_objects) {	2608	for my $name (sort keys %rbcd_objects) {
2119	my $guid = $rbcd_objects{$name};	2609	my $guid = $rbcd_objects{$name};
2120	my $type = $bcd_object_types{$name};	2610	my $type = $bcd_object_types{$name};
2121	my $tname = $bcd_types{$type};	2611	my $tname = $bcd_types{$type};
2122		2612
2123	$type = $type ? sprintf "(%08x) %s", $type, $tname : "-";	2613	$type = $type ? sprintf "(%08x) %s", $type, $tname : "-";
2124		2614
2125	printf "%-39s %-23s %s\n", $guid, $name, $type;	2615	printf "%-39s %-23s %s\n", $guid, $name, $type;
…		…
2139	BCDE_FORMAT_GUID_LIST , "guid list",	2629	BCDE_FORMAT_GUID_LIST , "guid list",
2140	BCDE_FORMAT_INTEGER , "integer",	2630	BCDE_FORMAT_INTEGER , "integer",
2141	BCDE_FORMAT_BOOLEAN , "boolean",	2631	BCDE_FORMAT_BOOLEAN , "boolean",
2142	BCDE_FORMAT_INTEGER_LIST, "integer list",	2632	BCDE_FORMAT_INTEGER_LIST, "integer list",
2143	);	2633	);
2144	my %rbcde = reverse %bcde;
2145	$_ = sprintf "%08x", $_ for values %rbcde;
2146		2634
2147	my %element;	2635	my @element;
2148		2636
		2637	for my $class (sort keys %rbcde_byclass) {
		2638	my $rbcde = $rbcde_byclass{$class};
		2639
2149	unless ($json) {	2640	unless ($json) {
2150	print "\n";	2641	print "\n";
		2642	printf "Elements applicable to class(es): $class\n";
2151	printf "%-9s %-12s %s\n", "Element", "Format", "Name Alias";	2643	printf "%-9s %-12s %s\n", "Element", "Format", "Name Alias";
2152	}	2644	}
2153	for my $name (sort keys %rbcde) {	2645	for my $name (sort keys %$rbcde) {
2154	my $id = $rbcde{$name};	2646	my $id = $rbcde->{$name};
2155	my $format = $format_name{(hex $id) & BCDE_FORMAT};	2647	my $format = $format_name{$id & BCDE_FORMAT};
2156		2648
2157	if ($json) {	2649	if ($json) {
2158	$element{$id} = [$format, $name];	2650	push @element, [$class, $id * 1, $format, $name];
2159	} else {	2651	} else {
		2652	$id = sprintf "%08x", $id;
2160	printf "%-9s %-12s %s\n", $id, $format, $name;	2653	printf "%-9s %-12s %s\n", $id, $format, $name;
		2654	}
2161	}	2655	}
2162	}	2656	}
2163	print "\n" unless $json;	2657	print "\n" unless $json;
2164		2658
2165	prjson {	2659	prjson {
2166	version => $JSON_VERSION,	2660	version => $JSON_VERSION,
2167	element => \%element,	2661	element => \@element,
		2662	class => \@bcde_typeclass,
2168	} if $json;	2663	} if $json;
2169		2664
2170	},	2665	},
2171		2666
2172	export => sub {	2667	export => sub {
2173	prjson bcd_decode regf_load shift;	2668	prjson bcd_decode regf_load shift;
2174	},	2669	},
2175		2670
2176	import => sub {	2671	import => sub {
2177	regf_save shift, bcd_encode rdjson;	2672	regf_save shift, bcd_encode rdjson;
		2673	},
		2674
		2675	create => sub {
		2676	my $path = shift;
		2677	my $stat = stat_get $path; # should actually be done at file load time
		2678	my $bcd = { };
		2679	bcd_edit $path, $bcd, @_;
		2680	regf_save $path, bcd_encode $bcd;
		2681	stat_set $path, $stat;
		2682	},
		2683
		2684	edit => sub {
		2685	my $path = shift;
		2686	my $stat = stat_get $path; # should actually be done at file load time
		2687	my $bcd = bcd_decode regf_load $path;
		2688	bcd_edit $path, $bcd, @_;
		2689	regf_save $path, bcd_encode $bcd;
		2690	stat_set $path, $stat;
		2691	},
		2692
		2693	parse => sub {
		2694	my $path = shift;
		2695	my $bcd = bcd_decode regf_load $path;
		2696	bcd_edit $path, $bcd, @_;
2178	},	2697	},
2179		2698
2180	"export-regf" => sub {	2699	"export-regf" => sub {
2181	prjson regf_load shift;	2700	prjson regf_load shift;
2182		2701
…		…
2185	"import-regf" => sub {	2704	"import-regf" => sub {
2186	regf_save shift, rdjson;	2705	regf_save shift, rdjson;
2187	},	2706	},
2188		2707
2189	lsblk => sub {	2708	lsblk => sub {
		2709	my $json = $_[0] eq "--json";
		2710
		2711	my $lsblk = lsblk;
		2712
		2713	if ($json) {
		2714	prjson $lsblk;
		2715	} else {
2190	printf "%-10s %-8.8s %-6.6s %-3s %s\n", "DEVICE", "LABEL", "FSTYPE", "PT", "DEVICE DESCRIPTOR";	2716	printf "%-10s %-8.8s %-6.6s %-3s %s\n", "DEVICE", "LABEL", "FSTYPE", "PT", "DEVICE DESCRIPTOR";
2191		2717	for my $dev (@$lsblk) {
2192	my $lsblk = $json_coder->decode (scalar qx<lsblk --json -o PATH,KNAME,TYPE,PTTYPE,PTUUID,PARTUUID,LABEL,FSTYPE>);	2718	for my $bcd ($dev->{bcd_device}, $dev->{bcd_legacy_device}) {
2193
2194	for my $dev (@{ $lsblk->{blockdevices} }) {
2195	my $pr = sub {
2196	printf "%-10s %-8.8s %-6.6s %-3s %s\n",	2719	printf "%-10s %-8.8s %-6.6s %-3s %s\n",
2197	$dev->{path}, $dev->{label}, $dev->{fstype}, $dev->{pttype}, $_[0];	2720	$dev->{path}, $dev->{label}, $dev->{fstype}, $dev->{pttype}, $bcd
2198	};
2199
2200	if ($dev->{type} eq "part") {
2201	if ($dev->{pttype} eq "gpt") {
2202	$pr->("partition=<null>,harddisk,gpt,$dev->{ptuuid},$dev->{partuuid}");
2203	} elsif ($dev->{pttype} eq "dos") { # why not "mbr" :(
2204	if ($dev->{partuuid} =~ /^([0-9a-f]{8})-([0-9a-f]{2})\z/i) {
2205	my ($diskid, $partno) = ($1, hex $2);
2206	$pr->("legacypartition=<null>,harddisk,mbr,$diskid,$partno");
2207	if (open my $fh, "/sys/class/block/$dev->{kname}/start") {
2208	my $start = 512 * readline $fh;
2209	$pr->("partition=<null>,harddisk,mbr,$diskid,$start");
2210	}	2721	if $bcd;
2211	}
2212	}	2722	}
2213	}	2723	}
2214	}	2724	}
2215	},	2725	},
		2726
		2727	"bcd-device" => sub {
		2728	prdev shift, "bcd_device";
		2729	},
		2730
		2731	"bcd-legacy-device" => sub {
		2732	prdev shift, "bcd_legacy_device";
		2733	},
		2734
		2735	version => sub {
		2736	print "\n",
		2737	"PBCDEDIT version $VERSION, copyright 2019 Marc A. Lehmann <pbcdedit\@schmorp.de>.\n",
		2738	"JSON schema version: $JSON_VERSION\n",
		2739	"Licensed under the GNU General Public License Version 3.0, or any later version.\n",
		2740	"\n",
		2741	$CHANGELOG,
		2742	"\n";
		2743	},
2216	);	2744	);
2217		2745
2218	my $cmd = shift;	2746	my $cmd = shift;
2219		2747
2220	unless (exists $CMD{$cmd}) {	2748	unless (exists $CMD{$cmd}) {

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines