MdeModulePkg/Include/Library/IpIoLib.h

   1 /** @file
   2   This library is only intended to be used by UEFI network stack modules.
   3   It provides the combined IpIo layer on the EFI IP4 Protocol and EFI IP6 protocol.
   4
   5 Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials are licensed and made available under
   7 the terms and conditions of the BSD License that accompanies this distribution.
   8 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
  16 #ifndef _IP_IO_H_
  17 #define _IP_IO_H_
  18
  19 #include <Protocol/Ip4.h>
  20 #include <Protocol/Ip6.h>
  21
  22 #include <Library/NetLib.h>
  23
  24 //
  25 // type and code define for ICMP protocol error
  26 // from IP
  27 //
  28 #define ICMP_TYPE_UNREACH              3
  29 #define ICMP_TYPE_TIMXCEED             11
  30 #define ICMP_TYPE_PARAMPROB            12
  31 #define ICMP_TYPE_SOURCEQUENCH         4
  32
  33 #define ICMP_CODE_UNREACH_NET          0
  34 #define ICMP_CODE_UNREACH_HOST         1
  35 #define ICMP_CODE_UNREACH_PROTOCOL     2
  36 #define ICMP_CODE_UNREACH_PORT         3
  37 #define ICMP_CODE_UNREACH_NEEDFRAG     4
  38 #define ICMP_CODE_UNREACH_SRCFAIL      5
  39 #define ICMP_CODE_UNREACH_NET_UNKNOWN  6
  40 #define ICMP_CODE_UNREACH_HOST_UNKNOWN 7
  41 #define ICMP_CODE_UNREACH_ISOLATED     8
  42 #define ICMP_CODE_UNREACH_NET_PROHIB   9
  43 #define ICMP_CODE_UNREACH_HOST_PROHIB  10
  44 #define ICMP_CODE_UNREACH_TOSNET       11
  45 #define ICMP_CODE_UNREACH_TOSHOST      12
  46
  47 /**
  48   Get the IP header length from the struct EFI_IP4_HEADER. HeaderLength is
  49   Internet header length in 32-bit words, so HeaderLength<<2 is the real
  50   length of IP header.
  51
  52   @param[out] HdrPtr   A pointer to EFI_IP4_HEADER.
  53
  54   @return The IP header length.
  55 **/
  56 #define EFI_IP4_HEADER_LEN(HdrPtr) ((HdrPtr)->HeaderLength << 2)
  57
  58 /**
  59   To types of ICMP error which consist of ICMP header, IP header and original
  60   datagram's data, get length from sum of ICMP header length, IP header length
  61   and first 64 bits of datagram's data length.
  62
  63   @param[in] IpHdr   A pointer to EFI_IP4_HEADER.
  64
  65   @return The ICMP error length.
  66 **/
  67 #define ICMP_ERRLEN(IpHdr) \
  68   (sizeof(IP4_ICMP_HEAD) + EFI_IP4_HEADER_LEN(IpHdr) + 8)
  69
  70 /**
  71   Get the packet header from NET_BUF.
  72
  73   @param[out]  Buf    A pointer to NET_BUF.
  74   @param[in]   Type   Header type.
  75
  76   @return The pointer to packet header.
  77 **/
  78 #define NET_PROTO_HDR(Buf, Type)  ((Type *) ((Buf)->BlockOp[0].Head))
  79
  80
  81 extern EFI_IP4_CONFIG_DATA  mIp4IoDefaultIpConfigData;
  82 extern EFI_IP6_CONFIG_DATA  mIp6IoDefaultIpConfigData;
  83
  84
  85 ///
  86 /// This error will be delivered to the
  87 /// listening transportation layer protocol
  88 /// that consumes IpIO.
  89 ///
  90
  91 #define  ICMP_ERR_UNREACH_NET           0
  92 #define  ICMP_ERR_UNREACH_HOST          1
  93 #define  ICMP_ERR_UNREACH_PROTOCOL      2
  94 #define  ICMP_ERR_UNREACH_PORT          3
  95 #define  ICMP_ERR_MSGSIZE               4
  96 #define  ICMP_ERR_UNREACH_SRCFAIL       5
  97 #define  ICMP_ERR_TIMXCEED_INTRANS      6
  98 #define  ICMP_ERR_TIMXCEED_REASS        7
  99 #define  ICMP_ERR_QUENCH                8
 100 #define  ICMP_ERR_PARAMPROB             9
 101
 102 #define  ICMP6_ERR_UNREACH_NET          0
 103 #define  ICMP6_ERR_UNREACH_HOST         1
 104 #define  ICMP6_ERR_UNREACH_PROTOCOL     2
 105 #define  ICMP6_ERR_UNREACH_PORT         3
 106 #define  ICMP6_ERR_PACKAGE_TOOBIG       4
 107 #define  ICMP6_ERR_TIMXCEED_HOPLIMIT    5
 108 #define  ICMP6_ERR_TIMXCEED_REASS       6
 109 #define  ICMP6_ERR_PARAMPROB_HEADER     7
 110 #define  ICMP6_ERR_PARAMPROB_NEXHEADER  8
 111 #define  ICMP6_ERR_PARAMPROB_IPV6OPTION 9
 112
 113 ///
 114 /// The helper struct for IpIoGetIcmpErrStatus(). It is for internal use only.
 115 ///
 116 typedef struct {
 117   BOOLEAN                   IsHard;
 118   BOOLEAN                   Notify;
 119 } ICMP_ERROR_INFO;
 120
 121 typedef union {
 122   EFI_IP4_COMPLETION_TOKEN  Ip4Token;
 123   EFI_IP6_COMPLETION_TOKEN  Ip6Token;
 124 } IP_IO_IP_COMPLETION_TOKEN;
 125
 126 typedef union {
 127   EFI_IP4_TRANSMIT_DATA     Ip4TxData;
 128   EFI_IP6_TRANSMIT_DATA     Ip6TxData;
 129 } IP_IO_IP_TX_DATA;
 130
 131 typedef union {
 132   EFI_IP4_RECEIVE_DATA      Ip4RxData;
 133   EFI_IP6_RECEIVE_DATA      Ip6RxData;
 134 } IP_IO_IP_RX_DATA;
 135
 136 typedef union {
 137   EFI_IP4_OVERRIDE_DATA     Ip4OverrideData;
 138   EFI_IP6_OVERRIDE_DATA     Ip6OverrideData;
 139 } IP_IO_OVERRIDE;
 140
 141 typedef union {
 142   EFI_IP4_CONFIG_DATA       Ip4CfgData;
 143   EFI_IP6_CONFIG_DATA       Ip6CfgData;
 144 } IP_IO_IP_CONFIG_DATA;
 145
 146 typedef union {
 147   EFI_IP4_HEADER            *Ip4Hdr;
 148   EFI_IP6_HEADER            *Ip6Hdr;
 149 } IP_IO_IP_HEADER;
 150
 151 typedef union {
 152   IP4_ADDR                  SubnetMask;
 153   UINT8                     PrefixLength;
 154 } IP_IO_IP_MASK;
 155
 156 typedef union {
 157   EFI_IP4_PROTOCOL  *Ip4;
 158   EFI_IP6_PROTOCOL  *Ip6;
 159 } IP_IO_IP_PROTOCOL;
 160
 161 ///
 162 /// The IP session for an IP receive packet.
 163 ///
 164 typedef struct _EFI_NET_SESSION_DATA {
 165   EFI_IP_ADDRESS        Source;     ///< Source IP of the received packet.
 166   EFI_IP_ADDRESS        Dest;       ///< Destination IP of the received packet.
 167   IP_IO_IP_HEADER       IpHdr;      ///< IP header of the received packet.
 168   UINT32                IpHdrLen;   ///< IP header length of the received packet.
 169                                     ///< For IPv6, it includes the IP6 header
 170                                     ///< length and extension header length. For
 171                                     ///< IPv4, it includes the IP4 header length
 172                                     ///< and options length.
 173   UINT8                 IpVersion;  ///< The IP version of the received packet.
 174 } EFI_NET_SESSION_DATA;
 175
 176 /**
 177   The prototype is called back when an IP packet is received.
 178
 179   @param[in] Status        The result of the receive request.
 180   @param[in] IcmpErr       Valid when Status is EFI_ICMP_ERROR.
 181   @param[in] NetSession    The IP session for the received packet.
 182   @param[in] Pkt           The packet received.
 183   @param[in] Context       The data provided by the user for the received packet when
 184                            the callback is registered in IP_IO_OPEN_DATA::RcvdContext.
 185
 186 **/
 187 typedef
 188 VOID
 189 (EFIAPI *PKT_RCVD_NOTIFY) (
 190   IN EFI_STATUS           Status,
 191   IN UINT8                IcmpErr,
 192   IN EFI_NET_SESSION_DATA *NetSession,
 193   IN NET_BUF              *Pkt,
 194   IN VOID                 *Context
 195   );
 196
 197 /**
 198   The prototype is called back when an IP packet is sent.
 199
 200   @param[in] Status        Result of the IP packet being sent.
 201   @param[in] Context       The data provided by user for the received packet when
 202                            the callback is registered in IP_IO_OPEN_DATA::SndContext.
 203   @param[in] Sender        A Union type to specify a pointer of EFI_IP4_PROTOCOL
 204                            or EFI_IP6_PROTOCOL.
 205   @param[in] NotifyData    The Context data specified when calling IpIoSend()
 206
 207 **/
 208 typedef
 209 VOID
 210 (EFIAPI *PKT_SENT_NOTIFY) (
 211   IN EFI_STATUS        Status,
 212   IN VOID              *Context,
 213   IN IP_IO_IP_PROTOCOL Sender,
 214   IN VOID              *NotifyData
 215   );
 216
 217 ///
 218 /// This data structure wraps Ip4/Ip6 instances. The IpIo Library uses it for all
 219 /// Ip4/Ip6 operations.
 220 ///
 221 typedef struct _IP_IO {
 222   ///
 223   /// The node used to link this IpIo to the active IpIo list.
 224   ///
 225   LIST_ENTRY                    Entry;
 226
 227   ///
 228   /// The list used to maintain the IP instance for different sending purpose.
 229   ///
 230   LIST_ENTRY                    IpList;
 231
 232   EFI_HANDLE                    Controller;
 233   EFI_HANDLE                    Image;
 234   EFI_HANDLE                    ChildHandle;
 235   //
 236   // The IP instance consumed by this IP_IO
 237   //
 238   IP_IO_IP_PROTOCOL             Ip;
 239   BOOLEAN                       IsConfigured;
 240
 241   ///
 242   /// Some ip configuration data can be changed.
 243   ///
 244   UINT8                         Protocol;
 245
 246   ///
 247   /// Token and event used to get data from IP.
 248   ///
 249   IP_IO_IP_COMPLETION_TOKEN     RcvToken;
 250
 251   ///
 252   /// List entry used to link the token passed to IP_IO.
 253   ///
 254   LIST_ENTRY                    PendingSndList;
 255
 256   //
 257   // User interface used to get notify from IP_IO
 258   //
 259   VOID                          *RcvdContext;    ///< See IP_IO_OPEN_DATA::RcvdContext.
 260   VOID                          *SndContext;     ///< See IP_IO_OPEN_DATA::SndContext.
 261   PKT_RCVD_NOTIFY               PktRcvdNotify;   ///< See IP_IO_OPEN_DATA::PktRcvdNotify.
 262   PKT_SENT_NOTIFY               PktSentNotify;   ///< See IP_IO_OPEN_DATA::PktSentNotify.
 263   UINT8                         IpVersion;
 264   IP4_ADDR                      StationIp;
 265   IP4_ADDR                      SubnetMask;
 266 } IP_IO;
 267
 268 ///
 269 /// The struct is for the user to pass IP configuration and callbacks to IP_IO.
 270 /// It is used by IpIoOpen().
 271 ///
 272 typedef struct _IP_IO_OPEN_DATA {
 273   IP_IO_IP_CONFIG_DATA IpConfigData;    ///< Configuration of the IP instance.
 274   VOID                 *RcvdContext;    ///< Context data used by receive callback.
 275   VOID                 *SndContext;     ///< Context data used by send callback.
 276   PKT_RCVD_NOTIFY      PktRcvdNotify;   ///< Receive callback.
 277   PKT_SENT_NOTIFY      PktSentNotify;   ///< Send callback.
 278 } IP_IO_OPEN_DATA;
 279
 280 ///
 281 /// Internal struct book-keeping send request of IP_IO.
 282 ///
 283 /// An IP_IO_SEND_ENTRY will be created each time a send request is issued to
 284 /// IP_IO via IpIoSend().
 285 ///
 286 typedef struct _IP_IO_SEND_ENTRY {
 287   LIST_ENTRY                Entry;
 288   IP_IO                     *IpIo;
 289   VOID                      *Context;
 290   VOID                      *NotifyData;
 291   IP_IO_IP_PROTOCOL         Ip;
 292   NET_BUF                   *Pkt;
 293   IP_IO_IP_COMPLETION_TOKEN SndToken;
 294 } IP_IO_SEND_ENTRY;
 295
 296 ///
 297 /// The IP_IO_IP_INFO is used in IpIoSend() to override the default IP instance
 298 /// in IP_IO.
 299 ///
 300 typedef struct _IP_IO_IP_INFO {
 301   EFI_IP_ADDRESS            Addr;
 302   IP_IO_IP_MASK             PreMask;
 303   LIST_ENTRY                Entry;
 304   EFI_HANDLE                ChildHandle;
 305   IP_IO_IP_PROTOCOL         Ip;
 306   IP_IO_IP_COMPLETION_TOKEN DummyRcvToken;
 307   INTN                      RefCnt;
 308   UINT8                     IpVersion;
 309 } IP_IO_IP_INFO;
 310
 311 /**
 312   Create a new IP_IO instance.
 313
 314   If IpVersion is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
 315
 316   This function uses IP4/IP6 service binding protocol in Controller to create
 317   an IP4/IP6 child (aka IP4/IP6 instance).
 318
 319   @param[in]  Image             The image handle of the driver or application that
 320                                 consumes IP_IO.
 321   @param[in]  Controller        The controller handle that has IP4 or IP6 service
 322                                 binding protocol installed.
 323   @param[in]  IpVersion         The version of the IP protocol to use, either
 324                                 IPv4 or IPv6.
 325
 326   @return The pointer to a newly created IP_IO instance, or NULL if failed.
 327
 328 **/
 329 IP_IO *
 330 EFIAPI
 331 IpIoCreate (
 332   IN EFI_HANDLE Image,
 333   IN EFI_HANDLE Controller,
 334   IN UINT8      IpVersion
 335   );
 336
 337 /**
 338   Destroy an IP_IO instance.
 339
 340   This function is paired with IpIoCreate(). The IP_IO will be closed first.
 341   Resource will be freed afterwards. See IpIoClose().
 342
 343   @param[in, out]  IpIo         The pointer to the IP_IO instance that needs to be
 344                                 destroyed.
 345
 346   @retval          EFI_SUCCESS  The IP_IO instance was destroyed successfully.
 347   @retval          Others       An error condition occurred.
 348
 349 **/
 350 EFI_STATUS
 351 EFIAPI
 352 IpIoDestroy (
 353   IN OUT IP_IO *IpIo
 354   );
 355
 356 /**
 357   Stop an IP_IO instance.
 358
 359   If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
 360
 361   This function is paired with IpIoOpen(). The IP_IO will be unconfigured, and all
 362   pending send/receive tokens will be canceled.
 363
 364   @param[in, out]  IpIo            The pointer to the IP_IO instance that needs to stop.
 365
 366   @retval          EFI_SUCCESS            The IP_IO instance stopped successfully.
 367   @retval          EFI_INVALID_PARAMETER  Invalid input parameter.
 368   @retval          Others                 Anrror condition occurred.
 369
 370 **/
 371 EFI_STATUS
 372 EFIAPI
 373 IpIoStop (
 374   IN OUT IP_IO *IpIo
 375   );
 376
 377 /**
 378   Open an IP_IO instance for use.
 379
 380   If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
 381
 382   This function is called after IpIoCreate(). It is used for configuring the IP
 383   instance and register the callbacks and their context data for sending and
 384   receiving IP packets.
 385
 386   @param[in, out]  IpIo               The pointer to an IP_IO instance that needs
 387                                       to open.
 388   @param[in]       OpenData           The configuration data and callbacks for
 389                                       the IP_IO instance.
 390
 391   @retval          EFI_SUCCESS            The IP_IO instance opened with OpenData
 392                                           successfully.
 393   @retval          EFI_ACCESS_DENIED      The IP_IO instance is configured, avoid to
 394                                           reopen it.
 395   @retval          EFI_UNSUPPORTED        IPv4 RawData mode is no supported.
 396   @retval          EFI_INVALID_PARAMETER  Invalid input parameter.
 397   @retval          Others                 Error condition occurred.
 398
 399 **/
 400 EFI_STATUS
 401 EFIAPI
 402 IpIoOpen (
 403   IN OUT IP_IO           *IpIo,
 404   IN     IP_IO_OPEN_DATA *OpenData
 405   );
 406
 407 /**
 408   Send out an IP packet.
 409
 410   This function is called after IpIoOpen(). The data to be sent is wrapped in
 411   Pkt. The IP instance wrapped in IpIo is used for sending by default but can be
 412   overriden by Sender. Other sending configs, like source address and gateway
 413   address etc., are specified in OverrideData.
 414
 415   @param[in, out]  IpIo                  Pointer to an IP_IO instance used for sending IP
 416                                          packet.
 417   @param[in, out]  Pkt                   Pointer to the IP packet to be sent.
 418   @param[in]       Sender                The IP protocol instance used for sending.
 419   @param[in]       Context               Optional context data.
 420   @param[in]       NotifyData            Optional notify data.
 421   @param[in]       Dest                  The destination IP address to send this packet to.
 422                                          This parameter is optional when using IPv6.
 423   @param[in]       OverrideData          The data to override some configuration of the IP
 424                                          instance used for sending.
 425
 426   @retval          EFI_SUCCESS           The operation is completed successfully.
 427   @retval          EFI_INVALID_PARAMETER The input parameter is not correct.
 428   @retval          EFI_NOT_STARTED       The IpIo is not configured.
 429   @retval          EFI_OUT_OF_RESOURCES  Failed due to resource limit.
 430   @retval          Others                Error condition occurred.
 431
 432 **/
 433 EFI_STATUS
 434 EFIAPI
 435 IpIoSend (
 436   IN OUT IP_IO          *IpIo,
 437   IN OUT NET_BUF        *Pkt,
 438   IN     IP_IO_IP_INFO  *Sender        OPTIONAL,
 439   IN     VOID           *Context       OPTIONAL,
 440   IN     VOID           *NotifyData    OPTIONAL,
 441   IN     EFI_IP_ADDRESS *Dest          OPTIONAL,
 442   IN     IP_IO_OVERRIDE *OverrideData  OPTIONAL
 443   );
 444
 445 /**
 446   Cancel the IP transmit token that wraps this Packet.
 447
 448   If IpIo is NULL, then ASSERT().
 449   If Packet is NULL, then ASSERT().
 450
 451   @param[in]  IpIo                  The pointer to the IP_IO instance.
 452   @param[in]  Packet                The pointer to the packet of NET_BUF to cancel.
 453
 454 **/
 455 VOID
 456 EFIAPI
 457 IpIoCancelTxToken (
 458   IN IP_IO  *IpIo,
 459   IN VOID   *Packet
 460   );
 461
 462 /**
 463   Add a new IP instance for sending data.
 464
 465   If IpIo is NULL, then ASSERT().
 466   If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
 467
 468   The function is used to add the IP_IO to the IP_IO sending list. The caller
 469   can later use IpIoFindSender() to get the IP_IO and call IpIoSend() to send
 470   data.
 471
 472   @param[in, out]  IpIo               The pointer to an IP_IO instance to add a new IP
 473                                       instance for sending purposes.
 474
 475   @return The pointer to the created IP_IO_IP_INFO structure; NULL if failed.
 476
 477 **/
 478 IP_IO_IP_INFO *
 479 EFIAPI
 480 IpIoAddIp (
 481   IN OUT IP_IO  *IpIo
 482   );
 483
 484 /**
 485   Configure the IP instance of this IpInfo and start the receiving if IpConfigData
 486   is not NULL.
 487
 488   If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
 489
 490   @param[in, out]  IpInfo          The pointer to the IP_IO_IP_INFO instance.
 491   @param[in, out]  IpConfigData    The IP4 or IP6 configure data used to configure
 492                                    the IP instance. If NULL, the IP instance is reset.
 493                                    If UseDefaultAddress is set to TRUE, and the configure
 494                                    operation succeeds, the default address information
 495                                    is written back in this IpConfigData.
 496
 497   @retval          EFI_SUCCESS     The IP instance of this IpInfo was configured successfully,
 498                                    or there is no need to reconfigure it.
 499   @retval          Others          The configuration failed.
 500
 501 **/
 502 EFI_STATUS
 503 EFIAPI
 504 IpIoConfigIp (
 505   IN OUT IP_IO_IP_INFO        *IpInfo,
 506   IN OUT VOID                 *IpConfigData OPTIONAL
 507   );
 508
 509 /**
 510   Destroy an IP instance maintained in IpIo->IpList for
 511   sending purpose.
 512
 513   If Ip version is not IP_VERSION_4 or IP_VERSION_6, then ASSERT().
 514
 515   This function pairs with IpIoAddIp(). The IpInfo is previously created by
 516   IpIoAddIp(). The IP_IO_IP_INFO::RefCnt is decremented and the IP instance
 517   will be dstroyed if the RefCnt is zero.
 518
 519   @param[in]  IpIo                  The pointer to the IP_IO instance.
 520   @param[in]  IpInfo                The pointer to the IpInfo to be removed.
 521
 522 **/
 523 VOID
 524 EFIAPI
 525 IpIoRemoveIp (
 526   IN IP_IO            *IpIo,
 527   IN IP_IO_IP_INFO    *IpInfo
 528   );
 529
 530 /**
 531   Find the first IP protocol maintained in IpIo whose local
 532   address is the same as Src.
 533
 534   This function is called when the caller needs the IpIo to send data to the
 535   specified Src. The IpIo was added previously by IpIoAddIp().
 536
 537   @param[in, out]  IpIo              The pointer to the pointer of the IP_IO instance.
 538   @param[in]       IpVersion         The version of the IP protocol to use, either
 539                                      IPv4 or IPv6.
 540   @param[in]       Src               The local IP address.
 541
 542   @return The pointer to the IP protocol can be used for sending purpose and its local
 543           address is the same with Src. NULL if failed.
 544
 545 **/
 546 IP_IO_IP_INFO *
 547 EFIAPI
 548 IpIoFindSender (
 549   IN OUT IP_IO           **IpIo,
 550   IN     UINT8           IpVersion,
 551   IN     EFI_IP_ADDRESS  *Src
 552   );
 553
 554 /**
 555   Get the ICMP error map information.
 556
 557   The ErrorStatus will be returned. The IsHard and Notify are optional. If they
 558   are not NULL, this routine will fill them.
 559
 560   @param[in]   IcmpError             IcmpError Type.
 561   @param[in]   IpVersion             The version of the IP protocol to use,
 562                                      either IPv4 or IPv6.
 563   @param[out]  IsHard                If TRUE, indicates that it is a hard error.
 564   @param[out]  Notify                If TRUE, SockError needs to be notified.
 565
 566   @retval EFI_UNSUPPORTED            Unrecognizable ICMP error code
 567   @return The ICMP Error Status, such as EFI_NETWORK_UNREACHABLE.
 568
 569 **/
 570 EFI_STATUS
 571 EFIAPI
 572 IpIoGetIcmpErrStatus (
 573   IN  UINT8       IcmpError,
 574   IN  UINT8       IpVersion,
 575   OUT BOOLEAN     *IsHard  OPTIONAL,
 576   OUT BOOLEAN     *Notify  OPTIONAL
 577   );
 578
 579 /**
 580   Refresh the remote peer's Neighbor Cache entries.
 581
 582   This function is called when the caller needs the IpIo to refresh the existing
 583   IPv6 neighbor cache entries since the neighbor is considered reachable by the
 584   node has recently received a confirmation that packets sent recently to the
 585   neighbor were received by its IP layer.
 586
 587   @param[in]   IpIo                  The pointer to an IP_IO instance
 588   @param[in]   Neighbor              The IP address of the neighbor
 589   @param[in]   Timeout               The time in 100-ns units that this entry will
 590                                      remain in the neighbor cache. A value of
 591                                      zero means that the entry is permanent.
 592                                      A value of non-zero means that the entry is
 593                                      dynamic and will be deleted after Timeout.
 594
 595   @retval      EFI_SUCCESS           The operation completed successfully.
 596   @retval      EFI_NOT_STARTED       The IpIo is not configured.
 597   @retval      EFI_INVALID_PARAMETER The Neighbor Address is invalid.
 598   @retval      EFI_NOT_FOUND         The neighbor cache entry is not in the
 599                                      neighbor table.
 600   @retval      EFI_UNSUPPORTED       IP version is IPv4, which doesn't support neighbor cache refresh.
 601   @retval      EFI_OUT_OF_RESOURCES  Failed due to resource limitations.
 602
 603 **/
 604 EFI_STATUS
 605 EFIAPI
 606 IpIoRefreshNeighbor (
 607   IN IP_IO           *IpIo,
 608   IN EFI_IP_ADDRESS  *Neighbor,
 609   IN UINT32          Timeout
 610   );
 611
 612 #endif
 613