Dhcp6Driver.c@ 99454

Last change on this file since 99454 was 99404, checked in by vboxsync, 2 years ago
Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
Property svn:eol-style set to `native`
File size: 21.5 KB

Line
1	/** @file
2	Driver Binding functions and Service Binding functions
3	implementation for Dhcp6 Driver.
4
5	Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
6
7	SPDX-License-Identifier: BSD-2-Clause-Patent
8
9	**/
10
11	#include "Dhcp6Impl.h"
12
13	EFI_DRIVER_BINDING_PROTOCOL gDhcp6DriverBinding = {
14	Dhcp6DriverBindingSupported,
15	Dhcp6DriverBindingStart,
16	Dhcp6DriverBindingStop,
17	0xa,
18	NULL,
19	NULL
20	};
21
22	EFI_SERVICE_BINDING_PROTOCOL gDhcp6ServiceBindingTemplate = {
23	Dhcp6ServiceBindingCreateChild,
24	Dhcp6ServiceBindingDestroyChild
25	};
26
27	/**
28	Configure the default Udp6Io to receive all the DHCP6 traffic
29	on this network interface.
30
31	@param[in] UdpIo The pointer to Udp6Io to be configured.
32	@param[in] Context The pointer to the context.
33
34	@retval EFI_SUCCESS The Udp6Io is successfully configured.
35	@retval Others Failed to configure the Udp6Io.
36
37	**/
38	EFI_STATUS
39	EFIAPI
40	Dhcp6ConfigureUdpIo (
41	IN UDP_IO *UdpIo,
42	IN VOID *Context
43	)
44	{
45	EFI_UDP6_PROTOCOL *Udp6;
46	EFI_UDP6_CONFIG_DATA *Config;
47
48	Udp6 = UdpIo->Protocol.Udp6;
49	Config = &(UdpIo->Config.Udp6);
50
51	ZeroMem (Config, sizeof (EFI_UDP6_CONFIG_DATA));
52
53	//
54	// Set Udp6 configure data for the Dhcp6 instance.
55	//
56	Config->AcceptPromiscuous = FALSE;
57	Config->AcceptAnyPort = FALSE;
58	Config->AllowDuplicatePort = FALSE;
59	Config->TrafficClass = 0;
60	Config->HopLimit = 128;
61	Config->ReceiveTimeout = 0;
62	Config->TransmitTimeout = 0;
63
64	//
65	// Configure an endpoint of client(0, 546), server(0, 0), the addresses
66	// will be overridden later. Note that we MUST not limit RemotePort.
67	// More details, refer to RFC 3315 section 5.2.
68	//
69	Config->StationPort = DHCP6_PORT_CLIENT;
70	Config->RemotePort = 0;
71
72	return Udp6->Configure (Udp6, Config);
73	}
74
75	/**
76	Destroy the Dhcp6 service. The Dhcp6 service may be partly initialized,
77	or partly destroyed. If a resource is destroyed, it is marked as such in
78	case the destroy failed and being called again later.
79
80	@param[in, out] Service The pointer to Dhcp6 service to be destroyed.
81
82	**/
83	VOID
84	Dhcp6DestroyService (
85	IN OUT DHCP6_SERVICE *Service
86	)
87	{
88	//
89	// All children instances should have been already destroyed here.
90	//
91	ASSERT (Service->NumOfChild == 0);
92
93	if (Service->ClientId != NULL) {
94	FreePool (Service->ClientId);
95	}
96
97	if (Service->UdpIo != NULL) {
98	UdpIoFreeIo (Service->UdpIo);
99	}
100
101	FreePool (Service);
102	}
103
104	/**
105	Create a new Dhcp6 service for the Nic controller.
106
107	@param[in] Controller The controller to be installed DHCP6 service
108	binding protocol.
109	@param[in] ImageHandle The image handle of the Dhcp6 driver.
110	@param[out] Service The return pointer of the new Dhcp6 service.
111
112	@retval EFI_SUCCESS The Dhcp6 service is created successfully.
113	@retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
114	@retval EFI_OUT_OF_RESOURCES Failed to allocate resource.
115
116	**/
117	EFI_STATUS
118	Dhcp6CreateService (
119	IN EFI_HANDLE Controller,
120	IN EFI_HANDLE ImageHandle,
121	OUT DHCP6_SERVICE **Service
122	)
123	{
124	DHCP6_SERVICE *Dhcp6Srv;
125	EFI_STATUS Status;
126
127	*Service = NULL;
128	Dhcp6Srv = AllocateZeroPool (sizeof (DHCP6_SERVICE));
129
130	if (Dhcp6Srv == NULL) {
131	return EFI_OUT_OF_RESOURCES;
132	}
133
134	//
135	// Open the SNP protocol to get mode data later.
136	//
137	Dhcp6Srv->Snp = NULL;
138	NetLibGetSnpHandle (Controller, &Dhcp6Srv->Snp);
139	if (Dhcp6Srv->Snp == NULL) {
140	FreePool (Dhcp6Srv);
141	return EFI_DEVICE_ERROR;
142	}
143
144	//
145	// Initialize the fields of the new Dhcp6 service.
146	//
147	Dhcp6Srv->Signature = DHCP6_SERVICE_SIGNATURE;
148	Dhcp6Srv->Controller = Controller;
149	Dhcp6Srv->Image = ImageHandle;
150	Dhcp6Srv->Xid = (0xffffff & NET_RANDOM (NetRandomInitSeed ()));
151
152	CopyMem (
153	&Dhcp6Srv->ServiceBinding,
154	&gDhcp6ServiceBindingTemplate,
155	sizeof (EFI_SERVICE_BINDING_PROTOCOL)
156	);
157
158	//
159	// Locate Ip6->Ip6Config and store it for get IP6 Duplicate Address Detection transmits.
160	//
161	Status = gBS->HandleProtocol (
162	Controller,
163	&gEfiIp6ConfigProtocolGuid,
164	(VOID **)&Dhcp6Srv->Ip6Cfg
165	);
166	if (EFI_ERROR (Status)) {
167	FreePool (Dhcp6Srv);
168	return Status;
169	}
170
171	//
172	// Generate client Duid: If SMBIOS system UUID is located, generate DUID in DUID-UUID format.
173	// Otherwise, in DUID-LLT format.
174	//
175	Dhcp6Srv->ClientId = Dhcp6GenerateClientId (Dhcp6Srv->Snp->Mode);
176
177	if (Dhcp6Srv->ClientId == NULL) {
178	FreePool (Dhcp6Srv);
179	return EFI_DEVICE_ERROR;
180	}
181
182	//
183	// Create an Udp6Io for stateful transmit/receive of each Dhcp6 instance.
184	//
185	Dhcp6Srv->UdpIo = UdpIoCreateIo (
186	Controller,
187	ImageHandle,
188	Dhcp6ConfigureUdpIo,
189	UDP_IO_UDP6_VERSION,
190	NULL
191	);
192
193	if (Dhcp6Srv->UdpIo == NULL) {
194	FreePool (Dhcp6Srv->ClientId);
195	FreePool (Dhcp6Srv);
196	return EFI_DEVICE_ERROR;
197	}
198
199	InitializeListHead (&Dhcp6Srv->Child);
200
201	*Service = Dhcp6Srv;
202
203	return EFI_SUCCESS;
204	}
205
206	/**
207	Destroy the Dhcp6 instance and recycle the resources.
208
209	@param[in, out] Instance The pointer to the Dhcp6 instance.
210
211	**/
212	VOID
213	Dhcp6DestroyInstance (
214	IN OUT DHCP6_INSTANCE *Instance
215	)
216	{
217	//
218	// Clean up the retry list first.
219	//
220	Dhcp6CleanupRetry (Instance, DHCP6_PACKET_ALL);
221	gBS->CloseEvent (Instance->Timer);
222
223	//
224	// Clean up the current configure data.
225	//
226	if (Instance->Config != NULL) {
227	Dhcp6CleanupConfigData (Instance->Config);
228	FreePool (Instance->Config);
229	}
230
231	//
232	// Clean up the current Ia.
233	//
234	if (Instance->IaCb.Ia != NULL) {
235	if (Instance->IaCb.Ia->ReplyPacket != NULL) {
236	FreePool (Instance->IaCb.Ia->ReplyPacket);
237	}
238
239	FreePool (Instance->IaCb.Ia);
240	}
241
242	if (Instance->Unicast != NULL) {
243	FreePool (Instance->Unicast);
244	}
245
246	if (Instance->AdSelect != NULL) {
247	FreePool (Instance->AdSelect);
248	}
249
250	FreePool (Instance);
251	}
252
253	/**
254	Create the Dhcp6 instance and initialize it.
255
256	@param[in] Service The pointer to the Dhcp6 service.
257	@param[out] Instance The pointer to the Dhcp6 instance.
258
259	@retval EFI_SUCCESS The Dhcp6 instance is created.
260	@retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
261
262	**/
263	EFI_STATUS
264	Dhcp6CreateInstance (
265	IN DHCP6_SERVICE *Service,
266	OUT DHCP6_INSTANCE **Instance
267	)
268	{
269	EFI_STATUS Status;
270	DHCP6_INSTANCE *Dhcp6Ins;
271
272	*Instance = NULL;
273	Dhcp6Ins = AllocateZeroPool (sizeof (DHCP6_INSTANCE));
274
275	if (Dhcp6Ins == NULL) {
276	return EFI_OUT_OF_RESOURCES;
277	}
278
279	//
280	// Initialize the fields of the new Dhcp6 instance.
281	//
282	Dhcp6Ins->Signature = DHCP6_INSTANCE_SIGNATURE;
283	Dhcp6Ins->UdpSts = EFI_ALREADY_STARTED;
284	Dhcp6Ins->Service = Service;
285	Dhcp6Ins->InDestroy = FALSE;
286	Dhcp6Ins->MediaPresent = TRUE;
287
288	CopyMem (
289	&Dhcp6Ins->Dhcp6,
290	&gDhcp6ProtocolTemplate,
291	sizeof (EFI_DHCP6_PROTOCOL)
292	);
293
294	InitializeListHead (&Dhcp6Ins->TxList);
295	InitializeListHead (&Dhcp6Ins->InfList);
296
297	//
298	// There is a timer for each Dhcp6 instance, which is used to track the
299	// lease time of Ia and the retransmission time of all sent packets.
300	//
301	Status = gBS->CreateEvent (
302	EVT_NOTIFY_SIGNAL \| EVT_TIMER,
303	TPL_CALLBACK,
304	Dhcp6OnTimerTick,
305	Dhcp6Ins,
306	&Dhcp6Ins->Timer
307	);
308
309	if (EFI_ERROR (Status)) {
310	FreePool (Dhcp6Ins);
311	return Status;
312	}
313
314	*Instance = Dhcp6Ins;
315
316	return EFI_SUCCESS;
317	}
318
319	/**
320	Callback function which provided by user to remove one node in NetDestroyLinkList process.
321
322	@param[in] Entry The entry to be removed.
323	@param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
324
325	@retval EFI_SUCCESS The entry has been removed successfully.
326	@retval Others Fail to remove the entry.
327
328	**/
329	EFI_STATUS
330	EFIAPI
331	Dhcp6DestroyChildEntry (
332	IN LIST_ENTRY *Entry,
333	IN VOID *Context
334	)
335	{
336	DHCP6_INSTANCE *Instance;
337	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
338
339	if ((Entry == NULL) \|\| (Context == NULL)) {
340	return EFI_INVALID_PARAMETER;
341	}
342
343	Instance = NET_LIST_USER_STRUCT_S (Entry, DHCP6_INSTANCE, Link, DHCP6_INSTANCE_SIGNATURE);
344	ServiceBinding = (EFI_SERVICE_BINDING_PROTOCOL *)Context;
345
346	return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
347	}
348
349	/**
350	Entry point of the DHCP6 driver to install various protocols.
351
352	@param[in] ImageHandle The handle of the UEFI image file.
353	@param[in] SystemTable The pointer to the EFI System Table.
354
355	@retval EFI_SUCCESS The operation completed successfully.
356	@retval Others Unexpected error occurs.
357
358	**/
359	EFI_STATUS
360	EFIAPI
361	Dhcp6DriverEntryPoint (
362	IN EFI_HANDLE ImageHandle,
363	IN EFI_SYSTEM_TABLE *SystemTable
364	)
365	{
366	return EfiLibInstallDriverBindingComponentName2 (
367	ImageHandle,
368	SystemTable,
369	&gDhcp6DriverBinding,
370	ImageHandle,
371	&gDhcp6ComponentName,
372	&gDhcp6ComponentName2
373	);
374	}
375
376	/**
377	Test to see if this driver supports ControllerHandle. This service
378	is called by the EFI boot service ConnectController(). In
379	order to make drivers as small as possible, there are a few calling
380	restrictions for this service. ConnectController() must
381	follow these calling restrictions. If any other agent wishes to call
382	Supported() it must also follow these calling restrictions.
383
384	@param[in] This The pointer to the driver binding protocol.
385	@param[in] ControllerHandle The handle of device to be tested.
386	@param[in] RemainingDevicePath Optional parameter use to pick a specific child
387	device to be started.
388
389	@retval EFI_SUCCESS This driver supports this device.
390	@retval Others This driver does not support this device.
391
392	**/
393	EFI_STATUS
394	EFIAPI
395	Dhcp6DriverBindingSupported (
396	IN EFI_DRIVER_BINDING_PROTOCOL *This,
397	IN EFI_HANDLE ControllerHandle,
398	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
399	)
400	{
401	return gBS->OpenProtocol (
402	ControllerHandle,
403	&gEfiUdp6ServiceBindingProtocolGuid,
404	NULL,
405	This->DriverBindingHandle,
406	ControllerHandle,
407	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
408	);
409	}
410
411	/**
412	Start this driver on ControllerHandle. This service is called by the
413	EFI boot service ConnectController(). In order to make
414	drivers as small as possible, there are a few calling restrictions for
415	this service. ConnectController() must follow these
416	calling restrictions. If any other agent wishes to call Start() it
417	must also follow these calling restrictions.
418
419	@param[in] This The pointer to the driver binding protocol.
420	@param[in] ControllerHandle The handle of device to be started.
421	@param[in] RemainingDevicePath Optional parameter use to pick a specific child
422	device to be started.
423
424	@retval EFI_SUCCESS This driver is installed to ControllerHandle.
425	@retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle.
426	@retval other This driver does not support this device.
427
428	**/
429	EFI_STATUS
430	EFIAPI
431	Dhcp6DriverBindingStart (
432	IN EFI_DRIVER_BINDING_PROTOCOL *This,
433	IN EFI_HANDLE ControllerHandle,
434	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
435	)
436	{
437	EFI_STATUS Status;
438	DHCP6_SERVICE *Service;
439
440	//
441	// Check the Dhcp6 service whether already started.
442	//
443	Status = gBS->OpenProtocol (
444	ControllerHandle,
445	&gEfiDhcp6ServiceBindingProtocolGuid,
446	NULL,
447	This->DriverBindingHandle,
448	ControllerHandle,
449	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
450	);
451
452	if (!EFI_ERROR (Status)) {
453	return EFI_ALREADY_STARTED;
454	}
455
456	//
457	// Create and initialize the Dhcp6 service.
458	//
459	Status = Dhcp6CreateService (
460	ControllerHandle,
461	This->DriverBindingHandle,
462	&Service
463	);
464
465	if (EFI_ERROR (Status)) {
466	return Status;
467	}
468
469	ASSERT (Service != NULL);
470
471	Status = gBS->InstallMultipleProtocolInterfaces (
472	&ControllerHandle,
473	&gEfiDhcp6ServiceBindingProtocolGuid,
474	&Service->ServiceBinding,
475	NULL
476	);
477
478	if (EFI_ERROR (Status)) {
479	Dhcp6DestroyService (Service);
480	return Status;
481	}
482
483	return EFI_SUCCESS;
484	}
485
486	/**
487	Stop this driver on ControllerHandle. This service is called by the
488	EFI boot service DisconnectController(). In order to
489	make drivers as small as possible, there are a few calling
490	restrictions for this service. DisconnectController()
491	must follow these calling restrictions. If any other agent wishes
492	to call Stop() it must also follow these calling restrictions.
493
494	@param[in] This Protocol instance pointer.
495	@param[in] ControllerHandle Handle of device to stop driver on
496	@param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
497	children is zero stop the entire bus driver.
498	@param[in] ChildHandleBuffer List of Child Handles to Stop.
499
500	@retval EFI_SUCCESS This driver is removed ControllerHandle
501	@retval EFI_DEVICE_ERROR An unexpected system or network error occurred.
502	@retval other This driver was not removed from this device
503
504	**/
505	EFI_STATUS
506	EFIAPI
507	Dhcp6DriverBindingStop (
508	IN EFI_DRIVER_BINDING_PROTOCOL *This,
509	IN EFI_HANDLE ControllerHandle,
510	IN UINTN NumberOfChildren,
511	IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
512	)
513	{
514	EFI_STATUS Status;
515	EFI_HANDLE NicHandle;
516	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
517	DHCP6_SERVICE *Service;
518	LIST_ENTRY *List;
519	UINTN ListLength;
520
521	//
522	// Find and check the Nic handle by the controller handle.
523	//
524	NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp6ProtocolGuid);
525
526	if (NicHandle == NULL) {
527	return EFI_SUCCESS;
528	}
529
530	Status = gBS->OpenProtocol (
531	NicHandle,
532	&gEfiDhcp6ServiceBindingProtocolGuid,
533	(VOID **)&ServiceBinding,
534	This->DriverBindingHandle,
535	NicHandle,
536	EFI_OPEN_PROTOCOL_GET_PROTOCOL
537	);
538
539	if (EFI_ERROR (Status)) {
540	return Status;
541	}
542
543	Service = DHCP6_SERVICE_FROM_THIS (ServiceBinding);
544	if (!IsListEmpty (&Service->Child)) {
545	//
546	// Destroy all the children instances before destroy the service.
547	//
548	List = &Service->Child;
549	Status = NetDestroyLinkList (
550	List,
551	Dhcp6DestroyChildEntry,
552	ServiceBinding,
553	&ListLength
554	);
555	if (EFI_ERROR (Status) \|\| (ListLength != 0)) {
556	Status = EFI_DEVICE_ERROR;
557	}
558	}
559
560	if ((NumberOfChildren == 0) && !IsListEmpty (&Service->Child)) {
561	Status = EFI_DEVICE_ERROR;
562	}
563
564	if ((NumberOfChildren == 0) && IsListEmpty (&Service->Child)) {
565	//
566	// Destroy the service itself if no child instance left.
567	//
568	Status = gBS->UninstallProtocolInterface (
569	NicHandle,
570	&gEfiDhcp6ServiceBindingProtocolGuid,
571	ServiceBinding
572	);
573	if (EFI_ERROR (Status)) {
574	goto ON_EXIT;
575	}
576
577	Dhcp6DestroyService (Service);
578	Status = EFI_SUCCESS;
579	}
580
581	ON_EXIT:
582	return Status;
583	}
584
585	/**
586	Creates a child handle and installs a protocol.
587
588	The CreateChild() function installs a protocol on ChildHandle.
589	If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
590	If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
591
592	@param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
593	@param[in, out] ChildHandle Pointer to the handle of the child to create. If it is NULL,
594	then a new handle is created. If it is a pointer to an existing
595	UEFI handle, then the protocol is added to the existing UEFI handle.
596
597	@retval EFI_SUCCESS The protocol was added to ChildHandle.
598	@retval EFI_INVALID_PARAMETER ChildHandle is NULL.
599	@retval other The child handle was not created.
600
601	**/
602	EFI_STATUS
603	EFIAPI
604	Dhcp6ServiceBindingCreateChild (
605	IN EFI_SERVICE_BINDING_PROTOCOL *This,
606	IN OUT EFI_HANDLE *ChildHandle
607	)
608	{
609	EFI_STATUS Status;
610	EFI_TPL OldTpl;
611	DHCP6_SERVICE *Service;
612	DHCP6_INSTANCE *Instance;
613	VOID *Udp6;
614
615	if ((This == NULL) \|\| (ChildHandle == NULL)) {
616	return EFI_INVALID_PARAMETER;
617	}
618
619	Service = DHCP6_SERVICE_FROM_THIS (This);
620
621	Status = Dhcp6CreateInstance (Service, &Instance);
622
623	if (EFI_ERROR (Status)) {
624	return Status;
625	}
626
627	ASSERT (Instance != NULL);
628
629	//
630	// Start the timer when the instance is ready to use.
631	//
632	Status = gBS->SetTimer (
633	Instance->Timer,
634	TimerPeriodic,
635	TICKS_PER_SECOND
636	);
637
638	if (EFI_ERROR (Status)) {
639	goto ON_ERROR;
640	}
641
642	//
643	// Install the DHCP6 protocol onto ChildHandle.
644	//
645	Status = gBS->InstallMultipleProtocolInterfaces (
646	ChildHandle,
647	&gEfiDhcp6ProtocolGuid,
648	&Instance->Dhcp6,
649	NULL
650	);
651
652	if (EFI_ERROR (Status)) {
653	goto ON_ERROR;
654	}
655
656	Instance->Handle = *ChildHandle;
657
658	//
659	// Open the UDP6 protocol BY_CHILD.
660	//
661	Status = gBS->OpenProtocol (
662	Service->UdpIo->UdpHandle,
663	&gEfiUdp6ProtocolGuid,
664	(VOID **)&Udp6,
665	gDhcp6DriverBinding.DriverBindingHandle,
666	Instance->Handle,
667	EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
668	);
669
670	if (EFI_ERROR (Status)) {
671	gBS->UninstallMultipleProtocolInterfaces (
672	Instance->Handle,
673	&gEfiDhcp6ProtocolGuid,
674	&Instance->Dhcp6,
675	NULL
676	);
677	goto ON_ERROR;
678	}
679
680	//
681	// Add into the children list of its parent service.
682	//
683	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
684
685	InsertTailList (&Service->Child, &Instance->Link);
686	Service->NumOfChild++;
687
688	gBS->RestoreTPL (OldTpl);
689	return EFI_SUCCESS;
690
691	ON_ERROR:
692
693	Dhcp6DestroyInstance (Instance);
694	return Status;
695	}
696
697	/**
698	Destroys a child handle with a protocol installed on it.
699
700	The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
701	that was installed by CreateChild() from ChildHandle. If the removed protocol is the
702	last protocol on ChildHandle, then ChildHandle is destroyed.
703
704	@param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
705	@param[in] ChildHandle Handle of the child to destroy
706
707	@retval EFI_SUCCESS The protocol was removed from ChildHandle.
708	@retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
709	@retval EFI_INVALID_PARAMETER Child handle is NULL.
710	@retval EFI_ACCESS_DENIED The protocol could not be removed from the ChildHandle
711	because its services are being used.
712	@retval other The child handle was not destroyed
713
714	**/
715	EFI_STATUS
716	EFIAPI
717	Dhcp6ServiceBindingDestroyChild (
718	IN EFI_SERVICE_BINDING_PROTOCOL *This,
719	IN EFI_HANDLE ChildHandle
720	)
721	{
722	EFI_STATUS Status;
723	EFI_TPL OldTpl;
724	EFI_DHCP6_PROTOCOL *Dhcp6;
725	DHCP6_SERVICE *Service;
726	DHCP6_INSTANCE *Instance;
727
728	if ((This == NULL) \|\| (ChildHandle == NULL)) {
729	return EFI_INVALID_PARAMETER;
730	}
731
732	//
733	// Retrieve the private context data structures
734	//
735	Status = gBS->OpenProtocol (
736	ChildHandle,
737	&gEfiDhcp6ProtocolGuid,
738	(VOID **)&Dhcp6,
739	gDhcp6DriverBinding.DriverBindingHandle,
740	ChildHandle,
741	EFI_OPEN_PROTOCOL_GET_PROTOCOL
742	);
743
744	if (EFI_ERROR (Status)) {
745	return EFI_UNSUPPORTED;
746	}
747
748	Instance = DHCP6_INSTANCE_FROM_THIS (Dhcp6);
749	Service = DHCP6_SERVICE_FROM_THIS (This);
750
751	if (Instance->Service != Service) {
752	return EFI_INVALID_PARAMETER;
753	}
754
755	if (Instance->InDestroy) {
756	return EFI_SUCCESS;
757	}
758
759	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
760
761	Instance->InDestroy = TRUE;
762
763	Status = gBS->CloseProtocol (
764	Service->UdpIo->UdpHandle,
765	&gEfiUdp6ProtocolGuid,
766	gDhcp6DriverBinding.DriverBindingHandle,
767	ChildHandle
768	);
769
770	if (EFI_ERROR (Status)) {
771	Instance->InDestroy = FALSE;
772	gBS->RestoreTPL (OldTpl);
773	return Status;
774	}
775
776	//
777	// Uninstall the MTFTP6 protocol first to enable a top down destruction.
778	//
779	gBS->RestoreTPL (OldTpl);
780	Status = gBS->UninstallProtocolInterface (
781	ChildHandle,
782	&gEfiDhcp6ProtocolGuid,
783	Dhcp6
784	);
785	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
786	if (EFI_ERROR (Status)) {
787	Instance->InDestroy = FALSE;
788	gBS->RestoreTPL (OldTpl);
789	return Status;
790	}
791
792	//
793	// Remove it from the children list of its parent service.
794	//
795	RemoveEntryList (&Instance->Link);
796	Service->NumOfChild--;
797
798	gBS->RestoreTPL (OldTpl);
799
800	Dhcp6DestroyInstance (Instance);
801	return EFI_SUCCESS;
802	}

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

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/Dhcp6Dxe/Dhcp6Driver.c@ 99454

Download in other formats: