/src/tmux/json.c

Source
/* $OpenBSD: json.c,v 1.1 2026/09/08 08:33:10 nicm Exp $ */

/*
 * Copyright (c) 2026 Dane Jensen <dhcjensen@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <ctype.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "tmux.h"

/*
 * Parse a subset of JSON. The subset accepted is:
 *
 * - Arrays may only hold objects.
 * - The top-level value must be an object.
 * - Numbers are 64-bit signed integers in base 10; there are no fractions and
 *   no exponents.
 * - There is no null, and a string may not be empty.
 * - Escapes are validated but not decoded.
 * - A key may not appear twice in the same object. Note that because escapes
 *   are not decoded, duplicate keys may go undetected.
 * - Objects may only be parsed to a fixed maximum depth.
 */

#define ERROR_CTX_LEN 8
#define PARSE_DEPTH_MAX 200

/* JSON token types. */
enum json_token_type {
  TOK_OPENOBJECT,
  TOK_CLOSEOBJECT,
  TOK_OPENARRAY,
  TOK_CLOSEARRAY,
  TOK_COMMA,
  TOK_COLON,
  TOK_QUOTE,
  TOK_VALUE,
  TOK_EOF
};

/* JSON token. */
struct json_token {
  enum json_token_type  type;
  int     offset;
  int     len;
};

/* JSON tokens. */
struct json_tokens {
  int      size;
  int      capacity;
  struct json_token *toks;
};

/* JSON node type. */
enum json_node_type {
  NODE_STRING,
  NODE_NUMBER,
  NODE_BOOLEAN,
  NODE_OBJECT,
  NODE_ARRAY
};

/* JSON field tree. */
RB_HEAD(json_fields, json_node);

/* JSON array queue. */
TAILQ_HEAD(json_members, json_node);

/* JSON parse context. */
struct json_parse_ctx {
  const char   *input;
  char    **cause;
  int     depth;
};

/* JSON node. */
struct json_node {
  enum json_node_type    type;
  char        *key;
  struct json_node    *parent;
  union {
    char      *str;
    int64_t      num;
    int      boolean;
    struct json_fields   fields;
    struct json_members  members;
  };
  RB_ENTRY(json_node)    oentry;
  TAILQ_ENTRY(json_node)     aentry;
};

static int
json_node_cmp(struct json_node *a, struct json_node *b)
{
  return (strcmp(a->key, b->key));
}
RB_GENERATE_STATIC(json_fields, json_node, oentry, json_node_cmp);

static struct json_tokens *json_tokenize_input(const char *, char **);
static struct json_tokens *json_create_tokens(void);
static void    json_destroy_tokens(struct json_tokens *);
static void    json_add_token(struct json_tokens *,
           enum json_token_type, const char *, const char *,
           int);
static int     json_tokenize_value(struct json_tokens *,
           const char *);
static void    json_error(char **, const char *, const char *);
static struct json_node *json_create_node(struct json_node *,
           enum json_node_type, const char *, void *);
static void    json_assign_value(struct json_node *, void *);
static struct json_node *json_parse_tokens(struct json_tokens **,
           struct json_parse_ctx *);
static char   *json_parse_key(struct json_token **,
           struct json_parse_ctx *);
static struct json_node *json_parse_object(struct json_token **,
           struct json_parse_ctx *, const char *,
           struct json_node *);
static struct json_node *json_parse_array(struct json_token **,
           struct json_parse_ctx *, const char *,
           struct json_node *);
static struct json_node *json_parse_string(struct json_token **,
           struct json_parse_ctx *, const char *,
           struct json_node *);
static struct json_node *json_parse_number(struct json_token **,
           struct json_parse_ctx *, const char *,
           struct json_node *);
static struct json_node *json_parse_boolean(struct json_token **,
           struct json_parse_ctx *, const char *,
           struct json_node *);

/* Parse an input string into JSON. */
struct json_node *
json_parse(const char *input, char **cause)
{
  struct json_tokens  *tokens;
  struct json_parse_ctx  pctx;

  if (*input == '\0') {
    json_error(cause, "empty input", NULL);
    return (NULL);
  }

  if ((tokens = json_tokenize_input(input, cause)) == NULL)
    return (NULL);

  pctx.input = input;
  pctx.cause = cause;
  pctx.depth = 0;

  return (json_parse_tokens(&tokens, &pctx));
}

/* Returns a field node from an object node. */
struct json_node *
json_find(struct json_node *jn, const char *key)
{
  struct json_node  *node = (struct json_node *)jn, tmp = { 0 };

  if (jn->type != NODE_OBJECT)
    return (NULL);

  tmp.key = (char *)key;
  return (RB_FIND(json_fields, &node->fields, &tmp));
}

/* Returns the first member of an array node. */
struct json_node *
json_array_first(struct json_node *jn)
{
  if (jn->type != NODE_ARRAY)
    return (NULL);

  return (TAILQ_FIRST(&jn->members));
}

/* Returns the next member of an array's member node. */
struct json_node *
json_array_next(struct json_node *member)
{
  if (member == NULL ||
      member->parent == NULL ||
      member->parent->type != NODE_ARRAY)
    return (NULL);
  return (TAILQ_NEXT(member, aentry));
}

/* Returns the string value from a node. */
int
json_get_string(struct json_node *jn, const char **s)
{
  if (jn->type != NODE_STRING)
    return (-1);

  *s = jn->str;
  return (0);
}

/* Returns the number value from a node. */
int
json_get_number(struct json_node *jn, int64_t *i)
{
  if (jn->type != NODE_NUMBER)
    return (-1);

  *i = jn->num;
  return (0);
}

/* Returns the boolean value from a node. */
int
json_get_boolean(struct json_node *jn, int *b)
{
  if (jn->type != NODE_BOOLEAN)
    return (-1);

  *b = jn->boolean;
  return (0);
}

/* Returns the object value from a node. */
int
json_get_object(struct json_node *jn, struct json_node **o)
{
  if (jn->type != NODE_OBJECT)
    return (-1);

  *o = jn;
  return (0);
}

/* Returns the array value from a node. */
int
json_get_array(struct json_node *jn, struct json_node **a)
{
  if (jn->type != NODE_ARRAY)
    return (-1);

  *a = jn;
  return (0);
}

/* Returns the string value from a given key in an object node. */
int
json_find_string(struct json_node *jn, const char *key, const char **out,
    char **cause)
{
  struct json_node  *field;

  if ((field = json_find(jn, key)) == NULL) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" not found", key);
    return (-1);
  }
  if (field->type != NODE_STRING) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" expected a string", key);
    return (-1);
  }
  *out = field->str;

  return (0);
}

/* Returns the number value from a given key in an object node. */
int
json_find_number(struct json_node *jn, const char *key, int64_t *out,
    char **cause)
{
  struct json_node  *field;

  if ((field = json_find(jn, key)) == NULL) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" not found", key);
    return (-1);
  }
  if (field->type != NODE_NUMBER) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" expected a number", key);
    return (-1);
  }
  *out = field->num;

  return (0);
}

/* Returns the boolean value from a given key in an object node. */
int
json_find_boolean(struct json_node *jn, const char *key, int *out, char **cause)
{
  struct json_node  *field;

  if ((field = json_find(jn, key)) == NULL) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" not found", key);
    return (-1);
  }
  if (field->type != NODE_BOOLEAN) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" expected a boolean", key);
    return (-1);
  }
  *out = field->boolean;

  return (0);
}

/* Returns the object value from a given key in an object node. */
int
json_find_object(struct json_node *jn, const char *key, struct json_node **out,
    char **cause)
{
  struct json_node  *field;

  if ((field = json_find(jn, key)) == NULL) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" not found", key);
    return (-1);
  }
  if (field->type != NODE_OBJECT) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" expected an object", key);
    return (-1);
  }
  *out = field;

  return (0);
}

/* Returns the array value from a given key in an object node. */
int
json_find_array(struct json_node *jn, const char *key, struct json_node **out,
    char **cause)
{
  struct json_node  *field;

  if ((field = json_find(jn, key)) == NULL) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" not found", key);
    return (-1);
  }
  if (field->type != NODE_ARRAY) {
    if (cause != NULL)
      xasprintf(cause, "key \"%s\" expected an array", key);
    return (-1);
  }
  *out = field;

  return (0);
}

/* Fill an error cause. */
static void
json_error(char **cause, const char *reason, const char *loc)
{
  const char  *ellipsis = "...";
  int    i;

  if (cause == NULL)
    return;
  if (loc == NULL || *loc == '\0') {
    xasprintf(cause, "%s", reason);
    return;
  }

  for (i = 0; i < ERROR_CTX_LEN + 1; i++) {
    if (loc[i] == '\0') {
      ellipsis = "";
      break;
    }
  }

  xasprintf(cause, "%s: %.*s%s", reason, ERROR_CTX_LEN, loc, ellipsis);
}

/* Tokenize the json string. */
static struct json_tokens *
json_tokenize_input(const char *input, char **cause)
{
  struct json_tokens  *tokens;
  enum json_token_type   type;
  const char    *loc, *start = input;
  int      in_string = 0, scan;

  tokens = json_create_tokens();
  while (*input != '\0') {
    loc = input;
    scan = 1;

    if (in_string && *input != '"') {
      type = TOK_VALUE;
    } else {
      switch (*input) {
      case ' ':
      case '\t':
      case '\n':
      case '\r':
        input++;
        continue;
      case '{':
        type = TOK_OPENOBJECT;
        break;
      case '}':
        type = TOK_CLOSEOBJECT;
        break;
      case '[':
        type = TOK_OPENARRAY;
        break;
      case ']':
        type = TOK_CLOSEARRAY;
        break;
      case '"':
        type = TOK_QUOTE;
        break;
      case ':':
        type = TOK_COLON;
        break;
      case ',':
        type = TOK_COMMA;
        break;
      default:
        type = TOK_VALUE;
        break;
      }
    }
    if (type == TOK_VALUE) {
      scan = json_tokenize_value(tokens, loc);
      if (scan == -1)
        goto fail;
      input += scan - 1;
    }
    json_add_token(tokens, type, start, loc, scan);
    if (type == TOK_QUOTE)
      in_string = !in_string;

    input++;
  }
  json_add_token(tokens, TOK_EOF, start, loc, 0);

  return (tokens);

fail:
  json_error(cause, "tokenization error", loc);
  json_destroy_tokens(tokens);
  return (NULL);
}

/*
 * Tokenize a value from the input string. Strings are terminated by a '"', and
 * numbers/booleans are terminated by a ',', ']', '}', or whitespace.
 */
static int
json_tokenize_value(struct json_tokens *tokens, const char *loc)
{
  struct json_token *prev;
  int      i, scan = 0;

  if (tokens->size == 0)
    return (-1);
  prev = &tokens->toks[tokens->size - 1];

  if (prev->type == TOK_QUOTE) {
    while (loc[scan] != '"') {
      if (loc[scan] == '\0' || (u_char)loc[scan] < 0x20)
        return (-1);
      if (loc[scan] != '\\') {
        scan++;
        continue;
      }
      scan++;
      switch (loc[scan]) {
      case '"':
      case '\\':
      case '/':
      case 'b':
      case 'f':
      case 'n':
      case 'r':
      case 't':
        scan++;
        break;
      case 'u':
        for (i = 1; i <= 4; i++) {
          if (!isxdigit((u_char)loc[scan + i]))
            return (-1);
        }
        scan += 5;
        break;
      default:
        return (-1);
      }
    }
  } else if (prev->type == TOK_COLON) {
    do {
      if (loc[scan] == '\0')
        return (-1);
      scan++;
    } while (loc[scan] != ']' && loc[scan] != '}' &&
        loc[scan] != ',' && !isspace((u_char) loc[scan]));
  } else
    return (-1);

  return (scan);
}

/* Create a new token container. */
static struct json_tokens *
json_create_tokens(void)
{
  struct json_tokens  *tokens;

  tokens = xmalloc(sizeof *tokens);
  tokens->size = 0;
  tokens->capacity = 1024;
  tokens->toks = xmalloc(tokens->capacity * sizeof *tokens->toks);

  return (tokens);
}

/* Free a token container. */
static void
json_destroy_tokens(struct json_tokens *tokens)
{
  free(tokens->toks);
  tokens->toks = NULL;
  free(tokens);
}

/* Add a token to tokens. */
static void
json_add_token(struct json_tokens *tokens, enum json_token_type type,
    const char *input, const char *loc, int len)
{
  struct json_token *tok;

  while (tokens->size >= tokens->capacity) {
    tokens->capacity *= 2;
    tokens->toks = xrealloc(tokens->toks,
        sizeof *tokens->toks * tokens->capacity);
  }

  tok = &tokens->toks[tokens->size++];
  tok->type = type;
  tok->offset = loc - input;
  tok->len = len;
}

/* Create a node and assign given values. */
static struct json_node *
json_create_node(struct json_node *parent, enum json_node_type type,
    const char *key, void *val)
{
  struct json_node  *node;

  node = xcalloc(1, sizeof *node);
  node->parent = parent;
  if (key != NULL)
    node->key = xstrdup(key);
  node->type = type;
  if (type == NODE_OBJECT)
    RB_INIT(&node->fields);
  else if (type == NODE_ARRAY)
    TAILQ_INIT(&node->members);
  if (val != NULL)
    json_assign_value(node, val);

  return (node);
}

/* Destroy a node and all of the node's fields. */
void
json_destroy_node(struct json_node *node)
{
  struct json_node  *field, *field1, *member;

  if (node == NULL)
    return;

  switch (node->type) {
  case NODE_STRING:
    free(node->str);
    break;
  case NODE_NUMBER:
  case NODE_BOOLEAN:
    break;
  case NODE_OBJECT:
    RB_FOREACH_SAFE(field, json_fields, &node->fields, field1) {
      RB_REMOVE(json_fields, &node->fields, field);
      json_destroy_node(field);
    }
    break;
  case NODE_ARRAY:
    while (!TAILQ_EMPTY(&node->members)) {
      member = TAILQ_FIRST(&node->members);
      TAILQ_REMOVE(&node->members, member, aentry);
      json_destroy_node(member);
    }
    break;
  }

  if (node->key != NULL)
    free(node->key);
  free(node);
}

/* Assign a value to a node. */
static void
json_assign_value(struct json_node *node, void *val)
{
  struct json_node  *child = val;

  switch (node->type) {
  case NODE_STRING:
    node->str = val;
    break;
  case NODE_NUMBER:
    node->num = *(int64_t *)val;
    break;
  case NODE_BOOLEAN:
    node->boolean = *(int *)val;
    break;
  case NODE_OBJECT:
    RB_INSERT(json_fields, &node->fields, child);
    break;
  case NODE_ARRAY:
    TAILQ_INSERT_TAIL(&node->members, child, aentry);
    break;
  default:
    fatalx("unknown node type");
  }
}

/* Parse a stream of tokens into nodes. Consumes the tokens. */
static struct json_node *
json_parse_tokens(struct json_tokens **tokens, struct json_parse_ctx *pctx)
{
  struct json_token *tok = (*tokens)->toks;
  struct json_node  *jn = NULL;

  if (tok->type == TOK_OPENOBJECT)
    jn = json_parse_object(&tok, pctx, NULL, NULL);
  else {
    json_error(pctx->cause, "expected object",
        pctx->input + tok->offset);
    goto fail;
  }
  if (jn == NULL)
    goto fail;

  if (tok->type != TOK_EOF) {
    json_error(pctx->cause, "unexpected trailing data",
        pctx->input + tok->offset);
    goto fail;
  }
  json_destroy_tokens(*tokens);
  *tokens = NULL;

  return (jn);

fail:
  if (jn != NULL)
    json_destroy_node(jn);
  json_destroy_tokens(*tokens);
  *tokens = NULL;
  return (NULL);
}

/* Parse and return a key string, and advance the token pointer. */
static char *
json_parse_key(struct json_token **tok, struct json_parse_ctx *pctx)
{
  int    len;
  const char  *loc, *start = pctx->input + (*tok)->offset;
  char    *key;

  if ((*tok)->type != TOK_QUOTE)
    goto fail;
  (*tok)++;

  loc = pctx->input + (*tok)->offset;
  len = (*tok)->len;

  if ((*tok)->type != TOK_VALUE)
    goto fail;
  (*tok)++;
  if ((*tok)->type != TOK_QUOTE)
    goto fail;

  key = xstrndup(loc, len);
  (*tok)++;

  return (key);

fail:
  json_error(pctx->cause, "invalid key", start);
  return (NULL);
}

