/*

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

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 of the License, or (at

 *   your option) any later version.

 *

 *   This program 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 General Public License for more details.

 *

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

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

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

 */

/**

 * $Id: 1c0db6c5857b81925cd5cc19da95f7f652bb4d4b $

 * @file json.c

 * @brief Common functions for working with json-c

 *

 * @author Arran Cudbard-Bell

 * @author Matthew Newton

 *

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

 * @copyright 2015,2020 Network RADIUS SAS (legal@networkradius.com)

 * @copyright 2015 The FreeRADIUS Server Project

 */

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

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

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

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

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

#include "base.h"

#include "lib/util/strerror.h"

fr_table_num_sorted_t const fr_json_format_table[] = {

  { L("array"),   JSON_MODE_ARRAY   },

  { L("array_of_names"),  JSON_MODE_ARRAY_OF_NAMES  },

  { L("array_of_values"), JSON_MODE_ARRAY_OF_VALUES },

  { L("object"),    JSON_MODE_OBJECT    },

  { L("object_simple"), JSON_MODE_OBJECT_SIMPLE },

};

size_t fr_json_format_table_len = NUM_ELEMENTS(fr_json_format_table);

fr_table_num_sorted_t const fr_json_binary_format_table[] = {

  { L("base16"),  JSON_BINARY_FORMAT_BASE16 },

  { L("base64"),  JSON_BINARY_FORMAT_BASE64 },

  { L("raw"), JSON_BINARY_FORMAT_RAW },

};

size_t fr_json_binary_format_table_len = NUM_ELEMENTS(fr_json_binary_format_table);

static fr_json_format_t const default_json_format = {

  .attr = { .prefix = NULL },

  .value = { .value_is_always_array = true },

  .output_mode = JSON_MODE_OBJECT

};

static conf_parser_t const json_format_attr_config[] = {

  { FR_CONF_OFFSET("prefix", fr_json_format_attr_t, prefix) },

  CONF_PARSER_TERMINATOR

};

static conf_parser_t const json_format_value_config[] = {

  { FR_CONF_OFFSET("single_value_as_array", fr_json_format_value_t, value_is_always_array), .dflt = "no" },

  { FR_CONF_OFFSET("enum_as_integer", fr_json_format_value_t, enum_as_int), .dflt = "no" },

  { FR_CONF_OFFSET("always_string", fr_json_format_value_t, always_string), .dflt = "no" },

  { FR_CONF_OFFSET("binary_format", fr_json_format_value_t, binary_format), .dflt = "raw",

    .func = cf_table_parse_int,

    .uctx = &(cf_table_parse_ctx_t){ .table = fr_json_binary_format_table, .len = &fr_json_binary_format_table_len } },

  CONF_PARSER_TERMINATOR

};

conf_parser_t const fr_json_format_config[] = {

  { FR_CONF_OFFSET("output_mode", fr_json_format_t, output_mode_str), .dflt = "object" },

  { FR_CONF_OFFSET_SUBSECTION("attribute", 0, fr_json_format_t, attr, json_format_attr_config) },

  { FR_CONF_OFFSET_SUBSECTION("value", 0, fr_json_format_t, value, json_format_value_config) },

  CONF_PARSER_TERMINATOR

};

static inline CC_HINT(always_inline)

void json_object_put_assert(json_object *obj)

{

  int ret;

  ret = json_object_put(obj);

  if (ret == 1) return;

  fr_assert_fail("json_object_put did not free object (returned %d), likely leaking memory", ret);

}

/** Convert json object to fr_value_box_t

 *

 * @param[in] ctx to allocate any value buffers in (should usually be the same as out).

 * @param[in] out Where to write value.  Must be initialised.

 * @param[in] object  to convert.

 * @param[in] enumv Any string values are assumed to be in PRESENTATION format, meaning

 *      that if an enumv is specified, they'll be checked against the list

 *      of aliases for that enumeration, and possibly converted into one of

 *      the enumeration values (which may not be a string).

 * @param[in] tainted Whether the data source is untrusted.

 * @return

 *  - 0 on success.

 *  - -1 on failure.

 */

int fr_json_object_to_value_box(TALLOC_CTX *ctx, fr_value_box_t *out, json_object *object,

        fr_dict_attr_t const *enumv, bool tainted)

{

  switch (json_object_get_type(object)) {

  case json_type_string:

  {

    char const      *value;

    size_t        len;

    fr_dict_enum_value_t const  *found;

    value = json_object_get_string(object);

    len = json_object_get_string_len(object);

    if (!enumv) goto no_enumv;

    if (fr_dict_valid_name(value, len) < 0) goto no_enumv;

    /*

     *  If an alias exists, use that value instead

     */

    found = fr_dict_enum_by_name(enumv, value, len);

    if (found) {

      if (unlikely(fr_value_box_copy(ctx, out, found->value)) < 0) return -1;

      return 0;

    }

  no_enumv:

    /*

     *  Just copy the string to the box.

     */

    if (fr_value_box_bstrndup(out, out, NULL, value, len, tainted) < 0) return -1;

  }

    break;

  case json_type_double:

    fr_value_box(out, json_object_get_double(object), tainted);

    break;

  case json_type_int:

  {

#ifdef HAVE_JSON_OBJECT_GET_INT64

    int64_t num;

#else

    int32_t num;

#endif

#ifndef HAVE_JSON_OBJECT_GET_INT64

    num = json_object_get_int(object);

#else

    num = json_object_get_int64(object);

    if (num < INT32_MIN) {     /* 64bit signed*/

      fr_value_box(out, (int64_t)num, tainted);

    } else if (num > UINT32_MAX) {   /* 64bit unsigned */

      fr_value_box(out, (uint64_t)num, tainted);

    } else

#endif

    if (num < INT16_MIN) {     /* 32bit signed */

      fr_value_box(out, (int32_t)num, tainted);

    } else if (num < INT8_MIN) {   /* 16bit signed */

      fr_value_box(out, (int16_t)num, tainted);

    } else if (num < 0) {     /* 8bit signed */

      fr_value_box(out, (int8_t)num, tainted);

    } else if (num > UINT16_MAX) {   /* 32bit unsigned */

      fr_value_box(out, (uint32_t)num, tainted);

    } else if (num > UINT8_MAX) {   /* 16bit unsigned */

      fr_value_box(out, (uint16_t)num, tainted);

    } else {       /* 8bit unsigned */

      fr_value_box(out, (uint8_t)num, tainted);

    }

  }

    break;

  case json_type_boolean:

    /* Must be cast to bool for correct generic case selection */

    fr_value_box(out, ((bool)(json_object_get_boolean(object) > 0)), tainted);

    break;

  case json_type_null:

  case json_type_array:

  case json_type_object:

  {

    char const *value = json_object_to_json_string(object);

    if (fr_value_box_bstrndup(out, out, NULL, value, strlen(value), tainted) < 0) return -1;

  }

    break;

  }

  out->tainted = tainted;

  return 0;

}

/** Convert boxed value_box to a JSON object

 *

 * @param[in] data  to convert.

 */

json_object *json_object_from_value_box(fr_value_box_t const *data)

{

  /*

   *  We're converting to PRESENTATION format

   *  so any attributes with enumeration values

   *  should be converted to string types.

   */

  if (data->enumv) {

    fr_dict_enum_value_t const *enumv;

    enumv = fr_dict_enum_by_value(data->enumv, data);

    if (enumv) return json_object_new_string(enumv->name);

  }

  switch (data->type) {

  default:

  do_string:

  {

    char    buffer[64];

    fr_sbuff_t  sbuff = FR_SBUFF_OUT(buffer, sizeof(buffer));

    if (fr_value_box_print(&sbuff, data, NULL) <= 0) return NULL;

    return json_object_new_string_len(buffer, fr_sbuff_used(&sbuff));

  }

  case FR_TYPE_STRING:

    return json_object_new_string_len(data->vb_strvalue, data->vb_length);

  case FR_TYPE_OCTETS:

    return json_object_new_string_len((char const *)data->vb_octets, data->vb_length);

  case FR_TYPE_BOOL:

    return json_object_new_boolean(data->vb_bool);

  case FR_TYPE_UINT8:

    return json_object_new_int(data->vb_uint8);

  case FR_TYPE_UINT16:

    return json_object_new_int(data->vb_uint16);

#ifdef HAVE_JSON_OBJECT_GET_INT64

  case FR_TYPE_UINT32:

    return json_object_new_int64((int64_t)data->vb_uint32);  /* uint32_t (max) > int32_t (max) */

  case FR_TYPE_UINT64:

    if (data->vb_uint64 > INT64_MAX) goto do_string;

    return json_object_new_int64(data->vb_uint64);

#else

  case FR_TYPE_UINT32:

    if (data->vb_uint32 > INT32_MAX) goto do_string;

    return json_object_new_int(data->vb_uint32);

#endif

  case FR_TYPE_INT8:

    return json_object_new_int(data->vb_int8);

  case FR_TYPE_INT16:

    return json_object_new_int(data->vb_int16);

  case FR_TYPE_INT32:

    return json_object_new_int(data->vb_int32);

#ifdef HAVE_JSON_OBJECT_GET_INT64

  case FR_TYPE_INT64:

    return json_object_new_int64(data->vb_int64);

  case FR_TYPE_SIZE:

    return json_object_new_int64(data->vb_size);

#endif

  case FR_TYPE_STRUCTURAL:

    fr_strerror_const("Can't convert structural type to JSON");

    return NULL;

  }

}

/** Print a value box as its equivalent JSON format without going via a struct json_object (in most cases)

 *

 * @param[out] out    buffer to write to.

 * @param[in] vb    to print.

 * @param[in] include_quotes  whether we should wrap string values,

 *        or non-native types like IPv4 addresses in quotes.

 * @return

 *  - <0 on error.

 *  - >= number of bytes written.

 */

fr_slen_t fr_json_str_from_value(fr_sbuff_t *out, fr_value_box_t const *vb, bool include_quotes)

{

  fr_sbuff_t our_out = FR_SBUFF(out);

  switch (vb->type) {

  case FR_TYPE_NULL:

    FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "null");

    break;

  case FR_TYPE_BOOL:

    FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, vb->vb_bool ? "true" : "false");

    break;

  /*

   *  This is identical to JSON-C's escaping function

   *  but we avoid creating JSON objects just to be able

   *  to escape strings.

   */

  case FR_TYPE_STRING:

  case FR_TYPE_OCTETS:

  {

    char const *last_app, *p, *end;

    if (include_quotes) FR_SBUFF_IN_CHAR_RETURN(&our_out, '"');

    last_app = p = vb->vb_strvalue;

    end = p + vb->vb_length;

    while (p < end) {

      if ((*p < ' ') || (*p == '"') || (*p == '\\') || (*p == '/')) {

        if (p > last_app) FR_SBUFF_IN_BSTRNCPY_RETURN(&our_out, last_app, p - last_app);

        switch (*p) {

        case '\b':

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\b");

          break;

        case '\n':

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\n");

          break;

        case '\r':

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\r");

          break;

        case '\t':

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\t");

          break;

        case '\f':

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\f");

          break;

        case '"':

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\\"");

          break;

        case '\\':

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\\\");

          break;

        case '/':

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\/");

          break;

        default:

          FR_SBUFF_IN_STRCPY_LITERAL_RETURN(&our_out, "\\u00");

          fr_base16_encode(&our_out, &FR_DBUFF_TMP((uint8_t const *)p, 1));

        }

        last_app = p + 1;

      }

      p++;

    }

    if (end > last_app) FR_SBUFF_IN_BSTRNCPY_RETURN(&our_out, last_app, end - last_app);

    if (include_quotes) FR_SBUFF_IN_CHAR_RETURN(&our_out, '"');

  }

    break;

  case FR_TYPE_UINT8:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%u", vb->vb_uint8);

    break;

  case FR_TYPE_UINT16:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%u", vb->vb_uint16);

    break;

  case FR_TYPE_UINT32:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%u", vb->vb_uint32);

    break;

  case FR_TYPE_UINT64:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%" PRIu64, vb->vb_uint64);

    break;

  case FR_TYPE_INT8:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%i", vb->vb_int8);

    break;

  case FR_TYPE_INT16:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%i", vb->vb_int16);

    break;

  case FR_TYPE_INT32:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%i", vb->vb_int32);

    break;

  case FR_TYPE_INT64:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%" PRIi64, vb->vb_int64);

    break;

  case FR_TYPE_SIZE:

    FR_SBUFF_IN_SPRINTF_RETURN(&our_out, "%zu", vb->vb_size);

    break;

  /*

   *  It's too complex to replicate the float/double printing

   *  here, so pass it off to JSON-C's printing functions.

   */

  case FR_TYPE_FLOAT32:

  {

    struct json_object *obj;

    fr_slen_t slen;

    obj = json_object_new_double((double)vb->vb_float32);

    if (unlikely(obj == NULL)) return -1;

    slen = fr_sbuff_in_strcpy(&our_out, json_object_to_json_string(obj));

    json_object_put_assert(obj);

    if (slen < 0) return slen;

    break;

  }

  case FR_TYPE_FLOAT64:

  {

    struct json_object *obj;

    fr_slen_t slen;

    obj = json_object_new_double((double)vb->vb_float64);

    if (unlikely(obj == NULL)) return -1;

    slen = fr_sbuff_in_strcpy(&our_out, json_object_to_json_string(obj));

    json_object_put_assert(obj);

    if (slen < 0) return slen;

    break;

  }

  case FR_TYPE_IPV4_ADDR:

  case FR_TYPE_IPV4_PREFIX:

  case FR_TYPE_IPV6_ADDR:

  case FR_TYPE_IPV6_PREFIX:

  case FR_TYPE_COMBO_IP_ADDR:

  case FR_TYPE_COMBO_IP_PREFIX:

  case FR_TYPE_IFID:

  case FR_TYPE_ETHERNET:

  case FR_TYPE_DATE:

  case FR_TYPE_TIME_DELTA:

  case FR_TYPE_ATTR:

  {

    fr_slen_t slen;

    if (include_quotes) FR_SBUFF_IN_CHAR_RETURN(&our_out, '"');

    slen = fr_value_box_print(&our_out, vb, NULL);

    if (include_quotes) FR_SBUFF_IN_CHAR_RETURN(&our_out, '"');

    /* Intentionally after writing second dquote, so the buffer is always has a properly terminated string */

    if (slen < 0) return slen;

  }

    break;

  case FR_TYPE_STRUCTURAL:

    fr_strerror_const("Structural boxes not yet supported");

    return -1;

  case FR_TYPE_INTERNAL:

    fr_strerror_printf("Box type %s cannot be converted to string", fr_type_to_str(vb->type));

    return -1;

  }

  return fr_sbuff_set(out, &our_out);

}

/** Print JSON-C version

 *

 */

void fr_json_version_print(void)

{

#ifdef HAVE_JSON_C_VERSION

  INFO("libfreeradius-json: json-c version: %s", json_c_version());

#else

  INFO("libfreeradius-json: json-c version: Unknown (less than 0.10) - Please upgrade");

#endif

}

/** Convert a value box into a JSON object

 *

 * If format.value.always_string is set then a numeric value

 * will be returned as a JSON string object.

 *

 * @param[in] ctx Talloc context.

 * @param[out] out  returned json object.

 * @param[in] vb  to get the value of.

 * @param[in] format  format definition, or NULL.

 * @return

 *  - 0 on success.

 *  - -1 on error.

 */

static inline CC_HINT(always_inline)

int json_afrom_value_box(TALLOC_CTX *ctx, json_object **out,

       fr_value_box_t const *vb, fr_json_format_t const *format)

{

  if (!format) {

    MEM(*out = json_object_from_value_box(vb));

    return 0;

  }

  /*

   *  Evaluated before "always_string".

   */

  if (vb->type == FR_TYPE_OCTETS) {

    switch (format->value.binary_format) {

    case JSON_BINARY_FORMAT_BASE16:

    case JSON_BINARY_FORMAT_BASE64:

    {

      fr_sbuff_t  *encoded;

      FR_SBUFF_TALLOC_THREAD_LOCAL(&encoded, 256, SIZE_MAX);

      switch (format->value.binary_format) {

      /*

       *  Hex encode octets values when requested.

       */

      case JSON_BINARY_FORMAT_BASE16:

        fr_base16_encode(encoded, &FR_DBUFF_TMP(vb->vb_octets, vb->vb_length));

        break;

      /*

       *  Base64-encode octets values when requested.

       */

      case JSON_BINARY_FORMAT_BASE64:

        fr_base64_encode(encoded, &FR_DBUFF_TMP(vb->vb_octets, vb->vb_length), true);

        break;

      default:

        break;

      }

      MEM(*out = json_object_new_string_len(fr_sbuff_start(encoded), fr_sbuff_used(encoded)));

      return 0;

    }

    case JSON_BINARY_FORMAT_RAW:

      break;

    }

  }

  if (format->value.always_string) {

    fr_value_box_t    vb_str = FR_VALUE_BOX_INITIALISER_NULL(vb_str);

    if (unlikely(fr_value_box_cast(ctx, &vb_str, FR_TYPE_STRING, NULL, vb) < 0)) return -1;

    MEM(*out = json_object_from_value_box(&vb_str));

    fr_value_box_clear(&vb_str);

    return 0;

  }

  MEM(*out = json_object_from_value_box(vb));

  return 0;

}

/** Convert fr_pair_t into a JSON object

 *

 * If format.value.enum_as_int is set, and the given VP is an enum

 * value, the integer value is returned as a json_object rather

 * than the text representation.

 *

 * If format.value.always_string is set then a numeric value

 * will be returned as a JSON string object.

 *

 * @param[in] ctx Talloc context.

 * @param[out] out  returned json object.

 * @param[in] vp  to get the value of.

 * @param[in] format  format definition, or NULL.

 * @return

 *  - 0 on success.

 *  - -1 on error.

 */

static int json_afrom_pair(TALLOC_CTX *ctx, json_object **out,

         fr_pair_t *vp, fr_json_format_t const *format)

{

  fr_value_box_t const  *vb;

  fr_assert(vp);

  vb = &vp->data;

  if (format->value.enum_as_int) {

    (void)fr_pair_value_enum_box(&vb, vp);

  }

  return json_afrom_value_box(ctx, out, vb, format);

}

/** Get attribute name with optional prefix

 *

 * If the format "attr.prefix" string is set then prepend this

 * to the given attribute name, otherwise just return name alone.

 *

 * @param[out] out sbuff to write the new name

 * @param[in] da dictionary attribute to get name of

 * @param[in] format json format structure

 * @return length of attribute name

 */

static inline ssize_t attr_name_with_prefix(fr_sbuff_t *out, fr_dict_attr_t const *da, fr_json_format_t const *format)

{

  fr_sbuff_t our_out;

  if (!out) return 0;

  our_out = FR_SBUFF(out);

  if (format->attr.prefix) {

    FR_SBUFF_IN_STRCPY_RETURN(&our_out, format->attr.prefix);

    FR_SBUFF_IN_CHAR_RETURN(&our_out, ':');

  }

  FR_SBUFF_IN_BSTRNCPY_RETURN(&our_out, da->name, da->name_len);

  FR_SBUFF_SET_RETURN(out, &our_out);

}

/** Verify that the options in fr_json_format_t are valid

 *

 * Warnings are optional, will fatal error if the format is corrupt.

 *

 * @param[in] format  the format structure to check

 * @param[in] verbose print out warnings if set

 * @return    true if format is good, otherwise false

 */

bool fr_json_format_verify(fr_json_format_t const *format, bool verbose)

{

  bool ret = true;

  fr_assert(format);

  switch (format->output_mode) {

  case JSON_MODE_OBJECT:

  case JSON_MODE_OBJECT_SIMPLE:

  case JSON_MODE_ARRAY:

    /* all options are valid */

    return true;

  case JSON_MODE_ARRAY_OF_VALUES:

    if (format->attr.prefix) {

      if (verbose) WARN("attribute name prefix not valid in output_mode 'array_of_values' and will be ignored");

      ret = false;

    }

    if (format->value.value_is_always_array) {

      if (verbose) WARN("'value_is_always_array' not valid in output_mode 'array_of_values' and will be ignored");

      ret = false;

    }

    return ret;

  case JSON_MODE_ARRAY_OF_NAMES:

    if (format->value.value_is_always_array) {

      if (verbose) WARN("'value_is_always_array' not valid in output_mode 'array_of_names' and will be ignored");

      ret = false;

    }

    if (format->value.enum_as_int) {

      if (verbose) WARN("'enum_as_int' not valid in output_mode 'array_of_names' and will be ignored");

      ret = false;

    }

    if (format->value.always_string) {

      if (verbose) WARN("'always_string' not valid in output_mode 'array_of_names' and will be ignored");

      ret = false;

    }

    return ret;

  default:

    ERROR("JSON format output mode is invalid");

  }

  /* If we get here, something has gone wrong */

  fr_assert(0);

  return false;

}

#define INVALID_TYPE \

do { \

  fr_assert(0); \

  fr_strerror_printf("Invalid type %s for attribute %s", fr_type_to_str(vp->vp_type), vp->da->name); \

  goto error; \

} while (0)

/** Returns a JSON object representation of a list of value pairs

 *

 * The result is a struct json_object, which should be free'd with

 * json_object_put() by the caller. Intended to only be called by

 * fr_json_afrom_pair_list().

 *

 * This function generates the "object" format, JSON_MODE_OBJECT.

 * @see fr_json_format_s

 *

@verbatim

{

  "<attribute0>":{

    "type":"<type0>",

    "value":[<value0>,<value1>,<valueN>]    // if value_is_always_array is true

  },              // or

  "<attribute1>":{

    "type":"<type1>",

    "value":<value0>        // if value_is_always_array is false

                // and there is only one value

  },

  "<attributeN>":{

    "type":"<typeN>",

    "value":[...]

  }

}

@endverbatim

 *

 * @param[in] ctx Talloc context.

 * @param[in] vps a list of value pairs.

 * @param[in] format  Formatting control, must be set.

 * @return JSON object with the generated representation.

 */

static CC_HINT(warn_unused_result)

json_object *json_object_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t *vps, fr_json_format_t const *format)

{

  fr_pair_t   *vp;

  struct json_object  *obj;

  char      buf[FR_DICT_ATTR_MAX_NAME_LEN + 32];

  /* Check format and type */

  fr_assert(format);

  fr_assert(format->output_mode == JSON_MODE_OBJECT);

  MEM(obj = json_object_new_object());

  for (vp = fr_pair_list_head(vps);

       vp;

       vp = fr_pair_list_next(vps, vp)) {

    fr_sbuff_t    attr_name;

    struct json_object  *vp_object, *values, *value, *type_name;

    if (vp->vp_raw) continue;

    /*

     *  Get attribute name and value.

     */

    fr_sbuff_init_in(&attr_name, buf, sizeof(buf) - 1);

    if (attr_name_with_prefix(&attr_name, vp->da, format) < 0) {

    error:

      json_object_put_assert(obj);

      return NULL;

    }

    switch (vp->vp_type) {

    case FR_TYPE_LEAF:

      if (json_afrom_pair(ctx, &value, vp, format) < 0) {

        fr_strerror_const("Failed to convert attribute value to JSON object");

        goto error;

      }

      break;

    /*

     *  For nested attributes we recurse.  The nesting is represented

     *  as a table, either as the single value, or as an element in

     *  an array.

     *

     *  ...

     *  "value" : { "nested_attr" : { "type" : "<nested_type>", "value" : "<nested_attr_value>" } }

     *  ...

     *

     *  ...

     *  "value" : [ { "nested_attr" : { "type" : "<nested_type>", "value" : "<nested_attr_value>" } } ]

     *  ...

     *

     *  The formatting of nested attributes and their structure is

     *  identical to top level attributes.

     */

    case FR_TYPE_STRUCTURAL:

      value = json_object_afrom_pair_list(ctx, &vp->vp_group, format);

      if (unlikely(value == NULL)) goto error;

      break;

    default:

      INVALID_TYPE;

    }

    /*

     *  Look in the table to see if we already have a key for the attribute

     *  we're working on.

     *

     *  If we don't we create a new object in either the form:

     *

     *  "<attribute>": {

     *    "type": "<type>",

     *    "value": [<value>]    // if value_is_always_array is true

     *            // or

     *    "value": <value>    // if value_is_always_array is false

     *            // and there is only one value

     *  }

     */

    if (!json_object_object_get_ex(obj, fr_sbuff_start(&attr_name), &vp_object)) {

      /*

       *  Wasn't there, so create a new object for this attribute.

       */

      MEM(vp_object = json_object_new_object());

      json_object_object_add(obj, fr_sbuff_start(&attr_name), vp_object);

      /*

       *  Add "type" to newly created keys.

       */

      MEM(type_name = json_object_new_string(fr_type_to_str(vp->vp_type)));

      json_object_object_add_ex(vp_object, "type", type_name, JSON_C_OBJECT_KEY_IS_CONSTANT);

      /*

       *  Create a "value" array to hold any attribute values for this attribute...

       */

      if (format->value.value_is_always_array) {

        MEM(values = json_object_new_array());

        json_object_object_add_ex(vp_object, "value", values, JSON_C_OBJECT_KEY_IS_CONSTANT);

        json_object_array_add(values, value);

        continue;

      }

      /*

       *  ...or just add the value directly.

       */

      json_object_object_add_ex(vp_object, "value", value, JSON_C_OBJECT_KEY_IS_CONSTANT);

      continue; /* Next attribute! */

    }

    /*

     *  Find the 'values' array to add the current value to.

     */

    if (!fr_cond_assert(json_object_object_get_ex(vp_object, "value", &values))) {

      fr_strerror_const("Inconsistent JSON tree");

      goto error;

    }

    /*

     *  If value_is_always_array is no set then "values" may not be an array, so it will

     *  need converting to an array to add this extra attribute.

     */

    if (!format->value.value_is_always_array) {

      json_type   type;

      struct json_object  *convert_value = values;

      /* Check "values" type */

      type = json_object_get_type(values);

      /* It wasn't an array, so turn it into one with the old value as the first entry */

      if (type != json_type_array) {

        MEM(values = json_object_new_array());

        json_object_array_add(values, json_object_get(convert_value));

        json_object_object_del(vp_object, "value");

        json_object_object_add_ex(vp_object, "value", values,

                JSON_C_OBJECT_KEY_IS_CONSTANT);

      }

    }

    json_object_array_add(values, value);

  }

  return obj;

}

