diff options
Diffstat (limited to 'comm/third_party/json-c/json_util.c')
-rw-r--r-- | comm/third_party/json-c/json_util.c | 296 |
1 files changed, 296 insertions, 0 deletions
diff --git a/comm/third_party/json-c/json_util.c b/comm/third_party/json-c/json_util.c new file mode 100644 index 0000000000..3e6a6c681b --- /dev/null +++ b/comm/third_party/json-c/json_util.c @@ -0,0 +1,296 @@ +/* + * $Id: json_util.c,v 1.4 2006/01/30 23:07:57 mclark Exp $ + * + * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. + * Michael Clark <michael@metaparadigm.com> + * + * This library is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See COPYING for details. + * + */ + +#include "config.h" +#undef realloc + +#include "strerror_override.h" + +#include <limits.h> +#include <stdarg.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#ifdef HAVE_SYS_TYPES_H +#include <sys/types.h> +#endif /* HAVE_SYS_TYPES_H */ + +#ifdef HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif /* HAVE_SYS_STAT_H */ + +#ifdef HAVE_FCNTL_H +#include <fcntl.h> +#endif /* HAVE_FCNTL_H */ + +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif /* HAVE_UNISTD_H */ + +#ifdef WIN32 +#define WIN32_LEAN_AND_MEAN +#include <io.h> +#include <windows.h> +#endif /* defined(WIN32) */ + +#if !defined(HAVE_OPEN) && defined(WIN32) +#define open _open +#endif + +#include "snprintf_compat.h" + +#include "debug.h" +#include "json_inttypes.h" +#include "json_object.h" +#include "json_tokener.h" +#include "json_util.h" +#include "printbuf.h" + +static int _json_object_to_fd(int fd, struct json_object *obj, int flags, const char *filename); + +static char _last_err[256] = ""; + +const char *json_util_get_last_err() +{ + if (_last_err[0] == '\0') + return NULL; + return _last_err; +} + +void _json_c_set_last_err(const char *err_fmt, ...) +{ + va_list ap; + va_start(ap, err_fmt); + // Ignore (attempted) overruns from snprintf + (void)vsnprintf(_last_err, sizeof(_last_err), err_fmt, ap); + va_end(ap); +} + +struct json_object *json_object_from_fd(int fd) +{ + return json_object_from_fd_ex(fd, -1); +} +struct json_object *json_object_from_fd_ex(int fd, int in_depth) +{ + struct printbuf *pb; + struct json_object *obj; + char buf[JSON_FILE_BUF_SIZE]; + int ret; + int depth = JSON_TOKENER_DEFAULT_DEPTH; + json_tokener *tok; + + if (!(pb = printbuf_new())) + { + _json_c_set_last_err("json_object_from_fd_ex: printbuf_new failed\n"); + return NULL; + } + + if (in_depth != -1) + depth = in_depth; + tok = json_tokener_new_ex(depth); + if (!tok) + { + _json_c_set_last_err( + "json_object_from_fd_ex: unable to allocate json_tokener(depth=%d): %s\n", depth, + strerror(errno)); + printbuf_free(pb); + return NULL; + } + + while ((ret = read(fd, buf, JSON_FILE_BUF_SIZE)) > 0) + { + printbuf_memappend(pb, buf, ret); + } + if (ret < 0) + { + _json_c_set_last_err("json_object_from_fd_ex: error reading fd %d: %s\n", fd, + strerror(errno)); + json_tokener_free(tok); + printbuf_free(pb); + return NULL; + } + + obj = json_tokener_parse_ex(tok, pb->buf, printbuf_length(pb)); + if (obj == NULL) + _json_c_set_last_err("json_tokener_parse_ex failed: %s\n", + json_tokener_error_desc(json_tokener_get_error(tok))); + + json_tokener_free(tok); + printbuf_free(pb); + return obj; +} + +struct json_object *json_object_from_file(const char *filename) +{ + struct json_object *obj; + int fd; + + if ((fd = open(filename, O_RDONLY)) < 0) + { + _json_c_set_last_err("json_object_from_file: error opening file %s: %s\n", + filename, strerror(errno)); + return NULL; + } + obj = json_object_from_fd(fd); + close(fd); + return obj; +} + +/* extended "format and write to file" function */ + +int json_object_to_file_ext(const char *filename, struct json_object *obj, int flags) +{ + int fd, ret; + int saved_errno; + + if (!obj) + { + _json_c_set_last_err("json_object_to_file_ext: object is null\n"); + return -1; + } + + if ((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0644)) < 0) + { + _json_c_set_last_err("json_object_to_file_ext: error opening file %s: %s\n", + filename, strerror(errno)); + return -1; + } + ret = _json_object_to_fd(fd, obj, flags, filename); + saved_errno = errno; + close(fd); + errno = saved_errno; + return ret; +} + +int json_object_to_fd(int fd, struct json_object *obj, int flags) +{ + if (!obj) + { + _json_c_set_last_err("json_object_to_fd: object is null\n"); + return -1; + } + + return _json_object_to_fd(fd, obj, flags, NULL); +} +static int _json_object_to_fd(int fd, struct json_object *obj, int flags, const char *filename) +{ + int ret; + const char *json_str; + unsigned int wpos, wsize; + + filename = filename ? filename : "(fd)"; + + if (!(json_str = json_object_to_json_string_ext(obj, flags))) + { + return -1; + } + + /* CAW: probably unnecessary, but the most 64bit safe */ + wsize = (unsigned int)(strlen(json_str) & UINT_MAX); + wpos = 0; + while (wpos < wsize) + { + if ((ret = write(fd, json_str + wpos, wsize - wpos)) < 0) + { + _json_c_set_last_err("json_object_to_fd: error writing file %s: %s\n", + filename, strerror(errno)); + return -1; + } + + /* because of the above check for ret < 0, we can safely cast and add */ + wpos += (unsigned int)ret; + } + + return 0; +} + +// backwards compatible "format and write to file" function + +int json_object_to_file(const char *filename, struct json_object *obj) +{ + return json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN); +} + +// Deprecated json_parse_double function. See json_tokener_parse_double instead. +int json_parse_double(const char *buf, double *retval) +{ + char *end; + *retval = strtod(buf, &end); + return end == buf ? 1 : 0; +} + +int json_parse_int64(const char *buf, int64_t *retval) +{ + char *end = NULL; + int64_t val; + + errno = 0; + val = strtoll(buf, &end, 10); + if (end != buf) + *retval = val; + return ((val == 0 && errno != 0) || (end == buf)) ? 1 : 0; +} + +int json_parse_uint64(const char *buf, uint64_t *retval) +{ + char *end = NULL; + uint64_t val; + + errno = 0; + while (*buf == ' ') + buf++; + if (*buf == '-') + return 1; /* error: uint cannot be negative */ + + val = strtoull(buf, &end, 10); + if (end != buf) + *retval = val; + return ((val == 0 && errno != 0) || (end == buf)) ? 1 : 0; +} + +#ifndef HAVE_REALLOC +void *rpl_realloc(void *p, size_t n) +{ + if (n == 0) + n = 1; + if (p == 0) + return malloc(n); + return realloc(p, n); +} +#endif + +#define NELEM(a) (sizeof(a) / sizeof(a[0])) +/* clang-format off */ +static const char *json_type_name[] = { + /* If you change this, be sure to update the enum json_type definition too */ + "null", + "boolean", + "double", + "int", + "object", + "array", + "string", +}; +/* clang-format on */ + +const char *json_type_to_name(enum json_type o_type) +{ + int o_type_int = (int)o_type; + if (o_type_int < 0 || o_type_int >= (int)NELEM(json_type_name)) + { + _json_c_set_last_err("json_type_to_name: type %d is out of range [0,%u]\n", o_type, + (unsigned)NELEM(json_type_name)); + return NULL; + } + return json_type_name[o_type]; +} |