HttpDriver.c@ 77775

Last change on this file since 77775 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: 38.4 KB

Line
1	/** @file
2	The driver binding and service binding protocol for HttpDxe driver.
3
4	Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
5	(C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
6
7	This program and the accompanying materials
8	are licensed and made available under the terms and conditions of the BSD License
9	which accompanies this distribution. The full text of the license may be found at
10	http://opensource.org/licenses/bsd-license.php.
11
12	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15	**/
16
17	#include "HttpDriver.h"
18
19	EFI_HTTP_UTILITIES_PROTOCOL *mHttpUtilities = NULL;
20
21	///
22	/// Driver Binding Protocol instance
23	///
24	EFI_DRIVER_BINDING_PROTOCOL gHttpDxeIp4DriverBinding = {
25	HttpDxeIp4DriverBindingSupported,
26	HttpDxeIp4DriverBindingStart,
27	HttpDxeIp4DriverBindingStop,
28	HTTP_DRIVER_VERSION,
29	NULL,
30	NULL
31	};
32
33	EFI_DRIVER_BINDING_PROTOCOL gHttpDxeIp6DriverBinding = {
34	HttpDxeIp6DriverBindingSupported,
35	HttpDxeIp6DriverBindingStart,
36	HttpDxeIp6DriverBindingStop,
37	HTTP_DRIVER_VERSION,
38	NULL,
39	NULL
40	};
41
42
43	/**
44	Create a HTTP driver service binding private instance.
45
46	@param[in] Controller The controller that has TCP4 service binding
47	installed.
48	@param[out] ServiceData Point to HTTP driver private instance.
49
50	@retval EFI_OUT_OF_RESOURCES Failed to allocate some resources.
51	@retval EFI_SUCCESS A new HTTP driver private instance is created.
52
53	**/
54	EFI_STATUS
55	HttpCreateService (
56	IN EFI_HANDLE Controller,
57	OUT HTTP_SERVICE **ServiceData
58	)
59	{
60	HTTP_SERVICE *HttpService;
61
62	ASSERT (ServiceData != NULL);
63	*ServiceData = NULL;
64
65	HttpService = AllocateZeroPool (sizeof (HTTP_SERVICE));
66	if (HttpService == NULL) {
67	return EFI_OUT_OF_RESOURCES;
68	}
69
70	HttpService->Signature = HTTP_SERVICE_SIGNATURE;
71	HttpService->ServiceBinding.CreateChild = HttpServiceBindingCreateChild;
72	HttpService->ServiceBinding.DestroyChild = HttpServiceBindingDestroyChild;
73	HttpService->ControllerHandle = Controller;
74	HttpService->ChildrenNumber = 0;
75	InitializeListHead (&HttpService->ChildrenList);
76
77	*ServiceData = HttpService;
78	return EFI_SUCCESS;
79	}
80
81	/**
82	Release all the resource used the HTTP service binding instance.
83
84	@param[in] HttpService The HTTP private instance.
85	@param[in] UsingIpv6 Indicate use TCP4 protocol or TCP6 protocol.
86	if TRUE, use Tcp6 protocol.
87	if FALSE, use Tcp4 protocl.
88	**/
89	VOID
90	HttpCleanService (
91	IN HTTP_SERVICE *HttpService,
92	IN BOOLEAN UsingIpv6
93	)
94	{
95
96	if (HttpService == NULL) {
97	return ;
98	}
99	if (!UsingIpv6) {
100	if (HttpService->Tcp4ChildHandle != NULL) {
101	gBS->CloseProtocol (
102	HttpService->Tcp4ChildHandle,
103	&gEfiTcp4ProtocolGuid,
104	HttpService->Ip4DriverBindingHandle,
105	HttpService->ControllerHandle
106	);
107
108	NetLibDestroyServiceChild (
109	HttpService->ControllerHandle,
110	HttpService->Ip4DriverBindingHandle,
111	&gEfiTcp4ServiceBindingProtocolGuid,
112	HttpService->Tcp4ChildHandle
113	);
114
115	HttpService->Tcp4ChildHandle = NULL;
116	}
117	} else {
118	if (HttpService->Tcp6ChildHandle != NULL) {
119	gBS->CloseProtocol (
120	HttpService->Tcp6ChildHandle,
121	&gEfiTcp6ProtocolGuid,
122	HttpService->Ip6DriverBindingHandle,
123	HttpService->ControllerHandle
124	);
125
126	NetLibDestroyServiceChild (
127	HttpService->ControllerHandle,
128	HttpService->Ip6DriverBindingHandle,
129	&gEfiTcp6ServiceBindingProtocolGuid,
130	HttpService->Tcp6ChildHandle
131	);
132
133	HttpService->Tcp6ChildHandle = NULL;
134	}
135	}
136
137	}
138
139	/**
140	The event process routine when the http utilities protocol is installed
141	in the system.
142
143	@param[in] Event Not used.
144	@param[in] Context The pointer to the IP4 config2 instance data or IP6 Config instance data.
145
146	**/
147	VOID
148	EFIAPI
149	HttpUtilitiesInstalledCallback (
150	IN EFI_EVENT Event,
151	IN VOID *Context
152	)
153	{
154	gBS->LocateProtocol (
155	&gEfiHttpUtilitiesProtocolGuid,
156	NULL,
157	(VOID **) &mHttpUtilities
158	);
159
160	//
161	// Close the event if Http utilities protocol is loacted.
162	//
163	if (mHttpUtilities != NULL && Event != NULL) {
164	gBS->CloseEvent (Event);
165	}
166	}
167
168	/**
169	This is the declaration of an EFI image entry point. This entry point is
170	the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
171	both device drivers and bus drivers.
172
173	@param ImageHandle The firmware allocated handle for the UEFI image.
174	@param SystemTable A pointer to the EFI System Table.
175
176	@retval EFI_SUCCESS The operation completed successfully.
177	@retval Others An unexpected error occurred.
178
179	**/
180	EFI_STATUS
181	EFIAPI
182	HttpDxeDriverEntryPoint (
183	IN EFI_HANDLE ImageHandle,
184	IN EFI_SYSTEM_TABLE *SystemTable
185	)
186	{
187	EFI_STATUS Status;
188	VOID *Registration;
189
190	gBS->LocateProtocol (
191	&gEfiHttpUtilitiesProtocolGuid,
192	NULL,
193	(VOID **) &mHttpUtilities
194	);
195
196	if (mHttpUtilities == NULL) {
197	//
198	// No Http utilities protocol, register a notify.
199	//
200	EfiCreateProtocolNotifyEvent (
201	&gEfiHttpUtilitiesProtocolGuid,
202	TPL_CALLBACK,
203	HttpUtilitiesInstalledCallback,
204	NULL,
205	&Registration
206	);
207	}
208
209	//
210	// Install UEFI Driver Model protocol(s).
211	//
212	Status = EfiLibInstallDriverBindingComponentName2 (
213	ImageHandle,
214	SystemTable,
215	&gHttpDxeIp4DriverBinding,
216	ImageHandle,
217	&gHttpDxeComponentName,
218	&gHttpDxeComponentName2
219	);
220	if (EFI_ERROR (Status)) {
221	return Status;
222	}
223
224	Status = EfiLibInstallDriverBindingComponentName2 (
225	ImageHandle,
226	SystemTable,
227	&gHttpDxeIp6DriverBinding,
228	NULL,
229	&gHttpDxeComponentName,
230	&gHttpDxeComponentName2
231	);
232	if (EFI_ERROR (Status)) {
233	gBS->UninstallMultipleProtocolInterfaces (
234	ImageHandle,
235	&gEfiDriverBindingProtocolGuid,
236	&gHttpDxeIp4DriverBinding,
237	&gEfiComponentName2ProtocolGuid,
238	&gHttpDxeComponentName2,
239	&gEfiComponentNameProtocolGuid,
240	&gHttpDxeComponentName,
241	NULL
242	);
243	}
244	return Status;
245	}
246
247	/**
248	Callback function which provided by user to remove one node in NetDestroyLinkList process.
249
250	@param[in] Entry The entry to be removed.
251	@param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
252
253	@retval EFI_INVALID_PARAMETER Any input parameter is NULL.
254	@retval EFI_SUCCESS The entry has been removed successfully.
255	@retval Others Fail to remove the entry.
256
257	**/
258	EFI_STATUS
259	EFIAPI
260	HttpDestroyChildEntryInHandleBuffer (
261	IN LIST_ENTRY *Entry,
262	IN VOID *Context
263	)
264	{
265	HTTP_PROTOCOL *HttpInstance;
266	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
267	UINTN NumberOfChildren;
268	EFI_HANDLE *ChildHandleBuffer;
269
270	if (Entry == NULL \|\| Context == NULL) {
271	return EFI_INVALID_PARAMETER;
272	}
273
274	HttpInstance = NET_LIST_USER_STRUCT_S (Entry, HTTP_PROTOCOL, Link, HTTP_PROTOCOL_SIGNATURE);
275	ServiceBinding = ((HTTP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
276	NumberOfChildren = ((HTTP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
277	ChildHandleBuffer = ((HTTP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
278
279	if (!NetIsInHandleBuffer (HttpInstance->Handle, NumberOfChildren, ChildHandleBuffer)) {
280	return EFI_SUCCESS;
281	}
282
283	return ServiceBinding->DestroyChild (ServiceBinding, HttpInstance->Handle);
284	}
285
286	/**
287	Test to see if this driver supports ControllerHandle. This is the worker function for
288	HttpDxeIp4(6)DriverBindingSupported.
289
290	@param[in] This The pointer to the driver binding protocol.
291	@param[in] ControllerHandle The handle of device to be tested.
292	@param[in] RemainingDevicePath Optional parameter used to pick a specific child
293	device to be started.
294	@param[in] IpVersion IP_VERSION_4 or IP_VERSION_6.
295
296	@retval EFI_SUCCESS This driver supports this device.
297	@retval EFI_UNSUPPORTED This driver does not support this device.
298
299	**/
300	EFI_STATUS
301	EFIAPI
302	HttpDxeSupported (
303	IN EFI_DRIVER_BINDING_PROTOCOL *This,
304	IN EFI_HANDLE ControllerHandle,
305	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL,
306	IN UINT8 IpVersion
307	)
308	{
309	EFI_STATUS Status;
310	EFI_GUID *TcpServiceBindingProtocolGuid;
311
312	if (IpVersion == IP_VERSION_4) {
313	TcpServiceBindingProtocolGuid = &gEfiTcp4ServiceBindingProtocolGuid;
314	} else {
315	TcpServiceBindingProtocolGuid = &gEfiTcp6ServiceBindingProtocolGuid;
316	}
317
318	Status = gBS->OpenProtocol (
319	ControllerHandle,
320	TcpServiceBindingProtocolGuid,
321	NULL,
322	This->DriverBindingHandle,
323	ControllerHandle,
324	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
325	);
326
327	if (EFI_ERROR (Status)) {
328	return EFI_UNSUPPORTED;
329	}
330
331	return EFI_SUCCESS;
332	}
333
334	/**
335	Start this driver on ControllerHandle. This is the worker function for
336	HttpDxeIp4(6)DriverBindingStart.
337
338	@param[in] This The pointer to the driver binding protocol.
339	@param[in] ControllerHandle The handle of device to be started.
340	@param[in] RemainingDevicePath Optional parameter used to pick a specific child
341	device to be started.
342	@param[in] IpVersion IP_VERSION_4 or IP_VERSION_6.
343
344
345	@retval EFI_SUCCESS This driver is installed to ControllerHandle.
346	@retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle.
347	@retval other This driver does not support this device.
348
349	**/
350	EFI_STATUS
351	EFIAPI
352	HttpDxeStart (
353	IN EFI_DRIVER_BINDING_PROTOCOL *This,
354	IN EFI_HANDLE ControllerHandle,
355	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL,
356	IN UINT8 IpVersion
357	)
358	{
359	EFI_STATUS Status;
360	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
361	HTTP_SERVICE *HttpService;
362	VOID *Interface;
363	BOOLEAN UsingIpv6;
364
365	UsingIpv6 = FALSE;
366
367	//
368	// Test for the Http service binding protocol
369	//
370	Status = gBS->OpenProtocol (
371	ControllerHandle,
372	&gEfiHttpServiceBindingProtocolGuid,
373	(VOID **) &ServiceBinding,
374	This->DriverBindingHandle,
375	ControllerHandle,
376	EFI_OPEN_PROTOCOL_GET_PROTOCOL
377	);
378
379	if (!EFI_ERROR (Status)) {
380	HttpService = HTTP_SERVICE_FROM_PROTOCOL (ServiceBinding);
381	} else {
382	Status = HttpCreateService (ControllerHandle, &HttpService);
383	if (EFI_ERROR (Status)) {
384	return Status;
385	}
386
387	ASSERT (HttpService != NULL);
388
389	//
390	// Install the HttpServiceBinding Protocol onto Controller
391	//
392	Status = gBS->InstallMultipleProtocolInterfaces (
393	&ControllerHandle,
394	&gEfiHttpServiceBindingProtocolGuid,
395	&HttpService->ServiceBinding,
396	NULL
397	);
398
399	if (EFI_ERROR (Status)) {
400	goto ON_ERROR;
401	}
402	}
403
404	if (IpVersion == IP_VERSION_4) {
405	HttpService->Ip4DriverBindingHandle = This->DriverBindingHandle;
406
407	if (HttpService->Tcp4ChildHandle == NULL) {
408	//
409	// Create a TCP4 child instance, but do not configure it. This will establish the parent-child relationship.
410	//
411	Status = NetLibCreateServiceChild (
412	ControllerHandle,
413	This->DriverBindingHandle,
414	&gEfiTcp4ServiceBindingProtocolGuid,
415	&HttpService->Tcp4ChildHandle
416	);
417
418	if (EFI_ERROR (Status)) {
419	goto ON_ERROR;
420	}
421
422	Status = gBS->OpenProtocol (
423	HttpService->Tcp4ChildHandle,
424	&gEfiTcp4ProtocolGuid,
425	&Interface,
426	This->DriverBindingHandle,
427	ControllerHandle,
428	EFI_OPEN_PROTOCOL_BY_DRIVER
429	);
430
431	if (EFI_ERROR (Status)) {
432	goto ON_ERROR;
433	}
434
435	} else {
436	return EFI_ALREADY_STARTED;
437	}
438
439	} else {
440	UsingIpv6 = TRUE;
441	HttpService->Ip6DriverBindingHandle = This->DriverBindingHandle;
442
443	if (HttpService->Tcp6ChildHandle == NULL) {
444	//
445	// Create a TCP6 child instance, but do not configure it. This will establish the parent-child relationship.
446	//
447	Status = NetLibCreateServiceChild (
448	ControllerHandle,
449	This->DriverBindingHandle,
450	&gEfiTcp6ServiceBindingProtocolGuid,
451	&HttpService->Tcp6ChildHandle
452	);
453
454	if (EFI_ERROR (Status)) {
455	goto ON_ERROR;
456	}
457
458	Status = gBS->OpenProtocol (
459	HttpService->Tcp6ChildHandle,
460	&gEfiTcp6ProtocolGuid,
461	&Interface,
462	This->DriverBindingHandle,
463	ControllerHandle,
464	EFI_OPEN_PROTOCOL_BY_DRIVER
465	);
466
467	if (EFI_ERROR (Status)) {
468	goto ON_ERROR;
469	}
470
471	} else {
472	return EFI_ALREADY_STARTED;
473	}
474
475	}
476
477	return EFI_SUCCESS;
478
479	ON_ERROR:
480
481	if (HttpService != NULL) {
482	HttpCleanService (HttpService, UsingIpv6);
483	if (HttpService->Tcp4ChildHandle == NULL && HttpService->Tcp6ChildHandle == NULL) {
484	FreePool (HttpService);
485	}
486	}
487
488	return Status;
489
490
491	}
492
493	/**
494	Stop this driver on ControllerHandle. This is the worker function for
495	HttpDxeIp4(6)DriverBindingStop.
496
497	@param[in] This Protocol instance pointer.
498	@param[in] ControllerHandle Handle of device to stop driver on.
499	@param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
500	children is zero stop the entire bus driver.
501	@param[in] ChildHandleBuffer List of Child Handles to Stop.
502	@param[in] IpVersion IP_VERSION_4 or IP_VERSION_6.
503
504	@retval EFI_SUCCESS This driver was removed ControllerHandle.
505	@retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
506	@retval Others This driver was not removed from this device
507
508	**/
509	EFI_STATUS
510	EFIAPI
511	HttpDxeStop (
512	IN EFI_DRIVER_BINDING_PROTOCOL *This,
513	IN EFI_HANDLE ControllerHandle,
514	IN UINTN NumberOfChildren,
515	IN EFI_HANDLE *ChildHandleBuffer,
516	IN UINT8 IpVersion
517	)
518	{
519	EFI_HANDLE NicHandle;
520	EFI_STATUS Status;
521	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
522	HTTP_SERVICE *HttpService;
523	LIST_ENTRY *List;
524	HTTP_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT Context;
525	BOOLEAN UsingIpv6;
526
527	//
528	// HTTP driver opens TCP4(6) child, So, Controller is a TCP4(6)
529	// child handle. Locate the Nic handle first. Then get the
530	// HTTP private data back.
531	//
532	if (IpVersion == IP_VERSION_4) {
533	UsingIpv6 = FALSE;
534	NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiTcp4ProtocolGuid);
535	} else {
536	UsingIpv6 = TRUE;
537	NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiTcp6ProtocolGuid);
538	}
539
540	if (NicHandle == NULL) {
541	return EFI_SUCCESS;
542	}
543
544	Status = gBS->OpenProtocol (
545	NicHandle,
546	&gEfiHttpServiceBindingProtocolGuid,
547	(VOID **) &ServiceBinding,
548	This->DriverBindingHandle,
549	NicHandle,
550	EFI_OPEN_PROTOCOL_GET_PROTOCOL
551	);
552
553	if (!EFI_ERROR (Status)) {
554
555	HttpService = HTTP_SERVICE_FROM_PROTOCOL (ServiceBinding);
556
557	if (NumberOfChildren != 0) {
558	//
559	// Destroy the HTTP child instance in ChildHandleBuffer.
560	//
561	List = &HttpService->ChildrenList;
562	Context.ServiceBinding = ServiceBinding;
563	Context.NumberOfChildren = NumberOfChildren;
564	Context.ChildHandleBuffer = ChildHandleBuffer;
565	Status = NetDestroyLinkList (
566	List,
567	HttpDestroyChildEntryInHandleBuffer,
568	&Context,
569	NULL
570	);
571	} else {
572
573	HttpCleanService (HttpService, UsingIpv6);
574
575	if (HttpService->Tcp4ChildHandle == NULL && HttpService->Tcp6ChildHandle == NULL) {
576	gBS->UninstallProtocolInterface (
577	NicHandle,
578	&gEfiHttpServiceBindingProtocolGuid,
579	ServiceBinding
580	);
581	FreePool (HttpService);
582	}
583	Status = EFI_SUCCESS;
584	}
585	}
586
587	return Status;
588
589	}
590
591	/**
592	Tests to see if this driver supports a given controller. If a child device is provided,
593	it further tests to see if this driver supports creating a handle for the specified child device.
594
595	This function checks to see if the driver specified by This supports the device specified by
596	ControllerHandle. Drivers will typically use the device path attached to
597	ControllerHandle and/or the services from the bus I/O abstraction attached to
598	ControllerHandle to determine if the driver supports ControllerHandle. This function
599	may be called many times during platform initialization. In order to reduce boot times, the tests
600	performed by this function must be very small, and take as little time as possible to execute. This
601	function must not change the state of any hardware devices, and this function must be aware that the
602	device specified by ControllerHandle may already be managed by the same driver or a
603	different driver. This function must match its calls to AllocatePages() with FreePages(),
604	AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
605	Because ControllerHandle may have been previously started by the same driver, if a protocol is
606	already in the opened state, then it must not be closed with CloseProtocol(). This is required
607	to guarantee the state of ControllerHandle is not modified by this function.
608
609	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
610	@param[in] ControllerHandle The handle of the controller to test. This handle
611	must support a protocol interface that supplies
612	an I/O abstraction to the driver.
613	@param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
614	parameter is ignored by device drivers, and is optional for bus
615	drivers. For bus drivers, if this parameter is not NULL, then
616	the bus driver must determine if the bus controller specified
617	by ControllerHandle and the child controller specified
618	by RemainingDevicePath are both supported by this
619	bus driver.
620
621	@retval EFI_SUCCESS The device specified by ControllerHandle and
622	RemainingDevicePath is supported by the driver specified by This.
623	@retval EFI_ALREADY_STARTED The device specified by ControllerHandle and
624	RemainingDevicePath is already being managed by the driver
625	specified by This.
626	@retval EFI_ACCESS_DENIED The device specified by ControllerHandle and
627	RemainingDevicePath is already being managed by a different
628	driver or an application that requires exclusive access.
629	Currently not implemented.
630	@retval EFI_UNSUPPORTED The device specified by ControllerHandle and
631	RemainingDevicePath is not supported by the driver specified by This.
632	**/
633	EFI_STATUS
634	EFIAPI
635	HttpDxeIp4DriverBindingSupported (
636	IN EFI_DRIVER_BINDING_PROTOCOL *This,
637	IN EFI_HANDLE ControllerHandle,
638	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
639	)
640	{
641	return HttpDxeSupported (
642	This,
643	ControllerHandle,
644	RemainingDevicePath,
645	IP_VERSION_4
646	);
647	}
648
649	/**
650	Starts a device controller or a bus controller.
651
652	The Start() function is designed to be invoked from the EFI boot service ConnectController().
653	As a result, much of the error checking on the parameters to Start() has been moved into this
654	common boot service. It is legal to call Start() from other locations,
655	but the following calling restrictions must be followed, or the system behavior will not be deterministic.
656	1. ControllerHandle must be a valid EFI_HANDLE.
657	2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
658	EFI_DEVICE_PATH_PROTOCOL.
659	3. Prior to calling Start(), the Supported() function for the driver specified by This must
660	have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
661
662	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
663	@param[in] ControllerHandle The handle of the controller to start. This handle
664	must support a protocol interface that supplies
665	an I/O abstraction to the driver.
666	@param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
667	parameter is ignored by device drivers, and is optional for bus
668	drivers. For a bus driver, if this parameter is NULL, then handles
669	for all the children of Controller are created by this driver.
670	If this parameter is not NULL and the first Device Path Node is
671	not the End of Device Path Node, then only the handle for the
672	child device specified by the first Device Path Node of
673	RemainingDevicePath is created by this driver.
674	If the first Device Path Node of RemainingDevicePath is
675	the End of Device Path Node, no child handle is created by this
676	driver.
677
678	@retval EFI_SUCCESS The device was started.
679	@retval EFI_ALREADY_STARTED This device is already running on ControllerHandle.
680	@retval EFI_DEVICE_ERROR The device could not be started due to a device error.Currently not implemented.
681	@retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
682	@retval Others The driver failded to start the device.
683
684	**/
685	EFI_STATUS
686	EFIAPI
687	HttpDxeIp4DriverBindingStart (
688	IN EFI_DRIVER_BINDING_PROTOCOL *This,
689	IN EFI_HANDLE ControllerHandle,
690	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
691	)
692	{
693	return HttpDxeStart (
694	This,
695	ControllerHandle,
696	RemainingDevicePath,
697	IP_VERSION_4
698	);
699	}
700
701	/**
702	Stops a device controller or a bus controller.
703
704	The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
705	As a result, much of the error checking on the parameters to Stop() has been moved
706	into this common boot service. It is legal to call Stop() from other locations,
707	but the following calling restrictions must be followed, or the system behavior will not be deterministic.
708	1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
709	same driver's Start() function.
710	2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
711	EFI_HANDLE. In addition, all of these handles must have been created in this driver's
712	Start() function, and the Start() function must have called OpenProtocol() on
713	ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
714
715	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
716	@param[in] ControllerHandle A handle to the device being stopped. The handle must
717	support a bus specific I/O protocol for the driver
718	to use to stop the device.
719	@param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
720	@param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
721	if NumberOfChildren is 0.
722
723	@retval EFI_SUCCESS The device was stopped.
724	@retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
725
726	**/
727	EFI_STATUS
728	EFIAPI
729	HttpDxeIp4DriverBindingStop (
730	IN EFI_DRIVER_BINDING_PROTOCOL *This,
731	IN EFI_HANDLE ControllerHandle,
732	IN UINTN NumberOfChildren,
733	IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
734	)
735	{
736	return HttpDxeStop (
737	This,
738	ControllerHandle,
739	NumberOfChildren,
740	ChildHandleBuffer,
741	IP_VERSION_4
742	);
743	}
744
745	/**
746	Tests to see if this driver supports a given controller. If a child device is provided,
747	it further tests to see if this driver supports creating a handle for the specified child device.
748
749	This function checks to see if the driver specified by This supports the device specified by
750	ControllerHandle. Drivers will typically use the device path attached to
751	ControllerHandle and/or the services from the bus I/O abstraction attached to
752	ControllerHandle to determine if the driver supports ControllerHandle. This function
753	may be called many times during platform initialization. In order to reduce boot times, the tests
754	performed by this function must be very small, and take as little time as possible to execute. This
755	function must not change the state of any hardware devices, and this function must be aware that the
756	device specified by ControllerHandle may already be managed by the same driver or a
757	different driver. This function must match its calls to AllocatePages() with FreePages(),
758	AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
759	Because ControllerHandle may have been previously started by the same driver, if a protocol is
760	already in the opened state, then it must not be closed with CloseProtocol(). This is required
761	to guarantee the state of ControllerHandle is not modified by this function.
762
763	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
764	@param[in] ControllerHandle The handle of the controller to test. This handle
765	must support a protocol interface that supplies
766	an I/O abstraction to the driver.
767	@param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
768	parameter is ignored by device drivers, and is optional for bus
769	drivers. For bus drivers, if this parameter is not NULL, then
770	the bus driver must determine if the bus controller specified
771	by ControllerHandle and the child controller specified
772	by RemainingDevicePath are both supported by this
773	bus driver.
774
775	@retval EFI_SUCCESS The device specified by ControllerHandle and
776	RemainingDevicePath is supported by the driver specified by This.
777	@retval EFI_ALREADY_STARTED The device specified by ControllerHandle and
778	RemainingDevicePath is already being managed by the driver
779	specified by This.
780	@retval EFI_ACCESS_DENIED The device specified by ControllerHandle and
781	RemainingDevicePath is already being managed by a different
782	driver or an application that requires exclusive access.
783	Currently not implemented.
784	@retval EFI_UNSUPPORTED The device specified by ControllerHandle and
785	RemainingDevicePath is not supported by the driver specified by This.
786	**/
787	EFI_STATUS
788	EFIAPI
789	HttpDxeIp6DriverBindingSupported (
790	IN EFI_DRIVER_BINDING_PROTOCOL *This,
791	IN EFI_HANDLE ControllerHandle,
792	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
793	)
794	{
795	return HttpDxeSupported (
796	This,
797	ControllerHandle,
798	RemainingDevicePath,
799	IP_VERSION_6
800	);
801
802	}
803
804	/**
805	Starts a device controller or a bus controller.
806
807	The Start() function is designed to be invoked from the EFI boot service ConnectController().
808	As a result, much of the error checking on the parameters to Start() has been moved into this
809	common boot service. It is legal to call Start() from other locations,
810	but the following calling restrictions must be followed, or the system behavior will not be deterministic.
811	1. ControllerHandle must be a valid EFI_HANDLE.
812	2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
813	EFI_DEVICE_PATH_PROTOCOL.
814	3. Prior to calling Start(), the Supported() function for the driver specified by This must
815	have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
816
817	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
818	@param[in] ControllerHandle The handle of the controller to start. This handle
819	must support a protocol interface that supplies
820	an I/O abstraction to the driver.
821	@param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This
822	parameter is ignored by device drivers, and is optional for bus
823	drivers. For a bus driver, if this parameter is NULL, then handles
824	for all the children of Controller are created by this driver.
825	If this parameter is not NULL and the first Device Path Node is
826	not the End of Device Path Node, then only the handle for the
827	child device specified by the first Device Path Node of
828	RemainingDevicePath is created by this driver.
829	If the first Device Path Node of RemainingDevicePath is
830	the End of Device Path Node, no child handle is created by this
831	driver.
832
833	@retval EFI_SUCCESS The device was started.
834	@retval EFI_ALREADY_STARTED This device is already running on ControllerHandle.
835	@retval EFI_DEVICE_ERROR The device could not be started due to a device error.Currently not implemented.
836	@retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
837	@retval Others The driver failded to start the device.
838
839	**/
840	EFI_STATUS
841	EFIAPI
842	HttpDxeIp6DriverBindingStart (
843	IN EFI_DRIVER_BINDING_PROTOCOL *This,
844	IN EFI_HANDLE ControllerHandle,
845	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
846	)
847	{
848	return HttpDxeStart (
849	This,
850	ControllerHandle,
851	RemainingDevicePath,
852	IP_VERSION_6
853	);
854	}
855
856	/**
857	Stops a device controller or a bus controller.
858
859	The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
860	As a result, much of the error checking on the parameters to Stop() has been moved
861	into this common boot service. It is legal to call Stop() from other locations,
862	but the following calling restrictions must be followed, or the system behavior will not be deterministic.
863	1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
864	same driver's Start() function.
865	2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
866	EFI_HANDLE. In addition, all of these handles must have been created in this driver's
867	Start() function, and the Start() function must have called OpenProtocol() on
868	ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
869
870	@param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
871	@param[in] ControllerHandle A handle to the device being stopped. The handle must
872	support a bus specific I/O protocol for the driver
873	to use to stop the device.
874	@param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer.
875	@param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL
876	if NumberOfChildren is 0.
877
878	@retval EFI_SUCCESS The device was stopped.
879	@retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
880
881	**/
882	EFI_STATUS
883	EFIAPI
884	HttpDxeIp6DriverBindingStop (
885	IN EFI_DRIVER_BINDING_PROTOCOL *This,
886	IN EFI_HANDLE ControllerHandle,
887	IN UINTN NumberOfChildren,
888	IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
889	)
890	{
891	return HttpDxeStop (
892	This,
893	ControllerHandle,
894	NumberOfChildren,
895	ChildHandleBuffer,
896	IP_VERSION_6
897	);
898	}
899	/**
900	Creates a child handle and installs a protocol.
901
902	The CreateChild() function installs a protocol on ChildHandle.
903	If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
904	If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
905
906	@param This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
907	@param ChildHandle Pointer to the handle of the child to create. If it is NULL,
908	then a new handle is created. If it is a pointer to an existing UEFI handle,
909	then the protocol is added to the existing UEFI handle.
910
911	@retval EFI_SUCCES The protocol was added to ChildHandle.
912	@retval EFI_INVALID_PARAMETER This is NULL, or ChildHandle is NULL.
913	@retval EFI_OUT_OF_RESOURCES There are not enough resources available to create
914	the child.
915	@retval other The child handle was not created.
916
917	**/
918	EFI_STATUS
919	EFIAPI
920	HttpServiceBindingCreateChild (
921	IN EFI_SERVICE_BINDING_PROTOCOL *This,
922	IN OUT EFI_HANDLE *ChildHandle
923	)
924	{
925	HTTP_SERVICE *HttpService;
926	HTTP_PROTOCOL *HttpInstance;
927	EFI_STATUS Status;
928	EFI_TPL OldTpl;
929
930	if ((This == NULL) \|\| (ChildHandle == NULL)) {
931	return EFI_INVALID_PARAMETER;
932	}
933
934	HttpService = HTTP_SERVICE_FROM_PROTOCOL (This);
935	HttpInstance = AllocateZeroPool (sizeof (HTTP_PROTOCOL));
936	if (HttpInstance == NULL) {
937	return EFI_OUT_OF_RESOURCES;
938	}
939
940	HttpInstance->Signature = HTTP_PROTOCOL_SIGNATURE;
941	HttpInstance->Service = HttpService;
942	HttpInstance->Method = HttpMethodMax;
943
944	CopyMem (&HttpInstance->Http, &mEfiHttpTemplate, sizeof (HttpInstance->Http));
945	NetMapInit (&HttpInstance->TxTokens);
946	NetMapInit (&HttpInstance->RxTokens);
947
948	//
949	// Install HTTP protocol onto ChildHandle
950	//
951	Status = gBS->InstallMultipleProtocolInterfaces (
952	ChildHandle,
953	&gEfiHttpProtocolGuid,
954	&HttpInstance->Http,
955	NULL
956	);
957
958	if (EFI_ERROR (Status)) {
959	goto ON_ERROR;
960	}
961
962	HttpInstance->Handle = *ChildHandle;
963
964	//
965	// Add it to the HTTP service's child list.
966	//
967	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
968
969	InsertTailList (&HttpService->ChildrenList, &HttpInstance->Link);
970	HttpService->ChildrenNumber++;
971
972	gBS->RestoreTPL (OldTpl);
973
974	return EFI_SUCCESS;
975
976	ON_ERROR:
977
978	NetMapClean (&HttpInstance->TxTokens);
979	NetMapClean (&HttpInstance->RxTokens);
980	FreePool (HttpInstance);
981
982	return Status;
983	}
984
985	/**
986	Destroys a child handle with a protocol installed on it.
987
988	The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
989	that was installed by CreateChild() from ChildHandle. If the removed protocol is the
990	last protocol on ChildHandle, then ChildHandle is destroyed.
991
992	@param This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
993	@param ChildHandle Handle of the child to destroy
994
995	@retval EFI_SUCCES The protocol was removed from ChildHandle.
996	@retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
997	@retval EFI_INVALID_PARAMETER Child handle is NULL.
998	@retval other The child handle was not destroyed
999
1000	**/
1001	EFI_STATUS
1002	EFIAPI
1003	HttpServiceBindingDestroyChild (
1004	IN EFI_SERVICE_BINDING_PROTOCOL *This,
1005	IN EFI_HANDLE ChildHandle
1006	)
1007	{
1008	HTTP_SERVICE *HttpService;
1009	HTTP_PROTOCOL *HttpInstance;
1010	EFI_HTTP_PROTOCOL *Http;
1011	EFI_STATUS Status;
1012	EFI_TPL OldTpl;
1013
1014	if ((This == NULL) \|\| (ChildHandle == NULL)) {
1015	return EFI_INVALID_PARAMETER;
1016	}
1017
1018	HttpService = HTTP_SERVICE_FROM_PROTOCOL (This);
1019	Status = gBS->OpenProtocol (
1020	ChildHandle,
1021	&gEfiHttpProtocolGuid,
1022	(VOID **) &Http,
1023	NULL,
1024	NULL,
1025	EFI_OPEN_PROTOCOL_GET_PROTOCOL
1026	);
1027	if (EFI_ERROR (Status)) {
1028	return EFI_UNSUPPORTED;
1029	}
1030
1031	HttpInstance = HTTP_INSTANCE_FROM_PROTOCOL (Http);
1032	if (HttpInstance->Service != HttpService) {
1033	return EFI_INVALID_PARAMETER;
1034	}
1035
1036	if (HttpInstance->InDestroy) {
1037	return EFI_SUCCESS;
1038	}
1039
1040	HttpInstance->InDestroy = TRUE;
1041
1042	//
1043	// Uninstall the HTTP protocol.
1044	//
1045	Status = gBS->UninstallProtocolInterface (
1046	ChildHandle,
1047	&gEfiHttpProtocolGuid,
1048	Http
1049	);
1050
1051	if (EFI_ERROR (Status)) {
1052	HttpInstance->InDestroy = FALSE;
1053	return Status;
1054	}
1055
1056	HttpCleanProtocol (HttpInstance);
1057
1058	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1059
1060	RemoveEntryList (&HttpInstance->Link);
1061	HttpService->ChildrenNumber--;
1062
1063	gBS->RestoreTPL (OldTpl);
1064
1065	FreePool (HttpInstance);
1066	return EFI_SUCCESS;
1067	}

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

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/HttpDxe/HttpDriver.c@ 77775

Download in other formats: