ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/pbcdedit/pbcdedit

Comparing pbcdedit/pbcdedit (file contents):
Revision 1.4 by root, Wed Aug 14 22:03:36 2019 UTC vs.
Revision 1.39 by root, Thu Aug 15 23:49:22 2019 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.2';
25	our $JSON_VERSION = 1; # the versiobn of the json objects generated by this program	25	our $JSON_VERSION = 2; # the version of the json objects generated by this program
		26
		27	our $CHANGELOG = <<EOF;
		28	1.2 Fri Aug 16 00:20:41 CEST 2019
		29	- bcde element names now depend on the bcd object type they are in,
		30	also affects "elements" output.
		31	- json schema bumped to 2.
		32	- new version command.
		33	- numerous minor bugfixes.
		34
		35	EOF
26		36
27	=head1 NAME	37	=head1 NAME
28		38
29	pbcdedit - portable boot configuration data (BCD) store editor	39	pbcdedit - portable boot configuration data (BCD) store editor
30		40
31	=head1 SYNOPSIS	41	=head1 SYNOPSIS
32		42
33	pbcdedit help # output manual page	43	pbcdedit help # output manual page
		44	pbcdedit version # output version and changelog
		45
34	pbcdedit export path/to/BCD # output BCD hive as JSON	46	pbcdedit export path/to/BCD # output BCD hive as JSON
35	pbcdedit import path/to/bcd # convert standard input to BCD hive	47	pbcdedit import path/to/BCD # convert standard input to BCD hive
36	pbcdedit edit path/to/BCD edit-instructions...	48	pbcdedit edit path/to/BCD edit-instructions...
37		49
38	pbcdedit objects # list all supported object aliases and types	50	pbcdedit objects # list all supported object aliases and types
39	pbcdedit elements # list all supported bcd element aliases	51	pbcdedit elements # list all supported bcd element aliases
40		52
41	=head1 DESCRIPTION	53	=head1 DESCRIPTION
42		54
43	This program allows you to create, read and modify Boot Configuration Data	55	This program allows you to create, read and modify Boot Configuration Data
44	(BCD) stores used by Windows Vista and newer versions of Windows.	56	(BCD) stores used by Windows Vista and newer versions of Windows.
45		57
		58	At this point, it is in relatively early stages of development and has
		59	received little to no real-world testing.
		60
46	Compared to other BCD editing programs it offers the following unique	61	Compared to other BCD editing programs it offers the following unique
47	features:	62	features:
48		63
49	=over	64	=over
50		65
…		…
55		70
56	=item Does not rely on Windows	71	=item Does not rely on Windows
57		72
58	As the "portable" in the name implies, this program does not rely on	73	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	74	C<bcdedit> or other windows programs or libraries, it works on any system
60	that supports at least perl version 5.14.	75	that supports at least perl version 5.16.
61		76
62	=item Decodes and encodes BCD device elements	77	=item Decodes and encodes BCD device elements
63		78
64	PBCDEDIT can concisely decode and encode BCD device element contents. This	79	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	80	is pretty unique, and offers a lot of potential that can't be realised
…		…
72	sensitive data.	87	sensitive data.
73		88
74	=back	89	=back
75		90
76	The target audience for this program is professionals and tinkerers who	91	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	92	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	93	program to use and requires patience and a good understanding of BCD
79	stores.	94	stores.
80		95
81		96
82	=head1 SUBCOMMANDS	97	=head1 SUBCOMMANDS
83		98
84	PCBEDIT expects a subcommand as first argument that tells it what to	99	PBCDEDIT expects a subcommand as first argument that tells it what to
85	do. The following subcommands exist:	100	do. The following subcommands exist:
86		101
87	=over	102	=over
88		103
89	=item help	104	=item C<help>
90		105
91	Displays the whole manuale page (this document).	106	Displays the whole manual page (this document).
92		107
		108	=item C<version>
		109
		110	This outputs the PBCDEDIT version, the JSON schema version it uses and the
		111	full log of changes.
		112
93	=item export F<path>	113	=item C<export> F<path>
94		114
95	Reads a BCD data store and writes a JSON representation of it to standard	115	Reads a BCD data store and writes a JSON representation of it to standard
96	output.	116	output.
97		117
98	The format of the data is explained later in this document.	118	The format of the data is explained later in this document.
99		119
100	Example: read a BCD store, modify it wiht an extenral program, write it again.	120	Example: read a BCD store, modify it with an external program, write it
		121	again.
101		122
102	pbcdedit export BCD | modify-json-somehow | pbcdedit import BCD	123	pbcdedit export BCD | modify-json-somehow | pbcdedit import BCD
103		124
104	=item import F<path>	125	=item C<import> F<path>
105		126
106	The reverse of C<export>: Reads a JSON representation of a BCD data store	127	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.	128	from standard input, and creates or replaces the given BCD data store.
108		129
109	=item edit F<path> instructions...	130	=item C<edit> F<path> I<instructions...>
110		131
111	#TODO	132	Load a BCD data store, apply some instructions to it, and save it again.
112		133
		134	See the section L<EDITING BCD STORES>, below, for more info.
		135
		136	=item C<parse> F<path> I<instructions...>
		137
		138	Same as C<edit>, above, except it doesn't save the data store again. Can
		139	be useful to extract some data from it.
		140
113	=item lsblk	141	=item C<lsblk>
114		142
115	On a GNU/Linux system, you can get a list of partition device descriptors	143	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	144	using this command - the external C<lsblk> command is required, as well as
117	a mounted C</sys> file system.	145	a mounted C</sys> file system.
118		146
119	The output will be a list of all partitions in the system and C<partition>	147	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>	148	descriptors for GPT and both C<legacypartition> and C<partition>
121	descritpors for MBR partitions.	149	descriptors for MBR partitions.
122		150
123	=item objects [--json]	151	=item C<objects> [C<--json>]
124		152
125	Outputs two tables: a table listing all type aliases with their hex bcd	153	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	154	element ID, and all object name aliases with their GUID and default type
127	(if any).	155	(if any).
128		156
129	With C<--json> it prints similar information as a JSON object, for easier parsing.	157	With C<--json> it prints similar information as a JSON object, for easier parsing.
130		158
131	=item elements [--json]	159	=item C<elements> [C<--json>]
132		160
133	Outputs a table of known element aliases with their hex ID and the format	161	Outputs a table of known element aliases with their hex ID and the format
134	type.	162	type.
135		163
136	With C<--json> it prints similar information as a JSON object, for easier parsing.	164	With C<--json> it prints similar information as a JSON object, for easier parsing.
137		165
138	=item export-regf F<path>	166	=item C<export-regf> F<path>
139		167
140	This has nothing to do with BCD data stores - it takes a registry hive	168	This has nothing to do with BCD stores, but simply exposes PCBEDIT's
		169	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	170	and outputs a JSON representation of it to standard output.
142	output.
143		171
144	Hive versions 1.2 till 1.6 are supported.	172	Hive versions 1.2 till 1.6 are supported.
145		173
146	=item import-regf F<path>	174	=item C<import-regf> F<path>
147		175
148	The reverse of C<export-regf>: reads a JSON representation of a registry	176	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	177	hive from standard input and creates or replaces the registry hive file
150	argument.	178	given as argument.
151		179
152	The written hive will always be in a slightly modified version 1.3	180	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	181	format. It's not the format windows would generate, but it should be
154	understood by any conformant hive reader.	182	understood by any conformant hive reader.
155		183
156	Note that the representation chosen by PBCDEDIT currently throws away	184	Note that the representation chosen by PBCDEDIT currently throws away
157	clasname data (often used for feeble attemtps at hiding stuff by	185	classname data (often used for feeble attempts at hiding stuff by
158	Microsoft) and security descriptors, so if you write anything other than	186	Microsoft) and security descriptors, so if you write anything other than
159	a BCD hive you will most likely destroy it.	187	a BCD hive you will most likely destroy it.
160		188
161	=back	189	=back
162		190
163		191
164	=head1 BCD DATA STORE REPRESENTATION FORMAT	192	=head1 BCD STORE REPRESENTATION FORMAT
165		193
166	A BCD data store is represented as a JSON object with one special key,	194	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	195	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>	196	one key-value pair in the object, and an additional key called C<meta>
169	contains meta information.	197	contains meta information.
…		…
205	}	233	}
206		234
207	=head2 Minimal BCD to boot windows	235	=head2 Minimal BCD to boot windows
208		236
209	Experimentally I found the following BCD is the minimum required to	237	Experimentally I found the following BCD is the minimum required to
210	successfully boot any post-XP version of Windows (suitable C<device> and	238	successfully boot any post-XP version of Windows (assuming suitable
211	C<osdevice> values, of course):	239	C<device> and C<osdevice> values, of course, and assuming a BIOS boot -
		240	for UEFI, you should use F<winload.efi> instead of F<winload.exe>):
