VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c@ 77662

Last change on this file since 77662 was 77662, checked in by vboxsync, 6 years ago

EFI: First step in UDK2018 merge. Does not build yet.
  • Property svn:eol-style set to native
File size: 56.5 KB
Line 
1/** @file
2 IpIo Library.
3
4(C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
5Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>
6This program and the accompanying materials
7are licensed and made available under the terms and conditions of the BSD License
8which accompanies this distribution. The full text of the license may be found at
9http://opensource.org/licenses/bsd-license.php
10
11THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13**/
14
15#include <Uefi.h>
16
17#include <Protocol/Udp4.h>
18
19#include <Library/IpIoLib.h>
20#include <Library/BaseLib.h>
21#include <Library/DebugLib.h>
22#include <Library/BaseMemoryLib.h>
23#include <Library/UefiBootServicesTableLib.h>
24#include <Library/MemoryAllocationLib.h>
25#include <Library/DpcLib.h>
26
27
28GLOBAL_REMOVE_IF_UNREFERENCED LIST_ENTRY mActiveIpIoList = {
29 &mActiveIpIoList,
30 &mActiveIpIoList
31};
32
33GLOBAL_REMOVE_IF_UNREFERENCED EFI_IP4_CONFIG_DATA mIp4IoDefaultIpConfigData = {
34 EFI_IP_PROTO_UDP,
35 FALSE,
36 TRUE,
37 FALSE,
38 FALSE,
39 FALSE,
40 {{0, 0, 0, 0}},
41 {{0, 0, 0, 0}},
42 0,
43 255,
44 FALSE,
45 FALSE,
46 0,
47 0
48};
49
50GLOBAL_REMOVE_IF_UNREFERENCED EFI_IP6_CONFIG_DATA mIp6IoDefaultIpConfigData = {
51 EFI_IP_PROTO_UDP,
52 FALSE,
53 TRUE,
54 FALSE,
55 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
56 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
57 0,
58 255,
59 0,
60 0,
61 0
62};
63
64GLOBAL_REMOVE_IF_UNREFERENCED ICMP_ERROR_INFO mIcmpErrMap[10] = {
65 {FALSE, TRUE }, // ICMP_ERR_UNREACH_NET
66 {FALSE, TRUE }, // ICMP_ERR_UNREACH_HOST
67 {TRUE, TRUE }, // ICMP_ERR_UNREACH_PROTOCOL
68 {TRUE, TRUE }, // ICMP_ERR_UNREACH_PORT
69 {TRUE, TRUE }, // ICMP_ERR_MSGSIZE
70 {FALSE, TRUE }, // ICMP_ERR_UNREACH_SRCFAIL
71 {FALSE, TRUE }, // ICMP_ERR_TIMXCEED_INTRANS
72 {FALSE, TRUE }, // ICMP_ERR_TIMEXCEED_REASS
73 {FALSE, FALSE}, // ICMP_ERR_QUENCH
74 {FALSE, TRUE } // ICMP_ERR_PARAMPROB
75};
76
77GLOBAL_REMOVE_IF_UNREFERENCED ICMP_ERROR_INFO mIcmp6ErrMap[10] = {
78 {FALSE, TRUE}, // ICMP6_ERR_UNREACH_NET
79 {FALSE, TRUE}, // ICMP6_ERR_UNREACH_HOST
80 {TRUE, TRUE}, // ICMP6_ERR_UNREACH_PROTOCOL
81 {TRUE, TRUE}, // ICMP6_ERR_UNREACH_PORT
82 {TRUE, TRUE}, // ICMP6_ERR_PACKAGE_TOOBIG
83 {FALSE, TRUE}, // ICMP6_ERR_TIMXCEED_HOPLIMIT
84 {FALSE, TRUE}, // ICMP6_ERR_TIMXCEED_REASS
85 {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_HEADER
86 {FALSE, TRUE}, // ICMP6_ERR_PARAMPROB_NEXHEADER
87 {FALSE, TRUE} // ICMP6_ERR_PARAMPROB_IPV6OPTION
88};
89
90
91/**
92 Notify function for IP transmit token.
93
94 @param[in] Context The context passed in by the event notifier.
95
96**/
97VOID
98EFIAPI
99IpIoTransmitHandlerDpc (
100 IN VOID *Context
101 );
102
103
104/**
105 Notify function for IP transmit token.
106
107 @param[in] Event The event signaled.
108 @param[in] Context The context passed in by the event notifier.
109
110**/
111VOID
112EFIAPI
113IpIoTransmitHandler (
114 IN EFI_EVENT Event,
115 IN VOID *Context
116 );
117
118
119/**
120 This function create an IP child ,open the IP protocol, and return the opened
121 IP protocol as Interface.
122
123 @param[in] ControllerHandle The controller handle.
124 @param[in] ImageHandle The image handle.
125 @param[in] ChildHandle Pointer to the buffer to save the IP child handle.
126 @param[in] IpVersion The version of the IP protocol to use, either
127 IPv4 or IPv6.
128 @param[out] Interface Pointer used to get the IP protocol interface.
129
130 @retval EFI_SUCCESS The IP child is created and the IP protocol
131 interface is retrieved.
132 @retval EFI_UNSUPPORTED Upsupported IpVersion.
133 @retval Others The required operation failed.
134
135**/
136EFI_STATUS
137IpIoCreateIpChildOpenProtocol (
138 IN EFI_HANDLE ControllerHandle,
139 IN EFI_HANDLE ImageHandle,
140 IN EFI_HANDLE *ChildHandle,
141 IN UINT8 IpVersion,
142 OUT VOID **Interface
143 )
144{
145 EFI_STATUS Status;
146 EFI_GUID *ServiceBindingGuid;
147 EFI_GUID *IpProtocolGuid;
148
149 if (IpVersion == IP_VERSION_4) {
150 ServiceBindingGuid = &gEfiIp4ServiceBindingProtocolGuid;
151 IpProtocolGuid = &gEfiIp4ProtocolGuid;
152 } else if (IpVersion == IP_VERSION_6){
153 ServiceBindingGuid = &gEfiIp6ServiceBindingProtocolGuid;
154 IpProtocolGuid = &gEfiIp6ProtocolGuid;
155 } else {
156 return EFI_UNSUPPORTED;
157 }
158
159 //
160 // Create an IP child.
161 //
162 Status = NetLibCreateServiceChild (
163 ControllerHandle,
164 ImageHandle,
165 ServiceBindingGuid,
166 ChildHandle
167 );
168 if (EFI_ERROR (Status)) {
169 return Status;
170 }
171
172 //
173 // Open the IP protocol installed on the *ChildHandle.
174 //
175 Status = gBS->OpenProtocol (
176 *ChildHandle,
177 IpProtocolGuid,
178 Interface,
179 ImageHandle,
180 ControllerHandle,
181 EFI_OPEN_PROTOCOL_BY_DRIVER
182 );
183 if (EFI_ERROR (Status)) {
184 //
185 // On failure, destroy the IP child.
186 //
187 NetLibDestroyServiceChild (
188 ControllerHandle,
189 ImageHandle,
190 ServiceBindingGuid,
191 *ChildHandle
192 );
193 }
194
195 return Status;
196}
197
198
199/**
200 This function close the previously openned IP protocol and destroy the IP child.
201
202 @param[in] ControllerHandle The controller handle.
203 @param[in] ImageHandle The image handle.
204 @param[in] ChildHandle The child handle of the IP child.
205 @param[in] IpVersion The version of the IP protocol to use, either
206 IPv4 or IPv6.
207
208 @retval EFI_SUCCESS The IP protocol is closed and the relevant IP child
209 is destroyed.
210 @retval EFI_UNSUPPORTED Upsupported IpVersion.
211 @retval Others The required operation failed.
212
213**/
214EFI_STATUS
215IpIoCloseProtocolDestroyIpChild (
216 IN EFI_HANDLE ControllerHandle,
217 IN EFI_HANDLE ImageHandle,
218 IN EFI_HANDLE ChildHandle,
219 IN UINT8 IpVersion
220 )
221{
222 EFI_STATUS Status;
223 EFI_GUID *ServiceBindingGuid;
224 EFI_GUID *IpProtocolGuid;
225
226 if (IpVersion == IP_VERSION_4) {
227 ServiceBindingGuid = &gEfiIp4ServiceBindingProtocolGuid;
228 IpProtocolGuid = &gEfiIp4ProtocolGuid;
229 } else if (IpVersion == IP_VERSION_6) {
230 ServiceBindingGuid = &gEfiIp6ServiceBindingProtocolGuid;
231 IpProtocolGuid = &gEfiIp6ProtocolGuid;
232 } else {
233 return EFI_UNSUPPORTED;
234 }
235
236 //
237 // Close the previously openned IP protocol.
238 //
239 Status = gBS->CloseProtocol (
240 ChildHandle,
241 IpProtocolGuid,
242 ImageHandle,
243 ControllerHandle
244 );
245 if (EFI_ERROR (Status)) {
246 return Status;
247 }
248
249 //
250 // Destroy the IP child.
251 //
252 return NetLibDestroyServiceChild (
253 ControllerHandle,
254 ImageHandle,
255 ServiceBindingGuid,
256 ChildHandle
257 );
258}
259
260/**
261 This function handles ICMPv4 packets. It is the worker function of
262 IpIoIcmpHandler.
263
264 @param[in] IpIo Pointer to the IP_IO instance.
265 @param[in, out] Pkt Pointer to the ICMPv4 packet.
266 @param[in] Session Pointer to the net session of this ICMPv4 packet.
267
268 @retval EFI_SUCCESS The ICMPv4 packet is handled successfully.
269 @retval EFI_ABORTED This type of ICMPv4 packet is not supported.
270
271**/
272EFI_STATUS
273IpIoIcmpv4Handler (
274 IN IP_IO *IpIo,
275 IN OUT NET_BUF *Pkt,
276 IN EFI_NET_SESSION_DATA *Session
277 )
278{
279 IP4_ICMP_ERROR_HEAD *IcmpHdr;
280 EFI_IP4_HEADER *IpHdr;
281 UINT8 IcmpErr;
282 UINT8 *PayLoadHdr;
283 UINT8 Type;
284 UINT8 Code;
285 UINT32 TrimBytes;
286
287 ASSERT (IpIo != NULL);
288 ASSERT (Pkt != NULL);
289 ASSERT (Session != NULL);
290 ASSERT (IpIo->IpVersion == IP_VERSION_4);
291
292 //
293 // Check the ICMP packet length.
294 //
295 if (Pkt->TotalSize < sizeof (IP4_ICMP_ERROR_HEAD)) {
296 return EFI_ABORTED;
297 }
298
299 IcmpHdr = NET_PROTO_HDR (Pkt, IP4_ICMP_ERROR_HEAD);
300 IpHdr = (EFI_IP4_HEADER *) (&IcmpHdr->IpHead);
301
302 if (Pkt->TotalSize < ICMP_ERRLEN (IpHdr)) {
303
304 return EFI_ABORTED;
305 }
306
307 Type = IcmpHdr->Head.Type;
308 Code = IcmpHdr->Head.Code;
309
310 //
311 // Analyze the ICMP Error in this ICMP pkt
312 //
313 switch (Type) {
314 case ICMP_TYPE_UNREACH:
315 switch (Code) {
316 case ICMP_CODE_UNREACH_NET:
317 case ICMP_CODE_UNREACH_HOST:
318 case ICMP_CODE_UNREACH_PROTOCOL:
319 case ICMP_CODE_UNREACH_PORT:
320 case ICMP_CODE_UNREACH_SRCFAIL:
321 IcmpErr = (UINT8) (ICMP_ERR_UNREACH_NET + Code);
322
323 break;
324
325 case ICMP_CODE_UNREACH_NEEDFRAG:
326 IcmpErr = ICMP_ERR_MSGSIZE;
327
328 break;
329
330 case ICMP_CODE_UNREACH_NET_UNKNOWN:
331 case ICMP_CODE_UNREACH_NET_PROHIB:
332 case ICMP_CODE_UNREACH_TOSNET:
333 IcmpErr = ICMP_ERR_UNREACH_NET;
334
335 break;
336
337 case ICMP_CODE_UNREACH_HOST_UNKNOWN:
338 case ICMP_CODE_UNREACH_ISOLATED:
339 case ICMP_CODE_UNREACH_HOST_PROHIB:
340 case ICMP_CODE_UNREACH_TOSHOST:
341 IcmpErr = ICMP_ERR_UNREACH_HOST;
342
343 break;
344
345 default:
346 return EFI_ABORTED;
347 }
348
349 break;
350
351 case ICMP_TYPE_TIMXCEED:
352 if (Code > 1) {
353 return EFI_ABORTED;
354 }
355
356 IcmpErr = (UINT8) (Code + ICMP_ERR_TIMXCEED_INTRANS);
357
358 break;
359
360 case ICMP_TYPE_PARAMPROB:
361 if (Code > 1) {
362 return EFI_ABORTED;
363 }
364
365 IcmpErr = ICMP_ERR_PARAMPROB;
366
367 break;
368
369 case ICMP_TYPE_SOURCEQUENCH:
370 if (Code != 0) {
371 return EFI_ABORTED;
372 }
373
374 IcmpErr = ICMP_ERR_QUENCH;
375
376 break;
377
378 default:
379 return EFI_ABORTED;
380 }
381
382 //
383 // Notify user the ICMP pkt only containing payload except
384 // IP and ICMP header
385 //
386 PayLoadHdr = (UINT8 *) ((UINT8 *) IpHdr + EFI_IP4_HEADER_LEN (IpHdr));
387 TrimBytes = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);
388
389 NetbufTrim (Pkt, TrimBytes, TRUE);
390
391 //
392 // If the input packet has invalid format, and TrimBytes is larger than
393 // the packet size, the NetbufTrim might trim the packet to zero.
394 //
395 if (Pkt->TotalSize != 0) {
396 IpIo->PktRcvdNotify (EFI_ICMP_ERROR, IcmpErr, Session, Pkt, IpIo->RcvdContext);
397 }
398
399 return EFI_SUCCESS;
400}
401
402/**
403 This function handles ICMPv6 packets. It is the worker function of
404 IpIoIcmpHandler.
405
406 @param[in] IpIo Pointer to the IP_IO instance.
407 @param[in, out] Pkt Pointer to the ICMPv6 packet.
408 @param[in] Session Pointer to the net session of this ICMPv6 packet.
409
410 @retval EFI_SUCCESS The ICMPv6 packet is handled successfully.
411 @retval EFI_ABORTED This type of ICMPv6 packet is not supported.
412
413**/
414EFI_STATUS
415IpIoIcmpv6Handler (
416 IN IP_IO *IpIo,
417 IN OUT NET_BUF *Pkt,
418 IN EFI_NET_SESSION_DATA *Session
419 )
420{
421 IP6_ICMP_ERROR_HEAD *IcmpHdr;
422 EFI_IP6_HEADER *IpHdr;
423 UINT8 IcmpErr;
424 UINT8 *PayLoadHdr;
425 UINT8 Type;
426 UINT8 Code;
427 UINT8 NextHeader;
428 UINT32 TrimBytes;
429 BOOLEAN Flag;
430
431 ASSERT (IpIo != NULL);
432 ASSERT (Pkt != NULL);
433 ASSERT (Session != NULL);
434 ASSERT (IpIo->IpVersion == IP_VERSION_6);
435
436 //
437 // Check the ICMPv6 packet length.
438 //
439 if (Pkt->TotalSize < sizeof (IP6_ICMP_ERROR_HEAD)) {
440
441 return EFI_ABORTED;
442 }
443
444 IcmpHdr = NET_PROTO_HDR (Pkt, IP6_ICMP_ERROR_HEAD);
445 Type = IcmpHdr->Head.Type;
446 Code = IcmpHdr->Head.Code;
447
448 //
449 // Analyze the ICMPv6 Error in this ICMPv6 packet
450 //
451 switch (Type) {
452 case ICMP_V6_DEST_UNREACHABLE:
453 switch (Code) {
454 case ICMP_V6_NO_ROUTE_TO_DEST:
455 case ICMP_V6_BEYOND_SCOPE:
456 case ICMP_V6_ROUTE_REJECTED:
457 IcmpErr = ICMP6_ERR_UNREACH_NET;
458
459 break;
460
461 case ICMP_V6_COMM_PROHIBITED:
462 case ICMP_V6_ADDR_UNREACHABLE:
463 case ICMP_V6_SOURCE_ADDR_FAILED:
464 IcmpErr = ICMP6_ERR_UNREACH_HOST;
465
466 break;
467
468 case ICMP_V6_PORT_UNREACHABLE:
469 IcmpErr = ICMP6_ERR_UNREACH_PORT;
470
471 break;
472
473 default:
474 return EFI_ABORTED;
475 }
476
477 break;
478
479 case ICMP_V6_PACKET_TOO_BIG:
480 if (Code >= 1) {
481 return EFI_ABORTED;
482 }
483
484 IcmpErr = ICMP6_ERR_PACKAGE_TOOBIG;
485
486 break;
487
488 case ICMP_V6_TIME_EXCEEDED:
489 if (Code > 1) {
490 return EFI_ABORTED;
491 }
492
493 IcmpErr = (UINT8) (ICMP6_ERR_TIMXCEED_HOPLIMIT + Code);
494
495 break;
496
497 case ICMP_V6_PARAMETER_PROBLEM:
498 if (Code > 3) {
499 return EFI_ABORTED;
500 }
501
502 IcmpErr = (UINT8) (ICMP6_ERR_PARAMPROB_HEADER + Code);
503
504 break;
505
506 default:
507
508 return EFI_ABORTED;
509 }
510
511 //
512 // Notify user the ICMPv6 packet only containing payload except
513 // IPv6 basic header, extension header and ICMP header
514 //
515
516 IpHdr = (EFI_IP6_HEADER *) (&IcmpHdr->IpHead);
517 NextHeader = IpHdr->NextHeader;
518 PayLoadHdr = (UINT8 *) ((UINT8 *) IcmpHdr + sizeof (IP6_ICMP_ERROR_HEAD));
519 Flag = TRUE;
520
521 do {
522 switch (NextHeader) {
523 case EFI_IP_PROTO_UDP:
524 case EFI_IP_PROTO_TCP:
525 case EFI_IP_PROTO_ICMP:
526 case IP6_NO_NEXT_HEADER:
527 Flag = FALSE;
528
529 break;
530
531 case IP6_HOP_BY_HOP:
532 case IP6_DESTINATION:
533 //
534 // The Hdr Ext Len is 8-bit unsigned integer in 8-octet units, not including
535 // the first 8 octets.
536 //
537 NextHeader = *(PayLoadHdr);
538 PayLoadHdr = (UINT8 *) (PayLoadHdr + (*(PayLoadHdr + 1) + 1) * 8);
539
540 break;
541
542 case IP6_FRAGMENT:
543 //
544 // The Fragment Header Length is 8 octets.
545 //
546 NextHeader = *(PayLoadHdr);
547 PayLoadHdr = (UINT8 *) (PayLoadHdr + 8);
548
549 break;
550
551 default:
552
553 return EFI_ABORTED;
554 }
555 } while (Flag);
556
557 TrimBytes = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);
558
559 NetbufTrim (Pkt, TrimBytes, TRUE);
560
561 //
562 // If the input packet has invalid format, and TrimBytes is larger than
563 // the packet size, the NetbufTrim might trim the packet to zero.
564 //
565 if (Pkt->TotalSize != 0) {
566 IpIo->PktRcvdNotify (EFI_ICMP_ERROR, IcmpErr, Session, Pkt, IpIo->RcvdContext);
567 }
568
569 return EFI_SUCCESS;
570}
571
572/**
573 This function handles ICMP packets.
574
575 @param[in] IpIo Pointer to the IP_IO instance.
576 @param[in, out] Pkt Pointer to the ICMP packet.
577 @param[in] Session Pointer to the net session of this ICMP packet.
578
579 @retval EFI_SUCCESS The ICMP packet is handled successfully.
580 @retval EFI_ABORTED This type of ICMP packet is not supported.
581 @retval EFI_UNSUPPORTED The IP protocol version in IP_IO is not supported.
582
583**/
584EFI_STATUS
585IpIoIcmpHandler (
586 IN IP_IO *IpIo,
587 IN OUT NET_BUF *Pkt,
588 IN EFI_NET_SESSION_DATA *Session
589 )
590{
591
592 if (IpIo->IpVersion == IP_VERSION_4) {
593
594 return IpIoIcmpv4Handler (IpIo, Pkt, Session);
595
596 } else if (IpIo->IpVersion == IP_VERSION_6) {
597
598 return IpIoIcmpv6Handler (IpIo, Pkt, Session);
599
600 } else {
601
602 return EFI_UNSUPPORTED;
603 }
604}
605
606
607/**
608 Free function for receive token of IP_IO. It is used to
609 signal the recycle event to notify IP to recycle the
610 data buffer.
611
612 @param[in] Event The event to be signaled.
613
614**/
615VOID
616EFIAPI
617IpIoExtFree (
618 IN VOID *Event
619 )
620{
621 gBS->SignalEvent ((EFI_EVENT) Event);
622}
623
624
625/**
626 Create a send entry to wrap a packet before sending
627 out it through IP.
628
629 @param[in, out] IpIo Pointer to the IP_IO instance.
630 @param[in, out] Pkt Pointer to the packet.
631 @param[in] Sender Pointer to the IP sender.
632 @param[in] Context Pointer to the context.
633 @param[in] NotifyData Pointer to the notify data.
634 @param[in] Dest Pointer to the destination IP address.
635 @param[in] Override Pointer to the overriden IP_IO data.
636
637 @return Pointer to the data structure created to wrap the packet. If any error occurs,
638 then return NULL.
639
640**/
641IP_IO_SEND_ENTRY *
642IpIoCreateSndEntry (
643 IN OUT IP_IO *IpIo,
644 IN OUT NET_BUF *Pkt,
645 IN IP_IO_IP_PROTOCOL Sender,
646 IN VOID *Context OPTIONAL,
647 IN VOID *NotifyData OPTIONAL,
648 IN EFI_IP_ADDRESS *Dest OPTIONAL,
649 IN IP_IO_OVERRIDE *Override
650 )
651{
652 IP_IO_SEND_ENTRY *SndEntry;
653 EFI_EVENT Event;
654 EFI_STATUS Status;
655 NET_FRAGMENT *ExtFragment;
656 UINT32 FragmentCount;
657 IP_IO_OVERRIDE *OverrideData;
658 IP_IO_IP_TX_DATA *TxData;
659 EFI_IP4_TRANSMIT_DATA *Ip4TxData;
660 EFI_IP6_TRANSMIT_DATA *Ip6TxData;
661
662 if ((IpIo->IpVersion != IP_VERSION_4) && (IpIo->IpVersion != IP_VERSION_6)) {
663 return NULL;
664 }
665
666 Event = NULL;
667 TxData = NULL;
668 OverrideData = NULL;
669
670 //
671 // Allocate resource for SndEntry
672 //
673 SndEntry = AllocatePool (sizeof (IP_IO_SEND_ENTRY));
674 if (NULL == SndEntry) {
675 return NULL;
676 }
677
678 Status = gBS->CreateEvent (
679 EVT_NOTIFY_SIGNAL,
680 TPL_NOTIFY,
681 IpIoTransmitHandler,
682 SndEntry,
683 &Event
684 );
685 if (EFI_ERROR (Status)) {
686 goto ON_ERROR;
687 }
688
689 FragmentCount = Pkt->BlockOpNum;
690
691 //
692 // Allocate resource for TxData
693 //
694 TxData = (IP_IO_IP_TX_DATA *) AllocatePool (
695 sizeof (IP_IO_IP_TX_DATA) + sizeof (NET_FRAGMENT) * (FragmentCount - 1)
696 );
697
698 if (NULL == TxData) {
699 goto ON_ERROR;
700 }
701
702 //
703 // Build a fragment table to contain the fragments in the packet.
704 //
705 if (IpIo->IpVersion == IP_VERSION_4) {
706 ExtFragment = (NET_FRAGMENT *) TxData->Ip4TxData.FragmentTable;
707 } else {
708 ExtFragment = (NET_FRAGMENT *) TxData->Ip6TxData.FragmentTable;
709 }
710
711 NetbufBuildExt (Pkt, ExtFragment, &FragmentCount);
712
713
714 //
715 // Allocate resource for OverrideData if needed
716 //
717 if (NULL != Override) {
718
719 OverrideData = AllocateCopyPool (sizeof (IP_IO_OVERRIDE), Override);
720 if (NULL == OverrideData) {
721 goto ON_ERROR;
722 }
723 }
724
725 //
726 // Set other fields of TxData except the fragment table
727 //
728 if (IpIo->IpVersion == IP_VERSION_4) {
729
730 Ip4TxData = &TxData->Ip4TxData;
731
732 IP4_COPY_ADDRESS (&Ip4TxData->DestinationAddress, Dest);
733
734 Ip4TxData->OverrideData = &OverrideData->Ip4OverrideData;
735 Ip4TxData->OptionsLength = 0;
736 Ip4TxData->OptionsBuffer = NULL;
737 Ip4TxData->TotalDataLength = Pkt->TotalSize;
738 Ip4TxData->FragmentCount = FragmentCount;
739
740 //
741 // Set the fields of SndToken
742 //
743 SndEntry->SndToken.Ip4Token.Event = Event;
744 SndEntry->SndToken.Ip4Token.Packet.TxData = Ip4TxData;
745 } else {
746
747 Ip6TxData = &TxData->Ip6TxData;
748
749 if (Dest != NULL) {
750 CopyMem (&Ip6TxData->DestinationAddress, Dest, sizeof (EFI_IPv6_ADDRESS));
751 } else {
752 ZeroMem (&Ip6TxData->DestinationAddress, sizeof (EFI_IPv6_ADDRESS));
753 }
754
755 Ip6TxData->OverrideData = &OverrideData->Ip6OverrideData;
756 Ip6TxData->DataLength = Pkt->TotalSize;
757 Ip6TxData->FragmentCount = FragmentCount;
758 Ip6TxData->ExtHdrsLength = 0;
759 Ip6TxData->ExtHdrs = NULL;
760
761 //
762 // Set the fields of SndToken
763 //
764 SndEntry->SndToken.Ip6Token.Event = Event;
765 SndEntry->SndToken.Ip6Token.Packet.TxData = Ip6TxData;
766 }
767
768 //
769 // Set the fields of SndEntry
770 //
771 SndEntry->IpIo = IpIo;
772 SndEntry->Ip = Sender;
773 SndEntry->Context = Context;
774 SndEntry->NotifyData = NotifyData;
775
776 SndEntry->Pkt = Pkt;
777 NET_GET_REF (Pkt);
778
779 InsertTailList (&IpIo->PendingSndList, &SndEntry->Entry);
780
781 return SndEntry;
782
783ON_ERROR:
784
785 if (OverrideData != NULL) {
786 FreePool (OverrideData);
787 }
788
789 if (TxData != NULL) {
790 FreePool (TxData);
791 }
792
793 if (SndEntry != NULL) {
794 FreePool (SndEntry);
795 }
796
797 if (Event != NULL) {
798 gBS->CloseEvent (Event);
799 }
800
801 return NULL;
802}
803
804
805/**
806 Destroy the SndEntry.
807
808 This function pairs with IpIoCreateSndEntry().
809
810 @param[in] SndEntry Pointer to the send entry to be destroyed.
811
812**/
813VOID
814IpIoDestroySndEntry (
815 IN IP_IO_SEND_ENTRY *SndEntry
816 )
817{
818 EFI_EVENT Event;
819 IP_IO_IP_TX_DATA *TxData;
820 IP_IO_OVERRIDE *Override;
821
822 if (SndEntry->IpIo->IpVersion == IP_VERSION_4) {
823 Event = SndEntry->SndToken.Ip4Token.Event;
824 TxData = (IP_IO_IP_TX_DATA *) SndEntry->SndToken.Ip4Token.Packet.TxData;
825 Override = (IP_IO_OVERRIDE *) TxData->Ip4TxData.OverrideData;
826 } else if (SndEntry->IpIo->IpVersion == IP_VERSION_6) {
827 Event = SndEntry->SndToken.Ip6Token.Event;
828 TxData = (IP_IO_IP_TX_DATA *) SndEntry->SndToken.Ip6Token.Packet.TxData;
829 Override = (IP_IO_OVERRIDE *) TxData->Ip6TxData.OverrideData;
830 } else {
831 return ;
832 }
833
834 gBS->CloseEvent (Event);
835
836 FreePool (TxData);
837
838 if (NULL != Override) {
839 FreePool (Override);
840 }
841
842 NetbufFree (SndEntry->Pkt);
843
844 RemoveEntryList (&SndEntry->Entry);
845
846 FreePool (SndEntry);
847}
848
849
850/**
851 Notify function for IP transmit token.
852
853 @param[in] Context The context passed in by the event notifier.
854
855**/
856VOID
857EFIAPI
858IpIoTransmitHandlerDpc (
859 IN VOID *Context
860 )
861{
862 IP_IO *IpIo;
863 IP_IO_SEND_ENTRY *SndEntry;
864 EFI_STATUS Status;
865
866 SndEntry = (IP_IO_SEND_ENTRY *) Context;
867
868 IpIo = SndEntry->IpIo;
869
870 if (IpIo->IpVersion == IP_VERSION_4) {
871 Status = SndEntry->SndToken.Ip4Token.Status;
872 } else if (IpIo->IpVersion == IP_VERSION_6){
873 Status = SndEntry->SndToken.Ip6Token.Status;
874 } else {
875 return ;
876 }
877
878 if ((IpIo->PktSentNotify != NULL) && (SndEntry->NotifyData != NULL)) {
879 IpIo->PktSentNotify (
880 Status,
881 SndEntry->Context,
882 SndEntry->Ip,
883 SndEntry->NotifyData
884 );
885 }
886
887 IpIoDestroySndEntry (SndEntry);
888}
889
890
891/**
892 Notify function for IP transmit token.
893
894 @param[in] Event The event signaled.
895 @param[in] Context The context passed in by the event notifier.
896
897**/
898VOID
899EFIAPI
900IpIoTransmitHandler (
901 IN EFI_EVENT Event,
902 IN VOID *Context
903 )
904{
905 //
906 // Request IpIoTransmitHandlerDpc as a DPC at TPL_CALLBACK
907 //
908 QueueDpc (TPL_CALLBACK, IpIoTransmitHandlerDpc, Context);
909}
910
911
912/**
913 The dummy handler for the dummy IP receive token.
914
915 @param[in] Context The context passed in by the event notifier.
916
917**/
918VOID
919EFIAPI
920IpIoDummyHandlerDpc (
921 IN VOID *Context
922 )
923{
924 IP_IO_IP_INFO *IpInfo;
925 EFI_STATUS Status;
926 EFI_EVENT RecycleEvent;
927
928 IpInfo = (IP_IO_IP_INFO *) Context;
929
930 if ((IpInfo->IpVersion != IP_VERSION_4) && (IpInfo->IpVersion != IP_VERSION_6)) {
931 return ;
932 }
933
934 RecycleEvent = NULL;
935
936 if (IpInfo->IpVersion == IP_VERSION_4) {
937 Status = IpInfo->DummyRcvToken.Ip4Token.Status;
938
939 if (IpInfo->DummyRcvToken.Ip4Token.Packet.RxData != NULL) {
940 RecycleEvent = IpInfo->DummyRcvToken.Ip4Token.Packet.RxData->RecycleSignal;
941 }
942 } else {
943 Status = IpInfo->DummyRcvToken.Ip6Token.Status;
944
945 if (IpInfo->DummyRcvToken.Ip6Token.Packet.RxData != NULL) {
946 RecycleEvent = IpInfo->DummyRcvToken.Ip6Token.Packet.RxData->RecycleSignal;
947 }
948 }
949
950
951
952 if (EFI_ABORTED == Status) {
953 //
954 // The reception is actively aborted by the consumer, directly return.
955 //
956 return;
957 } else if (EFI_SUCCESS == Status) {
958 //
959 // Recycle the RxData.
960 //
961 ASSERT (RecycleEvent != NULL);
962
963 gBS->SignalEvent (RecycleEvent);
964 }
965
966 //
967 // Continue the receive.
968 //
969 if (IpInfo->IpVersion == IP_VERSION_4) {
970 IpInfo->Ip.Ip4->Receive (
971 IpInfo->Ip.Ip4,
972 &IpInfo->DummyRcvToken.Ip4Token
973 );
974 } else {
975 IpInfo->Ip.Ip6->Receive (
976 IpInfo->Ip.Ip6,
977 &IpInfo->DummyRcvToken.Ip6Token
978 );
979 }
980}
981
982
983/**
984 This function add IpIoDummyHandlerDpc to the end of the DPC queue.
985
986 @param[in] Event The event signaled.
987 @param[in] Context The context passed in by the event notifier.
988
989**/
990VOID
991EFIAPI
992IpIoDummyHandler (
993 IN EFI_EVENT Event,
994 IN VOID *Context
995 )
996{
997 //
998 // Request IpIoDummyHandlerDpc as a DPC at TPL_CALLBACK
999 //
1000 QueueDpc (TPL_CALLBACK, IpIoDummyHandlerDpc, Context);
1001}
1002
1003
1004/**
1005 Notify function for the IP receive token, used to process
1006 the received IP packets.
1007
1008 @param[in] Context The context passed in by the event notifier.
1009
1010**/
1011VOID
1012EFIAPI
1013IpIoListenHandlerDpc (
1014 IN VOID *Context
1015 )
1016{
1017 IP_IO *IpIo;
1018 EFI_STATUS Status;
1019 IP_IO_IP_RX_DATA *RxData;
1020 EFI_NET_SESSION_DATA Session;
1021 NET_BUF *Pkt;
1022
1023 IpIo = (IP_IO *) Context;
1024
1025 if (IpIo->IpVersion == IP_VERSION_4) {
1026 Status = IpIo->RcvToken.Ip4Token.Status;
1027 RxData = (IP_IO_IP_RX_DATA *) IpIo->RcvToken.Ip4Token.Packet.RxData;
1028 } else if (IpIo->IpVersion == IP_VERSION_6) {
1029 Status = IpIo->RcvToken.Ip6Token.Status;
1030 RxData = (IP_IO_IP_RX_DATA *) IpIo->RcvToken.Ip6Token.Packet.RxData;
1031 } else {
1032 return;
1033 }
1034
1035 if (EFI_ABORTED == Status) {
1036 //
1037 // The reception is actively aborted by the consumer, directly return.
1038 //
1039 return;
1040 }
1041
1042 if ((EFI_SUCCESS != Status) && (EFI_ICMP_ERROR != Status)) {
1043 //
1044 // Only process the normal packets and the icmp error packets.
1045 //
1046 if (RxData != NULL) {
1047 goto CleanUp;
1048 } else {
1049 goto Resume;
1050 }
1051 }
1052
1053 //
1054 // if RxData is NULL with Status == EFI_SUCCESS or EFI_ICMP_ERROR, this should be a code issue in the low layer (IP).
1055 //
1056 ASSERT (RxData != NULL);
1057 if (RxData == NULL) {
1058 goto Resume;
1059 }
1060
1061 if (NULL == IpIo->PktRcvdNotify) {
1062 goto CleanUp;
1063 }
1064
1065 if (IpIo->IpVersion == IP_VERSION_4) {
1066 ASSERT (RxData->Ip4RxData.Header != NULL);
1067 if (IP4_IS_LOCAL_BROADCAST (EFI_IP4 (RxData->Ip4RxData.Header->SourceAddress))) {
1068 //
1069 // The source address is a broadcast address, discard it.
1070 //
1071 goto CleanUp;
1072 }
1073 if ((EFI_IP4 (RxData->Ip4RxData.Header->SourceAddress) != 0) &&
1074 (IpIo->SubnetMask != 0) &&
1075 IP4_NET_EQUAL (IpIo->StationIp, EFI_NTOHL (((EFI_IP4_RECEIVE_DATA *) RxData)->Header->SourceAddress), IpIo->SubnetMask) &&
1076 !NetIp4IsUnicast (EFI_NTOHL (((EFI_IP4_RECEIVE_DATA *) RxData)->Header->SourceAddress), IpIo->SubnetMask)) {
1077 //
1078 // The source address doesn't match StationIp and it's not a unicast IP address, discard it.
1079 //
1080 goto CleanUp;
1081 }
1082
1083 if (RxData->Ip4RxData.DataLength == 0) {
1084 //
1085 // Discard zero length data payload packet.
1086 //
1087 goto CleanUp;
1088 }
1089
1090 //
1091 // The fragment should always be valid for non-zero length packet.
1092 //
1093 ASSERT (RxData->Ip4RxData.FragmentCount != 0);
1094
1095 //
1096 // Create a netbuffer representing IPv4 packet
1097 //
1098 Pkt = NetbufFromExt (
1099 (NET_FRAGMENT *) RxData->Ip4RxData.FragmentTable,
1100 RxData->Ip4RxData.FragmentCount,
1101 0,
1102 0,
1103 IpIoExtFree,
1104 RxData->Ip4RxData.RecycleSignal
1105 );
1106 if (NULL == Pkt) {
1107 goto CleanUp;
1108 }
1109
1110 //
1111 // Create a net session
1112 //
1113 Session.Source.Addr[0] = EFI_IP4 (RxData->Ip4RxData.Header->SourceAddress);
1114 Session.Dest.Addr[0] = EFI_IP4 (RxData->Ip4RxData.Header->DestinationAddress);
1115 Session.IpHdr.Ip4Hdr = RxData->Ip4RxData.Header;
1116 Session.IpHdrLen = RxData->Ip4RxData.HeaderLength;
1117 Session.IpVersion = IP_VERSION_4;
1118 } else {
1119 ASSERT (RxData->Ip6RxData.Header != NULL);
1120 if (!NetIp6IsValidUnicast(&RxData->Ip6RxData.Header->SourceAddress)) {
1121 goto CleanUp;
1122 }
1123
1124 if (RxData->Ip6RxData.DataLength == 0) {
1125 //
1126 // Discard zero length data payload packet.
1127 //
1128 goto CleanUp;
1129 }
1130
1131 //
1132 // The fragment should always be valid for non-zero length packet.
1133 //
1134 ASSERT (RxData->Ip6RxData.FragmentCount != 0);
1135
1136 //
1137 // Create a netbuffer representing IPv6 packet
1138 //
1139 Pkt = NetbufFromExt (
1140 (NET_FRAGMENT *) RxData->Ip6RxData.FragmentTable,
1141 RxData->Ip6RxData.FragmentCount,
1142 0,
1143 0,
1144 IpIoExtFree,
1145 RxData->Ip6RxData.RecycleSignal
1146 );
1147 if (NULL == Pkt) {
1148 goto CleanUp;
1149 }
1150
1151 //
1152 // Create a net session
1153 //
1154 CopyMem (
1155 &Session.Source,
1156 &RxData->Ip6RxData.Header->SourceAddress,
1157 sizeof(EFI_IPv6_ADDRESS)
1158 );
1159 CopyMem (
1160 &Session.Dest,
1161 &RxData->Ip6RxData.Header->DestinationAddress,
1162 sizeof(EFI_IPv6_ADDRESS)
1163 );
1164 Session.IpHdr.Ip6Hdr = RxData->Ip6RxData.Header;
1165 Session.IpHdrLen = RxData->Ip6RxData.HeaderLength;
1166 Session.IpVersion = IP_VERSION_6;
1167 }
1168
1169 if (EFI_SUCCESS == Status) {
1170
1171 IpIo->PktRcvdNotify (EFI_SUCCESS, 0, &Session, Pkt, IpIo->RcvdContext);
1172 } else {
1173 //
1174 // Status is EFI_ICMP_ERROR
1175 //
1176 Status = IpIoIcmpHandler (IpIo, Pkt, &Session);
1177 if (EFI_ERROR (Status)) {
1178 NetbufFree (Pkt);
1179 }
1180 }
1181
1182 goto Resume;
1183
1184CleanUp:
1185
1186 if (IpIo->IpVersion == IP_VERSION_4){
1187 gBS->SignalEvent (RxData->Ip4RxData.RecycleSignal);
1188 } else {
1189 gBS->SignalEvent (RxData->Ip6RxData.RecycleSignal);
1190 }
1191
1192Resume:
1193
1194 if (IpIo->IpVersion == IP_VERSION_4){
1195 IpIo->Ip.Ip4->Receive (IpIo->Ip.Ip4, &(IpIo->RcvToken.Ip4Token));
1196 } else {
1197 IpIo->Ip.Ip6->Receive (IpIo->Ip.Ip6, &(IpIo->RcvToken.Ip6Token));
1198 }
1199}
1200
1201/**
1202 This function add IpIoListenHandlerDpc to the end of the DPC queue.
1203
1204 @param[in] Event The event signaled.
1205 @param[in] Context The context passed in by the event notifier.
1206
1207**/
1208VOID
1209EFIAPI
1210IpIoListenHandler (
1211 IN EFI_EVENT Event,
1212 IN VOID *Context
1213 )
1214{
1215 //
1216 // Request IpIoListenHandlerDpc as a DPC at TPL_CALLBACK
1217 //
1218 QueueDpc (TPL_CALLBACK, IpIoListenHandlerDpc, Context);
1219}
1220
1221
1222/**
1223 Create a new IP_IO instance.
1224
1225 If IpVersion is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
1226
1227 This function uses IP4/IP6 service binding protocol in Controller to create
1228 an IP4/IP6 child (aka IP4/IP6 instance).
1229
1230 @param[in] Image The image handle of the driver or application that
1231 consumes IP_IO.
1232 @param[in] Controller The controller handle that has IP4 or IP6 service
1233 binding protocol installed.
1234 @param[in] IpVersion The version of the IP protocol to use, either
1235 IPv4 or IPv6.
1236
1237 @return Pointer to a newly created IP_IO instance, or NULL if failed.
1238
1239**/
1240IP_IO *
1241EFIAPI
1242IpIoCreate (
1243 IN EFI_HANDLE Image,
1244 IN EFI_HANDLE Controller,
1245 IN UINT8 IpVersion
1246 )
1247{
1248 EFI_STATUS Status;
1249 IP_IO *IpIo;
1250 EFI_EVENT Event;
1251
1252 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));
1253
1254 IpIo = AllocateZeroPool (sizeof (IP_IO));
1255 if (NULL == IpIo) {
1256 return NULL;
1257 }
1258
1259 InitializeListHead (&(IpIo->PendingSndList));
1260 InitializeListHead (&(IpIo->IpList));
1261 IpIo->Controller = Controller;
1262 IpIo->Image = Image;
1263 IpIo->IpVersion = IpVersion;
1264 Event = NULL;
1265
1266 Status = gBS->CreateEvent (
1267 EVT_NOTIFY_SIGNAL,
1268 TPL_NOTIFY,
1269 IpIoListenHandler,
1270 IpIo,
1271 &Event
1272 );
1273 if (EFI_ERROR (Status)) {
1274 goto ReleaseIpIo;
1275 }
1276
1277 if (IpVersion == IP_VERSION_4) {
1278 IpIo->RcvToken.Ip4Token.Event = Event;
1279 } else {
1280 IpIo->RcvToken.Ip6Token.Event = Event;
1281 }
1282
1283 //
1284 // Create an IP child and open IP protocol
1285 //
1286 Status = IpIoCreateIpChildOpenProtocol (
1287 Controller,
1288 Image,
1289 &IpIo->ChildHandle,
1290 IpVersion,
1291 (VOID **) & (IpIo->Ip)
1292 );
1293 if (EFI_ERROR (Status)) {
1294 goto ReleaseIpIo;
1295 }
1296
1297 return IpIo;
1298
1299ReleaseIpIo:
1300
1301 if (Event != NULL) {
1302 gBS->CloseEvent (Event);
1303 }
1304
1305 gBS->FreePool (IpIo);
1306
1307 return NULL;
1308}
1309
1310
1311/**
1312 Open an IP_IO instance for use.
1313
1314 If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
1315
1316 This function is called after IpIoCreate(). It is used for configuring the IP
1317 instance and register the callbacks and their context data for sending and
1318 receiving IP packets.
1319
1320 @param[in, out] IpIo Pointer to an IP_IO instance that needs
1321 to open.
1322 @param[in] OpenData The configuration data and callbacks for
1323 the IP_IO instance.
1324
1325 @retval EFI_SUCCESS The IP_IO instance opened with OpenData
1326 successfully.
1327 @retval EFI_ACCESS_DENIED The IP_IO instance is configured, avoid to
1328 reopen it.
1329 @retval EFI_UNSUPPORTED IPv4 RawData mode is no supported.
1330 @retval EFI_INVALID_PARAMETER Invalid input parameter.
1331 @retval Others Error condition occurred.
1332
1333**/
1334EFI_STATUS
1335EFIAPI
1336IpIoOpen (
1337 IN OUT IP_IO *IpIo,
1338 IN IP_IO_OPEN_DATA *OpenData
1339 )
1340{
1341 EFI_STATUS Status;
1342 UINT8 IpVersion;
1343
1344 if (IpIo == NULL || OpenData == NULL) {
1345 return EFI_INVALID_PARAMETER;
1346 }
1347
1348 if (IpIo->IsConfigured) {
1349 return EFI_ACCESS_DENIED;
1350 }
1351
1352 IpVersion = IpIo->IpVersion;
1353
1354 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));
1355
1356 //
1357 // configure ip
1358 //
1359 if (IpVersion == IP_VERSION_4){
1360 //
1361 // RawData mode is no supported.
1362 //
1363 ASSERT (!OpenData->IpConfigData.Ip4CfgData.RawData);
1364 if (OpenData->IpConfigData.Ip4CfgData.RawData) {
1365 return EFI_UNSUPPORTED;
1366 }
1367
1368 if (!OpenData->IpConfigData.Ip4CfgData.UseDefaultAddress) {
1369 IpIo->StationIp = EFI_NTOHL (OpenData->IpConfigData.Ip4CfgData.StationAddress);
1370 IpIo->SubnetMask = EFI_NTOHL (OpenData->IpConfigData.Ip4CfgData.SubnetMask);
1371 }
1372
1373 Status = IpIo->Ip.Ip4->Configure (
1374 IpIo->Ip.Ip4,
1375 &OpenData->IpConfigData.Ip4CfgData
1376 );
1377 } else {
1378
1379 Status = IpIo->Ip.Ip6->Configure (
1380 IpIo->Ip.Ip6,
1381 &OpenData->IpConfigData.Ip6CfgData
1382 );
1383 }
1384
1385 if (EFI_ERROR (Status)) {
1386 return Status;
1387 }
1388
1389 //
1390 // @bug To delete the default route entry in this Ip, if it is:
1391 // @bug (0.0.0.0, 0.0.0.0, 0.0.0.0). Delete this statement if Ip modified
1392 // @bug its code
1393 //
1394 if (IpVersion == IP_VERSION_4){
1395 Status = IpIo->Ip.Ip4->Routes (
1396 IpIo->Ip.Ip4,
1397 TRUE,
1398 &mZeroIp4Addr,
1399 &mZeroIp4Addr,
1400 &mZeroIp4Addr
1401 );
1402
1403 if (EFI_ERROR (Status) && (EFI_NOT_FOUND != Status)) {
1404 return Status;
1405 }
1406 }
1407
1408 IpIo->PktRcvdNotify = OpenData->PktRcvdNotify;
1409 IpIo->PktSentNotify = OpenData->PktSentNotify;
1410
1411 IpIo->RcvdContext = OpenData->RcvdContext;
1412 IpIo->SndContext = OpenData->SndContext;
1413
1414 if (IpVersion == IP_VERSION_4){
1415 IpIo->Protocol = OpenData->IpConfigData.Ip4CfgData.DefaultProtocol;
1416
1417 //
1418 // start to listen incoming packet
1419 //
1420 Status = IpIo->Ip.Ip4->Receive (
1421 IpIo->Ip.Ip4,
1422 &(IpIo->RcvToken.Ip4Token)
1423 );
1424 if (EFI_ERROR (Status)) {
1425 IpIo->Ip.Ip4->Configure (IpIo->Ip.Ip4, NULL);
1426 return Status;
1427 }
1428
1429 } else {
1430
1431 IpIo->Protocol = OpenData->IpConfigData.Ip6CfgData.DefaultProtocol;
1432 Status = IpIo->Ip.Ip6->Receive (
1433 IpIo->Ip.Ip6,
1434 &(IpIo->RcvToken.Ip6Token)
1435 );
1436 if (EFI_ERROR (Status)) {
1437 IpIo->Ip.Ip6->Configure (IpIo->Ip.Ip6, NULL);
1438 return Status;
1439 }
1440 }
1441
1442 IpIo->IsConfigured = TRUE;
1443 InsertTailList (&mActiveIpIoList, &IpIo->Entry);
1444
1445 return Status;
1446}
1447
1448
1449/**
1450 Stop an IP_IO instance.
1451
1452 If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
1453
1454 This function is paired with IpIoOpen(). The IP_IO will be unconfigured and all
1455 the pending send/receive tokens will be canceled.
1456
1457 @param[in, out] IpIo Pointer to the IP_IO instance that needs to stop.
1458
1459 @retval EFI_SUCCESS The IP_IO instance stopped successfully.
1460 @retval EFI_INVALID_PARAMETER Invalid input parameter.
1461 @retval Others Error condition occurred.
1462
1463**/
1464EFI_STATUS
1465EFIAPI
1466IpIoStop (
1467 IN OUT IP_IO *IpIo
1468 )
1469{
1470 EFI_STATUS Status;
1471 IP_IO_IP_INFO *IpInfo;
1472 UINT8 IpVersion;
1473
1474 if (IpIo == NULL) {
1475 return EFI_INVALID_PARAMETER;
1476 }
1477
1478 if (!IpIo->IsConfigured) {
1479 return EFI_SUCCESS;
1480 }
1481
1482 IpVersion = IpIo->IpVersion;
1483
1484 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));
1485
1486 //
1487 // Remove the IpIo from the active IpIo list.
1488 //
1489 RemoveEntryList (&IpIo->Entry);
1490
1491 //
1492 // Configure NULL Ip
1493 //
1494 if (IpVersion == IP_VERSION_4) {
1495 Status = IpIo->Ip.Ip4->Configure (IpIo->Ip.Ip4, NULL);
1496 } else {
1497 Status = IpIo->Ip.Ip6->Configure (IpIo->Ip.Ip6, NULL);
1498 }
1499 if (EFI_ERROR (Status)) {
1500 return Status;
1501 }
1502
1503 IpIo->IsConfigured = FALSE;
1504
1505 //
1506 // Detroy the Ip List used by IpIo
1507 //
1508
1509 while (!IsListEmpty (&(IpIo->IpList))) {
1510 IpInfo = NET_LIST_HEAD (&(IpIo->IpList), IP_IO_IP_INFO, Entry);
1511
1512 IpIoRemoveIp (IpIo, IpInfo);
1513 }
1514
1515 //
1516 // All pending send tokens should be flushed by resetting the IP instances.
1517 //
1518 ASSERT (IsListEmpty (&IpIo->PendingSndList));
1519
1520 //
1521 // Close the receive event.
1522 //
1523 if (IpVersion == IP_VERSION_4){
1524 gBS->CloseEvent (IpIo->RcvToken.Ip4Token.Event);
1525 } else {
1526 gBS->CloseEvent (IpIo->RcvToken.Ip6Token.Event);
1527 }
1528
1529 return EFI_SUCCESS;
1530}
1531
1532
1533/**
1534 Destroy an IP_IO instance.
1535
1536 This function is paired with IpIoCreate(). The IP_IO will be closed first.
1537 Resource will be freed afterwards. See IpIoCloseProtocolDestroyIpChild().
1538
1539 @param[in, out] IpIo Pointer to the IP_IO instance that needs to be
1540 destroyed.
1541
1542 @retval EFI_SUCCESS The IP_IO instance destroyed successfully.
1543 @retval Others Error condition occurred.
1544
1545**/
1546EFI_STATUS
1547EFIAPI
1548IpIoDestroy (
1549 IN OUT IP_IO *IpIo
1550 )
1551{
1552 EFI_STATUS Status;
1553
1554 //
1555 // Stop the IpIo.
1556 //
1557 Status = IpIoStop (IpIo);
1558 if (EFI_ERROR (Status)) {
1559 return Status;
1560 }
1561
1562 //
1563 // Close the IP protocol and destroy the child.
1564 //
1565 Status = IpIoCloseProtocolDestroyIpChild (
1566 IpIo->Controller,
1567 IpIo->Image,
1568 IpIo->ChildHandle,
1569 IpIo->IpVersion
1570 );
1571 if (EFI_ERROR (Status)) {
1572 return Status;
1573 }
1574
1575 gBS->FreePool (IpIo);
1576
1577 return EFI_SUCCESS;
1578}
1579
1580
1581/**
1582 Send out an IP packet.
1583
1584 This function is called after IpIoOpen(). The data to be sent is wrapped in
1585 Pkt. The IP instance wrapped in IpIo is used for sending by default but can be
1586 overriden by Sender. Other sending configs, like source address and gateway
1587 address etc., are specified in OverrideData.
1588
1589 @param[in, out] IpIo Pointer to an IP_IO instance used for sending IP
1590 packet.
1591 @param[in, out] Pkt Pointer to the IP packet to be sent.
1592 @param[in] Sender The IP protocol instance used for sending.
1593 @param[in] Context Optional context data.
1594 @param[in] NotifyData Optional notify data.
1595 @param[in] Dest The destination IP address to send this packet to.
1596 This parameter is optional when using IPv6.
1597 @param[in] OverrideData The data to override some configuration of the IP
1598 instance used for sending.
1599
1600 @retval EFI_SUCCESS The operation is completed successfully.
1601 @retval EFI_INVALID_PARAMETER The input parameter is not correct.
1602 @retval EFI_NOT_STARTED The IpIo is not configured.
1603 @retval EFI_OUT_OF_RESOURCES Failed due to resource limit.
1604 @retval Others Error condition occurred.
1605
1606**/
1607EFI_STATUS
1608EFIAPI
1609IpIoSend (
1610 IN OUT IP_IO *IpIo,
1611 IN OUT NET_BUF *Pkt,
1612 IN IP_IO_IP_INFO *Sender OPTIONAL,
1613 IN VOID *Context OPTIONAL,
1614 IN VOID *NotifyData OPTIONAL,
1615 IN EFI_IP_ADDRESS *Dest OPTIONAL,
1616 IN IP_IO_OVERRIDE *OverrideData OPTIONAL
1617 )
1618{
1619 EFI_STATUS Status;
1620 IP_IO_IP_PROTOCOL Ip;
1621 IP_IO_SEND_ENTRY *SndEntry;
1622
1623 if ((IpIo == NULL) || (Pkt == NULL)) {
1624 return EFI_INVALID_PARAMETER;
1625 }
1626
1627 if ((IpIo->IpVersion == IP_VERSION_4) && (Dest == NULL)) {
1628 return EFI_INVALID_PARAMETER;
1629 }
1630
1631 if (!IpIo->IsConfigured) {
1632 return EFI_NOT_STARTED;
1633 }
1634
1635 Ip = (NULL == Sender) ? IpIo->Ip : Sender->Ip;
1636
1637 //
1638 // create a new SndEntry
1639 //
1640 SndEntry = IpIoCreateSndEntry (IpIo, Pkt, Ip, Context, NotifyData, Dest, OverrideData);
1641 if (NULL == SndEntry) {
1642 return EFI_OUT_OF_RESOURCES;
1643 }
1644
1645 //
1646 // Send this Packet
1647 //
1648 if (IpIo->IpVersion == IP_VERSION_4){
1649 Status = Ip.Ip4->Transmit (
1650 Ip.Ip4,
1651 &SndEntry->SndToken.Ip4Token
1652 );
1653 } else {
1654 Status = Ip.Ip6->Transmit (
1655 Ip.Ip6,
1656 &SndEntry->SndToken.Ip6Token
1657 );
1658 }
1659
1660 if (EFI_ERROR (Status)) {
1661 IpIoDestroySndEntry (SndEntry);
1662 }
1663
1664 return Status;
1665}
1666
1667
1668/**
1669 Cancel the IP transmit token which wraps this Packet.
1670
1671 If IpIo is NULL, then ASSERT().
1672 If Packet is NULL, then ASSERT().
1673
1674 @param[in] IpIo Pointer to the IP_IO instance.
1675 @param[in] Packet Pointer to the packet of NET_BUF to cancel.
1676
1677**/
1678VOID
1679EFIAPI
1680IpIoCancelTxToken (
1681 IN IP_IO *IpIo,
1682 IN VOID *Packet
1683 )
1684{
1685 LIST_ENTRY *Node;
1686 IP_IO_SEND_ENTRY *SndEntry;
1687 IP_IO_IP_PROTOCOL Ip;
1688
1689 ASSERT ((IpIo != NULL) && (Packet != NULL));
1690
1691 NET_LIST_FOR_EACH (Node, &IpIo->PendingSndList) {
1692
1693 SndEntry = NET_LIST_USER_STRUCT (Node, IP_IO_SEND_ENTRY, Entry);
1694
1695 if (SndEntry->Pkt == Packet) {
1696
1697 Ip = SndEntry->Ip;
1698
1699 if (IpIo->IpVersion == IP_VERSION_4) {
1700 Ip.Ip4->Cancel (
1701 Ip.Ip4,
1702 &SndEntry->SndToken.Ip4Token
1703 );
1704 } else {
1705 Ip.Ip6->Cancel (
1706 Ip.Ip6,
1707 &SndEntry->SndToken.Ip6Token
1708 );
1709 }
1710
1711 break;
1712 }
1713 }
1714
1715}
1716
1717
1718/**
1719 Add a new IP instance for sending data.
1720
1721 If IpIo is NULL, then ASSERT().
1722 If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
1723
1724 The function is used to add the IP_IO to the IP_IO sending list. The caller
1725 can later use IpIoFindSender() to get the IP_IO and call IpIoSend() to send
1726 data.
1727
1728 @param[in, out] IpIo Pointer to a IP_IO instance to add a new IP
1729 instance for sending purpose.
1730
1731 @return Pointer to the created IP_IO_IP_INFO structure, NULL if failed.
1732
1733**/
1734IP_IO_IP_INFO *
1735EFIAPI
1736IpIoAddIp (
1737 IN OUT IP_IO *IpIo
1738 )
1739{
1740 EFI_STATUS Status;
1741 IP_IO_IP_INFO *IpInfo;
1742 EFI_EVENT Event;
1743
1744 ASSERT (IpIo != NULL);
1745 ASSERT ((IpIo->IpVersion == IP_VERSION_4) || (IpIo->IpVersion == IP_VERSION_6));
1746
1747 IpInfo = AllocatePool (sizeof (IP_IO_IP_INFO));
1748 if (IpInfo == NULL) {
1749 return NULL;
1750 }
1751
1752 //
1753 // Init this IpInfo, set the Addr and SubnetMask to 0 before we configure the IP
1754 // instance.
1755 //
1756 InitializeListHead (&IpInfo->Entry);
1757 IpInfo->ChildHandle = NULL;
1758 ZeroMem (&IpInfo->Addr, sizeof (IpInfo->Addr));
1759 ZeroMem (&IpInfo->PreMask, sizeof (IpInfo->PreMask));
1760
1761 IpInfo->RefCnt = 1;
1762 IpInfo->IpVersion = IpIo->IpVersion;
1763
1764 //
1765 // Create the IP instance and open the IP protocol.
1766 //
1767 Status = IpIoCreateIpChildOpenProtocol (
1768 IpIo->Controller,
1769 IpIo->Image,
1770 &IpInfo->ChildHandle,
1771 IpInfo->IpVersion,
1772 (VOID **) &IpInfo->Ip
1773 );
1774 if (EFI_ERROR (Status)) {
1775 goto ReleaseIpInfo;
1776 }
1777
1778 //
1779 // Create the event for the DummyRcvToken.
1780 //
1781 Status = gBS->CreateEvent (
1782 EVT_NOTIFY_SIGNAL,
1783 TPL_NOTIFY,
1784 IpIoDummyHandler,
1785 IpInfo,
1786 &Event
1787 );
1788 if (EFI_ERROR (Status)) {
1789 goto ReleaseIpChild;
1790 }
1791
1792 if (IpInfo->IpVersion == IP_VERSION_4) {
1793 IpInfo->DummyRcvToken.Ip4Token.Event = Event;
1794 } else {
1795 IpInfo->DummyRcvToken.Ip6Token.Event = Event;
1796 }
1797
1798 //
1799 // Link this IpInfo into the IpIo.
1800 //
1801 InsertTailList (&IpIo->IpList, &IpInfo->Entry);
1802
1803 return IpInfo;
1804
1805ReleaseIpChild:
1806
1807 IpIoCloseProtocolDestroyIpChild (
1808 IpIo->Controller,
1809 IpIo->Image,
1810 IpInfo->ChildHandle,
1811 IpInfo->IpVersion
1812 );
1813
1814ReleaseIpInfo:
1815
1816 gBS->FreePool (IpInfo);
1817
1818 return NULL;
1819}
1820
1821
1822/**
1823 Configure the IP instance of this IpInfo and start the receiving if IpConfigData
1824 is not NULL.
1825
1826 If IpInfo is NULL, then ASSERT().
1827 If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
1828
1829 @param[in, out] IpInfo Pointer to the IP_IO_IP_INFO instance.
1830 @param[in, out] IpConfigData The IP configure data used to configure the IP
1831 instance, if NULL the IP instance is reset. If
1832 UseDefaultAddress is set to TRUE, and the configure
1833 operation succeeds, the default address information
1834 is written back in this IpConfigData.
1835
1836 @retval EFI_SUCCESS The IP instance of this IpInfo is configured successfully
1837 or no need to reconfigure it.
1838 @retval Others Configuration fails.
1839
1840**/
1841EFI_STATUS
1842EFIAPI
1843IpIoConfigIp (
1844 IN OUT IP_IO_IP_INFO *IpInfo,
1845 IN OUT VOID *IpConfigData OPTIONAL
1846 )
1847{
1848 EFI_STATUS Status;
1849 IP_IO_IP_PROTOCOL Ip;
1850 UINT8 IpVersion;
1851 EFI_IP4_MODE_DATA Ip4ModeData;
1852 EFI_IP6_MODE_DATA Ip6ModeData;
1853
1854 ASSERT (IpInfo != NULL);
1855
1856 if (IpInfo->RefCnt > 1) {
1857 //
1858 // This IP instance is shared, don't reconfigure it until it has only one
1859 // consumer. Currently, only the tcp children cloned from their passive parent
1860 // will share the same IP. So this cases only happens while IpConfigData is NULL,
1861 // let the last consumer clean the IP instance.
1862 //
1863 return EFI_SUCCESS;
1864 }
1865
1866 IpVersion = IpInfo->IpVersion;
1867 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));
1868
1869 Ip = IpInfo->Ip;
1870
1871 if (IpInfo->IpVersion == IP_VERSION_4) {
1872 Status = Ip.Ip4->Configure (Ip.Ip4, IpConfigData);
1873 } else {
1874 Status = Ip.Ip6->Configure (Ip.Ip6, IpConfigData);
1875 }
1876
1877 if (EFI_ERROR (Status)) {
1878 return Status;
1879 }
1880
1881 if (IpConfigData != NULL) {
1882 if (IpInfo->IpVersion == IP_VERSION_4) {
1883
1884 if (((EFI_IP4_CONFIG_DATA *) IpConfigData)->UseDefaultAddress) {
1885 Status = Ip.Ip4->GetModeData (
1886 Ip.Ip4,
1887 &Ip4ModeData,
1888 NULL,
1889 NULL
1890 );
1891 if (EFI_ERROR (Status)) {
1892 Ip.Ip4->Configure (Ip.Ip4, NULL);
1893 return Status;
1894 }
1895
1896 IP4_COPY_ADDRESS (&((EFI_IP4_CONFIG_DATA*) IpConfigData)->StationAddress, &Ip4ModeData.ConfigData.StationAddress);
1897 IP4_COPY_ADDRESS (&((EFI_IP4_CONFIG_DATA*) IpConfigData)->SubnetMask, &Ip4ModeData.ConfigData.SubnetMask);
1898 }
1899
1900 CopyMem (
1901 &IpInfo->Addr.Addr,
1902 &((EFI_IP4_CONFIG_DATA *) IpConfigData)->StationAddress,
1903 sizeof (IP4_ADDR)
1904 );
1905 CopyMem (
1906 &IpInfo->PreMask.SubnetMask,
1907 &((EFI_IP4_CONFIG_DATA *) IpConfigData)->SubnetMask,
1908 sizeof (IP4_ADDR)
1909 );
1910
1911 Status = Ip.Ip4->Receive (
1912 Ip.Ip4,
1913 &IpInfo->DummyRcvToken.Ip4Token
1914 );
1915 if (EFI_ERROR (Status)) {
1916 Ip.Ip4->Configure (Ip.Ip4, NULL);
1917 }
1918 } else {
1919 Status = Ip.Ip6->GetModeData (
1920 Ip.Ip6,
1921 &Ip6ModeData,
1922 NULL,
1923 NULL
1924 );
1925 if (EFI_ERROR (Status)) {
1926 Ip.Ip6->Configure (Ip.Ip6, NULL);
1927 return Status;
1928 }
1929
1930 if (Ip6ModeData.IsConfigured) {
1931 CopyMem (
1932 &((EFI_IP6_CONFIG_DATA *) IpConfigData)->StationAddress,
1933 &Ip6ModeData.ConfigData.StationAddress,
1934 sizeof (EFI_IPv6_ADDRESS)
1935 );
1936
1937 if (Ip6ModeData.AddressList != NULL) {
1938 FreePool (Ip6ModeData.AddressList);
1939 }
1940
1941 if (Ip6ModeData.GroupTable != NULL) {
1942 FreePool (Ip6ModeData.GroupTable);
1943 }
1944
1945 if (Ip6ModeData.RouteTable != NULL) {
1946 FreePool (Ip6ModeData.RouteTable);
1947 }
1948
1949 if (Ip6ModeData.NeighborCache != NULL) {
1950 FreePool (Ip6ModeData.NeighborCache);
1951 }
1952
1953 if (Ip6ModeData.PrefixTable != NULL) {
1954 FreePool (Ip6ModeData.PrefixTable);
1955 }
1956
1957 if (Ip6ModeData.IcmpTypeList != NULL) {
1958 FreePool (Ip6ModeData.IcmpTypeList);
1959 }
1960
1961 } else {
1962 Status = EFI_NO_MAPPING;
1963 return Status;
1964 }
1965
1966 CopyMem (
1967 &IpInfo->Addr,
1968 &Ip6ModeData.ConfigData.StationAddress,
1969 sizeof (EFI_IPv6_ADDRESS)
1970 );
1971
1972 Status = Ip.Ip6->Receive (
1973 Ip.Ip6,
1974 &IpInfo->DummyRcvToken.Ip6Token
1975 );
1976 if (EFI_ERROR (Status)) {
1977 Ip.Ip6->Configure (Ip.Ip6, NULL);
1978 }
1979 }
1980 } else {
1981 //
1982 // The IP instance is reset, set the stored Addr and SubnetMask to zero.
1983 //
1984 ZeroMem (&IpInfo->Addr, sizeof (IpInfo->Addr));
1985 ZeroMem (&IpInfo->PreMask, sizeof (IpInfo->PreMask));
1986 }
1987
1988 return Status;
1989}
1990
1991
1992/**
1993 Destroy an IP instance maintained in IpIo->IpList for
1994 sending purpose.
1995
1996 If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
1997
1998 This function pairs with IpIoAddIp(). The IpInfo is previously created by
1999 IpIoAddIp(). The IP_IO_IP_INFO::RefCnt is decremented and the IP instance
2000 will be dstroyed if the RefCnt is zero.
2001
2002 @param[in] IpIo Pointer to the IP_IO instance.
2003 @param[in] IpInfo Pointer to the IpInfo to be removed.
2004
2005**/
2006VOID
2007EFIAPI
2008IpIoRemoveIp (
2009 IN IP_IO *IpIo,
2010 IN IP_IO_IP_INFO *IpInfo
2011 )
2012{
2013
2014 UINT8 IpVersion;
2015
2016 if (IpIo == NULL || IpInfo == NULL) {
2017 return;
2018 }
2019
2020 ASSERT (IpInfo->RefCnt > 0);
2021
2022 NET_PUT_REF (IpInfo);
2023
2024 if (IpInfo->RefCnt > 0) {
2025
2026 return;
2027 }
2028
2029 IpVersion = IpIo->IpVersion;
2030
2031 ASSERT ((IpVersion == IP_VERSION_4) || (IpVersion == IP_VERSION_6));
2032
2033 RemoveEntryList (&IpInfo->Entry);
2034
2035 if (IpVersion == IP_VERSION_4){
2036 IpInfo->Ip.Ip4->Configure (
2037 IpInfo->Ip.Ip4,
2038 NULL
2039 );
2040 IpIoCloseProtocolDestroyIpChild (
2041 IpIo->Controller,
2042 IpIo->Image,
2043 IpInfo->ChildHandle,
2044 IP_VERSION_4
2045 );
2046
2047 gBS->CloseEvent (IpInfo->DummyRcvToken.Ip4Token.Event);
2048
2049 } else {
2050
2051 IpInfo->Ip.Ip6->Configure (
2052 IpInfo->Ip.Ip6,
2053 NULL
2054 );
2055
2056 IpIoCloseProtocolDestroyIpChild (
2057 IpIo->Controller,
2058 IpIo->Image,
2059 IpInfo->ChildHandle,
2060 IP_VERSION_6
2061 );
2062
2063 gBS->CloseEvent (IpInfo->DummyRcvToken.Ip6Token.Event);
2064 }
2065
2066 FreePool (IpInfo);
2067}
2068
2069
2070/**
2071 Find the first IP protocol maintained in IpIo whose local
2072 address is the same as Src.
2073
2074 This function is called when the caller needs the IpIo to send data to the
2075 specified Src. The IpIo was added previously by IpIoAddIp().
2076
2077 @param[in, out] IpIo Pointer to the pointer of the IP_IO instance.
2078 @param[in] IpVersion The version of the IP protocol to use, either
2079 IPv4 or IPv6.
2080 @param[in] Src The local IP address.
2081
2082 @return Pointer to the IP protocol can be used for sending purpose and its local
2083 address is the same with Src. NULL if failed.
2084
2085**/
2086IP_IO_IP_INFO *
2087EFIAPI
2088IpIoFindSender (
2089 IN OUT IP_IO **IpIo,
2090 IN UINT8 IpVersion,
2091 IN EFI_IP_ADDRESS *Src
2092 )
2093{
2094 LIST_ENTRY *IpIoEntry;
2095 IP_IO *IpIoPtr;
2096 LIST_ENTRY *IpInfoEntry;
2097 IP_IO_IP_INFO *IpInfo;
2098
2099 if (IpIo == NULL || Src == NULL) {
2100 return NULL;
2101 }
2102
2103 if ((IpVersion != IP_VERSION_4) && (IpVersion != IP_VERSION_6)) {
2104 return NULL;
2105 }
2106
2107 NET_LIST_FOR_EACH (IpIoEntry, &mActiveIpIoList) {
2108 IpIoPtr = NET_LIST_USER_STRUCT (IpIoEntry, IP_IO, Entry);
2109
2110 if (((*IpIo != NULL) && (*IpIo != IpIoPtr)) || (IpIoPtr->IpVersion != IpVersion)) {
2111 continue;
2112 }
2113
2114 NET_LIST_FOR_EACH (IpInfoEntry, &IpIoPtr->IpList) {
2115 IpInfo = NET_LIST_USER_STRUCT (IpInfoEntry, IP_IO_IP_INFO, Entry);
2116 if (IpInfo->IpVersion == IP_VERSION_4){
2117
2118 if (EFI_IP4_EQUAL (&IpInfo->Addr.v4, &Src->v4)) {
2119 *IpIo = IpIoPtr;
2120 return IpInfo;
2121 }
2122
2123 } else {
2124
2125 if (EFI_IP6_EQUAL (&IpInfo->Addr.v6, &Src->v6)) {
2126 *IpIo = IpIoPtr;
2127 return IpInfo;
2128 }
2129 }
2130 }
2131 }
2132
2133 //
2134 // No match.
2135 //
2136 return NULL;
2137}
2138
2139
2140/**
2141 Get the ICMP error map information.
2142
2143 The ErrorStatus will be returned. The IsHard and Notify are optional. If they
2144 are not NULL, this routine will fill them.
2145
2146 @param[in] IcmpError IcmpError Type.
2147 @param[in] IpVersion The version of the IP protocol to use,
2148 either IPv4 or IPv6.
2149 @param[out] IsHard If TRUE, indicates that it is a hard error.
2150 @param[out] Notify If TRUE, SockError needs to be notified.
2151
2152 @retval EFI_UNSUPPORTED Unrecognizable ICMP error code.
2153 @return ICMP Error Status, such as EFI_NETWORK_UNREACHABLE.
2154
2155**/
2156EFI_STATUS
2157EFIAPI
2158IpIoGetIcmpErrStatus (
2159 IN UINT8 IcmpError,
2160 IN UINT8 IpVersion,
2161 OUT BOOLEAN *IsHard OPTIONAL,
2162 OUT BOOLEAN *Notify OPTIONAL
2163 )
2164{
2165 if (IpVersion == IP_VERSION_4 ) {
2166 ASSERT (IcmpError <= ICMP_ERR_PARAMPROB);
2167
2168 if (IsHard != NULL) {
2169 *IsHard = mIcmpErrMap[IcmpError].IsHard;
2170 }
2171
2172 if (Notify != NULL) {
2173 *Notify = mIcmpErrMap[IcmpError].Notify;
2174 }
2175
2176 switch (IcmpError) {
2177 case ICMP_ERR_UNREACH_NET:
2178 return EFI_NETWORK_UNREACHABLE;
2179
2180 case ICMP_ERR_TIMXCEED_INTRANS:
2181 case ICMP_ERR_TIMXCEED_REASS:
2182 case ICMP_ERR_UNREACH_HOST:
2183 return EFI_HOST_UNREACHABLE;
2184
2185 case ICMP_ERR_UNREACH_PROTOCOL:
2186 return EFI_PROTOCOL_UNREACHABLE;
2187
2188 case ICMP_ERR_UNREACH_PORT:
2189 return EFI_PORT_UNREACHABLE;
2190
2191 case ICMP_ERR_MSGSIZE:
2192 case ICMP_ERR_UNREACH_SRCFAIL:
2193 case ICMP_ERR_QUENCH:
2194 case ICMP_ERR_PARAMPROB:
2195 return EFI_ICMP_ERROR;
2196
2197 default:
2198 ASSERT (FALSE);
2199 return EFI_UNSUPPORTED;
2200 }
2201
2202 } else if (IpVersion == IP_VERSION_6) {
2203
2204 ASSERT (IcmpError <= ICMP6_ERR_PARAMPROB_IPV6OPTION);
2205
2206 if (IsHard != NULL) {
2207 *IsHard = mIcmp6ErrMap[IcmpError].IsHard;
2208 }
2209
2210 if (Notify != NULL) {
2211 *Notify = mIcmp6ErrMap[IcmpError].Notify;
2212 }
2213
2214 switch (IcmpError) {
2215 case ICMP6_ERR_UNREACH_NET:
2216 return EFI_NETWORK_UNREACHABLE;
2217
2218 case ICMP6_ERR_UNREACH_HOST:
2219 case ICMP6_ERR_TIMXCEED_HOPLIMIT:
2220 case ICMP6_ERR_TIMXCEED_REASS:
2221 return EFI_HOST_UNREACHABLE;
2222
2223 case ICMP6_ERR_UNREACH_PROTOCOL:
2224 return EFI_PROTOCOL_UNREACHABLE;
2225
2226 case ICMP6_ERR_UNREACH_PORT:
2227 return EFI_PORT_UNREACHABLE;
2228
2229 case ICMP6_ERR_PACKAGE_TOOBIG:
2230 case ICMP6_ERR_PARAMPROB_HEADER:
2231 case ICMP6_ERR_PARAMPROB_NEXHEADER:
2232 case ICMP6_ERR_PARAMPROB_IPV6OPTION:
2233 return EFI_ICMP_ERROR;
2234
2235 default:
2236 ASSERT (FALSE);
2237 return EFI_UNSUPPORTED;
2238 }
2239
2240 } else {
2241 //
2242 // Should never be here
2243 //
2244 ASSERT (FALSE);
2245 return EFI_UNSUPPORTED;
2246 }
2247}
2248
2249
2250/**
2251 Refresh the remote peer's Neighbor Cache entries.
2252
2253 This function is called when the caller needs the IpIo to refresh the existing
2254 IPv6 neighbor cache entries since the neighbor is considered reachable by the
2255 node has recently received a confirmation that packets sent recently to the
2256 neighbor were received by its IP layer.
2257
2258 @param[in] IpIo Pointer to an IP_IO instance
2259 @param[in] Neighbor The IP address of the neighbor
2260 @param[in] Timeout Time in 100-ns units that this entry will
2261 remain in the neighbor cache. A value of
2262 zero means that the entry is permanent.
2263 A value of non-zero means that the entry is
2264 dynamic and will be deleted after Timeout.
2265
2266 @retval EFI_SUCCESS The operation is completed successfully.
2267 @retval EFI_NOT_STARTED The IpIo is not configured.
2268 @retval EFI_INVALID_PARAMETER Neighbor Address is invalid.
2269 @retval EFI_NOT_FOUND The neighbor cache entry is not in the
2270 neighbor table.
2271 @retval EFI_UNSUPPORTED IP version is IPv4, which doesn't support neighbor cache refresh.
2272 @retval EFI_OUT_OF_RESOURCES Failed due to resource limit.
2273
2274**/
2275EFI_STATUS
2276EFIAPI
2277IpIoRefreshNeighbor (
2278 IN IP_IO *IpIo,
2279 IN EFI_IP_ADDRESS *Neighbor,
2280 IN UINT32 Timeout
2281 )
2282{
2283 EFI_IP6_PROTOCOL *Ip;
2284
2285 if (!IpIo->IsConfigured) {
2286 return EFI_NOT_STARTED;
2287 }
2288
2289 if (IpIo->IpVersion != IP_VERSION_6) {
2290 return EFI_UNSUPPORTED;
2291 }
2292
2293 Ip = IpIo->Ip.Ip6;
2294
2295 return Ip->Neighbors (Ip, FALSE, &Neighbor->v6, NULL, Timeout, TRUE);
2296}
2297
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