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