10:33 p.m.
---
shared/jsmn.h | 468 ++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 468 insertions(+)
create mode 100644 shared/jsmn.h
diff --git a/shared/jsmn.h b/shared/jsmn.h
new file mode 100644
index 00000000..b95368a2
--- /dev/null
+++ b/shared/jsmn.h
@@ -0,0 +1,468 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2010 Serge Zaitsev
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef JSMN_H
+#define JSMN_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef JSMN_STATIC
+#define JSMN_API static
+#else
+#define JSMN_API extern
+#endif
+
+/**
+ * JSON type identifier. Basic types are:
+ * o Object
+ * o Array
+ * o String
+ * o Other primitive: number, boolean (true/false) or null
+ */
+typedef enum {
+ JSMN_UNDEFINED = 0,
+ JSMN_OBJECT = 1,
+ JSMN_ARRAY = 2,
+ JSMN_STRING = 3,
+ JSMN_PRIMITIVE = 4
+} jsmntype_t;
+
+enum jsmnerr {
+ /* Not enough tokens were provided */
+ JSMN_ERROR_NOMEM = -1,
+ /* Invalid character inside JSON string */
+ JSMN_ERROR_INVAL = -2,
+ /* The string is not a full JSON packet, more bytes expected */
+ JSMN_ERROR_PART = -3
+};
+
+/**
+ * JSON token description.
+ * type type (object, array, string etc.)
+ * start start position in JSON data string
+ * end end position in JSON data string
+ */
+typedef struct {
+ jsmntype_t type;
+ int start;
+ int end;
+ int size;
+#ifdef JSMN_PARENT_LINKS
+ int parent;
+#endif
+} jsmntok_t;
+
+/**
+ * JSON parser. Contains an array of token blocks available. Also stores
+ * the string being parsed now and current position in that string.
+ */
+typedef struct {
+ unsigned int pos; /* offset in the JSON string */
+ unsigned int toknext; /* next token to allocate */
+ int toksuper; /* superior token node, e.g. parent object or array */
+} jsmn_parser;
+
+/**
+ * Create JSON parser over an array of tokens
+ */
+JSMN_API void jsmn_init(jsmn_parser *parser);
+
+/**
+ * Run JSON parser. It parses a JSON data string into and array of tokens, each
+ * describing
+ * a single JSON object.
+ */
+JSMN_API int jsmn_parse(jsmn_parser *parser, const char *js, const size_t len,
+ jsmntok_t *tokens, const unsigned int num_tokens);
+
+#ifndef JSMN_HEADER
+/**
+ * Allocates a fresh unused token from the token pool.
+ */
+static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser, jsmntok_t *tokens,
+ const size_t num_tokens) {
+ jsmntok_t *tok;
+ if (parser->toknext >= num_tokens) {
+ return NULL;
+ }
+ tok = &tokens[parser->toknext++];
+ tok->start = tok->end = -1;
+ tok->size = 0;
+#ifdef JSMN_PARENT_LINKS
+ tok->parent = -1;
+#endif
+ return tok;
+}
+
+/**
+ * Fills token type and boundaries.
+ */
+static void jsmn_fill_token(jsmntok_t *token, const jsmntype_t type,
+ const int start, const int end) {
+ token->type = type;
+ token->start = start;
+ token->end = end;
+ token->size = 0;
+}
+
+/**
+ * Fills next available token with JSON primitive.
+ */
+static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
+ const size_t len, jsmntok_t *tokens,
+ const size_t num_tokens) {
+ jsmntok_t *token;
+ int start;
+
+ start = parser->pos;
+
+ for (; parser->pos < len && js[parser->pos] != '\0';
parser->pos++) {
+ switch (js[parser->pos]) {
+#ifndef JSMN_STRICT
+ /* In strict mode primitive must be followed by "," or "}" or
"]" */
+ case ':':
+#endif
+ case '\t':
+ case '\r':
+ case '\n':
+ case ' ':
+ case ',':
+ case ']':
+ case '}':
+ goto found;
+ }
+ if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
+ parser->pos = start;
+ return JSMN_ERROR_INVAL;
+ }
+ }
+#ifdef JSMN_STRICT
+ /* In strict mode primitive must be followed by a comma/object/array */
+ parser->pos = start;
+ return JSMN_ERROR_PART;
+#endif
+
+found:
+ if (tokens == NULL) {
+ parser->pos--;
+ return 0;
+ }
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
+ if (token == NULL) {
+ parser->pos = start;
+ return JSMN_ERROR_NOMEM;
+ }
+ jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
+#ifdef JSMN_PARENT_LINKS
+ token->parent = parser->toksuper;
+#endif
+ parser->pos--;
+ return 0;
+}
+
+/**
+ * Fills next token with JSON string.
+ */
+static int jsmn_parse_string(jsmn_parser *parser, const char *js,
+ const size_t len, jsmntok_t *tokens,
+ const size_t num_tokens) {
+ jsmntok_t *token;
+
+ int start = parser->pos;
+
+ parser->pos++;
+
+ /* Skip starting quote */
+ for (; parser->pos < len && js[parser->pos] != '\0';
parser->pos++) {
+ char c = js[parser->pos];
+
+ /* Quote: end of string */
+ if (c == '\"') {
+ if (tokens == NULL) {
+ return 0;
+ }
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
+ if (token == NULL) {
+ parser->pos = start;
+ return JSMN_ERROR_NOMEM;
+ }
+ jsmn_fill_token(token, JSMN_STRING, start + 1, parser->pos);
+#ifdef JSMN_PARENT_LINKS
+ token->parent = parser->toksuper;
+#endif
+ return 0;
+ }
+
+ /* Backslash: Quoted symbol expected */
+ if (c == '\\' && parser->pos + 1 < len) {
+ int i;
+ parser->pos++;
+ switch (js[parser->pos]) {
+ /* Allowed escaped symbols */
+ case '\"':
+ case '/':
+ case '\\':
+ case 'b':
+ case 'f':
+ case 'r':
+ case 'n':
+ case 't':
+ break;
+ /* Allows escaped symbol \uXXXX */
+ case 'u':
+ parser->pos++;
+ for (i = 0; i < 4 && parser->pos < len &&
js[parser->pos] != '\0';
+ i++) {
+ /* If it isn't a hex character we have an error */
+ if (!((js[parser->pos] >= 48 && js[parser->pos] <= 57) ||
/* 0-9 */
+ (js[parser->pos] >= 65 && js[parser->pos] <= 70) ||
/* A-F */
+ (js[parser->pos] >= 97 && js[parser->pos] <= 102))) {
/* a-f */
+ parser->pos = start;
+ return JSMN_ERROR_INVAL;
+ }
+ parser->pos++;
+ }
+ parser->pos--;
+ break;
+ /* Unexpected symbol */
+ default:
+ parser->pos = start;
+ return JSMN_ERROR_INVAL;
+ }
+ }
+ }
+ parser->pos = start;
+ return JSMN_ERROR_PART;
+}
+
+/**
+ * Parse JSON string and fill tokens.
+ */
+JSMN_API int jsmn_parse(jsmn_parser *parser, const char *js, const size_t len,
+ jsmntok_t *tokens, const unsigned int num_tokens) {
+ int r;
+ int i;
+ jsmntok_t *token;
+ int count = parser->toknext;
+
+ for (; parser->pos < len && js[parser->pos] != '\0';
parser->pos++) {
+ char c;
+ jsmntype_t type;
+
+ c = js[parser->pos];
+ switch (c) {
+ case '{':
+ case '[':
+ count++;
+ if (tokens == NULL) {
+ break;
+ }
+ token = jsmn_alloc_token(parser, tokens, num_tokens);
+ if (token == NULL) {
+ return JSMN_ERROR_NOMEM;
+ }
+ if (parser->toksuper != -1) {
+ jsmntok_t *t = &tokens[parser->toksuper];
+#ifdef JSMN_STRICT
+ /* In strict mode an object or array can't become a key */
+ if (t->type == JSMN_OBJECT) {
+ return JSMN_ERROR_INVAL;
+ }
+#endif
+ t->size++;
+#ifdef JSMN_PARENT_LINKS
+ token->parent = parser->toksuper;
+#endif
+ }
+ token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
+ token->start = parser->pos;
+ parser->toksuper = parser->toknext - 1;
+ break;
+ case '}':
+ case ']':
+ if (tokens == NULL) {
+ break;
+ }
+ type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
+#ifdef JSMN_PARENT_LINKS
+ if (parser->toknext < 1) {
+ return JSMN_ERROR_INVAL;
+ }
+ token = &tokens[parser->toknext - 1];
+ for (;;) {
+ if (token->start != -1 && token->end == -1) {
+ if (token->type != type) {
+ return JSMN_ERROR_INVAL;
+ }
+ token->end = parser->pos + 1;
+ parser->toksuper = token->parent;
+ break;
+ }
+ if (token->parent == -1) {
+ if (token->type != type || parser->toksuper == -1) {
+ return JSMN_ERROR_INVAL;
+ }
+ break;
+ }
+ token = &tokens[token->parent];
+ }
+#else
+ for (i = parser->toknext - 1; i >= 0; i--) {
+ token = &tokens[i];
+ if (token->start != -1 && token->end == -1) {
+ if (token->type != type) {
+ return JSMN_ERROR_INVAL;
+ }
+ parser->toksuper = -1;
+ token->end = parser->pos + 1;
+ break;
+ }
+ }
+ /* Error if unmatched closing bracket */
+ if (i == -1) {
+ return JSMN_ERROR_INVAL;
+ }
+ for (; i >= 0; i--) {
+ token = &tokens[i];
+ if (token->start != -1 && token->end == -1) {
+ parser->toksuper = i;
+ break;
+ }
+ }
+#endif
+ break;
+ case '\"':
+ r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
+ if (r < 0) {
+ return r;
+ }
+ count++;
+ if (parser->toksuper != -1 && tokens != NULL) {
+ tokens[parser->toksuper].size++;
+ }
+ break;
+ case '\t':
+ case '\r':
+ case '\n':
+ case ' ':
+ break;
+ case ':':
+ parser->toksuper = parser->toknext - 1;
+ break;
+ case ',':
+ if (tokens != NULL && parser->toksuper != -1 &&
+ tokens[parser->toksuper].type != JSMN_ARRAY &&
+ tokens[parser->toksuper].type != JSMN_OBJECT) {
+#ifdef JSMN_PARENT_LINKS
+ parser->toksuper = tokens[parser->toksuper].parent;
+#else
+ for (i = parser->toknext - 1; i >= 0; i--) {
+ if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
+ if (tokens[i].start != -1 && tokens[i].end == -1) {
+ parser->toksuper = i;
+ break;
+ }
+ }
+ }
+#endif
+ }
+ break;
+#ifdef JSMN_STRICT
+ /* In strict mode primitives are: numbers and booleans */
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 't':
+ case 'f':
+ case 'n':
+ /* And they must not be keys of the object */
+ if (tokens != NULL && parser->toksuper != -1) {
+ const jsmntok_t *t = &tokens[parser->toksuper];
+ if (t->type == JSMN_OBJECT ||
+ (t->type == JSMN_STRING && t->size != 0)) {
+ return JSMN_ERROR_INVAL;
+ }
+ }
+#else
+ /* In non-strict mode every unquoted value is a primitive */
+ default:
+#endif
+ r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
+ if (r < 0) {
+ return r;
+ }
+ count++;
+ if (parser->toksuper != -1 && tokens != NULL) {
+ tokens[parser->toksuper].size++;
+ }
+ break;
+
+#ifdef JSMN_STRICT
+ /* Unexpected char in strict mode */
+ default:
+ return JSMN_ERROR_INVAL;
+#endif
+ }
+ }
+
+ if (tokens != NULL) {
+ for (i = parser->toknext - 1; i >= 0; i--) {
+ /* Unmatched opened object or array */
+ if (tokens[i].start != -1 && tokens[i].end == -1) {
+ return JSMN_ERROR_PART;
+ }
+ }
+ }
+
+ return count;
+}
+
+/**
+ * Creates a new parser based over a given buffer with an array of tokens
+ * available.
+ */
+JSMN_API void jsmn_init(jsmn_parser *parser) {
+ parser->pos = 0;
+ parser->toknext = 0;
+ parser->toksuper = -1;
+}
+
+#endif /* JSMN_HEADER */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JSMN_H */
--
2.31.1
10:33 p.m.
New subject: [PATCH v4 2/3] json: introduce JSON module
This is a minimal wrapper around jsmn.h to make things a bit easier
for iterating through a JSON object.
To use, first parse the JSON and create a contents object using
json_contents_new(). This object can then be used to initialize a
json_iter object using json_iter_init().
The json_iter object can then be parsed with json_iter_parse by
passing in JSON_MANDATORY/JSON_OPTIONAL arguments. Currently only
JSON_STRING and JSON_OBJECT types are supported. Any JSON_MANDATORY
values that are not found will result in an error.
If a JSON_OPTIONAL string is not found, the pointer will be NULL.
If a JSON_OPTIONAL object is not found, this iterator will be
initialized but 'start' will be -1. This can be checked with a
convenience macro json_object_not_found();
---
Makefile.am | 4 +-
src/json.c | 270 ++++++++++++++++++++++++++++++++++++++++++++++++++++
src/json.h | 83 ++++++++++++++++
3 files changed, 356 insertions(+), 1 deletion(-)
create mode 100644 src/json.c
create mode 100644 src/json.h
v4:
* Fixed bug where mandatory value checks could be missed
* Renamed json_object_not_found to json_iter_is_valid
* Moved type check to not waste time if the type is unsupported.
diff --git a/Makefile.am b/Makefile.am
index 7fe4b5c3..fef2c2c4 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -249,6 +249,7 @@ src_iwd_SOURCES = src/main.c linux/nl80211.h src/iwd.h src/missing.h
\
src/sysfs.h src/sysfs.c \
src/offchannel.h src/offchannel.c \
src/dpp-util.h src/dpp-util.c \
+ src/json.h src/json.c \
$(eap_sources) \
$(builtin_sources)
@@ -566,7 +567,8 @@ EXTRA_DIST = src/genbuiltin src/iwd.service.in
src/net.connman.iwd.service \
AM_CFLAGS = $(ell_cflags) -fvisibility=hidden \
-DUNITDIR=\""$(top_srcdir)/unit/"\" \
- -DCERTDIR=\""$(top_builddir)/unit/"\"
+ -DCERTDIR=\""$(top_builddir)/unit/"\" \
+ -DJSMN_PARENT_LINKS -DJSMN_STRICT
if MAINTAINER_MODE
AM_CFLAGS += -DHAVE_PKCS8_SUPPORT
diff --git a/src/json.c b/src/json.c
new file mode 100644
index 00000000..20adcec7
--- /dev/null
+++ b/src/json.c
@@ -0,0 +1,270 @@
+/*
+ *
+ * Wireless daemon for Linux
+ *
+ * Copyright (C) 2021 Intel Corporation. All rights reserved.
+ *
+ * This library 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.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <ell/ell.h>
+
+#include "src/json.h"
+
+#include "shared/jsmn.h"
+
+/* Max number of tokens supported. Increase if larger objects are expected */
+#define JSON_DEFAULT_TOKENS 30
+
+#define TOK_LEN(token) (token)->end - (token)->start
+#define TOK_PTR(json, token) (void *)((json) + (token)->start)
+#define TOK_TO_STR(json, token) \
+({ \
+ char *_tmp = l_malloc(TOK_LEN((token)) + 1); \
+ memcpy(_tmp, TOK_PTR((json), (token)), TOK_LEN((token))); \
+ _tmp[TOK_LEN((token))] = '\0'; \
+ _tmp; \
+})
+
+#define ITER_END(iter) \
+ (((iter)->contents->tokens + (iter)->start) + (iter)->count)
+
+struct json_contents {
+ const char *json;
+ size_t json_len;
+ jsmntok_t *tokens;
+ int tokens_len;
+ jsmn_parser *p;
+};
+
+static jsmntok_t *next_key_in_parent(struct json_iter *iter, jsmntok_t *current)
+{
+ int parent = current->parent;
+
+ /* iterate the list and stop on the first token with the same parent */
+ while (++current < ITER_END(iter)) {
+ if (current->parent == parent)
+ return current;
+ }
+
+ return NULL;
+}
+
+/*
+ * 'object' is expected to be a value, so object - 1 is its key. Find
+ * the next key who's parent matches the parent of object - 1. The
+ * token preceeding this next key will mark the end of 'object'.
+ */
+static int find_object_tokens(struct json_iter *iter, jsmntok_t *object)
+{
+ jsmntok_t *next = next_key_in_parent(iter, object - 1);
+
+ /* End of token list */
+ if (!next)
+ next = ITER_END(iter);
+
+ return ((next - object) % sizeof(jsmntok_t)) - 1;
+}
+
+static void iter_recurse(struct json_iter *iter, jsmntok_t *object,
+ struct json_iter *child)
+{
+ struct json_contents *c = iter->contents;
+
+ child->contents = c;
+ child->start = (object - c->tokens) % sizeof(jsmntok_t);
+ child->count = find_object_tokens(iter, object);
+}
+
+struct json_contents *json_contents_new(const char *json, size_t json_len)
+{
+ struct json_contents *c = l_new(struct json_contents, 1);
+
+ c->json = json;
+ c->json_len = json_len;
+ c->p = l_new(jsmn_parser, 1);
+ c->tokens = l_new(jsmntok_t, JSON_DEFAULT_TOKENS);
+
+ jsmn_init(c->p);
+ c->tokens_len = jsmn_parse(c->p, c->json, c->json_len,
+ c->tokens, JSON_DEFAULT_TOKENS);
+ if (c->tokens_len < 0) {
+ json_contents_free(c);
+ return NULL;
+ }
+
+ return c;
+}
+
+void json_iter_init(struct json_iter *iter, struct json_contents *c)
+{
+ iter->contents = c;
+ iter->start = 0;
+ iter->count = c->tokens_len;
+}
+
+void json_contents_free(struct json_contents *c)
+{
+ l_free(c->p);
+ l_free(c->tokens);
+ l_free(c);
+}
+
+struct json_arg {
+ enum json_type type;
+ void *value;
+ jsmntok_t *v;
+};
+
+static void push_arg(struct l_queue *q, enum json_type type,
+ void *value, jsmntok_t *v)
+{
+ struct json_arg *arg = l_new(struct json_arg, 1);
+
+ arg->type = type;
+ arg->value = value;
+ arg->v = v;
+
+ l_queue_push_head(q, arg);
+}
+
+static void assign_arg(void *data, void *user_data)
+{
+ struct json_iter *iter = user_data;
+ struct json_arg *arg = data;
+ struct json_contents *c = iter->contents;
+ char **sval;
+ struct json_iter *oval;
+
+ switch (arg->type) {
+ case JSON_STRING:
+ sval = arg->value;
+
+ *sval = arg->v ? TOK_TO_STR(c->json, arg->v) : NULL;
+
+ break;
+ case JSON_OBJECT:
+ oval = arg->value;
+
+ if (!arg->v)
+ oval->start = -1;
+ else
+ iter_recurse(iter, arg->v, oval);
+
+ break;
+ default:
+ /* Types are verified earlier, this should never happen */
+ return;
+ }
+
+ l_free(arg);
+}
+
+bool json_iter_parse(struct json_iter *iter, enum json_type type, ...)
+{
+ struct json_contents *c = iter->contents;
+ va_list va;
+ int i;
+ int num = c->tokens->size;
+ jsmntok_t *next;
+ struct l_queue *args;
+
+ if (iter->start == -1)
+ return false;
+
+ args = l_queue_new();
+
+ va_start(va, type);
+
+ while (true) {
+ enum json_flag flag;
+ char *key;
+ void *value;
+ jsmntok_t *v = NULL;
+ void *ptr;
+ size_t len;
+
+ /* Check the type is supported before wasting any cycles */
+ switch (type) {
+ case JSON_UNDEFINED:
+ goto done;
+ case JSON_STRING:
+ case JSON_OBJECT:
+ break;
+ default:
+ goto error;
+ }
+
+ key = va_arg(va, char *);
+ value = va_arg(va, void *);
+ flag = va_arg(va, enum json_flag);
+
+ /* First key */
+ next = c->tokens + iter->start + 1;
+
+ /* Iterate over this objects keys */
+ for (i = 0; i < num; i++) {
+ ptr = TOK_PTR(c->json, next);
+ len = TOK_LEN(next);
+
+ if (next + 1 > ITER_END(iter))
+ goto error;
+
+ if (strlen(key) == len && !memcmp(ptr, key, len)) {
+ /* Key found but the wrong value type */
+ if ((next + 1)->type != (jsmntype_t)type)
+ goto error;
+
+ v = next + 1;
+ break;
+ }
+
+ next = next_key_in_parent(iter, next);
+ if (!next)
+ break;
+ }
+
+ if (flag == JSON_FLAG_MANDATORY && !v)
+ goto error;
+
+ /*
+ * Still push even if an optional value doesn't exist (!v) so
+ * the caller can check if it was found or not.
+ */
+ if (value)
+ push_arg(args, type, value, v);
+
+ type = va_arg(va, enum json_type);
+ }
+
+done:
+ va_end(va);
+
+ l_queue_foreach(args, assign_arg, iter);
+ l_queue_destroy(args, NULL);
+
+ return true;
+
+error:
+ l_queue_destroy(args, l_free);
+ return false;
+}
diff --git a/src/json.h b/src/json.h
new file mode 100644
index 00000000..915b675b
--- /dev/null
+++ b/src/json.h
@@ -0,0 +1,83 @@
+/*
+ *
+ * Wireless daemon for Linux
+ *
+ * Copyright (C) 2021 Intel Corporation. All rights reserved.
+ *
+ * This library 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.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+struct json_iter;
+
+/*
+ * Identical to JSMN types
+ */
+enum json_type {
+ JSON_UNDEFINED = 0,
+ JSON_OBJECT = 1,
+ JSON_ARRAY = 2,
+ JSON_STRING = 3,
+ JSON_PRIMITIVE = 4
+};
+
+enum json_flag {
+ JSON_FLAG_MANDATORY = 1,
+ JSON_FLAG_OPTIONAL = 2,
+};
+
+struct json_iter {
+ struct json_contents *contents;
+ int start;
+ int count;
+};
+
+#define JSON_MANDATORY(key, type, out) \
+ (type), (key), (out), JSON_FLAG_MANDATORY
+
+#define JSON_OPTIONAL(key, type, out) \
+ (type), (key), (out), JSON_FLAG_OPTIONAL
+
+#define json_iter_is_valid(iter) ((iter)->start != -1)
+
+struct json_contents *json_contents_new(const char *json, size_t json_len);
+void json_contents_free(struct json_contents *c);
+
+void json_iter_init(struct json_iter *iter, struct json_contents *c);
+
+/*
+ * Parse an arbitrary number of key/value pairs from a JSON iterator. Initially
+ * a new JSON contents object should be created with json_contents_new() and,
+ * when done, freed with json_contents_free.
+ *
+ * Iterators can be initialized with the json_contents object. Nested object
+ * iterators are also parsed with this function.
+ *
+ * Arguments should be specified using JSON_MANDATORY or JSON_OPTIONAL:
+ *
+ * r = json_iter_parse(iter, JSON_MANDATORY("mykey", JSON_STRING,
&strvalue),
+ * JSON_OPTIONAL("optkey", JSON_STRING, &optvalue),
+ * JSON_UNDEFINED);
+ *
+ * String values should be of type char ** and must be freed
+ * Object values should be of type struct json_iter *
+ *
+ * No other types are supported at this time, and json_iter_parse will fail if
+ * other types are encountered.
+ *
+ * JSON_OPTIONAL string values will point to NULL if not found
+ * JSON_OPTIONAL objects can be checked with json_object_not_found.
+ */
+bool json_iter_parse(struct json_iter *iter, enum json_type type, ...);
--
2.31.1
10:33 p.m.
New subject: [PATCH v4 3/3] unit: add JSON unit test
---
Makefile.am | 5 +-
unit/test-json.c | 234 +++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 238 insertions(+), 1 deletion(-)
create mode 100644 unit/test-json.c
diff --git a/Makefile.am b/Makefile.am
index fef2c2c4..312081a0 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -396,7 +396,7 @@ unit_tests = unit/test-cmac-aes \
unit/test-ie unit/test-util unit/test-ssid-security \
unit/test-arc4 unit/test-wsc unit/test-eap-mschapv2 \
unit/test-eap-sim unit/test-sae unit/test-p2p unit/test-band \
- unit/test-dpp
+ unit/test-dpp unit/test-json
if CLIENT
unit_tests += unit/test-client
@@ -556,6 +556,9 @@ unit_test_dpp_SOURCES = unit/test-dpp.c src/dpp-util.h src/dpp-util.c
\
unit_test_dpp_LDADD = $(ell_ldadd)
+unit_test_json_SOURCES = unit/test-json.c src/json.h src/json.c shared/jsmn.h
+unit_test_json_LDADD = $(ell_ldadd)
+
TESTS = $(unit_tests)
EXTRA_DIST = src/genbuiltin src/iwd.service.in src/net.connman.iwd.service \
diff --git a/unit/test-json.c b/unit/test-json.c
new file mode 100644
index 00000000..4c43a8cd
--- /dev/null
+++ b/unit/test-json.c
@@ -0,0 +1,234 @@
+/*
+ *
+ * Wireless daemon for Linux
+ *
+ * Copyright (C) 2021 Intel Corporation. All rights reserved.
+ *
+ * This library 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.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <assert.h>
+
+#include <ell/ell.h>
+
+#include "src/json.h"
+#include "ell/useful.h"
+
+struct json_contents;
+
+
+/*
+ * Object:
+ * { "test": "<smile emoji>" }
+ */
+static void test_json_unicode(const void *data)
+{
+ struct json_iter iter;
+ _auto_(l_free)char *v;
+ uint8_t expected[] = { 0xF0, 0x9F, 0x98, 0x80, 0 };
+
+ uint8_t s[] = { '{', '"', 't', 'e', 's',
't', '"', ':',
+ '"', 0xf0, 0x9f, 0x98, 0x80, '"', '}', 0 };
+ struct json_contents *c = json_contents_new((const char *)s, sizeof(s));
+
+ json_iter_init(&iter, c);
+ assert(json_iter_parse(&iter, JSON_MANDATORY("test", JSON_STRING,
&v),
+ JSON_UNDEFINED));
+
+ assert(!strcmp(v, (char *)expected));
+
+ json_contents_free(c);
+}
+
+static void test_json_escaped_unicode(const void *data)
+{
+ struct json_iter iter;
+ _auto_(l_free)char *v;
+ char *s = "{\"test\":\"\\uD8F0\"}";
+ char expected[] = "\\uD8F0";
+ struct json_contents *c = json_contents_new(s, strlen(s));
+
+ json_iter_init(&iter, c);
+ assert(json_iter_parse(&iter, JSON_MANDATORY("test", JSON_STRING,
&v),
+ JSON_UNDEFINED));
+
+ assert(!strcmp(v, expected));
+
+ json_contents_free(c);
+}
+
+/*
+ * Tests that unsupported types will not parse
+ */
+static void test_json_unsupported_types(const void *data)
+{
+ /*
+ * Valid JSON objects but currently unsupported types
+ */
+ char arrays[] = "{\"test\":[1, 2, 3, 4]}";
+ char integers[] = "{\"test\": 10 }";
+ char bools[] = "{\"test\": true}";
+
+ struct json_iter iter;
+ struct json_contents *c = json_contents_new(arrays, strlen(arrays));
+
+ json_iter_init(&iter, c);
+ assert(!json_iter_parse(&iter,
+ JSON_MANDATORY("test", JSON_ARRAY, NULL),
+ JSON_UNDEFINED));
+ json_contents_free(c);
+
+ c = json_contents_new(integers, strlen(integers));
+ json_iter_init(&iter, c);
+ assert(!json_iter_parse(&iter,
+ JSON_MANDATORY("test", JSON_PRIMITIVE, NULL),
+ JSON_UNDEFINED));
+ json_contents_free(c);
+
+ c = json_contents_new(bools, strlen(bools));
+ json_iter_init(&iter, c);
+ assert(!json_iter_parse(&iter,
+ JSON_MANDATORY("test", JSON_PRIMITIVE, NULL),
+ JSON_UNDEFINED));
+ json_contents_free(c);
+}
+
+/*
+ * Basic test string values and nested objects
+ */
+static void test_json(const void *data)
+{
+ char json[] = "{\"wi-fi_tech\":\"infra\","
+ "\"discovery\":"
+ "{\"ssid\":\"somessid\"},"
+ "\"cred\":"
+ "{\"akm\":\"psk\","
+ "\"pass\":\"somepassphrase\"}}";
+ _auto_(l_free)char *tech;
+ _auto_(l_free)char *ssid;
+ _auto_(l_free)char *akm;
+ _auto_(l_free)char *pass;
+ _auto_(l_free)char *opt_not_found;
+ struct json_iter objnotfound;
+ struct json_iter discovery;
+ struct json_iter cred;
+ struct json_iter iter;
+ struct json_contents *c = json_contents_new(json, strlen(json));
+
+ json_iter_init(&iter, c);
+ assert(json_iter_parse(&iter,
+ JSON_MANDATORY("wi-fi_tech", JSON_STRING, &tech),
+ JSON_MANDATORY("discovery", JSON_OBJECT, &discovery),
+ JSON_MANDATORY("cred", JSON_OBJECT, &cred),
+ JSON_OPTIONAL("notfound", JSON_STRING, &opt_not_found),
+ JSON_OPTIONAL("objnotfound", JSON_OBJECT, &objnotfound),
+ JSON_UNDEFINED));
+
+ assert(opt_not_found == NULL);
+ assert(!json_iter_is_valid(&objnotfound));
+
+ assert(!strcmp(tech, "infra"));
+
+ assert(json_iter_parse(&discovery,
+ JSON_MANDATORY("ssid", JSON_STRING, &ssid),
+ JSON_UNDEFINED));
+
+ assert(!strcmp(ssid, "somessid"));
+
+ assert(json_iter_parse(&cred,
+ JSON_MANDATORY("akm", JSON_STRING, &akm),
+ JSON_MANDATORY("pass", JSON_STRING, &pass),
+ JSON_UNDEFINED));
+ assert(!strcmp(akm, "psk"));
+ assert(!strcmp(pass, "somepassphrase"));
+
+ json_contents_free(c);
+}
+
+/*
+ * Tests empty objects parse successfully
+ */
+static void test_json_empty_objects(const void *data)
+{
+ char empty[] = "{}";
+ char nested_empty[] = "{\"empty\":{}}";
+ struct json_iter nested_iter;
+ struct json_iter iter;
+ struct json_contents *c = json_contents_new(empty, strlen(empty));
+
+ json_iter_init(&iter, c);
+ assert(json_iter_parse(&iter, JSON_UNDEFINED));
+
+ assert(json_iter_parse(&iter,
+ JSON_OPTIONAL("optional", JSON_OBJECT, NULL),
+ JSON_UNDEFINED));
+
+ assert(!json_iter_parse(&iter,
+ JSON_MANDATORY("optional", JSON_OBJECT, NULL),
+ JSON_UNDEFINED));
+ json_contents_free(c);
+
+ c = json_contents_new(nested_empty, strlen(nested_empty));
+ json_iter_init(&iter, c);
+ assert(json_iter_parse(&iter,
+ JSON_MANDATORY("empty", JSON_OBJECT, &nested_iter),
+ JSON_UNDEFINED));
+ assert(json_iter_parse(&nested_iter, JSON_UNDEFINED));
+ assert(!json_iter_parse(&nested_iter,
+ JSON_MANDATORY("mandatory", JSON_OBJECT, NULL),
+ JSON_UNDEFINED));
+ json_contents_free(c);
+}
+
+/*
+ * Tests that expected key/values can be provided in an order different than
+ * they appear in the JSON string.
+ */
+static void test_json_out_of_order(const void *data)
+{
+ char object[] =
"{\"key1\":{},\"key2\":\"val2\",\"key3\":\"val3\"}";
+ struct json_iter iter;
+ struct json_contents *c = json_contents_new(object, strlen(object));
+
+ json_iter_init(&iter, c);
+ assert(json_iter_parse(&iter,
+ JSON_OPTIONAL("nonexist1", JSON_STRING, NULL),
+ JSON_MANDATORY("key3", JSON_STRING, NULL),
+ JSON_MANDATORY("key2", JSON_STRING, NULL),
+ JSON_OPTIONAL("nonexist2", JSON_OBJECT, NULL),
+ JSON_MANDATORY("key1", JSON_OBJECT, NULL),
+ JSON_UNDEFINED));
+ json_contents_free(c);
+}
+
+int main(int argc, char *argv[])
+{
+ l_test_init(&argc, &argv);
+
+ l_test_add("json unicode", test_json_unicode, NULL);
+ l_test_add("json escaped unicode", test_json_escaped_unicode, NULL);
+ l_test_add("json nested objects", test_json, NULL);
+ l_test_add("json unsupported types", test_json_unsupported_types, NULL);
+ l_test_add("json empty objects", test_json_empty_objects, NULL);
+ l_test_add("json parse out of order", test_json_out_of_order, NULL);
+
+ return l_test_run();
+}
--
2.31.1
206
days inactive
206
days old
3 comments
2 participants
participants (2)
-
Denis Kenzior -
James Prestwood