HttpBootConfig.c@ 80721

Last change on this file since 80721 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
Property svn:eol-style set to `native`
File size: 23.1 KB

Line
1	/** @file
2	Helper functions for configuring or getting the parameters relating to HTTP Boot.
3
4	Copyright (c) 2016 - 2018, Intel Corporation. All rights reserved.<BR>
5	SPDX-License-Identifier: BSD-2-Clause-Patent
6
7	**/
8
9	#include "HttpBootDxe.h"
10	#include <Library/UefiBootManagerLib.h>
11
12	CHAR16 mHttpBootConfigStorageName[] = L"HTTP_BOOT_CONFIG_IFR_NVDATA";
13
14	/**
15	Add new boot option for HTTP boot.
16
17	@param[in] Private Pointer to the driver private data.
18	@param[in] UsingIpv6 Set to TRUE if creating boot option for IPv6.
19	@param[in] Description The description text of the boot option.
20	@param[in] Uri The URI string of the boot file.
21
22	@retval EFI_SUCCESS The boot option is created successfully.
23	@retval Others Failed to create new boot option.
24
25	**/
26	EFI_STATUS
27	HttpBootAddBootOption (
28	IN HTTP_BOOT_PRIVATE_DATA *Private,
29	IN BOOLEAN UsingIpv6,
30	IN CHAR16 *Description,
31	IN CHAR16 *Uri
32	)
33	{
34	EFI_DEV_PATH *Node;
35	EFI_DEVICE_PATH_PROTOCOL *TmpDevicePath;
36	EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
37	UINTN Length;
38	CHAR8 AsciiUri[URI_STR_MAX_SIZE];
39	EFI_STATUS Status;
40	UINTN Index;
41	EFI_BOOT_MANAGER_LOAD_OPTION NewOption;
42
43	NewDevicePath = NULL;
44	Node = NULL;
45	TmpDevicePath = NULL;
46
47	if (StrLen (Description) == 0) {
48	return EFI_INVALID_PARAMETER;
49	}
50
51	//
52	// Convert the scheme to all lower case.
53	//
54	for (Index = 0; Index < StrLen (Uri); Index++) {
55	if (Uri[Index] == L':') {
56	break;
57	}
58	if (Uri[Index] >= L'A' && Uri[Index] <= L'Z') {
59	Uri[Index] -= (CHAR16)(L'A' - L'a');
60	}
61	}
62
63	//
64	// Only accept empty URI, or http and https URI.
65	//
66	if ((StrLen (Uri) != 0) && (StrnCmp (Uri, L"http://", 7) != 0) && (StrnCmp (Uri, L"https://", 8) != 0)) {
67	return EFI_INVALID_PARAMETER;
68	}
69
70	//
71	// Create a new device path by appending the IP node and URI node to
72	// the driver's parent device path
73	//
74	if (!UsingIpv6) {
75	Node = AllocateZeroPool (sizeof (IPv4_DEVICE_PATH));
76	if (Node == NULL) {
77	Status = EFI_OUT_OF_RESOURCES;
78	goto ON_EXIT;
79	}
80	Node->Ipv4.Header.Type = MESSAGING_DEVICE_PATH;
81	Node->Ipv4.Header.SubType = MSG_IPv4_DP;
82	SetDevicePathNodeLength (Node, sizeof (IPv4_DEVICE_PATH));
83	} else {
84	Node = AllocateZeroPool (sizeof (IPv6_DEVICE_PATH));
85	if (Node == NULL) {
86	Status = EFI_OUT_OF_RESOURCES;
87	goto ON_EXIT;
88	}
89	Node->Ipv6.Header.Type = MESSAGING_DEVICE_PATH;
90	Node->Ipv6.Header.SubType = MSG_IPv6_DP;
91	SetDevicePathNodeLength (Node, sizeof (IPv6_DEVICE_PATH));
92	}
93	TmpDevicePath = AppendDevicePathNode (Private->ParentDevicePath, (EFI_DEVICE_PATH_PROTOCOL*) Node);
94	FreePool (Node);
95	if (TmpDevicePath == NULL) {
96	return EFI_OUT_OF_RESOURCES;
97	}
98	//
99	// Update the URI node with the input boot file URI.
100	//
101	UnicodeStrToAsciiStrS (Uri, AsciiUri, sizeof (AsciiUri));
102	Length = sizeof (EFI_DEVICE_PATH_PROTOCOL) + AsciiStrSize (AsciiUri);
103	Node = AllocatePool (Length);
104	if (Node == NULL) {
105	Status = EFI_OUT_OF_RESOURCES;
106	FreePool (TmpDevicePath);
107	goto ON_EXIT;
108	}
109	Node->DevPath.Type = MESSAGING_DEVICE_PATH;
110	Node->DevPath.SubType = MSG_URI_DP;
111	SetDevicePathNodeLength (Node, Length);
112	CopyMem ((UINT8*) Node + sizeof (EFI_DEVICE_PATH_PROTOCOL), AsciiUri, AsciiStrSize (AsciiUri));
113	NewDevicePath = AppendDevicePathNode (TmpDevicePath, (EFI_DEVICE_PATH_PROTOCOL*) Node);
114	FreePool (Node);
115	FreePool (TmpDevicePath);
116	if (NewDevicePath == NULL) {
117	Status = EFI_OUT_OF_RESOURCES;
118	goto ON_EXIT;
119	}
120
121	//
122	// Add a new load option.
123	//
124	Status = EfiBootManagerInitializeLoadOption (
125	&NewOption,
126	LoadOptionNumberUnassigned,
127	LoadOptionTypeBoot,
128	LOAD_OPTION_ACTIVE,
129	Description,
130	NewDevicePath,
131	NULL,
132	0
133	);
134	if (EFI_ERROR (Status)) {
135	goto ON_EXIT;
136	}
137
138	Status = EfiBootManagerAddLoadOptionVariable (&NewOption, (UINTN) -1);
139	EfiBootManagerFreeLoadOption (&NewOption);
140
141	ON_EXIT:
142
143	if (NewDevicePath != NULL) {
144	FreePool (NewDevicePath);
145	}
146
147	return Status;
148	}
149
150	/**
151
152	This function allows the caller to request the current
153	configuration for one or more named elements. The resulting
154	string is in <ConfigAltResp> format. Also, any and all alternative
155	configuration strings shall be appended to the end of the
156	current configuration string. If they are, they must appear
157	after the current configuration. They must contain the same
158	routing (GUID, NAME, PATH) as the current configuration string.
159	They must have an additional description indicating the type of
160	alternative configuration the string represents,
161	"ALTCFG=<StringToken>". That <StringToken> (when
162	converted from Hex UNICODE to binary) is a reference to a
163	string in the associated string pack.
164
165	@param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
166
167	@param[in] Request A null-terminated Unicode string in
168	<ConfigRequest> format. Note that this
169	includes the routing information as well as
170	the configurable name / value pairs. It is
171	invalid for this string to be in
172	<MultiConfigRequest> format.
173
174	@param[out] Progress On return, points to a character in the
175	Request string. Points to the string's null
176	terminator if request was successful. Points
177	to the most recent "&" before the first
178	failing name / value pair (or the beginning
179	of the string if the failure is in the first
180	name / value pair) if the request was not successful.
181
182	@param[out] Results A null-terminated Unicode string in
183	<ConfigAltResp> format which has all values
184	filled in for the names in the Request string.
185	String to be allocated by the called function.
186
187	@retval EFI_SUCCESS The Results string is filled with the
188	values corresponding to all requested
189	names.
190
191	@retval EFI_OUT_OF_RESOURCES Not enough memory to store the
192	parts of the results that must be
193	stored awaiting possible future
194	protocols.
195
196	@retval EFI_INVALID_PARAMETER For example, passing in a NULL
197	for the Request parameter
198	would result in this type of
199	error. In this case, the
200	Progress parameter would be
201	set to NULL.
202
203	@retval EFI_NOT_FOUND Routing data doesn't match any
204	known driver. Progress set to the
205	first character in the routing header.
206	Note: There is no requirement that the
207	driver validate the routing data. It
208	must skip the <ConfigHdr> in order to
209	process the names.
210
211	@retval EFI_INVALID_PARAMETER Illegal syntax. Progress set
212	to most recent "&" before the
213	error or the beginning of the
214	string.
215
216	@retval EFI_INVALID_PARAMETER Unknown name. Progress points
217	to the & before the name in
218	question.
219
220	**/
221	EFI_STATUS
222	EFIAPI
223	HttpBootFormExtractConfig (
224	IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
225	IN CONST EFI_STRING Request,
226	OUT EFI_STRING *Progress,
227	OUT EFI_STRING *Results
228	)
229	{
230	EFI_STATUS Status;
231	UINTN BufferSize;
232	HTTP_BOOT_FORM_CALLBACK_INFO *CallbackInfo;
233	EFI_STRING ConfigRequestHdr;
234	EFI_STRING ConfigRequest;
235	BOOLEAN AllocatedRequest;
236	UINTN Size;
237
238	if (Progress == NULL \|\| Results == NULL) {
239	return EFI_INVALID_PARAMETER;
240	}
241
242	*Progress = Request;
243	if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gHttpBootConfigGuid, mHttpBootConfigStorageName)) {
244	return EFI_NOT_FOUND;
245	}
246
247	ConfigRequestHdr = NULL;
248	ConfigRequest = NULL;
249	AllocatedRequest = FALSE;
250	Size = 0;
251
252	CallbackInfo = HTTP_BOOT_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS (This);
253	//
254	// Convert buffer data to <ConfigResp> by helper function BlockToConfig()
255	//
256	BufferSize = sizeof (HTTP_BOOT_CONFIG_IFR_NVDATA);
257	ZeroMem (&CallbackInfo->HttpBootNvData, BufferSize);
258	StrCpyS (CallbackInfo->HttpBootNvData.Description, DESCRIPTION_STR_MAX_SIZE / sizeof (CHAR16), HTTP_BOOT_DEFAULT_DESCRIPTION_STR);
259
260	ConfigRequest = Request;
261	if ((Request == NULL) \|\| (StrStr (Request, L"OFFSET") == NULL)) {
262	//
263	// Request has no request element, construct full request string.
264	// Allocate and fill a buffer large enough to hold the <ConfigHdr> template
265	// followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator
266	//
267	ConfigRequestHdr = HiiConstructConfigHdr (&gHttpBootConfigGuid, mHttpBootConfigStorageName, CallbackInfo->ChildHandle);
268	Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16);
269	ConfigRequest = AllocateZeroPool (Size);
270	if (ConfigRequest == NULL) {
271	return EFI_OUT_OF_RESOURCES;
272	}
273	AllocatedRequest = TRUE;
274	UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize);
275	FreePool (ConfigRequestHdr);
276	}
277
278	Status = gHiiConfigRouting->BlockToConfig (
279	gHiiConfigRouting,
280	ConfigRequest,
281	(UINT8 *) &CallbackInfo->HttpBootNvData,
282	BufferSize,
283	Results,
284	Progress
285	);
286
287	//
288	// Free the allocated config request string.
289	//
290	if (AllocatedRequest) {
291	FreePool (ConfigRequest);
292	ConfigRequest = NULL;
293	}
294	//
295	// Set Progress string to the original request string.
296	//
297	if (Request == NULL) {
298	*Progress = NULL;
299	} else if (StrStr (Request, L"OFFSET") == NULL) {
300	*Progress = Request + StrLen (Request);
301	}
302
303	return Status;
304	}
305
306	/**
307
308	This function applies changes in a driver's configuration.
309	Input is a Configuration, which has the routing data for this
310	driver followed by name / value configuration pairs. The driver
311	must apply those pairs to its configurable storage. If the
312	driver's configuration is stored in a linear block of data
313	and the driver's name / value pairs are in <BlockConfig>
314	format, it may use the ConfigToBlock helper function (above) to
315	simplify the job.
316
317	@param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
318
319	@param[in] Configuration A null-terminated Unicode string in
320	<ConfigString> format.
321
322	@param[out] Progress A pointer to a string filled in with the
323	offset of the most recent '&' before the
324	first failing name / value pair (or the
325	beginning of the string if the failure
326	is in the first name / value pair) or
327	the terminating NULL if all was
328	successful.
329
330	@retval EFI_SUCCESS The results have been distributed or are
331	awaiting distribution.
332
333	@retval EFI_OUT_OF_RESOURCES Not enough memory to store the
334	parts of the results that must be
335	stored awaiting possible future
336	protocols.
337
338	@retval EFI_INVALID_PARAMETERS Passing in a NULL for the
339	Results parameter would result
340	in this type of error.
341
342	@retval EFI_NOT_FOUND Target for the specified routing data
343	was not found.
344
345	**/
346	EFI_STATUS
347	EFIAPI
348	HttpBootFormRouteConfig (
349	IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
350	IN CONST EFI_STRING Configuration,
351	OUT EFI_STRING *Progress
352	)
353	{
354	EFI_STATUS Status;
355	UINTN BufferSize;
356	HTTP_BOOT_FORM_CALLBACK_INFO *CallbackInfo;
357	HTTP_BOOT_PRIVATE_DATA *Private;
358
359	if (Progress == NULL) {
360	return EFI_INVALID_PARAMETER;
361	}
362	*Progress = Configuration;
363
364	if (Configuration == NULL) {
365	return EFI_INVALID_PARAMETER;
366	}
367
368	//
369	// Check routing data in <ConfigHdr>.
370	// Note: there is no name for Name/Value storage, only GUID will be checked
371	//
372	if (!HiiIsConfigHdrMatch (Configuration, &gHttpBootConfigGuid, mHttpBootConfigStorageName)) {
373	return EFI_NOT_FOUND;
374	}
375
376	CallbackInfo = HTTP_BOOT_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS (This);
377	Private = HTTP_BOOT_PRIVATE_DATA_FROM_CALLBACK_INFO (CallbackInfo);
378
379	BufferSize = sizeof (HTTP_BOOT_CONFIG_IFR_NVDATA);
380	ZeroMem (&CallbackInfo->HttpBootNvData, BufferSize);
381
382	Status = gHiiConfigRouting->ConfigToBlock (
383	gHiiConfigRouting,
384	Configuration,
385	(UINT8 *) &CallbackInfo->HttpBootNvData,
386	&BufferSize,
387	Progress
388	);
389	if (EFI_ERROR (Status)) {
390	return Status;
391	}
392
393	//
394	// Create a new boot option according to the configuration data.
395	//
396	HttpBootAddBootOption (
397	Private,
398	(CallbackInfo->HttpBootNvData.IpVersion == HTTP_BOOT_IP_VERSION_6) ? TRUE : FALSE,
399	CallbackInfo->HttpBootNvData.Description,
400	CallbackInfo->HttpBootNvData.Uri
401	);
402
403	return EFI_SUCCESS;
404	}
405
406	/**
407
408	This function is called to provide results data to the driver.
409	This data consists of a unique key that is used to identify
410	which data is either being passed back or being asked for.
411
412	@param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
413	@param[in] Action Specifies the type of action taken by the browser.
414	@param[in] QuestionId A unique value which is sent to the original
415	exporting driver so that it can identify the type
416	of data to expect. The format of the data tends to
417	vary based on the opcode that generated the callback.
418	@param[in] Type The type of value for the question.
419	@param[in, out] Value A pointer to the data being sent to the original
420	exporting driver.
421	@param[out] ActionRequest On return, points to the action requested by the
422	callback function.
423
424	@retval EFI_SUCCESS The callback successfully handled the action.
425	@retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the
426	variable and its data.
427	@retval EFI_DEVICE_ERROR The variable could not be saved.
428	@retval EFI_UNSUPPORTED The specified Action is not supported by the
429	callback.
430	**/
431	EFI_STATUS
432	EFIAPI
433	HttpBootFormCallback (
434	IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This,
435	IN EFI_BROWSER_ACTION Action,
436	IN EFI_QUESTION_ID QuestionId,
437	IN UINT8 Type,
438	IN OUT EFI_IFR_TYPE_VALUE *Value,
439	OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest
440	)
441	{
442	EFI_INPUT_KEY Key;
443	CHAR16 *Uri;
444	UINTN UriLen;
445	CHAR8 *AsciiUri;
446	HTTP_BOOT_FORM_CALLBACK_INFO *CallbackInfo;
447	EFI_STATUS Status;
448
449	Uri = NULL;
450	UriLen = 0;
451	AsciiUri = NULL;
452	Status = EFI_SUCCESS;
453
454	if (This == NULL \|\| Value == NULL) {
455	return EFI_INVALID_PARAMETER;
456	}
457
458	CallbackInfo = HTTP_BOOT_FORM_CALLBACK_INFO_FROM_CONFIG_ACCESS (This);
459
460	if (Action != EFI_BROWSER_ACTION_CHANGING) {
461	return EFI_UNSUPPORTED;
462	}
463
464	switch (QuestionId) {
465	case KEY_INITIATOR_URI:
466	//
467	// Get user input URI string
468	//
469	Uri = HiiGetString (CallbackInfo->RegisteredHandle, Value->string, NULL);
470	if(Uri == NULL) {
471	return EFI_INVALID_PARAMETER;
472	}
473
474	//
475	// The URI should be either an empty string (for corporate environment) ,or http(s) for home environment.
476	// Pop up a message box for the unsupported URI.
477	//
478	if (StrLen (Uri) != 0) {
479	UriLen = StrLen (Uri) + 1;
480	AsciiUri = AllocateZeroPool (UriLen);
481	if (AsciiUri == NULL) {
482	FreePool (Uri);
483	return EFI_OUT_OF_RESOURCES;
484	}
485
486	UnicodeStrToAsciiStrS (Uri, AsciiUri, UriLen);
487
488	Status = HttpBootCheckUriScheme (AsciiUri);
489
490	if (Status == EFI_INVALID_PARAMETER) {
491
492	DEBUG ((EFI_D_ERROR, "HttpBootFormCallback: %r.\n", Status));
493
494	CreatePopUp (
495	EFI_LIGHTGRAY \| EFI_BACKGROUND_BLUE,
496	&Key,
497	L"ERROR: Unsupported URI!",
498	L"Only supports HTTP and HTTPS",
499	NULL
500	);
501	} else if (Status == EFI_ACCESS_DENIED) {
502
503	DEBUG ((EFI_D_ERROR, "HttpBootFormCallback: %r.\n", Status));
504
505	CreatePopUp (
506	EFI_LIGHTGRAY \| EFI_BACKGROUND_BLUE,
507	&Key,
508	L"ERROR: Unsupported URI!",
509	L"HTTP is disabled",
510	NULL
511	);
512	}
513	}
514
515	if (Uri != NULL) {
516	FreePool (Uri);
517	}
518
519	if (AsciiUri != NULL) {
520	FreePool (AsciiUri);
521	}
522
523	break;
524
525	default:
526	break;
527	}
528
529	return Status;
530	}
531
532	/**
533	Initialize the configuration form.
534
535	@param[in] Private Pointer to the driver private data.
536
537	@retval EFI_SUCCESS The configuration form is initialized.
538	@retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
539
540	**/
541	EFI_STATUS
542	HttpBootConfigFormInit (
543	IN HTTP_BOOT_PRIVATE_DATA *Private
544	)
545	{
546	EFI_STATUS Status;
547	HTTP_BOOT_FORM_CALLBACK_INFO *CallbackInfo;
548	VENDOR_DEVICE_PATH VendorDeviceNode;
549	CHAR16 *MacString;
550	CHAR16 *OldMenuString;
551	CHAR16 MenuString[128];
552
553	CallbackInfo = &Private->CallbackInfo;
554
555	if (CallbackInfo->Initilized) {
556	return EFI_SUCCESS;
557	}
558
559	CallbackInfo->Signature = HTTP_BOOT_FORM_CALLBACK_INFO_SIGNATURE;
560
561	//
562	// Construct device path node for EFI HII Config Access protocol,
563	// which consists of controller physical device path and one hardware
564	// vendor guid node.
565	//
566	ZeroMem (&VendorDeviceNode, sizeof (VENDOR_DEVICE_PATH));
567	VendorDeviceNode.Header.Type = HARDWARE_DEVICE_PATH;
568	VendorDeviceNode.Header.SubType = HW_VENDOR_DP;
569	CopyGuid (&VendorDeviceNode.Guid, &gEfiCallerIdGuid);
570	SetDevicePathNodeLength (&VendorDeviceNode.Header, sizeof (VENDOR_DEVICE_PATH));
571	CallbackInfo->HiiVendorDevicePath = AppendDevicePathNode (
572	Private->ParentDevicePath,
573	(EFI_DEVICE_PATH_PROTOCOL *) &VendorDeviceNode
574	);
575	if (CallbackInfo->HiiVendorDevicePath == NULL) {
576	Status = EFI_OUT_OF_RESOURCES;
577	goto Error;
578	}
579
580	CallbackInfo->ConfigAccess.ExtractConfig = HttpBootFormExtractConfig;
581	CallbackInfo->ConfigAccess.RouteConfig = HttpBootFormRouteConfig;
582	CallbackInfo->ConfigAccess.Callback = HttpBootFormCallback;
583
584	//
585	// Install Device Path Protocol and Config Access protocol to driver handle.
586	//
587	Status = gBS->InstallMultipleProtocolInterfaces (
588	&CallbackInfo->ChildHandle,
589	&gEfiDevicePathProtocolGuid,
590	CallbackInfo->HiiVendorDevicePath,
591	&gEfiHiiConfigAccessProtocolGuid,
592	&CallbackInfo->ConfigAccess,
593	NULL
594	);
595	if (EFI_ERROR (Status)) {
596	goto Error;
597	}
598
599	//
600	// Publish our HII data.
601	//
602	CallbackInfo->RegisteredHandle = HiiAddPackages (
603	&gHttpBootConfigGuid,
604	CallbackInfo->ChildHandle,
605	HttpBootDxeStrings,
606	HttpBootConfigVfrBin,
607	NULL
608	);
609	if (CallbackInfo->RegisteredHandle == NULL) {
610	Status = EFI_OUT_OF_RESOURCES;
611	goto Error;
612	}
613
614	//
615	// Append MAC string in the menu help string
616	//
617	Status = NetLibGetMacString (Private->Controller, NULL, &MacString);
618	if (!EFI_ERROR (Status)) {
619	OldMenuString = HiiGetString (
620	CallbackInfo->RegisteredHandle,
621	STRING_TOKEN (STR_HTTP_BOOT_CONFIG_FORM_HELP),
622	NULL
623	);
624	UnicodeSPrint (MenuString, 128, L"%s (MAC:%s)", OldMenuString, MacString);
625	HiiSetString (
626	CallbackInfo->RegisteredHandle,
627	STRING_TOKEN (STR_HTTP_BOOT_CONFIG_FORM_HELP),
628	MenuString,
629	NULL
630	);
631
632	FreePool (MacString);
633	FreePool (OldMenuString);
634
635	CallbackInfo->Initilized = TRUE;
636	return EFI_SUCCESS;
637	}
638
639	Error:
640
641	HttpBootConfigFormUnload (Private);
642	return Status;
643	}
644
645	/**
646	Unload the configuration form, this includes: delete all the configuration
647	entries, uninstall the form callback protocol, and free the resources used.
648	The form will only be unload completely when both IP4 and IP6 stack are stopped.
649
650	@param[in] Private Pointer to the driver private data.
651
652	@retval EFI_SUCCESS The configuration form is unloaded.
653	@retval Others Failed to unload the form.
654
655	**/
656	EFI_STATUS
657	HttpBootConfigFormUnload (
658	IN HTTP_BOOT_PRIVATE_DATA *Private
659	)
660	{
661	HTTP_BOOT_FORM_CALLBACK_INFO *CallbackInfo;
662
663	if (Private->Ip4Nic != NULL \|\| Private->Ip6Nic != NULL) {
664	//
665	// Only unload the configuration form when both IP4 and IP6 stack are stopped.
666	//
667	return EFI_SUCCESS;
668	}
669
670	CallbackInfo = &Private->CallbackInfo;
671	if (CallbackInfo->ChildHandle != NULL) {
672	//
673	// Uninstall EFI_HII_CONFIG_ACCESS_PROTOCOL
674	//
675	gBS->UninstallMultipleProtocolInterfaces (
676	CallbackInfo->ChildHandle,
677	&gEfiDevicePathProtocolGuid,
678	CallbackInfo->HiiVendorDevicePath,
679	&gEfiHiiConfigAccessProtocolGuid,
680	&CallbackInfo->ConfigAccess,
681	NULL
682	);
683	CallbackInfo->ChildHandle = NULL;
684	}
685
686	if (CallbackInfo->HiiVendorDevicePath != NULL) {
687	FreePool (CallbackInfo->HiiVendorDevicePath);
688	CallbackInfo->HiiVendorDevicePath = NULL;
689	}
690
691	if (CallbackInfo->RegisteredHandle != NULL) {
692	//
693	// Remove HII package list
694	//
695	HiiRemovePackages (CallbackInfo->RegisteredHandle);
696	CallbackInfo->RegisteredHandle = NULL;
697	}
698
699	return EFI_SUCCESS;
700	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/HttpBootDxe/HttpBootConfig.c@ 80721

Download in other formats: