/** @file
  IP6 option support functions and routines.

  Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>

  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "Ip6Impl.h"

/**
  Validate the IP6 option format for both the packets we received
  and that we will transmit. It will compute the ICMPv6 error message fields
  if the option is malformatted.

  @param[in]  IpSb              The IP6 service data.
  @param[in]  Packet            The to be validated packet.
  @param[in]  Option            The first byte of the option.
  @param[in]  OptionLen         The length of the whole option.
  @param[in]  Pointer           Identifies the octet offset within
                                the invoking packet where the error was detected.


  @retval TRUE     The option is properly formatted.
  @retval FALSE    The option is malformatted.

**/
BOOLEAN
Ip6IsOptionValid (
  IN IP6_SERVICE            *IpSb,
  IN NET_BUF                *Packet,
  IN UINT8                  *Option,
  IN UINT8                  OptionLen,
  IN UINT32                 Pointer
  )
{
  UINT8                      Offset;
  UINT8                      OptionType;

  Offset = 0;

  while (Offset < OptionLen) {
    OptionType = *(Option + Offset);

    switch (OptionType) {
    case Ip6OptionPad1:
      //
      // It is a Pad1 option
      //
      Offset++;
      break;
    case Ip6OptionPadN:
      //
      // It is a PadN option
      //
      Offset = (UINT8) (Offset + *(Option + Offset + 1) + 2);
      break;
    case Ip6OptionRouterAlert:
      //
      // It is a Router Alert Option
      //
      Offset += 4;
      break;
    default:
      //
      // The highest-order two bits specify the action must be taken if
      // the processing IPv6 node does not recognize the option type.
      //
      switch (OptionType & Ip6OptionMask) {
      case Ip6OptionSkip:
        Offset = (UINT8) (Offset + *(Option + Offset + 1));
        break;
      case Ip6OptionDiscard:
        return FALSE;
      case Ip6OptionParameterProblem:
        Pointer = Pointer + Offset + sizeof (EFI_IP6_HEADER);
        Ip6SendIcmpError (
          IpSb,
          Packet,
          NULL,
          &Packet->Ip.Ip6->SourceAddress,
          ICMP_V6_PARAMETER_PROBLEM,
          2,
          &Pointer
          );
        return FALSE;
      case Ip6OptionMask:
        if (!IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {
          Pointer = Pointer + Offset + sizeof (EFI_IP6_HEADER);
          Ip6SendIcmpError (
            IpSb,
            Packet,
            NULL,
            &Packet->Ip.Ip6->SourceAddress,
            ICMP_V6_PARAMETER_PROBLEM,
            2,
            &Pointer
            );
        }

        return FALSE;
        break;
      }

      break;
    }

  }

  return TRUE;
}

/**
  Validate the IP6 option format for both the packets we received
  and that we will transmit. It supports the defined options in Neighbor
  Discovery messages.

  @param[in]  Option            The first byte of the option.
  @param[in]  OptionLen         The length of the whole option.

  @retval TRUE     The option is properly formatted.
  @retval FALSE    The option is malformatted.

**/
BOOLEAN
Ip6IsNDOptionValid (
  IN UINT8                  *Option,
  IN UINT16                 OptionLen
  )
{
  UINT16                    Offset;
  UINT8                     OptionType;
  UINT16                    Length;

  Offset = 0;

  while (Offset < OptionLen) {
    OptionType = *(Option + Offset);
     Length    = (UINT16) (*(Option + Offset + 1) * 8);

    switch (OptionType) {
    case Ip6OptionPrefixInfo:
      if (Length != 32) {
        return FALSE;
      }

      break;

    case Ip6OptionMtu:
      if (Length != 8) {
        return FALSE;
      }

      break;

    default:
      //
      // Check the length of Ip6OptionEtherSource, Ip6OptionEtherTarget, and
      // Ip6OptionRedirected here. For unrecognized options, silently ignore
      // and continue processsing the message.
      //
      if (Length == 0) {
        return FALSE;
      }

      break;
    }

    Offset = (UINT16) (Offset + Length);
  }

  return TRUE;
}


/**
  Validate whether the NextHeader is a known valid protocol or one of the user configured
  protocols from the upper layer.

  @param[in]  IpSb          The IP6 service instance.
  @param[in]  NextHeader    The next header field.

  @retval TRUE              The NextHeader is a known valid protocol or user configured.
  @retval FALSE             The NextHeader is not a known valid protocol.

**/
BOOLEAN
Ip6IsValidProtocol (
  IN IP6_SERVICE            *IpSb,
  IN UINT8                  NextHeader
  )
{
  LIST_ENTRY                *Entry;
  IP6_PROTOCOL              *IpInstance;

  if (NextHeader == EFI_IP_PROTO_TCP ||
      NextHeader == EFI_IP_PROTO_UDP ||
      NextHeader == IP6_ICMP ||
      NextHeader == IP6_ESP
      ) {
    return TRUE;
  }

  if (IpSb == NULL) {
    return FALSE;
  }

  if (IpSb->Signature != IP6_SERVICE_SIGNATURE) {
    return FALSE;
  }

  NET_LIST_FOR_EACH (Entry, &IpSb->Children) {
    IpInstance = NET_LIST_USER_STRUCT_S (Entry, IP6_PROTOCOL, Link, IP6_PROTOCOL_SIGNATURE);
    if (IpInstance->State == IP6_STATE_CONFIGED) {
      if (IpInstance->ConfigData.DefaultProtocol == NextHeader) {
        return TRUE;
      }
    }
  }

  return FALSE;
}

/**
  Validate the IP6 extension header format for both the packets we received
  and that we will transmit. It will compute the ICMPv6 error message fields
  if the option is mal-formatted.

  @param[in]  IpSb          The IP6 service instance. This is an optional parameter.
  @param[in]  Packet        The data of the packet. Ignored if NULL.
  @param[in]  NextHeader    The next header field in IPv6 basic header.
  @param[in]  ExtHdrs       The first byte of the option.
  @param[in]  ExtHdrsLen    The length of the whole option.
  @param[in]  Rcvd          The option is from the packet we received if TRUE,
                            otherwise, the option we want to transmit.
  @param[out] FormerHeader  The offset of NextHeader which points to Fragment
                            Header when we received, of the ExtHdrs.
                            Ignored if we transmit.
  @param[out] LastHeader    The pointer of NextHeader of the last extension
                            header processed by IP6.
  @param[out] RealExtsLen   The length of extension headers processed by IP6 layer.
                            This is an optional parameter that may be NULL.
  @param[out] UnFragmentLen The length of unfragmented length of extension headers.
                            This is an optional parameter that may be NULL.
  @param[out] Fragmented    Indicate whether the packet is fragmented.
                            This is an optional parameter that may be NULL.

  @retval     TRUE          The option is properly formatted.
  @retval     FALSE         The option is malformatted.

**/
BOOLEAN
Ip6IsExtsValid (
  IN IP6_SERVICE            *IpSb           OPTIONAL,
  IN NET_BUF                *Packet         OPTIONAL,
  IN UINT8                  *NextHeader,
  IN UINT8                  *ExtHdrs,
  IN UINT32                 ExtHdrsLen,
  IN BOOLEAN                Rcvd,
  OUT UINT32                *FormerHeader   OPTIONAL,
  OUT UINT8                 **LastHeader,
  OUT UINT32                *RealExtsLen    OPTIONAL,
  OUT UINT32                *UnFragmentLen  OPTIONAL,
  OUT BOOLEAN               *Fragmented     OPTIONAL
  )
{
  UINT32                     Pointer;
  UINT32                     Offset;
  UINT8                      *Option;
  UINT8                      OptionLen;
  BOOLEAN                    Flag;
  UINT8                      CountD;
  UINT8                      CountA;
  IP6_FRAGMENT_HEADER        *FragmentHead;
  UINT16                     FragmentOffset;
  IP6_ROUTING_HEADER         *RoutingHead;

  if (RealExtsLen != NULL) {
    *RealExtsLen = 0;
  }

  if (UnFragmentLen != NULL) {
    *UnFragmentLen = 0;
  }

  if (Fragmented != NULL) {
    *Fragmented = FALSE;
  }

  *LastHeader = NextHeader;

  if (ExtHdrs == NULL && ExtHdrsLen == 0) {
    return TRUE;
  }

  if ((ExtHdrs == NULL && ExtHdrsLen != 0) || (ExtHdrs != NULL && ExtHdrsLen == 0)) {
    return FALSE;
  }

  Pointer = 0;
  Offset  = 0;
  Flag    = FALSE;
  CountD  = 0;
  CountA  = 0;

  while (Offset <= ExtHdrsLen) {

    switch (*NextHeader) {
    case IP6_HOP_BY_HOP:
      if (Offset != 0) {
        if (!Rcvd) {
          return FALSE;
        }
        //
        // Hop-by-Hop Options header is restricted to appear immediately after an IPv6 header only.
        // If not, generate a ICMP parameter problem message with code value of 1.
        //
        if (Pointer == 0) {
          Pointer = sizeof (EFI_IP6_HEADER);
        } else {
          Pointer = Offset + sizeof (EFI_IP6_HEADER);
        }

        if ((IpSb != NULL) && (Packet != NULL) &&
            !IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {
          Ip6SendIcmpError (
            IpSb,
            Packet,
            NULL,
            &Packet->Ip.Ip6->SourceAddress,
            ICMP_V6_PARAMETER_PROBLEM,
            1,
            &Pointer
            );
        }
        return FALSE;
      }

      Flag = TRUE;

    //
    // Fall through
    //
    case IP6_DESTINATION:
      if (*NextHeader == IP6_DESTINATION) {
        CountD++;
      }

      if (CountD > 2) {
        return FALSE;
      }

      NextHeader = ExtHdrs + Offset;
      Pointer    = Offset;

      Offset++;
      Option     = ExtHdrs + Offset;
      OptionLen  = (UINT8) ((*Option + 1) * 8 - 2);
      Option++;
      Offset++;

      if (IpSb != NULL && Packet != NULL && !Ip6IsOptionValid (IpSb, Packet, Option, OptionLen, Offset)) {
        return FALSE;
      }

      Offset = Offset + OptionLen;

      if (Flag) {
        if (UnFragmentLen != NULL) {
          *UnFragmentLen = Offset;
        }

        Flag = FALSE;
      }

      break;

    case IP6_ROUTING:
      NextHeader = ExtHdrs + Offset;
      RoutingHead = (IP6_ROUTING_HEADER *) NextHeader;

      //
      // Type 0 routing header is defined in RFC2460 and deprecated in RFC5095.
      // Thus all routing types are processed as unrecognized.
      //
      if (RoutingHead->SegmentsLeft == 0) {
        //
        // Ignore the routing header and proceed to process the next header.
        //
        Offset = Offset + (RoutingHead->HeaderLen + 1) * 8;

        if (UnFragmentLen != NULL) {
          *UnFragmentLen = Offset;
        }

      } else {
        //
        // Discard the packet and send an ICMP Parameter Problem, Code 0, message
        // to the packet's source address, pointing to the unrecognized routing
        // type.
        //
        Pointer = Offset + 2 + sizeof (EFI_IP6_HEADER);
        if ((IpSb != NULL) && (Packet != NULL) &&
            !IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {
          Ip6SendIcmpError (
            IpSb,
            Packet,
            NULL,
            &Packet->Ip.Ip6->SourceAddress,
            ICMP_V6_PARAMETER_PROBLEM,
            0,
            &Pointer
            );
        }

        return FALSE;
      }

      break;

    case IP6_FRAGMENT:

      //
      // RFC2402, AH header should after fragment header.
      //
      if (CountA > 1) {
        return FALSE;
      }

      //
      // RFC2460, ICMP Parameter Problem message with code 0 should be sent
      // if the length of a fragment is not a multiple of 8 octets and the M
      // flag of that fragment is 1, pointing to the Payload length field of the
      // fragment packet.
      //
      if (IpSb != NULL && Packet != NULL && (ExtHdrsLen % 8) != 0) {
        //
        // Check whether it is the last fragment.
        //
        FragmentHead = (IP6_FRAGMENT_HEADER *) (ExtHdrs + Offset);
        if (FragmentHead == NULL) {
          return FALSE;
        }

        FragmentOffset = NTOHS (FragmentHead->FragmentOffset);

        if (((FragmentOffset & 0x1) == 0x1) &&
            !IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {
          Pointer = sizeof (UINT32);
          Ip6SendIcmpError (
            IpSb,
            Packet,
            NULL,
            &Packet->Ip.Ip6->SourceAddress,
            ICMP_V6_PARAMETER_PROBLEM,
            0,
            &Pointer
            );
          return FALSE;
        }
      }

      if (Fragmented != NULL) {
        *Fragmented = TRUE;
      }

      if (Rcvd && FormerHeader != NULL) {
        *FormerHeader = (UINT32) (NextHeader - ExtHdrs);
      }

      NextHeader = ExtHdrs + Offset;
      Offset     = Offset + 8;
      break;

    case IP6_AH:
      if (++CountA > 1) {
        return FALSE;
      }

      Option     = ExtHdrs + Offset;
      NextHeader = Option;
      Option++;
      //
      // RFC2402, Payload length is specified in 32-bit words, minus "2".
      //
      OptionLen  = (UINT8) ((*Option + 2) * 4);
      Offset     = Offset + OptionLen;
      break;

    case IP6_NO_NEXT_HEADER:
      *LastHeader = NextHeader;
      return FALSE;
      break;

    default:
      if (Ip6IsValidProtocol (IpSb, *NextHeader)) {

        *LastHeader = NextHeader;

        if (RealExtsLen != NULL) {
          *RealExtsLen = Offset;
        }

        return TRUE;
      }

      //
      // The Next Header value is unrecognized by the node, discard the packet and
      // send an ICMP parameter problem message with code value of 1.
      //
      if (Offset == 0) {
        //
        // The Next Header directly follows IPv6 basic header.
        //
        Pointer = 6;
      } else {
        if (Pointer == 0) {
          Pointer = sizeof (EFI_IP6_HEADER);
        } else {
          Pointer = Offset + sizeof (EFI_IP6_HEADER);
        }
      }

      if ((IpSb != NULL) && (Packet != NULL) &&
          !IP6_IS_MULTICAST (&Packet->Ip.Ip6->DestinationAddress)) {
        Ip6SendIcmpError (
          IpSb,
          Packet,
          NULL,
          &Packet->Ip.Ip6->SourceAddress,
          ICMP_V6_PARAMETER_PROBLEM,
          1,
          &Pointer
          );
      }
      return FALSE;
    }
  }

  *LastHeader = NextHeader;

  if (RealExtsLen != NULL) {
    *RealExtsLen = Offset;
  }

  return TRUE;
}

/**
  Generate an IPv6 router alert option in network order and output it through Buffer.

  @param[out]     Buffer         Points to a buffer to record the generated option.
  @param[in, out] BufferLen      The length of Buffer, in bytes.
  @param[in]      NextHeader     The 8-bit selector indicates the type of header
                                 immediately following the Hop-by-Hop Options header.

  @retval EFI_BUFFER_TOO_SMALL   The Buffer is too small to contain the generated
                                 option. BufferLen is updated for the required size.

  @retval EFI_SUCCESS            The option is generated and filled in to Buffer.

**/
EFI_STATUS
Ip6FillHopByHop (
  OUT UINT8                  *Buffer,
  IN OUT UINTN               *BufferLen,
  IN UINT8                   NextHeader
  )
{
  UINT8                      BufferArray[8];

  if (*BufferLen < 8) {
    *BufferLen = 8;
    return EFI_BUFFER_TOO_SMALL;
  }

  //
  // Form the Hop-By-Hop option in network order.
  // NextHeader (1 octet) + HdrExtLen (1 octet) + RouterAlertOption(4 octets) + PadN
  // The Hdr Ext Len is the length in 8-octet units, and does not including the first 8 octets.
  //
  ZeroMem (BufferArray, sizeof (BufferArray));
  BufferArray[0] = NextHeader;
  BufferArray[2] = 0x5;
  BufferArray[3] = 0x2;
  BufferArray[6] = 1;

  CopyMem (Buffer, BufferArray, sizeof (BufferArray));
  return EFI_SUCCESS;
}

/**
  Insert a Fragment Header to the Extension headers and output it in UpdatedExtHdrs.

  @param[in]  IpSb             The IP6 service instance to transmit the packet.
  @param[in]  NextHeader       The extension header type of first extension header.
  @param[in]  LastHeader       The extension header type of last extension header.
  @param[in]  ExtHdrs          The length of the original extension header.
  @param[in]  ExtHdrsLen       The length of the extension headers.
  @param[in]  FragmentOffset   The fragment offset of the data following the header.
  @param[out] UpdatedExtHdrs   The updated ExtHdrs with Fragment header inserted.
                               It's caller's responsibility to free this buffer.

  @retval EFI_OUT_OF_RESOURCES Failed to finish the operation due to lake of
                               resource.
  @retval EFI_UNSUPPORTED      The extension header specified in ExtHdrs is not
                               supported currently.
  @retval EFI_SUCCESS          The operation performed successfully.

**/
EFI_STATUS
Ip6FillFragmentHeader (
  IN  IP6_SERVICE           *IpSb,
  IN  UINT8                 NextHeader,
  IN  UINT8                 LastHeader,
  IN  UINT8                 *ExtHdrs,
  IN  UINT32                ExtHdrsLen,
  IN  UINT16                FragmentOffset,
  OUT UINT8                 **UpdatedExtHdrs
  )
{
  UINT32                    Length;
  UINT8                     *Buffer;
  UINT32                    FormerHeader;
  UINT32                    Offset;
  UINT32                    Part1Len;
  UINT32                    HeaderLen;
  UINT8                     Current;
  IP6_FRAGMENT_HEADER       FragmentHead;

  if (UpdatedExtHdrs == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  Length = ExtHdrsLen + sizeof (IP6_FRAGMENT_HEADER);
  Buffer = AllocatePool (Length);
  if (Buffer == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  Offset         = 0;
  Part1Len       = 0;
  FormerHeader   = 0;
  Current        = NextHeader;

  while ((ExtHdrs != NULL) && (Offset <= ExtHdrsLen)) {
    switch (NextHeader) {
    case IP6_ROUTING:
    case IP6_HOP_BY_HOP:
    case IP6_DESTINATION:
      Current      = NextHeader;
      NextHeader   = *(ExtHdrs + Offset);

      if ((Current == IP6_DESTINATION) && (NextHeader != IP6_ROUTING)) {
        //
        // Destination Options header should occur at most twice, once before
        // a Routing header and once before the upper-layer header. Here we
        // find the one before the upper-layer header. Insert the Fragment
        // Header before it.
        //
        CopyMem (Buffer, ExtHdrs, Part1Len);
        *(Buffer + FormerHeader) = IP6_FRAGMENT;
        //
        // Exit the loop.
        //
        Offset = ExtHdrsLen + 1;
        break;
      }


      FormerHeader = Offset;
      HeaderLen    = (*(ExtHdrs + Offset + 1) + 1) * 8;
      Part1Len     = Part1Len + HeaderLen;
      Offset       = Offset + HeaderLen;
      break;

    case IP6_FRAGMENT:
      Current    = NextHeader;

      if (Part1Len != 0) {
        CopyMem (Buffer, ExtHdrs, Part1Len);
      }

      *(Buffer + FormerHeader) = IP6_FRAGMENT;

      //
      // Exit the loop.
      //
      Offset = ExtHdrsLen + 1;
      break;

    case IP6_AH:
      Current    = NextHeader;
      NextHeader = *(ExtHdrs + Offset);
      //
      // RFC2402, Payload length is specified in 32-bit words, minus "2".
      //
      HeaderLen  = (*(ExtHdrs + Offset + 1) + 2) * 4;
      Part1Len   = Part1Len + HeaderLen;
      Offset     = Offset + HeaderLen;
      break;

    default:
      if (Ip6IsValidProtocol (IpSb, NextHeader)) {
        Current = NextHeader;
        CopyMem (Buffer, ExtHdrs, Part1Len);
        *(Buffer + FormerHeader) = IP6_FRAGMENT;
        //
        // Exit the loop.
        //
        Offset = ExtHdrsLen + 1;
        break;
      }

      FreePool (Buffer);
      return EFI_UNSUPPORTED;
    }
  }

  //
  // Append the Fragment header. If the fragment offset indicates the fragment
  // is the first fragment.
  //
  if ((FragmentOffset & IP6_FRAGMENT_OFFSET_MASK) == 0) {
    FragmentHead.NextHeader = Current;
  } else {
    FragmentHead.NextHeader = LastHeader;
  }

  FragmentHead.Reserved       = 0;
  FragmentHead.FragmentOffset = HTONS (FragmentOffset);
  FragmentHead.Identification = mIp6Id;

  CopyMem (Buffer + Part1Len, &FragmentHead, sizeof (IP6_FRAGMENT_HEADER));

  if ((ExtHdrs != NULL) && (Part1Len < ExtHdrsLen)) {
    //
    // Append the part2 (fragmentable part) of Extension headers
    //
    CopyMem (
      Buffer + Part1Len + sizeof (IP6_FRAGMENT_HEADER),
      ExtHdrs + Part1Len,
      ExtHdrsLen - Part1Len
      );
  }

  *UpdatedExtHdrs = Buffer;

  return EFI_SUCCESS;
}