/** Returns a JSON object representation of a list of value pairs

 *

 * The result is a struct json_object, which should be free'd with

 * json_object_put() by the caller. Intended to only be called by

 * fr_json_afrom_pair_list().

 *

 * This function generates the "simple object" format, JSON_MODE_OBJECT_SIMPLE.

 * @see fr_json_format_s

 *

@verbatim

{

  "<attribute0>":[<value0>,<value1>,<valueN>] // if value_is_always_array is true

              // or

  "<attribute1>":<value0>       // if value_is_always_array is false,

              // and there is only one value

  "<attributeN>":[<value0>,<value1>,<valueN>]

}

@endverbatim

 *

 * @param[in] ctx Talloc context.

 * @param[in] vps a list of value pairs.

 * @param[in] format  Formatting control, must be set.

 * @return JSON object with the generated representation.

 */

static json_object *json_simple_obj_afrom_pair_list(TALLOC_CTX *ctx, fr_pair_list_t *vps,

             fr_json_format_t const *format)

{

  fr_pair_t   *vp;

  struct json_object  *obj;

  char      buf[FR_DICT_ATTR_MAX_NAME_LEN + 32];

  json_type   type;

  /* Check format and type */

  fr_assert(format);

  fr_assert(format->output_mode == JSON_MODE_OBJECT_SIMPLE);

  MEM(obj = json_object_new_object());

  for (vp = fr_pair_list_head(vps);

       vp;

       vp = fr_pair_list_next(vps, vp)) {

    fr_sbuff_t    attr_name;

    struct json_object  *vp_object, *value;

    struct json_object  *values = NULL;

    bool      add_single = false;

    if (vp->vp_raw) continue;

    /*

     *  Get attribute name and value.

     */

    fr_sbuff_init_in(&attr_name, buf, sizeof(buf) - 1);

    if (attr_name_with_prefix(&attr_name, vp->da, format) < 0) {

    error:

      json_object_put_assert(obj);

      return NULL;

    }

    switch (vp->vp_type) {

    case FR_TYPE_LEAF:

      if (json_afrom_pair(ctx, &value, vp, format) < 0) {

        fr_strerror_const("Failed to convert attribute value to JSON object");

        goto error;

      }

      break;

    /*

     *  For nested attributes we recurse.  The nesting is represented

     *  as a table, either as the single value, or as an element in

     *  an array.

     *

     *  ...

     *  "<parent>" : { "<nested_attr>" : <nested_attr_value> }

     *  ...

     *

     *  ...

     *  "<parent>" : [ { "<nested_attr>" : "<nested_attr_value>" } ]

     *  ...

     *

     *  The formatting of nested attributes and their structure is

     *  identical to top level attributes.

     */

    case FR_TYPE_STRUCTURAL:

      value = json_simple_obj_afrom_pair_list(ctx, &vp->vp_group, format);

      if (unlikely(value == NULL)) goto error;

      break;

    default:

      INVALID_TYPE;

    }

    /*

     *  See if we already have a key in the table we're working on,

     *  if not then create a new one.

     */

    if (!json_object_object_get_ex(obj, fr_sbuff_start(&attr_name), &vp_object)) {

      if (format->value.value_is_always_array) {

        /*

         *  We have been asked to ensure /all/ values are lists,

         *  even if there's only one attribute.

         */

        MEM(values = json_object_new_array());

        json_object_object_add(obj, fr_sbuff_start(&attr_name), values);