1. Import NetLib, IpIoLib and UdpIoLib class definitions

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

3 files changed, 3157 insertions, 0 deletions

diff --git a/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c
new file mode 100644
index 0000000000..88dcf76a05
--- /dev/null
+++ b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.c
@@ -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>

+#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,
+};
+
+
+/**

+  Converts the low nibble of a byte  to hex unicode character.

+

+  @param  Nibble  lower nibble of a byte.

+

+  @return Hex unicode character.

+

+**/

+CHAR16

+NibbleToHexChar (

+  IN UINT8      Nibble

+  )

+{

+  //

+  // Porting Guide:

+  // This library interface is simply obsolete.

+  // Include the source code to user code.

+  //

+

+  Nibble &= 0x0F;

+  if (Nibble <= 0x9) {

+    return (CHAR16)(Nibble + L'0');

+  }

+

+  return (CHAR16)(Nibble - 0xA + L'A');

+}

+

+/**
+  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
index 0000000000..be9ff1b379
--- /dev/null
+++ b/MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf
@@ -0,0 +1,66 @@
+#/** @file

+# Component name for module NetLib

+#

+# FIX ME!

+# Copyright (c) 2006, Intel Corporation. All right reserved.

+#

+#  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.

+#

+#

+#**/

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = NetLibDxe

+  FILE_GUID                      = db6dcef3-9f4e-4340-9351-fc35aa8a5888

+  MODULE_TYPE                    = DXE_DRIVER

+  VERSION_STRING                 = 1.0

+  LIBRARY_CLASS                  = NetLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER UEFI_APPLICATION UEFI_DRIVER

+  EDK_RELEASE_VERSION            = 0x00020000

+  EFI_SPECIFICATION_VERSION      = 0x00020000

+

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC

+#

+

+[Sources.common]

+  DxeNetLib.c

+  NetBuffer.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+

+

+[LibraryClasses]

+  MemoryAllocationLib

+  UefiLib

+  BaseLib

+  UefiBootServicesTableLib

+  UefiRuntimeServicesTableLib

+  BaseMemoryLib

+  DebugLib

+  PrintLib

+

+

+[Protocols]

+  gEfiIp4ProtocolGuid                           # PROTOCOL ALWAYS_CONSUMED

+  gEfiDriverDiagnosticsProtocolGuid             # PROTOCOL ALWAYS_CONSUMED

+  gEfiUdp4ServiceBindingProtocolGuid            # PROTOCOL ALWAYS_CONSUMED

+  gEfiLoadedImageProtocolGuid                   # PROTOCOL ALWAYS_CONSUMED

+  gEfiIp4ServiceBindingProtocolGuid             # PROTOCOL ALWAYS_CONSUMED

+  gEfiDriverConfigurationProtocolGuid           # PROTOCOL ALWAYS_CONSUMED

+  gEfiSimpleNetworkProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED

+  gEfiDriverBindingProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED

+  gEfiUdp4ProtocolGuid                          # PROTOCOL ALWAYS_CONSUMED

+  gEfiComponentNameProtocolGuid                 # PROTOCOL ALWAYS_CONSUMED

+

diff --git a/MdeModulePkg/Library/DxeNetLib/Netbuffer.c b/MdeModulePkg/Library/DxeNetLib/Netbuffer.c
new file mode 100644
index 0000000000..f32e31efbe
--- /dev/null
+++ b/MdeModulePkg/Library/DxeNetLib/Netbuffer.c
@@ -0,0 +1,1759 @@
+/** @file

+

+Copyright (c) 2005 - 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:

+

+  NetBuffer.c

+

+Abstract:

+

+

+

+**/

+

+#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>

+

+

+/**

+  Allocate and build up the sketch for a NET_BUF. The net buffer allocated

+  has the BlockOpNum's NET_BLOCK_OP, and its associated NET_VECTOR has the

+  BlockNum's NET_BLOCK.

+

+  @param  BlockNum              The number of NET_BLOCK in the Vector of net buffer

+  @param  BlockOpNum            The number of NET_BLOCK_OP in the net buffer

+

+  @retval *                     Pointer to the allocated NET_BUF. If NULL  the

+                                allocation failed due to resource limit.

+

+**/

+STATIC

+NET_BUF *

+NetbufAllocStruct (

+  IN UINT32                 BlockNum,

+  IN UINT32                 BlockOpNum

+  )

+{

+  NET_BUF                   *Nbuf;

+  NET_VECTOR                *Vector;

+

+  ASSERT (BlockOpNum >= 1);

+

+  //

+  // Allocate three memory blocks.

+  //

+  Nbuf = NetAllocateZeroPool (NET_BUF_SIZE (BlockOpNum));

+

+  if (Nbuf == NULL) {

+    return NULL;

+  }

+

+  Nbuf->Signature           = NET_BUF_SIGNATURE;

+  Nbuf->RefCnt              = 1;

+  Nbuf->BlockOpNum          = BlockOpNum;

+  NetListInit (&Nbuf->List);

+

+  if (BlockNum != 0) {

+    Vector = NetAllocateZeroPool (NET_VECTOR_SIZE (BlockNum));

+

+    if (Vector == NULL) {

+      goto FreeNbuf;

+    }

+

+    Vector->Signature = NET_VECTOR_SIGNATURE;

+    Vector->RefCnt    = 1;

+    Vector->BlockNum  = BlockNum;

+    Nbuf->Vector      = Vector;

+  }

+

+  return Nbuf;

+

+FreeNbuf:

+

+  NetFreePool (Nbuf);

+  return NULL;

+}

+

+

+/**

+  Allocate a single block NET_BUF. Upon allocation, all the

+  free space is in the tail room.

+

+  @param  Len                   The length of the block.

+

+  @retval *                     Pointer to the allocated NET_BUF. If NULL  the

+                                allocation failed due to resource limit.

+

+**/

+NET_BUF  *

+NetbufAlloc (

+  IN UINT32                 Len

+  )

+{

+  NET_BUF                   *Nbuf;

+  NET_VECTOR                *Vector;

+  UINT8                     *Bulk;

+

+  ASSERT (Len > 0);

+

+  Nbuf = NetbufAllocStruct (1, 1);

+

+  if (Nbuf == NULL) {

+    return NULL;

+  }

+

+  Bulk = NetAllocatePool (Len);

+

+  if (Bulk == NULL) {

+    goto FreeNBuf;

+  }

+

+  Vector = Nbuf->Vector;

+  Vector->Len                 = Len;

+

+  Vector->Block[0].Bulk       = Bulk;

+  Vector->Block[0].Len        = Len;

+

+  Nbuf->BlockOp[0].BlockHead  = Bulk;

+  Nbuf->BlockOp[0].BlockTail  = Bulk + Len;

+

+  Nbuf->BlockOp[0].Head       = Bulk;

+  Nbuf->BlockOp[0].Tail       = Bulk;

+  Nbuf->BlockOp[0].Size       = 0;

+

+  return Nbuf;

+

+FreeNBuf:

+  NetFreePool (Nbuf);

+  return NULL;

+}

