DxeNetLib.c

Go to the documentation of this file.

 
#include <Uefi.h>
 
#include <IndustryStandard/SmBios.h>
 
#include <Protocol/DriverBinding.h>
#include <Protocol/ServiceBinding.h>
#include <Protocol/SimpleNetwork.h>
#include <Protocol/AdapterInformation.h>
#include <Protocol/ManagedNetwork.h>
#include <Protocol/Ip4Config2.h>
#include <Protocol/ComponentName.h>
#include <Protocol/ComponentName2.h>
 
#include <Guid/SmBios.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/MemoryAllocationLib.h>
#include <Library/DevicePathLib.h>
#include <Library/PrintLib.h>
#include <Library/UefiLib.h>
#include <Protocol/Rng.h>
 
#define NIC_ITEM_CONFIG_SIZE  (sizeof (NIC_IP4_CONFIG_INFO) + sizeof (EFI_IP4_ROUTE_TABLE) * MAX_IP4_CONFIG_IN_VARIABLE)
#define DEFAULT_ZERO_START    ((UINTN) ~0)
 
//
// All the supported IP4 masks in host byte order.
//
GLOBAL_REMOVE_IF_UNREFERENCED IP4_ADDR  gIp4AllMasks[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,
};
 
GLOBAL_REMOVE_IF_UNREFERENCED EFI_IPv4_ADDRESS  mZeroIp4Addr = {
  { 0, 0, 0, 0 }
};
 
//
// Any error level digitally larger than mNetDebugLevelMax
// will be silently discarded.
//
GLOBAL_REMOVE_IF_UNREFERENCED UINTN   mNetDebugLevelMax = NETDEBUG_LEVEL_ERROR;
GLOBAL_REMOVE_IF_UNREFERENCED UINT32  mSyslogPacketSeq  = 0xDEADBEEF;
 
//
// You can change mSyslogDstMac mSyslogDstIp and mSyslogSrcIp
// here to direct the syslog packets to the syslog deamon. The
// default is broadcast to both the ethernet and IP.
//
GLOBAL_REMOVE_IF_UNREFERENCED UINT8   mSyslogDstMac[NET_ETHER_ADDR_LEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
GLOBAL_REMOVE_IF_UNREFERENCED UINT32  mSyslogDstIp                      = 0xffffffff;
GLOBAL_REMOVE_IF_UNREFERENCED UINT32  mSyslogSrcIp                      = 0;
 
GLOBAL_REMOVE_IF_UNREFERENCED CHAR8  *mMonthName[] = {
  "Jan",
  "Feb",
  "Mar",
  "Apr",
  "May",
  "Jun",
  "Jul",
  "Aug",
  "Sep",
  "Oct",
  "Nov",
  "Dec"
};
 
//
// VLAN device path node template
//
GLOBAL_REMOVE_IF_UNREFERENCED VLAN_DEVICE_PATH  mNetVlanDevicePathTemplate = {
  {
    MESSAGING_DEVICE_PATH,
    MSG_VLAN_DP,
    {
      (UINT8)(sizeof (VLAN_DEVICE_PATH)),
      (UINT8)((sizeof (VLAN_DEVICE_PATH)) >> 8)
    }
  },
  0
};
 
//
// These represent UEFI SPEC defined algorithms that should be supported by
// the RNG protocol and are generally considered secure.
//
// Assuming that PcdEnforceSecureRngAlgorithms is TRUE (the default) then
// only the algorithms defined here will be used by the network stack, and
// none of these being available will result in an error condition (even if
// some other RNG implementation is available).
//
// If PcdEnforceSecureRngAlgorithms is FALSE this list is not consulted,
// and the first available RNG algorithm is used.
//
// If your platform needs to use a specific algorithm for the random number
// generator, then you should modify this array.
//
static GLOBAL_REMOVE_IF_UNREFERENCED EFI_GUID  *mSecureHashAlgorithms[] = {
  &gEfiRngAlgorithmSp80090Ctr256Guid,  // SP800-90A DRBG CTR using AES-256
  &gEfiRngAlgorithmSp80090Hmac256Guid, // SP800-90A DRBG HMAC using SHA-256
  &gEfiRngAlgorithmSp80090Hash256Guid, // SP800-90A DRBG Hash using SHA-256
  &gEfiRngAlgorithmArmRndr,            // unspecified SP800-90A DRBG via ARM RNDR register
  &gEfiRngAlgorithmRaw,                // Raw data from NRBG (or TRNG)
};
 
#define SECURE_HASH_ALGORITHMS_SIZE  (sizeof (mSecureHashAlgorithms) / sizeof (EFI_GUID *))
 
EFI_SIMPLE_NETWORK_PROTOCOL *
SyslogLocateSnp (
  VOID
  )
{
  EFI_SIMPLE_NETWORK_PROTOCOL  *Snp;
  EFI_STATUS                   Status;
  EFI_HANDLE                   *Handles;
  UINTN                        HandleCount;
  UINTN                        Index;
 
  //
  // Locate the handles which has SNP installed.
  //
  Handles = NULL;
  Status  = gBS->LocateHandleBuffer (
                   ByProtocol,
                   &gEfiSimpleNetworkProtocolGuid,
                   NULL,
                   &HandleCount,
                   &Handles
                   );
 
  if (EFI_ERROR (Status) || (HandleCount == 0)) {
    return NULL;
  }
 
  //
  // Try to open one of the ethernet SNP protocol to send packet
  //
  Snp = NULL;
 
  for (Index = 0; Index < HandleCount; Index++) {
    Status = gBS->HandleProtocol (
                    Handles[Index],
                    &gEfiSimpleNetworkProtocolGuid,
                    (VOID **)&Snp
                    );
 
    if ((Status == EFI_SUCCESS) && (Snp != NULL) &&
        (Snp->Mode->IfType == NET_IFTYPE_ETHERNET) &&
        (Snp->Mode->MaxPacketSize >= NET_SYSLOG_PACKET_LEN))
    {
      break;
    }
 
    Snp = NULL;
  }
 
  FreePool (Handles);
  return Snp;
}
 
EFI_STATUS
SyslogSendPacket (
  IN CHAR8   *Packet,
  IN UINT32  Length
  )
{
  EFI_SIMPLE_NETWORK_PROTOCOL  *Snp;
  ETHER_HEAD                   *Ether;
  EFI_STATUS                   Status;
  EFI_EVENT                    TimeoutEvent;
  UINT8                        *TxBuf;
 
  ASSERT (Packet != NULL);
 
  Snp = SyslogLocateSnp ();
 
  if (Snp == NULL) {
    return EFI_DEVICE_ERROR;
  }
 
  Ether = (ETHER_HEAD *)Packet;
  CopyMem (Ether->SrcMac, Snp->Mode->CurrentAddress.Addr, NET_ETHER_ADDR_LEN);
 
  //
  // Start the timeout event.
  //
  Status = gBS->CreateEvent (
                  EVT_TIMER,
                  TPL_NOTIFY,
                  NULL,
                  NULL,
                  &TimeoutEvent
                  );
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = gBS->SetTimer (TimeoutEvent, TimerRelative, NET_SYSLOG_TX_TIMEOUT);
 
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  for ( ; ;) {
    //
    // Transmit the packet through SNP.
    //
    Status = Snp->Transmit (Snp, 0, Length, Packet, NULL, NULL, NULL);
 
    if ((Status != EFI_SUCCESS) && (Status != EFI_NOT_READY)) {
      Status = EFI_DEVICE_ERROR;
      break;
    }
 
    //
    // If Status is EFI_SUCCESS, the packet is put in the transmit queue.
    // if Status is EFI_NOT_READY, the transmit engine of the network
    // interface is busy. Both need to sync SNP.
    //
    TxBuf = NULL;
 
    do {
      //
      // Get the recycled transmit buffer status.
      //
      Snp->GetStatus (Snp, NULL, (VOID **)&TxBuf);
 
      if (!EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
        Status = EFI_TIMEOUT;
        break;
      }
    } while (TxBuf == NULL);
 
    if ((Status == EFI_SUCCESS) || (Status == EFI_TIMEOUT)) {
      break;
    }
 
    //
    // Status is EFI_NOT_READY. Restart the timer event and
    // call Snp->Transmit again.
    //
    gBS->SetTimer (TimeoutEvent, TimerRelative, NET_SYSLOG_TX_TIMEOUT);
  }
 
  gBS->SetTimer (TimeoutEvent, TimerCancel, 0);
 
ON_EXIT:
  gBS->CloseEvent (TimeoutEvent);
  return Status;
}
 
UINT32
SyslogBuildPacket (
  IN  UINT32  Level,
  IN  UINT8   *Module,
  IN  UINT8   *File,
  IN  UINT32  Line,
  IN  UINT8   *Message,
  IN  UINT32  BufLen,
  OUT CHAR8   *Buf
  )
{
  EFI_STATUS      Status;
  ETHER_HEAD      *Ether;
  IP4_HEAD        *Ip4;
  EFI_UDP_HEADER  *Udp4;
  EFI_TIME        Time;
  UINT32          Pri;
  UINT32          Len;
 
  //
  // Fill in the Ethernet header. Leave alone the source MAC.
  // SyslogSendPacket will fill in the address for us.
  //
  Ether = (ETHER_HEAD *)Buf;
  CopyMem (Ether->DstMac, mSyslogDstMac, NET_ETHER_ADDR_LEN);
  ZeroMem (Ether->SrcMac, NET_ETHER_ADDR_LEN);
 
  Ether->EtherType = HTONS (0x0800);    // IPv4 protocol
 
  Buf    += sizeof (ETHER_HEAD);
  BufLen -= sizeof (ETHER_HEAD);
 
  //
  // Fill in the IP header
  //
  Ip4           = (IP4_HEAD *)Buf;
  Ip4->HeadLen  = 5;
  Ip4->Ver      = 4;
  Ip4->Tos      = 0;
  Ip4->TotalLen = 0;
  Ip4->Id       = (UINT16)mSyslogPacketSeq;
  Ip4->Fragment = 0;
  Ip4->Ttl      = 16;
  Ip4->Protocol = 0x11;
  Ip4->Checksum = 0;
  Ip4->Src      = mSyslogSrcIp;
  Ip4->Dst      = mSyslogDstIp;
 
  Buf    += sizeof (IP4_HEAD);
  BufLen -= sizeof (IP4_HEAD);
 
  //
  // Fill in the UDP header, Udp checksum is optional. Leave it zero.
  //
  Udp4           = (EFI_UDP_HEADER *)Buf;
  Udp4->SrcPort  = HTONS (514);
  Udp4->DstPort  = HTONS (514);
  Udp4->Length   = 0;
  Udp4->Checksum = 0;
 
  Buf    += sizeof (EFI_UDP_HEADER);
  BufLen -= sizeof (EFI_UDP_HEADER);
 
  //
  // Build the syslog message body with <PRI> Timestamp  machine module Message
  //
  Pri    = ((NET_SYSLOG_FACILITY & 31) << 3) | (Level & 7);
  Status = gRT->GetTime (&Time, NULL);
  if (EFI_ERROR (Status)) {
    return 0;
  }
 
  //
  // Use %a to format the ASCII strings, %s to format UNICODE strings
  //
  Len  = 0;
  Len += (UINT32)AsciiSPrint (
                   Buf,
                   BufLen,
                   "<%d> %a %d %d:%d:%d ",
                   Pri,
                   mMonthName[Time.Month-1],
                   Time.Day,
                   Time.Hour,
                   Time.Minute,
                   Time.Second
                   );
 
  Len += (UINT32)AsciiSPrint (
                   Buf + Len,
                   BufLen - Len,
                   "Tiano %a: %a (Line: %d File: %a)",
                   Module,
                   Message,
                   Line,
                   File
                   );
  Len++;
 
  //
  // OK, patch the IP length/checksum and UDP length fields.
  //
  Len         += sizeof (EFI_UDP_HEADER);
  Udp4->Length = HTONS ((UINT16)Len);
 
  Len          += sizeof (IP4_HEAD);
  Ip4->TotalLen = HTONS ((UINT16)Len);
  Ip4->Checksum = (UINT16)(~NetblockChecksum ((UINT8 *)Ip4, sizeof (IP4_HEAD)));
 
  return Len + sizeof (ETHER_HEAD);
}
 
CHAR8 *
EFIAPI
NetDebugASPrint (
  IN CHAR8  *Format,
  ...
  )
{
  VA_LIST  Marker;
  CHAR8    *Buf;
 
  ASSERT (Format != NULL);
 
  Buf = (CHAR8 *)AllocatePool (NET_DEBUG_MSG_LEN);
 
  if (Buf == NULL) {
    return NULL;
  }
 
  VA_START (Marker, Format);
  AsciiVSPrint (Buf, NET_DEBUG_MSG_LEN, Format, Marker);
  VA_END (Marker);
 
  return Buf;
}
 
EFI_STATUS
EFIAPI
NetDebugOutput (
  IN UINT32  Level,
  IN UINT8   *Module,
  IN UINT8   *File,
  IN UINT32  Line,
  IN UINT8   *Message
  )
{
  CHAR8       *Packet;
  UINT32      Len;
  EFI_STATUS  Status;
 
  //
  // Check whether the message should be sent out
  //
  if ((Message == NULL) || (File == NULL) || (Module == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (Level > mNetDebugLevelMax) {
    Status = EFI_SUCCESS;
    goto ON_EXIT;
  }
 
  //
  // Allocate a maximum of 1024 bytes, the caller should ensure
  // that the message plus the ethernet/ip/udp header is shorter
  // than this
  //
  Packet = (CHAR8 *)AllocatePool (NET_SYSLOG_PACKET_LEN);
 
  if (Packet == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto ON_EXIT;
  }
 
  //
  // Build the message: Ethernet header + IP header + Udp Header + user data
  //
  Len = SyslogBuildPacket (
          Level,
          Module,
          File,
          Line,
          Message,
          NET_SYSLOG_PACKET_LEN,
          Packet
          );
  if (Len == 0) {
    Status = EFI_DEVICE_ERROR;
  } else {
    mSyslogPacketSeq++;
    Status = SyslogSendPacket (Packet, Len);
  }
 
  FreePool (Packet);
 
ON_EXIT:
  FreePool (Message);
  return Status;
}
 
INTN
EFIAPI
NetGetMaskLength (
  IN IP4_ADDR  NetMask
  )
{
  INTN  Index;
 
  for (Index = 0; Index <= IP4_MASK_MAX; Index++) {
    if (NetMask == gIp4AllMasks[Index]) {
      break;
    }
  }
 
  return Index;
}
 
INTN
EFIAPI
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;
  }
}
 
BOOLEAN
EFIAPI
NetIp4IsUnicast (
  IN IP4_ADDR  Ip,
  IN IP4_ADDR  NetMask
  )
{
  INTN  MaskLength;
 
  ASSERT (NetMask != 0);
 
  if ((Ip == 0) || IP4_IS_LOCAL_BROADCAST (Ip)) {
    return FALSE;
  }
 
  MaskLength = NetGetMaskLength (NetMask);
  ASSERT ((MaskLength >= 0) && (MaskLength <= IP4_MASK_NUM));
  if (MaskLength < 31) {
    if (((Ip &~NetMask) == ~NetMask) || ((Ip &~NetMask) == 0)) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
BOOLEAN
EFIAPI
NetIp6IsValidUnicast (
  IN EFI_IPv6_ADDRESS  *Ip6
  )
{
  UINT8  Byte;
  UINT8  Index;
 
  ASSERT (Ip6 != NULL);
 
  if (Ip6->Addr[0] == 0xFF) {
    return FALSE;
  }
 
  for (Index = 0; Index < 15; Index++) {
    if (Ip6->Addr[Index] != 0) {
      return TRUE;
    }
  }
 
  Byte = Ip6->Addr[Index];
 
  if ((Byte == 0x0) || (Byte == 0x1)) {
    return FALSE;
  }
 
  return TRUE;
}
 
BOOLEAN
EFIAPI
NetIp6IsUnspecifiedAddr (
  IN EFI_IPv6_ADDRESS  *Ip6
  )
{
  UINT8  Index;
 
  ASSERT (Ip6 != NULL);
 
  for (Index = 0; Index < 16; Index++) {
    if (Ip6->Addr[Index] != 0) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
BOOLEAN
EFIAPI
NetIp6IsLinkLocalAddr (
  IN EFI_IPv6_ADDRESS  *Ip6
  )
{
  UINT8  Index;
 
  ASSERT (Ip6 != NULL);
 
  if (Ip6->Addr[0] != 0xFE) {
    return FALSE;
  }
 
  if (Ip6->Addr[1] != 0x80) {
    return FALSE;
  }
 
  for (Index = 2; Index < 8; Index++) {
    if (Ip6->Addr[Index] != 0) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
BOOLEAN
EFIAPI
NetIp6IsNetEqual (
  EFI_IPv6_ADDRESS  *Ip1,
  EFI_IPv6_ADDRESS  *Ip2,
  UINT8             PrefixLength
  )
{
  UINT8  Byte;
  UINT8  Bit;
  UINT8  Mask;
 
  ASSERT ((Ip1 != NULL) && (Ip2 != NULL) && (PrefixLength < IP6_PREFIX_MAX));
 
  if (PrefixLength == 0) {
    return TRUE;
  }
 
  Byte = (UINT8)(PrefixLength / 8);
  Bit  = (UINT8)(PrefixLength % 8);
 
  if (CompareMem (Ip1, Ip2, Byte) != 0) {
    return FALSE;
  }
 
  if (Bit > 0) {
    Mask = (UINT8)(0xFF << (8 - Bit));
 
    ASSERT (Byte < 16);
    if (Byte >= 16) {
      return FALSE;
    }
 
    if ((Ip1->Addr[Byte] & Mask) != (Ip2->Addr[Byte] & Mask)) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
EFI_IPv6_ADDRESS *
EFIAPI
Ip6Swap128 (
  EFI_IPv6_ADDRESS  *Ip6
  )
{
  UINT64  High;
  UINT64  Low;
 
  ASSERT (Ip6 != NULL);
 
  CopyMem (&High, Ip6, sizeof (UINT64));
  CopyMem (&Low, &Ip6->Addr[8], sizeof (UINT64));
 
  High = SwapBytes64 (High);
  Low  = SwapBytes64 (Low);
 
  CopyMem (Ip6, &Low, sizeof (UINT64));
  CopyMem (&Ip6->Addr[8], &High, sizeof (UINT64));
 
  return Ip6;
}
 
EFI_STATUS
EFIAPI
PseudoRandom (
  OUT  VOID   *Output,
  IN   UINTN  OutputLength
  )
{
  EFI_RNG_PROTOCOL  *RngProtocol;
  EFI_STATUS        Status;
  UINTN             AlgorithmIndex;
 
  if ((Output == NULL) || (OutputLength == 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = gBS->LocateProtocol (&gEfiRngProtocolGuid, NULL, (VOID **)&RngProtocol);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "Failed to locate EFI_RNG_PROTOCOL: %r\n", Status));
    ASSERT_EFI_ERROR (Status);
    return Status;
  }
 
  if (PcdGetBool (PcdEnforceSecureRngAlgorithms)) {
    for (AlgorithmIndex = 0; AlgorithmIndex < SECURE_HASH_ALGORITHMS_SIZE; AlgorithmIndex++) {
      Status = RngProtocol->GetRNG (RngProtocol, mSecureHashAlgorithms[AlgorithmIndex], OutputLength, (UINT8 *)Output);
      if (!EFI_ERROR (Status)) {
        //
        // Secure Algorithm was supported on this platform
        //
        return EFI_SUCCESS;
      } else if (Status == EFI_UNSUPPORTED) {
        //
        // Secure Algorithm was not supported on this platform
        //
        DEBUG ((DEBUG_VERBOSE, "Failed to generate random data using secure algorithm %d: %r\n", AlgorithmIndex, Status));
 
        //
        // Try the next secure algorithm
        //
        continue;
      } else {
        //
        // Some other error occurred
        //
        DEBUG ((DEBUG_ERROR, "Failed to generate random data using secure algorithm %d: %r\n", AlgorithmIndex, Status));
        ASSERT_EFI_ERROR (Status);
        return Status;
      }
    }
 
    //
    // If we get here, we failed to generate random data using any secure algorithm
    // Platform owner should ensure that at least one secure algorithm is supported
    //
    DEBUG ((DEBUG_ERROR, "Failed to generate random data, no supported secure algorithm found\n"));
    ASSERT_EFI_ERROR (Status);
    return Status;
  }
 
  //
  // Lets try using the default algorithm (which may not be secure)
  //
  Status = RngProtocol->GetRNG (RngProtocol, NULL, OutputLength, (UINT8 *)Output);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a failed to generate random data: %r\n", __func__, Status));
    ASSERT_EFI_ERROR (Status);
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
PseudoRandomU32 (
  OUT UINT32  *Output
  )
{
  return PseudoRandom (Output, sizeof (*Output));
}
 
UINT32
EFIAPI
NetGetUint32 (
  IN UINT8  *Buf
  )
{
  UINT32  Value;
 
  ASSERT (Buf != NULL);
 
  CopyMem (&Value, Buf, sizeof (UINT32));
  return NTOHL (Value);
}
 
VOID
EFIAPI
NetPutUint32 (
  IN OUT UINT8   *Buf,
  IN     UINT32  Data
  )
{
  ASSERT (Buf != NULL);
 
  Data = HTONL (Data);
  CopyMem (Buf, &Data, sizeof (UINT32));
}
 
LIST_ENTRY *
EFIAPI
NetListRemoveHead (
  IN OUT LIST_ENTRY  *Head
  )
{
  LIST_ENTRY  *First;
 
  ASSERT (Head != NULL);
 
  if (IsListEmpty (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;
}
 
LIST_ENTRY *
EFIAPI
NetListRemoveTail (
  IN OUT LIST_ENTRY  *Head
  )
{
  LIST_ENTRY  *Last;
 
  ASSERT (Head != NULL);
 
  if (IsListEmpty (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;
}
 
VOID
EFIAPI
NetListInsertAfter (
  IN OUT LIST_ENTRY  *PrevEntry,
  IN OUT LIST_ENTRY  *NewEntry
  )
{
  ASSERT (PrevEntry != NULL && NewEntry != NULL);
 
  NewEntry->BackLink               = PrevEntry;
  NewEntry->ForwardLink            = PrevEntry->ForwardLink;
  PrevEntry->ForwardLink->BackLink = NewEntry;
  PrevEntry->ForwardLink           = NewEntry;
}
 
VOID
EFIAPI
NetListInsertBefore (
  IN OUT LIST_ENTRY  *PostEntry,
  IN OUT LIST_ENTRY  *NewEntry
  )
{
  ASSERT (PostEntry != NULL && NewEntry != NULL);
 
  NewEntry->ForwardLink            = PostEntry;
  NewEntry->BackLink               = PostEntry->BackLink;
  PostEntry->BackLink->ForwardLink = NewEntry;
  PostEntry->BackLink              = NewEntry;
}
 
EFI_STATUS
EFIAPI
NetDestroyLinkList (
  IN   LIST_ENTRY                      *List,
  IN   NET_DESTROY_LINK_LIST_CALLBACK  CallBack,
  IN   VOID                            *Context     OPTIONAL,
  OUT  UINTN                           *ListLength  OPTIONAL
  )
{
  UINTN       PreviousLength;
  LIST_ENTRY  *Entry;
  LIST_ENTRY  *Ptr;
  UINTN       Length;
  EFI_STATUS  Status;
 
  if ((List == NULL) || (CallBack == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Length = 0;
  do {
    PreviousLength = Length;
    Entry          = GetFirstNode (List);
    while (!IsNull (List, Entry)) {
      Status = CallBack (Entry, Context);
      if (EFI_ERROR (Status)) {
        return Status;
      }
 
      //
      // Walk through the list to see whether the Entry has been removed or not.
      // If the Entry still exists, just try to destroy the next one.
      // If not, go back to the start point to iterate the list again.
      //
      for (Ptr = List->ForwardLink; Ptr != List; Ptr = Ptr->ForwardLink) {
        if (Ptr == Entry) {
          break;
        }
      }
 
      if (Ptr == Entry) {
        Entry = GetNextNode (List, Entry);
      } else {
        Entry = GetFirstNode (List);
      }
    }
 
    for (Length = 0, Ptr = List->ForwardLink; Ptr != List; Length++, Ptr = Ptr->ForwardLink) {
    }
  } while (Length != PreviousLength);
 
  if (ListLength != NULL) {
    *ListLength = Length;
  }
 
  return EFI_SUCCESS;
}
 
BOOLEAN
EFIAPI
NetIsInHandleBuffer (
  IN  EFI_HANDLE  Handle,
  IN  UINTN       NumberOfChildren,
  IN  EFI_HANDLE  *ChildHandleBuffer OPTIONAL
  )
{
  UINTN  Index;
 
  if ((NumberOfChildren == 0) || (ChildHandleBuffer == NULL)) {
    return FALSE;
  }
 
  for (Index = 0; Index < NumberOfChildren; Index++) {
    if (Handle == ChildHandleBuffer[Index]) {
      return TRUE;
    }
  }
 
  return FALSE;
}
 
VOID
EFIAPI
NetMapInit (
  IN OUT NET_MAP  *Map
  )
{
  ASSERT (Map != NULL);
 
  InitializeListHead (&Map->Used);
  InitializeListHead (&Map->Recycled);
  Map->Count = 0;
}
 
VOID
EFIAPI
NetMapClean (
  IN OUT NET_MAP  *Map
  )
{
  NET_MAP_ITEM  *Item;
  LIST_ENTRY    *Entry;
  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);
 
    RemoveEntryList (&Item->Link);
    Map->Count--;
 
    gBS->FreePool (Item);
  }
 
  ASSERT ((Map->Count == 0) && IsListEmpty (&Map->Used));
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Map->Recycled) {
    Item = NET_LIST_USER_STRUCT (Entry, NET_MAP_ITEM, Link);
 
    RemoveEntryList (&Item->Link);
    gBS->FreePool (Item);
  }
 
  ASSERT (IsListEmpty (&Map->Recycled));
}
 
BOOLEAN
EFIAPI
NetMapIsEmpty (
  IN NET_MAP  *Map
  )
{
  ASSERT (Map != NULL);
  return (BOOLEAN)(Map->Count == 0);
}
 
UINTN
EFIAPI
NetMapGetCount (
  IN NET_MAP  *Map
  )
{
  ASSERT (Map != NULL);
  return Map->Count;
}
 
NET_MAP_ITEM *
NetMapAllocItem (
  IN OUT NET_MAP  *Map
  )
{
  NET_MAP_ITEM  *Item;
  LIST_ENTRY    *Head;
  UINTN         Index;
 
  ASSERT (Map != NULL);
 
  Head = &Map->Recycled;
 
  if (IsListEmpty (Head)) {
    for (Index = 0; Index < NET_MAP_INCREAMENT; Index++) {
      Item = AllocatePool (sizeof (NET_MAP_ITEM));
 
      if (Item == NULL) {
        if (Index == 0) {
          return NULL;
        }
 
        break;
      }
 
      InsertHeadList (Head, &Item->Link);
    }
  }
 
  Item = NET_LIST_HEAD (Head, NET_MAP_ITEM, Link);
  NetListRemoveHead (Head);
 
  return Item;
}
 
EFI_STATUS
EFIAPI
NetMapInsertHead (
  IN OUT NET_MAP  *Map,
  IN VOID         *Key,
  IN VOID         *Value    OPTIONAL
  )
{
  NET_MAP_ITEM  *Item;
 
  ASSERT (Map != NULL && Key != NULL);
 
  Item = NetMapAllocItem (Map);
 
  if (Item == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Item->Key   = Key;
  Item->Value = Value;
  InsertHeadList (&Map->Used, &Item->Link);
 
  Map->Count++;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NetMapInsertTail (
  IN OUT NET_MAP  *Map,
  IN VOID         *Key,
  IN VOID         *Value    OPTIONAL
  )
{
  NET_MAP_ITEM  *Item;
 
  ASSERT (Map != NULL && Key != NULL);
 
  Item = NetMapAllocItem (Map);
 
  if (Item == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Item->Key   = Key;
  Item->Value = Value;
  InsertTailList (&Map->Used, &Item->Link);
 
  Map->Count++;
 
  return EFI_SUCCESS;
}
 
BOOLEAN
NetItemInMap (
  IN NET_MAP       *Map,
  IN NET_MAP_ITEM  *Item
  )
{
  LIST_ENTRY  *ListEntry;
 
  ASSERT (Map != NULL && Item != NULL);
 
  NET_LIST_FOR_EACH (ListEntry, &Map->Used) {
    if (ListEntry == &Item->Link) {
      return TRUE;
    }
  }
 
  return FALSE;
}
 
NET_MAP_ITEM *
EFIAPI
NetMapFindKey (
  IN  NET_MAP  *Map,
  IN  VOID     *Key
  )
{
  LIST_ENTRY    *Entry;
  NET_MAP_ITEM  *Item;
 
  ASSERT (Map != NULL && Key != 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;
}
 
VOID *
EFIAPI
NetMapRemoveItem (
  IN  OUT NET_MAP       *Map,
  IN  OUT NET_MAP_ITEM  *Item,
  OUT VOID              **Value           OPTIONAL
  )
{
  ASSERT ((Map != NULL) && (Item != NULL));
  ASSERT (NetItemInMap (Map, Item));
 
  RemoveEntryList (&Item->Link);
  Map->Count--;
  InsertHeadList (&Map->Recycled, &Item->Link);
 
  if (Value != NULL) {
    *Value = Item->Value;
  }
 
  return Item->Key;
}
 
VOID *
EFIAPI
NetMapRemoveHead (
  IN OUT 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 && !IsListEmpty (&Map->Used));
 
  Item = NET_LIST_HEAD (&Map->Used, NET_MAP_ITEM, Link);
  RemoveEntryList (&Item->Link);
  Map->Count--;
  InsertHeadList (&Map->Recycled, &Item->Link);
 
  if (Value != NULL) {
    *Value = Item->Value;
  }
 
  return Item->Key;
}
 
VOID *
EFIAPI
NetMapRemoveTail (
  IN OUT 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 && !IsListEmpty (&Map->Used));
 
  Item = NET_LIST_TAIL (&Map->Used, NET_MAP_ITEM, Link);
  RemoveEntryList (&Item->Link);
  Map->Count--;
  InsertHeadList (&Map->Recycled, &Item->Link);
 
  if (Value != NULL) {
    *Value = Item->Value;
  }
 
  return Item->Key;
}
 
EFI_STATUS
EFIAPI
NetMapIterate (
  IN NET_MAP           *Map,
  IN NET_MAP_CALLBACK  CallBack,
  IN VOID              *Arg      OPTIONAL
  )
{
  LIST_ENTRY    *Entry;
  LIST_ENTRY    *Next;
  LIST_ENTRY    *Head;
  NET_MAP_ITEM  *Item;
  EFI_STATUS    Result;
 
  ASSERT ((Map != NULL) && (CallBack != NULL));
 
  Head = &Map->Used;
 
  if (IsListEmpty (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;
}
 
EFI_STATUS
EFIAPI
NetLibDefaultUnload (
  IN EFI_HANDLE  ImageHandle
  )
{
  EFI_STATUS                    Status;
  EFI_HANDLE                    *DeviceHandleBuffer;
  UINTN                         DeviceHandleCount;
  UINTN                         Index;
  UINTN                         Index2;
  EFI_DRIVER_BINDING_PROTOCOL   *DriverBinding;
  EFI_COMPONENT_NAME_PROTOCOL   *ComponentName;
  EFI_COMPONENT_NAME2_PROTOCOL  *ComponentName2;
 
  //
  // 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;
  }
 
  for (Index = 0; Index < DeviceHandleCount; Index++) {
    Status = gBS->HandleProtocol (
                    DeviceHandleBuffer[Index],
                    &gEfiDriverBindingProtocolGuid,
                    (VOID **)&DriverBinding
                    );
    if (EFI_ERROR (Status)) {
      continue;
    }
 
    if (DriverBinding->ImageHandle != ImageHandle) {
      continue;
    }
 
    //
    // Disconnect the driver specified by ImageHandle from all
    // the devices in the handle database.
    //
    for (Index2 = 0; Index2 < DeviceHandleCount; Index2++) {
      Status = gBS->DisconnectController (
                      DeviceHandleBuffer[Index2],
                      DriverBinding->DriverBindingHandle,
                      NULL
                      );
    }
 
    //
    // Uninstall all the protocols installed in the driver entry point
    //
    gBS->UninstallProtocolInterface (
           DriverBinding->DriverBindingHandle,
           &gEfiDriverBindingProtocolGuid,
           DriverBinding
           );
 
    Status = gBS->HandleProtocol (
                    DeviceHandleBuffer[Index],
                    &gEfiComponentNameProtocolGuid,
                    (VOID **)&ComponentName
                    );
    if (!EFI_ERROR (Status)) {
      gBS->UninstallProtocolInterface (
             DriverBinding->DriverBindingHandle,
             &gEfiComponentNameProtocolGuid,
             ComponentName
             );
    }
 
    Status = gBS->HandleProtocol (
                    DeviceHandleBuffer[Index],
                    &gEfiComponentName2ProtocolGuid,
                    (VOID **)&ComponentName2
                    );
    if (!EFI_ERROR (Status)) {
      gBS->UninstallProtocolInterface (
             DriverBinding->DriverBindingHandle,
             &gEfiComponentName2ProtocolGuid,
             ComponentName2
             );
    }
  }
 
  //
  // Free the buffer containing the list of handles from the handle database
  //
  if (DeviceHandleBuffer != NULL) {
    gBS->FreePool (DeviceHandleBuffer);
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NetLibCreateServiceChild (
  IN  EFI_HANDLE      Controller,
  IN  EFI_HANDLE      Image,
  IN  EFI_GUID        *ServiceBindingGuid,
  IN  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;
}
 
EFI_STATUS
EFIAPI
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;
  }
 
  //
  // destroy the child
  //
  Status = Service->DestroyChild (Service, ChildHandle);
  return Status;
}
 
EFI_HANDLE
EFIAPI
NetLibGetSnpHandle (
  IN   EFI_HANDLE                   ServiceHandle,
  OUT  EFI_SIMPLE_NETWORK_PROTOCOL  **Snp  OPTIONAL
  )
{
  EFI_STATUS                   Status;
  EFI_SIMPLE_NETWORK_PROTOCOL  *SnpInstance;
  EFI_DEVICE_PATH_PROTOCOL     *DevicePath;
  EFI_HANDLE                   SnpHandle;
 
  //
  // Try to open SNP from ServiceHandle
  //
  SnpInstance = NULL;
  Status      = gBS->HandleProtocol (ServiceHandle, &gEfiSimpleNetworkProtocolGuid, (VOID **)&SnpInstance);
  if (!EFI_ERROR (Status)) {
    if (Snp != NULL) {
      *Snp = SnpInstance;
    }
 
    return ServiceHandle;
  }
 
  //
  // Failed to open SNP, try to get SNP handle by LocateDevicePath()
  //
  DevicePath = DevicePathFromHandle (ServiceHandle);
  if (DevicePath == NULL) {
    return NULL;
  }
 
  SnpHandle = NULL;
  Status    = gBS->LocateDevicePath (&gEfiSimpleNetworkProtocolGuid, &DevicePath, &SnpHandle);
  if (EFI_ERROR (Status)) {
    //
    // Failed to find SNP handle
    //
    return NULL;
  }
 
  Status = gBS->HandleProtocol (SnpHandle, &gEfiSimpleNetworkProtocolGuid, (VOID **)&SnpInstance);
  if (!EFI_ERROR (Status)) {
    if (Snp != NULL) {
      *Snp = SnpInstance;
    }
 
    return SnpHandle;
  }
 
  return NULL;
}
 
UINT16
EFIAPI
NetLibGetVlanId (
  IN EFI_HANDLE  ServiceHandle
  )
{
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
  EFI_DEVICE_PATH_PROTOCOL  *Node;
 
  DevicePath = DevicePathFromHandle (ServiceHandle);
  if (DevicePath == NULL) {
    return 0;
  }
 
  Node = DevicePath;
  while (!IsDevicePathEnd (Node)) {
    if ((Node->Type == MESSAGING_DEVICE_PATH) && (Node->SubType == MSG_VLAN_DP)) {
      return ((VLAN_DEVICE_PATH *)Node)->VlanId;
    }
 
    Node = NextDevicePathNode (Node);
  }
 
  return 0;
}
 
EFI_HANDLE
EFIAPI
NetLibGetVlanHandle (
  IN EFI_HANDLE  ControllerHandle,
  IN UINT16      VlanId
  )
{
  EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
  EFI_DEVICE_PATH_PROTOCOL  *VlanDevicePath;
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
  VLAN_DEVICE_PATH          VlanNode;
  EFI_HANDLE                Handle;
 
  ParentDevicePath = DevicePathFromHandle (ControllerHandle);
  if (ParentDevicePath == NULL) {
    return NULL;
  }
 
  //
  // Construct VLAN device path
  //
  CopyMem (&VlanNode, &mNetVlanDevicePathTemplate, sizeof (VLAN_DEVICE_PATH));
  VlanNode.VlanId = VlanId;
  VlanDevicePath  = AppendDevicePathNode (
                      ParentDevicePath,
                      (EFI_DEVICE_PATH_PROTOCOL *)&VlanNode
                      );
  if (VlanDevicePath == NULL) {
    return NULL;
  }
 
  //
  // Find VLAN device handle
  //
  Handle     = NULL;
  DevicePath = VlanDevicePath;
  gBS->LocateDevicePath (
         &gEfiDevicePathProtocolGuid,
         &DevicePath,
         &Handle
         );
  if (!IsDevicePathEnd (DevicePath)) {
    //
    // Device path is not exactly match
    //
    Handle = NULL;
  }
 
  FreePool (VlanDevicePath);
  return Handle;
}
 
EFI_STATUS
EFIAPI
NetLibGetMacAddress (
  IN  EFI_HANDLE       ServiceHandle,
  OUT EFI_MAC_ADDRESS  *MacAddress,
  OUT UINTN            *AddressSize
  )
{
  EFI_STATUS                    Status;
  EFI_SIMPLE_NETWORK_PROTOCOL   *Snp;
  EFI_SIMPLE_NETWORK_MODE       *SnpMode;
  EFI_SIMPLE_NETWORK_MODE       SnpModeData;
  EFI_MANAGED_NETWORK_PROTOCOL  *Mnp;
  EFI_SERVICE_BINDING_PROTOCOL  *MnpSb;
  EFI_HANDLE                    SnpHandle;
  EFI_HANDLE                    MnpChildHandle;
 
  ASSERT (MacAddress != NULL);
  ASSERT (AddressSize != NULL);
 
  //
  // Try to get SNP handle
  //
  Snp       = NULL;
  SnpHandle = NetLibGetSnpHandle (ServiceHandle, &Snp);
  if (SnpHandle != NULL) {
    //
    // SNP found, use it directly
    //
    SnpMode = Snp->Mode;
  } else {
    //
    // Failed to get SNP handle, try to get MAC address from MNP
    //
    MnpChildHandle = NULL;
    Status         = gBS->HandleProtocol (
                            ServiceHandle,
                            &gEfiManagedNetworkServiceBindingProtocolGuid,
                            (VOID **)&MnpSb
                            );
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    //
    // Create a MNP child
    //
    Status = MnpSb->CreateChild (MnpSb, &MnpChildHandle);
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    //
    // Open MNP protocol
    //
    Status = gBS->HandleProtocol (
                    MnpChildHandle,
                    &gEfiManagedNetworkProtocolGuid,
                    (VOID **)&Mnp
                    );
    if (EFI_ERROR (Status)) {
      MnpSb->DestroyChild (MnpSb, MnpChildHandle);
      return Status;
    }
 
    //
    // Try to get SNP mode from MNP
    //
    Status = Mnp->GetModeData (Mnp, NULL, &SnpModeData);
    if (EFI_ERROR (Status) && (Status != EFI_NOT_STARTED)) {
      MnpSb->DestroyChild (MnpSb, MnpChildHandle);
      return Status;
    }
 
    SnpMode = &SnpModeData;
 
    //
    // Destroy the MNP child
    //
    MnpSb->DestroyChild (MnpSb, MnpChildHandle);
  }
 
  *AddressSize = SnpMode->HwAddressSize;
  CopyMem (MacAddress->Addr, SnpMode->CurrentAddress.Addr, SnpMode->HwAddressSize);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NetLibGetMacString (
  IN  EFI_HANDLE  ServiceHandle,
  IN  EFI_HANDLE  ImageHandle  OPTIONAL,
  OUT CHAR16      **MacString
  )
{
  EFI_STATUS       Status;
  EFI_MAC_ADDRESS  MacAddress;
  UINT8            *HwAddress;
  UINTN            HwAddressSize;
  UINT16           VlanId;
  CHAR16           *String;
  UINTN            Index;
  UINTN            BufferSize;
 
  ASSERT (MacString != NULL);
 
  //
  // Get MAC address of the network device
  //
  Status = NetLibGetMacAddress (ServiceHandle, &MacAddress, &HwAddressSize);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // It takes 2 unicode characters to represent a 1 byte binary buffer.
  // If VLAN is configured, it will need extra 5 characters like "\0005".
  // Plus one unicode character for the null-terminator.
  //
  BufferSize = (2 * HwAddressSize + 5 + 1) * sizeof (CHAR16);
  String     = AllocateZeroPool (BufferSize);
  if (String == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  *MacString = String;
 
  //
  // Convert the MAC address into a unicode string.
  //
  HwAddress = &MacAddress.Addr[0];
  for (Index = 0; Index < HwAddressSize; Index++) {
    UnicodeValueToStringS (
      String,
      BufferSize - ((UINTN)String - (UINTN)*MacString),
      PREFIX_ZERO | RADIX_HEX,
      *(HwAddress++),
      2
      );
    String += StrnLenS (String, (BufferSize - ((UINTN)String - (UINTN)*MacString)) / sizeof (CHAR16));
  }
 
  //
  // Append VLAN ID if any
  //
  VlanId = NetLibGetVlanId (ServiceHandle);
  if (VlanId != 0) {
    *String++ = L'\\';
    UnicodeValueToStringS (
      String,
      BufferSize - ((UINTN)String - (UINTN)*MacString),
      PREFIX_ZERO | RADIX_HEX,
      VlanId,
      4
      );
    String += StrnLenS (String, (BufferSize - ((UINTN)String - (UINTN)*MacString)) / sizeof (CHAR16));
  }
 
  //
  // Null terminate the Unicode string
  //
  *String = L'\0';
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NetLibDetectMedia (
  IN  EFI_HANDLE  ServiceHandle,
  OUT BOOLEAN     *MediaPresent
  )
{
  EFI_STATUS                   Status;
  EFI_HANDLE                   SnpHandle;
  EFI_SIMPLE_NETWORK_PROTOCOL  *Snp;
  UINT32                       InterruptStatus;
  UINT32                       OldState;
  EFI_MAC_ADDRESS              *MCastFilter;
  UINT32                       MCastFilterCount;
  UINT32                       EnableFilterBits;
  UINT32                       DisableFilterBits;
  BOOLEAN                      ResetMCastFilters;
 
  ASSERT (MediaPresent != NULL);
 
  //
  // Get SNP handle
  //
  Snp       = NULL;
  SnpHandle = NetLibGetSnpHandle (ServiceHandle, &Snp);
  if (SnpHandle == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Check whether SNP support media detection
  //
  if (!Snp->Mode->MediaPresentSupported) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Invoke Snp->GetStatus() to refresh MediaPresent field in SNP mode data
  //
  Status = Snp->GetStatus (Snp, &InterruptStatus, NULL);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  if (Snp->Mode->MediaPresent) {
    //
    // Media is present, return directly
    //
    *MediaPresent = TRUE;
    return EFI_SUCCESS;
  }
 
  //
  // Till now, GetStatus() report no media; while, in case UNDI not support
  // reporting media status from GetStatus(), this media status may be incorrect.
  // So, we will stop SNP and then restart it to get the correct media status.
  //
  OldState = Snp->Mode->State;
  if (OldState >= EfiSimpleNetworkMaxState) {
    return EFI_DEVICE_ERROR;
  }
 
  MCastFilter = NULL;
 
  if (OldState == EfiSimpleNetworkInitialized) {
    //
    // SNP is already in use, need Shutdown/Stop and then Start/Initialize
    //
 
    //
    // Backup current SNP receive filter settings
    //
    EnableFilterBits  = Snp->Mode->ReceiveFilterSetting;
    DisableFilterBits = Snp->Mode->ReceiveFilterMask ^ EnableFilterBits;
 
    ResetMCastFilters = TRUE;
    MCastFilterCount  = Snp->Mode->MCastFilterCount;
    if (MCastFilterCount != 0) {
      MCastFilter = AllocateCopyPool (
                      MCastFilterCount * sizeof (EFI_MAC_ADDRESS),
                      Snp->Mode->MCastFilter
                      );
      ASSERT (MCastFilter != NULL);
      if (MCastFilter == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto Exit;
      }
 
      ResetMCastFilters = FALSE;
    }
 
    //
    // Shutdown/Stop the simple network
    //
    Status = Snp->Shutdown (Snp);
    if (!EFI_ERROR (Status)) {
      Status = Snp->Stop (Snp);
    }
 
    if (EFI_ERROR (Status)) {
      goto Exit;
    }
 
    //
    // Start/Initialize the simple network
    //
    Status = Snp->Start (Snp);
    if (!EFI_ERROR (Status)) {
      Status = Snp->Initialize (Snp, 0, 0);
    }
 
    if (EFI_ERROR (Status)) {
      goto Exit;
    }
 
    //
    // Here we get the correct media status
    //
    *MediaPresent = Snp->Mode->MediaPresent;
 
    //
    // Restore SNP receive filter settings
    //
    Status = Snp->ReceiveFilters (
                    Snp,
                    EnableFilterBits,
                    DisableFilterBits,
                    ResetMCastFilters,
                    MCastFilterCount,
                    MCastFilter
                    );
 
    if (MCastFilter != NULL) {
      FreePool (MCastFilter);
    }
 
    return Status;
  }
 
  //
  // SNP is not in use, it's in state of EfiSimpleNetworkStopped or EfiSimpleNetworkStarted
  //
  if (OldState == EfiSimpleNetworkStopped) {
    //
    // SNP not start yet, start it
    //
    Status = Snp->Start (Snp);
    if (EFI_ERROR (Status)) {
      goto Exit;
    }
  }
 
  //
  // Initialize the simple network
  //
  Status = Snp->Initialize (Snp, 0, 0);
  if (EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
    goto Exit;
  }
 
  //
  // Here we get the correct media status
  //
  *MediaPresent = Snp->Mode->MediaPresent;
 
  //
  // Shut down the simple network
  //
  Snp->Shutdown (Snp);
 
Exit:
  if (OldState == EfiSimpleNetworkStopped) {
    //
    // Original SNP sate is Stopped, restore to original state
    //
    Snp->Stop (Snp);
  }
 
  if (MCastFilter != NULL) {
    FreePool (MCastFilter);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
NetLibDetectMediaWaitTimeout (
  IN  EFI_HANDLE  ServiceHandle,
  IN  UINT64      Timeout,
  OUT EFI_STATUS  *MediaState
  )
{
  EFI_STATUS                        Status;
  EFI_HANDLE                        SnpHandle;
  EFI_SIMPLE_NETWORK_PROTOCOL       *Snp;
  EFI_ADAPTER_INFORMATION_PROTOCOL  *Aip;
  EFI_ADAPTER_INFO_MEDIA_STATE      *MediaInfo;
  BOOLEAN                           MediaPresent;
  UINTN                             DataSize;
  EFI_STATUS                        TimerStatus;
  EFI_EVENT                         Timer;
  UINT64                            TimeRemained;
 
  if (MediaState == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  *MediaState = EFI_SUCCESS;
  MediaInfo   = NULL;
 
  //
  // Get SNP handle
  //
  Snp       = NULL;
  SnpHandle = NetLibGetSnpHandle (ServiceHandle, &Snp);
  if (SnpHandle == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = gBS->HandleProtocol (
                  SnpHandle,
                  &gEfiAdapterInformationProtocolGuid,
                  (VOID *)&Aip
                  );
  if (EFI_ERROR (Status)) {
    MediaPresent = TRUE;
    Status       = NetLibDetectMedia (ServiceHandle, &MediaPresent);
    if (!EFI_ERROR (Status)) {
      if (MediaPresent) {
        *MediaState = EFI_SUCCESS;
      } else {
        *MediaState = EFI_NO_MEDIA;
      }
    }
 
    //
    // NetLibDetectMedia doesn't support EFI_NOT_READY status, return now!
    //
    return Status;
  }
 
  Status = Aip->GetInformation (
                  Aip,
                  &gEfiAdapterInfoMediaStateGuid,
                  (VOID **)&MediaInfo,
                  &DataSize
                  );
  if (!EFI_ERROR (Status)) {
    *MediaState = MediaInfo->MediaState;
    FreePool (MediaInfo);
    if ((*MediaState != EFI_NOT_READY) || (Timeout < MEDIA_STATE_DETECT_TIME_INTERVAL)) {
      return EFI_SUCCESS;
    }
  } else {
    if (MediaInfo != NULL) {
      FreePool (MediaInfo);
    }
 
    if (Status == EFI_UNSUPPORTED) {
      //
      // If gEfiAdapterInfoMediaStateGuid is not supported, call NetLibDetectMedia to get media state!
      //
      MediaPresent = TRUE;
      Status       = NetLibDetectMedia (ServiceHandle, &MediaPresent);
      if (!EFI_ERROR (Status)) {
        if (MediaPresent) {
          *MediaState = EFI_SUCCESS;
        } else {
          *MediaState = EFI_NO_MEDIA;
        }
      }
 
      return Status;
    }
 
    return Status;
  }
 
  //
  // Loop to check media state
  //
 
  Timer        = NULL;
  TimeRemained = Timeout;
  Status       = gBS->CreateEvent (EVT_TIMER, TPL_CALLBACK, NULL, NULL, &Timer);
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  do {
    Status = gBS->SetTimer (
                    Timer,
                    TimerRelative,
                    MEDIA_STATE_DETECT_TIME_INTERVAL
                    );
    if (EFI_ERROR (Status)) {
      gBS->CloseEvent (Timer);
      return EFI_DEVICE_ERROR;
    }
 
    do {
      TimerStatus = gBS->CheckEvent (Timer);
      if (!EFI_ERROR (TimerStatus)) {
        TimeRemained -= MEDIA_STATE_DETECT_TIME_INTERVAL;
        Status        = Aip->GetInformation (
                               Aip,
                               &gEfiAdapterInfoMediaStateGuid,
                               (VOID **)&MediaInfo,
                               &DataSize
                               );
        if (!EFI_ERROR (Status)) {
          *MediaState = MediaInfo->MediaState;
          FreePool (MediaInfo);
        } else {
          if (MediaInfo != NULL) {
            FreePool (MediaInfo);
          }
 
          gBS->CloseEvent (Timer);
          return Status;
        }
      }
    } while (TimerStatus == EFI_NOT_READY);
  } while (*MediaState == EFI_NOT_READY && TimeRemained >= MEDIA_STATE_DETECT_TIME_INTERVAL);
 
  gBS->CloseEvent (Timer);
  if ((*MediaState == EFI_NOT_READY) && (TimeRemained < MEDIA_STATE_DETECT_TIME_INTERVAL)) {
    return EFI_TIMEOUT;
  } else {
    return EFI_SUCCESS;
  }
}
 
BOOLEAN
NetLibDefaultAddressIsStatic (
  IN EFI_HANDLE  Controller
  )
{
  EFI_STATUS                Status;
  EFI_IP4_CONFIG2_PROTOCOL  *Ip4Config2;
  UINTN                     DataSize;
  EFI_IP4_CONFIG2_POLICY    Policy;
  BOOLEAN                   IsStatic;
 
  Ip4Config2 = NULL;
 
  DataSize = sizeof (EFI_IP4_CONFIG2_POLICY);
 
  IsStatic = TRUE;
 
  //
  // Get Ip4Config2 policy.
  //
  Status = gBS->HandleProtocol (Controller, &gEfiIp4Config2ProtocolGuid, (VOID **)&Ip4Config2);
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  Status = Ip4Config2->GetData (Ip4Config2, Ip4Config2DataTypePolicy, &DataSize, &Policy);
  if (EFI_ERROR (Status)) {
    goto ON_EXIT;
  }
 
  IsStatic = (BOOLEAN)(Policy == Ip4Config2PolicyStatic);
 
ON_EXIT:
 
  return IsStatic;
}
 
VOID
EFIAPI
NetLibCreateIPv4DPathNode (
  IN OUT IPv4_DEVICE_PATH  *Node,
  IN EFI_HANDLE            Controller,
  IN IP4_ADDR              LocalIp,
  IN UINT16                LocalPort,
  IN IP4_ADDR              RemoteIp,
  IN UINT16                RemotePort,
  IN UINT16                Protocol,
  IN BOOLEAN               UseDefaultAddress
  )
{
  ASSERT (Node != NULL);
 
  Node->Header.Type    = MESSAGING_DEVICE_PATH;
  Node->Header.SubType = MSG_IPv4_DP;
  SetDevicePathNodeLength (&Node->Header, sizeof (IPv4_DEVICE_PATH));
 
  CopyMem (&Node->LocalIpAddress, &LocalIp, sizeof (EFI_IPv4_ADDRESS));
  CopyMem (&Node->RemoteIpAddress, &RemoteIp, sizeof (EFI_IPv4_ADDRESS));
 
  Node->LocalPort  = LocalPort;
  Node->RemotePort = RemotePort;
 
  Node->Protocol = Protocol;
 
  if (!UseDefaultAddress) {
    Node->StaticIpAddress = TRUE;
  } else {
    Node->StaticIpAddress = NetLibDefaultAddressIsStatic (Controller);
  }
 
  //
  // Set the Gateway IP address to default value 0:0:0:0.
  // Set the Subnet mask to default value 255:255:255:0.
  //
  ZeroMem (&Node->GatewayIpAddress, sizeof (EFI_IPv4_ADDRESS));
  SetMem (&Node->SubnetMask, sizeof (EFI_IPv4_ADDRESS), 0xff);
  Node->SubnetMask.Addr[3] = 0;
}
 
VOID
EFIAPI
NetLibCreateIPv6DPathNode (
  IN OUT IPv6_DEVICE_PATH  *Node,
  IN EFI_HANDLE            Controller,
  IN EFI_IPv6_ADDRESS      *LocalIp,
  IN UINT16                LocalPort,
  IN EFI_IPv6_ADDRESS      *RemoteIp,
  IN UINT16                RemotePort,
  IN UINT16                Protocol
  )
{
  ASSERT (Node != NULL && LocalIp != NULL && RemoteIp != NULL);
 
  Node->Header.Type    = MESSAGING_DEVICE_PATH;
  Node->Header.SubType = MSG_IPv6_DP;
  SetDevicePathNodeLength (&Node->Header, sizeof (IPv6_DEVICE_PATH));
 
  CopyMem (&Node->LocalIpAddress, LocalIp, sizeof (EFI_IPv6_ADDRESS));
  CopyMem (&Node->RemoteIpAddress, RemoteIp, sizeof (EFI_IPv6_ADDRESS));
 
  Node->LocalPort  = LocalPort;
  Node->RemotePort = RemotePort;
 
  Node->Protocol = Protocol;
 
  //
  // Set default value to IPAddressOrigin, PrefixLength.
  // Set the Gateway IP address to unspecified address.
  //
  Node->IpAddressOrigin = 0;
  Node->PrefixLength    = IP6_PREFIX_LENGTH;
  ZeroMem (&Node->GatewayIpAddress, sizeof (EFI_IPv6_ADDRESS));
}
 
EFI_HANDLE
EFIAPI
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;
 
  ASSERT (ProtocolGuid != NULL);
 
  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) != 0) {
      Handle = OpenBuffer[Index].ControllerHandle;
      break;
    }
  }
 
  gBS->FreePool (OpenBuffer);
  return Handle;
}
 
EFI_STATUS
EFIAPI
NetLibAsciiStrToIp4 (
  IN CONST CHAR8             *String,
  OUT      EFI_IPv4_ADDRESS  *Ip4Address
  )
{
  RETURN_STATUS  Status;
  CHAR8          *EndPointer;
 
  Status = AsciiStrToIpv4Address (String, &EndPointer, Ip4Address, NULL);
  if (RETURN_ERROR (Status) || (*EndPointer != '\0')) {
    return EFI_INVALID_PARAMETER;
  } else {
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
EFIAPI
NetLibAsciiStrToIp6 (
  IN CONST CHAR8             *String,
  OUT      EFI_IPv6_ADDRESS  *Ip6Address
  )
{
  RETURN_STATUS  Status;
  CHAR8          *EndPointer;
 
  Status = AsciiStrToIpv6Address (String, &EndPointer, Ip6Address, NULL);
  if (RETURN_ERROR (Status) || (*EndPointer != '\0')) {
    return EFI_INVALID_PARAMETER;
  } else {
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
EFIAPI
NetLibStrToIp4 (
  IN CONST CHAR16            *String,
  OUT      EFI_IPv4_ADDRESS  *Ip4Address
  )
{
  RETURN_STATUS  Status;
  CHAR16         *EndPointer;
 
  Status = StrToIpv4Address (String, &EndPointer, Ip4Address, NULL);
  if (RETURN_ERROR (Status) || (*EndPointer != L'\0')) {
    return EFI_INVALID_PARAMETER;
  } else {
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
EFIAPI
NetLibStrToIp6 (
  IN CONST CHAR16            *String,
  OUT      EFI_IPv6_ADDRESS  *Ip6Address
  )
{
  RETURN_STATUS  Status;
  CHAR16         *EndPointer;
 
  Status = StrToIpv6Address (String, &EndPointer, Ip6Address, NULL);
  if (RETURN_ERROR (Status) || (*EndPointer != L'\0')) {
    return EFI_INVALID_PARAMETER;
  } else {
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
EFIAPI
NetLibStrToIp6andPrefix (
  IN CONST CHAR16            *String,
  OUT      EFI_IPv6_ADDRESS  *Ip6Address,
  OUT      UINT8             *PrefixLength
  )
{
  RETURN_STATUS  Status;
  CHAR16         *EndPointer;
 
  Status = StrToIpv6Address (String, &EndPointer, Ip6Address, PrefixLength);
  if (RETURN_ERROR (Status) || (*EndPointer != L'\0')) {
    return EFI_INVALID_PARAMETER;
  } else {
    return EFI_SUCCESS;
  }
}
 
EFI_STATUS
EFIAPI
NetLibIp6ToStr (
  IN         EFI_IPv6_ADDRESS  *Ip6Address,
  OUT        CHAR16            *String,
  IN         UINTN             StringSize
  )
{
  UINT16  Ip6Addr[8];
  UINTN   Index;
  UINTN   LongestZerosStart;
  UINTN   LongestZerosLength;
  UINTN   CurrentZerosStart;
  UINTN   CurrentZerosLength;
  CHAR16  Buffer[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"];
  CHAR16  *Ptr;
 
  if ((Ip6Address == NULL) || (String == NULL) || (StringSize == 0)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Convert the UINT8 array to an UINT16 array for easy handling.
  //
  ZeroMem (Ip6Addr, sizeof (Ip6Addr));
  for (Index = 0; Index < 16; Index++) {
    Ip6Addr[Index / 2] |= (Ip6Address->Addr[Index] << ((1 - (Index % 2)) << 3));
  }
 
  //
  // Find the longest zeros and mark it.
  //
  CurrentZerosStart  = DEFAULT_ZERO_START;
  CurrentZerosLength = 0;
  LongestZerosStart  = DEFAULT_ZERO_START;
  LongestZerosLength = 0;
  for (Index = 0; Index < 8; Index++) {
    if (Ip6Addr[Index] == 0) {
      if (CurrentZerosStart == DEFAULT_ZERO_START) {
        CurrentZerosStart  = Index;
        CurrentZerosLength = 1;
      } else {
        CurrentZerosLength++;
      }
    } else {
      if (CurrentZerosStart != DEFAULT_ZERO_START) {
        if ((CurrentZerosLength > 2) && ((LongestZerosStart == (DEFAULT_ZERO_START)) || (CurrentZerosLength > LongestZerosLength))) {
          LongestZerosStart  = CurrentZerosStart;
          LongestZerosLength = CurrentZerosLength;
        }
 
        CurrentZerosStart  = DEFAULT_ZERO_START;
        CurrentZerosLength = 0;
      }
    }
  }
 
  if ((CurrentZerosStart != DEFAULT_ZERO_START) && (CurrentZerosLength > 2)) {
    if ((LongestZerosStart == DEFAULT_ZERO_START) || (LongestZerosLength < CurrentZerosLength)) {
      LongestZerosStart  = CurrentZerosStart;
      LongestZerosLength = CurrentZerosLength;
    }
  }
 
  Ptr = Buffer;
  for (Index = 0; Index < 8; Index++) {
    if ((LongestZerosStart != DEFAULT_ZERO_START) && (Index >= LongestZerosStart) && (Index < LongestZerosStart + LongestZerosLength)) {
      if (Index == LongestZerosStart) {
        *Ptr++ = L':';
      }
 
      continue;
    }
 
    if (Index != 0) {
      *Ptr++ = L':';
    }
 
    Ptr += UnicodeSPrint (Ptr, 10, L"%x", Ip6Addr[Index]);
  }
 
  if ((LongestZerosStart != DEFAULT_ZERO_START) && (LongestZerosStart + LongestZerosLength == 8)) {
    *Ptr++ = L':';
  }
 
  *Ptr = L'\0';
 
  if ((UINTN)Ptr - (UINTN)Buffer > StringSize) {
    return EFI_BUFFER_TOO_SMALL;
  }
 
  StrCpyS (String, StringSize / sizeof (CHAR16), Buffer);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
NetLibGetSystemGuid (
  OUT EFI_GUID  *SystemGuid
  )
{
  EFI_STATUS                    Status;
  SMBIOS_TABLE_ENTRY_POINT      *SmbiosTable;
  SMBIOS_TABLE_3_0_ENTRY_POINT  *Smbios30Table;
  SMBIOS_STRUCTURE_POINTER      Smbios;
  SMBIOS_STRUCTURE_POINTER      SmbiosEnd;
  CHAR8                         *String;
 
  ASSERT (SystemGuid != NULL);
 
  SmbiosTable = NULL;
  Status      = EfiGetSystemConfigurationTable (&gEfiSmbios3TableGuid, (VOID **)&Smbios30Table);
  if (!(EFI_ERROR (Status) || (Smbios30Table == NULL))) {
    Smbios.Hdr    = (SMBIOS_STRUCTURE *)(UINTN)Smbios30Table->TableAddress;
    SmbiosEnd.Raw = (UINT8 *)(UINTN)(Smbios30Table->TableAddress + Smbios30Table->TableMaximumSize);
  } else {
    Status = EfiGetSystemConfigurationTable (&gEfiSmbiosTableGuid, (VOID **)&SmbiosTable);
    if (EFI_ERROR (Status) || (SmbiosTable == NULL)) {
      return EFI_NOT_FOUND;
    }
 
    Smbios.Hdr    = (SMBIOS_STRUCTURE *)(UINTN)SmbiosTable->TableAddress;
    SmbiosEnd.Raw = (UINT8 *)((UINTN)SmbiosTable->TableAddress + SmbiosTable->TableLength);
  }
 
  do {
    if (Smbios.Hdr->Type == 1) {
      if (Smbios.Hdr->Length < 0x19) {
        //
        // Older version did not support UUID.
        //
        return EFI_NOT_FOUND;
      }
 
      //
      // SMBIOS tables are byte packed so we need to do a byte copy to
      // prevend alignment faults on Itanium-based platform.
      //
      CopyMem (SystemGuid, &Smbios.Type1->Uuid, sizeof (EFI_GUID));
      return EFI_SUCCESS;
    }
 
    //
    // Go to the next SMBIOS structure. Each SMBIOS structure may include 2 parts:
    // 1. Formatted section; 2. Unformatted string section. So, 2 steps are needed
    // to skip one SMBIOS structure.
    //
 
    //
    // Step 1: Skip over formatted section.
    //
    String = (CHAR8 *)(Smbios.Raw + Smbios.Hdr->Length);
 
    //
    // Step 2: Skip over unformatted string section.
    //
    do {
      //
      // Each string is terminated with a NULL(00h) BYTE and the sets of strings
      // is terminated with an additional NULL(00h) BYTE.
      //
      for ( ; *String != 0; String++) {
      }
 
      if (*(UINT8 *)++String == 0) {
        //
        // Pointer to the next SMBIOS structure.
        //
        Smbios.Raw = (UINT8 *)++String;
        break;
      }
    } while (TRUE);
  } while (Smbios.Raw < SmbiosEnd.Raw);
 
  return EFI_NOT_FOUND;
}
 
CHAR8 *
EFIAPI
NetLibCreateDnsQName (
  IN  CHAR16  *DomainName
  )
{
  CHAR8  *QueryName;
  UINTN  QueryNameSize;
  CHAR8  *Header;
  CHAR8  *Tail;
  UINTN  Len;
  UINTN  Index;
 
  ASSERT (DomainName != NULL);
 
  QueryName     = NULL;
  QueryNameSize = 0;
  Header        = NULL;
  Tail          = NULL;
 
  //
  // One byte for first label length, one byte for terminated length zero.
  //
  QueryNameSize = StrLen (DomainName) + 2;
 
  if (QueryNameSize > DNS_MAX_NAME_SIZE) {
    return NULL;
  }
 
  QueryName = AllocateZeroPool (QueryNameSize);
  if (QueryName == NULL) {
    return NULL;
  }
 
  Header = QueryName;
  Tail   = Header + 1;
  Len    = 0;
  for (Index = 0; DomainName[Index] != 0; Index++) {
    *Tail = (CHAR8)DomainName[Index];
    if (*Tail == '.') {
      *Header = (CHAR8)Len;
      Header  = Tail;
      Tail++;
      Len = 0;
    } else {
      Tail++;
      Len++;
    }
  }
 
  *Header = (CHAR8)Len;
  *Tail   = 0;
 
  return QueryName;
}