json.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DATA_JSON_H_
#define ZEPHYR_INCLUDE_DATA_JSON_H_
 
#include <zephyr/sys/util.h>
#include <stddef.h>
#include <zephyr/toolchain.h>
#include <zephyr/types.h>
#include <sys/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
enum json_tokens {
        /* Before changing this enum, ensure that its maximum
         * value is still within 7 bits. See comment next to the
         * declaration of `type` in struct json_obj_descr.
         */
 
        JSON_TOK_NONE = '_',
        JSON_TOK_OBJECT_START = '{',
        JSON_TOK_OBJECT_END = '}',
        JSON_TOK_ARRAY_START = '[',
        JSON_TOK_ARRAY_END = ']',
        JSON_TOK_STRING = '"',
        JSON_TOK_STRING_BUF = 's',
        JSON_TOK_COLON = ':',
        JSON_TOK_COMMA = ',',
        JSON_TOK_NUMBER = '0',
        JSON_TOK_FLOAT = '1',
        JSON_TOK_OPAQUE = '2',
        JSON_TOK_OBJ_ARRAY = '3',
        JSON_TOK_ENCODED_OBJ = '4',
        JSON_TOK_INT64 = '5',
        JSON_TOK_UINT64 = '6',
        JSON_TOK_FLOAT_FP = '7',
        JSON_TOK_DOUBLE_FP = '8',
        JSON_TOK_INT = 'i',
        JSON_TOK_UINT = 'u',
        JSON_TOK_TRUE = 't',
        JSON_TOK_FALSE = 'f',
        JSON_TOK_MIXED_ARRAY = 'm',
        JSON_TOK_NULL = 'n',
        JSON_TOK_ERROR = '!',
        JSON_TOK_EOF = '\0',
};
 
struct json_token {
        enum json_tokens type;
        char *start;
        char *end;
};
 
struct json_lexer {
        void *(*state)(struct json_lexer *lex);
        char *start;
        char *pos;
        char *end;
        struct json_token tok;
};
 
struct json_obj {
        struct json_lexer lex;
};
 
struct json_obj_token {
        char *start;
        size_t length;
};
 
 
struct json_obj_descr {
        const char *field_name;
 
        /* Alignment can be 1, 2, 4, or 8.  The macros to create
         * a struct json_obj_descr will store the alignment's
         * power of 2 in order to keep this value in the 0-3 range
         * and thus use only 2 bits.
         */
        uint32_t align_shift : 2;
 
        /* 127 characters is more than enough for a field name. */
        uint32_t field_name_len : 7;
 
        /* Valid values here (enum json_tokens): JSON_TOK_STRING,
         * JSON_TOK_NUMBER, JSON_TOK_TRUE, JSON_TOK_FALSE,
         * JSON_TOK_OBJECT_START, JSON_TOK_ARRAY_START.  (All others
         * ignored.) Maximum value is '}' (125), so this has to be 7 bits
         * long.
         */
        uint32_t type : 7;
 
        /* 65535 bytes is more than enough for many JSON payloads. */
        uint32_t offset : 16;
 
        union {
                struct {
                        const struct json_obj_descr *sub_descr;
                        size_t sub_descr_len;
                } object;
                struct {
                        const struct json_obj_descr *element_descr;
                        size_t n_elements;
                } array;
                struct {
                        size_t size;
                } field;
        };
};

typedef int (*json_append_bytes_t)(const char *bytes, size_t len,
                                   void *data);
 
#define Z_ALIGN_SHIFT(type)     (__alignof__(type) == 1 ? 0 : \
                                 __alignof__(type) == 2 ? 1 : \
                                 __alignof__(type) == 4 ? 2 : 3)

#define JSON_OBJ_DESCR_PRIM(struct_, field_name_, type_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#field_name_) - 1, \
                .type = type_, \
                .offset = offsetof(struct_, field_name_), \
                .field = { \
                        .size = SIZEOF_FIELD(struct_, field_name_) \
                }, \
        }

#define JSON_OBJ_DESCR_OBJECT(struct_, field_name_, sub_descr_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = (sizeof(#field_name_) - 1), \
                .type = JSON_TOK_OBJECT_START, \
                .offset = offsetof(struct_, field_name_), \
                .object = { \
                        .sub_descr = sub_descr_, \
                        .sub_descr_len = ARRAY_SIZE(sub_descr_), \
                }, \
        }

#define Z_JSON_ELEMENT_DESCR(struct_, len_field_, elem_type_, union_) \
        (const struct json_obj_descr[]) \
        { \
                { \
                        .align_shift = Z_ALIGN_SHIFT(struct_), \
                        .type = elem_type_, \
                        .offset = offsetof(struct_, len_field_), \
                        union_ \
                } \
        }

#define Z_JSON_DESCR_ARRAY(elem_descr_, elem_descr_len_) \
        { \
                .array = { \
                        .element_descr = elem_descr_, \
                        .n_elements = elem_descr_len_, \
                }, \
        }

#define Z_JSON_DESCR_OBJ(elem_descr_, elem_descr_len_) \
                .object = { \
                        .sub_descr = elem_descr_, \
                        .sub_descr_len = elem_descr_len_, \
                }, \

#define Z_JSON_DESCR_FIELD(struct_, field_name_) \
        { \
                .field = { \
                        .size = SIZEOF_FIELD(struct_, field_name_), \
                }, \
        }

#define JSON_OBJ_DESCR_ARRAY(struct_, field_name_, max_len_, \
                             len_field_, elem_type_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, field_name_), \
                .array = { \
                        .element_descr = Z_JSON_ELEMENT_DESCR(struct_, len_field_, \
                                elem_type_, \
                                Z_JSON_DESCR_FIELD(struct_, field_name_[0])), \
                        .n_elements = (max_len_), \
                }, \
        }

#define JSON_OBJ_DESCR_OBJ_ARRAY(struct_, field_name_, max_len_, \
                                 len_field_, elem_descr_, elem_descr_len_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, field_name_), \
                .array = { \
                        .element_descr = Z_JSON_ELEMENT_DESCR(struct_, len_field_, \
                                JSON_TOK_OBJECT_START, \
                                Z_JSON_DESCR_OBJ(elem_descr_, elem_descr_len_)), \
                        .n_elements = (max_len_), \
                }, \
        }

#define JSON_OBJ_DESCR_ARRAY_ARRAY(struct_, field_name_, max_len_, len_field_, \
                                   elem_descr_, elem_descr_len_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, field_name_), \
                .array = { \
                        .element_descr = Z_JSON_ELEMENT_DESCR( \
                                struct_, len_field_, JSON_TOK_ARRAY_START, \
                                Z_JSON_DESCR_ARRAY( \
                                        elem_descr_, \
                                        1 + ZERO_OR_COMPILE_ERROR(elem_descr_len_ == 1))), \
                        .n_elements = (max_len_), \
                }, \
        }

#define JSON_OBJ_DESCR_ARRAY_ARRAY_NAMED(struct_, json_field_name_, struct_field_name_, \
                                         max_len_, len_field_, elem_descr_, elem_descr_len_) \
        { \
                .field_name = (#json_field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#json_field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, struct_field_name_), \
                .array = { \
                        .element_descr = Z_JSON_ELEMENT_DESCR( \
                                struct_, len_field_, JSON_TOK_ARRAY_START, \
                                Z_JSON_DESCR_ARRAY( \
                                        elem_descr_, \
                                        1 + ZERO_OR_COMPILE_ERROR(elem_descr_len_ == 1))), \
                        .n_elements = (max_len_), \
                }, \
        }

#define JSON_OBJ_DESCR_PRIM_NAMED(struct_, json_field_name_, \
                                  struct_field_name_, type_) \
        { \
                .field_name = (json_field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(json_field_name_) - 1, \
                .type = type_, \
                .offset = offsetof(struct_, struct_field_name_), \
                .field = { \
                        .size = SIZEOF_FIELD(struct_, struct_field_name_) \
                }, \
        }

#define JSON_OBJ_DESCR_OBJECT_NAMED(struct_, json_field_name_, \
                                    struct_field_name_, sub_descr_) \
        { \
                .field_name = (json_field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = (sizeof(json_field_name_) - 1), \
                .type = JSON_TOK_OBJECT_START, \
                .offset = offsetof(struct_, struct_field_name_), \
                .object = { \
                        .sub_descr = sub_descr_, \
                        .sub_descr_len = ARRAY_SIZE(sub_descr_), \
                }, \
        }

#define JSON_OBJ_DESCR_ARRAY_NAMED(struct_, json_field_name_,\
                                   struct_field_name_, max_len_, len_field_, \
                                   elem_type_) \
        { \
                .field_name = (json_field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(json_field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, struct_field_name_), \
                .array = { \
                        .element_descr = Z_JSON_ELEMENT_DESCR(struct_, len_field_, \
                                elem_type_, \
                                Z_JSON_DESCR_FIELD(struct_, struct_field_name_[0])), \
                        .n_elements = (max_len_), \
                }, \
        }

#define JSON_OBJ_DESCR_OBJ_ARRAY_NAMED(struct_, json_field_name_, \
                                       struct_field_name_, max_len_, \
                                       len_field_, elem_descr_, \
                                       elem_descr_len_) \
        { \
                .field_name = json_field_name_, \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(json_field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, struct_field_name_), \
                .array = { \
                        .element_descr = Z_JSON_ELEMENT_DESCR(struct_, len_field_, \
                                JSON_TOK_OBJECT_START, \
                                Z_JSON_DESCR_OBJ(elem_descr_, elem_descr_len_)), \
                        .n_elements = (max_len_), \
                }, \
        }

int64_t json_obj_parse(char *json, size_t len,
        const struct json_obj_descr *descr, size_t descr_len,
        void *val);

int json_arr_parse(char *json, size_t len,
        const struct json_obj_descr *descr, void *val);

int json_arr_separate_object_parse_init(struct json_obj *json, char *payload, size_t len);

int json_arr_separate_parse_object(struct json_obj *json, const struct json_obj_descr *descr,
                                   size_t descr_len, void *val);

ssize_t json_escape(char *str, size_t *len, size_t buf_size);

size_t json_calc_escaped_len(const char *str, size_t len);

ssize_t json_calc_encoded_len(const struct json_obj_descr *descr,
                              size_t descr_len, const void *val);

ssize_t json_calc_encoded_arr_len(const struct json_obj_descr *descr,
                                  const void *val);

int json_obj_encode_buf(const struct json_obj_descr *descr, size_t descr_len,
                        const void *val, char *buffer, size_t buf_size);

int json_arr_encode_buf(const struct json_obj_descr *descr, const void *val,
                        char *buffer, size_t buf_size);

int json_obj_encode(const struct json_obj_descr *descr, size_t descr_len,
                    const void *val, json_append_bytes_t append_bytes,
                    void *data);

int json_arr_encode(const struct json_obj_descr *descr, const void *val,
                    json_append_bytes_t append_bytes, void *data);

struct json_mixed_arr_descr {
        uint32_t type : 7;
        size_t count_offset;
 
        union {
                struct {
                        size_t offset;
                        size_t size;
                } primitive;
 
                struct {
                        const struct json_obj_descr *sub_descr;
                        size_t sub_descr_len;
                        size_t offset;
                } object;
 
                struct {
                        const struct json_obj_descr *element_descr;
                        size_t n_elements;
                        size_t offset;
                } array;
 
                struct {
                        const struct json_mixed_arr_descr *sub_descr;
                        size_t sub_descr_len;
                        size_t offset;
                } mixed_array;
        };
};

#define JSON_MIXED_ARR_DESCR_PRIM(struct_, field_name_, type_, count_field_) \
{ \
        .type = type_, \
        .count_offset = offsetof(struct_, count_field_), \
        .primitive = { \
            .offset = offsetof(struct_, field_name_), \
            .size = SIZEOF_FIELD(struct_, field_name_) \
        } \
}

#define JSON_MIXED_ARR_DESCR_OBJECT(struct_, field_name_, sub_descr_, count_field_) \
{ \
        .type = JSON_TOK_OBJECT_START, \
        .count_offset = offsetof(struct_, count_field_), \
        .object = { \
                .sub_descr = sub_descr_, \
                .sub_descr_len = ARRAY_SIZE(sub_descr_), \
                .offset = offsetof(struct_, field_name_) \
        } \
}

#define JSON_MIXED_ARR_DESCR_ARRAY(struct_, field_name_, max_len_, elem_descr_, count_field_) \
{ \
        .type = JSON_TOK_ARRAY_START, \
        .count_offset = offsetof(struct_, count_field_), \
        .array = { \
                .element_descr = elem_descr_, \
                .n_elements = (max_len_), \
                .offset = offsetof(struct_, field_name_) \
        } \
}

#define JSON_MIXED_ARR_DESCR_MIXED_ARRAY(struct_, field_name_, sub_descr_, count_field_) \
{ \
        .type = JSON_TOK_MIXED_ARRAY, \
        .count_offset = offsetof(struct_, count_field_), \
        .mixed_array = { \
                .sub_descr = sub_descr_, \
                .sub_descr_len = ARRAY_SIZE(sub_descr_), \
                .offset = offsetof(struct_, field_name_) \
        } \
}

int json_mixed_arr_parse(char *json, size_t len,
                         const struct json_mixed_arr_descr *descr,
                         size_t descr_len, void *val);

int json_mixed_arr_encode(const struct json_mixed_arr_descr *descr,
                          size_t descr_len, void *val,
                          json_append_bytes_t append_bytes,
                          void *data);

int json_mixed_arr_encode_buf(const struct json_mixed_arr_descr *descr,
                              size_t descr_len, void *val,
                              char *buffer, size_t buf_size);

ssize_t json_calc_mixed_arr_len(const struct json_mixed_arr_descr *descr,
                                size_t descr_len, void *val);
 
#ifdef __cplusplus
}
#endif

#endif /* ZEPHYR_INCLUDE_DATA_JSON_H_ */