212		241
213	{	242	{
214	"{bootmgr}" : {	243	"{bootmgr}" : {
215	"resumeobject" : "{45b547a7-8ca6-4417-9eb0-a257b61f35b4}"	244	"default" : "{45b547a7-8ca6-4417-9eb0-a257b61f35b4}"
216	},	245	},
217		246
218	"{45b547a7-8ca6-4417-9eb0-a257b61f35b1}" : {	247	"{45b547a7-8ca6-4417-9eb0-a257b61f35b1}" : {
219	"type" : "application::osloader",	248	"type" : "application::osloader",
220	"description" : "Windows Boot",	249	"description" : "Windows Boot",
…		…
232	=head2 The C<meta> key	261	=head2 The C<meta> key
233		262
234	The C<meta> key is not stored in the BCD data store but is used only	263	The C<meta> key is not stored in the BCD data store but is used only
235	by PBCDEDIT. It is always generated when exporting, and importing will	264	by PBCDEDIT. It is always generated when exporting, and importing will
236	be refused when it exists and the version stored inside doesn't store	265	be refused when it exists and the version stored inside doesn't store
237	the JSON schema version of PBCDEDIT. This ensures that differemt and	266	the JSON schema version of PBCDEDIT. This ensures that different and
238	incompatible versions of PBCDEDIT will not read and misinterüret each	267	incompatible versions of PBCDEDIT will not read and misinterpret each
239	others data.	268	others data.
240		269
241	=head2 The object keys	270	=head2 The object keys
242		271
243	Every other key is a BCD object. There is usually a BCD object for the	272	Every other key is a BCD object. There is usually a BCD object for the
244	boot manager, one for every boot option and a few others that store common	273	boot manager, one for every boot option and a few others that store common
245	settings inherited by these.	274	settings inherited by these.
246		275
247	Each BCD object is represented by a GUID wrapped in curly braces. These	276	Each BCD object is represented by a GUID wrapped in curly braces. These
248	are usually random GUIDs used only to distinguish bCD objects from each	277	are usually random GUIDs used only to distinguish BCD objects from each
249	other. When adding a new boot option, you can simply generate a new GUID.	278	other. When adding a new boot option, you can simply generate a new GUID.
250		279
251	Some of these GUIDs are fixed well known GUIDs which PBCDEDIT will decode	280	Some of these GUIDs are fixed well known GUIDs which PBCDEDIT will decode
252	into human-readable strings such as C<{globalsettings}>, which is the same	281	into human-readable strings such as C<{globalsettings}>, which is the same
253	as C<{7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}>.	282	as C<{7ea2e1ac-2e61-4728-aaa3-896d9d0a9f0e}>.
…		…
287	get a list of all BCD elements known to PBCDEDIT by running F<pbcdedit	316	get a list of all BCD elements known to PBCDEDIT by running F<pbcdedit
288	elements>.	317	elements>.
289		318
290	What was said about duplicate keys mapping to the same object is true for	319	What was said about duplicate keys mapping to the same object is true for
291	elements as well, so, again, you should always use the canonical name,	320	elements as well, so, again, you should always use the canonical name,
292	whcih is the human radable alias, if known.	321	which is the human readable alias, if known.
293		322
294	=head3 BCD element types	323	=head3 BCD element types
295		324
296	Each BCD element has a type such as I<string> or I<boolean>. This type	325	Each BCD element has a type such as I<string> or I<boolean>. This type
297	determines how the value is interpreted, and most of them are pretty easy	326	determines how the value is interpreted, and most of them are pretty easy
…		…
309	"description" : "Windows 10",	338	"description" : "Windows 10",
310	"systemroot" : "\\Windows",	339	"systemroot" : "\\Windows",
311		340
312	=item boolean	341	=item boolean
313		342
314	Almost as simnple are booleans, which represent I<true>/I<false>,	343	Almost as simple are booleans, which represent I<true>/I<false>,
315	I<on>/I<off> and similar values. In the JSON form, true is represented	344	I<on>/I<off> and similar values. In the JSON form, true is represented
316	by the number C<1>, and false is represented by the number C<0>. Other	345	by the number C<1>, and false is represented by the number C<0>. Other
317	values will be accepted, but PBCDEDIT doesn't guarantee how these are	346	values will be accepted, but PBCDEDIT doesn't guarantee how these are
318	interpreted.	347	interpreted.
319		348
…		…
325		354
326	=item integer	355	=item integer
327		356
328	Again, very simple, this is a 64 bit integer. IT can be either specified	357	Again, very simple, this is a 64 bit integer. IT can be either specified
329	as a decimal number, as a hex number (by prefixing it with C<0x>) or as a	358	as a decimal number, as a hex number (by prefixing it with C<0x>) or as a
330	binatry number (prefix C<0b>).	359	binary number (prefix C<0b>).
331		360
332	For example, the boot C<timeout> is an integer, specifying the automatic	361	For example, the boot C<timeout> is an integer, specifying the automatic
333	boot delay in seconds:	362	boot delay in seconds:
334		363
335	"timeout" : 30,	364	"timeout" : 30,
336		365
337	=item integer list	366	=item integer list
338		367
339	This is a list of 64 bit integers separated by whitespace. It is not used	368	This is a list of 64 bit integers separated by whitespace. It is not used
340	much, so here is a somewhat artificial an untested exanmple of using	369	much, so here is a somewhat artificial an untested example of using
341	C<customactions> to specify a certain custom, eh, action to be executed	370	C<customactions> to specify a certain custom, eh, action to be executed
342	when pressing C<F10> at boot:	371	when pressing C<F10> at boot:
343		372
344	"customactions" : "0x1000044000001 0x54000001",	373	"customactions" : "0x1000044000001 0x54000001",
345		374
346	=item guid	375	=item guid
347		376
348	This represents a single GUID value wrqapped in curly braces. It is used a	377	This represents a single GUID value wrapped in curly braces. It is used a
349	lot to refer from one BCD object to other one.	378	lot to refer from one BCD object to other one.
350		379
351	For example, The C<{bootmgr}> object might refer to a resume boot option	380	For example, The C<{bootmgr}> object might refer to a resume boot option
352	using C<resumeobject>:	381	using C<default>:
353		382
354	"resumeobject" : "{7ae02178-821d-11e7-8813-1c872c5f5ab0}",	383	"default" : "{7ae02178-821d-11e7-8813-1c872c5f5ab0}",
355		384
356	Human readable aliases are used and allowed.	385	Human readable aliases are used and allowed.
357		386
358	=item guid list	387	=item guid list
359		388
360	Similar to te guid type, this represents a list of such GUIDs, separated	389	Similar to the GUID type, this represents a list of such GUIDs, separated
361	by whitespace from each other.	390	by whitespace from each other.
362		391
363	For example, many BCD objects can I<inherit> elements from other BCD	392	For example, many BCD objects can I<inherit> elements from other BCD
364	objects by specifying the GUIDs of those other objects ina GUID list	393	objects by specifying the GUIDs of those other objects in a GUID list
365	called surprisingly called C<inherit>:	394	called surprisingly called C<inherit>:
366		395
367	"inherit" : "{dbgsettings} {emssettings} {badmemory}",	396	"inherit" : "{dbgsettings} {emssettings} {badmemory}",
368		397
369	This example also shows how human readable aliases can be used.	398	This example also shows how human readable aliases can be used.
…		…
378	=back	407	=back
379		408
380	=head4 The BCD "device" element type	409	=head4 The BCD "device" element type
381		410
382	Device elements specify, well, devices. They are used for such diverse	411	Device elements specify, well, devices. They are used for such diverse
383	purposes such as finding a TFTP network boot imagem serial ports or VMBUS	412	purposes such as finding a TFTP network boot image, serial ports or VMBUS
384	devices, but most commonly they are used to specify the disk (harddisk,	413	devices, but most commonly they are used to specify the disk (harddisk,
385	cdrom ramdisk, vhd...) to boot from.	414	cdrom, ramdisk, vhd...) to boot from.
386		415
387	The device element is kind of a mini-language in its own which is much	416	The device element is kind of a mini-language in its own which is much
388	more versatile then the limited windows interface to it - BCDEDIT -	417	more versatile then the limited windows interface to it - BCDEDIT -
389	reveals.	418	reveals.
390		419
…		…
393	element, so almost everything known about it had to be researched first	422	element, so almost everything known about it had to be researched first
394	in the process of writing this script, and consequently, support for BCD	423	in the process of writing this script, and consequently, support for BCD
395	device elements is partial only.	424	device elements is partial only.
396		425
397	On the other hand, the expressive power of PBCDEDIT in specifying devices	426	On the other hand, the expressive power of PBCDEDIT in specifying devices
398	is much bigger than BCDEDIT and therefore more cna be don with it. The	427	is much bigger than BCDEDIT and therefore more can be done with it. The
399	downside is that BCD device elements are much more complicated than what	428	downside is that BCD device elements are much more complicated than what
400	you might think from reading the BCDEDIT documentation.	429	you might think from reading the BCDEDIT documentation.
401		430
402	In other words, simple things are complicated, and complicated things are	431	In other words, simple things are complicated, and complicated things are
403	possible.	432	possible.
404		433
405	Anyway, the general syntax of device elements is an optional GUID,	434	Anyway, the general syntax of device elements is an optional GUID,
406	followed by a device type, optionally followed by hexdecimal flags in	435	followed by a device type, optionally followed by hexadecimal flags in
407	angle brackets, optionally followed by C<=> and a comma-separated list of	436	angle brackets, optionally followed by C<=> and a comma-separated list of
408	arguments, some of which can be (and often are) in turn devices again.	437	arguments, some of which can be (and often are) in turn devices again.
409		438
410	[{GUID}]type[<flags>][=arg,arg...]	439	[{GUID}]type[<flags>][=arg,arg...]
411		440
…		…
437	The types understood and used by PBCDEDIT are as follows (keep in mind	466	The types understood and used by PBCDEDIT are as follows (keep in mind
438	that not of all the following is necessarily supported in PBCDEDIT):	467	that not of all the following is necessarily supported in PBCDEDIT):
439		468
440	=over	469	=over
441		470
442	=item binary=hex...	471	=item C<binary=>I<hex...>
443		472
444	This type isn't actually a real BCD element type, but a fallback for those	473	This type isn't actually a real BCD element type, but a fallback for those
445	cases where PBCDEDIT can't perfectly decode a device element (except for	474	cases where PBCDEDIT can't perfectly decode a device element (except for
446	the leading GUID, which it can always decode). In such cases, it will	475	the leading GUID, which it can always decode). In such cases, it will
447	convert the device into this type with a hexdump of the element data.	476	convert the device into this type with a hexdump of the element data.
448		477
449	=item null	478	=item C<null>
450		479
451	This is another special type - sometimes, a device all zero-filled, which	480	This is another special type - sometimes, a device all zero-filled, which
452	is not valid. This can mark the absence of a device or something PBCDEDIT	481	is not valid. This can mark the absence of a device or something PBCDEDIT
453	does not understand, so it decodes it into this special "all zero" type	482	does not understand, so it decodes it into this special "all zero" type
454	called C<null>.	483	called C<null>.
455		484
456	It's most commonly found in devices that can use an optional parent	485	It's most commonly found in devices that can use an optional parent
457	device, when no parent device is used.	486	device, when no parent device is used.
458		487
459	=item boot	488	=item C<boot>
460		489
461	Another type without parameters, this refers to the device that was booted	490	Another type without parameters, this refers to the device that was booted
462	from (nowadays typically the EFI system partition).	491	from (nowadays typically the EFI system partition).
463		492
464	=item vmbus=interfacetype,interfaceinstance	493	=item C<vmbus=>I<interfacetype>,I<interfaceinstance>
465		494
466	This specifies a VMBUS device with the given interface type and interface	495	This specifies a VMBUS device with the given interface type and interface
467	instance, both of which are "naked" (no curly braces) GUIDs.	496	instance, both of which are "naked" (no curly braces) GUIDs.
468		497
469	Made-up example (couldn't find a single example on the web):	498	Made-up example (couldn't find a single example on the web):
470		499
471	vmbus=c376c1c3-d276-48d2-90a9-c04748072c60,12345678-a234-b234-c234-d2345678abcd	500	vmbus=c376c1c3-d276-48d2-90a9-c04748072c60,12345678-a234-b234-c234-d2345678abcd
472		501
473	=item partition=<parent>,devicetype,partitiontype,diskid,partitionid	502	=item C<partition=><I<parent>>,I<devicetype>,I<partitiontype>,I<diskid>,I<partitionid>
474		503
475	This designates a specific partition on a block device. C<< <parent>	504	This designates a specific partition on a block device. I<parent> is an
476	>> is an optional parent device on which to search on, and is often	505	optional parent device on which to search on, and is often C<null>. Note
477	C<null>. Note that the anfgle brackets are part of the syntax.	506	that the angle brackets around I<parent> are part of the syntax.
478		507
479	C<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,	508	I<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,
480	C<file> or C<vhd>, where the first three should be self-explaining,	509	C<file> or C<vhd>, where the first three should be self-explaining,
481	C<file> is usually used to locate a device by finding a magic file, and	510	C<file> is usually used to locate a file to be used as a disk image,
482	C<vhd> is used for virtual harddisks - F<.vhd> and F<-vhdx> files.	511	and C<vhd> is used to treat files as virtual harddisks, i.e. F<vhd> and
		512	F<vhdx> files.
483		513
484	The C<partitiontype> is either C<mbr>, C<gpt> or C<raw>, the latter being	514	The I<partitiontype> is either C<mbr>, C<gpt> or C<raw>, the latter being
485	used for devices without partitions, such as cdroms, where the "partition"	515	used for devices without partitions, such as cdroms, where the "partition"
486	is usually the whole device.	516	is usually the whole device.
487		517
488	The C<diskid> identifies the disk or device using a unique signature, and	518	The I<diskid> identifies the disk or device using a unique signature, and
489	the same is true for the C<partitionid>. How these are interpreted depends	519	the same is true for the I<partitionid>. How these are interpreted depends
490	on the C<partitiontype>:	520	on the I<partitiontype>:
491		521
492	=over	522	=over
493		523
494	=item mbr	524	=item C<mbr>
495		525
496	The C<diskid> is the 32 bit disk signature stored at offset 0x1b8 in the	526	The C<diskid> is the 32 bit disk signature stored at offset 0x1b8 in the
497	MBR, interpreted as a 32 bit unsigned little endian integer and written as	527	MBR, interpreted as a 32 bit unsigned little endian integer and written as
498	hex number. That is, the bytes C<01 02 03 04> would become C<04030201>.	528	hex number. That is, the bytes C<01 02 03 04> would become C<04030201>.
499		529
500	Diskpart (using the C<DETAIL> command) and the C<lsblk> comamnd typically	530	Diskpart (using the C<DETAIL> command) and the C<lsblk> command typically
501	found on GNU/Linux systems (using e.g. C<lsblk -o NAME,PARTUUID>) can	531	found on GNU/Linux systems (using e.g. C<lsblk -o NAME,PARTUUID>) can
502	display the disk id.	532	display the I<diskid>.
503		533
504	The C<partitionid> is the byte offset(!) of the partition counting from	534	The I<partitionid> is the byte offset(!) of the partition counting from
505	the beginning of the MBR.	535	the beginning of the MBR.
506		536
507	Example, use the partition on the harddisk with C<diskid> C<47cbc08a>	537	Example, use the partition on the harddisk with I<diskid> C<47cbc08a>
508	starting at sector C<2048> (= 1048576 / 512).	538	starting at sector C<2048> (= 1048576 / 512).
509		539
510	partition=<null>,harddisk,mbr,47cbc08a,1048576	540	partition=<null>,harddisk,mbr,47cbc08a,1048576
511		541
512	=item gpt	542	=item C<gpt>
513		543
514	The C<diskid> is the disk UUID/disk identifier GUID from the partition	544	The I<diskid> is the disk GUID/disk identifier GUID from the partition
515	table (as displayed e.g. by C<gdisk>), and the C<partitionid> is the	545	table (as displayed e.g. by F<gdisk>), and the I<partitionid> is the
516	partition unique GUID (displayed using e.g. the C<gdisk> C<i> command).	546	partition unique GUID (displayed using e.g. the F<gdisk> F<i> command).
517		547
518	Example: use the partition C<76d39e5f-ad1b-407e-9c05-c81eb83b57dd> on GPT	548	Example: use the partition C<76d39e5f-ad1b-407e-9c05-c81eb83b57dd> on GPT
519	disk C<9742e468-9206-48a0-b4e4-c4e9745a356a>.	549	disk C<9742e468-9206-48a0-b4e4-c4e9745a356a>.
520		550
521	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd	551	partition=<null>,harddisk,gpt,9742e468-9206-48a0-b4e4-c4e9745a356a,76d39e5f-ad1b-407e-9c05-c81eb83b57dd
522		552
523	=item raw	553	=item C<raw>
524		554
525	Instead of diskid and partitionid, this type only accepts a decimal disk	555	Instead of I<diskid> and I<partitionid>, this type only accepts a decimal
526	number and signifies the whole disk. BCDEDIT cannot display the resulting	556	disk number and signifies the whole disk. BCDEDIT cannot display the
527	device, and I am doubtful whether it has a useful effect.	557	resulting device, and I am doubtful whether it has a useful effect.
528		558
529	=back	559	=back
530		560
531	=item legacypartition=<parent>,devicetype,partitiontype,diskid,partitionid	561	=item C<legacypartition=><I<parent>>,I<devicetype>,I<partitiontype>,I<diskid>,I<partitionid>
532		562
533	This is exactly the same as the C<partition> type, except for a tiny	563	This is exactly the same as the C<partition> type, except for a tiny
534	detail: instead of using the partition start offset, this type uses the	564	detail: instead of using the partition start offset, this type uses the
535	partition number for MBR disks. Behaviour other partition types should be	565	partition number for MBR disks. Behaviour other partition types should be
536	the same.	566	the same.
537		567
538	The partition number starts at C<1> and skips unused partition, so if	568	The partition number starts at C<1> and skips unused partition, so if
539	there are two primary partitions and another partition inside the extended	569	there are two primary partitions and another partition inside the extended
540	partition, the primary partitions are number C<1> and C<2> and the	570	partition, the primary partitions are number C<1> and C<2> and the
541	partition inside the extended partition is number C<3>, rwegardless of any	571	partition inside the extended partition is number C<3>, regardless of any
542	gaps.	572	gaps.
543		573
544	=item locate=<parent>,locatetype,locatearg	574	=item C<locate=><I<parent>>,I<locatetype>,I<locatearg>
545		575
546	This device description will make the bootloader search for a partition	576	This device description will make the bootloader search for a partition
547	with a given path.	577	with a given path.
548		578
549	The C<< <parent> >> device is the device to search on (angle brackets are	579	The I<parent> device is the device to search on (angle brackets are
550	still part of the syntax!) If it is C<< <null> >>, then C<locate> will	580	still part of the syntax!) If it is C<null>, then C<locate> will
551	search all disks it can find.	581	search all disks it can find.
552		582
553	C<locatetype> is either C<element> or C<path>, and merely distinguishes	583	I<locatetype> is either C<element> or C<path>, and merely distinguishes
554	between two different ways to specify the path to search for: C<element>	584	between two different ways to specify the path to search for: C<element>
555	uses an element ID (either as hex or as name) as C<locatearg> and C<path>	585	uses an element ID (either as hex or as name) as I<locatearg> and C<path>
556	uses a relative path as C<locatearg>.	586	uses a relative path as I<locatearg>.
557		587
558	Example: find any partition which has the C<magicfile.xxx> path in the	588	Example: find any partition which has the F<magicfile.xxx> path in the
559	root.	589	root.
560		590
561	locate=<null>,path,\magicfile.xxx	591	locate=<null>,path,\magicfile.xxx
562		592
563	Example: find any partition which has the path specified in the	593	Example: find any partition which has the path specified in the
564	C<systemroot> element (typically C<\Windows>).	594	C<systemroot> element (typically F<\Windows>).
565		595
566	locate=<null>,element,systemroot	596	locate=<null>,element,systemroot
567		597
568	=item block=devicetype,args...	598	=item C<block=>I<devicetype>,I<args...>
569		599
570	Last not least, the most complex type, C<block>, which... specifies block	600	Last not least, the most complex type, C<block>, which... specifies block
571	devices (which could be inside a F<vhdx> file for example).	601	devices (which could be inside a F<vhdx> file for example).
572		602
573	C<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,	603	I<devicetypes> is one of C<harddisk>, C<floppy>, C<cdrom>, C<ramdisk>,
574	C<file> or C<vhd> - the same as for C<partiion=>.	604	C<file> or C<vhd> - the same as for C<partiion=>.
575		605
576	The remaining arguments change depending on the C<devicetype>:	606	The remaining arguments change depending on the I<devicetype>:
577		607
578	=over	608	=over
579		609
580	=item block=file,<parent>,path	610	=item C<block=file>,<I<parent>>,I<path>
581		611
582	Interprets the C<< <parent> >> device (typically a partition) as a	612	Interprets the I<parent> device (typically a partition) as a
583	filesystem and specifies a file path inside.	613	filesystem and specifies a file path inside.
584		614
585	=item block=vhd,<parent>	615	=item C<block=vhd>,<I<parent>>
586		616
587	Pretty much just changes the interpretation of C<< <parent> >>, which is	617	Pretty much just changes the interpretation of I<parent>, which is
588	usually a disk image (C<block=file,...)>) to be a F<vhd> or F<vhdx> file.	618	usually a disk image (C<block=file,...)>) to be a F<vhd> or F<vhdx> file.
589		619
590	=item block=ramdisk,<parent>,base,size,offset,path	620	=item C<block=ramdisk>,<I<parent>>,I<base>,I<size>,I<offset>,I<path>
591		621
592	Interprets the C<< <parent> >> device as RAM disk, using the (decimal)	622	Interprets the I<parent> device as RAM disk, using the (decimal)
593	base address, byte size and byte offset inside a file specified by	623	base address, byte size and byte offset inside a file specified by
594	C<path>. The numbers are usually all C<0> because they cna be extracted	624	I<path>. The numbers are usually all C<0> because they can be extracted
595	from the RAM disk image or other parameters.	625	from the RAM disk image or other parameters.
596		626
597	This is most commonly used to boot C<wim> images.	627	This is most commonly used to boot C<wim> images.
598		628
599	=item block=floppy,drivenum	629	=item C<block=floppy>,I<drivenum>
600		630
601	Refers to a removable drive identified by a number. BCDEDIT cannot display	631	Refers to a removable drive identified by a number. BCDEDIT cannot display
602	the resultinfg device, and it is not clear what effect it will have.	632	the resulting device, and it is not clear what effect it will have.
603		633
604	=item block=cdrom,drivenum	634	=item C<block=cdrom>,I<drivenum>
605		635
606	Pretty much the same as C<floppy> but for CD-ROMs.	636	Pretty much the same as C<floppy> but for CD-ROMs.
607		637
608	=item anything else	638	=item anything else
609		639
…		…
613		643
614	=back5 Examples	644	=back5 Examples
615		645
616	This concludes the syntax overview for device elements, but probably	646	This concludes the syntax overview for device elements, but probably
617	leaves many questions open. I can't help with most of them, as I also ave	647	leaves many questions open. I can't help with most of them, as I also ave
618	many questions, but I can walk you through some actual examples using mroe	648	many questions, but I can walk you through some actual examples using more
619	complex aspects.	649	complex aspects.
620		650
621	=item locate=<block=vhd,<block=file,<locate=<null>,path,\disk.vhdx>,\disk.vhdx>>,element,path	651	=item C<< locate=<block=vhd,<block=file,<locate=<null>,path,\disk.vhdx>,\disk.vhdx>>,element,path >>
622		652
623	Just like with C declarations, you best treat device descriptors as	653	Just like with C declarations, you best treat device descriptors as
624	instructions to find your device and work your way from the inside out:	654	instructions to find your device and work your way from the inside out:
625		655
626	locate=<null>,path,\disk.vhdx	656	locate=<null>,path,\disk.vhdx
…		…
633	Next, this takes the device locate has found and finds a file called	663	Next, this takes the device locate has found and finds a file called
634	F<\disk.vhdx> on it. This is the same file locate was using, but that is	664	F<\disk.vhdx> on it. This is the same file locate was using, but that is
635	only because we find the device using the same path as finding the disk	665	only because we find the device using the same path as finding the disk
636	image, so this is purely incidental, although quite common.	666	image, so this is purely incidental, although quite common.
637		667
638	Bext, this file will be opened as a virtual disk:	668	Next, this file will be opened as a virtual disk:
639		669
640	block=vhd,<see above>	670	block=vhd,<see above>
641		671
642	And finally, inside this disk, another C<locate> will look for a partition	672	And finally, inside this disk, another C<locate> will look for a partition
643	with a path as specified in the C<path> element, which most likely will be	673	with a path as specified in the C<path> element, which most likely will be
…		…
646	locate=<see above>,element,path	676	locate=<see above>,element,path
647		677
648	As a result, this will boot the first Windows it finds on the first	678	As a result, this will boot the first Windows it finds on the first
649	F<disk.vhdx> disk image it can find anywhere.	679	F<disk.vhdx> disk image it can find anywhere.
650		680
651	=item locate=<block=vhd,<block=file,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,\win10.vhdx>>,element,path	681	=item C<< locate=<block=vhd,<block=file,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,\win10.vhdx>>,element,path >>
652		682
653	Pretty much the same as the previous case, but witzh a bit of variance. First, look for a specific partition on	683	Pretty much the same as the previous case, but with a bit of
654	an MBR-partitioned disk:	684	variance. First, look for a specific partition on an MBR-partitioned disk:
655		685
656	partition=<null>,harddisk,mbr,47cbc08a,242643632128	686	partition=<null>,harddisk,mbr,47cbc08a,242643632128
657		687
658	Then open the file F<\win10.vhdx> on that partition:	688	Then open the file F<\win10.vhdx> on that partition:
659		689
…		…
665		695
666	And again the windows loader (or whatever is in C<path>) will be searched:	696	And again the windows loader (or whatever is in C<path>) will be searched:
667		697
668	locate=<see above>,element,path	698	locate=<see above>,element,path
669		699
670	=item {b097d2b2-bc00-11e9-8a9a-525400123456}block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,0,0,0,\boot.wim	700	=item C<< {b097d2b2-bc00-11e9-8a9a-525400123456}block<1>=ramdisk,<partition=<null>,harddisk,mbr,47cbc08a,242643632128>,0,0,0,\boot.wim >>
671		701
672	This is quite different. First, it starts with a GUID. This GUID belongs	702	This is quite different. First, it starts with a GUID. This GUID belongs
673	to a BCD object of type C<device>, which has additional parameters:	703	to a BCD object of type C<device>, which has additional parameters:
674		704
675	"{b097d2b2-bc00-11e9-8a9a-525400123456}" : {	705	"{b097d2b2-bc00-11e9-8a9a-525400123456}" : {
…		…
678	"ramdisksdidevice" : "partition=<null>,harddisk,mbr,47cbc08a,1048576",	708	"ramdisksdidevice" : "partition=<null>,harddisk,mbr,47cbc08a,1048576",
679	"ramdisksdipath" : "\boot.sdi"	709	"ramdisksdipath" : "\boot.sdi"
680	},	710	},
681		711
682	I will not go into many details, but this specifies a (presumably empty)	712	I will not go into many details, but this specifies a (presumably empty)
683	template ramdisk image (F<\boot.sdi>) that is used to initiaolize the	713	template ramdisk image (F<\boot.sdi>) that is used to initialize the
684	ramdisk. The F<\boot.wim> file is then extracted into it. As you cna also	714	ramdisk. The F<\boot.wim> file is then extracted into it. As you can also
685	see, this F<.sdi> file resides on a different C<partition>.	715	see, this F<.sdi> file resides on a different C<partition>.
686		716
687	Continuitn, as always, form the inside out, first this device descriptor	717	Continuing, as always, from the inside out, first this device descriptor
688	finds a specific partition:	718	finds a specific partition:
689		719
690	partition=<null>,harddisk,mbr,47cbc08a,242643632128	720	partition=<null>,harddisk,mbr,47cbc08a,242643632128
691		721
692	And then specifies a C<ramdisk> image on this partition:	722	And then specifies a C<ramdisk> image on this partition:
693		723
694	block<1>=ramdisk,<see above>,0,0,0,\boot.wim	724	block<1>=ramdisk,<see above>,0,0,0,\boot.wim
695		725
696	I don't know what the purpose ofd the C<< <1> >> flag value is, but it	726	I don't know what the purpose of the C<< <1> >> flag value is, but it
697	seems to be always there on this kind of entry.	727	seems to be always there on this kind of entry.
698		728
		729	If you have some good examples to add here, feel free to mail me.
		730
		731
		732	=head1 EDITING BCD STORES
		733
		734	The C<edit> and C<parse> subcommands allow you to read a BCD data store
		735	and modify it or extract data from it. This is done by executing a series
		736	of "editing instructions" which are explained here.
		737
		738	=over
		739
		740	=item C<get> I<object> I<element>
		741
		742	Reads the BCD element I<element> from the BCD object I<object> and writes
		743	it to standard output, followed by a newline. The I<object> can be a GUID
		744	or a human-readable alias, or the special string C<{default}>, which will
		745	refer to the default BCD object.
		746
		747	Example: find description of the default BCD object.
		748
		749	pbcdedit parse BCD get "{default}" description
		750
		751	=item C<set> I<object> I<element> I<value>
		752
		753	Similar to C<get>, but sets the element to the given I<value> instead.
		754
		755	Example: change the bootmgr default too
		756	C<{b097d2ad-bc00-11e9-8a9a-525400123456}>:
		757
		758	pbcdedit edit BCD set "{bootmgr}" default "{b097d2ad-bc00-11e9-8a9a-525400123456}"
		759
		760	=item C<eval> I<perlcode>
		761
		762	This takes the next argument, interprets it as Perl code and
		763	evaluates it. This allows you to do more complicated modifications or
		764	extractions.
		765
		766	The following variables are predefined for your use:
		767
		768	=over
		769
		770	=item C<$PATH>
		771
		772	The path to the BCD data store, as given to C<edit> or C<parse>.
		773
		774	=item C<$BCD>
		775
		776	The decoded BCD data store.
		777
		778	=item C<$DEFAULT>
		779
		780	The default BCD object name.
		781
		782	=back
		783
		784	The example given for C<get>, above, could be expressed like this with
		785	C<eval>:
		786
		787	pbcdedit edit BCD eval 'say $BCD->{$DEFAULT}{description}'
		788
		789	The example given for C<set> could be expressed like this:
		790
		791	pbcdedit edit BCD eval '$BCD->{"{bootmgr}"{default} = "{b097d2ad-bc00-11e9-8a9a-525400123456}"'
		792
		793	=item C<do> I<path>
		794
		795	Similar to C<eval>, above, but instead of using the argument as perl code,
		796	it loads the perl code from the given file and executes it. This makes it
		797	easier to write more complicated or larger programs.
		798
		799	=back
		800
699		801
700	=head1 SEE ALSO	802	=head1 SEE ALSO
701		803
702	For ideas on what you can do, and some introductory material, try	804	For ideas on what you can do with BCD stores in
		805	general, and some introductory material, try
703	L<http://www.mistyprojects.co.uk/documents/BCDEdit/index.html>.	806	L<http://www.mistyprojects.co.uk/documents/BCDEdit/index.html>.
704		807
705	For good reference on BCD objects and elements, see Geoff Chappels pages	808	For good reference on which BCD objects and
		809	elements exist, see Geoff Chappell's pages at
706	at L<http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm>.	810	L<http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm>.
707		811
708	=head1 AUTHOR	812	=head1 AUTHOR
709		813
710	Written by Marc A. Lehmann <pbcdedit@schmorp.de>.	814	Written by Marc A. Lehmann L<pbcdedit@schmorp.de>.
711		815
712	=head1 REPORTING BUGS	816	=head1 REPORTING BUGS
713		817
714	Bugs can be reported dorectly tt he author at L<pcbedit@schmorp.de>.	818	Bugs can be reported directly the author at L<pcbedit@schmorp.de>.
715		819
716	=head1 BUGS AND SHORTCOMINGS	820	=head1 BUGS AND SHORTCOMINGS
717		821
718	This should be a module. Of a series of modules, even.	822	This should be a module. Of a series of modules, even.
719		823
720	Registry code should preserve classname and security descriptor data, and	824	Registry code should preserve classname and security descriptor data, and
721	whatever else is necessary to read and write any registry hive file.	825	whatever else is necessary to read and write any registry hive file.
722		826
723	I am also not happy with device descriptors being strings rather than a	827	I am also not happy with device descriptors being strings rather than a
724	data structure, but strings are probably better for command line usage. In	828	data structure, but strings are probably better for command line usage. In
725	any case,. device descriptors could be converted by simply "splitting" at	829	any case, device descriptors could be converted by simply "splitting" at
726	"=" and "," into an array reference, recursively.	830	"=" and "," into an array reference, recursively.
727		831
728	=head1 HOMEPAGE	832	=head1 HOMEPAGE
729		833
730	Original versions of this program can be found at	834	Original versions of this program can be found at
…		…
737	free to change and redistribute it. There is NO WARRANTY, to the extent	841	free to change and redistribute it. There is NO WARRANTY, to the extent
738	permitted by law.	842	permitted by law.
739		843
740	=cut	844	=cut
741		845
742	BEGIN { require "common/sense.pm"; common::sense->import } # common sense is optional, but recommended	846	# common sense is optional, but recommended
		847	BEGIN { eval { require "common/sense.pm"; } && common::sense->import }
743		848
744	use Data::Dump;	849	no warnings 'portable'; # avoid 32 bit integer warnings
		850
745	use Encode ();	851	use Encode ();
746	use List::Util ();	852	use List::Util ();
747	use IO::Handle ();	853	use IO::Handle ();
748	use Time::HiRes ();	854	use Time::HiRes ();
749		855
…		…
760	sub xxd($$) {	866	sub xxd($$) {
761	open my $xxd, "| xxd | sed -e 's/^/\Q$_[0]\E: /'";	867	open my $xxd, "| xxd | sed -e 's/^/\Q$_[0]\E: /'";
762	syswrite $xxd, $_[1];	868	syswrite $xxd, $_[1];
763	}	869	}
764		870
		871	sub file_load($) {
		872	my ($path) = @_;
		873
		874	open my $fh, "<:raw", $path
		875	or die "$path: $!\n";
		876	my $size = -s $fh;
		877	$size = read $fh, my $buf, $size
		878	or die "$path: short read\n";
		879
		880	$buf
		881	}
		882
765	# sources and resources used for this:	883	# sources and resources used for writing pbcdedit
		884	#
766	# registry:	885	# registry:
767	# https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md	886	# https://github.com/msuhanov/regf/blob/master/Windows%20registry%20file%20format%20specification.md
768	# http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/	887	# http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/
769	# bcd:	888	# bcd:
770	# http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm	889	# http://www.geoffchappell.com/notes/windows/boot/bcd/index.htm
…		…
1118	}	1237	}
1119		1238
1120	# load and parse registry from file	1239	# load and parse registry from file
1121	sub regf_load($) {	1240	sub regf_load($) {
1122	my ($path) = @_;	1241	my ($path) = @_;
1123	open my $regf, "<:raw", $path
1124	or die "$path: $!\n";
1125	my $size = -s $regf;
1126	$size = read $regf, my $buf, $size
1127	or die "$path: short read\n";
1128		1242
1129	regf_decode $buf	1243	regf_decode file_load $path
1130	}	1244	}
1131		1245
1132	# encode and save registry to file	1246	# encode and save registry to file
1133	sub regf_save {	1247	sub regf_save {
1134	my ($path, $hive) = @_;	1248	my ($path, $hive) = @_;
…		…
1263	sub BCDE_FORMAT_GUID_LIST () { 0x04000000 }	1377	sub BCDE_FORMAT_GUID_LIST () { 0x04000000 }
1264	sub BCDE_FORMAT_INTEGER () { 0x05000000 }	1378	sub BCDE_FORMAT_INTEGER () { 0x05000000 }
1265	sub BCDE_FORMAT_BOOLEAN () { 0x06000000 }	1379	sub BCDE_FORMAT_BOOLEAN () { 0x06000000 }
1266	sub BCDE_FORMAT_INTEGER_LIST () { 0x07000000 }	1380	sub BCDE_FORMAT_INTEGER_LIST () { 0x07000000 }
1267		1381
1268	sub dec_device;
1269	sub enc_device;
1270
1271	sub enc_integer($) {	1382	sub enc_integer($) {
1272	no warnings 'portable'; # ugh
1273	my $value = shift;	1383	my $value = shift;
1274	$value = oct $value if $value =~ /^0[bBxX]/;	1384	$value = oct $value if $value =~ /^0[bBxX]/;
1275	unpack "H*", pack "Q<", $value	1385	unpack "H*", pack "Q<", $value
1276	}	1386	}
		1387
		1388	sub enc_device($$);
		1389	sub dec_device($$);
1277		1390
1278	our %bcde_dec = (	1391	our %bcde_dec = (
1279	BCDE_FORMAT_DEVICE , \&dec_device,	1392	BCDE_FORMAT_DEVICE , \&dec_device,
1280	# # for round-trip verification	1393	# # for round-trip verification
1281	# BCDE_FORMAT_DEVICE , sub {	1394	# BCDE_FORMAT_DEVICE , sub {
…		…
1291	BCDE_FORMAT_BOOLEAN , sub { shift eq "00" ? 0 : 1 },	1404	BCDE_FORMAT_BOOLEAN , sub { shift eq "00" ? 0 : 1 },
1292	BCDE_FORMAT_INTEGER_LIST, sub { join " ", unpack "Q*", pack "H*", shift }, # not sure if this cna be 4 bytes	1405	BCDE_FORMAT_INTEGER_LIST, sub { join " ", unpack "Q*", pack "H*", shift }, # not sure if this cna be 4 bytes
1293	);	1406	);
1294		1407
1295	our %bcde_enc = (	1408	our %bcde_enc = (
1296	BCDE_FORMAT_DEVICE , sub { binary => enc_device shift },	1409	BCDE_FORMAT_DEVICE , sub { binary => enc_device $_[0], $_[1] },
1297	BCDE_FORMAT_STRING , sub { sz => shift },	1410	BCDE_FORMAT_STRING , sub { sz => shift },
1298	BCDE_FORMAT_GUID , sub { sz => "{" . (dec_guid enc_wguid shift) . "}" },	1411	BCDE_FORMAT_GUID , sub { sz => "{" . (dec_guid enc_wguid shift) . "}" },
1299	BCDE_FORMAT_GUID_LIST , sub { multi_sz => [map "{" . (dec_guid enc_wguid $_) . "}", split /\s+/, shift ] },	1412	BCDE_FORMAT_GUID_LIST , sub { multi_sz => [map "{" . (dec_guid enc_wguid $_) . "}", split /\s+/, shift ] },
1300	BCDE_FORMAT_INTEGER , sub { binary => enc_integer shift },	1413	BCDE_FORMAT_INTEGER , sub { binary => enc_integer shift },
1301	BCDE_FORMAT_BOOLEAN , sub { binary => shift ? "01" : "00" },	1414	BCDE_FORMAT_BOOLEAN , sub { binary => shift ? "01" : "00" },
1302	BCDE_FORMAT_INTEGER_LIST, sub { binary => join "", map enc_integer $_, split /\s+/, shift },	1415	BCDE_FORMAT_INTEGER_LIST, sub { binary => join "", map enc_integer $_, split /\s+/, shift },
1303	);	1416	);
1304		1417
1305	# BCD Elements	1418	# BCD Elements
1306	our %bcde = (	1419	our %bcde_byclass = (
		1420	any => {
1307	0x11000001 => 'device',	1421	0x11000001 => 'device',
1308	0x12000002 => 'path',	1422	0x12000002 => 'path',
1309	0x12000004 => 'description',	1423	0x12000004 => 'description',
1310	0x12000005 => 'locale',	1424	0x12000005 => 'locale',
1311	0x14000006 => 'inherit',	1425	0x14000006 => 'inherit',
1312	0x15000007 => 'truncatememory',	1426	0x15000007 => 'truncatememory',
1313	0x14000008 => 'recoverysequence',	1427	0x14000008 => 'recoverysequence',
1314	0x16000009 => 'recoveryenabled',	1428	0x16000009 => 'recoveryenabled',
1315	0x1700000a => 'badmemorylist',	1429	0x1700000a => 'badmemorylist',
1316	0x1600000b => 'badmemoryaccess',	1430	0x1600000b => 'badmemoryaccess',
1317	0x1500000c => 'firstmegabytepolicy',	1431	0x1500000c => 'firstmegabytepolicy',
1318	0x1500000d => 'relocatephysical',	1432	0x1500000d => 'relocatephysical',
1319	0x1500000e => 'avoidlowmemory',	1433	0x1500000e => 'avoidlowmemory',
1320	0x1600000f => 'traditionalkseg',	1434	0x1600000f => 'traditionalkseg',
1321	0x16000010 => 'bootdebug',	1435	0x16000010 => 'bootdebug',
1322	0x15000011 => 'debugtype',	1436	0x15000011 => 'debugtype',
1323	0x15000012 => 'debugaddress',	1437	0x15000012 => 'debugaddress',
1324	0x15000013 => 'debugport',	1438	0x15000013 => 'debugport',
1325	0x15000014 => 'baudrate',	1439	0x15000014 => 'baudrate',
1326	0x15000015 => 'channel',	1440	0x15000015 => 'channel',
1327	0x12000016 => 'targetname',	1441	0x12000016 => 'targetname',
1328	0x16000017 => 'noumex',	1442	0x16000017 => 'noumex',
1329	0x15000018 => 'debugstart',	1443	0x15000018 => 'debugstart',
1330	0x12000019 => 'busparams',	1444	0x12000019 => 'busparams',
1331	0x1500001a => 'hostip',	1445	0x1500001a => 'hostip',
1332	0x1500001b => 'port',	1446	0x1500001b => 'port',
1333	0x1600001c => 'dhcp',	1447	0x1600001c => 'dhcp',
1334	0x1200001d => 'key',	1448	0x1200001d => 'key',
1335	0x1600001e => 'vm',	1449	0x1600001e => 'vm',
1336	0x16000020 => 'bootems',	1450	0x16000020 => 'bootems',
1337	0x15000022 => 'emsport',	1451	0x15000022 => 'emsport',
1338	0x15000023 => 'emsbaudrate',	1452	0x15000023 => 'emsbaudrate',
1339	0x12000030 => 'loadoptions',	1453	0x12000030 => 'loadoptions',
1340	0x16000040 => 'advancedoptions',	1454	0x16000040 => 'advancedoptions',
1341	0x16000041 => 'optionsedit',	1455	0x16000041 => 'optionsedit',
1342	0x15000042 => 'keyringaddress',	1456	0x15000042 => 'keyringaddress',
1343	0x11000043 => 'bootstatdevice',	1457	0x11000043 => 'bootstatdevice',
1344	0x12000044 => 'bootstatfilepath',	1458	0x12000044 => 'bootstatfilepath',
1345	0x16000045 => 'preservebootstat',	1459	0x16000045 => 'preservebootstat',
1346	0x16000046 => 'graphicsmodedisabled',	1460	0x16000046 => 'graphicsmodedisabled',
1347	0x15000047 => 'configaccesspolicy',	1461	0x15000047 => 'configaccesspolicy',
1348	0x16000048 => 'nointegritychecks',	1462	0x16000048 => 'nointegritychecks',
1349	0x16000049 => 'testsigning',	1463	0x16000049 => 'testsigning',
1350	0x1200004a => 'fontpath',	1464	0x1200004a => 'fontpath',
1351	0x1500004b => 'integrityservices',	1465	0x1500004b => 'integrityservices',
1352	0x1500004c => 'volumebandid',	1466	0x1500004c => 'volumebandid',
1353	0x16000050 => 'extendedinput',	1467	0x16000050 => 'extendedinput',
1354	0x15000051 => 'initialconsoleinput',	1468	0x15000051 => 'initialconsoleinput',
1355	0x15000052 => 'graphicsresolution',	1469	0x15000052 => 'graphicsresolution',
1356	0x16000053 => 'restartonfailure',	1470	0x16000053 => 'restartonfailure',
1357	0x16000054 => 'highestmode',	1471	0x16000054 => 'highestmode',
1358	0x16000060 => 'isolatedcontext',	1472	0x16000060 => 'isolatedcontext',
1359	0x15000065 => 'displaymessage',	1473	0x15000065 => 'displaymessage',
1360	0x15000066 => 'displaymessageoverride',	1474	0x15000066 => 'displaymessageoverride',
1361	0x16000068 => 'nobootuxtext',	1475	0x16000068 => 'nobootuxtext',
1362	0x16000069 => 'nobootuxprogress',	1476	0x16000069 => 'nobootuxprogress',
1363	0x1600006a => 'nobootuxfade',	1477	0x1600006a => 'nobootuxfade',
1364	0x1600006b => 'bootuxreservepooldebug',	1478	0x1600006b => 'bootuxreservepooldebug',
1365	0x1600006c => 'bootuxdisabled',	1479	0x1600006c => 'bootuxdisabled',
1366	0x1500006d => 'bootuxfadeframes',	1480	0x1500006d => 'bootuxfadeframes',
1367	0x1600006e => 'bootuxdumpstats',	1481	0x1600006e => 'bootuxdumpstats',
1368	0x1600006f => 'bootuxshowstats',	1482	0x1600006f => 'bootuxshowstats',
1369	0x16000071 => 'multibootsystem',	1483	0x16000071 => 'multibootsystem',
1370	0x16000072 => 'nokeyboard',	1484	0x16000072 => 'nokeyboard',
1371	0x15000073 => 'aliaswindowskey',	1485	0x15000073 => 'aliaswindowskey',
1372	0x16000074 => 'bootshutdowndisabled',	1486	0x16000074 => 'bootshutdowndisabled',
1373	0x15000075 => 'performancefrequency',	1487	0x15000075 => 'performancefrequency',
1374	0x15000076 => 'securebootrawpolicy',	1488	0x15000076 => 'securebootrawpolicy',
1375	0x17000077 => 'allowedinmemorysettings',	1489	0x17000077 => 'allowedinmemorysettings',
1376	0x15000079 => 'bootuxtransitiontime',	1490	0x15000079 => 'bootuxtransitiontime',
1377	0x1600007a => 'mobilegraphics',	1491	0x1600007a => 'mobilegraphics',
1378	0x1600007b => 'forcefipscrypto',	1492	0x1600007b => 'forcefipscrypto',
1379	0x1500007d => 'booterrorux',	1493	0x1500007d => 'booterrorux',
1380	0x1600007e => 'flightsigning',	1494	0x1600007e => 'flightsigning',
1381	0x1500007f => 'measuredbootlogformat',	1495	0x1500007f => 'measuredbootlogformat',
1382	0x15000080 => 'displayrotation',	1496	0x15000080 => 'displayrotation',
1383	0x15000081 => 'logcontrol',	1497	0x15000081 => 'logcontrol',
1384	0x16000082 => 'nofirmwaresync',	1498	0x16000082 => 'nofirmwaresync',
1385	0x11000084 => 'windowssyspart',	1499	0x11000084 => 'windowssyspart',
1386	0x16000087 => 'numlock',	1500	0x16000087 => 'numlock',
1387	0x22000001 => 'bpbstring',	1501	0x26000202 => 'skipffumode',
		1502	0x26000203 => 'forceffumode',
		1503	0x25000510 => 'chargethreshold',
		1504	0x26000512 => 'offmodecharging',
		1505	0x25000aaa => 'bootflow',
		1506	0x45000001 => 'devicetype',
		1507	0x42000002 => 'applicationrelativepath',
		1508	0x42000003 => 'ramdiskdevicerelativepath',
		1509	0x46000004 => 'omitosloaderelements',
		1510	0x47000006 => 'elementstomigrate',
		1511	0x46000010 => 'recoveryos',
		1512	},
		1513	bootapp => {
		1514	0x26000145 => 'enablebootdebugpolicy',
		1515	0x26000146 => 'enablebootorderclean',
		1516	0x26000147 => 'enabledeviceid',
		1517	0x26000148 => 'enableffuloader',
		1518	0x26000149 => 'enableiuloader',
		1519	0x2600014a => 'enablemassstorage',
		1520	0x2600014b => 'enablerpmbprovisioning',
		1521	0x2600014c => 'enablesecurebootpolicy',
		1522	0x2600014d => 'enablestartcharge',
		1523	0x2600014e => 'enableresettpm',
		1524	},
		1525	bootmgr => {
1388	0x24000001 => 'displayorder',	1526	0x24000001 => 'displayorder',
1389	0x21000001 => 'filedevice',
1390	0x21000001 => 'osdevice',
1391	0x25000001 => 'passcount',
1392	0x26000001 => 'pxesoftreboot',
1393	0x22000002 => 'applicationname',
1394	0x24000002 => 'bootsequence',	1527	0x24000002 => 'bootsequence',
1395	0x22000002 => 'filepath',
1396	0x22000002 => 'systemroot',
1397	0x25000002 => 'testmix',
1398	0x26000003 => 'cacheenable',
1399	0x26000003 => 'customsettings',
1400	0x23000003 => 'default',	1528	0x23000003 => 'default',
1401	0x25000003 => 'failurecount',
1402	0x23000003 => 'resumeobject',
1403	0x26000004 => 'failuresenabled',
1404	0x26000004 => 'pae',
1405	0x26000004 => 'stampdisks',
1406	0x25000004 => 'testtofail',
1407	0x25000004 => 'timeout',	1529	0x25000004 => 'timeout',
1408	0x21000005 => 'associatedosdevice',
1409	0x26000005 => 'cacheenable',
1410	0x26000005 => 'resume',	1530	0x26000005 => 'resume',
1411	0x25000005 => 'stridefailcount',
1412	0x26000006 => 'debugoptionenabled',
1413	0x25000006 => 'invcfailcount',
1414	0x23000006 => 'resumeobject',	1531	0x23000006 => 'resumeobject',
1415	0x25000007 => 'bootux',
1416	0x25000007 => 'matsfailcount',
1417	0x24000007 => 'startupsequence',	1532	0x24000007 => 'startupsequence',
1418	0x25000008 => 'bootmenupolicy',
1419	0x25000008 => 'randfailcount',
1420	0x25000009 => 'chckrfailcount',
1421	0x26000010 => 'detecthal',
1422	0x24000010 => 'toolsdisplayorder',	1533	0x24000010 => 'toolsdisplayorder',
1423	0x22000011 => 'kernel',
1424	0x22000012 => 'hal',
1425	0x22000013 => 'dbgtransport',
1426	0x26000020 => 'displaybootmenu',	1534	0x26000020 => 'displaybootmenu',
1427	0x25000020 => 'nx',
1428	0x26000021 => 'noerrordisplay',	1535	0x26000021 => 'noerrordisplay',
1429	0x25000021 => 'pae',
1430	0x21000022 => 'bcddevice',	1536	0x21000022 => 'bcddevice',
1431	0x26000022 => 'winpe',
1432	0x22000023 => 'bcdfilepath',	1537	0x22000023 => 'bcdfilepath',
1433	0x26000024 => 'hormenabled',	1538	0x26000024 => 'hormenabled',
1434	0x26000024 => 'hormenabled',
1435	0x26000024 => 'nocrashautoreboot',
1436	0x26000025 => 'hiberboot',	1539	0x26000025 => 'hiberboot',
1437	0x26000025 => 'lastknowngood',
1438	0x26000026 => 'oslnointegritychecks',
1439	0x22000026 => 'passwordoverride',	1540	0x22000026 => 'passwordoverride',
1440	0x26000027 => 'osltestsigning',
1441	0x22000027 => 'pinpassphraseoverride',	1541	0x22000027 => 'pinpassphraseoverride',
1442	0x26000028 => 'processcustomactionsfirst',	1542	0x26000028 => 'processcustomactionsfirst',
1443	0x27000030 => 'customactions',	1543	0x27000030 => 'customactions',
1444	0x26000030 => 'nolowmem',
1445	0x26000031 => 'persistbootsequence',	1544	0x26000031 => 'persistbootsequence',
1446	0x25000031 => 'removememory',
1447	0x25000032 => 'increaseuserva',
1448	0x26000032 => 'skipstartupsequence',	1545	0x26000032 => 'skipstartupsequence',
1449	0x25000033 => 'perfmem',
1450	0x22000040 => 'fverecoveryurl',	1546	0x22000040 => 'fverecoveryurl',
1451	0x26000040 => 'vga',
1452	0x22000041 => 'fverecoverymessage',	1547	0x22000041 => 'fverecoverymessage',
		1548	},
		1549	device => {
		1550	0x35000001 => 'ramdiskimageoffset',
		1551	0x35000002 => 'ramdisktftpclientport',
		1552	0x31000003 => 'ramdisksdidevice',
		1553	0x32000004 => 'ramdisksdipath',
		1554	0x35000005 => 'ramdiskimagelength',
		1555	0x36000006 => 'exportascd',
		1556	0x35000007 => 'ramdisktftpblocksize',
		1557	0x35000008 => 'ramdisktftpwindowsize',
		1558	0x36000009 => 'ramdiskmcenabled',
		1559	0x3600000a => 'ramdiskmctftpfallback',
		1560	0x3600000b => 'ramdisktftpvarwindow',
		1561	},
		1562	memdiag => {
		1563	0x25000001 => 'passcount',
		1564	0x25000002 => 'testmix',
		1565	0x25000003 => 'failurecount',
		1566	0x26000003 => 'cacheenable',
		1567	0x25000004 => 'testtofail',
		1568	0x26000004 => 'failuresenabled',
		1569	0x25000005 => 'stridefailcount',
		1570	0x26000005 => 'cacheenable',
		1571	0x25000006 => 'invcfailcount',
		1572	0x25000007 => 'matsfailcount',
		1573	0x25000008 => 'randfailcount',
		1574	0x25000009 => 'chckrfailcount',
		1575	},
		1576	ntldr => {
		1577	0x22000001 => 'bpbstring',
		1578	},
		1579	osloader => {
		1580	0x21000001 => 'osdevice',
		1581	0x22000002 => 'systemroot',
		1582	0x23000003 => 'resumeobject',
		1583	0x26000004 => 'stampdisks',
		1584	0x26000010 => 'detecthal',
		1585	0x22000011 => 'kernel',
		1586	0x22000012 => 'hal',
		1587	0x22000013 => 'dbgtransport',
		1588	0x25000020 => 'nx',
		1589	0x25000021 => 'pae',
		1590	0x26000022 => 'winpe',
		1591	0x26000024 => 'nocrashautoreboot',
		1592	0x26000025 => 'lastknowngood',
		1593	0x26000026 => 'oslnointegritychecks',
		1594	0x26000027 => 'osltestsigning',
		1595	0x26000030 => 'nolowmem',
		1596	0x25000031 => 'removememory',
		1597	0x25000032 => 'increaseuserva',
		1598	0x25000033 => 'perfmem',
		1599	0x26000040 => 'vga',
1453	0x26000041 => 'quietboot',	1600	0x26000041 => 'quietboot',
1454	0x26000042 => 'novesa',	1601	0x26000042 => 'novesa',
1455	0x26000043 => 'novga',	1602	0x26000043 => 'novga',
1456	0x25000050 => 'clustermodeaddressing',	1603	0x25000050 => 'clustermodeaddressing',
1457	0x26000051 => 'usephysicaldestination',	1604	0x26000051 => 'usephysicaldestination',
1458	0x25000052 => 'restrictapiccluster',	1605	0x25000052 => 'restrictapiccluster',
1459	0x22000053 => 'evstore',	1606	0x22000053 => 'evstore',
1460	0x26000054 => 'uselegacyapicmode',	1607	0x26000054 => 'uselegacyapicmode',
1461	0x26000060 => 'onecpu',	1608	0x26000060 => 'onecpu',
1462	0x25000061 => 'numproc',	1609	0x25000061 => 'numproc',
1463	0x26000062 => 'maxproc',	1610	0x26000062 => 'maxproc',
1464	0x25000063 => 'configflags',	1611	0x25000063 => 'configflags',
1465	0x26000064 => 'maxgroup',	1612	0x26000064 => 'maxgroup',
1466	0x26000065 => 'groupaware',	1613	0x26000065 => 'groupaware',
1467	0x25000066 => 'groupsize',	1614	0x25000066 => 'groupsize',
1468	0x26000070 => 'usefirmwarepcisettings',	1615	0x26000070 => 'usefirmwarepcisettings',
1469	0x25000071 => 'msi',	1616	0x25000071 => 'msi',
1470	0x25000072 => 'pciexpress',	1617	0x25000072 => 'pciexpress',
1471	0x25000080 => 'safeboot',	1618	0x25000080 => 'safeboot',
1472	0x26000081 => 'safebootalternateshell',	1619	0x26000081 => 'safebootalternateshell',
1473	0x26000090 => 'bootlog',	1620	0x26000090 => 'bootlog',
1474	0x26000091 => 'sos',	1621	0x26000091 => 'sos',
1475	0x260000a0 => 'debug',	1622	0x260000a0 => 'debug',
1476	0x260000a1 => 'halbreakpoint',	1623	0x260000a1 => 'halbreakpoint',
1477	0x260000a2 => 'useplatformclock',	1624	0x260000a2 => 'useplatformclock',
1478	0x260000a3 => 'forcelegacyplatform',	1625	0x260000a3 => 'forcelegacyplatform',
1479	0x260000a4 => 'useplatformtick',	1626	0x260000a4 => 'useplatformtick',
1480	0x260000a5 => 'disabledynamictick',	1627	0x260000a5 => 'disabledynamictick',
1481	0x250000a6 => 'tscsyncpolicy',	1628	0x250000a6 => 'tscsyncpolicy',
1482	0x260000b0 => 'ems',	1629	0x260000b0 => 'ems',
1483	0x250000c0 => 'forcefailure',	1630	0x250000c0 => 'forcefailure',
1484	0x250000c1 => 'driverloadfailurepolicy',	1631	0x250000c1 => 'driverloadfailurepolicy',
1485	0x250000c2 => 'bootmenupolicy',	1632	0x250000c2 => 'bootmenupolicy',
1486	0x260000c3 => 'onetimeadvancedoptions',	1633	0x260000c3 => 'onetimeadvancedoptions',
1487	0x260000c4 => 'onetimeoptionsedit',	1634	0x260000c4 => 'onetimeoptionsedit',
1488	0x250000e0 => 'bootstatuspolicy',	1635	0x250000e0 => 'bootstatuspolicy',
1489	0x260000e1 => 'disableelamdrivers',	1636	0x260000e1 => 'disableelamdrivers',
1490	0x250000f0 => 'hypervisorlaunchtype',	1637	0x250000f0 => 'hypervisorlaunchtype',
1491	0x220000f1 => 'hypervisorpath',	1638	0x220000f1 => 'hypervisorpath',
1492	0x260000f2 => 'hypervisordebug',	1639	0x260000f2 => 'hypervisordebug',
1493	0x250000f3 => 'hypervisordebugtype',	1640	0x250000f3 => 'hypervisordebugtype',
1494	0x250000f4 => 'hypervisordebugport',	1641	0x250000f4 => 'hypervisordebugport',
1495	0x250000f5 => 'hypervisorbaudrate',	1642	0x250000f5 => 'hypervisorbaudrate',
1496	0x250000f6 => 'hypervisorchannel',	1643	0x250000f6 => 'hypervisorchannel',
1497	0x250000f7 => 'bootux',	1644	0x250000f7 => 'bootux',
1498	0x260000f8 => 'hypervisordisableslat',	1645	0x260000f8 => 'hypervisordisableslat',
1499	0x220000f9 => 'hypervisorbusparams',	1646	0x220000f9 => 'hypervisorbusparams',
1500	0x250000fa => 'hypervisornumproc',	1647	0x250000fa => 'hypervisornumproc',
1501	0x250000fb => 'hypervisorrootprocpernode',	1648	0x250000fb => 'hypervisorrootprocpernode',
1502	0x260000fc => 'hypervisoruselargevtlb',	1649	0x260000fc => 'hypervisoruselargevtlb',
1503	0x250000fd => 'hypervisorhostip',	1650	0x250000fd => 'hypervisorhostip',
1504	0x250000fe => 'hypervisorhostport',	1651	0x250000fe => 'hypervisorhostport',
1505	0x250000ff => 'hypervisordebugpages',	1652	0x250000ff => 'hypervisordebugpages',
1506	0x25000100 => 'tpmbootentropy',	1653	0x25000100 => 'tpmbootentropy',
1507	0x22000110 => 'hypervisorusekey',	1654	0x22000110 => 'hypervisorusekey',
1508	0x22000112 => 'hypervisorproductskutype',	1655	0x22000112 => 'hypervisorproductskutype',
1509	0x25000113 => 'hypervisorrootproc',	1656	0x25000113 => 'hypervisorrootproc',
1510	0x26000114 => 'hypervisordhcp',	1657	0x26000114 => 'hypervisordhcp',
1511	0x25000115 => 'hypervisoriommupolicy',	1658	0x25000115 => 'hypervisoriommupolicy',
1512	0x26000116 => 'hypervisorusevapic',	1659	0x26000116 => 'hypervisorusevapic',
1513	0x22000117 => 'hypervisorloadoptions',	1660	0x22000117 => 'hypervisorloadoptions',
1514	0x25000118 => 'hypervisormsrfilterpolicy',	1661	0x25000118 => 'hypervisormsrfilterpolicy',
1515	0x25000119 => 'hypervisormmionxpolicy',	1662	0x25000119 => 'hypervisormmionxpolicy',
1516	0x2500011a => 'hypervisorschedulertype',	1663	0x2500011a => 'hypervisorschedulertype',
1517	0x25000120 => 'xsavepolicy',	1664	0x25000120 => 'xsavepolicy',
1518	0x25000121 => 'xsaveaddfeature0',	1665	0x25000121 => 'xsaveaddfeature0',
1519	0x25000122 => 'xsaveaddfeature1',	1666	0x25000122 => 'xsaveaddfeature1',
1520	0x25000123 => 'xsaveaddfeature2',	1667	0x25000123 => 'xsaveaddfeature2',
1521	0x25000124 => 'xsaveaddfeature3',	1668	0x25000124 => 'xsaveaddfeature3',
1522	0x25000125 => 'xsaveaddfeature4',	1669	0x25000125 => 'xsaveaddfeature4',
1523	0x25000126 => 'xsaveaddfeature5',	1670	0x25000126 => 'xsaveaddfeature5',
1524	0x25000127 => 'xsaveaddfeature6',	1671	0x25000127 => 'xsaveaddfeature6',
1525	0x25000128 => 'xsaveaddfeature7',	1672	0x25000128 => 'xsaveaddfeature7',
1526	0x25000129 => 'xsaveremovefeature',	1673	0x25000129 => 'xsaveremovefeature',
1527	0x2500012a => 'xsaveprocessorsmask',	1674	0x2500012a => 'xsaveprocessorsmask',
1528	0x2500012b => 'xsavedisable',	1675	0x2500012b => 'xsavedisable',
1529	0x2500012c => 'kerneldebugtype',	1676	0x2500012c => 'kerneldebugtype',
1530	0x2200012d => 'kernelbusparams',	1677	0x2200012d => 'kernelbusparams',
1531	0x2500012e => 'kerneldebugaddress',	1678	0x2500012e => 'kerneldebugaddress',
1532	0x2500012f => 'kerneldebugport',	1679	0x2500012f => 'kerneldebugport',
1533	0x25000130 => 'claimedtpmcounter',	1680	0x25000130 => 'claimedtpmcounter',
1534	0x25000131 => 'kernelchannel',	1681	0x25000131 => 'kernelchannel',
1535	0x22000132 => 'kerneltargetname',	1682	0x22000132 => 'kerneltargetname',
1536	0x25000133 => 'kernelhostip',	1683	0x25000133 => 'kernelhostip',
1537	0x25000134 => 'kernelport',	1684	0x25000134 => 'kernelport',
1538	0x26000135 => 'kerneldhcp',	1685	0x26000135 => 'kerneldhcp',
1539	0x22000136 => 'kernelkey',	1686	0x22000136 => 'kernelkey',
1540	0x22000137 => 'imchivename',	1687	0x22000137 => 'imchivename',
1541	0x21000138 => 'imcdevice',	1688	0x21000138 => 'imcdevice',
1542	0x25000139 => 'kernelbaudrate',	1689	0x25000139 => 'kernelbaudrate',
1543	0x22000140 => 'mfgmode',	1690	0x22000140 => 'mfgmode',
1544	0x26000141 => 'event',	1691	0x26000141 => 'event',
1545	0x25000142 => 'vsmlaunchtype',	1692	0x25000142 => 'vsmlaunchtype',
1546	0x25000144 => 'hypervisorenforcedcodeintegrity',	1693	0x25000144 => 'hypervisorenforcedcodeintegrity',
1547	0x26000145 => 'enablebootdebugpolicy',
1548	0x26000146 => 'enablebootorderclean',
1549	0x26000147 => 'enabledeviceid',
1550	0x26000148 => 'enableffuloader',
1551	0x26000149 => 'enableiuloader',
1552	0x2600014a => 'enablemassstorage',
1553	0x2600014b => 'enablerpmbprovisioning',
1554	0x2600014c => 'enablesecurebootpolicy',
1555	0x2600014d => 'enablestartcharge',
1556	0x2600014e => 'enableresettpm',
1557	0x21000150 => 'systemdatadevice',	1694	0x21000150 => 'systemdatadevice',
1558	0x21000151 => 'osarcdevice',	1695	0x21000151 => 'osarcdevice',
1559	0x21000153 => 'osdatadevice',	1696	0x21000153 => 'osdatadevice',
1560	0x21000154 => 'bspdevice',	1697	0x21000154 => 'bspdevice',
1561	0x21000155 => 'bspfilepath',	1698	0x21000155 => 'bspfilepath',
1562	0x26000202 => 'skipffumode',	1699	},
1563	0x26000203 => 'forceffumode',	1700	resume => {
1564	0x25000510 => 'chargethreshold',	1701	0x21000001 => 'filedevice',
1565	0x26000512 => 'offmodecharging',	1702	0x22000002 => 'filepath',
1566	0x25000aaa => 'bootflow',	1703	0x26000003 => 'customsettings',
1567	0x35000001 => 'ramdiskimageoffset',	1704	0x26000004 => 'pae',
1568	0x35000002 => 'ramdisktftpclientport',	1705	0x21000005 => 'associatedosdevice',
1569	0x31000003 => 'ramdisksdidevice',	1706	0x26000006 => 'debugoptionenabled',
1570	0x32000004 => 'ramdisksdipath',	1707	0x25000007 => 'bootux',
1571	0x35000005 => 'ramdiskimagelength',	1708	0x25000008 => 'bootmenupolicy',
1572	0x36000006 => 'exportascd',	1709	0x26000024 => 'hormenabled',
1573	0x35000007 => 'ramdisktftpblocksize',	1710	},
1574	0x35000008 => 'ramdisktftpwindowsize',	1711	startup => {
1575	0x36000009 => 'ramdiskmcenabled',	1712	0x26000001 => 'pxesoftreboot',
1576	0x3600000a => 'ramdiskmctftpfallback',	1713	0x22000002 => 'applicationname',
1577	0x3600000b => 'ramdisktftpvarwindow',	1714	},
1578	0x45000001 => 'devicetype',
1579	0x42000002 => 'applicationrelativepath',
1580	0x42000003 => 'ramdiskdevicerelativepath',
1581	0x46000004 => 'omitosloaderelements',
1582	0x47000006 => 'elementstomigrate',
1583	0x46000010 => 'recoveryos',
1584	);	1715	);
1585		1716
1586	our %rbcde = reverse %bcde;	1717	# mask, value => class
		1718	our @bcde_typeclass = (
		1719	[0x00000000, 0x00000000, 'any'],
		1720	[0xf00fffff, 0x1000000a, 'bootapp'],
		1721	[0xf0ffffff, 0x2020000a, 'bootapp'],
		1722	[0xf00fffff, 0x10000001, 'bootmgr'],
		1723	[0xf00fffff, 0x10000002, 'bootmgr'],
		1724	[0xf0ffffff, 0x20200001, 'bootmgr'],
		1725	[0xf0ffffff, 0x20200002, 'bootmgr'],
		1726	[0xf0f00000, 0x20300000, 'device'],
		1727	[0xf0000000, 0x30000000, 'device'],
		1728	[0xf00fffff, 0x10000005, 'memdiag'],
		1729	[0xf0ffffff, 0x20200005, 'memdiag'],
		1730	[0xf00fffff, 0x10000006, 'ntldr'],
		1731	[0xf00fffff, 0x10000007, 'ntldr'],
		1732	[0xf0ffffff, 0x20200006, 'ntldr'],
		1733	[0xf0ffffff, 0x20200007, 'ntldr'],
		1734	[0xf00fffff, 0x10000003, 'osloader'],
		1735	[0xf0ffffff, 0x20200003, 'osloader'],
		1736	[0xf00fffff, 0x10000004, 'resume'],
		1737	[0xf0ffffff, 0x20200004, 'resume'],
		1738	[0xf00fffff, 0x10000009, 'startup'],
		1739	[0xf0ffffff, 0x20200009, 'startup'],
		1740	);
1587		1741
		1742	our %rbcde_byclass;
		1743
		1744	while (my ($k, $v) = each %bcde_byclass) {
		1745	$rbcde_byclass{$k} = { reverse %$v };
		1746	}
		1747
		1748	# decodes (numerical elem, type) to name
1588	sub dec_bcde_id($) {	1749	sub dec_bcde_id($$) {
		1750	for my $class (@bcde_typeclass) {
		1751	if (($_[1] & $class->[0]) == $class->[1]) {
		1752	if (my $id = $bcde_byclass{$class->[2]}{$_[0]}) {
		1753	return $id;
		1754	}
		1755	}
		1756	}
		1757
1589	$bcde{$_[0]} // sprintf "custom:%08x", $_[0]	1758	sprintf "custom:%08x", $_[0]
1590	}	1759	}
1591		1760
		1761	# encodes (elem as name, type)
1592	sub enc_bcde_id($) {	1762	sub enc_bcde_id($$) {
1593	$_[0] =~ /^custom:([0-9a-fA-F]{8}$)/	1763	$_[0] =~ /^custom:(?:0x)?([0-9a-fA-F]{8}$)/
1594	? hex $1	1764	and return hex $1;
1595	: $rbcde{$_[0]}	1765
		1766	for my $class (@bcde_typeclass) {
		1767	if (($_[1] & $class->[0]) == $class->[1]) {
		1768	if (my $value = $rbcde_byclass{$class->[2]}{$_[0]}) {
		1769	return $value;
		1770	}
		1771	}
		1772	}
		1773
		1774	undef
1596	}	1775	}
1597		1776
1598	# decode/encode bcd device element - the horror, no documentaion	1777	# decode/encode bcd device element - the horror, no documentaion
1599	# whatsoever, supercomplex, superinconsistent.	1778	# whatsoever, supercomplex, superinconsistent.
1600		1779
…		…
1604		1783
1605	our $NULL_DEVICE = "\x00" x 16;	1784	our $NULL_DEVICE = "\x00" x 16;
1606		1785
1607	# biggest bitch to decode, ever	1786	# biggest bitch to decode, ever
1608	# this decoded a device portion after the GUID	1787	# this decoded a device portion after the GUID
1609	sub dec_device_($);	1788	sub dec_device_($$);
1610	sub dec_device_($) {	1789	sub dec_device_($$) {
1611	my ($device) = @_;	1790	my ($device, $type) = @_;
1612		1791
1613	my $res;	1792	my $res;
1614		1793
1615	my ($type, $flags, $length, $pad) = unpack "VVVV", substr $device, 0, 4 * 4, "";	1794	my ($type, $flags, $length, $pad) = unpack "VVVV", substr $device, 0, 4 * 4, "";
1616		1795
…		…
1661		1840
1662	my $partid = $parttype eq "gpt" ? dec_guid $partdata	1841	my $partid = $parttype eq "gpt" ? dec_guid $partdata
1663	: $type eq "partition" ? unpack "Q<", $partdata # byte offset to partition start	1842	: $type eq "partition" ? unpack "Q<", $partdata # byte offset to partition start
1664	: unpack "L<", $partdata; # partition number, one-based	1843	: unpack "L<", $partdata; # partition number, one-based
1665		1844
1666	(my $parent, $device) = dec_device_ $device;	1845	(my $parent, $device) = dec_device_ $device, $type;
1667		1846
1668	$res .= "=";	1847	$res .= "=";
1669	$res .= "<$parent>";	1848	$res .= "<$parent>";
1670	$res .= ",$blocktype,$parttype,$diskid,$partid";	1849	$res .= ",$blocktype,$parttype,$diskid,$partid";
1671		1850
…		…
1691	or die "unsupported file descriptor version '$fver'\n";	1870	or die "unsupported file descriptor version '$fver'\n";
1692		1871
1693	$ftype == 5	1872	$ftype == 5
1694	or die "unsupported file descriptor path type '$type'\n";	1873	or die "unsupported file descriptor path type '$type'\n";
1695		1874
1696	(my $parent, $path) = dec_device_ $path;	1875	(my $parent, $path) = dec_device_ $path, $type;
1697		1876
1698	$path = $dec_path->($path, "file device without path");	1877	$path = $dec_path->($path, "file device without path");
1699		1878
1700	($parent, $path)	1879	($parent, $path)
1701	};	1880	};
…		…
1707		1886
1708	} elsif ($blocktype eq "vhd") {	1887	} elsif ($blocktype eq "vhd") {
1709	$device =~ s/^\x00{20}//s	1888	$device =~ s/^\x00{20}//s
1710	or die "virtualdisk has non-zero fields I don't understand\n";	1889	or die "virtualdisk has non-zero fields I don't understand\n";
1711		1890
1712	(my $parent, $device) = dec_device_ $device;	1891	(my $parent, $device) = dec_device_ $device, $type;
1713		1892
1714	$res .= "=vhd,<$parent>";	1893	$res .= "=vhd,<$parent>";
1715		1894
1716	} elsif ($blocktype eq "ramdisk") {	1895	} elsif ($blocktype eq "ramdisk") {
1717	my ($base, $size, $offset) = unpack "Q< Q< L<", substr $device, 0, 8 + 8 + 4, "";	1896	my ($base, $size, $offset) = unpack "Q< Q< L<", substr $device, 0, 8 + 8 + 4, "";
…		…
1730	my ($mode, $elem, $parent) = unpack "VVV", substr $device, 0, 4 * 3, "";	1909	my ($mode, $elem, $parent) = unpack "VVV", substr $device, 0, 4 * 3, "";
1731		1910
1732	if ($parent) {	1911	if ($parent) {
1733	# not sure why this is an offset - it must come after the path	1912	# not sure why this is an offset - it must come after the path
1734	$parent = substr $device, $parent - 4 * 3 - 4 * 4, 1e9, "";	1913	$parent = substr $device, $parent - 4 * 3 - 4 * 4, 1e9, "";
1735	($parent, my $tail) = dec_device_ $parent;	1914	($parent, my $tail) = dec_device_ $parent, $type;
1736	0 == length $tail	1915	0 == length $tail
1737	or die "trailing data after locate device parent\n";	1916	or die "trailing data after locate device parent\n";
1738	} else {	1917	} else {
1739	$parent = "null";	1918	$parent = "null";
1740	}	1919	}
…		…
1746		1925
1747	if ($mode == 0) { # "Element"	1926	if ($mode == 0) { # "Element"
1748	!length $path	1927	!length $path
1749	or die "device locate mode 0 having non-empty path ($mode, $elem, $path)\n";	1928	or die "device locate mode 0 having non-empty path ($mode, $elem, $path)\n";
1750		1929
1751	$elem = dec_bcde_id $elem;	1930	$elem = dec_bcde_id $elem, $type;
1752	$res .= "element,$elem";	1931	$res .= "element,$elem";
1753		1932
1754	} elsif ($mode == 1) { # "String"	1933	} elsif ($mode == 1) { # "String"
1755	!$elem	1934	!$elem
1756	or die "device locate mode 1 having non-zero element\n";	1935	or die "device locate mode 1 having non-zero element\n";
…		…
1781		1960
1782	($res, $tail)	1961	($res, $tail)
1783	}	1962	}
1784		1963
1785	# decode a full binary BCD device descriptor	1964	# decode a full binary BCD device descriptor
1786	sub dec_device($) {	1965	sub dec_device($$) {
1787	my ($device) = @_;	1966	my ($device, $type) = @_;
1788		1967
1789	$device = pack "H*", $device;	1968	$device = pack "H*", $device;
1790		1969
1791	my $guid = dec_guid substr $device, 0, 16, "";	1970	my $guid = dec_guid substr $device, 0, 16, "";
1792	$guid = $guid eq "00000000-0000-0000-0000-000000000000"	1971	$guid = $guid eq "00000000-0000-0000-0000-000000000000"
1793	? "" : "{$guid}";	1972	? "" : "{$guid}";
1794		1973
1795	eval {	1974	eval {
1796	my ($dev, $tail) = dec_device_ $device;	1975	my ($dev, $tail) = dec_device_ $device, $type;
1797		1976
1798	$tail eq ""	1977	$tail eq ""
1799	or die "unsupported trailing data after device descriptor\n";	1978	or die "unsupported trailing data after device descriptor\n";
1800		1979
1801	"$guid$dev"	1980	"$guid$dev"
…		…
1813		1992
1814	undef	1993	undef
1815	}	1994	}
1816		1995
1817	# encode the device portion after the GUID	1996	# encode the device portion after the GUID
1818	sub enc_device_;	1997	sub enc_device_($$);
1819	sub enc_device_ {	1998	sub enc_device_($$) {
1820	my ($device) = @_;	1999	my ($device, $type) = @_;
1821		2000
1822	my $enc_path = sub {	2001	my $enc_path = sub {
1823	my $path = shift;	2002	my $path = shift;
1824	$path =~ s/\//\\/g;	2003	$path =~ s/\//\\/g;
1825	(Encode::encode "UTF-16LE", $path) . "\x00\x00"	2004	(Encode::encode "UTF-16LE", $path) . "\x00\x00"
…		…
1843		2022
1844	my $parse_parent = sub {	2023	my $parse_parent = sub {
1845	my $parent;	2024	my $parent;
1846		2025
1847	if (s/^<//) {	2026	if (s/^<//) {
1848	($parent, $_) = enc_device_ $_;	2027	($parent, $_) = enc_device_ $_, $type;
1849	s/^>//	2028	s/^>//
1850	or die "$device: syntax error: parent device not followed by '>'\n";	2029	or die "$device: syntax error: parent device not followed by '>'\n";
1851	} else {	2030	} else {
1852	$parent = $NULL_DEVICE;	2031	$parent = $NULL_DEVICE;
1853	}	2032	}
…		…
1941		2120
1942	s/^,//	2121	s/^,//
1943	or die "$_: missing comma after locate parent device\n";	2122	or die "$_: missing comma after locate parent device\n";
1944		2123
1945	if (s/^element,//) {	2124	if (s/^element,//) {
1946	s/^([0-9a-z]+)//i	2125	s/^([0-9a-z:]+)//i
1947	or die "$_ locate element must be either name or 8-digit hex id\n";	2126	or die "$_ locate element must be either name or 8-digit hex id\n";
1948	$elem = enc_bcde_id $1;	2127	$elem = enc_bcde_id $1, $type;
1949	$mode = 0;	2128	$mode = 0;
1950	$path = $enc_path->("");	2129	$path = $enc_path->("");
1951		2130
1952	} elsif (s/^path,//) {	2131	} elsif (s/^path,//) {
1953	$mode = 1;	2132	$mode = 1;
…		…
2032	);	2211	);
2033	}	2212	}
2034	}	2213	}
2035		2214
2036	# encode a full binary BCD device descriptor	2215	# encode a full binary BCD device descriptor
2037	sub enc_device {	2216	sub enc_device($$) {
2038	my ($device) = @_;	2217	my ($device, $type) = @_;
2039		2218
2040	my $guid = "\x00" x 16;	2219	my $guid = "\x00" x 16;
2041		2220
2042	if ($device =~ s/^\{([A-Za-z0-9\-]+)\}//) {	2221	if ($device =~ s/^\{([A-Za-z0-9\-]+)\}//) {
2043	$guid = enc_guid $1	2222	$guid = enc_guid $1
2044	or die "$device: does not start with valid guid\n";	2223	or die "$device: does not start with valid guid\n";
2045	}	2224	}
2046		2225
2047	my ($descriptor, $tail) = enc_device_ $device;	2226	my ($descriptor, $tail) = enc_device_ $device, $type;
2048		2227
2049	length $tail	2228	length $tail
2050	and die "$device: garbage after device descriptor\n";	2229	and die "$device: garbage after device descriptor\n";
2051		2230
2052	unpack "H*", $guid . $descriptor	2231	unpack "H*", $guid . $descriptor
…		…
2067	$k = $bcd_objects{$k} // $k;	2246	$k = $bcd_objects{$k} // $k;
2068		2247
2069	my $type = $v->{Description}[0]{Type}[1];	2248	my $type = $v->{Description}[0]{Type}[1];
2070		2249
2071	if ($type != $bcd_object_types{$k}) {	2250	if ($type != $bcd_object_types{$k}) {
2072	$type = $bcd_types{$type} // sprintf "0x%08x", $type;	2251	$kv{type} = $bcd_types{$type} // sprintf "0x%08x", $type;
2073	$kv{type} = $type;
2074	}	2252	}
2075		2253
2076	my $elems = $v->{Elements}[1];	2254	my $elems = $v->{Elements}[1];
2077		2255
2078	while (my ($k, $v) = each %$elems) {	2256	while (my ($k, $v) = each %$elems) {
2079	my $k = hex $k;	2257	my $k = hex $k;
2080		2258
2081	my $v = $bcde_dec{$k & BCDE_FORMAT}->($v->[0]{Element}[1]);	2259	my $v = $bcde_dec{$k & BCDE_FORMAT}->($v->[0]{Element}[1], $type);
2082	my $k = dec_bcde_id $k;	2260	my $k = dec_bcde_id $k, $type;
2083		2261
2084	$kv{$k} = $v;	2262	$kv{$k} = $v;
2085	}	2263	}
2086		2264
2087	$bcd{$k} = \%kv;	2265	$bcd{$k} = \%kv;
…		…
2128	my %elem;	2306	my %elem;
2129		2307
2130	while (my ($k, $v) = each %$v) {	2308	while (my ($k, $v) = each %$v) {
2131	next if $k eq "type";	2309	next if $k eq "type";
2132		2310
2133	$k = (enc_bcde_id $k) // die "$k: invalid bcde element name or id\n";	2311	$k = (enc_bcde_id $k, $type) // die "$k: invalid bcde element name or id\n";
2134	$elem{sprintf "%08x", $k} = [{	2312	$elem{sprintf "%08x", $k} = [{
2135	Element => [ ($bcde_enc{$k & BCDE_FORMAT} // die "$k: unable to encode unknown bcd element type}")->($v)]	2313	Element => [ ($bcde_enc{$k & BCDE_FORMAT} // die "$k: unable to encode unknown bcd element type}")->($v)]
2136	}];	2314	}];
2137	}	2315	}
2138		2316
…		…
2154	Objects => [undef, \%objects],	2332	Objects => [undef, \%objects],
2155	}]]	2333	}]]
2156	}	2334	}
2157		2335
2158	#############################################################################	2336	#############################################################################
		2337	# edit instructions
		2338
		2339	sub bcd_edit_eval {
		2340	package pbcdedit;
		2341
		2342	our ($PATH, $BCD, $DEFAULT);
		2343
		2344	eval shift;
		2345	die "$@" if $@;
		2346	}
		2347
		2348	sub bcd_edit {
		2349	my ($path, $bcd, @insns) = @_;
		2350
		2351	my $default = $bcd->{"{bootmgr}"}{default};
		2352
		2353	# prepare "officially visible" variables
		2354	local $pbcdedit::PATH = $path;
		2355	local $pbcdedit::BCD = $bcd;
		2356	local $pbcdedit::DEFAULT = $default;
		2357
		2358	while (@insns) {
		2359	my $insn = shift @insns;
		2360
		2361	if ($insn eq "get") {
		2362	my $object = shift @insns;
		2363	my $elem = shift @insns;
		2364
		2365	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
		2366
		2367	print $bcd->{$object}{$elem}, "\n";
		2368
		2369	} elsif ($insn eq "set") {
		2370	my $object = shift @insns;
		2371	my $elem = shift @insns;
		2372	my $value = shift @insns;
		2373
		2374	$object = $object eq "{default}" ? $default : dec_wguid enc_wguid $object;
		2375
		2376	$bcd->{$object}{$elem} = $value;
		2377
		2378	} elsif ($insn eq "eval") {
		2379	my $perl = shift @insns;
		2380	bcd_edit_eval "#line 1 'eval'\n$perl";
		2381
		2382	} elsif ($insn eq "do") {
		2383	my $path = shift @insns;
		2384	my $file = file_load $path;
		2385	bcd_edit_eval "#line 1 '$path'\n$file";
		2386
		2387	} else {
		2388	die "$insn: not a recognized instruction for edit/parse\n";
		2389	}
		2390	}
		2391
		2392	}
		2393
		2394	#############################################################################
		2395	# command line parser
