ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/pbcdedit/pbcdedit

Comparing pbcdedit/pbcdedit (file contents):
Revision 1.9 by root, Wed Aug 14 22:54:28 2019 UTC vs.
Revision 1.38 by root, Thu Aug 15 23:48:21 2019 UTC

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

Diff Legend

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