EdkModulePkg/Universal/Network/PxeBc/Dxe/ip.h

/*++

Copyright (c) 2006, Intel Corporation                                                         
All rights reserved. This program and the accompanying materials                          
are licensed and made available under the terms and conditions of the BSD License         
which accompanies this distribution.  The full text of the license may be found at        
http://opensource.org/licenses/bsd-license.php                                            
                                                                                          
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

--*/

#ifndef _IP_H_
#define _IP_H_

#include "hton.h"

//
// Client architecture types
//
#define IA64            2
#define SYS_ARCH_EFI32  6

//
// portability macros
//
#define UDP_FILTER_MASK  (EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP | \
                         EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT | \
                         EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP | \
                         EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT | \
                         EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER \
          )

#define PXE_BOOT_LAYER_MASK             0x7FFF
#define PXE_BOOT_LAYER_INITIAL          0x0000
#define PXE_BOOT_LAYER_CREDENTIAL_FLAG  0x8000
#define MAX_BOOT_SERVERS                32

//
// macro to evaluate IP address as TRUE if it is a multicast IP address
//
#define IS_MULTICAST(ptr) ((*((UINT8 *) ptr) & 0xf0) == 0xe0)

//
// length macros
//
#define IP_ADDRESS_LENGTH(qp)   (((qp)->UsingIpv6) ? sizeof (EFI_IPv6_ADDRESS) : sizeof (EFI_IPv4_ADDRESS))

#define MAX_FRAME_DATA_SIZE     1488
#define ALLOCATE_SIZE(X)        (((X) + 7) & 0xfff8)
#define MODE_ALLOCATE_SIZE      ALLOCATE_SIZE (sizeof (EFI_PXE_BASE_CODE_MODE))
#define BUFFER_ALLOCATE_SIZE    (8192 + 512)
#define ROUTER_ALLOCATE_SIZE    ALLOCATE_SIZE ((sizeof (EFI_PXE_BASE_CODE_ROUTE_ENTRY) * PXE_ROUTER_TABLE_SIZE))
#define ARP_ALLOCATE_SIZE       ALLOCATE_SIZE ((sizeof (EFI_PXE_BASE_CODE_ARP_ENTRY) * PXE_ARP_CACHE_SIZE))
#define FILTER_ALLOCATE_SIZE    ALLOCATE_SIZE ((sizeof (EFI_IP_ADDRESS) * PXE_IP_FILTER_SIZE))
#define PXE_ARP_CACHE_SIZE      8
#define PXE_ROUTER_TABLE_SIZE   8
#define PXE_IP_FILTER_SIZE      8
#define ICMP_ALLOCATE_SIZE      ALLOCATE_SIZE (sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR))
#define TFTP_ERR_ALLOCATE_SIZE  ALLOCATE_SIZE (sizeof (EFI_PXE_BASE_CODE_TFTP_ERROR))

//
// DHCP discover/request packets are sent to this UDP port.  ProxyDHCP
// servers listen on this port for DHCP discover packets that have a
// class identifier (option 60) with 'PXEClient' in the first 9 bytes.
// Bootservers also listen on this port for PXE broadcast discover
// requests from PXE clients.
//
#define DHCP_SERVER_PORT  67

//
// When DHCP, proxyDHCP and Bootservers respond to DHCP and PXE broadcast
// discover requests by broadcasting the reply packet, the packet is
// broadcast to this port.
//
#define DHCP_CLIENT_PORT  68

//
// TFTP servers listen for TFTP open requests on this port.
//
#define TFTP_OPEN_PORT  69

//
// proxyDHCP and Bootservers listen on this port for a PXE unicast and/or
// multicast discover requests from PXE clients.  A PXE discover request
// looks like a DHCP discover or DHCP request packet.
//
#define PXE_DISCOVERY_PORT  4011

//
// This port is used by the PXE client/server protocol tests.
//
#define PXE_PORT_PXETEST_PORT 0x8080

//
// Definitions for Ethertype protocol numbers and interface types
// Per RFC 1700,
//
#define PXE_PROTOCOL_ETHERNET_IP    0x0800
#define PXE_PROTOCOL_ETHERNET_ARP   0x0806
#define PXE_PROTOCOL_ETHERNET_RARP  0x8035

#define PXE_IFTYPE_ETHERNET         0x01
#define PXE_IFTYPE_TOKENRING        0x04
#define PXE_IFTYPE_FIBRE_CHANNEL    0x12

//
// Definitions for internet protocol version 4 header
// Per RFC 791, September 1981.
//
#define IPVER4  4

#pragma pack(1) // make network structures packed byte alignment
typedef union {
  UINT8   B[4];
  UINT32  L;
} IPV4_ADDR;

#define IPV4_HEADER_LENGTH(IpHeaderPtr) (((IpHeaderPtr)->VersionIhl & 0xf) << 2)

#define SET_IPV4_VER_HDL(IpHeaderPtr, IpHeaderLen) { \
    (IpHeaderPtr)->VersionIhl = (UINT8) ((IPVER4 << 4) | ((IpHeaderLen) >> 2)); \
  }

typedef struct {
  UINT8     VersionIhl;
  UINT8     TypeOfService;
  UINT16    TotalLength;
  UINT16    Id;
  UINT16    FragmentFields;
  UINT8     TimeToLive;
  UINT8     Protocol;
  UINT16    HeaderChecksum;
  IPV4_ADDR SrcAddr;
  IPV4_ADDR DestAddr;
  //
  // options are not implemented
  //
} IPV4_HEADER;

#define IP_FRAG_RSVD    0x8000  // reserved bit - must be zero
#define IP_NO_FRAG      0x4000  // do not fragment bit
#define IP_MORE_FRAG    0x2000  // not last fragment
#define IP_FRAG_OFF_MSK 0x1fff  // fragment offset in 8 byte chunks
#define DEFAULT_RFC_TTL 64

#define PROT_ICMP       1
#define PROT_IGMP       2
#define PROT_TCP        6
#define PROT_UDP        17

/*
 * Definitions for internet control message protocol version 4 message
 * structure.  Per RFC 792, September 1981.
 */

//
// icmp header for all icmp messages
//
typedef struct {
  UINT8   Type;     // message type
  UINT8   Code;     // type specific - 0 for types we implement
  UINT16  Checksum; // ones complement of ones complement sum of 16 bit words of message
} ICMPV4_HEADER;

#define ICMP_DEST_UNREACHABLE   3
#define ICMP_SOURCE_QUENCH      4
#define ICMP_REDIRECT           5
#define ICMP_ECHO               8
#define ICMP_ECHO_REPLY         0
#define ICMP_ROUTER_ADV         9
#define ICMP_ROUTER_SOLICIT     10
#define ICMP_TIME_EXCEEDED      11
#define ICMP_PARAMETER_PROBLEM  12
#define ICMP_TIMESTAMP          13
#define ICMP_TIMESTAMP_REPLY    14
#define ICMP_INFO_REQ           15
#define ICMP_INFO_REQ_REPLY     16
#define ICMP_SUBNET_MASK_REQ    17
#define ICMP_SUBNET_MASK_REPLY  18
//
// other ICMP message types ignored in this implementation
//
// icmp general messages
//
typedef struct {
  ICMPV4_HEADER Header;
  //
  // generally unused except byte [0] for
  // parameter problem message
  //
  UINT8         GenerallyUnused[4];
  //
  // original message ip header of plus 64
  // bits of data
  //
  IPV4_HEADER   IpHeader;
} ICMPV4_GENERAL_MESSAGE;

//
// icmp req/rply message header
//
typedef struct {
  ICMPV4_HEADER Header;
  UINT16        Id;
  UINT16        SequenceNumber;
} ICMPV4_REQUEST_REPLY_HEADER;

//
// icmp echo message
//
typedef struct {
  ICMPV4_REQUEST_REPLY_HEADER Header;
  UINT8                       EchoData[1];  // variable length data to be echoed
} ICMPV4_ECHO_MESSAGE;

//
// icmp timestamp message - times are milliseconds since midnight UT -
// if non std, set high order bit
//
typedef struct {
  ICMPV4_REQUEST_REPLY_HEADER Header;
  UINT32                      OriginalTime; // originating timestamp
  UINT32                      ReceiveTime;  // receiving timestamp
  UINT32                      TransmitTime; // transmitting timestamp
} ICMPV4_TIMESTAMP_MESSAGE;