+

+

+/**

+  Free the vector

+

+  @param  Vector                Pointer to the NET_VECTOR to be freed.

+

+  @return None.

+

+**/

+STATIC

+VOID

+NetbufFreeVector (

+  IN NET_VECTOR             *Vector

+  )

+{

+  UINT32                    Index;

+

+  NET_CHECK_SIGNATURE (Vector, NET_VECTOR_SIGNATURE);

+  ASSERT (Vector->RefCnt > 0);

+

+  Vector->RefCnt--;

+

+  if (Vector->RefCnt > 0) {

+    return;

+  }

+

+  if (Vector->Free != NULL) {

+    //

+    // Call external free function to free the vector if it

+    // isn't NULL. If NET_VECTOR_OWN_FIRST is set, release the

+    // first block since it is allocated by us

+    //

+    if (Vector->Flag & NET_VECTOR_OWN_FIRST) {

+      NetFreePool (Vector->Block[0].Bulk);

+    }

+

+    Vector->Free (Vector->Arg);

+

+  } else {

+    //

+    // Free each memory block associated with the Vector

+    //

+    for (Index = 0; Index < Vector->BlockNum; Index++) {

+      NetFreePool (Vector->Block[Index].Bulk);

+    }

+  }

+

+  NetFreePool (Vector);

+}

+

+

+/**

+  Free the buffer and its associated NET_VECTOR.

+

+  @param  Nbuf                  Pointer to the NET_BUF to be freed.

+

+  @return None.

+

+**/

+VOID

+NetbufFree (

+  IN NET_BUF                *Nbuf

+  )

+{

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+  ASSERT (Nbuf->RefCnt > 0);

+

+  Nbuf->RefCnt--;

+

+  if (Nbuf->RefCnt == 0) {

+    //

+    // Update Vector only when NBuf is to be released. That is,

+    // all the sharing of Nbuf increse Vector's RefCnt by one

+    //

+    NetbufFreeVector (Nbuf->Vector);

+    NetFreePool (Nbuf);

+  }

+}

+

+

+/**

+  Create a copy of NET_BUF that share the associated NET_DATA.

+

+  @param  Nbuf                  Pointer to the net buffer to be cloned.

+

+  @retval *                     Pointer to the cloned net buffer.

+

+**/

+NET_BUF  *

+NetbufClone (

+  IN NET_BUF                *Nbuf

+  )

+{

+  NET_BUF                   *Clone;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+  Clone = NetAllocatePool (NET_BUF_SIZE (Nbuf->BlockOpNum));

+

+  if (Clone == NULL) {

+    return NULL;

+  }

+

+  Clone->Signature  = NET_BUF_SIGNATURE;

+  Clone->RefCnt     = 1;

+  NetListInit (&Clone->List);

+

+  Clone->Ip   = Nbuf->Ip;

+  Clone->Tcp  = Nbuf->Tcp;

+

+  NetCopyMem (Clone->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);

+

+  NET_GET_REF (Nbuf->Vector);

+

+  Clone->Vector     = Nbuf->Vector;

+  Clone->BlockOpNum = Nbuf->BlockOpNum;

+  Clone->TotalSize  = Nbuf->TotalSize;

+  NetCopyMem (Clone->BlockOp, Nbuf->BlockOp, sizeof (NET_BLOCK_OP) * Nbuf->BlockOpNum);

+

+  return Clone;

+}

+

+

+/**

+  Create a duplicated copy of Nbuf, data is copied. Also leave some

+  head space before the data.

+

+  @param  Nbuf                  Pointer to the net buffer to be cloned.

+  @param  Duplicate             Pointer to the net buffer to duplicate to, if NULL

+                                a new net  buffer is allocated.

+  @param  HeadSpace             Length of the head space to reserve

+

+  @retval *                     Pointer to the duplicated net buffer.

+

+**/

+NET_BUF  *

+NetbufDuplicate (

+  IN NET_BUF                *Nbuf,

+  IN NET_BUF                *Duplicate        OPTIONAL,

+  IN UINT32                 HeadSpace

+  )

+{

+  UINT8                     *Dst;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+  if (Duplicate == NULL) {

+    Duplicate = NetbufAlloc (Nbuf->TotalSize + HeadSpace);

+  }

+

+  if (Duplicate == NULL) {

+    return NULL;

+  }

+

+  //

+  // Don't set the IP and TCP head point, since it is most

+  // like that they are pointing to the memory of Nbuf.

+  //

+  NetCopyMem (Duplicate->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);

+  NetbufReserve (Duplicate, HeadSpace);

+

+  Dst = NetbufAllocSpace (Duplicate, Nbuf->TotalSize, NET_BUF_TAIL);

+  NetbufCopy (Nbuf, 0, Nbuf->TotalSize, Dst);

+

+  return Duplicate;

+}

+

+

+/**

+  Free a list of net buffers.

+

+  @param  Head                  Pointer to the head of linked net buffers.

+

+  @return None.

+

+**/

+VOID

+NetbufFreeList (

+  IN NET_LIST_ENTRY         *Head

+  )

+{

+  NET_LIST_ENTRY            *Entry;

+  NET_LIST_ENTRY            *Next;

+  NET_BUF                   *Nbuf;

+

+  Entry = Head->ForwardLink;

+

+  NET_LIST_FOR_EACH_SAFE (Entry, Next, Head) {

+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);

+    NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+    NetListRemoveEntry (Entry);

+    NetbufFree (Nbuf);

+  }

+

+  ASSERT (NetListIsEmpty (Head));

+}

+

+

+/**

+  Get the position of some byte in the net buffer. This can be used

+  to, for example, retrieve the IP header in the packet. It also

+  returns the fragment that contains the byte which is used mainly by

+  the buffer implementation itself.

+

+  @param  Nbuf                  Pointer to the net buffer.

+  @param  Offset                The index or offset of the byte

+  @param  Index                 Index of the fragment that contains the block

+

+  @retval *                     Pointer to the nth byte of data in the net buffer.

+                                If NULL, there is no such data in the net buffer.

+

+**/

+UINT8  *

+NetbufGetByte (

+  IN  NET_BUF               *Nbuf,

+  IN  UINT32                Offset,

+  OUT UINT32                *Index  OPTIONAL

+  )

+{

+  NET_BLOCK_OP              *BlockOp;

+  UINT32                    Loop;

+  UINT32                    Len;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+  if (Offset >= Nbuf->TotalSize) {

+    return NULL;

+  }

+

+  BlockOp = Nbuf->BlockOp;

+  Len     = 0;

+

+  for (Loop = 0; Loop < Nbuf->BlockOpNum; Loop++) {

+

+    if (Len + BlockOp[Loop].Size <= Offset) {

+      Len += BlockOp[Loop].Size;

+      continue;

+    }

+

+    if (Index != NULL) {

+      *Index = Loop;

+    }

+

+    return BlockOp[Loop].Head + (Offset - Len);

+  }

+

+  return NULL;

+}

+

+

+

+/**

+  Set the NET_BLOCK and corresponding NET_BLOCK_OP in

+  the buffer. All the pointers in NET_BLOCK and NET_BLOCK_OP

+  are set to the bulk's head and tail respectively. So, this

+  function alone can't be used by NetbufAlloc.

+

+  @param  Nbuf                  Pointer to the net buffer.

+  @param  Bulk                  Pointer to the data.

+  @param  Len                   Length of the bulk data.

+  @param  Index                 The data block index in the net buffer the bulk

+                                data should belong to.

+

+  @return None.

+

+**/

+STATIC

+VOID

+NetbufSetBlock (

+  IN NET_BUF                *Nbuf,

+  IN UINT8                  *Bulk,

+  IN UINT32                 Len,

+  IN UINT32                 Index

+  )

+{

+  NET_BLOCK_OP              *BlockOp;

+  NET_BLOCK                 *Block;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+  NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);

+  ASSERT (Index < Nbuf->BlockOpNum);

+

+  Block               = &(Nbuf->Vector->Block[Index]);

+  BlockOp             = &(Nbuf->BlockOp[Index]);

+  Block->Len          = Len;

+  Block->Bulk         = Bulk;

+  BlockOp->BlockHead  = Bulk;

+  BlockOp->BlockTail  = Bulk + Len;

+  BlockOp->Head       = Bulk;

+  BlockOp->Tail       = Bulk + Len;

+  BlockOp->Size       = Len;

+}

+

+

+

+/**

+  Set the NET_BLOCK_OP in the buffer. The corresponding NET_BLOCK

+  structure is left untouched. Some times, there is no 1:1 relationship

+  between NET_BLOCK and NET_BLOCK_OP. For example, that in NetbufGetFragment.

+

+  @param  Nbuf                  Pointer to the net buffer.

+  @param  Bulk                  Pointer to the data.

+  @param  Len                   Length of the bulk data.

+  @param  Index                 The data block index in the net buffer the bulk

+                                data should belong to.

+

+  @return None.

+

+**/

+STATIC

+VOID

+NetbufSetBlockOp (

+  IN NET_BUF                *Nbuf,

+  IN UINT8                  *Bulk,

+  IN UINT32                 Len,

+  IN UINT32                 Index

+  )

+{

+  NET_BLOCK_OP              *BlockOp;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+  ASSERT (Index < Nbuf->BlockOpNum);

+

+  BlockOp             = &(Nbuf->BlockOp[Index]);

+  BlockOp->BlockHead  = Bulk;

+  BlockOp->BlockTail  = Bulk + Len;

+  BlockOp->Head       = Bulk;

+  BlockOp->Tail       = Bulk + Len;

+  BlockOp->Size       = Len;

+}

+

+

+/**

+  Helper function for NetbufClone. It is necessary because NetbufGetFragment

+  may allocate the first block to accomodate the HeadSpace and HeadLen. So, it

+  need to create a new NET_VECTOR. But, we want to avoid data copy by sharing

+  the old NET_VECTOR.

+

+  @param  Arg                   Point to the old NET_VECTOR

+

+  @return NONE

+

+**/

+STATIC

+VOID

+NetbufGetFragmentFree (

+  IN VOID                   *Arg

+  )

+{

+  NET_VECTOR                *Vector;

+

+  Vector = (NET_VECTOR *)Arg;

+  NetbufFreeVector (Vector);

+}

+

+

+

+/**

+  Create a NET_BUF structure which contains Len byte data of

+  Nbuf starting from Offset. A new NET_BUF structure will be

+  created but the associated data in NET_VECTOR is shared.

+  This function exists to do IP packet fragmentation.

+

+  @param  Nbuf                  Pointer to the net buffer to be cloned.

+  @param  Offset                Starting point of the data to be included in new

+                                buffer.

+  @param  Len                   How many data to include in new data

+  @param  HeadSpace             How many bytes of head space to reserve for

+                                protocol header

+

+  @retval *                     Pointer to the cloned net buffer.

+

+**/

+NET_BUF  *

+NetbufGetFragment (

+  IN NET_BUF                *Nbuf,

+  IN UINT32                 Offset,

+  IN UINT32                 Len,

+  IN UINT32                 HeadSpace

+  )

+{

+  NET_BUF                   *Child;

+  NET_VECTOR                *Vector;

+  NET_BLOCK_OP              *BlockOp;

+  UINT32                    CurBlockOp;

+  UINT32                    BlockOpNum;

+  UINT8                     *FirstBulk;

+  UINT32                    Index;

+  UINT32                    First;

+  UINT32                    Last;

+  UINT32                    FirstSkip;

+  UINT32                    FirstLen;

+  UINT32                    LastLen;

+  UINT32                    Cur;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+  if ((Len == 0) || (Offset + Len > Nbuf->TotalSize)) {

+    return NULL;

+  }

+

+  //

+  // First find the first and last BlockOp that contains

+  // the valid data, and compute the offset of the first

+  // BlockOp and length of the last BlockOp

+  //

+  BlockOp = Nbuf->BlockOp;

+  Cur     = 0;

+

+  for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {

+    if (Offset < Cur + BlockOp[Index].Size) {

+      break;

+    }

+

+    Cur += BlockOp[Index].Size;

+  }

+

+  //

+  // First is the index of the first BlockOp, FirstSkip is

+  // the offset of the first byte in the first BlockOp.

+  //

+  First     = Index;

+  FirstSkip = Offset - Cur;

+  FirstLen  = BlockOp[Index].Size - FirstSkip;

+

+  //

+  //redundant assignment to make compiler happy.

+  //

+  Last      = 0;

+  LastLen   = 0;

+

+  if (Len > FirstLen) {

+    Cur += BlockOp[Index].Size;

+    Index++;

+

+    for (; Index < Nbuf->BlockOpNum; Index++) {

+      if (Offset + Len <= Cur + BlockOp[Index].Size) {

+        Last    = Index;

+        LastLen = Offset + Len - Cur;

+        break;

+      }

+

+      Cur += BlockOp[Index].Size;

+    }

+

+  } else {

+    Last     = First;

+    LastLen  = Len;

+    FirstLen = Len;

+  }

+

+  BlockOpNum = Last - First + 1;

+  CurBlockOp = 0;

+

+  if (HeadSpace != 0) {

+    //

+    // Allocate an extra block to accomdate the head space.

+    //

+    BlockOpNum++;

+

+    Child = NetbufAllocStruct (1, BlockOpNum);

+

+    if (Child == NULL) {

+      return NULL;

+    }

+

+    FirstBulk = NetAllocatePool (HeadSpace);

+

+    if (FirstBulk == NULL) {

+      goto FreeChild;

+    }

+

+    Vector        = Child->Vector;

+    Vector->Free  = NetbufGetFragmentFree;

+    Vector->Arg   = Nbuf->Vector;

+    Vector->Flag  = NET_VECTOR_OWN_FIRST;

+    Vector->Len   = HeadSpace;

+

+    //

+    //Reserve the head space in the first block

+    //

+    NetbufSetBlock (Child, FirstBulk, HeadSpace, 0);

+    Child->BlockOp[0].Head += HeadSpace;

+    Child->BlockOp[0].Size =  0;

+    CurBlockOp++;

+

+  }else {

+    Child = NetbufAllocStruct (0, BlockOpNum);

+

+    if (Child == NULL) {

+      return NULL;

+    }

+

+    Child->Vector = Nbuf->Vector;

+  }

+

+  NET_GET_REF (Nbuf->Vector);

+  Child->TotalSize = Len;

+

+  //

+  // Set all the BlockOp up, the first and last one are special

+  // and need special process.

+  //

+  NetbufSetBlockOp (

+    Child,

+    Nbuf->BlockOp[First].Head + FirstSkip,

+    FirstLen,

+    CurBlockOp++

+    );

+

+  for (Index = First + 1; Index <= Last - 1 ; Index++) {

+    NetbufSetBlockOp (

+      Child,

+      BlockOp[Index].Head,

+      BlockOp[Index].Size,

+      CurBlockOp++

+      );

+  }

+

+  if (First != Last) {

+    NetbufSetBlockOp (

+      Child,

+      BlockOp[Last].Head,

+      LastLen,

+      CurBlockOp

+      );

+  }

+

+  NetCopyMem (Child->ProtoData, Nbuf->ProtoData, NET_PROTO_DATA);

+  return Child;

+

+FreeChild:

+

+  NetFreePool (Child);

+  return NULL;

+}

+

+

+

+/**

+  Build a NET_BUF from external blocks.

+

+  @param  ExtFragment           Pointer to the data block.

+  @param  ExtNum                The number of the data block.

+  @param  HeadSpace             The head space to be reserved.

+  @param  HeadLen               The length of the protocol header, This function

+                                will pull that number of data into a linear block.

+  @param  ExtFree               Pointer to the caller provided free function.

+  @param  Arg                   The argument passed to ExtFree when ExtFree is

+                                called.

+

+  @retval *                     Pointer to the net buffer built from the data

+                                blocks.

+

+**/

+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

+  )

+{

+  NET_BUF                   *Nbuf;

+  NET_VECTOR                *Vector;

+  NET_FRAGMENT              SavedFragment;

+  UINT32                    SavedIndex;

+  UINT32                    TotalLen;

+  UINT32                    BlockNum;

+  UINT8                     *FirstBlock;

+  UINT32                    FirstBlockLen;

+  UINT8                     *Header;

+  UINT32                    CurBlock;

+  UINT32                    Index;

+  UINT32                    Len;

+  UINT32                    Copied;

+

+  ASSERT ((ExtFragment != NULL) && (ExtNum > 0) && (ExtFree != NULL));

+

+  SavedFragment.Bulk = NULL;

+  SavedFragment.Len  = 0;

+

+  FirstBlockLen  = 0;

+  FirstBlock     = NULL;

+  BlockNum       = ExtNum;

+  Index          = 0;

+  TotalLen       = 0;

+  SavedIndex     = 0;

+  Len            = 0;

+  Copied         = 0;

+

+  //

+  // No need to consolidate the header if the first block is

+  // longer than the header length or there is only one block.

+  //

+  if ((ExtFragment[0].Len >= HeadLen) || (ExtNum == 1)) {

+    HeadLen = 0;

+  }

+

+  //

+  // Allocate an extra block if we need to:

+  //  1. Allocate some header space

+  //  2. aggreate the packet header

+  //

+  if ((HeadSpace != 0) || (HeadLen != 0)) {

+    FirstBlockLen = HeadLen + HeadSpace;

+    FirstBlock    = NetAllocatePool (FirstBlockLen);

+

+    if (FirstBlock == NULL) {

+      return NULL;

+    }

+

+    BlockNum++;

+  }

+

+  //

+  // Copy the header to the first block, reduce the NET_BLOCK

+  // to allocate by one for each block that is completely covered

+  // by the first bulk.

+  //

+  if (HeadLen != 0) {

+    Len    = HeadLen;

+    Header = FirstBlock + HeadSpace;

+

+    for (Index = 0; Index < ExtNum; Index++) {

+      if (Len >= ExtFragment[Index].Len) {

+        NetCopyMem (Header, ExtFragment[Index].Bulk, ExtFragment[Index].Len);

+

+        Copied    += ExtFragment[Index].Len;

+        Len       -= ExtFragment[Index].Len;

+        Header    += ExtFragment[Index].Len;

+        TotalLen  += ExtFragment[Index].Len;

+        BlockNum--;

+

+        if (Len == 0) {

+          //

+          // Increament the index number to point to the next

+          // non-empty fragment.

+          //

+          Index++;

+          break;

+        }

+

+      } else {

+        NetCopyMem (Header, ExtFragment[Index].Bulk, Len);

+

+        Copied    += Len;

+        TotalLen  += Len;

+

+        //

+        // Adjust the block structure to exclude the data copied,

+        // So, the left-over block can be processed as other blocks.

+        // But it must be recovered later. (SavedIndex > 0) always

+        // holds since we don't aggreate the header if the first block

+        // is bigger enough that the header is continuous

+        //

+        SavedIndex    = Index;

+        SavedFragment = ExtFragment[Index];

+        ExtFragment[Index].Bulk += Len;

+        ExtFragment[Index].Len  -= Len;

+        break;

+      }

+    }

+  }

+

+  Nbuf = NetbufAllocStruct (BlockNum, BlockNum);

+

+  if (Nbuf == NULL) {

+    goto FreeFirstBlock;

+  }

+

+  Vector       = Nbuf->Vector;

+  Vector->Free = ExtFree;

+  Vector->Arg  = Arg;

+  Vector->Flag = (FirstBlockLen ? NET_VECTOR_OWN_FIRST : 0);

+

+  //

+  // Set the first block up which may contain

+  // some head space and aggregated header

+  //

+  CurBlock = 0;

+

+  if (FirstBlockLen != 0) {

+    NetbufSetBlock (Nbuf, FirstBlock, HeadSpace + Copied, 0);

+    Nbuf->BlockOp[0].Head += HeadSpace;

+    Nbuf->BlockOp[0].Size =  Copied;

+

+    CurBlock++;

+  }

+

+  for (; Index < ExtNum; Index++) {

+    NetbufSetBlock (Nbuf, ExtFragment[Index].Bulk, ExtFragment[Index].Len, CurBlock);

+    TotalLen += ExtFragment[Index].Len;

+    CurBlock++;

+  }

+

+  Vector->Len     = TotalLen + HeadSpace;

+  Nbuf->TotalSize = TotalLen;

+

+  if (SavedIndex) {

+    ExtFragment[SavedIndex] = SavedFragment;

+  }

+

+  return Nbuf;

+

+FreeFirstBlock:

+  NetFreePool (FirstBlock);

+  return NULL;

+}

