summaryrefslogtreecommitdiffstats
path: root/src/pulse/json.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/pulse/json.c614
1 files changed, 614 insertions, 0 deletions
diff --git a/src/pulse/json.c b/src/pulse/json.c
new file mode 100644
index 0000000..d126712
--- /dev/null
+++ b/src/pulse/json.c
@@ -0,0 +1,614 @@
+/***
+ This file is part of PulseAudio.
+
+ Copyright 2016 Arun Raghavan <mail@arunraghavan.net>
+
+ PulseAudio 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.
+
+ PulseAudio 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 Lesser General Public License
+ along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <math.h>
+
+#include <pulse/json.h>
+#include <pulse/xmalloc.h>
+#include <pulsecore/core-util.h>
+#include <pulsecore/hashmap.h>
+#include <pulsecore/strbuf.h>
+
+#define MAX_NESTING_DEPTH 20 /* Arbitrary number to make sure we don't have a stack overflow */
+
+struct pa_json_object {
+ pa_json_type type;
+
+ union {
+ int int_value;
+ double double_value;
+ bool bool_value;
+ char *string_value;
+ pa_hashmap *object_values; /* name -> object */
+ pa_idxset *array_values; /* objects */
+ };
+};
+
+static const char* parse_value(const char *str, const char *end, pa_json_object **obj, unsigned int depth);
+
+static pa_json_object* json_object_new(void) {
+ pa_json_object *obj;
+
+ obj = pa_xnew0(pa_json_object, 1);
+
+ return obj;
+}
+
+static bool is_whitespace(char c) {
+ return c == '\t' || c == '\n' || c == '\r' || c == ' ';
+}
+
+static bool is_digit(char c) {
+ return c >= '0' && c <= '9';
+}
+
+static bool is_end(const char c, const char *end) {
+ if (!end)
+ return c == '\0';
+ else {
+ while (*end) {
+ if (c == *end)
+ return true;
+ end++;
+ }
+ }
+
+ return false;
+}
+
+static const char* consume_string(const char *str, const char *expect) {
+ while (*expect) {
+ if (*str != *expect)
+ return NULL;
+
+ str++;
+ expect++;
+ }
+
+ return str;
+}
+
+static const char* parse_null(const char *str, pa_json_object *obj) {
+ str = consume_string(str, "null");
+
+ if (str)
+ obj->type = PA_JSON_TYPE_NULL;
+
+ return str;
+}
+
+static const char* parse_boolean(const char *str, pa_json_object *obj) {
+ const char *tmp;
+
+ tmp = consume_string(str, "true");
+
+ if (tmp) {
+ obj->type = PA_JSON_TYPE_BOOL;
+ obj->bool_value = true;
+ } else {
+ tmp = consume_string(str, "false");
+
+ if (str) {
+ obj->type = PA_JSON_TYPE_BOOL;
+ obj->bool_value = false;
+ }
+ }
+
+ return tmp;
+}
+
+static const char* parse_string(const char *str, pa_json_object *obj) {
+ pa_strbuf *buf = pa_strbuf_new();
+
+ str++; /* Consume leading '"' */
+
+ while (*str && *str != '"') {
+ if (*str != '\\') {
+ /* We only accept ASCII printable characters. */
+ if (*str < 0x20 || *str > 0x7E) {
+ pa_log("Invalid non-ASCII character: 0x%x", (unsigned int) *str);
+ goto error;
+ }
+
+ /* Normal character, juts consume */
+ pa_strbuf_putc(buf, *str);
+ } else {
+ /* Need to unescape */
+ str++;
+
+ switch (*str) {
+ case '"':
+ case '\\':
+ case '/':
+ pa_strbuf_putc(buf, *str);
+ break;
+
+ case 'b':
+ pa_strbuf_putc(buf, '\b' /* backspace */);
+ break;
+
+ case 'f':
+ pa_strbuf_putc(buf, '\f' /* form feed */);
+ break;
+
+ case 'n':
+ pa_strbuf_putc(buf, '\n' /* new line */);
+ break;
+
+ case 'r':
+ pa_strbuf_putc(buf, '\r' /* carriage return */);
+ break;
+
+ case 't':
+ pa_strbuf_putc(buf, '\t' /* horizontal tab */);
+ break;
+
+ case 'u':
+ pa_log("Unicode code points are currently unsupported");
+ goto error;
+
+ default:
+ pa_log("Unexepcted escape value: %c", *str);
+ goto error;
+ }
+ }
+
+ str++;
+ }
+
+ if (*str != '"') {
+ pa_log("Failed to parse remainder of string: %s", str);
+ goto error;
+ }
+
+ str++;
+
+ obj->type = PA_JSON_TYPE_STRING;
+ obj->string_value = pa_strbuf_to_string_free(buf);
+
+ return str;
+
+error:
+ pa_strbuf_free(buf);
+ return NULL;
+}
+
+static const char* parse_number(const char *str, pa_json_object *obj) {
+ bool negative = false, has_fraction = false, has_exponent = false, valid = false;
+ unsigned int integer = 0;
+ unsigned int fraction = 0;
+ unsigned int fraction_digits = 0;
+ int exponent = 0;
+
+ if (*str == '-') {
+ negative = true;
+ str++;
+ }
+
+ if (*str == '0') {
+ valid = true;
+ str++;
+ goto fraction;
+ }
+
+ while (is_digit(*str)) {
+ valid = true;
+
+ if (integer > ((negative ? INT_MAX : UINT_MAX) / 10)) {
+ pa_log("Integer overflow while parsing number");
+ goto error;
+ }
+
+ integer = (integer * 10) + (*str - '0');
+ str++;
+ }
+
+fraction:
+
+ if (!valid) {
+ pa_log("Missing digits while parsing number");
+ goto error;
+ }
+
+ if (*str == '.') {
+ has_fraction = true;
+ str++;
+ valid = false;
+
+ while (is_digit(*str)) {
+ valid = true;
+
+ if (fraction > (UINT_MAX / 10)) {
+ pa_log("Integer overflow while parsing fractional part of number");
+ goto error;
+ }
+
+ fraction = (fraction * 10) + (*str - '0');
+ fraction_digits++;
+ str++;
+ }
+
+ if (!valid) {
+ pa_log("No digit after '.' while parsing fraction");
+ goto error;
+ }
+ }
+
+ if (*str == 'e' || *str == 'E') {
+ bool exponent_negative = false;
+
+ has_exponent = true;
+ str++;
+ valid = false;
+
+ if (*str == '-') {
+ exponent_negative = true;
+ str++;
+ } else if (*str == '+')
+ str++;
+
+ while (is_digit(*str)) {
+ valid = true;
+
+ if (exponent > (INT_MAX / 10)) {
+ pa_log("Integer overflow while parsing exponent part of number");
+ goto error;
+ }
+
+ exponent = (exponent * 10) + (*str - '0');
+ str++;
+ }
+
+ if (!valid) {
+ pa_log("No digit in exponent while parsing fraction");
+ goto error;
+ }
+
+ if (exponent_negative)
+ exponent *= -1;
+ }
+
+ if (has_fraction || has_exponent) {
+ obj->type = PA_JSON_TYPE_DOUBLE;
+ obj->double_value =
+ (negative ? -1.0 : 1.0) * (integer + (double) fraction / pow(10, fraction_digits)) * pow(10, exponent);
+ } else {
+ obj->type = PA_JSON_TYPE_INT;
+ obj->int_value = (negative ? -1 : 1) * integer;
+ }
+
+ return str;
+
+error:
+ return NULL;
+}
+
+static const char *parse_object(const char *str, pa_json_object *obj, unsigned int depth) {
+ pa_json_object *name = NULL, *value = NULL;
+
+ obj->object_values = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func,
+ pa_xfree, (pa_free_cb_t) pa_json_object_free);
+
+ while (*str != '}') {
+ str++; /* Consume leading '{' or ',' */
+
+ str = parse_value(str, ":", &name, depth + 1);
+ if (!str || pa_json_object_get_type(name) != PA_JSON_TYPE_STRING) {
+ pa_log("Could not parse key for object");
+ goto error;
+ }
+
+ /* Consume the ':' */
+ str++;
+
+ str = parse_value(str, ",}", &value, depth + 1);
+ if (!str) {
+ pa_log("Could not parse value for object");
+ goto error;
+ }
+
+ pa_hashmap_put(obj->object_values, pa_xstrdup(pa_json_object_get_string(name)), value);
+ pa_json_object_free(name);
+
+ name = NULL;
+ value = NULL;
+ }
+
+ /* Drop trailing '}' */
+ str++;
+
+ /* We now know the value was correctly parsed */
+ obj->type = PA_JSON_TYPE_OBJECT;
+
+ return str;
+
+error:
+ pa_hashmap_free(obj->object_values);
+ obj->object_values = NULL;
+
+ if (name)
+ pa_json_object_free(name);
+ if (value)
+ pa_json_object_free(value);
+
+ return NULL;
+}
+
+static const char *parse_array(const char *str, pa_json_object *obj, unsigned int depth) {
+ pa_json_object *value;
+
+ obj->array_values = pa_idxset_new(NULL, NULL);
+
+ while (*str != ']') {
+ str++; /* Consume leading '[' or ',' */
+
+ /* Need to chew up whitespaces as a special case to deal with the
+ * possibility of an empty array */
+ while (is_whitespace(*str))
+ str++;
+
+ if (*str == ']')
+ break;
+
+ str = parse_value(str, ",]", &value, depth + 1);
+ if (!str) {
+ pa_log("Could not parse value for array");
+ goto error;
+ }
+
+ pa_idxset_put(obj->array_values, value, NULL);
+ }
+
+ /* Drop trailing ']' */
+ str++;
+
+ /* We now know the value was correctly parsed */
+ obj->type = PA_JSON_TYPE_ARRAY;
+
+ return str;
+
+error:
+ pa_idxset_free(obj->array_values, (pa_free_cb_t) pa_json_object_free);
+ obj->array_values = NULL;
+ return NULL;
+}
+
+typedef enum {
+ JSON_PARSER_STATE_INIT,
+ JSON_PARSER_STATE_FINISH,
+} json_parser_state;
+
+static const char* parse_value(const char *str, const char *end, pa_json_object **obj, unsigned int depth) {
+ json_parser_state state = JSON_PARSER_STATE_INIT;
+ pa_json_object *o;
+
+ pa_assert(str != NULL);
+
+ o = json_object_new();
+
+ if (depth > MAX_NESTING_DEPTH) {
+ pa_log("Exceeded maximum permitted nesting depth of objects (%u)", MAX_NESTING_DEPTH);
+ goto error;
+ }
+
+ while (!is_end(*str, end)) {
+ switch (state) {
+ case JSON_PARSER_STATE_INIT:
+ if (is_whitespace(*str)) {
+ str++;
+ } else if (*str == 'n') {
+ str = parse_null(str, o);
+ state = JSON_PARSER_STATE_FINISH;
+ } else if (*str == 't' || *str == 'f') {
+ str = parse_boolean(str, o);
+ state = JSON_PARSER_STATE_FINISH;
+ } else if (*str == '"') {
+ str = parse_string(str, o);
+ state = JSON_PARSER_STATE_FINISH;
+ } else if (is_digit(*str) || *str == '-') {
+ str = parse_number(str, o);
+ state = JSON_PARSER_STATE_FINISH;
+ } else if (*str == '{') {
+ str = parse_object(str, o, depth);
+ state = JSON_PARSER_STATE_FINISH;
+ } else if (*str == '[') {
+ str = parse_array(str, o, depth);
+ state = JSON_PARSER_STATE_FINISH;
+ } else {
+ pa_log("Invalid JSON string: %s", str);
+ goto error;
+ }
+
+ if (!str)
+ goto error;
+
+ break;
+
+ case JSON_PARSER_STATE_FINISH:
+ /* Consume trailing whitespaces */
+ if (is_whitespace(*str)) {
+ str++;
+ } else {
+ goto error;
+ }
+ }
+ }
+
+ if (pa_json_object_get_type(o) == PA_JSON_TYPE_INIT) {
+ /* We didn't actually get any data */
+ pa_log("No data while parsing json string: '%s' till '%s'", str, pa_strnull(end));
+ goto error;
+ }
+
+ *obj = o;
+
+ return str;
+
+error:
+ pa_json_object_free(o);
+ return NULL;
+}
+
+
+pa_json_object* pa_json_parse(const char *str) {
+ pa_json_object *obj;
+
+ str = parse_value(str, NULL, &obj, 0);
+
+ if (!str) {
+ pa_log("JSON parsing failed");
+ return NULL;
+ }
+
+ if (*str != '\0') {
+ pa_log("Unable to parse complete JSON string, remainder is: %s", str);
+ pa_json_object_free(obj);
+ return NULL;
+ }
+
+ return obj;
+}
+
+pa_json_type pa_json_object_get_type(const pa_json_object *obj) {
+ return obj->type;
+}
+
+void pa_json_object_free(pa_json_object *obj) {
+
+ switch (pa_json_object_get_type(obj)) {
+ case PA_JSON_TYPE_INIT:
+ case PA_JSON_TYPE_INT:
+ case PA_JSON_TYPE_DOUBLE:
+ case PA_JSON_TYPE_BOOL:
+ case PA_JSON_TYPE_NULL:
+ break;
+
+ case PA_JSON_TYPE_STRING:
+ pa_xfree(obj->string_value);
+ break;
+
+ case PA_JSON_TYPE_OBJECT:
+ pa_hashmap_free(obj->object_values);
+ break;
+
+ case PA_JSON_TYPE_ARRAY:
+ pa_idxset_free(obj->array_values, (pa_free_cb_t) pa_json_object_free);
+ break;
+
+ default:
+ pa_assert_not_reached();
+ }
+
+ pa_xfree(obj);
+}
+
+int pa_json_object_get_int(const pa_json_object *o) {
+ pa_assert(pa_json_object_get_type(o) == PA_JSON_TYPE_INT);
+ return o->int_value;
+}
+
+double pa_json_object_get_double(const pa_json_object *o) {
+ pa_assert(pa_json_object_get_type(o) == PA_JSON_TYPE_DOUBLE);
+ return o->double_value;
+}
+
+bool pa_json_object_get_bool(const pa_json_object *o) {
+ pa_assert(pa_json_object_get_type(o) == PA_JSON_TYPE_BOOL);
+ return o->bool_value;
+}
+
+const char* pa_json_object_get_string(const pa_json_object *o) {
+ pa_assert(pa_json_object_get_type(o) == PA_JSON_TYPE_STRING);
+ return o->string_value;
+}
+
+const pa_json_object* pa_json_object_get_object_member(const pa_json_object *o, const char *name) {
+ pa_assert(pa_json_object_get_type(o) == PA_JSON_TYPE_OBJECT);
+ return pa_hashmap_get(o->object_values, name);
+}
+
+int pa_json_object_get_array_length(const pa_json_object *o) {
+ pa_assert(pa_json_object_get_type(o) == PA_JSON_TYPE_ARRAY);
+ return pa_idxset_size(o->array_values);
+}
+
+const pa_json_object* pa_json_object_get_array_member(const pa_json_object *o, int index) {
+ pa_assert(pa_json_object_get_type(o) == PA_JSON_TYPE_ARRAY);
+ return pa_idxset_get_by_index(o->array_values, index);
+}
+
+bool pa_json_object_equal(const pa_json_object *o1, const pa_json_object *o2) {
+ int i;
+
+ if (pa_json_object_get_type(o1) != pa_json_object_get_type(o2))
+ return false;
+
+ switch (pa_json_object_get_type(o1)) {
+ case PA_JSON_TYPE_NULL:
+ return true;
+
+ case PA_JSON_TYPE_BOOL:
+ return o1->bool_value == o2->bool_value;
+
+ case PA_JSON_TYPE_INT:
+ return o1->int_value == o2->int_value;
+
+ case PA_JSON_TYPE_DOUBLE:
+ return PA_DOUBLE_IS_EQUAL(o1->double_value, o2->double_value);
+
+ case PA_JSON_TYPE_STRING:
+ return pa_streq(o1->string_value, o2->string_value);
+
+ case PA_JSON_TYPE_ARRAY:
+ if (pa_json_object_get_array_length(o1) != pa_json_object_get_array_length(o2))
+ return false;
+
+ for (i = 0; i < pa_json_object_get_array_length(o1); i++) {
+ if (!pa_json_object_equal(pa_json_object_get_array_member(o1, i),
+ pa_json_object_get_array_member(o2, i)))
+ return false;
+ }
+
+ return true;
+
+ case PA_JSON_TYPE_OBJECT: {
+ void *state;
+ const char *key;
+ const pa_json_object *v1, *v2;
+
+ if (pa_hashmap_size(o1->object_values) != pa_hashmap_size(o2->object_values))
+ return false;
+
+ PA_HASHMAP_FOREACH_KV(key, v1, o1->object_values, state) {
+ v2 = pa_json_object_get_object_member(o2, key);
+ if (!v2 || !pa_json_object_equal(v1, v2))
+ return false;
+ }
+
+ return true;
+ }
+
+ default:
+ pa_assert_not_reached();
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-26 07:46:35 +0000