1. Import NetLib, IpIoLib and UdpIoLib class definitions
authorvanjeff <vanjeff@6f19259b-4bc3-4df7-8a09-765794883524>
Mon, 23 Jul 2007 09:17:39 +0000 (09:17 +0000)
committervanjeff <vanjeff@6f19259b-4bc3-4df7-8a09-765794883524>
Mon, 23 Jul 2007 09:17:39 +0000 (09:17 +0000)
2. Import DxeNetLib, DxeIpIoLib and DxeUdpIoLib libraries instances
2. Port Ip4Config module

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3405 6f19259b-4bc3-4df7-8a09-765794883524

MdeModulePkg/Include/Library/IpIoLib.h [new file with mode: 0644]
MdeModulePkg/Include/Library/NetLib.h [new file with mode: 0644]
MdeModulePkg/Include/Library/UdpIoLib.h [new file with mode: 0644]
MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c [new file with mode: 0644]
MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf [new file with mode: 0644]
MdeModulePkg/Library/DxeNetLib/DxeNetLib.c [new file with mode: 0644]
MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf [new file with mode: 0644]
MdeModulePkg/Library/DxeNetLib/Netbuffer.c [new file with mode: 0644]
MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c [new file with mode: 0644]
MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf [new file with mode: 0644]
MdeModulePkg/MdeModulePkg.dsc