+

+

+/**

+  Build a fragment table to contain the fragments in the

+  buffer. This is the opposite of the NetbufFromExt.

+

+  @param  Nbuf                  Point to the net buffer

+  @param  ExtFragment           Pointer to the data block.

+  @param  ExtNum                The number of the data block.

+

+  @retval EFI_BUFFER_TOO_SMALL  The number of non-empty block is bigger than ExtNum

+  @retval EFI_SUCCESS           Fragment table built.

+

+**/

+EFI_STATUS

+NetbufBuildExt (

+  IN NET_BUF                *Nbuf,

+  IN NET_FRAGMENT           *ExtFragment,

+  IN UINT32                 *ExtNum

+  )

+{

+  UINT32                    Index;

+  UINT32                    Current;

+

+  Current = 0;

+

+  for (Index = 0; (Index < Nbuf->BlockOpNum); Index++) {

+    if (Nbuf->BlockOp[Index].Size == 0) {

+      continue;

+    }

+

+    if (Current < *ExtNum) {

+      ExtFragment[Current].Bulk = Nbuf->BlockOp[Index].Head;

+      ExtFragment[Current].Len  = Nbuf->BlockOp[Index].Size;

+      Current++;

+    } else {

+      return EFI_BUFFER_TOO_SMALL;

+    }

+  }

+

+  *ExtNum = Current;

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Build a NET_BUF from a list of NET_BUF.

+

+  @param  BufList               A List of NET_BUF.

+  @param  HeadSpace             The head space to be reserved.

+  @param  HeaderLen             The length of the protocol header, This function

+                                will pull that number of data into a linear block.

+  @param  ExtFree               Pointer to the caller provided free function.

+  @param  Arg                   The argument passed to ExtFree when ExtFree is

+                                called.

+

+  @retval *                     Pointer to the net buffer built from the data

+                                blocks.

+

+**/

+NET_BUF  *

+NetbufFromBufList (

+  IN NET_LIST_ENTRY         *BufList,

+  IN UINT32                 HeadSpace,

+  IN UINT32                 HeaderLen,

+  IN NET_VECTOR_EXT_FREE    ExtFree,

+  IN VOID                   *Arg              OPTIONAL

+  )

+{

+  NET_FRAGMENT              *Fragment;

+  UINT32                    FragmentNum;

+  NET_LIST_ENTRY            *Entry;

+  NET_BUF                   *Nbuf;

+  UINT32                    Index;

+  UINT32                    Current;

+

+  //

+  //Compute how many blocks are there

+  //

+  FragmentNum = 0;

+

+  NET_LIST_FOR_EACH (Entry, BufList) {

+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);

+    NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+    FragmentNum += Nbuf->BlockOpNum;

+  }

+

+  //

+  //Allocate and copy block points

+  //

+  Fragment = NetAllocatePool (sizeof (NET_FRAGMENT) * FragmentNum);

+

+  if (Fragment == NULL) {

+    return NULL;

+  }

+

+  Current = 0;

+

+  NET_LIST_FOR_EACH (Entry, BufList) {

+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);

+    NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+    for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {

+      if (Nbuf->BlockOp[Index].Size) {

+        Fragment[Current].Bulk = Nbuf->BlockOp[Index].Head;

+        Fragment[Current].Len  = Nbuf->BlockOp[Index].Size;

+        Current++;

+      }

+    }

+  }

+

+  Nbuf = NetbufFromExt (Fragment, Current, HeadSpace, HeaderLen, ExtFree, Arg);

+  NetFreePool (Fragment);

+

+  return Nbuf;

+}

+

+

+/**

+  Reserve some space in the header room of the buffer.

+  Upon allocation, all the space are in the tail room

+  of the buffer. Call this function to move some space

+  to the header room. This function is quite limited in

+  that it can only reserver space from the first block

+  of an empty NET_BUF not built from the external. But

+  it should be enough for the network stack.

+

+  @param  Nbuf                  Pointer to the net buffer.

+  @param  Len                   The length of buffer to be reserverd.

+

+  @return None.

+

+**/

+VOID

+NetbufReserve (

+  IN NET_BUF                *Nbuf,

+  IN UINT32                 Len

+  )

+{

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+  NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);

+

+  ASSERT ((Nbuf->BlockOpNum == 1) && (Nbuf->TotalSize == 0));

+  ASSERT ((Nbuf->Vector->Free == NULL) && (Nbuf->Vector->Len >= Len));

+

+  Nbuf->BlockOp[0].Head += Len;

+  Nbuf->BlockOp[0].Tail += Len;

+

+  ASSERT (Nbuf->BlockOp[0].Tail <= Nbuf->BlockOp[0].BlockTail);

+}

+

+

+/**

+  Allocate some space from the header or tail of the buffer.

+

+  @param  Nbuf                  Pointer to the net buffer.

+  @param  Len                   The length of the buffer to be allocated.

+  @param  FromHead              The flag to indicate whether reserve the data from

+                                head or tail. TRUE for from head, and FALSE for

+                                from tail.

+

+  @retval *                     Pointer to the first byte of the allocated buffer.

+

+**/

+UINT8  *

+NetbufAllocSpace (

+  IN NET_BUF                *Nbuf,

+  IN UINT32                 Len,

+  IN BOOLEAN                FromHead

+  )

