[mirror_edk2.git] / MdeModulePkg / Include / Library / NetLib.h

/** @file\r
  This library provides basic function for UEFI network stack.\r
\r
Copyright (c) 2005 - 2008, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#ifndef _NET_LIB_H_\r
#define _NET_LIB_H_\r
\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Protocol/DriverBinding.h>\r
#include <Protocol/ComponentName.h>\r
#include <Protocol/DriverConfiguration.h>\r
#include <Protocol/DriverDiagnostics.h>\r
#include <Protocol/Dpc.h>\r
\r
typedef UINT32          IP4_ADDR;\r
typedef UINT32          TCP_SEQNO;\r
typedef UINT16          TCP_PORTNO;\r
\r
typedef 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
} IP4_CLASS_TYPE;\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
  UINT8                 HeadLen : 4;\r
  UINT8                 Ver     : 4;\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
  UINT8                 Res     : 4;\r
  UINT8                 HeadLen : 4;\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
    (CompareMem ((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
#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
\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)  (CompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0)\r
\r
/**\r
  Return the length of the mask. If the mask is invalid,\r
  return the invalid length 33, which is IP4_MASK_NUM.\r
  NetMask is in the host byte order.\r
\r
  @param  NetMask               The netmask to get the length from\r
\r
  @return The length of the netmask, IP4_MASK_NUM if the mask isn't\r
  @return supported.\r
\r
**/\r
INTN\r
EFIAPI\r
NetGetMaskLength (\r
  IN IP4_ADDR               Mask\r
  );\r
\r
/**\r
  Return the class of the address, such as class a, b, c.\r
  Addr is in host byte order.\r
\r
  @param  Addr                  The address to get the class from\r
\r
  @return IP address class, such as IP4_ADDR_CLASSA\r
\r
**/\r
INTN\r
EFIAPI\r
NetGetIpClass (\r
  IN IP4_ADDR               Addr\r
  );\r
\r
/**\r
  Check whether the IP is a valid unicast address according to\r
  the netmask. If NetMask is zero, use the IP address's class to\r
  get the default mask.\r
\r
  @param  Ip                    The IP to check againist\r
  @param  NetMask               The mask of the IP\r
\r
  @return TRUE if IP is a valid unicast address on the network, otherwise FALSE\r
\r
**/\r
BOOLEAN\r
Ip4IsUnicast (\r
  IN IP4_ADDR               Ip,\r
  IN IP4_ADDR               NetMask\r
  );\r
\r
extern IP4_ADDR gIp4AllMasks [IP4_MASK_NUM];\r
\r
\r
extern EFI_IPv4_ADDRESS  mZeroIp4Addr;\r
\r
#define NET_IS_DIGIT(Ch)            (('0' <= (Ch)) && ((Ch) <= '9'))\r
#define NET_ROUNDUP(size, unit)     (((size) + (unit) - 1) & (~((unit) - 1)))\r
#define NET_IS_LOWER_CASE_CHAR(Ch)  (('a' <= (Ch)) && ((Ch) <= 'z'))\r
#define NET_IS_UPPER_CASE_CHAR(Ch)  (('A' <= (Ch)) && ((Ch) <= 'Z'))\r
\r
#define TICKS_PER_MS            10000U\r
#define TICKS_PER_SECOND        10000000U\r
\r
#define NET_RANDOM(Seed)        ((UINT32) ((UINT32) (Seed) * 1103515245UL + 12345) % 4294967295UL)\r
\r
/**\r
  Extract a UINT32 from a byte stream, then convert it to host\r
  byte order. Use this function to avoid alignment error.\r
\r
  @param  Buf                   The buffer to extract the UINT32.\r
\r
  @return The UINT32 extracted.\r
\r
**/\r
UINT32\r
EFIAPI\r
NetGetUint32 (\r
  IN UINT8                  *Buf\r
  );\r
\r
/**\r
  Put a UINT32 to the byte stream. Convert it from host byte order\r
  to network byte order before putting.\r
\r
  @param  Buf                   The buffer to put the UINT32\r
  @param  Data                  The data to put\r
\r
  @return None\r
\r
**/\r
VOID\r
EFIAPI\r
NetPutUint32 (\r
  IN UINT8                  *Buf,\r
  IN UINT32                 Data\r
  );\r
\r
/**\r
  Initialize a random seed using current time.\r
\r
  None\r
\r
  @return The random seed initialized with current time.\r
\r
**/\r
UINT32\r
EFIAPI\r
NetRandomInitSeed (\r
  VOID\r
  );\r
\r
\r
#define NET_LIST_USER_STRUCT(Entry, Type, Field)        \\r
          _CR(Entry, Type, Field)\r
\r
#define NET_LIST_USER_STRUCT_S(Entry, Type, Field, Sig)  \\r
          CR(Entry, Type, Field, Sig)\r
\r
//\r
// Iterate through the doule linked list. It is NOT delete safe\r
//\r
#define NET_LIST_FOR_EACH(Entry, ListHead) \\r
  for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink)\r
\r
//\r
// Iterate through the doule linked list. This is delete-safe.\r
// Don't touch NextEntry. Also, don't use this macro if list\r
// entries other than the Entry may be deleted when processing\r
// the current Entry.\r
//\r
#define NET_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \\r
  for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink; \\r
      Entry != (ListHead); \\r
      Entry = NextEntry, NextEntry = Entry->ForwardLink \\r
     )\r
\r
//\r
// Make sure the list isn't empty before get the frist/last record.\r
//\r
#define NET_LIST_HEAD(ListHead, Type, Field)  \\r
          NET_LIST_USER_STRUCT((ListHead)->ForwardLink, Type, Field)\r
\r
#define NET_LIST_TAIL(ListHead, Type, Field)  \\r
          NET_LIST_USER_STRUCT((ListHead)->BackLink, Type, Field)\r
\r
\r
/**\r
  Remove the first entry on the list\r
\r
  @param  Head                  The list header\r
\r
  @return The entry that is removed from the list, NULL if the list is empty.\r
\r
**/\r
LIST_ENTRY *\r
EFIAPI\r
NetListRemoveHead (\r
  LIST_ENTRY            *Head\r
  );\r
\r
/**\r
  Remove the last entry on the list\r
\r
  @param  Head                  The list head\r
\r
  @return The entry that is removed from the list, NULL if the list is empty.\r
\r
**/\r
LIST_ENTRY *\r
EFIAPI\r
NetListRemoveTail (\r
  LIST_ENTRY            *Head\r
  );\r
\r
/**\r
  Insert the NewEntry after the PrevEntry.\r
\r
  @param  PrevEntry             The previous entry to insert after\r
  @param  NewEntry              The new entry to insert\r
\r
  @return None\r
\r
**/\r
VOID\r
EFIAPI\r
NetListInsertAfter (\r
  IN LIST_ENTRY         *PrevEntry,\r
  IN LIST_ENTRY         *NewEntry\r
  );\r
\r
/**\r
  Insert the NewEntry before the PostEntry.\r
\r
  @param  PostEntry             The entry to insert before\r
  @param  NewEntry              The new entry to insert\r
\r
  @return None\r
\r
**/\r
VOID\r
EFIAPI\r
NetListInsertBefore (\r
  IN LIST_ENTRY         *PostEntry,\r
  IN LIST_ENTRY         *NewEntry\r
  );\r
\r
\r
//\r
// Object container: EFI network stack spec defines various kinds of\r
// tokens. The drivers can share code to manage those objects.\r
//\r
typedef struct {\r
  LIST_ENTRY                Link;\r
  VOID                      *Key;\r
  VOID                      *Value;\r
} NET_MAP_ITEM;\r
\r
typedef struct {\r
  LIST_ENTRY                Used;\r
  LIST_ENTRY                Recycled;\r
  UINTN                     Count;\r
} NET_MAP;\r
\r
#define NET_MAP_INCREAMENT  64\r
\r
/**\r
  Initialize the netmap. Netmap is a reposity to keep the <Key, Value> pairs.\r
\r
  @param  Map                   The netmap to initialize\r
\r
  @return None\r
\r
**/\r
VOID\r
EFIAPI\r
NetMapInit (\r
  IN NET_MAP                *Map\r
  );\r
\r
/**\r
  To clean up the netmap, that is, release allocated memories.\r
\r
  @param  Map                   The netmap to clean up.\r
\r
  @return None\r
\r
**/\r
VOID\r
EFIAPI\r
NetMapClean (\r
  IN NET_MAP                *Map\r
  );\r
\r
/**\r
  Test whether the netmap is empty\r
\r
  @param  Map                   The net map to test\r
\r
  @return TRUE if the netmap is empty, otherwise FALSE.\r
\r
**/\r
BOOLEAN\r
EFIAPI\r
NetMapIsEmpty (\r
  IN NET_MAP                *Map\r
  );\r
\r
/**\r
  Return the number of the <Key, Value> pairs in the netmap.\r
\r
  @param  Map                   The netmap to get the entry number\r
\r
  @return The entry number in the netmap.\r
\r
**/\r
UINTN\r
EFIAPI\r
NetMapGetCount (\r
  IN NET_MAP                *Map\r
  );\r
\r
/**\r
  Allocate an item to save the <Key, Value> pair to the head of the netmap.\r
\r
  @param  Map                   The netmap to insert into\r
  @param  Key                   The user's key\r
  @param  Value                 The user's value for the key\r
\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate the memory for the item\r
  @retval EFI_SUCCESS           The item is inserted to the head\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetMapInsertHead (\r
  IN NET_MAP                *Map,\r
  IN VOID                   *Key,\r
  IN VOID                   *Value    OPTIONAL\r
  );\r
\r
/**\r
  Allocate an item to save the <Key, Value> pair to the tail of the netmap.\r
\r
  @param  Map                   The netmap to insert into\r
  @param  Key                   The user's key\r
  @param  Value                 The user's value for the key\r
\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate the memory for the item\r
  @retval EFI_SUCCESS           The item is inserted to the tail\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetMapInsertTail (\r
  IN NET_MAP                *Map,\r
  IN VOID                   *Key,\r
  IN VOID                   *Value    OPTIONAL\r
  );\r
\r
/**\r
  Find the key in the netmap\r
\r
  @param  Map                   The netmap to search within\r
  @param  Key                   The key to search\r
\r
  @return The point to the item contains the Key, or NULL if Key isn't in the map.\r
\r
**/\r
NET_MAP_ITEM  *\r
EFIAPI\r
NetMapFindKey (\r
  IN  NET_MAP               *Map,\r
  IN  VOID                  *Key\r
  );\r
\r
/**\r
  Remove the item from the netmap\r
\r
  @param  Map                   The netmap to remove the item from\r
  @param  Item                  The item to remove\r
  @param  Value                 The variable to receive the value if not NULL\r
\r
  @return The key of the removed item.\r
\r
**/\r
VOID *\r
EFIAPI\r
NetMapRemoveItem (\r
  IN  NET_MAP               *Map,\r
  IN  NET_MAP_ITEM          *Item,\r
  OUT VOID                  **Value   OPTIONAL\r
  );\r
\r
/**\r
  Remove the first entry on the netmap.\r
\r
  @param  Map                   The netmap to remove the head from\r
  @param  Value                 The variable to receive the value if not NULL\r
\r
  @return The key of the item removed\r
\r
**/\r
VOID *\r
EFIAPI\r
NetMapRemoveHead (\r
  IN  NET_MAP               *Map,\r
  OUT VOID                  **Value   OPTIONAL\r
  );\r
\r
/**\r
  Remove the last entry on the netmap.\r
\r
  @param  Map                   The netmap to remove the tail from\r
  @param  Value                 The variable to receive the value if not NULL\r
\r
  @return The key of the item removed\r
\r
**/\r
VOID *\r
EFIAPI\r
NetMapRemoveTail (\r
  IN  NET_MAP               *Map,\r
  OUT VOID                  **Value OPTIONAL\r
  );\r
\r
typedef\r
EFI_STATUS\r
(*NET_MAP_CALLBACK) (\r
  IN NET_MAP                *Map,\r
  IN NET_MAP_ITEM           *Item,\r
  IN VOID                   *Arg\r
  );\r
\r
/**\r
  Iterate through the netmap and call CallBack for each item. It will\r
  contiue the traverse if CallBack returns EFI_SUCCESS, otherwise, break\r
  from the loop. It returns the CallBack's last return value. This\r
  function is delete safe for the current item.\r
\r
  @param  Map                   The Map to iterate through\r
  @param  CallBack              The callback function to call for each item.\r
  @param  Arg                   The opaque parameter to the callback\r
\r
  @return It returns the CallBack's last return value.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetMapIterate (\r
  IN NET_MAP                *Map,\r
  IN NET_MAP_CALLBACK       CallBack,\r
  IN VOID                   *Arg      OPTIONAL\r
  );\r
\r
\r
//\r
// Helper functions to implement driver binding and service binding protocols.\r
//\r
/**\r
  Create a child of the service that is identified by ServiceBindingGuid.\r
\r
  @param  ControllerHandle      The controller which has the service installed.\r
  @param  ImageHandle           The image handle used to open service.\r
  @param  ServiceBindingGuid    The service's Guid.\r
  @param  ChildHandle           The handle to receive the create child\r
\r
  @retval EFI_SUCCESS           The child is successfully created.\r
  @retval Others                Failed to create the child.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetLibCreateServiceChild (\r
  IN  EFI_HANDLE            ControllerHandle,\r
  IN  EFI_HANDLE            ImageHandle,\r
  IN  EFI_GUID              *ServiceBindingGuid,\r
  OUT EFI_HANDLE            *ChildHandle\r
  );\r
\r
/**\r
  Destory a child of the service that is identified by ServiceBindingGuid.\r
\r
  @param  ControllerHandle      The controller which has the service installed.\r
  @param  ImageHandle           The image handle used to open service.\r
  @param  ServiceBindingGuid    The service's Guid.\r
  @param  ChildHandle           The child to destory\r
\r
  @retval EFI_SUCCESS           The child is successfully destoried.\r
  @retval Others                Failed to destory the child.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetLibDestroyServiceChild (\r
  IN  EFI_HANDLE            ControllerHandle,\r
  IN  EFI_HANDLE            ImageHandle,\r
  IN  EFI_GUID              *ServiceBindingGuid,\r
  IN  EFI_HANDLE            ChildHandle\r
  );\r
\r
/**\r
  Convert the mac address of the simple network protocol installed on\r
  SnpHandle to a unicode string. Callers are responsible for freeing the\r
  string storage.\r
\r
  @param  SnpHandle             The handle where the simple network protocol is\r
                                installed on.\r
  @param  ImageHandle           The image handle used to act as the agent handle to\r
                                get the simple network protocol.\r
  @param  MacString             The pointer to store the address of the string\r
                                representation of  the mac address.\r
\r
  @retval EFI_OUT_OF_RESOURCES  There are not enough memory resource.\r
  @retval other                 Failed to open the simple network protocol.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetLibGetMacString (\r
  IN           EFI_HANDLE  SnpHandle,\r
  IN           EFI_HANDLE  ImageHandle,\r
  IN OUT       CHAR16      **MacString\r
  );\r
\r
/**\r
  Create an IPv4 device path node.\r
\r
  @param  Node                  Pointer to the IPv4 device path node.\r
  @param  Controller            The handle where the NIC IP4 config protocol resides.\r
  @param  LocalIp               The local IPv4 address.\r
  @param  LocalPort             The local port.\r
  @param  RemoteIp              The remote IPv4 address.\r
  @param  RemotePort            The remote port.\r
  @param  Protocol              The protocol type in the IP header.\r
  @param  UseDefaultAddress     Whether this instance is using default address or not.\r
\r
  @retval None\r
**/\r
VOID\r
EFIAPI\r
NetLibCreateIPv4DPathNode (\r
  IN OUT IPv4_DEVICE_PATH  *Node,\r
  IN EFI_HANDLE            Controller,\r
  IN IP4_ADDR              LocalIp,\r
  IN UINT16                LocalPort,\r
  IN IP4_ADDR              RemoteIp,\r
  IN UINT16                RemotePort,\r
  IN UINT16                Protocol,\r
  IN BOOLEAN               UseDefaultAddress\r
  );\r
\r
/**\r
  Find the UNDI/SNP handle from controller and protocol GUID.\r
  For example, IP will open a MNP child to transmit/receive\r
  packets, when MNP is stopped, IP should also be stopped. IP\r
  needs to find its own private data which is related the IP's\r
  service binding instance that is install on UNDI/SNP handle.\r
  Now, the controller is either a MNP or ARP child handle. But\r
  IP opens these handle BY_DRIVER, use that info, we can get the\r
  UNDI/SNP handle.\r
\r
  @param  Controller            Then protocol handle to check\r
  @param  ProtocolGuid          The protocol that is related with the handle.\r
\r
  @return The UNDI/SNP handle or NULL.\r
\r
**/\r
EFI_HANDLE\r
EFIAPI\r
NetLibGetNicHandle (\r
  IN EFI_HANDLE             Controller,\r
  IN EFI_GUID               *ProtocolGuid\r
  );\r
\r
/**\r
  Add a Deferred Procedure Call to the end of the DPC queue.\r
\r
  @param DpcTpl           The EFI_TPL that the DPC should be invoked.\r
  @param DpcProcedure     Pointer to the DPC's function.\r
  @param DpcContext       Pointer to the DPC's context.  Passed to DpcProcedure\r
                          when DpcProcedure is invoked.\r
\r
  @retval  EFI_SUCCESS              The DPC was queued.\r
  @retval  EFI_INVALID_PARAMETER    DpcTpl is not a valid EFI_TPL.\r
                                    DpcProcedure is NULL.\r
  @retval  EFI_OUT_OF_RESOURCES     There are not enough resources available to\r
                                    add the DPC to the queue.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetLibQueueDpc (\r
  IN EFI_TPL            DpcTpl,\r
  IN EFI_DPC_PROCEDURE  DpcProcedure,\r
  IN VOID               *DpcContext    OPTIONAL\r
  );\r
\r
/**\r
  Add a Deferred Procedure Call to the end of the DPC queue.\r
\r
  @retval  EFI_SUCCESS              One or more DPCs were invoked.\r
  @retval  EFI_NOT_FOUND            No DPCs were invoked.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetLibDispatchDpc (\r
  VOID\r
  );\r
\r
/**\r
  This is the default unload handle for all the network drivers.\r
\r
  @param  ImageHandle           The drivers' driver image.\r
\r
  @retval EFI_SUCCESS           The image is unloaded.\r
  @retval Others                Failed to unload the image.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetLibDefaultUnload (\r
  IN EFI_HANDLE             ImageHandle\r
  );\r
\r
typedef enum {\r
  //\r
  //Various signatures\r
  //\r
  NET_BUF_SIGNATURE    = EFI_SIGNATURE_32 ('n', 'b', 'u', 'f'),\r
  NET_VECTOR_SIGNATURE = EFI_SIGNATURE_32 ('n', 'v', 'e', 'c'),\r
  NET_QUE_SIGNATURE    = EFI_SIGNATURE_32 ('n', 'b', 'q', 'u'),\r
\r
\r
  NET_PROTO_DATA       = 64,   // Opaque buffer for protocols\r
  NET_BUF_HEAD         = 1,    // Trim or allocate space from head\r
  NET_BUF_TAIL         = 0,    // Trim or allocate space from tail\r
  NET_VECTOR_OWN_FIRST = 0x01  // We allocated the 1st block in the vector\r
} NET_SIGNATURE_TYPE;\r
\r
#define NET_CHECK_SIGNATURE(PData, SIGNATURE) \\r
  ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE)))\r
\r
#define NET_SWAP_SHORT(Value) \\r
  ((((Value) & 0xff) << 8) | (((Value) >> 8) & 0xff))\r
\r
//\r
// Single memory block in the vector.\r
//\r
typedef struct {\r
  UINT32              Len;        // The block's length\r
  UINT8               *Bulk;      // The block's Data\r
} NET_BLOCK;\r
\r
typedef VOID (*NET_VECTOR_EXT_FREE) (VOID *Arg);\r
\r
//\r
//NET_VECTOR contains several blocks to hold all packet's\r
//fragments and other house-keeping stuff for sharing. It\r
//doesn't specify the where actual packet fragment begins.\r
//\r
typedef struct {\r
  UINT32              Signature;\r
  INTN                RefCnt;  // Reference count to share NET_VECTOR.\r
  NET_VECTOR_EXT_FREE Free;    // external function to free NET_VECTOR\r
  VOID                *Arg;    // opeque argument to Free\r
  UINT32              Flag;    // Flags, NET_VECTOR_OWN_FIRST\r
  UINT32              Len;     // Total length of the assocated BLOCKs\r
\r
  UINT32              BlockNum;\r
  NET_BLOCK           Block[1];\r
} NET_VECTOR;\r
\r
//\r
//NET_BLOCK_OP operate on the NET_BLOCK, It specifies\r
//where the actual fragment begins and where it ends\r
//\r
typedef struct {\r
  UINT8               *BlockHead;   // Block's head, or the smallest valid Head\r
  UINT8               *BlockTail;   // Block's tail. BlockTail-BlockHead=block length\r
  UINT8               *Head;        // 1st byte of the data in the block\r
  UINT8               *Tail;        // Tail of the data in the block, Tail-Head=Size\r
  UINT32              Size;         // The size of the data\r
} NET_BLOCK_OP;\r
\r
\r
//\r
//NET_BUF is the buffer manage structure used by the\r
//network stack. Every network packet may be fragmented,\r
//and contains multiple fragments. The Vector points to\r
//memory blocks used by the each fragment, and BlockOp\r
//specifies where each fragment begins and ends.\r
//\r
//It also contains a opaque area for protocol to store\r
//per-packet informations. Protocol must be caution not\r
//to overwrite the members after that.\r
//\r
typedef struct {\r
  UINT32              Signature;\r
  INTN                RefCnt;\r
  LIST_ENTRY          List;       // The List this NET_BUF is on\r
\r
  IP4_HEAD            *Ip;        // Network layer header, for fast access\r
  TCP_HEAD            *Tcp;       // Transport layer header, for fast access\r
  UINT8               ProtoData [NET_PROTO_DATA]; //Protocol specific data\r
\r
  NET_VECTOR          *Vector;    // The vector containing the packet\r
\r
  UINT32              BlockOpNum; // Total number of BlockOp in the buffer\r
  UINT32              TotalSize;  // Total size of the actual packet\r
  NET_BLOCK_OP        BlockOp[1]; // Specify the position of actual packet\r
} NET_BUF;\r
\r
\r
//\r
//A queue of NET_BUFs, It is just a thin extension of\r
//NET_BUF functions.\r
//\r
typedef struct {\r
  UINT32              Signature;\r
  INTN                RefCnt;\r
  LIST_ENTRY          List;       // The List this buffer queue is on\r
\r
  LIST_ENTRY          BufList;    // list of queued buffers\r
  UINT32              BufSize;    // total length of DATA in the buffers\r
  UINT32              BufNum;     // total number of buffers on the chain\r
} NET_BUF_QUEUE;\r
\r
//\r
// Pseudo header for TCP and UDP checksum\r
//\r
#pragma pack(1)\r
typedef struct {\r
  IP4_ADDR            SrcIp;\r
  IP4_ADDR            DstIp;\r
  UINT8               Reserved;\r
  UINT8               Protocol;\r
  UINT16              Len;\r
} NET_PSEUDO_HDR;\r
#pragma pack()\r
\r
//\r
// The fragment entry table used in network interfaces. This is\r
// the same as NET_BLOCK now. Use two different to distinguish\r
// the two in case that NET_BLOCK be enhanced later.\r
//\r
typedef struct {\r
  UINT32              Len;\r
  UINT8               *Bulk;\r
} NET_FRAGMENT;\r
\r
#define NET_GET_REF(PData)      ((PData)->RefCnt++)\r
#define NET_PUT_REF(PData)      ((PData)->RefCnt--)\r
#define NETBUF_FROM_PROTODATA(Info) _CR((Info), NET_BUF, ProtoData)\r
\r
#define NET_BUF_SHARED(Buf) \\r
  (((Buf)->RefCnt > 1) || ((Buf)->Vector->RefCnt > 1))\r
\r
#define NET_VECTOR_SIZE(BlockNum) \\r
  (sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK))\r
\r
#define NET_BUF_SIZE(BlockOpNum)  \\r
  (sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP))\r
\r
#define NET_HEADSPACE(BlockOp)  \\r
  (UINTN)((BlockOp)->Head - (BlockOp)->BlockHead)\r
\r
#define NET_TAILSPACE(BlockOp)  \\r
  (UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail)\r
\r
/**\r
  Allocate a single block NET_BUF. Upon allocation, all the\r
  free space is in the tail room.\r
\r
  @param  Len                   The length of the block.\r
\r
  @retval *                     Pointer to the allocated NET_BUF. If NULL  the\r
                                allocation failed due to resource limit.\r
\r
**/\r
NET_BUF  *\r
EFIAPI\r
NetbufAlloc (\r
  IN UINT32                 Len\r
  );\r
\r
/**\r
  Free the buffer and its associated NET_VECTOR.\r
\r
  @param  Nbuf                  Pointer to the NET_BUF to be freed.\r
\r
  @return None.\r
\r
**/\r
VOID\r
EFIAPI\r
NetbufFree (\r
  IN NET_BUF                *Nbuf\r
  );\r
\r
/**\r
  Get the position of some byte in the net buffer. This can be used\r
  to, for example, retrieve the IP header in the packet. It also\r
  returns the fragment that contains the byte which is used mainly by\r
  the buffer implementation itself.\r
\r
  @param  Nbuf                  Pointer to the net buffer.\r
  @param  Offset                The index or offset of the byte\r
  @param  Index                 Index of the fragment that contains the block\r
\r
  @retval *                     Pointer to the nth byte of data in the net buffer.\r
                                If NULL, there is no such data in the net buffer.\r
\r
**/\r
UINT8  *\r
EFIAPI\r
NetbufGetByte (\r
  IN  NET_BUF               *Nbuf,\r
  IN  UINT32                Offset,\r
  OUT UINT32                *Index      OPTIONAL\r
  );\r
\r
/**\r
  Create a copy of NET_BUF that share the associated NET_DATA.\r
\r
  @param  Nbuf                  Pointer to the net buffer to be cloned.\r
\r
  @retval *                     Pointer to the cloned net buffer.\r
\r
**/\r
NET_BUF  *\r
EFIAPI\r
NetbufClone (\r
  IN NET_BUF                *Nbuf\r
  );\r
\r
/**\r
  Create a duplicated copy of Nbuf, data is copied. Also leave some\r
  head space before the data.\r
\r
  @param  Nbuf                  Pointer to the net buffer to be cloned.\r
  @param  Duplicate             Pointer to the net buffer to duplicate to, if NULL\r
                                a new net  buffer is allocated.\r
  @param  HeadSpace             Length of the head space to reserve\r
\r
  @retval *                     Pointer to the duplicated net buffer.\r
\r
**/\r
NET_BUF  *\r
EFIAPI\r
NetbufDuplicate (\r
  IN NET_BUF                *Nbuf,\r
  IN NET_BUF                *Duplicate    OPTIONAL,\r
  IN UINT32                 HeadSpace\r
  );\r
\r
/**\r
  Create a NET_BUF structure which contains Len byte data of\r
  Nbuf starting from Offset. A new NET_BUF structure will be\r
  created but the associated data in NET_VECTOR is shared.\r
  This function exists to do IP packet fragmentation.\r
\r
  @param  Nbuf                  Pointer to the net buffer to be cloned.\r
  @param  Offset                Starting point of the data to be included in new\r
                                buffer.\r
  @param  Len                   How many data to include in new data\r
  @param  HeadSpace             How many bytes of head space to reserve for\r
                                protocol header\r
\r
  @retval *                     Pointer to the cloned net buffer.\r
\r
**/\r
NET_BUF  *\r
EFIAPI\r
NetbufGetFragment (\r
  IN NET_BUF                *Nbuf,\r
  IN UINT32                 Offset,\r
  IN UINT32                 Len,\r
  IN UINT32                 HeadSpace\r
  );\r
\r
/**\r
  Reserve some space in the header room of the buffer.\r
  Upon allocation, all the space are in the tail room\r
  of the buffer. Call this function to move some space\r
  to the header room. This function is quite limited in\r
  that it can only reserver space from the first block\r
  of an empty NET_BUF not built from the external. But\r
  it should be enough for the network stack.\r
\r
  @param  Nbuf                  Pointer to the net buffer.\r
  @param  Len                   The length of buffer to be reserverd.\r
\r
  @return None.\r
\r
**/\r
VOID\r
EFIAPI\r
NetbufReserve (\r
  IN NET_BUF                *Nbuf,\r
  IN UINT32                 Len\r
  );\r
\r
/**\r
  Allocate some space from the header or tail of the buffer.\r
\r
  @param  Nbuf                  Pointer to the net buffer.\r
  @param  Len                   The length of the buffer to be allocated.\r
  @param  FromHead              The flag to indicate whether reserve the data from\r
                                head or tail. TRUE for from head, and FALSE for\r
                                from tail.\r
\r
  @retval *                     Pointer to the first byte of the allocated buffer.\r
\r
**/\r
UINT8  *\r
EFIAPI\r
NetbufAllocSpace (\r
  IN NET_BUF                *Nbuf,\r
  IN UINT32                 Len,\r
  IN BOOLEAN                FromHead\r
  );\r
\r
/**\r
  Trim some data from the header or tail of the buffer.\r
\r
  @param  Nbuf                  Pointer to the net buffer.\r
  @param  Len                   The length of the data to be trimmed.\r
  @param  FromHead              The flag to indicate whether trim data from head or\r
                                tail. TRUE for from head, and FALSE for from tail.\r
\r
  @retval UINTN                 Length of the actually trimmed data.\r
\r
**/\r
UINT32\r
EFIAPI\r
NetbufTrim (\r
  IN NET_BUF                *Nbuf,\r
  IN UINT32                 Len,\r
  IN BOOLEAN                FromHead\r
  );\r
\r
/**\r
  Copy the data from the specific offset to the destination.\r
\r
  @param  Nbuf                  Pointer to the net buffer.\r
  @param  Offset                The sequence number of the first byte to copy.\r
  @param  Len                   Length of the data to copy.\r
  @param  Dest                  The destination of the data to copy to.\r
\r
  @retval UINTN                 The length of the copied data.\r
\r
**/\r
UINT32\r
EFIAPI\r
NetbufCopy (\r
  IN NET_BUF                *Nbuf,\r
  IN UINT32                 Offset,\r
  IN UINT32                 Len,\r
  IN UINT8                  *Dest\r
  );\r
\r
/**\r
  Build a NET_BUF from external blocks.\r
\r
  @param  ExtFragment           Pointer to the data block.\r
  @param  ExtNum                The number of the data block.\r
  @param  HeadSpace             The head space to be reserved.\r
  @param  HeadLen               The length of the protocol header, This function\r
                                will pull that number of data into a linear block.\r
  @param  ExtFree               Pointer to the caller provided free function.\r
  @param  Arg                   The argument passed to ExtFree when ExtFree is\r
                                called.\r
\r
  @retval *                     Pointer to the net buffer built from the data\r
                                blocks.\r
\r
**/\r
NET_BUF  *\r
EFIAPI\r
NetbufFromExt (\r
  IN NET_FRAGMENT           *ExtFragment,\r
  IN UINT32                 ExtNum,\r
  IN UINT32                 HeadSpace,\r
  IN UINT32                 HeadLen,\r
  IN NET_VECTOR_EXT_FREE    ExtFree,\r
  IN VOID                   *Arg          OPTIONAL\r
  );\r
\r
/**\r
  Build a fragment table to contain the fragments in the\r
  buffer. This is the opposite of the NetbufFromExt.\r
\r
  @param  Nbuf                  Point to the net buffer\r
  @param  ExtFragment           Pointer to the data block.\r
  @param  ExtNum                The number of the data block.\r
\r
  @retval EFI_BUFFER_TOO_SMALL  The number of non-empty block is bigger than ExtNum\r
  @retval EFI_SUCCESS           Fragment table built.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
NetbufBuildExt (\r
  IN NET_BUF                *Nbuf,\r
  IN NET_FRAGMENT           *ExtFragment,\r
  IN UINT32                 *ExtNum\r
  );\r
\r
/**\r
  Build a NET_BUF from a list of NET_BUF.\r
\r
  @param  BufList               A List of NET_BUF.\r
  @param  HeadSpace             The head space to be reserved.\r
  @param  HeaderLen             The length of the protocol header, This function\r
                                will pull that number of data into a linear block.\r
  @param  ExtFree               Pointer to the caller provided free function.\r
  @param  Arg                   The argument passed to ExtFree when ExtFree is\r
                                called.\r
\r
  @retval *                     Pointer to the net buffer built from the data\r
                                blocks.\r
\r
**/\r
NET_BUF  *\r
EFIAPI\r
NetbufFromBufList (\r
  IN LIST_ENTRY             *BufList,\r
  IN UINT32                 HeadSpace,\r
  IN UINT32                 HeaderLen,\r
  IN NET_VECTOR_EXT_FREE    ExtFree,\r
  IN VOID                   *Arg                OPTIONAL\r
  );\r
\r
/**\r
  Free a list of net buffers.\r
\r
  @param  Head                  Pointer to the head of linked net buffers.\r
\r
  @return None.\r
\r
**/\r
VOID\r
EFIAPI\r
NetbufFreeList (\r
  IN LIST_ENTRY             *Head\r
  );\r
\r
/**\r
  Initiate the net buffer queue.\r
\r
  @param  NbufQue               Pointer to the net buffer queue to be initiated.\r
\r
  @return None.\r
\r
**/\r
VOID\r
EFIAPI\r
NetbufQueInit (\r
  IN NET_BUF_QUEUE          *NbufQue\r
  );\r
\r
/**\r
  Allocate an initialized net buffer queue.\r
\r
  None.\r
\r
  @retval *                     Pointer to the allocated net buffer queue.\r
\r
**/\r
NET_BUF_QUEUE  *\r
EFIAPI\r
NetbufQueAlloc (\r
  VOID\r
  );\r
\r
/**\r
  Free a net buffer queue.\r
\r
  @param  NbufQue               Poitner to the net buffer queue to be freed.\r
\r
  @return None.\r
\r
**/\r
VOID\r
EFIAPI\r
NetbufQueFree (\r
  IN NET_BUF_QUEUE          *NbufQue\r
  );\r
\r
/**\r
  Remove a net buffer from head in the specific queue.\r
\r
  @param  NbufQue               Pointer to the net buffer queue.\r
\r
  @retval *                     Pointer to the net buffer removed from the specific\r
                                queue.\r
\r
**/\r
NET_BUF  *\r
EFIAPI\r
NetbufQueRemove (\r
  IN NET_BUF_QUEUE          *NbufQue\r
  );\r
\r
/**\r
  Append a buffer to the end of the queue.\r
\r
  @param  NbufQue               Pointer to the net buffer queue.\r
  @param  Nbuf                  Pointer to the net buffer to be appended.\r
\r
  @return None.\r
\r
**/\r
VOID\r
EFIAPI\r
NetbufQueAppend (\r
  IN NET_BUF_QUEUE          *NbufQue,\r
  IN NET_BUF                *Nbuf\r
  );\r
\r
/**\r
  Copy some data from the buffer queue to the destination.\r
\r
  @param  NbufQue               Pointer to the net buffer queue.\r
  @param  Offset                The sequence number of the first byte to copy.\r
  @param  Len                   Length of the data to copy.\r
  @param  Dest                  The destination of the data to copy to.\r
\r
  @retval UINTN                 The length of the copied data.\r
\r
**/\r
UINT32\r
EFIAPI\r
NetbufQueCopy (\r
  IN NET_BUF_QUEUE          *NbufQue,\r
  IN UINT32                 Offset,\r
  IN UINT32                 Len,\r
  IN UINT8                  *Dest\r
  );\r
\r
/**\r
  Trim some data from the queue header, release the buffer if\r
  whole buffer is trimmed.\r
\r
  @param  NbufQue               Pointer to the net buffer queue.\r
  @param  Len                   Length of the data to trim.\r
\r
  @retval UINTN                 The length of the data trimmed.\r
\r
**/\r
UINT32\r
EFIAPI\r
NetbufQueTrim (\r
  IN NET_BUF_QUEUE          *NbufQue,\r
  IN UINT32                 Len\r
  );\r
\r
\r
/**\r
  Flush the net buffer queue.\r
\r
  @param  NbufQue               Pointer to the queue to be flushed.\r
\r
  @return None.\r
\r
**/\r
VOID\r
EFIAPI\r
NetbufQueFlush (\r
  IN NET_BUF_QUEUE          *NbufQue\r
  );\r
\r
/**\r
  Compute checksum for a bulk of data.\r
\r
  @param  Bulk                  Pointer to the data.\r
  @param  Len                   Length of the data, in bytes.\r
\r
  @retval UINT16                The computed checksum.\r
\r
**/\r
UINT16\r
EFIAPI\r
NetblockChecksum (\r
  IN UINT8                  *Bulk,\r
  IN UINT32                 Len\r
  );\r
\r
/**\r
  Add two checksums.\r
\r
  @param  Checksum1             The first checksum to be added.\r
  @param  Checksum2             The second checksum to be added.\r
\r
  @retval UINT16                The new checksum.\r
\r
**/\r
UINT16\r
EFIAPI\r
NetAddChecksum (\r
  IN UINT16                 Checksum1,\r
  IN UINT16                 Checksum2\r
  );\r
\r
/**\r
  Compute the checksum for a NET_BUF.\r
\r
  @param  Nbuf                  Pointer to the net buffer.\r
\r
  @retval UINT16                The computed checksum.\r
\r
**/\r
UINT16\r
EFIAPI\r
NetbufChecksum (\r
  IN NET_BUF                *Nbuf\r
  );\r
\r
/**\r
  Compute the checksum for TCP/UDP pseudo header.\r
  Src, Dst are in network byte order. and Len is\r
  in host byte order.\r
\r
  @param  Src                   The source address of the packet.\r
  @param  Dst                   The destination address of the packet.\r
  @param  Proto                 The protocol type of the packet.\r
  @param  Len                   The length of the packet.\r
\r
  @retval UINT16                The computed checksum.\r
\r
**/\r
UINT16\r
EFIAPI\r
NetPseudoHeadChecksum (\r
  IN IP4_ADDR               Src,\r
  IN IP4_ADDR               Dst,\r
  IN UINT8                  Proto,\r
  IN UINT16                 Len\r
  );\r
\r
#endif\r