Ip6Nd.c

Go to the documentation of this file.

 
#include "Ip6Impl.h"
 
EFI_MAC_ADDRESS  mZeroMacAddress;
 
EFI_STATUS
Ip6UpdateReachableTime (
  IN OUT IP6_SERVICE  *IpSb
  )
{
  UINT32      Random;
  EFI_STATUS  Status;
 
  Status = PseudoRandomU32 (&Random);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a failed to generate random number: %r\n", __func__, Status));
    return Status;
  }
 
  Random              = (Random / 4294967295UL) * IP6_RANDOM_FACTOR_SCALE;
  Random              = Random + IP6_MIN_RANDOM_FACTOR_SCALED;
  IpSb->ReachableTime = (IpSb->BaseReachableTime * Random) / IP6_RANDOM_FACTOR_SCALE;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip6BuildEfiNeighborCache (
  IN IP6_PROTOCOL             *IpInstance,
  OUT UINT32                  *NeighborCount,
  OUT EFI_IP6_NEIGHBOR_CACHE  **NeighborCache
  )
{
  IP6_NEIGHBOR_ENTRY      *Neighbor;
  LIST_ENTRY              *Entry;
  IP6_SERVICE             *IpSb;
  UINT32                  Count;
  EFI_IP6_NEIGHBOR_CACHE  *EfiNeighborCache;
  EFI_IP6_NEIGHBOR_CACHE  *NeighborCacheTmp;
 
  NET_CHECK_SIGNATURE (IpInstance, IP6_PROTOCOL_SIGNATURE);
  ASSERT (NeighborCount != NULL && NeighborCache != NULL);
 
  IpSb  = IpInstance->Service;
  Count = 0;
 
  NET_LIST_FOR_EACH (Entry, &IpSb->NeighborTable) {
    Count++;
  }
 
  if (Count == 0) {
    return EFI_SUCCESS;
  }
 
  NeighborCacheTmp = AllocatePool (Count * sizeof (EFI_IP6_NEIGHBOR_CACHE));
  if (NeighborCacheTmp == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  *NeighborCount = Count;
  Count          = 0;
 
  NET_LIST_FOR_EACH (Entry, &IpSb->NeighborTable) {
    Neighbor = NET_LIST_USER_STRUCT (Entry, IP6_NEIGHBOR_ENTRY, Link);
 
    EfiNeighborCache = NeighborCacheTmp + Count;
 
    EfiNeighborCache->State = Neighbor->State;
    IP6_COPY_ADDRESS (&EfiNeighborCache->Neighbor, &Neighbor->Neighbor);
    IP6_COPY_LINK_ADDRESS (&EfiNeighborCache->LinkAddress, &Neighbor->LinkAddress);
 
    Count++;
  }
 
  ASSERT (*NeighborCount == Count);
  *NeighborCache = NeighborCacheTmp;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip6BuildPrefixTable (
  IN IP6_PROTOCOL           *IpInstance,
  OUT UINT32                *PrefixCount,
  OUT EFI_IP6_ADDRESS_INFO  **PrefixTable
  )
{
  LIST_ENTRY             *Entry;
  IP6_SERVICE            *IpSb;
  UINT32                 Count;
  IP6_PREFIX_LIST_ENTRY  *PrefixList;
  EFI_IP6_ADDRESS_INFO   *EfiPrefix;
  EFI_IP6_ADDRESS_INFO   *PrefixTableTmp;
 
  NET_CHECK_SIGNATURE (IpInstance, IP6_PROTOCOL_SIGNATURE);
  ASSERT (PrefixCount != NULL && PrefixTable != NULL);
 
  IpSb  = IpInstance->Service;
  Count = 0;
 
  NET_LIST_FOR_EACH (Entry, &IpSb->OnlinkPrefix) {
    Count++;
  }
 
  if (Count == 0) {
    return EFI_SUCCESS;
  }
 
  PrefixTableTmp = AllocatePool (Count * sizeof (EFI_IP6_ADDRESS_INFO));
  if (PrefixTableTmp == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  *PrefixCount = Count;
  Count        = 0;
 
  NET_LIST_FOR_EACH (Entry, &IpSb->OnlinkPrefix) {
    PrefixList = NET_LIST_USER_STRUCT (Entry, IP6_PREFIX_LIST_ENTRY, Link);
    EfiPrefix  = PrefixTableTmp + Count;
    IP6_COPY_ADDRESS (&EfiPrefix->Address, &PrefixList->Prefix);
    EfiPrefix->PrefixLength = PrefixList->PrefixLength;
 
    Count++;
  }
 
  ASSERT (*PrefixCount == Count);
  *PrefixTable = PrefixTableTmp;
 
  return EFI_SUCCESS;
}
 
IP6_PREFIX_LIST_ENTRY *
Ip6CreatePrefixListEntry (
  IN IP6_SERVICE       *IpSb,
  IN BOOLEAN           OnLinkOrAuto,
  IN UINT32            ValidLifetime,
  IN UINT32            PreferredLifetime,
  IN UINT8             PrefixLength,
  IN EFI_IPv6_ADDRESS  *Prefix
  )
{
  IP6_PREFIX_LIST_ENTRY  *PrefixEntry;
  IP6_ROUTE_ENTRY        *RtEntry;
  LIST_ENTRY             *ListHead;
  LIST_ENTRY             *Entry;
  IP6_PREFIX_LIST_ENTRY  *TmpPrefixEntry;
 
  if ((Prefix == NULL) || (PreferredLifetime > ValidLifetime) || (PrefixLength > IP6_PREFIX_MAX)) {
    return NULL;
  }
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
 
  PrefixEntry = Ip6FindPrefixListEntry (
                  IpSb,
                  OnLinkOrAuto,
                  PrefixLength,
                  Prefix
                  );
  if (PrefixEntry != NULL) {
    PrefixEntry->RefCnt++;
    return PrefixEntry;
  }
 
  PrefixEntry = AllocatePool (sizeof (IP6_PREFIX_LIST_ENTRY));
  if (PrefixEntry == NULL) {
    return NULL;
  }
 
  PrefixEntry->RefCnt            = 1;
  PrefixEntry->ValidLifetime     = ValidLifetime;
  PrefixEntry->PreferredLifetime = PreferredLifetime;
  PrefixEntry->PrefixLength      = PrefixLength;
  IP6_COPY_ADDRESS (&PrefixEntry->Prefix, Prefix);
 
  ListHead = OnLinkOrAuto ? &IpSb->OnlinkPrefix : &IpSb->AutonomousPrefix;
 
  //
  // Create a direct route entry for on-link prefix and insert to route area.
  //
  if (OnLinkOrAuto) {
    RtEntry = Ip6CreateRouteEntry (Prefix, PrefixLength, NULL);
    if (RtEntry == NULL) {
      FreePool (PrefixEntry);
      return NULL;
    }
 
    RtEntry->Flag = IP6_DIRECT_ROUTE;
    InsertHeadList (&IpSb->RouteTable->RouteArea[PrefixLength], &RtEntry->Link);
    IpSb->RouteTable->TotalNum++;
  }
 
  //
  // Insert the prefix entry in the order that a prefix with longer prefix length
  // is put ahead in the list.
  //
  NET_LIST_FOR_EACH (Entry, ListHead) {
    TmpPrefixEntry = NET_LIST_USER_STRUCT (Entry, IP6_PREFIX_LIST_ENTRY, Link);
 
    if (TmpPrefixEntry->PrefixLength < PrefixEntry->PrefixLength) {
      break;
    }
  }
 
  NetListInsertBefore (Entry, &PrefixEntry->Link);
 
  return PrefixEntry;
}
 
VOID
Ip6DestroyPrefixListEntry (
  IN IP6_SERVICE            *IpSb,
  IN IP6_PREFIX_LIST_ENTRY  *PrefixEntry,
  IN BOOLEAN                OnLinkOrAuto,
  IN BOOLEAN                ImmediateDelete
  )
{
  LIST_ENTRY     *Entry;
  IP6_INTERFACE  *IpIf;
  EFI_STATUS     Status;
 
  if ((!ImmediateDelete) && (PrefixEntry->RefCnt > 0) && ((--PrefixEntry->RefCnt) > 0)) {
    return;
  }
 
  if (OnLinkOrAuto) {
    //
    // Remove the direct route for onlink prefix from route table.
    //
    do {
      Status = Ip6DelRoute (
                 IpSb->RouteTable,
                 &PrefixEntry->Prefix,
                 PrefixEntry->PrefixLength,
                 NULL
                 );
    } while (Status != EFI_NOT_FOUND);
  } else {
    //
    // Remove the corresponding addresses generated from this autonomous prefix.
    //
    NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
      IpIf = NET_LIST_USER_STRUCT_S (Entry, IP6_INTERFACE, Link, IP6_INTERFACE_SIGNATURE);
 
      Ip6RemoveAddr (IpSb, &IpIf->AddressList, &IpIf->AddressCount, &PrefixEntry->Prefix, PrefixEntry->PrefixLength);
    }
  }
 
  RemoveEntryList (&PrefixEntry->Link);
  FreePool (PrefixEntry);
}
 
IP6_PREFIX_LIST_ENTRY *
Ip6FindPrefixListEntry (
  IN IP6_SERVICE       *IpSb,
  IN BOOLEAN           OnLinkOrAuto,
  IN UINT8             PrefixLength,
  IN EFI_IPv6_ADDRESS  *Prefix
  )
{
  IP6_PREFIX_LIST_ENTRY  *PrefixList;
  LIST_ENTRY             *Entry;
  LIST_ENTRY             *ListHead;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
  ASSERT (Prefix != NULL);
 
  if (OnLinkOrAuto) {
    ListHead = &IpSb->OnlinkPrefix;
  } else {
    ListHead = &IpSb->AutonomousPrefix;
  }
 
  NET_LIST_FOR_EACH (Entry, ListHead) {
    PrefixList = NET_LIST_USER_STRUCT (Entry, IP6_PREFIX_LIST_ENTRY, Link);
    if (PrefixLength != 255) {
      //
      // Perform exactly prefix match.
      //
      if ((PrefixList->PrefixLength == PrefixLength) &&
          NetIp6IsNetEqual (&PrefixList->Prefix, Prefix, PrefixLength))
      {
        return PrefixList;
      }
    } else {
      //
      // Perform the longest prefix match. The list is already sorted with
      // the longest length prefix put at the head of the list.
      //
      if (NetIp6IsNetEqual (&PrefixList->Prefix, Prefix, PrefixList->PrefixLength)) {
        return PrefixList;
      }
    }
  }
 
  return NULL;
}
 
VOID
Ip6CleanPrefixListTable (
  IN IP6_SERVICE  *IpSb,
  IN LIST_ENTRY   *ListHead
  )
{
  IP6_PREFIX_LIST_ENTRY  *PrefixList;
  BOOLEAN                OnLink;
 
  OnLink = (BOOLEAN)(ListHead == &IpSb->OnlinkPrefix);
 
  while (!IsListEmpty (ListHead)) {
    PrefixList = NET_LIST_HEAD (ListHead, IP6_PREFIX_LIST_ENTRY, Link);
    Ip6DestroyPrefixListEntry (IpSb, PrefixList, OnLink, TRUE);
  }
}
 
VOID
Ip6OnArpResolved (
  IN VOID  *Context
  )
{
  LIST_ENTRY          *Entry;
  LIST_ENTRY          *Next;
  IP6_NEIGHBOR_ENTRY  *ArpQue;
  IP6_SERVICE         *IpSb;
  IP6_LINK_TX_TOKEN   *Token;
  EFI_STATUS          Status;
  BOOLEAN             Sent;
 
  ArpQue = (IP6_NEIGHBOR_ENTRY *)Context;
  if ((ArpQue == NULL) || (ArpQue->Interface == NULL)) {
    return;
  }
 
  IpSb = ArpQue->Interface->Service;
  if ((IpSb == NULL) || (IpSb->Signature != IP6_SERVICE_SIGNATURE)) {
    return;
  }
 
  //
  // ARP resolve failed for some reason. Release all the frame
  // and ARP queue itself. Ip6FreeArpQue will call the frame's
  // owner back.
  //
  if (NET_MAC_EQUAL (&ArpQue->LinkAddress, &mZeroMacAddress, IpSb->SnpMode.HwAddressSize)) {
    Ip6FreeNeighborEntry (IpSb, ArpQue, FALSE, TRUE, EFI_NO_MAPPING, NULL, NULL);
    return;
  }
 
  //
  // ARP resolve succeeded, Transmit all the frame.
  //
  Sent = FALSE;
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &ArpQue->Frames) {
    RemoveEntryList (Entry);
 
    Token = NET_LIST_USER_STRUCT (Entry, IP6_LINK_TX_TOKEN, Link);
    IP6_COPY_LINK_ADDRESS (&Token->DstMac, &ArpQue->LinkAddress);
 
    //
    // Insert the tx token before transmitting it via MNP as the FrameSentDpc
    // may be called before Mnp->Transmit returns which will remove this tx
    // token from the SentFrames list. Remove it from the list if the returned
    // Status of Mnp->Transmit is not EFI_SUCCESS as in this case the
    // FrameSentDpc won't be queued.
    //
    InsertTailList (&ArpQue->Interface->SentFrames, &Token->Link);
 
    Status = IpSb->Mnp->Transmit (IpSb->Mnp, &Token->MnpToken);
    if (EFI_ERROR (Status)) {
      RemoveEntryList (&Token->Link);
      Token->CallBack (Token->Packet, Status, 0, Token->Context);
 
      Ip6FreeLinkTxToken (Token);
      continue;
    } else {
      Sent = TRUE;
    }
  }
 
  //
  // Free the ArpQue only but not the whole neighbor entry.
  //
  Ip6FreeNeighborEntry (IpSb, ArpQue, FALSE, FALSE, EFI_SUCCESS, NULL, NULL);
 
  if (Sent && (ArpQue->State == EfiNeighborStale)) {
    ArpQue->State = EfiNeighborDelay;
    ArpQue->Ticks = (UINT32)IP6_GET_TICKS (IP6_DELAY_FIRST_PROBE_TIME);
  }
}
 
IP6_NEIGHBOR_ENTRY *
Ip6CreateNeighborEntry (
  IN IP6_SERVICE       *IpSb,
  IN IP6_ARP_CALLBACK  CallBack,
  IN EFI_IPv6_ADDRESS  *Ip6Address,
  IN EFI_MAC_ADDRESS   *LinkAddress OPTIONAL
  )
{
  IP6_NEIGHBOR_ENTRY  *Entry;
  IP6_DEFAULT_ROUTER  *DefaultRouter;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
  ASSERT (Ip6Address != NULL);
 
  Entry = AllocateZeroPool (sizeof (IP6_NEIGHBOR_ENTRY));
  if (Entry == NULL) {
    return NULL;
  }
 
  Entry->RefCnt    = 1;
  Entry->IsRouter  = FALSE;
  Entry->ArpFree   = FALSE;
  Entry->Dynamic   = FALSE;
  Entry->State     = EfiNeighborInComplete;
  Entry->Transmit  = IP6_MAX_MULTICAST_SOLICIT + 1;
  Entry->CallBack  = CallBack;
  Entry->Interface = NULL;
 
  InitializeListHead (&Entry->Frames);
 
  IP6_COPY_ADDRESS (&Entry->Neighbor, Ip6Address);
 
  if (LinkAddress != NULL) {
    IP6_COPY_LINK_ADDRESS (&Entry->LinkAddress, LinkAddress);
  } else {
    IP6_COPY_LINK_ADDRESS (&Entry->LinkAddress, &mZeroMacAddress);
  }
 
  InsertHeadList (&IpSb->NeighborTable, &Entry->Link);
 
  //
  // If corresponding default router entry exists, establish the relationship.
  //
  DefaultRouter = Ip6FindDefaultRouter (IpSb, Ip6Address);
  if (DefaultRouter != NULL) {
    DefaultRouter->NeighborCache = Entry;
  }
 
  return Entry;
}
 
IP6_NEIGHBOR_ENTRY *
Ip6FindNeighborEntry (
  IN IP6_SERVICE       *IpSb,
  IN EFI_IPv6_ADDRESS  *Ip6Address
  )
{
  LIST_ENTRY          *Entry;
  LIST_ENTRY          *Next;
  IP6_NEIGHBOR_ENTRY  *Neighbor;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
  ASSERT (Ip6Address != NULL);
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpSb->NeighborTable) {
    Neighbor = NET_LIST_USER_STRUCT (Entry, IP6_NEIGHBOR_ENTRY, Link);
    if (EFI_IP6_EQUAL (Ip6Address, &Neighbor->Neighbor)) {
      RemoveEntryList (Entry);
      InsertHeadList (&IpSb->NeighborTable, Entry);
 
      return Neighbor;
    }
  }
 
  return NULL;
}
 