//
// icmp info request structure - fill in source and dest net ip address on reply
//
typedef struct {
  ICMPV4_REQUEST_REPLY_HEADER Header;
} ICMPV4_INFO_MESSAGE;

//
// Definitions for internet control message protocol version 4 message structure
// Router discovery
// Per RFC 1256, September 1991.
//
//
// icmp router advertisement message
//
typedef struct {
  ICMPV4_HEADER Header;
  UINT8         NumberEntries;  // number of address entries
  UINT8         EntrySize;      // number of 32 bit words per address entry
  UINT16        Lifetime;       // seconds to consider info valid
  UINT32        RouterIp;
  UINT32        Preferance;
} ICMPV4_ROUTER_ADVERTISE_MESSAGE;

//
// icmp router solicitation message
//
typedef struct {
  ICMPV4_HEADER Header;
  UINT32        Reserved;
} ICMPV4_ROUTER_SOLICIT_MESSAGE;

#define MAX_SOLICITATION_DELAY      1   //  1 second
#define SOLICITATION_INTERVAL       3   //  3 seconds
#define MAX_SOLICITATIONS           3   //  3 transmissions
#define V1ROUTER_PRESENT_TIMEOUT    400 // 400 second timeout until v2 reports can be sent
#define UNSOLICITED_REPORT_INTERVAL 10  // 10 seconds between unsolicited reports
#define BROADCAST_IPv4              0xffffffff

//
// Definitions for address resolution protocol message structure
// Per RFC 826, November 1982
//
typedef struct {
  UINT16  HwType;     // hardware type - e.g. ethernet (1)
  UINT16  ProtType;   // protocol type - for ethernet, 0x800 for IP
  UINT8   HwAddLen;   // byte length of a hardware address (e.g. 6 for ethernet)
  UINT8   ProtAddLen; // byte length of a protocol address (e.g. 4 for ipv4)
  UINT16  OpCode;
  //
  // source and dest hw and prot addresses follow - see example below
  //
} ARP_HEADER;

#define ETHERNET_ADD_SPC  1

#define ETHER_TYPE_IP     0x800

#define ARP_REQUEST       1
#define ARP_REPLY         2

//
// generic ARP packet
//
typedef struct {
  ARP_HEADER      ArpHeader;
  EFI_MAC_ADDRESS SrcHardwareAddr;
  EFI_IP_ADDRESS  SrcProtocolAddr;
  EFI_MAC_ADDRESS DestHardwareAddr;
  EFI_IP_ADDRESS  DestProtocolAddr;
} ARP_PACKET;

#define ENET_HWADDLEN   6
#define IPV4_PROTADDLEN 4

//
// Definitions for user datagram protocol version 4 pseudo header & header
// Per RFC 768, 28 August 1980
//
typedef struct {
  IPV4_ADDR SrcAddr;      // source ip address
  IPV4_ADDR DestAddr;     // dest ip address
  UINT8     Zero;         // 0
  UINT8     Protocol;     // protocol
  UINT16    TotalLength;  // UDP length - sizeof udpv4hdr + data length
} UDPV4_PSEUDO_HEADER;

typedef struct {
  UINT16  SrcPort;        // source port identifier
  UINT16  DestPort;       // destination port identifier
  UINT16  TotalLength;    // total length header plus data
  //
  // ones complement of ones complement sum of 16 bit
  // words of pseudo header, UDP header, and data
  // zero checksum is transmitted as -0 (ones comp)
  // zero transmitted means checksum not computed
  // data follows
  //
  UINT16  Checksum;      
} UDPV4_HEADER;

typedef struct {
  UDPV4_PSEUDO_HEADER Udpv4PseudoHeader;
  UDPV4_HEADER        Udpv4Header;
} UDPV4_HEADERS;

//
// Definitions for transmission control protocol header
// Per RFC 793, September, 1981
//
typedef struct {
  IPV4_ADDR SrcAddr;      // source ip address
  IPV4_ADDR DestAddr;     // dest ip address
  UINT8     Zero;         // 0
  UINT8     Protocol;     // protocol
  UINT16    TotalLength;  // TCP length - TCP header length + data length
} TCPV4_PSEUDO_HEADER;

