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