NetLib.h

Go to the documentation of this file.

 
#ifndef _NET_LIB_H_
#define _NET_LIB_H_
 
#include <Protocol/Ip6.h>
 
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
 
typedef UINT32  IP4_ADDR;
typedef UINT32  TCP_SEQNO;
typedef UINT16  TCP_PORTNO;
 
#define  NET_ETHER_ADDR_LEN   6
#define  NET_IFTYPE_ETHERNET  0x01
 
#define  NET_VLAN_TAG_LEN  4
#define  ETHER_TYPE_VLAN   0x8100
 
#define  EFI_IP_PROTO_UDP      0x11
#define  EFI_IP_PROTO_TCP      0x06
#define  EFI_IP_PROTO_ICMP     0x01
#define  IP4_PROTO_IGMP        0x02
#define  IP6_ICMP              58
#define  DNS_MAX_NAME_SIZE     255
#define  DNS_MAX_MESSAGE_SIZE  512
 
//
// The address classification
//
#define  IP4_ADDR_CLASSA  1          // Deprecated
#define  IP4_ADDR_CLASSB  2          // Deprecated
#define  IP4_ADDR_CLASSC  3          // Deprecated
#define  IP4_ADDR_CLASSD  4
#define  IP4_ADDR_CLASSE  5
 
#define  IP4_MASK_NUM    33
#define  IP6_PREFIX_NUM  129
 
#define  IP4_MASK_MAX    32
#define  IP6_PREFIX_MAX  128
 
#define  IP6_HOP_BY_HOP      0
#define  IP6_DESTINATION     60
#define  IP6_ROUTING         43
#define  IP6_FRAGMENT        44
#define  IP6_AH              51
#define  IP6_ESP             50
#define  IP6_NO_NEXT_HEADER  59
 
#define  IP_VERSION_4  4
#define  IP_VERSION_6  6
 
#define  IP6_PREFIX_LENGTH  64
 
//
// DNS QTYPE values
//
#define  DNS_TYPE_A       1
#define  DNS_TYPE_NS      2
#define  DNS_TYPE_CNAME   5
#define  DNS_TYPE_SOA     6
#define  DNS_TYPE_WKS     11
#define  DNS_TYPE_PTR     12
#define  DNS_TYPE_HINFO   13
#define  DNS_TYPE_MINFO   14
#define  DNS_TYPE_MX      15
#define  DNS_TYPE_TXT     16
#define  DNS_TYPE_AAAA    28
#define  DNS_TYPE_SRV_RR  33
#define  DNS_TYPE_AXFR    252
#define  DNS_TYPE_MAILB   253
#define  DNS_TYPE_ANY     255
 
//
// DNS QCLASS values
//
#define  DNS_CLASS_INET  1
#define  DNS_CLASS_CH    3
#define  DNS_CLASS_HS    4
#define  DNS_CLASS_ANY   255
 
//
// Number of 100ns units time Interval for network media state detect
//
#define MEDIA_STATE_DETECT_TIME_INTERVAL  1000000U
 
#pragma pack(1)
 
//
// Ethernet head definition
//
typedef struct {
  UINT8     DstMac[NET_ETHER_ADDR_LEN];
  UINT8     SrcMac[NET_ETHER_ADDR_LEN];
  UINT16    EtherType;
} ETHER_HEAD;
 
//
// 802.1Q VLAN Tag Control Information
//
typedef union {
  struct {
    UINT16    Vid      : 12;            // Unique VLAN identifier (0 to 4094)
    UINT16    Cfi      : 1;             // Canonical Format Indicator
    UINT16    Priority : 3;             // 802.1Q priority level (0 to 7)
  } Bits;
  UINT16    Uint16;
} VLAN_TCI;
 
#define VLAN_TCI_CFI_CANONICAL_MAC      0
#define VLAN_TCI_CFI_NON_CANONICAL_MAC  1
 
//
// The EFI_IP4_HEADER is hard to use because the source and
// destination address are defined as EFI_IPv4_ADDRESS, which
// is a structure. Two structures can't be compared or masked
// directly. This is why there is an internal representation.
//
typedef struct {
  UINT8       HeadLen : 4;
  UINT8       Ver     : 4;
  UINT8       Tos;
  UINT16      TotalLen;
  UINT16      Id;
  UINT16      Fragment;
  UINT8       Ttl;
  UINT8       Protocol;
  UINT16      Checksum;
  IP4_ADDR    Src;
  IP4_ADDR    Dst;
} IP4_HEAD;
 
//
// ICMP head definition. Each ICMP message is categorized as either an error
// message or query message. Two message types have their own head format.
//
typedef struct {
  UINT8     Type;
  UINT8     Code;
  UINT16    Checksum;
} IP4_ICMP_HEAD;
 
typedef struct {
  IP4_ICMP_HEAD    Head;
  UINT32           Fourth;      // 4th filed of the head, it depends on Type.
  IP4_HEAD         IpHead;
} IP4_ICMP_ERROR_HEAD;
 
typedef struct {
  IP4_ICMP_HEAD    Head;
  UINT16           Id;
  UINT16           Seq;
} IP4_ICMP_QUERY_HEAD;
 
typedef struct {
  UINT8     Type;
  UINT8     Code;
  UINT16    Checksum;
} IP6_ICMP_HEAD;
 
typedef struct {
  IP6_ICMP_HEAD     Head;
  UINT32            Fourth;
  EFI_IP6_HEADER    IpHead;
} IP6_ICMP_ERROR_HEAD;
 
typedef struct {
  IP6_ICMP_HEAD    Head;
  UINT32           Fourth;
} IP6_ICMP_INFORMATION_HEAD;
 
//
// UDP header definition
//
typedef struct {
  UINT16    SrcPort;
  UINT16    DstPort;
  UINT16    Length;
  UINT16    Checksum;
} EFI_UDP_HEADER;
 
//
// TCP header definition
//
typedef struct {
  TCP_PORTNO    SrcPort;
  TCP_PORTNO    DstPort;
  TCP_SEQNO     Seq;
  TCP_SEQNO     Ack;
  UINT8         Res     : 4;
  UINT8         HeadLen : 4;
  UINT8         Flag;
  UINT16        Wnd;
  UINT16        Checksum;
  UINT16        Urg;
} TCP_HEAD;
 
#pragma pack()
 
#define NET_MAC_EQUAL(pMac1, pMac2, Len)     \
    (CompareMem ((pMac1), (pMac2), Len) == 0)
 
#define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \
    (((*((UINT8 *) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len)))
 
#define NTOHL(x)  SwapBytes32 (x)
 
#define HTONL(x)  NTOHL(x)
 
#define NTOHS(x)  SwapBytes16 (x)
 
#define HTONS(x)    NTOHS(x)
#define NTOHLL(x)   SwapBytes64 (x)
#define HTONLL(x)   NTOHLL(x)
#define NTOHLLL(x)  Ip6Swap128 (x)
#define HTONLLL(x)  NTOHLLL(x)
 
//
// Test the IP's attribute, All the IPs are in host byte order.
//
#define IP4_IS_MULTICAST(Ip)              (((Ip) & 0xF0000000) == 0xE0000000)
#define IP4_IS_UNSPECIFIED(Ip)            ((Ip) == 0)
#define IP4_IS_LOCAL_BROADCAST(Ip)        ((Ip) == 0xFFFFFFFF)
#define IP4_NET_EQUAL(Ip1, Ip2, NetMask)  (((Ip1) & (NetMask)) == ((Ip2) & (NetMask)))
#define IP4_IS_VALID_NETMASK(Ip)          (NetGetMaskLength (Ip) != (IP4_MASK_MAX + 1))
 
#define IP6_IS_MULTICAST(Ip6)  (((Ip6)->Addr[0]) == 0xFF)
 
//
// Convert the EFI_IP4_ADDRESS to plain UINT32 IP4 address.
//
#define EFI_IP4(EfiIpAddr)       (*(IP4_ADDR *) ((EfiIpAddr).Addr))
#define EFI_NTOHL(EfiIp)         (NTOHL (EFI_IP4 ((EfiIp))))
#define EFI_IP4_EQUAL(Ip1, Ip2)  (CompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0)
 
#define EFI_IP6_EQUAL(Ip1, Ip2)  (CompareMem ((Ip1), (Ip2), sizeof (EFI_IPv6_ADDRESS)) == 0)
 
#define IP4_COPY_ADDRESS(Dest, Src)        (CopyMem ((Dest), (Src), sizeof (EFI_IPv4_ADDRESS)))
#define IP6_COPY_ADDRESS(Dest, Src)        (CopyMem ((Dest), (Src), sizeof (EFI_IPv6_ADDRESS)))
#define IP6_COPY_LINK_ADDRESS(Mac1, Mac2)  (CopyMem ((Mac1), (Mac2), sizeof (EFI_MAC_ADDRESS)))
 
//
// The debug level definition. This value is also used as the
// syslog's severity level. Don't change it.
//
#define NETDEBUG_LEVEL_TRACE    5
#define NETDEBUG_LEVEL_WARNING  4
#define NETDEBUG_LEVEL_ERROR    3
 
//
// Network debug message is sent out as syslog packet.
//
#define NET_SYSLOG_FACILITY    16                 // Syslog local facility local use
#define NET_SYSLOG_PACKET_LEN  512
#define NET_SYSLOG_TX_TIMEOUT  (500 * 1000 * 10)  // 500ms
#define NET_DEBUG_MSG_LEN      470                // 512 - (ether+ip4+udp4 head length)
 
//
// The debug output expects the ASCII format string, Use %a to print ASCII
// string, and %s to print UNICODE string. PrintArg must be enclosed in ().
// For example: NET_DEBUG_TRACE ("Tcp", ("State transit to %a\n", Name));
//
#define NET_DEBUG_TRACE(Module, PrintArg) \
  NetDebugOutput ( \
    NETDEBUG_LEVEL_TRACE, \
    Module, \
    __FILE__, \
    DEBUG_LINE_NUMBER, \
    NetDebugASPrint PrintArg \
    )
 
#define NET_DEBUG_WARNING(Module, PrintArg) \
  NetDebugOutput ( \
    NETDEBUG_LEVEL_WARNING, \
    Module, \
    __FILE__, \
    DEBUG_LINE_NUMBER, \
    NetDebugASPrint PrintArg \
    )
 
#define NET_DEBUG_ERROR(Module, PrintArg) \
  NetDebugOutput ( \
    NETDEBUG_LEVEL_ERROR, \
    Module, \
    __FILE__, \
    DEBUG_LINE_NUMBER, \
    NetDebugASPrint PrintArg \
    )
 
CHAR8 *
EFIAPI
NetDebugASPrint (
  IN CHAR8  *Format,
  ...
  );
 
EFI_STATUS
EFIAPI
NetDebugOutput (
  IN UINT32  Level,
  IN UINT8   *Module,
  IN UINT8   *File,
  IN UINT32  Line,
  IN UINT8   *Message
  );
 
INTN
EFIAPI
NetGetMaskLength (
  IN IP4_ADDR  NetMask
  );
 
INTN
EFIAPI
NetGetIpClass (
  IN IP4_ADDR  Addr
  );
 
BOOLEAN
EFIAPI
NetIp4IsUnicast (
  IN IP4_ADDR  Ip,
  IN IP4_ADDR  NetMask
  );
 
BOOLEAN
EFIAPI
NetIp6IsValidUnicast (
  IN EFI_IPv6_ADDRESS  *Ip6
  );
 
BOOLEAN
EFIAPI
NetIp6IsUnspecifiedAddr (
  IN EFI_IPv6_ADDRESS  *Ip6
  );
 
BOOLEAN
EFIAPI
NetIp6IsLinkLocalAddr (
  IN EFI_IPv6_ADDRESS  *Ip6
  );
 
BOOLEAN
EFIAPI
NetIp6IsNetEqual (
  EFI_IPv6_ADDRESS  *Ip1,
  EFI_IPv6_ADDRESS  *Ip2,
  UINT8             PrefixLength
  );
 
EFI_IPv6_ADDRESS *
EFIAPI
Ip6Swap128 (
  EFI_IPv6_ADDRESS  *Ip6
  );
 
extern IP4_ADDR  gIp4AllMasks[IP4_MASK_NUM];
 
extern EFI_IPv4_ADDRESS  mZeroIp4Addr;
 
#define NET_IS_DIGIT(Ch)            (('0' <= (Ch)) && ((Ch) <= '9'))
#define NET_IS_HEX(Ch)              ((('0' <= (Ch)) && ((Ch) <= '9')) || (('A' <= (Ch)) && ((Ch) <= 'F')) || (('a' <= (Ch)) && ((Ch) <= 'f')))
#define NET_ROUNDUP(size, unit)     (((size) + (unit) - 1) & (~((unit) - 1)))
#define NET_IS_LOWER_CASE_CHAR(Ch)  (('a' <= (Ch)) && ((Ch) <= 'z'))
#define NET_IS_UPPER_CASE_CHAR(Ch)  (('A' <= (Ch)) && ((Ch) <= 'Z'))
 
#define TICKS_PER_MS      10000U
#define TICKS_PER_SECOND  10000000U
 
UINT32
EFIAPI
NetGetUint32 (
  IN UINT8  *Buf
  );
 
VOID
EFIAPI
NetPutUint32 (
  IN OUT UINT8   *Buf,
  IN     UINT32  Data
  );
 
EFI_STATUS
EFIAPI
PseudoRandom (
  OUT  VOID   *Output,
  IN   UINTN  OutputLength
  );
 
EFI_STATUS
EFIAPI
PseudoRandomU32 (
  OUT  UINT32  *Output
  );
 
#define NET_LIST_USER_STRUCT(Entry, Type, Field)        \
          BASE_CR(Entry, Type, Field)
 
#define NET_LIST_USER_STRUCT_S(Entry, Type, Field, Sig)  \
          CR(Entry, Type, Field, Sig)
 
//
// Iterate through the double linked list. It is NOT delete safe
//
#define NET_LIST_FOR_EACH(Entry, ListHead) \
  for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink)
 
//
// Iterate through the double linked list. This is delete-safe.
// Don't touch NextEntry. Also, don't use this macro if list
// entries other than the Entry may be deleted when processing
// the current Entry.
//
#define NET_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \
  for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink; \
      Entry != (ListHead); \
      Entry = NextEntry, NextEntry = Entry->ForwardLink \
     )
 
//
// Make sure the list isn't empty before getting the first/last record.
//
#define NET_LIST_HEAD(ListHead, Type, Field)  \
          NET_LIST_USER_STRUCT((ListHead)->ForwardLink, Type, Field)
 
#define NET_LIST_TAIL(ListHead, Type, Field)  \
          NET_LIST_USER_STRUCT((ListHead)->BackLink, Type, Field)
 
LIST_ENTRY *
EFIAPI
NetListRemoveHead (
  IN OUT LIST_ENTRY  *Head
  );
 
LIST_ENTRY *
EFIAPI
NetListRemoveTail (
  IN OUT LIST_ENTRY  *Head
  );
 
VOID
EFIAPI
NetListInsertAfter (
  IN OUT LIST_ENTRY  *PrevEntry,
  IN OUT LIST_ENTRY  *NewEntry
  );
 
VOID
EFIAPI
NetListInsertBefore (
  IN OUT LIST_ENTRY  *PostEntry,
  IN OUT LIST_ENTRY  *NewEntry
  );
 
typedef
EFI_STATUS
(EFIAPI *NET_DESTROY_LINK_LIST_CALLBACK)(
  IN LIST_ENTRY         *Entry,
  IN VOID               *Context   OPTIONAL
  );
 
EFI_STATUS
EFIAPI
NetDestroyLinkList (
  IN   LIST_ENTRY                      *List,
  IN   NET_DESTROY_LINK_LIST_CALLBACK  CallBack,
  IN   VOID                            *Context     OPTIONAL,
  OUT  UINTN                           *ListLength  OPTIONAL
  );
 
BOOLEAN
EFIAPI
NetIsInHandleBuffer (
  IN  EFI_HANDLE  Handle,
  IN  UINTN       NumberOfChildren,
  IN  EFI_HANDLE  *ChildHandleBuffer OPTIONAL
  );
 
//
// Object container: EFI network stack spec defines various kinds of
// tokens. The drivers can share code to manage those objects.
//
typedef struct {
  LIST_ENTRY    Link;
  VOID          *Key;
  VOID          *Value;
} NET_MAP_ITEM;
 
typedef struct {
  LIST_ENTRY    Used;
  LIST_ENTRY    Recycled;
  UINTN         Count;
} NET_MAP;
 
#define NET_MAP_INCREAMENT  64
 
VOID
EFIAPI
NetMapInit (
  IN OUT NET_MAP  *Map
  );
 
VOID
EFIAPI
NetMapClean (
  IN OUT NET_MAP  *Map
  );
 
BOOLEAN
EFIAPI
NetMapIsEmpty (
  IN NET_MAP  *Map
  );
 
UINTN
EFIAPI
NetMapGetCount (
  IN NET_MAP  *Map
  );
 
EFI_STATUS
EFIAPI
NetMapInsertHead (
  IN OUT NET_MAP  *Map,
  IN VOID         *Key,
  IN VOID         *Value    OPTIONAL
  );
 
EFI_STATUS
EFIAPI
NetMapInsertTail (
  IN OUT NET_MAP  *Map,
  IN VOID         *Key,
  IN VOID         *Value    OPTIONAL
  );
 
NET_MAP_ITEM *
EFIAPI
NetMapFindKey (
  IN  NET_MAP  *Map,
  IN  VOID     *Key
  );
 
VOID *
EFIAPI
NetMapRemoveItem (
  IN  OUT NET_MAP       *Map,
  IN  OUT NET_MAP_ITEM  *Item,
  OUT VOID              **Value           OPTIONAL
  );
 
VOID *
EFIAPI
NetMapRemoveHead (
  IN OUT NET_MAP  *Map,
  OUT VOID        **Value         OPTIONAL
  );
 
VOID *
EFIAPI
NetMapRemoveTail (
  IN OUT NET_MAP  *Map,
  OUT VOID        **Value       OPTIONAL
  );
 
typedef
EFI_STATUS
(EFIAPI *NET_MAP_CALLBACK)(
  IN NET_MAP                *Map,
  IN NET_MAP_ITEM           *Item,
  IN VOID                   *Arg
  );
 
EFI_STATUS
EFIAPI
NetMapIterate (
  IN NET_MAP           *Map,
  IN NET_MAP_CALLBACK  CallBack,
  IN VOID              *Arg      OPTIONAL
  );
 
//
// Helper functions to implement driver binding and service binding protocols.
//
 
EFI_STATUS
EFIAPI
NetLibCreateServiceChild (
  IN  EFI_HANDLE      Controller,
  IN  EFI_HANDLE      Image,
  IN  EFI_GUID        *ServiceBindingGuid,
  IN  OUT EFI_HANDLE  *ChildHandle
  );
 
EFI_STATUS
EFIAPI
NetLibDestroyServiceChild (
  IN  EFI_HANDLE  Controller,
  IN  EFI_HANDLE  Image,
  IN  EFI_GUID    *ServiceBindingGuid,
  IN  EFI_HANDLE  ChildHandle
  );
 
EFI_HANDLE
EFIAPI
NetLibGetSnpHandle (
  IN   EFI_HANDLE                   ServiceHandle,
  OUT  EFI_SIMPLE_NETWORK_PROTOCOL  **Snp  OPTIONAL
  );
 
UINT16
EFIAPI
NetLibGetVlanId (
  IN EFI_HANDLE  ServiceHandle
  );
 
EFI_HANDLE
EFIAPI
NetLibGetVlanHandle (
  IN EFI_HANDLE  ControllerHandle,
  IN UINT16      VlanId
  );
 
EFI_STATUS
EFIAPI
NetLibGetMacAddress (
  IN  EFI_HANDLE       ServiceHandle,
  OUT EFI_MAC_ADDRESS  *MacAddress,
  OUT UINTN            *AddressSize
  );
 
EFI_STATUS
EFIAPI
NetLibGetMacString (
  IN  EFI_HANDLE  ServiceHandle,
  IN  EFI_HANDLE  ImageHandle  OPTIONAL,
  OUT CHAR16      **MacString
  );
 
EFI_STATUS
EFIAPI
NetLibDetectMedia (
  IN  EFI_HANDLE  ServiceHandle,
  OUT BOOLEAN     *MediaPresent
  );
 
EFI_STATUS
EFIAPI
NetLibDetectMediaWaitTimeout (
  IN  EFI_HANDLE  ServiceHandle,
  IN  UINT64      Timeout,
  OUT EFI_STATUS  *MediaState
  );
 
VOID
EFIAPI
NetLibCreateIPv4DPathNode (
  IN OUT IPv4_DEVICE_PATH  *Node,
  IN EFI_HANDLE            Controller,
  IN IP4_ADDR              LocalIp,
  IN UINT16                LocalPort,
  IN IP4_ADDR              RemoteIp,
  IN UINT16                RemotePort,
  IN UINT16                Protocol,
  IN BOOLEAN               UseDefaultAddress
  );
 
VOID
EFIAPI
NetLibCreateIPv6DPathNode (
  IN OUT IPv6_DEVICE_PATH  *Node,
  IN EFI_HANDLE            Controller,
  IN EFI_IPv6_ADDRESS      *LocalIp,
  IN UINT16                LocalPort,
  IN EFI_IPv6_ADDRESS      *RemoteIp,
  IN UINT16                RemotePort,
  IN UINT16                Protocol
  );
 
EFI_HANDLE
EFIAPI
NetLibGetNicHandle (
  IN EFI_HANDLE  Controller,
  IN EFI_GUID    *ProtocolGuid
  );
 
EFI_STATUS
EFIAPI
NetLibDefaultUnload (
  IN EFI_HANDLE  ImageHandle
  );
 
EFI_STATUS
EFIAPI
NetLibAsciiStrToIp4 (
  IN CONST CHAR8             *String,
  OUT      EFI_IPv4_ADDRESS  *Ip4Address
  );
 
EFI_STATUS
EFIAPI
NetLibAsciiStrToIp6 (
  IN CONST CHAR8             *String,
  OUT      EFI_IPv6_ADDRESS  *Ip6Address
  );
 
EFI_STATUS
EFIAPI
NetLibStrToIp4 (
  IN CONST CHAR16            *String,
  OUT      EFI_IPv4_ADDRESS  *Ip4Address
  );
 
EFI_STATUS
EFIAPI
NetLibStrToIp6 (
  IN CONST CHAR16            *String,
  OUT      EFI_IPv6_ADDRESS  *Ip6Address
  );
 
EFI_STATUS
EFIAPI
NetLibStrToIp6andPrefix (
  IN CONST CHAR16            *String,
  OUT      EFI_IPv6_ADDRESS  *Ip6Address,
  OUT      UINT8             *PrefixLength
  );
 
EFI_STATUS
EFIAPI
NetLibIp6ToStr (
  IN         EFI_IPv6_ADDRESS  *Ip6Address,
  OUT        CHAR16            *String,
  IN         UINTN             StringSize
  );
 
//
// Various signatures
//
#define  NET_BUF_SIGNATURE     SIGNATURE_32 ('n', 'b', 'u', 'f')
#define  NET_VECTOR_SIGNATURE  SIGNATURE_32 ('n', 'v', 'e', 'c')
#define  NET_QUE_SIGNATURE     SIGNATURE_32 ('n', 'b', 'q', 'u')
 
#define  NET_PROTO_DATA        64   // Opaque buffer for protocols
#define  NET_BUF_HEAD          1    // Trim or allocate space from head
#define  NET_BUF_TAIL          0    // Trim or allocate space from tail
#define  NET_VECTOR_OWN_FIRST  0x01 // We allocated the 1st block in the vector
 
#define NET_CHECK_SIGNATURE(PData, SIGNATURE) \
  ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE)))
 
//
// Single memory block in the vector.
//
typedef struct {
  UINT32    Len;                  // The block's length
  UINT8     *Bulk;                // The block's Data
} NET_BLOCK;
 
typedef VOID (EFIAPI *NET_VECTOR_EXT_FREE)(VOID *Arg);
 
//
// NET_VECTOR contains several blocks to hold all packet's
// fragments and other house-keeping stuff for sharing. It
// doesn't specify the where actual packet fragment begins.
//
typedef struct {
  UINT32                 Signature;
  INTN                   RefCnt; // Reference count to share NET_VECTOR.
  NET_VECTOR_EXT_FREE    Free;   // external function to free NET_VECTOR
  VOID                   *Arg;   // opaque argument to Free
  UINT32                 Flag;   // Flags, NET_VECTOR_OWN_FIRST
  UINT32                 Len;    // Total length of the associated BLOCKs
 
  UINT32                 BlockNum;
  NET_BLOCK              Block[1];
} NET_VECTOR;
 
//
// NET_BLOCK_OP operates on the NET_BLOCK. It specifies
// where the actual fragment begins and ends
//
typedef struct {
  UINT8     *BlockHead;             // Block's head, or the smallest valid Head
  UINT8     *BlockTail;             // Block's tail. BlockTail-BlockHead=block length
  UINT8     *Head;                  // 1st byte of the data in the block
  UINT8     *Tail;                  // Tail of the data in the block, Tail-Head=Size
  UINT32    Size;                   // The size of the data
} NET_BLOCK_OP;
 
typedef union {
  IP4_HEAD          *Ip4;
  EFI_IP6_HEADER    *Ip6;
} NET_IP_HEAD;
 
//
// NET_BUF is the buffer manage structure used by the
// network stack. Every network packet may be fragmented. The Vector points to
// memory blocks used by each fragment, and BlockOp
// specifies where each fragment begins and ends.
//
// It also contains an opaque area for the protocol to store
// per-packet information. Protocol must be careful not
// to overwrite the members after that.
//
typedef struct {
  UINT32            Signature;
  INTN              RefCnt;
  LIST_ENTRY        List;                    // The List this NET_BUF is on
 
  NET_IP_HEAD       Ip;                        // Network layer header, for fast access
  TCP_HEAD          *Tcp;                      // Transport layer header, for fast access
  EFI_UDP_HEADER    *Udp;                      // User Datagram Protocol header
  UINT8             ProtoData[NET_PROTO_DATA]; // Protocol specific data
 
  NET_VECTOR        *Vector;                 // The vector containing the packet
 
  UINT32            BlockOpNum;              // Total number of BlockOp in the buffer
  UINT32            TotalSize;               // Total size of the actual packet
  NET_BLOCK_OP      BlockOp[1];              // Specify the position of actual packet
} NET_BUF;
 
//
// A queue of NET_BUFs. It is a thin extension of
// NET_BUF functions.
//
typedef struct {
  UINT32        Signature;
  INTN          RefCnt;
  LIST_ENTRY    List;             // The List this buffer queue is on
 
  LIST_ENTRY    BufList;          // list of queued buffers
  UINT32        BufSize;          // total length of DATA in the buffers
  UINT32        BufNum;           // total number of buffers on the chain
} NET_BUF_QUEUE;
 
//
// Pseudo header for TCP and UDP checksum
//
#pragma pack(1)
typedef struct {
  IP4_ADDR    SrcIp;
  IP4_ADDR    DstIp;
  UINT8       Reserved;
  UINT8       Protocol;
  UINT16      Len;
} NET_PSEUDO_HDR;
 
typedef struct {
  EFI_IPv6_ADDRESS    SrcIp;
  EFI_IPv6_ADDRESS    DstIp;
  UINT32              Len;
  UINT32              Reserved   : 24;
  UINT32              NextHeader : 8;
} NET_IP6_PSEUDO_HDR;
#pragma pack()
 
//
// The fragment entry table used in network interfaces. This is
// the same as NET_BLOCK now. Use two different to distinguish
// the two in case that NET_BLOCK be enhanced later.
//
typedef struct {
  UINT32    Len;
  UINT8     *Bulk;
} NET_FRAGMENT;
 
#define NET_GET_REF(PData)           ((PData)->RefCnt++)
#define NET_PUT_REF(PData)           ((PData)->RefCnt--)
#define NETBUF_FROM_PROTODATA(Info)  BASE_CR((Info), NET_BUF, ProtoData)
 
#define NET_BUF_SHARED(Buf) \
  (((Buf)->RefCnt > 1) || ((Buf)->Vector->RefCnt > 1))
 
#define NET_VECTOR_SIZE(BlockNum) \
  (sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK))
 
#define NET_BUF_SIZE(BlockOpNum)  \
  (sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP))
 
#define NET_HEADSPACE(BlockOp)  \
  ((UINTN)((BlockOp)->Head) - (UINTN)((BlockOp)->BlockHead))
 
#define NET_TAILSPACE(BlockOp)  \
  ((UINTN)((BlockOp)->BlockTail) - (UINTN)((BlockOp)->Tail))
 
NET_BUF  *
EFIAPI
NetbufAlloc (
  IN UINT32  Len
  );
 
VOID
EFIAPI
NetbufFree (
  IN NET_BUF  *Nbuf
  );
 
UINT8  *
EFIAPI
NetbufGetByte (
  IN  NET_BUF  *Nbuf,
  IN  UINT32   Offset,
  OUT UINT32   *Index  OPTIONAL
  );
 
NET_BUF *
EFIAPI
NetbufClone (
  IN NET_BUF  *Nbuf
  );
 
NET_BUF  *
EFIAPI
NetbufDuplicate (
  IN NET_BUF      *Nbuf,
  IN OUT NET_BUF  *Duplicate        OPTIONAL,
  IN UINT32       HeadSpace
  );
 
NET_BUF  *
EFIAPI
NetbufGetFragment (
  IN NET_BUF  *Nbuf,
  IN UINT32   Offset,
  IN UINT32   Len,
  IN UINT32   HeadSpace
  );
 
VOID
EFIAPI
NetbufReserve (
  IN OUT NET_BUF  *Nbuf,
  IN UINT32       Len
  );
 
UINT8 *
EFIAPI
NetbufAllocSpace (
  IN OUT NET_BUF  *Nbuf,
  IN UINT32       Len,
  IN BOOLEAN      FromHead
  );
 
UINT32
EFIAPI
NetbufTrim (
  IN OUT NET_BUF  *Nbuf,
  IN UINT32       Len,
  IN BOOLEAN      FromHead
  );
 
UINT32
EFIAPI
NetbufCopy (
  IN NET_BUF  *Nbuf,
  IN UINT32   Offset,
  IN UINT32   Len,
  IN UINT8    *Dest
  );
 
NET_BUF  *
EFIAPI
NetbufFromExt (
  IN NET_FRAGMENT         *ExtFragment,
  IN UINT32               ExtNum,
  IN UINT32               HeadSpace,
  IN UINT32               HeadLen,
  IN NET_VECTOR_EXT_FREE  ExtFree,
  IN VOID                 *Arg          OPTIONAL
  );
 
EFI_STATUS
EFIAPI
NetbufBuildExt (
  IN NET_BUF           *Nbuf,
  IN OUT NET_FRAGMENT  *ExtFragment,
  IN OUT UINT32        *ExtNum
  );
 
NET_BUF  *
EFIAPI
NetbufFromBufList (
  IN LIST_ENTRY           *BufList,
  IN UINT32               HeadSpace,
  IN UINT32               HeaderLen,
  IN NET_VECTOR_EXT_FREE  ExtFree,
  IN VOID                 *Arg              OPTIONAL
  );
 
VOID
EFIAPI
NetbufFreeList (
  IN OUT LIST_ENTRY  *Head
  );
 
VOID
EFIAPI
NetbufQueInit (
  IN OUT NET_BUF_QUEUE  *NbufQue
  );
 
NET_BUF_QUEUE  *
EFIAPI
NetbufQueAlloc (
  VOID
  );
 
VOID
EFIAPI
NetbufQueFree (
  IN NET_BUF_QUEUE  *NbufQue
  );
 
NET_BUF  *
EFIAPI
NetbufQueRemove (
  IN OUT NET_BUF_QUEUE  *NbufQue
  );
 
VOID
EFIAPI
NetbufQueAppend (
  IN OUT NET_BUF_QUEUE  *NbufQue,
  IN OUT NET_BUF        *Nbuf
  );
 
UINT32
EFIAPI
NetbufQueCopy (
  IN NET_BUF_QUEUE  *NbufQue,
  IN UINT32         Offset,
  IN UINT32         Len,
  OUT UINT8         *Dest
  );
 
UINT32
EFIAPI
NetbufQueTrim (
  IN OUT NET_BUF_QUEUE  *NbufQue,
  IN UINT32             Len
  );
 
VOID
EFIAPI
NetbufQueFlush (
  IN OUT NET_BUF_QUEUE  *NbufQue
  );
 
UINT16
EFIAPI
NetblockChecksum (
  IN UINT8   *Bulk,
  IN UINT32  Len
  );
 
UINT16
EFIAPI
NetAddChecksum (
  IN UINT16  Checksum1,
  IN UINT16  Checksum2
  );
 
UINT16
EFIAPI
NetbufChecksum (
  IN NET_BUF  *Nbuf
  );
 
UINT16
EFIAPI
NetPseudoHeadChecksum (
  IN IP4_ADDR  Src,
  IN IP4_ADDR  Dst,
  IN UINT8     Proto,
  IN UINT16    Len
  );
 
UINT16
EFIAPI
NetIp6PseudoHeadChecksum (
  IN EFI_IPv6_ADDRESS  *Src,
  IN EFI_IPv6_ADDRESS  *Dst,
  IN UINT8             NextHeader,
  IN UINT32            Len
  );
 
VOID
NetIpSecNetbufFree (
  NET_BUF  *Nbuf
  );
 
EFI_STATUS
EFIAPI
NetLibGetSystemGuid (
  OUT EFI_GUID  *SystemGuid
  );
 
CHAR8 *
EFIAPI
NetLibCreateDnsQName (
  IN  CHAR16  *DomainName
  );
 
#endif