EFI_STATUS
Ip6FreeNeighborEntry (
  IN IP6_SERVICE          *IpSb,
  IN IP6_NEIGHBOR_ENTRY   *NeighborCache,
  IN BOOLEAN              SendIcmpError,
  IN BOOLEAN              FullFree,
  IN EFI_STATUS           IoStatus,
  IN IP6_FRAME_TO_CANCEL  FrameToCancel OPTIONAL,
  IN VOID                 *Context      OPTIONAL
  )
{
  IP6_LINK_TX_TOKEN   *TxToken;
  LIST_ENTRY          *Entry;
  LIST_ENTRY          *Next;
  IP6_DEFAULT_ROUTER  *DefaultRouter;
 
  //
  // If FrameToCancel fails, the token will not be released.
  // To avoid the memory leak, stop this usage model.
  //
  if (FullFree && (FrameToCancel != NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &NeighborCache->Frames) {
    TxToken = NET_LIST_USER_STRUCT (Entry, IP6_LINK_TX_TOKEN, Link);
 
    if (SendIcmpError && !IP6_IS_MULTICAST (&TxToken->Packet->Ip.Ip6->DestinationAddress)) {
      Ip6SendIcmpError (
        IpSb,
        TxToken->Packet,
        NULL,
        &TxToken->Packet->Ip.Ip6->SourceAddress,
        ICMP_V6_DEST_UNREACHABLE,
        ICMP_V6_ADDR_UNREACHABLE,
        NULL
        );
    }
 
    if ((FrameToCancel == NULL) || FrameToCancel (TxToken, Context)) {
      RemoveEntryList (Entry);
      TxToken->CallBack (TxToken->Packet, IoStatus, 0, TxToken->Context);
      Ip6FreeLinkTxToken (TxToken);
    }
  }
 
  if (NeighborCache->ArpFree && IsListEmpty (&NeighborCache->Frames)) {
    RemoveEntryList (&NeighborCache->ArpList);
    NeighborCache->ArpFree = FALSE;
  }
 
  if (FullFree) {
    if (NeighborCache->IsRouter) {
      DefaultRouter = Ip6FindDefaultRouter (IpSb, &NeighborCache->Neighbor);
      if (DefaultRouter != NULL) {
        Ip6DestroyDefaultRouter (IpSb, DefaultRouter);
      }
    }
 
    RemoveEntryList (&NeighborCache->Link);
    FreePool (NeighborCache);
  }
 
  return EFI_SUCCESS;
}
 
IP6_DEFAULT_ROUTER *
Ip6CreateDefaultRouter (
  IN IP6_SERVICE       *IpSb,
  IN EFI_IPv6_ADDRESS  *Ip6Address,
  IN UINT16            RouterLifetime
  )
{
  IP6_DEFAULT_ROUTER  *Entry;
  IP6_ROUTE_ENTRY     *RtEntry;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
  ASSERT (Ip6Address != NULL);
 
  Entry = AllocatePool (sizeof (IP6_DEFAULT_ROUTER));
  if (Entry == NULL) {
    return NULL;
  }
 
  Entry->RefCnt        = 1;
  Entry->Lifetime      = RouterLifetime;
  Entry->NeighborCache = Ip6FindNeighborEntry (IpSb, Ip6Address);
  IP6_COPY_ADDRESS (&Entry->Router, Ip6Address);
 
  //
  // Add a default route into route table with both Destination and PrefixLength set to zero.
  //
  RtEntry = Ip6CreateRouteEntry (NULL, 0, Ip6Address);
  if (RtEntry == NULL) {
    FreePool (Entry);
    return NULL;
  }
 
  InsertHeadList (&IpSb->RouteTable->RouteArea[0], &RtEntry->Link);
  IpSb->RouteTable->TotalNum++;
 
  InsertTailList (&IpSb->DefaultRouterList, &Entry->Link);
 
  return Entry;
}
 
VOID
Ip6DestroyDefaultRouter (
  IN IP6_SERVICE         *IpSb,
  IN IP6_DEFAULT_ROUTER  *DefaultRouter
  )
{
  EFI_STATUS  Status;
 
  RemoveEntryList (&DefaultRouter->Link);
 
  //
  // Update the Destination Cache - all entries using the time-out router as next-hop
  // should perform next-hop determination again.
  //
  do {
    Status = Ip6DelRoute (IpSb->RouteTable, NULL, 0, &DefaultRouter->Router);
  } while (Status != EFI_NOT_FOUND);
 
  FreePool (DefaultRouter);
}
 
VOID
Ip6CleanDefaultRouterList (
  IN IP6_SERVICE  *IpSb
  )
{
  IP6_DEFAULT_ROUTER  *DefaultRouter;
 
  while (!IsListEmpty (&IpSb->DefaultRouterList)) {
    DefaultRouter = NET_LIST_HEAD (&IpSb->DefaultRouterList, IP6_DEFAULT_ROUTER, Link);
    Ip6DestroyDefaultRouter (IpSb, DefaultRouter);
  }
}
 
IP6_DEFAULT_ROUTER *
Ip6FindDefaultRouter (
  IN IP6_SERVICE       *IpSb,
  IN EFI_IPv6_ADDRESS  *Ip6Address
  )
{
  LIST_ENTRY          *Entry;
  IP6_DEFAULT_ROUTER  *DefaultRouter;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
  ASSERT (Ip6Address != NULL);
 
  NET_LIST_FOR_EACH (Entry, &IpSb->DefaultRouterList) {
    DefaultRouter = NET_LIST_USER_STRUCT (Entry, IP6_DEFAULT_ROUTER, Link);
    if (EFI_IP6_EQUAL (Ip6Address, &DefaultRouter->Router)) {
      return DefaultRouter;
    }
  }
 
  return NULL;
}
 
VOID
Ip6OnDADFinished (
  IN BOOLEAN        IsDadPassed,
  IN IP6_INTERFACE  *IpIf,
  IN IP6_DAD_ENTRY  *DadEntry
  )
{
  IP6_SERVICE               *IpSb;
  IP6_ADDRESS_INFO          *AddrInfo;
  EFI_DHCP6_PROTOCOL        *Dhcp6;
  UINT16                    OptBuf[4];
  EFI_DHCP6_PACKET_OPTION   *Oro;
  EFI_DHCP6_RETRANSMISSION  InfoReqReXmit;
  EFI_IPv6_ADDRESS          AllNodes;
 
  IpSb     = IpIf->Service;
  AddrInfo = DadEntry->AddressInfo;
 
  if (IsDadPassed) {
    //
    // DAD succeed.
    //
    if (NetIp6IsLinkLocalAddr (&AddrInfo->Address)) {
      ASSERT (!IpSb->LinkLocalOk);
 
      IP6_COPY_ADDRESS (&IpSb->LinkLocalAddr, &AddrInfo->Address);
      IpSb->LinkLocalOk = TRUE;
      IpIf->Configured  = TRUE;
 
      //
      // Check whether DHCP6 need to be started.
      //
      Dhcp6 = IpSb->Ip6ConfigInstance.Dhcp6;
 
      if (IpSb->Dhcp6NeedStart) {
        Dhcp6->Start (Dhcp6);
        IpSb->Dhcp6NeedStart = FALSE;
      }
 
      if (IpSb->Dhcp6NeedInfoRequest) {
        //
        // Set the exta options to send. Here we only want the option request option
        // with DNS SERVERS.
        //
        Oro                        = (EFI_DHCP6_PACKET_OPTION *)OptBuf;
        Oro->OpCode                = HTONS (DHCP6_OPT_ORO);
        Oro->OpLen                 = HTONS (2);
        *((UINT16 *)&Oro->Data[0]) = HTONS (DHCP6_OPT_DNS_SERVERS);
 
        InfoReqReXmit.Irt = 4;
        InfoReqReXmit.Mrc = 64;
        InfoReqReXmit.Mrt = 60;
        InfoReqReXmit.Mrd = 0;
 
        Dhcp6->InfoRequest (
                 Dhcp6,
                 TRUE,
                 Oro,
                 0,
                 NULL,
                 &InfoReqReXmit,
                 IpSb->Ip6ConfigInstance.Dhcp6Event,
                 Ip6ConfigOnDhcp6Reply,
                 &IpSb->Ip6ConfigInstance
                 );
      }
 
      //
      // Add an on-link prefix for link-local address.
      //
      Ip6CreatePrefixListEntry (
        IpSb,
        TRUE,
        (UINT32)IP6_INFINIT_LIFETIME,
        (UINT32)IP6_INFINIT_LIFETIME,
        IP6_LINK_LOCAL_PREFIX_LENGTH,
        &IpSb->LinkLocalAddr
        );
    } else {
      //
      // Global scope unicast address.
      //
      Ip6AddAddr (IpIf, AddrInfo);
 
      //
      // Add an on-link prefix for this address.
      //
      Ip6CreatePrefixListEntry (
        IpSb,
        TRUE,
        AddrInfo->ValidLifetime,
        AddrInfo->PreferredLifetime,
        AddrInfo->PrefixLength,
        &AddrInfo->Address
        );
 
      IpIf->Configured = TRUE;
    }
  } else {
    //
    // Leave the group we joined before.
    //
    Ip6LeaveGroup (IpSb, &DadEntry->Destination);
  }
 
  if (DadEntry->Callback != NULL) {
    DadEntry->Callback (IsDadPassed, &AddrInfo->Address, DadEntry->Context);
  }
 
  if (!IsDadPassed && NetIp6IsLinkLocalAddr (&AddrInfo->Address)) {
    FreePool (AddrInfo);
    RemoveEntryList (&DadEntry->Link);
    FreePool (DadEntry);
    //
    // Leave link-scope all-nodes multicast address (FF02::1)
    //
    Ip6SetToAllNodeMulticast (FALSE, IP6_LINK_LOCAL_SCOPE, &AllNodes);
    Ip6LeaveGroup (IpSb, &AllNodes);
    //
    // Disable IP operation since link-local address is a duplicate address.
    //
    IpSb->LinkLocalDadFail = TRUE;
    IpSb->Mnp->Configure (IpSb->Mnp, NULL);
    gBS->SetTimer (IpSb->Timer, TimerCancel, 0);
    gBS->SetTimer (IpSb->FasterTimer, TimerCancel, 0);
    return;
  }
 
  if (!IsDadPassed || NetIp6IsLinkLocalAddr (&AddrInfo->Address)) {
    //
    // Free the AddressInfo we hold if DAD fails or it is a link-local address.
    //
    FreePool (AddrInfo);
  }
 
  RemoveEntryList (&DadEntry->Link);
  FreePool (DadEntry);
}
 
EFI_STATUS
Ip6InitDADProcess (
  IN IP6_INTERFACE     *IpIf,
  IN IP6_ADDRESS_INFO  *AddressInfo,
  IN IP6_DAD_CALLBACK  Callback  OPTIONAL,
  IN VOID              *Context  OPTIONAL
  )
{
  IP6_DAD_ENTRY                             *Entry;
  EFI_IP6_CONFIG_DUP_ADDR_DETECT_TRANSMITS  *DadXmits;
  IP6_SERVICE                               *IpSb;
  EFI_STATUS                                Status;
  UINT32                                    MaxDelayTick;
  UINT32                                    Random;
 
  NET_CHECK_SIGNATURE (IpIf, IP6_INTERFACE_SIGNATURE);
  ASSERT (AddressInfo != NULL);
 
  Status = PseudoRandomU32 (&Random);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a failed to generate random number: %r\n", __func__, Status));
    return Status;
  }
 
  //
  // Do nothing if we have already started DAD on the address.
  //
  if (Ip6FindDADEntry (IpIf->Service, &AddressInfo->Address, NULL) != NULL) {
    return EFI_SUCCESS;
  }
 
  Status   = EFI_SUCCESS;
  IpSb     = IpIf->Service;
  DadXmits = &IpSb->Ip6ConfigInstance.DadXmits;
 
  //
  // Allocate the resources and insert info
  //
  Entry = AllocatePool (sizeof (IP6_DAD_ENTRY));
  if (Entry == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Map the incoming unicast address to solicited-node multicast address
  //
  Ip6CreateSNMulticastAddr (&AddressInfo->Address, &Entry->Destination);
 
  //
  // Join in the solicited-node multicast address.
  //
  Status = Ip6JoinGroup (IpSb, IpIf, &Entry->Destination);
  if (EFI_ERROR (Status)) {
    FreePool (Entry);
    return Status;
  }
 
  Entry->Signature   = IP6_DAD_ENTRY_SIGNATURE;
  Entry->MaxTransmit = DadXmits->DupAddrDetectTransmits;
  Entry->Transmit    = 0;
  Entry->Receive     = 0;
  MaxDelayTick       = IP6_MAX_RTR_SOLICITATION_DELAY / IP6_TIMER_INTERVAL_IN_MS;
  Entry->RetransTick = (MaxDelayTick * ((Random % 5) + 1)) / 5;
  Entry->AddressInfo = AddressInfo;
  Entry->Callback    = Callback;
  Entry->Context     = Context;
  InsertTailList (&IpIf->DupAddrDetectList, &Entry->Link);
 
  if (Entry->MaxTransmit == 0) {
    //
    // DAD is disabled on this interface, immediately mark this DAD successful.
    //
    Ip6OnDADFinished (TRUE, IpIf, Entry);
  }
 
  return EFI_SUCCESS;
}
 
IP6_DAD_ENTRY *
Ip6FindDADEntry (
  IN  IP6_SERVICE       *IpSb,
  IN  EFI_IPv6_ADDRESS  *Target,
  OUT IP6_INTERFACE     **Interface OPTIONAL
  )
{
  LIST_ENTRY        *Entry;
  LIST_ENTRY        *Entry2;
  IP6_INTERFACE     *IpIf;
  IP6_DAD_ENTRY     *DupAddrDetect;
  IP6_ADDRESS_INFO  *AddrInfo;
 
  NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
    IpIf = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);
 
    NET_LIST_FOR_EACH (Entry2, &IpIf->DupAddrDetectList) {
      DupAddrDetect = NET_LIST_USER_STRUCT_S (Entry2, IP6_DAD_ENTRY, Link, IP6_DAD_ENTRY_SIGNATURE);
      AddrInfo      = DupAddrDetect->AddressInfo;
      if (EFI_IP6_EQUAL (&AddrInfo->Address, Target)) {
        if (Interface != NULL) {
          *Interface = IpIf;
        }
 
        return DupAddrDetect;
      }
    }
  }
 
  return NULL;
}
 
