summaryrefslogtreecommitdiffstats
path: root/third_party/heimdal/lib/base/json.c
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/heimdal/lib/base/json.c')
-rw-r--r--third_party/heimdal/lib/base/json.c811
1 files changed, 811 insertions, 0 deletions
diff --git a/third_party/heimdal/lib/base/json.c b/third_party/heimdal/lib/base/json.c
new file mode 100644
index 0000000..2ef371b
--- /dev/null
+++ b/third_party/heimdal/lib/base/json.c
@@ -0,0 +1,811 @@
+/*
+ * Copyright (c) 2010 Kungliga Tekniska Högskolan
+ * (Royal Institute of Technology, Stockholm, Sweden).
+ * All rights reserved.
+ *
+ * Portions Copyright (c) 2010 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "baselocl.h"
+#include <ctype.h>
+#include <base64.h>
+
+static heim_base_once_t heim_json_once = HEIM_BASE_ONCE_INIT;
+static heim_string_t heim_tid_data_uuid_key = NULL;
+static const char base64_chars[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+static void
+json_init_once(void *arg)
+{
+ heim_tid_data_uuid_key = __heim_string_constant("heimdal-type-data-76d7fca2-d0da-4b20-a126-1a10f8a0eae6");
+}
+
+struct twojson {
+ void *ctx;
+ void (*out)(void *, const char *);
+ size_t indent;
+ heim_json_flags_t flags;
+ int ret;
+ int first;
+};
+
+struct heim_strbuf {
+ char *str;
+ size_t len;
+ size_t alloced;
+ int enomem;
+ heim_json_flags_t flags;
+};
+
+static int
+base2json(heim_object_t, struct twojson *);
+
+static void
+indent(struct twojson *j)
+{
+ size_t i = j->indent;
+ if (j->flags & HEIM_JSON_F_ONE_LINE)
+ return;
+ while (i--)
+ j->out(j->ctx, "\t");
+}
+
+static void
+array2json(heim_object_t value, void *ctx, int *stop)
+{
+ struct twojson *j = ctx;
+ if (j->ret)
+ return;
+ if (j->first) {
+ j->first = 0;
+ } else {
+ j->out(j->ctx, NULL); /* eat previous '\n' if possible */
+ j->out(j->ctx, ",\n");
+ }
+ j->ret = base2json(value, j);
+}
+
+static void
+dict2json(heim_object_t key, heim_object_t value, void *ctx)
+{
+ struct twojson *j = ctx;
+ if (j->ret)
+ return;
+ if (j->first) {
+ j->first = 0;
+ } else {
+ j->out(j->ctx, NULL); /* eat previous '\n' if possible */
+ j->out(j->ctx, ",\n");
+ }
+ j->ret = base2json(key, j);
+ if (j->ret)
+ return;
+ j->out(j->ctx, " : \n");
+ j->indent++;
+ j->ret = base2json(value, j);
+ if (j->ret)
+ return;
+ j->indent--;
+}
+
+static int
+base2json(heim_object_t obj, struct twojson *j)
+{
+ heim_tid_t type;
+ int first = 0;
+
+ if (obj == NULL) {
+ if (j->flags & HEIM_JSON_F_CNULL2JSNULL) {
+ obj = heim_null_create();
+ } else if (j->flags & HEIM_JSON_F_NO_C_NULL) {
+ return EINVAL;
+ } else {
+ indent(j);
+ j->out(j->ctx, "<NULL>\n"); /* This is NOT valid JSON! */
+ return 0;
+ }
+ }
+
+ type = heim_get_tid(obj);
+ switch (type) {
+ case HEIM_TID_ARRAY:
+ indent(j);
+ j->out(j->ctx, "[\n");
+ j->indent++;
+ first = j->first;
+ j->first = 1;
+ heim_array_iterate_f(obj, j, array2json);
+ j->indent--;
+ if (!j->first)
+ j->out(j->ctx, "\n");
+ indent(j);
+ j->out(j->ctx, "]\n");
+ j->first = first;
+ break;
+
+ case HEIM_TID_DICT:
+ indent(j);
+ j->out(j->ctx, "{\n");
+ j->indent++;
+ first = j->first;
+ j->first = 1;
+ heim_dict_iterate_f(obj, j, dict2json);
+ j->indent--;
+ if (!j->first)
+ j->out(j->ctx, "\n");
+ indent(j);
+ j->out(j->ctx, "}\n");
+ j->first = first;
+ break;
+
+ case HEIM_TID_STRING:
+ indent(j);
+ j->out(j->ctx, "\"");
+ j->out(j->ctx, heim_string_get_utf8(obj));
+ j->out(j->ctx, "\"");
+ break;
+
+ case HEIM_TID_DATA: {
+ heim_dict_t d;
+ heim_string_t v;
+ const heim_octet_string *data;
+ char *b64 = NULL;
+ int ret;
+
+ if (j->flags & HEIM_JSON_F_NO_DATA)
+ return EINVAL; /* JSON doesn't do binary */
+
+ data = heim_data_get_data(obj);
+ ret = rk_base64_encode(data->data, data->length, &b64);
+ if (ret < 0 || b64 == NULL)
+ return ENOMEM;
+
+ if (j->flags & HEIM_JSON_F_NO_DATA_DICT) {
+ indent(j);
+ j->out(j->ctx, "\"");
+ j->out(j->ctx, b64); /* base64-encode; hope there's no aliasing */
+ j->out(j->ctx, "\"");
+ free(b64);
+ } else {
+ /*
+ * JSON has no way to represent binary data, therefore the
+ * following is a Heimdal-specific convention.
+ *
+ * We encode binary data as a dict with a single very magic
+ * key with a base64-encoded value. The magic key includes
+ * a uuid, so we're not likely to alias accidentally.
+ */
+ d = heim_dict_create(2);
+ if (d == NULL) {
+ free(b64);
+ return ENOMEM;
+ }
+ v = heim_string_ref_create(b64, free);
+ if (v == NULL) {
+ free(b64);
+ heim_release(d);
+ return ENOMEM;
+ }
+ ret = heim_dict_set_value(d, heim_tid_data_uuid_key, v);
+ heim_release(v);
+ if (ret) {
+ heim_release(d);
+ return ENOMEM;
+ }
+ ret = base2json(d, j);
+ heim_release(d);
+ if (ret)
+ return ret;
+ }
+ break;
+ }
+
+ case HEIM_TID_NUMBER: {
+ char num[32];
+ indent(j);
+ snprintf(num, sizeof (num), "%d", heim_number_get_int(obj));
+ j->out(j->ctx, num);
+ break;
+ }
+ case HEIM_TID_NULL:
+ indent(j);
+ j->out(j->ctx, "null");
+ break;
+ case HEIM_TID_BOOL:
+ indent(j);
+ j->out(j->ctx, heim_bool_val(obj) ? "true" : "false");
+ break;
+ default:
+ return 1;
+ }
+ return 0;
+}
+
+static int
+heim_base2json(heim_object_t obj, void *ctx, heim_json_flags_t flags,
+ void (*out)(void *, const char *))
+{
+ struct twojson j;
+
+ if (flags & HEIM_JSON_F_STRICT_STRINGS)
+ return ENOTSUP; /* Sorry, not yet! */
+
+ heim_base_once_f(&heim_json_once, NULL, json_init_once);
+
+ j.indent = 0;
+ j.ctx = ctx;
+ j.out = out;
+ j.flags = flags;
+ j.ret = 0;
+ j.first = 1;
+
+ return base2json(obj, &j);
+}
+
+
+/*
+ *
+ */
+
+struct parse_ctx {
+ unsigned long lineno;
+ const uint8_t *p;
+ const uint8_t *pstart;
+ const uint8_t *pend;
+ heim_error_t error;
+ size_t depth;
+ heim_json_flags_t flags;
+};
+
+
+static heim_object_t
+parse_value(struct parse_ctx *ctx);
+
+/*
+ * This function eats whitespace, but, critically, it also succeeds
+ * only if there's anything left to parse.
+ */
+static int
+white_spaces(struct parse_ctx *ctx)
+{
+ while (ctx->p < ctx->pend) {
+ uint8_t c = *ctx->p;
+ if (c == ' ' || c == '\t' || c == '\r') {
+
+ } else if (c == '\n') {
+ ctx->lineno++;
+ } else
+ return 0;
+ (ctx->p)++;
+ }
+ return -1;
+}
+
+static int
+is_number(uint8_t n)
+{
+ return ('0' <= n && n <= '9');
+}
+
+static heim_number_t
+parse_number(struct parse_ctx *ctx)
+{
+ int number = 0, neg = 1;
+
+ if (ctx->p >= ctx->pend)
+ return NULL;
+
+ if (*ctx->p == '-') {
+ if (ctx->p + 1 >= ctx->pend)
+ return NULL;
+ neg = -1;
+ ctx->p += 1;
+ }
+
+ while (ctx->p < ctx->pend) {
+ if (is_number(*ctx->p)) {
+ number = (number * 10) + (*ctx->p - '0');
+ } else {
+ break;
+ }
+ ctx->p += 1;
+ }
+
+ return heim_number_create(number * neg);
+}
+
+static heim_string_t
+parse_string(struct parse_ctx *ctx)
+{
+ const uint8_t *start;
+ int quote = 0;
+
+ if (ctx->flags & HEIM_JSON_F_STRICT_STRINGS) {
+ ctx->error = heim_error_create(EINVAL, "Strict JSON string encoding "
+ "not yet supported");
+ return NULL;
+ }
+
+ if (*ctx->p != '"') {
+ ctx->error = heim_error_create(EINVAL, "Expected a JSON string but "
+ "found something else at line %lu",
+ ctx->lineno);
+ return NULL;
+ }
+ start = ++ctx->p;
+
+ while (ctx->p < ctx->pend) {
+ if (*ctx->p == '\n') {
+ ctx->lineno++;
+ } else if (*ctx->p == '\\') {
+ if (ctx->p + 1 == ctx->pend)
+ goto out;
+ ctx->p++;
+ quote = 1;
+ } else if (*ctx->p == '"') {
+ heim_object_t o;
+
+ if (quote) {
+ char *p0, *p;
+ p = p0 = malloc(ctx->p - start);
+ if (p == NULL)
+ goto out;
+ while (start < ctx->p) {
+ if (*start == '\\') {
+ start++;
+ /* XXX validate quoted char */
+ }
+ *p++ = *start++;
+ }
+ o = heim_string_create_with_bytes(p0, p - p0);
+ free(p0);
+ } else {
+ o = heim_string_create_with_bytes(start, ctx->p - start);
+ if (o == NULL) {
+ ctx->error = heim_error_create_enomem();
+ return NULL;
+ }
+
+ /* If we can decode as base64, then let's */
+ if (ctx->flags & HEIM_JSON_F_TRY_DECODE_DATA) {
+ void *buf;
+ size_t len;
+ const char *s;
+
+ s = heim_string_get_utf8(o);
+ len = strlen(s);
+
+ if (len >= 4 && strspn(s, base64_chars) >= len - 2) {
+ buf = malloc(len);
+ if (buf == NULL) {
+ heim_release(o);
+ ctx->error = heim_error_create_enomem();
+ return NULL;
+ }
+ len = rk_base64_decode(s, buf);
+ if (len == -1) {
+ free(buf);
+ return o;
+ }
+ heim_release(o);
+ o = heim_data_ref_create(buf, len, free);
+ }
+ }
+ }
+ ctx->p += 1;
+
+ return o;
+ }
+ ctx->p += 1;
+ }
+ out:
+ ctx->error = heim_error_create(EINVAL, "ran out of string");
+ return NULL;
+}
+
+static int
+parse_pair(heim_dict_t dict, struct parse_ctx *ctx)
+{
+ heim_string_t key;
+ heim_object_t value;
+
+ if (white_spaces(ctx))
+ return -1;
+
+ if (*ctx->p == '}') {
+ ctx->p++;
+ return 0;
+ }
+
+ if (ctx->flags & HEIM_JSON_F_STRICT_DICT)
+ /* JSON allows only string keys */
+ key = parse_string(ctx);
+ else
+ /* heim_dict_t allows any heim_object_t as key */
+ key = parse_value(ctx);
+ if (key == NULL)
+ /* Even heim_dict_t does not allow C NULLs as keys though! */
+ return -1;
+
+ if (white_spaces(ctx)) {
+ heim_release(key);
+ return -1;
+ }
+
+ if (*ctx->p != ':') {
+ heim_release(key);
+ return -1;
+ }
+
+ ctx->p += 1; /* safe because we call white_spaces() next */
+
+ if (white_spaces(ctx)) {
+ heim_release(key);
+ return -1;
+ }
+
+ value = parse_value(ctx);
+ if (value == NULL &&
+ (ctx->error != NULL || (ctx->flags & HEIM_JSON_F_NO_C_NULL))) {
+ if (ctx->error == NULL)
+ ctx->error = heim_error_create(EINVAL, "Invalid JSON encoding");
+ heim_release(key);
+ return -1;
+ }
+ heim_dict_set_value(dict, key, value);
+ heim_release(key);
+ heim_release(value);
+
+ if (white_spaces(ctx))
+ return -1;
+
+ if (*ctx->p == '}') {
+ /*
+ * Return 1 but don't consume the '}' so we can count the one
+ * pair in a one-pair dict
+ */
+ return 1;
+ } else if (*ctx->p == ',') {
+ ctx->p++;
+ return 1;
+ }
+ return -1;
+}
+
+static heim_dict_t
+parse_dict(struct parse_ctx *ctx)
+{
+ heim_dict_t dict;
+ size_t count = 0;
+ int ret;
+
+ heim_assert(*ctx->p == '{', "string doesn't start with {");
+
+ dict = heim_dict_create(11);
+ if (dict == NULL) {
+ ctx->error = heim_error_create_enomem();
+ return NULL;
+ }
+
+ ctx->p += 1; /* safe because parse_pair() calls white_spaces() first */
+
+ while ((ret = parse_pair(dict, ctx)) > 0)
+ count++;
+ if (ret < 0) {
+ heim_release(dict);
+ return NULL;
+ }
+ if (count == 1 && !(ctx->flags & HEIM_JSON_F_NO_DATA_DICT)) {
+ heim_object_t v = heim_dict_copy_value(dict, heim_tid_data_uuid_key);
+
+ /*
+ * Binary data encoded as a dict with a single magic key with
+ * base64-encoded value? Decode as heim_data_t.
+ */
+ if (v != NULL && heim_get_tid(v) == HEIM_TID_STRING) {
+ void *buf;
+ size_t len;
+
+ buf = malloc(strlen(heim_string_get_utf8(v)));
+ if (buf == NULL) {
+ heim_release(dict);
+ heim_release(v);
+ ctx->error = heim_error_create_enomem();
+ return NULL;
+ }
+ len = rk_base64_decode(heim_string_get_utf8(v), buf);
+ heim_release(v);
+ if (len == -1) {
+ free(buf);
+ return dict; /* assume aliasing accident */
+ }
+ heim_release(dict);
+ return (heim_dict_t)heim_data_ref_create(buf, len, free);
+ }
+ }
+ return dict;
+}
+
+static int
+parse_item(heim_array_t array, struct parse_ctx *ctx)
+{
+ heim_object_t value;
+
+ if (white_spaces(ctx))
+ return -1;
+
+ if (*ctx->p == ']') {
+ ctx->p++; /* safe because parse_value() calls white_spaces() first */
+ return 0;
+ }
+
+ value = parse_value(ctx);
+ if (value == NULL &&
+ (ctx->error || (ctx->flags & HEIM_JSON_F_NO_C_NULL)))
+ return -1;
+
+ heim_array_append_value(array, value);
+ heim_release(value);
+
+ if (white_spaces(ctx))
+ return -1;
+
+ if (*ctx->p == ']') {
+ ctx->p++;
+ return 0;
+ } else if (*ctx->p == ',') {
+ ctx->p++;
+ return 1;
+ }
+ return -1;
+}
+
+static heim_array_t
+parse_array(struct parse_ctx *ctx)
+{
+ heim_array_t array = heim_array_create();
+ int ret;
+
+ heim_assert(*ctx->p == '[', "array doesn't start with [");
+ ctx->p += 1;
+
+ while ((ret = parse_item(array, ctx)) > 0)
+ ;
+ if (ret < 0) {
+ heim_release(array);
+ return NULL;
+ }
+ return array;
+}
+
+static heim_object_t
+parse_value(struct parse_ctx *ctx)
+{
+ size_t len;
+ heim_object_t o;
+
+ if (white_spaces(ctx))
+ return NULL;
+
+ if (*ctx->p == '"') {
+ return parse_string(ctx);
+ } else if (*ctx->p == '{') {
+ if (ctx->depth-- == 1) {
+ ctx->error = heim_error_create(EINVAL, "JSON object too deep");
+ return NULL;
+ }
+ o = parse_dict(ctx);
+ ctx->depth++;
+ return o;
+ } else if (*ctx->p == '[') {
+ if (ctx->depth-- == 1) {
+ ctx->error = heim_error_create(EINVAL, "JSON object too deep");
+ return NULL;
+ }
+ o = parse_array(ctx);
+ ctx->depth++;
+ return o;
+ } else if (is_number(*ctx->p) || *ctx->p == '-') {
+ return parse_number(ctx);
+ }
+
+ len = ctx->pend - ctx->p;
+
+ if ((ctx->flags & HEIM_JSON_F_NO_C_NULL) == 0 &&
+ len >= 6 && memcmp(ctx->p, "<NULL>", 6) == 0) {
+ ctx->p += 6;
+ return heim_null_create();
+ } else if (len >= 4 && memcmp(ctx->p, "null", 4) == 0) {
+ ctx->p += 4;
+ return heim_null_create();
+ } else if (len >= 4 && strncasecmp((char *)ctx->p, "true", 4) == 0) {
+ ctx->p += 4;
+ return heim_bool_create(1);
+ } else if (len >= 5 && strncasecmp((char *)ctx->p, "false", 5) == 0) {
+ ctx->p += 5;
+ return heim_bool_create(0);
+ }
+
+ ctx->error = heim_error_create(EINVAL, "unknown char %c at %lu line %lu",
+ (char)*ctx->p,
+ (unsigned long)(ctx->p - ctx->pstart),
+ ctx->lineno);
+ return NULL;
+}
+
+
+heim_object_t
+heim_json_create(const char *string, size_t max_depth, heim_json_flags_t flags,
+ heim_error_t *error)
+{
+ return heim_json_create_with_bytes(string, strlen(string), max_depth, flags,
+ error);
+}
+
+heim_object_t
+heim_json_create_with_bytes(const void *data, size_t length, size_t max_depth,
+ heim_json_flags_t flags, heim_error_t *error)
+{
+ struct parse_ctx ctx;
+ heim_object_t o;
+
+ heim_base_once_f(&heim_json_once, NULL, json_init_once);
+
+ ctx.lineno = 1;
+ ctx.p = data;
+ ctx.pstart = data;
+ ctx.pend = ((uint8_t *)data) + length;
+ ctx.error = NULL;
+ ctx.flags = flags;
+ ctx.depth = max_depth;
+
+ o = parse_value(&ctx);
+
+ if (o == NULL && error) {
+ *error = ctx.error;
+ } else if (ctx.error) {
+ heim_release(ctx.error);
+ }
+
+ return o;
+}
+
+
+static void
+show_printf(void *ctx, const char *str)
+{
+ if (str == NULL)
+ return;
+ fprintf(ctx, "%s", str);
+}
+
+/**
+ * Dump a heimbase object to stderr (useful from the debugger!)
+ *
+ * @param obj object to dump using JSON or JSON-like format
+ *
+ * @addtogroup heimbase
+ */
+void
+heim_show(heim_object_t obj)
+{
+ heim_base2json(obj, stderr, HEIM_JSON_F_NO_DATA_DICT, show_printf);
+}
+
+static void
+strbuf_add(void *ctx, const char *str)
+{
+ struct heim_strbuf *strbuf = ctx;
+ size_t len;
+
+ if (strbuf->enomem)
+ return;
+
+ if (str == NULL) {
+ /*
+ * Eat the last '\n'; this is used when formatting dict pairs
+ * and array items so that the ',' separating them is never
+ * preceded by a '\n'.
+ */
+ if (strbuf->len > 0 && strbuf->str[strbuf->len - 1] == '\n')
+ strbuf->len--;
+ return;
+ }
+
+ len = strlen(str);
+ if ((len + 1) > (strbuf->alloced - strbuf->len)) {
+ size_t new_len = strbuf->alloced + (strbuf->alloced >> 2) + len + 1;
+ char *s;
+
+ s = realloc(strbuf->str, new_len);
+ if (s == NULL) {
+ strbuf->enomem = 1;
+ return;
+ }
+ strbuf->str = s;
+ strbuf->alloced = new_len;
+ }
+ /* +1 so we copy the NUL */
+ (void) memcpy(strbuf->str + strbuf->len, str, len + 1);
+ strbuf->len += len;
+ if (strbuf->str[strbuf->len - 1] == '\n' &&
+ strbuf->flags & HEIM_JSON_F_ONE_LINE)
+ strbuf->len--;
+}
+
+#define STRBUF_INIT_SZ 64
+
+heim_string_t
+heim_json_copy_serialize(heim_object_t obj, heim_json_flags_t flags, heim_error_t *error)
+{
+ heim_string_t str;
+ struct heim_strbuf strbuf;
+ int ret;
+
+ if (error)
+ *error = NULL;
+
+ memset(&strbuf, 0, sizeof (strbuf));
+ strbuf.str = malloc(STRBUF_INIT_SZ);
+ if (strbuf.str == NULL) {
+ if (error)
+ *error = heim_error_create_enomem();
+ return NULL;
+ }
+ strbuf.len = 0;
+ strbuf.alloced = STRBUF_INIT_SZ;
+ strbuf.str[0] = '\0';
+ strbuf.flags = flags;
+
+ ret = heim_base2json(obj, &strbuf, flags, strbuf_add);
+ if (ret || strbuf.enomem) {
+ if (error) {
+ if (strbuf.enomem || ret == ENOMEM)
+ *error = heim_error_create_enomem();
+ else
+ *error = heim_error_create(1, "Impossible to JSON-encode "
+ "object");
+ }
+ free(strbuf.str);
+ return NULL;
+ }
+ if (flags & HEIM_JSON_F_ONE_LINE) {
+ strbuf.flags &= ~HEIM_JSON_F_ONE_LINE;
+ strbuf_add(&strbuf, "\n");
+ }
+ str = heim_string_ref_create(strbuf.str, free);
+ if (str == NULL) {
+ if (error)
+ *error = heim_error_create_enomem();
+ free(strbuf.str);
+ }
+ return str;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-23 02:42:12 +0000