/* Parse an object value, return the node, and advance the token pointer. */
static struct json_node *
json_parse_object(struct json_token **tok, struct json_parse_ctx *pctx,
    const char *key, struct json_node *parent)
{
  struct json_node  *object, *field;
  char      *fkey = NULL;
  u_char      *valstr;

  if ((*tok)->type != TOK_OPENOBJECT)
    return (NULL);

  pctx->depth++;
  if (pctx->depth > PARSE_DEPTH_MAX) {
    json_error(pctx->cause, "parse depth exceeded",
        pctx->input + (*tok)->offset);
    return (NULL);
  }

  (*tok)++;

  object = json_create_node(parent, NODE_OBJECT, key, NULL);
  while ((*tok)->type != TOK_CLOSEOBJECT) {
    if ((fkey = json_parse_key(tok, pctx)) == NULL)
      goto fail;
    if (json_find(object, fkey) != NULL) {
      json_error(pctx->cause, "duplicate key",
          pctx->input + (*tok)->offset);
      goto fail;
    }
    if ((*tok)->type != TOK_COLON) {
      json_error(pctx->cause, "missing colon",
          pctx->input + (*tok)->offset);
      goto fail;
    }
    (*tok)++;

    switch ((*tok)->type) {
    case TOK_QUOTE:
      field = json_parse_string(tok, pctx, fkey, object);
      break;
    case TOK_VALUE:
      valstr = (u_char *)(pctx->input + (*tok)->offset);
      if ((*valstr == '-' && isdigit(valstr[1])) ||
          isdigit(*valstr)) {
        field = json_parse_number(tok, pctx, fkey,
            object);
      } else {
        field = json_parse_boolean(tok, pctx, fkey,
            object);
      }
      break;
    case TOK_OPENOBJECT:
      field = json_parse_object(tok, pctx, fkey, object);
      break;
    case TOK_OPENARRAY:
      field = json_parse_array(tok, pctx, fkey, object);
      break;
    default:
      json_error(pctx->cause,
          "unexpected value when parsing object",
          pctx->input + (*tok)->offset);
      goto fail;
    }
    if (field == NULL)
      goto fail;

    json_assign_value(object, field);
    if ((*tok)->type == TOK_COMMA) {
      if ((*tok)[1].type == TOK_CLOSEOBJECT) {
        json_error(pctx->cause, "invalid object",
            pctx->input + (*tok)->offset);
        goto fail;
      }
      (*tok)++;
    } else if ((*tok)->type != TOK_CLOSEOBJECT) {
      json_error(pctx->cause, "invalid object",
          pctx->input + (*tok)->offset);
      goto fail;
    }
    free(fkey);
  }
  (*tok)++;
  pctx->depth--;
  return (object);

fail:
  if (fkey != NULL)
    free(fkey);
  json_destroy_node(object);
  return (NULL);
}

/* Parse an array value, return the node, and advance the token pointer. */
static struct json_node *
json_parse_array(struct json_token **tok, struct json_parse_ctx *pctx,
    const char *key, struct json_node *parent)
{
  struct json_node  *array, *member;

  if ((*tok)->type != TOK_OPENARRAY)
    return (NULL);
  (*tok)++;

  array = json_create_node(parent, NODE_ARRAY, key, NULL);
  while ((*tok)->type != TOK_CLOSEARRAY) {
    switch ((*tok)->type) {
    case TOK_OPENOBJECT:
      member = json_parse_object(tok, pctx, NULL, array);
      break;
    default:
      json_error(pctx->cause, "invalid array member",
          pctx->input + (*tok)->offset);
      goto fail;
    }
    if (member == NULL)
      goto fail;

    json_assign_value(array, member);

    if ((*tok)->type == TOK_COMMA) {
      if ((*tok)[1].type == TOK_CLOSEARRAY) {
        json_error(pctx->cause, "invalid array",
            pctx->input + (*tok)->offset);
        goto fail;
      }
      (*tok)++;
    } else if ((*tok)->type != TOK_CLOSEARRAY) {
      json_error(pctx->cause, "invalid array",
          pctx->input + (*tok)->offset);
      goto fail;
    }
  }
  (*tok)++;
  return (array);

fail:
  json_destroy_node(array);
  return (NULL);
}

/* Parse a string value, return the node, and advance the token pointer. */
static struct json_node *
json_parse_string(struct json_token **tok, struct json_parse_ctx *pctx,
    const char *key, struct json_node *parent)
{
  const char  *loc, *start = pctx->input + (*tok)->offset;
  char    *str;
  int    len;

  if ((*tok)->type != TOK_QUOTE)
    goto fail;
  (*tok)++;
  if ((*tok)->type != TOK_VALUE)
    goto fail;

  loc = pctx->input + (*tok)->offset;
  len = (*tok)->len;
  (*tok)++;

  if ((*tok)->type != TOK_QUOTE)
    goto fail;
  (*tok)++;

  str = xstrndup(loc, len);
  return (json_create_node(parent, NODE_STRING, key, str));

fail:
  json_error(pctx->cause, "invalid string", start);
  return (NULL);
}

/* Parse a number value, return the node, and advance the token pointer. */
static struct json_node *
json_parse_number(struct json_token **tok, struct json_parse_ctx *pctx,
    const char *key, struct json_node *parent)
{
  const char  *start = pctx->input + (*tok)->offset;
  char    *endptr;
  int64_t    num;
  int    len = (*tok)->len;

  if ((start[0] == '0' && len != 1) ||
      (start[0] == '-' && start[1] == '0' && len != 2))
    goto fail;

  errno = 0;
  num = strtoll(start, &endptr, 10);
  if (errno != 0 || endptr != start + len)
    goto fail;
  (*tok)++;

  return (json_create_node(parent, NODE_NUMBER, key, &num));

fail:
  json_error(pctx->cause, "invalid number", start);
  return (NULL);
}

/* Parse a boolean value, return the node, and advance the token pointer. */
static struct json_node *
json_parse_boolean(struct json_token **tok, struct json_parse_ctx *pctx,
    const char *key, struct json_node *parent)
{
  int    len = (*tok)->len, boolean;
  const char  *start = pctx->input + (*tok)->offset;

  if (strncmp(start, "true", len) == 0 && len == 4)
    boolean = 1;
  else if (strncmp(start, "false", len) == 0 && len == 5)
    boolean = 0;
  else
    goto fail;
  (*tok)++;

  return (json_create_node(parent, NODE_BOOLEAN, key, &boolean));

fail:
  json_error(pctx->cause, "invalid boolean", start);
  return (NULL);
}

/* Append a node as JSON. */
static void
json_string_append(struct evbuffer *buffer, struct json_node *node)
{
  struct json_node  *field, *member;
  const char  *s;
  int    comma = 0;

  switch (node->type) {
  case NODE_STRING:
    evbuffer_add_printf(buffer, "\"%s\"", node->str);
    break;
  case NODE_NUMBER:
    evbuffer_add_printf(buffer, "%lld", (long long)node->num);
    break;
  case NODE_BOOLEAN:
    if (node->boolean)
      s = "true";
    else
      s = "false";
    evbuffer_add(buffer, s, strlen(s));
    break;
  case NODE_OBJECT:
    evbuffer_add(buffer, "{", 1);
    RB_FOREACH(field, json_fields, &node->fields) {
      if (comma)
        evbuffer_add(buffer, ",", 1);
      evbuffer_add_printf(buffer, "\"%s\":", field->key);
      json_string_append(buffer, field);
      comma = 1;
    }
    evbuffer_add(buffer, "}", 1);
    break;
  case NODE_ARRAY:
    evbuffer_add(buffer, "[", 1);
    TAILQ_FOREACH(member, &node->members, aentry) {
      if (comma)
        evbuffer_add(buffer, ",", 1);
      json_string_append(buffer, member);
      comma = 1;
    }
    evbuffer_add(buffer, "]", 1);
    break;
  }
}

/* Convert a node back to JSON. */
char *
json_to_string(struct json_node *node)
{
  struct evbuffer *buffer;
  char    *out;

  if (node == NULL)
    return (NULL);
  buffer = evbuffer_new();
  if (buffer == NULL)
    fatalx("out of memory");
  json_string_append(buffer, node);
  out = xmemdup(EVBUFFER_DATA(buffer), EVBUFFER_LENGTH(buffer));
  evbuffer_free(buffer);
  return (out);
}

Coverage Report

Created: 2026-09-13 06:02