diff --git a/MdeModulePkg/Include/Library/IpIoLib.h b/MdeModulePkg/Include/Library/IpIoLib.h
new file mode 100644 (file)
index 0000000..15cfbf8
--- /dev/null
@@ -0,0 +1,255 @@
+/** @file
+
+Copyright (c) 2005 - 2007, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+Module Name:
+
+  IpIo.h
+
+Abstract:
+
+
+**/
+
+#ifndef _IP_IO_H_
+#define _IP_IO_H_
+
+#include <PiDxe.h>
+#include <Protocol/Ip4.h>\r
+#include <Library/IpIoLib.h>\r
+#include <Library/NetLib.h>
+
+//\r
+// type and code define for ICMP protocol error got\r
+// from IP\r
+//\r
+#define ICMP_TYPE_UNREACH              3\r
+#define ICMP_TYPE_TIMXCEED            11\r
+#define ICMP_TYPE_PARAMPROB            12\r
+#define ICMP_TYPE_SOURCEQUENCH         4\r
+\r
+#define ICMP_CODE_UNREACH_NET          0\r
+#define ICMP_CODE_UNREACH_HOST         1\r
+#define ICMP_CODE_UNREACH_PROTOCOL     2\r
+#define ICMP_CODE_UNREACH_PORT         3\r
+#define ICMP_CODE_UNREACH_NEEDFRAG     4\r
+#define ICMP_CODE_UNREACH_SRCFAIL      5\r
+#define ICMP_CODE_UNREACH_NET_UNKNOWN  6\r
+#define ICMP_CODE_UNREACH_HOST_UNKNOWN 7\r
+#define ICMP_CODE_UNREACH_ISOLATED     8\r
+#define ICMP_CODE_UNREACH_NET_PROHIB   9\r
+#define ICMP_CODE_UNREACH_HOST_PROHIB  10\r
+#define ICMP_CODE_UNREACH_TOSNET       11\r
+#define ICMP_CODE_UNREACH_TOSHOST      12\r
+\r
+//\r
+// this error will be delivered to the\r
+// listening transportation layer protocol\r
+// consuming IpIO\r
+//\r
+typedef enum {\r
+  ICMP_ERR_UNREACH_NET      = 0,\r
+  ICMP_ERR_UNREACH_HOST,\r
+  ICMP_ERR_UNREACH_PROTOCOL,\r
+  ICMP_ERR_UNREACH_PORT,\r
+  ICMP_ERR_MSGSIZE,\r
+  ICMP_ERR_UNREACH_SRCFAIL,\r
+  ICMP_ERR_TIMXCEED_INTRANS,\r
+  ICMP_ERR_TIMXCEED_REASS,\r
+  ICMP_ERR_QUENCH,\r
+  ICMP_ERR_PARAMPROB\r
+} ICMP_ERROR;\r
+\r
+typedef struct _ICMP_ERROR_INFO {\r
+  EFI_STATUS  Error;\r
+  BOOLEAN     IsHard;\r
+  BOOLEAN     Notify;\r
+} ICMP_ERROR_INFO;\r
+
+//
+// Driver Consumed Protocol Prototypes
+//
+//@MT:#include EFI_PROTOCOL_CONSUMER (Ip4)
+//@MT:#include EFI_PROTOCOL_CONSUMER (Udp4)
+
+#define EFI_IP4_HEADER_LEN(HdrPtr) ((HdrPtr)->HeaderLength << 2)
+
+extern EFI_IP4_CONFIG_DATA  mIpIoDefaultIpConfigData;
+
+typedef struct _EFI_NET_SESSION_DATA {
+  IP4_ADDR        Source;
+  IP4_ADDR        Dest;
+  EFI_IP4_HEADER  *IpHdr;
+} EFI_NET_SESSION_DATA;
+
+typedef
+VOID
+(*PKT_RCVD_NOTIFY) (
+  IN EFI_STATUS           Status,  // rcvd pkt result
+  IN ICMP_ERROR           IcmpErr, // if Status == EFI_ICMP_ERROR, this
+                                  // field is valid for user
+  IN EFI_NET_SESSION_DATA *NetSession, // the communication point
+  IN NET_BUF              *Pkt,    // packet received
+  IN VOID                 *Context // the Context provided by user for recive data
+  );
+
+typedef
+VOID
+(*PKT_SENT_NOTIFY) (
+  IN EFI_STATUS  Status,      // sent pkt result
+  IN VOID        *Context,    // the context provided by user for sending data
+  IN VOID        *Sender,     // the sender to be notified
+  IN VOID        *NotifyData  // sent pkt related data to notify
+  );
+
+typedef struct _IP_IO {
+
+  //
+  // the node used to link this IpIo to the active IpIo list.
+  //
+  NET_LIST_ENTRY                Entry;
+
+  // the list used to maintain the IP instance for different sending purpose.
+  //
+  NET_LIST_ENTRY                IpList;
+
+  //
+  // the ip instance consumed by this IP IO
+  //
+  EFI_HANDLE                    Controller;
+  EFI_HANDLE                    Image;
+  EFI_HANDLE                    ChildHandle;
+  EFI_IP4_PROTOCOL              *Ip;
+  BOOLEAN                       IsConfigured;
+
+  //
+  // some ip config data can be changed
+  //
+  UINT8                         Protocol;
+
+  //
+  // token and event used to get data from IP
+  //
+  EFI_IP4_COMPLETION_TOKEN      RcvToken;
+
+  //
+  // list entry used to link the token passed to IP_IO
+  //
+  NET_LIST_ENTRY                PendingSndList;
+
+  //
+  // User interface used to get notify from IP_IO
+  //
+  VOID                          *RcvdContext;
+  VOID                          *SndContext;
+  PKT_RCVD_NOTIFY               PktRcvdNotify;
+  PKT_SENT_NOTIFY               PktSentNotify;
+} IP_IO;
+
+typedef struct _IP_IO_OPEN_DATA {
+  EFI_IP4_CONFIG_DATA IpConfigData;
+  VOID                *RcvdContext;
+  VOID                *SndContext;
+  PKT_RCVD_NOTIFY     PktRcvdNotify;
+  PKT_SENT_NOTIFY     PktSentNotify;
+} IP_IO_OPEN_DATA;
+
+typedef struct _IP_IO_SEND_ENTRY {
+  NET_LIST_ENTRY            Entry;
+  IP_IO                     *IpIo;
+  VOID                      *Context;
+  VOID                      *NotifyData;
+  EFI_IP4_PROTOCOL          *Ip;
+  NET_BUF                   *Pkt;
+  EFI_IP4_COMPLETION_TOKEN  *SndToken;
+} IP_IO_SEND_ENTRY;
+
+typedef struct _EFI_IP4_OVERRIDE_DATA IP_IO_OVERRIDE;
+
+typedef struct _IP_IO_IP_INFO {
+  IP4_ADDR                  Addr;
+  IP4_ADDR                  SubnetMask;
+  NET_LIST_ENTRY            Entry;
+  EFI_HANDLE                ChildHandle;
+  EFI_IP4_PROTOCOL          *Ip;
+  EFI_IP4_COMPLETION_TOKEN  DummyRcvToken;
+  INTN                      RefCnt;
+} IP_IO_IP_INFO;
+
+IP_IO *
+IpIoCreate (
+  IN EFI_HANDLE Image,
+  IN EFI_HANDLE Controller
+  );
+
+EFI_STATUS
+IpIoDestroy (
+  IN IP_IO *IpIo
+  );
+
+EFI_STATUS
+IpIoStop (
+  IN IP_IO *IpIo
+  );
+
+EFI_STATUS
+IpIoOpen (
+  IN IP_IO           *IpIo,
+  IN IP_IO_OPEN_DATA *OpenData
+  );
+
+EFI_STATUS
+IpIoSend (
+  IN IP_IO           *IpIo,
+  IN NET_BUF         *Pkt,
+  IN IP_IO_IP_INFO   *Sender,
+  IN VOID            *Context    OPTIONAL,
+  IN VOID            *NotifyData OPTIONAL,
+  IN IP4_ADDR        Dest,
+  IN IP_IO_OVERRIDE  *OverrideData
+  );
+
+VOID
+IpIoCancelTxToken (
+  IN IP_IO  *IpIo,
+  IN VOID   *Packet
+  );
+
+IP_IO_IP_INFO *
+IpIoAddIp (
+  IN IP_IO  *IpIo
+  );
+
+EFI_STATUS
+IpIoConfigIp (
+  IN     IP_IO_IP_INFO        *IpInfo,
+  IN OUT EFI_IP4_CONFIG_DATA  *Ip4ConfigData OPTIONAL
+  );
+
+VOID
+IpIoRemoveIp (
+  IN IP_IO            *IpIo,
+  IN IP_IO_IP_INFO    *IpInfo
+  );
+
+IP_IO_IP_INFO *
+IpIoFindSender (
+  IN OUT IP_IO     **IpIo,
+  IN     IP4_ADDR  Src
+  );
+
+EFI_STATUS
+IpIoGetIcmpErrStatus (
+  IN  ICMP_ERROR  IcmpError,
+  OUT BOOLEAN     *IsHard, OPTIONAL
+  OUT BOOLEAN     *Notify OPTIONAL
+  );
+
+#endif
diff --git a/MdeModulePkg/Include/Library/NetLib.h b/MdeModulePkg/Include/Library/NetLib.h
new file mode 100644 (file)
index 0000000..215a2fb
--- /dev/null
@@ -0,0 +1,812 @@
+/** @file
+
+Copyright (c) 2005 - 2007, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+Module Name:
+
+  NetLib.h
+
+Abstract:
+
+  Library for the UEFI network stack.
+
+
+**/
+
+#ifndef _NET_LIB_H_
+#define _NET_LIB_H_
+
+#include <PiDxe.h>
+#include <Protocol/DriverBinding.h>
+#include <Protocol/ComponentName.h>
+#include <Protocol/DriverConfiguration.h>
+#include <Protocol/DriverDiagnostics.h>
+
+#define EFI_NET_LITTLE_ENDIAN
+
+typedef UINT32          IP4_ADDR;
+typedef UINT32          TCP_SEQNO;
+typedef UINT16          TCP_PORTNO;
+
+enum {
+  NET_ETHER_ADDR_LEN    = 6,
+  NET_IFTYPE_ETHERNET   = 0x01,
+
+  EFI_IP_PROTO_UDP      = 0x11,
+  EFI_IP_PROTO_TCP      = 0x06,
+  EFI_IP_PROTO_ICMP     = 0x01,
+
+  //
+  // The address classfication
+  //
+  IP4_ADDR_CLASSA       = 1,
+  IP4_ADDR_CLASSB,
+  IP4_ADDR_CLASSC,
+  IP4_ADDR_CLASSD,
+  IP4_ADDR_CLASSE,
+
+  IP4_MASK_NUM          = 33,
+};
+
+#pragma pack(1)
+
+//
+// Ethernet head definition
+//
+typedef struct {
+  UINT8                 DstMac [NET_ETHER_ADDR_LEN];
+  UINT8                 SrcMac [NET_ETHER_ADDR_LEN];
+  UINT16                EtherType;
+} ETHER_HEAD;
+
+
+//
+// The EFI_IP4_HEADER is hard to use because the source and
+// destination address are defined as EFI_IPv4_ADDRESS, which
+// is a structure. Two structures can't be compared or masked
+// directly. This is why there is an internal representation.
+//
+typedef struct {
+#ifdef EFI_NET_LITTLE_ENDIAN
+  UINT8                 HeadLen : 4;
+  UINT8                 Ver     : 4;
+#else
+  UINT8                 Ver     : 4;
+  UINT8                 HeadLen : 4;
+#endif
+  UINT8                 Tos;
+  UINT16                TotalLen;
+  UINT16                Id;
+  UINT16                Fragment;
+  UINT8                 Ttl;
+  UINT8                 Protocol;
+  UINT16                Checksum;
+  IP4_ADDR              Src;
+  IP4_ADDR              Dst;
+} IP4_HEAD;
+
+
+//
+// ICMP head definition. ICMP message is categoried as either an error
+// message or query message. Two message types have their own head format.
+//
+typedef struct {
+  UINT8                 Type;
+  UINT8                 Code;
+  UINT16                Checksum;
+} IP4_ICMP_HEAD;
+
+typedef struct {
+  IP4_ICMP_HEAD         Head;
+  UINT32                Fourth; // 4th filed of the head, it depends on Type.
+  IP4_HEAD              IpHead;
+} IP4_ICMP_ERROR_HEAD;
+
+typedef struct {
+  IP4_ICMP_HEAD         Head;
+  UINT16                Id;
+  UINT16                Seq;
+} IP4_ICMP_QUERY_HEAD;
+
+
+//
+// UDP header definition
+//
+typedef struct {
+  UINT16                SrcPort;
+  UINT16                DstPort;
+  UINT16                Length;
+  UINT16                Checksum;
+} EFI_UDP4_HEADER;
+
+
+//
+// TCP header definition
+//
+typedef struct {
+  TCP_PORTNO            SrcPort;
+  TCP_PORTNO            DstPort;
+  TCP_SEQNO             Seq;
+  TCP_SEQNO             Ack;
+#ifdef EFI_NET_LITTLE_ENDIAN
+  UINT8                 Res     : 4;
+  UINT8                 HeadLen : 4;
+#else
+  UINT8                 HeadLen : 4;
+  UINT8                 Res     : 4;
+#endif
+  UINT8                 Flag;
+  UINT16                Wnd;
+  UINT16                Checksum;
+  UINT16                Urg;
+} TCP_HEAD;
+
+#pragma pack()
+
+#define NET_MAC_EQUAL(pMac1, pMac2, Len)     \
+    (NetCompareMem ((pMac1), (pMac2), Len) == 0)
+
+#define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \
+    (((*((UINT8 *) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len)))
+
+#ifdef EFI_NET_LITTLE_ENDIAN
+#define NTOHL(x) (UINT32)((((UINT32) (x) & 0xff)     << 24) | \
+                          (((UINT32) (x) & 0xff00)   << 8)  | \
+                          (((UINT32) (x) & 0xff0000) >> 8)  | \
+                          (((UINT32) (x) & 0xff000000) >> 24))
+
+#define HTONL(x)  NTOHL(x)
+
+#define NTOHS(x)  (UINT16)((((UINT16) (x) & 0xff) << 8) | \
+                           (((UINT16) (x) & 0xff00) >> 8))
+
+#define HTONS(x)  NTOHS(x)
+#else
+#define NTOHL(x)  (UINT32)(x)
+#define HTONL(x)  (UINT32)(x)
+#define NTOHS(x)  (UINT16)(x)
+#define HTONS(x)  (UINT16)(x)
+#endif
+
+//
+// Test the IP's attribute, All the IPs are in host byte order.
+//
+#define IP4_IS_MULTICAST(Ip)              (((Ip) & 0xF0000000) == 0xE0000000)
+#define IP4_IS_LOCAL_BROADCAST(Ip)        ((Ip) == 0xFFFFFFFF)
+#define IP4_NET_EQUAL(Ip1, Ip2, NetMask)  (((Ip1) & (NetMask)) == ((Ip2) & (NetMask)))
+#define IP4_IS_VALID_NETMASK(Ip)          (NetGetMaskLength (Ip) != IP4_MASK_NUM)
+
+//
+// Convert the EFI_IP4_ADDRESS to plain UINT32 IP4 address.
+//
+#define EFI_IP4(EfiIpAddr)                (*(IP4_ADDR *) ((EfiIpAddr).Addr))
+#define EFI_NTOHL(EfiIp)                  (NTOHL (EFI_IP4 ((EfiIp))))
+#define EFI_IP_EQUAL(Ip1, Ip2)            (EFI_IP4 (Ip1) == EFI_IP4 (Ip2))
+
+INTN
+NetGetMaskLength (
+  IN IP4_ADDR               Mask
+  );
+
+INTN
+NetGetIpClass (
+  IN IP4_ADDR               Addr
+  );
+
+BOOLEAN
+Ip4IsUnicast (
+  IN IP4_ADDR               Ip,
+  IN IP4_ADDR               NetMask
+  );
+
+extern IP4_ADDR mIp4AllMasks [IP4_MASK_NUM];
+
+//@MT:#include EFI_PROTOCOL_CONSUMER (LoadedImage)
+//@MT:#include EFI_PROTOCOL_CONSUMER (ServiceBinding)
+//@MT:#include EFI_PROTOCOL_CONSUMER (SimpleNetwork)
+
+//
+// Wrap functions to ease the impact of EFI library changes.
+//
+#define NetAllocateZeroPool     AllocateZeroPool
+#define NetAllocatePool         AllocatePool
+#define NetFreePool             gBS->FreePool
+#define NetCopyMem              CopyMem
+#define NetSetMem               SetMem
+#define NetZeroMem(Dest, Len)   SetMem ((Dest), (Len), 0)
+#define NetCompareMem           CompareMem
+
+//
+// Lock primitives: the stack implements its lock primitives according
+// to the standard EFI enviornment. It will NOT consider multiprocessor.
+//
+#define NET_TPL_LOCK            TPL_CALLBACK
+#define NET_TPL_RECYCLE_LOCK    (NET_TPL_LOCK + 1)
+#define NET_TPL_EVENT           TPL_CALLBACK
+#define NET_TPL_RECYCLE         (NET_TPL_LOCK + 1)
+#define NET_TPL_SLOW_TIMER      (TPL_CALLBACK - 1)
+#define NET_TPL_FAST_TIMER      NET_TPL_RECYCLE
+#define NET_TPL_TIMER           TPL_CALLBACK
+
+#define NET_LOCK                 EFI_LOCK
+#define NET_LOCK_INIT(x)         EfiInitializeLock (x, NET_TPL_LOCK)
+#define NET_RECYCLE_LOCK_INIT(x) EfiInitializeLock (x, NET_TPL_RECYCLE_LOCK)
+#define NET_TRYLOCK(x)           EfiAcquireLockOrFail (x)
+#define NET_UNLOCK(x)            EfiReleaseLock (x)
+
+#define NET_RAISE_TPL(x)        (gBS->RaiseTPL (x))
+#define NET_RESTORE_TPL(x)      (gBS->RestoreTPL (x))
+
+#define TICKS_PER_MS            10000U
+#define TICKS_PER_SECOND        10000000U
+
+#define NET_MIN(a, b)           ((a) < (b) ? (a) : (b))
+#define NET_MAX(a, b)           ((a) > (b) ? (a) : (b))
+#define NET_RANDOM(Seed)        (((Seed) * 1103515245L + 12345) % 4294967295L)
+
+
+UINT32
+NetGetUint32 (
+  IN UINT8                  *Buf
+  );
+
+VOID
+NetPutUint32 (
+  IN UINT8                  *Buf,
+  IN UINT32                 Data
+  );
+
+UINT32
+NetRandomInitSeed (
+  VOID
+  );
+
+
+//
+// Double linked list entry functions, this extends the
+// EFI list functions.
+//
+typedef LIST_ENTRY      NET_LIST_ENTRY;
+
+#define NetListInit(Head)              InitializeListHead(Head)
+#define NetListInsertHead(Head, Entry) InsertHeadList((Head), (Entry))
+#define NetListInsertTail(Head, Entry) InsertTailList((Head), (Entry))
+#define NetListIsEmpty(List)           IsListEmpty(List)
+
+#define NET_LIST_USER_STRUCT(Entry, Type, Field)        \
+          _CR(Entry, Type, Field)
+
+#define NET_LIST_USER_STRUCT_S(Entry, Type, Field, Sig)  \
+          CR(Entry, Type, Field, Sig)
+
+//
+// Iterate through the doule linked list. It is NOT delete safe
+//
+#define NET_LIST_FOR_EACH(Entry, ListHead) \
+  for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink)
+
+//
+// Iterate through the doule linked list. This is delete-safe.
+// Don't touch NextEntry. Also, don't use this macro if list
+// entries other than the Entry may be deleted when processing
+// the current Entry.
+//
+#define NET_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \
+  for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink; \
+      Entry != (ListHead); \
+      Entry = NextEntry, NextEntry = Entry->ForwardLink \
+     )
+
+//
+// Make sure the list isn't empty before get the frist/last record.
+//
+#define NET_LIST_HEAD(ListHead, Type, Field)  \
+          NET_LIST_USER_STRUCT((ListHead)->ForwardLink, Type, Field)
+
+#define NET_LIST_TAIL(ListHead, Type, Field)  \
+          NET_LIST_USER_STRUCT((ListHead)->BackLink, Type, Field)
+
+#define NetListRemoveEntry(Entry) RemoveEntryList (Entry)
+
+NET_LIST_ENTRY*
+NetListRemoveHead (
+  NET_LIST_ENTRY            *Head
+  );
+
+NET_LIST_ENTRY*
+NetListRemoveTail (
+  NET_LIST_ENTRY            *Head
+  );
+
+VOID
+NetListInsertAfter (
+  IN NET_LIST_ENTRY         *PrevEntry,
+  IN NET_LIST_ENTRY         *NewEntry
+  );
+
+VOID
+NetListInsertBefore (
+  IN NET_LIST_ENTRY         *PostEntry,
+  IN NET_LIST_ENTRY         *NewEntry
+  );
+
+
+//
+// Object container: EFI network stack spec defines various kinds of
+// tokens. The drivers can share code to manage those objects.
+//
+typedef struct {
+  NET_LIST_ENTRY            Link;
+  VOID                      *Key;
+  VOID                      *Value;
+} NET_MAP_ITEM;
+
+typedef struct {
+  NET_LIST_ENTRY            Used;
+  NET_LIST_ENTRY            Recycled;
+  UINTN                     Count;
+} NET_MAP;
+
+#define NET_MAP_INCREAMENT  64
+
+VOID
+NetMapInit (
+  IN NET_MAP                *Map
+  );
+
+VOID
+NetMapClean (
+  IN NET_MAP                *Map
+  );
+
+BOOLEAN
+NetMapIsEmpty (
+  IN NET_MAP                *Map
+  );
+
+UINTN
+NetMapGetCount (
+  IN NET_MAP                *Map
+  );
+
+EFI_STATUS
+NetMapInsertHead (
+  IN NET_MAP                *Map,
+  IN VOID                   *Key,
+  IN VOID                   *Value    OPTIONAL
+  );
+
+EFI_STATUS
+NetMapInsertTail (
+  IN NET_MAP                *Map,
+  IN VOID                   *Key,
+  IN VOID                   *Value    OPTIONAL
+  );
+
+NET_MAP_ITEM  *
+NetMapFindKey (
+  IN  NET_MAP               *Map,
+  IN  VOID                  *Key
+  );
+
+VOID *
+NetMapRemoveItem (
+  IN  NET_MAP               *Map,
+  IN  NET_MAP_ITEM          *Item,
+  OUT VOID                  **Value   OPTIONAL
+  );
+
+VOID *
+NetMapRemoveHead (
+  IN  NET_MAP               *Map,
+  OUT VOID                  **Value   OPTIONAL
+  );
+
+VOID *
+NetMapRemoveTail (
+  IN  NET_MAP               *Map,
+  OUT VOID                  **Value OPTIONAL
+  );
+
+typedef
+EFI_STATUS
+(*NET_MAP_CALLBACK) (
+  IN NET_MAP                *Map,
+  IN NET_MAP_ITEM           *Item,
+  IN VOID                   *Arg
+  );
+
+EFI_STATUS
+NetMapIterate (
+  IN NET_MAP                *Map,
+  IN NET_MAP_CALLBACK       CallBack,
+  IN VOID                   *Arg      OPTIONAL
+  );
+
+
+//
+// Helper functions to implement driver binding and service binding protocols.
+//
+EFI_STATUS
+NetLibCreateServiceChild (
+  IN  EFI_HANDLE            ControllerHandle,
+  IN  EFI_HANDLE            ImageHandle,
+  IN  EFI_GUID              *ServiceBindingGuid,
+  OUT EFI_HANDLE            *ChildHandle
+  );
+
+EFI_STATUS
+NetLibDestroyServiceChild (
+  IN  EFI_HANDLE            ControllerHandle,
+  IN  EFI_HANDLE            ImageHandle,
+  IN  EFI_GUID              *ServiceBindingGuid,
+  IN  EFI_HANDLE            ChildHandle
+  );
+
+EFI_STATUS
+NetLibGetMacString (
+  IN           EFI_HANDLE  SnpHandle,
+  IN           EFI_HANDLE  ImageHandle,
+  IN OUT CONST CHAR16      **MacString
+  );
+
+EFI_HANDLE
+NetLibGetNicHandle (
+  IN EFI_HANDLE             Controller,
+  IN EFI_GUID               *ProtocolGuid
+  );
+
+typedef
+EFI_STATUS
+(EFIAPI *NET_LIB_DRIVER_UNLOAD) (
+  IN EFI_HANDLE             ImageHandle
+  );
+
+EFI_STATUS
+EFIAPI
+NetLibDefaultUnload (
+  IN EFI_HANDLE             ImageHandle
+  );
+
+EFI_STATUS
+NetLibInstallAllDriverProtocolsWithUnload (
+  IN EFI_HANDLE                         ImageHandle,
+  IN EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL        *DriverBinding,
+  IN EFI_HANDLE                         DriverBindingHandle,
+  IN EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
+  IN EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration, OPTIONAL
+  IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics, OPTIONAL
+  IN NET_LIB_DRIVER_UNLOAD              CustomizedUnload
+  );
+
+EFI_STATUS
+NetLibInstallAllDriverProtocols (
+  IN EFI_HANDLE                         ImageHandle,
+  IN EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL        *DriverBinding,
+  IN EFI_HANDLE                         DriverBindingHandle,
+  IN EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
+  IN EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration, OPTIONAL
+  IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics OPTIONAL
+  );
+\r
+enum {
+  //
+  //Various signatures
+  //
+  NET_BUF_SIGNATURE    = EFI_SIGNATURE_32 ('n', 'b', 'u', 'f'),
+  NET_VECTOR_SIGNATURE = EFI_SIGNATURE_32 ('n', 'v', 'e', 'c'),
+  NET_QUE_SIGNATURE    = EFI_SIGNATURE_32 ('n', 'b', 'q', 'u'),
+
+
+  NET_PROTO_DATA       = 64,   // Opaque buffer for protocols
+  NET_BUF_HEAD         = 1,    // Trim or allocate space from head
+  NET_BUF_TAIL         = 0,    // Trim or allocate space from tail
+  NET_VECTOR_OWN_FIRST = 0x01, // We allocated the 1st block in the vector
+};
+
+#define NET_CHECK_SIGNATURE(PData, SIGNATURE) \
+  ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE)))
+
+#define NET_SWAP_SHORT(Value) \
+  ((((Value) & 0xff) << 8) | (((Value) >> 8) & 0xff))
+
+//
+// Single memory block in the vector.
+//
+typedef struct {
+  UINT32              Len;        // The block's length
+  UINT8               *Bulk;      // The block's Data
+} NET_BLOCK;
+
+typedef VOID (*NET_VECTOR_EXT_FREE) (VOID *Arg);
+
+//
+//NET_VECTOR contains several blocks to hold all packet's
+//fragments and other house-keeping stuff for sharing. It
+//doesn't specify the where actual packet fragment begins.
+//
+typedef struct {
+  UINT32              Signature;
+  INTN                RefCnt;  // Reference count to share NET_VECTOR.
+  NET_VECTOR_EXT_FREE Free;    // external function to free NET_VECTOR
+  VOID                *Arg;    // opeque argument to Free
+  UINT32              Flag;    // Flags, NET_VECTOR_OWN_FIRST
+  UINT32              Len;     // Total length of the assocated BLOCKs
+
+  UINT32              BlockNum;
+  NET_BLOCK           Block[1];
+} NET_VECTOR;
+
+//
+//NET_BLOCK_OP operate on the NET_BLOCK, It specifies
+//where the actual fragment begins and where it ends
+//
+typedef struct {
+  UINT8               *BlockHead;   // Block's head, or the smallest valid Head
+  UINT8               *BlockTail;   // Block's tail. BlockTail-BlockHead=block length
+  UINT8               *Head;        // 1st byte of the data in the block
+  UINT8               *Tail;        // Tail of the data in the block, Tail-Head=Size
+  UINT32              Size;         // The size of the data
+} NET_BLOCK_OP;
+
+
+//
+//NET_BUF is the buffer manage structure used by the
+//network stack. Every network packet may be fragmented,
+//and contains multiple fragments. The Vector points to
+//memory blocks used by the each fragment, and BlockOp
+//specifies where each fragment begins and ends.
+//
+//It also contains a opaque area for protocol to store
+//per-packet informations. Protocol must be caution not
+//to overwrite the members after that.
+//
+typedef struct {
+  UINT32              Signature;
+  INTN                RefCnt;
+  NET_LIST_ENTRY      List;       // The List this NET_BUF is on
+
+  IP4_HEAD            *Ip;        // Network layer header, for fast access
+  TCP_HEAD            *Tcp;       // Transport layer header, for fast access
+  UINT8               ProtoData [NET_PROTO_DATA]; //Protocol specific data
+
+  NET_VECTOR          *Vector;    // The vector containing the packet
+
+  UINT32              BlockOpNum; // Total number of BlockOp in the buffer
+  UINT32              TotalSize;  // Total size of the actual packet
+  NET_BLOCK_OP        BlockOp[1]; // Specify the position of actual packet
+} NET_BUF;
+
+
+//
+//A queue of NET_BUFs, It is just a thin extension of
+//NET_BUF functions.
+//
+typedef struct {
+  UINT32              Signature;
+  INTN                RefCnt;
+  NET_LIST_ENTRY      List;       // The List this buffer queue is on
+
+  NET_LIST_ENTRY      BufList;    // list of queued buffers
+  UINT32              BufSize;    // total length of DATA in the buffers
+  UINT32              BufNum;     // total number of buffers on the chain
+} NET_BUF_QUEUE;
+
+//
+// Pseudo header for TCP and UDP checksum
+//
+#pragma pack(1)
+typedef struct {
+  IP4_ADDR            SrcIp;
+  IP4_ADDR            DstIp;
+  UINT8               Reserved;
+  UINT8               Protocol;
+  UINT16              Len;
+} NET_PSEUDO_HDR;
+#pragma pack()
+
+//
+// The fragment entry table used in network interfaces. This is
+// the same as NET_BLOCK now. Use two different to distinguish
+// the two in case that NET_BLOCK be enhanced later.
+//
+typedef struct {
+  UINT32              Len;
+  UINT8               *Bulk;
+} NET_FRAGMENT;
+
+#define NET_GET_REF(PData)      ((PData)->RefCnt++)
+#define NET_PUT_REF(PData)      ((PData)->RefCnt--)
+#define NETBUF_FROM_PROTODATA(Info) _CR((Info), NET_BUF, ProtoData)
+
+#define NET_BUF_SHARED(Buf) \
+  (((Buf)->RefCnt > 1) || ((Buf)->Vector->RefCnt > 1))
+
+#define NET_VECTOR_SIZE(BlockNum) \
+  (sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK))
+
+#define NET_BUF_SIZE(BlockOpNum)  \
+  (sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP))
+
+#define NET_HEADSPACE(BlockOp)  \
+  (UINTN)((BlockOp)->Head - (BlockOp)->BlockHead)
+
+#define NET_TAILSPACE(BlockOp)  \
+  (UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail)
+
+NET_BUF  *
+NetbufAlloc (
+  IN UINT32                 Len
+  );
+
+VOID
+NetbufFree (
+  IN NET_BUF                *Nbuf
+  );
+
+
+UINT8  *
+NetbufGetByte (
+  IN  NET_BUF               *Nbuf,
+  IN  UINT32                Offset,
+  OUT UINT32                *Index      OPTIONAL
+  );
+
+NET_BUF  *
+NetbufClone (
+  IN NET_BUF                *Nbuf
+  );
+
+NET_BUF  *
+NetbufDuplicate (
+  IN NET_BUF                *Nbuf,
+  IN NET_BUF                *Duplicate    OPTIONAL,
+  IN UINT32                 HeadSpace
+  );
+
+NET_BUF  *
+NetbufGetFragment (
+  IN NET_BUF                *Nbuf,
+  IN UINT32                 Offset,
+  IN UINT32                 Len,
+  IN UINT32                 HeadSpace
+  );
+
+VOID
+NetbufReserve (
+  IN NET_BUF                *Nbuf,
+  IN UINT32                 Len
+  );
+
+UINT8  *
+NetbufAllocSpace (
+  IN NET_BUF                *Nbuf,
+  IN UINT32                 Len,
+  IN BOOLEAN                FromHead
+  );
+
+UINT32
+NetbufTrim (
+  IN NET_BUF                *Nbuf,
+  IN UINT32                 Len,
+  IN BOOLEAN                FromHead
+  );
+
+UINT32
+NetbufCopy (
+  IN NET_BUF                *Nbuf,
+  IN UINT32                 Offset,
+  IN UINT32                 Len,
+  IN UINT8                  *Dest
+  );
+
+NET_BUF  *
+NetbufFromExt (
+  IN NET_FRAGMENT           *ExtFragment,
+  IN UINT32                 ExtNum,
+  IN UINT32                 HeadSpace,
+  IN UINT32                 HeadLen,
+  IN NET_VECTOR_EXT_FREE    ExtFree,
+  IN VOID                   *Arg          OPTIONAL
+  );
+
+EFI_STATUS
+NetbufBuildExt (
+  IN NET_BUF                *Nbuf,
+  IN NET_FRAGMENT           *ExtFragment,
+  IN UINT32                 *ExtNum
+  );
+
+NET_BUF  *
+NetbufFromBufList (
+  IN NET_LIST_ENTRY         *BufList,
+  IN UINT32                 HeadSpace,
+  IN UINT32                 HeaderLen,
+  IN NET_VECTOR_EXT_FREE    ExtFree,
+  IN VOID                   *Arg                OPTIONAL
+  );
+
+VOID
+NetbufFreeList (
+  IN NET_LIST_ENTRY         *Head
+  );
+
+VOID
+NetbufQueInit (
+  IN NET_BUF_QUEUE          *NbufQue
+  );
+
+NET_BUF_QUEUE  *
+NetbufQueAlloc (
+  VOID
+  );
+
+VOID
+NetbufQueFree (
+  IN NET_BUF_QUEUE          *NbufQue
+  );
+
+NET_BUF  *
+NetbufQueRemove (
+  IN NET_BUF_QUEUE          *NbufQue
+  );
+
+VOID
+NetbufQueAppend (
+  IN NET_BUF_QUEUE          *NbufQue,
+  IN NET_BUF                *Nbuf
+  );
+
+UINT32
+NetbufQueCopy (
+  IN NET_BUF_QUEUE          *NbufQue,
+  IN UINT32                 Offset,
+  IN UINT32                 Len,
+  IN UINT8                  *Dest
+  );
+
+UINT32
+NetbufQueTrim (
+  IN NET_BUF_QUEUE          *NbufQue,
+  IN UINT32                 Len
+  );
+
+VOID
+NetbufQueFlush (
+  IN NET_BUF_QUEUE          *NbufQue
+  );
+
+UINT16
+NetblockChecksum (
+  IN UINT8                  *Bulk,
+  IN UINT32                 Len
+  );
+
+UINT16
+NetAddChecksum (
+  IN UINT16                 Checksum1,
+  IN UINT16                 Checksum2
+  );
+
+UINT16
+NetbufChecksum (
+  IN NET_BUF                *Nbuf
+  );
+
+UINT16
+NetPseudoHeadChecksum (
+  IN IP4_ADDR               Src,
+  IN IP4_ADDR               Dst,
+  IN UINT8                  Proto,
+  IN UINT16                 Len
+  );
+#endif
diff --git a/MdeModulePkg/Include/Library/UdpIoLib.h b/MdeModulePkg/Include/Library/UdpIoLib.h
new file mode 100644 (file)
index 0000000..3f49cc9
--- /dev/null
@@ -0,0 +1,177 @@
+/** @file
+
+Copyright (c) 2006, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+
+Module Name:
+
+  Udp4Io.h
+
+Abstract:
+
+  The helper routines to access UDP service. It is used by both
+  DHCP and MTFTP.
+
+
+**/
+
+#ifndef _UDP4IO_H_
+#define _UDP4IO_H_
+
+#include <PiDxe.h>\r
+\r
+#include <Protocol/Udp4.h>\r
+\r
+#include <Library/UdpIoLib.h>
+#include <Library/NetLib.h>
+
+typedef struct _UDP_IO_PORT UDP_IO_PORT;
+
+enum {
+  UDP_IO_RX_SIGNATURE = EFI_SIGNATURE_32 ('U', 'D', 'P', 'R'),
+  UDP_IO_TX_SIGNATURE = EFI_SIGNATURE_32 ('U', 'D', 'P', 'T'),
+  UDP_IO_SIGNATURE    = EFI_SIGNATURE_32 ('U', 'D', 'P', 'I'),
+};
+
+typedef struct {
+  IP4_ADDR                  LocalAddr;
+  UINT16                    LocalPort;
+  IP4_ADDR                  RemoteAddr;
+  UINT16                    RemotePort;
+} UDP_POINTS;
+
+//
+// This prototype is used by both receive and transmission.
+// When receiving Netbuf is allocated by UDP access point, and
+// released by user. When transmitting, the NetBuf is from user,
+// and provided to the callback as a reference.
+//
+typedef
+VOID
+(*UDP_IO_CALLBACK) (
+  IN NET_BUF                *Packet,
+  IN UDP_POINTS             *Points,
+  IN EFI_STATUS             IoStatus,
+  IN VOID                   *Context
+  );
+
+//
+// Each receive request is wrapped in an UDP_RX_TOKEN. Upon completion,
+// the CallBack will be called. Only one receive request is send to UDP.
+// HeadLen gives the length of the application's header. UDP_IO will
+// make the application's header continous before delivery up.
+//
+typedef struct {
+  UINT32                    Signature;
+  UDP_IO_PORT               *UdpIo;
+
+  UDP_IO_CALLBACK           CallBack;
+  VOID                      *Context;
+
+  UINT32                    HeadLen;
+  EFI_UDP4_COMPLETION_TOKEN UdpToken;
+} UDP_RX_TOKEN;
+
+//
+// Each transmit request is wrapped in an UDP_TX_TOKEN. Upon completion,
+// the CallBack will be called. There can be several transmit requests.
+//
+typedef struct {
+  UINT32                    Signature;
+  NET_LIST_ENTRY            Link;
+  UDP_IO_PORT               *UdpIo;
+
+  UDP_IO_CALLBACK           CallBack;
+  NET_BUF                   *Packet;
+  VOID                      *Context;
+
+  EFI_UDP4_SESSION_DATA     UdpSession;
+  EFI_IPv4_ADDRESS          Gateway;
+
+  EFI_UDP4_COMPLETION_TOKEN UdpToken;
+  EFI_UDP4_TRANSMIT_DATA    UdpTxData;
+} UDP_TX_TOKEN;
+
+typedef struct _UDP_IO_PORT {
+  UINT32                    Signature;
+  NET_LIST_ENTRY            Link;
+  INTN                      RefCnt;
+
+  //
+  // Handle used to create/destory UDP child
+  //
+  EFI_HANDLE                Controller;
+  EFI_HANDLE                Image;
+  EFI_HANDLE                UdpHandle;
+
+  EFI_UDP4_PROTOCOL         *Udp;
+  EFI_UDP4_CONFIG_DATA      UdpConfig;
+  EFI_SIMPLE_NETWORK_MODE   SnpMode;
+
+  NET_LIST_ENTRY            SentDatagram;
+  UDP_RX_TOKEN              *RecvRequest;
+};
+
+typedef
+EFI_STATUS
+(*UDP_IO_CONFIG) (
+  IN UDP_IO_PORT            *UdpIo,
+  IN VOID                   *Context
+  );
+
+typedef
+BOOLEAN
+(*UDP_IO_TO_CANCEL) (
+  IN UDP_TX_TOKEN           *Token,
+  IN VOID                   *Context
+  );
+
+UDP_IO_PORT *
+UdpIoCreatePort (
+  IN  EFI_HANDLE            Controller,
+  IN  EFI_HANDLE            ImageHandle,
+  IN  UDP_IO_CONFIG         Configure,
+  IN  VOID                  *Context
+  );
+
+EFI_STATUS
+UdpIoFreePort (
+  IN  UDP_IO_PORT           *UdpIo
+  );
+
+VOID
+UdpIoCleanPort (
+  IN  UDP_IO_PORT           *UdpIo
+  );
+
+EFI_STATUS
+UdpIoSendDatagram (
+  IN  UDP_IO_PORT           *UdpIo,
+  IN  NET_BUF               *Packet,
+  IN  UDP_POINTS            *EndPoint, OPTIONAL
+  IN  IP4_ADDR              Gateway,
+  IN  UDP_IO_CALLBACK       CallBack,
+  IN  VOID                  *Context
+  );
+
+VOID
+UdpIoCancelSentDatagram (
+  IN  UDP_IO_PORT           *UdpIo,
+  IN  NET_BUF               *Packet
+  );
+
+EFI_STATUS
+UdpIoRecvDatagram (
+  IN  UDP_IO_PORT           *UdpIo,
+  IN  UDP_IO_CALLBACK       CallBack,
+  IN  VOID                  *Context,
+  IN  UINT32                HeadLen
+  );
+#endif
diff --git a/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c b/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.c
new file mode 100644 (file)
index 0000000..4a068ea
--- /dev/null
@@ -0,0 +1,1299 @@
+/** @file\r
+\r
+Copyright (c) 2005 - 2007, 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
+Module Name:\r
+\r
+  IpIo.c\r
+\r
+Abstract:\r
+\r
+  The implementation of the IpIo layer.\r
+\r
+\r
+**/\r
+\r
+#include <PiDxe.h>\r
+\r
+#include <Protocol/Udp4.h>\r
+\r
+#include <Library/IpIoLib.h>\r
+#include <Library/BaseLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+\r
+\r
+#define NET_PROTO_HDR(Buf, Type)  ((Type *) ((Buf)->BlockOp[0].Head))\r
+#define ICMP_ERRLEN(IpHdr) \\r
+  (sizeof(IP4_ICMP_HEAD) + EFI_IP4_HEADER_LEN(IpHdr) + 8)\r
+\r
+NET_LIST_ENTRY  mActiveIpIoList = {\r
+  &mActiveIpIoList,\r
+  &mActiveIpIoList\r
+};\r
+\r
+EFI_IP4_CONFIG_DATA  mIpIoDefaultIpConfigData = {\r
+  EFI_IP_PROTO_UDP,\r
+  FALSE,\r
+  TRUE,\r
+  FALSE,\r
+  FALSE,\r
+  FALSE,\r
+  {0, 0, 0, 0},\r
+  {0, 0, 0, 0},\r
+  0,\r
+  255,\r
+  FALSE,\r
+  FALSE,\r
+  0,\r
+  0\r
+};\r
+\r
+STATIC\r
+VOID\r
+EFIAPI\r
+IpIoTransmitHandler (\r
+  IN EFI_EVENT Event,\r
+  IN VOID      *Context\r
+  );\r
+\r
+\r
+/**\r
+  This function create an ip child ,open the IP protocol, return the opened\r
+  Ip protocol to Interface.\r
+\r
+  @param  ControllerHandle      The controller handle.\r
+  @param  ImageHandle           The image handle.\r
+  @param  ChildHandle           Pointer to the buffer to save the ip child handle.\r
+  @param  Interface             Pointer used to get the ip protocol interface.\r
+\r
+  @retval EFI_SUCCESS           The ip child is created and the ip protocol\r
+                                interface is retrieved.\r
+  @retval other                 The required operation failed.\r
+\r
+**/\r
+STATIC\r
+EFI_STATUS\r
+IpIoCreateIpChildOpenProtocol (\r
+  IN  EFI_HANDLE  ControllerHandle,\r
+  IN  EFI_HANDLE  ImageHandle,\r
+  IN  EFI_HANDLE  *ChildHandle,\r
+  OUT VOID        **Interface\r
+  )\r
+{\r
+  EFI_STATUS  Status;\r
+\r
+  //\r
+  // Create an ip child.\r
+  //\r
+  Status = NetLibCreateServiceChild (\r
+             ControllerHandle,\r
+             ImageHandle,\r
+             &gEfiIp4ServiceBindingProtocolGuid,\r
+             ChildHandle\r
+             );\r
+  if (EFI_ERROR (Status)) {\r
+    return Status;\r
+  }\r
+\r
+  //\r
+  // Open the ip protocol installed on the *ChildHandle.\r
+  //\r
+  Status = gBS->OpenProtocol (\r
+                  *ChildHandle,\r
+                  &gEfiIp4ProtocolGuid,\r
+                  Interface,\r
+                  ImageHandle,\r
+                  ControllerHandle,\r
+                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
+                  );\r
+  if (EFI_ERROR (Status)) {\r
+    //\r
+    // On failure, destroy the ip child.\r
+    //\r
+    NetLibDestroyServiceChild (\r
+      ControllerHandle,\r
+      ImageHandle,\r
+      &gEfiIp4ServiceBindingProtocolGuid,\r
+      *ChildHandle\r
+      );\r
+  }\r
+\r
+  return Status;\r
+}\r
+\r
+\r
+/**\r
+  This function close the previously openned ip protocol and destroy the ip child.\r
+\r
+  @param  ControllerHandle      The controller handle.\r
+  @param  ImageHandle           the image handle.\r
+  @param  ChildHandle           The child handle of the ip child.\r
+\r
+  @retval EFI_SUCCESS           The ip protocol is closed and the relevant ip child\r
+                                is destroyed.\r
+  @retval other                 The required operation failed.\r
+\r
+**/\r
+STATIC\r
+EFI_STATUS\r
+IpIoCloseProtocolDestroyIpChild (\r
+  IN EFI_HANDLE  ControllerHandle,\r
+  IN EFI_HANDLE  ImageHandle,\r
+  IN EFI_HANDLE  ChildHandle\r
+  )\r
+{\r
+  EFI_STATUS  Status;\r
+\r
+  //\r
+  // Close the previously openned ip protocol.\r
+  //\r
+  gBS->CloseProtocol (\r
+         ChildHandle,\r
+         &gEfiIp4ProtocolGuid,\r
+         ImageHandle,\r
+         ControllerHandle\r
+         );\r
+\r
+  //\r
+  // Destroy the ip child.\r
+  //\r
+  Status = NetLibDestroyServiceChild (\r
+             ControllerHandle,\r
+             ImageHandle,\r
+             &gEfiIp4ServiceBindingProtocolGuid,\r
+             ChildHandle\r
+             );\r
+\r
+  return Status;\r
+}\r
+\r
+\r
+/**\r
+  Handle ICMP packets.\r
+\r
+  @param  IpIo                  Pointer to the IP_IO instance.\r
+  @param  Pkt                   Pointer to the ICMP packet.\r
+  @param  Session               Pointer to the net session of this ICMP packet.\r
+\r
+  @retval EFI_SUCCESS           The ICMP packet is handled successfully.\r
+  @retval EFI_ABORTED           This type of ICMP packet is not supported.\r
+\r
+**/\r
+STATIC\r
+EFI_STATUS\r
+IpIoIcmpHandler (\r
+  IN IP_IO                *IpIo,\r
+  IN NET_BUF              *Pkt,\r
+  IN EFI_NET_SESSION_DATA *Session\r
+  )\r
+{\r
+  IP4_ICMP_ERROR_HEAD  *IcmpHdr;\r
+  EFI_IP4_HEADER       *IpHdr;\r
+  ICMP_ERROR           IcmpErr;\r
+  UINT8                *PayLoadHdr;\r
+  UINT8                Type;\r
+  UINT8                Code;\r
+  UINT32               TrimBytes;\r
+\r
+  IcmpHdr = NET_PROTO_HDR (Pkt, IP4_ICMP_ERROR_HEAD);\r
+  IpHdr   = (EFI_IP4_HEADER *) (&IcmpHdr->IpHead);\r
+\r
+  //\r
+  // Check the ICMP packet length.\r
+  //\r
+  if (Pkt->TotalSize < ICMP_ERRLEN (IpHdr)) {\r
+\r
+    return EFI_ABORTED;\r
+  }\r
+\r
+  Type = IcmpHdr->Head.Type;\r
+  Code = IcmpHdr->Head.Code;\r
+\r
+  //\r
+  // Analyze the ICMP Error in this ICMP pkt\r
+  //\r
+  switch (Type) {\r
+  case ICMP_TYPE_UNREACH:\r
+    switch (Code) {\r
+    case ICMP_CODE_UNREACH_NET:\r
+    case ICMP_CODE_UNREACH_HOST:\r
+    case ICMP_CODE_UNREACH_PROTOCOL:\r
+    case ICMP_CODE_UNREACH_PORT:\r
+    case ICMP_CODE_UNREACH_SRCFAIL:\r
+      IcmpErr = ICMP_ERR_UNREACH_NET + Code;\r
+\r
+      break;\r
+\r
+    case ICMP_CODE_UNREACH_NEEDFRAG:\r
+      IcmpErr = ICMP_ERR_MSGSIZE;\r
+\r
+      break;\r
+\r
+    case ICMP_CODE_UNREACH_NET_UNKNOWN:\r
+    case ICMP_CODE_UNREACH_NET_PROHIB:\r
+    case ICMP_CODE_UNREACH_TOSNET:\r
+      IcmpErr = ICMP_ERR_UNREACH_NET;\r
+\r
+      break;\r
+\r
+    case ICMP_CODE_UNREACH_HOST_UNKNOWN:\r
+    case ICMP_CODE_UNREACH_ISOLATED:\r
+    case ICMP_CODE_UNREACH_HOST_PROHIB:\r
+    case ICMP_CODE_UNREACH_TOSHOST:\r
+      IcmpErr = ICMP_ERR_UNREACH_HOST;\r
+\r
+      break;\r
+\r
+    default:\r
+      return EFI_ABORTED;\r
+\r
+      break;\r
+    }\r
+\r
+    break;\r
+\r
+  case ICMP_TYPE_TIMXCEED:\r
+    if (Code > 1) {\r
+      return EFI_ABORTED;\r
+    }\r
+\r
+    IcmpErr = Code + ICMP_ERR_TIMXCEED_INTRANS;\r
+\r
+    break;\r
+\r
+  case ICMP_TYPE_PARAMPROB:\r
+    if (Code > 1) {\r
+      return EFI_ABORTED;\r
+    }\r
+\r
+    IcmpErr = ICMP_ERR_PARAMPROB;\r
+\r
+    break;\r
+\r
+  case ICMP_TYPE_SOURCEQUENCH:\r
+    if (Code != 0) {\r
+      return EFI_ABORTED;\r
+    }\r
+\r
+    IcmpErr = ICMP_ERR_QUENCH;\r
+\r
+    break;\r
+\r
+  default:\r
+    return EFI_ABORTED;\r
+\r
+    break;\r
+  }\r
+\r
+  //\r
+  // Notify user the ICMP pkt only containing payload except\r
+  // IP and ICMP header\r
+  //\r
+  PayLoadHdr = (UINT8 *) ((UINT8 *) IpHdr + EFI_IP4_HEADER_LEN (IpHdr));\r
+  TrimBytes  = (UINT32) (PayLoadHdr - (UINT8 *) IcmpHdr);\r
+\r
+  NetbufTrim (Pkt, TrimBytes, TRUE);\r
+\r
+  IpIo->PktRcvdNotify (EFI_ICMP_ERROR, IcmpErr, Session, Pkt, IpIo->RcvdContext);\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+  Ext free function for net buffer. This function is\r
+  called when the net buffer is freed. It is used to\r
+  signal the recycle event to notify IP to recycle the\r
+  data buffer.\r
+\r
+  @param  Event                 The event to be signaled.\r
+\r
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+IpIoExtFree (\r
+  IN VOID  *Event\r
+  )\r
+{\r
+  gBS->SignalEvent ((EFI_EVENT) Event);\r
+}\r
+\r
+\r
+/**\r
+  Create a send entry to wrap a packet before sending\r
+  out it through IP.\r
+\r
+  @param  IpIo                  Pointer to the IP_IO instance.\r
+  @param  Pkt                   Pointer to the packet.\r
+  @param  Sender                Pointer to the IP sender.\r
+  @param  NotifyData            Pointer to the notify data.\r
+  @param  Dest                  Pointer to the destination IP address.\r
+  @param  Override              Pointer to the overriden IP_IO data.\r
+\r
+  @return Pointer to the data structure created to wrap the packet. If NULL,\r
+  @return resource limit occurred.\r
+\r
+**/\r
+STATIC\r
+IP_IO_SEND_ENTRY *\r
+IpIoCreateSndEntry (\r
+  IN IP_IO             *IpIo,\r
+  IN NET_BUF           *Pkt,\r
+  IN EFI_IP4_PROTOCOL  *Sender,\r
+  IN VOID              *Context    OPTIONAL,\r
+  IN VOID              *NotifyData OPTIONAL,\r
+  IN IP4_ADDR          Dest,\r
+  IN IP_IO_OVERRIDE    *Override\r
+  )\r
+{\r
+  IP_IO_SEND_ENTRY          *SndEntry;\r
+  EFI_IP4_COMPLETION_TOKEN  *SndToken;\r
+  EFI_IP4_TRANSMIT_DATA     *TxData;\r
+  EFI_STATUS                Status;\r
+  EFI_IP4_OVERRIDE_DATA     *OverrideData;\r
+  UINT32                    Index;\r
+\r
+  //\r
+  // Allocate resource for SndEntry\r
+  //\r
+  SndEntry = NetAllocatePool (sizeof (IP_IO_SEND_ENTRY));\r
+  if (NULL == SndEntry) {\r
+    return NULL;\r
+  }\r
+\r
+  //\r
+  // Allocate resource for SndToken\r
+  //\r
+  SndToken = NetAllocatePool (sizeof (EFI_IP4_COMPLETION_TOKEN));\r
+  if (NULL == SndToken) {\r
+    goto ReleaseSndEntry;\r
+  }\r
+\r
+  Status = gBS->CreateEvent (\r
+                  EVT_NOTIFY_SIGNAL,\r
+                  NET_TPL_EVENT,\r
+                  IpIoTransmitHandler,\r
+                  SndEntry,\r
+                  &(SndToken->Event)\r
+                  );\r
+  if (EFI_ERROR (Status)) {\r
+    goto ReleaseSndToken;\r
+  }\r
+\r
+  //\r
+  // Allocate resource for TxData\r
+  //\r
+  TxData = NetAllocatePool (\r
+    sizeof (EFI_IP4_TRANSMIT_DATA) +\r
+    sizeof (EFI_IP4_FRAGMENT_DATA) * (Pkt->BlockOpNum - 1)\r
+    );\r
+\r
+  if (NULL == TxData) {\r
+    goto ReleaseEvent;\r
+  }\r
+\r
+  //\r
+  // Allocate resource for OverrideData if needed\r
+  //\r
+  OverrideData = NULL;\r
+  if (NULL != Override) {\r
+\r
+    OverrideData = NetAllocatePool (sizeof (EFI_IP4_OVERRIDE_DATA));\r
+    if (NULL == OverrideData) {\r
+      goto ReleaseResource;\r
+    }\r
+    //\r
+    // Set the fields of OverrideData\r
+    //\r
+    *OverrideData = * (EFI_IP4_OVERRIDE_DATA *) Override;\r
+  }\r
+\r
+  //\r
+  // Set the fields of TxData\r
+  //\r
+  EFI_IP4 (TxData->DestinationAddress)  = Dest;\r
+  TxData->OverrideData                  = OverrideData;\r
+  TxData->OptionsLength                 = 0;\r
+  TxData->OptionsBuffer                 = NULL;\r
+  TxData->TotalDataLength               = Pkt->TotalSize;\r
+  TxData->FragmentCount                 = Pkt->BlockOpNum;\r
+\r
+  for (Index = 0; Index < Pkt->BlockOpNum; Index++) {\r
+\r
+    TxData->FragmentTable[Index].FragmentBuffer = Pkt->BlockOp[Index].Head;\r
+    TxData->FragmentTable[Index].FragmentLength = Pkt->BlockOp[Index].Size;\r
+  }\r
+\r
+  //\r
+  // Set the fields of SndToken\r
+  //\r
+  SndToken->Packet.TxData = TxData;\r
+\r
+  //\r
+  // Set the fields of SndEntry\r
+  //\r
+  SndEntry->IpIo        = IpIo;\r
+  SndEntry->Ip      = Sender;\r
+  SndEntry->Context     = Context;\r
+  SndEntry->NotifyData  = NotifyData;\r
+\r
+  SndEntry->Pkt         = Pkt;\r
+  NET_GET_REF (Pkt);\r
+\r
+  SndEntry->SndToken = SndToken;\r
+\r
+  NetListInsertTail (&IpIo->PendingSndList, &SndEntry->Entry);\r
+\r
+  return SndEntry;\r
+\r
+ReleaseResource:\r
+  NetFreePool (TxData);\r
+\r
+ReleaseEvent:\r
+  gBS->CloseEvent (SndToken->Event);\r
+\r
+ReleaseSndToken:\r
+  NetFreePool (SndToken);\r
+\r
+ReleaseSndEntry:\r
+  NetFreePool (SndEntry);\r
+\r
+  return NULL;\r
+}\r
+\r
+\r
+/**\r
+  Destroy the SndEntry.\r
+\r
+  @param  SndEntry              Pointer to the send entry to be destroyed.\r
+\r
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+IpIoDestroySndEntry (\r
+  IN IP_IO_SEND_ENTRY  *SndEntry\r
+  )\r
+{\r
+  EFI_IP4_TRANSMIT_DATA  *TxData;\r
+\r
+  TxData = SndEntry->SndToken->Packet.TxData;\r
+\r
+  if (NULL != TxData->OverrideData) {\r
+    NetFreePool (TxData->OverrideData);\r
+  }\r
+\r
+  NetFreePool (TxData);\r
+  NetbufFree (SndEntry->Pkt);\r
+  gBS->CloseEvent (SndEntry->SndToken->Event);\r
+\r
+  NetFreePool (SndEntry->SndToken);\r
+  NetListRemoveEntry (&SndEntry->Entry);\r
+\r
+  NetFreePool (SndEntry);\r
+}\r
+\r
+\r
+/**\r
+  Notify function for IP transmit token.\r
+\r
+  @param  Event                 The event signaled.\r
+  @param  Context               The context passed in by the event notifier.\r
+\r
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+EFIAPI\r
+IpIoTransmitHandler (\r
+  IN EFI_EVENT Event,\r
+  IN VOID      *Context\r
+  )\r
+{\r
+  IP_IO             *IpIo;\r
+  IP_IO_SEND_ENTRY  *SndEntry;\r
+\r
+  SndEntry  = (IP_IO_SEND_ENTRY *) Context;\r
+\r
+  IpIo      = SndEntry->IpIo;\r
+\r
+  if (IpIo->PktSentNotify && SndEntry->NotifyData) {\r
+    IpIo->PktSentNotify (\r
+            SndEntry->SndToken->Status,\r
+            SndEntry->Context,\r
+            SndEntry->Ip,\r
+            SndEntry->NotifyData\r
+            );\r
+  }\r
+\r
+  IpIoDestroySndEntry (SndEntry);\r
+}\r
+\r
+\r
+/**\r
+  The dummy handler for the dummy IP receive token.\r
+\r
+  @param  Evt                   The event signaled.\r
+  @param  Context               The context passed in by the event notifier.\r
+\r
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+EFIAPI\r
+IpIoDummyHandler (\r
+  IN EFI_EVENT Event,\r
+  IN VOID      *Context\r
+  )\r
+{\r
+  IP_IO_IP_INFO             *IpInfo;\r
+  EFI_IP4_COMPLETION_TOKEN  *DummyToken;\r
+\r
+  ASSERT (Event && Context);\r
+\r
+  IpInfo      = (IP_IO_IP_INFO *) Context;\r
+  DummyToken  = &(IpInfo->DummyRcvToken);\r
+\r
+  if (EFI_SUCCESS == DummyToken->Status) {\r
+    ASSERT (DummyToken->Packet.RxData);\r
+\r
+    gBS->SignalEvent (DummyToken->Packet.RxData->RecycleSignal);\r
+  }\r
+\r
+  IpInfo->Ip->Receive (IpInfo->Ip, DummyToken);\r
+}\r
+\r
+\r
+/**\r
+  Notify function for the IP receive token, used to process\r
+  the received IP packets.\r
+\r
+  @param  Event                 The event signaled.\r
+  @param  Context               The context passed in by the event notifier.\r
+\r
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+EFIAPI\r
+IpIoListenHandler (\r
+  IN EFI_EVENT Event,\r
+  IN VOID      *Context\r
+  )\r
+{\r
+  IP_IO                 *IpIo;\r
+  EFI_STATUS            Status;\r
+  EFI_IP4_RECEIVE_DATA  *RxData;\r
+  EFI_IP4_PROTOCOL      *Ip;\r
+  EFI_NET_SESSION_DATA  Session;\r
+  NET_BUF               *Pkt;\r
+\r
+  IpIo    = (IP_IO *) Context;\r
+\r
+  Ip      = IpIo->Ip;\r
+  Status  = IpIo->RcvToken.Status;\r
+  RxData  = IpIo->RcvToken.Packet.RxData;\r
+\r
+  if (((EFI_SUCCESS != Status) && (EFI_ICMP_ERROR != Status)) || (NULL == RxData)) {\r
+    //\r
+    // Only process the normal packets and the icmp error packets, if RxData is NULL\r
+    // with Status == EFI_SUCCESS or EFI_ICMP_ERROR, just resume the receive although\r
+    // this should be a bug of the low layer (IP).\r
+    //\r
+    goto Resume;\r
+  }\r
+\r
+  if (NULL == IpIo->PktRcvdNotify) {\r
+    goto CleanUp;\r
+  }\r
+\r
+  if ((EFI_IP4 (RxData->Header->SourceAddress) != 0) &&\r
+    !Ip4IsUnicast (EFI_NTOHL (RxData->Header->SourceAddress), 0)) {\r
+    //\r
+    // The source address is not zero and it's not a unicast IP address, discard it.\r
+    //\r
+    goto CleanUp;\r
+  }\r
+\r
+  //\r
+  // Create a netbuffer representing packet\r
+  //\r
+  Pkt = NetbufFromExt (\r
+          (NET_FRAGMENT *) RxData->FragmentTable,\r
+          RxData->FragmentCount,\r
+          0,\r
+          0,\r
+          IpIoExtFree,\r
+          RxData->RecycleSignal\r
+          );\r
+  if (NULL == Pkt) {\r
+    goto CleanUp;\r
+  }\r
+\r
+  //\r
+  // Create a net session\r
+  //\r
+  Session.Source = EFI_IP4 (RxData->Header->SourceAddress);\r
+  Session.Dest   = EFI_IP4 (RxData->Header->DestinationAddress);\r
+  Session.IpHdr  = RxData->Header;\r
+\r
+  if (EFI_SUCCESS == Status) {\r
+\r
+    IpIo->PktRcvdNotify (EFI_SUCCESS, 0, &Session, Pkt, IpIo->RcvdContext);\r
+  } else {\r
+    //\r
+    // Status is EFI_ICMP_ERROR\r
+    //\r
+    Status = IpIoIcmpHandler (IpIo, Pkt, &Session);\r
+    if (EFI_ERROR (Status)) {\r
+      NetbufFree (Pkt);\r
+    }\r
+  }\r
+\r
+  goto Resume;\r
+\r
+CleanUp:\r
+  gBS->SignalEvent (RxData->RecycleSignal);\r
+\r
+Resume:\r
+  Ip->Receive (Ip, &(IpIo->RcvToken));\r
+}\r
+\r
+\r
+/**\r
+  Create a new IP_IO instance.\r
+\r
+  @param  Image                 The image handle of an IP_IO consumer protocol.\r
+  @param  Controller            The controller handle of an IP_IO consumer protocol\r
+                                installed on.\r
+\r
+  @return Pointer to a newly created IP_IO instance.\r
+\r
+**/\r
+IP_IO *\r
+IpIoCreate (\r
+  IN EFI_HANDLE Image,\r
+  IN EFI_HANDLE Controller\r
+  )\r
+{\r
+  EFI_STATUS  Status;\r
+  IP_IO       *IpIo;\r
+\r
+  IpIo = NetAllocateZeroPool (sizeof (IP_IO));\r
+  if (NULL == IpIo) {\r
+    return NULL;\r
+  }\r
+\r
+  NetListInit (&(IpIo->PendingSndList));\r
+  NetListInit (&(IpIo->IpList));\r
+  IpIo->Controller  = Controller;\r
+  IpIo->Image       = Image;\r
+\r
+  Status = gBS->CreateEvent (\r
+                  EVT_NOTIFY_SIGNAL,\r
+                  NET_TPL_EVENT,\r
+                  IpIoListenHandler,\r
+                  IpIo,\r
+                  &(IpIo->RcvToken.Event)\r
+                  );\r
+  if (EFI_ERROR (Status)) {\r
+    goto ReleaseIpIo;\r
+  }\r
+\r
+  //\r
+  // Create an IP child and open IP protocol\r
+  //\r
+  Status = IpIoCreateIpChildOpenProtocol (\r
+             Controller,\r
+             Image,\r
+             &IpIo->ChildHandle,\r
+             (VOID **)&(IpIo->Ip)\r
+             );\r
+  if (EFI_ERROR (Status)) {\r
+    goto ReleaseIpIo;\r
+  }\r
+\r
+  return IpIo;\r
+\r
+ReleaseIpIo:\r
+\r
+  if (NULL != IpIo->RcvToken.Event) {\r
+    gBS->CloseEvent (IpIo->RcvToken.Event);\r
+  }\r
+\r
+  NetFreePool (IpIo);\r
+\r
+  return NULL;\r
+}\r
+\r
+\r
+/**\r
+  Open an IP_IO instance for use.\r
+\r
+  @param  IpIo                  Pointer to an IP_IO instance that needs to open.\r
+  @param  OpenData              The configuration data for the IP_IO instance.\r
+\r
+  @retval EFI_SUCCESS           The IP_IO instance opened with OpenData\r
+                                successfully.\r
+  @retval other                 Error condition occurred.\r
+\r
+**/\r
+EFI_STATUS\r
+IpIoOpen (\r
+  IN IP_IO           *IpIo,\r
+  IN IP_IO_OPEN_DATA *OpenData\r
+  )\r
+{\r
+  EFI_STATUS        Status;\r
+  EFI_IP4_PROTOCOL  *Ip;\r
+  EFI_IPv4_ADDRESS  ZeroIp;\r
+\r
+  if (IpIo->IsConfigured) {\r
+    return EFI_ACCESS_DENIED;\r
+  }\r
+\r
+  Ip = IpIo->Ip;\r
+\r
+  //\r
+  // configure ip\r
+  //\r
+  Status = Ip->Configure (Ip, &OpenData->IpConfigData);\r
+  if (EFI_ERROR (Status)) {\r
+    return Status;\r
+  }\r
+\r
+  //\r
+  // bugbug: to delete the default route entry in this Ip, if it is:\r
+  // (0.0.0.0, 0.0.0.0, 0.0.0.0). Delete this statement if Ip modified\r
+  // its code\r
+  //\r
+  EFI_IP4 (ZeroIp) = 0;\r
+  Status = Ip->Routes (Ip, TRUE, &ZeroIp, &ZeroIp, &ZeroIp);\r
+\r
+  if (EFI_ERROR (Status) && (EFI_NOT_FOUND != Status)) {\r
+    return Status;\r
+  }\r
+\r
+  IpIo->PktRcvdNotify = OpenData->PktRcvdNotify;\r
+  IpIo->PktSentNotify = OpenData->PktSentNotify;\r
+\r
+  IpIo->RcvdContext   = OpenData->RcvdContext;\r
+  IpIo->SndContext    = OpenData->SndContext;\r
+\r
+  IpIo->Protocol      = OpenData->IpConfigData.DefaultProtocol;\r
+\r
+  //\r
+  // start to listen incoming packet\r
+  //\r
+  Status = Ip->Receive (Ip, &(IpIo->RcvToken));\r
+  if (EFI_ERROR (Status)) {\r
+    Ip->Configure (Ip, NULL);\r
+    goto ErrorExit;\r
+  }\r
+\r
+  IpIo->IsConfigured = TRUE;\r
+  NetListInsertTail (&mActiveIpIoList, &IpIo->Entry);\r
+\r
+ErrorExit:\r
+\r
+  return Status;\r
+}\r
+\r
+\r
+/**\r
+  Stop an IP_IO instance.\r
+\r
+  @param  IpIo                  Pointer to the IP_IO instance that needs to stop.\r
+\r
+  @retval EFI_SUCCESS           The IP_IO instance stopped successfully.\r
+  @retval other                 Error condition occurred.\r
+\r
+**/\r
+EFI_STATUS\r
+IpIoStop (\r
+  IN IP_IO *IpIo\r
+  )\r
+{\r
+  EFI_STATUS        Status;\r
+  EFI_IP4_PROTOCOL  *Ip;\r
+  IP_IO_IP_INFO     *IpInfo;\r
+\r
+  if (!IpIo->IsConfigured) {\r
+    return EFI_SUCCESS;\r
+  }\r
+\r
+  //\r
+  // Remove the IpIo from the active IpIo list.\r
+  //\r
+  NetListRemoveEntry (&IpIo->Entry);\r
+\r
+  Ip = IpIo->Ip;\r
+\r
+  //\r
+  // Configure NULL Ip\r
+  //\r
+  Status = Ip->Configure (Ip, NULL);\r
+  if (EFI_ERROR (Status)) {\r
+    return Status;\r
+  }\r
+\r
+  IpIo->IsConfigured = FALSE;\r
+\r
+  //\r
+  // Detroy the Ip List used by IpIo\r
+  //\r
+  while (!NetListIsEmpty (&(IpIo->IpList))) {\r
+    IpInfo = NET_LIST_HEAD (&(IpIo->IpList), IP_IO_IP_INFO, Entry);\r
+\r
+    IpIoRemoveIp (IpIo, IpInfo);\r
+  }\r
+\r
+  //\r
+  // All pending snd tokens should be flushed by reseting the IP instances.\r
+  //\r
+  ASSERT (NetListIsEmpty (&IpIo->PendingSndList));\r
+\r
+  //\r
+  // Close the receive event.\r
+  //\r
+  gBS->CloseEvent (IpIo->RcvToken.Event);\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+  Destroy an IP_IO instance.\r
+\r
+  @param  IpIo                  Pointer to the IP_IO instance that needs to\r
+                                destroy.\r
+\r
+  @retval EFI_SUCCESS           The IP_IO instance destroyed successfully.\r
+  @retval other                 Error condition occurred.\r
+\r
+**/\r
+EFI_STATUS\r
+IpIoDestroy (\r
+  IN IP_IO *IpIo\r
+  )\r
+{\r
+  //\r
+  // Stop the IpIo.\r
+  //\r
+  IpIoStop (IpIo);\r
+\r
+  //\r
+  // Close the IP protocol and destroy the child.\r
+  //\r
+  IpIoCloseProtocolDestroyIpChild (IpIo->Controller, IpIo->Image, IpIo->ChildHandle);\r
+\r
+  NetFreePool (IpIo);\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+  Send out an IP packet.\r
+\r
+  @param  IpIo                  Pointer to an IP_IO instance used for sending IP\r
+                                packet.\r
+  @param  Pkt                   Pointer to the IP packet to be sent.\r
+  @param  Sender                The IP protocol instance used for sending.\r
+  @param  NotifyData\r
+  @param  Dest                  The destination IP address to send this packet to.\r
+  @param  OverrideData          The data to override some configuration of the IP\r
+                                instance used for sending.\r
+\r
+  @retval EFI_SUCCESS           The operation is completed successfully.\r
+  @retval EFI_NOT_STARTED       The IpIo is not configured.\r
+  @retval EFI_OUT_OF_RESOURCES  Failed due to resource limit.\r
+\r
+**/\r
+EFI_STATUS\r
+IpIoSend (\r
+  IN IP_IO           *IpIo,\r
+  IN NET_BUF         *Pkt,\r
+  IN IP_IO_IP_INFO   *Sender,\r
+  IN VOID            *Context    OPTIONAL,\r
+  IN VOID            *NotifyData OPTIONAL,\r
+  IN IP4_ADDR        Dest,\r
+  IN IP_IO_OVERRIDE  *OverrideData\r
+  )\r
+{\r
+  EFI_STATUS        Status;\r
+  EFI_IP4_PROTOCOL  *Ip;\r
+  IP_IO_SEND_ENTRY  *SndEntry;\r
+\r
+  if (!IpIo->IsConfigured) {\r
+    return EFI_NOT_STARTED;\r
+  }\r
+\r
+  Ip = (NULL == Sender) ? IpIo->Ip : Sender->Ip;\r
+\r
+  //\r
+  // create a new SndEntry\r
+  //\r
+  SndEntry = IpIoCreateSndEntry (IpIo, Pkt, Ip, Context, NotifyData, Dest, OverrideData);\r
+  if (NULL == SndEntry) {\r
+    return EFI_OUT_OF_RESOURCES;\r
+  }\r
+\r
+  //\r
+  // Send this Packet\r
+  //\r
+  Status = Ip->Transmit (Ip, SndEntry->SndToken);\r
+  if (EFI_ERROR (Status)) {\r
+    IpIoDestroySndEntry (SndEntry);\r
+  }\r
+\r
+  return Status;\r
+}\r
+\r
+\r
+/**\r
+  Cancel the IP transmit token which wraps this Packet.\r
+\r
+  @param  IpIo                  Pointer to the IP_IO instance.\r
+  @param  Packet                Pointer to the packet to cancel.\r
+\r
+  @return N/A.\r
+\r
+**/\r
+VOID\r
+IpIoCancelTxToken (\r
+  IN IP_IO  *IpIo,\r
+  IN VOID   *Packet\r
+  )\r
+{\r
+  NET_LIST_ENTRY    *Node;\r
+  IP_IO_SEND_ENTRY  *SndEntry;\r
+  EFI_IP4_PROTOCOL  *Ip;\r
+\r
+  ASSERT (IpIo && Packet);\r
+\r
+  NET_LIST_FOR_EACH (Node, &IpIo->PendingSndList) {\r
+\r
+    SndEntry = NET_LIST_USER_STRUCT (Node, IP_IO_SEND_ENTRY, Entry);\r
+\r
+    if (SndEntry->Pkt == Packet) {\r
+\r
+      Ip = SndEntry->Ip;\r
+      Ip->Cancel (Ip, SndEntry->SndToken);\r
+\r
+      //\r
+      // Abort the user token.\r
+      //\r
+      SndEntry->SndToken->Status = EFI_ABORTED;\r
+      IpIoTransmitHandler (NULL, SndEntry);\r
+\r
+      break;\r
+    }\r
+  }\r
+\r
+}\r
+\r
+\r
+/**\r
+  Add a new IP instance for sending data.\r
+\r
+  @param  IpIo                  Pointer to a IP_IO instance to add a new IP\r
+                                instance for sending purpose.\r
+\r
+  @return Pointer to the created IP_IO_IP_INFO structure, NULL is failed.\r
+\r
+**/\r
+IP_IO_IP_INFO *\r
+IpIoAddIp (\r
+  IN IP_IO  *IpIo\r
+  )\r
+{\r
+  EFI_STATUS     Status;\r
+  IP_IO_IP_INFO  *IpInfo;\r
+\r
+  ASSERT (IpIo);\r
+\r
+  IpInfo = NetAllocatePool (sizeof (IP_IO_IP_INFO));\r
+  if (IpInfo == NULL) {\r
+    return IpInfo;\r
+  }\r
+\r
+  //\r
+  // Init this IpInfo, set the Addr and SubnetMask to 0 before we configure the IP\r
+  // instance.\r
+  //\r
+  NetListInit (&IpInfo->Entry);\r
+  IpInfo->ChildHandle = NULL;\r
+  IpInfo->Addr        = 0;\r
+  IpInfo->SubnetMask  = 0;\r
+  IpInfo->RefCnt      = 1;\r
+\r
+  //\r
+  // Create the IP instance and open the Ip4 protocol.\r
+  //\r
+  Status = IpIoCreateIpChildOpenProtocol (\r
+             IpIo->Controller,\r
+             IpIo->Image,\r
+             &IpInfo->ChildHandle,\r
+             &IpInfo->Ip\r
+             );\r
+  if (EFI_ERROR (Status)) {\r
+    goto ReleaseIpInfo;\r
+  }\r
+\r
+  //\r
+  // Create the event for the DummyRcvToken.\r
+  //\r
+  Status = gBS->CreateEvent (\r
+                  EVT_NOTIFY_SIGNAL,\r
+                  NET_TPL_EVENT,\r
+                  IpIoDummyHandler,\r
+                  IpInfo,\r
+                  &IpInfo->DummyRcvToken.Event\r
+                  );\r
+  if (EFI_ERROR (Status)) {\r
+    goto ReleaseIpChild;\r
+  }\r
+\r
+  //\r
+  // Link this IpInfo into the IpIo.\r
+  //\r
+  NetListInsertTail (&IpIo->IpList, &IpInfo->Entry);\r
+\r
+  return IpInfo;\r
+\r
+ReleaseIpChild:\r
+\r
+  IpIoCloseProtocolDestroyIpChild (\r
+    IpIo->Controller,\r
+    IpIo->Image,\r
+    IpInfo->ChildHandle\r
+    );\r
+\r
+ReleaseIpInfo:\r
+\r
+  NetFreePool (IpInfo);\r
+\r
+  return NULL;\r
+}\r
+\r
+\r
+/**\r
+  Configure the IP instance of this IpInfo and start the receiving if Ip4ConfigData\r
+  is not NULL.\r
+\r
+  @param  IpInfo                Pointer to the IP_IO_IP_INFO instance.\r
+  @param  Ip4ConfigData         The IP4 configure data used to configure the ip\r
+                                instance, if NULL the ip instance is reseted. If\r
+                                UseDefaultAddress is set to TRUE, and the configure\r
+                                operation succeeds, the default address information\r
+                                is written back in this Ip4ConfigData.\r
+\r
+  @retval EFI_STATUS            The status returned by IP4->Configure or\r
+                                IP4->Receive.\r
+\r
+**/\r
+EFI_STATUS\r
+IpIoConfigIp (\r
+  IN     IP_IO_IP_INFO        *IpInfo,\r
+  IN OUT EFI_IP4_CONFIG_DATA  *Ip4ConfigData OPTIONAL\r
+  )\r
+{\r
+  EFI_STATUS         Status;\r
+  EFI_IP4_PROTOCOL   *Ip;\r
+  EFI_IP4_MODE_DATA  Ip4ModeData;\r
+\r
+  ASSERT (IpInfo);\r
+\r
+  if (IpInfo->RefCnt > 1) {\r
+    //\r
+    // This IP instance is shared, don't reconfigure it until it has only one\r
+    // consumer. Currently, only the tcp children cloned from their passive parent\r
+    // will share the same IP. So this cases only happens while Ip4ConfigData is NULL,\r
+    // let the last consumer clean the IP instance.\r
+    //\r
+    return EFI_SUCCESS;\r
+  }\r
+\r
+  Ip = IpInfo->Ip;\r
+\r
+  Status = Ip->Configure (Ip, Ip4ConfigData);\r
+  if (EFI_ERROR (Status)) {\r
+    goto OnExit;\r
+  }\r
+\r
+  if (Ip4ConfigData != NULL) {\r
+\r
+    if (Ip4ConfigData->UseDefaultAddress) {\r
+      Ip->GetModeData (Ip, &Ip4ModeData, NULL, NULL);\r
+\r
+      Ip4ConfigData->StationAddress = Ip4ModeData.ConfigData.StationAddress;\r
+      Ip4ConfigData->SubnetMask     = Ip4ModeData.ConfigData.SubnetMask;\r
+    }\r
+\r
+    IpInfo->Addr       = EFI_IP4 (Ip4ConfigData->StationAddress);\r
+    IpInfo->SubnetMask = EFI_IP4 (Ip4ConfigData->SubnetMask);\r
+\r
+    Status = Ip->Receive (Ip, &IpInfo->DummyRcvToken);\r
+    if (EFI_ERROR (Status)) {\r
+      Ip->Configure (Ip, NULL);\r
+    }\r
+  } else {\r
+\r
+    //\r
+    // The IP instance is reseted, set the stored Addr and SubnetMask to zero.\r
+    //\r
+    IpInfo->Addr       = 0;\r
+    IpInfo->SubnetMask =0;\r
+  }\r
+\r
+OnExit:\r
+\r
+  return Status;\r
+}\r
+\r
+\r
+/**\r
+  Destroy an IP instance maintained in IpIo->IpList for\r
+  sending purpose.\r
+\r
+  @param  IpIo                  Pointer to the IP_IO instance.\r
+  @param  IpInfo                Pointer to the IpInfo to be removed.\r
+\r
+  @return None.\r
+\r
+**/\r
+VOID\r
+IpIoRemoveIp (\r
+  IN IP_IO          *IpIo,\r
+  IN IP_IO_IP_INFO  *IpInfo\r
+  )\r
+{\r
+  ASSERT (IpInfo->RefCnt > 0);\r
+\r
+  NET_PUT_REF (IpInfo);\r
+\r
+  if (IpInfo->RefCnt > 0) {\r
+\r
+    return;\r
+  }\r
+\r
+  NetListRemoveEntry (&IpInfo->Entry);\r
+\r
+  IpInfo->Ip->Configure (IpInfo->Ip, NULL);\r
+\r
+  IpIoCloseProtocolDestroyIpChild (IpIo->Controller, IpIo->Image, IpInfo->ChildHandle);\r
+\r
+  gBS->CloseEvent (IpInfo->DummyRcvToken.Event);\r
+\r
+  NetFreePool (IpInfo);\r
+}\r
+\r
+\r
+/**\r
+  Find the first IP protocol maintained in IpIo whose local\r
+  address is the same with Src.\r
+\r
+  @param  IpIo                  Pointer to the pointer of the IP_IO instance.\r
+  @param  Src                   The local IP address.\r
+\r
+  @return Pointer to the IP protocol can be used for sending purpose and its local\r
+  @return address is the same with Src.\r
+\r
+**/\r
+IP_IO_IP_INFO *\r
+IpIoFindSender (\r
+  IN OUT IP_IO     **IpIo,\r
+  IN     IP4_ADDR  Src\r
+  )\r
+{\r
+  NET_LIST_ENTRY  *IpIoEntry;\r
+  IP_IO           *IpIoPtr;\r
+  NET_LIST_ENTRY  *IpInfoEntry;\r
+  IP_IO_IP_INFO   *IpInfo;\r
+\r
+  NET_LIST_FOR_EACH (IpIoEntry, &mActiveIpIoList) {\r
+    IpIoPtr = NET_LIST_USER_STRUCT (IpIoEntry, IP_IO, Entry);\r
+\r
+    if ((*IpIo != NULL) && (*IpIo != IpIoPtr)) {\r
+      continue;\r
+    }\r
+\r
+    NET_LIST_FOR_EACH (IpInfoEntry, &IpIoPtr->IpList) {\r
+      IpInfo = NET_LIST_USER_STRUCT (IpInfoEntry, IP_IO_IP_INFO, Entry);\r
+\r
+      if (IpInfo->Addr == Src) {\r
+        *IpIo = IpIoPtr;\r
+        return IpInfo;\r
+      }\r
+    }\r
+  }\r
+\r
+  //\r
+  // No match.\r
+  //\r
+  return NULL;\r
+}\r
+\r
+\r
+/**\r
+  Get the ICMP error map information, the ErrorStatus will be returned.\r
+  The IsHard and Notify are optional. If they are not NULL, this rouine will\r
+  fill them.\r
+  We move IcmpErrMap[] to local variable to enable EBC build.\r
+\r
+  @param  IcmpError             IcmpError Type\r
+  @param  IsHard                Whether it is a hard error\r
+  @param  Notify                Whether it need to notify SockError\r
+\r
+  @return ICMP Error Status\r
+\r
+**/\r
+EFI_STATUS\r
+IpIoGetIcmpErrStatus (\r
+  IN  ICMP_ERROR  IcmpError,\r
+  OUT BOOLEAN     *IsHard, OPTIONAL\r
+  OUT BOOLEAN     *Notify OPTIONAL\r
+  )\r
+{\r
+  ICMP_ERROR_INFO  IcmpErrMap[] = {\r
+    { EFI_NETWORK_UNREACHABLE,  FALSE, TRUE  }, // ICMP_ERR_UNREACH_NET\r
+    { EFI_HOST_UNREACHABLE,     FALSE, TRUE  }, // ICMP_ERR_UNREACH_HOST\r
+    { EFI_PROTOCOL_UNREACHABLE, TRUE,  TRUE  }, // ICMP_ERR_UNREACH_PROTOCOL\r
+    { EFI_PORT_UNREACHABLE,     TRUE,  TRUE  }, // ICMP_ERR_UNREACH_PORT\r
+    { EFI_ICMP_ERROR,           TRUE,  TRUE  }, // ICMP_ERR_MSGSIZE\r
+    { EFI_ICMP_ERROR,           FALSE, TRUE  }, // ICMP_ERR_UNREACH_SRCFAIL\r
+    { EFI_HOST_UNREACHABLE,     FALSE, TRUE  }, // ICMP_ERR_TIMXCEED_INTRANS\r
+    { EFI_HOST_UNREACHABLE,     FALSE, TRUE  }, // ICMP_ERR_TIMEXCEED_REASS\r
+    { EFI_ICMP_ERROR,           FALSE, FALSE }, // ICMP_ERR_QUENCH\r
+    { EFI_ICMP_ERROR,           FALSE, TRUE  }  // ICMP_ERR_PARAMPROB\r
+  };\r
+\r
+  ASSERT ((IcmpError >= ICMP_ERR_UNREACH_NET) && (IcmpError <= ICMP_ERR_PARAMPROB));\r
+\r
+  if (IsHard != NULL) {\r
+    *IsHard = IcmpErrMap[IcmpError].IsHard;\r
+  }\r
+\r
+  if (Notify != NULL) {\r
+    *Notify = IcmpErrMap[IcmpError].Notify;\r
+  }\r
+\r
+  return IcmpErrMap[IcmpError].Error;\r
+}\r
+\r
diff --git a/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf b/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf
new file mode 100644 (file)
index 0000000..9430d8a
--- /dev/null
@@ -0,0 +1,65 @@
+#/** @file\r
+# Component name for module NetLib\r
+#\r
+# FIX ME!\r
+# Copyright (c) 2006, Intel Corporation. All right reserved.\r
+#\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
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010005\r
+  BASE_NAME                      = NetIpIoDxe\r
+  FILE_GUID                      = A302F877-8625-425c-B1EC-7487B62C4FDA\r
+  MODULE_TYPE                    = DXE_DRIVER\r
+  VERSION_STRING                 = 1.0\r
+  LIBRARY_CLASS                  = IpIoLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER\r
+  EDK_RELEASE_VERSION            = 0x00020000\r
+  EFI_SPECIFICATION_VERSION      = 0x00020000\r
+\r
+\r
+#\r
+# The following information is for reference only and not required by the build tools.\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC\r
+#\r
+\r
+[Sources.common]\r
+  DxeIpIoLib.c\r
+\r
+[Packages]\r
+  MdePkg/MdePkg.dec\r
+  MdeModulePkg/MdeModulePkg.dec\r
+\r
+\r
+[LibraryClasses]\r
+  MemoryAllocationLib\r
+  UefiLib\r
+  BaseLib\r
+  UefiBootServicesTableLib\r
+  UefiRuntimeServicesTableLib\r
+  BaseMemoryLib\r
+  DebugLib\r
+  PrintLib\r
+\r
+\r
+[Protocols]\r
+  gEfiIp4ProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverDiagnosticsProtocolGuid             # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiUdp4ServiceBindingProtocolGuid            # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiLoadedImageProtocolGuid                   # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiIp4ServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverConfigurationProtocolGuid           # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiSimpleNetworkProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverBindingProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiUdp4ProtocolGuid                          # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiComponentNameProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+\r
diff --git a/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c
new file mode 100644 (file)
index 0000000..88dcf76
--- /dev/null
@@ -0,0 +1,1332 @@
+/** @file
+
+Copyright (c) 2005 - 2007, Intel Corporation
+All rights reserved. This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+Module Name:
+
+  NetLib.c
+
+Abstract:
+
+
+
+**/
+
+#include <PiDxe.h>
+
+#include <Protocol/ServiceBinding.h>
+#include <Protocol/SimpleNetwork.h>
+#include <Protocol/LoadedImage.h>
+
+#include <Library/NetLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Library/UefiLib.h>\r
+#include <Library/MemoryAllocationLib.h>
+
+
+//
+// All the supported IP4 maskes in host byte order.
+//
+IP4_ADDR  mIp4AllMasks[IP4_MASK_NUM] = {
+  0x00000000,
+  0x80000000,
+  0xC0000000,
+  0xE0000000,
+  0xF0000000,
+  0xF8000000,
+  0xFC000000,
+  0xFE000000,
+
+  0xFF000000,
+  0xFF800000,
+  0xFFC00000,
+  0xFFE00000,
+  0xFFF00000,
+  0xFFF80000,
+  0xFFFC0000,
+  0xFFFE0000,
+
+  0xFFFF0000,
+  0xFFFF8000,
+  0xFFFFC000,
+  0xFFFFE000,
+  0xFFFFF000,
+  0xFFFFF800,
+  0xFFFFFC00,
+  0xFFFFFE00,
+
+  0xFFFFFF00,
+  0xFFFFFF80,
+  0xFFFFFFC0,
+  0xFFFFFFE0,
+  0xFFFFFFF0,
+  0xFFFFFFF8,
+  0xFFFFFFFC,
+  0xFFFFFFFE,
+  0xFFFFFFFF,
+};
+
+
+/**\r
+  Converts the low nibble of a byte  to hex unicode character.\r
+\r
+  @param  Nibble  lower nibble of a byte.\r
+\r
+  @return Hex unicode character.\r
+\r
+**/\r
+CHAR16\r
+NibbleToHexChar (\r
+  IN UINT8      Nibble\r
+  )\r
+{\r
+  //\r
+  // Porting Guide:\r
+  // This library interface is simply obsolete.\r
+  // Include the source code to user code.\r
+  //\r
+\r
+  Nibble &= 0x0F;\r
+  if (Nibble <= 0x9) {\r
+    return (CHAR16)(Nibble + L'0');\r
+  }\r
+\r
+  return (CHAR16)(Nibble - 0xA + L'A');\r
+}\r
+\r
+/**
+  Return the length of the mask. If the mask is invalid,
+  return the invalid length 33, which is IP4_MASK_NUM.
+  NetMask is in the host byte order.
+
+  @param  NetMask               The netmask to get the length from
+
+  @return The length of the netmask, IP4_MASK_NUM if the mask isn't
+  @return supported.
+
+**/
+INTN
+NetGetMaskLength (
+  IN IP4_ADDR               NetMask
+  )
+{
+  INTN                      Index;
+
+  for (Index = 0; Index < IP4_MASK_NUM; Index++) {
+    if (NetMask == mIp4AllMasks[Index]) {
+      break;
+    }
+  }
+
+  return Index;
+}
+
+
+
+/**
+  Return the class of the address, such as class a, b, c.
+  Addr is in host byte order.
+
+  @param  Addr                  The address to get the class from
+
+  @return IP address class, such as IP4_ADDR_CLASSA
+
+**/
+INTN
+NetGetIpClass (
+  IN IP4_ADDR               Addr
+  )
+{
+  UINT8                     ByteOne;
+
+  ByteOne = (UINT8) (Addr >> 24);
+
+  if ((ByteOne & 0x80) == 0) {
+    return IP4_ADDR_CLASSA;
+
+  } else if ((ByteOne & 0xC0) == 0x80) {
+    return IP4_ADDR_CLASSB;
+
+  } else if ((ByteOne & 0xE0) == 0xC0) {
+    return IP4_ADDR_CLASSC;
+
+  } else if ((ByteOne & 0xF0) == 0xE0) {
+    return IP4_ADDR_CLASSD;
+
+  } else {
+    return IP4_ADDR_CLASSE;
+
+  }
+}
+
+
+/**
+  Check whether the IP is a valid unicast address according to
+  the netmask. If NetMask is zero, use the IP address's class to
+  get the default mask.
+
+  @param  Ip                    The IP to check againist
+  @param  NetMask               The mask of the IP
+
+  @return TRUE if IP is a valid unicast address on the network, otherwise FALSE
+
+**/
+BOOLEAN
+Ip4IsUnicast (
+  IN IP4_ADDR               Ip,
+  IN IP4_ADDR               NetMask
+  )
+{
+  INTN                      Class;
+
+  Class = NetGetIpClass (Ip);
+
+  if ((Ip == 0) || (Class >= IP4_ADDR_CLASSD)) {
+    return FALSE;
+  }
+
+  if (NetMask == 0) {
+    NetMask = mIp4AllMasks[Class << 3];
+  }
+
+  if (((Ip &~NetMask) == ~NetMask) || ((Ip &~NetMask) == 0)) {
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+
+/**
+  Initialize a random seed using current time.
+
+  None
+
+  @return The random seed initialized with current time.
+
+**/
+UINT32
+NetRandomInitSeed (
+  VOID
+  )
+{
+  EFI_TIME                  Time;
+  UINT32                    Seed;
+
+  gRT->GetTime (&Time, NULL);
+  Seed = (~Time.Hour << 24 | Time.Second << 16 | Time.Minute << 8 | Time.Day);
+  Seed ^= Time.Nanosecond;
+  Seed ^= Time.Year << 7;
+
+  return Seed;
+}
+
+
+/**
+  Extract a UINT32 from a byte stream, then convert it to host
+  byte order. Use this function to avoid alignment error.
+
+  @param  Buf                   The buffer to extract the UINT32.
+
+  @return The UINT32 extracted.
+
+**/
+UINT32
+NetGetUint32 (
+  IN UINT8                  *Buf
+  )
+{
+  UINT32                    Value;
+
+  NetCopyMem (&Value, Buf, sizeof (UINT32));
+  return NTOHL (Value);
+}
+
+
+/**
+  Put a UINT32 to the byte stream. Convert it from host byte order
+  to network byte order before putting.
+
+  @param  Buf                   The buffer to put the UINT32
+  @param  Data                  The data to put
+
+  @return None
+
+**/
+VOID
+NetPutUint32 (
+  IN UINT8                  *Buf,
+  IN UINT32                 Data
+  )
+{
+  Data = HTONL (Data);
+  NetCopyMem (Buf, &Data, sizeof (UINT32));
+}
+
+
+/**
+  Remove the first entry on the list
+
+  @param  Head                  The list header
+
+  @return The entry that is removed from the list, NULL if the list is empty.
+
+**/
+NET_LIST_ENTRY *
+NetListRemoveHead (
+  NET_LIST_ENTRY            *Head
+  )
+{
+  NET_LIST_ENTRY            *First;
+
+  ASSERT (Head != NULL);
+
+  if (NetListIsEmpty (Head)) {
+    return NULL;
+  }
+
+  First                         = Head->ForwardLink;
+  Head->ForwardLink             = First->ForwardLink;
+  First->ForwardLink->BackLink  = Head;
+
+  DEBUG_CODE (
+    First->ForwardLink  = (LIST_ENTRY     *) NULL;
+    First->BackLink     = (LIST_ENTRY     *) NULL;
+  );
+
+  return First;
+}
+
+
+/**
+  Remove the last entry on the list
+
+  @param  Head                  The list head
+
+  @return The entry that is removed from the list, NULL if the list is empty.
+
+**/
+NET_LIST_ENTRY *
+NetListRemoveTail (
+  NET_LIST_ENTRY            *Head
+  )
+{
+  NET_LIST_ENTRY            *Last;
+
+  ASSERT (Head != NULL);
+
+  if (NetListIsEmpty (Head)) {
+    return NULL;
+  }
+
+  Last                        = Head->BackLink;
+  Head->BackLink              = Last->BackLink;
+  Last->BackLink->ForwardLink = Head;
+
+  DEBUG_CODE (
+    Last->ForwardLink = (LIST_ENTRY     *) NULL;
+    Last->BackLink    = (LIST_ENTRY     *) NULL;
+  );
+
+  return Last;
+}
+
+
+/**
+  Insert the NewEntry after the PrevEntry
+
+  @param  PrevEntry             The previous entry to insert after
+  @param  NewEntry              The new entry to insert
+
+  @return None
+
+**/
+VOID
+NetListInsertAfter (
+  IN NET_LIST_ENTRY         *PrevEntry,
+  IN NET_LIST_ENTRY         *NewEntry
+  )
+{
+  NewEntry->BackLink                = PrevEntry;
+  NewEntry->ForwardLink             = PrevEntry->ForwardLink;
+  PrevEntry->ForwardLink->BackLink  = NewEntry;
+  PrevEntry->ForwardLink            = NewEntry;
+}
+
+
+/**
+  Insert the NewEntry before the PostEntry
+
+  @param  PostEntry             The entry to insert before
+  @param  NewEntry              The new entry to insert
+
+  @return None
+
+**/
+VOID
+NetListInsertBefore (
+  IN NET_LIST_ENTRY *PostEntry,
+  IN NET_LIST_ENTRY *NewEntry
+  )
+{
+  NewEntry->ForwardLink             = PostEntry;
+  NewEntry->BackLink                = PostEntry->BackLink;
+  PostEntry->BackLink->ForwardLink  = NewEntry;
+  PostEntry->BackLink               = NewEntry;
+}
+
+
+/**
+  Initialize the netmap. Netmap is a reposity to keep the <Key, Value> pairs.
+
+  @param  Map                   The netmap to initialize
+
+  @return None
+
+**/
+VOID
+NetMapInit (
+  IN NET_MAP                *Map
+  )
+{
+  ASSERT (Map != NULL);
+
+  NetListInit (&Map->Used);
+  NetListInit (&Map->Recycled);
+  Map->Count = 0;
+}
+
+
+/**
+  To clean up the netmap, that is, release allocated memories.
+
+  @param  Map                   The netmap to clean up.
+
+  @return None
+
+**/
+VOID
+NetMapClean (
+  IN NET_MAP                *Map
+  )
+{
+  NET_MAP_ITEM              *Item;
+  NET_LIST_ENTRY            *Entry;
+  NET_LIST_ENTRY            *Next;
+
+  ASSERT (Map != NULL);
+
+  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Map->Used) {
+    Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
+
+    NetListRemoveEntry (&Item->Link);
+    Map->Count--;
+
+    NetFreePool (Item);
+  }
+
+  ASSERT ((Map->Count == 0) && NetListIsEmpty (&Map->Used));
+
+  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Map->Recycled) {
+    Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
+
+    NetListRemoveEntry (&Item->Link);
+    NetFreePool (Item);
+  }
+
+  ASSERT (NetListIsEmpty (&Map->Recycled));
+}
+
+
+/**
+  Test whether the netmap is empty
+
+  @param  Map                   The net map to test
+
+  @return TRUE if the netmap is empty, otherwise FALSE.
+
+**/
+BOOLEAN
+NetMapIsEmpty (
+  IN NET_MAP                *Map
+  )
+{
+  ASSERT (Map != NULL);
+  return (BOOLEAN) (Map->Count == 0);
+}
+
+
+/**
+  Return the number of the <Key, Value> pairs in the netmap.
+
+  @param  Map                   The netmap to get the entry number
+
+  @return The entry number in the netmap.
+
+**/
+UINTN
+NetMapGetCount (
+  IN NET_MAP                *Map
+  )
+{
+  return Map->Count;
+}
+
+
+/**
+  Allocate an item for the netmap. It will try to allocate
+  a batch of items and return one.
+
+  @param  Map                   The netmap to allocate item for
+
+  @return The allocated item or NULL
+
+**/
+STATIC
+NET_MAP_ITEM *
+NetMapAllocItem (
+  IN NET_MAP                *Map
+  )
+{
+  NET_MAP_ITEM              *Item;
+  NET_LIST_ENTRY            *Head;
+  UINTN                     Index;
+
+  ASSERT (Map != NULL);
+
+  Head = &Map->Recycled;
+
+  if (NetListIsEmpty (Head)) {
+    for (Index = 0; Index < NET_MAP_INCREAMENT; Index++) {
+      Item = NetAllocatePool (sizeof (NET_MAP_ITEM));
+
+      if (Item == NULL) {
+        if (Index == 0) {
+          return NULL;
+        }
+
+        break;
+      }
+
+      NetListInsertHead (Head, &Item->Link);
+    }
+  }
+
+  Item = NET_LIST_HEAD (Head, NET_MAP_ITEM, Link);
+  NetListRemoveHead (Head);
+
+  return Item;
+}
+
+
+/**
+  Allocate an item to save the <Key, Value> pair to the head of the netmap.
+
+  @param  Map                   The netmap to insert into
+  @param  Key                   The user's key
+  @param  Value                 The user's value for the key
+
+  @retval EFI_OUT_OF_RESOURCES  Failed to allocate the memory for the item
+  @retval EFI_SUCCESS           The item is inserted to the head
+
+**/
+EFI_STATUS
+NetMapInsertHead (
+  IN NET_MAP                *Map,
+  IN VOID                   *Key,
+  IN VOID                   *Value    OPTIONAL
+  )
+{
+  NET_MAP_ITEM              *Item;
+
+  ASSERT (Map != NULL);
+
+  Item = NetMapAllocItem (Map);
+
+  if (Item == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Item->Key   = Key;
+  Item->Value = Value;
+  NetListInsertHead (&Map->Used, &Item->Link);
+
+  Map->Count++;
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Allocate an item to save the <Key, Value> pair to the tail of the netmap.
+
+  @param  Map                   The netmap to insert into
+  @param  Key                   The user's key
+  @param  Value                 The user's value for the key
+
+  @retval EFI_OUT_OF_RESOURCES  Failed to allocate the memory for the item
+  @retval EFI_SUCCESS           The item is inserted to the tail
+
+**/
+EFI_STATUS
+NetMapInsertTail (
+  IN NET_MAP                *Map,
+  IN VOID                   *Key,
+  IN VOID                   *Value    OPTIONAL
+  )
+{
+  NET_MAP_ITEM              *Item;
+
+  ASSERT (Map != NULL);
+
+  Item = NetMapAllocItem (Map);
+
+  if (Item == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Item->Key   = Key;
+  Item->Value = Value;
+  NetListInsertTail (&Map->Used, &Item->Link);
+
+  Map->Count++;
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Check whther the item is in the Map
+
+  @param  Map                   The netmap to search within
+  @param  Item                  The item to search
+
+  @return TRUE if the item is in the netmap, otherwise FALSE.
+
+**/
+STATIC
+BOOLEAN
+NetItemInMap (
+  IN NET_MAP                *Map,
+  IN NET_MAP_ITEM           *Item
+  )
+{
+  NET_LIST_ENTRY            *ListEntry;
+
+  NET_LIST_FOR_EACH (ListEntry, &Map->Used) {
+    if (ListEntry == &Item->Link) {
+      return TRUE;
+    }
+  }
+
+  return FALSE;
+}
+
+
+/**
+  Find the key in the netmap
+
+  @param  Map                   The netmap to search within
+  @param  Key                   The key to search
+
+  @return The point to the item contains the Key, or NULL if Key isn't in the map.
+
+**/
+NET_MAP_ITEM *
+NetMapFindKey (
+  IN  NET_MAP               *Map,
+  IN  VOID                  *Key
+  )
+{
+  NET_LIST_ENTRY          *Entry;
+  NET_MAP_ITEM            *Item;
+
+  ASSERT (Map != NULL);
+
+  NET_LIST_FOR_EACH (Entry, &Map->Used) {
+    Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
+
+    if (Item->Key == Key) {
+      return Item;
+    }
+  }
+
+  return NULL;
+}
+
+
+/**
+  Remove the item from the netmap
+
+  @param  Map                   The netmap to remove the item from
+  @param  Item                  The item to remove
+  @param  Value                 The variable to receive the value if not NULL
+
+  @return The key of the removed item.
+
+**/
+VOID *
+NetMapRemoveItem (
+  IN  NET_MAP             *Map,
+  IN  NET_MAP_ITEM        *Item,
+  OUT VOID                **Value           OPTIONAL
+  )
+{
+  ASSERT ((Map != NULL) && (Item != NULL));
+  ASSERT (NetItemInMap (Map, Item));
+
+  NetListRemoveEntry (&Item->Link);
+  Map->Count--;
+  NetListInsertHead (&Map->Recycled, &Item->Link);
+
+  if (Value != NULL) {
+    *Value = Item->Value;
+  }
+
+  return Item->Key;
+}
+
+
+/**
+  Remove the first entry on the netmap
+
+  @param  Map                   The netmap to remove the head from
+  @param  Value                 The variable to receive the value if not NULL
+
+  @return The key of the item removed
+
+**/
+VOID *
+NetMapRemoveHead (
+  IN  NET_MAP               *Map,
+  OUT VOID                  **Value         OPTIONAL
+  )
+{
+  NET_MAP_ITEM  *Item;
+
+  //
+  // Often, it indicates a programming error to remove
+  // the first entry in an empty list
+  //
+  ASSERT (Map && !NetListIsEmpty (&Map->Used));
+
+  Item = NET_LIST_HEAD (&Map->Used, NET_MAP_ITEM, Link);
+  NetListRemoveEntry (&Item->Link);
+  Map->Count--;
+  NetListInsertHead (&Map->Recycled, &Item->Link);
+
+  if (Value != NULL) {
+    *Value = Item->Value;
+  }
+
+  return Item->Key;
+}
+
+
+/**
+  Remove the last entry on the netmap
+
+  @param  Map                   The netmap to remove the tail from
+  @param  Value                 The variable to receive the value if not NULL
+
+  @return The key of the item removed
+
+**/
+VOID *
+NetMapRemoveTail (
+  IN  NET_MAP               *Map,
+  OUT VOID                  **Value       OPTIONAL
+  )
+{
+  NET_MAP_ITEM              *Item;
+
+  //
+  // Often, it indicates a programming error to remove
+  // the last entry in an empty list
+  //
+  ASSERT (Map && !NetListIsEmpty (&Map->Used));
+
+  Item = NET_LIST_TAIL (&Map->Used, NET_MAP_ITEM, Link);
+  NetListRemoveEntry (&Item->Link);
+  Map->Count--;
+  NetListInsertHead (&Map->Recycled, &Item->Link);
+
+  if (Value != NULL) {
+    *Value = Item->Value;
+  }
+
+  return Item->Key;
+}
+
+
+/**
+  Iterate through the netmap and call CallBack for each item. It will
+  contiue the traverse if CallBack returns EFI_SUCCESS, otherwise, break
+  from the loop. It returns the CallBack's last return value. This
+  function is delete safe for the current item.
+
+  @param  Map                   The Map to iterate through
+  @param  CallBack              The callback function to call for each item.
+  @param  Arg                   The opaque parameter to the callback
+
+  @return It returns the CallBack's last return value.
+
+**/
+EFI_STATUS
+NetMapIterate (
+  IN NET_MAP                *Map,
+  IN NET_MAP_CALLBACK       CallBack,
+  IN VOID                   *Arg
+  )
+{
+
+  NET_LIST_ENTRY            *Entry;
+  NET_LIST_ENTRY            *Next;
+  NET_LIST_ENTRY            *Head;
+  NET_MAP_ITEM              *Item;
+  EFI_STATUS                Result;
+
+  ASSERT ((Map != NULL) && (CallBack != NULL));
+
+  Head = &Map->Used;
+
+  if (NetListIsEmpty (Head)) {
+    return EFI_SUCCESS;
+  }
+
+  NET_LIST_FOR_EACH_SAFE (Entry, Next, Head) {
+    Item   = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
+    Result = CallBack (Map, Item, Arg);
+
+    if (EFI_ERROR (Result)) {
+      return Result;
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  This is the default unload handle for all the network drivers.
+
+  @param  ImageHandle           The drivers' driver image.
+
+  @retval EFI_SUCCESS           The image is unloaded.
+  @retval Others                Failed to unload the image.
+
+**/
+EFI_STATUS
+EFIAPI
+NetLibDefaultUnload (
+  IN EFI_HANDLE             ImageHandle
+  )
+{
+  EFI_STATUS                        Status;
+  EFI_HANDLE                        *DeviceHandleBuffer;
+  UINTN                             DeviceHandleCount;
+  UINTN                             Index;
+  EFI_DRIVER_BINDING_PROTOCOL       *DriverBinding;
+#if (EFI_SPECIFICATION_VERSION >= 0x00020000)
+  EFI_COMPONENT_NAME2_PROTOCOL      *ComponentName;
+#else
+  EFI_COMPONENT_NAME_PROTOCOL       *ComponentName;
+#endif
+  EFI_DRIVER_CONFIGURATION_PROTOCOL *DriverConfiguration;
+  EFI_DRIVER_DIAGNOSTICS_PROTOCOL   *DriverDiagnostics;
+
+  //
+  // Get the list of all the handles in the handle database.
+  // If there is an error getting the list, then the unload
+  // operation fails.
+  //
+  Status = gBS->LocateHandleBuffer (
+                  AllHandles,
+                  NULL,
+                  NULL,
+                  &DeviceHandleCount,
+                  &DeviceHandleBuffer
+                  );
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Disconnect the driver specified by ImageHandle from all
+  // the devices in the handle database.
+  //
+  for (Index = 0; Index < DeviceHandleCount; Index++) {
+    Status = gBS->DisconnectController (
+                    DeviceHandleBuffer[Index],
+                    ImageHandle,
+                    NULL
+                    );
+  }
+
+  //
+  // Uninstall all the protocols installed in the driver entry point
+  //
+  for (Index = 0; Index < DeviceHandleCount; Index++) {
+    Status = gBS->HandleProtocol (
+                    DeviceHandleBuffer[Index],
+                    &gEfiDriverBindingProtocolGuid,
+                    &DriverBinding
+                    );
+
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+
+    if (DriverBinding->ImageHandle != ImageHandle) {
+      continue;
+    }
+
+    gBS->UninstallProtocolInterface (
+          ImageHandle,
+          &gEfiDriverBindingProtocolGuid,
+          DriverBinding
+          );
+#if (EFI_SPECIFICATION_VERSION >= 0x00020000)
+    Status = gBS->HandleProtocol (
+                    DeviceHandleBuffer[Index],
+                    &gEfiComponentName2ProtocolGuid,
+                    &ComponentName
+                    );
+    if (!EFI_ERROR (Status)) {
+      gBS->UninstallProtocolInterface (
+            ImageHandle,
+            &gEfiComponentName2ProtocolGuid,
+            ComponentName
+            );
+    }
+#else
+    Status = gBS->HandleProtocol (
+                    DeviceHandleBuffer[Index],
+                    &gEfiComponentNameProtocolGuid,
+                    &ComponentName
+                    );
+    if (!EFI_ERROR (Status)) {
+      gBS->UninstallProtocolInterface (
+             ImageHandle,
+             &gEfiComponentNameProtocolGuid,
+             ComponentName
+             );
+    }
+#endif
+
+    Status = gBS->HandleProtocol (
+                    DeviceHandleBuffer[Index],
+                    &gEfiDriverConfigurationProtocolGuid,
+                    &DriverConfiguration
+                    );
+
+    if (!EFI_ERROR (Status)) {
+      gBS->UninstallProtocolInterface (
+            ImageHandle,
+            &gEfiDriverConfigurationProtocolGuid,
+            DriverConfiguration
+            );
+    }
+
+    Status = gBS->HandleProtocol (
+                    DeviceHandleBuffer[Index],
+                    &gEfiDriverDiagnosticsProtocolGuid,
+                    &DriverDiagnostics
+                    );
+
+    if (!EFI_ERROR (Status)) {
+      gBS->UninstallProtocolInterface (
+            ImageHandle,
+            &gEfiDriverDiagnosticsProtocolGuid,
+            DriverDiagnostics
+            );
+    }
+  }
+
+  //
+  // Free the buffer containing the list of handles from the handle database
+  //
+  if (DeviceHandleBuffer != NULL) {
+    gBS->FreePool (DeviceHandleBuffer);
+  }
+
+  return EFI_SUCCESS;
+}
+
+
+
+/**
+  Create a child of the service that is identified by ServiceBindingGuid.
+
+  @param  Controller            The controller which has the service installed.
+  @param  Image                 The image handle used to open service.
+  @param  ServiceBindingGuid    The service's Guid.
+  @param  ChildHandle           The handle to receive the create child
+
+  @retval EFI_SUCCESS           The child is successfully created.
+  @retval Others                Failed to create the child.
+
+**/
+EFI_STATUS
+NetLibCreateServiceChild (
+  IN  EFI_HANDLE            Controller,
+  IN  EFI_HANDLE            Image,
+  IN  EFI_GUID              *ServiceBindingGuid,
+  OUT EFI_HANDLE            *ChildHandle
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_SERVICE_BINDING_PROTOCOL  *Service;
+
+
+  ASSERT ((ServiceBindingGuid != NULL) && (ChildHandle != NULL));
+
+  //
+  // Get the ServiceBinding Protocol
+  //
+  Status = gBS->OpenProtocol (
+                  Controller,
+                  ServiceBindingGuid,
+                  (VOID **) &Service,
+                  Image,
+                  Controller,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Create a child
+  //
+  Status = Service->CreateChild (Service, ChildHandle);
+  return Status;
+}
+
+
+/**
+  Destory a child of the service that is identified by ServiceBindingGuid.
+
+  @param  Controller            The controller which has the service installed.
+  @param  Image                 The image handle used to open service.
+  @param  ServiceBindingGuid    The service's Guid.
+  @param  ChildHandle           The child to destory
+
+  @retval EFI_SUCCESS           The child is successfully destoried.
+  @retval Others                Failed to destory the child.
+
+**/
+EFI_STATUS
+NetLibDestroyServiceChild (
+  IN  EFI_HANDLE            Controller,
+  IN  EFI_HANDLE            Image,
+  IN  EFI_GUID              *ServiceBindingGuid,
+  IN  EFI_HANDLE            ChildHandle
+  )
+{
+  EFI_STATUS                    Status;
+  EFI_SERVICE_BINDING_PROTOCOL  *Service;
+
+  ASSERT (ServiceBindingGuid != NULL);
+
+  //
+  // Get the ServiceBinding Protocol
+  //
+  Status = gBS->OpenProtocol (
+                  Controller,
+                  ServiceBindingGuid,
+                  (VOID **) &Service,
+                  Image,
+                  Controller,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // destory the child
+  //
+  Status = Service->DestroyChild (Service, ChildHandle);
+  return Status;
+}
+
+
+/**
+  Convert the mac address of the simple network protocol installed on
+  SnpHandle to a unicode string. Callers are responsible for freeing the
+  string storage.
+
+  @param  SnpHandle             The handle where the simple network protocol is
+                                installed on.
+  @param  ImageHandle           The image handle used to act as the agent handle to
+                                get the simple network protocol.
+  @param  MacString             The pointer to store the address of the string
+                                representation of  the mac address.
+
+  @retval EFI_OUT_OF_RESOURCES  There are not enough memory resource.
+  @retval other                 Failed to open the simple network protocol.
+
+**/
+EFI_STATUS
+NetLibGetMacString (
+  IN           EFI_HANDLE  SnpHandle,
+  IN           EFI_HANDLE  ImageHandle,
+  IN OUT CONST CHAR16      **MacString
+  )
+{
+  EFI_STATUS                   Status;
+  EFI_SIMPLE_NETWORK_PROTOCOL  *Snp;
+  EFI_SIMPLE_NETWORK_MODE      *Mode;
+  CHAR16                       *MacAddress;
+  UINTN                        Index;
+
+  *MacString = NULL;
+
+  //
+  // Get the Simple Network protocol from the SnpHandle.
+  //
+  Status = gBS->OpenProtocol (
+                  SnpHandle,
+                  &gEfiSimpleNetworkProtocolGuid,
+                  (VOID **) &Snp,
+                  ImageHandle,
+                  SnpHandle,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Mode = Snp->Mode;
+
+  //
+  // It takes 2 unicode characters to represent a 1 byte binary buffer.
+  // Plus one unicode character for the null-terminator.
+  //
+  MacAddress = NetAllocatePool ((2 * Mode->HwAddressSize + 1) * sizeof (CHAR16));
+  if (MacAddress == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Convert the mac address into a unicode string.
+  //
+  for (Index = 0; Index < Mode->HwAddressSize; Index++) {
+    MacAddress[Index * 2]     = NibbleToHexChar (Mode->CurrentAddress.Addr[Index] >> 4);
+    MacAddress[Index * 2 + 1] = NibbleToHexChar (Mode->CurrentAddress.Addr[Index]);
+  }
+
+  MacAddress[Mode->HwAddressSize * 2] = L'\0';
+
+  *MacString = MacAddress;
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Find the UNDI/SNP handle from controller and protocol GUID.
+  For example, IP will open a MNP child to transmit/receive
+  packets, when MNP is stopped, IP should also be stopped. IP
+  needs to find its own private data which is related the IP's
+  service binding instance that is install on UNDI/SNP handle.
+  Now, the controller is either a MNP or ARP child handle. But
+  IP opens these handle BY_DRIVER, use that info, we can get the
+  UNDI/SNP handle.
+
+  @param  Controller            Then protocol handle to check
+  @param  ProtocolGuid          The protocol that is related with the handle.
+
+  @return The UNDI/SNP handle or NULL.
+
+**/
+EFI_HANDLE
+NetLibGetNicHandle (
+  IN EFI_HANDLE             Controller,
+  IN EFI_GUID               *ProtocolGuid
+  )
+{
+  EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenBuffer;
+  EFI_HANDLE                          Handle;
+  EFI_STATUS                          Status;
+  UINTN                               OpenCount;
+  UINTN                               Index;
+
+  Status = gBS->OpenProtocolInformation (
+                  Controller,
+                  ProtocolGuid,
+                  &OpenBuffer,
+                  &OpenCount
+                  );
+
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  }
+
+  Handle = NULL;
+
+  for (Index = 0; Index < OpenCount; Index++) {
+    if (OpenBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) {
+      Handle = OpenBuffer[Index].ControllerHandle;
+      break;
+    }
+  }
+
+  gBS->FreePool (OpenBuffer);
+  return Handle;
+}
+
+EFI_STATUS
+NetLibInstallAllDriverProtocols (
+  IN EFI_HANDLE                         ImageHandle,
+  IN EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL        *DriverBinding,
+  IN EFI_HANDLE                         DriverBindingHandle,
+  IN EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
+  IN EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration, OPTIONAL
+  IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics    OPTIONAL
+  )
+/*++
+
+Routine Description:
+
+  Intialize a driver by installing the Driver Binding Protocol onto the
+  driver's DriverBindingHandle.  This is typically the same as the driver's
+  ImageHandle, but it can be different if the driver produces multiple
+  DriverBinding Protocols.  This function also initializes the EFI Driver
+  Library that initializes the global variables gST, gBS, gRT.
+
+Arguments:
+
+  ImageHandle         - The image handle of the driver
+  SystemTable         - The EFI System Table that was passed to the driver's
+                        entry point
+  DriverBinding       - A Driver Binding Protocol instance that this driver
+                        is producing.
+  DriverBindingHandle - The handle that DriverBinding is to be installe onto.
+                        If this parameter is NULL, then a new handle is created.
+  ComponentName       - A Component Name Protocol instance that this driver is
+                        producing.
+  DriverConfiguration - A Driver Configuration Protocol instance that this
+                        driver is producing.
+  DriverDiagnostics   - A Driver Diagnostics Protocol instance that this
+                        driver is producing.
+
+Returns:
+
+  EFI_SUCCESS if all the protocols were installed onto DriverBindingHandle
+  Otherwise, then return status from gBS->InstallProtocolInterface()
+
+--*/
+{
+  return NetLibInstallAllDriverProtocolsWithUnload (
+           ImageHandle,
+           SystemTable,
+           DriverBinding,
+           DriverBindingHandle,
+           ComponentName,
+           DriverConfiguration,
+           DriverDiagnostics,
+           NetLibDefaultUnload
+           );
+}
+
+EFI_STATUS
+NetLibInstallAllDriverProtocolsWithUnload (
+  IN EFI_HANDLE                         ImageHandle,
+  IN EFI_SYSTEM_TABLE                   *SystemTable,
+  IN EFI_DRIVER_BINDING_PROTOCOL        *DriverBinding,
+  IN EFI_HANDLE                         DriverBindingHandle,
+  IN EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
+  IN EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration,   OPTIONAL
+  IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics,     OPTIONAL
+  IN NET_LIB_DRIVER_UNLOAD              Unload
+  )
+/*++
+
+Routine Description:
+
+  Intialize a driver by installing the Driver Binding Protocol onto the
+  driver's DriverBindingHandle.  This is typically the same as the driver's
+  ImageHandle, but it can be different if the driver produces multiple
+  DriverBinding Protocols.  This function also initializes the EFI Driver
+  Library that initializes the global variables gST, gBS, gRT.
+
+Arguments:
+
+  ImageHandle         - The image handle of the driver
+  SystemTable         - The EFI System Table that was passed to the driver's
+                        entry point
+  DriverBinding       - A Driver Binding Protocol instance that this driver
+                        is producing.
+  DriverBindingHandle - The handle that DriverBinding is to be installe onto.
+                        If this parameter is NULL, then a new handle is created.
+  ComponentName       - A Component Name Protocol instance that this driver is
+                        producing.
+  DriverConfiguration - A Driver Configuration Protocol instance that this
+                        driver is producing.
+  DriverDiagnostics   - A Driver Diagnostics Protocol instance that this
+                        driver is producing.
+  Unload    - The customized unload to install.
+
+Returns:
+
+  EFI_SUCCESS if all the protocols were installed onto DriverBindingHandle
+  Otherwise, then return status from gBS->InstallProtocolInterface()
+
+--*/
+{
+  EFI_STATUS                Status;
+  EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
+
+  Status = EfiLibInstallAllDriverProtocols (
+             ImageHandle,
+             SystemTable,
+             DriverBinding,
+             DriverBindingHandle,
+             ComponentName,
+             DriverConfiguration,
+             DriverDiagnostics
+             );
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Retrieve the Loaded Image Protocol from Image Handle
+  //
+  Status = gBS->OpenProtocol (
+                  ImageHandle,
+                  &gEfiLoadedImageProtocolGuid,
+                  (VOID **) &LoadedImage,
+                  ImageHandle,
+                  ImageHandle,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Fill in the Unload() service of the Loaded Image Protocol
+  //
+  LoadedImage->Unload = (Unload == NULL) ? NetLibDefaultUnload : Unload;
+  return EFI_SUCCESS;
+}
+
diff --git a/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf
new file mode 100644 (file)
index 0000000..be9ff1b
--- /dev/null
@@ -0,0 +1,66 @@
+#/** @file\r
+# Component name for module NetLib\r
+#\r
+# FIX ME!\r
+# Copyright (c) 2006, Intel Corporation. All right reserved.\r
+#\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
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010005\r
+  BASE_NAME                      = NetLibDxe\r
+  FILE_GUID                      = db6dcef3-9f4e-4340-9351-fc35aa8a5888\r
+  MODULE_TYPE                    = DXE_DRIVER\r
+  VERSION_STRING                 = 1.0\r
+  LIBRARY_CLASS                  = NetLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER\r
+  EDK_RELEASE_VERSION            = 0x00020000\r
+  EFI_SPECIFICATION_VERSION      = 0x00020000\r
+\r
+\r
+#\r
+# The following information is for reference only and not required by the build tools.\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC\r
+#\r
+\r
+[Sources.common]\r
+  DxeNetLib.c\r
+  NetBuffer.c\r
+\r
+[Packages]\r
+  MdePkg/MdePkg.dec\r
+  MdeModulePkg/MdeModulePkg.dec\r
+\r
+\r
+[LibraryClasses]\r
+  MemoryAllocationLib\r
+  UefiLib\r
+  BaseLib\r
+  UefiBootServicesTableLib\r
+  UefiRuntimeServicesTableLib\r
+  BaseMemoryLib\r
+  DebugLib\r
+  PrintLib\r
+\r
+\r
+[Protocols]\r
+  gEfiIp4ProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverDiagnosticsProtocolGuid             # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiUdp4ServiceBindingProtocolGuid            # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiLoadedImageProtocolGuid                   # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiIp4ServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverConfigurationProtocolGuid           # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiSimpleNetworkProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverBindingProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiUdp4ProtocolGuid                          # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiComponentNameProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+\r
diff --git a/MdeModulePkg/Library/DxeNetLib/Netbuffer.c b/MdeModulePkg/Library/DxeNetLib/Netbuffer.c
new file mode 100644 (file)
index 0000000..f32e31e
--- /dev/null
@@ -0,0 +1,1759 @@
+/** @file\r
+\r
+Copyright (c) 2005 - 2006, 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
+Module Name:\r
+\r
+  NetBuffer.c\r
+\r
+Abstract:\r
+\r
+\r
+\r
+**/\r
+\r
+#include <PiDxe.h>
+
+#include <Library/NetLib.h>
+#include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/MemoryAllocationLib.h>\r
+\r
+\r
+/**\r
+  Allocate and build up the sketch for a NET_BUF. The net buffer allocated\r
+  has the BlockOpNum's NET_BLOCK_OP, and its associated NET_VECTOR has the\r
+  BlockNum's NET_BLOCK.\r
+\r
+  @param  BlockNum              The number of NET_BLOCK in the Vector of net buffer\r
+  @param  BlockOpNum            The number of NET_BLOCK_OP in the net buffer\r
+\r
+  @retval *                     Pointer to the allocated NET_BUF. If NULL  the\r
+                                allocation failed due to resource limit.\r
+\r
+**/\r
+STATIC\r
+NET_BUF *\r
+NetbufAllocStruct (\r
+  IN UINT32                 BlockNum,\r
+  IN UINT32                 BlockOpNum\r
+  )\r
+{\r
+  NET_BUF                   *Nbuf;\r
+  NET_VECTOR                *Vector;\r
+\r
+  ASSERT (BlockOpNum >= 1);\r
+\r
+  //\r
+  // Allocate three memory blocks.\r
+  //\r
+  Nbuf = NetAllocateZeroPool (NET_BUF_SIZE (BlockOpNum));\r
+\r
+  if (Nbuf == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  Nbuf->Signature           = NET_BUF_SIGNATURE;\r
+  Nbuf->RefCnt              = 1;\r
+  Nbuf->BlockOpNum          = BlockOpNum;\r
+  NetListInit (&Nbuf->List);\r
+\r
+  if (BlockNum != 0) {\r
+    Vector = NetAllocateZeroPool (NET_VECTOR_SIZE (BlockNum));\r
+\r
+    if (Vector == NULL) {\r
+      goto FreeNbuf;\r
+    }\r
+\r
+    Vector->Signature = NET_VECTOR_SIGNATURE;\r
+    Vector->RefCnt    = 1;\r
+    Vector->BlockNum  = BlockNum;\r
+    Nbuf->Vector      = Vector;\r
+  }\r
+\r
+  return Nbuf;\r
+\r
+FreeNbuf:\r
+\r
+  NetFreePool (Nbuf);\r
+  return NULL;\r
+}\r
+\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
+NetbufAlloc (\r
+  IN UINT32                 Len\r
+  )\r
+{\r
+  NET_BUF                   *Nbuf;\r
+  NET_VECTOR                *Vector;\r
+  UINT8                     *Bulk;\r
+\r
+  ASSERT (Len > 0);\r
+\r
+  Nbuf = NetbufAllocStruct (1, 1);\r
+\r
+  if (Nbuf == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  Bulk = NetAllocatePool (Len);\r
+\r
+  if (Bulk == NULL) {\r
+    goto FreeNBuf;\r
+  }\r
+\r
+  Vector = Nbuf->Vector;\r
+  Vector->Len                 = Len;\r
+\r
+  Vector->Block[0].Bulk       = Bulk;\r
+  Vector->Block[0].Len        = Len;\r
+\r
+  Nbuf->BlockOp[0].BlockHead  = Bulk;\r
+  Nbuf->BlockOp[0].BlockTail  = Bulk + Len;\r
+\r
+  Nbuf->BlockOp[0].Head       = Bulk;\r
+  Nbuf->BlockOp[0].Tail       = Bulk;\r
+  Nbuf->BlockOp[0].Size       = 0;\r
+\r
+  return Nbuf;\r
+\r
+FreeNBuf:\r
+  NetFreePool (Nbuf);\r
+  return NULL;\r
+}\r
+\r
+\r
+/**\r
+  Free the vector\r
+\r
+  @param  Vector                Pointer to the NET_VECTOR to be freed.\r
+\r
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+NetbufFreeVector (\r
+  IN NET_VECTOR             *Vector\r
+  )\r
+{\r
+  UINT32                    Index;\r
+\r
+  NET_CHECK_SIGNATURE (Vector, NET_VECTOR_SIGNATURE);\r
+  ASSERT (Vector->RefCnt > 0);\r
+\r
+  Vector->RefCnt--;\r
+\r
+  if (Vector->RefCnt > 0) {\r
+    return;\r
+  }\r
+\r
+  if (Vector->Free != NULL) {\r
+    //\r
+    // Call external free function to free the vector if it\r
+    // isn't NULL. If NET_VECTOR_OWN_FIRST is set, release the\r
+    // first block since it is allocated by us\r
+    //\r
+    if (Vector->Flag & NET_VECTOR_OWN_FIRST) {\r
+      NetFreePool (Vector->Block[0].Bulk);\r
+    }\r
+\r
+    Vector->Free (Vector->Arg);\r
+\r
+  } else {\r
+    //\r
+    // Free each memory block associated with the Vector\r
+    //\r
+    for (Index = 0; Index < Vector->BlockNum; Index++) {\r
+      NetFreePool (Vector->Block[Index].Bulk);\r
+    }\r
+  }\r
+\r
+  NetFreePool (Vector);\r
+}\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
+NetbufFree (\r
+  IN NET_BUF                *Nbuf\r
+  )\r
+{\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+  ASSERT (Nbuf->RefCnt > 0);\r
+\r
+  Nbuf->RefCnt--;\r
+\r
+  if (Nbuf->RefCnt == 0) {\r
+    //\r
+    // Update Vector only when NBuf is to be released. That is,\r
+    // all the sharing of Nbuf increse Vector's RefCnt by one\r
+    //\r
+    NetbufFreeVector (Nbuf->Vector);\r
+    NetFreePool (Nbuf);\r
+  }\r
+}\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
+NetbufClone (\r
+  IN NET_BUF                *Nbuf\r
+  )\r
+{\r
+  NET_BUF                   *Clone;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+  Clone = NetAllocatePool (NET_BUF_SIZE (Nbuf->BlockOpNum));\r
+\r
+  if (Clone == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  Clone->Signature  = NET_BUF_SIGNATURE;\r
+  Clone->RefCnt     = 1;\r
+  NetListInit (&Clone->List);\r
+\r
+  Clone->Ip   = Nbuf->Ip;\r
+  Clone->Tcp  = Nbuf->Tcp;\r
+\r
+  NetCopyMem (Clone->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+\r
+  NET_GET_REF (Nbuf->Vector);\r
+\r
+  Clone->Vector     = Nbuf->Vector;\r
+  Clone->BlockOpNum = Nbuf->BlockOpNum;\r
+  Clone->TotalSize  = Nbuf->TotalSize;\r
+  NetCopyMem (Clone->BlockOp, Nbuf->BlockOp, sizeof (NET_BLOCK_OP) * Nbuf->BlockOpNum);\r
+\r
+  return Clone;\r
+}\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
+NetbufDuplicate (\r
+  IN NET_BUF                *Nbuf,\r
+  IN NET_BUF                *Duplicate        OPTIONAL,\r
+  IN UINT32                 HeadSpace\r
+  )\r
+{\r
+  UINT8                     *Dst;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+  if (Duplicate == NULL) {\r
+    Duplicate = NetbufAlloc (Nbuf->TotalSize + HeadSpace);\r
+  }\r
+\r
+  if (Duplicate == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  //\r
+  // Don't set the IP and TCP head point, since it is most\r
+  // like that they are pointing to the memory of Nbuf.\r
+  //\r
+  NetCopyMem (Duplicate->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+  NetbufReserve (Duplicate, HeadSpace);\r
+\r
+  Dst = NetbufAllocSpace (Duplicate, Nbuf->TotalSize, NET_BUF_TAIL);\r
+  NetbufCopy (Nbuf, 0, Nbuf->TotalSize, Dst);\r
+\r
+  return Duplicate;\r
+}\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
+NetbufFreeList (\r
+  IN NET_LIST_ENTRY         *Head\r
+  )\r
+{\r
+  NET_LIST_ENTRY            *Entry;\r
+  NET_LIST_ENTRY            *Next;\r
+  NET_BUF                   *Nbuf;\r
+\r
+  Entry = Head->ForwardLink;\r
+\r
+  NET_LIST_FOR_EACH_SAFE (Entry, Next, Head) {\r
+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+    NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+    NetListRemoveEntry (Entry);\r
+    NetbufFree (Nbuf);\r
+  }\r
+\r
+  ASSERT (NetListIsEmpty (Head));\r
+}\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
+NetbufGetByte (\r
+  IN  NET_BUF               *Nbuf,\r
+  IN  UINT32                Offset,\r
+  OUT UINT32                *Index  OPTIONAL\r
+  )\r
+{\r
+  NET_BLOCK_OP              *BlockOp;\r
+  UINT32                    Loop;\r
+  UINT32                    Len;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+  if (Offset >= Nbuf->TotalSize) {\r
+    return NULL;\r
+  }\r
+\r
+  BlockOp = Nbuf->BlockOp;\r
+  Len     = 0;\r
+\r
+  for (Loop = 0; Loop < Nbuf->BlockOpNum; Loop++) {\r
+\r
+    if (Len + BlockOp[Loop].Size <= Offset) {\r
+      Len += BlockOp[Loop].Size;\r
+      continue;\r
+    }\r
+\r
+    if (Index != NULL) {\r
+      *Index = Loop;\r
+    }\r
+\r
+    return BlockOp[Loop].Head + (Offset - Len);\r
+  }\r
+\r
+  return NULL;\r
+}\r
+\r
+\r
+\r
+/**\r
+  Set the NET_BLOCK and corresponding NET_BLOCK_OP in\r
+  the buffer. All the pointers in NET_BLOCK and NET_BLOCK_OP\r
+  are set to the bulk's head and tail respectively. So, this\r
+  function alone can't be used by NetbufAlloc.\r
+\r
+  @param  Nbuf                  Pointer to the net buffer.\r
+  @param  Bulk                  Pointer to the data.\r
+  @param  Len                   Length of the bulk data.\r
+  @param  Index                 The data block index in the net buffer the bulk\r
+                                data should belong to.\r
+\r
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+NetbufSetBlock (\r
+  IN NET_BUF                *Nbuf,\r
+  IN UINT8                  *Bulk,\r
+  IN UINT32                 Len,\r
+  IN UINT32                 Index\r
+  )\r
+{\r
+  NET_BLOCK_OP              *BlockOp;\r
+  NET_BLOCK                 *Block;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+  NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);\r
+  ASSERT (Index < Nbuf->BlockOpNum);\r
+\r
+  Block               = &(Nbuf->Vector->Block[Index]);\r
+  BlockOp             = &(Nbuf->BlockOp[Index]);\r
+  Block->Len          = Len;\r
+  Block->Bulk         = Bulk;\r
+  BlockOp->BlockHead  = Bulk;\r
+  BlockOp->BlockTail  = Bulk + Len;\r
+  BlockOp->Head       = Bulk;\r
+  BlockOp->Tail       = Bulk + Len;\r
+  BlockOp->Size       = Len;\r
+}\r
+\r
+\r
+\r
+/**\r
+  Set the NET_BLOCK_OP in the buffer. The corresponding NET_BLOCK\r
+  structure is left untouched. Some times, there is no 1:1 relationship\r
+  between NET_BLOCK and NET_BLOCK_OP. For example, that in NetbufGetFragment.\r
+\r
+  @param  Nbuf                  Pointer to the net buffer.\r
+  @param  Bulk                  Pointer to the data.\r
+  @param  Len                   Length of the bulk data.\r
+  @param  Index                 The data block index in the net buffer the bulk\r
+                                data should belong to.\r
+\r
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+NetbufSetBlockOp (\r
+  IN NET_BUF                *Nbuf,\r
+  IN UINT8                  *Bulk,\r
+  IN UINT32                 Len,\r
+  IN UINT32                 Index\r
+  )\r
+{\r
+  NET_BLOCK_OP              *BlockOp;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+  ASSERT (Index < Nbuf->BlockOpNum);\r
+\r
+  BlockOp             = &(Nbuf->BlockOp[Index]);\r
+  BlockOp->BlockHead  = Bulk;\r
+  BlockOp->BlockTail  = Bulk + Len;\r
+  BlockOp->Head       = Bulk;\r
+  BlockOp->Tail       = Bulk + Len;\r
+  BlockOp->Size       = Len;\r
+}\r
+\r
+\r
+/**\r
+  Helper function for NetbufClone. It is necessary because NetbufGetFragment\r
+  may allocate the first block to accomodate the HeadSpace and HeadLen. So, it\r
+  need to create a new NET_VECTOR. But, we want to avoid data copy by sharing\r
+  the old NET_VECTOR.\r
+\r
+  @param  Arg                   Point to the old NET_VECTOR\r
+\r
+  @return NONE\r
+\r
+**/\r
+STATIC\r
+VOID\r
+NetbufGetFragmentFree (\r
+  IN VOID                   *Arg\r
+  )\r
+{\r
+  NET_VECTOR                *Vector;\r
+\r
+  Vector = (NET_VECTOR *)Arg;\r
+  NetbufFreeVector (Vector);\r
+}\r
+\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
+NetbufGetFragment (\r
+  IN NET_BUF                *Nbuf,\r
+  IN UINT32                 Offset,\r
+  IN UINT32                 Len,\r
+  IN UINT32                 HeadSpace\r
+  )\r
+{\r
+  NET_BUF                   *Child;\r
+  NET_VECTOR                *Vector;\r
+  NET_BLOCK_OP              *BlockOp;\r
+  UINT32                    CurBlockOp;\r
+  UINT32                    BlockOpNum;\r
+  UINT8                     *FirstBulk;\r
+  UINT32                    Index;\r
+  UINT32                    First;\r
+  UINT32                    Last;\r
+  UINT32                    FirstSkip;\r
+  UINT32                    FirstLen;\r
+  UINT32                    LastLen;\r
+  UINT32                    Cur;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+  if ((Len == 0) || (Offset + Len > Nbuf->TotalSize)) {\r
+    return NULL;\r
+  }\r
+\r
+  //\r
+  // First find the first and last BlockOp that contains\r
+  // the valid data, and compute the offset of the first\r
+  // BlockOp and length of the last BlockOp\r
+  //\r
+  BlockOp = Nbuf->BlockOp;\r
+  Cur     = 0;\r
+\r
+  for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {\r
+    if (Offset < Cur + BlockOp[Index].Size) {\r
+      break;\r
+    }\r
+\r
+    Cur += BlockOp[Index].Size;\r
+  }\r
+\r
+  //\r
+  // First is the index of the first BlockOp, FirstSkip is\r
+  // the offset of the first byte in the first BlockOp.\r
+  //\r
+  First     = Index;\r
+  FirstSkip = Offset - Cur;\r
+  FirstLen  = BlockOp[Index].Size - FirstSkip;\r
+\r
+  //\r
+  //redundant assignment to make compiler happy.\r
+  //\r
+  Last      = 0;\r
+  LastLen   = 0;\r
+\r
+  if (Len > FirstLen) {\r
+    Cur += BlockOp[Index].Size;\r
+    Index++;\r
+\r
+    for (; Index < Nbuf->BlockOpNum; Index++) {\r
+      if (Offset + Len <= Cur + BlockOp[Index].Size) {\r
+        Last    = Index;\r
+        LastLen = Offset + Len - Cur;\r
+        break;\r
+      }\r
+\r
+      Cur += BlockOp[Index].Size;\r
+    }\r
+\r
+  } else {\r
+    Last     = First;\r
+    LastLen  = Len;\r
+    FirstLen = Len;\r
+  }\r
+\r
+  BlockOpNum = Last - First + 1;\r
+  CurBlockOp = 0;\r
+\r
+  if (HeadSpace != 0) {\r
+    //\r
+    // Allocate an extra block to accomdate the head space.\r
+    //\r
+    BlockOpNum++;\r
+\r
+    Child = NetbufAllocStruct (1, BlockOpNum);\r
+\r
+    if (Child == NULL) {\r
+      return NULL;\r
+    }\r
+\r
+    FirstBulk = NetAllocatePool (HeadSpace);\r
+\r
+    if (FirstBulk == NULL) {\r
+      goto FreeChild;\r
+    }\r
+\r
+    Vector        = Child->Vector;\r
+    Vector->Free  = NetbufGetFragmentFree;\r
+    Vector->Arg   = Nbuf->Vector;\r
+    Vector->Flag  = NET_VECTOR_OWN_FIRST;\r
+    Vector->Len   = HeadSpace;\r
+\r
+    //\r
+    //Reserve the head space in the first block\r
+    //\r
+    NetbufSetBlock (Child, FirstBulk, HeadSpace, 0);\r
+    Child->BlockOp[0].Head += HeadSpace;\r
+    Child->BlockOp[0].Size =  0;\r
+    CurBlockOp++;\r
+\r
+  }else {\r
+    Child = NetbufAllocStruct (0, BlockOpNum);\r
+\r
+    if (Child == NULL) {\r
+      return NULL;\r
+    }\r
+\r
+    Child->Vector = Nbuf->Vector;\r
+  }\r
+\r
+  NET_GET_REF (Nbuf->Vector);\r
+  Child->TotalSize = Len;\r
+\r
+  //\r
+  // Set all the BlockOp up, the first and last one are special\r
+  // and need special process.\r
+  //\r
+  NetbufSetBlockOp (\r
+    Child,\r
+    Nbuf->BlockOp[First].Head + FirstSkip,\r
+    FirstLen,\r
+    CurBlockOp++\r
+    );\r
+\r
+  for (Index = First + 1; Index <= Last - 1 ; Index++) {\r
+    NetbufSetBlockOp (\r
+      Child,\r
+      BlockOp[Index].Head,\r
+      BlockOp[Index].Size,\r
+      CurBlockOp++\r
+      );\r
+  }\r
+\r
+  if (First != Last) {\r
+    NetbufSetBlockOp (\r
+      Child,\r
+      BlockOp[Last].Head,\r
+      LastLen,\r
+      CurBlockOp\r
+      );\r
+  }\r
+\r
+  NetCopyMem (Child->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);\r
+  return Child;\r
+\r
+FreeChild:\r
+\r
+  NetFreePool (Child);\r
+  return NULL;\r
+}\r
+\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
+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
+  NET_BUF                   *Nbuf;\r
+  NET_VECTOR                *Vector;\r
+  NET_FRAGMENT              SavedFragment;\r
+  UINT32                    SavedIndex;\r
+  UINT32                    TotalLen;\r
+  UINT32                    BlockNum;\r
+  UINT8                     *FirstBlock;\r
+  UINT32                    FirstBlockLen;\r
+  UINT8                     *Header;\r
+  UINT32                    CurBlock;\r
+  UINT32                    Index;\r
+  UINT32                    Len;\r
+  UINT32                    Copied;\r
+\r
+  ASSERT ((ExtFragment != NULL) && (ExtNum > 0) && (ExtFree != NULL));\r
+\r
+  SavedFragment.Bulk = NULL;\r
+  SavedFragment.Len  = 0;\r
+\r
+  FirstBlockLen  = 0;\r
+  FirstBlock     = NULL;\r
+  BlockNum       = ExtNum;\r
+  Index          = 0;\r
+  TotalLen       = 0;\r
+  SavedIndex     = 0;\r
+  Len            = 0;\r
+  Copied         = 0;\r
+\r
+  //\r
+  // No need to consolidate the header if the first block is\r
+  // longer than the header length or there is only one block.\r
+  //\r
+  if ((ExtFragment[0].Len >= HeadLen) || (ExtNum == 1)) {\r
+    HeadLen = 0;\r
+  }\r
+\r
+  //\r
+  // Allocate an extra block if we need to:\r
+  //  1. Allocate some header space\r
+  //  2. aggreate the packet header\r
+  //\r
+  if ((HeadSpace != 0) || (HeadLen != 0)) {\r
+    FirstBlockLen = HeadLen + HeadSpace;\r
+    FirstBlock    = NetAllocatePool (FirstBlockLen);\r
+\r
+    if (FirstBlock == NULL) {\r
+      return NULL;\r
+    }\r
+\r
+    BlockNum++;\r
+  }\r
+\r
+  //\r
+  // Copy the header to the first block, reduce the NET_BLOCK\r
+  // to allocate by one for each block that is completely covered\r
+  // by the first bulk.\r
+  //\r
+  if (HeadLen != 0) {\r
+    Len    = HeadLen;\r
+    Header = FirstBlock + HeadSpace;\r
+\r
+    for (Index = 0; Index < ExtNum; Index++) {\r
+      if (Len >= ExtFragment[Index].Len) {\r
+        NetCopyMem (Header, ExtFragment[Index].Bulk, ExtFragment[Index].Len);\r
+\r
+        Copied    += ExtFragment[Index].Len;\r
+        Len       -= ExtFragment[Index].Len;\r
+        Header    += ExtFragment[Index].Len;\r
+        TotalLen  += ExtFragment[Index].Len;\r
+        BlockNum--;\r
+\r
+        if (Len == 0) {\r
+          //\r
+          // Increament the index number to point to the next\r
+          // non-empty fragment.\r
+          //\r
+          Index++;\r
+          break;\r
+        }\r
+\r
+      } else {\r
+        NetCopyMem (Header, ExtFragment[Index].Bulk, Len);\r
+\r
+        Copied    += Len;\r
+        TotalLen  += Len;\r
+\r
+        //\r
+        // Adjust the block structure to exclude the data copied,\r
+        // So, the left-over block can be processed as other blocks.\r
+        // But it must be recovered later. (SavedIndex > 0) always\r
+        // holds since we don't aggreate the header if the first block\r
+        // is bigger enough that the header is continuous\r
+        //\r
+        SavedIndex    = Index;\r
+        SavedFragment = ExtFragment[Index];\r
+        ExtFragment[Index].Bulk += Len;\r
+        ExtFragment[Index].Len  -= Len;\r
+        break;\r
+      }\r
+    }\r
+  }\r
+\r
+  Nbuf = NetbufAllocStruct (BlockNum, BlockNum);\r
+\r
+  if (Nbuf == NULL) {\r
+    goto FreeFirstBlock;\r
+  }\r
+\r
+  Vector       = Nbuf->Vector;\r
+  Vector->Free = ExtFree;\r
+  Vector->Arg  = Arg;\r
+  Vector->Flag = (FirstBlockLen ? NET_VECTOR_OWN_FIRST : 0);\r
+\r
+  //\r
+  // Set the first block up which may contain\r
+  // some head space and aggregated header\r
+  //\r
+  CurBlock = 0;\r
+\r
+  if (FirstBlockLen != 0) {\r
+    NetbufSetBlock (Nbuf, FirstBlock, HeadSpace + Copied, 0);\r
+    Nbuf->BlockOp[0].Head += HeadSpace;\r
+    Nbuf->BlockOp[0].Size =  Copied;\r
+\r
+    CurBlock++;\r
+  }\r
+\r
+  for (; Index < ExtNum; Index++) {\r
+    NetbufSetBlock (Nbuf, ExtFragment[Index].Bulk, ExtFragment[Index].Len, CurBlock);\r
+    TotalLen += ExtFragment[Index].Len;\r
+    CurBlock++;\r
+  }\r
+\r
+  Vector->Len     = TotalLen + HeadSpace;\r
+  Nbuf->TotalSize = TotalLen;\r
+\r
+  if (SavedIndex) {\r
+    ExtFragment[SavedIndex] = SavedFragment;\r
+  }\r
+\r
+  return Nbuf;\r
+\r
+FreeFirstBlock:\r
+  NetFreePool (FirstBlock);\r
+  return NULL;\r
+}\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
+NetbufBuildExt (\r
+  IN NET_BUF                *Nbuf,\r
+  IN NET_FRAGMENT           *ExtFragment,\r
+  IN UINT32                 *ExtNum\r
+  )\r
+{\r
+  UINT32                    Index;\r
+  UINT32                    Current;\r
+\r
+  Current = 0;\r
+\r
+  for (Index = 0; (Index < Nbuf->BlockOpNum); Index++) {\r
+    if (Nbuf->BlockOp[Index].Size == 0) {\r
+      continue;\r
+    }\r
+\r
+    if (Current < *ExtNum) {\r
+      ExtFragment[Current].Bulk = Nbuf->BlockOp[Index].Head;\r
+      ExtFragment[Current].Len  = Nbuf->BlockOp[Index].Size;\r
+      Current++;\r
+    } else {\r
+      return EFI_BUFFER_TOO_SMALL;\r
+    }\r
+  }\r
+\r
+  *ExtNum = Current;\r
+  return EFI_SUCCESS;\r
+}\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
+NetbufFromBufList (\r
+  IN NET_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
+  NET_FRAGMENT              *Fragment;\r
+  UINT32                    FragmentNum;\r
+  NET_LIST_ENTRY            *Entry;\r
+  NET_BUF                   *Nbuf;\r
+  UINT32                    Index;\r
+  UINT32                    Current;\r
+\r
+  //\r
+  //Compute how many blocks are there\r
+  //\r
+  FragmentNum = 0;\r
+\r
+  NET_LIST_FOR_EACH (Entry, BufList) {\r
+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+    NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+    FragmentNum += Nbuf->BlockOpNum;\r
+  }\r
+\r
+  //\r
+  //Allocate and copy block points\r
+  //\r
+  Fragment = NetAllocatePool (sizeof (NET_FRAGMENT) * FragmentNum);\r
+\r
+  if (Fragment == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  Current = 0;\r
+\r
+  NET_LIST_FOR_EACH (Entry, BufList) {\r
+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+    NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+    for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {\r
+      if (Nbuf->BlockOp[Index].Size) {\r
+        Fragment[Current].Bulk = Nbuf->BlockOp[Index].Head;\r
+        Fragment[Current].Len  = Nbuf->BlockOp[Index].Size;\r
+        Current++;\r
+      }\r
+    }\r
+  }\r
+\r
+  Nbuf = NetbufFromExt (Fragment, Current, HeadSpace, HeaderLen, ExtFree, Arg);\r
+  NetFreePool (Fragment);\r
+\r
+  return Nbuf;\r
+}\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
+NetbufReserve (\r
+  IN NET_BUF                *Nbuf,\r
+  IN UINT32                 Len\r
+  )\r
+{\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+  NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);\r
+\r
+  ASSERT ((Nbuf->BlockOpNum == 1) && (Nbuf->TotalSize == 0));\r
+  ASSERT ((Nbuf->Vector->Free == NULL) && (Nbuf->Vector->Len >= Len));\r
+\r
+  Nbuf->BlockOp[0].Head += Len;\r
+  Nbuf->BlockOp[0].Tail += Len;\r
+\r
+  ASSERT (Nbuf->BlockOp[0].Tail <= Nbuf->BlockOp[0].BlockTail);\r
+}\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
+NetbufAllocSpace (\r
+  IN NET_BUF                *Nbuf,\r
+  IN UINT32                 Len,\r
+  IN BOOLEAN                FromHead\r
+  )\r
+{\r
+  NET_BLOCK_OP              *BlockOp;\r
+  UINT32                    Index;\r
+  UINT8                     *SavedTail;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+  NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);\r
+\r
+  ASSERT (Len > 0);\r
+\r
+  if (FromHead) {\r
+    //\r
+    // Allocate some space from head. If the buffer is empty,\r
+    // allocate from the first block. If it isn't, allocate\r
+    // from the first non-empty block, or the block before that.\r
+    //\r
+    if (Nbuf->TotalSize == 0) {\r
+      Index = 0;\r
+    } else {\r
+      NetbufGetByte (Nbuf, 0, &Index);\r
+\r
+      if ((NET_HEADSPACE(&(Nbuf->BlockOp[Index])) < Len) && (Index > 0)) {\r
+        Index--;\r
+      }\r
+    }\r
+\r
+    BlockOp = &(Nbuf->BlockOp[Index]);\r
+\r
+    if (NET_HEADSPACE (BlockOp) < Len) {\r
+      return NULL;\r
+    }\r
+\r
+    BlockOp->Head   -= Len;\r
+    BlockOp->Size   += Len;\r
+    Nbuf->TotalSize += Len;\r
+\r
+    return BlockOp->Head;\r
+\r
+  } else {\r
+    //\r
+    // Allocate some space from the tail. If the buffer is empty,\r
+    // allocate from the first block. If it isn't, allocate\r
+    // from the last non-empty block, or the block after that.\r
+    //\r
+    if (Nbuf->TotalSize == 0) {\r
+      Index = 0;\r
+    } else {\r
+      NetbufGetByte (Nbuf, Nbuf->TotalSize - 1, &Index);\r
+\r
+      if ((NET_TAILSPACE(&(Nbuf->BlockOp[Index])) < Len) &&\r
+          (Index < Nbuf->BlockOpNum - 1)) {\r
+\r
+        Index++;\r
+      }\r
+    }\r
+\r
+    BlockOp = &(Nbuf->BlockOp[Index]);\r
+\r
+    if (NET_TAILSPACE (BlockOp) < Len) {\r
+      return NULL;\r
+    }\r
+\r
+    SavedTail       = BlockOp->Tail;\r
+\r
+    BlockOp->Tail   += Len;\r
+    BlockOp->Size   += Len;\r
+    Nbuf->TotalSize += Len;\r
+\r
+    return SavedTail;\r
+  }\r
+}\r
+\r
+\r
+/**\r
+  Trim a single NET_BLOCK.\r
+\r
+  @param  BlockOp               Pointer to the NET_BLOCK.\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
+  @return None.\r
+\r
+**/\r
+STATIC\r
+VOID\r
+NetblockTrim (\r
+  IN NET_BLOCK_OP           *BlockOp,\r
+  IN UINT32                 Len,\r
+  IN BOOLEAN                FromHead\r
+  )\r
+{\r
+  ASSERT (BlockOp && (BlockOp->Size >= Len));\r
+\r
+  BlockOp->Size -= Len;\r
+\r
+  if (FromHead) {\r
+    BlockOp->Head += Len;\r
+  } else {\r
+    BlockOp->Tail -= Len;\r
+  }\r
+}\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
+NetbufTrim (\r
+  IN NET_BUF                *Nbuf,\r
+  IN UINT32                 Len,\r
+  IN BOOLEAN                FromHead\r
+  )\r
+{\r
+  NET_BLOCK_OP              *BlockOp;\r
+  UINT32                    Index;\r
+  UINT32                    Trimmed;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+  if (Len > Nbuf->TotalSize) {\r
+    Len = Nbuf->TotalSize;\r
+  }\r
+\r
+  //\r
+  // If FromTail is true, iterate backward. That\r
+  // is, init Index to NBuf->BlockNum - 1, and\r
+  // decrease it by 1 during each loop. Otherwise,\r
+  // iterate forward. That is, init Index to 0, and\r
+  // increase it by 1 during each loop.\r
+  //\r
+  Trimmed          = 0;\r
+  Nbuf->TotalSize -= Len;\r
+\r
+  Index   = (FromHead ? 0 : Nbuf->BlockOpNum - 1);\r
+  BlockOp = Nbuf->BlockOp;\r
+\r
+  for (;;) {\r
+    if (BlockOp[Index].Size == 0) {\r
+      Index += (FromHead ? 1 : -1);\r
+      continue;\r
+    }\r
+\r
+    if (Len > BlockOp[Index].Size) {\r
+      Len     -= BlockOp[Index].Size;\r
+      Trimmed += BlockOp[Index].Size;\r
+      NetblockTrim (&BlockOp[Index], BlockOp[Index].Size, FromHead);\r
+    } else {\r
+      Trimmed += Len;\r
+      NetblockTrim (&BlockOp[Index], Len, FromHead);\r
+      break;\r
+    }\r
+\r
+    Index += (FromHead ? 1 : -1);\r
+  }\r
+\r
+  return Trimmed;\r
+}\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
+NetbufCopy (\r
+  IN NET_BUF                *Nbuf,\r
+  IN UINT32                 Offset,\r
+  IN UINT32                 Len,\r
+  IN UINT8                  *Dest\r
+  )\r
+{\r
+  NET_BLOCK_OP              *BlockOp;\r
+  UINT32                    Skip;\r
+  UINT32                    Left;\r
+  UINT32                    Copied;\r
+  UINT32                    Index;\r
+  UINT32                    Cur;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+  ASSERT (Dest);\r
+\r
+  if ((Len == 0) || (Nbuf->TotalSize <= Offset)) {\r
+    return 0;\r
+  }\r
+\r
+  if (Nbuf->TotalSize - Offset < Len) {\r
+    Len = Nbuf->TotalSize - Offset;\r
+  }\r
+\r
+  BlockOp = Nbuf->BlockOp;\r
+\r
+  //\r
+  // Skip to the offset. Don't make "Offset-By-One" error here.\r
+  // Cur + BLOCK.SIZE is the first sequence number of next block.\r
+  // So, (Offset < Cur + BLOCK.SIZE) means that the  first byte\r
+  // is in the current block. if (Offset == Cur + BLOCK.SIZE), the\r
+  // first byte is the next block's first byte.\r
+  //\r
+  Cur = 0;\r
+\r
+  for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {\r
+    if (BlockOp[Index].Size == 0) {\r
+      continue;\r
+    }\r
+\r
+    if (Offset < Cur + BlockOp[Index].Size) {\r
+      break;\r
+    }\r
+\r
+    Cur += BlockOp[Index].Size;\r
+  }\r
+\r
+  //\r
+  // Cur is the sequence number of the first byte in the block\r
+  // Offset - Cur is the number of bytes before first byte to\r
+  // to copy in the current block.\r
+  //\r
+  Skip  = Offset - Cur;\r
+  Left  = BlockOp[Index].Size - Skip;\r
+\r
+  if (Len <= Left) {\r
+    NetCopyMem (Dest, BlockOp[Index].Head + Skip, Len);\r
+    return Len;\r
+  }\r
+\r
+  NetCopyMem (Dest, BlockOp[Index].Head + Skip, Left);\r
+\r
+  Dest  += Left;\r
+  Len   -= Left;\r
+  Copied = Left;\r
+\r
+  Index++;\r
+\r
+  for (; Index < Nbuf->BlockOpNum; Index++) {\r
+    if (Len > BlockOp[Index].Size) {\r
+      Len    -= BlockOp[Index].Size;\r
+      Copied += BlockOp[Index].Size;\r
+\r
+      NetCopyMem (Dest, BlockOp[Index].Head, BlockOp[Index].Size);\r
+      Dest   += BlockOp[Index].Size;\r
+    } else {\r
+      Copied += Len;\r
+      NetCopyMem (Dest, BlockOp[Index].Head, Len);\r
+      break;\r
+    }\r
+  }\r
+\r
+  return Copied;\r
+}\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
+NetbufQueInit (\r
+  IN NET_BUF_QUEUE          *NbufQue\r
+  )\r
+{\r
+  NbufQue->Signature  = NET_QUE_SIGNATURE;\r
+  NbufQue->RefCnt     = 1;\r
+  NetListInit (&NbufQue->List);\r
+\r
+  NetListInit (&NbufQue->BufList);\r
+  NbufQue->BufSize  = 0;\r
+  NbufQue->BufNum   = 0;\r
+}\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
+NetbufQueAlloc (\r
+  VOID\r
+  )\r
+{\r
+  NET_BUF_QUEUE             *NbufQue;\r
+\r
+  NbufQue = NetAllocatePool (sizeof (NET_BUF_QUEUE));\r
+  if (NbufQue == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  NetbufQueInit (NbufQue);\r
+\r
+  return NbufQue;\r
+}\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
+NetbufQueFree (\r
+  IN NET_BUF_QUEUE          *NbufQue\r
+  )\r
+{\r
+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+\r
+  NbufQue->RefCnt--;\r
+\r
+  if (NbufQue->RefCnt == 0) {\r
+    NetbufQueFlush (NbufQue);\r
+    NetFreePool (NbufQue);\r
+  }\r
+}\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
+NetbufQueAppend (\r
+  IN NET_BUF_QUEUE          *NbufQue,\r
+  IN NET_BUF                *Nbuf\r
+  )\r
+{\r
+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+  NetListInsertTail (&NbufQue->BufList, &Nbuf->List);\r
+\r
+  NbufQue->BufSize += Nbuf->TotalSize;\r
+  NbufQue->BufNum++;\r
+}\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
+NetbufQueRemove (\r
+  IN NET_BUF_QUEUE          *NbufQue\r
+  )\r
+{\r
+  NET_BUF                   *First;\r
+\r
+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+\r
+  if (NbufQue->BufNum == 0) {\r
+    return NULL;\r
+  }\r
+\r
+  First = NET_LIST_USER_STRUCT (NbufQue->BufList.ForwardLink, NET_BUF, List);\r
+\r
+  NetListRemoveHead (&NbufQue->BufList);\r
+\r
+  NbufQue->BufSize -= First->TotalSize;\r
+  NbufQue->BufNum--;\r
+  return First;\r
+}\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
+NetbufQueCopy (\r
+  IN NET_BUF_QUEUE          *NbufQue,\r
+  IN UINT32                 Offset,\r
+  IN UINT32                 Len,\r
+  IN UINT8                  *Dest\r
+  )\r
+{\r
+  NET_LIST_ENTRY            *Entry;\r
+  NET_BUF                   *Nbuf;\r
+  UINT32                    Skip;\r
+  UINT32                    Left;\r
+  UINT32                    Cur;\r
+  UINT32                    Copied;\r
+\r
+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+  ASSERT (Dest != NULL);\r
+\r
+  if ((Len == 0) || (NbufQue->BufSize <= Offset)) {\r
+    return 0;\r
+  }\r
+\r
+  if (NbufQue->BufSize - Offset < Len) {\r
+    Len = NbufQue->BufSize - Offset;\r
+  }\r
+\r
+  //\r
+  // skip to the Offset\r
+  //\r
+  Cur   = 0;\r
+  Nbuf  = NULL;\r
+\r
+  NET_LIST_FOR_EACH (Entry, &NbufQue->BufList) {\r
+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+\r
+    if (Offset < Cur + Nbuf->TotalSize) {\r
+      break;\r
+    }\r
+\r
+    Cur += Nbuf->TotalSize;\r
+  }\r
+\r
+  //\r
+  // Copy the data in the first buffer.\r
+  //\r
+  Skip  = Offset - Cur;\r
+  Left  = Nbuf->TotalSize - Skip;\r
+\r
+  if (Len < Left) {\r
+    return NetbufCopy (Nbuf, Skip, Len, Dest);\r
+  }\r
+\r
+  NetbufCopy (Nbuf, Skip, Left, Dest);\r
+  Dest  += Left;\r
+  Len   -= Left;\r
+  Copied = Left;\r
+\r
+  //\r
+  // Iterate over the others\r
+  //\r
+  Entry = Entry->ForwardLink;\r
+\r
+  while ((Len > 0) && (Entry != &NbufQue->BufList)) {\r
+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+\r
+    if (Len > Nbuf->TotalSize) {\r
+      Len -= Nbuf->TotalSize;\r
+      Copied += Nbuf->TotalSize;\r
+\r
+      NetbufCopy (Nbuf, 0, Nbuf->TotalSize, Dest);\r
+      Dest += Nbuf->TotalSize;\r
+\r
+    } else {\r
+      NetbufCopy (Nbuf, 0, Len, Dest);\r
+      Copied += Len;\r
+      break;\r
+    }\r
+\r
+    Entry = Entry->ForwardLink;\r
+  }\r
+\r
+  return Copied;\r
+}\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
+NetbufQueTrim (\r
+  IN NET_BUF_QUEUE          *NbufQue,\r
+  IN UINT32                 Len\r
+  )\r
+{\r
+  NET_LIST_ENTRY            *Entry;\r
+  NET_LIST_ENTRY            *Next;\r
+  NET_BUF                   *Nbuf;\r
+  UINT32                    Trimmed;\r
+\r
+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+\r
+  if (Len == 0) {\r
+    return 0;\r
+  }\r
+\r
+  if (Len > NbufQue->BufSize) {\r
+    Len = NbufQue->BufSize;\r
+  }\r
+\r
+  NbufQue->BufSize -= Len;\r
+  Trimmed = 0;\r
+\r
+  NET_LIST_FOR_EACH_SAFE (Entry, Next, &NbufQue->BufList) {\r
+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);\r
+\r
+    if (Len >= Nbuf->TotalSize) {\r
+      Trimmed += Nbuf->TotalSize;\r
+      Len -= Nbuf->TotalSize;\r
+\r
+      NetListRemoveEntry (Entry);\r
+      NetbufFree (Nbuf);\r
+\r
+      NbufQue->BufNum--;\r
+\r
+      if (Len == 0) {\r
+        break;\r
+      }\r
+\r
+    } else {\r
+      Trimmed += NetbufTrim (Nbuf, Len, NET_BUF_HEAD);\r
+      break;\r
+    }\r
+  }\r
+\r
+  return Trimmed;\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
+NetbufQueFlush (\r
+  IN NET_BUF_QUEUE          *NbufQue\r
+  )\r
+{\r
+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);\r
+\r
+  NetbufFreeList (&NbufQue->BufList);\r
+\r
+  NbufQue->BufNum   = 0;\r
+  NbufQue->BufSize  = 0;\r
+}\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
+NetblockChecksum (\r
+  IN UINT8                  *Bulk,\r
+  IN UINT32                 Len\r
+  )\r
+{\r
+  register UINT32           Sum;\r
+\r
+  Sum = 0;\r
+\r
+  while (Len > 1) {\r
+    Sum += *(UINT16 *) Bulk;\r
+    Bulk += 2;\r
+    Len -= 2;\r
+  }\r
+\r
+  //\r
+  // Add left-over byte, if any\r
+  //\r
+  if (Len > 0) {\r
+    Sum += *(UINT8 *) Bulk;\r
+  }\r
+\r
+  //\r
+  // Fold 32-bit sum to 16 bits\r
+  //\r
+  while (Sum >> 16) {\r
+    Sum = (Sum & 0xffff) + (Sum >> 16);\r
+\r
+  }\r
+\r
+  return (UINT16) Sum;\r
+}\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
+NetAddChecksum (\r
+  IN UINT16                 Checksum1,\r
+  IN UINT16                 Checksum2\r
+  )\r
+{\r
+  UINT32                    Sum;\r
+\r
+  Sum = Checksum1 + Checksum2;\r
+\r
+  //\r
+  // two UINT16 can only add up to a carry of 1.\r
+  //\r
+  if (Sum >> 16) {\r
+    Sum = (Sum & 0xffff) + 1;\r
+\r
+  }\r
+\r
+  return (UINT16) Sum;\r
+}\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
+NetbufChecksum (\r
+  IN NET_BUF                *Nbuf\r
+  )\r
+{\r
+  NET_BLOCK_OP              *BlockOp;\r
+  UINT32                    Offset;\r
+  UINT16                    TotalSum;\r
+  UINT16                    BlockSum;\r
+  UINT32                    Index;\r
+\r
+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);\r
+\r
+  TotalSum  = 0;\r
+  Offset    = 0;\r
+  BlockOp   = Nbuf->BlockOp;\r
+\r
+  for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {\r
+    if (BlockOp[Index].Size == 0) {\r
+      continue;\r
+    }\r
+\r
+    BlockSum = NetblockChecksum (BlockOp[Index].Head, BlockOp[Index].Size);\r
+\r
+    if (Offset & 0x01) {\r
+      //\r
+      // The checksum starts with an odd byte, swap\r
+      // the checksum before added to total checksum\r
+      //\r
+      BlockSum = NET_SWAP_SHORT (BlockSum);\r
+    }\r
+\r
+    TotalSum = NetAddChecksum (BlockSum, TotalSum);\r
+    Offset  += BlockOp[Index].Size;\r
+  }\r
+\r
+  return TotalSum;\r
+}\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
+NetPseudoHeadChecksum (\r
+  IN IP4_ADDR               Src,\r
+  IN IP4_ADDR               Dst,\r
+  IN UINT8                  Proto,\r
+  IN UINT16                 Len\r
+  )\r
+{\r
+  NET_PSEUDO_HDR            Hdr;\r
+\r
+  //\r
+  // Zero the memory to relieve align problems\r
+  //\r
+  NetZeroMem (&Hdr, sizeof (Hdr));\r
+\r
+  Hdr.SrcIp     = Src;\r
+  Hdr.DstIp     = Dst;\r
+  Hdr.Protocol  = Proto;\r
+  Hdr.Len       = HTONS (Len);\r
+\r
+  return NetblockChecksum ((UINT8 *) &Hdr, sizeof (Hdr));\r
+}\r
diff --git a/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c b/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.c
new file mode 100644 (file)
index 0000000..84bc295
--- /dev/null
@@ -0,0 +1,727 @@
+/** @file\r
+\r
+Copyright (c) 2006 - 2007, 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
+Module Name:\r
+\r
+  Udp4Io.c\r
+\r
+Abstract:\r
+\r
+  Help functions to access UDP service, it is used by both the DHCP and MTFTP.\r
+\r
+\r
+**/\r
+\r
+#include <PiDxe.h>\r
+\r
+#include <Protocol/Udp4.h>\r
+\r
+#include <Library/UdpIoLib.h>\r
+#include <Library/BaseLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+\r
+STATIC\r
+VOID\r
+EFIAPI\r
+UdpIoOnDgramSent (\r
+  IN EFI_EVENT              Event,\r
+  IN VOID                   *Context\r
+  );\r
+\r
+STATIC\r
+VOID\r
+EFIAPI\r
+UdpIoOnDgramRcvd (\r
+  IN EFI_EVENT              Event,\r
+  IN VOID                   *Context\r
+  );\r
+\r
+\r
+/**\r
+  Wrap a transmit request into a UDP_TX_TOKEN.\r
+\r
+  @param  UdpIo                 The UdpIo port to send packet to\r
+  @param  Packet                The user's packet\r
+  @param  EndPoint              The local and remote access point\r
+  @param  Gateway               The overrided next hop\r
+  @param  CallBack              The function to call when transmission completed.\r
+  @param  Context               The opaque parameter to the call back\r
+\r
+  @return The wrapped transmission request or NULL if failed to allocate resources.\r
+\r
+**/\r
+STATIC\r
+UDP_TX_TOKEN *\r
+UdpIoWrapTx (\r
+  IN UDP_IO_PORT            *UdpIo,\r
+  IN NET_BUF                *Packet,\r
+  IN UDP_POINTS             *EndPoint, OPTIONAL\r
+  IN IP4_ADDR               Gateway,\r
+  IN UDP_IO_CALLBACK        CallBack,\r
+  IN VOID                   *Context\r
+  )\r
+{\r
+  UDP_TX_TOKEN              *Token;\r
+  EFI_UDP4_COMPLETION_TOKEN *UdpToken;\r
+  EFI_UDP4_TRANSMIT_DATA    *UdpTxData;\r
+  EFI_STATUS                Status;\r
+  UINT32                    Count;\r
+\r
+  Token = NetAllocatePool (sizeof (UDP_TX_TOKEN) +\r
+                           sizeof (EFI_UDP4_FRAGMENT_DATA) * (Packet->BlockOpNum - 1));\r
+\r
+  if (Token == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  Token->Signature  = UDP_IO_TX_SIGNATURE;\r
+  NetListInit (&Token->Link);\r
+\r
+  Token->UdpIo      = UdpIo;\r
+  Token->CallBack   = CallBack;\r
+  Token->Packet     = Packet;\r
+  Token->Context    = Context;\r
+\r
+  UdpToken          = &(Token->UdpToken);\r
+  UdpToken->Status  = EFI_NOT_READY;\r
+\r
+  Status = gBS->CreateEvent (\r
+                  EVT_NOTIFY_SIGNAL,\r
+                  TPL_CALLBACK,\r
+                  UdpIoOnDgramSent,\r
+                  Token,\r
+                  &UdpToken->Event\r
+                  );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    NetFreePool (Token);\r
+    return NULL;\r
+  }\r
+\r
+  UdpTxData                 = &Token->UdpTxData;\r
+  UdpToken->Packet.TxData   = UdpTxData;\r
+\r
+  UdpTxData->UdpSessionData = NULL;\r
+  UdpTxData->GatewayAddress = NULL;\r
+\r
+  if (EndPoint != NULL) {\r
+    EFI_IP4 (Token->UdpSession.SourceAddress)      = HTONL (EndPoint->LocalAddr);\r
+    EFI_IP4 (Token->UdpSession.DestinationAddress) = HTONL (EndPoint->RemoteAddr);\r
+    Token->UdpSession.SourcePort                   = EndPoint->LocalPort;\r
+    Token->UdpSession.DestinationPort              = EndPoint->RemotePort;\r
+    UdpTxData->UdpSessionData                      = &Token->UdpSession;\r
+  }\r
+\r
+  if (Gateway != 0) {\r
+    EFI_IP4 (Token->Gateway)  = HTONL (Gateway);\r
+    UdpTxData->GatewayAddress = &Token->Gateway;\r
+  }\r
+\r
+  UdpTxData->DataLength = Packet->TotalSize;\r
+  Count                 = Packet->BlockOpNum;\r
+  NetbufBuildExt (Packet, (NET_FRAGMENT *) UdpTxData->FragmentTable, &Count);\r
+  UdpTxData->FragmentCount = Count;\r
+\r
+  return Token;\r
+}\r
+\r
+\r
+/**\r
+  Free a UDP_TX_TOKEN. The event is closed and memory released.\r
+\r
+  @param  Token                 The UDP_TX_TOKEN to release.\r
+\r
+  @return None\r
+\r
+**/\r
+VOID\r
+UdpIoFreeTxToken (\r
+  IN UDP_TX_TOKEN           *Token\r
+  )\r
+{\r
+  gBS->CloseEvent (Token->UdpToken.Event);\r
+  NetFreePool (Token);\r
+}\r
+\r
+\r
+/**\r
+  Create a UDP_RX_TOKEN to wrap the request.\r
+\r
+  @param  UdpIo                 The UdpIo to receive packets from\r
+  @param  CallBack              The function to call when receive finished.\r
+  @param  Context               The opaque parameter to the CallBack\r
+  @param  HeadLen               The head length to reserver for the packet.\r
+\r
+  @return The Wrapped request or NULL if failed to allocate resources.\r
+\r
+**/\r
+UDP_RX_TOKEN *\r
+UdpIoCreateRxToken (\r
+  IN UDP_IO_PORT            *UdpIo,\r
+  IN UDP_IO_CALLBACK        CallBack,\r
+  IN VOID                   *Context,\r
+  IN UINT32                 HeadLen\r
+  )\r
+{\r
+  UDP_RX_TOKEN              *Token;\r
+  EFI_STATUS                Status;\r
+\r
+  Token = NetAllocatePool (sizeof (UDP_RX_TOKEN));\r
+\r
+  if (Token == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  Token->Signature              = UDP_IO_RX_SIGNATURE;\r
+  Token->UdpIo                  = UdpIo;\r
+  Token->CallBack               = CallBack;\r
+  Token->Context                = Context;\r
+  Token->HeadLen                = HeadLen;\r
+\r
+  Token->UdpToken.Status        = EFI_NOT_READY;\r
+  Token->UdpToken.Packet.RxData = NULL;\r
+\r
+  Status = gBS->CreateEvent (\r
+                  EVT_NOTIFY_SIGNAL,\r
+                  TPL_CALLBACK,\r
+                  UdpIoOnDgramRcvd,\r
+                  Token,\r
+                  &Token->UdpToken.Event\r
+                  );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    NetFreePool (Token);\r
+    return NULL;\r
+  }\r
+\r
+  return Token;\r
+}\r
+\r
+\r
+/**\r
+  Free a receive request wrap.\r
+\r
+  @param  Token                 The receive request to release.\r
+\r
+  @return None\r
+\r
+**/\r
+VOID\r
+UdpIoFreeRxToken (\r
+  IN UDP_RX_TOKEN           *Token\r
+  )\r
+{\r
+  gBS->CloseEvent (Token->UdpToken.Event);\r
+  NetFreePool (Token);\r
+}\r
+\r
+\r
+/**\r
+  Create a UDP IO port to access the UDP service. It will\r
+  create and configure a UDP child.\r
+\r
+  @param  Controller            The controller that has the UDP service binding\r
+                                protocol installed.\r
+  @param  Image                 The image handle for the driver.\r
+  @param  Configure             The function to configure the created UDP child\r
+  @param  Context               The opaque parameter for the Configure funtion.\r
+\r
+  @return A point to just created UDP IO port or NULL if failed.\r
+\r
+**/\r
+UDP_IO_PORT *\r
+UdpIoCreatePort (\r
+  IN  EFI_HANDLE            Controller,\r
+  IN  EFI_HANDLE            Image,\r
+  IN  UDP_IO_CONFIG         Configure,\r
+  IN  VOID                  *Context\r
+  )\r
+{\r
+  UDP_IO_PORT               *UdpIo;\r
+  EFI_STATUS                Status;\r
+\r
+  ASSERT (Configure != NULL);\r
+\r
+  UdpIo = NetAllocatePool (sizeof (UDP_IO_PORT));\r
+\r
+  if (UdpIo == NULL) {\r
+    return NULL;\r
+  }\r
+\r
+  UdpIo->Signature    = UDP_IO_SIGNATURE;\r
+  NetListInit (&UdpIo->Link);\r
+  UdpIo->RefCnt       = 1;\r
+\r
+  UdpIo->Controller   = Controller;\r
+  UdpIo->Image        = Image;\r
+\r
+  NetListInit (&UdpIo->SentDatagram);\r
+  UdpIo->RecvRequest  = NULL;\r
+  UdpIo->UdpHandle    = NULL;\r
+\r
+  //\r
+  // Create a UDP child then open and configure it\r
+  //\r
+  Status = NetLibCreateServiceChild (\r
+             Controller,\r
+             Image,\r
+             &gEfiUdp4ServiceBindingProtocolGuid,\r
+             &UdpIo->UdpHandle\r
+             );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    goto FREE_MEM;\r
+  }\r
+\r
+  Status = gBS->OpenProtocol (\r
+                  UdpIo->UdpHandle,\r
+                  &gEfiUdp4ProtocolGuid,\r
+                  &UdpIo->Udp,\r
+                  Image,\r
+                  Controller,\r
+                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
+                  );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    goto FREE_CHILD;\r
+  }\r
+\r
+  if (EFI_ERROR (Configure (UdpIo, Context))) {\r
+    goto CLOSE_PROTOCOL;\r
+  }\r
+\r
+  Status = UdpIo->Udp->GetModeData (UdpIo->Udp, NULL, NULL, NULL, &UdpIo->SnpMode);\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    goto CLOSE_PROTOCOL;\r
+  }\r
+\r
+  return UdpIo;\r
+\r
+CLOSE_PROTOCOL:\r
+  gBS->CloseProtocol (UdpIo->UdpHandle, &gEfiUdp4ProtocolGuid, Image, Controller);\r
+\r
+FREE_CHILD:\r
+  NetLibDestroyServiceChild (\r
+    Controller,\r
+    Image,\r
+    &gEfiUdp4ServiceBindingProtocolGuid,\r
+    UdpIo->UdpHandle\r
+    );\r
+\r
+FREE_MEM:\r
+  NetFreePool (UdpIo);\r
+  return NULL;\r
+}\r
+\r
+\r
+/**\r
+  Cancel all the sent datagram that pass the selection of ToCancel.\r
+  If ToCancel is NULL, all the datagrams are cancelled.\r
+\r
+  @param  UdpIo                 The UDP IO port to cancel packet\r
+  @param  IoStatus              The IoStatus to return to the packet owners.\r
+  @param  ToCancel              The select funtion to test whether to cancel this\r
+                                packet or not.\r
+  @param  Context               The opaque parameter to the ToCancel.\r
+\r
+  @return None\r
+\r
+**/\r
+STATIC\r
+VOID\r
+UdpIoCancelDgrams (\r
+  IN UDP_IO_PORT            *UdpIo,\r
+  IN EFI_STATUS             IoStatus,\r
+  IN UDP_IO_TO_CANCEL       ToCancel,        OPTIONAL\r
+  IN VOID                   *Context\r
+  )\r
+{\r
+  NET_LIST_ENTRY            *Entry;\r
+  NET_LIST_ENTRY            *Next;\r
+  UDP_TX_TOKEN              *Token;\r
+\r
+  NET_LIST_FOR_EACH_SAFE (Entry, Next, &UdpIo->SentDatagram) {\r
+    Token = NET_LIST_USER_STRUCT (Entry, UDP_TX_TOKEN, Link);\r
+\r
+    if ((ToCancel == NULL) || (ToCancel (Token, Context))) {\r
+      NetListRemoveEntry (Entry);\r
+      UdpIo->Udp->Cancel (UdpIo->Udp, &Token->UdpToken);\r
+      Token->CallBack (Token->Packet, NULL, IoStatus, Token->Context);\r
+      UdpIoFreeTxToken (Token);\r
+    }\r
+  }\r
+}\r
+\r
+\r
+/**\r
+  Free the UDP IO port and all its related resources including\r
+  all the transmitted packet.\r
+\r
+  @param  UdpIo                 The UDP IO port to free.\r
+\r
+  @retval EFI_SUCCESS           The UDP IO port is freed.\r
+\r
+**/\r
+EFI_STATUS\r
+UdpIoFreePort (\r
+  IN  UDP_IO_PORT           *UdpIo\r
+  )\r
+{\r
+  UDP_RX_TOKEN  *RxToken;\r
+\r
+  //\r
+  // Cancel all the sent datagram and receive requests. The\r
+  // callbacks of transmit requests are executed to allow the\r
+  // caller to release the resource. The callback of receive\r
+  // request are NOT executed. This is because it is most\r
+  // likely that the current user of the UDP IO port is closing\r
+  // itself.\r
+  //\r
+  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
+\r
+  if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
+    UdpIo->RecvRequest = NULL;\r
+    UdpIo->Udp->Cancel (UdpIo->Udp, &RxToken->UdpToken);\r
+    UdpIoFreeRxToken (RxToken);\r
+  }\r
+\r
+  //\r
+  // Close then destory the UDP child\r
+  //\r
+  gBS->CloseProtocol (\r
+         UdpIo->UdpHandle,\r
+         &gEfiUdp4ProtocolGuid,\r
+         UdpIo->Image,\r
+         UdpIo->Controller\r
+         );\r
+\r
+  NetLibDestroyServiceChild (\r
+    UdpIo->Controller,\r
+    UdpIo->Image,\r
+    &gEfiUdp4ServiceBindingProtocolGuid,\r
+    UdpIo->UdpHandle\r
+    );\r
+\r
+  NetListRemoveEntry (&UdpIo->Link);\r
+  NetFreePool (UdpIo);\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+  Clean up the UDP IO port. It will release all the transmitted\r
+  datagrams and receive request. It will also configure NULL the\r
+  UDP child.\r
+\r
+  @param  UdpIo                 UDP IO port to clean up.\r
+\r
+  @return None\r
+\r
+**/\r
+VOID\r
+UdpIoCleanPort (\r
+  IN  UDP_IO_PORT           *UdpIo\r
+  )\r
+{\r
+  UDP_RX_TOKEN              *RxToken;\r
+\r
+  //\r
+  // Cancel all the sent datagram and receive requests.\r
+  //\r
+  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, NULL, NULL);\r
+\r
+  if ((RxToken = UdpIo->RecvRequest) != NULL) {\r
+    UdpIo->RecvRequest = NULL;\r
+    UdpIo->Udp->Cancel (UdpIo->Udp, &RxToken->UdpToken);\r
+    UdpIoFreeRxToken (RxToken);\r
+  }\r
+\r
+  UdpIo->Udp->Configure (UdpIo->Udp, NULL);\r
+}\r
+\r
+\r
+/**\r
+  The callback function when the packet is sent by UDP.\r
+  It will remove the packet from the local list then call\r
+  the packet owner's callback function.\r
+\r
+  @param  Event                 The event signalled.\r
+  @param  Context               The UDP TX Token.\r
+\r
+  @return None\r
+\r
+**/\r
+STATIC\r
+VOID\r
+EFIAPI\r
+UdpIoOnDgramSent (\r
+  IN EFI_EVENT              Event,\r
+  IN VOID                   *Context\r
+  )\r
+{\r
+  UDP_TX_TOKEN              *Token;\r
+\r
+  Token   = (UDP_TX_TOKEN *) Context;\r
+  ASSERT (Token->Signature == UDP_IO_TX_SIGNATURE);\r
+\r
+  NetListRemoveEntry (&Token->Link);\r
+  Token->CallBack (Token->Packet, NULL, Token->UdpToken.Status, Token->Context);\r
+\r
+  UdpIoFreeTxToken (Token);\r
+}\r
+\r
+\r
+/**\r
+  Send a packet through the UDP IO port.\r
+\r
+  @param  UdpIo                 The UDP IO Port to send the packet through\r
+  @param  Packet                The packet to send\r
+  @param  EndPoint              The local and remote access point\r
+  @param  Gateway               The gateway to use\r
+  @param  CallBack              The call back function to call when packet is\r
+                                transmitted or failed.\r
+  @param  Context               The opque parameter to the CallBack\r
+\r
+  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource for the packet\r
+  @retval EFI_SUCCESS           The packet is successfully delivered to UDP  for\r
+                                transmission.\r
+\r
+**/\r
+EFI_STATUS\r
+UdpIoSendDatagram (\r
+  IN  UDP_IO_PORT           *UdpIo,\r
+  IN  NET_BUF               *Packet,\r
+  IN  UDP_POINTS            *EndPoint, OPTIONAL\r
+  IN  IP4_ADDR              Gateway,\r
+  IN  UDP_IO_CALLBACK       CallBack,\r
+  IN  VOID                  *Context\r
+  )\r
+{\r
+  UDP_TX_TOKEN              *Token;\r
+  EFI_STATUS                Status;\r
+\r
+  Token = UdpIoWrapTx (UdpIo, Packet, EndPoint, Gateway, CallBack, Context);\r
+\r
+  if (Token == NULL) {\r
+    return EFI_OUT_OF_RESOURCES;\r
+  }\r
+\r
+  Status = UdpIo->Udp->Transmit (UdpIo->Udp, &Token->UdpToken);\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    UdpIoFreeTxToken (Token);\r
+    return Status;\r
+  }\r
+\r
+  NetListInsertHead (&UdpIo->SentDatagram, &Token->Link);\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+  The selection function to cancel a single sent datagram.\r
+\r
+  @param  Token                 The UDP TX token to test againist.\r
+  @param  Context               The context\r
+\r
+  @return TRUE if the packet is to be cancelled, otherwise FALSE.\r
+\r
+**/\r
+STATIC\r
+BOOLEAN\r
+UdpIoCancelSingleDgram (\r
+  IN UDP_TX_TOKEN           *Token,\r
+  IN VOID                   *Context\r
+  )\r
+{\r
+  NET_BUF                   *Packet;\r
+\r
+  Packet = (NET_BUF *) Context;\r
+\r
+  if (Token->Packet == Packet) {\r
+    return TRUE;\r
+  }\r
+\r
+  return FALSE;\r
+}\r
+\r
+\r
+/**\r
+  Cancel a single sent datagram.\r
+\r
+  @param  UdpIo                 The UDP IO port to cancel the packet from\r
+  @param  Packet                The packet to cancel\r
+\r
+  @return None\r
+\r
+**/\r
+VOID\r
+UdpIoCancelSentDatagram (\r
+  IN  UDP_IO_PORT           *UdpIo,\r
+  IN  NET_BUF               *Packet\r
+  )\r
+{\r
+  UdpIoCancelDgrams (UdpIo, EFI_ABORTED, UdpIoCancelSingleDgram, Packet);\r
+}\r
+\r
+\r
+/**\r
+  Recycle the received UDP data.\r
+\r
+  @param  Context               The UDP_RX_TOKEN\r
+\r
+  @return None\r
+\r
+**/\r
+STATIC\r
+VOID\r
+UdpIoRecycleDgram (\r
+  IN VOID                   *Context\r
+  )\r
+{\r
+  UDP_RX_TOKEN              *Token;\r
+\r
+  Token = (UDP_RX_TOKEN *) Context;\r
+  gBS->SignalEvent (Token->UdpToken.Packet.RxData->RecycleSignal);\r
+  UdpIoFreeRxToken (Token);\r
+}\r
+\r
+\r
+/**\r
+  The event handle for UDP receive request. It will build\r
+  a NET_BUF from the recieved UDP data, then deliver it\r
+  to the receiver.\r
+\r
+  @param  Event                 The UDP receive request event\r
+  @param  Context               The UDP RX token.\r
+\r
+  @return None\r
+\r
+**/\r
+STATIC\r
+VOID\r
+EFIAPI\r
+UdpIoOnDgramRcvd (\r
+  IN EFI_EVENT              Event,\r
+  IN VOID                   *Context\r
+  )\r
+{\r
+  EFI_UDP4_COMPLETION_TOKEN *UdpToken;\r
+  EFI_UDP4_RECEIVE_DATA     *UdpRxData;\r
+  EFI_UDP4_SESSION_DATA     *UdpSession;\r
+  UDP_RX_TOKEN              *Token;\r
+  UDP_POINTS                Points;\r
+  NET_BUF                   *Netbuf;\r
+\r
+  Token   = (UDP_RX_TOKEN *) Context;\r
+\r
+  ASSERT ((Token->Signature == UDP_IO_RX_SIGNATURE) &&\r
+          (Token == Token->UdpIo->RecvRequest));\r
+\r
+  //\r
+  // Clear the receive request first in case that the caller\r
+  // wants to restart the receive in the callback.\r
+  //\r
+  Token->UdpIo->RecvRequest = NULL;\r
+\r
+  UdpToken  = &Token->UdpToken;\r
+  UdpRxData = UdpToken->Packet.RxData;\r
+\r
+  if (EFI_ERROR (UdpToken->Status) || (UdpRxData == NULL)) {\r
+    Token->CallBack (NULL, NULL, UdpToken->Status, Token->Context);\r
+    UdpIoFreeRxToken (Token);\r
+\r
+    goto ON_EXIT;\r
+  }\r
+\r
+  //\r
+  // Build a NET_BUF from the UDP receive data, then deliver it up.\r
+  //\r
+  Netbuf = NetbufFromExt (\r
+             (NET_FRAGMENT *) UdpRxData->FragmentTable,\r
+             UdpRxData->FragmentCount,\r
+             0,\r
+             (UINT32) Token->HeadLen,\r
+             UdpIoRecycleDgram,\r
+             Token\r
+             );\r
+\r
+  if (Netbuf == NULL) {\r
+    gBS->SignalEvent (UdpRxData->RecycleSignal);\r
+    Token->CallBack (NULL, NULL, EFI_OUT_OF_RESOURCES, Token->Context);\r
+\r
+    UdpIoFreeRxToken (Token);\r
+    goto ON_EXIT;\r
+  }\r
+\r
+  UdpSession        = &UdpRxData->UdpSession;\r
+  Points.LocalAddr  = EFI_NTOHL (UdpSession->DestinationAddress);\r
+  Points.LocalPort  = UdpSession->DestinationPort;\r
+  Points.RemoteAddr = EFI_NTOHL (UdpSession->SourceAddress);\r
+  Points.RemotePort = UdpSession->SourcePort;\r
+\r
+  Token->CallBack (Netbuf, &Points, EFI_SUCCESS, Token->Context);\r
+\r
+ON_EXIT:\r
+  return;\r
+}\r
+\r
+\r
+/**\r
+  Issue a receive request to the UDP IO port.\r
+\r
+  @param  UdpIo                 The UDP IO port to recieve the packet from.\r
+  @param  CallBack              The call back function to execute when receive\r
+                                finished.\r
+  @param  Context               The opque context to the call back\r
+  @param  HeadLen               The lenght of the application's header\r
+\r
+  @retval EFI_ALREADY_STARTED   There is already a pending receive request. Only\r
+                                one receive request is supported.\r
+  @retval EFI_OUT_OF_RESOURCES  Failed to allocate some resource.\r
+  @retval EFI_SUCCESS           The receive request is issued successfully.\r
+\r
+**/\r
+EFI_STATUS\r
+UdpIoRecvDatagram (\r
+  IN  UDP_IO_PORT           *UdpIo,\r
+  IN  UDP_IO_CALLBACK       CallBack,\r
+  IN  VOID                  *Context,\r
+  IN  UINT32                HeadLen\r
+  )\r
+{\r
+  UDP_RX_TOKEN              *Token;\r
+  EFI_STATUS                Status;\r
+\r
+  if (UdpIo->RecvRequest != NULL) {\r
+    return EFI_ALREADY_STARTED;\r
+  }\r
+\r
+  Token = UdpIoCreateRxToken (UdpIo, CallBack, Context, HeadLen);\r
+\r
+  if (Token == NULL) {\r
+    return EFI_OUT_OF_RESOURCES;\r
+  }\r
+\r
+  Status = UdpIo->Udp->Receive (UdpIo->Udp, &Token->UdpToken);\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    UdpIoFreeRxToken (Token);\r
+    return Status;\r
+  }\r
+\r
+  UdpIo->RecvRequest = Token;\r
+  return EFI_SUCCESS;\r
+}\r
diff --git a/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf b/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf
new file mode 100644 (file)
index 0000000..421eaa0
--- /dev/null
@@ -0,0 +1,65 @@
+#/** @file\r
+# Component name for module NetLib\r
+#\r
+# FIX ME!\r
+# Copyright (c) 2006, Intel Corporation. All right reserved.\r
+#\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
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010005\r
+  BASE_NAME                      = DxeUpdIoDxe\r
+  FILE_GUID                      = 7E615AA1-41EE-49d4-B7E9-1D7A60AA5C8D\r
+  MODULE_TYPE                    = DXE_DRIVER\r
+  VERSION_STRING                 = 1.0\r
+  LIBRARY_CLASS                  = UdpIoLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER\r
+  EDK_RELEASE_VERSION            = 0x00020000\r
+  EFI_SPECIFICATION_VERSION      = 0x00020000\r
+\r
+\r
+#\r
+# The following information is for reference only and not required by the build tools.\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC\r
+#\r
+\r
+[Sources.common]\r
+  DxeUdpIoLib.c\r
+\r
+[Packages]\r
+  MdePkg/MdePkg.dec\r
+  MdeModulePkg/MdeModulePkg.dec\r
+\r
+\r
+[LibraryClasses]\r
+  MemoryAllocationLib\r
+  UefiLib\r
+  BaseLib\r
+  UefiBootServicesTableLib\r
+  UefiRuntimeServicesTableLib\r
+  BaseMemoryLib\r
+  DebugLib\r
+  PrintLib\r
+\r
+\r
+[Protocols]\r
+  gEfiIp4ProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverDiagnosticsProtocolGuid             # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiUdp4ServiceBindingProtocolGuid            # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiLoadedImageProtocolGuid                   # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiIp4ServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverConfigurationProtocolGuid           # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiSimpleNetworkProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiDriverBindingProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiUdp4ProtocolGuid                          # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiComponentNameProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED\r
+\r
index 73cb07a..b461ecc 100644 (file)
   ScsiLib|$(WORKSPACE)/MdePkg/Library/UefiScsiLib/UefiScsiLib.inf\r
   FrameworkHiiLib|$(WORKSPACE)/IntelFrameworkPkg/Library/FrameworkHiiLib/HiiLib.inf\r
   UsbLib|$(WORKSPACE)/MdePkg/Library/UefiUsbLib/UefiUsbLib.inf\r
+  NetLib|$(WORKSPACE)/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf\r
+  IpIoLib|$(WORKSPACE)/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf\r
 \r
 [LibraryClasses.common.DXE_RUNTIME_DRIVER]\r
   HobLib|$(WORKSPACE)/MdePkg/Library/DxeHobLib/DxeHobLib.inf\r
   $(WORKSPACE)/MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.inf\r
   $(WORKSPACE)/MdeModulePkg/Library/EdkDxePrintLib/EdkDxePrintLib.inf\r
 \r
+  $(WORKSPACE)/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf\r
+  $(WORKSPACE)/MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf\r
+  $(WORKSPACE)/MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf\r
+\r
+  $(WORKSPACE)/MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4ConfigDxe.inf\r
+\r
   $(WORKSPACE)/MdeModulePkg/Application/HelloWorld/HelloWorld.inf\r
 \r
   $(WORKSPACE)/MdeModulePkg/Bus/Pci/AtapiPassThruDxe/AtapiPassThru.inf\r