typedef struct {
  UINT16  SrcPort;        // source port identifier
  UINT16  DestPort;       // destination port identifier
  UINT32  SeqNumber;      // Sequence number
  UINT32  AckNumber;      // Acknowledgement Number
  //
  // Nibble of HLEN (length of header in 32-bit multiples)
  // 6bits of RESERVED
  // Nibble of Code Bits
  //
  UINT16  HlenResCode;
  UINT16  Window;   // Software buffer size (sliding window size) in network-standard byte order
  //
  // ones complement of ones complement sum of 16 bit words of
  // pseudo header, TCP header, and data
  // zero checksum is transmitted as -0 (ones comp)
  // zero transmitted means checksum not computed
  //
  UINT16  Checksum; 
  UINT16  UrgentPointer;                // pointer to urgent data (allows sender to specify urgent data)
} TCPV4_HEADER;

typedef struct {
  TCPV4_PSEUDO_HEADER Tcpv4PseudoHeader;
  TCPV4_HEADER        Tcpv4Header;
} TCPV4_HEADERS;

typedef struct {
  UINT8 Kind;                           // one of the following:
  UINT8 Length;                         // total option length including Kind and Lth
  UINT8 Data[1];                        // length = Lth - 2
} TCPV4_OPTION;

#define TCP_OP_END                0     // only used to pad to end of TCP header
#define TCP_NOP                   1     // optional - may be used to pad between options to get alignment
#define TCP_MAX_SEG               2     // maximum receive segment size - only send at initial connection request
#define MAX_MEDIA_HDR_SIZE        64
#define MIN_ENET_DATA_SIZE        64
#define MAX_ENET_DATA_SIZE        1500  // temp def - make a network based var
#define MAX_IPV4_PKT_SIZE         65535 // maximum IP packet size
#define MAX_IPV4_DATA_SIZE        (MAX_IPV4_PKT_SIZE - sizeof (IPV4_HEADER))
#define MAX_IPV4_FRAME_DATA_SIZE  (MAX_FRAME_DATA_SIZE - sizeof (IPV4_HEADER))
#define REAS_IPV4_PKT_SIZE        576   // minimum IP packet size all IP host can handle
#define REAS_IPV4_DATA_SIZE       (REAS_IPV4_PKT_SIZE - sizeof (IPV4_HEADER))

//
//
//
typedef union {
  UINT8           Data[MAX_ENET_DATA_SIZE];
  ICMPV4_HEADER   IcmpHeader;
  IGMPV2_MESSAGE  IgmpMessage;
  struct {
    UDPV4_HEADER  UdpHeader;
    UINT8         Data[1];
  } Udp;
  struct {
    TCPV4_HEADER  TcpHeader;
    UINT8         Data[1];
  } Tcp;
} PROTOCOL_UNION;

//
// out buffer structure
//
typedef struct {
  UINT8           MediaHeader[MAX_MEDIA_HDR_SIZE];
  IPV4_HEADER     IpHeader;
  //
  // following union placement only valid if no option IP header
  //
  PROTOCOL_UNION  u;
} IPV4_BUFFER;

typedef struct {
  IPV4_HEADER     IpHeader;
  //
  // following union placement only valid if no option IP header
  //
  PROTOCOL_UNION  u;
} IPV4_STRUCT;

#pragma pack()  // reset to default
  
  ////////////////////////////////////////////////////////////
//
//  BC IP Filter Routine
//
EFI_STATUS
IpFilter (
  PXE_BASECODE_DEVICE            *Private,
  IN EFI_PXE_BASE_CODE_IP_FILTER *Filter
  )
;

//
// //////////////////////////////////////////////////////////////////////
//
//  Udp Write Routine - called by base code - e.g. TFTP - already locked
//
EFI_STATUS
UdpWrite (
  IN PXE_BASECODE_DEVICE                      *Private,
  IN UINT16                                   OpFlags,
  IN EFI_IP_ADDRESS                           *DestIpPtr,
  IN EFI_PXE_BASE_CODE_UDP_PORT               *DestPortptr,
  IN EFI_IP_ADDRESS                           *GatewayIpPtr, OPTIONAL
  IN EFI_IP_ADDRESS                           *SrcIpPtr, OPTIONAL
  IN OUT EFI_PXE_BASE_CODE_UDP_PORT           *SrcPortPtr, OPTIONAL
  IN UINTN                                    *HeaderSizePtr, OPTIONAL
  IN VOID                                     *HeaderPtr, OPTIONAL
  IN UINTN                                    *BufferSizePtr,
  IN VOID                                     *BufferPtr
  )
