UefiShellBcfgCommandLib.c

最後變更在這個檔案是 105670,由 vboxsync 提交於 7 月前
Devices/EFI/FirmwareNew: Merge edk2-stable-202405 and make it build on aarch64, bugref:4643
屬性 svn:eol-style 設為 `native`
檔案大小: 70.3 KB

行
1	/** @file
2	Main file for BCFG command.
3
4	(C) Copyright 2014-2015 Hewlett-Packard Development Company, L.P.<BR>
5	Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
6	SPDX-License-Identifier: BSD-2-Clause-Patent
7
8	**/
9
10	#include <Uefi.h>
11
12	#include <Guid/GlobalVariable.h>
13	#include <Guid/ShellLibHiiGuid.h>
14
15	#include <Protocol/Shell.h>
16	#include <Protocol/ShellParameters.h>
17	#include <Protocol/DevicePath.h>
18	#include <Protocol/LoadedImage.h>
19	#include <Protocol/UnicodeCollation.h>
20
21	#include <Library/BaseLib.h>
22	#include <Library/BaseMemoryLib.h>
23	#include <Library/DebugLib.h>
24	#include <Library/MemoryAllocationLib.h>
25	#include <Library/PcdLib.h>
26	#include <Library/ShellCommandLib.h>
27	#include <Library/ShellLib.h>
28	#include <Library/SortLib.h>
29	#include <Library/UefiLib.h>
30	#include <Library/UefiRuntimeServicesTableLib.h>
31	#include <Library/UefiBootServicesTableLib.h>
32	#include <Library/HiiLib.h>
33	#include <Library/FileHandleLib.h>
34	#include <Library/PrintLib.h>
35	#include <Library/HandleParsingLib.h>
36	#include <Library/DevicePathLib.h>
37	#include <Library/UefiBootManagerLib.h>
38
39	STATIC CONST CHAR16 mFileName[] = L"ShellCommands";
40	STATIC EFI_HII_HANDLE gShellBcfgHiiHandle = NULL;
41
42	typedef enum {
43	BcfgTargetBootOrder = 0,
44	BcfgTargetDriverOrder = 1,
45	BcfgTargetMax = 2
46	} BCFG_OPERATION_TARGET;
47
48	typedef enum {
49	BcfgTypeDump = 0,
50	BcfgTypeAdd = 1,
51	BcfgTypeAddp = 2,
52	BcfgTypeAddh = 3,
53	BcfgTypeRm = 4,
54	BcfgTypeMv = 5,
55	BcfgTypeOpt = 6,
56	BcfgTypeMod = 7,
57	BcfgTypeModf = 8,
58	BcfgTypeModp = 9,
59	BcfgTypeModh = 10,
60	BcfgTypeMax = 11
61	} BCFG_OPERATION_TYPE;
62
63	typedef struct {
64	BCFG_OPERATION_TARGET Target;
65	BCFG_OPERATION_TYPE Type;
66	UINT16 Number1;
67	UINT16 Number2;
68	UINTN HandleIndex;
69	CHAR16 *FileName;
70	CHAR16 *Description;
71	UINT16 *Order;
72	CONST CHAR16 *OptData;
73	} BGFG_OPERATION;
74
75	/**
76	Update the optional data for a boot or driver option.
77
78	If optional data exists it will be changed.
79
80	@param[in] Index The boot or driver option index update.
81	@param[in] DataSize The size in bytes of Data.
82	@param[in] Data The buffer for the optional data.
83	@param[in] Target The target of the operation.
84
85	@retval EFI_SUCCESS The data was successfully updated.
86	@retval other A error occurred.
87	**/
88	EFI_STATUS
89	UpdateOptionalData (
90	UINT16 Index,
91	UINTN DataSize,
92	UINT8 *Data,
93	IN CONST BCFG_OPERATION_TARGET Target
94	)
95	{
96	EFI_STATUS Status;
97	CHAR16 VariableName[12];
98	UINTN OriginalSize;
99	UINT8 *OriginalData;
100	UINTN NewSize;
101	UINT8 *NewData;
102	UINTN OriginalOptionDataSize;
103
104	UnicodeSPrint (VariableName, sizeof (VariableName), L"%s%04x", Target == BcfgTargetBootOrder ? L"Boot" : L"Driver", Index);
105
106	OriginalSize = 0;
107	OriginalData = NULL;
108	NewData = NULL;
109	NewSize = 0;
110
111	Status = gRT->GetVariable (
112	VariableName,
113	(EFI_GUID *)&gEfiGlobalVariableGuid,
114	NULL,
115	&OriginalSize,
116	OriginalData
117	);
118	if (Status == EFI_BUFFER_TOO_SMALL) {
119	OriginalData = AllocateZeroPool (OriginalSize);
120	if (OriginalData == NULL) {
121	return (EFI_OUT_OF_RESOURCES);
122	}
123
124	Status = gRT->GetVariable (
125	VariableName,
126	(EFI_GUID *)&gEfiGlobalVariableGuid,
127	NULL,
128	&OriginalSize,
129	OriginalData
130	);
131	}
132
133	if (!EFI_ERROR (Status)) {
134	//
135	// Allocate new struct and discard old optional data.
136	//
137	ASSERT (OriginalData != NULL);
138	OriginalOptionDataSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (((CHAR16 *)(OriginalData + sizeof (UINT32) + sizeof (UINT16))));
139	OriginalOptionDataSize += ((UINT16 )(OriginalData + sizeof (UINT32)));
140	OriginalOptionDataSize -= OriginalSize;
141	NewSize = OriginalSize - OriginalOptionDataSize + DataSize;
142	NewData = AllocatePool (NewSize);
143	if (NewData == NULL) {
144	Status = EFI_OUT_OF_RESOURCES;
145	} else {
146	CopyMem (NewData, OriginalData, OriginalSize - OriginalOptionDataSize);
147	CopyMem (NewData + OriginalSize - OriginalOptionDataSize, Data, DataSize);
148	}
149	}
150
151	if (!EFI_ERROR (Status)) {
152	//
153	// put the data back under the variable
154	//
155	Status = gRT->SetVariable (
156	VariableName,
157	(EFI_GUID *)&gEfiGlobalVariableGuid,
158	EFI_VARIABLE_NON_VOLATILE\|EFI_VARIABLE_BOOTSERVICE_ACCESS\|EFI_VARIABLE_RUNTIME_ACCESS,
159	NewSize,
160	NewData
161	);
162	}
163
164	SHELL_FREE_NON_NULL (OriginalData);
165	SHELL_FREE_NON_NULL (NewData);
166	return (Status);
167	}
168
169	/**
170	This function will get a CRC for a boot option.
171
172	@param[in, out] Crc The CRC value to return.
173	@param[in] BootIndex The boot option index to CRC.
174
175	@retval EFI_SUCCESS The CRC was successfully returned.
176	@retval other A error occurred.
177	**/
178	EFI_STATUS
179	GetBootOptionCrc (
180	UINT32 *Crc,
181	UINT16 BootIndex
182	)
183	{
184	CHAR16 VariableName[12];
185	EFI_STATUS Status;
186	UINT8 *Buffer;
187	UINTN BufferSize;
188
189	Buffer = NULL;
190	BufferSize = 0;
191
192	//
193	// Get the data Buffer
194	//
195	UnicodeSPrint (VariableName, sizeof (VariableName), L"%Boot%04x", BootIndex);
196	Status = gRT->GetVariable (
197	VariableName,
198	(EFI_GUID *)&gEfiGlobalVariableGuid,
199	NULL,
200	&BufferSize,
201	NULL
202	);
203	if (Status == EFI_BUFFER_TOO_SMALL) {
204	Buffer = AllocateZeroPool (BufferSize);
205	Status = gRT->GetVariable (
206	VariableName,
207	(EFI_GUID *)&gEfiGlobalVariableGuid,
208	NULL,
209	&BufferSize,
210	Buffer
211	);
212	}
213
214	//
215	// Get the CRC computed
216	//
217	if (!EFI_ERROR (Status)) {
218	Status = gBS->CalculateCrc32 (Buffer, BufferSize, Crc);
219	}
220
221	SHELL_FREE_NON_NULL (Buffer);
222	return EFI_SUCCESS;
223	}
224
225	/**
226	This function will populate the device path protocol parameter based on TheHandle.
227
228	@param[in] TheHandle Driver handle.
229	@param[in, out] FilePath On a successful return the device path to the handle.
230
231	@retval EFI_SUCCESS The device path was successfully returned.
232	@retval other A error from gBS->HandleProtocol.
233
234	@sa HandleProtocol
235	**/
236	EFI_STATUS
237	GetDevicePathForDriverHandle (
238	IN EFI_HANDLE TheHandle,
239	IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath
240	)
241	{
242	EFI_STATUS Status;
243	EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
244	EFI_DEVICE_PATH_PROTOCOL *ImageDevicePath;
245
246	Status = gBS->OpenProtocol (
247	TheHandle,
248	&gEfiLoadedImageProtocolGuid,
249	(VOID **)&LoadedImage,
250	gImageHandle,
251	NULL,
252	EFI_OPEN_PROTOCOL_GET_PROTOCOL
253	);
254	if (!EFI_ERROR (Status)) {
255	Status = gBS->OpenProtocol (
256	LoadedImage->DeviceHandle,
257	&gEfiDevicePathProtocolGuid,
258	(VOID **)&ImageDevicePath,
259	gImageHandle,
260	NULL,
261	EFI_OPEN_PROTOCOL_GET_PROTOCOL
262	);
263	if (!EFI_ERROR (Status)) {
264	// *DevPath = DuplicateDevicePath (ImageDevicePath);
265	// *FilePath = DuplicateDevicePath (LoadedImage->FilePath);
266	*FilePath = AppendDevicePath (ImageDevicePath, LoadedImage->FilePath);
267	gBS->CloseProtocol (
268	LoadedImage->DeviceHandle,
269	&gEfiDevicePathProtocolGuid,
270	gImageHandle,
271	NULL
272	);
273	}
274
275	gBS->CloseProtocol (
276	TheHandle,
277	&gEfiLoadedImageProtocolGuid,
278	gImageHandle,
279	NULL
280	);
281	}
282
283	return (Status);
284	}
285
286	/**
287	Function to get Device Path by a handle.
288
289	@param[in] TheHandle Use it to get DevicePath.
290	@param[in] Target Boot option target.
291	@param[in, out] DevicePath On a successful return the device path to the handle.
292
293	@retval SHELL_INVALID_PARAMETER The handle was NULL.
294	@retval SHELL_NOT_FOUND Not found device path by handle.
295	@retval SHELL_SUCCESS Get device path successfully.
296	**/
297	SHELL_STATUS
298	GetDevicePathByHandle (
299	IN EFI_HANDLE TheHandle,
300	IN BCFG_OPERATION_TARGET Target,
301	IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath
302	)
303	{
304	EFI_STATUS Status;
305	SHELL_STATUS ShellStatus;
306
307	UINTN DriverBindingHandleCount;
308	UINTN ParentControllerHandleCount;
309	UINTN ChildControllerHandleCount;
310
311	ShellStatus = SHELL_SUCCESS;
312
313	if (TheHandle == NULL) {
314	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Handle Number");
315	return SHELL_INVALID_PARAMETER;
316	}
317
318	Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (TheHandle, &DriverBindingHandleCount, NULL);
319	if (EFI_ERROR (Status)) {
320	DriverBindingHandleCount = 0;
321	}
322
323	Status = PARSE_HANDLE_DATABASE_PARENTS (TheHandle, &ParentControllerHandleCount, NULL);
324	if (EFI_ERROR (Status)) {
325	ParentControllerHandleCount = 0;
326	}
327
328	Status = ParseHandleDatabaseForChildControllers (TheHandle, &ChildControllerHandleCount, NULL);
329	if (EFI_ERROR (Status)) {
330	ChildControllerHandleCount = 0;
331	}
332
333	Status = gBS->HandleProtocol (TheHandle, &gEfiDevicePathProtocolGuid, (VOID **)DevicePath);
334
335	if ((DriverBindingHandleCount > 0) \|\|
336	(ParentControllerHandleCount > 0) \|\|
337	(ChildControllerHandleCount > 0) \|\|
338	!EFI_ERROR (Status)
339	)
340	{
341	//
342	// The handle points to a real controller which has a device path.
343	//
344	if (Target == BcfgTargetDriverOrder) {
345	ShellPrintHiiEx (
346	-1,
347	-1,
348	NULL,
349	STRING_TOKEN (STR_GEN_PARAM_INV),
350	gShellBcfgHiiHandle,
351	L"bcfg",
352	L"Handle should point to driver image."
353	);
354	ShellStatus = SHELL_NOT_FOUND;
355	}
356	} else {
357	//
358	// The handle points to a driver image.
359	//
360	if (Target == BcfgTargetBootOrder) {
361	ShellPrintHiiEx (
362	-1,
363	-1,
364	NULL,
365	STRING_TOKEN (STR_GEN_PARAM_INV),
366	gShellBcfgHiiHandle,
367	L"bcfg",
368	L"Handle should point to controller."
369	);
370	ShellStatus = SHELL_NOT_FOUND;
371	} else {
372	if (EFI_ERROR (GetDevicePathForDriverHandle (TheHandle, DevicePath))) {
373	ShellStatus = SHELL_NOT_FOUND;
374	}
375	}
376	}
377
378	return (ShellStatus);
379	}
380
381	/**
382	Function to modify an option.
383
384	@param[in] BcfgOperation Pointer to BCFG operation.
385	@param[in] OrderCount The number if items in CurrentOrder.
386
387	@retval SHELL_SUCCESS The operation was successful.
388	@retval SHELL_INVALID_PARAMETER A parameter was invalid.
389	@retval SHELL_OUT_OF_RESOUCES A memory allocation failed.
390	**/
391	SHELL_STATUS
392	BcfgMod (
393	IN CONST BGFG_OPERATION *BcfgOperation,
394	IN CONST UINTN OrderCount
395	)
396	{
397	EFI_STATUS Status;
398	EFI_HANDLE CurHandle;
399	SHELL_STATUS ShellStatus;
400	CHAR16 OptionStr[40];
401	EFI_SHELL_FILE_INFO *FileList;
402	EFI_SHELL_FILE_INFO *Arg;
403	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
404	EFI_DEVICE_PATH_PROTOCOL *DevicePathBuffer;
405	EFI_DEVICE_PATH_PROTOCOL *DevicePathWalker;
406	EFI_BOOT_MANAGER_LOAD_OPTION LoadOption;
407
408	ShellStatus = SHELL_SUCCESS;
409	FileList = NULL;
410	DevicePath = NULL;
411	DevicePathBuffer = NULL;
412
413	ZeroMem (&LoadOption, sizeof (EFI_BOOT_MANAGER_LOAD_OPTION));
414
415	if (((BcfgOperation->Type == BcfgTypeMod) && (BcfgOperation->Description == NULL)) \|\|
416	((BcfgOperation->Type == BcfgTypeModf) && (BcfgOperation->FileName == NULL)) \|\|
417	((BcfgOperation->Type == BcfgTypeModp) && (BcfgOperation->FileName == NULL)) \|\|
418	((BcfgOperation->Type == BcfgTypeModh) && (BcfgOperation->HandleIndex == 0)) \|\|
419	(BcfgOperation->Number1 > OrderCount)
420	)
421	{
422	return (SHELL_INVALID_PARAMETER);
423	}
424
425	if (BcfgOperation->Type == BcfgTypeModh) {
426	CurHandle = ConvertHandleIndexToHandle (BcfgOperation->HandleIndex);
427	ShellStatus = GetDevicePathByHandle (CurHandle, BcfgOperation->Target, &DevicePathBuffer);
428	if (ShellStatus == SHELL_SUCCESS) {
429	DevicePath = DuplicateDevicePath (DevicePathBuffer);
430	}
431	} else if ((BcfgOperation->Type == BcfgTypeModf) \|\| (BcfgOperation->Type == BcfgTypeModp)) {
432	//
433	// Get Device Path by FileName.
434	//
435	ShellOpenFileMetaArg ((CHAR16 *)BcfgOperation->FileName, EFI_FILE_MODE_READ, &FileList);
436	if (FileList == NULL) {
437	//
438	// The name of file matched nothing.
439	//
440	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellBcfgHiiHandle, L"bcfg", BcfgOperation->FileName);
441	ShellStatus = SHELL_INVALID_PARAMETER;
442	} else if (FileList->Link.ForwardLink != FileList->Link.BackLink) {
443	//
444	// If the name of file expanded to multiple names, it's fail.
445	//
446	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE), gShellBcfgHiiHandle, L"bcfg", BcfgOperation->FileName);
447	ShellStatus = SHELL_INVALID_PARAMETER;
448	} else {
449	Arg = (EFI_SHELL_FILE_INFO *)GetFirstNode (&FileList->Link);
450	if (EFI_ERROR (Arg->Status)) {
451	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE_OPEN), gShellBcfgHiiHandle, L"bcfg", BcfgOperation->FileName);
452	ShellStatus = SHELL_INVALID_PARAMETER;
453	} else {
454	DevicePathBuffer = gEfiShellProtocol->GetDevicePathFromFilePath (Arg->FullName);
455	if (DevicePathBuffer == NULL) {
456	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE_DP), gShellBcfgHiiHandle, L"bcfg", Arg->FullName);
457	ShellStatus = SHELL_UNSUPPORTED;
458	}
459	}
460	}
461
462	if (ShellStatus == SHELL_SUCCESS) {
463	if (BcfgOperation->Type == BcfgTypeModp) {
464	ShellStatus = SHELL_INVALID_PARAMETER;
465	DevicePathWalker = DevicePathBuffer;
466	while (!IsDevicePathEnd (DevicePathWalker)) {
467	if ((DevicePathType (DevicePathWalker) == MEDIA_DEVICE_PATH) &&
468	(DevicePathSubType (DevicePathWalker) == MEDIA_HARDDRIVE_DP)
469	)
470	{
471	//
472	// We found the portion of device path starting with the hard driver partition.
473	//
474	ShellStatus = SHELL_SUCCESS;
475	DevicePath = DuplicateDevicePath (DevicePathWalker);
476	break;
477	} else {
478	DevicePathWalker = NextDevicePathNode (DevicePathWalker);
479	}
480	}
481	} else {
482	DevicePath = DuplicateDevicePath (DevicePathBuffer);
483	}
484
485	FreePool (DevicePathBuffer);
486	}
487	}
488
489	if (ShellStatus == SHELL_SUCCESS) {
490	if (BcfgOperation->Target == BcfgTargetBootOrder) {
491	UnicodeSPrint (OptionStr, sizeof (OptionStr), L"Boot%04x", BcfgOperation->Order[BcfgOperation->Number1]);
492	} else {
493	UnicodeSPrint (OptionStr, sizeof (OptionStr), L"Driver%04x", BcfgOperation->Order[BcfgOperation->Number1]);
494	}
495
496	Status = EfiBootManagerVariableToLoadOption (OptionStr, &LoadOption);
497	if (EFI_ERROR (Status)) {
498	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NONE), gShellBcfgHiiHandle);
499	ShellStatus = SHELL_NOT_FOUND;
500	}
501	}
502
503	if (ShellStatus == SHELL_SUCCESS) {
504	if (BcfgOperation->Type == BcfgTypeMod) {
505	SHELL_FREE_NON_NULL (LoadOption.Description);
506	LoadOption.Description = AllocateCopyPool (StrSize (BcfgOperation->Description), BcfgOperation->Description);
507	} else {
508	SHELL_FREE_NON_NULL (LoadOption.FilePath);
509	LoadOption.FilePath = DuplicateDevicePath (DevicePath);
510	}
511
512	Status = EfiBootManagerLoadOptionToVariable (&LoadOption);
513	if (EFI_ERROR (Status)) {
514	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", OptionStr);
515	ShellStatus = SHELL_INVALID_PARAMETER;
516	}
517	}
518
519	EfiBootManagerFreeLoadOption (&LoadOption);
520
521	if (DevicePath != NULL) {
522	FreePool (DevicePath);
523	}
524
525	if (FileList != NULL) {
526	ShellCloseFileMetaArg (&FileList);
527	}
528
529	return (ShellStatus);
530	}
531
532	/**
533	Function to add a option.
534
535	@param[in] Position The position to add Target at.
536	@param[in] File The file to make the target.
537	@param[in] Desc The description text.
538	@param[in] CurrentOrder The pointer to the current order of items.
539	@param[in] OrderCount The number if items in CurrentOrder.
540	@param[in] Target The info on the option to add.
541	@param[in] UseHandle TRUE to use HandleNumber, FALSE to use File and Desc.
542	@param[in] UsePath TRUE to convert to devicepath.
543	@param[in] HandleNumber The handle number to add.
544
545	@retval SHELL_SUCCESS The operation was successful.
546	@retval SHELL_INVALID_PARAMETER A parameter was invalid.
547	**/
548	SHELL_STATUS
549	BcfgAdd (
550	IN UINTN Position,
551	IN CONST CHAR16 *File,
552	IN CONST CHAR16 *Desc,
553	IN CONST UINT16 *CurrentOrder,
554	IN CONST UINTN OrderCount,
555	IN CONST BCFG_OPERATION_TARGET Target,
556	IN CONST BOOLEAN UseHandle,
557	IN CONST BOOLEAN UsePath,
558	IN CONST UINTN HandleNumber
559	)
560	{
561	EFI_STATUS Status;
562	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
563	EFI_DEVICE_PATH_PROTOCOL *DevPath;
564	EFI_DEVICE_PATH_PROTOCOL *FilePath;
565	CHAR16 *Str;
566	UINT8 *TempByteBuffer;
567	UINT8 *TempByteStart;
568	EFI_SHELL_FILE_INFO *Arg;
569	EFI_SHELL_FILE_INFO *FileList;
570	CHAR16 OptionStr[40];
571	UINTN DescSize, FilePathSize;
572	BOOLEAN Found;
573	UINTN TargetLocation;
574	UINTN Index;
575	EFI_HANDLE *Handles;
576	EFI_HANDLE CurHandle;
577	UINTN DriverBindingHandleCount;
578	UINTN ParentControllerHandleCount;
579	UINTN ChildControllerHandleCount;
580	SHELL_STATUS ShellStatus;
581	UINT16 *NewOrder;
582
583	if (!UseHandle) {
584	if ((File == NULL) \|\| (Desc == NULL)) {
585	return (SHELL_INVALID_PARAMETER);
586	}
587	} else {
588	if (HandleNumber == 0) {
589	return (SHELL_INVALID_PARAMETER);
590	}
591	}
592
593	if (Position > OrderCount) {
594	Position = OrderCount;
595	}
596
597	Str = NULL;
598	FilePath = NULL;
599	FileList = NULL;
600	Handles = NULL;
601	ShellStatus = SHELL_SUCCESS;
602	TargetLocation = 0xFFFF;
603
604	if (UseHandle) {
605	CurHandle = ConvertHandleIndexToHandle (HandleNumber);
606	if (CurHandle == NULL) {
607	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Handle Number");
608	ShellStatus = SHELL_INVALID_PARAMETER;
609	} else {
610	if (Target == BcfgTargetBootOrder) {
611	//
612	// Make sure that the handle should point to a real controller
613	//
614	Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
615	CurHandle,
616	&DriverBindingHandleCount,
617	NULL
618	);
619
620	Status = PARSE_HANDLE_DATABASE_PARENTS (
621	CurHandle,
622	&ParentControllerHandleCount,
623	NULL
624	);
625
626	Status = ParseHandleDatabaseForChildControllers (
627	CurHandle,
628	&ChildControllerHandleCount,
629	NULL
630	);
631
632	if ( (DriverBindingHandleCount > 0)
633	\|\| (ParentControllerHandleCount > 0)
634	\|\| (ChildControllerHandleCount > 0))
635	{
636	FilePath = NULL;
637	Status = gBS->HandleProtocol (
638	CurHandle,
639	&gEfiDevicePathProtocolGuid,
640	(VOID **)&FilePath
641	);
642	}
643
644	if (EFI_ERROR (Status)) {
645	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_HANDLE), gShellBcfgHiiHandle, L"bcfg", HandleNumber);
646	ShellStatus = SHELL_INVALID_PARAMETER;
647	}
648	} else {
649	//
650	// Make sure that the handle should point to driver, not a controller.
651	//
652	Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
653	CurHandle,
654	&DriverBindingHandleCount,
655	NULL
656	);
657
658	Status = PARSE_HANDLE_DATABASE_PARENTS (
659	CurHandle,
660	&ParentControllerHandleCount,
661	NULL
662	);
663
664	Status = ParseHandleDatabaseForChildControllers (
665	CurHandle,
666	&ChildControllerHandleCount,
667	NULL
668	);
669
670	Status = gBS->HandleProtocol (
671	CurHandle,
672	&gEfiDevicePathProtocolGuid,
673	(VOID **)&FilePath
674	);
675
676	if ( (DriverBindingHandleCount > 0)
677	\|\| (ParentControllerHandleCount > 0)
678	\|\| (ChildControllerHandleCount > 0)
679	\|\| !EFI_ERROR (Status))
680	{
681	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Handle Number");
682	ShellStatus = SHELL_INVALID_PARAMETER;
683	} else {
684	//
685	// Get the DevicePath from the loaded image information.
686	//
687	Status = GetDevicePathForDriverHandle (CurHandle, &FilePath);
688	}
689	}
690	}
691	} else {
692	//
693	// Get file info
694	//
695	ShellOpenFileMetaArg ((CHAR16 *)File, EFI_FILE_MODE_READ, &FileList);
696
697	if (FileList == NULL) {
698	//
699	// If filename matched nothing fail
700	//
701	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellBcfgHiiHandle, L"bcfg", File);
702	ShellStatus = SHELL_INVALID_PARAMETER;
703	} else if (FileList->Link.ForwardLink != FileList->Link.BackLink) {
704	//
705	// If filename expanded to multiple names, fail
706	//
707	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE), gShellBcfgHiiHandle, L"bcfg", File);
708	ShellStatus = SHELL_INVALID_PARAMETER;
709	} else {
710	Arg = (EFI_SHELL_FILE_INFO *)GetFirstNode (&FileList->Link);
711	if (EFI_ERROR (Arg->Status)) {
712	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE_OPEN), gShellBcfgHiiHandle, L"bcfg", File);
713	ShellStatus = SHELL_INVALID_PARAMETER;
714	} else {
715	//
716	// Build FilePath to the filename
717	//
718
719	//
720	// get the device path
721	//
722	DevicePath = gEfiShellProtocol->GetDevicePathFromFilePath (Arg->FullName);
723	if (DevicePath == NULL) {
724	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_FILE_DP), gShellBcfgHiiHandle, L"bcfg", Arg->FullName);
725	ShellStatus = SHELL_UNSUPPORTED;
726	} else {
727	if (UsePath) {
728	DevPath = DevicePath;
729	ShellStatus = SHELL_INVALID_PARAMETER;
730	while (!IsDevicePathEnd (DevPath)) {
731	if ((DevicePathType (DevPath) == MEDIA_DEVICE_PATH) &&
732	(DevicePathSubType (DevPath) == MEDIA_HARDDRIVE_DP))
733	{
734	//
735	// If we find it use it instead
736	//
737	ShellStatus = SHELL_SUCCESS;
738	FilePath = DuplicateDevicePath (DevPath);
739	break;
740	}
741
742	DevPath = NextDevicePathNode (DevPath);
743	}
744	} else {
745	FilePath = DuplicateDevicePath (DevicePath);
746	}
747
748	FreePool (DevicePath);
749	}
750	}
751	}
752	}
753
754	if (ShellStatus == SHELL_SUCCESS) {
755	//
756	// Find a free target ,a brute force implementation
757	//
758	Found = FALSE;
759	for (TargetLocation = 0; TargetLocation < 0xFFFF; TargetLocation++) {
760	Found = TRUE;
761	for (Index = 0; Index < OrderCount; Index++) {
762	if (CurrentOrder[Index] == TargetLocation) {
763	Found = FALSE;
764	break;
765	}
766	}
767
768	if (Found) {
769	break;
770	}
771	}
772
773	if (TargetLocation == 0xFFFF) {
774	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_TARGET_NF), gShellBcfgHiiHandle, L"bcfg");
775	} else {
776	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_TARGET), gShellBcfgHiiHandle, TargetLocation);
777	}
778	}
779
780	if (ShellStatus == SHELL_SUCCESS) {
781	//
782	// Add the option
783	//
784	DescSize = StrSize (Desc);
785	FilePathSize = GetDevicePathSize (FilePath);
786
787	TempByteBuffer = AllocateZeroPool (sizeof (UINT32) + sizeof (UINT16) + DescSize + FilePathSize);
788	if (TempByteBuffer != NULL) {
789	TempByteStart = TempByteBuffer;
790	((UINT32 )TempByteBuffer) = LOAD_OPTION_ACTIVE; // Attributes
791	TempByteBuffer += sizeof (UINT32);
792
793	((UINT16 )TempByteBuffer) = (UINT16)FilePathSize; // FilePathListLength
794	TempByteBuffer += sizeof (UINT16);
795
796	CopyMem (TempByteBuffer, Desc, DescSize);
797	TempByteBuffer += DescSize;
798	ASSERT (FilePath != NULL);
799	CopyMem (TempByteBuffer, FilePath, FilePathSize);
800
801	UnicodeSPrint (OptionStr, sizeof (OptionStr), L"%s%04x", Target == BcfgTargetBootOrder ? L"Boot" : L"Driver", TargetLocation);
802	Status = gRT->SetVariable (
803	OptionStr,
804	&gEfiGlobalVariableGuid,
805	EFI_VARIABLE_NON_VOLATILE\|EFI_VARIABLE_BOOTSERVICE_ACCESS\|EFI_VARIABLE_RUNTIME_ACCESS,
806	sizeof (UINT32) + sizeof (UINT16) + DescSize + FilePathSize,
807	TempByteStart
808	);
809
810	FreePool (TempByteStart);
811	} else {
812	Status = EFI_OUT_OF_RESOURCES;
813	}
814
815	if (EFI_ERROR (Status)) {
816	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", OptionStr);
817	} else {
818	NewOrder = AllocateZeroPool ((OrderCount + 1) * sizeof (NewOrder[0]));
819	if (NewOrder != NULL) {
820	CopyMem (NewOrder, CurrentOrder, (OrderCount) * sizeof (NewOrder[0]));
821
822	//
823	// Insert target into order list
824	//
825	for (Index = OrderCount; Index > Position; Index--) {
826	NewOrder[Index] = NewOrder[Index - 1];
827	}
828
829	NewOrder[Position] = (UINT16)TargetLocation;
830	Status = gRT->SetVariable (
831	Target == BcfgTargetBootOrder ? L"BootOrder" : L"DriverOrder",
832	&gEfiGlobalVariableGuid,
833	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS,
834	(OrderCount + 1) * sizeof (UINT16),
835	NewOrder
836	);
837
838	FreePool (NewOrder);
839
840	if (EFI_ERROR (Status)) {
841	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_WRITE_FAIL), gShellBcfgHiiHandle, L"bcfg", Target == BcfgTargetBootOrder ? L"BootOrder" : L"DriverOrder");
842	ShellStatus = SHELL_INVALID_PARAMETER;
843	} else {
844	Print (L"bcfg: Add %s as %x\n", OptionStr, Position);
845	}
846	}
847	}
848	}
849
850	//
851	// If always Free FilePath, will free devicepath in system when use "addh"
852	//
853	if ((FilePath != NULL) && !UseHandle) {
854	FreePool (FilePath);
855	}
856
857	if (Str != NULL) {
858	FreePool (Str);
859	}
860
861	if (Handles != NULL) {
862	FreePool (Handles);
863	}
864
865	if (FileList != NULL) {
866	ShellCloseFileMetaArg (&FileList);
867	}
868
869	return (ShellStatus);
870	}
871
872	/**
873	Function to remove an item.
874
875	@param[in] Target The target item to move.
876	@param[in] CurrentOrder The pointer to the current order of items.
877	@param[in] OrderCount The number if items in CurrentOrder.
878	@param[in] Location The current location of the Target.
879
880	@retval SHELL_SUCCESS The operation was successful.
881	@retval SHELL_INVALID_PARAMETER A parameter was invalid.
882	**/
883	SHELL_STATUS
884	BcfgRemove (
885	IN CONST BCFG_OPERATION_TARGET Target,
886	IN CONST UINT16 *CurrentOrder,
887	IN CONST UINTN OrderCount,
888	IN CONST UINT16 Location
889	)
890	{
891	CHAR16 VariableName[12];
892	UINT16 *NewOrder;
893	EFI_STATUS Status;
894	UINTN NewCount;
895
896	UnicodeSPrint (VariableName, sizeof (VariableName), L"%s%04x", Target == BcfgTargetBootOrder ? L"Boot" : L"Driver", CurrentOrder[Location]);
897	Status = gRT->SetVariable (
898	VariableName,
899	(EFI_GUID *)&gEfiGlobalVariableGuid,
900	EFI_VARIABLE_NON_VOLATILE\|EFI_VARIABLE_BOOTSERVICE_ACCESS\|EFI_VARIABLE_RUNTIME_ACCESS,
901	0,
902	NULL
903	);
904	if (EFI_ERROR (Status)) {
905	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_WRITE_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName);
906	return (SHELL_INVALID_PARAMETER);
907	}
908
909	NewOrder = AllocateZeroPool (OrderCount*sizeof (CurrentOrder[0]));
910	if (NewOrder != NULL) {
911	NewCount = OrderCount;
912	CopyMem (NewOrder, CurrentOrder, OrderCount*sizeof (CurrentOrder[0]));
913	CopyMem (NewOrder+Location, NewOrder+Location+1, (OrderCount - Location - 1)*sizeof (CurrentOrder[0]));
914	NewCount--;
915
916	Status = gRT->SetVariable (
917	Target == BcfgTargetBootOrder ? (CHAR16 )L"BootOrder" : (CHAR16 )L"DriverOrder",
918	(EFI_GUID *)&gEfiGlobalVariableGuid,
919	EFI_VARIABLE_NON_VOLATILE\|EFI_VARIABLE_BOOTSERVICE_ACCESS\|EFI_VARIABLE_RUNTIME_ACCESS,
920	NewCount*sizeof (NewOrder[0]),
921	NewOrder
922	);
923	FreePool (NewOrder);
924	} else {
925	Status = EFI_OUT_OF_RESOURCES;
926	}
927
928	if (EFI_ERROR (Status)) {
929	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_WRITE_FAIL), gShellBcfgHiiHandle, L"bcfg", Target == BcfgTargetBootOrder ? (CHAR16 )L"BootOrder" : (CHAR16 )L"DriverOrder");
930	return (SHELL_INVALID_PARAMETER);
931	}
932
933	return (SHELL_SUCCESS);
934	}
935
936	/**
937	Function to move a item to another location.
938
939	@param[in] Target The target item to move.
940	@param[in] CurrentOrder The pointer to the current order of items.
941	@param[in] OrderCount The number if items in CurrentOrder.
942	@param[in] OldLocation The current location of the Target.
943	@param[in] NewLocation The desired location of the Target.
944
945	@retval SHELL_SUCCESS The operation was successful.
946	@retval SHELL_INVALID_PARAMETER A parameter was invalid.
947	**/
948	SHELL_STATUS
949	BcfgMove (
950	IN CONST BCFG_OPERATION_TARGET Target,
951	IN CONST UINT16 *CurrentOrder,
952	IN CONST UINTN OrderCount,
953	IN CONST UINT16 OldLocation,
954	IN UINT16 NewLocation
955	)
956	{
957	UINT16 *NewOrder;
958	EFI_STATUS Status;
959	UINT16 Temp;
960
961	NewOrder = AllocateCopyPool (OrderCount*sizeof (CurrentOrder[0]), CurrentOrder);
962	if (NewOrder == NULL) {
963	return (SHELL_OUT_OF_RESOURCES);
964	}
965
966	//
967	// correct the new location
968	//
969	if (NewLocation >= OrderCount) {
970	if (OrderCount > 0) {
971	NewLocation = (UINT16)OrderCount - 1;
972	} else {
973	NewLocation = 0;
974	}
975	}
976
977	Temp = CurrentOrder[OldLocation];
978	CopyMem (NewOrder+OldLocation, NewOrder+OldLocation+1, (OrderCount - OldLocation - 1)*sizeof (CurrentOrder[0]));
979	CopyMem (NewOrder+NewLocation+1, NewOrder+NewLocation, (OrderCount - NewLocation - 1)*sizeof (CurrentOrder[0]));
980	NewOrder[NewLocation] = Temp;
981
982	Status = gRT->SetVariable (
983	Target == BcfgTargetBootOrder ? (CHAR16 )L"BootOrder" : (CHAR16 )L"DriverOrder",
984	(EFI_GUID *)&gEfiGlobalVariableGuid,
985	EFI_VARIABLE_NON_VOLATILE\|EFI_VARIABLE_BOOTSERVICE_ACCESS\|EFI_VARIABLE_RUNTIME_ACCESS,
986	OrderCount*sizeof (CurrentOrder[0]),
987	NewOrder
988	);
989
990	FreePool (NewOrder);
991
992	if (EFI_ERROR (Status)) {
993	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_WRITE_FAIL), gShellBcfgHiiHandle, L"bcfg", Target == BcfgTargetBootOrder ? (CHAR16 )L"BootOrder" : (CHAR16 )L"DriverOrder");
994	return (SHELL_INVALID_PARAMETER);
995	}
996
997	return (SHELL_SUCCESS);
998	}
999
1000	/**
1001	Function to add optional data to an option.
1002
1003	@param[in] OptData The optional data to add.
1004	@param[in] CurrentOrder The pointer to the current order of items.
1005	@param[in] OrderCount The number if items in CurrentOrder.
1006	@param[in] Target The target of the operation.
1007
1008	@retval SHELL_SUCCESS The operation was succesful.
1009	**/
1010	SHELL_STATUS
1011	BcfgAddOpt (
1012	IN CONST CHAR16 *OptData,
1013	IN CONST UINT16 *CurrentOrder,
1014	IN CONST UINTN OrderCount,
1015	IN CONST BCFG_OPERATION_TARGET Target
1016	)
1017	{
1018	EFI_KEY_OPTION NewKeyOption;
1019	EFI_KEY_OPTION *KeyOptionBuffer;
1020	SHELL_STATUS ShellStatus;
1021	EFI_STATUS Status;
1022	UINT16 OptionIndex;
1023	UINT16 LoopCounter;
1024	UINT64 Intermediate;
1025	CONST CHAR16 *Temp;
1026	CONST CHAR16 *Walker;
1027	CHAR16 *FileName;
1028	CHAR16 *Temp2;
1029	CHAR16 *Data;
1030	UINT32 KeyIndex;
1031	CHAR16 VariableName[12];
1032	VOID *VariableData;
1033
1034	SHELL_FILE_HANDLE FileHandle;
1035
1036	Status = EFI_SUCCESS;
1037	ShellStatus = SHELL_SUCCESS;
1038	Walker = OptData;
1039	FileName = NULL;
1040	Data = NULL;
1041	KeyOptionBuffer = NULL;
1042	VariableData = NULL;
1043
1044	ZeroMem (&NewKeyOption, sizeof (EFI_KEY_OPTION));
1045	ZeroMem (VariableName, sizeof (VariableName));
1046
1047	while (Walker[0] == L' ') {
1048	Walker++;
1049	}
1050
1051	//
1052	// Get the index of the variable we are changing.
1053	//
1054	Status = ShellConvertStringToUint64 (Walker, &Intermediate, TRUE, TRUE);
1055	if (EFI_ERROR (Status) \|\| (((UINT16)Intermediate) != Intermediate) \|\| (StrStr (Walker, L" ") == NULL) \|\| (((UINT16)Intermediate) > ((UINT16)OrderCount))) {
1056	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Option Index");
1057	ShellStatus = SHELL_INVALID_PARAMETER;
1058	return (ShellStatus);
1059	}
1060
1061	OptionIndex = (UINT16)Intermediate;
1062
1063	Temp = StrStr (Walker, L" ");
1064	if (Temp != NULL) {
1065	Walker = Temp;
1066	}
1067
1068	while (Walker[0] == L' ') {
1069	Walker++;
1070	}
1071
1072	//
1073	// determine whether we have file with data, quote delimited information, or a hot-key
1074	//
1075	if (Walker[0] == L'\"') {
1076	//
1077	// quoted filename or quoted information.
1078	//
1079	Temp = StrStr (Walker+1, L"\"");
1080	if ((Temp == NULL) \|\| (StrLen (Temp) != 1)) {
1081	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker);
1082	ShellStatus = SHELL_INVALID_PARAMETER;
1083	} else {
1084	FileName = StrnCatGrow (&FileName, NULL, Walker+1, 0);
1085	if (FileName == NULL) {
1086	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellBcfgHiiHandle, L"bcfg");
1087	ShellStatus = SHELL_OUT_OF_RESOURCES;
1088	return (ShellStatus);
1089	}
1090
1091	Temp2 = StrStr (FileName, L"\"");
1092	ASSERT (Temp2 != NULL);
1093	Temp2[0] = CHAR_NULL;
1094	Temp2++;
1095	if (StrLen (Temp2) > 0) {
1096	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker);
1097	ShellStatus = SHELL_INVALID_PARAMETER;
1098	}
1099
1100	if (EFI_ERROR (ShellFileExists (Walker))) {
1101	//
1102	// Not a file. must be misc information.
1103	//
1104	Data = FileName;
1105	FileName = NULL;
1106	} else {
1107	FileName = StrnCatGrow (&FileName, NULL, Walker, 0);
1108	}
1109	}
1110	} else {
1111	//
1112	// filename or hot key information.
1113	//
1114	if (StrStr (Walker, L" ") == NULL) {
1115	//
1116	// filename
1117	//
1118	if (EFI_ERROR (ShellFileExists (Walker))) {
1119	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FIND_FAIL), gShellBcfgHiiHandle, L"bcfg", Walker);
1120	ShellStatus = SHELL_INVALID_PARAMETER;
1121	} else {
1122	FileName = StrnCatGrow (&FileName, NULL, Walker, 0);
1123	}
1124	} else {
1125	if (Target != BcfgTargetBootOrder) {
1126	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_BOOT_ONLY), gShellBcfgHiiHandle, L"bcfg");
1127	ShellStatus = SHELL_INVALID_PARAMETER;
1128	}
1129
1130	if (ShellStatus == SHELL_SUCCESS) {
1131	//
1132	// Get hot key information
1133	//
1134	Status = ShellConvertStringToUint64 (Walker, &Intermediate, FALSE, TRUE);
1135	if (EFI_ERROR (Status) \|\| (((UINT32)Intermediate) != Intermediate) \|\| (StrStr (Walker, L" ") == NULL)) {
1136	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker);
1137	ShellStatus = SHELL_INVALID_PARAMETER;
1138	}
1139
1140	NewKeyOption.KeyData.PackedValue = (UINT32)Intermediate;
1141	Temp = StrStr (Walker, L" ");
1142	if (Temp != NULL) {
1143	Walker = Temp;
1144	}
1145
1146	while (Walker[0] == L' ') {
1147	Walker++;
1148	}
1149	}
1150
1151	if (ShellStatus == SHELL_SUCCESS) {
1152	//
1153	// Now we know how many EFI_INPUT_KEY structs we need to attach to the end of the EFI_KEY_OPTION struct.
1154	// Re-allocate with the added information.
1155	//
1156	KeyOptionBuffer = AllocatePool (sizeof (EFI_KEY_OPTION) + (sizeof (EFI_INPUT_KEY) * NewKeyOption.KeyData.Options.InputKeyCount));
1157	if (KeyOptionBuffer == NULL) {
1158	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_MEM), gShellBcfgHiiHandle, L"bcfg");
1159	ShellStatus = SHELL_OUT_OF_RESOURCES;
1160	return ShellStatus;
1161	}
1162
1163	CopyMem (KeyOptionBuffer, &NewKeyOption, sizeof (EFI_KEY_OPTION));
1164	}
1165
1166	for (LoopCounter = 0; ShellStatus == SHELL_SUCCESS && LoopCounter < NewKeyOption.KeyData.Options.InputKeyCount; LoopCounter++) {
1167	//
1168	// ScanCode
1169	//
1170	Status = ShellConvertStringToUint64 (Walker, &Intermediate, FALSE, TRUE);
1171	if (EFI_ERROR (Status) \|\| (((UINT16)Intermediate) != Intermediate) \|\| (StrStr (Walker, L" ") == NULL)) {
1172	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker);
1173	ShellStatus = SHELL_INVALID_PARAMETER;
1174	}
1175
1176	((EFI_INPUT_KEY )(((UINT8 )KeyOptionBuffer) + sizeof (EFI_KEY_OPTION)))[LoopCounter].ScanCode = (UINT16)Intermediate;
1177	Temp = StrStr (Walker, L" ");
1178	if (Temp != NULL) {
1179	Walker = Temp;
1180	}
1181
1182	while (Walker[0] == L' ') {
1183	Walker++;
1184	}
1185
1186	//
1187	// UnicodeChar
1188	//
1189	Status = ShellConvertStringToUint64 (Walker, &Intermediate, FALSE, TRUE);
1190	if (EFI_ERROR (Status) \|\| (((UINT16)Intermediate) != Intermediate)) {
1191	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", Walker);
1192	ShellStatus = SHELL_INVALID_PARAMETER;
1193	}
1194
1195	((EFI_INPUT_KEY )(((UINT8 )KeyOptionBuffer) + sizeof (EFI_KEY_OPTION)))[LoopCounter].UnicodeChar = (UINT16)Intermediate;
1196	Temp = StrStr (Walker, L" ");
1197	if (Temp != NULL) {
1198	Walker = Temp;
1199	}
1200
1201	while (Walker[0] == L' ') {
1202	Walker++;
1203	}
1204	}
1205
1206	if (ShellStatus == SHELL_SUCCESS) {
1207	//
1208	// Now do the BootOption / BootOptionCrc
1209	//
1210	ASSERT (OptionIndex <= OrderCount);
1211	KeyOptionBuffer->BootOption = CurrentOrder[OptionIndex];
1212	Status = GetBootOptionCrc (&(KeyOptionBuffer->BootOptionCrc), KeyOptionBuffer->BootOption);
1213	if (EFI_ERROR (Status)) {
1214	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"Option Index");
1215	ShellStatus = SHELL_INVALID_PARAMETER;
1216	}
1217	}
1218
1219	if (ShellStatus == SHELL_SUCCESS) {
1220	for (Temp2 = NULL, KeyIndex = 0; KeyIndex <= 0xFFFF; KeyIndex++) {
1221	UnicodeSPrint (VariableName, sizeof (VariableName), L"Key%04x", KeyIndex);
1222	Status = GetEfiGlobalVariable2 (VariableName, &VariableData, NULL);
1223	if (Status == EFI_NOT_FOUND) {
1224	break;
1225	}
1226
1227	if (!EFI_ERROR (Status)) {
1228	SHELL_FREE_NON_NULL (VariableData);
1229	}
1230	}
1231
1232	if (KeyIndex <= 0xFFFF) {
1233	Status = gRT->SetVariable (
1234	VariableName,
1235	(EFI_GUID *)&gEfiGlobalVariableGuid,
1236	EFI_VARIABLE_NON_VOLATILE\|EFI_VARIABLE_BOOTSERVICE_ACCESS\|EFI_VARIABLE_RUNTIME_ACCESS,
1237	sizeof (EFI_KEY_OPTION) + (sizeof (EFI_INPUT_KEY) * NewKeyOption.KeyData.Options.InputKeyCount),
1238	KeyOptionBuffer
1239	);
1240	if (EFI_ERROR (Status)) {
1241	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName);
1242	ShellStatus = SHELL_INVALID_PARAMETER;
1243	}
1244	} else {
1245	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_VAR_NO_NUM), gShellBcfgHiiHandle, L"bcfg");
1246	ShellStatus = SHELL_INVALID_PARAMETER;
1247	}
1248
1249	ASSERT (FileName == NULL && Data == NULL);
1250	}
1251	}
1252	}
1253
1254	//
1255	// Shouldn't be possible to have have both. Neither is ok though.
1256	//
1257	ASSERT (FileName == NULL \|\| Data == NULL);
1258
1259	if ((ShellStatus == SHELL_SUCCESS) && ((FileName != NULL) \|\| (Data != NULL))) {
1260	if (FileName != NULL) {
1261	//
1262	// Open the file and populate the data buffer.
1263	//
1264	Status = ShellOpenFileByName (
1265	FileName,
1266	&FileHandle,
1267	EFI_FILE_MODE_READ,
1268	0
1269	);
1270	if (!EFI_ERROR (Status)) {
1271	Status = ShellGetFileSize (FileHandle, &Intermediate);
1272	}
1273
1274	Data = AllocateZeroPool ((UINTN)Intermediate);
1275	if (Data == NULL) {
1276	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_MEM), gShellBcfgHiiHandle, L"bcfg");
1277	ShellStatus = SHELL_OUT_OF_RESOURCES;
1278	}
1279
1280	if (!EFI_ERROR (Status)) {
1281	Status = ShellReadFile (FileHandle, (UINTN *)&Intermediate, Data);
1282	}
1283	} else {
1284	Intermediate = StrSize (Data);
1285	}
1286
1287	if (!EFI_ERROR (Status) && (ShellStatus == SHELL_SUCCESS) && (Data != NULL)) {
1288	Status = UpdateOptionalData (CurrentOrder[OptionIndex], (UINTN)Intermediate, (UINT8 *)Data, Target);
1289	if (EFI_ERROR (Status)) {
1290	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName);
1291	ShellStatus = SHELL_INVALID_PARAMETER;
1292	}
1293	}
1294
1295	if (EFI_ERROR (Status) && (ShellStatus == SHELL_SUCCESS)) {
1296	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_SET_VAR_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName);
1297	ShellStatus = SHELL_INVALID_PARAMETER;
1298	}
1299	}
1300
1301	SHELL_FREE_NON_NULL (Data);
1302	SHELL_FREE_NON_NULL (KeyOptionBuffer);
1303	SHELL_FREE_NON_NULL (FileName);
1304	return ShellStatus;
1305	}
1306
1307	/**
1308	Function to dump the Bcfg information.
1309
1310	@param[in] Op The operation.
1311	@param[in] OrderCount How many to dump.
1312	@param[in] CurrentOrder The pointer to the current order of items.
1313	@param[in] VerboseOutput TRUE for extra output. FALSE otherwise.
1314
1315	@retval SHELL_SUCCESS The dump was successful.
1316	@retval SHELL_INVALID_PARAMETER A parameter was invalid.
1317	**/
1318	SHELL_STATUS
1319	BcfgDisplayDump (
1320	IN CONST CHAR16 *Op,
1321	IN CONST UINTN OrderCount,
1322	IN CONST UINT16 *CurrentOrder,
1323	IN CONST BOOLEAN VerboseOutput
1324	)
1325	{
1326	EFI_STATUS Status;
1327	UINT8 *Buffer;
1328	UINTN BufferSize;
1329	CHAR16 VariableName[12];
1330	UINTN LoopVar;
1331	CHAR16 *DevPathString;
1332	VOID *FilePathList;
1333	UINTN Errors;
1334	EFI_LOAD_OPTION *LoadOption;
1335	CHAR16 *Description;
1336	UINTN DescriptionSize;
1337	UINTN OptionalDataOffset;
1338
1339	if (OrderCount == 0) {
1340	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NONE), gShellBcfgHiiHandle, L"bcfg");
1341	return (SHELL_SUCCESS);
1342	}
1343
1344	Errors = 0;
1345
1346	for (LoopVar = 0; LoopVar < OrderCount; LoopVar++) {
1347	Buffer = NULL;
1348	BufferSize = 0;
1349	DevPathString = NULL;
1350
1351	UnicodeSPrint (VariableName, sizeof (VariableName), L"%s%04x", Op, CurrentOrder[LoopVar]);
1352
1353	Status = gRT->GetVariable (
1354	VariableName,
1355	(EFI_GUID *)&gEfiGlobalVariableGuid,
1356	NULL,
1357	&BufferSize,
1358	Buffer
1359	);
1360	if (Status == EFI_BUFFER_TOO_SMALL) {
1361	Buffer = AllocateZeroPool (BufferSize);
1362	Status = gRT->GetVariable (
1363	VariableName,
1364	(EFI_GUID *)&gEfiGlobalVariableGuid,
1365	NULL,
1366	&BufferSize,
1367	Buffer
1368	);
1369	}
1370
1371	if (EFI_ERROR (Status) \|\| (Buffer == NULL)) {
1372	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_READ_FAIL), gShellBcfgHiiHandle, L"bcfg", VariableName);
1373	++Errors;
1374	goto Cleanup;
1375	}
1376
1377	//
1378	// We expect the Attributes, FilePathListLength, and L'\0'-terminated
1379	// Description fields to be present.
1380	//
1381	if (BufferSize < sizeof *LoadOption + sizeof (CHAR16)) {
1382	ShellPrintHiiEx (
1383	-1,
1384	-1,
1385	NULL,
1386	STRING_TOKEN (STR_BCFG_VAR_CORRUPT),
1387	gShellBcfgHiiHandle,
1388	L"bcfg",
1389	VariableName
1390	);
1391	++Errors;
1392	goto Cleanup;
1393	}
1394
1395	LoadOption = (EFI_LOAD_OPTION *)Buffer;
1396	Description = (CHAR16 *)(Buffer + sizeof (EFI_LOAD_OPTION));
1397	DescriptionSize = StrSize (Description);
1398
1399	if (LoadOption->FilePathListLength != 0) {
1400	FilePathList = (UINT8 *)Description + DescriptionSize;
1401	DevPathString = ConvertDevicePathToText (FilePathList, TRUE, FALSE);
1402	}
1403
1404	OptionalDataOffset = sizeof *LoadOption + DescriptionSize +
1405	LoadOption->FilePathListLength;
1406
1407	ShellPrintHiiEx (
1408	-1,
1409	-1,
1410	NULL,
1411	STRING_TOKEN (STR_BCFG_LOAD_OPTIONS),
1412	gShellBcfgHiiHandle,
1413	LoopVar,
1414	VariableName,
1415	Description,
1416	DevPathString,
1417	OptionalDataOffset >= BufferSize ? L'N' : L'Y'
1418	);
1419	if (VerboseOutput && (OptionalDataOffset < BufferSize)) {
1420	DumpHex (
1421	2, // Indent
1422	0, // Offset (displayed)
1423	BufferSize - OptionalDataOffset, // DataSize
1424	Buffer + OptionalDataOffset // UserData
1425	);
1426	}
1427
1428	Cleanup:
1429	if (Buffer != NULL) {
1430	FreePool (Buffer);
1431	}
1432
1433	if (DevPathString != NULL) {
1434	FreePool (DevPathString);
1435	}
1436	}
1437
1438	return (Errors > 0) ? SHELL_INVALID_PARAMETER : SHELL_SUCCESS;
1439	}
1440
1441	/**
1442	Function to initialize the BCFG operation structure.
1443
1444	@param[in] Struct The stuct to initialize.
1445	**/
1446	VOID
1447	InitBcfgStruct (
1448	IN BGFG_OPERATION *Struct
1449	)
1450	{
1451	ASSERT (Struct != NULL);
1452	Struct->Target = BcfgTargetMax;
1453	Struct->Type = BcfgTypeMax;
1454	Struct->Number1 = 0;
1455	Struct->Number2 = 0;
1456	Struct->HandleIndex = 0;
1457	Struct->FileName = NULL;
1458	Struct->Description = NULL;
1459	Struct->Order = NULL;
1460	Struct->OptData = NULL;
1461	}
1462
1463	STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
1464	{ L"-v", TypeFlag },
1465	{ L"-opt", TypeMaxValue },
1466	{ NULL, TypeMax }
1467	};
1468
1469	/**
1470	Function for 'bcfg' command.
1471
1472	@param[in] ImageHandle Handle to the Image (NULL if Internal).
1473	@param[in] SystemTable Pointer to the System Table (NULL if Internal).
1474	**/
1475	SHELL_STATUS
1476	EFIAPI
1477	ShellCommandRunBcfg (
1478	IN EFI_HANDLE ImageHandle,
1479	IN EFI_SYSTEM_TABLE *SystemTable
1480	)
1481	{
1482	EFI_STATUS Status;
1483	LIST_ENTRY *Package;
1484	CHAR16 *ProblemParam;
1485	SHELL_STATUS ShellStatus;
1486	UINTN ParamNumber;
1487	CONST CHAR16 *CurrentParam;
1488	BGFG_OPERATION CurrentOperation;
1489	UINTN Length;
1490	UINT64 Intermediate;
1491	UINT16 Count;
1492
1493	Length = 0;
1494	ProblemParam = NULL;
1495	Package = NULL;
1496	ShellStatus = SHELL_SUCCESS;
1497
1498	InitBcfgStruct (&CurrentOperation);
1499
1500	//
1501	// initialize the shell lib (we must be in non-auto-init...)
1502	//
1503	Status = ShellInitialize ();
1504	ASSERT_EFI_ERROR (Status);
1505
1506	Status = CommandInit ();
1507	ASSERT_EFI_ERROR (Status);
1508
1509	//
1510	// parse the command line
1511	//
1512	Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
1513	if (EFI_ERROR (Status)) {
1514	if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
1515	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellBcfgHiiHandle, L"bcfg", ProblemParam);
1516	FreePool (ProblemParam);
1517	ShellStatus = SHELL_INVALID_PARAMETER;
1518	} else {
1519	ASSERT (FALSE);
1520	}
1521	} else {
1522	//
1523	// Read in if we are doing -OPT
1524	//
1525	if (ShellCommandLineGetFlag (Package, L"-opt")) {
1526	CurrentOperation.OptData = ShellCommandLineGetValue (Package, L"-opt");
1527	if (CurrentOperation.OptData == NULL) {
1528	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellBcfgHiiHandle, L"bcfg", L"-opt");
1529	ShellStatus = SHELL_INVALID_PARAMETER;
1530	}
1531
1532	CurrentOperation.Type = BcfgTypeOpt;
1533	}
1534
1535	//
1536	// small block to read the target of the operation
1537	//
1538	if (((ShellCommandLineGetCount (Package) < 3) && (CurrentOperation.Type != BcfgTypeOpt)) \|\|
1539	((ShellCommandLineGetCount (Package) < 2) && (CurrentOperation.Type == BcfgTypeOpt))
1540	)
1541	{
1542	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1543	ShellStatus = SHELL_INVALID_PARAMETER;
1544	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)ShellCommandLineGetRawValue (Package, 1), L"driver") == 0) {
1545	CurrentOperation.Target = BcfgTargetDriverOrder;
1546	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)ShellCommandLineGetRawValue (Package, 1), L"boot") == 0) {
1547	CurrentOperation.Target = BcfgTargetBootOrder;
1548	} else {
1549	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_DRIVER_BOOT), gShellBcfgHiiHandle, L"bcfg");
1550	ShellStatus = SHELL_INVALID_PARAMETER;
1551	}
1552
1553	//
1554	// Read in the boot or driver order environment variable (not needed for opt)
1555	//
1556	if ((ShellStatus == SHELL_SUCCESS) && (CurrentOperation.Target < BcfgTargetMax)) {
1557	Length = 0;
1558	Status = gRT->GetVariable (
1559	CurrentOperation.Target == BcfgTargetBootOrder ? (CHAR16 )L"BootOrder" : (CHAR16 )L"DriverOrder",
1560	(EFI_GUID *)&gEfiGlobalVariableGuid,
1561	NULL,
1562	&Length,
1563	CurrentOperation.Order
1564	);
1565	if (Status == EFI_BUFFER_TOO_SMALL) {
1566	CurrentOperation.Order = AllocateZeroPool (Length+(4*sizeof (CurrentOperation.Order[0])));
1567	if (CurrentOperation.Order == NULL) {
1568	ShellStatus = SHELL_OUT_OF_RESOURCES;
1569	} else {
1570	Status = gRT->GetVariable (
1571	CurrentOperation.Target == BcfgTargetBootOrder ? (CHAR16 )L"BootOrder" : (CHAR16 )L"DriverOrder",
1572	(EFI_GUID *)&gEfiGlobalVariableGuid,
1573	NULL,
1574	&Length,
1575	CurrentOperation.Order
1576	);
1577	}
1578	}
1579	}
1580
1581	Count = (UINT16)(Length / sizeof (CurrentOperation.Order[0]));
1582
1583	//
1584	// large block to read the type of operation and verify parameter types for the info.
1585	//
1586	if ((ShellStatus == SHELL_SUCCESS) && (CurrentOperation.Target < BcfgTargetMax)) {
1587	for (ParamNumber = 2; ParamNumber < ShellCommandLineGetCount (Package) && ShellStatus == SHELL_SUCCESS; ParamNumber++) {
1588	CurrentParam = ShellCommandLineGetRawValue (Package, ParamNumber);
1589	if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"dump") == 0) {
1590	CurrentOperation.Type = BcfgTypeDump;
1591	if (ShellCommandLineGetCount (Package) > 3) {
1592	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellBcfgHiiHandle, L"bcfg");
1593	ShellStatus = SHELL_INVALID_PARAMETER;
1594	}
1595	} else if (ShellCommandLineGetFlag (Package, L"-v")) {
1596	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", L"-v (without dump)");
1597	ShellStatus = SHELL_INVALID_PARAMETER;
1598	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"add") == 0) {
1599	if ((ParamNumber + 3) >= ShellCommandLineGetCount (Package)) {
1600	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1601	ShellStatus = SHELL_INVALID_PARAMETER;
1602	}
1603
1604	CurrentOperation.Type = BcfgTypeAdd;
1605	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1606	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1607	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1608	ShellStatus = SHELL_INVALID_PARAMETER;
1609	} else {
1610	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1611	CurrentOperation.Number1 = (UINT16)Intermediate;
1612	ASSERT (CurrentOperation.FileName == NULL);
1613	CurrentOperation.FileName = StrnCatGrow (&CurrentOperation.FileName, NULL, ShellCommandLineGetRawValue (Package, ++ParamNumber), 0);
1614	ASSERT (CurrentOperation.Description == NULL);
1615	CurrentOperation.Description = StrnCatGrow (&CurrentOperation.Description, NULL, ShellCommandLineGetRawValue (Package, ++ParamNumber), 0);
1616	}
1617	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"addp") == 0) {
1618	if ((ParamNumber + 3) >= ShellCommandLineGetCount (Package)) {
1619	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1620	ShellStatus = SHELL_INVALID_PARAMETER;
1621	}
1622
1623	CurrentOperation.Type = BcfgTypeAddp;
1624	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1625	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1626	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1627	ShellStatus = SHELL_INVALID_PARAMETER;
1628	} else {
1629	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1630	CurrentOperation.Number1 = (UINT16)Intermediate;
1631	ASSERT (CurrentOperation.FileName == NULL);
1632	CurrentOperation.FileName = StrnCatGrow (&CurrentOperation.FileName, NULL, ShellCommandLineGetRawValue (Package, ++ParamNumber), 0);
1633	ASSERT (CurrentOperation.Description == NULL);
1634	CurrentOperation.Description = StrnCatGrow (&CurrentOperation.Description, NULL, ShellCommandLineGetRawValue (Package, ++ParamNumber), 0);
1635	}
1636	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"addh") == 0) {
1637	if ((ParamNumber + 3) >= ShellCommandLineGetCount (Package)) {
1638	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1639	ShellStatus = SHELL_INVALID_PARAMETER;
1640	}
1641
1642	CurrentOperation.Type = BcfgTypeAddh;
1643	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1644	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1645	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1646	ShellStatus = SHELL_INVALID_PARAMETER;
1647	} else {
1648	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1649	CurrentOperation.Number1 = (UINT16)Intermediate;
1650	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1651	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1652	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1653	ShellStatus = SHELL_INVALID_PARAMETER;
1654	} else {
1655	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1656	CurrentOperation.HandleIndex = (UINT16)Intermediate;
1657	ASSERT (CurrentOperation.Description == NULL);
1658	CurrentOperation.Description = StrnCatGrow (&CurrentOperation.Description, NULL, ShellCommandLineGetRawValue (Package, ++ParamNumber), 0);
1659	}
1660	}
1661	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"rm") == 0) {
1662	if ((ParamNumber + 1) >= ShellCommandLineGetCount (Package)) {
1663	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1664	ShellStatus = SHELL_INVALID_PARAMETER;
1665	}
1666
1667	CurrentOperation.Type = BcfgTypeRm;
1668	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1669	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1670	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1671	ShellStatus = SHELL_INVALID_PARAMETER;
1672	} else {
1673	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1674	CurrentOperation.Number1 = (UINT16)Intermediate;
1675	if (CurrentOperation.Number1 >= Count) {
1676	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count);
1677	ShellStatus = SHELL_INVALID_PARAMETER;
1678	}
1679	}
1680	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"mv") == 0) {
1681	if ((ParamNumber + 2) >= ShellCommandLineGetCount (Package)) {
1682	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1683	ShellStatus = SHELL_INVALID_PARAMETER;
1684	}
1685
1686	CurrentOperation.Type = BcfgTypeMv;
1687	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1688	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1689	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1690	ShellStatus = SHELL_INVALID_PARAMETER;
1691	} else {
1692	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1693	CurrentOperation.Number1 = (UINT16)Intermediate;
1694	if (CurrentOperation.Number1 >= Count) {
1695	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count);
1696	ShellStatus = SHELL_INVALID_PARAMETER;
1697	} else {
1698	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1699	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1700	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1701	ShellStatus = SHELL_INVALID_PARAMETER;
1702	} else {
1703	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1704	CurrentOperation.Number2 = (UINT16)Intermediate;
1705	}
1706
1707	if ( (CurrentOperation.Number2 == CurrentOperation.Number1)
1708	\|\| (CurrentOperation.Number2 >= Count)
1709	)
1710	{
1711	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count);
1712	ShellStatus = SHELL_INVALID_PARAMETER;
1713	}
1714	}
1715	}
1716	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"mod") == 0) {
1717	if ((ParamNumber + 2) >= ShellCommandLineGetCount (Package)) {
1718	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1719	ShellStatus = SHELL_INVALID_PARAMETER;
1720	} else {
1721	CurrentOperation.Type = BcfgTypeMod;
1722	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1723	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1724	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1725	ShellStatus = SHELL_INVALID_PARAMETER;
1726	} else {
1727	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1728	CurrentOperation.Number1 = (UINT16)Intermediate;
1729	if (CurrentOperation.Number1 >= Count) {
1730	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count);
1731	ShellStatus = SHELL_INVALID_PARAMETER;
1732	} else {
1733	ASSERT (CurrentOperation.Description == NULL);
1734	CurrentOperation.Description = StrnCatGrow (&CurrentOperation.Description, NULL, ShellCommandLineGetRawValue (Package, ++ParamNumber), 0);
1735	}
1736	}
1737	}
1738	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"modf") == 0) {
1739	if ((ParamNumber + 2) >= ShellCommandLineGetCount (Package)) {
1740	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1741	ShellStatus = SHELL_INVALID_PARAMETER;
1742	} else {
1743	CurrentOperation.Type = BcfgTypeModf;
1744	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1745	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1746	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1747	ShellStatus = SHELL_INVALID_PARAMETER;
1748	} else {
1749	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1750	CurrentOperation.Number1 = (UINT16)Intermediate;
1751	if (CurrentOperation.Number1 >= Count) {
1752	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count);
1753	ShellStatus = SHELL_INVALID_PARAMETER;
1754	} else {
1755	ASSERT (CurrentOperation.FileName == NULL);
1756	CurrentOperation.FileName = StrnCatGrow (&CurrentOperation.FileName, NULL, ShellCommandLineGetRawValue (Package, ++ParamNumber), 0);
1757	}
1758	}
1759	}
1760	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"modp") == 0) {
1761	if ((ParamNumber + 2) >= ShellCommandLineGetCount (Package)) {
1762	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1763	ShellStatus = SHELL_INVALID_PARAMETER;
1764	} else {
1765	CurrentOperation.Type = BcfgTypeModp;
1766	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1767	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1768	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1769	ShellStatus = SHELL_INVALID_PARAMETER;
1770	} else {
1771	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1772	CurrentOperation.Number1 = (UINT16)Intermediate;
1773	if (CurrentOperation.Number1 >= Count) {
1774	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count);
1775	ShellStatus = SHELL_INVALID_PARAMETER;
1776	} else {
1777	ASSERT (CurrentOperation.FileName == NULL);
1778	CurrentOperation.FileName = StrnCatGrow (&CurrentOperation.FileName, NULL, ShellCommandLineGetRawValue (Package, ++ParamNumber), 0);
1779	}
1780	}
1781	}
1782	} else if (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)CurrentParam, L"modh") == 0) {
1783	if ((ParamNumber + 2) >= ShellCommandLineGetCount (Package)) {
1784	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellBcfgHiiHandle, L"bcfg");
1785	ShellStatus = SHELL_INVALID_PARAMETER;
1786	} else {
1787	CurrentOperation.Type = BcfgTypeModh;
1788	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1789	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1790	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1791	ShellStatus = SHELL_INVALID_PARAMETER;
1792	} else {
1793	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1794	CurrentOperation.Number1 = (UINT16)Intermediate;
1795	if (CurrentOperation.Number1 >= Count) {
1796	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_BCFG_NUMB_RANGE), gShellBcfgHiiHandle, L"bcfg", Count);
1797	ShellStatus = SHELL_INVALID_PARAMETER;
1798	} else {
1799	CurrentParam = ShellCommandLineGetRawValue (Package, ++ParamNumber);
1800	if ((CurrentParam == NULL) \|\| !ShellIsHexOrDecimalNumber (CurrentParam, TRUE, FALSE)) {
1801	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1802	ShellStatus = SHELL_INVALID_PARAMETER;
1803	} else {
1804	Status = ShellConvertStringToUint64 (CurrentParam, &Intermediate, TRUE, FALSE);
1805	CurrentOperation.HandleIndex = (UINT16)Intermediate;
1806	}
1807	}
1808	}
1809	}
1810	} else {
1811	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellBcfgHiiHandle, L"bcfg", CurrentParam);
1812	ShellStatus = SHELL_INVALID_PARAMETER;
1813	}
1814	}
1815	}
1816
1817	if ((ShellStatus == SHELL_SUCCESS) && (CurrentOperation.Target < BcfgTargetMax) && (CurrentOperation.Type < BcfgTypeMax)) {
1818	//
1819	// we have all the info. Do the work
1820	//
1821	switch (CurrentOperation.Type) {
1822	case BcfgTypeDump:
1823	ShellStatus = BcfgDisplayDump (
1824	CurrentOperation.Target == BcfgTargetBootOrder ? L"Boot" : L"Driver",
1825	Count,
1826	CurrentOperation.Order,
1827	ShellCommandLineGetFlag (Package, L"-v")
1828	);
1829	break;
1830	case BcfgTypeMv:
1831	ShellStatus = BcfgMove (
1832	CurrentOperation.Target,
1833	CurrentOperation.Order,
1834	Count,
1835	CurrentOperation.Number1,
1836	CurrentOperation.Number2
1837	);
1838	break;
1839	case BcfgTypeRm:
1840	ShellStatus = BcfgRemove (
1841	CurrentOperation.Target,
1842	CurrentOperation.Order,
1843	Count,
1844	CurrentOperation.Number1
1845	);
1846	break;
1847	case BcfgTypeAdd:
1848	case BcfgTypeAddp:
1849	case BcfgTypeAddh:
1850	ShellStatus = BcfgAdd (
1851	CurrentOperation.Number1,
1852	CurrentOperation.FileName,
1853	CurrentOperation.Description == NULL ? L"" : CurrentOperation.Description,
1854	CurrentOperation.Order,
1855	Count,
1856	CurrentOperation.Target,
1857	(BOOLEAN)(CurrentOperation.Type == BcfgTypeAddh),
1858	(BOOLEAN)(CurrentOperation.Type == BcfgTypeAddp),
1859	CurrentOperation.HandleIndex
1860	);
1861	break;
1862	case BcfgTypeMod:
1863	case BcfgTypeModf:
1864	case BcfgTypeModp:
1865	case BcfgTypeModh:
1866	ShellStatus = BcfgMod (&CurrentOperation, Count);
1867	break;
1868	case BcfgTypeOpt:
1869	ShellStatus = BcfgAddOpt (
1870	CurrentOperation.OptData,
1871	CurrentOperation.Order,
1872	Count,
1873	CurrentOperation.Target
1874	);
1875	break;
1876	default:
1877	ASSERT (FALSE);
1878	}
1879	}
1880	}
1881
1882	if (Package != NULL) {
1883	ShellCommandLineFreeVarList (Package);
1884	}
1885
1886	if (CurrentOperation.FileName != NULL) {
1887	FreePool (CurrentOperation.FileName);
1888	}
1889
1890	if (CurrentOperation.Description != NULL) {
1891	FreePool (CurrentOperation.Description);
1892	}
1893
1894	if (CurrentOperation.Order != NULL) {
1895	FreePool (CurrentOperation.Order);
1896	}
1897
1898	return (ShellStatus);
1899	}
1900
1901	/**
1902	Function to get the filename with help context if HII will not be used.
1903
1904	@return The filename with help text in it.
1905	**/
1906	CONST CHAR16 *
1907	EFIAPI
1908	ShellCommandGetManFileNameBcfg (
1909	VOID
1910	)
1911	{
1912	return (mFileName);
1913	}
1914
1915	/**
1916	"Constructor" for the library.
1917
1918	This will register the handler for the bcfg command.
1919
1920	@param[in] ImageHandle the image handle of the process
1921	@param[in] SystemTable the EFI System Table pointer
1922	@param[in] Name the profile name to use
1923
1924	@retval EFI_SUCCESS the shell command handlers were installed successfully
1925	@retval EFI_UNSUPPORTED the shell level required was not found.
1926	**/
1927	EFI_STATUS
1928	EFIAPI
1929	BcfgLibraryRegisterBcfgCommand (
1930	IN EFI_HANDLE ImageHandle,
1931	IN EFI_SYSTEM_TABLE *SystemTable,
1932	IN CONST CHAR16 *Name
1933	)
1934	{
1935	if (gShellBcfgHiiHandle != NULL) {
1936	return (EFI_SUCCESS);
1937	}
1938
1939	gShellBcfgHiiHandle = HiiAddPackages (&gShellBcfgHiiGuid, gImageHandle, UefiShellBcfgCommandLibStrings, NULL);
1940	if (gShellBcfgHiiHandle == NULL) {
1941	return (EFI_DEVICE_ERROR);
1942	}
1943
1944	//
1945	// install our shell command handler
1946	//
1947	ShellCommandRegisterCommandName (L"bcfg", ShellCommandRunBcfg, ShellCommandGetManFileNameBcfg, 0, Name, FALSE, gShellBcfgHiiHandle, STRING_TOKEN (STR_GET_HELP_BCFG));
1948
1949	return (EFI_SUCCESS);
1950	}
1951
1952	/**
1953	Destructor for the library. free any resources.
1954
1955	@param ImageHandle The image handle of the process.
1956	@param SystemTable The EFI System Table pointer.
1957	**/
1958	EFI_STATUS
1959	EFIAPI
1960	BcfgLibraryUnregisterBcfgCommand (
1961	IN EFI_HANDLE ImageHandle,
1962	IN EFI_SYSTEM_TABLE *SystemTable
1963	)
1964	{
1965	if (gShellBcfgHiiHandle != NULL) {
1966	HiiRemovePackages (gShellBcfgHiiHandle);
1967	}
1968
1969	gShellBcfgHiiHandle = NULL;
1970	return (EFI_SUCCESS);
1971	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellBcfgCommandLib/UefiShellBcfgCommandLib.c

以其他格式下載: