nuttx/net/ipfrag/ipv6_frag.c

/****************************************************************************
 * net/ipfrag/ipv6_frag.c
 * Handling incoming IPv6 fragment input
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>
#if defined(CONFIG_NET_IPv6) && defined (CONFIG_NET_IPFRAG)

#include <sys/ioctl.h>
#include <stdint.h>
#include <stdlib.h>
#include <debug.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <net/if.h>

#include <nuttx/kmalloc.h>
#include <nuttx/net/netconfig.h>
#include <nuttx/net/netdev.h>
#include <nuttx/net/netstats.h>
#include <nuttx/net/ip.h>
#include <nuttx/net/ipv6ext.h>

#include "netdev/netdev.h"
#include "inet/inet.h"
#include "ipfrag.h"

/****************************************************************************
 * Private Data
 ****************************************************************************/

/* The increasing number used for the IP ID field of IPv6 Fragment Header. */

static uint32_t g_ipv6id;

/****************************************************************************
 * Private Function Prototypes
 ****************************************************************************/

static int32_t ipv6_fragin_getinfo(FAR struct iob_s *iob,
                                   FAR struct ip_fraglink_s *fraglink);
static uint32_t ipv6_fragin_reassemble(FAR struct ip_fragsnode_s *node);
static inline void
ipv6_fragout_buildipv6header(FAR struct ipv6_hdr_s *ref,
                             FAR struct ipv6_hdr_s *ipv6,
                             uint16_t hdrlen, uint16_t datalen,
                             uint16_t nxthdroff, uint16_t nxtprot);
static inline void
ipv6_fragout_buildipv6fragheader(FAR struct ipv6_fragment_extension_s *frag,
                                 uint8_t nxthdr, uint16_t ipoff,
                                 uint32_t ipid);
static uint16_t ipv6_fragout_getunfraginfo(FAR struct iob_s *iob,
                                           uint16_t *hdroff,
                                           uint16_t *hdrtype);

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: ipv6_fragin_getinfo
 *
 * Description:
 *   Polulate fragment information from the input ipv6 packet data.
 *
 * Input Parameters:
 *   iob      - An IPv6 fragment
 *   fraglink - node of the lower-level linked list, it maintains information
 *              of one fragment
 *
 * Returned Value:
 *   OK    - Got fragment information.
 *   EINVAL - The input ipv6 packet is not a fragment.
 *
 ****************************************************************************/

static int32_t ipv6_fragin_getinfo(FAR struct iob_s *iob,
                                   FAR struct ip_fraglink_s *fraglink)
{
  FAR struct ipv6_hdr_s *ipv6 = (FAR struct ipv6_hdr_s *)
                                (iob->io_data + iob->io_offset);
  FAR struct ipv6_extension_s *exthdr;
  FAR uint8_t *payload;
  uint16_t paylen;
  uint8_t nxthdr;

  paylen  = ((uint16_t)ipv6->len[0] << 8) + (uint16_t)ipv6->len[1];
  payload = (FAR uint8_t *)(ipv6 + 1);
  exthdr  = (FAR struct ipv6_extension_s *)payload;
  nxthdr  = ipv6->proto;

  while (nxthdr != NEXT_FRAGMENT_EH && ipv6_exthdr(nxthdr))
    {
      uint16_t extlen;

      exthdr   = (FAR struct ipv6_extension_s *)payload;
      extlen   = EXTHDR_LEN((unsigned int)exthdr->len);
      payload += extlen;
      paylen  -= extlen;
      nxthdr   = exthdr->nxthdr;
    };

  if (nxthdr == NEXT_FRAGMENT_EH)
    {
      FAR struct ipv6_fragment_extension_s *fraghdr;

      fraghdr = (FAR struct ipv6_fragment_extension_s *)exthdr;

      /* Cut the size of fragment header, notice fragment header don't has a
       * length filed.
       */

      paylen -= EXTHDR_FRAG_LEN;

      fraglink->flink     = NULL;
      fraglink->fragsnode = NULL;

      fraglink->isipv4    = FALSE;
      fraglink->fragoff   = (fraghdr->msoffset << 8) + fraghdr->lsoffset;
      fraglink->morefrags = fraglink->fragoff & 0x1;
      fraglink->fragoff  &= 0xfff8;
      fraglink->fraglen   = paylen;
      fraglink->ipid      = NTOHL(
        ((uint32_t)(*(FAR uint16_t *)(&fraghdr->id[0])) << 16) +
         (uint32_t)(*(FAR uint16_t *)(&fraghdr->id[2])));

      fraglink->frag      = iob;

      return OK;
    }
  else
    {
      return -EINVAL;
    }
}

/****************************************************************************
 * Name: ipv6_fragin_reassemble
 *
 * Description:
 *   Reassemble all ipv6 fragments to build an IP frame.
 *
 * Input Parameters:
 *   node - node of the upper-level linked list, it maintains
 *          information about all fragments belonging to an IP datagram
 *
 * Returned Value:
 *   The length of the reassembled IP frame
 *
 ****************************************************************************/

static uint32_t ipv6_fragin_reassemble(FAR struct ip_fragsnode_s *node)
{
  FAR struct iob_s *head = NULL;
  FAR struct ipv6_hdr_s *ipv6;
  FAR struct ip_fraglink_s *fraglink;

  /* Loop to walk through the fragment list and reassemble those fragments,
   * the fraglink list was ordered by fragment offset value
   */

  fraglink = node->frags;
  node->frags = NULL;

  while (fraglink != NULL)
    {
      FAR uint8_t *payload;
      uint8_t nxthdr;
      FAR struct iob_s *iob;
      FAR struct ip_fraglink_s *linknext;
      FAR struct ipv6_extension_s *exthdr;
      FAR struct ipv6_fragment_extension_s *fraghdr;

      iob     = fraglink->frag;
      ipv6    = (FAR struct ipv6_hdr_s *)(iob->io_data + iob->io_offset);
      payload = (FAR uint8_t *)(ipv6 + 1);
      exthdr  = (FAR struct ipv6_extension_s *)payload;
      nxthdr  = ipv6->proto;

      /* Find fragment header and the front header which is close to the
       * fragment header
       */

      while (nxthdr != NEXT_FRAGMENT_EH && ipv6_exthdr(nxthdr))
        {
          uint16_t extlen;

          exthdr   = (FAR struct ipv6_extension_s *)payload;
          extlen   = EXTHDR_LEN((unsigned int)exthdr->len);
          payload += extlen;
          nxthdr   = exthdr->nxthdr;
        };

      fraghdr  = (FAR struct ipv6_fragment_extension_s *)payload;

      /* Skip fragment header, notice fragment header don't has a length
       * filed
       */

      payload += EXTHDR_FRAG_LEN;

      if (fraglink->fragoff == 0)
        {
          /* This is the zero fragment, Set the front header's next header
           * filed to the next header value of the fragment header
           */

          if (ipv6->proto == NEXT_FRAGMENT_EH)
            {
              ipv6->proto = fraghdr->nxthdr;
            }
          else
            {
              exthdr->nxthdr = fraghdr->nxthdr;
            }

          /* Remove fragment header and fix up the data length */

          memmove(fraghdr, payload,
                  iob->io_len - (payload - (iob->io_data + iob->io_offset)));
          iob->io_len    -= EXTHDR_FRAG_LEN;
          iob->io_pktlen -= EXTHDR_FRAG_LEN;

          /* Remember the head iob */

          head = iob;
        }
      else
        {
          uint16_t new_off;

          /* Fix up the value of offset and length for this none zero
           * fragment
           */

          new_off         = payload - iob->io_data;
          iob->io_len    -= new_off - iob->io_offset;
          iob->io_pktlen -= new_off - iob->io_offset;
          iob->io_offset  = new_off;

          /* Concatenate this iob to the reassembly chain */

          iob_concat(head, iob);
        }

      linknext = fraglink->flink;
      kmm_free(fraglink);
      fraglink = linknext;
    }

  /* Remember the reassembled outgoing IP frame */

  node->outgoframe = head;

  /* Adjust the length value in the IP Header */

  ipv6 = (FAR struct ipv6_hdr_s *)(head->io_data + head->io_offset);
  ipv6->len[0] = (head->io_pktlen - IPv6_HDRLEN) >> 8;
  ipv6->len[1] = (head->io_pktlen - IPv6_HDRLEN) & 0xff;

  return head->io_pktlen;
}

/****************************************************************************
 * Name: ipv6_fragout_buildipv6header
 *
 * Description:
 *   Build IPv6 header for an IPv6 fragment.
 *
 * Input Parameters:
 *   ref    - The reference IPv6 Header
 *   ipv6   - The pointer of the newly generated IPv6 Header
 *   hdrlen - Including the length of IPv6 basic header and all
 *            extention headers
 *   datalen   - The data length follows the IPv6 basic header
 *   nxthdroff - The offset of 'next header' to be updated
 *   nxtprot   - The value of 'next header' to be updated
 *
 * Returned Value:
 *   None
 *
 ****************************************************************************/

static inline void
ipv6_fragout_buildipv6header(FAR struct ipv6_hdr_s *ref,
                             FAR struct ipv6_hdr_s *ipv6,
                             uint16_t hdrlen, uint16_t datalen,
                             uint16_t nxthdroff, uint16_t nxtprot)
{
  if (ref != ipv6)
    {
      /* Copy unfragmentable header data from reference header */

      memcpy(ipv6, ref, hdrlen);
    }

  /* Update length filed */

  ipv6->len[0]      = datalen >> 8;
  ipv6->len[1]      = datalen & 0xff;

  /* If extension headers exist, update the Next Header field in the
   * last extension header of the unfragmentable part; Otherwise update
   * the Next Header field of the basic IPv6 header.
   */

  *((uint8_t *)ipv6 + nxthdroff) = nxtprot;
}

/****************************************************************************
 * Name: ipv6_fragout_buildipv6fragheader
 *
 * Description:
 *   Build IPv6 fragment extension header for an IPv6 fragment.
 *
 * Input Parameters:
 *   frag    - The pointer of the newly generated IPv6 fragment Header
 *   nxthdr  - The first header type in the fragmentable part
 *   ipoff   - Fragment offset
 *   ipid    - The value of IPv6 IP ID
 *
 * Returned Value:
 *   None
 *
 ****************************************************************************/

static inline void
ipv6_fragout_buildipv6fragheader(FAR struct ipv6_fragment_extension_s *frag,
                                 uint8_t nxthdr, uint16_t ipoff,
                                 uint32_t ipid)
{
  frag->nxthdr = nxthdr;
  frag->reserved = 0;
  frag->msoffset = ipoff >> 8;
  frag->lsoffset = ipoff & 0xff;
  *(FAR uint16_t *)&frag->id[0] = HTONL(ipid) & 0xffff;
  *(FAR uint16_t *)&frag->id[2] = HTONL(ipid) >> 16;
}

/****************************************************************************
 * Name: ipv6_fragout_getunfraginfo
 *
 * Description:
 *   Get the length of Unfragmentable Part of the original ipv6 packet,
 *   remember the offset and value of nextheader in the last extension
 *   header of the unfragmentable part.
 *   Refer to rfc2460, section-4.1, section-4.5
 *
 * Input Parameters:
 *   iob     - Outgoing data waiting for fragment
 *   hdroff  - The offset of the last next header position in the
 *             unfragmentable part
 *   hdrtype - The first header type in the fragmentable part
 *
 * Returned Value:
 *   Unfragmentable Part length
 *
 ****************************************************************************/

static uint16_t ipv6_fragout_getunfraginfo(FAR struct iob_s *iob,
                                           uint16_t *hdroff,
                                           uint16_t *hdrtype)
{
  uint32_t     iter = 0;
  bool         destopt = false;
  uint16_t     delta = sizeof(struct ipv6_hdr_s);
  uint16_t     unfraglen = delta;
  uint8_t      nxthdr;
  FAR struct   ipv6_hdr_s *ipv6;
  FAR struct   ipv6_extension_s *exthdr;
  FAR uint8_t *payload;

  ipv6     = (FAR struct ipv6_hdr_s *)(iob->io_data + iob->io_offset);
  payload  = (FAR uint8_t *)(ipv6 + 1);
  exthdr   = (FAR struct ipv6_extension_s *)payload;
  nxthdr   = ipv6->proto;

  *hdroff  = offsetof(struct ipv6_hdr_s, proto);
  *hdrtype = ipv6->proto;

  /* Traverse up to three extension headers, if the Destination Options
   * Header appears repeatedly, ingore the secondary one and end the search.
   * refer to rfc2460, section-4.1
   */

  while (ipv6_exthdr(nxthdr) && iter++ < 3)
    {
      uint16_t extlen;

      exthdr   = (FAR struct ipv6_extension_s *)payload;
      extlen   = EXTHDR_LEN((unsigned int)exthdr->len);

      switch (nxthdr)
        {
          case NEXT_DESTOPT_EH:
            if (!destopt)
              {
                destopt = true;
              }
            else
              {
                /* This is the secondary Destination Options Header,
                 * end the search
                 */

                goto done;
              }

          case NEXT_ROUTING_EH:
          case NEXT_HOPBYBOT_EH:
              unfraglen = delta + extlen;
              *hdroff = delta;
              *hdrtype = exthdr->nxthdr;
        }

      payload += extlen;
      delta   += extlen;
      nxthdr   = exthdr->nxthdr;
    }

done:
  return unfraglen;
}

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: ipv6_fragin
 *
 * Description:
 *   Handling incoming IPv6 fragment input, the input data
 *   (dev->d_iob) can be an I/O buffer chain
 *
 * Input Parameters:
 *   dev    - The NIC device that the fragmented data comes from
 *
 * Returned Value:
 *   ENOMEM - No memory
 *   OK     - The input fragment is processed as expected
 *
 ****************************************************************************/

int32_t ipv6_fragin(FAR struct net_driver_s *dev)
{
  FAR struct ip_fragsnode_s *node = NULL;
  FAR struct ip_fraglink_s *fraginfo = NULL;
  bool restartwdog;

  if (dev->d_len != dev->d_iob->io_pktlen)
    {
      nerr("ERROR: Parameters error.\n");
      return -EINVAL;
    }

  fraginfo = kmm_malloc(sizeof(struct ip_fraglink_s));
  if (fraginfo == NULL)
    {
      nerr("ERROR: Failed to allocate buffer.\n");
      return -ENOMEM;
    }

  /* Polulate fragment information from input packet data */

  ipv6_fragin_getinfo(dev->d_iob, fraginfo);

  nxmutex_lock(&g_ipfrag_lock);

  /* Need to restart reassembly worker if the original linked list is empty */

  restartwdog = ip_fragin_enqueue(dev, fraginfo);

  node = fraginfo->fragsnode;
  if (node->verifyflag & IP_FRAGVERIFY_RECVDALLFRAGS)
    {
      /* Well, all fragments of an IP frame have been received, remove
       * node from link list first, then reassemble and dispatch to the
       * stack.
       */

      ip_frag_remnode(node);

      /* All fragments belonging to one IP frame have been separated
       * from the fragment processing module, unlocks mutex as soon
       * as possible
       */

      nxmutex_unlock(&g_ipfrag_lock);

      /* Reassemble fragments to one IP frame and set the resulting
       * IP frame to dev->d_iob
       */

      ipv6_fragin_reassemble(node);
      netdev_iob_replace(dev, node->outgoframe);

      /* Free the memory of node */

      kmm_free(node);

      return ipv6_input(dev);
    }

  nxmutex_unlock(&g_ipfrag_lock);

  if (restartwdog)
    {
      /* Restart the work queue for fragment processing */

      ip_frag_startwdog();
    }

  return OK;
}

/****************************************************************************
 * Name: ipv6_fragout
 *
 * Description:
 *   Execute the ipv6 fragment function. After this work is done, all
 *   fragments are maintained by dev->d_fragout. In order to reduce the
 *   cyclomatic complexity and facilitate maintenance, fragmentation is
 *   performed in two steps:
 *   1. Reconstruct I/O Buffer according to MTU, which will reserve
 *      the space for the L3 header;
 *   2. Fill the L3 header into the reserved space.
 *
 * Input Parameters:
 *   dev    - The NIC device
 *   mtu    - The MTU of current NIC
 *
 * Returned Value:
 *   0 if success or a negative value if fail.
 *
 * Assumptions:
 *   Data length(dev->d_iob->io_pktlen) is grater than the MTU of
 *   current NIC
 *
 ****************************************************************************/

int32_t ipv6_fragout(FAR struct net_driver_s *dev, uint16_t mtu)
{
  uint16_t unfraglen;
  uint16_t offset = 0;
  uint32_t ipid;
  uint32_t iter;
  uint32_t nfrags;
  uint16_t hdroff;
  uint16_t hdrtype;
  FAR struct iob_s *frag;
  FAR struct ipv6_hdr_s *ref = NULL;
  FAR struct ipv6_fragment_extension_s *fraghdr;
  struct iob_queue_s fragq =
    {
      NULL, NULL
    };

  /* Get the length of Unfragmentable Part of the original ipv6 packet,
   * Get the offset and value of nextheader filed in the last extension
   * header of the unfragmentable part.
   */

  unfraglen = ipv6_fragout_getunfraginfo(dev->d_iob, &hdroff, &hdrtype);

  /* Reconstruct I/O Buffer according to MTU, which will reserve
   * the space for the L3 header
   */

  nfrags = ip_fragout_slice(dev->d_iob, PF_INET6, mtu, unfraglen, &fragq);
  ASSERT(nfrags > 1);
  netdev_iob_clear(dev);

  ipid = ++g_ipv6id;

  /* Fill the L3 header into the reserved space */

  for (iter = 0; iter < nfrags; iter++)
    {
      frag = iob_remove_queue(&fragq);

      if (iter == 0)
        {
          ref = (FAR struct ipv6_hdr_s *)(frag->io_data + frag->io_offset);

          /* Update the IPv6 header for the zero fragment */

          ipv6_fragout_buildipv6header(ref, ref, unfraglen,
                frag->io_pktlen - IPv6_HDRLEN, hdroff, NEXT_FRAGMENT_EH);

          /* Build the fragment header for the zero fragment */

          fraghdr = (FAR struct ipv6_fragment_extension_s *)
                    (frag->io_data + frag->io_offset + unfraglen);
          ipv6_fragout_buildipv6fragheader(fraghdr, hdrtype,
                    FRAGHDR_FRAG_MOREFRAGS, ipid);
        }
      else
        {
          uint16_t ipoff = offset - iter * (unfraglen + EXTHDR_FRAG_LEN);

          if (iter < nfrags - 1)
            {
              ipoff |= FRAGHDR_FRAG_MOREFRAGS;
            }

          /* Refer to the zero fragment ipv6 header to construct the ipv6
           * header of non-zero fragment
           */

          ipv6_fragout_buildipv6header(ref,
                  (FAR struct ipv6_hdr_s *)(frag->io_data + frag->io_offset),
                  unfraglen, frag->io_pktlen - IPv6_HDRLEN, hdroff,
                  NEXT_FRAGMENT_EH);

          /* Build extension fragment header for non-zero fragment */

          fraghdr = (FAR struct ipv6_fragment_extension_s *)
                    (frag->io_data + frag->io_offset + unfraglen);
          ipv6_fragout_buildipv6fragheader(fraghdr, hdrtype, ipoff, ipid);
        }

      /* Enqueue this fragment to dev->d_fragout */

      if (iob_tryadd_queue(frag, &dev->d_fragout) < 0)
        {
          goto fail;
        }

      offset += frag->io_pktlen;
    }

#ifdef CONFIG_NET_STATISTICS
  g_netstats.ipv6.sent += nfrags - 1;
#endif

  netdev_txnotify_dev(dev);

  return OK;

fail:
  netdev_iob_release(dev);
  iob_free_chain(frag);
  iob_free_queue(&fragq);
  iob_free_queue(&dev->d_fragout);
  --g_ipv6id;
  return -ENOMEM;
}

#endif /* CONFIG_NET_IPv6 && CONFIG_NET_IPFRAG */