[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 <Protocol/DriverBinding.h>
#include <Protocol/ComponentName.h>
#include <Protocol/DriverConfiguration.h>
#include <Protocol/DriverDiagnostics.h>
#include <Protocol/Dpc.h>

#define EFI_NET_LITTLE_ENDIAN

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 {
#ifdef EFI_NET_LITTLE_ENDIAN
  UINT8                 HeadLen : 4;
  UINT8                 Ver     : 4;
#else
  UINT8                 Ver     : 4;
  UINT8                 HeadLen : 4;
#endif
  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;
#ifdef EFI_NET_LITTLE_ENDIAN
  UINT8                 Res     : 4;
  UINT8                 HeadLen : 4;
#else
  UINT8                 HeadLen : 4;
  UINT8                 Res     : 4;
#endif
  UINT8                 Flag;
  UINT16                Wnd;
  UINT16                Checksum;
  UINT16                Urg;
} TCP_HEAD;

#pragma pack()

#define NET_MAC_EQUAL(pMac1, pMac2, Len)     \
    (NetCompareMem ((pMac1), (pMac2), Len) == 0)

#define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \
    (((*((UINT8 *) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len)))

#ifdef EFI_NET_LITTLE_ENDIAN
#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)
#else
#define NTOHL(x)  (UINT32)(x)
#define HTONL(x)  (UINT32)(x)
#define NTOHS(x)  (UINT16)(x)
#define HTONS(x)  (UINT16)(x)
#endif

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

//
// Wrap functions to ease the impact of EFI library changes.
//
#define NetAllocateZeroPool     AllocateZeroPool
#define NetAllocatePool         AllocatePool
#define NetFreePool             gBS->FreePool
#define NetCopyMem              CopyMem
#define NetSetMem               SetMem
#define NetZeroMem(Dest, Len)   SetMem ((Dest), (Len), 0)
#define NetCompareMem           CompareMem

//
// Lock primitives: the stack implements its lock primitives according
// to the standard EFI enviornment. It will NOT consider multiprocessor.
//
#define NET_TPL_LOCK            TPL_CALLBACK
#define NET_TPL_EVENT           TPL_NOTIFY
#define NET_TPL_RECYCLE         TPL_NOTIFY
#define NET_TPL_TIMER           NET_TPL_LOCK

#define NET_LOCK                 EFI_LOCK
#define NET_LOCK_INIT(x)         EfiInitializeLock (x, NET_TPL_LOCK)
#define NET_RECYCLE_LOCK_INIT(x) EfiInitializeLock (x, NET_TPL_RECYCLE)
#define NET_TRYLOCK(x)           EfiAcquireLockOrFail (x)
#define NET_UNLOCK(x)            EfiReleaseLock (x)

#define NET_RAISE_TPL(x)        (gBS->RaiseTPL (x))
#define NET_RESTORE_TPL(x)      (gBS->RestoreTPL (x))

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


//
// Double linked list entry functions, this extends the
// EFI list functions.
//
typedef LIST_ENTRY      NET_LIST_ENTRY;

#define NetListInit(Head)              InitializeListHead(Head)
#define NetListInsertHead(Head, Entry) InsertHeadList((Head), (Entry))
#define NetListInsertTail(Head, Entry) InsertTailList((Head), (Entry))
#define NetListIsEmpty(List)           IsListEmpty(List)

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

#define NetListRemoveEntry(Entry) RemoveEntryList (Entry)

NET_LIST_ENTRY*
NetListRemoveHead (
  NET_LIST_ENTRY            *Head
  );

NET_LIST_ENTRY*
NetListRemoveTail (
  NET_LIST_ENTRY            *Head
  );

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

VOID
NetListInsertBefore (
  IN NET_LIST_ENTRY         *PostEntry,
  IN NET_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 {
  NET_LIST_ENTRY            Link;
  VOID                      *Key;
  VOID                      *Value;
} NET_MAP_ITEM;

typedef struct {
  NET_LIST_ENTRY            Used;
  NET_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;
  NET_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;
  NET_LIST_ENTRY      List;       // The List this buffer queue is on

  NET_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 NET_LIST_ENTRY         *BufList,
  IN UINT32                 HeadSpace,
  IN UINT32                 HeaderLen,
  IN NET_VECTOR_EXT_FREE    ExtFree,
  IN VOID                   *Arg                OPTIONAL
  );

VOID
NetbufFreeList (
  IN NET_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
  );

//
// The debug level definition. This value is also used as the
// syslog's servity level. Don't change it.
//
enum {
  NETDEBUG_LEVEL_TRACE   = 5,
  NETDEBUG_LEVEL_WARNING = 4,
  NETDEBUG_LEVEL_ERROR   = 3,
};

#ifdef EFI_NETWORK_STACK_DEBUG

//
// 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__, \
    __LINE__, \
    NetDebugASPrint PrintArg \
    )

#define NET_DEBUG_WARNING(Module, PrintArg) \
  NetDebugOutput ( \
    NETDEBUG_LEVEL_WARNING, \
    Module, \
    __FILE__, \
    __LINE__, \
    NetDebugASPrint PrintArg \
    )

#define NET_DEBUG_ERROR(Module, PrintArg) \
  NetDebugOutput ( \
    NETDEBUG_LEVEL_ERROR, \
    Module, \
    __FILE__, \
    __LINE__, \
    NetDebugASPrint PrintArg \
    )

#else
#define NET_DEBUG_TRACE(Module, PrintString)
#define NET_DEBUG_WARNING(Module, PrintString)
#define NET_DEBUG_ERROR(Module, PrintString)
#endif

UINT8 *
NetDebugASPrint (
  UINT8                     *Format,
  ...
  );

EFI_STATUS
NetDebugOutput (
  UINT32                    Level,
  UINT8                     *Module,
  UINT8                     *File,
  UINT32                    Line,
  UINT8                     *Message
  );

//
// Network debug message is sent out as syslog.
//
enum {
  NET_SYSLOG_FACILITY       = 16,             // Syslog local facility local use
  NET_SYSLOG_PACKET_LEN     = 512,
  NET_DEBUG_MSG_LEN         = 470,            // 512 - (ether+ip+udp head length)
  NET_SYSLOG_TX_TIMEOUT     = 500 *1000 *10,  // 500ms
};
#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>
	27	#include <Protocol/DriverBinding.h>
	28	#include <Protocol/ComponentName.h>
	29	#include <Protocol/DriverConfiguration.h>
	30	#include <Protocol/DriverDiagnostics.h>
36ee91ca	31	#include <Protocol/Dpc.h>
	32
	33	#define EFI_NET_LITTLE_ENDIAN
	34
	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 {
	78	#ifdef EFI_NET_LITTLE_ENDIAN
	79	UINT8 HeadLen : 4;
	80	UINT8 Ver : 4;
	81	#else
	82	UINT8 Ver : 4;
	83	UINT8 HeadLen : 4;
	84	#endif
	85	UINT8 Tos;
	86	UINT16 TotalLen;
	87	UINT16 Id;
	88	UINT16 Fragment;
	89	UINT8 Ttl;
	90	UINT8 Protocol;
	91	UINT16 Checksum;
	92	IP4_ADDR Src;
	93	IP4_ADDR Dst;
	94	} IP4_HEAD;
95
96
97	//
98	// ICMP head definition. ICMP message is categoried as either an error
99	// message or query message. Two message types have their own head format.
100	//
101	typedef struct {
102	UINT8 Type;
103	UINT8 Code;
104	UINT16 Checksum;
105	} IP4_ICMP_HEAD;
106
107	typedef struct {
108	IP4_ICMP_HEAD Head;
109	UINT32 Fourth; // 4th filed of the head, it depends on Type.
110	IP4_HEAD IpHead;
111	} IP4_ICMP_ERROR_HEAD;
112
113	typedef struct {
114	IP4_ICMP_HEAD Head;
115	UINT16 Id;
116	UINT16 Seq;
117	} IP4_ICMP_QUERY_HEAD;
118
119
120	//
121	// UDP header definition
122	//
123	typedef struct {
124	UINT16 SrcPort;
125	UINT16 DstPort;
126	UINT16 Length;
127	UINT16 Checksum;
128	} EFI_UDP4_HEADER;
129
130
131	//
132	// TCP header definition
133	//
134	typedef struct {
135	TCP_PORTNO SrcPort;
136	TCP_PORTNO DstPort;
137	TCP_SEQNO Seq;
138	TCP_SEQNO Ack;
139	#ifdef EFI_NET_LITTLE_ENDIAN
140	UINT8 Res : 4;
141	UINT8 HeadLen : 4;
142	#else
143	UINT8 HeadLen : 4;
144	UINT8 Res : 4;
145	#endif
146	UINT8 Flag;
147	UINT16 Wnd;
148	UINT16 Checksum;
149	UINT16 Urg;
150	} TCP_HEAD;
151
152	#pragma pack()
153
154	#define NET_MAC_EQUAL(pMac1, pMac2, Len) \
155	(NetCompareMem ((pMac1), (pMac2), Len) == 0)
156
157	#define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \
158	(((((UINT8 ) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len)))
159
160	#ifdef EFI_NET_LITTLE_ENDIAN
161	#define NTOHL(x) (UINT32)((((UINT32) (x) & 0xff) << 24) \| \
162	(((UINT32) (x) & 0xff00) << 8) \| \
163	(((UINT32) (x) & 0xff0000) >> 8) \| \
164	(((UINT32) (x) & 0xff000000) >> 24))
165
166	#define HTONL(x) NTOHL(x)
167
168	#define NTOHS(x) (UINT16)((((UINT16) (x) & 0xff) << 8) \| \
169	(((UINT16) (x) & 0xff00) >> 8))
170
171	#define HTONS(x) NTOHS(x)
172	#else
173	#define NTOHL(x) (UINT32)(x)
174	#define HTONL(x) (UINT32)(x)
175	#define NTOHS(x) (UINT16)(x)
176	#define HTONS(x) (UINT16)(x)
177	#endif
178
179	//
180	// Test the IP's attribute, All the IPs are in host byte order.
181	//
182	#define IP4_IS_MULTICAST(Ip) (((Ip) & 0xF0000000) == 0xE0000000)
183	#define IP4_IS_LOCAL_BROADCAST(Ip) ((Ip) == 0xFFFFFFFF)
184	#define IP4_NET_EQUAL(Ip1, Ip2, NetMask) (((Ip1) & (NetMask)) == ((Ip2) & (NetMask)))
185	#define IP4_IS_VALID_NETMASK(Ip) (NetGetMaskLength (Ip) != IP4_MASK_NUM)
186
187	//
188	// Convert the EFI_IP4_ADDRESS to plain UINT32 IP4 address.
189	//
190	#define EFI_IP4(EfiIpAddr) ((IP4_ADDR ) ((EfiIpAddr).Addr))
191	#define EFI_NTOHL(EfiIp) (NTOHL (EFI_IP4 ((EfiIp))))
192	#define EFI_IP4_EQUAL(Ip1, Ip2) (NetCompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0)
193
194	INTN
195	NetGetMaskLength (
196	IN IP4_ADDR Mask
197	);
198
199	INTN
200	NetGetIpClass (
201	IN IP4_ADDR Addr
202	);
203
204	BOOLEAN
205	Ip4IsUnicast (
206	IN IP4_ADDR Ip,
207	IN IP4_ADDR NetMask
208	);
cbf316f2	209
cbf316f2	210	extern IP4_ADDR mIp4AllMasks [IP4_MASK_NUM];
cbf316f2	211
cbf316f2	212
772db4bb	213	extern EFI_IPv4_ADDRESS mZeroIp4Addr;
772db4bb	214
c4a62a12	215	#define NET_IS_DIGIT(Ch) (('0' <= (Ch)) && ((Ch) <= '9'))
	216	#define NET_ROUNDUP(size, unit) (((size) + (unit) - 1) & (~((unit) - 1)))
	217
cbf316f2	218	//
	219	// Wrap functions to ease the impact of EFI library changes.
	220	//
	221	#define NetAllocateZeroPool AllocateZeroPool
	222	#define NetAllocatePool AllocatePool
	223	#define NetFreePool gBS->FreePool
	224	#define NetCopyMem CopyMem
	225	#define NetSetMem SetMem
	226	#define NetZeroMem(Dest, Len) SetMem ((Dest), (Len), 0)
	227	#define NetCompareMem CompareMem
	228
	229	//
	230	// Lock primitives: the stack implements its lock primitives according
	231	// to the standard EFI enviornment. It will NOT consider multiprocessor.
	232	//
	233	#define NET_TPL_LOCK TPL_CALLBACK
36ee91ca	234	#define NET_TPL_EVENT TPL_NOTIFY
	235	#define NET_TPL_RECYCLE TPL_NOTIFY
	236	#define NET_TPL_TIMER NET_TPL_LOCK
cbf316f2	237
	238	#define NET_LOCK EFI_LOCK
	239	#define NET_LOCK_INIT(x) EfiInitializeLock (x, NET_TPL_LOCK)
36ee91ca	240	#define NET_RECYCLE_LOCK_INIT(x) EfiInitializeLock (x, NET_TPL_RECYCLE)
cbf316f2	241	#define NET_TRYLOCK(x) EfiAcquireLockOrFail (x)
	242	#define NET_UNLOCK(x) EfiReleaseLock (x)
	243
	244	#define NET_RAISE_TPL(x) (gBS->RaiseTPL (x))
	245	#define NET_RESTORE_TPL(x) (gBS->RestoreTPL (x))
	246
	247	#define TICKS_PER_MS 10000U
	248	#define TICKS_PER_SECOND 10000000U
	249
84b5c78e	250	#define NET_RANDOM(Seed) ((UINT32) ((UINT32) (Seed) * 1103515245UL + 12345) % 4294967295UL)
cbf316f2	251
	252
	253	UINT32
	254	NetGetUint32 (
	255	IN UINT8 *Buf
	256	);
	257
	258	VOID
	259	NetPutUint32 (
	260	IN UINT8 *Buf,
	261	IN UINT32 Data
	262	);
	263
	264	UINT32
	265	NetRandomInitSeed (
	266	VOID
	267	);
	268
	269
	270	//
	271	// Double linked list entry functions, this extends the
	272	// EFI list functions.
	273	//
	274	typedef LIST_ENTRY NET_LIST_ENTRY;
	275
	276	#define NetListInit(Head) InitializeListHead(Head)
	277	#define NetListInsertHead(Head, Entry) InsertHeadList((Head), (Entry))
	278	#define NetListInsertTail(Head, Entry) InsertTailList((Head), (Entry))
	279	#define NetListIsEmpty(List) IsListEmpty(List)
	280
	281	#define NET_LIST_USER_STRUCT(Entry, Type, Field) \
	282	_CR(Entry, Type, Field)
	283
	284	#define NET_LIST_USER_STRUCT_S(Entry, Type, Field, Sig) \
	285	CR(Entry, Type, Field, Sig)
	286
	287	//
	288	// Iterate through the doule linked list. It is NOT delete safe
	289	//
	290	#define NET_LIST_FOR_EACH(Entry, ListHead) \
	291	for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink)
	292
	293	//
	294	// Iterate through the doule linked list. This is delete-safe.
	295	// Don't touch NextEntry. Also, don't use this macro if list
	296	// entries other than the Entry may be deleted when processing
	297	// the current Entry.
	298	//
	299	#define NET_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \
	300	for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink; \
	301	Entry != (ListHead); \
	302	Entry = NextEntry, NextEntry = Entry->ForwardLink \
	303	)
	304
	305	//
	306	// Make sure the list isn't empty before get the frist/last record.
	307	//
	308	#define NET_LIST_HEAD(ListHead, Type, Field) \
	309	NET_LIST_USER_STRUCT((ListHead)->ForwardLink, Type, Field)
	310
	311	#define NET_LIST_TAIL(ListHead, Type, Field) \
	312	NET_LIST_USER_STRUCT((ListHead)->BackLink, Type, Field)
	313
	314	#define NetListRemoveEntry(Entry) RemoveEntryList (Entry)
315
316	NET_LIST_ENTRY*
317	NetListRemoveHead (
318	NET_LIST_ENTRY *Head
319	);
320
321	NET_LIST_ENTRY*
322	NetListRemoveTail (
323	NET_LIST_ENTRY *Head
324	);
325
326	VOID
327	NetListInsertAfter (
328	IN NET_LIST_ENTRY *PrevEntry,
329	IN NET_LIST_ENTRY *NewEntry
330	);
331
332	VOID
333	NetListInsertBefore (
334	IN NET_LIST_ENTRY *PostEntry,
335	IN NET_LIST_ENTRY *NewEntry
336	);
337
338
339	//
340	// Object container: EFI network stack spec defines various kinds of
341	// tokens. The drivers can share code to manage those objects.
342	//
343	typedef struct {
344	NET_LIST_ENTRY Link;
345	VOID *Key;
346	VOID *Value;
347	} NET_MAP_ITEM;
348
349	typedef struct {
350	NET_LIST_ENTRY Used;
351	NET_LIST_ENTRY Recycled;
352	UINTN Count;
353	} NET_MAP;
354
355	#define NET_MAP_INCREAMENT 64
356
357	VOID
358	NetMapInit (
359	IN NET_MAP *Map
360	);
361
362	VOID
363	NetMapClean (
364	IN NET_MAP *Map
365	);
366
367	BOOLEAN
368	NetMapIsEmpty (
369	IN NET_MAP *Map
370	);
371
372	UINTN
373	NetMapGetCount (
374	IN NET_MAP *Map
375	);
376
377	EFI_STATUS
378	NetMapInsertHead (
379	IN NET_MAP *Map,
380	IN VOID *Key,
381	IN VOID *Value OPTIONAL
382	);
383
384	EFI_STATUS
385	NetMapInsertTail (
386	IN NET_MAP *Map,
387	IN VOID *Key,
388	IN VOID *Value OPTIONAL
389	);
390
391	NET_MAP_ITEM *
392	NetMapFindKey (
393	IN NET_MAP *Map,
394	IN VOID *Key
395	);
396
397	VOID *
398	NetMapRemoveItem (
399	IN NET_MAP *Map,
400	IN NET_MAP_ITEM *Item,
401	OUT VOID **Value OPTIONAL
402	);
403
404	VOID *
405	NetMapRemoveHead (
406	IN NET_MAP *Map,
407	OUT VOID **Value OPTIONAL
408	);
409
410	VOID *
411	NetMapRemoveTail (
412	IN NET_MAP *Map,
413	OUT VOID **Value OPTIONAL
414	);
415
416	typedef
417	EFI_STATUS
418	(*NET_MAP_CALLBACK) (
419	IN NET_MAP *Map,
420	IN NET_MAP_ITEM *Item,
421	IN VOID *Arg
422	);
423
424	EFI_STATUS
425	NetMapIterate (
426	IN NET_MAP *Map,
427	IN NET_MAP_CALLBACK CallBack,
428	IN VOID *Arg OPTIONAL
429	);
430
431
432	//
433	// Helper functions to implement driver binding and service binding protocols.
434	//
435	EFI_STATUS
436	NetLibCreateServiceChild (
437	IN EFI_HANDLE ControllerHandle,
438	IN EFI_HANDLE ImageHandle,
439	IN EFI_GUID *ServiceBindingGuid,
440	OUT EFI_HANDLE *ChildHandle
441	);
442
443	EFI_STATUS
444	NetLibDestroyServiceChild (
445	IN EFI_HANDLE ControllerHandle,
446	IN EFI_HANDLE ImageHandle,
447	IN EFI_GUID *ServiceBindingGuid,
448	IN EFI_HANDLE ChildHandle
449	);
450
451	EFI_STATUS
452	NetLibGetMacString (
453	IN EFI_HANDLE SnpHandle,
454	IN EFI_HANDLE ImageHandle,
4eb65aff	455	IN OUT CHAR16 **MacString
cbf316f2	456	);
cbf316f2	457
e5e12de7	458	VOID
	459	NetLibCreateIPv4DPathNode (
	460	IN OUT IPv4_DEVICE_PATH *Node,
	461	IN EFI_HANDLE Controller,
	462	IN IP4_ADDR LocalIp,
	463	IN UINT16 LocalPort,
	464	IN IP4_ADDR RemoteIp,
	465	IN UINT16 RemotePort,
	466	IN UINT16 Protocol,
	467	IN BOOLEAN UseDefaultAddress
	468	);
	469
cbf316f2	470	EFI_HANDLE
	471	NetLibGetNicHandle (
	472	IN EFI_HANDLE Controller,
	473	IN EFI_GUID *ProtocolGuid
	474	);
	475
36ee91ca	476	EFI_STATUS
	477	NetLibQueueDpc (
	478	IN EFI_TPL DpcTpl,
	479	IN EFI_DPC_PROCEDURE DpcProcedure,
	480	IN VOID *DpcContext OPTIONAL
	481	);
	482
	483	EFI_STATUS
	484	NetLibDispatchDpc (
	485	VOID
	486	);
	487
cbf316f2	488	EFI_STATUS
	489	EFIAPI
	490	NetLibDefaultUnload (
	491	IN EFI_HANDLE ImageHandle
	492	);
	493
cbf316f2	494	enum {
	495	//
	496	//Various signatures
	497	//
	498	NET_BUF_SIGNATURE = EFI_SIGNATURE_32 ('n', 'b', 'u', 'f'),
	499	NET_VECTOR_SIGNATURE = EFI_SIGNATURE_32 ('n', 'v', 'e', 'c'),
	500	NET_QUE_SIGNATURE = EFI_SIGNATURE_32 ('n', 'b', 'q', 'u'),
	501
	502
	503	NET_PROTO_DATA = 64, // Opaque buffer for protocols
	504	NET_BUF_HEAD = 1, // Trim or allocate space from head
	505	NET_BUF_TAIL = 0, // Trim or allocate space from tail
	506	NET_VECTOR_OWN_FIRST = 0x01, // We allocated the 1st block in the vector
	507	};
	508
	509	#define NET_CHECK_SIGNATURE(PData, SIGNATURE) \
	510	ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE)))
	511
	512	#define NET_SWAP_SHORT(Value) \
	513	((((Value) & 0xff) << 8) \| (((Value) >> 8) & 0xff))
	514
	515	//
	516	// Single memory block in the vector.
	517	//
	518	typedef struct {
	519	UINT32 Len; // The block's length
	520	UINT8 *Bulk; // The block's Data
	521	} NET_BLOCK;
	522
	523	typedef VOID (NET_VECTOR_EXT_FREE) (VOID Arg);
	524
	525	//
	526	//NET_VECTOR contains several blocks to hold all packet's
	527	//fragments and other house-keeping stuff for sharing. It
	528	//doesn't specify the where actual packet fragment begins.
	529	//
	530	typedef struct {
	531	UINT32 Signature;
	532	INTN RefCnt; // Reference count to share NET_VECTOR.
	533	NET_VECTOR_EXT_FREE Free; // external function to free NET_VECTOR
	534	VOID *Arg; // opeque argument to Free
	535	UINT32 Flag; // Flags, NET_VECTOR_OWN_FIRST
	536	UINT32 Len; // Total length of the assocated BLOCKs
	537
	538	UINT32 BlockNum;
	539	NET_BLOCK Block[1];
	540	} NET_VECTOR;
	541
	542	//
	543	//NET_BLOCK_OP operate on the NET_BLOCK, It specifies
	544	//where the actual fragment begins and where it ends
	545	//
	546	typedef struct {
	547	UINT8 *BlockHead; // Block's head, or the smallest valid Head
	548	UINT8 *BlockTail; // Block's tail. BlockTail-BlockHead=block length
	549	UINT8 *Head; // 1st byte of the data in the block
	550	UINT8 *Tail; // Tail of the data in the block, Tail-Head=Size
	551	UINT32 Size; // The size of the data
	552	} NET_BLOCK_OP;
	553
	554
	555	//
	556	//NET_BUF is the buffer manage structure used by the
	557	//network stack. Every network packet may be fragmented,
558	//and contains multiple fragments. The Vector points to
559	//memory blocks used by the each fragment, and BlockOp
560	//specifies where each fragment begins and ends.
561	//
562	//It also contains a opaque area for protocol to store
563	//per-packet informations. Protocol must be caution not
564	//to overwrite the members after that.
565	//
566	typedef struct {
567	UINT32 Signature;
568	INTN RefCnt;
569	NET_LIST_ENTRY List; // The List this NET_BUF is on
570
571	IP4_HEAD *Ip; // Network layer header, for fast access
572	TCP_HEAD *Tcp; // Transport layer header, for fast access
573	UINT8 ProtoData [NET_PROTO_DATA]; //Protocol specific data
574
575	NET_VECTOR *Vector; // The vector containing the packet
576
577	UINT32 BlockOpNum; // Total number of BlockOp in the buffer
578	UINT32 TotalSize; // Total size of the actual packet
579	NET_BLOCK_OP BlockOp[1]; // Specify the position of actual packet
580	} NET_BUF;
581
582
583	//
584	//A queue of NET_BUFs, It is just a thin extension of
585	//NET_BUF functions.
586	//
587	typedef struct {
588	UINT32 Signature;
589	INTN RefCnt;
590	NET_LIST_ENTRY List; // The List this buffer queue is on
591
592	NET_LIST_ENTRY BufList; // list of queued buffers
593	UINT32 BufSize; // total length of DATA in the buffers
594	UINT32 BufNum; // total number of buffers on the chain
595	} NET_BUF_QUEUE;
596
597	//
598	// Pseudo header for TCP and UDP checksum
599	//
600	#pragma pack(1)
601	typedef struct {
602	IP4_ADDR SrcIp;
603	IP4_ADDR DstIp;
604	UINT8 Reserved;
605	UINT8 Protocol;
606	UINT16 Len;
607	} NET_PSEUDO_HDR;
608	#pragma pack()
609
610	//
611	// The fragment entry table used in network interfaces. This is
612	// the same as NET_BLOCK now. Use two different to distinguish
613	// the two in case that NET_BLOCK be enhanced later.
614	//
615	typedef struct {
616	UINT32 Len;
617	UINT8 *Bulk;
618	} NET_FRAGMENT;
619
620	#define NET_GET_REF(PData) ((PData)->RefCnt++)
621	#define NET_PUT_REF(PData) ((PData)->RefCnt--)
622	#define NETBUF_FROM_PROTODATA(Info) _CR((Info), NET_BUF, ProtoData)
623
624	#define NET_BUF_SHARED(Buf) \
625	(((Buf)->RefCnt > 1) \|\| ((Buf)->Vector->RefCnt > 1))
626
627	#define NET_VECTOR_SIZE(BlockNum) \
628	(sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK))
629
630	#define NET_BUF_SIZE(BlockOpNum) \
631	(sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP))
632
633	#define NET_HEADSPACE(BlockOp) \
634	(UINTN)((BlockOp)->Head - (BlockOp)->BlockHead)
635
636	#define NET_TAILSPACE(BlockOp) \
637	(UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail)
638
639	NET_BUF *
640	NetbufAlloc (
641	IN UINT32 Len
642	);
643
644	VOID
645	NetbufFree (
646	IN NET_BUF *Nbuf
647	);
648
649
650	UINT8 *
651	NetbufGetByte (
652	IN NET_BUF *Nbuf,
653	IN UINT32 Offset,
654	OUT UINT32 *Index OPTIONAL
655	);
656
657	NET_BUF *
658	NetbufClone (
659	IN NET_BUF *Nbuf
660	);
661
662	NET_BUF *
663	NetbufDuplicate (
664	IN NET_BUF *Nbuf,
665	IN NET_BUF *Duplicate OPTIONAL,
666	IN UINT32 HeadSpace
667	);
668
669	NET_BUF *
670	NetbufGetFragment (
671	IN NET_BUF *Nbuf,
672	IN UINT32 Offset,
673	IN UINT32 Len,
674	IN UINT32 HeadSpace
675	);
676
677	VOID
678	NetbufReserve (
679	IN NET_BUF *Nbuf,
680	IN UINT32 Len
681	);
682
683	UINT8 *
684	NetbufAllocSpace (
685	IN NET_BUF *Nbuf,
686	IN UINT32 Len,
687	IN BOOLEAN FromHead
688	);
689
690	UINT32
691	NetbufTrim (
692	IN NET_BUF *Nbuf,
693	IN UINT32 Len,
694	IN BOOLEAN FromHead
695	);
696
697	UINT32
698	NetbufCopy (
699	IN NET_BUF *Nbuf,
700	IN UINT32 Offset,
701	IN UINT32 Len,
702	IN UINT8 *Dest
703	);
704
705	NET_BUF *
706	NetbufFromExt (
707	IN NET_FRAGMENT *ExtFragment,
708	IN UINT32 ExtNum,
709	IN UINT32 HeadSpace,
710	IN UINT32 HeadLen,
711	IN NET_VECTOR_EXT_FREE ExtFree,
712	IN VOID *Arg OPTIONAL
713	);
714
715	EFI_STATUS
716	NetbufBuildExt (
717	IN NET_BUF *Nbuf,
718	IN NET_FRAGMENT *ExtFragment,
719	IN UINT32 *ExtNum
720	);
721
722	NET_BUF *
723	NetbufFromBufList (
724	IN NET_LIST_ENTRY *BufList,
725	IN UINT32 HeadSpace,
726	IN UINT32 HeaderLen,
727	IN NET_VECTOR_EXT_FREE ExtFree,
728	IN VOID *Arg OPTIONAL
729	);
730
731	VOID
732	NetbufFreeList (
733	IN NET_LIST_ENTRY *Head
734	);
735
736	VOID
737	NetbufQueInit (
738	IN NET_BUF_QUEUE *NbufQue
739	);
740
741	NET_BUF_QUEUE *
742	NetbufQueAlloc (
743	VOID
744	);
745
746	VOID
747	NetbufQueFree (
748	IN NET_BUF_QUEUE *NbufQue
749	);
750
751	NET_BUF *
752	NetbufQueRemove (
753	IN NET_BUF_QUEUE *NbufQue
754	);
755
756	VOID
757	NetbufQueAppend (
758	IN NET_BUF_QUEUE *NbufQue,
759	IN NET_BUF *Nbuf
760	);
761
762	UINT32
763	NetbufQueCopy (
764	IN NET_BUF_QUEUE *NbufQue,
765	IN UINT32 Offset,
766	IN UINT32 Len,
767	IN UINT8 *Dest
768	);
769
770	UINT32
771	NetbufQueTrim (
772	IN NET_BUF_QUEUE *NbufQue,
773	IN UINT32 Len
774	);
775
776	VOID
777	NetbufQueFlush (
778	IN NET_BUF_QUEUE *NbufQue
779	);
780
781	UINT16
782	NetblockChecksum (
783	IN UINT8 *Bulk,
784	IN UINT32 Len
785	);
786
787	UINT16
788	NetAddChecksum (
789	IN UINT16 Checksum1,
790	IN UINT16 Checksum2
791	);
792
793	UINT16
794	NetbufChecksum (
795	IN NET_BUF *Nbuf
796	);
797
798	UINT16
799	NetPseudoHeadChecksum (
800	IN IP4_ADDR Src,
801	IN IP4_ADDR Dst,
802	IN UINT8 Proto,
803	IN UINT16 Len
804	);
8a67d61d	805
36ee91ca	806	//
	807	// The debug level definition. This value is also used as the
	808	// syslog's servity level. Don't change it.
	809	//
	810	enum {
	811	NETDEBUG_LEVEL_TRACE = 5,
	812	NETDEBUG_LEVEL_WARNING = 4,
	813	NETDEBUG_LEVEL_ERROR = 3,
	814	};
	815
	816	#ifdef EFI_NETWORK_STACK_DEBUG
	817
	818	//
	819	// The debug output expects the ASCII format string, Use %a to print ASCII
	820	// string, and %s to print UNICODE string. PrintArg must be enclosed in ().
	821	// For example: NET_DEBUG_TRACE ("Tcp", ("State transit to %a\n", Name));
	822	//
	823	#define NET_DEBUG_TRACE(Module, PrintArg) \
	824	NetDebugOutput ( \
	825	NETDEBUG_LEVEL_TRACE, \
	826	Module, \
	827	__FILE__, \
	828	__LINE__, \
	829	NetDebugASPrint PrintArg \
	830	)
	831
	832	#define NET_DEBUG_WARNING(Module, PrintArg) \
	833	NetDebugOutput ( \
	834	NETDEBUG_LEVEL_WARNING, \
	835	Module, \
	836	__FILE__, \
	837	__LINE__, \
	838	NetDebugASPrint PrintArg \
	839	)
	840
	841	#define NET_DEBUG_ERROR(Module, PrintArg) \
	842	NetDebugOutput ( \
	843	NETDEBUG_LEVEL_ERROR, \
	844	Module, \
	845	__FILE__, \
	846	__LINE__, \
	847	NetDebugASPrint PrintArg \
	848	)
	849
	850	#else
	851	#define NET_DEBUG_TRACE(Module, PrintString)
	852	#define NET_DEBUG_WARNING(Module, PrintString)
	853	#define NET_DEBUG_ERROR(Module, PrintString)
	854	#endif
	855
	856	UINT8 *
	857	NetDebugASPrint (
	858	UINT8 *Format,
	859	...
	860	);
	861
	862	EFI_STATUS
	863	NetDebugOutput (
	864	UINT32 Level,
	865	UINT8 *Module,
	866	UINT8 *File,
	867	UINT32 Line,
	868	UINT8 *Message
	869	);
870
871	//
872	// Network debug message is sent out as syslog.
873	//
874	enum {
875	NET_SYSLOG_FACILITY = 16, // Syslog local facility local use
876	NET_SYSLOG_PACKET_LEN = 512,
877	NET_DEBUG_MSG_LEN = 470, // 512 - (ether+ip+udp head length)
878	NET_SYSLOG_TX_TIMEOUT = 500 1000 10, // 500ms
8a67d61d	879	};
cbf316f2	880	#endif