8725670a8e8a4a51c098dcd7b1e61f067039c021
[mirror_edk2.git] / NetworkPkg / DnsDxe / DnsImpl.c
1 /** @file
2 DnsDxe support functions implementation.
3
4 Copyright (c) 2015, 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 "DnsImpl.h"
16
17 /**
18 Remove TokenEntry from TokenMap.
19
20 @param[in] TokenMap All DNSv4 Token entrys.
21 @param[in] TokenEntry TokenEntry need to be removed.
22
23 @retval EFI_SUCCESS Remove TokenEntry from TokenMap sucessfully.
24 @retval EFI_NOT_FOUND TokenEntry is not found in TokenMap.
25
26 **/
27 EFI_STATUS
28 Dns4RemoveTokenEntry (
29 IN NET_MAP *TokenMap,
30 IN DNS4_TOKEN_ENTRY *TokenEntry
31 )
32 {
33 NET_MAP_ITEM *Item;
34
35 //
36 // Find the TokenEntry first.
37 //
38 Item = NetMapFindKey (TokenMap, (VOID *) TokenEntry);
39
40 if (Item != NULL) {
41 //
42 // Remove the TokenEntry if it's found in the map.
43 //
44 NetMapRemoveItem (TokenMap, Item, NULL);
45
46 return EFI_SUCCESS;
47 }
48
49 return EFI_NOT_FOUND;
50 }
51
52 /**
53 Remove TokenEntry from TokenMap.
54
55 @param[in] TokenMap All DNSv6 Token entrys.
56 @param[in] TokenEntry TokenEntry need to be removed.
57
58 @retval EFI_SUCCESS Remove TokenEntry from TokenMap sucessfully.
59 @retval EFI_NOT_FOUND TokenEntry is not found in TokenMap.
60
61 **/
62 EFI_STATUS
63 Dns6RemoveTokenEntry (
64 IN NET_MAP *TokenMap,
65 IN DNS6_TOKEN_ENTRY *TokenEntry
66 )
67 {
68 NET_MAP_ITEM *Item;
69
70 //
71 // Find the TokenEntry first.
72 //
73 Item = NetMapFindKey (TokenMap, (VOID *) TokenEntry);
74
75 if (Item != NULL) {
76 //
77 // Remove the TokenEntry if it's found in the map.
78 //
79 NetMapRemoveItem (TokenMap, Item, NULL);
80
81 return EFI_SUCCESS;
82 }
83
84 return EFI_NOT_FOUND;
85 }
86
87 /**
88 This function cancle the token specified by Arg in the Map.
89
90 @param[in] Map Pointer to the NET_MAP.
91 @param[in] Item Pointer to the NET_MAP_ITEM.
92 @param[in] Arg Pointer to the token to be cancelled. If NULL, all
93 the tokens in this Map will be cancelled.
94 This parameter is optional and may be NULL.
95
96 @retval EFI_SUCCESS The token is cancelled if Arg is NULL, or the token
97 is not the same as that in the Item, if Arg is not
98 NULL.
99 @retval EFI_ABORTED Arg is not NULL, and the token specified by Arg is
100 cancelled.
101
102 **/
103 EFI_STATUS
104 EFIAPI
105 Dns4CancelTokens (
106 IN NET_MAP *Map,
107 IN NET_MAP_ITEM *Item,
108 IN VOID *Arg OPTIONAL
109 )
110 {
111 DNS4_TOKEN_ENTRY *TokenEntry;
112 NET_BUF *Packet;
113 UDP_IO *UdpIo;
114
115 if ((Arg != NULL) && (Item->Key != Arg)) {
116 return EFI_SUCCESS;
117 }
118
119 if (Item->Value != NULL) {
120 //
121 // If the TokenEntry is a transmit TokenEntry, the corresponding Packet is recorded in
122 // Item->Value.
123 //
124 Packet = (NET_BUF *) (Item->Value);
125 UdpIo = (UDP_IO *) (*((UINTN *) &Packet->ProtoData[0]));
126
127 UdpIoCancelSentDatagram (UdpIo, Packet);
128 }
129
130 //
131 // Remove TokenEntry from Dns4TxTokens.
132 //
133 TokenEntry = (DNS4_TOKEN_ENTRY *) Item->Key;
134 if (Dns4RemoveTokenEntry (Map, TokenEntry) == EFI_SUCCESS) {
135 TokenEntry->Token->Status = EFI_ABORTED;
136 gBS->SignalEvent (TokenEntry->Token->Event);
137 DispatchDpc ();
138 }
139
140 if (Arg != NULL) {
141 return EFI_ABORTED;
142 }
143
144 return EFI_SUCCESS;
145 }
146
147 /**
148 This function cancle the token specified by Arg in the Map.
149
150 @param[in] Map Pointer to the NET_MAP.
151 @param[in] Item Pointer to the NET_MAP_ITEM.
152 @param[in] Arg Pointer to the token to be cancelled. If NULL, all
153 the tokens in this Map will be cancelled.
154 This parameter is optional and may be NULL.
155
156 @retval EFI_SUCCESS The token is cancelled if Arg is NULL, or the token
157 is not the same as that in the Item, if Arg is not
158 NULL.
159 @retval EFI_ABORTED Arg is not NULL, and the token specified by Arg is
160 cancelled.
161
162 **/
163 EFI_STATUS
164 EFIAPI
165 Dns6CancelTokens (
166 IN NET_MAP *Map,
167 IN NET_MAP_ITEM *Item,
168 IN VOID *Arg OPTIONAL
169 )
170 {
171 DNS6_TOKEN_ENTRY *TokenEntry;
172 NET_BUF *Packet;
173 UDP_IO *UdpIo;
174
175 if ((Arg != NULL) && (Item->Key != Arg)) {
176 return EFI_SUCCESS;
177 }
178
179 if (Item->Value != NULL) {
180 //
181 // If the TokenEntry is a transmit TokenEntry, the corresponding Packet is recorded in
182 // Item->Value.
183 //
184 Packet = (NET_BUF *) (Item->Value);
185 UdpIo = (UDP_IO *) (*((UINTN *) &Packet->ProtoData[0]));
186
187 UdpIoCancelSentDatagram (UdpIo, Packet);
188 }
189
190 //
191 // Remove TokenEntry from Dns6TxTokens.
192 //
193 TokenEntry = (DNS6_TOKEN_ENTRY *) Item->Key;
194 if (Dns6RemoveTokenEntry (Map, TokenEntry) == EFI_SUCCESS) {
195 TokenEntry->Token->Status = EFI_ABORTED;
196 gBS->SignalEvent (TokenEntry->Token->Event);
197 DispatchDpc ();
198 }
199
200 if (Arg != NULL) {
201 return EFI_ABORTED;
202 }
203
204 return EFI_SUCCESS;
205 }
206
207 /**
208 Get the TokenEntry from the TokensMap.
209
210 @param[in] TokensMap All DNSv4 Token entrys
211 @param[in] Token Pointer to the token to be get.
212 @param[out] TokenEntry Pointer to TokenEntry corresponding Token.
213
214 @retval EFI_SUCCESS Get the TokenEntry from the TokensMap sucessfully.
215 @retval EFI_NOT_FOUND TokenEntry is not found in TokenMap.
216
217 **/
218 EFI_STATUS
219 EFIAPI
220 GetDns4TokenEntry (
221 IN NET_MAP *TokensMap,
222 IN EFI_DNS4_COMPLETION_TOKEN *Token,
223 OUT DNS4_TOKEN_ENTRY **TokenEntry
224 )
225 {
226 LIST_ENTRY *Entry;
227
228 NET_MAP_ITEM *Item;
229
230 NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {
231 Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
232 *TokenEntry = (DNS4_TOKEN_ENTRY *) (Item->Key);
233 if ((*TokenEntry)->Token == Token) {
234 return EFI_SUCCESS;
235 }
236 }
237
238 *TokenEntry = NULL;
239
240 return EFI_NOT_FOUND;
241 }
242
243 /**
244 Get the TokenEntry from the TokensMap.
245
246 @param[in] TokensMap All DNSv6 Token entrys
247 @param[in] Token Pointer to the token to be get.
248 @param[out] TokenEntry Pointer to TokenEntry corresponding Token.
249
250 @retval EFI_SUCCESS Get the TokenEntry from the TokensMap sucessfully.
251 @retval EFI_NOT_FOUND TokenEntry is not found in TokenMap.
252
253 **/
254 EFI_STATUS
255 EFIAPI
256 GetDns6TokenEntry (
257 IN NET_MAP *TokensMap,
258 IN EFI_DNS6_COMPLETION_TOKEN *Token,
259 OUT DNS6_TOKEN_ENTRY **TokenEntry
260 )
261 {
262 LIST_ENTRY *Entry;
263
264 NET_MAP_ITEM *Item;
265
266 NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {
267 Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
268 *TokenEntry = (DNS6_TOKEN_ENTRY *) (Item->Key);
269 if ((*TokenEntry)->Token == Token) {
270 return EFI_SUCCESS;
271 }
272 }
273
274 *TokenEntry =NULL;
275
276 return EFI_NOT_FOUND;
277 }
278
279 /**
280 Cancel DNS4 tokens from the DNS4 instance.
281
282 @param[in] Instance Pointer to the DNS instance context data.
283 @param[in] Token Pointer to the token to be canceled. If NULL, all
284 tokens in this instance will be cancelled.
285 This parameter is optional and may be NULL.
286
287 @retval EFI_SUCCESS The Token is cancelled.
288 @retval EFI_NOT_FOUND The Token is not found.
289
290 **/
291 EFI_STATUS
292 Dns4InstanceCancelToken (
293 IN DNS_INSTANCE *Instance,
294 IN EFI_DNS4_COMPLETION_TOKEN *Token
295 )
296 {
297 EFI_STATUS Status;
298 DNS4_TOKEN_ENTRY *TokenEntry;
299
300 TokenEntry = NULL;
301
302 if(Token != NULL ) {
303 Status = GetDns4TokenEntry (&Instance->Dns4TxTokens, Token, &TokenEntry);
304 if (EFI_ERROR (Status)) {
305 return Status;
306 }
307 } else {
308 TokenEntry = NULL;
309 }
310
311 //
312 // Cancel this TokenEntry from the Dns4TxTokens map.
313 //
314 Status = NetMapIterate (&Instance->Dns4TxTokens, Dns4CancelTokens, TokenEntry);
315
316 if ((TokenEntry != NULL) && (Status == EFI_ABORTED)) {
317 //
318 // If Token isn't NULL and Status is EFI_ABORTED, the token is cancelled from
319 // the Dns4TxTokens and returns success.
320 //
321 if (NetMapIsEmpty (&Instance->Dns4TxTokens)) {
322 Instance->UdpIo->Protocol.Udp4->Cancel (Instance->UdpIo->Protocol.Udp4, &Instance->UdpIo->RecvRequest->Token.Udp4);
323 }
324 return EFI_SUCCESS;
325 }
326
327 ASSERT ((TokenEntry != NULL) || (0 == NetMapGetCount (&Instance->Dns4TxTokens)));
328
329 if (NetMapIsEmpty (&Instance->Dns4TxTokens)) {
330 Instance->UdpIo->Protocol.Udp4->Cancel (Instance->UdpIo->Protocol.Udp4, &Instance->UdpIo->RecvRequest->Token.Udp4);
331 }
332
333 return EFI_SUCCESS;
334 }
335
336 /**
337 Cancel DNS6 tokens from the DNS6 instance.
338
339 @param[in] Instance Pointer to the DNS instance context data.
340 @param[in] Token Pointer to the token to be canceled. If NULL, all
341 tokens in this instance will be cancelled.
342 This parameter is optional and may be NULL.
343
344 @retval EFI_SUCCESS The Token is cancelled.
345 @retval EFI_NOT_FOUND The Token is not found.
346
347 **/
348 EFI_STATUS
349 Dns6InstanceCancelToken (
350 IN DNS_INSTANCE *Instance,
351 IN EFI_DNS6_COMPLETION_TOKEN *Token
352 )
353 {
354 EFI_STATUS Status;
355 DNS6_TOKEN_ENTRY *TokenEntry;
356
357 TokenEntry = NULL;
358
359 if(Token != NULL ) {
360 Status = GetDns6TokenEntry (&Instance->Dns6TxTokens, Token, &TokenEntry);
361 if (EFI_ERROR (Status)) {
362 return Status;
363 }
364 } else {
365 TokenEntry = NULL;
366 }
367
368 //
369 // Cancel this TokenEntry from the Dns6TxTokens map.
370 //
371 Status = NetMapIterate (&Instance->Dns6TxTokens, Dns6CancelTokens, TokenEntry);
372
373 if ((TokenEntry != NULL) && (Status == EFI_ABORTED)) {
374 //
375 // If Token isn't NULL and Status is EFI_ABORTED, the token is cancelled from
376 // the Dns6TxTokens and returns success.
377 //
378 if (NetMapIsEmpty (&Instance->Dns6TxTokens)) {
379 Instance->UdpIo->Protocol.Udp6->Cancel (Instance->UdpIo->Protocol.Udp6, &Instance->UdpIo->RecvRequest->Token.Udp6);
380 }
381 return EFI_SUCCESS;
382 }
383
384 ASSERT ((TokenEntry != NULL) || (0 == NetMapGetCount (&Instance->Dns6TxTokens)));
385
386 if (NetMapIsEmpty (&Instance->Dns6TxTokens)) {
387 Instance->UdpIo->Protocol.Udp6->Cancel (Instance->UdpIo->Protocol.Udp6, &Instance->UdpIo->RecvRequest->Token.Udp6);
388 }
389
390 return EFI_SUCCESS;
391 }
392
393 /**
394 Free the resource related to the configure parameters.
395
396 @param Config The DNS configure data
397
398 **/
399 VOID
400 Dns4CleanConfigure (
401 IN OUT EFI_DNS4_CONFIG_DATA *Config
402 )
403 {
404 if (Config->DnsServerList != NULL) {
405 FreePool (Config->DnsServerList);
406 }
407
408 ZeroMem (Config, sizeof (EFI_DNS4_CONFIG_DATA));
409 }
410
411 /**
412 Free the resource related to the configure parameters.
413
414 @param Config The DNS configure data
415
416 **/
417 VOID
418 Dns6CleanConfigure (
419 IN OUT EFI_DNS6_CONFIG_DATA *Config
420 )
421 {
422 if (Config->DnsServerList != NULL) {
423 FreePool (Config->DnsServerList);
424 }
425
426 ZeroMem (Config, sizeof (EFI_DNS6_CONFIG_DATA));
427 }
428
429 /**
430 Allocate memory for configure parameter such as timeout value for Dst,
431 then copy the configure parameter from Src to Dst.
432
433 @param[out] Dst The destination DHCP configure data.
434 @param[in] Src The source DHCP configure data.
435
436 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
437 @retval EFI_SUCCESS The configure is copied.
438
439 **/
440 EFI_STATUS
441 Dns4CopyConfigure (
442 OUT EFI_DNS4_CONFIG_DATA *Dst,
443 IN EFI_DNS4_CONFIG_DATA *Src
444 )
445 {
446 UINTN Len;
447 UINT32 Index;
448
449 CopyMem (Dst, Src, sizeof (*Dst));
450 Dst->DnsServerList = NULL;
451
452 //
453 // Allocate a memory then copy DnsServerList to it
454 //
455 if (Src->DnsServerList != NULL) {
456 Len = Src->DnsServerListCount * sizeof (EFI_IPv4_ADDRESS);
457 Dst->DnsServerList = AllocatePool (Len);
458 if (Dst->DnsServerList == NULL) {
459 Dns4CleanConfigure (Dst);
460 return EFI_OUT_OF_RESOURCES;
461 }
462
463 for (Index = 0; Index < Src->DnsServerListCount; Index++) {
464 CopyMem (&Dst->DnsServerList[Index], &Src->DnsServerList[Index], sizeof (EFI_IPv4_ADDRESS));
465 }
466 }
467
468 return EFI_SUCCESS;
469 }
470
471 /**
472 Allocate memory for configure parameter such as timeout value for Dst,
473 then copy the configure parameter from Src to Dst.
474
475 @param[out] Dst The destination DHCP configure data.
476 @param[in] Src The source DHCP configure data.
477
478 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
479 @retval EFI_SUCCESS The configure is copied.
480
481 **/
482 EFI_STATUS
483 Dns6CopyConfigure (
484 OUT EFI_DNS6_CONFIG_DATA *Dst,
485 IN EFI_DNS6_CONFIG_DATA *Src
486 )
487 {
488 UINTN Len;
489 UINT32 Index;
490
491 CopyMem (Dst, Src, sizeof (*Dst));
492 Dst->DnsServerList = NULL;
493
494 //
495 // Allocate a memory then copy DnsServerList to it
496 //
497 if (Src->DnsServerList != NULL) {
498 Len = Src->DnsServerCount * sizeof (EFI_IPv6_ADDRESS);
499 Dst->DnsServerList = AllocatePool (Len);
500 if (Dst->DnsServerList == NULL) {
501 Dns6CleanConfigure (Dst);
502 return EFI_OUT_OF_RESOURCES;
503 }
504
505 for (Index = 0; Index < Src->DnsServerCount; Index++) {
506 CopyMem (&Dst->DnsServerList[Index], &Src->DnsServerList[Index], sizeof (EFI_IPv6_ADDRESS));
507 }
508 }
509
510 return EFI_SUCCESS;
511 }
512
513 /**
514 Callback of Dns packet. Does nothing.
515
516 @param Arg The context.
517
518 **/
519 VOID
520 EFIAPI
521 DnsDummyExtFree (
522 IN VOID *Arg
523 )
524 {
525 }
526
527 /**
528 Poll the UDP to get the IP4 default address, which may be retrieved
529 by DHCP.
530
531 The default time out value is 5 seconds. If IP has retrieved the default address,
532 the UDP is reconfigured.
533
534 @param Instance The DNS instance
535 @param UdpIo The UDP_IO to poll
536 @param UdpCfgData The UDP configure data to reconfigure the UDP_IO
537
538 @retval TRUE The default address is retrieved and UDP is reconfigured.
539 @retval FALSE Some error occured.
540
541 **/
542 BOOLEAN
543 Dns4GetMapping (
544 IN DNS_INSTANCE *Instance,
545 IN UDP_IO *UdpIo,
546 IN EFI_UDP4_CONFIG_DATA *UdpCfgData
547 )
548 {
549 DNS_SERVICE *Service;
550 EFI_IP4_MODE_DATA Ip4Mode;
551 EFI_UDP4_PROTOCOL *Udp;
552 EFI_STATUS Status;
553
554 ASSERT (Instance->Dns4CfgData.UseDefaultSetting);
555
556 Service = Instance->Service;
557 Udp = UdpIo->Protocol.Udp4;
558
559 Status = gBS->SetTimer (
560 Service->TimerToGetMap,
561 TimerRelative,
562 DNS_TIME_TO_GETMAP * TICKS_PER_SECOND
563 );
564 if (EFI_ERROR (Status)) {
565 return FALSE;
566 }
567
568 while (!EFI_ERROR (gBS->CheckEvent (Service->TimerToGetMap))) {
569 Udp->Poll (Udp);
570
571 if (!EFI_ERROR (Udp->GetModeData (Udp, NULL, &Ip4Mode, NULL, NULL)) &&
572 Ip4Mode.IsConfigured) {
573
574 Udp->Configure (Udp, NULL);
575 return (BOOLEAN) (Udp->Configure (Udp, UdpCfgData) == EFI_SUCCESS);
576 }
577 }
578
579 return FALSE;
580 }
581
582 /**
583 Configure the opened Udp6 instance until the corresponding Ip6 instance
584 has been configured.
585
586 @param Instance The DNS instance
587 @param UdpIo The UDP_IO to poll
588 @param UdpCfgData The UDP configure data to reconfigure the UDP_IO
589
590 @retval TRUE Configure the Udp6 instance successfully.
591 @retval FALSE Some error occured.
592
593 **/
594 BOOLEAN
595 Dns6GetMapping (
596 IN DNS_INSTANCE *Instance,
597 IN UDP_IO *UdpIo,
598 IN EFI_UDP6_CONFIG_DATA *UdpCfgData
599 )
600 {
601 DNS_SERVICE *Service;
602 EFI_IP6_MODE_DATA Ip6Mode;
603 EFI_UDP6_PROTOCOL *Udp;
604 EFI_STATUS Status;
605
606 Service = Instance->Service;
607 Udp = UdpIo->Protocol.Udp6;
608
609 Status = gBS->SetTimer (
610 Service->TimerToGetMap,
611 TimerRelative,
612 DNS_TIME_TO_GETMAP * TICKS_PER_SECOND
613 );
614 if (EFI_ERROR (Status)) {
615 return FALSE;
616 }
617
618 while (!EFI_ERROR (gBS->CheckEvent (Service->TimerToGetMap))) {
619 Udp->Poll (Udp);
620
621 if (!EFI_ERROR (Udp->GetModeData (Udp, NULL, &Ip6Mode, NULL, NULL)) &&
622 Ip6Mode.IsConfigured) {
623
624 Udp->Configure (Udp, NULL);
625 return (BOOLEAN) (Udp->Configure (Udp, UdpCfgData) == EFI_SUCCESS);
626 }
627 }
628
629 return FALSE;
630 }
631
632 /**
633 Configure the UDP.
634
635 @param Instance The DNS session
636 @param UdpIo The UDP_IO instance
637
638 @retval EFI_SUCCESS The UDP is successfully configured for the
639 session.
640
641 **/
642 EFI_STATUS
643 Dns4ConfigUdp (
644 IN DNS_INSTANCE *Instance,
645 IN UDP_IO *UdpIo
646 )
647 {
648 EFI_DNS4_CONFIG_DATA *Config;
649 EFI_UDP4_CONFIG_DATA UdpConfig;
650 EFI_STATUS Status;
651
652 Config = &Instance->Dns4CfgData;
653
654 UdpConfig.AcceptBroadcast = FALSE;
655 UdpConfig.AcceptPromiscuous = FALSE;
656 UdpConfig.AcceptAnyPort = FALSE;
657 UdpConfig.AllowDuplicatePort = FALSE;
658 UdpConfig.TypeOfService = 0;
659 UdpConfig.TimeToLive = 128;
660 UdpConfig.DoNotFragment = FALSE;
661 UdpConfig.ReceiveTimeout = 0;
662 UdpConfig.TransmitTimeout = 0;
663 UdpConfig.UseDefaultAddress = Config->UseDefaultSetting;
664 UdpConfig.SubnetMask = Config->SubnetMask;
665 UdpConfig.StationPort = Config->LocalPort;
666 UdpConfig.RemotePort = DNS_SERVER_PORT;
667
668 CopyMem (&UdpConfig.StationAddress, &Config->StationIp, sizeof (EFI_IPv4_ADDRESS));
669 CopyMem (&UdpConfig.RemoteAddress, &Instance->SessionDnsServer.v4, sizeof (EFI_IPv4_ADDRESS));
670
671 Status = UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, &UdpConfig);
672
673 if ((Status == EFI_NO_MAPPING) && Dns4GetMapping (Instance, UdpIo, &UdpConfig)) {
674 return EFI_SUCCESS;
675 }
676
677 return Status;
678 }
679
680 /**
681 Configure the UDP.
682
683 @param Instance The DNS session
684 @param UdpIo The UDP_IO instance
685
686 @retval EFI_SUCCESS The UDP is successfully configured for the
687 session.
688
689 **/
690 EFI_STATUS
691 Dns6ConfigUdp (
692 IN DNS_INSTANCE *Instance,
693 IN UDP_IO *UdpIo
694 )
695 {
696 EFI_DNS6_CONFIG_DATA *Config;
697 EFI_UDP6_CONFIG_DATA UdpConfig;
698 EFI_STATUS Status;
699
700 Config = &Instance->Dns6CfgData;
701
702 UdpConfig.AcceptPromiscuous = FALSE;
703 UdpConfig.AcceptAnyPort = FALSE;
704 UdpConfig.AllowDuplicatePort = FALSE;
705 UdpConfig.TrafficClass = 0;
706 UdpConfig.HopLimit = 128;
707 UdpConfig.ReceiveTimeout = 0;
708 UdpConfig.TransmitTimeout = 0;
709 UdpConfig.StationPort = Config->LocalPort;
710 UdpConfig.RemotePort = DNS_SERVER_PORT;
711 CopyMem (&UdpConfig.StationAddress, &Config->StationIp, sizeof (EFI_IPv6_ADDRESS));
712 CopyMem (&UdpConfig.RemoteAddress, &Instance->SessionDnsServer.v6, sizeof (EFI_IPv6_ADDRESS));
713
714 Status = UdpIo->Protocol.Udp6->Configure (UdpIo->Protocol.Udp6, &UdpConfig);
715
716 if ((Status == EFI_NO_MAPPING) && Dns6GetMapping (Instance, UdpIo, &UdpConfig)) {
717 return EFI_SUCCESS;
718 }
719
720 return Status;
721 }
722
723 /**
724 Update Dns4 cache to shared list of caches of all DNSv4 instances.
725
726 @param Dns4CacheList All Dns4 cache list.
727 @param DeleteFlag If FALSE, this function is to add one entry to the DNS Cache.
728 If TRUE, this function will delete matching DNS Cache entry.
729 @param Override If TRUE, the matching DNS cache entry will be overwritten with the supplied parameter.
730 If FALSE, EFI_ACCESS_DENIED will be returned if the entry to be added is already exists.
731 @param DnsCacheEntry Entry Pointer to DNS Cache entry.
732
733 @retval EFI_SUCCESS Update Dns4 cache successfully.
734 @retval Others Failed to update Dns4 cache.
735
736 **/
737 EFI_STATUS
738 EFIAPI
739 UpdateDns4Cache (
740 IN LIST_ENTRY *Dns4CacheList,
741 IN BOOLEAN DeleteFlag,
742 IN BOOLEAN Override,
743 IN EFI_DNS4_CACHE_ENTRY DnsCacheEntry
744 )
745 {
746 DNS4_CACHE *NewDnsCache;
747 DNS4_CACHE *Item;
748 LIST_ENTRY *Entry;
749 LIST_ENTRY *Next;
750
751 NewDnsCache = NULL;
752 Item = NULL;
753
754 //
755 // Search the database for the matching EFI_DNS_CACHE_ENTRY
756 //
757 NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns4CacheList) {
758 Item = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);
759 if (StrCmp (DnsCacheEntry.HostName, Item->DnsCache.HostName) == 0 && \
760 CompareMem (DnsCacheEntry.IpAddress, Item->DnsCache.IpAddress, sizeof (EFI_IPv4_ADDRESS)) == 0) {
761 //
762 // This is the Dns cache entry
763 //
764 if (DeleteFlag) {
765 //
766 // Delete matching DNS Cache entry
767 //
768 RemoveEntryList (&Item->AllCacheLink);
769
770 return EFI_SUCCESS;
771 } else if (Override) {
772 //
773 // Update this one
774 //
775 Item->DnsCache.Timeout = DnsCacheEntry.Timeout;
776
777 return EFI_SUCCESS;
778 }else {
779 return EFI_ACCESS_DENIED;
780 }
781 }
782 }
783
784 //
785 // Add new one
786 //
787 NewDnsCache = AllocatePool (sizeof (DNS4_CACHE));
788 if (NewDnsCache == NULL) {
789 return EFI_OUT_OF_RESOURCES;
790 }
791
792 InitializeListHead (&NewDnsCache->AllCacheLink);
793
794 NewDnsCache->DnsCache.HostName = AllocatePool (StrSize (DnsCacheEntry.HostName));
795 if (NewDnsCache->DnsCache.HostName == NULL) {
796 return EFI_OUT_OF_RESOURCES;
797 }
798
799 CopyMem (NewDnsCache->DnsCache.HostName, DnsCacheEntry.HostName, StrSize (DnsCacheEntry.HostName));
800
801 NewDnsCache->DnsCache.IpAddress = AllocatePool (sizeof (EFI_IPv4_ADDRESS));
802 if (NewDnsCache->DnsCache.IpAddress == NULL) {
803 return EFI_OUT_OF_RESOURCES;
804 }
805
806 CopyMem (NewDnsCache->DnsCache.IpAddress, DnsCacheEntry.IpAddress, sizeof (EFI_IPv4_ADDRESS));
807
808 NewDnsCache->DnsCache.Timeout = DnsCacheEntry.Timeout;
809
810 InsertTailList (Dns4CacheList, &NewDnsCache->AllCacheLink);
811
812 return EFI_SUCCESS;
813 }
814
815 /**
816 Update Dns6 cache to shared list of caches of all DNSv6 instances.
817
818 @param Dns6CacheList All Dns6 cache list.
819 @param DeleteFlag If FALSE, this function is to add one entry to the DNS Cache.
820 If TRUE, this function will delete matching DNS Cache entry.
821 @param Override If TRUE, the matching DNS cache entry will be overwritten with the supplied parameter.
822 If FALSE, EFI_ACCESS_DENIED will be returned if the entry to be added is already exists.
823 @param DnsCacheEntry Entry Pointer to DNS Cache entry.
824
825 @retval EFI_SUCCESS Update Dns6 cache successfully.
826 @retval Others Failed to update Dns6 cache.
827 **/
828 EFI_STATUS
829 EFIAPI
830 UpdateDns6Cache (
831 IN LIST_ENTRY *Dns6CacheList,
832 IN BOOLEAN DeleteFlag,
833 IN BOOLEAN Override,
834 IN EFI_DNS6_CACHE_ENTRY DnsCacheEntry
835 )
836 {
837 DNS6_CACHE *NewDnsCache;
838 DNS6_CACHE *Item;
839 LIST_ENTRY *Entry;
840 LIST_ENTRY *Next;
841
842 NewDnsCache = NULL;
843 Item = NULL;
844
845 //
846 // Search the database for the matching EFI_DNS_CACHE_ENTRY
847 //
848 NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns6CacheList) {
849 Item = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);
850 if (StrCmp (DnsCacheEntry.HostName, Item->DnsCache.HostName) == 0 && \
851 CompareMem (DnsCacheEntry.IpAddress, Item->DnsCache.IpAddress, sizeof (EFI_IPv6_ADDRESS)) == 0) {
852 //
853 // This is the Dns cache entry
854 //
855 if (DeleteFlag) {
856 //
857 // Delete matching DNS Cache entry
858 //
859 RemoveEntryList (&Item->AllCacheLink);
860
861 return EFI_SUCCESS;
862 } else if (Override) {
863 //
864 // Update this one
865 //
866 Item->DnsCache.Timeout = DnsCacheEntry.Timeout;
867
868 return EFI_SUCCESS;
869 }else {
870 return EFI_ACCESS_DENIED;
871 }
872 }
873 }
874
875 //
876 // Add new one
877 //
878 NewDnsCache = AllocatePool (sizeof (DNS6_CACHE));
879 if (NewDnsCache == NULL) {
880 return EFI_OUT_OF_RESOURCES;
881 }
882
883 InitializeListHead (&NewDnsCache->AllCacheLink);
884
885 NewDnsCache->DnsCache.HostName = AllocatePool (StrSize (DnsCacheEntry.HostName));
886 if (NewDnsCache->DnsCache.HostName == NULL) {
887 return EFI_OUT_OF_RESOURCES;
888 }
889
890 CopyMem (NewDnsCache->DnsCache.HostName, DnsCacheEntry.HostName, StrSize (DnsCacheEntry.HostName));
891
892 NewDnsCache->DnsCache.IpAddress = AllocatePool (sizeof (EFI_IPv6_ADDRESS));
893 if (NewDnsCache->DnsCache.IpAddress == NULL) {
894 return EFI_OUT_OF_RESOURCES;
895 }
896
897 CopyMem (NewDnsCache->DnsCache.IpAddress, DnsCacheEntry.IpAddress, sizeof (EFI_IPv6_ADDRESS));
898
899 NewDnsCache->DnsCache.Timeout = DnsCacheEntry.Timeout;
900
901 InsertTailList (Dns6CacheList, &NewDnsCache->AllCacheLink);
902
903 return EFI_SUCCESS;
904 }
905
906 /**
907 Add Dns4 ServerIp to common list of addresses of all configured DNSv4 server.
908
909 @param Dns4ServerList Common list of addresses of all configured DNSv4 server.
910 @param ServerIp DNS server Ip.
911
912 @retval EFI_SUCCESS Add Dns4 ServerIp to common list successfully.
913 @retval Others Failed to add Dns4 ServerIp to common list.
914
915 **/
916 EFI_STATUS
917 EFIAPI
918 AddDns4ServerIp (
919 IN LIST_ENTRY *Dns4ServerList,
920 IN EFI_IPv4_ADDRESS ServerIp
921 )
922 {
923 DNS4_SERVER_IP *NewServerIp;
924 DNS4_SERVER_IP *Item;
925 LIST_ENTRY *Entry;
926 LIST_ENTRY *Next;
927
928 NewServerIp = NULL;
929 Item = NULL;
930
931 //
932 // Search the database for the matching ServerIp
933 //
934 NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns4ServerList) {
935 Item = NET_LIST_USER_STRUCT (Entry, DNS4_SERVER_IP, AllServerLink);
936 if (CompareMem (&Item->Dns4ServerIp, &ServerIp, sizeof (EFI_IPv4_ADDRESS)) == 0) {
937 //
938 // Already done.
939 //
940 return EFI_SUCCESS;
941 }
942 }
943
944 //
945 // Add new one
946 //
947 NewServerIp = AllocatePool (sizeof (DNS4_SERVER_IP));
948 if (NewServerIp == NULL) {
949 return EFI_OUT_OF_RESOURCES;
950 }
951
952 InitializeListHead (&NewServerIp->AllServerLink);
953
954 CopyMem (&NewServerIp->Dns4ServerIp, &ServerIp, sizeof (EFI_IPv4_ADDRESS));
955
956 InsertTailList (Dns4ServerList, &NewServerIp->AllServerLink);
957
958 return EFI_SUCCESS;
959 }
960
961 /**
962 Add Dns6 ServerIp to common list of addresses of all configured DNSv6 server.
963
964 @param Dns6ServerList Common list of addresses of all configured DNSv6 server.
965 @param ServerIp DNS server Ip.
966
967 @retval EFI_SUCCESS Add Dns6 ServerIp to common list successfully.
968 @retval Others Failed to add Dns6 ServerIp to common list.
969
970 **/
971 EFI_STATUS
972 EFIAPI
973 AddDns6ServerIp (
974 IN LIST_ENTRY *Dns6ServerList,
975 IN EFI_IPv6_ADDRESS ServerIp
976 )
977 {
978 DNS6_SERVER_IP *NewServerIp;
979 DNS6_SERVER_IP *Item;
980 LIST_ENTRY *Entry;
981 LIST_ENTRY *Next;
982
983 NewServerIp = NULL;
984 Item = NULL;
985
986 //
987 // Search the database for the matching ServerIp
988 //
989 NET_LIST_FOR_EACH_SAFE (Entry, Next, Dns6ServerList) {
990 Item = NET_LIST_USER_STRUCT (Entry, DNS6_SERVER_IP, AllServerLink);
991 if (CompareMem (&Item->Dns6ServerIp, &ServerIp, sizeof (EFI_IPv6_ADDRESS)) == 0) {
992 //
993 // Already done.
994 //
995 return EFI_SUCCESS;
996 }
997 }
998
999 //
1000 // Add new one
1001 //
1002 NewServerIp = AllocatePool (sizeof (DNS6_SERVER_IP));
1003 if (NewServerIp == NULL) {
1004 return EFI_OUT_OF_RESOURCES;
1005 }
1006
1007 InitializeListHead (&NewServerIp->AllServerLink);
1008
1009 CopyMem (&NewServerIp->Dns6ServerIp, &ServerIp, sizeof (EFI_IPv6_ADDRESS));
1010
1011 InsertTailList (Dns6ServerList, &NewServerIp->AllServerLink);
1012
1013 return EFI_SUCCESS;
1014 }
1015
1016 /**
1017 Fill QName for IP querying. QName is a domain name represented as
1018 a sequence of labels, where each label consists of a length octet
1019 followed by that number of octets. The domain name terminates with
1020 the zero length octet for the null label of the root. Caller should
1021 take responsibility to the buffer in QName.
1022
1023 @param HostName Queried HostName
1024
1025 @retval NULL Failed to fill QName.
1026 @return QName filled successfully.
1027
1028 **/
1029 UINT8 *
1030 EFIAPI
1031 DnsFillinQNameForQueryIp (
1032 IN CHAR16 *HostName
1033 )
1034 {
1035 CHAR8 *QueryName;
1036 CHAR8 *Header;
1037 CHAR8 *Tail;
1038 UINTN Len;
1039 UINTN Index;
1040
1041 QueryName = NULL;
1042 Header = NULL;
1043 Tail = NULL;
1044
1045 QueryName = AllocateZeroPool (DNS_DEFAULT_BLKSIZE);
1046 if (QueryName == NULL) {
1047 return NULL;
1048 }
1049
1050 Header = QueryName;
1051 Tail = Header + 1;
1052 Len = 0;
1053 for (Index = 0; HostName[Index] != 0; Index++) {
1054 *Tail = (CHAR8) HostName[Index];
1055 if (*Tail == '.') {
1056 *Header = (CHAR8) Len;
1057 Header = Tail;
1058 Tail ++;
1059 Len = 0;
1060 } else {
1061 Tail++;
1062 Len++;
1063 }
1064 }
1065 *Header = (CHAR8) Len;
1066 *Tail = 0;
1067
1068 return QueryName;
1069 }
1070
1071 /**
1072 Find out whether the response is valid or invalid.
1073
1074 @param TokensMap All DNS transmittal Tokens entry.
1075 @param Identification Identification for queried packet.
1076 @param Type Type for queried packet.
1077 @param Item Return corresponding Token entry.
1078
1079 @retval TRUE The response is valid.
1080 @retval FALSE The response is invalid.
1081
1082 **/
1083 BOOLEAN
1084 IsValidDnsResponse (
1085 IN NET_MAP *TokensMap,
1086 IN UINT16 Identification,
1087 IN UINT16 Type,
1088 OUT NET_MAP_ITEM **Item
1089 )
1090 {
1091 LIST_ENTRY *Entry;
1092
1093 NET_BUF *Packet;
1094 UINT8 *TxString;
1095 DNS_HEADER *DnsHeader;
1096 CHAR8 *QueryName;
1097 DNS_QUERY_SECTION *QuerySection;
1098
1099 NET_LIST_FOR_EACH (Entry, &TokensMap->Used) {
1100 *Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
1101 Packet = (NET_BUF *) ((*Item)->Value);
1102 if (Packet == NULL){
1103
1104 continue;
1105 } else {
1106 TxString = NetbufGetByte (Packet, 0, NULL);
1107 ASSERT (TxString != NULL);
1108 DnsHeader = (DNS_HEADER *) TxString;
1109 QueryName = (CHAR8 *) (TxString + sizeof (*DnsHeader));
1110 QuerySection = (DNS_QUERY_SECTION *) (QueryName + AsciiStrLen (QueryName) + 1);
1111
1112 DnsHeader->Identification = NTOHS (DnsHeader->Identification);
1113 QuerySection->Type = NTOHS (QuerySection->Type);
1114
1115 if (DnsHeader->Identification == Identification && QuerySection->Type == Type) {
1116 return TRUE;
1117 }
1118 }
1119 }
1120
1121 *Item =NULL;
1122
1123 return FALSE;
1124 }
1125
1126 /**
1127 Parse Dns Response.
1128
1129 @param Instance The DNS instance
1130 @param RxString Received buffer.
1131 @param Completed Flag to indicate that Dns response is valid.
1132
1133 @retval EFI_SUCCESS Parse Dns Response successfully.
1134 @retval Others Failed to parse Dns Response.
1135
1136 **/
1137 EFI_STATUS
1138 ParseDnsResponse (
1139 IN OUT DNS_INSTANCE *Instance,
1140 IN UINT8 *RxString,
1141 OUT BOOLEAN *Completed
1142 )
1143 {
1144 DNS_HEADER *DnsHeader;
1145
1146 CHAR8 *QueryName;
1147 DNS_QUERY_SECTION *QuerySection;
1148
1149 CHAR8 *AnswerName;
1150 DNS_ANSWER_SECTION *AnswerSection;
1151 UINT8 *AnswerData;
1152
1153 NET_MAP_ITEM *Item;
1154 DNS4_TOKEN_ENTRY *Dns4TokenEntry;
1155 DNS6_TOKEN_ENTRY *Dns6TokenEntry;
1156
1157 UINT32 IpCount;
1158 UINT32 RRCount;
1159 UINT32 AnswerSectionNum;
1160
1161 EFI_IPv4_ADDRESS *HostAddr4;
1162 EFI_IPv6_ADDRESS *HostAddr6;
1163
1164 EFI_DNS4_CACHE_ENTRY *Dns4CacheEntry;
1165 EFI_DNS6_CACHE_ENTRY *Dns6CacheEntry;
1166
1167 DNS_RESOURCE_RECORD *Dns4RR;
1168 DNS6_RESOURCE_RECORD *Dns6RR;
1169
1170 EFI_STATUS Status;
1171
1172 EFI_TPL OldTpl;
1173
1174 Item = NULL;
1175 Dns4TokenEntry = NULL;
1176 Dns6TokenEntry = NULL;
1177
1178 IpCount = 0;
1179 RRCount = 0;
1180 AnswerSectionNum = 0;
1181
1182 HostAddr4 = NULL;
1183 HostAddr6 = NULL;
1184
1185 Dns4CacheEntry = NULL;
1186 Dns6CacheEntry = NULL;
1187
1188 Dns4RR = NULL;
1189 Dns6RR = NULL;
1190
1191 *Completed = TRUE;
1192 Status = EFI_SUCCESS;
1193
1194 //
1195 // Get header
1196 //
1197 DnsHeader = (DNS_HEADER *) RxString;
1198
1199 DnsHeader->Identification = NTOHS (DnsHeader->Identification);
1200 DnsHeader->Flags.Uint16 = NTOHS (DnsHeader->Flags.Uint16);
1201 DnsHeader->QuestionsNum = NTOHS (DnsHeader->QuestionsNum);
1202 DnsHeader->AnswersNum = NTOHS (DnsHeader->AnswersNum);
1203 DnsHeader->AuthorityNum = NTOHS (DnsHeader->AuthorityNum);
1204 DnsHeader->AditionalNum = NTOHS (DnsHeader->AditionalNum);
1205
1206 //
1207 // Get Query name
1208 //
1209 QueryName = (CHAR8 *) (RxString + sizeof (*DnsHeader));
1210
1211 //
1212 // Get query section
1213 //
1214 QuerySection = (DNS_QUERY_SECTION *) (QueryName + AsciiStrLen (QueryName) + 1);
1215 QuerySection->Type = NTOHS (QuerySection->Type);
1216 QuerySection->Class = NTOHS (QuerySection->Class);
1217
1218 //
1219 // Get Answer name
1220 //
1221 AnswerName = (CHAR8 *) QuerySection + sizeof (*QuerySection);
1222
1223 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
1224
1225 //
1226 // Check DnsResponse Validity, if so, also get a valid NET_MAP_ITEM.
1227 //
1228 if (Instance->Service->IpVersion == IP_VERSION_4) {
1229 if (!IsValidDnsResponse (&Instance->Dns4TxTokens, DnsHeader->Identification, QuerySection->Type, &Item)) {
1230 *Completed = FALSE;
1231 Status = EFI_ABORTED;
1232 goto ON_EXIT;
1233 }
1234 ASSERT (Item != NULL);
1235 Dns4TokenEntry = (DNS4_TOKEN_ENTRY *) (Item->Key);
1236 } else {
1237 if (!IsValidDnsResponse (&Instance->Dns6TxTokens, DnsHeader->Identification, QuerySection->Type, &Item)) {
1238 *Completed = FALSE;
1239 Status = EFI_ABORTED;
1240 goto ON_EXIT;
1241 }
1242 ASSERT (Item != NULL);
1243 Dns6TokenEntry = (DNS6_TOKEN_ENTRY *) (Item->Key);
1244 }
1245
1246 //
1247 // Continue Check Some Errors.
1248 //
1249 if (DnsHeader->Flags.Bits.RCode != DNS_FLAGS_RCODE_NO_ERROR || DnsHeader->AnswersNum < 1 || \
1250 DnsHeader->Flags.Bits.QR != DNS_FLAGS_QR_RESPONSE || QuerySection->Class != DNS_CLASS_INET) {
1251 Status = EFI_ABORTED;
1252 goto ON_EXIT;
1253 }
1254
1255 //
1256 // Free the sending packet.
1257 //
1258 if (Item->Value != NULL) {
1259 NetbufFree ((NET_BUF *) (Item->Value));
1260 }
1261
1262 //
1263 // Do some buffer allocations.
1264 //
1265 if (Instance->Service->IpVersion == IP_VERSION_4) {
1266 ASSERT (Dns4TokenEntry != NULL);
1267
1268 if (Dns4TokenEntry->GeneralLookUp) {
1269 //
1270 // It's the GeneralLookUp querying.
1271 //
1272 Dns4TokenEntry->Token->RspData.GLookupData = AllocatePool (sizeof (DNS_RESOURCE_RECORD));
1273 if (Dns4TokenEntry->Token->RspData.GLookupData == NULL) {
1274 Status = EFI_OUT_OF_RESOURCES;
1275 goto ON_EXIT;
1276 }
1277 Dns4TokenEntry->Token->RspData.GLookupData->RRList = AllocatePool (DnsHeader->AnswersNum * sizeof (DNS_RESOURCE_RECORD));
1278 if (Dns4TokenEntry->Token->RspData.GLookupData->RRList == NULL) {
1279 Status = EFI_OUT_OF_RESOURCES;
1280 goto ON_EXIT;
1281 }
1282 } else {
1283 //
1284 // It's not the GeneralLookUp querying. Check the Query type.
1285 //
1286 if (QuerySection->Type == DNS_TYPE_A) {
1287 Dns4TokenEntry->Token->RspData.H2AData = AllocatePool (sizeof (DNS_HOST_TO_ADDR_DATA));
1288 if (Dns4TokenEntry->Token->RspData.H2AData == NULL) {
1289 Status = EFI_OUT_OF_RESOURCES;
1290 goto ON_EXIT;
1291 }
1292 Dns4TokenEntry->Token->RspData.H2AData->IpList = AllocatePool (DnsHeader->AnswersNum * sizeof (EFI_IPv4_ADDRESS));
1293 if (Dns4TokenEntry->Token->RspData.H2AData->IpList == NULL) {
1294 Status = EFI_OUT_OF_RESOURCES;
1295 goto ON_EXIT;
1296 }
1297 } else {
1298 Status = EFI_UNSUPPORTED;
1299 goto ON_EXIT;
1300 }
1301 }
1302 } else {
1303 ASSERT (Dns6TokenEntry != NULL);
1304
1305 if (Dns6TokenEntry->GeneralLookUp) {
1306 //
1307 // It's the GeneralLookUp querying.
1308 //
1309 Dns6TokenEntry->Token->RspData.GLookupData = AllocatePool (sizeof (DNS_RESOURCE_RECORD));
1310 if (Dns6TokenEntry->Token->RspData.GLookupData == NULL) {
1311 Status = EFI_UNSUPPORTED;
1312 goto ON_EXIT;
1313 }
1314 Dns6TokenEntry->Token->RspData.GLookupData->RRList = AllocatePool (DnsHeader->AnswersNum * sizeof (DNS_RESOURCE_RECORD));
1315 if (Dns6TokenEntry->Token->RspData.GLookupData->RRList == NULL) {
1316 Status = EFI_UNSUPPORTED;
1317 goto ON_EXIT;
1318 }
1319 } else {
1320 //
1321 // It's not the GeneralLookUp querying. Check the Query type.
1322 //
1323 if (QuerySection->Type == DNS_TYPE_AAAA) {
1324 Dns6TokenEntry->Token->RspData.H2AData = AllocatePool (sizeof (DNS6_HOST_TO_ADDR_DATA));
1325 if (Dns6TokenEntry->Token->RspData.H2AData == NULL) {
1326 Status = EFI_UNSUPPORTED;
1327 goto ON_EXIT;
1328 }
1329 Dns6TokenEntry->Token->RspData.H2AData->IpList = AllocatePool (DnsHeader->AnswersNum * sizeof (EFI_IPv6_ADDRESS));
1330 if (Dns6TokenEntry->Token->RspData.H2AData->IpList == NULL) {
1331 Status = EFI_UNSUPPORTED;
1332 goto ON_EXIT;
1333 }
1334 } else {
1335 Status = EFI_UNSUPPORTED;
1336 goto ON_EXIT;
1337 }
1338 }
1339 }
1340
1341 //
1342 // Processing AnswerSection.
1343 //
1344 while (AnswerSectionNum < DnsHeader->AnswersNum) {
1345 //
1346 // Answer name should be PTR.
1347 //
1348 ASSERT ((*(UINT8 *) AnswerName & 0xC0) == 0xC0);
1349
1350 //
1351 // Get Answer section.
1352 //
1353 AnswerSection = (DNS_ANSWER_SECTION *) (AnswerName + sizeof (UINT16));
1354 AnswerSection->Type = NTOHS (AnswerSection->Type);
1355 AnswerSection->Class = NTOHS (AnswerSection->Class);
1356 AnswerSection->Ttl = NTOHL (AnswerSection->Ttl);
1357 AnswerSection->DataLength = NTOHS (AnswerSection->DataLength);
1358
1359 //
1360 // Check whether it's the GeneralLookUp querying.
1361 //
1362 if (Instance->Service->IpVersion == IP_VERSION_4 && Dns4TokenEntry->GeneralLookUp) {
1363 ASSERT (Dns4TokenEntry != NULL);
1364
1365 Dns4RR = Dns4TokenEntry->Token->RspData.GLookupData->RRList;
1366 AnswerData = (UINT8 *) AnswerSection + sizeof (*AnswerSection);
1367
1368 //
1369 // Fill the ResourceRecord.
1370 //
1371 Dns4RR[RRCount].QName = AllocateZeroPool (AsciiStrLen (QueryName) + 1);
1372 if (Dns4RR[RRCount].QName == NULL) {
1373 Status = EFI_UNSUPPORTED;
1374 goto ON_EXIT;
1375 }
1376 CopyMem (Dns4RR[RRCount].QName, QueryName, AsciiStrLen (QueryName));
1377 Dns4RR[RRCount].QType = AnswerSection->Type;
1378 Dns4RR[RRCount].QClass = AnswerSection->Class;
1379 Dns4RR[RRCount].TTL = AnswerSection->Ttl;
1380 Dns4RR[RRCount].DataLength = AnswerSection->DataLength;
1381 Dns4RR[RRCount].RData = AllocateZeroPool (Dns4RR[RRCount].DataLength);
1382 if (Dns4RR[RRCount].RData == NULL) {
1383 Status = EFI_UNSUPPORTED;
1384 goto ON_EXIT;
1385 }
1386 CopyMem (Dns4RR[RRCount].RData, AnswerData, Dns4RR[RRCount].DataLength);
1387
1388 RRCount ++;
1389 } else if (Instance->Service->IpVersion == IP_VERSION_6 && Dns6TokenEntry->GeneralLookUp) {
1390 ASSERT (Dns6TokenEntry != NULL);
1391
1392 Dns6RR = Dns6TokenEntry->Token->RspData.GLookupData->RRList;
1393 AnswerData = (UINT8 *) AnswerSection + sizeof (*AnswerSection);
1394
1395 //
1396 // Fill the ResourceRecord.
1397 //
1398 Dns6RR[RRCount].QName = AllocateZeroPool (AsciiStrLen (QueryName) + 1);
1399 if (Dns6RR[RRCount].QName == NULL) {
1400 Status = EFI_UNSUPPORTED;
1401 goto ON_EXIT;
1402 }
1403 CopyMem (Dns6RR[RRCount].QName, QueryName, AsciiStrLen (QueryName));
1404 Dns6RR[RRCount].QType = AnswerSection->Type;
1405 Dns6RR[RRCount].QClass = AnswerSection->Class;
1406 Dns6RR[RRCount].TTL = AnswerSection->Ttl;
1407 Dns6RR[RRCount].DataLength = AnswerSection->DataLength;
1408 Dns6RR[RRCount].RData = AllocateZeroPool (Dns6RR[RRCount].DataLength);
1409 if (Dns6RR[RRCount].RData == NULL) {
1410 Status = EFI_UNSUPPORTED;
1411 goto ON_EXIT;
1412 }
1413 CopyMem (Dns6RR[RRCount].RData, AnswerData, Dns6RR[RRCount].DataLength);
1414
1415 RRCount ++;
1416 } else {
1417 //
1418 // It's not the GeneralLookUp querying.
1419 // Check the Query type, parse the response packet.
1420 //
1421 switch (AnswerSection->Type) {
1422 case DNS_TYPE_A:
1423 //
1424 // This is address entry, get Data.
1425 //
1426 ASSERT (Dns4TokenEntry != NULL && AnswerSection->DataLength == 4);
1427
1428 HostAddr4 = Dns4TokenEntry->Token->RspData.H2AData->IpList;
1429 AnswerData = (UINT8 *) AnswerSection + sizeof (*AnswerSection);
1430 CopyMem (&HostAddr4[IpCount], AnswerData, sizeof (EFI_IPv4_ADDRESS));
1431
1432 //
1433 // Update DNS cache dynamically.
1434 //
1435 if (Dns4CacheEntry != NULL) {
1436 if (Dns4CacheEntry->HostName != NULL) {
1437 FreePool (Dns4CacheEntry->HostName);
1438 }
1439
1440 if (Dns4CacheEntry->IpAddress != NULL) {
1441 FreePool (Dns4CacheEntry->IpAddress);
1442 }
1443
1444 FreePool (Dns4CacheEntry);
1445 }
1446
1447 //
1448 // Allocate new CacheEntry pool.
1449 //
1450 Dns4CacheEntry = AllocateZeroPool (sizeof (EFI_DNS4_CACHE_ENTRY));
1451 if (Dns4CacheEntry == NULL) {
1452 Status = EFI_UNSUPPORTED;
1453 goto ON_EXIT;
1454 }
1455 Dns4CacheEntry->HostName = AllocateZeroPool (2 * (StrLen(Dns4TokenEntry->QueryHostName) + 1));
1456 if (Dns4CacheEntry->HostName == NULL) {
1457 Status = EFI_UNSUPPORTED;
1458 goto ON_EXIT;
1459 }
1460 CopyMem (Dns4CacheEntry->HostName, Dns4TokenEntry->QueryHostName, 2 * (StrLen(Dns4TokenEntry->QueryHostName) + 1));
1461 Dns4CacheEntry->IpAddress = AllocateZeroPool (sizeof (EFI_IPv4_ADDRESS));
1462 if (Dns4CacheEntry->IpAddress == NULL) {
1463 Status = EFI_UNSUPPORTED;
1464 goto ON_EXIT;
1465 }
1466 CopyMem (Dns4CacheEntry->IpAddress, AnswerData, sizeof (EFI_IPv4_ADDRESS));
1467 Dns4CacheEntry->Timeout = AnswerSection->Ttl;
1468
1469 UpdateDns4Cache (&mDriverData->Dns4CacheList, FALSE, TRUE, *Dns4CacheEntry);
1470
1471 IpCount ++;
1472 break;
1473 case DNS_TYPE_AAAA:
1474 //
1475 // This is address entry, get Data.
1476 //
1477 ASSERT (Dns6TokenEntry != NULL && AnswerSection->DataLength == 16);
1478
1479 HostAddr6 = Dns6TokenEntry->Token->RspData.H2AData->IpList;
1480 AnswerData = (UINT8 *) AnswerSection + sizeof (*AnswerSection);
1481 CopyMem (&HostAddr6[IpCount], AnswerData, sizeof (EFI_IPv6_ADDRESS));
1482
1483 //
1484 // Update DNS cache dynamically.
1485 //
1486 if (Dns6CacheEntry != NULL) {
1487 if (Dns6CacheEntry->HostName != NULL) {
1488 FreePool (Dns6CacheEntry->HostName);
1489 }
1490
1491 if (Dns6CacheEntry->IpAddress != NULL) {
1492 FreePool (Dns6CacheEntry->IpAddress);
1493 }
1494
1495 FreePool (Dns6CacheEntry);
1496 }
1497
1498 //
1499 // Allocate new CacheEntry pool.
1500 //
1501 Dns6CacheEntry = AllocateZeroPool (sizeof (EFI_DNS6_CACHE_ENTRY));
1502 if (Dns6CacheEntry == NULL) {
1503 Status = EFI_UNSUPPORTED;
1504 goto ON_EXIT;
1505 }
1506 Dns6CacheEntry->HostName = AllocateZeroPool (2 * (StrLen(Dns6TokenEntry->QueryHostName) + 1));
1507 if (Dns6CacheEntry->HostName == NULL) {
1508 Status = EFI_UNSUPPORTED;
1509 goto ON_EXIT;
1510 }
1511 CopyMem (Dns6CacheEntry->HostName, Dns6TokenEntry->QueryHostName, 2 * (StrLen(Dns6TokenEntry->QueryHostName) + 1));
1512 Dns6CacheEntry->IpAddress = AllocateZeroPool (sizeof (EFI_IPv6_ADDRESS));
1513 if (Dns6CacheEntry->IpAddress == NULL) {
1514 Status = EFI_UNSUPPORTED;
1515 goto ON_EXIT;
1516 }
1517 CopyMem (Dns6CacheEntry->IpAddress, AnswerData, sizeof (EFI_IPv6_ADDRESS));
1518 Dns6CacheEntry->Timeout = AnswerSection->Ttl;
1519
1520 UpdateDns6Cache (&mDriverData->Dns6CacheList, FALSE, TRUE, *Dns6CacheEntry);
1521
1522 IpCount ++;
1523 break;
1524 default:
1525 Status = EFI_UNSUPPORTED;
1526 goto ON_EXIT;
1527 }
1528 }
1529
1530 //
1531 // Find next one
1532 //
1533 AnswerName = (CHAR8 *) AnswerSection + sizeof (*AnswerSection) + AnswerSection->DataLength;
1534 AnswerSectionNum ++;
1535 }
1536
1537 if (Instance->Service->IpVersion == IP_VERSION_4) {
1538 ASSERT (Dns4TokenEntry != NULL);
1539
1540 if (Dns4TokenEntry->GeneralLookUp) {
1541 Dns4TokenEntry->Token->RspData.GLookupData->RRCount = RRCount;
1542 } else {
1543 if (QuerySection->Type == DNS_TYPE_A) {
1544 Dns4TokenEntry->Token->RspData.H2AData->IpCount = IpCount;
1545 } else {
1546 Status = EFI_UNSUPPORTED;
1547 goto ON_EXIT;
1548 }
1549 }
1550 } else {
1551 ASSERT (Dns6TokenEntry != NULL);
1552
1553 if (Dns6TokenEntry->GeneralLookUp) {
1554 Dns6TokenEntry->Token->RspData.GLookupData->RRCount = RRCount;
1555 } else {
1556 if (QuerySection->Type == DNS_TYPE_AAAA) {
1557 Dns6TokenEntry->Token->RspData.H2AData->IpCount = IpCount;
1558 } else {
1559 Status = EFI_UNSUPPORTED;
1560 goto ON_EXIT;
1561 }
1562 }
1563 }
1564
1565 //
1566 // Parsing is complete, SignalEvent here.
1567 //
1568 if (Instance->Service->IpVersion == IP_VERSION_4) {
1569 ASSERT (Dns4TokenEntry != NULL);
1570 Dns4RemoveTokenEntry (&Instance->Dns4TxTokens, Dns4TokenEntry);
1571 Dns4TokenEntry->Token->Status = EFI_SUCCESS;
1572 if (Dns4TokenEntry->Token->Event != NULL) {
1573 gBS->SignalEvent (Dns4TokenEntry->Token->Event);
1574 DispatchDpc ();
1575 }
1576 } else {
1577 ASSERT (Dns6TokenEntry != NULL);
1578 Dns6RemoveTokenEntry (&Instance->Dns6TxTokens, Dns6TokenEntry);
1579 Dns6TokenEntry->Token->Status = EFI_SUCCESS;
1580 if (Dns6TokenEntry->Token->Event != NULL) {
1581 gBS->SignalEvent (Dns6TokenEntry->Token->Event);
1582 DispatchDpc ();
1583 }
1584 }
1585
1586 //
1587 // Free allocated CacheEntry pool.
1588 //
1589 if (Dns4CacheEntry != NULL) {
1590 if (Dns4CacheEntry->HostName != NULL) {
1591 FreePool (Dns4CacheEntry->HostName);
1592 }
1593
1594 if (Dns4CacheEntry->IpAddress != NULL) {
1595 FreePool (Dns4CacheEntry->IpAddress);
1596 }
1597
1598 FreePool (Dns4CacheEntry);
1599 }
1600
1601 if (Dns6CacheEntry != NULL) {
1602 if (Dns6CacheEntry->HostName != NULL) {
1603 FreePool (Dns6CacheEntry->HostName);
1604 }
1605
1606 if (Dns6CacheEntry->IpAddress != NULL) {
1607 FreePool (Dns6CacheEntry->IpAddress);
1608 }
1609
1610 FreePool (Dns6CacheEntry);
1611 }
1612
1613 ON_EXIT:
1614 gBS->RestoreTPL (OldTpl);
1615 return Status;
1616 }
1617
1618 /**
1619 Parse response packet.
1620
1621 @param Packet The packets received.
1622 @param EndPoint The local/remote UDP access point
1623 @param IoStatus The status of the UDP receive
1624 @param Context The opaque parameter to the function.
1625
1626 **/
1627 VOID
1628 EFIAPI
1629 DnsOnPacketReceived (
1630 NET_BUF *Packet,
1631 UDP_END_POINT *EndPoint,
1632 EFI_STATUS IoStatus,
1633 VOID *Context
1634 )
1635 {
1636 DNS_INSTANCE *Instance;
1637
1638 UINT8 *RcvString;
1639
1640 BOOLEAN Completed;
1641
1642 Instance = (DNS_INSTANCE *) Context;
1643 NET_CHECK_SIGNATURE (Instance, DNS_INSTANCE_SIGNATURE);
1644
1645 RcvString = NULL;
1646 Completed = FALSE;
1647
1648 if (EFI_ERROR (IoStatus)) {
1649 goto ON_EXIT;
1650 }
1651
1652 ASSERT (Packet != NULL);
1653
1654 RcvString = NetbufGetByte (Packet, 0, NULL);
1655 ASSERT (RcvString != NULL);
1656
1657 //
1658 // Parse Dns Response
1659 //
1660 ParseDnsResponse (Instance, RcvString, &Completed);
1661
1662 ON_EXIT:
1663
1664 if (Packet != NULL) {
1665 NetbufFree (Packet);
1666 }
1667
1668 if (!Completed) {
1669 UdpIoRecvDatagram (Instance->UdpIo, DnsOnPacketReceived, Instance, 0);
1670 }
1671 }
1672
1673 /**
1674 Release the net buffer when packet is sent.
1675
1676 @param Packet The packets received.
1677 @param EndPoint The local/remote UDP access point
1678 @param IoStatus The status of the UDP receive
1679 @param Context The opaque parameter to the function.
1680
1681 **/
1682 VOID
1683 EFIAPI
1684 DnsOnPacketSent (
1685 NET_BUF *Packet,
1686 UDP_END_POINT *EndPoint,
1687 EFI_STATUS IoStatus,
1688 VOID *Context
1689 )
1690 {
1691 DNS_INSTANCE *Instance;
1692 LIST_ENTRY *Entry;
1693 NET_MAP_ITEM *Item;
1694 DNS4_TOKEN_ENTRY *Dns4TokenEntry;
1695 DNS6_TOKEN_ENTRY *Dns6TokenEntry;
1696
1697 Dns4TokenEntry = NULL;
1698 Dns6TokenEntry = NULL;
1699
1700 Instance = (DNS_INSTANCE *) Context;
1701 NET_CHECK_SIGNATURE (Instance, DNS_INSTANCE_SIGNATURE);
1702
1703 if (Instance->Service->IpVersion == IP_VERSION_4) {
1704 NET_LIST_FOR_EACH (Entry, &Instance->Dns4TxTokens.Used) {
1705 Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
1706 if (Packet == (NET_BUF *)(Item->Value)) {
1707 Dns4TokenEntry = ((DNS4_TOKEN_ENTRY *)Item->Key);
1708 Dns4TokenEntry->PacketToLive = Dns4TokenEntry->Token->RetryInterval;
1709 break;
1710 }
1711 }
1712 } else {
1713 NET_LIST_FOR_EACH (Entry, &Instance->Dns6TxTokens.Used) {
1714 Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
1715 if (Packet == (NET_BUF *)(Item->Value)) {
1716 Dns6TokenEntry = ((DNS6_TOKEN_ENTRY *)Item->Key);
1717 Dns6TokenEntry->PacketToLive = Dns6TokenEntry->Token->RetryInterval;
1718 break;
1719 }
1720 }
1721 }
1722
1723 NetbufFree (Packet);
1724 }
1725
1726 /**
1727 Query request information.
1728
1729 @param Instance The DNS instance
1730 @param Packet The packet for querying request information.
1731
1732 @retval EFI_SUCCESS Query request information successfully.
1733 @retval Others Failed to query request information.
1734
1735 **/
1736 EFI_STATUS
1737 DoDnsQuery (
1738 IN DNS_INSTANCE *Instance,
1739 IN NET_BUF *Packet
1740 )
1741 {
1742 EFI_STATUS Status;
1743
1744 //
1745 // Ready to receive the DNS response.
1746 //
1747 if (Instance->UdpIo->RecvRequest == NULL) {
1748 Status = UdpIoRecvDatagram (Instance->UdpIo, DnsOnPacketReceived, Instance, 0);
1749 if (EFI_ERROR (Status)) {
1750 return Status;
1751 }
1752 }
1753
1754 //
1755 // Transmit the DNS packet.
1756 //
1757 NET_GET_REF (Packet);
1758
1759 Status = UdpIoSendDatagram (Instance->UdpIo, Packet, NULL, NULL, DnsOnPacketSent, Instance);
1760
1761 return Status;
1762 }
1763
1764 /**
1765 Construct the Packet according query section.
1766
1767 @param Instance The DNS instance
1768 @param QueryName Queried Name
1769 @param Type Queried Type
1770 @param Class Queried Class
1771 @param Packet The packet for query
1772
1773 @retval EFI_SUCCESS The packet is constructed.
1774 @retval Others Failed to construct the Packet.
1775
1776 **/
1777 EFI_STATUS
1778 ConstructDNSQuery (
1779 IN DNS_INSTANCE *Instance,
1780 IN CHAR8 *QueryName,
1781 IN UINT16 Type,
1782 IN UINT16 Class,
1783 OUT NET_BUF **Packet
1784 )
1785 {
1786 NET_FRAGMENT Frag;
1787 DNS_HEADER *DnsHeader;
1788 DNS_QUERY_SECTION *DnsQuery;
1789
1790 Frag.Bulk = AllocatePool (DNS_DEFAULT_BLKSIZE * sizeof (UINT8));
1791 if (Frag.Bulk == NULL) {
1792 return EFI_OUT_OF_RESOURCES;
1793 }
1794
1795 //
1796 // Fill header
1797 //
1798 DnsHeader = (DNS_HEADER *) Frag.Bulk;
1799 DnsHeader->Identification = (UINT16)NET_RANDOM (NetRandomInitSeed());
1800 DnsHeader->Flags.Uint16 = 0x0000;
1801 DnsHeader->Flags.Bits.RD = 1;
1802 DnsHeader->Flags.Bits.OpCode = DNS_FLAGS_OPCODE_STANDARD;
1803 DnsHeader->Flags.Bits.QR = DNS_FLAGS_QR_QUERY;
1804 DnsHeader->QuestionsNum = 1;
1805 DnsHeader->AnswersNum = 0;
1806 DnsHeader->AuthorityNum = 0;
1807 DnsHeader->AditionalNum = 0;
1808
1809 DnsHeader->Identification = HTONS (DnsHeader->Identification);
1810 DnsHeader->Flags.Uint16 = HTONS (DnsHeader->Flags.Uint16);
1811 DnsHeader->QuestionsNum = HTONS (DnsHeader->QuestionsNum);
1812 DnsHeader->AnswersNum = HTONS (DnsHeader->AnswersNum);
1813 DnsHeader->AuthorityNum = HTONS (DnsHeader->AuthorityNum);
1814 DnsHeader->AditionalNum = HTONS (DnsHeader->AditionalNum);
1815
1816 Frag.Len = sizeof (*DnsHeader);
1817
1818 //
1819 // Fill Query name
1820 //
1821 CopyMem (Frag.Bulk + Frag.Len, QueryName, AsciiStrLen (QueryName));
1822 Frag.Len = (UINT32) (Frag.Len + AsciiStrLen (QueryName));
1823 *(Frag.Bulk + Frag.Len) = 0;
1824 Frag.Len ++;
1825
1826 //
1827 // Rest query section
1828 //
1829 DnsQuery = (DNS_QUERY_SECTION *) (Frag.Bulk + Frag.Len);
1830
1831 DnsQuery->Type = HTONS (Type);
1832 DnsQuery->Class = HTONS (Class);
1833
1834 Frag.Len += sizeof (*DnsQuery);
1835
1836 //
1837 // Wrap the Frag in a net buffer.
1838 //
1839 *Packet = NetbufFromExt (&Frag, 1, 0, 0, DnsDummyExtFree, NULL);
1840 if (*Packet == NULL) {
1841 FreePool (Frag.Bulk);
1842 return EFI_OUT_OF_RESOURCES;
1843 }
1844
1845 //
1846 // Store the UdpIo in ProtoData.
1847 //
1848 *((UINTN *) &((*Packet)->ProtoData[0])) = (UINTN) (Instance->UdpIo);
1849
1850 return EFI_SUCCESS;
1851 }
1852
1853 /**
1854 Retransmit the packet.
1855
1856 @param Instance The DNS instance
1857 @param Packet Retransmit the packet
1858
1859 @retval EFI_SUCCESS The packet is retransmitted.
1860 @retval Others Failed to retransmit.
1861
1862 **/
1863 EFI_STATUS
1864 DnsRetransmit (
1865 IN DNS_INSTANCE *Instance,
1866 IN NET_BUF *Packet
1867 )
1868 {
1869 EFI_STATUS Status;
1870
1871 UINT8 *Buffer;
1872
1873 ASSERT (Packet != NULL);
1874
1875 //
1876 // Set the requests to the listening port, other packets to the connected port
1877 //
1878 Buffer = NetbufGetByte (Packet, 0, NULL);
1879 ASSERT (Buffer != NULL);
1880
1881 NET_GET_REF (Packet);
1882
1883 Status = UdpIoSendDatagram (
1884 Instance->UdpIo,
1885 Packet,
1886 NULL,
1887 NULL,
1888 DnsOnPacketSent,
1889 Instance
1890 );
1891
1892 if (EFI_ERROR (Status)) {
1893 NET_PUT_REF (Packet);
1894 }
1895
1896 return Status;
1897 }
1898
1899 /**
1900 The timer ticking function for the DNS services.
1901
1902 @param Event The ticking event
1903 @param Context The DNS service instance
1904
1905 **/
1906 VOID
1907 EFIAPI
1908 DnsOnTimerRetransmit (
1909 IN EFI_EVENT Event,
1910 IN VOID *Context
1911 )
1912 {
1913 DNS_SERVICE *Service;
1914
1915 LIST_ENTRY *Entry;
1916 LIST_ENTRY *Next;
1917
1918 DNS_INSTANCE *Instance;
1919 LIST_ENTRY *EntryNetMap;
1920 NET_MAP_ITEM *ItemNetMap;
1921 DNS4_TOKEN_ENTRY *Dns4TokenEntry;
1922 DNS6_TOKEN_ENTRY *Dns6TokenEntry;
1923
1924 Dns4TokenEntry = NULL;
1925 Dns6TokenEntry = NULL;
1926
1927 Service = (DNS_SERVICE *) Context;
1928
1929
1930 if (Service->IpVersion == IP_VERSION_4) {
1931 //
1932 // Iterate through all the children of the DNS service instance. Time
1933 // out the packet. If maximum retries reached, clean the Token up.
1934 //
1935 NET_LIST_FOR_EACH_SAFE (Entry, Next, &Service->Dns4ChildrenList) {
1936 Instance = NET_LIST_USER_STRUCT (Entry, DNS_INSTANCE, Link);
1937
1938 EntryNetMap = Instance->Dns4TxTokens.Used.ForwardLink;
1939 while (EntryNetMap != &Instance->Dns4TxTokens.Used) {
1940 ItemNetMap = NET_LIST_USER_STRUCT (EntryNetMap, NET_MAP_ITEM, Link);
1941 Dns4TokenEntry = (DNS4_TOKEN_ENTRY *)(ItemNetMap->Key);
1942 if (Dns4TokenEntry->PacketToLive == 0 || (--Dns4TokenEntry->PacketToLive > 0)) {
1943 EntryNetMap = EntryNetMap->ForwardLink;
1944 continue;
1945 }
1946
1947 //
1948 // Retransmit the packet if haven't reach the maxmium retry count,
1949 // otherwise exit the transfer.
1950 //
1951 if (++Dns4TokenEntry->Token->RetryCount < Instance->MaxRetry) {
1952 DnsRetransmit (Instance, (NET_BUF *)ItemNetMap->Value);
1953 EntryNetMap = EntryNetMap->ForwardLink;
1954 } else {
1955 //
1956 // Maximum retries reached, clean the Token up.
1957 //
1958 Dns4RemoveTokenEntry (&Instance->Dns4TxTokens, Dns4TokenEntry);
1959 Dns4TokenEntry->Token->Status = EFI_TIMEOUT;
1960 gBS->SignalEvent (Dns4TokenEntry->Token->Event);
1961 DispatchDpc ();
1962
1963 //
1964 // Free the sending packet.
1965 //
1966 if (ItemNetMap->Value != NULL) {
1967 NetbufFree ((NET_BUF *)(ItemNetMap->Value));
1968 }
1969
1970 EntryNetMap = Instance->Dns4TxTokens.Used.ForwardLink;
1971 }
1972 }
1973 }
1974 }else {
1975 //
1976 // Iterate through all the children of the DNS service instance. Time
1977 // out the packet. If maximum retries reached, clean the Token up.
1978 //
1979 NET_LIST_FOR_EACH_SAFE (Entry, Next, &Service->Dns6ChildrenList) {
1980 Instance = NET_LIST_USER_STRUCT (Entry, DNS_INSTANCE, Link);
1981
1982 EntryNetMap = Instance->Dns6TxTokens.Used.ForwardLink;
1983 while (EntryNetMap != &Instance->Dns6TxTokens.Used) {
1984 ItemNetMap = NET_LIST_USER_STRUCT (EntryNetMap, NET_MAP_ITEM, Link);
1985 Dns6TokenEntry = (DNS6_TOKEN_ENTRY *) (ItemNetMap->Key);
1986 if (Dns6TokenEntry->PacketToLive == 0 || (--Dns6TokenEntry->PacketToLive > 0)) {
1987 EntryNetMap = EntryNetMap->ForwardLink;
1988 continue;
1989 }
1990
1991 //
1992 // Retransmit the packet if haven't reach the maxmium retry count,
1993 // otherwise exit the transfer.
1994 //
1995 if (++Dns6TokenEntry->Token->RetryCount < Instance->MaxRetry) {
1996 DnsRetransmit (Instance, (NET_BUF *) ItemNetMap->Value);
1997 EntryNetMap = EntryNetMap->ForwardLink;
1998 } else {
1999 //
2000 // Maximum retries reached, clean the Token up.
2001 //
2002 Dns6RemoveTokenEntry (&Instance->Dns6TxTokens, Dns6TokenEntry);
2003 Dns6TokenEntry->Token->Status = EFI_TIMEOUT;
2004 gBS->SignalEvent (Dns6TokenEntry->Token->Event);
2005 DispatchDpc ();
2006
2007 //
2008 // Free the sending packet.
2009 //
2010 if (ItemNetMap->Value != NULL) {
2011 NetbufFree ((NET_BUF *) (ItemNetMap->Value));
2012 }
2013
2014 EntryNetMap = Instance->Dns6TxTokens.Used.ForwardLink;
2015 }
2016 }
2017 }
2018 }
2019 }
2020
2021 /**
2022 The timer ticking function for the DNS driver.
2023
2024 @param Event The ticking event
2025 @param Context NULL
2026
2027 **/
2028 VOID
2029 EFIAPI
2030 DnsOnTimerUpdate (
2031 IN EFI_EVENT Event,
2032 IN VOID *Context
2033 )
2034 {
2035 LIST_ENTRY *Entry;
2036 LIST_ENTRY *Next;
2037 DNS4_CACHE *Item4;
2038 DNS6_CACHE *Item6;
2039
2040 Item4 = NULL;
2041 Item6 = NULL;
2042
2043 //
2044 // Iterate through all the DNS4 cache list.
2045 //
2046 NET_LIST_FOR_EACH_SAFE (Entry, Next, &mDriverData->Dns4CacheList) {
2047 Item4 = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);
2048 Item4->DnsCache.Timeout--;
2049 }
2050
2051 Entry = mDriverData->Dns4CacheList.ForwardLink;
2052 while (Entry != &mDriverData->Dns4CacheList) {
2053 Item4 = NET_LIST_USER_STRUCT (Entry, DNS4_CACHE, AllCacheLink);
2054 if (Item4->DnsCache.Timeout<=0) {
2055 RemoveEntryList (&Item4->AllCacheLink);
2056 Entry = mDriverData->Dns4CacheList.ForwardLink;
2057 } else {
2058 Entry = Entry->ForwardLink;
2059 }
2060 }
2061
2062 //
2063 // Iterate through all the DNS6 cache list.
2064 //
2065 NET_LIST_FOR_EACH_SAFE (Entry, Next, &mDriverData->Dns6CacheList) {
2066 Item6 = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);
2067 Item6->DnsCache.Timeout--;
2068 }
2069
2070 Entry = mDriverData->Dns6CacheList.ForwardLink;
2071 while (Entry != &mDriverData->Dns6CacheList) {
2072 Item6 = NET_LIST_USER_STRUCT (Entry, DNS6_CACHE, AllCacheLink);
2073 if (Item6->DnsCache.Timeout<=0) {
2074 RemoveEntryList (&Item6->AllCacheLink);
2075 Entry = mDriverData->Dns6CacheList.ForwardLink;
2076 } else {
2077 Entry = Entry->ForwardLink;
2078 }
2079 }
2080 }
2081