2159		2396
2160	# json to stdout	2397	# json to stdout
2161	sub prjson($) {	2398	sub prjson($) {
2162	print $json_coder->encode ($_[0]);	2399	print $json_coder->encode ($_[0]);
2163	}	2400	}
…		…
2202		2439
2203	print "\n";	2440	print "\n";
2204		2441
2205	printf "%-39s %-23s %s\n", "Object GUID", "Alias", "(Hex) Default Type";	2442	printf "%-39s %-23s %s\n", "Object GUID", "Alias", "(Hex) Default Type";
2206	for my $name (sort keys %rbcd_objects) {	2443	for my $name (sort keys %rbcd_objects) {
2207	my $guid = $rbcd_objects{$name};	2444	my $guid = $rbcd_objects{$name};
2208	my $type = $bcd_object_types{$name};	2445	my $type = $bcd_object_types{$name};
2209	my $tname = $bcd_types{$type};	2446	my $tname = $bcd_types{$type};
2210		2447
2211	$type = $type ? sprintf "(%08x) %s", $type, $tname : "-";	2448	$type = $type ? sprintf "(%08x) %s", $type, $tname : "-";
2212		2449
2213	printf "%-39s %-23s %s\n", $guid, $name, $type;	2450	printf "%-39s %-23s %s\n", $guid, $name, $type;
…		…
2227	BCDE_FORMAT_GUID_LIST , "guid list",	2464	BCDE_FORMAT_GUID_LIST , "guid list",
2228	BCDE_FORMAT_INTEGER , "integer",	2465	BCDE_FORMAT_INTEGER , "integer",
2229	BCDE_FORMAT_BOOLEAN , "boolean",	2466	BCDE_FORMAT_BOOLEAN , "boolean",
2230	BCDE_FORMAT_INTEGER_LIST, "integer list",	2467	BCDE_FORMAT_INTEGER_LIST, "integer list",
2231	);	2468	);
2232	my %rbcde = reverse %bcde;
2233	$_ = sprintf "%08x", $_ for values %rbcde;
2234		2469
2235	my %element;	2470	my %element;
2236		2471
		2472	for my $class (sort keys %rbcde_byclass) {
		2473	my $rbcde = $rbcde_byclass{$class};
		2474
2237	unless ($json) {	2475	unless ($json) {
2238	print "\n";	2476	print "\n";
		2477	printf "Elements applicable to class(es): $class\n";
2239	printf "%-9s %-12s %s\n", "Element", "Format", "Name Alias";	2478	printf "%-9s %-12s %s\n", "Element", "Format", "Name Alias";
2240	}	2479	}
2241	for my $name (sort keys %rbcde) {	2480	for my $name (sort keys %$rbcde) {
2242	my $id = $rbcde{$name};	2481	my $id = $rbcde->{$name};
2243	my $format = $format_name{(hex $id) & BCDE_FORMAT};	2482	my $format = $format_name{$id & BCDE_FORMAT};
		2483	$id = sprintf "%08x", $id;
2244		2484
2245	if ($json) {	2485	if ($json) {
2246	$element{$id} = [$format, $name];	2486	$element{$id} = [$class, $format, $name];
2247	} else {	2487	} else {
2248	printf "%-9s %-12s %s\n", $id, $format, $name;	2488	printf "%-9s %-12s %s\n", $id, $format, $name;
		2489	}
2249	}	2490	}
2250	}	2491	}
2251	print "\n" unless $json;	2492	print "\n" unless $json;
2252		2493
2253	prjson {	2494	prjson {
2254	version => $JSON_VERSION,	2495	version => $JSON_VERSION,
2255	element => \%element,	2496	element => \%element,
		2497	class => \@bcde_typeclass,
2256	} if $json;	2498	} if $json;
2257		2499
2258	},	2500	},
2259		2501
2260	export => sub {	2502	export => sub {
2261	prjson bcd_decode regf_load shift;	2503	prjson bcd_decode regf_load shift;
2262	},	2504	},
2263		2505
2264	import => sub {	2506	import => sub {
2265	regf_save shift, bcd_encode rdjson;	2507	regf_save shift, bcd_encode rdjson;
		2508	},
		2509
		2510	edit => sub {
		2511	my $path = shift;
		2512	my $bcd = bcd_decode regf_load $path;
		2513	bcd_edit $path, $bcd, @_;
		2514	regf_save $path, bcd_encode $bcd;
		2515	},
		2516
		2517	parse => sub {
		2518	my $path = shift;
		2519	my $bcd = bcd_decode regf_load $path;
		2520	bcd_edit $path, $bcd, @_;
2266	},	2521	},
2267		2522
2268	"export-regf" => sub {	2523	"export-regf" => sub {
2269	prjson regf_load shift;	2524	prjson regf_load shift;
2270		2525
…		…
2299	}	2554	}
2300	}	2555	}
2301	}	2556	}
2302	}	2557	}
2303	},	2558	},
		2559
		2560	version => sub {
		2561	print "\n",
		2562	"PBCDEDIT version $VERSION, copyright 2019 Marc A. Lehmann <pbcdedit\@schmorp.de>.\n",
		2563	"JSON schema version: $JSON_VERSION\n",
		2564	"Licensed under the GNU General Public License Version 3.0, or any later version.\n",
		2565	"\n",
		2566	$CHANGELOG,
		2567	"\n";
		2568	},
2304	);	2569	);
2305		2570
2306	my $cmd = shift;	2571	my $cmd = shift;
2307		2572
2308	unless (exists $CMD{$cmd}) {	2573	unless (exists $CMD{$cmd}) {

Diff Legend

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