;

//
// /////////////////////////////////////////////////////////////////////
//
//  Udp Read Routine - called by base code - e.g. TFTP - already locked
//
EFI_STATUS
UdpRead (
  IN PXE_BASECODE_DEVICE            *Private,
  IN UINT16                         OpFlags,
  IN OUT EFI_IP_ADDRESS             *DestIpPtr, OPTIONAL
  IN OUT EFI_PXE_BASE_CODE_UDP_PORT *DestPorPtrt, OPTIONAL
  IN OUT EFI_IP_ADDRESS             *SrcIpPtr, OPTIONAL
  IN OUT EFI_PXE_BASE_CODE_UDP_PORT *SrcPortPtr, OPTIONAL
  IN UINTN                          *HeaderSizePtr, OPTIONAL
  IN VOID                           *HeaderPtr, OPTIONAL
  IN OUT UINTN                      *BufferSizePtr,
  IN VOID                           *BufferPtr,
  IN EFI_EVENT                      TimeoutEvent
  )
;

VOID
IgmpLeaveGroup (
  PXE_BASECODE_DEVICE *Private,
  EFI_IP_ADDRESS      *
  )
;

VOID
IgmpJoinGroup (
  PXE_BASECODE_DEVICE *Private,
  EFI_IP_ADDRESS      *
  )
;

//
// convert number to zero filled ascii value of length lth
//
VOID
CvtNum (
  UINTN Number,
  UINT8 *BufferPtr,
  INTN  BufferLen
  )
;

//
// convert number to ascii string at ptr
//
VOID
UtoA10 (
  UINTN Number,
  UINT8 *BufferPtr
  )
;

//
// convert ascii numeric string to UINTN
//
UINTN
AtoU (
  UINT8 *BufferPtr
  )
;

UINT64
AtoU64 (
  UINT8 *BufferPtr
  )
;

//
// calculate the internet checksum (RFC 1071)
// return 16 bit ones complement of ones complement sum of 16 bit words
//
UINT16
IpChecksum (
  UINT16 *MessagePtr,
  UINTN  ByteLength
  )
;

//
// do checksum on non contiguous header and data
//
UINT16
IpChecksum2 (
  UINT16 *Header,
  UINTN  HeaderLength,
  UINT16 *Message,
  UINTN  MessageLength
  )
;

//
// update checksum when only a single word changes
//
UINT16
UpdateChecksum (
  UINT16 OldChecksum,
  UINT16 OldWord,
  UINT16 NewWord
  )
;

VOID
SeedRandom (
  IN PXE_BASECODE_DEVICE  *Private,
  IN UINT16               InitialSeed
  )
;

UINT16
Random (
  IN PXE_BASECODE_DEVICE  *Private
  )
;

EFI_STATUS
SendPacket (
  PXE_BASECODE_DEVICE           *Private,
  VOID                          *HeaderPtr,
  VOID                          *PacketPtr,
  INTN                          PacketLength,
  VOID                          *HardwareAddress,
  UINT16                        MediaProtocol,
  IN EFI_PXE_BASE_CODE_FUNCTION Function
  )
;

VOID
HandleArpReceive (
  PXE_BASECODE_DEVICE *Private,
  ARP_PACKET          *ArpPacketPtr,
  VOID                *HeaderPtr
  )
;

VOID
HandleIgmp (
  PXE_BASECODE_DEVICE *Private,
  IGMPV2_MESSAGE      *IgmpMessageptr,
  UINTN               IgmpMessageLen
  )
;

VOID
IgmpCheckTimers (
  PXE_BASECODE_DEVICE *Private
  )
;  // poll when doing a receive
// return hw add of IP and TRUE if available, otherwise FALSE
//
BOOLEAN
GetHwAddr (
  IN PXE_BASECODE_DEVICE  *Private,
  EFI_IP_ADDRESS          *ProtocolAddressPtr,
  EFI_MAC_ADDRESS         *HardwareAddressPtr
  )
;