EFI_STATUS
Ip6SendRouterSolicit (
  IN IP6_SERVICE       *IpSb,
  IN IP6_INTERFACE     *Interface          OPTIONAL,
  IN EFI_IPv6_ADDRESS  *SourceAddress      OPTIONAL,
  IN EFI_IPv6_ADDRESS  *DestinationAddress OPTIONAL,
  IN EFI_MAC_ADDRESS   *SourceLinkAddress  OPTIONAL
  )
{
  NET_BUF                    *Packet;
  EFI_IP6_HEADER             Head;
  IP6_ICMP_INFORMATION_HEAD  *IcmpHead;
  IP6_ETHER_ADDR_OPTION      *LinkLayerOption;
  UINT16                     PayloadLen;
  IP6_INTERFACE              *IpIf;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
 
  IpIf = Interface;
  if ((IpIf == NULL) && (IpSb->DefaultInterface != NULL)) {
    IpIf = IpSb->DefaultInterface;
  }
 
  //
  // Generate the packet to be sent
  //
 
  PayloadLen = (UINT16)sizeof (IP6_ICMP_INFORMATION_HEAD);
  if (SourceLinkAddress != NULL) {
    PayloadLen += sizeof (IP6_ETHER_ADDR_OPTION);
  }
 
  Packet = NetbufAlloc (sizeof (EFI_IP6_HEADER) + (UINT32)PayloadLen);
  if (Packet == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Create the basic IPv6 header.
  //
  Head.FlowLabelL    = 0;
  Head.FlowLabelH    = 0;
  Head.PayloadLength = HTONS (PayloadLen);
  Head.NextHeader    = IP6_ICMP;
  Head.HopLimit      = IP6_HOP_LIMIT;
 
  if (SourceAddress != NULL) {
    IP6_COPY_ADDRESS (&Head.SourceAddress, SourceAddress);
  } else {
    ZeroMem (&Head.SourceAddress, sizeof (EFI_IPv6_ADDRESS));
  }
 
  if (DestinationAddress != NULL) {
    IP6_COPY_ADDRESS (&Head.DestinationAddress, DestinationAddress);
  } else {
    Ip6SetToAllNodeMulticast (TRUE, IP6_LINK_LOCAL_SCOPE, &Head.DestinationAddress);
  }
 
  NetbufReserve (Packet, sizeof (EFI_IP6_HEADER));
 
  //
  // Fill in the ICMP header, and Source link-layer address if contained.
  //
 
  IcmpHead = (IP6_ICMP_INFORMATION_HEAD *)NetbufAllocSpace (Packet, sizeof (IP6_ICMP_INFORMATION_HEAD), FALSE);
  ASSERT (IcmpHead != NULL);
  ZeroMem (IcmpHead, sizeof (IP6_ICMP_INFORMATION_HEAD));
  IcmpHead->Head.Type = ICMP_V6_ROUTER_SOLICIT;
  IcmpHead->Head.Code = 0;
 
  LinkLayerOption = NULL;
  if (SourceLinkAddress != NULL) {
    LinkLayerOption = (IP6_ETHER_ADDR_OPTION *)NetbufAllocSpace (
                                                 Packet,
                                                 sizeof (IP6_ETHER_ADDR_OPTION),
                                                 FALSE
                                                 );
    ASSERT (LinkLayerOption != NULL);
    LinkLayerOption->Type   = Ip6OptionEtherSource;
    LinkLayerOption->Length = (UINT8)sizeof (IP6_ETHER_ADDR_OPTION);
    CopyMem (LinkLayerOption->EtherAddr, SourceLinkAddress, 6);
  }
 
  //
  // Transmit the packet
  //
  return Ip6Output (IpSb, IpIf, NULL, Packet, &Head, NULL, 0, Ip6SysPacketSent, NULL);
}
 
EFI_STATUS
Ip6SendNeighborAdvertise (
  IN IP6_SERVICE       *IpSb,
  IN EFI_IPv6_ADDRESS  *SourceAddress,
  IN EFI_IPv6_ADDRESS  *DestinationAddress,
  IN EFI_IPv6_ADDRESS  *TargetIp6Address,
  IN EFI_MAC_ADDRESS   *TargetLinkAddress,
  IN BOOLEAN           IsRouter,
  IN BOOLEAN           Override,
  IN BOOLEAN           Solicited
  )
{
  NET_BUF                    *Packet;
  EFI_IP6_HEADER             Head;
  IP6_ICMP_INFORMATION_HEAD  *IcmpHead;
  IP6_ETHER_ADDR_OPTION      *LinkLayerOption;
  EFI_IPv6_ADDRESS           *Target;
  UINT16                     PayloadLen;
 
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
 
  //
  // The Neighbor Advertisement message must include a Target link-layer address option
  // when responding to multicast solicitation and should include such option when
  // responding to unicast solicitation. It also must include such option as unsolicited
  // advertisement.
  //
  ASSERT (DestinationAddress != NULL && TargetIp6Address != NULL && TargetLinkAddress != NULL);
 
  PayloadLen = (UINT16)(sizeof (IP6_ICMP_INFORMATION_HEAD) + sizeof (EFI_IPv6_ADDRESS) + sizeof (IP6_ETHER_ADDR_OPTION));
 
  //
  // Generate the packet to be sent
  //
 
  Packet = NetbufAlloc (sizeof (EFI_IP6_HEADER) + (UINT32)PayloadLen);
  if (Packet == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Create the basic IPv6 header.
  //
  Head.FlowLabelL    = 0;
  Head.FlowLabelH    = 0;
  Head.PayloadLength = HTONS (PayloadLen);
  Head.NextHeader    = IP6_ICMP;
  Head.HopLimit      = IP6_HOP_LIMIT;
 
  IP6_COPY_ADDRESS (&Head.SourceAddress, SourceAddress);
  IP6_COPY_ADDRESS (&Head.DestinationAddress, DestinationAddress);
 
  NetbufReserve (Packet, sizeof (EFI_IP6_HEADER));
 
  //
  // Fill in the ICMP header, Target address, and Target link-layer address.
  // Set the Router flag, Solicited flag and Override flag.
  //
 
  IcmpHead = (IP6_ICMP_INFORMATION_HEAD *)NetbufAllocSpace (Packet, sizeof (IP6_ICMP_INFORMATION_HEAD), FALSE);
  ASSERT (IcmpHead != NULL);
  ZeroMem (IcmpHead, sizeof (IP6_ICMP_INFORMATION_HEAD));
  IcmpHead->Head.Type = ICMP_V6_NEIGHBOR_ADVERTISE;
  IcmpHead->Head.Code = 0;
 
  if (IsRouter) {
    IcmpHead->Fourth |= IP6_IS_ROUTER_FLAG;
  }
 
  if (Solicited) {
    IcmpHead->Fourth |= IP6_SOLICITED_FLAG;
  }
 
  if (Override) {
    IcmpHead->Fourth |= IP6_OVERRIDE_FLAG;
  }
 
  Target = (EFI_IPv6_ADDRESS *)NetbufAllocSpace (Packet, sizeof (EFI_IPv6_ADDRESS), FALSE);
  ASSERT (Target != NULL);
  IP6_COPY_ADDRESS (Target, TargetIp6Address);
 
  LinkLayerOption = (IP6_ETHER_ADDR_OPTION *)NetbufAllocSpace (
                                               Packet,
                                               sizeof (IP6_ETHER_ADDR_OPTION),
                                               FALSE
                                               );
  ASSERT (LinkLayerOption != NULL);
  LinkLayerOption->Type   = Ip6OptionEtherTarget;
  LinkLayerOption->Length = 1;
  CopyMem (LinkLayerOption->EtherAddr, TargetLinkAddress, 6);
 
  //
  // Transmit the packet
  //
  return Ip6Output (IpSb, NULL, NULL, Packet, &Head, NULL, 0, Ip6SysPacketSent, NULL);
}
 
EFI_STATUS
Ip6SendNeighborSolicit (
  IN IP6_SERVICE       *IpSb,
  IN EFI_IPv6_ADDRESS  *SourceAddress,
  IN EFI_IPv6_ADDRESS  *DestinationAddress,
  IN EFI_IPv6_ADDRESS  *TargetIp6Address,
  IN EFI_MAC_ADDRESS   *SourceLinkAddress OPTIONAL
  )
{
  NET_BUF                    *Packet;
  EFI_IP6_HEADER             Head;
  IP6_ICMP_INFORMATION_HEAD  *IcmpHead;
  IP6_ETHER_ADDR_OPTION      *LinkLayerOption;
  EFI_IPv6_ADDRESS           *Target;
  BOOLEAN                    IsDAD;
  UINT16                     PayloadLen;
  IP6_NEIGHBOR_ENTRY         *Neighbor;
 
  //
  // Check input parameters
  //
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
  if ((DestinationAddress == NULL) || (TargetIp6Address == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  IsDAD = FALSE;
 
  if ((SourceAddress == NULL) || ((SourceAddress != NULL) && NetIp6IsUnspecifiedAddr (SourceAddress))) {
    IsDAD = TRUE;
  }
 
  //
  // The Neighbor Solicitation message should include a source link-layer address option
  // if the solicitation is not sent by performing DAD - Duplicate Address Detection.
  // Otherwise must not include it.
  //
  PayloadLen = (UINT16)(sizeof (IP6_ICMP_INFORMATION_HEAD) + sizeof (EFI_IPv6_ADDRESS));
 
  if (!IsDAD) {
    if (SourceLinkAddress == NULL) {
      return EFI_INVALID_PARAMETER;
    }
 
    PayloadLen = (UINT16)(PayloadLen + sizeof (IP6_ETHER_ADDR_OPTION));
  }
 
  //
  // Generate the packet to be sent
  //
 
  Packet = NetbufAlloc (sizeof (EFI_IP6_HEADER) + (UINT32)PayloadLen);
  if (Packet == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Create the basic IPv6 header
  //
  Head.FlowLabelL    = 0;
  Head.FlowLabelH    = 0;
  Head.PayloadLength = HTONS (PayloadLen);
  Head.NextHeader    = IP6_ICMP;
  Head.HopLimit      = IP6_HOP_LIMIT;
 
  if (SourceAddress != NULL) {
    IP6_COPY_ADDRESS (&Head.SourceAddress, SourceAddress);
  } else {
    ZeroMem (&Head.SourceAddress, sizeof (EFI_IPv6_ADDRESS));
  }
 
  IP6_COPY_ADDRESS (&Head.DestinationAddress, DestinationAddress);
 
  NetbufReserve (Packet, sizeof (EFI_IP6_HEADER));
 
  //
  // Fill in the ICMP header, Target address, and Source link-layer address.
  //
  IcmpHead = (IP6_ICMP_INFORMATION_HEAD *)NetbufAllocSpace (Packet, sizeof (IP6_ICMP_INFORMATION_HEAD), FALSE);
  ASSERT (IcmpHead != NULL);
  ZeroMem (IcmpHead, sizeof (IP6_ICMP_INFORMATION_HEAD));
  IcmpHead->Head.Type = ICMP_V6_NEIGHBOR_SOLICIT;
  IcmpHead->Head.Code = 0;
 
  Target = (EFI_IPv6_ADDRESS *)NetbufAllocSpace (Packet, sizeof (EFI_IPv6_ADDRESS), FALSE);
  ASSERT (Target != NULL);
  IP6_COPY_ADDRESS (Target, TargetIp6Address);
 
  LinkLayerOption = NULL;
  if (!IsDAD) {
    //
    // Fill in the source link-layer address option
    //
    LinkLayerOption = (IP6_ETHER_ADDR_OPTION *)NetbufAllocSpace (
                                                 Packet,
                                                 sizeof (IP6_ETHER_ADDR_OPTION),
                                                 FALSE
                                                 );
    ASSERT (LinkLayerOption != NULL);
    LinkLayerOption->Type   = Ip6OptionEtherSource;
    LinkLayerOption->Length = 1;
    CopyMem (LinkLayerOption->EtherAddr, SourceLinkAddress, 6);
  }
 
  //
  // Create a Neighbor Cache entry in the INCOMPLETE state when performing
  // address resolution.
  //
  if (!IsDAD && Ip6IsSNMulticastAddr (DestinationAddress)) {
    Neighbor = Ip6FindNeighborEntry (IpSb, TargetIp6Address);
    if (Neighbor == NULL) {
      Neighbor = Ip6CreateNeighborEntry (IpSb, Ip6OnArpResolved, TargetIp6Address, NULL);
      ASSERT (Neighbor != NULL);
    }
  }
 
  //
  // Transmit the packet
  //
  return Ip6Output (IpSb, IpSb->DefaultInterface, NULL, Packet, &Head, NULL, 0, Ip6SysPacketSent, NULL);
}
 
EFI_STATUS
Ip6ProcessNeighborSolicit (
  IN IP6_SERVICE     *IpSb,
  IN EFI_IP6_HEADER  *Head,
  IN NET_BUF         *Packet
  )
{
  IP6_ICMP_INFORMATION_HEAD  Icmp;
  EFI_IPv6_ADDRESS           Target;
  IP6_ETHER_ADDR_OPTION      LinkLayerOption;
  BOOLEAN                    IsDAD;
  BOOLEAN                    IsUnicast;
  BOOLEAN                    IsMaintained;
  IP6_DAD_ENTRY              *DupAddrDetect;
  IP6_INTERFACE              *IpIf;
  IP6_NEIGHBOR_ENTRY         *Neighbor;
  BOOLEAN                    Solicited;
  BOOLEAN                    UpdateCache;
  EFI_IPv6_ADDRESS           Dest;
  UINT16                     OptionLen;
  UINT8                      *Option;
  BOOLEAN                    Provided;
  EFI_STATUS                 Status;
  VOID                       *MacAddress;
 
  NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *)&Icmp);
  NetbufCopy (Packet, sizeof (Icmp), sizeof (Target), Target.Addr);
 
  //
  // Perform Message Validation:
  // The IP Hop Limit field has a value of 255, i.e., the packet
  // could not possibly have been forwarded by a router.
  // ICMP Code is 0.
  // Target Address is not a multicast address.
  //
  Status = EFI_INVALID_PARAMETER;
 
  if ((Head->HopLimit != IP6_HOP_LIMIT) || (Icmp.Head.Code != 0) || !NetIp6IsValidUnicast (&Target)) {
    goto Exit;
  }
 
  //
  // ICMP length is 24 or more octets.
  //
  OptionLen = 0;
  if (Head->PayloadLength < IP6_ND_LENGTH) {
    goto Exit;
  } else {
    OptionLen = (UINT16)(Head->PayloadLength - IP6_ND_LENGTH);
    if (OptionLen != 0) {
      Option = NetbufGetByte (Packet, IP6_ND_LENGTH, NULL);
      ASSERT (Option != NULL);
 
      //
      // All included options should have a length that is greater than zero.
      //
      if (!Ip6IsNDOptionValid (Option, OptionLen)) {
        goto Exit;
      }
    }
  }
 
  IsDAD        = NetIp6IsUnspecifiedAddr (&Head->SourceAddress);
  IsUnicast    = (BOOLEAN) !Ip6IsSNMulticastAddr (&Head->DestinationAddress);
  IsMaintained = Ip6IsOneOfSetAddress (IpSb, &Target, &IpIf, NULL);
 
  Provided = FALSE;
  if (OptionLen >= sizeof (IP6_ETHER_ADDR_OPTION)) {
    NetbufCopy (
      Packet,
      IP6_ND_LENGTH,
      sizeof (IP6_ETHER_ADDR_OPTION),
      (UINT8 *)&LinkLayerOption
      );
    //
    // The solicitation for neighbor discovery should include a source link-layer
    // address option. If the option is not recognized, silently ignore it.
    //
    if (LinkLayerOption.Type == Ip6OptionEtherSource) {
      if (IsDAD) {
        //
        // If the IP source address is the unspecified address, the source
        // link-layer address option must not be included in the message.
        //
        goto Exit;
      }
 
      Provided = TRUE;
    }
  }
 
  //
  // If the IP source address is the unspecified address, the IP
  // destination address is a solicited-node multicast address.
  //
  if (IsDAD && IsUnicast) {
    goto Exit;
  }
 
  //
  // If the target address is tentative, and the source address is a unicast address,
  // the solicitation's sender is performing address resolution on the target;
  //  the solicitation should be silently ignored.
  //
  if (!IsDAD && !IsMaintained) {
    goto Exit;
  }
 
  //
  // If received unicast neighbor solicitation but destination is not this node,
  // drop the packet.
  //
  if (IsUnicast && !IsMaintained) {
    goto Exit;
  }
 
  //
  // In DAD, when target address is a tentative address,
  // process the received neighbor solicitation message but not send out response.
  //
  if (IsDAD && !IsMaintained) {
    DupAddrDetect = Ip6FindDADEntry (IpSb, &Target, &IpIf);
    if (DupAddrDetect != NULL) {
      //
      // Check the MAC address of the incoming packet.
      //
      if (IpSb->RecvRequest.MnpToken.Packet.RxData == NULL) {
        goto Exit;
      }
 
      MacAddress = IpSb->RecvRequest.MnpToken.Packet.RxData->SourceAddress;
      if (MacAddress != NULL) {
        if (CompareMem (
              MacAddress,
              &IpSb->SnpMode.CurrentAddress,
              IpSb->SnpMode.HwAddressSize
              ) != 0)
        {
          //
          // The NS is from another node to performing DAD on the same address.
          // Fail DAD for the tentative address.
          //
          Ip6OnDADFinished (FALSE, IpIf, DupAddrDetect);
          Status = EFI_ICMP_ERROR;
        } else {
          //
          // The below layer loopback the NS we sent. Record it and wait for more.
          //
          DupAddrDetect->Receive++;
          Status = EFI_SUCCESS;
        }
      }
    }
 
    goto Exit;
  }
 
  //
  // If the solicitation does not contain a link-layer address, DO NOT create or
  // update the neighbor cache entries.
  //
  if (Provided) {
    Neighbor    = Ip6FindNeighborEntry (IpSb, &Head->SourceAddress);
    UpdateCache = FALSE;
 
    if (Neighbor == NULL) {
      Neighbor = Ip6CreateNeighborEntry (IpSb, Ip6OnArpResolved, &Head->SourceAddress, NULL);
      if (Neighbor == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto Exit;
      }
 
      UpdateCache = TRUE;
    } else {
      if (CompareMem (Neighbor->LinkAddress.Addr, LinkLayerOption.EtherAddr, 6) != 0) {
        UpdateCache = TRUE;
      }
    }
 
    if (UpdateCache) {
      Neighbor->State = EfiNeighborStale;
      Neighbor->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
      CopyMem (Neighbor->LinkAddress.Addr, LinkLayerOption.EtherAddr, 6);
      //
      // Send queued packets if exist.
      //
      Neighbor->CallBack ((VOID *)Neighbor);
    }
  }
 
  //
  // Sends a Neighbor Advertisement as response.
  // Set the Router flag to zero since the node is a host.
  // If the source address of the solicitation is unspecified, and target address
  // is one of the maintained address, reply a unsolicited multicast advertisement.
  //
  if (IsDAD && IsMaintained) {
    Solicited = FALSE;
    Ip6SetToAllNodeMulticast (FALSE, IP6_LINK_LOCAL_SCOPE, &Dest);
  } else {
    Solicited = TRUE;
    IP6_COPY_ADDRESS (&Dest, &Head->SourceAddress);
  }
 
  Status = Ip6SendNeighborAdvertise (
             IpSb,
             &Target,
             &Dest,
             &Target,
             &IpSb->SnpMode.CurrentAddress,
             FALSE,
             TRUE,
             Solicited
             );
Exit:
  NetbufFree (Packet);
  return Status;
}
 
EFI_STATUS
Ip6ProcessNeighborAdvertise (
  IN IP6_SERVICE     *IpSb,
  IN EFI_IP6_HEADER  *Head,
  IN NET_BUF         *Packet
  )
{
  IP6_ICMP_INFORMATION_HEAD  Icmp;
  EFI_IPv6_ADDRESS           Target;
  IP6_ETHER_ADDR_OPTION      LinkLayerOption;
  BOOLEAN                    Provided;
  INTN                       Compare;
  IP6_NEIGHBOR_ENTRY         *Neighbor;
  IP6_DEFAULT_ROUTER         *DefaultRouter;
  BOOLEAN                    Solicited;
  BOOLEAN                    IsRouter;
  BOOLEAN                    Override;
  IP6_DAD_ENTRY              *DupAddrDetect;
  IP6_INTERFACE              *IpIf;
  UINT16                     OptionLen;
  UINT8                      *Option;
  EFI_STATUS                 Status;
 
  NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *)&Icmp);
  NetbufCopy (Packet, sizeof (Icmp), sizeof (Target), Target.Addr);
 
  //
  // Validate the incoming Neighbor Advertisement
  //
  Status = EFI_INVALID_PARAMETER;
  //
  // The IP Hop Limit field has a value of 255, i.e., the packet
  // could not possibly have been forwarded by a router.
  // ICMP Code is 0.
  // Target Address is not a multicast address.
  //
  if ((Head->HopLimit != IP6_HOP_LIMIT) || (Icmp.Head.Code != 0) || !NetIp6IsValidUnicast (&Target)) {
    goto Exit;
  }
 
  //
  // ICMP length is 24 or more octets.
  //
  Provided  = FALSE;
  OptionLen = 0;
  if (Head->PayloadLength < IP6_ND_LENGTH) {
    goto Exit;
  } else {
    OptionLen = (UINT16)(Head->PayloadLength - IP6_ND_LENGTH);
    if (OptionLen != 0) {
      Option = NetbufGetByte (Packet, IP6_ND_LENGTH, NULL);
      ASSERT (Option != NULL);
 
      //
      // All included options should have a length that is greater than zero.
      //
      if (!Ip6IsNDOptionValid (Option, OptionLen)) {
        goto Exit;
      }
    }
  }
 
  //
  // If the IP destination address is a multicast address, Solicited Flag is ZERO.
  //
  Solicited = FALSE;
  if ((Icmp.Fourth & IP6_SOLICITED_FLAG) == IP6_SOLICITED_FLAG) {
    Solicited = TRUE;
  }
 
  if (IP6_IS_MULTICAST (&Head->DestinationAddress) && Solicited) {
    goto Exit;
  }
 
  //
  // DAD - Check whether the Target is one of our tentative address.
  //
  DupAddrDetect = Ip6FindDADEntry (IpSb, &Target, &IpIf);
  if (DupAddrDetect != NULL) {
    //
    // DAD fails, some other node is using this address.
    //
    NetbufFree (Packet);
    Ip6OnDADFinished (FALSE, IpIf, DupAddrDetect);
    return EFI_ICMP_ERROR;
  }
 
  //
  // Search the Neighbor Cache for the target's entry. If no entry exists,
  // the advertisement should be silently discarded.
  //
  Neighbor = Ip6FindNeighborEntry (IpSb, &Target);
  if (Neighbor == NULL) {
    goto Exit;
  }
 
  //
  // Get IsRouter Flag and Override Flag
  //
  IsRouter = FALSE;
  Override = FALSE;
  if ((Icmp.Fourth & IP6_IS_ROUTER_FLAG) == IP6_IS_ROUTER_FLAG) {
    IsRouter = TRUE;
  }
 
  if ((Icmp.Fourth & IP6_OVERRIDE_FLAG) == IP6_OVERRIDE_FLAG) {
    Override = TRUE;
  }
 
  //
  // Check whether link layer option is included.
  //
  if (OptionLen >= sizeof (IP6_ETHER_ADDR_OPTION)) {
    NetbufCopy (
      Packet,
      IP6_ND_LENGTH,
      sizeof (IP6_ETHER_ADDR_OPTION),
      (UINT8 *)&LinkLayerOption
      );
 
    if (LinkLayerOption.Type == Ip6OptionEtherTarget) {
      Provided = TRUE;
    }
  }
 
  Compare = 0;
  if (Provided) {
    Compare = CompareMem (Neighbor->LinkAddress.Addr, LinkLayerOption.EtherAddr, 6);
  }
 
  if (!Neighbor->IsRouter && IsRouter) {
    DefaultRouter = Ip6FindDefaultRouter (IpSb, &Target);
    if (DefaultRouter != NULL) {
      DefaultRouter->NeighborCache = Neighbor;
    }
  }
 
  if (Neighbor->State == EfiNeighborInComplete) {
    //
    // If the target's Neighbor Cache entry is in INCOMPLETE state and no
    // Target Link-Layer address option is included while link layer has
    // address, the message should be silently discarded.
    //
    if (!Provided) {
      goto Exit;
    }
 
    //
    // Update the Neighbor Cache
    //
    CopyMem (Neighbor->LinkAddress.Addr, LinkLayerOption.EtherAddr, 6);
    if (Solicited) {
      Neighbor->State = EfiNeighborReachable;
      Neighbor->Ticks = IP6_GET_TICKS (IpSb->ReachableTime);
    } else {
      Neighbor->State = EfiNeighborStale;
      Neighbor->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
      //
      // Send any packets queued for the neighbor awaiting address resolution.
      //
      Neighbor->CallBack ((VOID *)Neighbor);
    }
 
    Neighbor->IsRouter = IsRouter;
  } else {
    if (!Override && (Compare != 0)) {
      //
      // When the Override Flag is clear and supplied link-layer address differs from
      // that in the cache, if the state of the entry is not REACHABLE, ignore the
      // message. Otherwise set it to STALE but do not update the entry in any
      // other way.
      //
      if (Neighbor->State == EfiNeighborReachable) {
        Neighbor->State = EfiNeighborStale;
        Neighbor->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
      }
    } else {
      if (Compare != 0) {
        CopyMem (Neighbor->LinkAddress.Addr, LinkLayerOption.EtherAddr, 6);
      }
 
      //
      // Update the entry's state
      //
      if (Solicited) {
        Neighbor->State = EfiNeighborReachable;
        Neighbor->Ticks = IP6_GET_TICKS (IpSb->ReachableTime);
      } else {
        if (Compare != 0) {
          Neighbor->State = EfiNeighborStale;
          Neighbor->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
        }
      }
 
      //
      // When IsRouter is changed from TRUE to FALSE, remove the router from the
      // Default Router List and remove the Destination Cache entries for all destinations
      // using the neighbor as a router.
      //
      if (Neighbor->IsRouter && !IsRouter) {
        DefaultRouter = Ip6FindDefaultRouter (IpSb, &Target);
        if (DefaultRouter != NULL) {
          Ip6DestroyDefaultRouter (IpSb, DefaultRouter);
        }
      }
 
      Neighbor->IsRouter = IsRouter;
    }
  }
 
  if (Neighbor->State == EfiNeighborReachable) {
    Neighbor->CallBack ((VOID *)Neighbor);
  }
 
  Status = EFI_SUCCESS;
 
Exit:
  NetbufFree (Packet);
  return Status;
}
 
EFI_STATUS
Ip6ProcessRouterAdvertise (
  IN IP6_SERVICE     *IpSb,
  IN EFI_IP6_HEADER  *Head,
  IN NET_BUF         *Packet
  )
{
  IP6_ICMP_INFORMATION_HEAD  Icmp;
  UINT32                     ReachableTime;
  UINT32                     RetransTimer;
  UINT16                     RouterLifetime;
  UINT32                     Offset;
  UINT8                      Type;
  UINT8                      Length;
  IP6_ETHER_ADDR_OPTION      LinkLayerOption;
  UINT32                     Fourth;
  UINT8                      CurHopLimit;
  BOOLEAN                    Mflag;
  BOOLEAN                    Oflag;
  IP6_DEFAULT_ROUTER         *DefaultRouter;
  IP6_NEIGHBOR_ENTRY         *NeighborCache;
  EFI_MAC_ADDRESS            LinkLayerAddress;
  IP6_MTU_OPTION             MTUOption;
  IP6_PREFIX_INFO_OPTION     PrefixOption;
  IP6_PREFIX_LIST_ENTRY      *PrefixList;
  BOOLEAN                    OnLink;
  BOOLEAN                    Autonomous;
  EFI_IPv6_ADDRESS           StatelessAddress;
  EFI_STATUS                 Status;
  UINT16                     OptionLen;
  UINT8                      *Option;
  INTN                       Result;
 
  Status = EFI_INVALID_PARAMETER;
 
  if (IpSb->Ip6ConfigInstance.Policy != Ip6ConfigPolicyAutomatic) {
    //
    // Skip the process below as it's not required under the current policy.
    //
    goto Exit;
  }
 
  NetbufCopy (Packet, 0, sizeof (Icmp), (UINT8 *)&Icmp);
 
  //
  // Validate the incoming Router Advertisement
  //
 
  //
  // The IP source address must be a link-local address
  //
  if (!NetIp6IsLinkLocalAddr (&Head->SourceAddress)) {
    goto Exit;
  }
 
  //
  // The IP Hop Limit field has a value of 255, i.e. the packet
  // could not possibly have been forwarded by a router.
  // ICMP Code is 0.
  // ICMP length (derived from the IP length) is 16 or more octets.
  //
  if ((Head->HopLimit != IP6_HOP_LIMIT) || (Icmp.Head.Code != 0) ||
      (Head->PayloadLength < IP6_RA_LENGTH))
  {
    goto Exit;
  }
 
  //
  // All included options have a length that is greater than zero.
  //
  OptionLen = (UINT16)(Head->PayloadLength - IP6_RA_LENGTH);
  if (OptionLen != 0) {
    Option = NetbufGetByte (Packet, IP6_RA_LENGTH, NULL);
    ASSERT (Option != NULL);
 
    if (!Ip6IsNDOptionValid (Option, OptionLen)) {
      goto Exit;
    }
  }
 
  //
  // Process Fourth field.
  // In Router Advertisement, Fourth is composed of CurHopLimit (8bit), M flag, O flag,
  // and Router Lifetime (16 bit).
  //
 
  Fourth = NTOHL (Icmp.Fourth);
  CopyMem (&RouterLifetime, &Fourth, sizeof (UINT16));
 
  //
  // If the source address already in the default router list, update it.
  // Otherwise create a new entry.
  // A Lifetime of zero indicates that the router is not a default router.
  //
  DefaultRouter = Ip6FindDefaultRouter (IpSb, &Head->SourceAddress);
  if (DefaultRouter == NULL) {
    if (RouterLifetime != 0) {
      DefaultRouter = Ip6CreateDefaultRouter (IpSb, &Head->SourceAddress, RouterLifetime);
      if (DefaultRouter == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto Exit;
      }
    }
  } else {
    if (RouterLifetime != 0) {
      DefaultRouter->Lifetime = RouterLifetime;
      //
      // Check the corresponding neighbor cache entry here.
      //
      if (DefaultRouter->NeighborCache == NULL) {
        DefaultRouter->NeighborCache = Ip6FindNeighborEntry (IpSb, &Head->SourceAddress);
      }
    } else {
      //
      // If the address is in the host's default router list and the router lifetime is zero,
      // immediately time-out the entry.
      //
      Ip6DestroyDefaultRouter (IpSb, DefaultRouter);
    }
  }
 
  CurHopLimit = *((UINT8 *)&Fourth + 3);
  if (CurHopLimit != 0) {
    IpSb->CurHopLimit = CurHopLimit;
  }
 
  Mflag = FALSE;
  Oflag = FALSE;
  if ((*((UINT8 *)&Fourth + 2) & IP6_M_ADDR_CONFIG_FLAG) == IP6_M_ADDR_CONFIG_FLAG) {
    Mflag = TRUE;
  } else {
    if ((*((UINT8 *)&Fourth + 2) & IP6_O_CONFIG_FLAG) == IP6_O_CONFIG_FLAG) {
      Oflag = TRUE;
    }
  }
 
  if (Mflag || Oflag) {
    //
    // Use Ip6Config to get available addresses or other configuration from DHCP.
    //
    Ip6ConfigStartStatefulAutoConfig (&IpSb->Ip6ConfigInstance, Oflag);
  }
 
  //
  // Process Reachable Time and Retrans Timer fields.
  //
  NetbufCopy (Packet, sizeof (Icmp), sizeof (UINT32), (UINT8 *)&ReachableTime);
  NetbufCopy (Packet, sizeof (Icmp) + sizeof (UINT32), sizeof (UINT32), (UINT8 *)&RetransTimer);
  ReachableTime = NTOHL (ReachableTime);
  RetransTimer  = NTOHL (RetransTimer);
 
  if ((ReachableTime != 0) && (ReachableTime != IpSb->BaseReachableTime)) {
    //
    // If new value is not unspecified and differs from the previous one, record it
    // in BaseReachableTime and recompute a ReachableTime.
    //
    IpSb->BaseReachableTime = ReachableTime;
    Status                  = Ip6UpdateReachableTime (IpSb);
    if (EFI_ERROR (Status)) {
      goto Exit;
    }
  }
 
  if (RetransTimer != 0) {
    IpSb->RetransTimer = RetransTimer;
  }
 
  //
  // IsRouter flag must be set to TRUE if corresponding neighbor cache entry exists.
  //
  NeighborCache = Ip6FindNeighborEntry (IpSb, &Head->SourceAddress);
  if (NeighborCache != NULL) {
    NeighborCache->IsRouter = TRUE;
  }
 
  //
  // If an valid router advertisement is received, stops router solicitation.
  //
  IpSb->RouterAdvertiseReceived = TRUE;
 
  //
  // The only defined options that may appear are the Source
  // Link-Layer Address, Prefix information and MTU options.
  // All included options have a length that is greater than zero and
  // fit within the input packet.
  //
  Offset = 16;
  while (Offset < (UINT32)Head->PayloadLength) {
    NetbufCopy (Packet, Offset, sizeof (UINT8), &Type);
    switch (Type) {
      case Ip6OptionEtherSource:
        //
        // Update the neighbor cache
        //
        NetbufCopy (Packet, Offset, sizeof (IP6_ETHER_ADDR_OPTION), (UINT8 *)&LinkLayerOption);
 
        //
        // Option size validity ensured by Ip6IsNDOptionValid().
        //
        ASSERT (LinkLayerOption.Length != 0);
        ASSERT (Offset + (UINT32)LinkLayerOption.Length * 8 <= (UINT32)Head->PayloadLength);
 
        ZeroMem (&LinkLayerAddress, sizeof (EFI_MAC_ADDRESS));
        CopyMem (&LinkLayerAddress, LinkLayerOption.EtherAddr, 6);
 
        if (NeighborCache == NULL) {
          NeighborCache = Ip6CreateNeighborEntry (
                            IpSb,
                            Ip6OnArpResolved,
                            &Head->SourceAddress,
                            &LinkLayerAddress
                            );
          if (NeighborCache == NULL) {
            Status = EFI_OUT_OF_RESOURCES;
            goto Exit;
          }
 
          NeighborCache->IsRouter = TRUE;
          NeighborCache->State    = EfiNeighborStale;
          NeighborCache->Ticks    = (UINT32)IP6_INFINIT_LIFETIME;
        } else {
          Result = CompareMem (&LinkLayerAddress, &NeighborCache->LinkAddress, 6);
 
          //
          // If the link-local address is the same as that already in the cache,
          // the cache entry's state remains unchanged. Otherwise update the
          // reachability state to STALE.
          //
          if ((NeighborCache->State == EfiNeighborInComplete) || (Result != 0)) {
            CopyMem (&NeighborCache->LinkAddress, &LinkLayerAddress, 6);
 
            NeighborCache->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
 
            if (NeighborCache->State == EfiNeighborInComplete) {
              //
              // Send queued packets if exist.
              //
              NeighborCache->State = EfiNeighborStale;
              NeighborCache->CallBack ((VOID *)NeighborCache);
            } else {
              NeighborCache->State = EfiNeighborStale;
            }
          }
        }
 
        Offset += (UINT32)LinkLayerOption.Length * 8;
        break;
      case Ip6OptionPrefixInfo:
        NetbufCopy (Packet, Offset, sizeof (IP6_PREFIX_INFO_OPTION), (UINT8 *)&PrefixOption);
 
        //
        // Option size validity ensured by Ip6IsNDOptionValid().
        //
        ASSERT (PrefixOption.Length == 4);
        ASSERT (Offset + (UINT32)PrefixOption.Length * 8 <= (UINT32)Head->PayloadLength);
 
        PrefixOption.ValidLifetime     = NTOHL (PrefixOption.ValidLifetime);
        PrefixOption.PreferredLifetime = NTOHL (PrefixOption.PreferredLifetime);
 
        //
        // Get L and A flag, recorded in the lower 2 bits of Reserved1
        //
        OnLink = FALSE;
        if ((PrefixOption.Reserved1 & IP6_ON_LINK_FLAG) == IP6_ON_LINK_FLAG) {
          OnLink = TRUE;
        }
 
        Autonomous = FALSE;
        if ((PrefixOption.Reserved1 & IP6_AUTO_CONFIG_FLAG) == IP6_AUTO_CONFIG_FLAG) {
          Autonomous = TRUE;
        }
 
        //
        // If the prefix is the link-local prefix, silently ignore the prefix option.
        //
        if ((PrefixOption.PrefixLength == IP6_LINK_LOCAL_PREFIX_LENGTH) &&
            NetIp6IsLinkLocalAddr (&PrefixOption.Prefix)
            )
        {
          Offset += sizeof (IP6_PREFIX_INFO_OPTION);
          break;
        }
 
        //
        // Do following if on-link flag is set according to RFC4861.
        //
        if (OnLink) {
          PrefixList = Ip6FindPrefixListEntry (
                         IpSb,
                         TRUE,
                         PrefixOption.PrefixLength,
                         &PrefixOption.Prefix
                         );
          //
          // Create a new entry for the prefix, if the ValidLifetime is zero,
          // silently ignore the prefix option.
          //
          if ((PrefixList == NULL) && (PrefixOption.ValidLifetime != 0)) {
            PrefixList = Ip6CreatePrefixListEntry (
                           IpSb,
                           TRUE,
                           PrefixOption.ValidLifetime,
                           PrefixOption.PreferredLifetime,
                           PrefixOption.PrefixLength,
                           &PrefixOption.Prefix
                           );
            if (PrefixList == NULL) {
              Status = EFI_OUT_OF_RESOURCES;
              goto Exit;
            }
          } else if (PrefixList != NULL) {
            if (PrefixOption.ValidLifetime != 0) {
              PrefixList->ValidLifetime = PrefixOption.ValidLifetime;
            } else {
              //
              // If the prefix exists and incoming ValidLifetime is zero, immediately
              // remove the prefix.
              Ip6DestroyPrefixListEntry (IpSb, PrefixList, OnLink, TRUE);
            }
          }
        }
 
        //
        // Do following if Autonomous flag is set according to RFC4862.
        //
        if (Autonomous && (PrefixOption.PreferredLifetime <= PrefixOption.ValidLifetime)) {
          PrefixList = Ip6FindPrefixListEntry (
                         IpSb,
                         FALSE,
                         PrefixOption.PrefixLength,
                         &PrefixOption.Prefix
                         );
          //
          // Create a new entry for the prefix, and form an address by prefix + interface id
          // If the sum of the prefix length and interface identifier length
          // does not equal 128 bits, the Prefix Information option MUST be ignored.
          //
          if ((PrefixList == NULL) &&
              (PrefixOption.ValidLifetime != 0) &&
              (PrefixOption.PrefixLength + IpSb->InterfaceIdLen * 8 == 128)
              )
          {
            //
            // Form the address in network order.
            //
            CopyMem (&StatelessAddress, &PrefixOption.Prefix, sizeof (UINT64));
            CopyMem (&StatelessAddress.Addr[8], IpSb->InterfaceId, sizeof (UINT64));
 
            //
            // If the address is not yet in the assigned address list, adds it into.
            //
            if (!Ip6IsOneOfSetAddress (IpSb, &StatelessAddress, NULL, NULL)) {
              //
              // And also not in the DAD process, check its uniqueness firstly.
              //
              if (Ip6FindDADEntry (IpSb, &StatelessAddress, NULL) == NULL) {
                Status = Ip6SetAddress (
                           IpSb->DefaultInterface,
                           &StatelessAddress,
                           FALSE,
                           PrefixOption.PrefixLength,
                           PrefixOption.ValidLifetime,
                           PrefixOption.PreferredLifetime,
                           NULL,
                           NULL
                           );
                if (EFI_ERROR (Status)) {
                  goto Exit;
                }
              }
            }
 
            //
            // Adds the prefix option to stateless prefix option list.
            //
            PrefixList = Ip6CreatePrefixListEntry (
                           IpSb,
                           FALSE,
                           PrefixOption.ValidLifetime,
                           PrefixOption.PreferredLifetime,
                           PrefixOption.PrefixLength,
                           &PrefixOption.Prefix
                           );
            if (PrefixList == NULL) {
              Status = EFI_OUT_OF_RESOURCES;
              goto Exit;
            }
          } else if (PrefixList != NULL) {
            //
            // Reset the preferred lifetime of the address if the advertised prefix exists.
            // Perform specific action to valid lifetime together.
            //
            PrefixList->PreferredLifetime = PrefixOption.PreferredLifetime;
            if ((PrefixOption.ValidLifetime > 7200) ||
                (PrefixOption.ValidLifetime > PrefixList->ValidLifetime))
            {
              //
              // If the received Valid Lifetime is greater than 2 hours or
              // greater than RemainingLifetime, set the valid lifetime of the
              // corresponding address to the advertised Valid Lifetime.
              //
              PrefixList->ValidLifetime = PrefixOption.ValidLifetime;
            } else if (PrefixList->ValidLifetime <= 7200) {
              //
              // If RemainingLifetime is less than or equals to 2 hours, ignore the
              // Prefix Information option with regards to the valid lifetime.
              // TODO: If this option has been authenticated, set the valid lifetime.
              //
            } else {
              //
              // Otherwise, reset the valid lifetime of the corresponding
              // address to 2 hours.
              //
              PrefixList->ValidLifetime = 7200;
            }
          }
        }
 
        Offset += sizeof (IP6_PREFIX_INFO_OPTION);
        break;
      case Ip6OptionMtu:
        NetbufCopy (Packet, Offset, sizeof (IP6_MTU_OPTION), (UINT8 *)&MTUOption);
 
        //
        // Option size validity ensured by Ip6IsNDOptionValid().
        //
        ASSERT (MTUOption.Length == 1);
        ASSERT (Offset + (UINT32)MTUOption.Length * 8 <= (UINT32)Head->PayloadLength);
 
        //
        // Use IPv6 minimum link MTU 1280 bytes as the maximum packet size in order
        // to omit implementation of Path MTU Discovery. Thus ignore the MTU option
        // in Router Advertisement.
        //
 
        Offset += sizeof (IP6_MTU_OPTION);
        break;
      default:
        //
        // Silently ignore unrecognized options
        //
        NetbufCopy (Packet, Offset + sizeof (UINT8), sizeof (UINT8), &Length);
 
        ASSERT (Length != 0);
 
        Offset += (UINT32)Length * 8;
        break;
    }
  }
 
  Status = EFI_SUCCESS;
 
Exit:
  NetbufFree (Packet);
  return Status;
}
 
EFI_STATUS
Ip6ProcessRedirect (
  IN IP6_SERVICE     *IpSb,
  IN EFI_IP6_HEADER  *Head,
  IN NET_BUF         *Packet
  )
{
  IP6_ICMP_INFORMATION_HEAD  *Icmp;
  EFI_IPv6_ADDRESS           *Target;
  EFI_IPv6_ADDRESS           *IcmpDest;
  UINT8                      *Option;
  UINT16                     OptionLen;
  IP6_ROUTE_ENTRY            *RouteEntry;
  IP6_ROUTE_CACHE_ENTRY      *RouteCache;
  IP6_NEIGHBOR_ENTRY         *NeighborCache;
  INT32                      Length;
  UINT8                      OptLen;
  IP6_ETHER_ADDR_OPTION      *LinkLayerOption;
  EFI_MAC_ADDRESS            Mac;
  UINT32                     Index;
  BOOLEAN                    IsRouter;
  EFI_STATUS                 Status;
  INTN                       Result;
 
  Status = EFI_INVALID_PARAMETER;
 
  Icmp = (IP6_ICMP_INFORMATION_HEAD *)NetbufGetByte (Packet, 0, NULL);
  if (Icmp == NULL) {
    goto Exit;
  }
 
  //
  // Validate the incoming Redirect message
  //
 
  //
  // The IP Hop Limit field has a value of 255, i.e. the packet
  // could not possibly have been forwarded by a router.
  // ICMP Code is 0.
  // ICMP length (derived from the IP length) is 40 or more octets.
  //
  if ((Head->HopLimit != IP6_HOP_LIMIT) || (Icmp->Head.Code != 0) ||
      (Head->PayloadLength < IP6_REDITECT_LENGTH))
  {
    goto Exit;
  }
 
  //
  // The IP source address must be a link-local address
  //
  if (!NetIp6IsLinkLocalAddr (&Head->SourceAddress)) {
    goto Exit;
  }
 
  //
  // The dest of this ICMP redirect message is not us.
  //
  if (!Ip6IsOneOfSetAddress (IpSb, &Head->DestinationAddress, NULL, NULL)) {
    goto Exit;
  }
 
  //
  // All included options have a length that is greater than zero.
  //
  OptionLen = (UINT16)(Head->PayloadLength - IP6_REDITECT_LENGTH);
  if (OptionLen != 0) {
    Option = NetbufGetByte (Packet, IP6_REDITECT_LENGTH, NULL);
    ASSERT (Option != NULL);
 
    if (!Ip6IsNDOptionValid (Option, OptionLen)) {
      goto Exit;
    }
  }
 
  Target   = (EFI_IPv6_ADDRESS *)(Icmp + 1);
  IcmpDest = Target + 1;
 
  //
  // The ICMP Destination Address field in the redirect message does not contain
  // a multicast address.
  //
  if (IP6_IS_MULTICAST (IcmpDest)) {
    goto Exit;
  }
 
  //
  // The ICMP Target Address is either a link-local address (when redirected to
  // a router) or the same as the ICMP Destination Address (when redirected to
  // the on-link destination).
  //
  IsRouter = (BOOLEAN) !EFI_IP6_EQUAL (Target, IcmpDest);
  if (!NetIp6IsLinkLocalAddr (Target) && IsRouter) {
    goto Exit;
  }
 
  //
  // Check the options. The only interested option here is the target-link layer
  // address option.
  //
  Length          = Packet->TotalSize - 40;
  Option          = (UINT8 *)(IcmpDest + 1);
  LinkLayerOption = NULL;
  while (Length > 0) {
    switch (*Option) {
      case Ip6OptionEtherTarget:
 
        LinkLayerOption = (IP6_ETHER_ADDR_OPTION *)Option;
        OptLen          = LinkLayerOption->Length;
        if (OptLen != 1) {
          //
          // For ethernet, the length must be 1.
          //
          goto Exit;
        }
 
        break;
 
      default:
 
        OptLen = *(Option + 1);
        if (OptLen == 0) {
          //
          // A length of 0 is invalid.
          //
          goto Exit;
        }
 
        break;
    }
 
    Length -= 8 * OptLen;
    Option += 8 * OptLen;
  }
 
  if (Length != 0) {
    goto Exit;
  }
 
  //
  // The IP source address of the Redirect is the same as the current
  // first-hop router for the specified ICMP Destination Address.
  //
  RouteCache = Ip6FindRouteCache (IpSb->RouteTable, IcmpDest, &Head->DestinationAddress);
  if (RouteCache != NULL) {
    if (!EFI_IP6_EQUAL (&RouteCache->NextHop, &Head->SourceAddress)) {
      //
      // The source of this Redirect message must match the NextHop of the
      // corresponding route cache entry.
      //
      goto Exit;
    }
 
    //
    // Update the NextHop.
    //
    IP6_COPY_ADDRESS (&RouteCache->NextHop, Target);
 
    if (!IsRouter) {
      RouteEntry       = (IP6_ROUTE_ENTRY *)RouteCache->Tag;
      RouteEntry->Flag = RouteEntry->Flag | IP6_DIRECT_ROUTE;
    }
  } else {
    //
    // Get the Route Entry.
    //
    RouteEntry = Ip6FindRouteEntry (IpSb->RouteTable, IcmpDest, NULL);
    if (RouteEntry == NULL) {
      RouteEntry = Ip6CreateRouteEntry (IcmpDest, 0, NULL);
      if (RouteEntry == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto Exit;
      }
    }
 
    if (!IsRouter) {
      RouteEntry->Flag = IP6_DIRECT_ROUTE;
    }
 
    //
    // Create a route cache for this.
    //
    RouteCache = Ip6CreateRouteCacheEntry (
                   IcmpDest,
                   &Head->DestinationAddress,
                   Target,
                   (UINTN)RouteEntry
                   );
    if (RouteCache == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto Exit;
    }
 
    //
    // Insert the newly created route cache entry.
    //
    Index = IP6_ROUTE_CACHE_HASH (IcmpDest, &Head->DestinationAddress);
    InsertHeadList (&IpSb->RouteTable->Cache.CacheBucket[Index], &RouteCache->Link);
  }
 
  //
  // Try to locate the neighbor cache for the Target.
  //
  NeighborCache = Ip6FindNeighborEntry (IpSb, Target);
 
  if (LinkLayerOption != NULL) {
    if (NeighborCache == NULL) {
      //
      // Create a neighbor cache for the Target.
      //
      ZeroMem (&Mac, sizeof (EFI_MAC_ADDRESS));
      CopyMem (&Mac, LinkLayerOption->EtherAddr, 6);
      NeighborCache = Ip6CreateNeighborEntry (IpSb, Ip6OnArpResolved, Target, &Mac);
      if (NeighborCache == NULL) {
        //
        // Just report a success here. The neighbor cache can be created in
        // some other place.
        //
        Status = EFI_SUCCESS;
        goto Exit;
      }
 
      NeighborCache->State = EfiNeighborStale;
      NeighborCache->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
    } else {
      Result = CompareMem (LinkLayerOption->EtherAddr, &NeighborCache->LinkAddress, 6);
 
      //
      // If the link-local address is the same as that already in the cache,
      // the cache entry's state remains unchanged. Otherwise update the
      // reachability state to STALE.
      //
      if ((NeighborCache->State == EfiNeighborInComplete) || (Result != 0)) {
        CopyMem (&NeighborCache->LinkAddress, LinkLayerOption->EtherAddr, 6);
 
        NeighborCache->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
 
        if (NeighborCache->State == EfiNeighborInComplete) {
          //
          // Send queued packets if exist.
          //
          NeighborCache->State = EfiNeighborStale;
          NeighborCache->CallBack ((VOID *)NeighborCache);
        } else {
          NeighborCache->State = EfiNeighborStale;
        }
      }
    }
  }
 
  if ((NeighborCache != NULL) && IsRouter) {
    //
    // The Target is a router, set IsRouter to TRUE.
    //
    NeighborCache->IsRouter = TRUE;
  }
 
  Status = EFI_SUCCESS;
 
Exit:
  NetbufFree (Packet);
  return Status;
}
 
EFI_STATUS
Ip6AddNeighbor (
  IN IP6_SERVICE       *IpSb,
  IN EFI_IPv6_ADDRESS  *TargetIp6Address,
  IN EFI_MAC_ADDRESS   *TargetLinkAddress OPTIONAL,
  IN UINT32            Timeout,
  IN BOOLEAN           Override
  )
{
  IP6_NEIGHBOR_ENTRY  *Neighbor;
 
  Neighbor = Ip6FindNeighborEntry (IpSb, TargetIp6Address);
  if (Neighbor != NULL) {
    if (!Override) {
      return EFI_ACCESS_DENIED;
    } else {
      if (TargetLinkAddress != NULL) {
        IP6_COPY_LINK_ADDRESS (&Neighbor->LinkAddress, TargetLinkAddress);
      }
    }
  } else {
    if (TargetLinkAddress == NULL) {
      return EFI_NOT_FOUND;
    }
 
    Neighbor = Ip6CreateNeighborEntry (IpSb, Ip6OnArpResolved, TargetIp6Address, TargetLinkAddress);
    if (Neighbor == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
  }
 
  Neighbor->State = EfiNeighborReachable;
 
  if (Timeout != 0) {
    Neighbor->Ticks   = IP6_GET_TICKS (Timeout / TICKS_PER_MS);
    Neighbor->Dynamic = TRUE;
  } else {
    Neighbor->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
Ip6DelNeighbor (
  IN IP6_SERVICE       *IpSb,
  IN EFI_IPv6_ADDRESS  *TargetIp6Address,
  IN EFI_MAC_ADDRESS   *TargetLinkAddress OPTIONAL,
  IN UINT32            Timeout,
  IN BOOLEAN           Override
  )
{
  IP6_NEIGHBOR_ENTRY  *Neighbor;
 
  Neighbor = Ip6FindNeighborEntry (IpSb, TargetIp6Address);
  if (Neighbor == NULL) {
    return EFI_NOT_FOUND;
  }
 
  RemoveEntryList (&Neighbor->Link);
  FreePool (Neighbor);
 
  return EFI_SUCCESS;
}
 
VOID
EFIAPI
Ip6NdFasterTimerTicking (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  LIST_ENTRY           *Entry;
  LIST_ENTRY           *Next;
  LIST_ENTRY           *Entry2;
  IP6_INTERFACE        *IpIf;
  IP6_DELAY_JOIN_LIST  *DelayNode;
  EFI_IPv6_ADDRESS     Source;
  IP6_DAD_ENTRY        *DupAddrDetect;
  EFI_STATUS           Status;
  IP6_NEIGHBOR_ENTRY   *NeighborCache;
  EFI_IPv6_ADDRESS     Destination;
  IP6_SERVICE          *IpSb;
  BOOLEAN              Flag;
 
  IpSb = (IP6_SERVICE *)Context;
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);
 
  ZeroMem (&Source, sizeof (EFI_IPv6_ADDRESS));
 
  //
  // A host SHOULD transmit up to MAX_RTR_SOLICITATIONS (3) Router
  // Solicitation messages, each separated by at least
  // RTR_SOLICITATION_INTERVAL (4) seconds.
  //
  if ((IpSb->Ip6ConfigInstance.Policy == Ip6ConfigPolicyAutomatic) &&
      !IpSb->RouterAdvertiseReceived &&
      (IpSb->SolicitTimer > 0)
      )
  {
    if ((IpSb->Ticks == 0) || (--IpSb->Ticks == 0)) {
      Status = Ip6SendRouterSolicit (IpSb, NULL, NULL, NULL, NULL);
      if (!EFI_ERROR (Status)) {
        IpSb->SolicitTimer--;
        IpSb->Ticks = (UINT32)IP6_GET_TICKS (IP6_RTR_SOLICITATION_INTERVAL);
      }
    }
  }
 
  NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {
    IpIf = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);
 
    //
    // Process the delay list to join the solicited-node multicast address.
    //
    NET_LIST_FOR_EACH_SAFE (Entry2, Next, &IpIf->DelayJoinList) {
      DelayNode = NET_LIST_USER_STRUCT (Entry2, IP6_DELAY_JOIN_LIST, Link);
      if ((DelayNode->DelayTime == 0) || (--DelayNode->DelayTime == 0)) {
        //
        // The timer expires, init the duplicate address detection.
        //
        Ip6InitDADProcess (
          DelayNode->Interface,
          DelayNode->AddressInfo,
          DelayNode->DadCallback,
          DelayNode->Context
          );
 
        //
        // Remove the delay node
        //
        RemoveEntryList (&DelayNode->Link);
        FreePool (DelayNode);
      }
    }
 
    //
    // Process the duplicate address detection list.
    //
    NET_LIST_FOR_EACH_SAFE (Entry2, Next, &IpIf->DupAddrDetectList) {
      DupAddrDetect = NET_LIST_USER_STRUCT (Entry2, IP6_DAD_ENTRY, Link);
 
      if ((DupAddrDetect->RetransTick == 0) || (--DupAddrDetect->RetransTick == 0)) {
        //
        // The timer expires, check the remaining transmit counts.
        //
        if (DupAddrDetect->Transmit < DupAddrDetect->MaxTransmit) {
          //
          // Send the Neighbor Solicitation message with
          // Source - unspecified address, destination - solicited-node multicast address
          // Target - the address to be validated
          //
          Status = Ip6SendNeighborSolicit (
                     IpSb,
                     NULL,
                     &DupAddrDetect->Destination,
                     &DupAddrDetect->AddressInfo->Address,
                     NULL
                     );
          if (EFI_ERROR (Status)) {
            return;
          }
 
          DupAddrDetect->Transmit++;
          DupAddrDetect->RetransTick = IP6_GET_TICKS (IpSb->RetransTimer);
        } else {
          //
          // All required solicitation has been sent out, and the RetransTime after the last
          // Neighbor Solicit is elapsed, finish the DAD process.
          //
          Flag = FALSE;
          if ((DupAddrDetect->Receive == 0) ||
              (DupAddrDetect->Transmit <= DupAddrDetect->Receive))
          {
            Flag = TRUE;
          }
 
          Ip6OnDADFinished (Flag, IpIf, DupAddrDetect);
        }
      }
    }
  }
 
  //
  // Polling the state of Neighbor cache
  //
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpSb->NeighborTable) {
    NeighborCache = NET_LIST_USER_STRUCT (Entry, IP6_NEIGHBOR_ENTRY, Link);
 
    switch (NeighborCache->State) {
      case EfiNeighborInComplete:
        if (NeighborCache->Ticks > 0) {
          --NeighborCache->Ticks;
        }
 
        //
        // Retransmit Neighbor Solicitation messages approximately every
        // RetransTimer milliseconds while awaiting a response.
        //
        if (NeighborCache->Ticks == 0) {
          if (NeighborCache->Transmit > 1) {
            //
            // Send out multicast neighbor solicitation for address resolution.
            // After last neighbor solicitation message has been sent out, wait
            // for RetransTimer and then remove entry if no response is received.
            //
            Ip6CreateSNMulticastAddr (&NeighborCache->Neighbor, &Destination);
            Status = Ip6SelectSourceAddress (IpSb, &NeighborCache->Neighbor, &Source);
            if (EFI_ERROR (Status)) {
              return;
            }
 
            Status = Ip6SendNeighborSolicit (
                       IpSb,
                       &Source,
                       &Destination,
                       &NeighborCache->Neighbor,
                       &IpSb->SnpMode.CurrentAddress
                       );
            if (EFI_ERROR (Status)) {
              return;
            }
          }
 
          //
          // Update the retransmit times.
          //
          if (NeighborCache->Transmit > 0) {
            --NeighborCache->Transmit;
            NeighborCache->Ticks = IP6_GET_TICKS (IpSb->RetransTimer);
          }
        }
 
        if (NeighborCache->Transmit == 0) {
          //
          // Timeout, send ICMP destination unreachable packet and then remove entry
          //
          Status = Ip6FreeNeighborEntry (
                     IpSb,
                     NeighborCache,
                     TRUE,
                     TRUE,
                     EFI_ICMP_ERROR,
                     NULL,
                     NULL
                     );
          if (EFI_ERROR (Status)) {
            return;
          }
        }
 
        break;
 
      case EfiNeighborReachable:
        //
        // This entry is inserted by EfiIp6Neighbors() as static entry
        // and will not timeout.
        //
        if (!NeighborCache->Dynamic && (NeighborCache->Ticks == IP6_INFINIT_LIFETIME)) {
          break;
        }
 
        if ((NeighborCache->Ticks == 0) || (--NeighborCache->Ticks == 0)) {
          if (NeighborCache->Dynamic) {
            //
            // This entry is inserted by EfiIp6Neighbors() as dynamic entry
            // and will be deleted after timeout.
            //
            Status = Ip6FreeNeighborEntry (
                       IpSb,
                       NeighborCache,
                       FALSE,
                       TRUE,
                       EFI_TIMEOUT,
                       NULL,
                       NULL
                       );
            if (EFI_ERROR (Status)) {
              return;
            }
          } else {
            NeighborCache->State = EfiNeighborStale;
            NeighborCache->Ticks = (UINT32)IP6_INFINIT_LIFETIME;
          }
        }
 
        break;
 
      case EfiNeighborDelay:
        if ((NeighborCache->Ticks == 0) || (--NeighborCache->Ticks == 0)) {
          NeighborCache->State    = EfiNeighborProbe;
          NeighborCache->Ticks    = IP6_GET_TICKS (IpSb->RetransTimer);
          NeighborCache->Transmit = IP6_MAX_UNICAST_SOLICIT + 1;
          //
          // Send out unicast neighbor solicitation for Neighbor Unreachability Detection
          //
          Status = Ip6SelectSourceAddress (IpSb, &NeighborCache->Neighbor, &Source);
          if (EFI_ERROR (Status)) {
            return;
          }
 
          Status = Ip6SendNeighborSolicit (
                     IpSb,
                     &Source,
                     &NeighborCache->Neighbor,
                     &NeighborCache->Neighbor,
                     &IpSb->SnpMode.CurrentAddress
                     );
          if (EFI_ERROR (Status)) {
            return;
          }
 
          NeighborCache->Transmit--;
        }
 
        break;
 
      case EfiNeighborProbe:
        if (NeighborCache->Ticks > 0) {
          --NeighborCache->Ticks;
        }
 
        //
        // Retransmit Neighbor Solicitation messages approximately every
        // RetransTimer milliseconds while awaiting a response.
        //
        if (NeighborCache->Ticks == 0) {
          if (NeighborCache->Transmit > 1) {
            //
            // Send out unicast neighbor solicitation for Neighbor Unreachability
            // Detection. After last neighbor solicitation message has been sent out,
            // wait for RetransTimer and then remove entry if no response is received.
            //
            Status = Ip6SelectSourceAddress (IpSb, &NeighborCache->Neighbor, &Source);
            if (EFI_ERROR (Status)) {
              return;
            }
 
            Status = Ip6SendNeighborSolicit (
                       IpSb,
                       &Source,
                       &NeighborCache->Neighbor,
                       &NeighborCache->Neighbor,
                       &IpSb->SnpMode.CurrentAddress
                       );
            if (EFI_ERROR (Status)) {
              return;
            }
          }
 
          //
          // Update the retransmit times.
          //
          if (NeighborCache->Transmit > 0) {
            --NeighborCache->Transmit;
            NeighborCache->Ticks = IP6_GET_TICKS (IpSb->RetransTimer);
          }
        }
 
        if (NeighborCache->Transmit == 0) {
          //
          // Delete the neighbor entry.
          //
          Status = Ip6FreeNeighborEntry (
                     IpSb,
                     NeighborCache,
                     FALSE,
                     TRUE,
                     EFI_TIMEOUT,
                     NULL,
                     NULL
                     );
          if (EFI_ERROR (Status)) {
            return;
          }
        }
 
        break;
 
      default:
        break;
    }
  }
}
 
VOID
Ip6NdTimerTicking (
  IN IP6_SERVICE  *IpSb
  )
{
  LIST_ENTRY             *Entry;
  LIST_ENTRY             *Next;
  IP6_DEFAULT_ROUTER     *DefaultRouter;
  IP6_PREFIX_LIST_ENTRY  *PrefixOption;
  UINT8                  Index;
  IP6_ROUTE_CACHE_ENTRY  *RouteCache;
 
  //
  // Decrease the lifetime of default router, if expires remove it from default router list.
  //
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpSb->DefaultRouterList) {
    DefaultRouter = NET_LIST_USER_STRUCT (Entry, IP6_DEFAULT_ROUTER, Link);
    if (DefaultRouter->Lifetime != IP6_INF_ROUTER_LIFETIME) {
      if ((DefaultRouter->Lifetime == 0) || (--DefaultRouter->Lifetime == 0)) {
        Ip6DestroyDefaultRouter (IpSb, DefaultRouter);
      }
    }
  }
 
  //
  // Decrease Valid lifetime and Preferred lifetime of Prefix options and corresponding addresses.
  //
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpSb->AutonomousPrefix) {
    PrefixOption = NET_LIST_USER_STRUCT (Entry, IP6_PREFIX_LIST_ENTRY, Link);
    if (PrefixOption->ValidLifetime != (UINT32)IP6_INFINIT_LIFETIME) {
      if ((PrefixOption->ValidLifetime > 0) && (--PrefixOption->ValidLifetime > 0)) {
        if ((PrefixOption->PreferredLifetime != (UINT32)IP6_INFINIT_LIFETIME) &&
            (PrefixOption->PreferredLifetime > 0)
            )
        {
          --PrefixOption->PreferredLifetime;
        }
      } else {
        Ip6DestroyPrefixListEntry (IpSb, PrefixOption, FALSE, TRUE);
      }
    }
  }
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &IpSb->OnlinkPrefix) {
    PrefixOption = NET_LIST_USER_STRUCT (Entry, IP6_PREFIX_LIST_ENTRY, Link);
    if (PrefixOption->ValidLifetime != (UINT32)IP6_INFINIT_LIFETIME) {
      if ((PrefixOption->ValidLifetime == 0) || (--PrefixOption->ValidLifetime == 0)) {
        Ip6DestroyPrefixListEntry (IpSb, PrefixOption, TRUE, TRUE);
      }
    }
  }
 
  //
  // Each bucket of route cache can contain at most IP6_ROUTE_CACHE_MAX entries.
  // Remove the entries at the tail of the bucket. These entries
  // are likely to be used least.
  // Reclaim frequency is set to 1 second.
  //
  for (Index = 0; Index < IP6_ROUTE_CACHE_HASH_SIZE; Index++) {
    while (IpSb->RouteTable->Cache.CacheNum[Index] > IP6_ROUTE_CACHE_MAX) {
      Entry = NetListRemoveTail (&IpSb->RouteTable->Cache.CacheBucket[Index]);
      if (Entry == NULL) {
        break;
      }
 
      RouteCache = NET_LIST_USER_STRUCT (Entry, IP6_ROUTE_CACHE_ENTRY, Link);
      Ip6FreeRouteCacheEntry (RouteCache);
      ASSERT (IpSb->RouteTable->Cache.CacheNum[Index] > 0);
      IpSb->RouteTable->Cache.CacheNum[Index]--;
    }
  }
}