/*
   * Copyright (C) 2017 Freie Universität Berlin
   *
   * This file is subject to the terms and conditions of the GNU Lesser
   * General Public License v2.1. See the file LICENSE in the top level
   * directory for more details.
   */
  
  /**
   * @{
   *
   * @file
   * @author  Martine Lenders <m.lenders@fu-berlin.de>
   */
  
  #include "net/gnrc/icmpv6.h"
  #include "net/gnrc/ipv6.h"
  #include "net/gnrc/netif.h"
  #ifdef MODULE_GNRC_SIXLOWPAN_ND
  #include "net/gnrc/sixlowpan/nd.h"
  #endif
  #include "net/ndp.h"
  
  #include "net/gnrc/ndp2.h"
  
  #define ENABLE_DEBUG    (0)
  #include "debug.h"
  
  #if ENABLE_DEBUG
  static char addr_str[IPV6_ADDR_MAX_STR_LEN];
  #endif
  
  gnrc_pktsnip_t *gnrc_ndp2_nbr_sol_build(const ipv6_addr_t *tgt,
                                          gnrc_pktsnip_t *options)
  {
      gnrc_pktsnip_t *pkt;
  
      assert((tgt != NULL) && !ipv6_addr_is_multicast(tgt));
      DEBUG("ndp2: building neighbor solicitation message\n");
      pkt = gnrc_icmpv6_build(options, ICMPV6_NBR_SOL, 0, sizeof(ndp_nbr_sol_t));
      if (pkt != NULL) {
          ndp_nbr_sol_t *nbr_sol = pkt->data;
          nbr_sol->resv.u32 = 0;
          nbr_sol->tgt.u64[0].u64 = tgt->u64[0].u64;
          nbr_sol->tgt.u64[1].u64 = tgt->u64[1].u64;
      }
  #if ENABLE_DEBUG
      else {
          DEBUG("ndp2: NS not created due to no space in packet buffer\n");
      }
  #endif
      return pkt;
  }
  
  gnrc_pktsnip_t *gnrc_ndp2_nbr_adv_build(const ipv6_addr_t *tgt, uint8_t flags,
                                          gnrc_pktsnip_t *options)
  {
      gnrc_pktsnip_t *pkt;
  
      assert((tgt != NULL) && !ipv6_addr_is_multicast(tgt));
      DEBUG("ndp2: building neighbor advertisement message\n");
      pkt = gnrc_icmpv6_build(options, ICMPV6_NBR_ADV, 0, sizeof(ndp_nbr_adv_t));
      if (pkt != NULL) {
          ndp_nbr_adv_t *nbr_adv = pkt->data;
          nbr_adv->flags = (flags & NDP_NBR_ADV_FLAGS_MASK);
          nbr_adv->resv[0] = nbr_adv->resv[1] = nbr_adv->resv[2] = 0;
          nbr_adv->tgt.u64[0].u64 = tgt->u64[0].u64;
          nbr_adv->tgt.u64[1].u64 = tgt->u64[1].u64;
      }
  #if ENABLE_DEBUG
      else {
          DEBUG("ndp2: NA not created due to no space in packet buffer\n");
      }
  #endif
      return pkt;
  }
  
  gnrc_pktsnip_t *gnrc_ndp2_rtr_sol_build(gnrc_pktsnip_t *options)
  {
      gnrc_pktsnip_t *pkt;
  
      DEBUG("ndp2: building router solicitation message\n");
      pkt = gnrc_icmpv6_build(options, ICMPV6_RTR_SOL, 0, sizeof(ndp_rtr_sol_t));
      if (pkt != NULL) {
          ndp_rtr_sol_t *rtr_sol = pkt->data;
          rtr_sol->resv.u32 = 0;
      }
  #if ENABLE_DEBUG
      else {
          DEBUG("ndp2: RS not created due to no space in packet buffer\n");
      }
  #endif
      return pkt;
  }
  
  gnrc_pktsnip_t *gnrc_ndp2_rtr_adv_build(uint8_t cur_hl, uint8_t flags,
                                          uint16_t ltime, uint32_t reach_time,
                                          uint32_t retrans_timer,
                                          gnrc_pktsnip_t *options)
  {
      gnrc_pktsnip_t *pkt;
  
      DEBUG("ndp2: building router advertisement message\n");
      pkt = gnrc_icmpv6_build(options, ICMPV6_RTR_ADV, 0, sizeof(ndp_rtr_adv_t));
      if (pkt != NULL) {
          ndp_rtr_adv_t *rtr_adv = pkt->data;
          rtr_adv->cur_hl = cur_hl;
          rtr_adv->flags = (flags & NDP_RTR_ADV_FLAGS_MASK);
          rtr_adv->ltime = byteorder_htons(ltime);
          rtr_adv->reach_time = byteorder_htonl(reach_time);
          rtr_adv->retrans_timer = byteorder_htonl(retrans_timer);
      }
  #if ENABLE_DEBUG
      else {
          DEBUG("ndp2: RA not created due to no space in packet buffer\n");
      }
  #endif
      return pkt;
  }
  
  static inline size_t _ceil8(uint8_t length)
  {
      /* NDP options use units of 8 byte for their length field, so round up */
      return (length + 7U) & 0xf8U;
  }
  
  gnrc_pktsnip_t *gnrc_ndp2_opt_build(uint8_t type, size_t size,
                                      gnrc_pktsnip_t *next)
  {
      gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(next, NULL, _ceil8(size),
                                            GNRC_NETTYPE_UNDEF);
  
      if (pkt != NULL) {
          ndp_opt_t *opt = pkt->data;
          opt->type = type;
          opt->len = (uint8_t)(pkt->size / 8);
      }
  #if ENABLE_DEBUG
      else {
          DEBUG("ndp2: option not created due to no space in packet buffer\n");
      }
  #endif
      return pkt;
  }
  
  static inline gnrc_pktsnip_t *_opt_l2a_build(const uint8_t *l2addr,
                                               uint8_t l2addr_len,
                                               gnrc_pktsnip_t *next,
                                               uint8_t type)
  {
      gnrc_pktsnip_t *pkt = gnrc_ndp2_opt_build(type,
                                                sizeof(ndp_opt_t) + l2addr_len,
                                                next);
  
      if (pkt != NULL) {
          ndp_opt_t *l2a_opt = pkt->data;
  
          memset(l2a_opt + 1, 0, pkt->size - sizeof(ndp_opt_t));
          memcpy(l2a_opt + 1, l2addr, l2addr_len);
      }
      return pkt;
  }
  
  gnrc_pktsnip_t *gnrc_ndp2_opt_sl2a_build(const uint8_t *l2addr,
                                           uint8_t l2addr_len,
                                           gnrc_pktsnip_t *next)
  {
      assert((l2addr != NULL) && (l2addr_len != 0));
      DEBUG("ndp2: building source link-layer address option (l2addr: %s)\n",
            gnrc_netif_addr_to_str(addr_str, sizeof(addr_str), l2addr,
                                   l2addr_len));
      return _opt_l2a_build(l2addr, l2addr_len, next, NDP_OPT_SL2A);
  }
  
  gnrc_pktsnip_t *gnrc_ndp2_opt_tl2a_build(const uint8_t *l2addr,
                                           uint8_t l2addr_len,
                                           gnrc_pktsnip_t *next)
  {
      assert((l2addr != NULL) && (l2addr_len != 0));
      DEBUG("ndp2: building target link-layer address option (l2addr: %s)\n",
            gnrc_netif_addr_to_str(addr_str, sizeof(addr_str), l2addr,
                                   l2addr_len));
      return _opt_l2a_build(l2addr, l2addr_len, next, NDP_OPT_TL2A);
  }
  
  gnrc_pktsnip_t *gnrc_ndp2_opt_pi_build(const ipv6_addr_t *prefix,
                                         uint8_t prefix_len,
                                         uint32_t valid_ltime, uint32_t pref_ltime,
                                         uint8_t flags, gnrc_pktsnip_t *next)
  {
      assert(prefix != NULL);
      assert(!ipv6_addr_is_link_local(prefix) && !ipv6_addr_is_multicast(prefix));
      assert(prefix_len <= 128);
      gnrc_pktsnip_t *pkt = gnrc_ndp2_opt_build(NDP_OPT_PI, sizeof(ndp_opt_pi_t),
                                                next);
  
      if (pkt != NULL) {
          ndp_opt_pi_t *pi_opt = pkt->data;
  
          pi_opt->prefix_len = prefix_len;
          pi_opt->flags = (flags & NDP_OPT_PI_FLAGS_MASK);
          pi_opt->valid_ltime = byteorder_htonl(valid_ltime);
          pi_opt->pref_ltime = byteorder_htonl(pref_ltime);
          pi_opt->resv.u32 = 0;
          /* Bits beyond prefix_len MUST be 0 */
          ipv6_addr_set_unspecified(&pi_opt->prefix);
          ipv6_addr_init_prefix(&pi_opt->prefix, prefix, prefix_len);
      }
      return pkt;
  }
  
  gnrc_pktsnip_t *gnrc_ndp2_opt_mtu_build(uint32_t mtu, gnrc_pktsnip_t *next)
  {
      gnrc_pktsnip_t *pkt = gnrc_ndp2_opt_build(NDP_OPT_MTU,
                                                sizeof(ndp_opt_mtu_t), next);
  
      if (pkt != NULL) {
          ndp_opt_mtu_t *mtu_opt = pkt->data;
  
          mtu_opt->resv.u16 = 0;
          mtu_opt->mtu = byteorder_htonl(mtu);
      }
      return pkt;
  }
  
  static gnrc_pktsnip_t *_build_headers(gnrc_ipv6_netif_t *netif,
                                        const ipv6_addr_t *src,
                                        const ipv6_addr_t *dst,
                                        gnrc_pktsnip_t *payload);
  static size_t _get_l2src(gnrc_ipv6_netif_t *netif, uint8_t *l2src,
                           size_t l2src_maxlen);
  
  void gnrc_ndp2_nbr_sol_send(const ipv6_addr_t *tgt, gnrc_ipv6_netif_t *netif,
                              const ipv6_addr_t *src, const ipv6_addr_t *dst,
                              gnrc_pktsnip_t *ext_opts)
  {
      assert((tgt != NULL) && !ipv6_addr_is_multicast(tgt));
      assert((netif != NULL) && (dst != NULL));
      gnrc_pktsnip_t *hdr, *pkt = ext_opts;
      /* cppcheck-suppress variableScope
       * (reason: also used in MODULE_GNRC_SIXLOWPAN_ND compile path) */
      uint8_t l2src[8];
      /* cppcheck-suppress variableScope
       * (reason: also used in MODULE_GNRC_SIXLOWPAN_ND compile path) */
      size_t l2src_len = 0;
  
      DEBUG("ndp2: send neighbor solicitation (iface: %" PRIkernel_pid ", "
            "src: %s, ", netif->pid,
            ipv6_addr_to_str(addr_str, (src != NULL) ? src : &ipv6_addr_unspecified,
                             sizeof(addr_str)));
      DEBUG("tgt: %s, ", ipv6_addr_to_str(addr_str, tgt, sizeof(addr_str)));
      DEBUG("dst: %s)\n", ipv6_addr_to_str(addr_str, dst, sizeof(addr_str)));
      /* check if there is a fitting source address to target */
      if (src == NULL) {
          src = gnrc_ipv6_netif_find_best_src_addr(netif->pid, tgt, false);
      }
  
      /* add SL2AO based on interface and source address */
      if ((src != NULL) && !ipv6_addr_is_unspecified(src)) {
          l2src_len = _get_l2src(netif, l2src, sizeof(l2src));
  
          if (l2src_len > 0) {
              /* add source address link-layer address option */
              hdr = gnrc_ndp2_opt_sl2a_build(l2src, l2src_len, pkt);
  
              if (hdr == NULL) {
                  DEBUG("ndp2: error allocating SL2AO.\n");
                  gnrc_pktbuf_release(pkt);
                  return;
              }
              pkt = hdr;
          }
      }
      /* add neighbor solicitation header */
      hdr = gnrc_ndp2_nbr_sol_build(tgt, pkt);
      if (hdr == NULL) {
          DEBUG("ndp2: error allocating neighbor solicitation.\n");
          gnrc_pktbuf_release(pkt);
          return;
      }
      pkt = hdr;
      /* add remaining headers */
      hdr = _build_headers(netif, src, dst, pkt);
      if (hdr == NULL) {
          DEBUG("ndp2: error adding lower-layer headers.\n");
          gnrc_pktbuf_release(pkt);
      }
      else if (gnrc_netapi_dispatch_send(GNRC_NETTYPE_NDP2,
                                         GNRC_NETREG_DEMUX_CTX_ALL, hdr) == 0) {
          DEBUG("ndp2: unable to send neighbor solicitation\n");
          gnrc_pktbuf_release(hdr);
      }
  }
  
  void gnrc_ndp2_nbr_adv_send(const ipv6_addr_t *tgt, gnrc_ipv6_netif_t *netif,
                              const ipv6_addr_t *dst, bool supply_tl2a,
                              gnrc_pktsnip_t *ext_opts)
  {
      ipv6_addr_t real_dst;
      gnrc_pktsnip_t *hdr, *pkt = ext_opts;
      uint8_t adv_flags = 0;
  
      assert((tgt != NULL) && !ipv6_addr_is_multicast(tgt));
      assert((netif != NULL) && (dst != NULL));
      DEBUG("ndp2: send neighbor advertisement (iface: %" PRIkernel_pid
            ", tgt: %s, ", netif->pid,
            ipv6_addr_to_str(addr_str, tgt, sizeof(addr_str)));
      DEBUG("dst: %s, supply_tl2a: %d)\n",
            ipv6_addr_to_str(addr_str, dst, sizeof(addr_str)), supply_tl2a);
      if ((netif->flags & GNRC_IPV6_NETIF_FLAGS_ROUTER) &&
          (netif->flags & GNRC_IPV6_NETIF_FLAGS_RTR_ADV)) {
          adv_flags |= NDP_NBR_ADV_FLAGS_R;
      }
      if (ipv6_addr_is_unspecified(dst)) {
          memcpy(&real_dst, &ipv6_addr_all_nodes_link_local, sizeof(ipv6_addr_t));
          supply_tl2a = true;
      }
      else {
          memcpy(&real_dst, dst, sizeof(real_dst));
          adv_flags |= NDP_NBR_ADV_FLAGS_S;
      }
      /* add SL2AO based on target address */
      if (supply_tl2a) {
          uint8_t l2tgt[8];
          size_t l2tgt_len;
          /* we previously checked if we are the target, so we can take our L2tgt */
          l2tgt_len = _get_l2src(netif, l2tgt, sizeof(l2tgt));
  
          if (l2tgt_len > 0) {
              /* add target address link-layer address option */
              hdr = gnrc_ndp2_opt_tl2a_build(l2tgt, l2tgt_len, pkt);
  
              if (hdr == NULL) {
                  DEBUG("ndp2: error allocating TL2AO.\n");
                  gnrc_pktbuf_release(ext_opts);
                  return;
              }
              pkt = hdr;
          }
      }
      /* TODO: also check if the node provides proxy services for tgt */
      if ((pkt != NULL) &&
          (!gnrc_ipv6_netif_addr_is_non_unicast(tgt) || supply_tl2a)) {
          /* TL2A is not supplied and tgt is not anycast */
          adv_flags |= NDP_NBR_ADV_FLAGS_O;
      }
      /* add neighbor advertisement header */
      hdr = gnrc_ndp2_nbr_adv_build(tgt, adv_flags, pkt);
      if (hdr == NULL) {
          DEBUG("ndp2: error allocating neighbor advertisement.\n");
          gnrc_pktbuf_release(pkt);
          return;
      }
      pkt = hdr;
      /* add remaining headers */
      hdr = _build_headers(netif, NULL, &real_dst, pkt);
      if (hdr == NULL) {
          DEBUG("ndp2: error adding lower-layer headers.\n");
          gnrc_pktbuf_release(pkt);
      }
      else if (gnrc_netapi_dispatch_send(GNRC_NETTYPE_NDP2,
                                         GNRC_NETREG_DEMUX_CTX_ALL, hdr) == 0) {
          DEBUG("ndp2: unable to send neighbor advertisement\n");
          gnrc_pktbuf_release(hdr);
      }
  }
  
  void gnrc_ndp2_rtr_sol_send(gnrc_ipv6_netif_t *netif, const ipv6_addr_t *dst)
  {
      gnrc_pktsnip_t *hdr, *pkt = NULL;
      ipv6_addr_t *src = NULL;
  
      assert(netif != NULL);
      if (dst == NULL) {
          dst = &ipv6_addr_all_routers_link_local;
      }
      DEBUG("ndp2: send router solicitation (iface: %" PRIkernel_pid
            ", dst: %s)\n", netif->pid,
            ipv6_addr_to_str(addr_str, dst, sizeof(addr_str)));
      /* add SL2AO => check if there is a fitting source address to target */
      if ((src = gnrc_ipv6_netif_find_best_src_addr(netif->pid, dst,
                                                    false)) != NULL) {
          uint8_t l2src[8];
          size_t l2src_len = _get_l2src(netif, l2src, sizeof(l2src));
          if (l2src_len > 0) {
              /* add source address link-layer address option */
              pkt = gnrc_ndp2_opt_sl2a_build(l2src, l2src_len, NULL);
              if (pkt == NULL) {
                  DEBUG("ndp2: error allocating SL2AO.\n");
                  gnrc_pktbuf_release(pkt);
                  return;
              }
          }
      }
      /* add router solicitation header */
      hdr = gnrc_ndp2_rtr_sol_build(pkt);
      if (hdr == NULL) {
          DEBUG("ndp2: error allocating router solicitation.\n");
          gnrc_pktbuf_release(pkt);
          return;
      }
      pkt = hdr;
      /* add remaining headers */
      hdr = _build_headers(netif, src, dst, pkt);
      if (hdr == NULL) {
          DEBUG("ndp2: error adding lower-layer headers.\n");
          gnrc_pktbuf_release(pkt);
      }
      else if (gnrc_netapi_dispatch_send(GNRC_NETTYPE_NDP2,
                                         GNRC_NETREG_DEMUX_CTX_ALL, hdr) == 0) {
          DEBUG("ndp2: unable to send router advertisement\n");
          gnrc_pktbuf_release(hdr);
      }
  }
  
  void gnrc_ndp2_rtr_adv_send(gnrc_ipv6_netif_t *netif, const ipv6_addr_t *src,
                              const ipv6_addr_t *dst, bool fin,
                              gnrc_pktsnip_t *ext_opts)
  {
  #if GNRC_IPV6_NIB_CONF_ROUTER
      gnrc_pktsnip_t *hdr = NULL, *pkt = ext_opts;
      uint32_t reach_time = 0, retrans_timer = 0;
      uint16_t adv_ltime = 0;
      uint8_t cur_hl = 0;
  
      if (dst == NULL) {
          dst = &ipv6_addr_all_nodes_link_local;
      }
      DEBUG("ndp2: send router advertisement (iface: %" PRIkernel_pid ", dst: %s%s\n",
            netif->pid, ipv6_addr_to_str(addr_str, dst, sizeof(addr_str)),
            fin ? ", final" : "");
      if (netif->flags & GNRC_IPV6_NETIF_FLAGS_ADV_MTU) {
          if ((hdr = gnrc_ndp2_opt_mtu_build(netif->mtu, pkt)) == NULL) {
              DEBUG("ndp rtr: no space left in packet buffer\n");
              return;
          }
          pkt = hdr;
      }
      if (src == NULL) {
          /* get address from source selection algorithm.
           * Only link local addresses may be used (RFC 4861 section 4.1) */
          src = gnrc_ipv6_netif_find_best_src_addr(netif->pid, dst, true);
      }
      /* add SL2A for source address */
      if (src != NULL) {
          DEBUG(" - SL2A\n");
          uint8_t l2src[8];
          size_t l2src_len;
          /* optimization note: MAY also be omitted to facilitate in-bound load balancing over
           * replicated interfaces.
           * source: https://tools.ietf.org/html/rfc4861#section-6.2.3 */
          l2src_len = _get_l2src(netif, l2src, sizeof(l2src));
          if (l2src_len > 0) {
              /* add source address link-layer address option */
              hdr = gnrc_ndp2_opt_sl2a_build(l2src, l2src_len, pkt);
  
              if (hdr == NULL) {
                  DEBUG("ndp2: error allocating Source Link-layer address option.\n");
                  gnrc_pktbuf_release(pkt);
                  return;
              }
              pkt = hdr;
          }
      }
      if (netif->flags & GNRC_IPV6_NETIF_FLAGS_ADV_CUR_HL) {
          cur_hl = netif->cur_hl;
      }
      if (netif->flags & GNRC_IPV6_NETIF_FLAGS_ADV_REACH_TIME) {
  
          if (netif->reach_time > (3600 * US_PER_SEC)) { /* reach_time > 1 hour */
              reach_time = (3600 * MS_PER_SEC);
          }
          else {
              reach_time = netif->reach_time / US_PER_MS;
          }
      }
      if (netif->flags & GNRC_IPV6_NETIF_FLAGS_ADV_RETRANS_TIMER) {
          retrans_timer = netif->retrans_timer / US_PER_MS;
      }
      if (!fin) {
          /* TODO set netif dependent adv_ltime */
          adv_ltime = 1800U;
      }
      hdr = gnrc_ndp2_rtr_adv_build(cur_hl,
                                    (netif->flags & (GNRC_IPV6_NETIF_FLAGS_OTHER_CONF |
                                                          GNRC_IPV6_NETIF_FLAGS_MANAGED)) >> 8,
                                    adv_ltime, reach_time, retrans_timer, pkt);
      if (hdr == NULL) {
          DEBUG("ndp2: error allocating router advertisement.\n");
          gnrc_pktbuf_release(pkt);
          return;
      }
      pkt = hdr;
      hdr = _build_headers(netif, src, dst, pkt);
      if (hdr == NULL) {
          DEBUG("ndp2: error adding lower-layer headers.\n");
          gnrc_pktbuf_release(pkt);
      }
      else if (gnrc_netapi_dispatch_send(GNRC_NETTYPE_NDP2,
                                         GNRC_NETREG_DEMUX_CTX_ALL, hdr) == 0) {
          DEBUG("ndp2: unable to send router solicitation\n");
          gnrc_pktbuf_release(hdr);
      }
  #else
      (void)netif;
      (void)src;
      (void)dst;
      (void)fin;
      DEBUG("ndp2: not a router, dropping ext_opts\n");
      gnrc_pktbuf_release(ext_opts);
  #endif  /* GNRC_IPV6_NIB_CONF_ROUTER */
  }
  
  static gnrc_pktsnip_t *_build_headers(gnrc_ipv6_netif_t *netif,
                                        const ipv6_addr_t *src,
                                        const ipv6_addr_t *dst,
                                        gnrc_pktsnip_t *payload)
  {
      gnrc_pktsnip_t *l2hdr;
      gnrc_pktsnip_t *iphdr = gnrc_ipv6_hdr_build(payload, src, dst);
  
      if (iphdr == NULL) {
          DEBUG("ndp2: error allocating IPv6 header.\n");
          return NULL;
      }
      ((ipv6_hdr_t *)iphdr->data)->hl = 255;
      /* add netif header for send interface specification */
      l2hdr = gnrc_netif_hdr_build(NULL, 0, NULL, 0);
      if (l2hdr == NULL) {
          DEBUG("ndp2: error allocating netif header.\n");
          gnrc_pktbuf_remove_snip(iphdr, iphdr);
          return NULL;
      }
      ((gnrc_netif_hdr_t *)l2hdr->data)->if_pid = netif->pid;
      LL_PREPEND(iphdr, l2hdr);
      return l2hdr;
  }
  
  static size_t _get_l2src(gnrc_ipv6_netif_t *netif, uint8_t *l2src,
                           size_t l2src_maxlen)
  {
      bool try_long = false;
      int res;
      uint16_t l2src_len;
      /* maximum address length that fits into a minimum length (8) S/TL2A option */
      const uint16_t max_short_len = 6;
  
      /* try getting source address */
      if ((gnrc_netapi_get(netif->pid, NETOPT_SRC_LEN, 0, &l2src_len,
                           sizeof(l2src_len)) >= 0) &&
          (l2src_len > max_short_len)) {
          try_long = true;
      }
  
      if (try_long && ((res = gnrc_netapi_get(netif->pid, NETOPT_ADDRESS_LONG, 0,
                                              l2src,
                                              l2src_maxlen)) > max_short_len)) {
          l2src_len = (uint16_t)res;
      }
      else if ((res = gnrc_netapi_get(netif->pid, NETOPT_ADDRESS, 0, l2src,
                                      l2src_maxlen)) >= 0) {
          l2src_len = (uint16_t)res;
      }
      else {
          DEBUG("ndp2: no link-layer address found.\n");
          l2src_len = 0;
      }
  
      return l2src_len;
  }
  
  /** @} */