/*

 *   This library is free software; you can redistribute it and/or

 *   modify it under the terms of the GNU Lesser General Public

 *   License as published by the Free Software Foundation; either

 *   version 2.1 of the License, or (at your option) any later version.

 *

 *   This library is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

 *   Lesser General Public License for more details.

 *

 *   You should have received a copy of the GNU Lesser General Public

 *   License along with this library; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA

 */

/**

 * $Id: 85e1cdf59923173579798d0f0ce5826c3386c2d8 $

 *

 * @file protocols/dhcpv6/decode.c

 * @brief Functions to decode DHCP options.

 *

 * @author Arran Cudbard-Bell (a.cudbardb@freeradius.org)

 *

 * @copyright 2018 The FreeRADIUS server project

 * @copyright 2018 NetworkRADIUS SARL (legal@networkradius.com)

 */

#include <stdint.h>

#include <stddef.h>

#include <freeradius-devel/io/test_point.h>

#include <freeradius-devel/util/dns.h>

#include <freeradius-devel/util/proto.h>

#include <freeradius-devel/util/struct.h>

#include "dhcpv6.h"

#include "attrs.h"

/*

 *    RFC 8415 Section 21.7 defines option codes that MUST NOT appear

 *    in an Option Request option.  We convert the attributes to a

 *    64-bit number which can be easily checked.

 */

#define DHCPV6_ORO_FORBIDDEN          \

  ((1ULL << 1)  |  /* OPTION_CLIENTID */      \

   (1ULL << 2)  |  /* OPTION_SERVERID */      \

   (1ULL << 3)  |  /* OPTION_IA_NA */     \

   (1ULL << 4)  |  /* OPTION_IA_TA */     \

   (1ULL << 5)  |  /* OPTION_IAADDR */      \

   (1ULL << 6)  |  /* OPTION_ORO */     \

   (1ULL << 7)  |  /* OPTION_PREFERENCE */    \

   (1ULL << 8)  |  /* OPTION_ELAPSED_TIME */  \

   (1ULL << 9)  |  /* OPTION_RELAY_MSG */     \

   (1ULL << 11) |  /* OPTION_AUTH */      \

   (1ULL << 12) |  /* OPTION_UNICAST */     \

   (1ULL << 13) |  /* OPTION_STATUS_CODE */   \

   (1ULL << 14) |  /* OPTION_RAPID_COMMIT */  \

   (1ULL << 15) |  /* OPTION_USER_CLASS */    \

   (1ULL << 16) |  /* OPTION_VENDOR_CLASS */  \

   (1ULL << 18) |  /* OPTION_INTERFACE_ID */  \

   (1ULL << 19) |  /* OPTION_RECONF_MSG */    \

   (1ULL << 20) |  /* OPTION_RECONF_ACCEPT */ \

   (1ULL << 25) |  /* OPTION_IA_PD */     \

   (1ULL << 26))    /* OPTION_IAPREFIX */

static ssize_t decode_option(TALLOC_CTX *ctx, fr_pair_list_t *out,

           fr_dict_attr_t const *parent,

           uint8_t const *data, size_t const data_len, void *decode_ctx);

static ssize_t decode_tlv_trampoline(TALLOC_CTX *ctx, fr_pair_list_t *out,

             fr_dict_attr_t const *parent,

             uint8_t const *data, size_t const data_len, void *decode_ctx)

{

  return fr_pair_tlvs_from_network(ctx, out, parent, data, data_len, decode_ctx, decode_option, NULL, true);

}

static ssize_t decode_value(TALLOC_CTX *ctx, fr_pair_list_t *out,

          fr_dict_attr_t const *parent,

          uint8_t const *data, size_t const data_len, void *decode_ctx);

/** Handle arrays of DNS labels for fr_struct_from_network()

 *

 */

static ssize_t decode_value_trampoline(TALLOC_CTX *ctx, fr_pair_list_t *out,

               fr_dict_attr_t const *parent,

               uint8_t const *data, size_t const data_len, void *decode_ctx)

{

  if ((parent->type == FR_TYPE_STRING) && fr_dhcpv6_flag_any_dns_label(parent)) {

    return fr_pair_dns_labels_from_network(ctx, out, parent, data, data, data_len, NULL, false);

  }

  return decode_value(ctx, out, parent, data, data_len, decode_ctx);

}

