[mirror_edk2.git] / NetworkPkg / Ip6Dxe / Ip6Output.c

/** @file\r
  The internal functions and routines to transmit the IP6 packet.\r
\r
  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "Ip6Impl.h"\r
\r
UINT32 mIp6Id;\r
\r
/**\r
  Output all the available source addresses to a list entry head SourceList. The\r
  number of source addresses are also returned.\r
\r
  @param[in]       IpSb             Points to an IP6 service binding instance.\r
  @param[out]      SourceList       The list entry head of all source addresses.\r
                                    It is the caller's responsibility to free the\r
                                    resources.\r
  @param[out]      SourceCount      The number of source addresses.\r
\r
  @retval EFI_SUCCESS           The source addresses were copied to a list entry head\r
                                SourceList.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to allocate resources to complete the operation.\r
\r
**/\r
EFI_STATUS\r
Ip6CandidateSource (\r
  IN IP6_SERVICE            *IpSb,\r
  OUT LIST_ENTRY            *SourceList,\r
  OUT UINT32                *SourceCount\r
  )\r
{\r
  IP6_INTERFACE             *IpIf;\r
  LIST_ENTRY                *Entry;\r
  LIST_ENTRY                *Entry2;\r
  IP6_ADDRESS_INFO          *AddrInfo;\r
  IP6_ADDRESS_INFO          *Copy;\r
\r
  *SourceCount = 0;\r
\r
  if (IpSb->LinkLocalOk) {\r
    Copy = AllocatePool (sizeof (IP6_ADDRESS_INFO));\r
    if (Copy == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Copy->Signature         = IP6_ADDR_INFO_SIGNATURE;\r
    IP6_COPY_ADDRESS (&Copy->Address, &IpSb->LinkLocalAddr);\r
    Copy->IsAnycast         = FALSE;\r
    Copy->PrefixLength      = IP6_LINK_LOCAL_PREFIX_LENGTH;\r
    Copy->ValidLifetime     = (UINT32) IP6_INFINIT_LIFETIME;\r
    Copy->PreferredLifetime = (UINT32) IP6_INFINIT_LIFETIME;\r
\r
    InsertTailList (SourceList, &Copy->Link);\r
    (*SourceCount)++;\r
  }\r
\r
  NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) {\r
    IpIf = NET_LIST_USER_STRUCT (Entry, IP6_INTERFACE, Link);\r
\r
    NET_LIST_FOR_EACH (Entry2, &IpIf->AddressList) {\r
      AddrInfo = NET_LIST_USER_STRUCT_S (Entry2, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);\r
\r
      if (AddrInfo->IsAnycast) {\r
        //\r
        // Never use an anycast address.\r
        //\r
        continue;\r
      }\r
\r
      Copy = AllocateCopyPool (sizeof (IP6_ADDRESS_INFO), AddrInfo);\r
      if (Copy == NULL) {\r
        return EFI_OUT_OF_RESOURCES;\r
      }\r
\r
      InsertTailList (SourceList, &Copy->Link);\r
      (*SourceCount)++;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Calculate how many bits are the same between two IPv6 addresses.\r
\r
  @param[in]       AddressA         Points to an IPv6 address.\r
  @param[in]       AddressB         Points to another IPv6 address.\r
\r
  @return The common bits of the AddressA and AddressB.\r
\r
**/\r
UINT8\r
Ip6CommonPrefixLen (\r
  IN EFI_IPv6_ADDRESS       *AddressA,\r
  IN EFI_IPv6_ADDRESS       *AddressB\r
  )\r
{\r
  UINT8                     Count;\r
  UINT8                     Index;\r
  UINT8                     ByteA;\r
  UINT8                     ByteB;\r
  UINT8                     NumBits;\r
\r
  Count = 0;\r
  Index = 0;\r
\r
  while (Index < 16) {\r
    ByteA = AddressA->Addr[Index];\r
    ByteB = AddressB->Addr[Index];\r
\r
    if (ByteA == ByteB) {\r
      Count += 8;\r
      Index++;\r
      continue;\r
    }\r
\r
    //\r
    // Check how many bits are common between the two bytes.\r
    //\r
    NumBits = 8;\r
    ByteA   = (UINT8) (ByteA ^ ByteB);\r
\r
    while (ByteA != 0) {\r
      NumBits--;\r
      ByteA = (UINT8) (ByteA >> 1);\r
    }\r
\r
    return (UINT8) (Count + NumBits);\r
  }\r
\r
  return Count;\r
}\r
\r
/**\r
  Output all the available source addresses to a list entry head SourceList. The\r
  number of source addresses are also returned.\r
\r
  @param[in]       IpSb             Points to a IP6 service binding instance.\r
  @param[in]       Destination      The IPv6 destination address.\r
  @param[out]      Source           The selected IPv6 source address according to\r
                                    the Destination.\r
\r
  @retval EFI_SUCCESS           The source addresses were copied to a list entry\r
                                head SourceList.\r
  @retval EFI_NO_MAPPING        The IPv6 stack is not auto configured.\r
\r
**/\r
EFI_STATUS\r
Ip6SelectSourceAddress (\r
  IN IP6_SERVICE            *IpSb,\r
  IN EFI_IPv6_ADDRESS       *Destination,\r
  OUT EFI_IPv6_ADDRESS      *Source\r
  )\r
{\r
  EFI_STATUS                Status;\r
  LIST_ENTRY                SourceList;\r
  UINT32                    SourceCount;\r
  UINT8                     ScopeD;\r
  LIST_ENTRY                *Entry;\r
  IP6_ADDRESS_INFO          *AddrInfo;\r
  IP6_PREFIX_LIST_ENTRY     *Prefix;\r
  UINT8                     LastCommonLength;\r
  UINT8                     CurrentCommonLength;\r
  EFI_IPv6_ADDRESS          *TmpAddress;\r
\r
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
\r
  Status = EFI_SUCCESS;\r
  InitializeListHead (&SourceList);\r
\r
  if (!IpSb->LinkLocalOk) {\r
    return EFI_NO_MAPPING;\r
  }\r
\r
  //\r
  // Rule 1: Prefer same address.\r
  //\r
  if (Ip6IsOneOfSetAddress (IpSb, Destination, NULL, NULL)) {\r
    IP6_COPY_ADDRESS (Source, Destination);\r
    goto Exit;\r
  }\r
\r
  //\r
  // Rule 2: Prefer appropriate scope.\r
  //\r
  if (IP6_IS_MULTICAST (Destination)) {\r
    ScopeD = (UINT8) (Destination->Addr[1] >> 4);\r
  } else if (NetIp6IsLinkLocalAddr (Destination)) {\r
    ScopeD = 0x2;\r
  } else {\r
    ScopeD = 0xE;\r
  }\r
\r
  if (ScopeD <= 0x2) {\r
    //\r
    // Return the link-local address if it exists\r
    // One IP6_SERVICE only has one link-local address.\r
    //\r
    IP6_COPY_ADDRESS (Source, &IpSb->LinkLocalAddr);\r
    goto Exit;\r
  }\r
\r
  //\r
  // All candidate source addresses are global unicast address.\r
  //\r
  Ip6CandidateSource (IpSb, &SourceList, &SourceCount);\r
\r
  if (SourceCount == 0) {\r
    Status = EFI_NO_MAPPING;\r
    goto Exit;\r
  }\r
\r
  IP6_COPY_ADDRESS (Source, &IpSb->LinkLocalAddr);\r
\r
  if (SourceCount == 1) {\r
    goto Exit;\r
  }\r
\r
  //\r
  // Rule 3: Avoid deprecated addresses.\r
  // TODO: check the "deprecated" state of the stateful configured address\r
  //\r
  NET_LIST_FOR_EACH (Entry, &IpSb->AutonomousPrefix) {\r
    Prefix = NET_LIST_USER_STRUCT (Entry, IP6_PREFIX_LIST_ENTRY, Link);\r
    if (Prefix->PreferredLifetime == 0) {\r
      Ip6RemoveAddr (NULL, &SourceList, &SourceCount, &Prefix->Prefix, Prefix->PrefixLength);\r
\r
      if (SourceCount == 1) {\r
        goto Exit;\r
      }\r
    }\r
  }\r
\r
  //\r
  // TODO: Rule 4: Prefer home addresses.\r
  // TODO: Rule 5: Prefer outgoing interface.\r
  // TODO: Rule 6: Prefer matching label.\r
  // TODO: Rule 7: Prefer public addresses.\r
  //\r
\r
  //\r
  // Rule 8: Use longest matching prefix.\r
  //\r
  LastCommonLength = Ip6CommonPrefixLen (Source, Destination);\r
  TmpAddress       = NULL;\r
\r
  for (Entry = SourceList.ForwardLink; Entry != &SourceList; Entry = Entry->ForwardLink) {\r
    AddrInfo = NET_LIST_USER_STRUCT_S (Entry, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE);\r
\r
    CurrentCommonLength = Ip6CommonPrefixLen (&AddrInfo->Address, Destination);\r
    if (CurrentCommonLength > LastCommonLength) {\r
      LastCommonLength = CurrentCommonLength;\r
      TmpAddress       = &AddrInfo->Address;\r
    }\r
  }\r
\r
  if (TmpAddress != NULL) {\r
    IP6_COPY_ADDRESS (Source, TmpAddress);\r
  }\r
\r
Exit:\r
\r
  Ip6RemoveAddr (NULL, &SourceList, &SourceCount, NULL, 0);\r
\r
  return Status;\r
}\r
\r
/**\r
  Select an interface to send the packet generated in the IP6 driver\r
  itself: that is, not by the requests of the IP6 child's consumer. Such\r
  packets include the ICMPv6 echo replies and other ICMPv6 error packets.\r
\r
  @param[in]  IpSb                 The IP4 service that wants to send the packets.\r
  @param[in]  Destination          The destination of the packet.\r
  @param[in, out]  Source          The source of the packet.\r
\r
  @return NULL if no proper interface is found, otherwise, the interface that\r
          can be used to send the system packet from.\r
\r
**/\r
IP6_INTERFACE *\r
Ip6SelectInterface (\r
  IN IP6_SERVICE            *IpSb,\r
  IN EFI_IPv6_ADDRESS       *Destination,\r
  IN OUT EFI_IPv6_ADDRESS   *Source\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_IPv6_ADDRESS          SelectedSource;\r
  IP6_INTERFACE             *IpIf;\r
  BOOLEAN                   Exist;\r
\r
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
  ASSERT (Destination != NULL && Source != NULL);\r
\r
  if (NetIp6IsUnspecifiedAddr (Destination)) {\r
    return NULL;\r
  }\r
\r
  if (!NetIp6IsUnspecifiedAddr (Source)) {\r
    Exist = Ip6IsOneOfSetAddress (IpSb, Source, &IpIf, NULL);\r
    ASSERT (Exist);\r
\r
    return IpIf;\r
  }\r
\r
  //\r
  // If source is unspecified, select a source according to the destination.\r
  //\r
  Status = Ip6SelectSourceAddress (IpSb, Destination, &SelectedSource);\r
  if (EFI_ERROR (Status)) {\r
    return IpSb->DefaultInterface;\r
  }\r
\r
  Ip6IsOneOfSetAddress (IpSb, &SelectedSource, &IpIf, NULL);\r
  IP6_COPY_ADDRESS (Source, &SelectedSource);\r
\r
  return IpIf;\r
}\r
\r
/**\r
  The default callback function for the system generated packet.\r
  It will free the packet.\r
\r
  @param[in]  Packet        The packet that transmitted.\r
  @param[in]  IoStatus      The result of the transmission, succeeded or failed.\r
  @param[in]  LinkFlag      Not used when transmitted. Check IP6_FRAME_CALLBACK\r
                            for reference.\r
  @param[in]  Context       The context provided by us.\r
\r
**/\r
VOID\r
Ip6SysPacketSent (\r
  NET_BUF                   *Packet,\r
  EFI_STATUS                IoStatus,\r
  UINT32                    LinkFlag,\r
  VOID                      *Context\r
  )\r
{\r
  NetbufFree (Packet);\r
  Packet = NULL;\r
}\r
\r
/**\r
  Prefix an IP6 basic head and unfragmentable extension headers and a fragment header\r
  to the Packet. Used for IP6 fragmentation.\r
\r
  @param[in]  IpSb             The IP6 service instance to transmit the packet.\r
  @param[in]  Packet           The packet to prefix the IP6 header to.\r
  @param[in]  Head             The caller supplied header.\r
  @param[in]  FragmentOffset   The fragment offset of the data following the header.\r
  @param[in]  ExtHdrs          The length of the original extension header.\r
  @param[in]  ExtHdrsLen       The length of the extension headers.\r
  @param[in]  LastHeader       The pointer of next header of last extension header.\r
  @param[in]  HeadLen          The length of the unfragmented part of the IP6 header.\r
\r
  @retval EFI_BAD_BUFFER_SIZE  There is no enough room in the head space of\r
                               Packet.\r
  @retval EFI_SUCCESS          The operation performed successfully.\r
\r
**/\r
EFI_STATUS\r
Ip6PrependHead (\r
  IN IP6_SERVICE            *IpSb,\r
  IN NET_BUF                *Packet,\r
  IN EFI_IP6_HEADER         *Head,\r
  IN UINT16                 FragmentOffset,\r
  IN UINT8                  *ExtHdrs,\r
  IN UINT32                 ExtHdrsLen,\r
  IN UINT8                  LastHeader,\r
  IN UINT32                 HeadLen\r
  )\r
{\r
  UINT32                    Len;\r
  UINT32                    UnFragExtHdrsLen;\r
  EFI_IP6_HEADER            *PacketHead;\r
  UINT8                     *UpdatedExtHdrs;\r
  EFI_STATUS                Status;\r
  UINT8                     NextHeader;\r
\r
  UpdatedExtHdrs = NULL;\r
\r
  //\r
  // HeadLen is the length of the fixed part of the sequences of fragments, i.e.\r
  // the unfragment part.\r
  //\r
  PacketHead = (EFI_IP6_HEADER *) NetbufAllocSpace (Packet, HeadLen, NET_BUF_HEAD);\r
  if (PacketHead == NULL) {\r
    return EFI_BAD_BUFFER_SIZE;\r
  }\r
\r
  //\r
  // Set the head up, convert the host byte order to network byte order\r
  //\r
  CopyMem (PacketHead, Head, sizeof (EFI_IP6_HEADER));\r
  PacketHead->PayloadLength = HTONS ((UINT16) (Packet->TotalSize - sizeof (EFI_IP6_HEADER)));\r
  Packet->Ip.Ip6            = PacketHead;\r
\r
  Len              = HeadLen - sizeof (EFI_IP6_HEADER);\r
  UnFragExtHdrsLen = Len - sizeof (IP6_FRAGMENT_HEADER);\r
\r
  if (UnFragExtHdrsLen == 0) {\r
    PacketHead->NextHeader = IP6_FRAGMENT;\r
  }\r
\r
  //\r
  // Append the extension headers: firstly copy the unfragmentable headers, then append\r
  // fragmentation header.\r
  //\r
  if ((FragmentOffset & IP6_FRAGMENT_OFFSET_MASK) == 0) {\r
    NextHeader = Head->NextHeader;\r
  } else {\r
    NextHeader = PacketHead->NextHeader;\r
  }\r
\r
  Status = Ip6FillFragmentHeader (\r
             IpSb,\r
             NextHeader,\r
             LastHeader,\r
             ExtHdrs,\r
             ExtHdrsLen,\r
             FragmentOffset,\r
             &UpdatedExtHdrs\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  CopyMem (\r
    (UINT8 *) (PacketHead + 1),\r
    UpdatedExtHdrs,\r
    UnFragExtHdrsLen + sizeof (IP6_FRAGMENT_HEADER)\r
    );\r
\r
  FreePool (UpdatedExtHdrs);\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Transmit an IP6 packet. The packet comes either from the IP6\r
  child's consumer (IpInstance != NULL) or the IP6 driver itself\r
  (IpInstance == NULL). It will route the packet, fragment it,\r
  then transmit all the fragments through an interface.\r
\r
  @param[in]  IpSb             The IP6 service instance to transmit the packet.\r
  @param[in]  Interface        The IP6 interface to transmit the packet. Ignored\r
                               if NULL.\r
  @param[in]  IpInstance       The IP6 child that issues the transmission.  It is\r
                               NULL if the packet is from the system.\r
  @param[in]  Packet           The user data to send, excluding the IP header.\r
  @param[in]  Head             The caller supplied header. The caller should set\r
                               the  following header fields: NextHeader, HopLimit,\r
                               Src, Dest, FlowLabel, PayloadLength. This function\r
                               will fill in the Ver, TrafficClass.\r
  @param[in]  ExtHdrs          The extension headers to append to the IPv6 basic\r
                               header.\r
  @param[in]  ExtHdrsLen       The length of the extension headers.\r
  @param[in]  Callback         The callback function to issue when transmission\r
                               completed.\r
  @param[in]  Context          The opaque context for the callback.\r
\r
  @retval EFI_INVALID_PARAMETER Any input parameter or the packet is invalid.\r
  @retval EFI_NO_MAPPING        There is no interface to the destination.\r
  @retval EFI_NOT_FOUND         There is no route to the destination.\r
  @retval EFI_SUCCESS           The packet successfully transmitted.\r
  @retval EFI_OUT_OF_RESOURCES  Failed to finish the operation due to lack of\r
                                resources.\r
  @retval Others                Failed to transmit the packet.\r
\r
**/\r
EFI_STATUS\r
Ip6Output (\r
  IN IP6_SERVICE            *IpSb,\r
  IN IP6_INTERFACE          *Interface   OPTIONAL,\r
  IN IP6_PROTOCOL           *IpInstance  OPTIONAL,\r
  IN NET_BUF                *Packet,\r
  IN EFI_IP6_HEADER         *Head,\r
  IN UINT8                  *ExtHdrs,\r
  IN UINT32                 ExtHdrsLen,\r
  IN IP6_FRAME_CALLBACK     Callback,\r
  IN VOID                   *Context\r
  )\r
{\r
  IP6_INTERFACE             *IpIf;\r
  EFI_IPv6_ADDRESS          NextHop;\r
  IP6_NEIGHBOR_ENTRY        *NeighborCache;\r
  IP6_ROUTE_CACHE_ENTRY     *RouteCache;\r
  EFI_STATUS                Status;\r
  UINT32                    Mtu;\r
  UINT32                    HeadLen;\r
  UINT16                    FragmentOffset;\r
  UINT8                     *LastHeader;\r
  UINT32                    UnFragmentLen;\r
  UINT32                    UnFragmentHdrsLen;\r
  UINT32                    FragmentHdrsLen;\r
  UINT16                    *Checksum;\r
  UINT16                    PacketChecksum;\r
  UINT16                    PseudoChecksum;\r
  UINT32                    Index;\r
  UINT32                    PacketLen;\r
  UINT32                    RealExtLen;\r
  UINT32                    Offset;\r
  NET_BUF                   *TmpPacket;\r
  NET_BUF                   *Fragment;\r
  UINT32                    Num;\r
  UINT8                     *Buf;\r
  EFI_IP6_HEADER            *PacketHead;\r
  IP6_ICMP_HEAD             *IcmpHead;\r
  IP6_TXTOKEN_WRAP          *Wrap;\r
  IP6_ROUTE_ENTRY           *RouteEntry;\r
  UINT8                     *UpdatedExtHdrs;\r
  UINT8                     NextHeader;\r
  UINT8                     LastHeaderBackup;\r
  BOOLEAN                   FragmentHeadInserted;\r
  UINT8                     *ExtHdrsBackup;\r
  UINT8                     NextHeaderBackup;\r
  EFI_IPv6_ADDRESS          Source;\r
  EFI_IPv6_ADDRESS          Destination;\r
\r
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
\r
  //\r
  // RFC2460: Each extension header is an integer multiple of 8 octets long,\r
  // in order to retain 8-octet alignment for subsequent headers.\r
  //\r
  if ((ExtHdrsLen & 0x7) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  LastHeader = NULL;\r
\r
  Ip6IsExtsValid (\r
    NULL,\r
    NULL,\r
    &Head->NextHeader,\r
    ExtHdrs,\r
    ExtHdrsLen,\r
    FALSE,\r
    NULL,\r
    &LastHeader,\r
    NULL,\r
    NULL,\r
    NULL\r
    );\r
\r
  //\r
  // Select an interface/source for system packet, application\r
  // should select them itself.\r
  //\r
  IpIf = Interface;\r
  if (IpIf == NULL) {\r
    //\r
    // IpInstance->Interface is NULL when IpInstance is configured with both stationaddress\r
    // and destinationaddress is unspecified.\r
    //\r
    if (IpInstance == NULL || IpInstance->Interface == NULL) {\r
      IpIf = Ip6SelectInterface (IpSb, &Head->DestinationAddress, &Head->SourceAddress);\r
      if (IpInstance != NULL) {\r
        IpInstance->Interface = IpIf;\r
      }\r
    } else {\r
      IpIf = IpInstance->Interface;\r
    }\r
  }\r
\r
  if (IpIf == NULL) {\r
    return EFI_NO_MAPPING;\r
  }\r
\r
  //\r
  // Update the common field in Head here.\r
  //\r
  Head->Version       = 6;\r
  Head->TrafficClassL = 0;\r
  Head->TrafficClassH = 0;\r
\r
  Checksum            = NULL;\r
  NextHeader          = *LastHeader;\r
\r
  switch (NextHeader) {\r
  case EFI_IP_PROTO_UDP:\r
    Packet->Udp = (EFI_UDP_HEADER *) NetbufGetByte (Packet, 0, NULL);\r
    ASSERT (Packet->Udp != NULL);\r
    if (Packet->Udp->Checksum == 0) {\r
      Checksum = &Packet->Udp->Checksum;\r
    }\r
    break;\r
\r
  case EFI_IP_PROTO_TCP:\r
    Packet->Tcp = (TCP_HEAD *) NetbufGetByte (Packet, 0, NULL);\r
    ASSERT (Packet->Tcp != NULL);\r
    if (Packet->Tcp->Checksum == 0) {\r
      Checksum = &Packet->Tcp->Checksum;\r
    }\r
    break;\r
\r
  case IP6_ICMP:\r
    //\r
    // Don't send ICMP packet to an IPv6 anycast address.\r
    //\r
    if (Ip6IsAnycast (IpSb, &Head->DestinationAddress)) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    IcmpHead = (IP6_ICMP_HEAD *) NetbufGetByte (Packet, 0, NULL);\r
    ASSERT (IcmpHead != NULL);\r
    if (IcmpHead->Checksum == 0) {\r
      Checksum = &IcmpHead->Checksum;\r
    }\r
    break;\r
\r
  default:\r
    break;\r
  }\r
\r
  if (Checksum != NULL) {\r
    //\r
    // Calculate the checksum for upper layer protocol if it is not calculated due to lack of\r
    // IPv6 source address.\r
    //\r
    PacketChecksum = NetbufChecksum (Packet);\r
    PseudoChecksum = NetIp6PseudoHeadChecksum (\r
                      &Head->SourceAddress,\r
                      &Head->DestinationAddress,\r
                      NextHeader,\r
                      Packet->TotalSize\r
                      );\r
    *Checksum = (UINT16) ~NetAddChecksum (PacketChecksum, PseudoChecksum);\r
  }\r
\r
  Status = Ip6IpSecProcessPacket (\r
             IpSb,\r
             &Head,\r
             LastHeader, // no need get the lasthead value for output\r
             &Packet,\r
             &ExtHdrs,\r
             &ExtHdrsLen,\r
             EfiIPsecOutBound,\r
             Context\r
             );\r
\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  LastHeader = NULL;\r
  //\r
  // Check incoming parameters.\r
  //\r
  if (!Ip6IsExtsValid (\r
         IpSb,\r
         Packet,\r
         &Head->NextHeader,\r
         ExtHdrs,\r
         ExtHdrsLen,\r
         FALSE,\r
         NULL,\r
         &LastHeader,\r
         &RealExtLen,\r
         &UnFragmentHdrsLen,\r
         NULL\r
         )) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((RealExtLen & 0x7) != 0) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  LastHeaderBackup = *LastHeader;\r
\r
  //\r
  // Perform next hop determination:\r
  // For multicast packets, the next-hop is always the destination address and\r
  // is considered to be on-link.\r
  //\r
  if (IP6_IS_MULTICAST (&Head->DestinationAddress)) {\r
    IP6_COPY_ADDRESS (&NextHop, &Head->DestinationAddress);\r
  } else {\r
    //\r
    // For unicast packets, use a combination of the Destination Cache, the Prefix List\r
    // and the Default Router List to determine the IP address of the appropriate next hop.\r
    //\r
\r
    NeighborCache = Ip6FindNeighborEntry (IpSb, &Head->DestinationAddress);\r
    if (NeighborCache != NULL) {\r
      //\r
      // Hit Neighbor Cache.\r
      //\r
      IP6_COPY_ADDRESS (&NextHop, &Head->DestinationAddress);\r
    } else {\r
      //\r
      // Not in Neighbor Cache, check Router cache\r
      //\r
      RouteCache = Ip6Route (IpSb, &Head->DestinationAddress, &Head->SourceAddress);\r
      if (RouteCache == NULL) {\r
        return EFI_NOT_FOUND;\r
      }\r
\r
      IP6_COPY_ADDRESS (&NextHop, &RouteCache->NextHop);\r
      Ip6FreeRouteCacheEntry (RouteCache);\r
    }\r
  }\r
\r
  //\r
  // Examines the Neighbor Cache for link-layer information about that neighbor.\r
  // DO NOT create neighbor cache if neighbor is itself - when reporting ICMP error.\r
  //\r
  if (!IP6_IS_MULTICAST (&NextHop) && !EFI_IP6_EQUAL (&Head->DestinationAddress, &Head->SourceAddress)) {\r
    NeighborCache = Ip6FindNeighborEntry (IpSb, &NextHop);\r
    if (NeighborCache == NULL) {\r
      NeighborCache = Ip6CreateNeighborEntry (IpSb, Ip6OnArpResolved, &NextHop, NULL);\r
\r
      if (NeighborCache == NULL) {\r
        return EFI_OUT_OF_RESOURCES;\r
      }\r
\r
      //\r
      // Send out multicast neighbor solicitation for address resolution immediately.\r
      //\r
      Ip6CreateSNMulticastAddr (&NeighborCache->Neighbor, &Destination);\r
      Status = Ip6SelectSourceAddress (IpSb, &NeighborCache->Neighbor, &Source);\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
\r
      Status = Ip6SendNeighborSolicit (\r
                 IpSb,\r
                 &Source,\r
                 &Destination,\r
                 &NeighborCache->Neighbor,\r
                 &IpSb->SnpMode.CurrentAddress\r
                 );\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
\r
      --NeighborCache->Transmit;\r
      NeighborCache->Ticks = IP6_GET_TICKS (IpSb->RetransTimer) + 1;\r
    }\r
\r
    NeighborCache->Interface = IpIf;\r
  }\r
\r
  UpdatedExtHdrs       = NULL;\r
  ExtHdrsBackup        = NULL;\r
  NextHeaderBackup     = 0;\r
  FragmentHeadInserted = FALSE;\r
\r
  //\r
  // Check whether we received Packet Too Big message for the packet sent to the\r
  // Destination. If yes include a Fragment Header in the subsequent packets.\r
  //\r
  RouteEntry = Ip6FindRouteEntry (\r
                 IpSb->RouteTable,\r
                 &Head->DestinationAddress,\r
                 NULL\r
                 );\r
  if (RouteEntry != NULL) {\r
    if ((RouteEntry->Flag & IP6_PACKET_TOO_BIG) == IP6_PACKET_TOO_BIG) {\r
\r
      //\r
      // FragmentHead is inserted after Hop-by-Hop Options header, Destination\r
      // Options header (first occur), Routing header, and before Fragment header,\r
      // Authentication header, Encapsulating Security Payload header, and\r
      // Destination Options header (last occur), and upper-layer header.\r
      //\r
      Status = Ip6FillFragmentHeader (\r
                 IpSb,\r
                 Head->NextHeader,\r
                 LastHeaderBackup,\r
                 ExtHdrs,\r
                 ExtHdrsLen,\r
                 0,\r
                 &UpdatedExtHdrs\r
                 );\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
\r
      if ((ExtHdrs == NULL) && (ExtHdrsLen == 0)) {\r
        NextHeaderBackup = Head->NextHeader;\r
        Head->NextHeader = IP6_FRAGMENT;\r
      }\r
\r
      ExtHdrsBackup    = ExtHdrs;\r
      ExtHdrs          = UpdatedExtHdrs;\r
      ExtHdrsLen       = ExtHdrsLen + sizeof (IP6_FRAGMENT_HEADER);\r
      RealExtLen       = RealExtLen + sizeof (IP6_FRAGMENT_HEADER);\r
\r
      mIp6Id++;\r
\r
      FragmentHeadInserted = TRUE;\r
    }\r
\r
    Ip6FreeRouteEntry (RouteEntry);\r
  }\r
\r
  //\r
  // OK, selected the source and route, fragment the packet then send\r
  // them. Tag each fragment other than the first one as spawn from it.\r
  // Each extension header is an integer multiple of 8 octets long, in\r
  // order to retain 8-octet alignment for subsequent headers.\r
  //\r
  Mtu     = IpSb->MaxPacketSize + sizeof (EFI_IP6_HEADER);\r
  HeadLen = sizeof (EFI_IP6_HEADER) + RealExtLen;\r
\r
  if (Packet->TotalSize + HeadLen > Mtu) {\r
    //\r
    // Remove the inserted Fragment Header since we need fragment the packet.\r
    //\r
    if (FragmentHeadInserted) {\r
      ExtHdrs    = ExtHdrsBackup;\r
      ExtHdrsLen = ExtHdrsLen - sizeof (IP6_FRAGMENT_HEADER);\r
\r
      if ((ExtHdrs == NULL) && (ExtHdrsLen == 0)) {\r
        Head->NextHeader = NextHeaderBackup;\r
      }\r
    }\r
\r
    FragmentHdrsLen = ExtHdrsLen - UnFragmentHdrsLen;\r
\r
    //\r
    // The packet is beyond the maximum which can be described through the\r
    // fragment offset field in Fragment header.\r
    //\r
    if ((((Packet->TotalSize + FragmentHdrsLen) >> 3) & (~0x1fff)) != 0) {\r
      Status = EFI_BAD_BUFFER_SIZE;\r
      goto Error;\r
    }\r
\r
    if (FragmentHdrsLen != 0) {\r
      //\r
      // Append the fragmentable extension hdrs before the upper layer payload\r
      // to form a new NET_BUF. This NET_BUF contains all the buffer which will\r
      // be fragmented below.\r
      //\r
      TmpPacket = NetbufGetFragment (Packet, 0, Packet->TotalSize, FragmentHdrsLen);\r
      ASSERT (TmpPacket != NULL);\r
\r
      //\r
      // Allocate the space to contain the fragmentable hdrs and copy the data.\r
      //\r
      Buf = NetbufAllocSpace (TmpPacket, FragmentHdrsLen, TRUE);\r
      ASSERT (Buf != NULL);\r
      CopyMem (Buf, ExtHdrs + UnFragmentHdrsLen, FragmentHdrsLen);\r
\r
      //\r
      // Free the old Packet.\r
      //\r
      NetbufFree (Packet);\r
      Packet = TmpPacket;\r
    }\r
\r
    //\r
    // The unfragment part which appears in every fragmented IPv6 packet includes\r
    // the IPv6 header, the unfragmentable extension hdrs and the fragment header.\r
    //\r
    UnFragmentLen = sizeof (EFI_IP6_HEADER) + UnFragmentHdrsLen + sizeof (IP6_FRAGMENT_HEADER);\r
\r
    //\r
    // Mtu now is the length of the fragment part in a full-length fragment.\r
    //\r
    Mtu = (Mtu - UnFragmentLen) & (~0x07);\r
    Num = (Packet->TotalSize + Mtu - 1) / Mtu;\r
\r
    for (Index = 0, Offset = 0, PacketLen = Mtu; Index < Num; Index++) {\r
      //\r
      // Get fragment from the Packet, append UnFragnmentLen spare buffer\r
      // before the fragmented data, the corresponding data is filled in later.\r
      //\r
      Fragment = NetbufGetFragment (Packet, Offset, PacketLen, UnFragmentLen);\r
      if (Fragment == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
        goto Error;\r
      }\r
\r
      FragmentOffset = (UINT16) ((UINT16) Offset | 0x1);\r
      if (Index == Num - 1){\r
        //\r
        // The last fragment, clear the M flag.\r
        //\r
        FragmentOffset &= (~0x1);\r
      }\r
\r
      Status = Ip6PrependHead (\r
                 IpSb,\r
                 Fragment,\r
                 Head,\r
                 FragmentOffset,\r
                 ExtHdrs,\r
                 ExtHdrsLen,\r
                 LastHeaderBackup,\r
                 UnFragmentLen\r
                 );\r
      ASSERT (Status == EFI_SUCCESS);\r
\r
      Status = Ip6SendFrame (\r
                 IpIf,\r
                 IpInstance,\r
                 Fragment,\r
                 &NextHop,\r
                 Ip6SysPacketSent,\r
                 Packet\r
                 );\r
      if (EFI_ERROR (Status)) {\r
        goto Error;\r
      }\r
\r
      //\r
      // The last fragment of upper layer packet, update the IP6 token status.\r
      //\r
      if ((Index == Num -1) && (Context != NULL)) {\r
        Wrap                = (IP6_TXTOKEN_WRAP *) Context;\r
        Wrap->Token->Status = Status;\r
      }\r
\r
      Offset    += PacketLen;\r
      PacketLen = Packet->TotalSize - Offset;\r
      if (PacketLen > Mtu) {\r
        PacketLen = Mtu;\r
      }\r
    }\r
\r
    NetbufFree (Packet);\r
    mIp6Id++;\r
\r
    if (UpdatedExtHdrs != NULL) {\r
      FreePool (UpdatedExtHdrs);\r
    }\r
\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Need not fragment the packet, send it in one frame.\r
  //\r
  PacketHead = (EFI_IP6_HEADER *) NetbufAllocSpace (Packet, HeadLen, NET_BUF_HEAD);\r
  if (PacketHead == NULL) {\r
    Status = EFI_BAD_BUFFER_SIZE;\r
    goto Error;\r
  }\r
\r
  CopyMem (PacketHead, Head, sizeof (EFI_IP6_HEADER));\r
  Packet->Ip.Ip6 = PacketHead;\r
\r
  if (ExtHdrs != NULL) {\r
    Buf = (UINT8 *) (PacketHead + 1);\r
    CopyMem (Buf, ExtHdrs, ExtHdrsLen);\r
  }\r
\r
  if (UpdatedExtHdrs != NULL) {\r
    //\r
    // A Fragment Header is inserted to the packet, update the payload length.\r
    //\r
    PacketHead->PayloadLength = (UINT16) (NTOHS (PacketHead->PayloadLength) +\r
                                sizeof (IP6_FRAGMENT_HEADER));\r
    PacketHead->PayloadLength = HTONS (PacketHead->PayloadLength);\r
    FreePool (UpdatedExtHdrs);\r
  }\r
\r
  return Ip6SendFrame (\r
           IpIf,\r
           IpInstance,\r
           Packet,\r
           &NextHop,\r
           Callback,\r
           Context\r
           );\r
\r
Error:\r
  if (UpdatedExtHdrs != NULL) {\r
    FreePool (UpdatedExtHdrs);\r
  }\r
  Ip6CancelPacket (IpIf, Packet, Status);\r
  return Status;\r
}\r
\r
/**\r
  The filter function to find a packet and all its fragments.\r
  The packet's fragments have their Context set to the packet.\r
\r
  @param[in]  Frame            The frames hold by the low level interface.\r
  @param[in]  Context          Context to the function, which is the packet.\r
\r
  @retval TRUE                 This is the packet to cancel or its fragments.\r
  @retval FALSE                This is an unrelated packet.\r
\r
**/\r
BOOLEAN\r
Ip6CancelPacketFragments (\r
  IN IP6_LINK_TX_TOKEN   *Frame,\r
  IN VOID                *Context\r
  )\r
{\r
  if ((Frame->Packet == (NET_BUF *) Context) || (Frame->Context == Context)) {\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Remove all the frames on the interface that pass the FrameToCancel,\r
  either queued on ARP queues or that have already been delivered to\r
  MNP and not yet recycled.\r
\r
  @param[in]  Interface     Interface to remove the frames from.\r
  @param[in]  IoStatus      The transmit status returned to the frames' callback.\r
  @param[in]  FrameToCancel Function to select the frame to cancel; NULL to select all.\r
  @param[in]  Context       Opaque parameters passed to FrameToCancel. Ignored if\r
                            FrameToCancel is NULL.\r
\r
**/\r
VOID\r
Ip6CancelFrames (\r
  IN IP6_INTERFACE          *Interface,\r
  IN EFI_STATUS             IoStatus,\r
  IN IP6_FRAME_TO_CANCEL    FrameToCancel   OPTIONAL,\r
  IN VOID                   *Context        OPTIONAL\r
  )\r
{\r
  LIST_ENTRY                *Entry;\r
  LIST_ENTRY                *Next;\r
  IP6_LINK_TX_TOKEN         *Token;\r
  IP6_SERVICE               *IpSb;\r
  IP6_NEIGHBOR_ENTRY        *ArpQue;\r
  EFI_STATUS                Status;\r
\r
  IpSb = Interface->Service;\r
  NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE);\r
\r
  //\r
  // Cancel all the pending frames on ARP requests\r
  //\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->ArpQues) {\r
    ArpQue = NET_LIST_USER_STRUCT (Entry, IP6_NEIGHBOR_ENTRY, ArpList);\r
\r
    Status = Ip6FreeNeighborEntry (\r
               IpSb,\r
               ArpQue,\r
               FALSE,\r
               FALSE,\r
               IoStatus,\r
               FrameToCancel,\r
               Context\r
               );\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  //\r
  // Cancel all the frames that have been delivered to MNP\r
  // but not yet recycled.\r
  //\r
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Interface->SentFrames) {\r
    Token = NET_LIST_USER_STRUCT (Entry, IP6_LINK_TX_TOKEN, Link);\r
\r
    if ((FrameToCancel == NULL) || FrameToCancel (Token, Context)) {\r
      IpSb->Mnp->Cancel (IpSb->Mnp, &Token->MnpToken);\r
    }\r
  }\r
}\r
\r
/**\r
  Cancel the Packet and all its fragments.\r
\r
  @param[in]  IpIf                 The interface from which the Packet is sent.\r
  @param[in]  Packet               The Packet to cancel.\r
  @param[in]  IoStatus             The status returns to the sender.\r
\r
**/\r
VOID\r
Ip6CancelPacket (\r
  IN IP6_INTERFACE    *IpIf,\r
  IN NET_BUF          *Packet,\r
  IN EFI_STATUS       IoStatus\r
  )\r
{\r
  Ip6CancelFrames (IpIf, IoStatus, Ip6CancelPacketFragments, Packet);\r
}\r
\r