RedfishPkg: Use DSC include file

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

/** @file\r
  IP6 option support functions and routines.\r
\r
  Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "Ip6Impl.h"\r
\r
/**\r
  Validate the IP6 option format for both the packets we received\r
  and that we will transmit. It will compute the ICMPv6 error message fields\r
  if the option is malformatted.\r
\r
  @param[in]  IpSb              The IP6 service data.\r
  @param[in]  Packet            The to be validated packet.\r
  @param[in]  Option            The first byte of the option.\r
  @param[in]  OptionLen         The length of the whole option.\r
  @param[in]  Pointer           Identifies the octet offset within\r
                                the invoking packet where the error was detected.\r
\r
\r
  @retval TRUE     The option is properly formatted.\r
  @retval FALSE    The option is malformatted.\r
\r
**/\r
BOOLEAN\r
Ip6IsOptionValid (\r
  IN IP6_SERVICE            *IpSb,\r
  IN NET_BUF                *Packet,\r
  IN UINT8                  *Option,\r
  IN UINT8                  OptionLen,\r
  IN UINT32                 Pointer\r
  )\r
{\r
  UINT8                      Offset;\r
  UINT8                      OptionType;\r
\r
  Offset = 0;\r
\r
  while (Offset < OptionLen) {\r
    OptionType = *(Option + Offset);\r
\r
    switch (OptionType) {\r
    case Ip6OptionPad1:\r
      //\r
      // It is a Pad1 option\r
      //\r
      Offset++;\r
      break;\r
    case Ip6OptionPadN:\r
      //\r
      // It is a PadN option\r
      //\r
      Offset = (UINT8) (Offset + *(Option + Offset + 1) + 2);\r
      break;\r
    case Ip6OptionRouterAlert:\r
      //\r
      // It is a Router Alert Option\r
      //\r
      Offset += 4;\r
      break;\r
    default:\r
      //\r
      // The highest-order two bits specify the action must be taken if\r
      // the processing IPv6 node does not recognize the option type.\r
      //\r
      switch (OptionType & Ip6OptionMask) {\r
      case Ip6OptionSkip:\r
        Offset = (UINT8) (Offset + *(Option + Offset + 1));\r
        break;\r
      case Ip6OptionDiscard:\r
        return FALSE;\r
      case Ip6OptionParameterProblem:\r
        Pointer = Pointer + Offset + sizeof (EFI_IP6_HEADER);\r
        Ip6SendIcmpError (\r
          IpSb,\r
          Packet,\r
          NULL,\r
          &Packet->Ip.Ip6->SourceAddress,\r
          ICMP_V6_PARAMETER_PROBLEM,\r
          2,\r
          &Pointer\r
          );\r
        return FALSE;\r
      case Ip6OptionMask:\r
        if (!IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {\r
          Pointer = Pointer + Offset + sizeof (EFI_IP6_HEADER);\r
          Ip6SendIcmpError (\r
            IpSb,\r
            Packet,\r
            NULL,\r
            &Packet->Ip.Ip6->SourceAddress,\r
            ICMP_V6_PARAMETER_PROBLEM,\r
            2,\r
            &Pointer\r
            );\r
        }\r
\r
        return FALSE;\r
        break;\r
      }\r
\r
      break;\r
    }\r
\r
  }\r
\r
  return TRUE;\r
}\r
\r
/**\r
  Validate the IP6 option format for both the packets we received\r
  and that we will transmit. It supports the defined options in Neighbor\r
  Discovery messages.\r
\r
  @param[in]  Option            The first byte of the option.\r
  @param[in]  OptionLen         The length of the whole option.\r
\r
  @retval TRUE     The option is properly formatted.\r
  @retval FALSE    The option is malformatted.\r
\r
**/\r
BOOLEAN\r
Ip6IsNDOptionValid (\r
  IN UINT8                  *Option,\r
  IN UINT16                 OptionLen\r
  )\r
{\r
  UINT32                    Offset;\r
  UINT16                    Length;\r
  IP6_OPTION_HEADER         *OptionHeader;\r
\r
  if (Option == NULL) {\r
    ASSERT (Option != NULL);\r
    return FALSE;\r
  }\r
\r
  Offset = 0;\r
\r
  //\r
  // RFC 4861 states that Neighbor Discovery packet can contain zero or more\r
  // options. Start processing the options if at least Type + Length fields\r
  // fit within the input buffer.\r
  //\r
  while (Offset + sizeof (IP6_OPTION_HEADER) - 1 < OptionLen) {\r
    OptionHeader  = (IP6_OPTION_HEADER*) (Option + Offset);\r
    Length        = (UINT16) OptionHeader->Length * 8;\r
\r
    switch (OptionHeader->Type) {\r
    case Ip6OptionPrefixInfo:\r
      if (Length != 32) {\r
        return FALSE;\r
      }\r
      break;\r
\r
    case Ip6OptionMtu:\r
      if (Length != 8) {\r
        return FALSE;\r
      }\r
      break;\r
\r
    default:\r
      // RFC 4861 states that Length field cannot be 0.\r
      if (Length == 0) {\r
        return FALSE;\r
      }\r
      break;\r
    }\r
\r
    //\r
    // Check whether recognized options are within the input buffer's scope.\r
    //\r
    switch (OptionHeader->Type) {\r
    case Ip6OptionEtherSource:\r
    case Ip6OptionEtherTarget:\r
    case Ip6OptionPrefixInfo:\r
    case Ip6OptionRedirected:\r
    case Ip6OptionMtu:\r
      if (Offset + Length > (UINT32) OptionLen) {\r
        return FALSE;\r
      }\r
      break;\r
\r
    default:\r
      //\r
      // Unrecognized options can be either valid (but unused) or invalid\r
      // (garbage in between or right after valid options). Silently ignore.\r
      //\r
      break;\r
    }\r
\r
    //\r
    // Advance to the next option.\r
    // Length already considers option header's Type + Length.\r
    //\r
    Offset += Length;\r
  }\r
\r
  return TRUE;\r
}\r
\r
\r
/**\r
  Validate whether the NextHeader is a known valid protocol or one of the user configured\r
  protocols from the upper layer.\r
\r
  @param[in]  IpSb          The IP6 service instance.\r
  @param[in]  NextHeader    The next header field.\r
\r
  @retval TRUE              The NextHeader is a known valid protocol or user configured.\r
  @retval FALSE             The NextHeader is not a known valid protocol.\r
\r
**/\r
BOOLEAN\r
Ip6IsValidProtocol (\r
  IN IP6_SERVICE            *IpSb,\r
  IN UINT8                  NextHeader\r
  )\r
{\r
  LIST_ENTRY                *Entry;\r
  IP6_PROTOCOL              *IpInstance;\r
\r
  if (NextHeader == EFI_IP_PROTO_TCP ||\r
      NextHeader == EFI_IP_PROTO_UDP ||\r
      NextHeader == IP6_ICMP ||\r
      NextHeader == IP6_ESP\r
      ) {\r
    return TRUE;\r
  }\r
\r
  if (IpSb == NULL) {\r
    return FALSE;\r
  }\r
\r
  if (IpSb->Signature != IP6_SERVICE_SIGNATURE) {\r
    return FALSE;\r
  }\r
\r
  NET_LIST_FOR_EACH (Entry, &IpSb->Children) {\r
    IpInstance = NET_LIST_USER_STRUCT_S (Entry, IP6_PROTOCOL, Link, IP6_PROTOCOL_SIGNATURE);\r
    if (IpInstance->State == IP6_STATE_CONFIGED) {\r
      if (IpInstance->ConfigData.DefaultProtocol == NextHeader) {\r
        return TRUE;\r
      }\r
    }\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Validate the IP6 extension header format for both the packets we received\r
  and that we will transmit. It will compute the ICMPv6 error message fields\r
  if the option is mal-formatted.\r
\r
  @param[in]  IpSb          The IP6 service instance. This is an optional parameter.\r
  @param[in]  Packet        The data of the packet. Ignored if NULL.\r
  @param[in]  NextHeader    The next header field in IPv6 basic header.\r
  @param[in]  ExtHdrs       The first byte of the option.\r
  @param[in]  ExtHdrsLen    The length of the whole option.\r
  @param[in]  Rcvd          The option is from the packet we received if TRUE,\r
                            otherwise, the option we want to transmit.\r
  @param[out] FormerHeader  The offset of NextHeader which points to Fragment\r
                            Header when we received, of the ExtHdrs.\r
                            Ignored if we transmit.\r
  @param[out] LastHeader    The pointer of NextHeader of the last extension\r
                            header processed by IP6.\r
  @param[out] RealExtsLen   The length of extension headers processed by IP6 layer.\r
                            This is an optional parameter that may be NULL.\r
  @param[out] UnFragmentLen The length of unfragmented length of extension headers.\r
                            This is an optional parameter that may be NULL.\r
  @param[out] Fragmented    Indicate whether the packet is fragmented.\r
                            This is an optional parameter that may be NULL.\r
\r
  @retval     TRUE          The option is properly formatted.\r
  @retval     FALSE         The option is malformatted.\r
\r
**/\r
BOOLEAN\r
Ip6IsExtsValid (\r
  IN IP6_SERVICE            *IpSb           OPTIONAL,\r
  IN NET_BUF                *Packet         OPTIONAL,\r
  IN UINT8                  *NextHeader,\r
  IN UINT8                  *ExtHdrs,\r
  IN UINT32                 ExtHdrsLen,\r
  IN BOOLEAN                Rcvd,\r
  OUT UINT32                *FormerHeader   OPTIONAL,\r
  OUT UINT8                 **LastHeader,\r
  OUT UINT32                *RealExtsLen    OPTIONAL,\r
  OUT UINT32                *UnFragmentLen  OPTIONAL,\r
  OUT BOOLEAN               *Fragmented     OPTIONAL\r
  )\r
{\r
  UINT32                     Pointer;\r
  UINT32                     Offset;\r
  UINT8                      *Option;\r
  UINT8                      OptionLen;\r
  BOOLEAN                    Flag;\r
  UINT8                      CountD;\r
  UINT8                      CountA;\r
  IP6_FRAGMENT_HEADER        *FragmentHead;\r
  UINT16                     FragmentOffset;\r
  IP6_ROUTING_HEADER         *RoutingHead;\r
\r
  if (RealExtsLen != NULL) {\r
    *RealExtsLen = 0;\r
  }\r
\r
  if (UnFragmentLen != NULL) {\r
    *UnFragmentLen = 0;\r
  }\r
\r
  if (Fragmented != NULL) {\r
    *Fragmented = FALSE;\r
  }\r
\r
  *LastHeader = NextHeader;\r
\r
  if (ExtHdrs == NULL && ExtHdrsLen == 0) {\r
    return TRUE;\r
  }\r
\r
  if ((ExtHdrs == NULL && ExtHdrsLen != 0) || (ExtHdrs != NULL && ExtHdrsLen == 0)) {\r
    return FALSE;\r
  }\r
\r
  Pointer = 0;\r
  Offset  = 0;\r
  Flag    = FALSE;\r
  CountD  = 0;\r
  CountA  = 0;\r
\r
  while (Offset <= ExtHdrsLen) {\r
\r
    switch (*NextHeader) {\r
    case IP6_HOP_BY_HOP:\r
      if (Offset != 0) {\r
        if (!Rcvd) {\r
          return FALSE;\r
        }\r
        //\r
        // Hop-by-Hop Options header is restricted to appear immediately after an IPv6 header only.\r
        // If not, generate a ICMP parameter problem message with code value of 1.\r
        //\r
        if (Pointer == 0) {\r
          Pointer = sizeof (EFI_IP6_HEADER);\r
        } else {\r
          Pointer = Offset + sizeof (EFI_IP6_HEADER);\r
        }\r
\r
        if ((IpSb != NULL) && (Packet != NULL) &&\r
            !IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {\r
          Ip6SendIcmpError (\r
            IpSb,\r
            Packet,\r
            NULL,\r
            &Packet->Ip.Ip6->SourceAddress,\r
            ICMP_V6_PARAMETER_PROBLEM,\r
            1,\r
            &Pointer\r
            );\r
        }\r
        return FALSE;\r
      }\r
\r
      Flag = TRUE;\r
\r
    //\r
    // Fall through\r
    //\r
    case IP6_DESTINATION:\r
      if (*NextHeader == IP6_DESTINATION) {\r
        CountD++;\r
      }\r
\r
      if (CountD > 2) {\r
        return FALSE;\r
      }\r
\r
      NextHeader = ExtHdrs + Offset;\r
      Pointer    = Offset;\r
\r
      Offset++;\r
      Option     = ExtHdrs + Offset;\r
      OptionLen  = (UINT8) ((*Option + 1) * 8 - 2);\r
      Option++;\r
      Offset++;\r
\r
      if (IpSb != NULL && Packet != NULL && !Ip6IsOptionValid (IpSb, Packet, Option, OptionLen, Offset)) {\r
        return FALSE;\r
      }\r
\r
      Offset = Offset + OptionLen;\r
\r
      if (Flag) {\r
        if (UnFragmentLen != NULL) {\r
          *UnFragmentLen = Offset;\r
        }\r
\r
        Flag = FALSE;\r
      }\r
\r
      break;\r
\r
    case IP6_ROUTING:\r
      NextHeader = ExtHdrs + Offset;\r
      RoutingHead = (IP6_ROUTING_HEADER *) NextHeader;\r
\r
      //\r
      // Type 0 routing header is defined in RFC2460 and deprecated in RFC5095.\r
      // Thus all routing types are processed as unrecognized.\r
      //\r
      if (RoutingHead->SegmentsLeft == 0) {\r
        //\r
        // Ignore the routing header and proceed to process the next header.\r
        //\r
        Offset = Offset + (RoutingHead->HeaderLen + 1) * 8;\r
\r
        if (UnFragmentLen != NULL) {\r
          *UnFragmentLen = Offset;\r
        }\r
\r
      } else {\r
        //\r
        // Discard the packet and send an ICMP Parameter Problem, Code 0, message\r
        // to the packet's source address, pointing to the unrecognized routing\r
        // type.\r
        //\r
        Pointer = Offset + 2 + sizeof (EFI_IP6_HEADER);\r
        if ((IpSb != NULL) && (Packet != NULL) &&\r
            !IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {\r
          Ip6SendIcmpError (\r
            IpSb,\r
            Packet,\r
            NULL,\r
            &Packet->Ip.Ip6->SourceAddress,\r
            ICMP_V6_PARAMETER_PROBLEM,\r
            0,\r
            &Pointer\r
            );\r
        }\r
\r
        return FALSE;\r
      }\r
\r
      break;\r
\r
    case IP6_FRAGMENT:\r
\r
      //\r
      // RFC2402, AH header should after fragment header.\r
      //\r
      if (CountA > 1) {\r
        return FALSE;\r
      }\r
\r
      //\r
      // RFC2460, ICMP Parameter Problem message with code 0 should be sent\r
      // if the length of a fragment is not a multiple of 8 octets and the M\r
      // flag of that fragment is 1, pointing to the Payload length field of the\r
      // fragment packet.\r
      //\r
      if (IpSb != NULL && Packet != NULL && (ExtHdrsLen % 8) != 0) {\r
        //\r
        // Check whether it is the last fragment.\r
        //\r
        FragmentHead = (IP6_FRAGMENT_HEADER *) (ExtHdrs + Offset);\r
        if (FragmentHead == NULL) {\r
          return FALSE;\r
        }\r
\r
        FragmentOffset = NTOHS (FragmentHead->FragmentOffset);\r
\r
        if (((FragmentOffset & 0x1) == 0x1) &&\r
            !IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {\r
          Pointer = sizeof (UINT32);\r
          Ip6SendIcmpError (\r
            IpSb,\r
            Packet,\r
            NULL,\r
            &Packet->Ip.Ip6->SourceAddress,\r
            ICMP_V6_PARAMETER_PROBLEM,\r
            0,\r
            &Pointer\r
            );\r
          return FALSE;\r
        }\r
      }\r
\r
      if (Fragmented != NULL) {\r
        *Fragmented = TRUE;\r
      }\r
\r
      if (Rcvd && FormerHeader != NULL) {\r
        *FormerHeader = (UINT32) (NextHeader - ExtHdrs);\r
      }\r
\r
      NextHeader = ExtHdrs + Offset;\r
      Offset     = Offset + 8;\r
      break;\r
\r
    case IP6_AH:\r
      if (++CountA > 1) {\r
        return FALSE;\r
      }\r
\r
      Option     = ExtHdrs + Offset;\r
      NextHeader = Option;\r
      Option++;\r
      //\r
      // RFC2402, Payload length is specified in 32-bit words, minus "2".\r
      //\r
      OptionLen  = (UINT8) ((*Option + 2) * 4);\r
      Offset     = Offset + OptionLen;\r
      break;\r
\r
    case IP6_NO_NEXT_HEADER:\r
      *LastHeader = NextHeader;\r
      return FALSE;\r
      break;\r
\r
    default:\r
      if (Ip6IsValidProtocol (IpSb, *NextHeader)) {\r
\r
        *LastHeader = NextHeader;\r
\r
        if (RealExtsLen != NULL) {\r
          *RealExtsLen = Offset;\r
        }\r
\r
        return TRUE;\r
      }\r
\r
      //\r
      // The Next Header value is unrecognized by the node, discard the packet and\r
      // send an ICMP parameter problem message with code value of 1.\r
      //\r
      if (Offset == 0) {\r
        //\r
        // The Next Header directly follows IPv6 basic header.\r
        //\r
        Pointer = 6;\r
      } else {\r
        if (Pointer == 0) {\r
          Pointer = sizeof (EFI_IP6_HEADER);\r
        } else {\r
          Pointer = Offset + sizeof (EFI_IP6_HEADER);\r
        }\r
      }\r
\r
      if ((IpSb != NULL) && (Packet != NULL) &&\r
          !IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {\r
        Ip6SendIcmpError (\r
          IpSb,\r
          Packet,\r
          NULL,\r
          &Packet->Ip.Ip6->SourceAddress,\r
          ICMP_V6_PARAMETER_PROBLEM,\r
          1,\r
          &Pointer\r
          );\r
      }\r
      return FALSE;\r
    }\r
  }\r
\r
  *LastHeader = NextHeader;\r
\r
  if (RealExtsLen != NULL) {\r
    *RealExtsLen = Offset;\r
  }\r
\r
  return TRUE;\r
}\r
\r
/**\r
  Generate an IPv6 router alert option in network order and output it through Buffer.\r
\r
  @param[out]     Buffer         Points to a buffer to record the generated option.\r
  @param[in, out] BufferLen      The length of Buffer, in bytes.\r
  @param[in]      NextHeader     The 8-bit selector indicates the type of header\r
                                 immediately following the Hop-by-Hop Options header.\r
\r
  @retval EFI_BUFFER_TOO_SMALL   The Buffer is too small to contain the generated\r
                                 option. BufferLen is updated for the required size.\r
\r
  @retval EFI_SUCCESS            The option is generated and filled in to Buffer.\r
\r
**/\r
EFI_STATUS\r
Ip6FillHopByHop (\r
  OUT UINT8                  *Buffer,\r
  IN OUT UINTN               *BufferLen,\r
  IN UINT8                   NextHeader\r
  )\r
{\r
  UINT8                      BufferArray[8];\r
\r
  if (*BufferLen < 8) {\r
    *BufferLen = 8;\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // Form the Hop-By-Hop option in network order.\r
  // NextHeader (1 octet) + HdrExtLen (1 octet) + RouterAlertOption(4 octets) + PadN\r
  // The Hdr Ext Len is the length in 8-octet units, and does not including the first 8 octets.\r
  //\r
  ZeroMem (BufferArray, sizeof (BufferArray));\r
  BufferArray[0] = NextHeader;\r
  BufferArray[2] = 0x5;\r
  BufferArray[3] = 0x2;\r
  BufferArray[6] = 1;\r
\r
  CopyMem (Buffer, BufferArray, sizeof (BufferArray));\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Insert a Fragment Header to the Extension headers and output it in UpdatedExtHdrs.\r
\r
  @param[in]  IpSb             The IP6 service instance to transmit the packet.\r
  @param[in]  NextHeader       The extension header type of first extension header.\r
  @param[in]  LastHeader       The extension header type of last extension 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]  FragmentOffset   The fragment offset of the data following the header.\r
  @param[out] UpdatedExtHdrs   The updated ExtHdrs with Fragment header inserted.\r
                               It's caller's responsibility to free this buffer.\r
\r
  @retval EFI_OUT_OF_RESOURCES Failed to finish the operation due to lake of\r
                               resource.\r
  @retval EFI_UNSUPPORTED      The extension header specified in ExtHdrs is not\r
                               supported currently.\r
  @retval EFI_SUCCESS          The operation performed successfully.\r
\r
**/\r
EFI_STATUS\r
Ip6FillFragmentHeader (\r
  IN  IP6_SERVICE           *IpSb,\r
  IN  UINT8                 NextHeader,\r
  IN  UINT8                 LastHeader,\r
  IN  UINT8                 *ExtHdrs,\r
  IN  UINT32                ExtHdrsLen,\r
  IN  UINT16                FragmentOffset,\r
  OUT UINT8                 **UpdatedExtHdrs\r
  )\r
{\r
  UINT32                    Length;\r
  UINT8                     *Buffer;\r
  UINT32                    FormerHeader;\r
  UINT32                    Offset;\r
  UINT32                    Part1Len;\r
  UINT32                    HeaderLen;\r
  UINT8                     Current;\r
  IP6_FRAGMENT_HEADER       FragmentHead;\r
\r
  if (UpdatedExtHdrs == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Length = ExtHdrsLen + sizeof (IP6_FRAGMENT_HEADER);\r
  Buffer = AllocatePool (Length);\r
  if (Buffer == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Offset         = 0;\r
  Part1Len       = 0;\r
  FormerHeader   = 0;\r
  Current        = NextHeader;\r
\r
  while ((ExtHdrs != NULL) && (Offset <= ExtHdrsLen)) {\r
    switch (NextHeader) {\r
    case IP6_ROUTING:\r
    case IP6_HOP_BY_HOP:\r
    case IP6_DESTINATION:\r
      Current      = NextHeader;\r
      NextHeader   = *(ExtHdrs + Offset);\r
\r
      if ((Current == IP6_DESTINATION) && (NextHeader != IP6_ROUTING)) {\r
        //\r
        // Destination Options header should occur at most twice, once before\r
        // a Routing header and once before the upper-layer header. Here we\r
        // find the one before the upper-layer header. Insert the Fragment\r
        // Header before it.\r
        //\r
        CopyMem (Buffer, ExtHdrs, Part1Len);\r
        *(Buffer + FormerHeader) = IP6_FRAGMENT;\r
        //\r
        // Exit the loop.\r
        //\r
        Offset = ExtHdrsLen + 1;\r
        break;\r
      }\r
\r
\r
      FormerHeader = Offset;\r
      HeaderLen    = (*(ExtHdrs + Offset + 1) + 1) * 8;\r
      Part1Len     = Part1Len + HeaderLen;\r
      Offset       = Offset + HeaderLen;\r
      break;\r
\r
    case IP6_FRAGMENT:\r
      Current    = NextHeader;\r
\r
      if (Part1Len != 0) {\r
        CopyMem (Buffer, ExtHdrs, Part1Len);\r
      }\r
\r
      *(Buffer + FormerHeader) = IP6_FRAGMENT;\r
\r
      //\r
      // Exit the loop.\r
      //\r
      Offset = ExtHdrsLen + 1;\r
      break;\r
\r
    case IP6_AH:\r
      Current    = NextHeader;\r
      NextHeader = *(ExtHdrs + Offset);\r
      //\r
      // RFC2402, Payload length is specified in 32-bit words, minus "2".\r
      //\r
      HeaderLen  = (*(ExtHdrs + Offset + 1) + 2) * 4;\r
      Part1Len   = Part1Len + HeaderLen;\r
      Offset     = Offset + HeaderLen;\r
      break;\r
\r
    default:\r
      if (Ip6IsValidProtocol (IpSb, NextHeader)) {\r
        Current = NextHeader;\r
        CopyMem (Buffer, ExtHdrs, Part1Len);\r
        *(Buffer + FormerHeader) = IP6_FRAGMENT;\r
        //\r
        // Exit the loop.\r
        //\r
        Offset = ExtHdrsLen + 1;\r
        break;\r
      }\r
\r
      FreePool (Buffer);\r
      return EFI_UNSUPPORTED;\r
    }\r
  }\r
\r
  //\r
  // Append the Fragment header. If the fragment offset indicates the fragment\r
  // is the first fragment.\r
  //\r
  if ((FragmentOffset & IP6_FRAGMENT_OFFSET_MASK) == 0) {\r
    FragmentHead.NextHeader = Current;\r
  } else {\r
    FragmentHead.NextHeader = LastHeader;\r
  }\r
\r
  FragmentHead.Reserved       = 0;\r
  FragmentHead.FragmentOffset = HTONS (FragmentOffset);\r
  FragmentHead.Identification = mIp6Id;\r
\r
  CopyMem (Buffer + Part1Len, &FragmentHead, sizeof (IP6_FRAGMENT_HEADER));\r
\r
  if ((ExtHdrs != NULL) && (Part1Len < ExtHdrsLen)) {\r
    //\r
    // Append the part2 (fragmentable part) of Extension headers\r
    //\r
    CopyMem (\r
      Buffer + Part1Len + sizeof (IP6_FRAGMENT_HEADER),\r
      ExtHdrs + Part1Len,\r
      ExtHdrsLen - Part1Len\r
      );\r
  }\r
\r
  *UpdatedExtHdrs = Buffer;\r
\r
  return EFI_SUCCESS;\r
}\r
\r