[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>

#define EFI_NET_LITTLE_ENDIAN\r
\r
typedef UINT32          IP4_ADDR;\r
typedef UINT32          TCP_SEQNO;\r
typedef UINT16          TCP_PORTNO;\r
\r
enum {\r
  NET_ETHER_ADDR_LEN    = 6,\r
  NET_IFTYPE_ETHERNET   = 0x01,\r
\r
  EFI_IP_PROTO_UDP      = 0x11,\r
  EFI_IP_PROTO_TCP      = 0x06,\r
  EFI_IP_PROTO_ICMP     = 0x01,\r
\r
  //\r
  // The address classfication\r
  //\r
  IP4_ADDR_CLASSA       = 1,\r
  IP4_ADDR_CLASSB,\r
  IP4_ADDR_CLASSC,\r
  IP4_ADDR_CLASSD,\r
  IP4_ADDR_CLASSE,\r
\r
  IP4_MASK_NUM          = 33,\r
};\r
\r
#pragma pack(1)\r
\r
//\r
// Ethernet head definition\r
//\r
typedef struct {\r
  UINT8                 DstMac [NET_ETHER_ADDR_LEN];\r
  UINT8                 SrcMac [NET_ETHER_ADDR_LEN];\r
  UINT16                EtherType;\r
} ETHER_HEAD;\r
\r
\r
//\r
// The EFI_IP4_HEADER is hard to use because the source and\r
// destination address are defined as EFI_IPv4_ADDRESS, which\r
// is a structure. Two structures can't be compared or masked\r
// directly. This is why there is an internal representation.\r
//\r
typedef struct {\r
#ifdef EFI_NET_LITTLE_ENDIAN\r
  UINT8                 HeadLen : 4;\r
  UINT8                 Ver     : 4;\r
#else\r
  UINT8                 Ver     : 4;\r
  UINT8                 HeadLen : 4;\r
#endif\r
  UINT8                 Tos;\r
  UINT16                TotalLen;\r
  UINT16                Id;\r
  UINT16                Fragment;\r
  UINT8                 Ttl;\r
  UINT8                 Protocol;\r
  UINT16                Checksum;\r
  IP4_ADDR              Src;\r
  IP4_ADDR              Dst;\r
} IP4_HEAD;\r
\r
\r
//\r
// ICMP head definition. ICMP message is categoried as either an error\r
// message or query message. Two message types have their own head format.\r
//\r
typedef struct {\r
  UINT8                 Type;\r
  UINT8                 Code;\r
  UINT16                Checksum;\r
} IP4_ICMP_HEAD;\r
\r
typedef struct {\r
  IP4_ICMP_HEAD         Head;\r
  UINT32                Fourth; // 4th filed of the head, it depends on Type.\r
  IP4_HEAD              IpHead;\r
} IP4_ICMP_ERROR_HEAD;\r
\r
typedef struct {\r
  IP4_ICMP_HEAD         Head;\r
  UINT16                Id;\r
  UINT16                Seq;\r
} IP4_ICMP_QUERY_HEAD;\r
\r
\r
//\r
// UDP header definition\r
//\r
typedef struct {\r
  UINT16                SrcPort;\r
  UINT16                DstPort;\r
  UINT16                Length;\r
  UINT16                Checksum;\r
} EFI_UDP4_HEADER;\r
\r
\r
//\r
// TCP header definition\r
//\r
typedef struct {\r
  TCP_PORTNO            SrcPort;\r
  TCP_PORTNO            DstPort;\r
  TCP_SEQNO             Seq;\r
  TCP_SEQNO             Ack;\r
#ifdef EFI_NET_LITTLE_ENDIAN\r
  UINT8                 Res     : 4;\r
  UINT8                 HeadLen : 4;\r
#else\r
  UINT8                 HeadLen : 4;\r
  UINT8                 Res     : 4;\r
#endif\r
  UINT8                 Flag;\r
  UINT16                Wnd;\r
  UINT16                Checksum;\r
  UINT16                Urg;\r
} TCP_HEAD;\r
\r
#pragma pack()\r
\r
#define NET_MAC_EQUAL(pMac1, pMac2, Len)     \\r
    (NetCompareMem ((pMac1), (pMac2), Len) == 0)\r
\r
#define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \\r
    (((*((UINT8 *) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len)))\r
\r
#ifdef EFI_NET_LITTLE_ENDIAN\r
#define NTOHL(x) (UINT32)((((UINT32) (x) & 0xff)     << 24) | \\r
                          (((UINT32) (x) & 0xff00)   << 8)  | \\r
                          (((UINT32) (x) & 0xff0000) >> 8)  | \\r
                          (((UINT32) (x) & 0xff000000) >> 24))\r
\r
#define HTONL(x)  NTOHL(x)\r
\r
#define NTOHS(x)  (UINT16)((((UINT16) (x) & 0xff) << 8) | \\r
                           (((UINT16) (x) & 0xff00) >> 8))\r
\r
#define HTONS(x)  NTOHS(x)\r
#else\r
#define NTOHL(x)  (UINT32)(x)\r
#define HTONL(x)  (UINT32)(x)\r
#define NTOHS(x)  (UINT16)(x)\r
#define HTONS(x)  (UINT16)(x)\r
#endif\r
\r
//\r
// Test the IP's attribute, All the IPs are in host byte order.\r
//\r
#define IP4_IS_MULTICAST(Ip)              (((Ip) & 0xF0000000) == 0xE0000000)\r
#define IP4_IS_LOCAL_BROADCAST(Ip)        ((Ip) == 0xFFFFFFFF)\r
#define IP4_NET_EQUAL(Ip1, Ip2, NetMask)  (((Ip1) & (NetMask)) == ((Ip2) & (NetMask)))\r
#define IP4_IS_VALID_NETMASK(Ip)          (NetGetMaskLength (Ip) != IP4_MASK_NUM)\r
\r
//\r
// Convert the EFI_IP4_ADDRESS to plain UINT32 IP4 address.\r
//\r
#define EFI_IP4(EfiIpAddr)       (*(IP4_ADDR *) ((EfiIpAddr).Addr))\r
#define EFI_NTOHL(EfiIp)         (NTOHL (EFI_IP4 ((EfiIp))))\r
#define EFI_IP4_EQUAL(Ip1, Ip2)  (NetCompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0)\r
\r
INTN\r
NetGetMaskLength (\r
  IN IP4_ADDR               Mask\r
  );\r
\r
INTN\r
NetGetIpClass (\r
  IN IP4_ADDR               Addr\r
  );\r
\r
BOOLEAN\r
Ip4IsUnicast (\r
  IN IP4_ADDR               Ip,\r
  IN IP4_ADDR               NetMask\r
  );\r
\r
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_RECYCLE_LOCK    (NET_TPL_LOCK + 1)
#define NET_TPL_EVENT           TPL_CALLBACK
#define NET_TPL_RECYCLE         (NET_TPL_LOCK + 1)
#define NET_TPL_SLOW_TIMER      (TPL_CALLBACK - 1)
#define NET_TPL_FAST_TIMER      NET_TPL_RECYCLE
#define NET_TPL_TIMER           TPL_CALLBACK

#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_LOCK)
#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_MIN(a, b)           ((a) < (b) ? (a) : (b))
#define NET_MAX(a, b)           ((a) > (b) ? (a) : (b))
#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
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
  );

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