static ssize_t decode_value(TALLOC_CTX *ctx, fr_pair_list_t *out,

          fr_dict_attr_t const *parent,

          uint8_t const *data, size_t const data_len, void *decode_ctx)

{

  ssize_t     slen;

  fr_pair_t   *vp = NULL;

  fr_dict_attr_t const  *ref;

  FR_PROTO_HEX_DUMP(data, data_len, "decode_value");

  switch (parent->type) {

  case FR_TYPE_ATTR:

    /*

     *  Force the length of the data to be two,

     *  otherwise the "from network" call complains.

     *  Because we pass in the enumv as the _parent_

     *  and not the da.  The da is marked as "array",

     *  but the parent is not.

     */

    if (data_len < 2) goto raw;

    /*

     *  Run-time checks rather than assertions.

     */

    if (!parent->parent->flags.is_root) return -1;

    vp = fr_pair_afrom_da(ctx, parent);

    if (!vp) return PAIR_DECODE_OOM;

    PAIR_ALLOCED(vp);

    slen = fr_value_box_from_network(vp, &vp->data, vp->vp_type, parent->parent,

             &FR_DBUFF_TMP(data, 2), 2, true);

    if (slen <= 0) {

      TALLOC_FREE(vp);

      goto raw;

    }

    vp->vp_tainted = true;

    fr_pair_append(out, vp);

    return 2;

  /*

   *  Address MAY be shorter than 16 bytes.

   */

  case FR_TYPE_IPV6_PREFIX:

    if (data_len == 0) {

    raw:

      return fr_pair_raw_from_network(ctx, out, parent, data, data_len);

    }

    vp = fr_pair_afrom_da(ctx, parent);

    if (!vp) return PAIR_DECODE_OOM;

    PAIR_ALLOCED(vp);

    slen = fr_value_box_ipaddr_from_network(&vp->data, parent->type, parent,

              data[0], data + 1, data_len - 1,

              (parent->parent->type == FR_TYPE_STRUCT), true);

    if (slen < 0) goto raw_free;

    slen++;   /* account for the prefix */

    break;

  /*

   *  A bool is encoded as an empty option if it's

   *  true.  A bool is omitted entirely if it's

   *  false.

   */

  case FR_TYPE_BOOL:

    if (data_len != 0) goto raw;

    vp = fr_pair_afrom_da(ctx, parent);

    if (!vp) return PAIR_DECODE_OOM;

    PAIR_ALLOCED(vp);

    vp->vp_bool = true;

    slen = 0;

    break;

  /*

   *  A standard 32bit integer, but unlike normal UNIX timestamps

   *  starts from the 1st of January 2000.

   *

   *  In the encoder we subtract 30 years to any values, so

   *  here we need to add that to the time here.

   */

  case FR_TYPE_DATE:

    vp = fr_pair_afrom_da(ctx, parent);

    if (!vp) return PAIR_DECODE_OOM;

    PAIR_ALLOCED(vp);

    slen = fr_value_box_from_network(vp, &vp->data, vp->vp_type, vp->da,

             &FR_DBUFF_TMP(data, data_len), data_len, true);

    if (slen < 0) {

      talloc_free(vp);

      goto raw;

    }

    vp->vp_date = fr_unix_time_add(vp->vp_date, fr_time_delta_from_sec(DHCPV6_DATE_OFFSET));

    break;

  case FR_TYPE_STRUCT:

    slen = fr_struct_from_network(ctx, out, parent, data, data_len,

                decode_ctx, decode_value_trampoline, decode_tlv_trampoline);

    if (slen < 0) goto raw;

    if (parent->flags.array) return slen;

    return data_len;

  case FR_TYPE_GROUP:

    vp = fr_pair_afrom_da(ctx, parent);

    if (!vp) return PAIR_DECODE_OOM;

    PAIR_ALLOCED(vp);

    ref = fr_dict_attr_ref(parent);

    if (ref && (ref->dict != dict_dhcpv6)) {

      fr_dict_protocol_t const *proto;

      proto = fr_dict_protocol(ref->dict);

      fr_assert(proto != NULL);

      if (!proto->decode) {

      raw_free:

        talloc_free(vp);

        goto raw;

      }

      slen = proto->decode(vp, &vp->vp_group, data, data_len);

      if (slen < 0) goto raw_free;

      vp->vp_tainted = true;

    } else {

      if (!ref) ref = fr_dict_root(dict_dhcpv6);

      /*

       *  Child VPs go into the child group, not in the main parent list.  BUT, we start

       *  decoding attributes from the ref, and not from the group parent.

       */

      slen = fr_pair_tlvs_from_network(vp, &vp->vp_group, ref, data, data_len, decode_ctx, decode_option, NULL, false);

      if (slen < 0) goto raw_free;

    }

    fr_pair_append(out, vp);

    return data_len;

  case FR_TYPE_IPV6_ADDR:

    vp = fr_pair_afrom_da(ctx, parent);

    if (!vp) return PAIR_DECODE_OOM;

    PAIR_ALLOCED(vp);

    slen = fr_value_box_ipaddr_from_network(&vp->data, parent->type, parent,

              128, data, data_len,

              true, true);

    if (slen < 0) goto raw_free;

    break;

  default:

    vp = fr_pair_afrom_da(ctx, parent);

    if (!vp) return PAIR_DECODE_OOM;

    PAIR_ALLOCED(vp);

    slen = fr_value_box_from_network(vp, &vp->data, vp->vp_type, vp->da,

             &FR_DBUFF_TMP(data, data_len), data_len, true);

    if (slen < 0) goto raw_free;

    break;

  }

  /*

   *  The input is larger than the decoded value, re-do it as a raw attribute.

   */

  if (!parent->flags.array && ((size_t) slen < data_len)) {

    talloc_free(vp);

    goto raw;

  }

  fr_assert(vp != NULL);

  vp->vp_tainted = true;

  fr_pair_append(out, vp);

  if (parent->flags.array) return slen;

  return data_len;

}

