HttpBootConfig.c@ 77662

Last change on this file since 77662 was 77662, checked in by vboxsync, 6 years ago
EFI: First step in UDK2018 merge. Does not build yet.
Property svn:eol-style set to `native`
File size: 23.4 KB

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

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

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

Download in other formats: