[mirror_edk2.git] / MdeModulePkg / Include / Library / NetLib.h

/** @file

Copyright (c) 2005 - 2007, 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.

Module Name:

  NetLib.h

Abstract:

  Library for the UEFI network stack.


**/

#ifndef _NET_LIB_H_
#define _NET_LIB_H_

#include <PiDxe.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Protocol/DriverBinding.h>
#include <Protocol/ComponentName.h>
#include <Protocol/DriverConfiguration.h>
#include <Protocol/DriverDiagnostics.h>
#include <Protocol/Dpc.h>

typedef UINT32          IP4_ADDR;
typedef UINT32          TCP_SEQNO;
typedef UINT16          TCP_PORTNO;

enum {
  NET_ETHER_ADDR_LEN    = 6,
  NET_IFTYPE_ETHERNET   = 0x01,

  EFI_IP_PROTO_UDP      = 0x11,
  EFI_IP_PROTO_TCP      = 0x06,
  EFI_IP_PROTO_ICMP     = 0x01,

  //
  // The address classfication
  //
  IP4_ADDR_CLASSA       = 1,
  IP4_ADDR_CLASSB,
  IP4_ADDR_CLASSC,
  IP4_ADDR_CLASSD,
  IP4_ADDR_CLASSE,

  IP4_MASK_NUM          = 33,
};

#pragma pack(1)

//
// Ethernet head definition
//
typedef struct {
  UINT8                 DstMac [NET_ETHER_ADDR_LEN];
  UINT8                 SrcMac [NET_ETHER_ADDR_LEN];
  UINT16                EtherType;
} ETHER_HEAD;


//
// 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. ICMP message is categoried 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;


//
// UDP header definition
//
typedef struct {
  UINT16                SrcPort;
  UINT16                DstPort;
  UINT16                Length;
  UINT16                Checksum;
} EFI_UDP4_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) (UINT32)((((UINT32) (x) & 0xff)     << 24) | \
                          (((UINT32) (x) & 0xff00)   << 8)  | \
                          (((UINT32) (x) & 0xff0000) >> 8)  | \
                          (((UINT32) (x) & 0xff000000) >> 24))

#define HTONL(x)  NTOHL(x)

#define NTOHS(x)  (UINT16)((((UINT16) (x) & 0xff) << 8) | \
                           (((UINT16) (x) & 0xff00) >> 8))

#define HTONS(x)  NTOHS(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_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_NUM)

//
// 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)

INTN
NetGetMaskLength (
  IN IP4_ADDR               Mask
  );

INTN
NetGetIpClass (
  IN IP4_ADDR               Addr
  );

BOOLEAN
Ip4IsUnicast (
  IN IP4_ADDR               Ip,
  IN IP4_ADDR               NetMask
  );

extern IP4_ADDR mIp4AllMasks [IP4_MASK_NUM];


extern EFI_IPv4_ADDRESS  mZeroIp4Addr;

#define NET_IS_DIGIT(Ch)            (('0' <= (Ch)) && ((Ch) <= '9'))
#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

#define NET_RANDOM(Seed)        ((UINT32) ((UINT32) (Seed) * 1103515245UL + 12345) % 4294967295UL)


UINT32
NetGetUint32 (
  IN UINT8                  *Buf
  );

VOID
NetPutUint32 (
  IN UINT8                  *Buf,
  IN UINT32                 Data
  );

UINT32
NetRandomInitSeed (
  VOID
  );


#define NET_LIST_USER_STRUCT(Entry, Type, Field)        \
          _CR(Entry, Type, Field)

#define NET_LIST_USER_STRUCT_S(Entry, Type, Field, Sig)  \
          CR(Entry, Type, Field, Sig)

//
// Iterate through the doule 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 doule 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 get the frist/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 *
NetListRemoveHead (
  LIST_ENTRY            *Head
  );

LIST_ENTRY *
NetListRemoveTail (
  LIST_ENTRY            *Head
  );

VOID
NetListInsertAfter (
  IN LIST_ENTRY         *PrevEntry,
  IN LIST_ENTRY         *NewEntry
  );

VOID
NetListInsertBefore (
  IN LIST_ENTRY         *PostEntry,
  IN LIST_ENTRY         *NewEntry
  );


//
// 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
NetMapInit (
  IN NET_MAP                *Map
  );

VOID
NetMapClean (
  IN NET_MAP                *Map
  );

BOOLEAN
NetMapIsEmpty (
  IN NET_MAP                *Map
  );

UINTN
NetMapGetCount (
  IN NET_MAP                *Map
  );

EFI_STATUS
NetMapInsertHead (
  IN NET_MAP                *Map,
  IN VOID                   *Key,
  IN VOID                   *Value    OPTIONAL
  );

EFI_STATUS
NetMapInsertTail (
  IN NET_MAP                *Map,
  IN VOID                   *Key,
  IN VOID                   *Value    OPTIONAL
  );

NET_MAP_ITEM  *
NetMapFindKey (
  IN  NET_MAP               *Map,
  IN  VOID                  *Key
  );

VOID *
NetMapRemoveItem (
  IN  NET_MAP               *Map,
  IN  NET_MAP_ITEM          *Item,
  OUT VOID                  **Value   OPTIONAL
  );

VOID *
NetMapRemoveHead (
  IN  NET_MAP               *Map,
  OUT VOID                  **Value   OPTIONAL
  );

VOID *
NetMapRemoveTail (
  IN  NET_MAP               *Map,
  OUT VOID                  **Value OPTIONAL
  );

typedef
EFI_STATUS
(*NET_MAP_CALLBACK) (
  IN NET_MAP                *Map,
  IN NET_MAP_ITEM           *Item,
  IN VOID                   *Arg
  );

EFI_STATUS
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
NetLibCreateServiceChild (
  IN  EFI_HANDLE            ControllerHandle,
  IN  EFI_HANDLE            ImageHandle,
  IN  EFI_GUID              *ServiceBindingGuid,
  OUT EFI_HANDLE            *ChildHandle
  );

EFI_STATUS
NetLibDestroyServiceChild (
  IN  EFI_HANDLE            ControllerHandle,
  IN  EFI_HANDLE            ImageHandle,
  IN  EFI_GUID              *ServiceBindingGuid,
  IN  EFI_HANDLE            ChildHandle
  );

EFI_STATUS
NetLibGetMacString (
  IN           EFI_HANDLE  SnpHandle,
  IN           EFI_HANDLE  ImageHandle,
  IN OUT       CHAR16      **MacString
  );

VOID
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
  );

EFI_HANDLE
NetLibGetNicHandle (
  IN EFI_HANDLE             Controller,
  IN EFI_GUID               *ProtocolGuid
  );

EFI_STATUS
NetLibQueueDpc (
  IN EFI_TPL            DpcTpl,
  IN EFI_DPC_PROCEDURE  DpcProcedure,
  IN VOID               *DpcContext    OPTIONAL
  );

EFI_STATUS
NetLibDispatchDpc (
  VOID
  );

EFI_STATUS
EFIAPI
NetLibDefaultUnload (
  IN EFI_HANDLE             ImageHandle
  );

enum {
  //
  //Various signatures
  //
  NET_BUF_SIGNATURE    = EFI_SIGNATURE_32 ('n', 'b', 'u', 'f'),
  NET_VECTOR_SIGNATURE = EFI_SIGNATURE_32 ('n', 'v', 'e', 'c'),
  NET_QUE_SIGNATURE    = EFI_SIGNATURE_32 ('n', 'b', 'q', 'u'),


  NET_PROTO_DATA       = 64,   // Opaque buffer for protocols
  NET_BUF_HEAD         = 1,    // Trim or allocate space from head
  NET_BUF_TAIL         = 0,    // Trim or allocate space from tail
  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)))

#define NET_SWAP_SHORT(Value) \
  ((((Value) & 0xff) << 8) | (((Value) >> 8) & 0xff))

//
// Single memory block in the vector.
//
typedef struct {
  UINT32              Len;        // The block's length
  UINT8               *Bulk;      // The block's Data
} NET_BLOCK;

typedef VOID (*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;    // opeque argument to Free
  UINT32              Flag;    // Flags, NET_VECTOR_OWN_FIRST
  UINT32              Len;     // Total length of the assocated BLOCKs

  UINT32              BlockNum;
  NET_BLOCK           Block[1];
} NET_VECTOR;

//
//NET_BLOCK_OP operate on the NET_BLOCK, It specifies
//where the actual fragment begins and where it 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;


//
//NET_BUF is the buffer manage structure used by the
//network stack. Every network packet may be fragmented,
//and contains multiple fragments. The Vector points to
//memory blocks used by the each fragment, and BlockOp
//specifies where each fragment begins and ends.
//
//It also contains a opaque area for protocol to store
//per-packet informations. Protocol must be caution not
//to overwrite the members after that.
//
typedef struct {
  UINT32              Signature;
  INTN                RefCnt;
  LIST_ENTRY          List;       // The List this NET_BUF is on

  IP4_HEAD            *Ip;        // Network layer header, for fast access
  TCP_HEAD            *Tcp;       // Transport layer header, for fast access
  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 just 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;
#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) _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 - (BlockOp)->BlockHead)

#define NET_TAILSPACE(BlockOp)  \
  (UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail)

NET_BUF  *
NetbufAlloc (
  IN UINT32                 Len
  );

VOID
NetbufFree (
  IN NET_BUF                *Nbuf
  );


UINT8  *
NetbufGetByte (
  IN  NET_BUF               *Nbuf,
  IN  UINT32                Offset,
  OUT UINT32                *Index      OPTIONAL
  );

NET_BUF  *
NetbufClone (
  IN NET_BUF                *Nbuf
  );

NET_BUF  *
NetbufDuplicate (
  IN NET_BUF                *Nbuf,
  IN NET_BUF                *Duplicate    OPTIONAL,
  IN UINT32                 HeadSpace
  );

NET_BUF  *
NetbufGetFragment (
  IN NET_BUF                *Nbuf,
  IN UINT32                 Offset,
  IN UINT32                 Len,
  IN UINT32                 HeadSpace
  );

VOID
NetbufReserve (
  IN NET_BUF                *Nbuf,
  IN UINT32                 Len
  );

UINT8  *
NetbufAllocSpace (
  IN NET_BUF                *Nbuf,
  IN UINT32                 Len,
  IN BOOLEAN                FromHead
  );

UINT32
NetbufTrim (
  IN NET_BUF                *Nbuf,
  IN UINT32                 Len,
  IN BOOLEAN                FromHead
  );

UINT32
NetbufCopy (
  IN NET_BUF                *Nbuf,
  IN UINT32                 Offset,
  IN UINT32                 Len,
  IN UINT8                  *Dest
  );

NET_BUF  *
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
NetbufBuildExt (
  IN NET_BUF                *Nbuf,
  IN NET_FRAGMENT           *ExtFragment,
  IN UINT32                 *ExtNum
  );

NET_BUF  *
NetbufFromBufList (
  IN LIST_ENTRY             *BufList,
  IN UINT32                 HeadSpace,
  IN UINT32                 HeaderLen,
  IN NET_VECTOR_EXT_FREE    ExtFree,
  IN VOID                   *Arg                OPTIONAL
  );

VOID
NetbufFreeList (
  IN LIST_ENTRY             *Head
  );

VOID
NetbufQueInit (
  IN NET_BUF_QUEUE          *NbufQue
  );

NET_BUF_QUEUE  *
NetbufQueAlloc (
  VOID
  );

VOID
NetbufQueFree (
  IN NET_BUF_QUEUE          *NbufQue
  );

NET_BUF  *
NetbufQueRemove (
  IN NET_BUF_QUEUE          *NbufQue
  );

VOID
NetbufQueAppend (
  IN NET_BUF_QUEUE          *NbufQue,
  IN NET_BUF                *Nbuf
  );

UINT32
NetbufQueCopy (
  IN NET_BUF_QUEUE          *NbufQue,
  IN UINT32                 Offset,
  IN UINT32                 Len,
  IN UINT8                  *Dest
  );

UINT32
NetbufQueTrim (
  IN NET_BUF_QUEUE          *NbufQue,
  IN UINT32                 Len
  );

VOID
NetbufQueFlush (
  IN NET_BUF_QUEUE          *NbufQue
  );

UINT16
NetblockChecksum (
  IN UINT8                  *Bulk,
  IN UINT32                 Len
  );

UINT16
NetAddChecksum (
  IN UINT16                 Checksum1,
  IN UINT16                 Checksum2
  );

UINT16
NetbufChecksum (
  IN NET_BUF                *Nbuf
  );

UINT16
NetPseudoHeadChecksum (
  IN IP4_ADDR               Src,
  IN IP4_ADDR               Dst,
  IN UINT8                  Proto,
  IN UINT16                 Len
  );

#endif
Commit	Line	Data
cbf316f2	1	/** @file
	2
	3	Copyright (c) 2005 - 2007, Intel Corporation
	4	All rights reserved. This program and the accompanying materials
	5	are licensed and made available under the terms and conditions of the BSD License
	6	which accompanies this distribution. The full text of the license may be found at
	7	http://opensource.org/licenses/bsd-license.php
	8
	9	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
	10	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
	11
	12	Module Name:
	13
	14	NetLib.h
	15
	16	Abstract:
	17
	18	Library for the UEFI network stack.
	19
	20
	21	**/
	22
	23	#ifndef _NET_LIB_H_
	24	#define _NET_LIB_H_
	25
	26	#include <PiDxe.h>
6a690e23	27	#include <Library/BaseMemoryLib.h>
6a690e23	28	#include <Library/MemoryAllocationLib.h>
cbf316f2	29	#include <Protocol/DriverBinding.h>
	30	#include <Protocol/ComponentName.h>
	31	#include <Protocol/DriverConfiguration.h>
	32	#include <Protocol/DriverDiagnostics.h>
36ee91ca	33	#include <Protocol/Dpc.h>
36ee91ca	34
36ee91ca	35	typedef UINT32 IP4_ADDR;
	36	typedef UINT32 TCP_SEQNO;
	37	typedef UINT16 TCP_PORTNO;
	38
	39	enum {
	40	NET_ETHER_ADDR_LEN = 6,
	41	NET_IFTYPE_ETHERNET = 0x01,
	42
	43	EFI_IP_PROTO_UDP = 0x11,
	44	EFI_IP_PROTO_TCP = 0x06,
	45	EFI_IP_PROTO_ICMP = 0x01,
	46
	47	//
	48	// The address classfication
	49	//
	50	IP4_ADDR_CLASSA = 1,
	51	IP4_ADDR_CLASSB,
	52	IP4_ADDR_CLASSC,
	53	IP4_ADDR_CLASSD,
	54	IP4_ADDR_CLASSE,
	55
	56	IP4_MASK_NUM = 33,
	57	};
	58
	59	#pragma pack(1)
	60
	61	//
	62	// Ethernet head definition
	63	//
	64	typedef struct {
	65	UINT8 DstMac [NET_ETHER_ADDR_LEN];
	66	UINT8 SrcMac [NET_ETHER_ADDR_LEN];
	67	UINT16 EtherType;
	68	} ETHER_HEAD;
	69
	70
	71	//
	72	// The EFI_IP4_HEADER is hard to use because the source and
	73	// destination address are defined as EFI_IPv4_ADDRESS, which
	74	// is a structure. Two structures can't be compared or masked
	75	// directly. This is why there is an internal representation.
	76	//
	77	typedef struct {
36ee91ca	78	UINT8 HeadLen : 4;
36ee91ca	79	UINT8 Ver : 4;
36ee91ca	80	UINT8 Tos;
	81	UINT16 TotalLen;
	82	UINT16 Id;
	83	UINT16 Fragment;
	84	UINT8 Ttl;
	85	UINT8 Protocol;
	86	UINT16 Checksum;
	87	IP4_ADDR Src;
	88	IP4_ADDR Dst;
	89	} IP4_HEAD;
	90
	91
	92	//
	93	// ICMP head definition. ICMP message is categoried as either an error
	94	// message or query message. Two message types have their own head format.
	95	//
	96	typedef struct {
	97	UINT8 Type;
	98	UINT8 Code;
	99	UINT16 Checksum;
	100	} IP4_ICMP_HEAD;
	101
	102	typedef struct {
	103	IP4_ICMP_HEAD Head;
	104	UINT32 Fourth; // 4th filed of the head, it depends on Type.
	105	IP4_HEAD IpHead;
	106	} IP4_ICMP_ERROR_HEAD;
	107
	108	typedef struct {
	109	IP4_ICMP_HEAD Head;
	110	UINT16 Id;
	111	UINT16 Seq;
	112	} IP4_ICMP_QUERY_HEAD;
	113
	114
	115	//
	116	// UDP header definition
	117	//
	118	typedef struct {
	119	UINT16 SrcPort;
	120	UINT16 DstPort;
	121	UINT16 Length;
	122	UINT16 Checksum;
	123	} EFI_UDP4_HEADER;
	124
	125
	126	//
	127	// TCP header definition
	128	//
	129	typedef struct {
	130	TCP_PORTNO SrcPort;
	131	TCP_PORTNO DstPort;
	132	TCP_SEQNO Seq;
	133	TCP_SEQNO Ack;
36ee91ca	134	UINT8 Res : 4;
36ee91ca	135	UINT8 HeadLen : 4;
36ee91ca	136	UINT8 Flag;
	137	UINT16 Wnd;
	138	UINT16 Checksum;
	139	UINT16 Urg;
	140	} TCP_HEAD;
	141
	142	#pragma pack()
	143
	144	#define NET_MAC_EQUAL(pMac1, pMac2, Len) \
e48e37fc	145	(CompareMem ((pMac1), (pMac2), Len) == 0)
36ee91ca	146
	147	#define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \
	148	(((((UINT8 ) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len)))
	149
36ee91ca	150	#define NTOHL(x) (UINT32)((((UINT32) (x) & 0xff) << 24) \| \
	151	(((UINT32) (x) & 0xff00) << 8) \| \
	152	(((UINT32) (x) & 0xff0000) >> 8) \| \
	153	(((UINT32) (x) & 0xff000000) >> 24))
	154
	155	#define HTONL(x) NTOHL(x)
	156
	157	#define NTOHS(x) (UINT16)((((UINT16) (x) & 0xff) << 8) \| \
	158	(((UINT16) (x) & 0xff00) >> 8))
	159
	160	#define HTONS(x) NTOHS(x)
36ee91ca	161
	162	//
	163	// Test the IP's attribute, All the IPs are in host byte order.
	164	//
	165	#define IP4_IS_MULTICAST(Ip) (((Ip) & 0xF0000000) == 0xE0000000)
	166	#define IP4_IS_LOCAL_BROADCAST(Ip) ((Ip) == 0xFFFFFFFF)
	167	#define IP4_NET_EQUAL(Ip1, Ip2, NetMask) (((Ip1) & (NetMask)) == ((Ip2) & (NetMask)))
	168	#define IP4_IS_VALID_NETMASK(Ip) (NetGetMaskLength (Ip) != IP4_MASK_NUM)
	169
	170	//
	171	// Convert the EFI_IP4_ADDRESS to plain UINT32 IP4 address.
	172	//
	173	#define EFI_IP4(EfiIpAddr) ((IP4_ADDR ) ((EfiIpAddr).Addr))
	174	#define EFI_NTOHL(EfiIp) (NTOHL (EFI_IP4 ((EfiIp))))
e48e37fc	175	#define EFI_IP4_EQUAL(Ip1, Ip2) (CompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0)
36ee91ca	176
	177	INTN
	178	NetGetMaskLength (
	179	IN IP4_ADDR Mask
	180	);
	181
	182	INTN
	183	NetGetIpClass (
	184	IN IP4_ADDR Addr
	185	);
	186
	187	BOOLEAN
	188	Ip4IsUnicast (
	189	IN IP4_ADDR Ip,
	190	IN IP4_ADDR NetMask
	191	);
cbf316f2	192
cbf316f2	193	extern IP4_ADDR mIp4AllMasks [IP4_MASK_NUM];
cbf316f2	194
cbf316f2	195
772db4bb	196	extern EFI_IPv4_ADDRESS mZeroIp4Addr;
772db4bb	197
c4a62a12	198	#define NET_IS_DIGIT(Ch) (('0' <= (Ch)) && ((Ch) <= '9'))
c4a62a12	199	#define NET_ROUNDUP(size, unit) (((size) + (unit) - 1) & (~((unit) - 1)))
6a690e23	200	#define NET_IS_LOWER_CASE_CHAR(Ch) (('a' <= (Ch)) && ((Ch) <= 'z'))
6a690e23	201	#define NET_IS_UPPER_CASE_CHAR(Ch) (('A' <= (Ch)) && ((Ch) <= 'Z'))
c4a62a12	202
cbf316f2	203	#define TICKS_PER_MS 10000U
	204	#define TICKS_PER_SECOND 10000000U
	205
84b5c78e	206	#define NET_RANDOM(Seed) ((UINT32) ((UINT32) (Seed) * 1103515245UL + 12345) % 4294967295UL)
cbf316f2	207
	208
	209	UINT32
	210	NetGetUint32 (
	211	IN UINT8 *Buf
	212	);
	213
	214	VOID
	215	NetPutUint32 (
	216	IN UINT8 *Buf,
	217	IN UINT32 Data
	218	);
	219
	220	UINT32
	221	NetRandomInitSeed (
	222	VOID
	223	);
	224
	225
cbf316f2	226	#define NET_LIST_USER_STRUCT(Entry, Type, Field) \
	227	_CR(Entry, Type, Field)
	228
	229	#define NET_LIST_USER_STRUCT_S(Entry, Type, Field, Sig) \
	230	CR(Entry, Type, Field, Sig)
	231
	232	//
	233	// Iterate through the doule linked list. It is NOT delete safe
	234	//
	235	#define NET_LIST_FOR_EACH(Entry, ListHead) \
	236	for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink)
	237
	238	//
	239	// Iterate through the doule linked list. This is delete-safe.
	240	// Don't touch NextEntry. Also, don't use this macro if list
	241	// entries other than the Entry may be deleted when processing
	242	// the current Entry.
	243	//
	244	#define NET_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \
	245	for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink; \
	246	Entry != (ListHead); \
	247	Entry = NextEntry, NextEntry = Entry->ForwardLink \
	248	)
	249
	250	//
	251	// Make sure the list isn't empty before get the frist/last record.
	252	//
	253	#define NET_LIST_HEAD(ListHead, Type, Field) \
	254	NET_LIST_USER_STRUCT((ListHead)->ForwardLink, Type, Field)
	255
	256	#define NET_LIST_TAIL(ListHead, Type, Field) \
	257	NET_LIST_USER_STRUCT((ListHead)->BackLink, Type, Field)
	258
cbf316f2	259
e733f542	260	LIST_ENTRY *
cbf316f2	261	NetListRemoveHead (
e48e37fc	262	LIST_ENTRY *Head
cbf316f2	263	);
cbf316f2	264
e733f542	265	LIST_ENTRY *
cbf316f2	266	NetListRemoveTail (
e48e37fc	267	LIST_ENTRY *Head
cbf316f2	268	);
	269
	270	VOID
	271	NetListInsertAfter (
e48e37fc	272	IN LIST_ENTRY *PrevEntry,
e48e37fc	273	IN LIST_ENTRY *NewEntry
cbf316f2	274	);
	275
	276	VOID
	277	NetListInsertBefore (
e48e37fc	278	IN LIST_ENTRY *PostEntry,
e48e37fc	279	IN LIST_ENTRY *NewEntry
cbf316f2	280	);
	281
	282
	283	//
	284	// Object container: EFI network stack spec defines various kinds of
	285	// tokens. The drivers can share code to manage those objects.
	286	//
	287	typedef struct {
e48e37fc	288	LIST_ENTRY Link;
cbf316f2	289	VOID *Key;
	290	VOID *Value;
	291	} NET_MAP_ITEM;
	292
	293	typedef struct {
e48e37fc	294	LIST_ENTRY Used;
e48e37fc	295	LIST_ENTRY Recycled;
cbf316f2	296	UINTN Count;
	297	} NET_MAP;
	298
	299	#define NET_MAP_INCREAMENT 64
	300
	301	VOID
	302	NetMapInit (
	303	IN NET_MAP *Map
	304	);
	305
	306	VOID
	307	NetMapClean (
	308	IN NET_MAP *Map
	309	);
	310
	311	BOOLEAN
	312	NetMapIsEmpty (
	313	IN NET_MAP *Map
	314	);
	315
	316	UINTN
	317	NetMapGetCount (
	318	IN NET_MAP *Map
	319	);
	320
	321	EFI_STATUS
	322	NetMapInsertHead (
	323	IN NET_MAP *Map,
	324	IN VOID *Key,
	325	IN VOID *Value OPTIONAL
	326	);
	327
	328	EFI_STATUS
	329	NetMapInsertTail (
	330	IN NET_MAP *Map,
	331	IN VOID *Key,
	332	IN VOID *Value OPTIONAL
	333	);
	334
	335	NET_MAP_ITEM *
	336	NetMapFindKey (
	337	IN NET_MAP *Map,
	338	IN VOID *Key
	339	);
	340
	341	VOID *
	342	NetMapRemoveItem (
	343	IN NET_MAP *Map,
	344	IN NET_MAP_ITEM *Item,
	345	OUT VOID **Value OPTIONAL
	346	);
	347
	348	VOID *
	349	NetMapRemoveHead (
	350	IN NET_MAP *Map,
	351	OUT VOID **Value OPTIONAL
	352	);
	353
	354	VOID *
	355	NetMapRemoveTail (
	356	IN NET_MAP *Map,
	357	OUT VOID **Value OPTIONAL
	358	);
	359
360	typedef
361	EFI_STATUS
362	(*NET_MAP_CALLBACK) (
363	IN NET_MAP *Map,
364	IN NET_MAP_ITEM *Item,
365	IN VOID *Arg
366	);
367
368	EFI_STATUS
369	NetMapIterate (
370	IN NET_MAP *Map,
371	IN NET_MAP_CALLBACK CallBack,
372	IN VOID *Arg OPTIONAL
373	);
374
375
376	//
377	// Helper functions to implement driver binding and service binding protocols.
378	//
379	EFI_STATUS
380	NetLibCreateServiceChild (
381	IN EFI_HANDLE ControllerHandle,
382	IN EFI_HANDLE ImageHandle,
383	IN EFI_GUID *ServiceBindingGuid,
384	OUT EFI_HANDLE *ChildHandle
385	);
386
387	EFI_STATUS
388	NetLibDestroyServiceChild (
389	IN EFI_HANDLE ControllerHandle,
390	IN EFI_HANDLE ImageHandle,
391	IN EFI_GUID *ServiceBindingGuid,
392	IN EFI_HANDLE ChildHandle
393	);
394
395	EFI_STATUS
396	NetLibGetMacString (
397	IN EFI_HANDLE SnpHandle,
398	IN EFI_HANDLE ImageHandle,
4eb65aff	399	IN OUT CHAR16 **MacString
cbf316f2	400	);
cbf316f2	401
e5e12de7	402	VOID
	403	NetLibCreateIPv4DPathNode (
	404	IN OUT IPv4_DEVICE_PATH *Node,
	405	IN EFI_HANDLE Controller,
	406	IN IP4_ADDR LocalIp,
	407	IN UINT16 LocalPort,
	408	IN IP4_ADDR RemoteIp,
	409	IN UINT16 RemotePort,
	410	IN UINT16 Protocol,
	411	IN BOOLEAN UseDefaultAddress
	412	);
	413
cbf316f2	414	EFI_HANDLE
	415	NetLibGetNicHandle (
	416	IN EFI_HANDLE Controller,
	417	IN EFI_GUID *ProtocolGuid
	418	);
	419
36ee91ca	420	EFI_STATUS
	421	NetLibQueueDpc (
	422	IN EFI_TPL DpcTpl,
	423	IN EFI_DPC_PROCEDURE DpcProcedure,
	424	IN VOID *DpcContext OPTIONAL
	425	);
	426
	427	EFI_STATUS
	428	NetLibDispatchDpc (
	429	VOID
	430	);
	431
cbf316f2	432	EFI_STATUS
	433	EFIAPI
	434	NetLibDefaultUnload (
	435	IN EFI_HANDLE ImageHandle
	436	);
	437
cbf316f2	438	enum {
	439	//
	440	//Various signatures
	441	//
	442	NET_BUF_SIGNATURE = EFI_SIGNATURE_32 ('n', 'b', 'u', 'f'),
	443	NET_VECTOR_SIGNATURE = EFI_SIGNATURE_32 ('n', 'v', 'e', 'c'),
	444	NET_QUE_SIGNATURE = EFI_SIGNATURE_32 ('n', 'b', 'q', 'u'),
	445
	446
	447	NET_PROTO_DATA = 64, // Opaque buffer for protocols
	448	NET_BUF_HEAD = 1, // Trim or allocate space from head
	449	NET_BUF_TAIL = 0, // Trim or allocate space from tail
	450	NET_VECTOR_OWN_FIRST = 0x01, // We allocated the 1st block in the vector
	451	};
	452
	453	#define NET_CHECK_SIGNATURE(PData, SIGNATURE) \
	454	ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE)))
	455
	456	#define NET_SWAP_SHORT(Value) \
	457	((((Value) & 0xff) << 8) \| (((Value) >> 8) & 0xff))
	458
	459	//
	460	// Single memory block in the vector.
	461	//
	462	typedef struct {
	463	UINT32 Len; // The block's length
	464	UINT8 *Bulk; // The block's Data
	465	} NET_BLOCK;
	466
	467	typedef VOID (NET_VECTOR_EXT_FREE) (VOID Arg);
	468
	469	//
	470	//NET_VECTOR contains several blocks to hold all packet's
	471	//fragments and other house-keeping stuff for sharing. It
	472	//doesn't specify the where actual packet fragment begins.
	473	//
	474	typedef struct {
	475	UINT32 Signature;
	476	INTN RefCnt; // Reference count to share NET_VECTOR.
	477	NET_VECTOR_EXT_FREE Free; // external function to free NET_VECTOR
	478	VOID *Arg; // opeque argument to Free
	479	UINT32 Flag; // Flags, NET_VECTOR_OWN_FIRST
	480	UINT32 Len; // Total length of the assocated BLOCKs
	481
	482	UINT32 BlockNum;
	483	NET_BLOCK Block[1];
	484	} NET_VECTOR;
	485
	486	//
	487	//NET_BLOCK_OP operate on the NET_BLOCK, It specifies
	488	//where the actual fragment begins and where it ends
	489	//
	490	typedef struct {
	491	UINT8 *BlockHead; // Block's head, or the smallest valid Head
	492	UINT8 *BlockTail; // Block's tail. BlockTail-BlockHead=block length
	493	UINT8 *Head; // 1st byte of the data in the block
	494	UINT8 *Tail; // Tail of the data in the block, Tail-Head=Size
	495	UINT32 Size; // The size of the data
	496	} NET_BLOCK_OP;
	497
	498
	499	//
	500	//NET_BUF is the buffer manage structure used by the
	501	//network stack. Every network packet may be fragmented,
502	//and contains multiple fragments. The Vector points to
503	//memory blocks used by the each fragment, and BlockOp
504	//specifies where each fragment begins and ends.
505	//
506	//It also contains a opaque area for protocol to store
507	//per-packet informations. Protocol must be caution not
508	//to overwrite the members after that.
509	//
510	typedef struct {
511	UINT32 Signature;
512	INTN RefCnt;
e48e37fc	513	LIST_ENTRY List; // The List this NET_BUF is on
cbf316f2	514
	515	IP4_HEAD *Ip; // Network layer header, for fast access
	516	TCP_HEAD *Tcp; // Transport layer header, for fast access
	517	UINT8 ProtoData [NET_PROTO_DATA]; //Protocol specific data
	518
	519	NET_VECTOR *Vector; // The vector containing the packet
	520
	521	UINT32 BlockOpNum; // Total number of BlockOp in the buffer
	522	UINT32 TotalSize; // Total size of the actual packet
	523	NET_BLOCK_OP BlockOp[1]; // Specify the position of actual packet
	524	} NET_BUF;
	525
	526
	527	//
	528	//A queue of NET_BUFs, It is just a thin extension of
	529	//NET_BUF functions.
	530	//
	531	typedef struct {
	532	UINT32 Signature;
	533	INTN RefCnt;
e48e37fc	534	LIST_ENTRY List; // The List this buffer queue is on
cbf316f2	535
e48e37fc	536	LIST_ENTRY BufList; // list of queued buffers
cbf316f2	537	UINT32 BufSize; // total length of DATA in the buffers
	538	UINT32 BufNum; // total number of buffers on the chain
	539	} NET_BUF_QUEUE;
	540
	541	//
	542	// Pseudo header for TCP and UDP checksum
	543	//
	544	#pragma pack(1)
	545	typedef struct {
	546	IP4_ADDR SrcIp;
	547	IP4_ADDR DstIp;
	548	UINT8 Reserved;
	549	UINT8 Protocol;
	550	UINT16 Len;
	551	} NET_PSEUDO_HDR;
	552	#pragma pack()
	553
	554	//
	555	// The fragment entry table used in network interfaces. This is
	556	// the same as NET_BLOCK now. Use two different to distinguish
	557	// the two in case that NET_BLOCK be enhanced later.
	558	//
	559	typedef struct {
	560	UINT32 Len;
	561	UINT8 *Bulk;
	562	} NET_FRAGMENT;
	563
	564	#define NET_GET_REF(PData) ((PData)->RefCnt++)
	565	#define NET_PUT_REF(PData) ((PData)->RefCnt--)
	566	#define NETBUF_FROM_PROTODATA(Info) _CR((Info), NET_BUF, ProtoData)
	567
	568	#define NET_BUF_SHARED(Buf) \
	569	(((Buf)->RefCnt > 1) \|\| ((Buf)->Vector->RefCnt > 1))
	570
	571	#define NET_VECTOR_SIZE(BlockNum) \
	572	(sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK))
	573
	574	#define NET_BUF_SIZE(BlockOpNum) \
	575	(sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP))
	576
	577	#define NET_HEADSPACE(BlockOp) \
	578	(UINTN)((BlockOp)->Head - (BlockOp)->BlockHead)
	579
	580	#define NET_TAILSPACE(BlockOp) \
	581	(UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail)
	582
	583	NET_BUF *
	584	NetbufAlloc (
	585	IN UINT32 Len
	586	);
	587
	588	VOID
	589	NetbufFree (
	590	IN NET_BUF *Nbuf
	591	);
	592
	593
	594	UINT8 *
	595	NetbufGetByte (
	596	IN NET_BUF *Nbuf,
	597	IN UINT32 Offset,
	598	OUT UINT32 *Index OPTIONAL
	599	);
	600
601	NET_BUF *
602	NetbufClone (
603	IN NET_BUF *Nbuf
604	);
605
606	NET_BUF *
607	NetbufDuplicate (
608	IN NET_BUF *Nbuf,
609	IN NET_BUF *Duplicate OPTIONAL,
610	IN UINT32 HeadSpace
611	);
612
613	NET_BUF *
614	NetbufGetFragment (
615	IN NET_BUF *Nbuf,
616	IN UINT32 Offset,
617	IN UINT32 Len,
618	IN UINT32 HeadSpace
619	);
620
621	VOID
622	NetbufReserve (
623	IN NET_BUF *Nbuf,
624	IN UINT32 Len
625	);
626
627	UINT8 *
628	NetbufAllocSpace (
629	IN NET_BUF *Nbuf,
630	IN UINT32 Len,
631	IN BOOLEAN FromHead
632	);
633
634	UINT32
635	NetbufTrim (
636	IN NET_BUF *Nbuf,
637	IN UINT32 Len,
638	IN BOOLEAN FromHead
639	);
640
641	UINT32
642	NetbufCopy (
643	IN NET_BUF *Nbuf,
644	IN UINT32 Offset,
645	IN UINT32 Len,
646	IN UINT8 *Dest
647	);
648
649	NET_BUF *
650	NetbufFromExt (
651	IN NET_FRAGMENT *ExtFragment,
652	IN UINT32 ExtNum,
653	IN UINT32 HeadSpace,
654	IN UINT32 HeadLen,
655	IN NET_VECTOR_EXT_FREE ExtFree,
656	IN VOID *Arg OPTIONAL
657	);
658
659	EFI_STATUS
660	NetbufBuildExt (
661	IN NET_BUF *Nbuf,
662	IN NET_FRAGMENT *ExtFragment,
663	IN UINT32 *ExtNum
664	);
665
666	NET_BUF *
667	NetbufFromBufList (
e48e37fc	668	IN LIST_ENTRY *BufList,
cbf316f2	669	IN UINT32 HeadSpace,
	670	IN UINT32 HeaderLen,
	671	IN NET_VECTOR_EXT_FREE ExtFree,
	672	IN VOID *Arg OPTIONAL
	673	);
	674
	675	VOID
	676	NetbufFreeList (
e48e37fc	677	IN LIST_ENTRY *Head
cbf316f2	678	);
	679
	680	VOID
	681	NetbufQueInit (
	682	IN NET_BUF_QUEUE *NbufQue
	683	);
	684
	685	NET_BUF_QUEUE *
	686	NetbufQueAlloc (
	687	VOID
	688	);
	689
	690	VOID
	691	NetbufQueFree (
	692	IN NET_BUF_QUEUE *NbufQue
	693	);
	694
	695	NET_BUF *
	696	NetbufQueRemove (
	697	IN NET_BUF_QUEUE *NbufQue
	698	);
	699
	700	VOID
	701	NetbufQueAppend (
	702	IN NET_BUF_QUEUE *NbufQue,
	703	IN NET_BUF *Nbuf
	704	);
	705
	706	UINT32
	707	NetbufQueCopy (
	708	IN NET_BUF_QUEUE *NbufQue,
	709	IN UINT32 Offset,
	710	IN UINT32 Len,
	711	IN UINT8 *Dest
	712	);
	713
	714	UINT32
	715	NetbufQueTrim (
	716	IN NET_BUF_QUEUE *NbufQue,
	717	IN UINT32 Len
	718	);
	719
	720	VOID
	721	NetbufQueFlush (
	722	IN NET_BUF_QUEUE *NbufQue
	723	);
	724
	725	UINT16
	726	NetblockChecksum (
	727	IN UINT8 *Bulk,
	728	IN UINT32 Len
	729	);
	730
	731	UINT16
	732	NetAddChecksum (
	733	IN UINT16 Checksum1,
	734	IN UINT16 Checksum2
	735	);
	736
	737	UINT16
	738	NetbufChecksum (
	739	IN NET_BUF *Nbuf
	740	);
	741
742	UINT16
743	NetPseudoHeadChecksum (
744	IN IP4_ADDR Src,
745	IN IP4_ADDR Dst,
746	IN UINT8 Proto,
747	IN UINT16 Len
748	);
8a67d61d	749
cbf316f2	750	#endif