static ssize_t decode_option(TALLOC_CTX *ctx, fr_pair_list_t *out,

            fr_dict_attr_t const *parent,

            uint8_t const *data, size_t const data_len, void *decode_ctx)

{

  unsigned int      option;

  size_t      len;

  ssize_t     slen;

  fr_dict_attr_t const  *da;

  fr_dhcpv6_decode_ctx_t  *packet_ctx = decode_ctx;

#ifdef STATIC_ANALYZER

  if (!packet_ctx || !packet_ctx->tmp_ctx) return PAIR_DECODE_FATAL_ERROR;

#endif

  /*

   *  Must have at least an option header.

   */

  if (data_len < 4) {

    fr_strerror_printf("%s: Insufficient data", __FUNCTION__);

    return -(data_len);

  }

  option = DHCPV6_GET_OPTION_NUM(data);

  len = DHCPV6_GET_OPTION_LEN(data);

  if (len > (data_len - 4)) {

    fr_strerror_printf("%s: Option overflows input.  "

           "Optional length must be less than %zu bytes, got %zu bytes",

           __FUNCTION__, data_len - 4, len);

    return PAIR_DECODE_FATAL_ERROR;

  }

  da = fr_dict_attr_child_by_num(parent, option);

  if (!da) {

    da = fr_dict_attr_unknown_raw_afrom_num(packet_ctx->tmp_ctx, parent, option);

    if (!da) return PAIR_DECODE_FATAL_ERROR;

  }

  FR_PROTO_TRACE("decode context changed %s -> %s",da->parent->name, da->name);

  /*

   *  Relay messages are weird, and contain complete DHCPv6

   *  packets, copied verbatim from the DHCPv6 client.

   */

  if (da == attr_relay_message) {

    fr_pair_t *vp;

    vp = fr_pair_afrom_da(ctx, attr_relay_message);

    if (!vp) return PAIR_DECODE_FATAL_ERROR;

    PAIR_ALLOCED(vp);

    /*

     *  Check if the relayed packet is OK.  If not, it's an error.

     */

    if (!fr_dhcpv6_ok(data + 4, len, 200)) return -1;

    slen = fr_dhcpv6_decode(vp, &vp->vp_group, data + 4, len);

    if (slen < 0) {

      talloc_free(vp);

    raw:

      slen = fr_pair_raw_from_network(ctx, out, da, data + 4, len);

      if (slen < 0) return slen;

      return 4 + slen;

    }

    fr_pair_append(out, vp);

  } else if ((da->type == FR_TYPE_STRING) && fr_dhcpv6_flag_any_dns_label(da)) {

    slen = fr_pair_dns_labels_from_network(ctx, out, da, data + 4, data + 4, len, NULL, true);

    if (slen < 0) return slen;

  } else if (da->flags.array) {

    if (da == attr_option_request) {

      uint8_t const *p;

      if ((len < 2) || ((len & 0x01) != 0)) {

        fr_strerror_const("Invalid Option-Request, length is not a multiple of 2");

        return -1;

      }

      /*

       *  Check for the forbidden options.

       */

      for (p = data + 4; p < (data + 4 + len); p += 2) {

        if (*p) continue;

        if (*p > 26) continue;

        if ((1 << *p) & DHCPV6_ORO_FORBIDDEN) {

          fr_strerror_printf("Option %u is forbidden inside of Option-Request", *p);

          return -1;

        }

      }

    }

    slen = fr_pair_array_from_network(ctx, out, da, data + 4, len, decode_ctx, decode_value);

  } else if (da->type == FR_TYPE_VSA) {

    bool      append_vsa = false;

    bool      append_vp = false;

    uint32_t    pen;

    fr_dict_attr_t const  *vendor;

    fr_pair_t   *vsa, *vp;

    fr_pair_list_t    list;

    /*

     *  Insufficient room for a 4-octet enterprise

     *  code, plus at least one option header.

     */

    if (len < 8) goto raw;

    pen = fr_nbo_to_uint32(data + 4);

    /*

     *  Verify that the VSA contains a vendor.

     *

     *  If it doesn't then this vendor is unknown, but we know

     *  vendor attributes have a standard format, so we can

     *  decode the data anyway.

     */

    vendor = fr_dict_attr_child_by_num(da, pen);

    if (!vendor) {

      fr_dict_attr_t *n;

      n = fr_dict_attr_unknown_vendor_afrom_num(packet_ctx->tmp_ctx, da, pen);

      if (!n) return PAIR_DECODE_OOM;

      vendor = n;

    }

    vsa = fr_pair_find_by_da(out, NULL, da);

    if (!vsa) {

      vsa = fr_pair_afrom_da(ctx, da);

      if (!vsa) return PAIR_DECODE_FATAL_ERROR;

      PAIR_ALLOCED(vsa);

      append_vsa = true;

    }

    vp = NULL;

    if (!append_vsa) vp = fr_pair_find_by_da(&vsa->vp_group, NULL, vendor);

    if (!vp) {

      vp = fr_pair_afrom_da(vsa, vendor);

      if (!vp) return PAIR_DECODE_FATAL_ERROR;

      PAIR_ALLOCED(vp);

      append_vp = true;

    }

    fr_pair_list_init(&list);

    slen = fr_pair_tlvs_from_network(vp, &vp->vp_group, vendor, data + 8, len - 4,

             decode_ctx, decode_option, NULL, false);

    if (slen < 0) {

      fr_pair_list_free(&list);

      if (append_vp) talloc_free(vp);

      if (append_vsa) talloc_free(vsa);

      goto raw;

    }

    /*

     *  The child list contains vendors, and we have to merge the vendors 

     */

    fr_pair_list_append(&vp->vp_group, &list);

    if (append_vp) fr_pair_append(&vsa->vp_group, vp);

    if (append_vsa) fr_pair_append(out, vsa);

  } else if (da->type == FR_TYPE_TLV) {

    slen = fr_pair_tlvs_from_network(ctx, out, da, data + 4, len, decode_ctx, decode_option, NULL, true);

  } else if (da == attr_auth) {

    /*

     *  See RFC 8415 Section 18 (option format), and Section 20 (functionality).

     *

     *  The Auth option can be sent from a server to client in a Reply message, and contains a

     *  128-bit secret key that is recorded somewhere on the server side.

     *

     *  The Auth option can be sent from a server to a client in a Reconfigure message, and

     *  contains an HMAC-MD5 of the packet and the secret key.

     *

     *  We are not currently a DHCPv6 client, so we do not support the Auth option, or

     *  Reconfigure messages.  See verify_to_client() in base.c.

     */

    fr_strerror_const("The 'Auth' option is not supported");

    return -1;

  } else {

    slen = decode_value(ctx, out, da, data + 4, len, decode_ctx);

  }

  if (slen < 0) goto raw;

  return len + 4;

}

/** Create a "normal" fr_pair_t from the given data

 *

 *    0                   1                   2                   3

 *    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1

 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

 *   |          option-code          |           option-len          |

 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

 */

ssize_t fr_dhcpv6_decode_option(TALLOC_CTX *ctx, fr_pair_list_t *out,

        uint8_t const *data, size_t data_len, void *decode_ctx)

{

  FR_PROTO_HEX_DUMP(data, data_len, "fr_dhcpv6_decode_pair");

  /*

   *  The API changes, so we just bounce directly to the

   *  decode_option() function.

   *

   *  All options including VSAs in DHCPv6 MUST follow the

   *  standard format.

   */

  return decode_option(ctx, out, fr_dict_root(dict_dhcpv6), data, data_len, decode_ctx);

}

ssize_t fr_dhcpv6_decode_foreign(TALLOC_CTX *ctx, fr_pair_list_t *out,

         uint8_t const *data, size_t data_len)

{

  ssize_t slen;

  uint8_t const *attr, *end;

  fr_dhcpv6_decode_ctx_t decode_ctx = {};

  fr_assert(dict_dhcpv6 != NULL);

  decode_ctx.tmp_ctx = talloc(ctx, uint8_t);

  attr = data;

  end = data + data_len;

  while (attr < end) {

    slen = fr_dhcpv6_decode_option(ctx, out, attr, (end - attr), &decode_ctx);

    if (slen < 0) {

      talloc_free(decode_ctx.tmp_ctx);

      return slen;

    }

    /*

     *  If slen is larger than the room in the packet,

     *  all kinds of bad things happen.

     */

     if (!fr_cond_assert(slen <= (end - attr))) {

      talloc_free(decode_ctx.tmp_ctx);

       return -slen - (attr - data);

     }

    attr += slen;

    talloc_free_children(decode_ctx.tmp_ctx);

  }

  talloc_free(decode_ctx.tmp_ctx);

  return data_len;

}

static int decode_test_ctx(void **out, TALLOC_CTX *ctx, UNUSED fr_dict_t const *dict,

         UNUSED fr_dict_attr_t const *root_da)

{

  fr_dhcpv6_decode_ctx_t  *test_ctx;

  test_ctx = talloc_zero(ctx, fr_dhcpv6_decode_ctx_t);

  if (!test_ctx) return -1;

  test_ctx->tmp_ctx = talloc(test_ctx, uint8_t);

  *out = test_ctx;

  return 0;

}

static ssize_t fr_dhcpv6_decode_proto(TALLOC_CTX *ctx, fr_pair_list_t *out, uint8_t const *data, size_t data_len, UNUSED void *proto_ctx)

{

  size_t packet_len = data_len;

//  fr_dhcpv6_decode_ctx_t  *test_ctx = talloc_get_type_abort(proto_ctx, fr_dhcpv6_decode_ctx_t);

  if (!fr_dhcpv6_ok(data, packet_len, 200)) return -1;

  return fr_dhcpv6_decode(ctx, out, data, packet_len);

}

static ssize_t decode_pair(TALLOC_CTX *ctx, fr_pair_list_t *out, NDEBUG_UNUSED fr_dict_attr_t const *parent,

         uint8_t const *data, size_t data_len, void *decode_ctx)

{

  fr_assert(parent == fr_dict_root(dict_dhcpv6));

  return decode_option(ctx, out, fr_dict_root(dict_dhcpv6), data, data_len, decode_ctx);

}

/*

 *  Test points

 */

extern fr_test_point_pair_decode_t dhcpv6_tp_decode_pair;

fr_test_point_pair_decode_t dhcpv6_tp_decode_pair = {

  .test_ctx = decode_test_ctx,

  .func   = decode_pair,

};

extern fr_test_point_proto_decode_t dhcpv6_tp_decode_proto;

fr_test_point_proto_decode_t dhcpv6_tp_decode_proto = {

  .test_ctx = decode_test_ctx,

  .func   = fr_dhcpv6_decode_proto

};