MdeModulePkg/Include/Library/NetLib.h

   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
  32 #define EFI_NET_LITTLE_ENDIAN
  33
  34 typedef UINT32          IP4_ADDR;
  35 typedef UINT32          TCP_SEQNO;
  36 typedef UINT16          TCP_PORTNO;
  37
  38 enum {
  39   NET_ETHER_ADDR_LEN    = 6,
  40   NET_IFTYPE_ETHERNET   = 0x01,
  41
  42   EFI_IP_PROTO_UDP      = 0x11,
  43   EFI_IP_PROTO_TCP      = 0x06,
  44   EFI_IP_PROTO_ICMP     = 0x01,
  45
  46   //
  47   // The address classfication
  48   //
  49   IP4_ADDR_CLASSA       = 1,
  50   IP4_ADDR_CLASSB,
  51   IP4_ADDR_CLASSC,
  52   IP4_ADDR_CLASSD,
  53   IP4_ADDR_CLASSE,
  54
  55   IP4_MASK_NUM          = 33,
  56 };
  57
  58 #pragma pack(1)
  59
  60 //
  61 // Ethernet head definition
  62 //
  63 typedef struct {
  64   UINT8                 DstMac [NET_ETHER_ADDR_LEN];
  65   UINT8                 SrcMac [NET_ETHER_ADDR_LEN];
  66   UINT16                EtherType;
  67 } ETHER_HEAD;
  68
  69
  70 //
  71 // The EFI_IP4_HEADER is hard to use because the source and
  72 // destination address are defined as EFI_IPv4_ADDRESS, which
  73 // is a structure. Two structures can't be compared or masked
  74 // directly. This is why there is an internal representation.
  75 //
  76 typedef struct {
  77 #ifdef EFI_NET_LITTLE_ENDIAN
  78   UINT8                 HeadLen : 4;
  79   UINT8                 Ver     : 4;
  80 #else
  81   UINT8                 Ver     : 4;
  82   UINT8                 HeadLen : 4;
  83 #endif
  84   UINT8                 Tos;
  85   UINT16                TotalLen;
  86   UINT16                Id;
  87   UINT16                Fragment;
  88   UINT8                 Ttl;
  89   UINT8                 Protocol;
  90   UINT16                Checksum;
  91   IP4_ADDR              Src;
  92   IP4_ADDR              Dst;
  93 } IP4_HEAD;
  94
  95
  96 //
  97 // ICMP head definition. ICMP message is categoried as either an error
  98 // message or query message. Two message types have their own head format.
  99 //
 100 typedef struct {
 101   UINT8                 Type;
 102   UINT8                 Code;
 103   UINT16                Checksum;
 104 } IP4_ICMP_HEAD;
 105
 106 typedef struct {
 107   IP4_ICMP_HEAD         Head;
 108   UINT32                Fourth; // 4th filed of the head, it depends on Type.
 109   IP4_HEAD              IpHead;
 110 } IP4_ICMP_ERROR_HEAD;
 111
 112 typedef struct {
 113   IP4_ICMP_HEAD         Head;
 114   UINT16                Id;
 115   UINT16                Seq;
 116 } IP4_ICMP_QUERY_HEAD;
 117
 118
 119 //
 120 // UDP header definition
 121 //
 122 typedef struct {
 123   UINT16                SrcPort;
 124   UINT16                DstPort;
 125   UINT16                Length;
 126   UINT16                Checksum;
 127 } EFI_UDP4_HEADER;
 128
 129
 130 //
 131 // TCP header definition
 132 //
 133 typedef struct {
 134   TCP_PORTNO            SrcPort;
 135   TCP_PORTNO            DstPort;
 136   TCP_SEQNO             Seq;
 137   TCP_SEQNO             Ack;
 138 #ifdef EFI_NET_LITTLE_ENDIAN
 139   UINT8                 Res     : 4;
 140   UINT8                 HeadLen : 4;
 141 #else
 142   UINT8                 HeadLen : 4;
 143   UINT8                 Res     : 4;
 144 #endif
 145   UINT8                 Flag;
 146   UINT16                Wnd;
 147   UINT16                Checksum;
 148   UINT16                Urg;
 149 } TCP_HEAD;
 150
 151 #pragma pack()
 152
 153 #define NET_MAC_EQUAL(pMac1, pMac2, Len)     \
 154     (NetCompareMem ((pMac1), (pMac2), Len) == 0)
 155
 156 #define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \
 157     (((*((UINT8 *) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len)))
 158
 159 #ifdef EFI_NET_LITTLE_ENDIAN
 160 #define NTOHL(x) (UINT32)((((UINT32) (x) & 0xff)     << 24) | \
 161                           (((UINT32) (x) & 0xff00)   << 8)  | \
 162                           (((UINT32) (x) & 0xff0000) >> 8)  | \
 163                           (((UINT32) (x) & 0xff000000) >> 24))
 164
 165 #define HTONL(x)  NTOHL(x)
 166
 167 #define NTOHS(x)  (UINT16)((((UINT16) (x) & 0xff) << 8) | \
 168                            (((UINT16) (x) & 0xff00) >> 8))
 169
 170 #define HTONS(x)  NTOHS(x)
 171 #else
 172 #define NTOHL(x)  (UINT32)(x)
 173 #define HTONL(x)  (UINT32)(x)
 174 #define NTOHS(x)  (UINT16)(x)
 175 #define HTONS(x)  (UINT16)(x)
 176 #endif
 177
 178 //
 179 // Test the IP's attribute, All the IPs are in host byte order.
 180 //
 181 #define IP4_IS_MULTICAST(Ip)              (((Ip) & 0xF0000000) == 0xE0000000)
 182 #define IP4_IS_LOCAL_BROADCAST(Ip)        ((Ip) == 0xFFFFFFFF)
 183 #define IP4_NET_EQUAL(Ip1, Ip2, NetMask)  (((Ip1) & (NetMask)) == ((Ip2) & (NetMask)))
 184 #define IP4_IS_VALID_NETMASK(Ip)          (NetGetMaskLength (Ip) != IP4_MASK_NUM)
 185
 186 //
 187 // Convert the EFI_IP4_ADDRESS to plain UINT32 IP4 address.
 188 //
 189 #define EFI_IP4(EfiIpAddr)       (*(IP4_ADDR *) ((EfiIpAddr).Addr))
 190 #define EFI_NTOHL(EfiIp)         (NTOHL (EFI_IP4 ((EfiIp))))
 191 #define EFI_IP4_EQUAL(Ip1, Ip2)  (NetCompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0)
 192
 193 INTN
 194 NetGetMaskLength (
 195   IN IP4_ADDR               Mask
 196   );
 197
 198 INTN
 199 NetGetIpClass (
 200   IN IP4_ADDR               Addr
 201   );
 202
 203 BOOLEAN
 204 Ip4IsUnicast (
 205   IN IP4_ADDR               Ip,
 206   IN IP4_ADDR               NetMask
 207   );
 208
 209 extern IP4_ADDR mIp4AllMasks [IP4_MASK_NUM];
 210
 211
 212 extern EFI_IPv4_ADDRESS  mZeroIp4Addr;
 213
 214 #define NET_IS_DIGIT(Ch)  (('0' <= (Ch)) && ((Ch) <= '9'))
 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))
 252 #define NET_RANDOM(Seed)        ((UINT32) ((UINT32) (Seed) * 1103515245UL + 12345) % 4294967295UL)
 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,
 457   IN OUT       CHAR16      **MacString
 458   );
 459
 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
 472 EFI_HANDLE
 473 NetLibGetNicHandle (
 474   IN EFI_HANDLE             Controller,
 475   IN EFI_GUID               *ProtocolGuid
 476   );
 477
 478 EFI_STATUS
 479 EFIAPI
 480 NetLibDefaultUnload (
 481   IN EFI_HANDLE             ImageHandle
 482   );
 483
 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   );
 795
 796 //
 797 // The debug level definition. This value is also used as the
 798 // syslog's servity level. Don't change it.
 799 //
 800 enum {
 801   NETDEBUG_LEVEL_TRACE   = 5,
 802   NETDEBUG_LEVEL_WARNING = 4,
 803   NETDEBUG_LEVEL_ERROR   = 3,
 804 };
 805
 806 #ifdef EFI_NETWORK_STACK_DEBUG
 807
 808 //
 809 // The debug output expects the ASCII format string, Use %a to print ASCII
 810 // string, and %s to print UNICODE string. PrintArg must be enclosed in ().
 811 // For example: NET_DEBUG_TRACE ("Tcp", ("State transit to %a\n", Name));
 812 //
 813 #define NET_DEBUG_TRACE(Module, PrintArg) \
 814   NetDebugOutput ( \
 815     NETDEBUG_LEVEL_TRACE, \
 816     Module, \
 817     __FILE__, \
 818     __LINE__, \
 819     NetDebugASPrint PrintArg \
 820     )
 821
 822 #define NET_DEBUG_WARNING(Module, PrintArg) \
 823   NetDebugOutput ( \
 824     NETDEBUG_LEVEL_WARNING, \
 825     Module, \
 826     __FILE__, \
 827     __LINE__, \
 828     NetDebugASPrint PrintArg \
 829     )
 830
 831 #define NET_DEBUG_ERROR(Module, PrintArg) \
 832   NetDebugOutput ( \
 833     NETDEBUG_LEVEL_ERROR, \
 834     Module, \
 835     __FILE__, \
 836     __LINE__, \
 837     NetDebugASPrint PrintArg \
 838     )
 839
 840 #else
 841 #define NET_DEBUG_TRACE(Module, PrintString)
 842 #define NET_DEBUG_WARNING(Module, PrintString)
 843 #define NET_DEBUG_ERROR(Module, PrintString)
 844 #endif
 845
 846 UINT8 *
 847 NetDebugASPrint (
 848   UINT8                     *Format,
 849   ...
 850   );
 851
 852 EFI_STATUS
 853 NetDebugOutput (
 854   UINT32                    Level,
 855   UINT8                     *Module,
 856   UINT8                     *File,
 857   UINT32                    Line,
 858   UINT8                     *Message
 859   );
 860
 861 //
 862 // Network debug message is sent out as syslog.
 863 //
 864 enum {
 865   NET_SYSLOG_FACILITY       = 16,             // Syslog local facility local use
 866   NET_SYSLOG_PACKET_LEN     = 512,
 867   NET_DEBUG_MSG_LEN         = 470,            // 512 - (ether+ip+udp head length)
 868   NET_SYSLOG_TX_TIMEOUT     = 500 *1000 *10,  // 500ms
 869 };
 870 #endif