+{

+  NET_BLOCK_OP              *BlockOp;

+  UINT32                    Index;

+  UINT8                     *SavedTail;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+  NET_CHECK_SIGNATURE (Nbuf->Vector, NET_VECTOR_SIGNATURE);

+

+  ASSERT (Len > 0);

+

+  if (FromHead) {

+    //

+    // Allocate some space from head. If the buffer is empty,

+    // allocate from the first block. If it isn't, allocate

+    // from the first non-empty block, or the block before that.

+    //

+    if (Nbuf->TotalSize == 0) {

+      Index = 0;

+    } else {

+      NetbufGetByte (Nbuf, 0, &Index);

+

+      if ((NET_HEADSPACE(&(Nbuf->BlockOp[Index])) < Len) && (Index > 0)) {

+        Index--;

+      }

+    }

+

+    BlockOp = &(Nbuf->BlockOp[Index]);

+

+    if (NET_HEADSPACE (BlockOp) < Len) {

+      return NULL;

+    }

+

+    BlockOp->Head   -= Len;

+    BlockOp->Size   += Len;

+    Nbuf->TotalSize += Len;

+

+    return BlockOp->Head;

+

+  } else {

+    //

+    // Allocate some space from the tail. If the buffer is empty,

+    // allocate from the first block. If it isn't, allocate

+    // from the last non-empty block, or the block after that.

+    //

+    if (Nbuf->TotalSize == 0) {

+      Index = 0;

+    } else {

+      NetbufGetByte (Nbuf, Nbuf->TotalSize - 1, &Index);

+

+      if ((NET_TAILSPACE(&(Nbuf->BlockOp[Index])) < Len) &&

+          (Index < Nbuf->BlockOpNum - 1)) {

+

+        Index++;

+      }

+    }

+

+    BlockOp = &(Nbuf->BlockOp[Index]);

+

+    if (NET_TAILSPACE (BlockOp) < Len) {

+      return NULL;

+    }

+

+    SavedTail       = BlockOp->Tail;

+

+    BlockOp->Tail   += Len;

+    BlockOp->Size   += Len;

+    Nbuf->TotalSize += Len;

+

+    return SavedTail;

+  }

+}

+

+

+/**

+  Trim a single NET_BLOCK.

+

+  @param  BlockOp               Pointer to the NET_BLOCK.

+  @param  Len                   The length of the data to be trimmed.

+  @param  FromHead              The flag to indicate whether trim data from head or

+                                tail. TRUE for from head, and FALSE for from tail.

+

+  @return None.

+

+**/

+STATIC

+VOID

+NetblockTrim (

+  IN NET_BLOCK_OP           *BlockOp,

+  IN UINT32                 Len,

+  IN BOOLEAN                FromHead

+  )

+{

+  ASSERT (BlockOp && (BlockOp->Size >= Len));

+

+  BlockOp->Size -= Len;

+

+  if (FromHead) {

+    BlockOp->Head += Len;

+  } else {

+    BlockOp->Tail -= Len;

+  }

+}

+

+

+/**

+  Trim some data from the header or tail of the buffer.

+

+  @param  Nbuf                  Pointer to the net buffer.

+  @param  Len                   The length of the data to be trimmed.

+  @param  FromHead              The flag to indicate whether trim data from head or

+                                tail. TRUE for from head, and FALSE for from tail.

+

+  @retval UINTN                 Length of the actually trimmed data.

+

+**/

+UINT32

+NetbufTrim (

+  IN NET_BUF                *Nbuf,

+  IN UINT32                 Len,

+  IN BOOLEAN                FromHead

+  )

+{

+  NET_BLOCK_OP              *BlockOp;

+  UINT32                    Index;

+  UINT32                    Trimmed;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+  if (Len > Nbuf->TotalSize) {

+    Len = Nbuf->TotalSize;

+  }

+

+  //

+  // If FromTail is true, iterate backward. That

+  // is, init Index to NBuf->BlockNum - 1, and

+  // decrease it by 1 during each loop. Otherwise,

+  // iterate forward. That is, init Index to 0, and

+  // increase it by 1 during each loop.

+  //

+  Trimmed          = 0;

+  Nbuf->TotalSize -= Len;

+

+  Index   = (FromHead ? 0 : Nbuf->BlockOpNum - 1);

+  BlockOp = Nbuf->BlockOp;

+

+  for (;;) {

+    if (BlockOp[Index].Size == 0) {

+      Index += (FromHead ? 1 : -1);

+      continue;

+    }

+

+    if (Len > BlockOp[Index].Size) {

+      Len     -= BlockOp[Index].Size;

+      Trimmed += BlockOp[Index].Size;

+      NetblockTrim (&BlockOp[Index], BlockOp[Index].Size, FromHead);

+    } else {

+      Trimmed += Len;

+      NetblockTrim (&BlockOp[Index], Len, FromHead);

+      break;

+    }

+

+    Index += (FromHead ? 1 : -1);

+  }

+

+  return Trimmed;

+}

+

+

+/**

+  Copy the data from the specific offset to the destination.

+

+  @param  Nbuf                  Pointer to the net buffer.

+  @param  Offset                The sequence number of the first byte to copy.

+  @param  Len                   Length of the data to copy.

+  @param  Dest                  The destination of the data to copy to.

+

+  @retval UINTN                 The length of the copied data.

+

+**/

+UINT32

+NetbufCopy (

+  IN NET_BUF                *Nbuf,

+  IN UINT32                 Offset,

+  IN UINT32                 Len,

+  IN UINT8                  *Dest

+  )

+{

+  NET_BLOCK_OP              *BlockOp;

+  UINT32                    Skip;

+  UINT32                    Left;

+  UINT32                    Copied;

+  UINT32                    Index;

+  UINT32                    Cur;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+  ASSERT (Dest);

+

+  if ((Len == 0) || (Nbuf->TotalSize <= Offset)) {

+    return 0;

+  }

+

+  if (Nbuf->TotalSize - Offset < Len) {

+    Len = Nbuf->TotalSize - Offset;

+  }

+

+  BlockOp = Nbuf->BlockOp;

+

+  //

+  // Skip to the offset. Don't make "Offset-By-One" error here.

+  // Cur + BLOCK.SIZE is the first sequence number of next block.

+  // So, (Offset < Cur + BLOCK.SIZE) means that the  first byte

+  // is in the current block. if (Offset == Cur + BLOCK.SIZE), the

+  // first byte is the next block's first byte.

+  //

+  Cur = 0;

+

+  for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {

+    if (BlockOp[Index].Size == 0) {

+      continue;

+    }

+

+    if (Offset < Cur + BlockOp[Index].Size) {

+      break;

+    }

+

+    Cur += BlockOp[Index].Size;

+  }

+

+  //

+  // Cur is the sequence number of the first byte in the block

+  // Offset - Cur is the number of bytes before first byte to

+  // to copy in the current block.

+  //

+  Skip  = Offset - Cur;

+  Left  = BlockOp[Index].Size - Skip;

+

+  if (Len <= Left) {

+    NetCopyMem (Dest, BlockOp[Index].Head + Skip, Len);

+    return Len;

+  }

+

+  NetCopyMem (Dest, BlockOp[Index].Head + Skip, Left);

+

+  Dest  += Left;

+  Len   -= Left;

+  Copied = Left;

+

+  Index++;

+

+  for (; Index < Nbuf->BlockOpNum; Index++) {

+    if (Len > BlockOp[Index].Size) {

+      Len    -= BlockOp[Index].Size;

+      Copied += BlockOp[Index].Size;

+

+      NetCopyMem (Dest, BlockOp[Index].Head, BlockOp[Index].Size);

+      Dest   += BlockOp[Index].Size;

+    } else {

+      Copied += Len;

+      NetCopyMem (Dest, BlockOp[Index].Head, Len);

+      break;

+    }

+  }

+

+  return Copied;

+}

+

+

+/**

+  Initiate the net buffer queue.

+

+  @param  NbufQue               Pointer to the net buffer queue to be initiated.

+

+  @return None.

+

+**/

+VOID

+NetbufQueInit (

+  IN NET_BUF_QUEUE          *NbufQue

+  )

+{

+  NbufQue->Signature  = NET_QUE_SIGNATURE;

+  NbufQue->RefCnt     = 1;

+  NetListInit (&NbufQue->List);

+

+  NetListInit (&NbufQue->BufList);

+  NbufQue->BufSize  = 0;

+  NbufQue->BufNum   = 0;

+}

+

+

+/**

+  Allocate an initialized net buffer queue.

+

+  None.

+

+  @retval *                     Pointer to the allocated net buffer queue.

+

+**/

+NET_BUF_QUEUE  *

+NetbufQueAlloc (

+  VOID

+  )

+{

+  NET_BUF_QUEUE             *NbufQue;

+

+  NbufQue = NetAllocatePool (sizeof (NET_BUF_QUEUE));

+  if (NbufQue == NULL) {

+    return NULL;

+  }

+

+  NetbufQueInit (NbufQue);

+

+  return NbufQue;

+}

+

+

+/**

+  Free a net buffer queue.

+

+  @param  NbufQue               Poitner to the net buffer queue to be freed.

+

+  @return None.

+

+**/

+VOID

+NetbufQueFree (

+  IN NET_BUF_QUEUE          *NbufQue

+  )

+{

+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);

+

+  NbufQue->RefCnt--;

+

+  if (NbufQue->RefCnt == 0) {

+    NetbufQueFlush (NbufQue);

+    NetFreePool (NbufQue);

+  }

+}

+

+

+/**

+  Append a buffer to the end of the queue.

+

+  @param  NbufQue               Pointer to the net buffer queue.

+  @param  Nbuf                  Pointer to the net buffer to be appended.

+

+  @return None.

+

+**/

+VOID

+NetbufQueAppend (

+  IN NET_BUF_QUEUE          *NbufQue,

+  IN NET_BUF                *Nbuf

+  )

+{

+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+  NetListInsertTail (&NbufQue->BufList, &Nbuf->List);

+

+  NbufQue->BufSize += Nbuf->TotalSize;

+  NbufQue->BufNum++;

+}

+

+

+/**

+  Remove a net buffer from head in the specific queue.

+

+  @param  NbufQue               Pointer to the net buffer queue.

+

+  @retval *                     Pointer to the net buffer removed from the specific

+                                queue.

+

+**/

+NET_BUF  *

+NetbufQueRemove (

+  IN NET_BUF_QUEUE          *NbufQue

+  )

+{

+  NET_BUF                   *First;

+

+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);

+

+  if (NbufQue->BufNum == 0) {

+    return NULL;

+  }

+

+  First = NET_LIST_USER_STRUCT (NbufQue->BufList.ForwardLink, NET_BUF, List);

+

+  NetListRemoveHead (&NbufQue->BufList);

+

+  NbufQue->BufSize -= First->TotalSize;

+  NbufQue->BufNum--;

+  return First;

+}

+

+

+/**

+  Copy some data from the buffer queue to the destination.

+

+  @param  NbufQue               Pointer to the net buffer queue.

+  @param  Offset                The sequence number of the first byte to copy.

+  @param  Len                   Length of the data to copy.

+  @param  Dest                  The destination of the data to copy to.

+

+  @retval UINTN                 The length of the copied data.

+

+**/

+UINT32

+NetbufQueCopy (

+  IN NET_BUF_QUEUE          *NbufQue,

+  IN UINT32                 Offset,

+  IN UINT32                 Len,

+  IN UINT8                  *Dest

+  )

+{

+  NET_LIST_ENTRY            *Entry;

+  NET_BUF                   *Nbuf;

+  UINT32                    Skip;

+  UINT32                    Left;

+  UINT32                    Cur;

+  UINT32                    Copied;

+

+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);

+  ASSERT (Dest != NULL);

+

+  if ((Len == 0) || (NbufQue->BufSize <= Offset)) {

+    return 0;

+  }

+

+  if (NbufQue->BufSize - Offset < Len) {

+    Len = NbufQue->BufSize - Offset;

+  }

+

+  //

+  // skip to the Offset

+  //

+  Cur   = 0;

+  Nbuf  = NULL;

+

+  NET_LIST_FOR_EACH (Entry, &NbufQue->BufList) {

+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);

+

+    if (Offset < Cur + Nbuf->TotalSize) {

+      break;

+    }

+

+    Cur += Nbuf->TotalSize;

+  }

+

+  //

+  // Copy the data in the first buffer.

+  //

+  Skip  = Offset - Cur;

+  Left  = Nbuf->TotalSize - Skip;

+

+  if (Len < Left) {

+    return NetbufCopy (Nbuf, Skip, Len, Dest);

+  }

+

+  NetbufCopy (Nbuf, Skip, Left, Dest);

+  Dest  += Left;

+  Len   -= Left;

+  Copied = Left;

+

+  //

+  // Iterate over the others

+  //

+  Entry = Entry->ForwardLink;

+

+  while ((Len > 0) && (Entry != &NbufQue->BufList)) {

+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);

+

+    if (Len > Nbuf->TotalSize) {

+      Len -= Nbuf->TotalSize;

+      Copied += Nbuf->TotalSize;

+

+      NetbufCopy (Nbuf, 0, Nbuf->TotalSize, Dest);

+      Dest += Nbuf->TotalSize;

+

+    } else {

+      NetbufCopy (Nbuf, 0, Len, Dest);

+      Copied += Len;

+      break;

+    }

+

+    Entry = Entry->ForwardLink;

+  }

+

+  return Copied;

+}

+

+

+/**

+  Trim some data from the queue header, release the buffer if

+  whole buffer is trimmed.

+

+  @param  NbufQue               Pointer to the net buffer queue.

+  @param  Len                   Length of the data to trim.

+

+  @retval UINTN                 The length of the data trimmed.

+

+**/

+UINT32

+NetbufQueTrim (

+  IN NET_BUF_QUEUE          *NbufQue,

+  IN UINT32                 Len

+  )

+{

+  NET_LIST_ENTRY            *Entry;

+  NET_LIST_ENTRY            *Next;

+  NET_BUF                   *Nbuf;

+  UINT32                    Trimmed;

+

+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);

+

+  if (Len == 0) {

+    return 0;

+  }

+

+  if (Len > NbufQue->BufSize) {

+    Len = NbufQue->BufSize;

+  }

+

+  NbufQue->BufSize -= Len;

+  Trimmed = 0;

+

+  NET_LIST_FOR_EACH_SAFE (Entry, Next, &NbufQue->BufList) {

+    Nbuf = NET_LIST_USER_STRUCT (Entry, NET_BUF, List);

+

+    if (Len >= Nbuf->TotalSize) {

+      Trimmed += Nbuf->TotalSize;

+      Len -= Nbuf->TotalSize;

+

+      NetListRemoveEntry (Entry);

+      NetbufFree (Nbuf);

+

+      NbufQue->BufNum--;

+

+      if (Len == 0) {

+        break;

+      }

+

+    } else {

+      Trimmed += NetbufTrim (Nbuf, Len, NET_BUF_HEAD);

+      break;

+    }

+  }

+

+  return Trimmed;

+}

+

+

+/**

+  Flush the net buffer queue.

+

+  @param  NbufQue               Pointer to the queue to be flushed.

+

+  @return None.

+

+**/

+VOID

+NetbufQueFlush (

+  IN NET_BUF_QUEUE          *NbufQue

+  )

+{

+  NET_CHECK_SIGNATURE (NbufQue, NET_QUE_SIGNATURE);

+

+  NetbufFreeList (&NbufQue->BufList);

+

+  NbufQue->BufNum   = 0;

+  NbufQue->BufSize  = 0;

+}

+

+

+/**

+  Compute checksum for a bulk of data.

+

+  @param  Bulk                  Pointer to the data.

+  @param  Len                   Length of the data, in bytes.

+

+  @retval UINT16                The computed checksum.

+

+**/

+UINT16

+NetblockChecksum (

+  IN UINT8                  *Bulk,

+  IN UINT32                 Len

+  )

+{

+  register UINT32           Sum;

+

+  Sum = 0;

+

+  while (Len > 1) {

+    Sum += *(UINT16 *) Bulk;

+    Bulk += 2;

+    Len -= 2;

+  }

+

+  //

+  // Add left-over byte, if any

+  //

+  if (Len > 0) {

+    Sum += *(UINT8 *) Bulk;

+  }

+

+  //

+  // Fold 32-bit sum to 16 bits

+  //

+  while (Sum >> 16) {

+    Sum = (Sum & 0xffff) + (Sum >> 16);

+

+  }

+

+  return (UINT16) Sum;

+}

+

+

+/**

+  Add two checksums.

+

+  @param  Checksum1             The first checksum to be added.

+  @param  Checksum2             The second checksum to be added.

+

+  @retval UINT16                The new checksum.

+

+**/

+UINT16

+NetAddChecksum (

+  IN UINT16                 Checksum1,

+  IN UINT16                 Checksum2

+  )

+{

+  UINT32                    Sum;

+

+  Sum = Checksum1 + Checksum2;

+

+  //

+  // two UINT16 can only add up to a carry of 1.

+  //

+  if (Sum >> 16) {

+    Sum = (Sum & 0xffff) + 1;

+

+  }

+

+  return (UINT16) Sum;

+}

+

+

+/**

+  Compute the checksum for a NET_BUF.

+

+  @param  Nbuf                  Pointer to the net buffer.

+

+  @retval UINT16                The computed checksum.

+

+**/

+UINT16

+NetbufChecksum (

+  IN NET_BUF                *Nbuf

+  )

+{

+  NET_BLOCK_OP              *BlockOp;

+  UINT32                    Offset;

+  UINT16                    TotalSum;

+  UINT16                    BlockSum;

+  UINT32                    Index;

+

+  NET_CHECK_SIGNATURE (Nbuf, NET_BUF_SIGNATURE);

+

+  TotalSum  = 0;

+  Offset    = 0;

+  BlockOp   = Nbuf->BlockOp;

+

+  for (Index = 0; Index < Nbuf->BlockOpNum; Index++) {

+    if (BlockOp[Index].Size == 0) {

+      continue;

+    }

+

+    BlockSum = NetblockChecksum (BlockOp[Index].Head, BlockOp[Index].Size);

+

+    if (Offset & 0x01) {

+      //

+      // The checksum starts with an odd byte, swap

+      // the checksum before added to total checksum

+      //

+      BlockSum = NET_SWAP_SHORT (BlockSum);

+    }

+

+    TotalSum = NetAddChecksum (BlockSum, TotalSum);

+    Offset  += BlockOp[Index].Size;

+  }

+

+  return TotalSum;

+}

+

+

+/**

+  Compute the checksum for TCP/UDP pseudo header.

+  Src, Dst are in network byte order. and Len is

+  in host byte order.

+

+  @param  Src                   The source address of the packet.

+  @param  Dst                   The destination address of the packet.

+  @param  Proto                 The protocol type of the packet.

+  @param  Len                   The length of the packet.

+

+  @retval UINT16                The computed checksum.

+

+**/

+UINT16

+NetPseudoHeadChecksum (

+  IN IP4_ADDR               Src,

+  IN IP4_ADDR               Dst,

+  IN UINT8                  Proto,

+  IN UINT16                 Len

+  )

+{

+  NET_PSEUDO_HDR            Hdr;

+

+  //

+  // Zero the memory to relieve align problems

+  //

+  NetZeroMem (&Hdr, sizeof (Hdr));

+

+  Hdr.SrcIp     = Src;

+  Hdr.DstIp     = Dst;

+  Hdr.Protocol  = Proto;

+  Hdr.Len       = HTONS (Len);

+

+  return NetblockChecksum ((UINT8 *) &Hdr, sizeof (Hdr));

+}