Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 1 | /** |
| 2 | * @file parser_json.c |
| 3 | * @author Radek Krejci <rkrejci@cesnet.cz> |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 4 | * @author Michal Vasko <mvasko@cesnet.cz> |
Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 5 | * @brief JSON data parser for libyang |
| 6 | * |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 7 | * Copyright (c) 2020 - 2023 CESNET, z.s.p.o. |
Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 8 | * |
| 9 | * This source code is licensed under BSD 3-Clause License (the "License"). |
| 10 | * You may not use this file except in compliance with the License. |
| 11 | * You may obtain a copy of the License at |
| 12 | * |
| 13 | * https://opensource.org/licenses/BSD-3-Clause |
| 14 | */ |
| 15 | |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 16 | #define _GNU_SOURCE |
Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 17 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 18 | #include <assert.h> |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 19 | #include <stdint.h> |
Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 20 | #include <stdlib.h> |
| 21 | #include <string.h> |
| 22 | |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 23 | #include "common.h" |
Michal Vasko | bbdadda | 2022-01-06 11:40:10 +0100 | [diff] [blame] | 24 | #include "compat.h" |
Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 25 | #include "context.h" |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 26 | #include "dict.h" |
Michal Vasko | afac782 | 2020-10-20 14:22:26 +0200 | [diff] [blame] | 27 | #include "in_internal.h" |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 28 | #include "json.h" |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 29 | #include "log.h" |
Radek Krejci | 7711410 | 2021-03-10 15:21:57 +0100 | [diff] [blame] | 30 | #include "parser_data.h" |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 31 | #include "parser_internal.h" |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 32 | #include "plugins_exts.h" |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 33 | #include "set.h" |
| 34 | #include "tree.h" |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 35 | #include "tree_data.h" |
| 36 | #include "tree_data_internal.h" |
| 37 | #include "tree_schema.h" |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 38 | #include "tree_schema_internal.h" |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 39 | #include "validation.h" |
Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 40 | |
| 41 | /** |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 42 | * @brief Free the JSON data parser context. |
| 43 | * |
| 44 | * JSON implementation of lyd_ctx_free_clb(). |
| 45 | */ |
| 46 | static void |
| 47 | lyd_json_ctx_free(struct lyd_ctx *lydctx) |
| 48 | { |
| 49 | struct lyd_json_ctx *ctx = (struct lyd_json_ctx *)lydctx; |
| 50 | |
| 51 | if (lydctx) { |
| 52 | lyd_ctx_free(lydctx); |
| 53 | lyjson_ctx_free(ctx->jsonctx); |
| 54 | free(ctx); |
| 55 | } |
| 56 | } |
| 57 | |
| 58 | /** |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 59 | * @brief Pass the responsibility for releasing the dynamic values to @p dst. |
aPiecek | d2c3937 | 2021-06-16 14:03:12 +0200 | [diff] [blame] | 60 | * |
| 61 | * @param[in] jsonctx JSON context which contains the dynamic value. |
| 62 | * @param[in,out] dst Pointer to which the responsibility will be submited. |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 63 | * If the pointer is already pointing to some allocated memory, it is released beforehand. |
aPiecek | d2c3937 | 2021-06-16 14:03:12 +0200 | [diff] [blame] | 64 | */ |
| 65 | static void |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 66 | lyjson_ctx_give_dynamic_value(struct lyjson_ctx *jsonctx, char **dst) |
aPiecek | d2c3937 | 2021-06-16 14:03:12 +0200 | [diff] [blame] | 67 | { |
| 68 | assert(jsonctx && dst); |
| 69 | |
| 70 | if (!jsonctx->dynamic) { |
| 71 | return; |
| 72 | } |
| 73 | |
| 74 | if (dst) { |
| 75 | free(*dst); |
| 76 | } |
| 77 | *dst = NULL; |
| 78 | |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 79 | /* give the dynamic value */ |
aPiecek | d2c3937 | 2021-06-16 14:03:12 +0200 | [diff] [blame] | 80 | *dst = (char *)jsonctx->value; |
| 81 | |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 82 | /* responsibility for the release is now passed to dst */ |
aPiecek | d2c3937 | 2021-06-16 14:03:12 +0200 | [diff] [blame] | 83 | jsonctx->dynamic = 0; |
| 84 | } |
| 85 | |
| 86 | /** |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 87 | * @brief Parse JSON member-name as [\@][prefix:][name] |
| 88 | * |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 89 | * \@ - metadata flag, maps to 1 in @p is_meta_p |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 90 | * prefix - name of the module of the data node |
| 91 | * name - name of the data node |
| 92 | * |
| 93 | * All the output parameter are mandatory. Function only parse the member-name, all the appropriate checks are up to the caller. |
| 94 | * |
| 95 | * @param[in] value String to parse |
| 96 | * @param[in] value_len Length of the @p str. |
| 97 | * @param[out] name_p Pointer to the beginning of the parsed name. |
| 98 | * @param[out] name_len_p Pointer to the length of the parsed name. |
| 99 | * @param[out] prefix_p Pointer to the beginning of the parsed prefix. If the member-name does not contain prefix, result is NULL. |
| 100 | * @param[out] prefix_len_p Pointer to the length of the parsed prefix. If the member-name does not contain prefix, result is 0. |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 101 | * @param[out] is_meta_p Pointer to the metadata flag, set to 1 if the member-name contains \@, 0 otherwise. |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 102 | */ |
| 103 | static void |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 104 | lydjson_parse_name(const char *value, size_t value_len, const char **name_p, size_t *name_len_p, const char **prefix_p, |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 105 | size_t *prefix_len_p, ly_bool *is_meta_p) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 106 | { |
| 107 | const char *name, *prefix = NULL; |
| 108 | size_t name_len, prefix_len = 0; |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 109 | ly_bool is_meta = 0; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 110 | |
| 111 | name = memchr(value, ':', value_len); |
| 112 | if (name != NULL) { |
| 113 | prefix = value; |
| 114 | if (*prefix == '@') { |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 115 | is_meta = 1; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 116 | prefix++; |
| 117 | } |
| 118 | prefix_len = name - prefix; |
| 119 | name++; |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 120 | name_len = value_len - (prefix_len + 1) - is_meta; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 121 | } else { |
| 122 | name = value; |
| 123 | if (name[0] == '@') { |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 124 | is_meta = 1; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 125 | name++; |
| 126 | } |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 127 | name_len = value_len - is_meta; |
Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 128 | } |
| 129 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 130 | *name_p = name; |
| 131 | *name_len_p = name_len; |
| 132 | *prefix_p = prefix; |
| 133 | *prefix_len_p = prefix_len; |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 134 | *is_meta_p = is_meta; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 135 | } |
| 136 | |
| 137 | /** |
| 138 | * @brief Get correct prefix (module_name) inside the @p node. |
| 139 | * |
| 140 | * @param[in] node Data node to get inherited prefix. |
| 141 | * @param[in] local_prefix Local prefix to replace the inherited prefix. |
| 142 | * @param[in] local_prefix_len Length of the @p local_prefix string. In case of 0, the inherited prefix is taken. |
| 143 | * @param[out] prefix_p Pointer to the resulting prefix string, Note that the result can be NULL in case of no local prefix |
| 144 | * and no context @p node to get inherited prefix. |
| 145 | * @param[out] prefix_len_p Pointer to the length of the resulting @p prefix_p string. Note that the result can be 0 in case |
| 146 | * of no local prefix and no context @p node to get inherited prefix. |
| 147 | * @return LY_ERR value. |
| 148 | */ |
| 149 | static LY_ERR |
Michal Vasko | a5da329 | 2020-08-12 13:10:50 +0200 | [diff] [blame] | 150 | lydjson_get_node_prefix(struct lyd_node *node, const char *local_prefix, size_t local_prefix_len, const char **prefix_p, |
Radek Krejci | 0f96988 | 2020-08-21 16:56:47 +0200 | [diff] [blame] | 151 | size_t *prefix_len_p) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 152 | { |
| 153 | struct lyd_node_opaq *onode; |
| 154 | const char *module_name = NULL; |
| 155 | |
| 156 | assert(prefix_p && prefix_len_p); |
| 157 | |
| 158 | if (local_prefix_len) { |
| 159 | *prefix_p = local_prefix; |
| 160 | *prefix_len_p = local_prefix_len; |
| 161 | return LY_SUCCESS; |
| 162 | } |
| 163 | |
| 164 | *prefix_p = NULL; |
| 165 | while (node) { |
| 166 | if (node->schema) { |
| 167 | *prefix_p = node->schema->module->name; |
| 168 | break; |
| 169 | } |
Michal Vasko | 22df3f0 | 2020-08-24 13:29:22 +0200 | [diff] [blame] | 170 | onode = (struct lyd_node_opaq *)node; |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 171 | if (onode->name.module_name) { |
| 172 | *prefix_p = onode->name.module_name; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 173 | break; |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 174 | } else if (onode->name.prefix) { |
| 175 | *prefix_p = onode->name.prefix; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 176 | break; |
| 177 | } |
Michal Vasko | 9e68508 | 2021-01-29 14:49:09 +0100 | [diff] [blame] | 178 | node = lyd_parent(node); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 179 | } |
| 180 | *prefix_len_p = ly_strlen(module_name); |
| 181 | |
| 182 | return LY_SUCCESS; |
| 183 | } |
| 184 | |
| 185 | /** |
Michal Vasko | 87c5d6b | 2023-02-14 15:27:41 +0100 | [diff] [blame] | 186 | * @brief Skip the current JSON item (based on status). |
| 187 | * |
| 188 | * The JSON context is moved to the last "status" of the JSON item so to completely |
| 189 | * finish the skip, one more JSON context move is required. |
Michal Vasko | a4af625 | 2022-05-20 10:38:54 +0200 | [diff] [blame] | 190 | * |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 191 | * @param[in] jsonctx JSON context with the input data to skip. |
| 192 | * @return LY_ERR value. |
| 193 | */ |
| 194 | static LY_ERR |
| 195 | lydjson_data_skip(struct lyjson_ctx *jsonctx) |
| 196 | { |
| 197 | enum LYJSON_PARSER_STATUS status, current; |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 198 | uint32_t depth; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 199 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 200 | status = lyjson_ctx_status(jsonctx); |
| 201 | depth = lyjson_ctx_depth(jsonctx); |
Michal Vasko | a4af625 | 2022-05-20 10:38:54 +0200 | [diff] [blame] | 202 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 203 | switch (status) { |
| 204 | case LYJSON_OBJECT: |
| 205 | ++depth; |
Michal Vasko | a4af625 | 2022-05-20 10:38:54 +0200 | [diff] [blame] | 206 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 207 | /* skip until object closes */ |
| 208 | do { |
Michal Vasko | 4f04d76 | 2022-09-05 08:38:26 +0200 | [diff] [blame] | 209 | LY_CHECK_RET(lyjson_ctx_next(jsonctx, ¤t)); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 210 | } while ((current != LYJSON_OBJECT_CLOSED) || (depth != lyjson_ctx_depth(jsonctx))); |
| 211 | break; |
| 212 | case LYJSON_ARRAY: |
| 213 | ++depth; |
Juraj Vijtiuk | 2e88368 | 2021-09-20 17:00:56 +0200 | [diff] [blame] | 214 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 215 | /* skip until array closes */ |
| 216 | do { |
| 217 | LY_CHECK_RET(lyjson_ctx_next(jsonctx, ¤t)); |
| 218 | } while ((current != LYJSON_ARRAY_CLOSED) || (depth != lyjson_ctx_depth(jsonctx))); |
| 219 | break; |
| 220 | case LYJSON_OBJECT_NAME: |
| 221 | /* just get to the value */ |
| 222 | LY_CHECK_RET(lyjson_ctx_next(jsonctx, ¤t)); |
| 223 | if ((current == LYJSON_OBJECT) || (current == LYJSON_ARRAY)) { |
| 224 | LY_CHECK_RET(lydjson_data_skip(jsonctx)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 225 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 226 | break; |
| 227 | default: |
| 228 | /* no other status expected */ |
| 229 | LOGINT(jsonctx->ctx); |
| 230 | return LY_EINT; |
Michal Vasko | a4af625 | 2022-05-20 10:38:54 +0200 | [diff] [blame] | 231 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 232 | |
| 233 | return LY_SUCCESS; |
| 234 | } |
| 235 | |
| 236 | /** |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 237 | * @brief Get schema node corresponding to the input parameters. |
| 238 | * |
| 239 | * @param[in] lydctx JSON data parser context. |
| 240 | * @param[in] is_attr Flag if the reference to the node is an attribute, for logging only. |
| 241 | * @param[in] prefix Requested node's prefix (module name). |
| 242 | * @param[in] prefix_len Length of the @p prefix. |
| 243 | * @param[in] name Requested node's name. |
| 244 | * @param[in] name_len Length of the @p name. |
| 245 | * @param[in] parent Parent of the node being processed, can be NULL in case of top-level. |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 246 | * @param[out] snode Found schema node corresponding to the input parameters. If NULL, parse as an opaque node. |
| 247 | * @param[out] ext Extension instance that provided @p snode, if any. |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 248 | * @return LY_SUCCES on success. |
| 249 | * @return LY_ENOT if the whole object was parsed (skipped or as an extension). |
| 250 | * @return LY_ERR on error. |
| 251 | */ |
| 252 | static LY_ERR |
| 253 | lydjson_get_snode(struct lyd_json_ctx *lydctx, ly_bool is_attr, const char *prefix, size_t prefix_len, const char *name, |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 254 | size_t name_len, struct lyd_node *parent, const struct lysc_node **snode, struct lysc_ext_instance **ext) |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 255 | { |
| 256 | LY_ERR ret = LY_SUCCESS, r; |
| 257 | struct lys_module *mod = NULL; |
| 258 | uint32_t getnext_opts = lydctx->int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0; |
| 259 | |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 260 | *snode = NULL; |
| 261 | *ext = NULL; |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 262 | |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 263 | /* get the element module, prefer parent context because of extensions */ |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 264 | if (prefix_len) { |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 265 | mod = ly_ctx_get_module_implemented2(parent ? LYD_CTX(parent) : lydctx->jsonctx->ctx, prefix, prefix_len); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 266 | } else if (parent) { |
| 267 | if (parent->schema) { |
| 268 | mod = parent->schema->module; |
| 269 | } |
Michal Vasko | e3ed7dc | 2022-11-30 11:39:44 +0100 | [diff] [blame] | 270 | } else if (!(lydctx->int_opts & LYD_INTOPT_ANY)) { |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 271 | LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX_JSON, "Top-level JSON object member \"%.*s\" must be namespace-qualified.", |
| 272 | (int)(is_attr ? name_len + 1 : name_len), is_attr ? name - 1 : name); |
| 273 | ret = LY_EVALID; |
| 274 | goto cleanup; |
| 275 | } |
| 276 | if (!mod) { |
| 277 | /* check for extension data */ |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 278 | r = ly_nested_ext_schema(parent, NULL, prefix, prefix_len, LY_VALUE_JSON, NULL, name, name_len, snode, ext); |
| 279 | if (r != LY_ENOT) { |
| 280 | /* success or error */ |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 281 | ret = r; |
| 282 | goto cleanup; |
| 283 | } |
| 284 | |
| 285 | /* unknown module */ |
| 286 | if (lydctx->parse_opts & LYD_PARSE_STRICT) { |
| 287 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "No module named \"%.*s\" in the context.", (int)prefix_len, prefix); |
| 288 | ret = LY_EVALID; |
| 289 | goto cleanup; |
| 290 | } |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | /* get the schema node */ |
| 294 | if (mod && (!parent || parent->schema)) { |
| 295 | if (!parent && lydctx->ext) { |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 296 | *snode = lysc_ext_find_node(lydctx->ext, mod, name, name_len, 0, getnext_opts); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 297 | } else { |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 298 | *snode = lys_find_child(parent ? parent->schema : NULL, mod, name, name_len, 0, getnext_opts); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 299 | } |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 300 | if (!*snode) { |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 301 | /* check for extension data */ |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 302 | r = ly_nested_ext_schema(parent, NULL, prefix, prefix_len, LY_VALUE_JSON, NULL, name, name_len, snode, ext); |
| 303 | if (r != LY_ENOT) { |
| 304 | /* success or error */ |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 305 | ret = r; |
| 306 | goto cleanup; |
| 307 | } |
| 308 | |
| 309 | /* unknown data node */ |
| 310 | if (lydctx->parse_opts & LYD_PARSE_STRICT) { |
| 311 | if (parent) { |
| 312 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Node \"%.*s\" not found as a child of \"%s\" node.", |
| 313 | (int)name_len, name, LYD_NAME(parent)); |
| 314 | } else if (lydctx->ext) { |
| 315 | if (lydctx->ext->argument) { |
| 316 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, |
| 317 | "Node \"%.*s\" not found in the \"%s\" %s extension instance.", |
| 318 | (int)name_len, name, lydctx->ext->argument, lydctx->ext->def->name); |
| 319 | } else { |
| 320 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Node \"%.*s\" not found in the %s extension instance.", |
| 321 | (int)name_len, name, lydctx->ext->def->name); |
| 322 | } |
| 323 | } else { |
| 324 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Node \"%.*s\" not found in the \"%s\" module.", |
| 325 | (int)name_len, name, mod->name); |
| 326 | } |
| 327 | ret = LY_EVALID; |
| 328 | goto cleanup; |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 329 | } |
| 330 | } else { |
| 331 | /* check that schema node is valid and can be used */ |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 332 | ret = lyd_parser_check_schema((struct lyd_ctx *)lydctx, *snode); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 333 | } |
| 334 | } |
| 335 | |
| 336 | cleanup: |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 337 | return ret; |
| 338 | } |
| 339 | |
| 340 | /** |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 341 | * @brief Check that the input data are parseable as the @p list. |
| 342 | * |
| 343 | * Checks for all the list's keys. Function does not revert the context state. |
| 344 | * |
| 345 | * @param[in] jsonctx JSON parser context. |
| 346 | * @param[in] list List schema node corresponding to the input data object. |
| 347 | * @return LY_SUCCESS in case the data are ok for the @p list |
| 348 | * @return LY_ENOT in case the input data are not sufficient to fully parse the list instance. |
| 349 | */ |
| 350 | static LY_ERR |
| 351 | lydjson_check_list(struct lyjson_ctx *jsonctx, const struct lysc_node *list) |
| 352 | { |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 353 | LY_ERR rc = LY_SUCCESS; |
| 354 | enum LYJSON_PARSER_STATUS status = lyjson_ctx_status(jsonctx); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 355 | struct ly_set key_set = {0}; |
| 356 | const struct lysc_node *snode; |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 357 | uint32_t i; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 358 | |
| 359 | assert(list && (list->nodetype == LYS_LIST)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 360 | |
| 361 | /* get all keys into a set (keys do not have if-features or anything) */ |
| 362 | snode = NULL; |
Michal Vasko | 7b1ad1a | 2020-11-02 15:41:27 +0100 | [diff] [blame] | 363 | while ((snode = lys_getnext(snode, list, NULL, 0)) && (snode->flags & LYS_KEY)) { |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 364 | rc = ly_set_add(&key_set, (void *)snode, 1, NULL); |
| 365 | LY_CHECK_GOTO(rc, cleanup); |
| 366 | } |
| 367 | if (!key_set.count) { |
| 368 | /* no keys */ |
| 369 | goto cleanup; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 370 | } |
| 371 | |
Michal Vasko | 86fdf34 | 2022-12-01 11:08:29 +0100 | [diff] [blame] | 372 | if (status == LYJSON_OBJECT) { |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 373 | do { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 374 | const char *name, *prefix; |
| 375 | size_t name_len, prefix_len; |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 376 | ly_bool is_attr; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 377 | |
| 378 | /* match the key */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 379 | LY_CHECK_GOTO(rc = lyjson_ctx_next(jsonctx, &status), cleanup); |
Michal Vasko | b81b5eb | 2023-04-21 14:03:25 +0200 | [diff] [blame] | 380 | if (status != LYJSON_OBJECT_NAME) { |
| 381 | break; |
| 382 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 383 | snode = NULL; |
| 384 | lydjson_parse_name(jsonctx->value, jsonctx->value_len, &name, &name_len, &prefix, &prefix_len, &is_attr); |
| 385 | |
| 386 | if (!is_attr && !prefix) { |
| 387 | for (i = 0; i < key_set.count; ++i) { |
Michal Vasko | d990ee5 | 2023-04-21 14:03:56 +0200 | [diff] [blame] | 388 | if (!ly_strncmp(key_set.snodes[i]->name, name, name_len)) { |
| 389 | snode = key_set.snodes[i]; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 390 | break; |
| 391 | } |
| 392 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 393 | |
| 394 | /* get the value */ |
| 395 | LY_CHECK_GOTO(rc = lyjson_ctx_next(jsonctx, &status), cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 396 | |
| 397 | if (snode) { |
| 398 | /* we have the key, validate the value */ |
Michal Vasko | b677d8e | 2023-03-23 15:37:07 +0100 | [diff] [blame] | 399 | if ((status < LYJSON_NUMBER) || (status > LYJSON_NULL)) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 400 | /* not a terminal */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 401 | rc = LY_ENOT; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 402 | goto cleanup; |
| 403 | } |
| 404 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 405 | rc = lys_value_validate(NULL, snode, jsonctx->value, jsonctx->value_len, LY_VALUE_JSON, NULL); |
| 406 | LY_CHECK_GOTO(rc, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 407 | |
| 408 | /* key with a valid value, remove from the set */ |
| 409 | ly_set_rm_index(&key_set, i, NULL); |
| 410 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 411 | |
| 412 | /* next object */ |
| 413 | LY_CHECK_GOTO(rc = lyjson_ctx_next(jsonctx, &status), cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 414 | } else { |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 415 | /* skip the uninteresting object */ |
| 416 | LY_CHECK_GOTO(rc = lydjson_data_skip(jsonctx), cleanup); |
| 417 | LY_CHECK_GOTO(rc = lyjson_ctx_next(jsonctx, &status), cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 418 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 419 | } while (key_set.count && (status == LYJSON_OBJECT_NEXT)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 420 | } |
| 421 | |
| 422 | if (key_set.count) { |
| 423 | /* some keys are missing/did not validate */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 424 | rc = LY_ENOT; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 425 | } |
| 426 | |
| 427 | cleanup: |
| 428 | ly_set_erase(&key_set, NULL); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 429 | return rc; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 430 | } |
| 431 | |
| 432 | /** |
| 433 | * @brief Get the hint for the data type parsers according to the current JSON parser context. |
| 434 | * |
| 435 | * @param[in] lydctx JSON data parser context. The context is supposed to be on a value. |
| 436 | * @param[in,out] status Pointer to the current context status, |
| 437 | * in some circumstances the function manipulates with the context so the status is updated. |
| 438 | * @param[out] type_hint_p Pointer to the variable to store the result. |
| 439 | * @return LY_SUCCESS in case of success. |
| 440 | * @return LY_EINVAL in case of invalid context status not referring to a value. |
| 441 | */ |
| 442 | static LY_ERR |
Radek Krejci | 1deb5be | 2020-08-26 16:43:36 +0200 | [diff] [blame] | 443 | lydjson_value_type_hint(struct lyd_json_ctx *lydctx, enum LYJSON_PARSER_STATUS *status_p, uint32_t *type_hint_p) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 444 | { |
| 445 | *type_hint_p = 0; |
| 446 | |
| 447 | if (*status_p == LYJSON_ARRAY) { |
| 448 | /* only [null] */ |
| 449 | LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, status_p)); |
Michal Vasko | 0ebc95f | 2022-07-11 15:55:38 +0200 | [diff] [blame] | 450 | if (*status_p != LYJSON_NULL) { |
Michal Vasko | d1336a3 | 2022-10-25 15:00:20 +0200 | [diff] [blame] | 451 | LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX_JSON, |
| 452 | "Expected JSON name/value or special name/[null], but input data contains name/[%s].", |
Michal Vasko | 0ebc95f | 2022-07-11 15:55:38 +0200 | [diff] [blame] | 453 | lyjson_token2str(*status_p)); |
| 454 | return LY_EINVAL; |
| 455 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 456 | |
| 457 | LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, NULL)); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 458 | if (lyjson_ctx_status(lydctx->jsonctx) != LYJSON_ARRAY_CLOSED) { |
Michal Vasko | 0ebc95f | 2022-07-11 15:55:38 +0200 | [diff] [blame] | 459 | LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX_JSON, "Expected array end, but input data contains %s.", |
| 460 | lyjson_token2str(*status_p)); |
| 461 | return LY_EINVAL; |
| 462 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 463 | |
Michal Vasko | feca4fb | 2020-10-05 08:58:40 +0200 | [diff] [blame] | 464 | *type_hint_p = LYD_VALHINT_EMPTY; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 465 | } else if (*status_p == LYJSON_STRING) { |
Michal Vasko | feca4fb | 2020-10-05 08:58:40 +0200 | [diff] [blame] | 466 | *type_hint_p = LYD_VALHINT_STRING | LYD_VALHINT_NUM64; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 467 | } else if (*status_p == LYJSON_NUMBER) { |
Michal Vasko | feca4fb | 2020-10-05 08:58:40 +0200 | [diff] [blame] | 468 | *type_hint_p = LYD_VALHINT_DECNUM; |
Michal Vasko | 6973015 | 2020-10-09 16:30:07 +0200 | [diff] [blame] | 469 | } else if ((*status_p == LYJSON_FALSE) || (*status_p == LYJSON_TRUE)) { |
Michal Vasko | feca4fb | 2020-10-05 08:58:40 +0200 | [diff] [blame] | 470 | *type_hint_p = LYD_VALHINT_BOOLEAN; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 471 | } else if (*status_p == LYJSON_NULL) { |
| 472 | *type_hint_p = 0; |
| 473 | } else { |
Michal Vasko | 0ebc95f | 2022-07-11 15:55:38 +0200 | [diff] [blame] | 474 | LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX_JSON, "Unexpected input data %s.", lyjson_token2str(*status_p)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 475 | return LY_EINVAL; |
| 476 | } |
| 477 | |
| 478 | return LY_SUCCESS; |
| 479 | } |
| 480 | |
| 481 | /** |
| 482 | * @brief Check in advance if the input data are parsable according to the provided @p snode. |
| 483 | * |
| 484 | * Note that the checks are done only in case the LYD_PARSE_OPAQ is allowed. Otherwise the same checking |
| 485 | * is naturally done when the data are really parsed. |
| 486 | * |
| 487 | * @param[in] lydctx JSON data parser context. When the function returns, the context is in the same state |
| 488 | * as before calling, despite it is necessary to process input data for checking. |
| 489 | * @param[in] snode Schema node corresponding to the member currently being processed in the context. |
| 490 | * @param[out] type_hint_p Pointer to a variable to store detected value type hint in case of leaf or leaf-list. |
| 491 | * @return LY_SUCCESS in case the data are ok for the @p snode or the LYD_PARSE_OPAQ is not enabled. |
| 492 | * @return LY_ENOT in case the input data are not sufficient to fully parse the list instance |
| 493 | * @return LY_EINVAL in case of invalid leaf JSON encoding |
| 494 | * and they are expected to be parsed as opaq nodes. |
| 495 | */ |
| 496 | static LY_ERR |
Radek Krejci | 1deb5be | 2020-08-26 16:43:36 +0200 | [diff] [blame] | 497 | lydjson_data_check_opaq(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, uint32_t *type_hint_p) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 498 | { |
| 499 | LY_ERR ret = LY_SUCCESS; |
| 500 | struct lyjson_ctx *jsonctx = lydctx->jsonctx; |
| 501 | enum LYJSON_PARSER_STATUS status; |
| 502 | |
| 503 | assert(snode); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 504 | |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 505 | if (!(snode->nodetype & (LYD_NODE_TERM | LYS_LIST))) { |
| 506 | /* can always be parsed as a data node if we have the schema node */ |
| 507 | return LY_SUCCESS; |
| 508 | } |
| 509 | |
Michal Vasko | 8543070 | 2021-07-21 14:29:56 +0200 | [diff] [blame] | 510 | /* backup parser */ |
| 511 | lyjson_ctx_backup(jsonctx); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 512 | status = lyjson_ctx_status(jsonctx); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 513 | |
Michal Vasko | 8543070 | 2021-07-21 14:29:56 +0200 | [diff] [blame] | 514 | if (lydctx->parse_opts & LYD_PARSE_OPAQ) { |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 515 | /* check if the node is parseable. if not, NULL the snode to announce that it is supposed to be parsed |
| 516 | * as an opaq node */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 517 | switch (snode->nodetype) { |
| 518 | case LYS_LEAFLIST: |
| 519 | case LYS_LEAF: |
| 520 | /* value may not be valid in which case we parse it as an opaque node */ |
| 521 | ret = lydjson_value_type_hint(lydctx, &status, type_hint_p); |
| 522 | if (ret) { |
| 523 | break; |
| 524 | } |
| 525 | |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 526 | if (lys_value_validate(NULL, snode, jsonctx->value, jsonctx->value_len, LY_VALUE_JSON, NULL)) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 527 | ret = LY_ENOT; |
| 528 | } |
| 529 | break; |
| 530 | case LYS_LIST: |
| 531 | /* lists may not have all its keys */ |
| 532 | if (lydjson_check_list(jsonctx, snode)) { |
Michal Vasko | 86fdf34 | 2022-12-01 11:08:29 +0100 | [diff] [blame] | 533 | /* invalid list, parse as opaque if it misses/has invalid some keys */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 534 | ret = LY_ENOT; |
| 535 | } |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 536 | break; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 537 | } |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 538 | } else if (snode->nodetype & LYD_NODE_TERM) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 539 | ret = lydjson_value_type_hint(lydctx, &status, type_hint_p); |
| 540 | } |
| 541 | |
Michal Vasko | 8543070 | 2021-07-21 14:29:56 +0200 | [diff] [blame] | 542 | /* restore parser */ |
| 543 | lyjson_ctx_restore(jsonctx); |
| 544 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 545 | return ret; |
| 546 | } |
| 547 | |
| 548 | /** |
| 549 | * @brief Join the forward-referencing metadata with their target data nodes. |
| 550 | * |
| 551 | * Note that JSON encoding for YANG data allows forward-referencing metadata only for leafs/leaf-lists. |
| 552 | * |
| 553 | * @param[in] lydctx JSON data parser context. |
| 554 | * @param[in,out] first_p Pointer to the first sibling node variable (top-level or in a particular parent node) |
| 555 | * as a starting point to search for the metadata's target data node |
| 556 | * @return LY_SUCCESS on success |
| 557 | * @return LY_EVALID in case there are some metadata with unresolved target data node instance |
| 558 | */ |
| 559 | static LY_ERR |
| 560 | lydjson_metadata_finish(struct lyd_json_ctx *lydctx, struct lyd_node **first_p) |
| 561 | { |
| 562 | LY_ERR ret = LY_SUCCESS; |
aPiecek | 5057c2e | 2021-05-17 10:28:03 +0200 | [diff] [blame] | 563 | struct lyd_node *node, *attr, *next, *meta_iter; |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 564 | struct lysc_ext_instance *ext; |
Radek Krejci | 1deb5be | 2020-08-26 16:43:36 +0200 | [diff] [blame] | 565 | uint64_t instance = 0; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 566 | const char *prev = NULL; |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 567 | uint32_t log_location_items = 0; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 568 | |
| 569 | /* finish linking metadata */ |
| 570 | LY_LIST_FOR_SAFE(*first_p, next, attr) { |
Michal Vasko | 22df3f0 | 2020-08-24 13:29:22 +0200 | [diff] [blame] | 571 | struct lyd_node_opaq *meta_container = (struct lyd_node_opaq *)attr; |
Radek Krejci | 1deb5be | 2020-08-26 16:43:36 +0200 | [diff] [blame] | 572 | uint64_t match = 0; |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 573 | ly_bool is_attr; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 574 | const char *name, *prefix; |
| 575 | size_t name_len, prefix_len; |
| 576 | const struct lysc_node *snode; |
| 577 | |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 578 | if (attr->schema || (meta_container->name.name[0] != '@')) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 579 | /* not an opaq metadata node */ |
| 580 | continue; |
| 581 | } |
| 582 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 583 | LOG_LOCSET(NULL, attr, NULL, NULL); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 584 | log_location_items++; |
| 585 | |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 586 | if (prev != meta_container->name.name) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 587 | /* metas' names are stored in dictionary, so checking pointers must works */ |
| 588 | lydict_remove(lydctx->jsonctx->ctx, prev); |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 589 | LY_CHECK_GOTO(ret = lydict_insert(lydctx->jsonctx->ctx, meta_container->name.name, 0, &prev), cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 590 | instance = 1; |
| 591 | } else { |
| 592 | instance++; |
| 593 | } |
| 594 | |
aPiecek | 5057c2e | 2021-05-17 10:28:03 +0200 | [diff] [blame] | 595 | /* find the corresponding data node */ |
| 596 | LY_LIST_FOR(*first_p, node) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 597 | if (!node->schema) { |
| 598 | /* opaq node - we are going to put into it just a generic attribute. */ |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 599 | if (strcmp(&meta_container->name.name[1], ((struct lyd_node_opaq *)node)->name.name)) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 600 | continue; |
| 601 | } |
| 602 | |
Michal Vasko | feca4fb | 2020-10-05 08:58:40 +0200 | [diff] [blame] | 603 | if (((struct lyd_node_opaq *)node)->hints & LYD_NODEHINT_LIST) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 604 | LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX, "Metadata container references a sibling list node %s.", |
| 605 | ((struct lyd_node_opaq *)node)->name.name); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 606 | ret = LY_EVALID; |
| 607 | goto cleanup; |
| 608 | } |
| 609 | |
| 610 | /* match */ |
| 611 | match++; |
| 612 | if (match != instance) { |
| 613 | continue; |
| 614 | } |
| 615 | |
| 616 | LY_LIST_FOR(meta_container->child, meta_iter) { |
| 617 | /* convert opaq node to a attribute of the opaq node */ |
Michal Vasko | 22df3f0 | 2020-08-24 13:29:22 +0200 | [diff] [blame] | 618 | struct lyd_node_opaq *meta = (struct lyd_node_opaq *)meta_iter; |
Radek Krejci | bb27df3 | 2020-11-13 15:39:16 +0100 | [diff] [blame] | 619 | |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 620 | ret = lyd_create_attr(node, NULL, lydctx->jsonctx->ctx, meta->name.name, strlen(meta->name.name), |
| 621 | meta->name.prefix, ly_strlen(meta->name.prefix), meta->name.module_name, |
Radek Krejci | 8df109d | 2021-04-23 12:19:08 +0200 | [diff] [blame] | 622 | ly_strlen(meta->name.module_name), meta->value, ly_strlen(meta->value), NULL, LY_VALUE_JSON, |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 623 | NULL, meta->hints); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 624 | LY_CHECK_GOTO(ret, cleanup); |
| 625 | } |
| 626 | |
| 627 | /* done */ |
| 628 | break; |
| 629 | } else { |
| 630 | /* this is the second time we are resolving the schema node, so it must succeed, |
| 631 | * but remember that snode can be still NULL */ |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 632 | lydjson_parse_name(meta_container->name.name, strlen(meta_container->name.name), &name, &name_len, |
| 633 | &prefix, &prefix_len, &is_attr); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 634 | assert(is_attr); |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 635 | lydjson_get_snode(lydctx, is_attr, prefix, prefix_len, name, name_len, lyd_parent(*first_p), &snode, &ext); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 636 | |
| 637 | if (snode != node->schema) { |
| 638 | continue; |
| 639 | } |
| 640 | |
| 641 | /* match */ |
| 642 | match++; |
| 643 | if (match != instance) { |
| 644 | continue; |
| 645 | } |
| 646 | |
| 647 | LY_LIST_FOR(meta_container->child, meta_iter) { |
| 648 | /* convert opaq node to a metadata of the node */ |
Michal Vasko | 22df3f0 | 2020-08-24 13:29:22 +0200 | [diff] [blame] | 649 | struct lyd_node_opaq *meta = (struct lyd_node_opaq *)meta_iter; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 650 | struct lys_module *mod = NULL; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 651 | |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 652 | mod = ly_ctx_get_module_implemented(lydctx->jsonctx->ctx, meta->name.prefix); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 653 | if (mod) { |
Michal Vasko | 22df3f0 | 2020-08-24 13:29:22 +0200 | [diff] [blame] | 654 | ret = lyd_parser_create_meta((struct lyd_ctx *)lydctx, node, NULL, mod, |
Michal Vasko | ad92b67 | 2020-11-12 13:11:31 +0100 | [diff] [blame] | 655 | meta->name.name, strlen(meta->name.name), meta->value, ly_strlen(meta->value), |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 656 | NULL, LY_VALUE_JSON, NULL, meta->hints, node->schema); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 657 | LY_CHECK_GOTO(ret, cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 658 | } else if (lydctx->parse_opts & LYD_PARSE_STRICT) { |
Michal Vasko | 4eab562 | 2021-07-22 15:36:45 +0200 | [diff] [blame] | 659 | if (meta->name.prefix) { |
| 660 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, |
| 661 | "Unknown (or not implemented) YANG module \"%s\" of metadata \"%s%s%s\".", |
| 662 | meta->name.prefix, meta->name.prefix, ly_strlen(meta->name.prefix) ? ":" : "", |
| 663 | meta->name.name); |
| 664 | } else { |
| 665 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Missing YANG module of metadata \"%s\".", |
| 666 | meta->name.name); |
| 667 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 668 | ret = LY_EVALID; |
| 669 | goto cleanup; |
| 670 | } |
| 671 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 672 | |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 673 | /* add/correct flags */ |
| 674 | ret = lyd_parse_set_data_flags(node, &node->meta, (struct lyd_ctx *)lydctx, ext); |
| 675 | LY_CHECK_GOTO(ret, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 676 | break; |
| 677 | } |
| 678 | } |
| 679 | |
| 680 | if (match != instance) { |
| 681 | /* there is no corresponding data node for the metadata */ |
| 682 | if (instance > 1) { |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 683 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, |
| 684 | "Missing JSON data instance #%" PRIu64 " to be coupled with %s metadata.", |
Michal Vasko | 54ba891 | 2021-07-23 12:46:23 +0200 | [diff] [blame] | 685 | instance, meta_container->name.name); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 686 | } else { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 687 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Missing JSON data instance to be coupled with %s metadata.", |
| 688 | meta_container->name.name); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 689 | } |
| 690 | ret = LY_EVALID; |
| 691 | } else { |
| 692 | /* remove the opaq attr */ |
| 693 | if (attr == (*first_p)) { |
aPiecek | 5057c2e | 2021-05-17 10:28:03 +0200 | [diff] [blame] | 694 | *first_p = attr->next; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 695 | } |
| 696 | lyd_free_tree(attr); |
| 697 | } |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 698 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 699 | LOG_LOCBACK(0, log_location_items, 0, 0); |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 700 | log_location_items = 0; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 701 | } |
| 702 | |
| 703 | cleanup: |
| 704 | lydict_remove(lydctx->jsonctx->ctx, prev); |
| 705 | |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 706 | LOG_LOCBACK(0, log_location_items, 0, 0); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 707 | return ret; |
| 708 | } |
| 709 | |
| 710 | /** |
| 711 | * @brief Parse a metadata member. |
| 712 | * |
| 713 | * @param[in] lydctx JSON data parser context. |
| 714 | * @param[in] snode Schema node of the metadata parent. |
| 715 | * @param[in] node Parent node in case the metadata is not forward-referencing (only LYD_NODE_TERM) |
| 716 | * so the data node does not exists. In such a case the metadata is stored in the context for the later |
| 717 | * processing by lydjson_metadata_finish(). |
| 718 | * @return LY_SUCCESS on success |
| 719 | * @return Various LY_ERR values in case of failure. |
| 720 | */ |
| 721 | static LY_ERR |
| 722 | lydjson_metadata(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, struct lyd_node *node) |
| 723 | { |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 724 | LY_ERR rc = LY_SUCCESS; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 725 | enum LYJSON_PARSER_STATUS status; |
| 726 | const char *expected; |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 727 | ly_bool in_parent = 0; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 728 | const char *name, *prefix = NULL; |
aPiecek | 303fb25 | 2021-06-16 11:54:26 +0200 | [diff] [blame] | 729 | char *dynamic_prefname = NULL; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 730 | size_t name_len, prefix_len = 0; |
| 731 | struct lys_module *mod; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 732 | const struct ly_ctx *ctx = lydctx->jsonctx->ctx; |
Radek Krejci | 857189e | 2020-09-01 13:26:36 +0200 | [diff] [blame] | 733 | ly_bool is_attr = 0; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 734 | struct lyd_node *prev = node; |
Michal Vasko | 09d13b3 | 2022-12-01 13:49:50 +0100 | [diff] [blame] | 735 | uint32_t instance = 0, val_hints; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 736 | uint16_t nodetype; |
| 737 | |
| 738 | assert(snode || node); |
| 739 | |
| 740 | nodetype = snode ? snode->nodetype : LYS_CONTAINER; |
Michal Vasko | 66c1631 | 2022-12-01 10:37:43 +0100 | [diff] [blame] | 741 | LOG_LOCSET(snode, NULL, NULL, NULL); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 742 | |
| 743 | /* move to the second item in the name/X pair */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 744 | LY_CHECK_GOTO(rc = lyjson_ctx_next(lydctx->jsonctx, &status), cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 745 | |
| 746 | /* check attribute encoding */ |
| 747 | switch (nodetype) { |
| 748 | case LYS_LEAFLIST: |
| 749 | expected = "@name/array of objects/nulls"; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 750 | LY_CHECK_GOTO(status != LYJSON_ARRAY, representation_error); |
| 751 | |
| 752 | next_entry: |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 753 | if (status == LYJSON_ARRAY_CLOSED) { |
Michal Vasko | 57c8d43 | 2022-11-30 15:35:56 +0100 | [diff] [blame] | 754 | /* no more metadata */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 755 | goto cleanup; |
| 756 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 757 | |
| 758 | /* move into the array/next item */ |
| 759 | LY_CHECK_GOTO(rc = lyjson_ctx_next(lydctx->jsonctx, &status), cleanup); |
| 760 | instance++; |
Michal Vasko | 57c8d43 | 2022-11-30 15:35:56 +0100 | [diff] [blame] | 761 | LY_CHECK_GOTO((status != LYJSON_OBJECT) && (status != LYJSON_NULL), representation_error); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 762 | |
Michal Vasko | 6973015 | 2020-10-09 16:30:07 +0200 | [diff] [blame] | 763 | if (!node || (node->schema != prev->schema)) { |
Michal Vasko | 54ba891 | 2021-07-23 12:46:23 +0200 | [diff] [blame] | 764 | LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Missing JSON data instance #%u of %s:%s to be coupled with metadata.", |
Michal Vasko | 6973015 | 2020-10-09 16:30:07 +0200 | [diff] [blame] | 765 | instance, prev->schema->module->name, prev->schema->name); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 766 | rc = LY_EVALID; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 767 | goto cleanup; |
| 768 | } |
| 769 | |
| 770 | if (status == LYJSON_NULL) { |
| 771 | /* continue with the next entry in the leaf-list array */ |
| 772 | prev = node; |
| 773 | node = node->next; |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 774 | |
| 775 | LY_CHECK_GOTO(rc = lyjson_ctx_next(lydctx->jsonctx, &status), cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 776 | goto next_entry; |
| 777 | } |
| 778 | break; |
| 779 | case LYS_LEAF: |
| 780 | case LYS_ANYXML: |
| 781 | expected = "@name/object"; |
| 782 | |
aPiecek | 5b115fc | 2021-05-24 14:32:42 +0200 | [diff] [blame] | 783 | LY_CHECK_GOTO(status != LYJSON_OBJECT, representation_error); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 784 | break; |
| 785 | case LYS_CONTAINER: |
| 786 | case LYS_LIST: |
| 787 | case LYS_ANYDATA: |
| 788 | case LYS_NOTIF: |
| 789 | case LYS_ACTION: |
| 790 | case LYS_RPC: |
| 791 | in_parent = 1; |
| 792 | expected = "@/object"; |
| 793 | LY_CHECK_GOTO(status != LYJSON_OBJECT, representation_error); |
| 794 | break; |
Radek Krejci | 8f5fad2 | 2020-09-15 16:50:54 +0200 | [diff] [blame] | 795 | default: |
Michal Vasko | 66c1631 | 2022-12-01 10:37:43 +0100 | [diff] [blame] | 796 | LOGINT(ctx); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 797 | rc = LY_EINT; |
Michal Vasko | 66c1631 | 2022-12-01 10:37:43 +0100 | [diff] [blame] | 798 | goto cleanup; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 799 | } |
| 800 | |
| 801 | /* process all the members inside a single metadata object */ |
| 802 | assert(status == LYJSON_OBJECT); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 803 | do { |
| 804 | LY_CHECK_GOTO(rc = lyjson_ctx_next(lydctx->jsonctx, &status), cleanup); |
Michal Vasko | 5a71327 | 2023-03-27 09:01:43 +0200 | [diff] [blame] | 805 | LY_CHECK_GOTO(status != LYJSON_OBJECT_NAME, representation_error); |
| 806 | |
aPiecek | d2c3937 | 2021-06-16 14:03:12 +0200 | [diff] [blame] | 807 | lydjson_parse_name(lydctx->jsonctx->value, lydctx->jsonctx->value_len, &name, &name_len, &prefix, &prefix_len, &is_attr); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 808 | lyjson_ctx_give_dynamic_value(lydctx->jsonctx, &dynamic_prefname); |
aPiecek | 303fb25 | 2021-06-16 11:54:26 +0200 | [diff] [blame] | 809 | |
Michal Vasko | 69d0ca1 | 2021-07-23 10:22:03 +0200 | [diff] [blame] | 810 | if (!name_len) { |
| 811 | LOGVAL(ctx, LYVE_SYNTAX_JSON, "Metadata in JSON found with an empty name, followed by: %.10s", name); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 812 | rc = LY_EVALID; |
Michal Vasko | 69d0ca1 | 2021-07-23 10:22:03 +0200 | [diff] [blame] | 813 | goto cleanup; |
| 814 | } else if (!prefix_len) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 815 | LOGVAL(ctx, LYVE_SYNTAX_JSON, "Metadata in JSON must be namespace-qualified, missing prefix for \"%.*s\".", |
Radek Krejci | 422afb1 | 2021-03-04 16:38:16 +0100 | [diff] [blame] | 816 | (int)lydctx->jsonctx->value_len, lydctx->jsonctx->value); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 817 | rc = LY_EVALID; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 818 | goto cleanup; |
| 819 | } else if (is_attr) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 820 | LOGVAL(ctx, LYVE_SYNTAX_JSON, "Invalid format of the Metadata identifier in JSON, unexpected '@' in \"%.*s\"", |
Radek Krejci | 422afb1 | 2021-03-04 16:38:16 +0100 | [diff] [blame] | 821 | (int)lydctx->jsonctx->value_len, lydctx->jsonctx->value); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 822 | rc = LY_EVALID; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 823 | goto cleanup; |
| 824 | } |
| 825 | |
| 826 | /* get the element module */ |
| 827 | mod = ly_ctx_get_module_implemented2(ctx, prefix, prefix_len); |
| 828 | if (!mod) { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 829 | if (lydctx->parse_opts & LYD_PARSE_STRICT) { |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 830 | LOGVAL(ctx, LYVE_REFERENCE, "Prefix \"%.*s\" of the metadata \"%.*s\" does not match any module in the context.", |
Radek Krejci | 422afb1 | 2021-03-04 16:38:16 +0100 | [diff] [blame] | 831 | (int)prefix_len, prefix, (int)name_len, name); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 832 | rc = LY_EVALID; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 833 | goto cleanup; |
| 834 | } |
Michal Vasko | a556f16 | 2022-01-17 14:08:30 +0100 | [diff] [blame] | 835 | if (node->schema) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 836 | /* skip element with children */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 837 | LY_CHECK_GOTO(rc = lydjson_data_skip(lydctx->jsonctx), cleanup); |
| 838 | status = lyjson_ctx_status(lydctx->jsonctx); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 839 | /* end of the item */ |
| 840 | continue; |
| 841 | } |
Michal Vasko | a556f16 | 2022-01-17 14:08:30 +0100 | [diff] [blame] | 842 | assert(lydctx->parse_opts & LYD_PARSE_OPAQ); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 843 | } |
| 844 | |
| 845 | /* get the value */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 846 | LY_CHECK_GOTO(rc = lyjson_ctx_next(lydctx->jsonctx, &status), cleanup); |
Michal Vasko | 09d13b3 | 2022-12-01 13:49:50 +0100 | [diff] [blame] | 847 | |
| 848 | /* get value hints */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 849 | LY_CHECK_GOTO(rc = lydjson_value_type_hint(lydctx, &status, &val_hints), cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 850 | |
| 851 | if (node->schema) { |
| 852 | /* create metadata */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 853 | rc = lyd_parser_create_meta((struct lyd_ctx *)lydctx, node, NULL, mod, name, name_len, lydctx->jsonctx->value, |
Michal Vasko | 09d13b3 | 2022-12-01 13:49:50 +0100 | [diff] [blame] | 854 | lydctx->jsonctx->value_len, &lydctx->jsonctx->dynamic, LY_VALUE_JSON, NULL, val_hints, node->schema); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 855 | LY_CHECK_GOTO(rc, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 856 | |
| 857 | /* add/correct flags */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 858 | rc = lyd_parse_set_data_flags(node, &node->meta, (struct lyd_ctx *)lydctx, NULL); |
| 859 | LY_CHECK_GOTO(rc, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 860 | } else { |
| 861 | /* create attribute */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 862 | const char *module_name; |
| 863 | size_t module_name_len; |
| 864 | |
| 865 | lydjson_get_node_prefix(node, prefix, prefix_len, &module_name, &module_name_len); |
| 866 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 867 | /* attr2 is always changed to the created attribute */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 868 | rc = lyd_create_attr(node, NULL, lydctx->jsonctx->ctx, name, name_len, prefix, prefix_len, module_name, |
Michal Vasko | 501af03 | 2020-11-11 20:27:44 +0100 | [diff] [blame] | 869 | module_name_len, lydctx->jsonctx->value, lydctx->jsonctx->value_len, &lydctx->jsonctx->dynamic, |
Michal Vasko | 09d13b3 | 2022-12-01 13:49:50 +0100 | [diff] [blame] | 870 | LY_VALUE_JSON, NULL, val_hints); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 871 | LY_CHECK_GOTO(rc, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 872 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 873 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 874 | /* next member */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 875 | LY_CHECK_GOTO(rc = lyjson_ctx_next(lydctx->jsonctx, &status), cleanup); |
| 876 | } while (status == LYJSON_OBJECT_NEXT); |
| 877 | LY_CHECK_GOTO(status != LYJSON_OBJECT_CLOSED, representation_error); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 878 | |
| 879 | if (nodetype == LYS_LEAFLIST) { |
| 880 | /* continue by processing another metadata object for the following |
Michal Vasko | b404355 | 2022-12-01 10:11:55 +0100 | [diff] [blame] | 881 | * leaf-list instance since they are always instantiated in JSON array */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 882 | prev = node; |
| 883 | node = node->next; |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 884 | |
| 885 | LY_CHECK_GOTO(rc = lyjson_ctx_next(lydctx->jsonctx, &status), cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 886 | goto next_entry; |
| 887 | } |
| 888 | |
Radek Krejci | 5813c36 | 2021-01-05 10:51:57 +0100 | [diff] [blame] | 889 | /* success */ |
| 890 | goto cleanup; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 891 | |
| 892 | representation_error: |
Radek Krejci | 2efc45b | 2020-12-22 16:25:44 +0100 | [diff] [blame] | 893 | LOGVAL(ctx, LYVE_SYNTAX_JSON, |
Michal Vasko | 6973015 | 2020-10-09 16:30:07 +0200 | [diff] [blame] | 894 | "The attribute(s) of %s \"%s\" is expected to be represented as JSON %s, but input data contains @%s/%s.", |
Michal Vasko | 5722c1b | 2022-01-24 07:47:49 +0100 | [diff] [blame] | 895 | lys_nodetype2str(nodetype), node ? LYD_NAME(node) : LYD_NAME(prev), expected, lyjson_token2str(status), |
| 896 | in_parent ? "" : "name"); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 897 | rc = LY_EVALID; |
Radek Krejci | 5813c36 | 2021-01-05 10:51:57 +0100 | [diff] [blame] | 898 | |
| 899 | cleanup: |
aPiecek | 303fb25 | 2021-06-16 11:54:26 +0200 | [diff] [blame] | 900 | free(dynamic_prefname); |
Radek Krejci | ddace2c | 2021-01-08 11:30:56 +0100 | [diff] [blame] | 901 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 902 | return rc; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 903 | } |
| 904 | |
| 905 | /** |
Michal Vasko | 6ee6f43 | 2021-07-16 09:49:14 +0200 | [diff] [blame] | 906 | * @brief Eat the node pointed by @p node_p by inserting it into @p parent and maintain the @p first_p pointing |
| 907 | * to the first child node. |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 908 | * |
| 909 | * @param[in] parent Parent node to insert to, can be NULL in case of top-level (or provided first_p). |
Michal Vasko | 6ee6f43 | 2021-07-16 09:49:14 +0200 | [diff] [blame] | 910 | * @param[in,out] first_p Pointer to the first sibling node in case of top-level. |
| 911 | * @param[in,out] node_p pointer to the new node to insert, after the insert is done, pointer is set to NULL. |
| 912 | * @param[in] last If set, always insert at the end. |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 913 | * @param[in] ext Extension instance of @p node_p, if any. |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 914 | */ |
| 915 | static void |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 916 | lydjson_maintain_children(struct lyd_node *parent, struct lyd_node **first_p, struct lyd_node **node_p, ly_bool last, |
| 917 | struct lysc_ext_instance *ext) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 918 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 919 | if (!*node_p) { |
| 920 | return; |
| 921 | } |
| 922 | |
| 923 | /* insert, keep first pointer correct */ |
| 924 | if (ext) { |
| 925 | lyplg_ext_insert(parent, *node_p); |
| 926 | } else { |
| 927 | lyd_insert_node(parent, first_p, *node_p, last); |
| 928 | } |
| 929 | if (first_p) { |
| 930 | if (parent) { |
| 931 | *first_p = lyd_child(parent); |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 932 | } else { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 933 | while ((*first_p)->prev->next) { |
| 934 | *first_p = (*first_p)->prev; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 935 | } |
| 936 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 937 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 938 | *node_p = NULL; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 939 | } |
| 940 | |
aPiecek | 4bf4721 | 2021-05-27 10:55:47 +0200 | [diff] [blame] | 941 | /** |
| 942 | * @brief Wrapper for ::lyd_create_opaq(). |
| 943 | * |
| 944 | * @param[in] lydctx JSON data parser context. |
| 945 | * @param[in] name Name of the opaq node to create. |
| 946 | * @param[in] name_len Length of the @p name string. |
| 947 | * @param[in] prefix Prefix of the opaq node to create. |
| 948 | * @param[in] prefix_len Length of the @p prefx string. |
Michal Vasko | 80623c5 | 2023-04-28 14:22:06 +0200 | [diff] [blame] | 949 | * @param[in] parent Data parent of the opaq node, to inherit module name from. |
aPiecek | 4bf4721 | 2021-05-27 10:55:47 +0200 | [diff] [blame] | 950 | * @param[in,out] status_inner_p In case of processing JSON array, this parameter points to a standalone |
| 951 | * context status of the array content. Otherwise, it is supposed to be the same as @p status_p. |
| 952 | * @param[out] node_p Pointer to the created opaq node. |
| 953 | * @return LY_ERR value. |
| 954 | */ |
| 955 | static LY_ERR |
| 956 | lydjson_create_opaq(struct lyd_json_ctx *lydctx, const char *name, size_t name_len, const char *prefix, size_t prefix_len, |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 957 | struct lyd_node *parent, enum LYJSON_PARSER_STATUS *status_inner_p, struct lyd_node **node_p) |
aPiecek | 4bf4721 | 2021-05-27 10:55:47 +0200 | [diff] [blame] | 958 | { |
| 959 | LY_ERR ret = LY_SUCCESS; |
| 960 | const char *value = NULL, *module_name; |
| 961 | size_t value_len = 0, module_name_len = 0; |
| 962 | ly_bool dynamic = 0; |
| 963 | uint32_t type_hint = 0; |
| 964 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 965 | if (*status_inner_p != LYJSON_OBJECT) { |
aPiecek | 4bf4721 | 2021-05-27 10:55:47 +0200 | [diff] [blame] | 966 | /* prepare for creating opaq node with a value */ |
| 967 | value = lydctx->jsonctx->value; |
| 968 | value_len = lydctx->jsonctx->value_len; |
| 969 | dynamic = lydctx->jsonctx->dynamic; |
| 970 | lydctx->jsonctx->dynamic = 0; |
| 971 | |
| 972 | LY_CHECK_RET(lydjson_value_type_hint(lydctx, status_inner_p, &type_hint)); |
| 973 | } |
| 974 | |
Michal Vasko | 80623c5 | 2023-04-28 14:22:06 +0200 | [diff] [blame] | 975 | /* get the module name */ |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 976 | lydjson_get_node_prefix(parent, prefix, prefix_len, &module_name, &module_name_len); |
Michal Vasko | 80623c5 | 2023-04-28 14:22:06 +0200 | [diff] [blame] | 977 | if (!module_name && !parent && lydctx->any_schema) { |
| 978 | /* in an anyxml/anydata tree, parsing first node, use the previous any schema node */ |
| 979 | module_name = lydctx->any_schema->module->name; |
| 980 | module_name_len = strlen(module_name); |
| 981 | } |
| 982 | |
| 983 | /* create node */ |
aPiecek | 4bf4721 | 2021-05-27 10:55:47 +0200 | [diff] [blame] | 984 | ret = lyd_create_opaq(lydctx->jsonctx->ctx, name, name_len, prefix, prefix_len, module_name, module_name_len, value, |
| 985 | value_len, &dynamic, LY_VALUE_JSON, NULL, type_hint, node_p); |
| 986 | if (dynamic) { |
| 987 | free((char *)value); |
| 988 | } |
| 989 | |
| 990 | return ret; |
| 991 | } |
| 992 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 993 | static LY_ERR lydjson_subtree_r(struct lyd_json_ctx *lydctx, struct lyd_node *parent, struct lyd_node **first_p, |
| 994 | struct ly_set *parsed); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 995 | |
| 996 | /** |
| 997 | * @brief Parse opaq node from the input. |
| 998 | * |
| 999 | * In case of processing array, the whole array is being processed and the resulting @p node_p is the last item of the array. |
| 1000 | * |
| 1001 | * @param[in] lydctx JSON data parser context. |
| 1002 | * @param[in] name Name of the opaq node to create. |
| 1003 | * @param[in] name_len Length of the @p name string. |
| 1004 | * @param[in] prefix Prefix of the opaq node to create. |
| 1005 | * @param[in] prefix_len Length of the @p prefx string. |
| 1006 | * @param[in] parent Data parent of the opaq node to create, can be NULL in case of top level, |
| 1007 | * but must be set if @p first is not. |
| 1008 | * @param[in,out] status_p Pointer to the current status of the parser context, |
| 1009 | * since the function manipulates with the context and process the input, the status can be updated. |
| 1010 | * @param[in,out] status_inner_p In case of processing JSON array, this parameter points to a standalone |
| 1011 | * context status of the array content. Otherwise, it is supposed to be the same as @p status_p. |
| 1012 | * @param[in,out] first_p First top-level/parent sibling, must be set if @p parent is not. |
| 1013 | * @param[out] node_p Pointer to the created opaq node. |
| 1014 | * @return LY_ERR value. |
| 1015 | */ |
| 1016 | static LY_ERR |
Michal Vasko | a5da329 | 2020-08-12 13:10:50 +0200 | [diff] [blame] | 1017 | lydjson_parse_opaq(struct lyd_json_ctx *lydctx, const char *name, size_t name_len, const char *prefix, size_t prefix_len, |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1018 | struct lyd_node *parent, enum LYJSON_PARSER_STATUS *status_p, enum LYJSON_PARSER_STATUS *status_inner_p, |
| 1019 | struct lyd_node **first_p, struct lyd_node **node_p) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1020 | { |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1021 | LY_CHECK_RET(lydjson_create_opaq(lydctx, name, name_len, prefix, prefix_len, parent, status_inner_p, node_p)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1022 | |
Michal Vasko | 1a85d33 | 2021-08-27 10:35:28 +0200 | [diff] [blame] | 1023 | if ((*status_p == LYJSON_ARRAY) && (*status_inner_p == LYJSON_NULL)) { |
| 1024 | /* special array null value */ |
| 1025 | ((struct lyd_node_opaq *)*node_p)->hints |= LYD_VALHINT_EMPTY; |
| 1026 | |
| 1027 | /* must be the only item */ |
| 1028 | LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, status_inner_p)); |
| 1029 | if (*status_inner_p != LYJSON_ARRAY_CLOSED) { |
| 1030 | LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX, "Array \"null\" member with another member."); |
| 1031 | return LY_EVALID; |
| 1032 | } |
| 1033 | |
| 1034 | goto finish; |
| 1035 | } |
| 1036 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1037 | while (*status_p == LYJSON_ARRAY) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1038 | /* process another instance of the same node */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1039 | if (*status_inner_p == LYJSON_OBJECT) { |
Michal Vasko | 1a85d33 | 2021-08-27 10:35:28 +0200 | [diff] [blame] | 1040 | /* array with objects, list */ |
| 1041 | ((struct lyd_node_opaq *)*node_p)->hints |= LYD_NODEHINT_LIST; |
| 1042 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1043 | /* but first process children of the object in the array */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1044 | do { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1045 | LY_CHECK_RET(lydjson_subtree_r(lydctx, *node_p, lyd_node_child_p(*node_p), NULL)); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1046 | *status_inner_p = lyjson_ctx_status(lydctx->jsonctx); |
| 1047 | } while (*status_inner_p == LYJSON_OBJECT_NEXT); |
Michal Vasko | 1a85d33 | 2021-08-27 10:35:28 +0200 | [diff] [blame] | 1048 | } else { |
| 1049 | /* array with values, leaf-list */ |
| 1050 | ((struct lyd_node_opaq *)*node_p)->hints |= LYD_NODEHINT_LEAFLIST; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1051 | } |
| 1052 | |
| 1053 | LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, status_inner_p)); |
aPiecek | dbb8baf | 2021-05-27 11:01:51 +0200 | [diff] [blame] | 1054 | if (*status_inner_p == LYJSON_ARRAY_CLOSED) { |
| 1055 | goto finish; |
| 1056 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1057 | assert(*status_inner_p == LYJSON_ARRAY_NEXT); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1058 | |
| 1059 | /* continue with the next instance */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1060 | LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, status_inner_p)); |
aPiecek | dbb8baf | 2021-05-27 11:01:51 +0200 | [diff] [blame] | 1061 | assert(node_p); |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1062 | lydjson_maintain_children(parent, first_p, node_p, lydctx->parse_opts & LYD_PARSE_ORDERED ? 1 : 0, NULL); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1063 | LY_CHECK_RET(lydjson_create_opaq(lydctx, name, name_len, prefix, prefix_len, parent, status_inner_p, node_p)); |
aPiecek | dbb8baf | 2021-05-27 11:01:51 +0200 | [diff] [blame] | 1064 | } |
| 1065 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1066 | if (*status_p == LYJSON_OBJECT) { |
aPiecek | dbb8baf | 2021-05-27 11:01:51 +0200 | [diff] [blame] | 1067 | /* process children */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1068 | do { |
aPiecek | dbb8baf | 2021-05-27 11:01:51 +0200 | [diff] [blame] | 1069 | LY_CHECK_RET(lydjson_subtree_r(lydctx, *node_p, lyd_node_child_p(*node_p), NULL)); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1070 | *status_p = lyjson_ctx_status(lydctx->jsonctx); |
| 1071 | } while (*status_p == LYJSON_OBJECT_NEXT); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1072 | } |
| 1073 | |
aPiecek | dbb8baf | 2021-05-27 11:01:51 +0200 | [diff] [blame] | 1074 | finish: |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1075 | /* finish linking metadata */ |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1076 | return lydjson_metadata_finish(lydctx, lyd_node_child_p(*node_p)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1077 | } |
| 1078 | |
| 1079 | /** |
aPiecek | 6cee5d0 | 2021-05-12 10:32:00 +0200 | [diff] [blame] | 1080 | * @brief Move to the second item in the name/X pair and parse opaq node from the input. |
| 1081 | * |
| 1082 | * This function is basically the wrapper of the ::lydjson_parse_opaq(). |
| 1083 | * In addition, it calls the ::json_ctx_next() and prepares the status_inner_p parameter |
| 1084 | * for ::lydjson_parse_opaq(). |
| 1085 | * |
| 1086 | * @param[in] lydctx JSON data parser context. |
| 1087 | * @param[in] name Name of the opaq node to create. |
| 1088 | * @param[in] name_len Length of the @p name string. |
| 1089 | * @param[in] prefix Prefix of the opaq node to create. |
| 1090 | * @param[in] prefix_len Length of the @p prefx string. |
| 1091 | * @param[in] parent Data parent of the opaq node to create, can be NULL in case of top level, |
| 1092 | * but must be set if @p first is not. |
| 1093 | * @param[in,out] status_p Pointer to the current status of the parser context, |
| 1094 | * since the function manipulates with the context and process the input, the status can be updated. |
| 1095 | * @param[in,out] first_p First top-level/parent sibling, must be set if @p parent is not. |
| 1096 | * @param[out] node_p Pointer to the created opaq node. |
| 1097 | * @return LY_ERR value. |
| 1098 | */ |
| 1099 | static LY_ERR |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1100 | lydjson_ctx_next_parse_opaq(struct lyd_json_ctx *lydctx, const char *name, size_t name_len, const char *prefix, |
| 1101 | size_t prefix_len, struct lyd_node *parent, enum LYJSON_PARSER_STATUS *status_p, |
aPiecek | 6cee5d0 | 2021-05-12 10:32:00 +0200 | [diff] [blame] | 1102 | struct lyd_node **first_p, struct lyd_node **node_p) |
| 1103 | { |
| 1104 | enum LYJSON_PARSER_STATUS status_inner = 0; |
| 1105 | |
| 1106 | /* move to the second item in the name/X pair */ |
| 1107 | LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, status_p)); |
| 1108 | |
| 1109 | if (*status_p == LYJSON_ARRAY) { |
| 1110 | /* move into the array */ |
| 1111 | LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, &status_inner)); |
| 1112 | } else { |
| 1113 | /* just a flag to pass correct parameters into lydjson_parse_opaq() */ |
| 1114 | status_inner = LYJSON_ERROR; |
| 1115 | } |
| 1116 | |
| 1117 | if (status_inner == LYJSON_ERROR) { |
| 1118 | status_inner = *status_p; |
| 1119 | } |
| 1120 | |
| 1121 | /* parse opaq node from the input */ |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1122 | LY_CHECK_RET(lydjson_parse_opaq(lydctx, name, name_len, prefix, prefix_len, parent, status_p, &status_inner, |
| 1123 | first_p, node_p)); |
aPiecek | 6cee5d0 | 2021-05-12 10:32:00 +0200 | [diff] [blame] | 1124 | |
| 1125 | return LY_SUCCESS; |
| 1126 | } |
| 1127 | |
| 1128 | /** |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1129 | * @brief Process the attribute container (starting by @) |
| 1130 | * |
| 1131 | * @param[in] lydctx JSON data parser context. |
| 1132 | * @param[in] attr_node The data node referenced by the attribute container, if already known. |
| 1133 | * @param[in] snode The schema node of the data node referenced by the attribute container, if known. |
| 1134 | * @param[in] name Name of the opaq node to create. |
| 1135 | * @param[in] name_len Length of the @p name string. |
| 1136 | * @param[in] prefix Prefix of the opaq node to create. |
| 1137 | * @param[in] prefix_len Length of the @p prefx string. |
| 1138 | * @param[in] parent Data parent of the opaq node to create, can be NULL in case of top level, |
| 1139 | * but must be set if @p first is not. |
| 1140 | * @param[in,out] status_p Pointer to the current status of the parser context, |
| 1141 | * since the function manipulates with the context and process the input, the status can be updated. |
| 1142 | * @param[in,out] first_p First top-level/parent sibling, must be set if @p parent is not. |
| 1143 | * @param[out] node_p Pointer to the created opaq node. |
| 1144 | * @return LY_ERR value. |
| 1145 | */ |
| 1146 | static LY_ERR |
| 1147 | lydjson_parse_attribute(struct lyd_json_ctx *lydctx, struct lyd_node *attr_node, const struct lysc_node *snode, |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1148 | const char *name, size_t name_len, const char *prefix, size_t prefix_len, struct lyd_node *parent, |
| 1149 | enum LYJSON_PARSER_STATUS *status_p, struct lyd_node **first_p, struct lyd_node **node_p) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1150 | { |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1151 | LY_ERR r; |
Michal Vasko | dcad5c8 | 2022-12-01 16:16:58 +0100 | [diff] [blame] | 1152 | const char *opaq_name, *mod_name; |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1153 | size_t opaq_name_len; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1154 | |
Michal Vasko | fceac69 | 2022-12-01 13:50:27 +0100 | [diff] [blame] | 1155 | if (!snode && !prefix) { |
| 1156 | /* set the prefix */ |
| 1157 | if (parent) { |
| 1158 | lydjson_get_node_prefix(parent, NULL, 0, &prefix, &prefix_len); |
| 1159 | } else { |
| 1160 | prefix = ""; |
| 1161 | prefix_len = 0; |
| 1162 | } |
| 1163 | } |
| 1164 | |
| 1165 | /* parse as an attribute to a (opaque) node */ |
| 1166 | if (!attr_node) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1167 | /* try to find the instance */ |
Michal Vasko | fceac69 | 2022-12-01 13:50:27 +0100 | [diff] [blame] | 1168 | LY_LIST_FOR(*first_p, attr_node) { |
| 1169 | if (snode) { |
| 1170 | if (attr_node->schema) { |
| 1171 | if (attr_node->schema == snode) { |
| 1172 | break; |
| 1173 | } |
| 1174 | } else { |
Michal Vasko | dcad5c8 | 2022-12-01 16:16:58 +0100 | [diff] [blame] | 1175 | mod_name = ((struct lyd_node_opaq *)attr_node)->name.module_name; |
| 1176 | if (!strcmp(LYD_NAME(attr_node), snode->name) && mod_name && !strcmp(mod_name, snode->module->name)) { |
Michal Vasko | fceac69 | 2022-12-01 13:50:27 +0100 | [diff] [blame] | 1177 | break; |
| 1178 | } |
| 1179 | } |
| 1180 | } else { |
| 1181 | if (attr_node->schema) { |
| 1182 | if (!ly_strncmp(LYD_NAME(attr_node), name, name_len) && |
| 1183 | !ly_strncmp(attr_node->schema->module->name, prefix, prefix_len)) { |
| 1184 | break; |
| 1185 | } |
| 1186 | } else { |
Michal Vasko | dcad5c8 | 2022-12-01 16:16:58 +0100 | [diff] [blame] | 1187 | mod_name = ((struct lyd_node_opaq *)attr_node)->name.module_name; |
| 1188 | if (!ly_strncmp(LYD_NAME(attr_node), name, name_len) && mod_name && |
| 1189 | !ly_strncmp(mod_name, prefix, prefix_len)) { |
Michal Vasko | fceac69 | 2022-12-01 13:50:27 +0100 | [diff] [blame] | 1190 | break; |
| 1191 | } |
| 1192 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1193 | } |
| 1194 | } |
| 1195 | } |
| 1196 | if (!attr_node) { |
| 1197 | /* parse just as an opaq node with the name beginning with @, |
| 1198 | * later we have to check that it belongs to a standard node |
| 1199 | * and it is supposed to be converted to a metadata */ |
| 1200 | uint32_t prev_opts; |
| 1201 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1202 | /* backup parser options to parse unknown metadata as opaq nodes and try to resolve them later */ |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1203 | prev_opts = lydctx->parse_opts; |
| 1204 | lydctx->parse_opts &= ~LYD_PARSE_STRICT; |
| 1205 | lydctx->parse_opts |= LYD_PARSE_OPAQ; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1206 | |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1207 | opaq_name = prefix ? prefix - 1 : name - 1; |
| 1208 | opaq_name_len = prefix ? prefix_len + name_len + 2 : name_len + 1; |
| 1209 | r = lydjson_ctx_next_parse_opaq(lydctx, opaq_name, opaq_name_len, NULL, 0, parent, status_p, first_p, node_p); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1210 | |
| 1211 | /* restore the parser options */ |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1212 | lydctx->parse_opts = prev_opts; |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1213 | LY_CHECK_RET(r); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1214 | } else { |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1215 | LY_CHECK_RET(lydjson_metadata(lydctx, snode, attr_node)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1216 | } |
| 1217 | |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1218 | return LY_SUCCESS; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1219 | } |
| 1220 | |
| 1221 | /** |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1222 | * @brief Parse a single anydata/anyxml node. |
| 1223 | * |
| 1224 | * @param[in] lydctx JSON data parser context. When the function returns, the context is in the same state |
| 1225 | * as before calling, despite it is necessary to process input data for checking. |
| 1226 | * @param[in] snode Schema node corresponding to the member currently being processed in the context. |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1227 | * @param[in] ext Extension instance of @p snode, if any. |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1228 | * @param[in,out] status JSON parser status, is updated. |
| 1229 | * @param[out] node Parsed data (or opaque) node. |
| 1230 | * @return LY_SUCCESS if a node was successfully parsed, |
| 1231 | * @return LY_ENOT in case of invalid JSON encoding, |
| 1232 | * @return LY_ERR on other errors. |
| 1233 | */ |
| 1234 | static LY_ERR |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1235 | lydjson_parse_any(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, struct lysc_ext_instance *ext, |
| 1236 | enum LYJSON_PARSER_STATUS *status, struct lyd_node **node) |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1237 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1238 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1239 | uint32_t prev_parse_opts, prev_int_opts; |
| 1240 | struct ly_in in_start; |
Michal Vasko | 7ca3325 | 2022-12-21 09:30:32 +0100 | [diff] [blame] | 1241 | char *val = NULL; |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1242 | const char *end; |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1243 | struct lyd_node *tree = NULL; |
| 1244 | |
| 1245 | assert(snode->nodetype & LYD_NODE_ANY); |
| 1246 | |
| 1247 | /* status check according to allowed JSON types */ |
| 1248 | if (snode->nodetype == LYS_ANYXML) { |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1249 | LY_CHECK_RET((*status != LYJSON_OBJECT) && (*status != LYJSON_ARRAY) && (*status != LYJSON_NUMBER) && |
| 1250 | (*status != LYJSON_STRING) && (*status != LYJSON_FALSE) && (*status != LYJSON_TRUE) && |
| 1251 | (*status != LYJSON_NULL), LY_ENOT); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1252 | } else { |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1253 | LY_CHECK_RET(*status != LYJSON_OBJECT, LY_ENOT); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1254 | } |
| 1255 | |
| 1256 | /* create any node */ |
| 1257 | switch (*status) { |
| 1258 | case LYJSON_OBJECT: |
| 1259 | /* parse any data tree with correct options, first backup the current options and then make the parser |
| 1260 | * process data as opaq nodes */ |
| 1261 | prev_parse_opts = lydctx->parse_opts; |
| 1262 | lydctx->parse_opts &= ~LYD_PARSE_STRICT; |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1263 | lydctx->parse_opts |= LYD_PARSE_OPAQ | (ext ? LYD_PARSE_ONLY : 0); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1264 | prev_int_opts = lydctx->int_opts; |
| 1265 | lydctx->int_opts |= LYD_INTOPT_ANY | LYD_INTOPT_WITH_SIBLINGS; |
Michal Vasko | 80623c5 | 2023-04-28 14:22:06 +0200 | [diff] [blame] | 1266 | lydctx->any_schema = snode; |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1267 | |
| 1268 | /* process the anydata content */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1269 | do { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1270 | r = lydjson_subtree_r(lydctx, NULL, &tree, NULL); |
| 1271 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
| 1272 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1273 | *status = lyjson_ctx_status(lydctx->jsonctx); |
| 1274 | } while (*status == LYJSON_OBJECT_NEXT); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1275 | |
| 1276 | /* restore parser options */ |
| 1277 | lydctx->parse_opts = prev_parse_opts; |
| 1278 | lydctx->int_opts = prev_int_opts; |
Michal Vasko | 80623c5 | 2023-04-28 14:22:06 +0200 | [diff] [blame] | 1279 | lydctx->any_schema = NULL; |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1280 | |
| 1281 | /* finish linking metadata */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1282 | r = lydjson_metadata_finish(lydctx, &tree); |
| 1283 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1284 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1285 | r = lyd_create_any(snode, tree, LYD_ANYDATA_DATATREE, 1, node); |
| 1286 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1287 | break; |
| 1288 | case LYJSON_ARRAY: |
| 1289 | /* skip until the array end */ |
| 1290 | in_start = *lydctx->jsonctx->in; |
| 1291 | LY_CHECK_RET(lydjson_data_skip(lydctx->jsonctx)); |
| 1292 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1293 | /* return back by all the WS */ |
| 1294 | end = lydctx->jsonctx->in->current; |
| 1295 | while (is_jsonws(end[-1])) { |
| 1296 | --end; |
| 1297 | } |
| 1298 | |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1299 | /* make a copy of the whole array and store it */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1300 | if (asprintf(&val, "[%.*s", (int)(end - in_start.current), in_start.current) == -1) { |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1301 | LOGMEM(lydctx->jsonctx->ctx); |
| 1302 | return LY_EMEM; |
| 1303 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1304 | r = lyd_create_any(snode, val, LYD_ANYDATA_JSON, 1, node); |
| 1305 | LY_CHECK_ERR_GOTO(r, rc = r, val_err); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1306 | break; |
| 1307 | case LYJSON_STRING: |
| 1308 | /* string value */ |
| 1309 | if (lydctx->jsonctx->dynamic) { |
| 1310 | LY_CHECK_RET(lyd_create_any(snode, lydctx->jsonctx->value, LYD_ANYDATA_STRING, 1, node)); |
| 1311 | lydctx->jsonctx->dynamic = 0; |
| 1312 | } else { |
| 1313 | val = strndup(lydctx->jsonctx->value, lydctx->jsonctx->value_len); |
| 1314 | LY_CHECK_ERR_RET(!val, LOGMEM(lydctx->jsonctx->ctx), LY_EMEM); |
| 1315 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1316 | r = lyd_create_any(snode, val, LYD_ANYDATA_STRING, 1, node); |
| 1317 | LY_CHECK_ERR_GOTO(r, rc = r, val_err); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1318 | } |
| 1319 | break; |
| 1320 | case LYJSON_NUMBER: |
| 1321 | case LYJSON_FALSE: |
| 1322 | case LYJSON_TRUE: |
| 1323 | /* JSON value */ |
| 1324 | assert(!lydctx->jsonctx->dynamic); |
| 1325 | val = strndup(lydctx->jsonctx->value, lydctx->jsonctx->value_len); |
| 1326 | LY_CHECK_ERR_RET(!val, LOGMEM(lydctx->jsonctx->ctx), LY_EMEM); |
| 1327 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1328 | r = lyd_create_any(snode, val, LYD_ANYDATA_JSON, 1, node); |
| 1329 | LY_CHECK_ERR_GOTO(r, rc = r, val_err); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1330 | break; |
| 1331 | case LYJSON_NULL: |
| 1332 | /* no value */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1333 | r = lyd_create_any(snode, NULL, LYD_ANYDATA_JSON, 1, node); |
| 1334 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1335 | break; |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1336 | default: |
| 1337 | LOGINT_RET(lydctx->jsonctx->ctx); |
| 1338 | } |
| 1339 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1340 | cleanup: |
| 1341 | return rc; |
Michal Vasko | 7ca3325 | 2022-12-21 09:30:32 +0100 | [diff] [blame] | 1342 | |
| 1343 | val_err: |
| 1344 | free(val); |
| 1345 | return rc; |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1346 | } |
| 1347 | |
| 1348 | /** |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1349 | * @brief Parse a single instance of an inner node. |
| 1350 | * |
| 1351 | * @param[in] lydctx JSON data parser context. |
| 1352 | * @param[in] snode Schema node corresponding to the member currently being processed in the context. |
| 1353 | * @param[in] ext Extension instance of @p snode, if any. |
| 1354 | * @param[in,out] status JSON parser status, is updated. |
| 1355 | * @param[out] node Parsed data (or opaque) node. |
| 1356 | * @return LY_SUCCESS if a node was successfully parsed, |
| 1357 | * @return LY_ENOT in case of invalid JSON encoding, |
| 1358 | * @return LY_ERR on other errors. |
| 1359 | */ |
| 1360 | static LY_ERR |
| 1361 | lydjson_parse_instance_inner(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, struct lysc_ext_instance *ext, |
| 1362 | enum LYJSON_PARSER_STATUS *status, struct lyd_node **node) |
| 1363 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1364 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1365 | uint32_t prev_parse_opts = lydctx->parse_opts; |
| 1366 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1367 | LY_CHECK_RET(*status != LYJSON_OBJECT, LY_ENOT); |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1368 | |
| 1369 | /* create inner node */ |
| 1370 | LY_CHECK_RET(lyd_create_inner(snode, node)); |
| 1371 | |
| 1372 | /* use it for logging */ |
| 1373 | LOG_LOCSET(NULL, *node, NULL, NULL); |
| 1374 | |
| 1375 | if (ext) { |
| 1376 | /* only parse these extension data and validate afterwards */ |
| 1377 | lydctx->parse_opts |= LYD_PARSE_ONLY; |
| 1378 | } |
| 1379 | |
| 1380 | /* process children */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1381 | do { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1382 | r = lydjson_subtree_r(lydctx, *node, lyd_node_child_p(*node), NULL); |
| 1383 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
| 1384 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1385 | *status = lyjson_ctx_status(lydctx->jsonctx); |
| 1386 | } while (*status == LYJSON_OBJECT_NEXT); |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1387 | |
| 1388 | /* finish linking metadata */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1389 | r = lydjson_metadata_finish(lydctx, lyd_node_child_p(*node)); |
| 1390 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1391 | |
| 1392 | if (snode->nodetype == LYS_LIST) { |
| 1393 | /* check all keys exist */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1394 | r = lyd_parse_check_keys(*node); |
| 1395 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1396 | } |
| 1397 | |
| 1398 | if (!(lydctx->parse_opts & LYD_PARSE_ONLY)) { |
| 1399 | /* new node validation, autodelete CANNOT occur, all nodes are new */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1400 | r = lyd_validate_new(lyd_node_child_p(*node), snode, NULL, lydctx->val_opts, NULL); |
| 1401 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1402 | |
| 1403 | /* add any missing default children */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1404 | r = lyd_new_implicit_r(*node, lyd_node_child_p(*node), NULL, NULL, &lydctx->node_when, &lydctx->node_types, |
| 1405 | &lydctx->ext_node, (lydctx->val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, NULL); |
| 1406 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1407 | } |
| 1408 | |
| 1409 | cleanup: |
| 1410 | lydctx->parse_opts = prev_parse_opts; |
| 1411 | LOG_LOCBACK(0, 1, 0, 0); |
Michal Vasko | 6a5e469 | 2023-03-01 14:41:39 +0100 | [diff] [blame] | 1412 | if (!(*node)->hash) { |
| 1413 | /* list without keys is unusable */ |
| 1414 | lyd_free_tree(*node); |
| 1415 | *node = NULL; |
| 1416 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1417 | return rc; |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1418 | } |
| 1419 | |
| 1420 | /** |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1421 | * @brief Parse a single instance of a node. |
| 1422 | * |
| 1423 | * @param[in] lydctx JSON data parser context. When the function returns, the context is in the same state |
| 1424 | * as before calling, despite it is necessary to process input data for checking. |
| 1425 | * @param[in] parent Data parent of the subtree, must be set if @p first is not. |
| 1426 | * @param[in,out] first_p Pointer to the variable holding the first top-level sibling, must be set if @p parent is not. |
| 1427 | * @param[in] snode Schema node corresponding to the member currently being processed in the context. |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1428 | * @param[in] ext Extension instance of @p snode, if any. |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1429 | * @param[in] name Parsed JSON node name. |
| 1430 | * @param[in] name_len Lenght of @p name. |
| 1431 | * @param[in] prefix Parsed JSON node prefix. |
| 1432 | * @param[in] prefix_len Length of @p prefix. |
| 1433 | * @param[in,out] status JSON parser status, is updated. |
| 1434 | * @param[out] node Parsed data (or opaque) node. |
| 1435 | * @return LY_SUCCESS if a node was successfully parsed, |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1436 | * @return LY_ENOT in case of invalid JSON encoding, |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1437 | * @return LY_ERR on other errors. |
| 1438 | */ |
| 1439 | static LY_ERR |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1440 | lydjson_parse_instance(struct lyd_json_ctx *lydctx, struct lyd_node *parent, struct lyd_node **first_p, |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1441 | const struct lysc_node *snode, struct lysc_ext_instance *ext, const char *name, size_t name_len, |
| 1442 | const char *prefix, size_t prefix_len, enum LYJSON_PARSER_STATUS *status, struct lyd_node **node) |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1443 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1444 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1445 | uint32_t type_hints = 0; |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1446 | |
| 1447 | LOG_LOCSET(snode, NULL, NULL, NULL); |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1448 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1449 | r = lydjson_data_check_opaq(lydctx, snode, &type_hints); |
| 1450 | if (r == LY_SUCCESS) { |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1451 | assert(snode->nodetype & (LYD_NODE_TERM | LYD_NODE_INNER | LYD_NODE_ANY)); |
| 1452 | if (snode->nodetype & LYD_NODE_TERM) { |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1453 | if ((*status != LYJSON_ARRAY) && (*status != LYJSON_NUMBER) && (*status != LYJSON_STRING) && |
| 1454 | (*status != LYJSON_FALSE) && (*status != LYJSON_TRUE) && (*status != LYJSON_NULL)) { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1455 | rc = LY_ENOT; |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1456 | goto cleanup; |
| 1457 | } |
Michal Vasko | bbdadda | 2022-01-06 11:40:10 +0100 | [diff] [blame] | 1458 | |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1459 | /* create terminal node */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1460 | r = lyd_parser_create_term((struct lyd_ctx *)lydctx, snode, lydctx->jsonctx->value, |
| 1461 | lydctx->jsonctx->value_len, &lydctx->jsonctx->dynamic, LY_VALUE_JSON, NULL, type_hints, node); |
| 1462 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1463 | |
| 1464 | /* move JSON parser */ |
Michal Vasko | 8543070 | 2021-07-21 14:29:56 +0200 | [diff] [blame] | 1465 | if (*status == LYJSON_ARRAY) { |
| 1466 | /* only [null], 2 more moves are needed */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1467 | r = lyjson_ctx_next(lydctx->jsonctx, status); |
| 1468 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 8543070 | 2021-07-21 14:29:56 +0200 | [diff] [blame] | 1469 | assert(*status == LYJSON_NULL); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1470 | |
| 1471 | r = lyjson_ctx_next(lydctx->jsonctx, status); |
| 1472 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 8543070 | 2021-07-21 14:29:56 +0200 | [diff] [blame] | 1473 | assert(*status == LYJSON_ARRAY_CLOSED); |
| 1474 | } |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1475 | } else if (snode->nodetype & LYD_NODE_INNER) { |
| 1476 | /* create inner node */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1477 | r = lydjson_parse_instance_inner(lydctx, snode, ext, status, node); |
| 1478 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Michal Vasko | 76096ec | 2022-02-24 16:06:16 +0100 | [diff] [blame] | 1479 | } else { |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1480 | /* create any node */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1481 | r = lydjson_parse_any(lydctx, snode, ext, status, node); |
| 1482 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1483 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1484 | LY_CHECK_GOTO(!*node, cleanup); |
Michal Vasko | caf608d | 2021-07-23 13:51:23 +0200 | [diff] [blame] | 1485 | |
| 1486 | /* add/correct flags */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1487 | r = lyd_parse_set_data_flags(*node, &(*node)->meta, (struct lyd_ctx *)lydctx, ext); |
| 1488 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 135719f | 2022-08-25 12:18:17 +0200 | [diff] [blame] | 1489 | |
Michal Vasko | eba2311 | 2022-08-26 08:35:41 +0200 | [diff] [blame] | 1490 | if (!(lydctx->parse_opts & LYD_PARSE_ONLY)) { |
| 1491 | /* store for ext instance node validation, if needed */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1492 | r = lyd_validate_node_ext(*node, &lydctx->ext_node); |
| 1493 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | eba2311 | 2022-08-26 08:35:41 +0200 | [diff] [blame] | 1494 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1495 | } else if (r == LY_ENOT) { |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1496 | /* parse it again as an opaq node */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1497 | r = lydjson_parse_opaq(lydctx, name, name_len, prefix, prefix_len, parent, status, status, first_p, node); |
| 1498 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1499 | |
Michal Vasko | feca4fb | 2020-10-05 08:58:40 +0200 | [diff] [blame] | 1500 | if (snode->nodetype == LYS_LIST) { |
| 1501 | ((struct lyd_node_opaq *)*node)->hints |= LYD_NODEHINT_LIST; |
| 1502 | } else if (snode->nodetype == LYS_LEAFLIST) { |
| 1503 | ((struct lyd_node_opaq *)*node)->hints |= LYD_NODEHINT_LEAFLIST; |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1504 | } |
Michal Vasko | a32b6b7 | 2022-07-11 15:55:56 +0200 | [diff] [blame] | 1505 | } else { |
| 1506 | /* error */ |
Michal Vasko | 1e8746a | 2023-02-13 09:15:16 +0100 | [diff] [blame] | 1507 | rc = r; |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1508 | goto cleanup; |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1509 | } |
| 1510 | |
Michal Vasko | e0608fa | 2022-10-25 15:01:24 +0200 | [diff] [blame] | 1511 | cleanup: |
| 1512 | LOG_LOCBACK(1, 0, 0, 0); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1513 | return rc; |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1514 | } |
| 1515 | |
| 1516 | /** |
Michal Vasko | a5da329 | 2020-08-12 13:10:50 +0200 | [diff] [blame] | 1517 | * @brief Parse JSON subtree. All leaf-list and list instances of a node are considered one subtree. |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1518 | * |
| 1519 | * @param[in] lydctx JSON data parser context. |
| 1520 | * @param[in] parent Data parent of the subtree, must be set if @p first is not. |
| 1521 | * @param[in,out] first_p Pointer to the variable holding the first top-level sibling, must be set if @p parent is not. |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1522 | * @param[in,out] parsed Optional set to add all the parsed siblings into. |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1523 | * @return LY_ERR value. |
| 1524 | */ |
| 1525 | static LY_ERR |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1526 | lydjson_subtree_r(struct lyd_json_ctx *lydctx, struct lyd_node *parent, struct lyd_node **first_p, struct ly_set *parsed) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1527 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1528 | LY_ERR r, rc = LY_SUCCESS; |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1529 | enum LYJSON_PARSER_STATUS status = lyjson_ctx_status(lydctx->jsonctx); |
aPiecek | 49e2a3a | 2021-05-13 10:36:46 +0200 | [diff] [blame] | 1530 | const char *name, *prefix = NULL, *expected = NULL; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1531 | size_t name_len, prefix_len = 0; |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1532 | ly_bool is_meta = 0, parse_subtree; |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 1533 | const struct lysc_node *snode = NULL; |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1534 | struct lysc_ext_instance *ext; |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1535 | struct lyd_node *node = NULL, *attr_node = NULL; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1536 | const struct ly_ctx *ctx = lydctx->jsonctx->ctx; |
aPiecek | 49e2a3a | 2021-05-13 10:36:46 +0200 | [diff] [blame] | 1537 | char *value = NULL; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1538 | |
| 1539 | assert(parent || first_p); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1540 | assert((status == LYJSON_OBJECT) || (status == LYJSON_OBJECT_NEXT)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1541 | |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1542 | parse_subtree = lydctx->parse_opts & LYD_PARSE_SUBTREE ? 1 : 0; |
| 1543 | /* all descendants should be parsed */ |
| 1544 | lydctx->parse_opts &= ~LYD_PARSE_SUBTREE; |
| 1545 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1546 | r = lyjson_ctx_next(lydctx->jsonctx, &status); |
| 1547 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1548 | if (status == LYJSON_OBJECT_CLOSED) { |
| 1549 | /* empty object, fine... */ |
| 1550 | goto cleanup; |
| 1551 | } |
| 1552 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1553 | /* process the node name */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1554 | assert(status == LYJSON_OBJECT_NAME); |
aPiecek | d2c3937 | 2021-06-16 14:03:12 +0200 | [diff] [blame] | 1555 | lydjson_parse_name(lydctx->jsonctx->value, lydctx->jsonctx->value_len, &name, &name_len, &prefix, &prefix_len, &is_meta); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1556 | lyjson_ctx_give_dynamic_value(lydctx->jsonctx, &value); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1557 | |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 1558 | if (!is_meta || name_len || prefix_len) { |
| 1559 | /* get the schema node */ |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1560 | r = lydjson_get_snode(lydctx, is_meta, prefix, prefix_len, name, name_len, parent, &snode, &ext); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1561 | if (r == LY_ENOT) { |
| 1562 | /* data parsed */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1563 | goto cleanup; |
Michal Vasko | 514f698 | 2023-02-17 09:07:39 +0100 | [diff] [blame] | 1564 | } else if ((r == LY_EVALID) && (lydctx->val_opts & LYD_VALIDATE_MULTI_ERROR)) { |
| 1565 | rc = r; |
| 1566 | |
| 1567 | /* skip the invalid data */ |
| 1568 | if ((r = lydjson_data_skip(lydctx->jsonctx))) { |
| 1569 | rc = r; |
| 1570 | } |
Michal Vasko | 1241ebc | 2023-04-04 10:03:45 +0200 | [diff] [blame] | 1571 | r = lyjson_ctx_next(lydctx->jsonctx, &status); |
| 1572 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 514f698 | 2023-02-17 09:07:39 +0100 | [diff] [blame] | 1573 | goto cleanup; |
| 1574 | } else if (r) { |
| 1575 | /* error */ |
| 1576 | rc = r; |
| 1577 | goto cleanup; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1578 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1579 | |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 1580 | if (!snode) { |
| 1581 | /* we will not be parsing it as metadata */ |
| 1582 | is_meta = 0; |
| 1583 | } |
| 1584 | } |
| 1585 | |
| 1586 | if (is_meta) { |
| 1587 | /* parse as metadata */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1588 | if (!name_len && !prefix_len && !parent) { |
| 1589 | LOGVAL(ctx, LYVE_SYNTAX_JSON, |
| 1590 | "Invalid metadata format - \"@\" can be used only inside anydata, container or list entries."); |
| 1591 | r = LY_EVALID; |
| 1592 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
| 1593 | } else if (!name_len && !prefix_len) { |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 1594 | /* parent's metadata without a name - use the schema from the parent */ |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1595 | attr_node = parent; |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 1596 | snode = attr_node->schema; |
| 1597 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1598 | r = lydjson_parse_attribute(lydctx, attr_node, snode, name, name_len, prefix, prefix_len, parent, &status, |
Michal Vasko | 6973015 | 2020-10-09 16:30:07 +0200 | [diff] [blame] | 1599 | first_p, &node); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1600 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 1601 | } else if (!snode) { |
Michal Vasko | 87c5d6b | 2023-02-14 15:27:41 +0100 | [diff] [blame] | 1602 | if (!(lydctx->parse_opts & LYD_PARSE_OPAQ)) { |
| 1603 | /* skip element with children */ |
| 1604 | r = lydjson_data_skip(lydctx->jsonctx); |
| 1605 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1606 | } else { |
| 1607 | /* parse as an opaq node */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1608 | |
Michal Vasko | 87c5d6b | 2023-02-14 15:27:41 +0100 | [diff] [blame] | 1609 | /* opaq node cannot have an empty string as the name. */ |
| 1610 | if (name_len == 0) { |
Michal Vasko | bfebf66 | 2023-02-17 09:07:22 +0100 | [diff] [blame] | 1611 | LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX_JSON, "JSON object member name cannot be a zero-length string."); |
Michal Vasko | 87c5d6b | 2023-02-14 15:27:41 +0100 | [diff] [blame] | 1612 | r = LY_EVALID; |
| 1613 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
| 1614 | } |
| 1615 | |
| 1616 | /* move to the second item in the name/X pair and parse opaq */ |
| 1617 | r = lydjson_ctx_next_parse_opaq(lydctx, name, name_len, prefix, prefix_len, parent, &status, first_p, &node); |
| 1618 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
aPiecek | b7b29e6 | 2021-05-11 10:02:43 +0200 | [diff] [blame] | 1619 | } |
Michal Vasko | cabe070 | 2020-08-12 10:14:36 +0200 | [diff] [blame] | 1620 | } else { |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1621 | /* parse as a standard lyd_node but it can still turn out to be an opaque node */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1622 | |
| 1623 | /* move to the second item in the name/X pair */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1624 | r = lyjson_ctx_next(lydctx->jsonctx, &status); |
| 1625 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1626 | |
Michal Vasko | 7ca3325 | 2022-12-21 09:30:32 +0100 | [diff] [blame] | 1627 | /* set expected representation */ |
| 1628 | switch (snode->nodetype) { |
| 1629 | case LYS_LEAFLIST: |
| 1630 | expected = "name/array of values"; |
| 1631 | break; |
| 1632 | case LYS_LIST: |
| 1633 | expected = "name/array of objects"; |
| 1634 | break; |
| 1635 | case LYS_LEAF: |
| 1636 | if (status == LYJSON_ARRAY) { |
| 1637 | expected = "name/[null]"; |
| 1638 | } else { |
| 1639 | expected = "name/value"; |
| 1640 | } |
| 1641 | break; |
| 1642 | case LYS_CONTAINER: |
| 1643 | case LYS_NOTIF: |
| 1644 | case LYS_ACTION: |
| 1645 | case LYS_RPC: |
| 1646 | case LYS_ANYDATA: |
| 1647 | expected = "name/object"; |
| 1648 | break; |
| 1649 | case LYS_ANYXML: |
| 1650 | if (status == LYJSON_ARRAY) { |
| 1651 | expected = "name/array"; |
| 1652 | } else { |
| 1653 | expected = "name/value"; |
| 1654 | } |
| 1655 | break; |
| 1656 | } |
| 1657 | |
| 1658 | /* check the representation according to the nodetype and then continue with the content */ |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1659 | switch (snode->nodetype) { |
| 1660 | case LYS_LEAFLIST: |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1661 | case LYS_LIST: |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1662 | LY_CHECK_GOTO(status != LYJSON_ARRAY, representation_error); |
| 1663 | |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1664 | /* process all the values/objects */ |
| 1665 | do { |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1666 | /* move into array/next value */ |
| 1667 | r = lyjson_ctx_next(lydctx->jsonctx, &status); |
| 1668 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1669 | if (status == LYJSON_ARRAY_CLOSED) { |
| 1670 | /* empty array, fine... */ |
| 1671 | break; |
| 1672 | } |
| 1673 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1674 | r = lydjson_parse_instance(lydctx, parent, first_p, snode, ext, name, name_len, prefix, prefix_len, |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1675 | &status, &node); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1676 | if (r == LY_ENOT) { |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1677 | goto representation_error; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1678 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1679 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
| 1680 | |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1681 | lydjson_maintain_children(parent, first_p, &node, lydctx->parse_opts & LYD_PARSE_ORDERED ? 1 : 0, ext); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1682 | |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1683 | /* move after the item(s) */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1684 | r = lyjson_ctx_next(lydctx->jsonctx, &status); |
| 1685 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1686 | } while (status == LYJSON_ARRAY_NEXT); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1687 | |
| 1688 | break; |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1689 | case LYS_LEAF: |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1690 | case LYS_CONTAINER: |
| 1691 | case LYS_NOTIF: |
| 1692 | case LYS_ACTION: |
| 1693 | case LYS_RPC: |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1694 | case LYS_ANYDATA: |
| 1695 | case LYS_ANYXML: |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1696 | /* process the value/object */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1697 | r = lydjson_parse_instance(lydctx, parent, first_p, snode, ext, name, name_len, prefix, prefix_len, |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1698 | &status, &node); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1699 | if (r == LY_ENOT) { |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1700 | goto representation_error; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1701 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1702 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1703 | |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1704 | if (snode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1705 | /* rememeber the RPC/action/notification */ |
| 1706 | lydctx->op_node = node; |
| 1707 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1708 | break; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1709 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1710 | } |
| 1711 | |
Michal Vasko | 32ac994 | 2020-08-12 14:35:12 +0200 | [diff] [blame] | 1712 | /* finally connect the parsed node */ |
Michal Vasko | 8cc3f66 | 2022-03-29 11:25:51 +0200 | [diff] [blame] | 1713 | lydjson_maintain_children(parent, first_p, &node, lydctx->parse_opts & LYD_PARSE_ORDERED ? 1 : 0, ext); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1714 | |
| 1715 | /* rememeber a successfully parsed node */ |
Michal Vasko | 4e26adc | 2022-03-30 11:01:16 +0200 | [diff] [blame] | 1716 | if (parsed && node) { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1717 | ly_set_add(parsed, node, 1, NULL); |
| 1718 | } |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1719 | |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1720 | if (!parse_subtree) { |
| 1721 | /* move after the item(s) */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1722 | r = lyjson_ctx_next(lydctx->jsonctx, &status); |
| 1723 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1724 | } |
| 1725 | |
Radek Krejci | 5813c36 | 2021-01-05 10:51:57 +0100 | [diff] [blame] | 1726 | /* success */ |
| 1727 | goto cleanup; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1728 | |
| 1729 | representation_error: |
Michal Vasko | bfebf66 | 2023-02-17 09:07:22 +0100 | [diff] [blame] | 1730 | LOGVAL(ctx, LYVE_SYNTAX_JSON, "Expecting JSON %s but %s \"%s\" is represented in input data as name/%s.", |
| 1731 | expected, lys_nodetype2str(snode->nodetype), snode->name, lyjson_token2str(status)); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1732 | rc = LY_EVALID; |
| 1733 | if (lydctx->val_opts & LYD_VALIDATE_MULTI_ERROR) { |
| 1734 | /* try to skip the invalid data */ |
Michal Vasko | 560f9de | 2023-02-10 09:56:01 +0100 | [diff] [blame] | 1735 | if ((r = lydjson_data_skip(lydctx->jsonctx))) { |
| 1736 | rc = r; |
| 1737 | } |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1738 | } |
Radek Krejci | 5813c36 | 2021-01-05 10:51:57 +0100 | [diff] [blame] | 1739 | |
| 1740 | cleanup: |
aPiecek | 49e2a3a | 2021-05-13 10:36:46 +0200 | [diff] [blame] | 1741 | free(value); |
Radek Krejci | 5813c36 | 2021-01-05 10:51:57 +0100 | [diff] [blame] | 1742 | lyd_free_tree(node); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1743 | return rc; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1744 | } |
| 1745 | |
| 1746 | /** |
| 1747 | * @brief Common start of JSON parser processing different types of the input data. |
| 1748 | * |
| 1749 | * @param[in] ctx libyang context |
| 1750 | * @param[in] in Input structure. |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1751 | * @param[in] parse_opts Options for parser, see @ref dataparseroptions. |
| 1752 | * @param[in] val_opts Options for the validation phase, see @ref datavalidationoptions. |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1753 | * @param[out] lydctx_p Data parser context to finish validation. |
| 1754 | * @return LY_ERR value. |
| 1755 | */ |
| 1756 | static LY_ERR |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1757 | lyd_parse_json_init(const struct ly_ctx *ctx, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts, |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1758 | struct lyd_json_ctx **lydctx_p) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1759 | { |
| 1760 | LY_ERR ret = LY_SUCCESS; |
| 1761 | struct lyd_json_ctx *lydctx; |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1762 | enum LYJSON_PARSER_STATUS status; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1763 | |
Radek Krejci | cd5f622 | 2020-11-12 08:54:13 +0100 | [diff] [blame] | 1764 | assert(lydctx_p); |
Radek Krejci | cd5f622 | 2020-11-12 08:54:13 +0100 | [diff] [blame] | 1765 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1766 | /* init context */ |
| 1767 | lydctx = calloc(1, sizeof *lydctx); |
| 1768 | LY_CHECK_ERR_RET(!lydctx, LOGMEM(ctx), LY_EMEM); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1769 | lydctx->parse_opts = parse_opts; |
| 1770 | lydctx->val_opts = val_opts; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1771 | lydctx->free = lyd_json_ctx_free; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1772 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1773 | LY_CHECK_ERR_RET(ret = lyjson_ctx_new(ctx, in, &lydctx->jsonctx), free(lydctx), ret); |
| 1774 | status = lyjson_ctx_status(lydctx->jsonctx); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1775 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1776 | /* parse_opts & LYD_PARSE_SUBTREE not implemented */ |
| 1777 | if (status != LYJSON_OBJECT) { |
Radek Krejci | cd5f622 | 2020-11-12 08:54:13 +0100 | [diff] [blame] | 1778 | /* expecting top-level object */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1779 | LOGVAL(ctx, LYVE_SYNTAX_JSON, "Expected top-level JSON object, but %s found.", lyjson_token2str(status)); |
Radek Krejci | cd5f622 | 2020-11-12 08:54:13 +0100 | [diff] [blame] | 1780 | *lydctx_p = NULL; |
Michal Vasko | 9350901 | 2020-11-13 10:26:09 +0100 | [diff] [blame] | 1781 | lyd_json_ctx_free((struct lyd_ctx *)lydctx); |
Radek Krejci | cd5f622 | 2020-11-12 08:54:13 +0100 | [diff] [blame] | 1782 | return LY_EVALID; |
Radek Krejci | 284f31f | 2020-09-18 15:40:29 +0200 | [diff] [blame] | 1783 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1784 | |
| 1785 | *lydctx_p = lydctx; |
| 1786 | return LY_SUCCESS; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1787 | } |
| 1788 | |
| 1789 | LY_ERR |
Radek Krejci | f16e254 | 2021-02-17 15:39:23 +0100 | [diff] [blame] | 1790 | lyd_parse_json(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent, |
Michal Vasko | e3ed7dc | 2022-11-30 11:39:44 +0100 | [diff] [blame] | 1791 | struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts, uint32_t int_opts, |
Michal Vasko | ddd7659 | 2022-01-17 13:34:48 +0100 | [diff] [blame] | 1792 | struct ly_set *parsed, ly_bool *subtree_sibling, struct lyd_ctx **lydctx_p) |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1793 | { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1794 | LY_ERR r, rc = LY_SUCCESS; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1795 | struct lyd_json_ctx *lydctx = NULL; |
| 1796 | enum LYJSON_PARSER_STATUS status; |
| 1797 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1798 | rc = lyd_parse_json_init(ctx, in, parse_opts, val_opts, &lydctx); |
| 1799 | LY_CHECK_GOTO(rc, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1800 | |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1801 | lydctx->int_opts = int_opts; |
Radek Krejci | f16e254 | 2021-02-17 15:39:23 +0100 | [diff] [blame] | 1802 | lydctx->ext = ext; |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1803 | |
| 1804 | /* find the operation node if it exists already */ |
| 1805 | LY_CHECK_GOTO(rc = lyd_parser_find_operation(parent, int_opts, &lydctx->op_node), cleanup); |
| 1806 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1807 | /* read subtree(s) */ |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1808 | do { |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1809 | r = lydjson_subtree_r(lydctx, parent, first_p, parsed); |
| 1810 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1811 | |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1812 | status = lyjson_ctx_status(lydctx->jsonctx); |
Michal Vasko | 6a5e469 | 2023-03-01 14:41:39 +0100 | [diff] [blame] | 1813 | |
| 1814 | if (!(int_opts & LYD_INTOPT_WITH_SIBLINGS)) { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1815 | break; |
| 1816 | } |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1817 | } while (status == LYJSON_OBJECT_NEXT); |
Michal Vasko | 6a5e469 | 2023-03-01 14:41:39 +0100 | [diff] [blame] | 1818 | assert((status == LYJSON_END) || (status == LYJSON_OBJECT_CLOSED)); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1819 | |
| 1820 | if ((int_opts & LYD_INTOPT_NO_SIBLINGS) && lydctx->jsonctx->in->current[0] && |
Michal Vasko | 09e0463 | 2023-03-22 14:34:10 +0100 | [diff] [blame] | 1821 | (lyjson_ctx_status(lydctx->jsonctx) != LYJSON_OBJECT_CLOSED)) { |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1822 | LOGVAL(ctx, LYVE_SYNTAX, "Unexpected sibling node."); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1823 | r = LY_EVALID; |
| 1824 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1825 | } |
| 1826 | if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NOTIF | LYD_INTOPT_REPLY)) && !lydctx->op_node) { |
| 1827 | LOGVAL(ctx, LYVE_DATA, "Missing the operation node."); |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1828 | r = LY_EVALID; |
| 1829 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1830 | } |
| 1831 | |
| 1832 | /* finish linking metadata */ |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1833 | r = lydjson_metadata_finish(lydctx, parent ? lyd_node_child_p(parent) : first_p); |
| 1834 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1835 | |
Michal Vasko | 61ad1ff | 2022-02-10 15:48:39 +0100 | [diff] [blame] | 1836 | if (parse_opts & LYD_PARSE_SUBTREE) { |
| 1837 | /* check for a sibling object */ |
| 1838 | assert(subtree_sibling); |
| 1839 | if (lydctx->jsonctx->in->current[0] == ',') { |
| 1840 | *subtree_sibling = 1; |
| 1841 | |
| 1842 | /* move to the next object */ |
| 1843 | ly_in_skip(lydctx->jsonctx->in, 1); |
| 1844 | } else { |
| 1845 | *subtree_sibling = 0; |
| 1846 | } |
| 1847 | } |
| 1848 | |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1849 | cleanup: |
| 1850 | /* there should be no unresolved types stored */ |
Michal Vasko | 58c8b56 | 2021-12-09 09:25:33 +0100 | [diff] [blame] | 1851 | assert(!(parse_opts & LYD_PARSE_ONLY) || !lydctx || (!lydctx->node_types.count && !lydctx->meta_types.count && |
Michal Vasko | 49c39d8 | 2020-11-06 17:20:27 +0100 | [diff] [blame] | 1852 | !lydctx->node_when.count)); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1853 | |
Michal Vasko | d027f38 | 2023-02-10 09:13:25 +0100 | [diff] [blame] | 1854 | if (rc && (!lydctx || !(lydctx->val_opts & LYD_VALIDATE_MULTI_ERROR) || (rc != LY_EVALID))) { |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1855 | lyd_json_ctx_free((struct lyd_ctx *)lydctx); |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1856 | } else { |
| 1857 | *lydctx_p = (struct lyd_ctx *)lydctx; |
Michal Vasko | f8ebf13 | 2022-11-21 14:06:48 +0100 | [diff] [blame] | 1858 | |
| 1859 | /* the JSON context is no more needed, freeing it also stops logging line numbers which would be confusing now */ |
| 1860 | lyjson_ctx_free(lydctx->jsonctx); |
| 1861 | lydctx->jsonctx = NULL; |
Radek Krejci | 1798aae | 2020-07-14 13:26:06 +0200 | [diff] [blame] | 1862 | } |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 1863 | return rc; |
Michal Vasko | 90932a9 | 2020-02-12 14:33:03 +0100 | [diff] [blame] | 1864 | } |
Michal Vasko | 820efe8 | 2023-05-12 15:47:43 +0200 | [diff] [blame^] | 1865 | |
| 1866 | /** |
| 1867 | * @brief Parse a specific JSON object into an opaque node. |
| 1868 | * |
| 1869 | * @param[in] jsonctx JSON parser context. |
| 1870 | * @param[in] name Name of the object. |
| 1871 | * @param[in] module Module name of the object, NULL if none expected. |
| 1872 | * @param[in] value Whether a value is expected. |
| 1873 | * @param[out] evnp Parsed envelope (opaque node). |
| 1874 | * @return LY_SUCCESS on success. |
| 1875 | * @return LY_ENOT if the specified object did not match. |
| 1876 | * @return LY_ERR value on error. |
| 1877 | */ |
| 1878 | static LY_ERR |
| 1879 | lydjson_envelope(struct lyjson_ctx *jsonctx, const char *name, const char *module, ly_bool value, struct lyd_node **envp) |
| 1880 | { |
| 1881 | LY_ERR rc = LY_SUCCESS, r; |
| 1882 | enum LYJSON_PARSER_STATUS status = lyjson_ctx_status(jsonctx); |
| 1883 | const char *nam, *prefix, *val = NULL; |
| 1884 | size_t nam_len, prefix_len, val_len = 0; |
| 1885 | ly_bool is_meta; |
| 1886 | |
| 1887 | assert(status == LYJSON_OBJECT); |
| 1888 | |
| 1889 | *envp = NULL; |
| 1890 | |
| 1891 | r = lyjson_ctx_next(jsonctx, &status); |
| 1892 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1893 | if (status == LYJSON_OBJECT_CLOSED) { |
| 1894 | LOGVAL(jsonctx->ctx, LYVE_SYNTAX, "Empty JSON object."); |
| 1895 | rc = LY_EVALID; |
| 1896 | goto cleanup; |
| 1897 | } |
| 1898 | |
| 1899 | /* process the name */ |
| 1900 | assert(status == LYJSON_OBJECT_NAME); |
| 1901 | lydjson_parse_name(jsonctx->value, jsonctx->value_len, &nam, &nam_len, &prefix, &prefix_len, &is_meta); |
| 1902 | if (is_meta) { |
| 1903 | LOGVAL(jsonctx->ctx, LYVE_DATA, "Unexpected metadata."); |
| 1904 | rc = LY_EVALID; |
| 1905 | goto cleanup; |
| 1906 | } else if (module && ly_strncmp(module, prefix, prefix_len)) { |
| 1907 | LOGVAL(jsonctx->ctx, LYVE_DATA, "Unexpected module \"%.*s\" instead of \"%s\".", (int)prefix_len, prefix, module); |
| 1908 | rc = LY_EVALID; |
| 1909 | goto cleanup; |
| 1910 | } else if (ly_strncmp(name, nam, nam_len)) { |
| 1911 | LOGVAL(jsonctx->ctx, LYVE_DATA, "Unexpected object \"%.*s\" instead of \"%s\".", (int)nam_len, nam, name); |
| 1912 | rc = LY_EVALID; |
| 1913 | goto cleanup; |
| 1914 | } |
| 1915 | |
| 1916 | r = lyjson_ctx_next(jsonctx, &status); |
| 1917 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1918 | |
| 1919 | if (value) { |
| 1920 | if (status != LYJSON_STRING) { |
| 1921 | LOGVAL(jsonctx->ctx, LYVE_SYNTAX_JSON, "Expecting JSON %s but %s found.", lyjson_token2str(LYJSON_STRING), |
| 1922 | lyjson_token2str(status)); |
| 1923 | rc = LY_EVALID; |
| 1924 | goto cleanup; |
| 1925 | } |
| 1926 | |
| 1927 | val = jsonctx->value; |
| 1928 | val_len = jsonctx->value_len; |
| 1929 | |
| 1930 | r = lyjson_ctx_next(jsonctx, &status); |
| 1931 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1932 | } |
| 1933 | |
| 1934 | /* create node */ |
| 1935 | rc = lyd_create_opaq(jsonctx->ctx, name, strlen(name), prefix, prefix_len, prefix, prefix_len, val, val_len, |
| 1936 | NULL, LY_VALUE_JSON, NULL, LYD_VALHINT_STRING, envp); |
| 1937 | LY_CHECK_GOTO(rc, cleanup); |
| 1938 | |
| 1939 | cleanup: |
| 1940 | if (rc) { |
| 1941 | lyd_free_tree(*envp); |
| 1942 | *envp = NULL; |
| 1943 | } |
| 1944 | return rc; |
| 1945 | } |
| 1946 | |
| 1947 | /** |
| 1948 | * @brief Parse all expected non-data JSON objects of a RESTCONF notification message. |
| 1949 | * |
| 1950 | * @param[in] jsonctx JSON parser context. |
| 1951 | * @param[out] evnp Parsed envelope(s) (opaque node). |
| 1952 | * @param[out] int_opts Internal options for parsing the rest of YANG data. |
| 1953 | * @param[out] close_elem Number of parsed opened objects that need to be closed. |
| 1954 | * @return LY_SUCCESS on success. |
| 1955 | * @return LY_ERR value on error. |
| 1956 | */ |
| 1957 | static LY_ERR |
| 1958 | lydjson_env_restconf_notif(struct lyjson_ctx *jsonctx, struct lyd_node **envp, uint32_t *int_opts, uint32_t *close_elem) |
| 1959 | { |
| 1960 | LY_ERR rc = LY_SUCCESS, r; |
| 1961 | struct lyd_node *child; |
| 1962 | |
| 1963 | assert(envp && !*envp); |
| 1964 | |
| 1965 | /* parse "notification" */ |
| 1966 | r = lydjson_envelope(jsonctx, "notification", "ietf-restconf", 0, envp); |
| 1967 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1968 | |
| 1969 | /* parse "eventTime" */ |
| 1970 | r = lydjson_envelope(jsonctx, "eventTime", NULL, 1, &child); |
| 1971 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1972 | |
| 1973 | /* insert */ |
| 1974 | lyd_insert_node(*envp, NULL, child, 0); |
| 1975 | |
| 1976 | /* validate value */ |
| 1977 | r = lyd_parser_notif_eventtime_validate(child); |
| 1978 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 1979 | |
| 1980 | /* RESTCONF notification */ |
| 1981 | *int_opts = LYD_INTOPT_NO_SIBLINGS | LYD_INTOPT_NOTIF; |
| 1982 | *close_elem = 1; |
| 1983 | |
| 1984 | cleanup: |
| 1985 | if (rc) { |
| 1986 | lyd_free_tree(*envp); |
| 1987 | *envp = NULL; |
| 1988 | } |
| 1989 | return rc; |
| 1990 | } |
| 1991 | |
| 1992 | LY_ERR |
| 1993 | lyd_parse_json_restconf(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent, |
| 1994 | struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts, enum lyd_type data_type, |
| 1995 | struct lyd_node **envp, struct ly_set *parsed, struct lyd_ctx **lydctx_p) |
| 1996 | { |
| 1997 | LY_ERR rc = LY_SUCCESS, r; |
| 1998 | struct lyd_json_ctx *lydctx; |
| 1999 | enum LYJSON_PARSER_STATUS status; |
| 2000 | uint32_t i, int_opts = 0, close_elem = 0; |
| 2001 | ly_bool parsed_data_nodes = 0; |
| 2002 | |
| 2003 | assert(ctx && in && lydctx_p); |
| 2004 | assert(!(parse_opts & ~LYD_PARSE_OPTS_MASK)); |
| 2005 | assert(!(val_opts & ~LYD_VALIDATE_OPTS_MASK)); |
| 2006 | |
| 2007 | assert((data_type == LYD_TYPE_RPC_RESTCONF) || (data_type == LYD_TYPE_NOTIF_RESTCONF) || |
| 2008 | (data_type == LYD_TYPE_REPLY_RESTCONF)); |
| 2009 | assert(!(parse_opts & LYD_PARSE_SUBTREE)); |
| 2010 | |
| 2011 | /* init context */ |
| 2012 | rc = lyd_parse_json_init(ctx, in, parse_opts, val_opts, &lydctx); |
| 2013 | LY_CHECK_GOTO(rc, cleanup); |
| 2014 | lydctx->ext = ext; |
| 2015 | |
| 2016 | switch (data_type) { |
| 2017 | case LYD_TYPE_RPC_RESTCONF: |
| 2018 | assert(parent); |
| 2019 | |
| 2020 | /* parse "input" */ |
| 2021 | rc = lydjson_envelope(lydctx->jsonctx, "input", lyd_owner_module(parent)->name, 0, envp); |
| 2022 | LY_CHECK_GOTO(rc, cleanup); |
| 2023 | |
| 2024 | int_opts = LYD_INTOPT_WITH_SIBLINGS | LYD_INTOPT_RPC | LYD_INTOPT_ACTION; |
| 2025 | close_elem = 1; |
| 2026 | break; |
| 2027 | case LYD_TYPE_NOTIF_RESTCONF: |
| 2028 | assert(!parent); |
| 2029 | rc = lydjson_env_restconf_notif(lydctx->jsonctx, envp, &int_opts, &close_elem); |
| 2030 | LY_CHECK_GOTO(rc, cleanup); |
| 2031 | break; |
| 2032 | case LYD_TYPE_REPLY_RESTCONF: |
| 2033 | assert(parent); |
| 2034 | |
| 2035 | /* parse "output" */ |
| 2036 | rc = lydjson_envelope(lydctx->jsonctx, "output", lyd_owner_module(parent)->name, 0, envp); |
| 2037 | LY_CHECK_GOTO(rc, cleanup); |
| 2038 | |
| 2039 | int_opts = LYD_INTOPT_WITH_SIBLINGS | LYD_INTOPT_REPLY; |
| 2040 | close_elem = 1; |
| 2041 | break; |
| 2042 | default: |
| 2043 | LOGINT(ctx); |
| 2044 | rc = LY_EINT; |
| 2045 | goto cleanup; |
| 2046 | } |
| 2047 | |
| 2048 | lydctx->int_opts = int_opts; |
| 2049 | |
| 2050 | /* find the operation node if it exists already */ |
| 2051 | LY_CHECK_GOTO(rc = lyd_parser_find_operation(parent, int_opts, &lydctx->op_node), cleanup); |
| 2052 | |
| 2053 | /* read subtree(s) */ |
| 2054 | do { |
| 2055 | r = lydjson_subtree_r(lydctx, parent, first_p, parsed); |
| 2056 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
| 2057 | parsed_data_nodes = 1; |
| 2058 | |
| 2059 | status = lyjson_ctx_status(lydctx->jsonctx); |
| 2060 | |
| 2061 | if (!(int_opts & LYD_INTOPT_WITH_SIBLINGS)) { |
| 2062 | break; |
| 2063 | } |
| 2064 | } while (status == LYJSON_OBJECT_NEXT); |
| 2065 | assert((status == LYJSON_END) || (status == LYJSON_OBJECT_CLOSED)); |
| 2066 | |
| 2067 | /* close all opened elements */ |
| 2068 | for (i = 0; i < close_elem; ++i) { |
| 2069 | if (status != LYJSON_OBJECT_CLOSED) { |
| 2070 | LOGVAL(ctx, LYVE_SYNTAX_JSON, "Expecting JSON %s but %s found.", lyjson_token2str(LYJSON_OBJECT_CLOSED), |
| 2071 | lyjson_token2str(status)); |
| 2072 | rc = LY_EVALID; |
| 2073 | goto cleanup; |
| 2074 | } |
| 2075 | |
| 2076 | r = lyjson_ctx_next(lydctx->jsonctx, &status); |
| 2077 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 2078 | } |
| 2079 | |
| 2080 | if ((int_opts & LYD_INTOPT_NO_SIBLINGS) && lydctx->jsonctx->in->current[0] && |
| 2081 | (lyjson_ctx_status(lydctx->jsonctx) != LYJSON_OBJECT_CLOSED)) { |
| 2082 | LOGVAL(ctx, LYVE_SYNTAX, "Unexpected sibling node."); |
| 2083 | r = LY_EVALID; |
| 2084 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
| 2085 | } |
| 2086 | if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NOTIF | LYD_INTOPT_REPLY)) && !lydctx->op_node) { |
| 2087 | LOGVAL(ctx, LYVE_DATA, "Missing the operation node."); |
| 2088 | r = LY_EVALID; |
| 2089 | LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup); |
| 2090 | } |
| 2091 | |
| 2092 | /* finish linking metadata */ |
| 2093 | r = lydjson_metadata_finish(lydctx, parent ? lyd_node_child_p(parent) : first_p); |
| 2094 | LY_CHECK_ERR_GOTO(r, rc = r, cleanup); |
| 2095 | |
| 2096 | if (!parsed_data_nodes) { |
| 2097 | /* no data nodes were parsed */ |
| 2098 | lydctx->op_node = NULL; |
| 2099 | } |
| 2100 | |
| 2101 | cleanup: |
| 2102 | /* there should be no unres stored if validation should be skipped */ |
| 2103 | assert(!(parse_opts & LYD_PARSE_ONLY) || (!lydctx->node_types.count && !lydctx->meta_types.count && |
| 2104 | !lydctx->node_when.count)); |
| 2105 | |
| 2106 | if (rc) { |
| 2107 | lyd_json_ctx_free((struct lyd_ctx *)lydctx); |
| 2108 | } else { |
| 2109 | *lydctx_p = (struct lyd_ctx *)lydctx; |
| 2110 | |
| 2111 | /* the JSON context is no more needed, freeing it also stops logging line numbers which would be confusing now */ |
| 2112 | lyjson_ctx_free(lydctx->jsonctx); |
| 2113 | lydctx->jsonctx = NULL; |
| 2114 | } |
| 2115 | return rc; |
| 2116 | } |