EFI_STATUS
DoArp (
  IN PXE_BASECODE_DEVICE  *Private,
  IN EFI_IP_ADDRESS       *ProtocolAddressPtr,
  OUT EFI_MAC_ADDRESS     *HardwareAddressptr
  )
;

BOOLEAN
OnSameSubnet (
  UINTN           IpAddressLen,
  EFI_IP_ADDRESS  *Ip1,
  EFI_IP_ADDRESS  *Ip2,
  EFI_IP_ADDRESS  *SubnetMask
  )
;

VOID
IpAddRouter (
  PXE_BASECODE_DEVICE *Private,
  EFI_IP_ADDRESS      *RouterIp
  )
;

#define Ip4AddRouter(Private, Ipv4Ptr)  IpAddRouter (Private, (EFI_IP_ADDRESS *) Ipv4Ptr)

//
// routine to send ipv4 packet
// ipv4 + upper protocol header for length TotHdrLth in xmtbuf, ipv4 header length IpHdrLth
// routine fills in ipv4hdr Ver_Hdl, TotLth, and Checksum, moves in Data, and gets dest MAC address
//
EFI_STATUS
Ipv4Xmt (
  PXE_BASECODE_DEVICE         *Private,
  UINT32                      GatewayIP,
  UINTN                       IpHeaderLen,
  UINTN                       TotalHeaderLen,
  VOID                        *Data,
  UINTN                       DataLen,
  EFI_PXE_BASE_CODE_FUNCTION  Function
  )
;

//
// send ipv4 packet with ipv4 option
//
EFI_STATUS
Ipv4SendWOp (
  PXE_BASECODE_DEVICE         *Private,
  UINT32                      GatewayIP,
  UINT8                       *MessagePtr,
  UINTN                       MessageLth,
  UINT8                       Protocol,
  UINT8                       *Option,
  UINTN                       OptionLen,
  UINT32                      DestIp,
  EFI_PXE_BASE_CODE_FUNCTION  Function
  )
;

//
// send MsgLth message at MsgPtr - higher level protocol header already in xmtbuf, length HdrSize
//
EFI_STATUS
Ip4Send (
  IN PXE_BASECODE_DEVICE  *Private,     // pointer to instance data
  IN UINTN                MayFragment,  //
  IN UINT8                Protocol,     // protocol
  IN UINT32               SrcIp,        // Source IP address
  IN UINT32               DestIp,       // Destination IP address
  IN UINT32               GatewayIp,    // used if not NULL and needed
  IN UINTN                HeaderSize,   // protocol header byte length
  IN UINT8                *MsgPtr,      // pointer to data
  IN UINTN                MsgLength
  )
;                                    // data byte length
// receive up to MsgLth message into MsgPtr for protocol Prot
// return message length, src/dest ips if select any, and pointer to protocol header
//
EFI_STATUS
IpReceive (
  IN PXE_BASECODE_DEVICE    *Private,   // pointer to instance data
  UINT16                    OpFlags,    // Flags to determine if filtering on IP addresses
  EFI_IP_ADDRESS            *SrcIpPtr,  // if filtering, O if accept any
  EFI_IP_ADDRESS            *DstIpPtr,  // if filtering, O if accept any
  UINT8                     Protocol,   // protocol
  VOID                      *HeaderPtr, // address of where to put protocol header
  UINTN                     HeaderSize, // protocol header byte length
  UINT8                     *MsgPtr,    // pointer to data buffer
  UINTN                     *MsgLenPtr, // pointer to data buffer length/ O - returned data length
  IN EFI_EVENT              TimeoutEvent
  )
;

#if 0
VOID
WaitForTxComplete (
  IN PXE_BASECODE_DEVICE    *Private
  )
;
#endif
//
// routine to cycle waiting for a receive or timeout
//
EFI_STATUS
WaitForReceive (
  IN PXE_BASECODE_DEVICE        *Private,
  IN EFI_PXE_BASE_CODE_FUNCTION Function,
  IN EFI_EVENT                  TimeoutEvent,
  IN OUT UINTN                  *HeaderSizePtr,
  IN OUT UINTN                  *BufferSizePtr,
  IN OUT UINT16                 *ProtocolPtr
  )
;

#endif /* _IP_H_ */

/* EOF - ip.h */