VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/DnsDxe/DnsDhcp.c@ 81519

Last change on this file since 81519 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: 20.4 KB
Line 
1/** @file
2Functions implementation related with DHCPv4/v6 for DNS driver.
3
4Copyright (c) 2015 - 2018, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "DnsImpl.h"
10
11/**
12 This function initialize the DHCP4 message instance.
13
14 This function will pad each item of dhcp4 message packet.
15
16 @param Seed Pointer to the message instance of the DHCP4 packet.
17 @param InterfaceInfo Pointer to the EFI_IP4_CONFIG2_INTERFACE_INFO instance.
18
19**/
20VOID
21DnsInitSeedPacket (
22 OUT EFI_DHCP4_PACKET *Seed,
23 IN EFI_IP4_CONFIG2_INTERFACE_INFO *InterfaceInfo
24 )
25{
26 EFI_DHCP4_HEADER *Header;
27
28 //
29 // Get IfType and HwAddressSize from SNP mode data.
30 //
31 Seed->Size = sizeof (EFI_DHCP4_PACKET);
32 Seed->Length = sizeof (Seed->Dhcp4);
33 Header = &Seed->Dhcp4.Header;
34 ZeroMem (Header, sizeof (EFI_DHCP4_HEADER));
35 Header->OpCode = DHCP4_OPCODE_REQUEST;
36 Header->HwType = InterfaceInfo->IfType;
37 Header->HwAddrLen = (UINT8) InterfaceInfo->HwAddressSize;
38 CopyMem (Header->ClientHwAddr, &(InterfaceInfo->HwAddress), Header->HwAddrLen);
39
40 Seed->Dhcp4.Magik = DHCP4_MAGIC;
41 Seed->Dhcp4.Option[0] = DHCP4_TAG_EOP;
42}
43
44/**
45 The common notify function.
46
47 @param[in] Event The event signaled.
48 @param[in] Context The context.
49
50**/
51VOID
52EFIAPI
53DhcpCommonNotify (
54 IN EFI_EVENT Event,
55 IN VOID *Context
56 )
57{
58 if ((Event == NULL) || (Context == NULL)) {
59 return ;
60 }
61
62 *((BOOLEAN *) Context) = TRUE;
63}
64
65/**
66 Parse the ACK to get required information
67
68 @param Dhcp4 The DHCP4 protocol.
69 @param Packet Packet waiting for parse.
70 @param DnsServerInfor The required Dns4 server information.
71
72 @retval EFI_SUCCESS The DNS information is got from the DHCP ACK.
73 @retval EFI_NO_MAPPING DHCP failed to acquire address and other information.
74 @retval EFI_DEVICE_ERROR Other errors as indicated.
75 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
76
77**/
78EFI_STATUS
79ParseDhcp4Ack (
80 IN EFI_DHCP4_PROTOCOL *Dhcp4,
81 IN EFI_DHCP4_PACKET *Packet,
82 IN DNS4_SERVER_INFOR *DnsServerInfor
83 )
84{
85 EFI_STATUS Status;
86 UINT32 OptionCount;
87 EFI_DHCP4_PACKET_OPTION **OptionList;
88 UINT32 ServerCount;
89 EFI_IPv4_ADDRESS *ServerList;
90 UINT32 Index;
91 UINT32 Count;
92
93 ServerCount = 0;
94 ServerList = NULL;
95
96 OptionCount = 0;
97 OptionList = NULL;
98
99 Status = Dhcp4->Parse (Dhcp4, Packet, &OptionCount, OptionList);
100 if (Status != EFI_BUFFER_TOO_SMALL) {
101 return EFI_DEVICE_ERROR;
102 }
103
104 OptionList = AllocatePool (OptionCount * sizeof (EFI_DHCP4_PACKET_OPTION *));
105 if (OptionList == NULL) {
106 return EFI_OUT_OF_RESOURCES;
107 }
108
109 Status = Dhcp4->Parse (Dhcp4, Packet, &OptionCount, OptionList);
110 if (EFI_ERROR (Status)) {
111 gBS->FreePool (OptionList);
112 return EFI_DEVICE_ERROR;
113 }
114
115 Status = EFI_NOT_FOUND;
116
117 for (Index = 0; Index < OptionCount; Index++) {
118 //
119 // Get DNS server addresses
120 //
121 if (OptionList[Index]->OpCode == DHCP4_TAG_DNS_SERVER) {
122
123 if (((OptionList[Index]->Length & 0x3) != 0) || (OptionList[Index]->Length == 0)) {
124 Status = EFI_DEVICE_ERROR;
125 break;
126 }
127
128 ServerCount = OptionList[Index]->Length/4;
129 ServerList = AllocatePool (ServerCount * sizeof (EFI_IPv4_ADDRESS));
130 if (ServerList == NULL) {
131 return EFI_OUT_OF_RESOURCES;
132 }
133
134 for(Count=0; Count < ServerCount; Count++){
135 CopyMem (ServerList + Count, &OptionList[Index]->Data[4 * Count], sizeof (EFI_IPv4_ADDRESS));
136 }
137
138 *(DnsServerInfor->ServerCount) = ServerCount;
139 DnsServerInfor->ServerList = ServerList;
140
141 Status = EFI_SUCCESS;
142 }
143 }
144
145 gBS->FreePool (OptionList);
146
147 return Status;
148}
149
150/**
151 EFI_DHCP6_INFO_CALLBACK is provided by the consumer of the EFI DHCPv6 Protocol
152 instance to intercept events that occurs in the DHCPv6 Information Request
153 exchange process.
154
155 @param This Pointer to the EFI_DHCP6_PROTOCOL instance that
156 is used to configure this callback function.
157 @param Context Pointer to the context that is initialized in
158 the EFI_DHCP6_PROTOCOL.InfoRequest().
159 @param Packet Pointer to Reply packet that has been received.
160 The EFI DHCPv6 Protocol instance is responsible
161 for freeing the buffer.
162
163 @retval EFI_SUCCESS The DNS information is got from the DHCP ACK.
164 @retval EFI_DEVICE_ERROR Other errors as indicated.
165 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
166**/
167EFI_STATUS
168EFIAPI
169ParseDhcp6Ack (
170 IN EFI_DHCP6_PROTOCOL *This,
171 IN VOID *Context,
172 IN EFI_DHCP6_PACKET *Packet
173 )
174{
175 EFI_STATUS Status;
176 UINT32 OptionCount;
177 EFI_DHCP6_PACKET_OPTION **OptionList;
178 DNS6_SERVER_INFOR *DnsServerInfor;
179 UINT32 ServerCount;
180 EFI_IPv6_ADDRESS *ServerList;
181 UINT32 Index;
182 UINT32 Count;
183
184 OptionCount = 0;
185 ServerCount = 0;
186 ServerList = NULL;
187
188 Status = This->Parse (This, Packet, &OptionCount, NULL);
189 if (Status != EFI_BUFFER_TOO_SMALL) {
190 return EFI_DEVICE_ERROR;
191 }
192
193 OptionList = AllocateZeroPool (OptionCount * sizeof (EFI_DHCP6_PACKET_OPTION *));
194 if (OptionList == NULL) {
195 return EFI_OUT_OF_RESOURCES;
196 }
197
198 Status = This->Parse (This, Packet, &OptionCount, OptionList);
199 if (EFI_ERROR (Status)) {
200 gBS->FreePool (OptionList);
201 return EFI_DEVICE_ERROR;
202 }
203
204 DnsServerInfor = (DNS6_SERVER_INFOR *) Context;
205
206 for (Index = 0; Index < OptionCount; Index++) {
207 OptionList[Index]->OpCode = NTOHS (OptionList[Index]->OpCode);
208 OptionList[Index]->OpLen = NTOHS (OptionList[Index]->OpLen);
209
210 //
211 // Get DNS server addresses from this reply packet.
212 //
213 if (OptionList[Index]->OpCode == DHCP6_TAG_DNS_SERVER) {
214
215 if (((OptionList[Index]->OpLen & 0xf) != 0) || (OptionList[Index]->OpLen == 0)) {
216 Status = EFI_DEVICE_ERROR;
217 gBS->FreePool (OptionList);
218 return Status;
219 }
220
221 ServerCount = OptionList[Index]->OpLen/16;
222 ServerList = AllocatePool (ServerCount * sizeof (EFI_IPv6_ADDRESS));
223 if (ServerList == NULL) {
224 gBS->FreePool (OptionList);
225 return EFI_OUT_OF_RESOURCES;
226 }
227
228 for(Count=0; Count < ServerCount; Count++){
229 CopyMem (ServerList + Count, &OptionList[Index]->Data[16 * Count], sizeof (EFI_IPv6_ADDRESS));
230 }
231
232 *(DnsServerInfor->ServerCount) = ServerCount;
233 DnsServerInfor->ServerList = ServerList;
234 }
235 }
236
237 gBS->FreePool (OptionList);
238
239 return Status;
240
241}
242
243/**
244 Parse the DHCP ACK to get Dns4 server information.
245
246 @param Instance The DNS instance.
247 @param DnsServerCount Retrieved Dns4 server Ip count.
248 @param DnsServerList Retrieved Dns4 server Ip list.
249
250 @retval EFI_SUCCESS The Dns4 information is got from the DHCP ACK.
251 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
252 @retval EFI_NO_MEDIA There was a media error.
253 @retval Others Other errors as indicated.
254
255**/
256EFI_STATUS
257GetDns4ServerFromDhcp4 (
258 IN DNS_INSTANCE *Instance,
259 OUT UINT32 *DnsServerCount,
260 OUT EFI_IPv4_ADDRESS **DnsServerList
261 )
262{
263 EFI_STATUS Status;
264 EFI_HANDLE Image;
265 EFI_HANDLE Controller;
266 EFI_STATUS MediaStatus;
267 EFI_HANDLE MnpChildHandle;
268 EFI_MANAGED_NETWORK_PROTOCOL *Mnp;
269 EFI_MANAGED_NETWORK_CONFIG_DATA MnpConfigData;
270 EFI_HANDLE Dhcp4Handle;
271 EFI_DHCP4_PROTOCOL *Dhcp4;
272 EFI_IP4_CONFIG2_PROTOCOL *Ip4Config2;
273 UINTN DataSize;
274 VOID *Data;
275 EFI_IP4_CONFIG2_INTERFACE_INFO *InterfaceInfo;
276 EFI_DHCP4_PACKET SeedPacket;
277 EFI_DHCP4_PACKET_OPTION *ParaList[2];
278 DNS4_SERVER_INFOR DnsServerInfor;
279
280 EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN Token;
281 BOOLEAN IsDone;
282 UINTN Index;
283
284 Image = Instance->Service->ImageHandle;
285 Controller = Instance->Service->ControllerHandle;
286
287 MnpChildHandle = NULL;
288 Mnp = NULL;
289
290 Dhcp4Handle = NULL;
291 Dhcp4 = NULL;
292
293 Ip4Config2 = NULL;
294 DataSize = 0;
295 Data = NULL;
296 InterfaceInfo = NULL;
297
298 ZeroMem ((UINT8 *) ParaList, sizeof (ParaList));
299
300 ZeroMem (&MnpConfigData, sizeof (EFI_MANAGED_NETWORK_CONFIG_DATA));
301
302 ZeroMem (&DnsServerInfor, sizeof (DNS4_SERVER_INFOR));
303
304 ZeroMem (&Token, sizeof (EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN));
305
306 DnsServerInfor.ServerCount = DnsServerCount;
307
308 IsDone = FALSE;
309
310 //
311 // Check media.
312 //
313 MediaStatus = EFI_SUCCESS;
314 NetLibDetectMediaWaitTimeout (Controller, DNS_CHECK_MEDIA_GET_DHCP_WAITING_TIME, &MediaStatus);
315 if (MediaStatus != EFI_SUCCESS) {
316 return EFI_NO_MEDIA;
317 }
318
319 //
320 // Create a Mnp child instance, get the protocol and config for it.
321 //
322 Status = NetLibCreateServiceChild (
323 Controller,
324 Image,
325 &gEfiManagedNetworkServiceBindingProtocolGuid,
326 &MnpChildHandle
327 );
328 if (EFI_ERROR (Status)) {
329 return Status;
330 }
331
332 Status = gBS->OpenProtocol (
333 MnpChildHandle,
334 &gEfiManagedNetworkProtocolGuid,
335 (VOID **) &Mnp,
336 Image,
337 Controller,
338 EFI_OPEN_PROTOCOL_BY_DRIVER
339 );
340 if (EFI_ERROR (Status)) {
341 goto ON_EXIT;
342 }
343
344 MnpConfigData.ReceivedQueueTimeoutValue = 0;
345 MnpConfigData.TransmitQueueTimeoutValue = 0;
346 MnpConfigData.ProtocolTypeFilter = IP4_ETHER_PROTO;
347 MnpConfigData.EnableUnicastReceive = TRUE;
348 MnpConfigData.EnableMulticastReceive = TRUE;
349 MnpConfigData.EnableBroadcastReceive = TRUE;
350 MnpConfigData.EnablePromiscuousReceive = FALSE;
351 MnpConfigData.FlushQueuesOnReset = TRUE;
352 MnpConfigData.EnableReceiveTimestamps = FALSE;
353 MnpConfigData.DisableBackgroundPolling = FALSE;
354
355 Status = Mnp->Configure(Mnp, &MnpConfigData);
356 if (EFI_ERROR (Status)) {
357 goto ON_EXIT;
358 }
359
360 //
361 // Create a DHCP4 child instance and get the protocol.
362 //
363 Status = NetLibCreateServiceChild (
364 Controller,
365 Image,
366 &gEfiDhcp4ServiceBindingProtocolGuid,
367 &Dhcp4Handle
368 );
369 if (EFI_ERROR (Status)) {
370 goto ON_EXIT;
371 }
372
373 Status = gBS->OpenProtocol (
374 Dhcp4Handle,
375 &gEfiDhcp4ProtocolGuid,
376 (VOID **) &Dhcp4,
377 Image,
378 Controller,
379 EFI_OPEN_PROTOCOL_BY_DRIVER
380 );
381 if (EFI_ERROR (Status)) {
382 goto ON_EXIT;
383 }
384
385 //
386 // Get Ip4Config2 instance info.
387 //
388 Status = gBS->HandleProtocol (Controller, &gEfiIp4Config2ProtocolGuid, (VOID **) &Ip4Config2);
389 if (EFI_ERROR (Status)) {
390 goto ON_EXIT;
391 }
392
393 Status = Ip4Config2->GetData (Ip4Config2, Ip4Config2DataTypeInterfaceInfo, &DataSize, Data);
394 if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
395 goto ON_EXIT;
396 }
397
398 Data = AllocateZeroPool (DataSize);
399 if (Data == NULL) {
400 Status = EFI_OUT_OF_RESOURCES;
401 goto ON_EXIT;
402 }
403
404 Status = Ip4Config2->GetData (Ip4Config2, Ip4Config2DataTypeInterfaceInfo, &DataSize, Data);
405 if (EFI_ERROR (Status)) {
406 goto ON_EXIT;
407 }
408
409 InterfaceInfo = (EFI_IP4_CONFIG2_INTERFACE_INFO *)Data;
410
411 //
412 // Build required Token.
413 //
414 Status = gBS->CreateEvent (
415 EVT_NOTIFY_SIGNAL,
416 TPL_NOTIFY,
417 DhcpCommonNotify,
418 &IsDone,
419 &Token.CompletionEvent
420 );
421 if (EFI_ERROR (Status)) {
422 goto ON_EXIT;
423 }
424
425 SetMem (&Token.RemoteAddress, sizeof (EFI_IPv4_ADDRESS), 0xff);
426
427 Token.RemotePort = 67;
428
429 Token.ListenPointCount = 1;
430
431 Token.ListenPoints = AllocateZeroPool (Token.ListenPointCount * sizeof (EFI_DHCP4_LISTEN_POINT));
432 if (Token.ListenPoints == NULL) {
433 Status = EFI_OUT_OF_RESOURCES;
434 goto ON_EXIT;
435 }
436
437 if (Instance->Dns4CfgData.UseDefaultSetting) {
438 CopyMem (&(Token.ListenPoints[0].ListenAddress), &(InterfaceInfo->StationAddress), sizeof (EFI_IPv4_ADDRESS));
439 CopyMem (&(Token.ListenPoints[0].SubnetMask), &(InterfaceInfo->SubnetMask), sizeof (EFI_IPv4_ADDRESS));
440 } else {
441 CopyMem (&(Token.ListenPoints[0].ListenAddress), &(Instance->Dns4CfgData.StationIp), sizeof (EFI_IPv4_ADDRESS));
442 CopyMem (&(Token.ListenPoints[0].SubnetMask), &(Instance->Dns4CfgData.SubnetMask), sizeof (EFI_IPv4_ADDRESS));
443 }
444
445 Token.ListenPoints[0].ListenPort = 68;
446
447 Token.TimeoutValue = DNS_TIME_TO_GETMAP;
448
449 DnsInitSeedPacket (&SeedPacket, InterfaceInfo);
450
451 ParaList[0] = AllocateZeroPool (sizeof (EFI_DHCP4_PACKET_OPTION));
452 if (ParaList[0] == NULL) {
453 Status = EFI_OUT_OF_RESOURCES;
454 goto ON_EXIT;
455 }
456
457 ParaList[0]->OpCode = DHCP4_TAG_TYPE;
458 ParaList[0]->Length = 1;
459 ParaList[0]->Data[0] = DHCP4_MSG_REQUEST;
460
461 ParaList[1] = AllocateZeroPool (sizeof (EFI_DHCP4_PACKET_OPTION));
462 if (ParaList[1] == NULL) {
463 Status = EFI_OUT_OF_RESOURCES;
464 goto ON_EXIT;
465 }
466
467 ParaList[1]->OpCode = DHCP4_TAG_PARA_LIST;
468 ParaList[1]->Length = 1;
469 ParaList[1]->Data[0] = DHCP4_TAG_DNS_SERVER;
470
471 Status = Dhcp4->Build (Dhcp4, &SeedPacket, 0, NULL, 2, ParaList, &Token.Packet);
472
473 Token.Packet->Dhcp4.Header.Xid = HTONL(NET_RANDOM (NetRandomInitSeed ()));
474
475 Token.Packet->Dhcp4.Header.Reserved = HTONS ((UINT16)0x8000);
476
477 if (Instance->Dns4CfgData.UseDefaultSetting) {
478 CopyMem (&(Token.Packet->Dhcp4.Header.ClientAddr), &(InterfaceInfo->StationAddress), sizeof (EFI_IPv4_ADDRESS));
479 } else {
480 CopyMem (&(Token.Packet->Dhcp4.Header.ClientAddr), &(Instance->Dns4CfgData.StationIp), sizeof (EFI_IPv4_ADDRESS));
481 }
482
483 CopyMem (Token.Packet->Dhcp4.Header.ClientHwAddr, &(InterfaceInfo->HwAddress), InterfaceInfo->HwAddressSize);
484
485 Token.Packet->Dhcp4.Header.HwAddrLen = (UINT8)(InterfaceInfo->HwAddressSize);
486
487 //
488 // TransmitReceive Token
489 //
490 Status = Dhcp4->TransmitReceive (Dhcp4, &Token);
491 if (EFI_ERROR (Status)) {
492 goto ON_EXIT;
493 }
494
495 //
496 // Poll the packet
497 //
498 do {
499 Status = Mnp->Poll (Mnp);
500 } while (!IsDone);
501
502 //
503 // Parse the ACK to get required information if received done.
504 //
505 if (IsDone && !EFI_ERROR (Token.Status)) {
506 for (Index = 0; Index < Token.ResponseCount; Index++) {
507 Status = ParseDhcp4Ack (Dhcp4, &Token.ResponseList[Index], &DnsServerInfor);
508 if (!EFI_ERROR (Status)) {
509 break;
510 }
511 }
512
513 *DnsServerList = DnsServerInfor.ServerList;
514 } else {
515 Status = Token.Status;
516 }
517
518ON_EXIT:
519
520 if (Data != NULL) {
521 FreePool (Data);
522 }
523
524 for (Index = 0; Index < 2; Index++) {
525 if (ParaList[Index] != NULL) {
526 FreePool (ParaList[Index]);
527 }
528 }
529
530 if (Token.ListenPoints) {
531 FreePool (Token.ListenPoints);
532 }
533
534 if (Token.Packet) {
535 FreePool (Token.Packet);
536 }
537
538 if (Token.ResponseList != NULL) {
539 FreePool (Token.ResponseList);
540 }
541
542 if (Token.CompletionEvent != NULL) {
543 gBS->CloseEvent (Token.CompletionEvent);
544 }
545
546 if (Dhcp4 != NULL) {
547 Dhcp4->Stop (Dhcp4);
548 Dhcp4->Configure (Dhcp4, NULL);
549
550 gBS->CloseProtocol (
551 Dhcp4Handle,
552 &gEfiDhcp4ProtocolGuid,
553 Image,
554 Controller
555 );
556 }
557
558 if (Dhcp4Handle != NULL) {
559 NetLibDestroyServiceChild (
560 Controller,
561 Image,
562 &gEfiDhcp4ServiceBindingProtocolGuid,
563 Dhcp4Handle
564 );
565 }
566
567 if (Mnp != NULL) {
568 Mnp->Configure (Mnp, NULL);
569
570 gBS->CloseProtocol (
571 MnpChildHandle,
572 &gEfiManagedNetworkProtocolGuid,
573 Image,
574 Controller
575 );
576 }
577
578 NetLibDestroyServiceChild (
579 Controller,
580 Image,
581 &gEfiManagedNetworkServiceBindingProtocolGuid,
582 MnpChildHandle
583 );
584
585 return Status;
586}
587
588/**
589 Parse the DHCP ACK to get Dns6 server information.
590
591 @param Image The handle of the driver image.
592 @param Controller The handle of the controller.
593 @param DnsServerCount Retrieved Dns6 server Ip count.
594 @param DnsServerList Retrieved Dns6 server Ip list.
595
596 @retval EFI_SUCCESS The Dns6 information is got from the DHCP ACK.
597 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
598 @retval EFI_NO_MEDIA There was a media error.
599 @retval Others Other errors as indicated.
600
601**/
602EFI_STATUS
603GetDns6ServerFromDhcp6 (
604 IN EFI_HANDLE Image,
605 IN EFI_HANDLE Controller,
606 OUT UINT32 *DnsServerCount,
607 OUT EFI_IPv6_ADDRESS **DnsServerList
608 )
609{
610 EFI_HANDLE Dhcp6Handle;
611 EFI_DHCP6_PROTOCOL *Dhcp6;
612 EFI_STATUS Status;
613 EFI_STATUS TimerStatus;
614 EFI_DHCP6_PACKET_OPTION *Oro;
615 EFI_DHCP6_RETRANSMISSION InfoReqReXmit;
616 EFI_EVENT Timer;
617 EFI_STATUS MediaStatus;
618 DNS6_SERVER_INFOR DnsServerInfor;
619
620 Dhcp6Handle = NULL;
621 Dhcp6 = NULL;
622 Oro = NULL;
623 Timer = NULL;
624
625 ZeroMem (&DnsServerInfor, sizeof (DNS6_SERVER_INFOR));
626
627 DnsServerInfor.ServerCount = DnsServerCount;
628
629 //
630 // Check media status before doing DHCP.
631 //
632 MediaStatus = EFI_SUCCESS;
633 NetLibDetectMediaWaitTimeout (Controller, DNS_CHECK_MEDIA_GET_DHCP_WAITING_TIME, &MediaStatus);
634 if (MediaStatus != EFI_SUCCESS) {
635 return EFI_NO_MEDIA;
636 }
637
638 //
639 // Create a DHCP6 child instance and get the protocol.
640 //
641 Status = NetLibCreateServiceChild (
642 Controller,
643 Image,
644 &gEfiDhcp6ServiceBindingProtocolGuid,
645 &Dhcp6Handle
646 );
647 if (EFI_ERROR (Status)) {
648 return Status;
649 }
650
651 Status = gBS->OpenProtocol (
652 Dhcp6Handle,
653 &gEfiDhcp6ProtocolGuid,
654 (VOID **) &Dhcp6,
655 Image,
656 Controller,
657 EFI_OPEN_PROTOCOL_BY_DRIVER
658 );
659 if (EFI_ERROR (Status)) {
660 goto ON_EXIT;
661 }
662
663 Oro = AllocateZeroPool (sizeof (EFI_DHCP6_PACKET_OPTION) + 1);
664 if (Oro == NULL) {
665 Status = EFI_OUT_OF_RESOURCES;
666 goto ON_EXIT;
667 }
668
669 //
670 // Ask the server to reply with DNS options.
671 // All members in EFI_DHCP6_PACKET_OPTION are in network order.
672 //
673 Oro->OpCode = HTONS (DHCP6_TAG_DNS_REQUEST);
674 Oro->OpLen = HTONS (2);
675 Oro->Data[1] = DHCP6_TAG_DNS_SERVER;
676
677 InfoReqReXmit.Irt = 4;
678 InfoReqReXmit.Mrc = 1;
679 InfoReqReXmit.Mrt = 10;
680 InfoReqReXmit.Mrd = 30;
681
682 Status = Dhcp6->InfoRequest (
683 Dhcp6,
684 TRUE,
685 Oro,
686 0,
687 NULL,
688 &InfoReqReXmit,
689 NULL,
690 ParseDhcp6Ack,
691 &DnsServerInfor
692 );
693 if (Status == EFI_NO_MAPPING) {
694 Status = gBS->CreateEvent (EVT_TIMER, TPL_CALLBACK, NULL, NULL, &Timer);
695 if (EFI_ERROR (Status)) {
696 goto ON_EXIT;
697 }
698
699 Status = gBS->SetTimer (
700 Timer,
701 TimerRelative,
702 DNS_TIME_TO_GETMAP * TICKS_PER_SECOND
703 );
704
705 if (EFI_ERROR (Status)) {
706 goto ON_EXIT;
707 }
708
709 do {
710 TimerStatus = gBS->CheckEvent (Timer);
711 if (!EFI_ERROR (TimerStatus)) {
712 Status = Dhcp6->InfoRequest (
713 Dhcp6,
714 TRUE,
715 Oro,
716 0,
717 NULL,
718 &InfoReqReXmit,
719 NULL,
720 ParseDhcp6Ack,
721 &DnsServerInfor
722 );
723 }
724 } while (TimerStatus == EFI_NOT_READY);
725 }
726
727 *DnsServerList = DnsServerInfor.ServerList;
728
729ON_EXIT:
730
731 if (Oro != NULL) {
732 FreePool (Oro);
733 }
734
735 if (Timer != NULL) {
736 gBS->CloseEvent (Timer);
737 }
738
739 if (Dhcp6 != NULL) {
740 gBS->CloseProtocol (
741 Dhcp6Handle,
742 &gEfiDhcp6ProtocolGuid,
743 Image,
744 Controller
745 );
746 }
747
748 NetLibDestroyServiceChild (
749 Controller,
750 Image,
751 &gEfiDhcp6ServiceBindingProtocolGuid,
752 Dhcp6Handle
753 );
754
755 return Status;
756
757}
758
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette