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 typedef
 479 EFI_STATUS
 480 (EFIAPI *NET_LIB_DRIVER_UNLOAD) (
 481   IN EFI_HANDLE             ImageHandle
 482   );
 483
 484 EFI_STATUS
 485 EFIAPI
 486 NetLibDefaultUnload (
 487   IN EFI_HANDLE             ImageHandle
 488   );
 489
 490 EFI_STATUS
 491 NetLibInstallAllDriverProtocolsWithUnload (
 492   IN EFI_HANDLE                         ImageHandle,
 493   IN EFI_SYSTEM_TABLE                   *SystemTable,
 494   IN EFI_DRIVER_BINDING_PROTOCOL        *DriverBinding,
 495   IN EFI_HANDLE                         DriverBindingHandle,
 496   IN EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
 497   IN EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration, OPTIONAL
 498   IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics, OPTIONAL
 499   IN NET_LIB_DRIVER_UNLOAD              CustomizedUnload
 500   );
 501
 502 EFI_STATUS
 503 NetLibInstallAllDriverProtocols (
 504   IN EFI_HANDLE                         ImageHandle,
 505   IN EFI_SYSTEM_TABLE                   *SystemTable,
 506   IN EFI_DRIVER_BINDING_PROTOCOL        *DriverBinding,
 507   IN EFI_HANDLE                         DriverBindingHandle,
 508   IN EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
 509   IN EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration, OPTIONAL
 510   IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics OPTIONAL
 511   );
 512
 513 enum {
 514   //
 515   //Various signatures
 516   //
 517   NET_BUF_SIGNATURE    = EFI_SIGNATURE_32 ('n', 'b', 'u', 'f'),
 518   NET_VECTOR_SIGNATURE = EFI_SIGNATURE_32 ('n', 'v', 'e', 'c'),
 519   NET_QUE_SIGNATURE    = EFI_SIGNATURE_32 ('n', 'b', 'q', 'u'),
 520
 521
 522   NET_PROTO_DATA       = 64,   // Opaque buffer for protocols
 523   NET_BUF_HEAD         = 1,    // Trim or allocate space from head
 524   NET_BUF_TAIL         = 0,    // Trim or allocate space from tail
 525   NET_VECTOR_OWN_FIRST = 0x01, // We allocated the 1st block in the vector
 526 };
 527
 528 #define NET_CHECK_SIGNATURE(PData, SIGNATURE) \
 529   ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE)))
 530
 531 #define NET_SWAP_SHORT(Value) \
 532   ((((Value) & 0xff) << 8) | (((Value) >> 8) & 0xff))
 533
 534 //
 535 // Single memory block in the vector.
 536 //
 537 typedef struct {
 538   UINT32              Len;        // The block's length
 539   UINT8               *Bulk;      // The block's Data
 540 } NET_BLOCK;
 541
 542 typedef VOID (*NET_VECTOR_EXT_FREE) (VOID *Arg);
 543
 544 //
 545 //NET_VECTOR contains several blocks to hold all packet's
 546 //fragments and other house-keeping stuff for sharing. It
 547 //doesn't specify the where actual packet fragment begins.
 548 //
 549 typedef struct {
 550   UINT32              Signature;
 551   INTN                RefCnt;  // Reference count to share NET_VECTOR.
 552   NET_VECTOR_EXT_FREE Free;    // external function to free NET_VECTOR
 553   VOID                *Arg;    // opeque argument to Free
 554   UINT32              Flag;    // Flags, NET_VECTOR_OWN_FIRST
 555   UINT32              Len;     // Total length of the assocated BLOCKs
 556
 557   UINT32              BlockNum;
 558   NET_BLOCK           Block[1];
 559 } NET_VECTOR;
 560
 561 //
 562 //NET_BLOCK_OP operate on the NET_BLOCK, It specifies
 563 //where the actual fragment begins and where it ends
 564 //
 565 typedef struct {
 566   UINT8               *BlockHead;   // Block's head, or the smallest valid Head
 567   UINT8               *BlockTail;   // Block's tail. BlockTail-BlockHead=block length
 568   UINT8               *Head;        // 1st byte of the data in the block
 569   UINT8               *Tail;        // Tail of the data in the block, Tail-Head=Size
 570   UINT32              Size;         // The size of the data
 571 } NET_BLOCK_OP;
 572
 573
 574 //
 575 //NET_BUF is the buffer manage structure used by the
 576 //network stack. Every network packet may be fragmented,
 577 //and contains multiple fragments. The Vector points to
 578 //memory blocks used by the each fragment, and BlockOp
 579 //specifies where each fragment begins and ends.
 580 //
 581 //It also contains a opaque area for protocol to store
 582 //per-packet informations. Protocol must be caution not
 583 //to overwrite the members after that.
 584 //
 585 typedef struct {
 586   UINT32              Signature;
 587   INTN                RefCnt;
 588   NET_LIST_ENTRY      List;       // The List this NET_BUF is on
 589
 590   IP4_HEAD            *Ip;        // Network layer header, for fast access
 591   TCP_HEAD            *Tcp;       // Transport layer header, for fast access
 592   UINT8               ProtoData [NET_PROTO_DATA]; //Protocol specific data
 593
 594   NET_VECTOR          *Vector;    // The vector containing the packet
 595
 596   UINT32              BlockOpNum; // Total number of BlockOp in the buffer
 597   UINT32              TotalSize;  // Total size of the actual packet
 598   NET_BLOCK_OP        BlockOp[1]; // Specify the position of actual packet
 599 } NET_BUF;
 600
 601
 602 //
 603 //A queue of NET_BUFs, It is just a thin extension of
 604 //NET_BUF functions.
 605 //
 606 typedef struct {
 607   UINT32              Signature;
 608   INTN                RefCnt;
 609   NET_LIST_ENTRY      List;       // The List this buffer queue is on
 610
 611   NET_LIST_ENTRY      BufList;    // list of queued buffers
 612   UINT32              BufSize;    // total length of DATA in the buffers
 613   UINT32              BufNum;     // total number of buffers on the chain
 614 } NET_BUF_QUEUE;
 615
 616 //
 617 // Pseudo header for TCP and UDP checksum
 618 //
 619 #pragma pack(1)
 620 typedef struct {
 621   IP4_ADDR            SrcIp;
 622   IP4_ADDR            DstIp;
 623   UINT8               Reserved;
 624   UINT8               Protocol;
 625   UINT16              Len;
 626 } NET_PSEUDO_HDR;
 627 #pragma pack()
 628
 629 //
 630 // The fragment entry table used in network interfaces. This is
 631 // the same as NET_BLOCK now. Use two different to distinguish
 632 // the two in case that NET_BLOCK be enhanced later.
 633 //
 634 typedef struct {
 635   UINT32              Len;
 636   UINT8               *Bulk;
 637 } NET_FRAGMENT;
 638
 639 #define NET_GET_REF(PData)      ((PData)->RefCnt++)
 640 #define NET_PUT_REF(PData)      ((PData)->RefCnt--)
 641 #define NETBUF_FROM_PROTODATA(Info) _CR((Info), NET_BUF, ProtoData)
 642
 643 #define NET_BUF_SHARED(Buf) \
 644   (((Buf)->RefCnt > 1) || ((Buf)->Vector->RefCnt > 1))
 645
 646 #define NET_VECTOR_SIZE(BlockNum) \
 647   (sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK))
 648
 649 #define NET_BUF_SIZE(BlockOpNum)  \
 650   (sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP))
 651
 652 #define NET_HEADSPACE(BlockOp)  \
 653   (UINTN)((BlockOp)->Head - (BlockOp)->BlockHead)
 654
 655 #define NET_TAILSPACE(BlockOp)  \
 656   (UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail)
 657
 658 NET_BUF  *
 659 NetbufAlloc (
 660   IN UINT32                 Len
 661   );
 662
 663 VOID
 664 NetbufFree (
 665   IN NET_BUF                *Nbuf
 666   );
 667
 668
 669 UINT8  *
 670 NetbufGetByte (
 671   IN  NET_BUF               *Nbuf,
 672   IN  UINT32                Offset,
 673   OUT UINT32                *Index      OPTIONAL
 674   );
 675
 676 NET_BUF  *
 677 NetbufClone (
 678   IN NET_BUF                *Nbuf
 679   );
 680
 681 NET_BUF  *
 682 NetbufDuplicate (
 683   IN NET_BUF                *Nbuf,
 684   IN NET_BUF                *Duplicate    OPTIONAL,
 685   IN UINT32                 HeadSpace
 686   );
 687
 688 NET_BUF  *
 689 NetbufGetFragment (
 690   IN NET_BUF                *Nbuf,
 691   IN UINT32                 Offset,
 692   IN UINT32                 Len,
 693   IN UINT32                 HeadSpace
 694   );
 695
 696 VOID
 697 NetbufReserve (
 698   IN NET_BUF                *Nbuf,
 699   IN UINT32                 Len
 700   );
 701
 702 UINT8  *
 703 NetbufAllocSpace (
 704   IN NET_BUF                *Nbuf,
 705   IN UINT32                 Len,
 706   IN BOOLEAN                FromHead
 707   );
 708
 709 UINT32
 710 NetbufTrim (
 711   IN NET_BUF                *Nbuf,
 712   IN UINT32                 Len,
 713   IN BOOLEAN                FromHead
 714   );
 715
 716 UINT32
 717 NetbufCopy (
 718   IN NET_BUF                *Nbuf,
 719   IN UINT32                 Offset,
 720   IN UINT32                 Len,
 721   IN UINT8                  *Dest
 722   );
 723
 724 NET_BUF  *
 725 NetbufFromExt (
 726   IN NET_FRAGMENT           *ExtFragment,
 727   IN UINT32                 ExtNum,
 728   IN UINT32                 HeadSpace,
 729   IN UINT32                 HeadLen,
 730   IN NET_VECTOR_EXT_FREE    ExtFree,
 731   IN VOID                   *Arg          OPTIONAL
 732   );
 733
 734 EFI_STATUS
 735 NetbufBuildExt (
 736   IN NET_BUF                *Nbuf,
 737   IN NET_FRAGMENT           *ExtFragment,
 738   IN UINT32                 *ExtNum
 739   );
 740
 741 NET_BUF  *
 742 NetbufFromBufList (
 743   IN NET_LIST_ENTRY         *BufList,
 744   IN UINT32                 HeadSpace,
 745   IN UINT32                 HeaderLen,
 746   IN NET_VECTOR_EXT_FREE    ExtFree,
 747   IN VOID                   *Arg                OPTIONAL
 748   );
 749
 750 VOID
 751 NetbufFreeList (
 752   IN NET_LIST_ENTRY         *Head
 753   );
 754
 755 VOID
 756 NetbufQueInit (
 757   IN NET_BUF_QUEUE          *NbufQue
 758   );
 759
 760 NET_BUF_QUEUE  *
 761 NetbufQueAlloc (
 762   VOID
 763   );
 764
 765 VOID
 766 NetbufQueFree (
 767   IN NET_BUF_QUEUE          *NbufQue
 768   );
 769
 770 NET_BUF  *
 771 NetbufQueRemove (
 772   IN NET_BUF_QUEUE          *NbufQue
 773   );
 774
 775 VOID
 776 NetbufQueAppend (
 777   IN NET_BUF_QUEUE          *NbufQue,
 778   IN NET_BUF                *Nbuf
 779   );
 780
 781 UINT32
 782 NetbufQueCopy (
 783   IN NET_BUF_QUEUE          *NbufQue,
 784   IN UINT32                 Offset,
 785   IN UINT32                 Len,
 786   IN UINT8                  *Dest
 787   );
 788
 789 UINT32
 790 NetbufQueTrim (
 791   IN NET_BUF_QUEUE          *NbufQue,
 792   IN UINT32                 Len
 793   );
 794
 795 VOID
 796 NetbufQueFlush (
 797   IN NET_BUF_QUEUE          *NbufQue
 798   );
 799
 800 UINT16
 801 NetblockChecksum (
 802   IN UINT8                  *Bulk,
 803   IN UINT32                 Len
 804   );
 805
 806 UINT16
 807 NetAddChecksum (
 808   IN UINT16                 Checksum1,
 809   IN UINT16                 Checksum2
 810   );
 811
 812 UINT16
 813 NetbufChecksum (
 814   IN NET_BUF                *Nbuf
 815   );
 816
 817 UINT16
 818 NetPseudoHeadChecksum (
 819   IN IP4_ADDR               Src,
 820   IN IP4_ADDR               Dst,
 821   IN UINT8                  Proto,
 822   IN UINT16                 Len
 823   );
 824
 825 //
 826 // The debug level definition. This value is also used as the
 827 // syslog's servity level. Don't change it.
 828 //
 829 enum {
 830   NETDEBUG_LEVEL_TRACE   = 5,
 831   NETDEBUG_LEVEL_WARNING = 4,
 832   NETDEBUG_LEVEL_ERROR   = 3,
 833 };
 834
 835 #ifdef EFI_NETWORK_STACK_DEBUG
 836
 837 //
 838 // The debug output expects the ASCII format string, Use %a to print ASCII
 839 // string, and %s to print UNICODE string. PrintArg must be enclosed in ().
 840 // For example: NET_DEBUG_TRACE ("Tcp", ("State transit to %a\n", Name));
 841 //
 842 #define NET_DEBUG_TRACE(Module, PrintArg) \
 843   NetDebugOutput ( \
 844     NETDEBUG_LEVEL_TRACE, \
 845     Module, \
 846     __FILE__, \
 847     __LINE__, \
 848     NetDebugASPrint PrintArg \
 849     )
 850
 851 #define NET_DEBUG_WARNING(Module, PrintArg) \
 852   NetDebugOutput ( \
 853     NETDEBUG_LEVEL_WARNING, \
 854     Module, \
 855     __FILE__, \
 856     __LINE__, \
 857     NetDebugASPrint PrintArg \
 858     )
 859
 860 #define NET_DEBUG_ERROR(Module, PrintArg) \
 861   NetDebugOutput ( \
 862     NETDEBUG_LEVEL_ERROR, \
 863     Module, \
 864     __FILE__, \
 865     __LINE__, \
 866     NetDebugASPrint PrintArg \
 867     )
 868
 869 #else
 870 #define NET_DEBUG_TRACE(Module, PrintString)
 871 #define NET_DEBUG_WARNING(Module, PrintString)
 872 #define NET_DEBUG_ERROR(Module, PrintString)
 873 #endif
 874
 875 UINT8 *
 876 NetDebugASPrint (
 877   UINT8                     *Format,
 878   ...
 879   );
 880
 881 EFI_STATUS
 882 NetDebugOutput (
 883   UINT32                    Level,
 884   UINT8                     *Module,
 885   UINT8                     *File,
 886   UINT32                    Line,
 887   UINT8                     *Message
 888   );
 889
 890 //
 891 // Network debug message is sent out as syslog.
 892 //
 893 enum {
 894   NET_SYSLOG_FACILITY       = 16,             // Syslog local facility local use
 895   NET_SYSLOG_PACKET_LEN     = 512,
 896   NET_DEBUG_MSG_LEN         = 470,            // 512 - (ether+ip+udp head length)
 897   NET_SYSLOG_TX_TIMEOUT     = 500 *1000 *10,  // 500ms
 898 };
 899 #endif