blob: 01aaed8ba23efe089b061b495d687cdef3b3a992 [file] [log] [blame]
Michal Vasko90932a92020-02-12 14:33:03 +01001/**
2 * @file parser_json.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief JSON data parser for libyang
5 *
Radek Krejci1798aae2020-07-14 13:26:06 +02006 * Copyright (c) 2020 CESNET, z.s.p.o.
Michal Vasko90932a92020-02-12 14:33:03 +01007 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
Radek Krejci535ea9f2020-05-29 16:01:05 +020015#define _GNU_SOURCE
Michal Vasko90932a92020-02-12 14:33:03 +010016
Radek Krejci1798aae2020-07-14 13:26:06 +020017#include <assert.h>
Radek Krejci47fab892020-11-05 17:02:41 +010018#include <stdint.h>
Michal Vasko90932a92020-02-12 14:33:03 +010019#include <stdlib.h>
20#include <string.h>
21
Radek Krejci535ea9f2020-05-29 16:01:05 +020022#include "common.h"
aPiecek49e2a3a2021-05-13 10:36:46 +020023#include "compat.h"
Michal Vasko90932a92020-02-12 14:33:03 +010024#include "context.h"
Radek Krejci47fab892020-11-05 17:02:41 +010025#include "dict.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020026#include "in_internal.h"
Radek Krejci1798aae2020-07-14 13:26:06 +020027#include "json.h"
Radek Krejci47fab892020-11-05 17:02:41 +010028#include "log.h"
Radek Krejci77114102021-03-10 15:21:57 +010029#include "parser_data.h"
Radek Krejci1798aae2020-07-14 13:26:06 +020030#include "parser_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010031#include "set.h"
32#include "tree.h"
Radek Krejci1798aae2020-07-14 13:26:06 +020033#include "tree_data.h"
34#include "tree_data_internal.h"
35#include "tree_schema.h"
Radek Krejci47fab892020-11-05 17:02:41 +010036#include "tree_schema_internal.h"
Radek Krejci1798aae2020-07-14 13:26:06 +020037#include "validation.h"
Michal Vasko90932a92020-02-12 14:33:03 +010038
39/**
Radek Krejci1798aae2020-07-14 13:26:06 +020040 * @brief Internal context for JSON YANG data parser.
41 *
42 * Note that the structure maps to the lyd_ctx which is common for all the data parsers
43 */
44struct lyd_json_ctx {
Radek Krejcif16e2542021-02-17 15:39:23 +010045 const struct lysc_ext_instance *ext; /**< extension instance possibly changing document root context of the data being parsed */
Michal Vaskoe0665742021-02-11 11:08:44 +010046 uint32_t parse_opts; /**< various @ref dataparseroptions. */
47 uint32_t val_opts; /**< various @ref datavalidationoptions. */
Radek Krejci1798aae2020-07-14 13:26:06 +020048 uint32_t int_opts; /**< internal data parser options */
49 uint32_t path_len; /**< used bytes in the path buffer */
50 char path[LYD_PARSER_BUFSIZE]; /**< buffer for the generated path */
Michal Vaskoc43c8ab2021-03-05 13:32:44 +010051 struct ly_set node_when; /**< set of nodes with "when" conditions */
Radek Krejci4f2e3e52021-03-30 14:20:28 +020052 struct ly_set node_exts; /**< set of nodes and extensions connected with a plugin providing own validation callback */
Michal Vasko49c39d82020-11-06 17:20:27 +010053 struct ly_set node_types; /**< set of nodes validated with LY_EINCOMPLETE result */
54 struct ly_set meta_types; /**< set of metadata validated with LY_EINCOMPLETE result */
Radek Krejci1798aae2020-07-14 13:26:06 +020055 struct lyd_node *op_node; /**< if an RPC/action/notification is being parsed, store the pointer to it */
56
57 /* callbacks */
58 lyd_ctx_free_clb free; /* destructor */
Radek Krejci1798aae2020-07-14 13:26:06 +020059
60 struct lyjson_ctx *jsonctx; /**< JSON context */
61};
62
63/**
64 * @brief Free the JSON data parser context.
65 *
66 * JSON implementation of lyd_ctx_free_clb().
67 */
68static void
69lyd_json_ctx_free(struct lyd_ctx *lydctx)
70{
71 struct lyd_json_ctx *ctx = (struct lyd_json_ctx *)lydctx;
72
73 if (lydctx) {
74 lyd_ctx_free(lydctx);
75 lyjson_ctx_free(ctx->jsonctx);
76 free(ctx);
77 }
78}
79
80/**
Radek Krejci1798aae2020-07-14 13:26:06 +020081 * @brief Parse JSON member-name as [\@][prefix:][name]
82 *
Michal Vaskocabe0702020-08-12 10:14:36 +020083 * \@ - metadata flag, maps to 1 in @p is_meta_p
Radek Krejci1798aae2020-07-14 13:26:06 +020084 * prefix - name of the module of the data node
85 * name - name of the data node
86 *
87 * All the output parameter are mandatory. Function only parse the member-name, all the appropriate checks are up to the caller.
88 *
89 * @param[in] value String to parse
90 * @param[in] value_len Length of the @p str.
91 * @param[out] name_p Pointer to the beginning of the parsed name.
92 * @param[out] name_len_p Pointer to the length of the parsed name.
93 * @param[out] prefix_p Pointer to the beginning of the parsed prefix. If the member-name does not contain prefix, result is NULL.
94 * @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 Vaskocabe0702020-08-12 10:14:36 +020095 * @param[out] is_meta_p Pointer to the metadata flag, set to 1 if the member-name contains \@, 0 otherwise.
Radek Krejci1798aae2020-07-14 13:26:06 +020096 */
97static void
Michal Vaskocabe0702020-08-12 10:14:36 +020098lydjson_parse_name(const char *value, size_t value_len, const char **name_p, size_t *name_len_p, const char **prefix_p,
Radek Krejci857189e2020-09-01 13:26:36 +020099 size_t *prefix_len_p, ly_bool *is_meta_p)
Radek Krejci1798aae2020-07-14 13:26:06 +0200100{
101 const char *name, *prefix = NULL;
102 size_t name_len, prefix_len = 0;
Radek Krejci857189e2020-09-01 13:26:36 +0200103 ly_bool is_meta = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200104
105 name = memchr(value, ':', value_len);
106 if (name != NULL) {
107 prefix = value;
108 if (*prefix == '@') {
Michal Vaskocabe0702020-08-12 10:14:36 +0200109 is_meta = 1;
Radek Krejci1798aae2020-07-14 13:26:06 +0200110 prefix++;
111 }
112 prefix_len = name - prefix;
113 name++;
Michal Vaskocabe0702020-08-12 10:14:36 +0200114 name_len = value_len - (prefix_len + 1) - is_meta;
Radek Krejci1798aae2020-07-14 13:26:06 +0200115 } else {
116 name = value;
117 if (name[0] == '@') {
Michal Vaskocabe0702020-08-12 10:14:36 +0200118 is_meta = 1;
Radek Krejci1798aae2020-07-14 13:26:06 +0200119 name++;
120 }
Michal Vaskocabe0702020-08-12 10:14:36 +0200121 name_len = value_len - is_meta;
Michal Vasko90932a92020-02-12 14:33:03 +0100122 }
123
Radek Krejci1798aae2020-07-14 13:26:06 +0200124 *name_p = name;
125 *name_len_p = name_len;
126 *prefix_p = prefix;
127 *prefix_len_p = prefix_len;
Michal Vaskocabe0702020-08-12 10:14:36 +0200128 *is_meta_p = is_meta;
Radek Krejci1798aae2020-07-14 13:26:06 +0200129}
130
131/**
132 * @brief Get correct prefix (module_name) inside the @p node.
133 *
134 * @param[in] node Data node to get inherited prefix.
135 * @param[in] local_prefix Local prefix to replace the inherited prefix.
136 * @param[in] local_prefix_len Length of the @p local_prefix string. In case of 0, the inherited prefix is taken.
137 * @param[out] prefix_p Pointer to the resulting prefix string, Note that the result can be NULL in case of no local prefix
138 * and no context @p node to get inherited prefix.
139 * @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
140 * of no local prefix and no context @p node to get inherited prefix.
141 * @return LY_ERR value.
142 */
143static LY_ERR
Michal Vaskoa5da3292020-08-12 13:10:50 +0200144lydjson_get_node_prefix(struct lyd_node *node, const char *local_prefix, size_t local_prefix_len, const char **prefix_p,
Radek Krejci0f969882020-08-21 16:56:47 +0200145 size_t *prefix_len_p)
Radek Krejci1798aae2020-07-14 13:26:06 +0200146{
147 struct lyd_node_opaq *onode;
148 const char *module_name = NULL;
149
150 assert(prefix_p && prefix_len_p);
151
152 if (local_prefix_len) {
153 *prefix_p = local_prefix;
154 *prefix_len_p = local_prefix_len;
155 return LY_SUCCESS;
156 }
157
158 *prefix_p = NULL;
159 while (node) {
160 if (node->schema) {
161 *prefix_p = node->schema->module->name;
162 break;
163 }
Michal Vasko22df3f02020-08-24 13:29:22 +0200164 onode = (struct lyd_node_opaq *)node;
Michal Vaskoad92b672020-11-12 13:11:31 +0100165 if (onode->name.module_name) {
166 *prefix_p = onode->name.module_name;
Radek Krejci1798aae2020-07-14 13:26:06 +0200167 break;
Michal Vaskoad92b672020-11-12 13:11:31 +0100168 } else if (onode->name.prefix) {
169 *prefix_p = onode->name.prefix;
Radek Krejci1798aae2020-07-14 13:26:06 +0200170 break;
171 }
Michal Vasko9e685082021-01-29 14:49:09 +0100172 node = lyd_parent(node);
Radek Krejci1798aae2020-07-14 13:26:06 +0200173 }
174 *prefix_len_p = ly_strlen(module_name);
175
176 return LY_SUCCESS;
177}
178
179/**
180 * @brief Get schema node corresponding to the input parameters.
181 *
182 * @param[in] lydctx JSON data parser context.
183 * @param[in] is_attr Flag if the reference to the node is an attribute, for logging only.
184 * @param[in] prefix Requested node's prefix (module name).
185 * @param[in] prefix_len Length of the @p prefix.
186 * @param[in] name Requested node's name.
187 * @param[in] name_len Length of the @p name.
Michal Vasko2552ea32020-12-08 15:32:34 +0100188 * @param[in] parent Parent of the node being processed, can be NULL in case of top-level.
Radek Krejci1798aae2020-07-14 13:26:06 +0200189 * @param[out] snode_p Pointer to the found schema node corresponding to the input parameters.
190 * @return LY_SUCCES on success, note that even in this case the returned value of @p snode_p can be NULL, so the data are expected to be parsed as opaq.
191 * @return LY_EVALID on failure, error message is logged
192 * @return LY_ENOT in case the input data are expected to be skipped
193 */
194static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200195lydjson_get_snode(const struct lyd_json_ctx *lydctx, ly_bool is_attr, const char *prefix, size_t prefix_len, const char *name,
Radek Krejci0f969882020-08-21 16:56:47 +0200196 size_t name_len, const struct lyd_node_inner *parent, const struct lysc_node **snode_p)
Radek Krejci1798aae2020-07-14 13:26:06 +0200197{
Radek Krejci2efc45b2020-12-22 16:25:44 +0100198 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +0200199 struct lys_module *mod = NULL;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100200 uint32_t getnext_opts = lydctx->int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200201
202 /* init return value */
203 *snode_p = NULL;
204
Michal Vasko9e543402021-06-11 13:55:30 +0200205 LOG_LOCSET(NULL, parent ? &parent->node : NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100206
Radek Krejci1798aae2020-07-14 13:26:06 +0200207 /* get the element module */
Michal Vasko2552ea32020-12-08 15:32:34 +0100208 if (prefix_len) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200209 mod = ly_ctx_get_module_implemented2(lydctx->jsonctx->ctx, prefix, prefix_len);
210 } else if (parent) {
211 if (parent->schema) {
212 mod = parent->schema->module;
213 }
214 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100215 LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX_JSON, "Top-level JSON object member \"%.*s\" must be namespace-qualified.",
Radek Krejci422afb12021-03-04 16:38:16 +0100216 (int)(is_attr ? name_len + 1 : name_len), is_attr ? name - 1 : name);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100217 ret = LY_EVALID;
218 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +0200219 }
220 if (!mod) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100221 if (lydctx->parse_opts & LYD_PARSE_STRICT) {
Radek Krejci422afb12021-03-04 16:38:16 +0100222 LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "No module named \"%.*s\" in the context.", (int)prefix_len, prefix);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100223 ret = LY_EVALID;
224 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +0200225 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100226 if (!(lydctx->parse_opts & LYD_PARSE_OPAQ)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100227 ret = LY_ENOT;
228 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +0200229 }
230 }
231
Radek Krejci1798aae2020-07-14 13:26:06 +0200232 /* get the schema node */
233 if (mod && (!parent || parent->schema)) {
Radek Krejcif16e2542021-02-17 15:39:23 +0100234 if (!parent && lydctx->ext) {
Radek Krejciba05eab2021-03-10 13:19:29 +0100235 *snode_p = lysc_ext_find_node(lydctx->ext, mod, name, name_len, 0, getnext_opts);
Radek Krejcif16e2542021-02-17 15:39:23 +0100236 } else {
237 *snode_p = lys_find_child(parent ? parent->schema : NULL, mod, name, name_len, 0, getnext_opts);
238 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200239 if (!*snode_p) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100240 if (lydctx->parse_opts & LYD_PARSE_STRICT) {
Radek Krejcif16e2542021-02-17 15:39:23 +0100241 if (lydctx->ext) {
242 if (lydctx->ext->argument) {
243 LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Node \"%.*s\" not found in the \"%s\" %s extension instance.",
Radek Krejci422afb12021-03-04 16:38:16 +0100244 (int)name_len, name, lydctx->ext->argument, lydctx->ext->def->name);
Radek Krejcif16e2542021-02-17 15:39:23 +0100245 } else {
246 LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Node \"%.*s\" not found in the %s extension instance.",
Radek Krejci422afb12021-03-04 16:38:16 +0100247 (int)name_len, name, lydctx->ext->def->name);
Radek Krejcif16e2542021-02-17 15:39:23 +0100248 }
249 } else {
250 LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Node \"%.*s\" not found in the \"%s\" module.",
Radek Krejci422afb12021-03-04 16:38:16 +0100251 (int)name_len, name, mod->name);
Radek Krejcif16e2542021-02-17 15:39:23 +0100252 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100253 ret = LY_EVALID;
254 goto cleanup;
Michal Vaskoe0665742021-02-11 11:08:44 +0100255 } else if (!(lydctx->parse_opts & LYD_PARSE_OPAQ)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200256 /* skip element with children */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100257 ret = LY_ENOT;
258 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +0200259 }
260 } else {
261 /* check that schema node is valid and can be used */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100262 ret = lyd_parser_check_schema((struct lyd_ctx *)lydctx, *snode_p);
Radek Krejci1798aae2020-07-14 13:26:06 +0200263 }
264 }
265
Radek Krejci2efc45b2020-12-22 16:25:44 +0100266cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100267 LOG_LOCBACK(0, parent ? 1 : 0, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100268 return ret;
Radek Krejci1798aae2020-07-14 13:26:06 +0200269}
270
271/**
272 * @brief Skip the currently open JSON object/array
273 * @param[in] jsonctx JSON context with the input data to skip.
274 * @return LY_ERR value.
275 */
276static LY_ERR
277lydjson_data_skip(struct lyjson_ctx *jsonctx)
278{
279 enum LYJSON_PARSER_STATUS status, current;
280 size_t sublevels = 1;
281
282 status = lyjson_ctx_status(jsonctx, 0);
283
284 /* skip after the content */
285 do {
286 LY_CHECK_RET(lyjson_ctx_next(jsonctx, &current));
287 if (current == status) {
288 sublevels++;
289 } else if (current == status + 1) {
290 sublevels--;
291 }
Radek Krejci79856c42020-11-19 11:44:08 +0100292 } while (current != status + 1 || sublevels);
Radek Krejci1798aae2020-07-14 13:26:06 +0200293 /* open the next sibling */
294 LY_CHECK_RET(lyjson_ctx_next(jsonctx, NULL));
295
296 return LY_SUCCESS;
297}
298
299/**
Radek Krejci1798aae2020-07-14 13:26:06 +0200300 * @brief Check that the input data are parseable as the @p list.
301 *
302 * Checks for all the list's keys. Function does not revert the context state.
303 *
304 * @param[in] jsonctx JSON parser context.
305 * @param[in] list List schema node corresponding to the input data object.
306 * @return LY_SUCCESS in case the data are ok for the @p list
307 * @return LY_ENOT in case the input data are not sufficient to fully parse the list instance.
308 */
309static LY_ERR
310lydjson_check_list(struct lyjson_ctx *jsonctx, const struct lysc_node *list)
311{
312 LY_ERR ret = LY_SUCCESS;
313 enum LYJSON_PARSER_STATUS status = lyjson_ctx_status(jsonctx, 0);
314 struct ly_set key_set = {0};
315 const struct lysc_node *snode;
316 uint32_t i, status_count;
317
318 assert(list && (list->nodetype == LYS_LIST));
319 assert(status == LYJSON_OBJECT);
320
321 /* get all keys into a set (keys do not have if-features or anything) */
322 snode = NULL;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100323 while ((snode = lys_getnext(snode, list, NULL, 0)) && (snode->flags & LYS_KEY)) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200324 ret = ly_set_add(&key_set, (void *)snode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200325 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +0200326 }
327
328 if (status != LYJSON_OBJECT_EMPTY) {
329 status_count = jsonctx->status.count;
330
331 while (key_set.count && status != LYJSON_OBJECT_CLOSED) {
332 const char *name, *prefix;
333 size_t name_len, prefix_len;
Radek Krejci857189e2020-09-01 13:26:36 +0200334 ly_bool is_attr;
Radek Krejci1798aae2020-07-14 13:26:06 +0200335
336 /* match the key */
337 snode = NULL;
338 lydjson_parse_name(jsonctx->value, jsonctx->value_len, &name, &name_len, &prefix, &prefix_len, &is_attr);
339
340 if (!is_attr && !prefix) {
341 for (i = 0; i < key_set.count; ++i) {
342 snode = (const struct lysc_node *)key_set.objs[i];
343 if (!ly_strncmp(snode->name, name, name_len)) {
344 break;
345 }
346 }
347 /* go into the item to a) process it as a key or b) start skipping it as another list child */
348 ret = lyjson_ctx_next(jsonctx, &status);
349 LY_CHECK_GOTO(ret, cleanup);
350
351 if (snode) {
352 /* we have the key, validate the value */
353 if (status < LYJSON_NUMBER) {
354 /* not a terminal */
355 ret = LY_ENOT;
356 goto cleanup;
357 }
358
Radek Krejci8df109d2021-04-23 12:19:08 +0200359 ret = lys_value_validate(NULL, snode, jsonctx->value, jsonctx->value_len, LY_VALUE_JSON, NULL);
Radek Krejci1798aae2020-07-14 13:26:06 +0200360 LY_CHECK_GOTO(ret, cleanup);
361
362 /* key with a valid value, remove from the set */
363 ly_set_rm_index(&key_set, i, NULL);
364 }
365 } else {
366 /* start skipping the member we are not interested in */
367 ret = lyjson_ctx_next(jsonctx, &status);
368 LY_CHECK_GOTO(ret, cleanup);
369 }
370 /* move to the next child */
371 while (status_count < jsonctx->status.count) {
372 ret = lyjson_ctx_next(jsonctx, &status);
373 LY_CHECK_GOTO(ret, cleanup);
374 }
375 }
376 }
377
378 if (key_set.count) {
379 /* some keys are missing/did not validate */
380 ret = LY_ENOT;
381 }
382
383cleanup:
384 ly_set_erase(&key_set, NULL);
385 return ret;
386}
387
388/**
389 * @brief Get the hint for the data type parsers according to the current JSON parser context.
390 *
391 * @param[in] lydctx JSON data parser context. The context is supposed to be on a value.
392 * @param[in,out] status Pointer to the current context status,
393 * in some circumstances the function manipulates with the context so the status is updated.
394 * @param[out] type_hint_p Pointer to the variable to store the result.
395 * @return LY_SUCCESS in case of success.
396 * @return LY_EINVAL in case of invalid context status not referring to a value.
397 */
398static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200399lydjson_value_type_hint(struct lyd_json_ctx *lydctx, enum LYJSON_PARSER_STATUS *status_p, uint32_t *type_hint_p)
Radek Krejci1798aae2020-07-14 13:26:06 +0200400{
401 *type_hint_p = 0;
402
403 if (*status_p == LYJSON_ARRAY) {
404 /* only [null] */
405 LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, status_p));
406 LY_CHECK_RET(*status_p != LYJSON_NULL, LY_EINVAL);
407
408 LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, NULL));
409 LY_CHECK_RET(lyjson_ctx_status(lydctx->jsonctx, 0) != LYJSON_ARRAY_CLOSED, LY_EINVAL);
410
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200411 *type_hint_p = LYD_VALHINT_EMPTY;
Radek Krejci1798aae2020-07-14 13:26:06 +0200412 } else if (*status_p == LYJSON_STRING) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200413 *type_hint_p = LYD_VALHINT_STRING | LYD_VALHINT_NUM64;
Radek Krejci1798aae2020-07-14 13:26:06 +0200414 } else if (*status_p == LYJSON_NUMBER) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200415 *type_hint_p = LYD_VALHINT_DECNUM;
Michal Vasko69730152020-10-09 16:30:07 +0200416 } else if ((*status_p == LYJSON_FALSE) || (*status_p == LYJSON_TRUE)) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200417 *type_hint_p = LYD_VALHINT_BOOLEAN;
Radek Krejci1798aae2020-07-14 13:26:06 +0200418 } else if (*status_p == LYJSON_NULL) {
419 *type_hint_p = 0;
420 } else {
421 return LY_EINVAL;
422 }
423
424 return LY_SUCCESS;
425}
426
427/**
428 * @brief Check in advance if the input data are parsable according to the provided @p snode.
429 *
430 * Note that the checks are done only in case the LYD_PARSE_OPAQ is allowed. Otherwise the same checking
431 * is naturally done when the data are really parsed.
432 *
433 * @param[in] lydctx JSON data parser context. When the function returns, the context is in the same state
434 * as before calling, despite it is necessary to process input data for checking.
435 * @param[in] snode Schema node corresponding to the member currently being processed in the context.
436 * @param[out] type_hint_p Pointer to a variable to store detected value type hint in case of leaf or leaf-list.
437 * @return LY_SUCCESS in case the data are ok for the @p snode or the LYD_PARSE_OPAQ is not enabled.
438 * @return LY_ENOT in case the input data are not sufficient to fully parse the list instance
439 * @return LY_EINVAL in case of invalid leaf JSON encoding
440 * and they are expected to be parsed as opaq nodes.
441 */
442static LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200443lydjson_data_check_opaq(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, uint32_t *type_hint_p)
Radek Krejci1798aae2020-07-14 13:26:06 +0200444{
445 LY_ERR ret = LY_SUCCESS;
446 struct lyjson_ctx *jsonctx = lydctx->jsonctx;
447 enum LYJSON_PARSER_STATUS status;
448
449 assert(snode);
Radek Krejci1798aae2020-07-14 13:26:06 +0200450
Michal Vasko32ac9942020-08-12 14:35:12 +0200451 if (!(snode->nodetype & (LYD_NODE_TERM | LYS_LIST))) {
452 /* can always be parsed as a data node if we have the schema node */
453 return LY_SUCCESS;
454 }
455
Michal Vaskoe0665742021-02-11 11:08:44 +0100456 if (lydctx->parse_opts & LYD_PARSE_OPAQ) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200457 /* backup parser */
458 lyjson_ctx_backup(jsonctx);
459 status = lyjson_ctx_status(jsonctx, 0);
460
Michal Vasko32ac9942020-08-12 14:35:12 +0200461 /* check if the node is parseable. if not, NULL the snode to announce that it is supposed to be parsed
462 * as an opaq node */
Radek Krejci1798aae2020-07-14 13:26:06 +0200463 switch (snode->nodetype) {
464 case LYS_LEAFLIST:
465 case LYS_LEAF:
466 /* value may not be valid in which case we parse it as an opaque node */
467 ret = lydjson_value_type_hint(lydctx, &status, type_hint_p);
468 if (ret) {
469 break;
470 }
471
Radek Krejci8df109d2021-04-23 12:19:08 +0200472 if (lys_value_validate(NULL, snode, jsonctx->value, jsonctx->value_len, LY_VALUE_JSON, NULL)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200473 ret = LY_ENOT;
474 }
475 break;
476 case LYS_LIST:
477 /* lists may not have all its keys */
478 if (lydjson_check_list(jsonctx, snode)) {
479 /* invalid list, parse as opaque if it missing/has invalid some keys */
480 ret = LY_ENOT;
481 }
Michal Vasko32ac9942020-08-12 14:35:12 +0200482 break;
Radek Krejci1798aae2020-07-14 13:26:06 +0200483 }
484
485 /* restore parser */
486 lyjson_ctx_restore(jsonctx);
Michal Vasko32ac9942020-08-12 14:35:12 +0200487 } else if (snode->nodetype & LYD_NODE_TERM) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200488 status = lyjson_ctx_status(jsonctx, 0);
489 ret = lydjson_value_type_hint(lydctx, &status, type_hint_p);
490 }
491
492 return ret;
493}
494
495/**
496 * @brief Join the forward-referencing metadata with their target data nodes.
497 *
498 * Note that JSON encoding for YANG data allows forward-referencing metadata only for leafs/leaf-lists.
499 *
500 * @param[in] lydctx JSON data parser context.
501 * @param[in,out] first_p Pointer to the first sibling node variable (top-level or in a particular parent node)
502 * as a starting point to search for the metadata's target data node
503 * @return LY_SUCCESS on success
504 * @return LY_EVALID in case there are some metadata with unresolved target data node instance
505 */
506static LY_ERR
507lydjson_metadata_finish(struct lyd_json_ctx *lydctx, struct lyd_node **first_p)
508{
509 LY_ERR ret = LY_SUCCESS;
aPiecek5057c2e2021-05-17 10:28:03 +0200510 struct lyd_node *node, *attr, *next, *meta_iter;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200511 uint64_t instance = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200512 const char *prev = NULL;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100513 uint32_t log_location_items = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200514
515 /* finish linking metadata */
516 LY_LIST_FOR_SAFE(*first_p, next, attr) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200517 struct lyd_node_opaq *meta_container = (struct lyd_node_opaq *)attr;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200518 uint64_t match = 0;
Radek Krejci857189e2020-09-01 13:26:36 +0200519 ly_bool is_attr;
Radek Krejci1798aae2020-07-14 13:26:06 +0200520 const char *name, *prefix;
521 size_t name_len, prefix_len;
522 const struct lysc_node *snode;
523
Michal Vaskoad92b672020-11-12 13:11:31 +0100524 if (attr->schema || (meta_container->name.name[0] != '@')) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200525 /* not an opaq metadata node */
526 continue;
527 }
528
Radek Krejciddace2c2021-01-08 11:30:56 +0100529 LOG_LOCSET(NULL, attr, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100530 log_location_items++;
531
Michal Vaskoad92b672020-11-12 13:11:31 +0100532 if (prev != meta_container->name.name) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200533 /* metas' names are stored in dictionary, so checking pointers must works */
534 lydict_remove(lydctx->jsonctx->ctx, prev);
Michal Vaskoad92b672020-11-12 13:11:31 +0100535 LY_CHECK_GOTO(ret = lydict_insert(lydctx->jsonctx->ctx, meta_container->name.name, 0, &prev), cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +0200536 instance = 1;
537 } else {
538 instance++;
539 }
540
aPiecek5057c2e2021-05-17 10:28:03 +0200541 /* find the corresponding data node */
542 LY_LIST_FOR(*first_p, node) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200543 if (!node->schema) {
544 /* opaq node - we are going to put into it just a generic attribute. */
Michal Vaskoad92b672020-11-12 13:11:31 +0100545 if (strcmp(&meta_container->name.name[1], ((struct lyd_node_opaq *)node)->name.name)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200546 continue;
547 }
548
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200549 if (((struct lyd_node_opaq *)node)->hints & LYD_NODEHINT_LIST) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100550 LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX, "Metadata container references a sibling list node %s.",
551 ((struct lyd_node_opaq *)node)->name.name);
Radek Krejci1798aae2020-07-14 13:26:06 +0200552 ret = LY_EVALID;
553 goto cleanup;
554 }
555
556 /* match */
557 match++;
558 if (match != instance) {
559 continue;
560 }
561
562 LY_LIST_FOR(meta_container->child, meta_iter) {
563 /* convert opaq node to a attribute of the opaq node */
Michal Vasko22df3f02020-08-24 13:29:22 +0200564 struct lyd_node_opaq *meta = (struct lyd_node_opaq *)meta_iter;
Radek Krejcibb27df32020-11-13 15:39:16 +0100565
Michal Vaskoad92b672020-11-12 13:11:31 +0100566 ret = lyd_create_attr(node, NULL, lydctx->jsonctx->ctx, meta->name.name, strlen(meta->name.name),
567 meta->name.prefix, ly_strlen(meta->name.prefix), meta->name.module_name,
Radek Krejci8df109d2021-04-23 12:19:08 +0200568 ly_strlen(meta->name.module_name), meta->value, ly_strlen(meta->value), NULL, LY_VALUE_JSON,
Michal Vaskoad92b672020-11-12 13:11:31 +0100569 NULL, meta->hints);
Radek Krejci1798aae2020-07-14 13:26:06 +0200570 LY_CHECK_GOTO(ret, cleanup);
571 }
572
573 /* done */
574 break;
575 } else {
576 /* this is the second time we are resolving the schema node, so it must succeed,
577 * but remember that snode can be still NULL */
Michal Vaskoad92b672020-11-12 13:11:31 +0100578 lydjson_parse_name(meta_container->name.name, strlen(meta_container->name.name), &name, &name_len,
579 &prefix, &prefix_len, &is_attr);
Radek Krejci1798aae2020-07-14 13:26:06 +0200580 assert(is_attr);
581 ret = lydjson_get_snode(lydctx, is_attr, prefix, prefix_len, name, name_len, (*first_p)->parent, &snode);
582 assert(ret == LY_SUCCESS);
583
584 if (snode != node->schema) {
585 continue;
586 }
587
588 /* match */
589 match++;
590 if (match != instance) {
591 continue;
592 }
593
594 LY_LIST_FOR(meta_container->child, meta_iter) {
595 /* convert opaq node to a metadata of the node */
Michal Vasko22df3f02020-08-24 13:29:22 +0200596 struct lyd_node_opaq *meta = (struct lyd_node_opaq *)meta_iter;
Radek Krejci1798aae2020-07-14 13:26:06 +0200597 struct lys_module *mod = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200598 ly_bool dynamic = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200599
Michal Vaskoad92b672020-11-12 13:11:31 +0100600 mod = ly_ctx_get_module_implemented(lydctx->jsonctx->ctx, meta->name.prefix);
Radek Krejci1798aae2020-07-14 13:26:06 +0200601 if (mod) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200602 ret = lyd_parser_create_meta((struct lyd_ctx *)lydctx, node, NULL, mod,
Michal Vaskoad92b672020-11-12 13:11:31 +0100603 meta->name.name, strlen(meta->name.name), meta->value, ly_strlen(meta->value),
Radek Krejci8df109d2021-04-23 12:19:08 +0200604 &dynamic, LY_VALUE_JSON, NULL, meta->hints);
Radek Krejci1798aae2020-07-14 13:26:06 +0200605 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +0100606 } else if (lydctx->parse_opts & LYD_PARSE_STRICT) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100607 LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE,
Michal Vasko69730152020-10-09 16:30:07 +0200608 "Unknown (or not implemented) YANG module \"%s\" for metadata \"%s%s%s\".",
Michal Vaskoad92b672020-11-12 13:11:31 +0100609 meta->name.prefix, meta->name.prefix, ly_strlen(meta->name.prefix) ? ":" : "", meta->name.name);
Radek Krejci1798aae2020-07-14 13:26:06 +0200610 ret = LY_EVALID;
611 goto cleanup;
612 }
613 }
614 /* add/correct flags */
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200615 lyd_parse_set_data_flags(node, &lydctx->node_when, &lydctx->node_exts, &node->meta, lydctx->parse_opts);
Radek Krejci1798aae2020-07-14 13:26:06 +0200616
617 /* done */
618 break;
619 }
620 }
621
622 if (match != instance) {
623 /* there is no corresponding data node for the metadata */
624 if (instance > 1) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100625 LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Missing %d%s JSON data instance to be coupled with %s metadata.",
626 instance, instance == 2 ? "nd" : (instance == 3 ? "rd" : "th"), meta_container->name.name);
Radek Krejci1798aae2020-07-14 13:26:06 +0200627 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100628 LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Missing JSON data instance to be coupled with %s metadata.",
629 meta_container->name.name);
Radek Krejci1798aae2020-07-14 13:26:06 +0200630 }
631 ret = LY_EVALID;
632 } else {
633 /* remove the opaq attr */
634 if (attr == (*first_p)) {
aPiecek5057c2e2021-05-17 10:28:03 +0200635 *first_p = attr->next;
Radek Krejci1798aae2020-07-14 13:26:06 +0200636 }
637 lyd_free_tree(attr);
638 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100639
Radek Krejciddace2c2021-01-08 11:30:56 +0100640 LOG_LOCBACK(0, log_location_items, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100641 log_location_items = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200642 }
643
644cleanup:
645 lydict_remove(lydctx->jsonctx->ctx, prev);
646
Radek Krejciddace2c2021-01-08 11:30:56 +0100647 LOG_LOCBACK(0, log_location_items, 0, 0);
Radek Krejci1798aae2020-07-14 13:26:06 +0200648 return ret;
649}
650
651/**
652 * @brief Parse a metadata member.
653 *
654 * @param[in] lydctx JSON data parser context.
655 * @param[in] snode Schema node of the metadata parent.
656 * @param[in] node Parent node in case the metadata is not forward-referencing (only LYD_NODE_TERM)
657 * so the data node does not exists. In such a case the metadata is stored in the context for the later
658 * processing by lydjson_metadata_finish().
659 * @return LY_SUCCESS on success
660 * @return Various LY_ERR values in case of failure.
661 */
662static LY_ERR
663lydjson_metadata(struct lyd_json_ctx *lydctx, const struct lysc_node *snode, struct lyd_node *node)
664{
665 LY_ERR ret = LY_SUCCESS;
666 enum LYJSON_PARSER_STATUS status;
667 const char *expected;
Radek Krejci857189e2020-09-01 13:26:36 +0200668 ly_bool in_parent = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200669 const char *name, *prefix = NULL;
670 size_t name_len, prefix_len = 0;
671 struct lys_module *mod;
672 struct lyd_meta *meta = NULL;
673 const struct ly_ctx *ctx = lydctx->jsonctx->ctx;
Radek Krejci857189e2020-09-01 13:26:36 +0200674 ly_bool is_attr = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200675 struct lyd_node *prev = node;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200676 uint32_t instance = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +0200677 uint16_t nodetype;
678
679 assert(snode || node);
680
681 nodetype = snode ? snode->nodetype : LYS_CONTAINER;
682
683 /* move to the second item in the name/X pair */
684 ret = lyjson_ctx_next(lydctx->jsonctx, &status);
685 LY_CHECK_GOTO(ret, cleanup);
686
687 /* check attribute encoding */
688 switch (nodetype) {
689 case LYS_LEAFLIST:
690 expected = "@name/array of objects/nulls";
691
692 LY_CHECK_GOTO(status != LYJSON_ARRAY, representation_error);
693
694next_entry:
695 instance++;
696
697 /* move into array / next entry */
698 ret = lyjson_ctx_next(lydctx->jsonctx, &status);
699 LY_CHECK_GOTO(ret, cleanup);
700
701 if (status == LYJSON_ARRAY_CLOSED) {
702 /* we are done, move after the array */
703 ret = lyjson_ctx_next(lydctx->jsonctx, NULL);
704 goto cleanup;
705 }
706 LY_CHECK_GOTO(status != LYJSON_OBJECT && status != LYJSON_NULL, representation_error);
707
Michal Vasko69730152020-10-09 16:30:07 +0200708 if (!node || (node->schema != prev->schema)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100709 LOGVAL(lydctx->jsonctx->ctx, LYVE_REFERENCE, "Missing JSON data instance no. %u of %s:%s to be coupled with metadata.",
Michal Vasko69730152020-10-09 16:30:07 +0200710 instance, prev->schema->module->name, prev->schema->name);
Radek Krejci1798aae2020-07-14 13:26:06 +0200711 ret = LY_EVALID;
712 goto cleanup;
713 }
714
715 if (status == LYJSON_NULL) {
716 /* continue with the next entry in the leaf-list array */
717 prev = node;
718 node = node->next;
719 goto next_entry;
720 }
721 break;
722 case LYS_LEAF:
723 case LYS_ANYXML:
724 expected = "@name/object";
725
aPiecek5b115fc2021-05-24 14:32:42 +0200726 LY_CHECK_GOTO(status != LYJSON_OBJECT, representation_error);
Radek Krejci1798aae2020-07-14 13:26:06 +0200727 break;
728 case LYS_CONTAINER:
729 case LYS_LIST:
730 case LYS_ANYDATA:
731 case LYS_NOTIF:
732 case LYS_ACTION:
733 case LYS_RPC:
734 in_parent = 1;
735 expected = "@/object";
736 LY_CHECK_GOTO(status != LYJSON_OBJECT, representation_error);
737 break;
Radek Krejci8f5fad22020-09-15 16:50:54 +0200738 default:
739 LOGINT_RET(ctx);
Radek Krejci1798aae2020-07-14 13:26:06 +0200740 }
741
742 /* process all the members inside a single metadata object */
743 assert(status == LYJSON_OBJECT);
744
Radek Krejciddace2c2021-01-08 11:30:56 +0100745 LOG_LOCSET(snode, NULL, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100746
Radek Krejci1798aae2020-07-14 13:26:06 +0200747 while (status != LYJSON_OBJECT_CLOSED) {
748 lydjson_parse_name(lydctx->jsonctx->value, lydctx->jsonctx->value_len, &name, &name_len, &prefix, &prefix_len, &is_attr);
749 if (!prefix) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100750 LOGVAL(ctx, LYVE_SYNTAX_JSON, "Metadata in JSON must be namespace-qualified, missing prefix for \"%.*s\".",
Radek Krejci422afb12021-03-04 16:38:16 +0100751 (int)lydctx->jsonctx->value_len, lydctx->jsonctx->value);
Radek Krejci1798aae2020-07-14 13:26:06 +0200752 ret = LY_EVALID;
753 goto cleanup;
754 } else if (is_attr) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100755 LOGVAL(ctx, LYVE_SYNTAX_JSON, "Invalid format of the Metadata identifier in JSON, unexpected '@' in \"%.*s\"",
Radek Krejci422afb12021-03-04 16:38:16 +0100756 (int)lydctx->jsonctx->value_len, lydctx->jsonctx->value);
Radek Krejci1798aae2020-07-14 13:26:06 +0200757 ret = LY_EVALID;
758 goto cleanup;
759 }
760
761 /* get the element module */
762 mod = ly_ctx_get_module_implemented2(ctx, prefix, prefix_len);
763 if (!mod) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100764 if (lydctx->parse_opts & LYD_PARSE_STRICT) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100765 LOGVAL(ctx, LYVE_REFERENCE, "Prefix \"%.*s\" of the metadata \"%.*s\" does not match any module in the context.",
Radek Krejci422afb12021-03-04 16:38:16 +0100766 (int)prefix_len, prefix, (int)name_len, name);
Radek Krejci1798aae2020-07-14 13:26:06 +0200767 ret = LY_EVALID;
768 goto cleanup;
769 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100770 if (!(lydctx->parse_opts & LYD_PARSE_OPAQ)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200771 /* skip element with children */
772 ret = lydjson_data_skip(lydctx->jsonctx);
773 LY_CHECK_GOTO(ret, cleanup);
774 status = lyjson_ctx_status(lydctx->jsonctx, 0);
775 /* end of the item */
776 continue;
777 }
778 }
779
780 /* get the value */
781 ret = lyjson_ctx_next(lydctx->jsonctx, NULL);
782 LY_CHECK_GOTO(ret, cleanup);
783
784 if (node->schema) {
785 /* create metadata */
786 meta = NULL;
Michal Vasko22df3f02020-08-24 13:29:22 +0200787 ret = lyd_parser_create_meta((struct lyd_ctx *)lydctx, node, &meta, mod, name, name_len, lydctx->jsonctx->value,
Radek Krejci8df109d2021-04-23 12:19:08 +0200788 lydctx->jsonctx->value_len, &lydctx->jsonctx->dynamic, LY_VALUE_JSON, NULL,
Michal Vasko69730152020-10-09 16:30:07 +0200789 LYD_HINT_DATA);
Radek Krejci1798aae2020-07-14 13:26:06 +0200790 LY_CHECK_GOTO(ret, cleanup);
791
792 /* add/correct flags */
Radek Krejci4f2e3e52021-03-30 14:20:28 +0200793 lyd_parse_set_data_flags(node, &lydctx->node_when, &lydctx->node_exts, &meta, lydctx->parse_opts);
Radek Krejci1798aae2020-07-14 13:26:06 +0200794 } else {
795 /* create attribute */
Radek Krejci1798aae2020-07-14 13:26:06 +0200796 const char *module_name;
797 size_t module_name_len;
798
799 lydjson_get_node_prefix(node, prefix, prefix_len, &module_name, &module_name_len);
800
Radek Krejci1798aae2020-07-14 13:26:06 +0200801 /* attr2 is always changed to the created attribute */
Michal Vasko501af032020-11-11 20:27:44 +0100802 ret = lyd_create_attr(node, NULL, lydctx->jsonctx->ctx, name, name_len, prefix, prefix_len, module_name,
803 module_name_len, lydctx->jsonctx->value, lydctx->jsonctx->value_len, &lydctx->jsonctx->dynamic,
Radek Krejci8df109d2021-04-23 12:19:08 +0200804 LY_VALUE_JSON, NULL, 0);
Radek Krejci1798aae2020-07-14 13:26:06 +0200805 LY_CHECK_GOTO(ret, cleanup);
806 }
807 /* next member */
808 ret = lyjson_ctx_next(lydctx->jsonctx, &status);
809 LY_CHECK_GOTO(ret, cleanup);
aPiecekde3c6922021-05-24 14:42:10 +0200810 LY_CHECK_GOTO((status != LYJSON_OBJECT) && (status != LYJSON_OBJECT_CLOSED), representation_error);
Radek Krejci1798aae2020-07-14 13:26:06 +0200811 }
812
813 if (nodetype == LYS_LEAFLIST) {
814 /* continue by processing another metadata object for the following
815 * leaf-list instance since they are allways instantiated in JSON array */
816 prev = node;
817 node = node->next;
818 goto next_entry;
819 }
820
821 /* move after the metadata */
822 ret = lyjson_ctx_next(lydctx->jsonctx, NULL);
823 LY_CHECK_GOTO(ret, cleanup);
824
Radek Krejci5813c362021-01-05 10:51:57 +0100825 /* success */
826 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +0200827
828representation_error:
Radek Krejci2efc45b2020-12-22 16:25:44 +0100829 LOGVAL(ctx, LYVE_SYNTAX_JSON,
Michal Vasko69730152020-10-09 16:30:07 +0200830 "The attribute(s) of %s \"%s\" is expected to be represented as JSON %s, but input data contains @%s/%s.",
Michal Vaskoad92b672020-11-12 13:11:31 +0100831 lys_nodetype2str(nodetype), node->schema ? node->schema->name : ((struct lyd_node_opaq *)node)->name.name,
Michal Vasko69730152020-10-09 16:30:07 +0200832 expected, lyjson_token2str(status), in_parent ? "" : "name");
Radek Krejci1798aae2020-07-14 13:26:06 +0200833
Radek Krejci2efc45b2020-12-22 16:25:44 +0100834 ret = LY_EVALID;
Radek Krejci5813c362021-01-05 10:51:57 +0100835
836cleanup:
Radek Krejciddace2c2021-01-08 11:30:56 +0100837 LOG_LOCBACK(1, 0, 0, 0);
Radek Krejci5813c362021-01-05 10:51:57 +0100838 return ret;
Radek Krejci1798aae2020-07-14 13:26:06 +0200839}
840
841/**
842 * @brief Eat the node pointed by @p node_p by inserting it into @p parent and maintain the @p first_p pointing to the first child node.
843 *
844 * @param[in] parent Parent node to insert to, can be NULL in case of top-level (or provided first_p).
845 * @param[in, out] first_p Pointer to the first sibling node in case of top-level.
846 * @param[in, out] node_p pointer to the new node to insert, after the insert is done, pointer is set to NULL.
847 */
848static void
849lydjson_maintain_children(struct lyd_node_inner *parent, struct lyd_node **first_p, struct lyd_node **node_p)
850{
851 if (*node_p) {
852 /* insert, keep first pointer correct */
Michal Vasko08e9b112021-06-11 15:41:17 +0200853 lyd_insert_node(parent ? &parent->node : NULL, first_p, *node_p);
Radek Krejci1798aae2020-07-14 13:26:06 +0200854 if (first_p) {
855 if (parent) {
856 *first_p = parent->child;
857 } else {
858 while ((*first_p)->prev->next) {
859 *first_p = (*first_p)->prev;
860 }
861 }
862 }
863 *node_p = NULL;
864 }
865}
866
aPiecek4bf47212021-05-27 10:55:47 +0200867/**
868 * @brief Wrapper for ::lyd_create_opaq().
869 *
870 * @param[in] lydctx JSON data parser context.
871 * @param[in] name Name of the opaq node to create.
872 * @param[in] name_len Length of the @p name string.
873 * @param[in] prefix Prefix of the opaq node to create.
874 * @param[in] prefix_len Length of the @p prefx string.
875 * @param[in] parent Data parent of the opaq node to create, can be NULL in case of top level,
876 * but must be set if @p first is not.
877 * @param[in,out] status_inner_p In case of processing JSON array, this parameter points to a standalone
878 * context status of the array content. Otherwise, it is supposed to be the same as @p status_p.
879 * @param[out] node_p Pointer to the created opaq node.
880 * @return LY_ERR value.
881 */
882static LY_ERR
883lydjson_create_opaq(struct lyd_json_ctx *lydctx, const char *name, size_t name_len, const char *prefix, size_t prefix_len,
884 struct lyd_node_inner *parent, enum LYJSON_PARSER_STATUS *status_inner_p, struct lyd_node **node_p)
885{
886 LY_ERR ret = LY_SUCCESS;
887 const char *value = NULL, *module_name;
888 size_t value_len = 0, module_name_len = 0;
889 ly_bool dynamic = 0;
890 uint32_t type_hint = 0;
891
892 if ((*status_inner_p != LYJSON_OBJECT) && (*status_inner_p != LYJSON_OBJECT_EMPTY)) {
893 /* prepare for creating opaq node with a value */
894 value = lydctx->jsonctx->value;
895 value_len = lydctx->jsonctx->value_len;
896 dynamic = lydctx->jsonctx->dynamic;
897 lydctx->jsonctx->dynamic = 0;
898
899 LY_CHECK_RET(lydjson_value_type_hint(lydctx, status_inner_p, &type_hint));
900 }
901
902 /* create node */
Michal Vaskod8e774e2021-06-15 14:58:07 +0200903 lydjson_get_node_prefix(parent ? &parent->node : NULL, prefix, prefix_len, &module_name, &module_name_len);
aPiecek4bf47212021-05-27 10:55:47 +0200904 ret = lyd_create_opaq(lydctx->jsonctx->ctx, name, name_len, prefix, prefix_len, module_name, module_name_len, value,
905 value_len, &dynamic, LY_VALUE_JSON, NULL, type_hint, node_p);
906 if (dynamic) {
907 free((char *)value);
908 }
909
910 return ret;
911}
912
Michal Vaskoe0665742021-02-11 11:08:44 +0100913static LY_ERR lydjson_subtree_r(struct lyd_json_ctx *lydctx, struct lyd_node *parent, struct lyd_node **first_p,
914 struct ly_set *parsed);
Radek Krejci1798aae2020-07-14 13:26:06 +0200915
916/**
917 * @brief Parse opaq node from the input.
918 *
919 * In case of processing array, the whole array is being processed and the resulting @p node_p is the last item of the array.
920 *
921 * @param[in] lydctx JSON data parser context.
922 * @param[in] name Name of the opaq node to create.
923 * @param[in] name_len Length of the @p name string.
924 * @param[in] prefix Prefix of the opaq node to create.
925 * @param[in] prefix_len Length of the @p prefx string.
926 * @param[in] parent Data parent of the opaq node to create, can be NULL in case of top level,
927 * but must be set if @p first is not.
928 * @param[in,out] status_p Pointer to the current status of the parser context,
929 * since the function manipulates with the context and process the input, the status can be updated.
930 * @param[in,out] status_inner_p In case of processing JSON array, this parameter points to a standalone
931 * context status of the array content. Otherwise, it is supposed to be the same as @p status_p.
932 * @param[in,out] first_p First top-level/parent sibling, must be set if @p parent is not.
933 * @param[out] node_p Pointer to the created opaq node.
934 * @return LY_ERR value.
935 */
936static LY_ERR
Michal Vaskoa5da3292020-08-12 13:10:50 +0200937lydjson_parse_opaq(struct lyd_json_ctx *lydctx, const char *name, size_t name_len, const char *prefix, size_t prefix_len,
Radek Krejci0f969882020-08-21 16:56:47 +0200938 struct lyd_node_inner *parent, enum LYJSON_PARSER_STATUS *status_p,
939 enum LYJSON_PARSER_STATUS *status_inner_p, struct lyd_node **first_p, struct lyd_node **node_p)
Radek Krejci1798aae2020-07-14 13:26:06 +0200940{
941 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +0200942
aPiecek4bf47212021-05-27 10:55:47 +0200943 ret = lydjson_create_opaq(lydctx, name, name_len, prefix, prefix_len, parent, status_inner_p, node_p);
Radek Krejcid46e46a2020-09-15 14:22:42 +0200944 LY_CHECK_RET(ret);
Radek Krejci1798aae2020-07-14 13:26:06 +0200945
aPiecekdbb8baf2021-05-27 11:01:51 +0200946 while ((*status_p == LYJSON_ARRAY) || (*status_p == LYJSON_ARRAY_EMPTY)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200947 /* process another instance of the same node */
948 /* but first mark the node to be expected a list or a leaf-list */
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200949 ((struct lyd_node_opaq *)*node_p)->hints |= LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST;
Radek Krejci1798aae2020-07-14 13:26:06 +0200950
Michal Vasko69730152020-10-09 16:30:07 +0200951 if ((*status_inner_p == LYJSON_OBJECT) || (*status_inner_p == LYJSON_OBJECT_EMPTY)) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200952 /* but first process children of the object in the array */
953 while (*status_inner_p != LYJSON_OBJECT_CLOSED && *status_inner_p != LYJSON_OBJECT_EMPTY) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100954 LY_CHECK_RET(lydjson_subtree_r(lydctx, *node_p, lyd_node_child_p(*node_p), NULL));
Radek Krejci1798aae2020-07-14 13:26:06 +0200955 *status_inner_p = lyjson_ctx_status(lydctx->jsonctx, 0);
956 }
957 }
958
959 LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, status_inner_p));
aPiecekdbb8baf2021-05-27 11:01:51 +0200960 if (*status_inner_p == LYJSON_ARRAY_CLOSED) {
961 goto finish;
962 }
Radek Krejci1798aae2020-07-14 13:26:06 +0200963
964 /* continue with the next instance */
aPiecekdbb8baf2021-05-27 11:01:51 +0200965 assert(node_p);
966 lydjson_maintain_children(parent, first_p, node_p);
967 ret = lydjson_create_opaq(lydctx, name, name_len, prefix, prefix_len, parent, status_inner_p, node_p);
968 LY_CHECK_RET(ret);
969 }
970
971 if ((*status_p == LYJSON_OBJECT) || (*status_p == LYJSON_OBJECT_EMPTY)) {
972 /* process children */
973 while (*status_p != LYJSON_OBJECT_CLOSED && *status_p != LYJSON_OBJECT_EMPTY) {
974 LY_CHECK_RET(lydjson_subtree_r(lydctx, *node_p, lyd_node_child_p(*node_p), NULL));
975 *status_p = lyjson_ctx_status(lydctx->jsonctx, 0);
Radek Krejci1798aae2020-07-14 13:26:06 +0200976 }
977 }
978
aPiecekdbb8baf2021-05-27 11:01:51 +0200979finish:
Radek Krejci1798aae2020-07-14 13:26:06 +0200980 /* finish linking metadata */
Michal Vaskoe0665742021-02-11 11:08:44 +0100981 LY_CHECK_RET(lydjson_metadata_finish(lydctx, lyd_node_child_p(*node_p)));
Radek Krejci1798aae2020-07-14 13:26:06 +0200982
983 /* move after the item */
984 return lyjson_ctx_next(lydctx->jsonctx, status_p);
985}
986
987/**
aPiecek6cee5d02021-05-12 10:32:00 +0200988 * @brief Move to the second item in the name/X pair and parse opaq node from the input.
989 *
990 * This function is basically the wrapper of the ::lydjson_parse_opaq().
991 * In addition, it calls the ::json_ctx_next() and prepares the status_inner_p parameter
992 * for ::lydjson_parse_opaq().
993 *
994 * @param[in] lydctx JSON data parser context.
995 * @param[in] name Name of the opaq node to create.
996 * @param[in] name_len Length of the @p name string.
997 * @param[in] prefix Prefix of the opaq node to create.
998 * @param[in] prefix_len Length of the @p prefx string.
999 * @param[in] parent Data parent of the opaq node to create, can be NULL in case of top level,
1000 * but must be set if @p first is not.
1001 * @param[in,out] status_p Pointer to the current status of the parser context,
1002 * since the function manipulates with the context and process the input, the status can be updated.
1003 * @param[in,out] first_p First top-level/parent sibling, must be set if @p parent is not.
1004 * @param[out] node_p Pointer to the created opaq node.
1005 * @return LY_ERR value.
1006 */
1007static LY_ERR
1008lydjson_ctx_next_parse_opaq(struct lyd_json_ctx *lydctx, const char *name, size_t name_len,
1009 const char *prefix, size_t prefix_len, struct lyd_node_inner *parent, enum LYJSON_PARSER_STATUS *status_p,
1010 struct lyd_node **first_p, struct lyd_node **node_p)
1011{
1012 enum LYJSON_PARSER_STATUS status_inner = 0;
1013
1014 /* move to the second item in the name/X pair */
1015 LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, status_p));
1016
1017 if (*status_p == LYJSON_ARRAY) {
1018 /* move into the array */
1019 LY_CHECK_RET(lyjson_ctx_next(lydctx->jsonctx, &status_inner));
1020 } else {
1021 /* just a flag to pass correct parameters into lydjson_parse_opaq() */
1022 status_inner = LYJSON_ERROR;
1023 }
1024
1025 if (status_inner == LYJSON_ERROR) {
1026 status_inner = *status_p;
1027 }
1028
1029 /* parse opaq node from the input */
1030 LY_CHECK_RET(lydjson_parse_opaq(lydctx, name, name_len, prefix, prefix_len, parent, status_p, &status_inner, first_p, node_p));
1031
1032 return LY_SUCCESS;
1033}
1034
1035/**
Radek Krejci1798aae2020-07-14 13:26:06 +02001036 * @brief Process the attribute container (starting by @)
1037 *
1038 * @param[in] lydctx JSON data parser context.
1039 * @param[in] attr_node The data node referenced by the attribute container, if already known.
1040 * @param[in] snode The schema node of the data node referenced by the attribute container, if known.
1041 * @param[in] name Name of the opaq node to create.
1042 * @param[in] name_len Length of the @p name string.
1043 * @param[in] prefix Prefix of the opaq node to create.
1044 * @param[in] prefix_len Length of the @p prefx string.
1045 * @param[in] parent Data parent of the opaq node to create, can be NULL in case of top level,
1046 * but must be set if @p first is not.
1047 * @param[in,out] status_p Pointer to the current status of the parser context,
1048 * since the function manipulates with the context and process the input, the status can be updated.
1049 * @param[in,out] first_p First top-level/parent sibling, must be set if @p parent is not.
1050 * @param[out] node_p Pointer to the created opaq node.
1051 * @return LY_ERR value.
1052 */
1053static LY_ERR
1054lydjson_parse_attribute(struct lyd_json_ctx *lydctx, struct lyd_node *attr_node, const struct lysc_node *snode,
Michal Vaskoe0665742021-02-11 11:08:44 +01001055 const char *name, size_t name_len, const char *prefix, size_t prefix_len, struct lyd_node *parent,
1056 enum LYJSON_PARSER_STATUS *status_p, struct lyd_node **first_p, struct lyd_node **node_p)
Radek Krejci1798aae2020-07-14 13:26:06 +02001057{
1058 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02001059
1060 /* parse as an attribute to a node */
1061 if (!attr_node && snode) {
1062 /* try to find the instance */
1063 for (struct lyd_node *iter = *first_p; iter; iter = iter->next) {
1064 if (iter->schema == snode) {
1065 attr_node = iter;
1066 break;
1067 }
1068 }
1069 }
1070 if (!attr_node) {
1071 /* parse just as an opaq node with the name beginning with @,
1072 * later we have to check that it belongs to a standard node
1073 * and it is supposed to be converted to a metadata */
1074 uint32_t prev_opts;
1075
Radek Krejci1798aae2020-07-14 13:26:06 +02001076 /* backup parser options to parse unknown metadata as opaq nodes and try to resolve them later */
Michal Vaskoe0665742021-02-11 11:08:44 +01001077 prev_opts = lydctx->parse_opts;
1078 lydctx->parse_opts &= ~LYD_PARSE_STRICT;
1079 lydctx->parse_opts |= LYD_PARSE_OPAQ;
Radek Krejci1798aae2020-07-14 13:26:06 +02001080
aPiecek6cee5d02021-05-12 10:32:00 +02001081 ret = lydjson_ctx_next_parse_opaq(lydctx, prefix ? prefix - 1 : name - 1, prefix ? prefix_len + name_len + 2 : name_len + 1,
1082 NULL, 0, (struct lyd_node_inner *)parent, status_p, first_p, node_p);
Radek Krejci1798aae2020-07-14 13:26:06 +02001083
1084 /* restore the parser options */
Michal Vaskoe0665742021-02-11 11:08:44 +01001085 lydctx->parse_opts = prev_opts;
Radek Krejci1798aae2020-07-14 13:26:06 +02001086 } else {
1087 ret = lydjson_metadata(lydctx, snode, attr_node);
1088 }
1089
1090 return ret;
1091}
1092
1093/**
Michal Vasko32ac9942020-08-12 14:35:12 +02001094 * @brief Parse a single instance of a node.
1095 *
1096 * @param[in] lydctx JSON data parser context. When the function returns, the context is in the same state
1097 * as before calling, despite it is necessary to process input data for checking.
1098 * @param[in] parent Data parent of the subtree, must be set if @p first is not.
1099 * @param[in,out] first_p Pointer to the variable holding the first top-level sibling, must be set if @p parent is not.
1100 * @param[in] snode Schema node corresponding to the member currently being processed in the context.
1101 * @param[in] name Parsed JSON node name.
1102 * @param[in] name_len Lenght of @p name.
1103 * @param[in] prefix Parsed JSON node prefix.
1104 * @param[in] prefix_len Length of @p prefix.
1105 * @param[in,out] status JSON parser status, is updated.
1106 * @param[out] node Parsed data (or opaque) node.
1107 * @return LY_SUCCESS if a node was successfully parsed,
1108 * @return LY_EINVAL in case of invalid JSON encoding,
1109 * @return LY_ERR on other errors.
1110 */
1111static LY_ERR
1112lydjson_parse_instance(struct lyd_json_ctx *lydctx, struct lyd_node_inner *parent, struct lyd_node **first_p,
Radek Krejci0f969882020-08-21 16:56:47 +02001113 const struct lysc_node *snode, const char *name, size_t name_len, const char *prefix, size_t prefix_len,
1114 enum LYJSON_PARSER_STATUS *status, struct lyd_node **node)
Michal Vasko32ac9942020-08-12 14:35:12 +02001115{
1116 LY_ERR ret;
Radek Krejci2b18bf12020-11-06 11:20:20 +01001117 uint32_t type_hints = 0;
Michal Vasko32ac9942020-08-12 14:35:12 +02001118 uint32_t prev_opts;
1119 struct lyd_node *tree = NULL;
1120
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001121 ret = lydjson_data_check_opaq(lydctx, snode, &type_hints);
Michal Vasko32ac9942020-08-12 14:35:12 +02001122 if (ret == LY_SUCCESS) {
1123 assert(snode->nodetype & (LYD_NODE_TERM | LYD_NODE_INNER | LYD_NODE_ANY));
1124 if (snode->nodetype & LYD_NODE_TERM) {
1125 /* create terminal node */
1126 ret = lyd_parser_create_term((struct lyd_ctx *)lydctx, snode, lydctx->jsonctx->value,
Radek Krejci8df109d2021-04-23 12:19:08 +02001127 lydctx->jsonctx->value_len, &lydctx->jsonctx->dynamic, LY_VALUE_JSON, NULL,
Michal Vasko69730152020-10-09 16:30:07 +02001128 type_hints, node);
Michal Vasko32ac9942020-08-12 14:35:12 +02001129 LY_CHECK_RET(ret);
1130
1131 /* move JSON parser */
1132 ret = lyjson_ctx_next(lydctx->jsonctx, status);
1133 LY_CHECK_RET(ret);
1134 } else if (snode->nodetype & LYD_NODE_INNER) {
1135 /* create inner node */
1136 LY_CHECK_RET(*status != LYJSON_OBJECT && *status != LYJSON_OBJECT_EMPTY, LY_EINVAL);
1137
1138 ret = lyd_create_inner(snode, node);
1139 LY_CHECK_RET(ret);
1140
Radek Krejciddace2c2021-01-08 11:30:56 +01001141 LOG_LOCSET(snode, *node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001142
Michal Vasko32ac9942020-08-12 14:35:12 +02001143 /* process children */
1144 while (*status != LYJSON_OBJECT_CLOSED && *status != LYJSON_OBJECT_EMPTY) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001145 ret = lydjson_subtree_r(lydctx, *node, lyd_node_child_p(*node), NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +01001146 LY_CHECK_ERR_RET(ret, LOG_LOCBACK(1, 1, 0, 0), ret);
Michal Vasko32ac9942020-08-12 14:35:12 +02001147 *status = lyjson_ctx_status(lydctx->jsonctx, 0);
1148 }
1149
1150 /* finish linking metadata */
Michal Vaskoe0665742021-02-11 11:08:44 +01001151 ret = lydjson_metadata_finish(lydctx, lyd_node_child_p(*node));
Radek Krejciddace2c2021-01-08 11:30:56 +01001152 LY_CHECK_ERR_RET(ret, LOG_LOCBACK(1, 1, 0, 0), ret);
Michal Vasko32ac9942020-08-12 14:35:12 +02001153
1154 if (snode->nodetype == LYS_LIST) {
1155 /* check all keys exist */
1156 ret = lyd_parse_check_keys(*node);
Radek Krejciddace2c2021-01-08 11:30:56 +01001157 LY_CHECK_ERR_RET(ret, LOG_LOCBACK(1, 1, 0, 0), ret);
Michal Vasko32ac9942020-08-12 14:35:12 +02001158 }
1159
Michal Vaskoe0665742021-02-11 11:08:44 +01001160 if (!(lydctx->parse_opts & LYD_PARSE_ONLY)) {
Michal Vasko32ac9942020-08-12 14:35:12 +02001161 /* new node validation, autodelete CANNOT occur, all nodes are new */
Michal Vaskoe0665742021-02-11 11:08:44 +01001162 ret = lyd_validate_new(lyd_node_child_p(*node), snode, NULL, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +01001163 LY_CHECK_ERR_RET(ret, LOG_LOCBACK(1, 1, 0, 0), ret);
Michal Vasko32ac9942020-08-12 14:35:12 +02001164
1165 /* add any missing default children */
Radek Krejci4f2e3e52021-03-30 14:20:28 +02001166 ret = lyd_new_implicit_r(*node, lyd_node_child_p(*node), NULL, NULL, &lydctx->node_when, &lydctx->node_exts,
1167 &lydctx->node_types, (lydctx->val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, NULL);
Radek Krejciddace2c2021-01-08 11:30:56 +01001168 LY_CHECK_ERR_RET(ret, LOG_LOCBACK(1, 1, 0, 0), ret);
Michal Vasko32ac9942020-08-12 14:35:12 +02001169 }
1170
Radek Krejciddace2c2021-01-08 11:30:56 +01001171 LOG_LOCBACK(1, 1, 0, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001172
Michal Vasko32ac9942020-08-12 14:35:12 +02001173 /* move JSON parser */
1174 ret = lyjson_ctx_next(lydctx->jsonctx, status);
1175 LY_CHECK_RET(ret);
1176 } else if (snode->nodetype & LYD_NODE_ANY) {
1177 /* create any node */
1178 LY_CHECK_RET(*status != LYJSON_OBJECT && *status != LYJSON_OBJECT_EMPTY, LY_EINVAL);
1179
1180 /* parse any data tree with correct options */
1181 /* first backup the current options and then make the parser to process data as opaq nodes */
Michal Vaskoe0665742021-02-11 11:08:44 +01001182 prev_opts = lydctx->parse_opts;
1183 lydctx->parse_opts &= ~LYD_PARSE_STRICT;
1184 lydctx->parse_opts |= LYD_PARSE_OPAQ;
Michal Vasko32ac9942020-08-12 14:35:12 +02001185
1186 /* process the anydata content */
1187 while (*status != LYJSON_OBJECT_CLOSED && *status != LYJSON_OBJECT_EMPTY) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001188 ret = lydjson_subtree_r(lydctx, NULL, &tree, NULL);
Michal Vasko32ac9942020-08-12 14:35:12 +02001189 LY_CHECK_RET(ret);
1190 *status = lyjson_ctx_status(lydctx->jsonctx, 0);
1191 }
1192
1193 /* restore parser options */
Michal Vaskoe0665742021-02-11 11:08:44 +01001194 lydctx->parse_opts = prev_opts;
Michal Vasko32ac9942020-08-12 14:35:12 +02001195
1196 /* finish linking metadata */
1197 ret = lydjson_metadata_finish(lydctx, &tree);
1198 LY_CHECK_RET(ret);
1199
Michal Vasko366a4a12020-12-04 16:23:57 +01001200 ret = lyd_create_any(snode, tree, LYD_ANYDATA_DATATREE, 1, node);
Michal Vasko32ac9942020-08-12 14:35:12 +02001201 LY_CHECK_RET(ret);
1202 }
1203 } else if (ret == LY_ENOT) {
1204 /* parse it again as an opaq node */
1205 ret = lydjson_parse_opaq(lydctx, name, name_len, prefix, prefix_len, parent,
Michal Vasko69730152020-10-09 16:30:07 +02001206 status, status, first_p, node);
Michal Vasko32ac9942020-08-12 14:35:12 +02001207 LY_CHECK_RET(ret);
1208
Michal Vaskofeca4fb2020-10-05 08:58:40 +02001209 if (snode->nodetype == LYS_LIST) {
1210 ((struct lyd_node_opaq *)*node)->hints |= LYD_NODEHINT_LIST;
1211 } else if (snode->nodetype == LYS_LEAFLIST) {
1212 ((struct lyd_node_opaq *)*node)->hints |= LYD_NODEHINT_LEAFLIST;
Michal Vasko32ac9942020-08-12 14:35:12 +02001213 }
1214 }
1215
1216 return ret;
1217}
1218
1219/**
Michal Vaskoa5da3292020-08-12 13:10:50 +02001220 * @brief Parse JSON subtree. All leaf-list and list instances of a node are considered one subtree.
Radek Krejci1798aae2020-07-14 13:26:06 +02001221 *
1222 * @param[in] lydctx JSON data parser context.
1223 * @param[in] parent Data parent of the subtree, must be set if @p first is not.
1224 * @param[in,out] first_p Pointer to the variable holding the first top-level sibling, must be set if @p parent is not.
Michal Vaskoe0665742021-02-11 11:08:44 +01001225 * @param[in,out] parsed Optional set to add all the parsed siblings into.
Radek Krejci1798aae2020-07-14 13:26:06 +02001226 * @return LY_ERR value.
1227 */
1228static LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +01001229lydjson_subtree_r(struct lyd_json_ctx *lydctx, struct lyd_node *parent, struct lyd_node **first_p, struct ly_set *parsed)
Radek Krejci1798aae2020-07-14 13:26:06 +02001230{
1231 LY_ERR ret = LY_SUCCESS;
1232 enum LYJSON_PARSER_STATUS status = lyjson_ctx_status(lydctx->jsonctx, 0);
aPiecek49e2a3a2021-05-13 10:36:46 +02001233 const char *name, *prefix = NULL, *expected = NULL;
Radek Krejci1798aae2020-07-14 13:26:06 +02001234 size_t name_len, prefix_len = 0;
Radek Krejci857189e2020-09-01 13:26:36 +02001235 ly_bool is_meta = 0;
Michal Vaskocabe0702020-08-12 10:14:36 +02001236 const struct lysc_node *snode = NULL;
Michal Vasko32ac9942020-08-12 14:35:12 +02001237 struct lyd_node *node = NULL, *attr_node = NULL;
Radek Krejci1798aae2020-07-14 13:26:06 +02001238 const struct ly_ctx *ctx = lydctx->jsonctx->ctx;
aPiecek49e2a3a2021-05-13 10:36:46 +02001239 char *value = NULL;
Radek Krejci1798aae2020-07-14 13:26:06 +02001240
1241 assert(parent || first_p);
1242 assert(status == LYJSON_OBJECT);
1243
aPiecek49e2a3a2021-05-13 10:36:46 +02001244 /* Duplicate ::lyjson_ctx.value because it can be dynamically allocated and later
1245 * ::lyjson_ctx_next() will release it although this string is needed for the ::lydjson_parse_opaq().
1246 */
1247 value = strndup(lydctx->jsonctx->value, lydctx->jsonctx->value_len);
1248 if (!value) {
1249 LOGMEM(lydctx->jsonctx->ctx);
1250 ret = LY_EMEM;
1251 goto cleanup;
1252 }
1253
Radek Krejci1798aae2020-07-14 13:26:06 +02001254 /* process the node name */
aPiecek49e2a3a2021-05-13 10:36:46 +02001255 lydjson_parse_name(value, lydctx->jsonctx->value_len, &name, &name_len, &prefix, &prefix_len, &is_meta);
Radek Krejci1798aae2020-07-14 13:26:06 +02001256
Michal Vaskocabe0702020-08-12 10:14:36 +02001257 if (!is_meta || name_len || prefix_len) {
1258 /* get the schema node */
Michal Vaskoe0665742021-02-11 11:08:44 +01001259 ret = lydjson_get_snode(lydctx, is_meta, prefix, prefix_len, name, name_len, (struct lyd_node_inner *)parent, &snode);
Michal Vaskocabe0702020-08-12 10:14:36 +02001260 if (ret == LY_ENOT) {
1261 /* skip element with children */
1262 ret = lydjson_data_skip(lydctx->jsonctx);
1263 LY_CHECK_GOTO(ret, cleanup);
1264 status = lyjson_ctx_status(lydctx->jsonctx, 0);
1265 /* nothing for now, continue with another call of lydjson_subtree_r() */
Radek Krejci1798aae2020-07-14 13:26:06 +02001266 goto cleanup;
1267 }
Radek Krejci1798aae2020-07-14 13:26:06 +02001268 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +02001269
Michal Vaskocabe0702020-08-12 10:14:36 +02001270 if (!snode) {
1271 /* we will not be parsing it as metadata */
1272 is_meta = 0;
1273 }
1274 }
1275
1276 if (is_meta) {
1277 /* parse as metadata */
1278 if (!name_len && !prefix_len) {
1279 /* parent's metadata without a name - use the schema from the parent */
1280 if (!parent) {
Radek Krejci2efc45b2020-12-22 16:25:44 +01001281 LOGVAL(ctx, LYVE_SYNTAX_JSON,
Michal Vasko69730152020-10-09 16:30:07 +02001282 "Invalid metadata format - \"@\" can be used only inside anydata, container or list entries.");
Michal Vaskocabe0702020-08-12 10:14:36 +02001283 ret = LY_EVALID;
1284 goto cleanup;
1285 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001286 attr_node = parent;
Michal Vaskocabe0702020-08-12 10:14:36 +02001287 snode = attr_node->schema;
1288 }
1289 ret = lydjson_parse_attribute(lydctx, attr_node, snode, name, name_len, prefix, prefix_len, parent, &status,
Michal Vasko69730152020-10-09 16:30:07 +02001290 first_p, &node);
Michal Vaskocabe0702020-08-12 10:14:36 +02001291 LY_CHECK_GOTO(ret, cleanup);
1292 } else if (!snode) {
Radek Krejci1798aae2020-07-14 13:26:06 +02001293 /* parse as an opaq node */
Michal Vaskoe0665742021-02-11 11:08:44 +01001294 assert((lydctx->parse_opts & LYD_PARSE_OPAQ) || (lydctx->int_opts));
Radek Krejci1798aae2020-07-14 13:26:06 +02001295
aPiecekb7b29e62021-05-11 10:02:43 +02001296 /* opaq node cannot have an empty string as the name. */
1297 if (name_len == 0) {
1298 LOGVAL(lydctx->jsonctx->ctx, LYVE_SYNTAX_JSON, "A JSON object member name cannot be a zero-length string.");
1299 ret = LY_EVALID;
1300 goto cleanup;
1301 }
1302
aPiecek6cee5d02021-05-12 10:32:00 +02001303 /* move to the second item in the name/X pair and parse opaq */
1304 ret = lydjson_ctx_next_parse_opaq(lydctx, name, name_len, prefix, prefix_len,
1305 (struct lyd_node_inner *)parent, &status, first_p, &node);
Radek Krejci1798aae2020-07-14 13:26:06 +02001306 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskocabe0702020-08-12 10:14:36 +02001307 } else {
Michal Vasko32ac9942020-08-12 14:35:12 +02001308 /* parse as a standard lyd_node but it can still turn out to be an opaque node */
Radek Krejci1798aae2020-07-14 13:26:06 +02001309
1310 /* move to the second item in the name/X pair */
1311 ret = lyjson_ctx_next(lydctx->jsonctx, &status);
1312 LY_CHECK_GOTO(ret, cleanup);
1313
1314 /* first check the expected representation according to the nodetype and then continue with the content */
1315 switch (snode->nodetype) {
1316 case LYS_LEAFLIST:
Michal Vasko32ac9942020-08-12 14:35:12 +02001317 case LYS_LIST:
1318 if (snode->nodetype == LYS_LEAFLIST) {
1319 expected = "name/array of values";
1320 } else {
1321 expected = "name/array of objects";
1322 }
Radek Krejci1798aae2020-07-14 13:26:06 +02001323
1324 LY_CHECK_GOTO(status != LYJSON_ARRAY, representation_error);
1325
1326 /* move into array */
1327 ret = lyjson_ctx_next(lydctx->jsonctx, &status);
1328 LY_CHECK_GOTO(ret, cleanup);
1329
Michal Vasko32ac9942020-08-12 14:35:12 +02001330 /* process all the values/objects */
1331 do {
Michal Vaskoe0665742021-02-11 11:08:44 +01001332 lydjson_maintain_children((struct lyd_node_inner *)parent, first_p, &node);
Radek Krejci1798aae2020-07-14 13:26:06 +02001333
Michal Vaskoe0665742021-02-11 11:08:44 +01001334 ret = lydjson_parse_instance(lydctx, (struct lyd_node_inner *)parent, first_p, snode, name, name_len,
1335 prefix, prefix_len, &status, &node);
Michal Vasko32ac9942020-08-12 14:35:12 +02001336 if (ret == LY_EINVAL) {
1337 goto representation_error;
1338 } else if (ret) {
1339 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +02001340 }
Michal Vasko32ac9942020-08-12 14:35:12 +02001341 } while (status != LYJSON_ARRAY_CLOSED);
Radek Krejci1798aae2020-07-14 13:26:06 +02001342
Michal Vasko32ac9942020-08-12 14:35:12 +02001343 /* move after the array */
1344 ret = lyjson_ctx_next(lydctx->jsonctx, &status);
1345 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +02001346
1347 break;
Michal Vasko32ac9942020-08-12 14:35:12 +02001348 case LYS_LEAF:
Radek Krejci1798aae2020-07-14 13:26:06 +02001349 case LYS_CONTAINER:
1350 case LYS_NOTIF:
1351 case LYS_ACTION:
1352 case LYS_RPC:
Michal Vasko32ac9942020-08-12 14:35:12 +02001353 case LYS_ANYDATA:
1354 case LYS_ANYXML:
1355 if (snode->nodetype == LYS_LEAF) {
1356 if (status == LYJSON_ARRAY) {
1357 expected = "name/[null]";
1358 } else {
1359 expected = "name/value";
1360 }
1361 } else {
Radek Krejci1798aae2020-07-14 13:26:06 +02001362 expected = "name/object";
1363 }
1364
Michal Vasko32ac9942020-08-12 14:35:12 +02001365 /* process the value/object */
Michal Vaskoe0665742021-02-11 11:08:44 +01001366 ret = lydjson_parse_instance(lydctx, (struct lyd_node_inner *)parent, first_p, snode, name, name_len,
1367 prefix, prefix_len, &status, &node);
Michal Vasko32ac9942020-08-12 14:35:12 +02001368 if (ret == LY_EINVAL) {
1369 goto representation_error;
1370 } else if (ret) {
1371 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +02001372 }
1373
Michal Vasko32ac9942020-08-12 14:35:12 +02001374 if (snode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) {
Radek Krejci1798aae2020-07-14 13:26:06 +02001375 /* rememeber the RPC/action/notification */
1376 lydctx->op_node = node;
1377 }
1378
1379 break;
Radek Krejci1798aae2020-07-14 13:26:06 +02001380 }
Radek Krejci1798aae2020-07-14 13:26:06 +02001381 }
1382
Michal Vasko32ac9942020-08-12 14:35:12 +02001383 /* finally connect the parsed node */
Michal Vaskoe0665742021-02-11 11:08:44 +01001384 lydjson_maintain_children((struct lyd_node_inner *)parent, first_p, &node);
1385
1386 /* rememeber a successfully parsed node */
1387 if (parsed) {
1388 ly_set_add(parsed, node, 1, NULL);
1389 }
Radek Krejci1798aae2020-07-14 13:26:06 +02001390
Radek Krejci5813c362021-01-05 10:51:57 +01001391 /* success */
1392 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +02001393
1394representation_error:
Michal Vaskoe0665742021-02-11 11:08:44 +01001395 LOG_LOCSET(NULL, parent, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001396 LOGVAL(ctx, LYVE_SYNTAX_JSON, "The %s \"%s\" is expected to be represented as JSON %s, but input data contains name/%s.",
Michal Vasko69730152020-10-09 16:30:07 +02001397 lys_nodetype2str(snode->nodetype), snode->name, expected, lyjson_token2str(status));
Radek Krejciddace2c2021-01-08 11:30:56 +01001398 LOG_LOCBACK(0, parent ? 1 : 0, 0, 0);
Radek Krejci1798aae2020-07-14 13:26:06 +02001399 ret = LY_EVALID;
Radek Krejci5813c362021-01-05 10:51:57 +01001400
1401cleanup:
aPiecek49e2a3a2021-05-13 10:36:46 +02001402 free(value);
Radek Krejci5813c362021-01-05 10:51:57 +01001403 lyd_free_tree(node);
1404 return ret;
Radek Krejci1798aae2020-07-14 13:26:06 +02001405}
1406
1407/**
1408 * @brief Common start of JSON parser processing different types of the input data.
1409 *
1410 * @param[in] ctx libyang context
1411 * @param[in] in Input structure.
Michal Vaskoe0665742021-02-11 11:08:44 +01001412 * @param[in] parse_opts Options for parser, see @ref dataparseroptions.
1413 * @param[in] val_opts Options for the validation phase, see @ref datavalidationoptions.
Radek Krejci1798aae2020-07-14 13:26:06 +02001414 * @param[out] lydctx_p Data parser context to finish validation.
Radek Krejcicd5f6222020-11-12 08:54:13 +01001415 * @param[out] status Storage for the current context's status
Radek Krejci1798aae2020-07-14 13:26:06 +02001416 * @return LY_ERR value.
1417 */
1418static LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +01001419lyd_parse_json_init(const struct ly_ctx *ctx, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts,
Radek Krejcicd5f6222020-11-12 08:54:13 +01001420 struct lyd_json_ctx **lydctx_p, enum LYJSON_PARSER_STATUS *status)
Radek Krejci1798aae2020-07-14 13:26:06 +02001421{
1422 LY_ERR ret = LY_SUCCESS;
1423 struct lyd_json_ctx *lydctx;
Radek Krejcid54412f2020-12-17 20:25:35 +01001424 size_t i;
Radek Krejci1798aae2020-07-14 13:26:06 +02001425
Radek Krejcicd5f6222020-11-12 08:54:13 +01001426 assert(lydctx_p);
1427 assert(status);
1428
Radek Krejci1798aae2020-07-14 13:26:06 +02001429 /* init context */
1430 lydctx = calloc(1, sizeof *lydctx);
1431 LY_CHECK_ERR_RET(!lydctx, LOGMEM(ctx), LY_EMEM);
Michal Vaskoe0665742021-02-11 11:08:44 +01001432 lydctx->parse_opts = parse_opts;
1433 lydctx->val_opts = val_opts;
Radek Krejci1798aae2020-07-14 13:26:06 +02001434 lydctx->free = lyd_json_ctx_free;
Radek Krejci1798aae2020-07-14 13:26:06 +02001435
Radek Krejci284f31f2020-09-18 15:40:29 +02001436 /* starting top-level */
1437 for (i = 0; in->current[i] != '\0' && is_jsonws(in->current[i]); i++) {
Radek Krejcif13b87b2020-12-01 22:02:17 +01001438 if (in->current[i] == '\n') {
1439 /* new line */
Radek Krejcid54412f2020-12-17 20:25:35 +01001440 LY_IN_NEW_LINE(in);
Michal Vasko61d76362020-10-07 10:47:30 +02001441 }
Radek Krejci284f31f2020-09-18 15:40:29 +02001442 }
Radek Krejci1798aae2020-07-14 13:26:06 +02001443
Radek Krejci284f31f2020-09-18 15:40:29 +02001444 LY_CHECK_ERR_RET(ret = lyjson_ctx_new(ctx, in, &lydctx->jsonctx), free(lydctx), ret);
Radek Krejcicd5f6222020-11-12 08:54:13 +01001445 *status = lyjson_ctx_status(lydctx->jsonctx, 0);
Radek Krejcibb27df32020-11-13 15:39:16 +01001446 if ((*status == LYJSON_END) || (*status == LYJSON_OBJECT_EMPTY) || (*status == LYJSON_OBJECT)) {
Radek Krejci284f31f2020-09-18 15:40:29 +02001447 *lydctx_p = lydctx;
1448 return LY_SUCCESS;
Radek Krejcicd5f6222020-11-12 08:54:13 +01001449 } else {
1450 /* expecting top-level object */
Radek Krejci2efc45b2020-12-22 16:25:44 +01001451 LOGVAL(ctx, LYVE_SYNTAX_JSON, "Expected top-level JSON object, but %s found.",
Radek Krejcicd5f6222020-11-12 08:54:13 +01001452 lyjson_token2str(*status));
1453 *lydctx_p = NULL;
Michal Vasko93509012020-11-13 10:26:09 +01001454 lyd_json_ctx_free((struct lyd_ctx *)lydctx);
Radek Krejcicd5f6222020-11-12 08:54:13 +01001455 return LY_EVALID;
Radek Krejci284f31f2020-09-18 15:40:29 +02001456 }
Radek Krejci1798aae2020-07-14 13:26:06 +02001457}
1458
1459LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +01001460lyd_parse_json(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
1461 struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts, enum lyd_type data_type,
1462 struct ly_set *parsed, struct lyd_ctx **lydctx_p)
Radek Krejci1798aae2020-07-14 13:26:06 +02001463{
Michal Vaskoe0665742021-02-11 11:08:44 +01001464 LY_ERR rc = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02001465 struct lyd_json_ctx *lydctx = NULL;
1466 enum LYJSON_PARSER_STATUS status;
Michal Vaskoe0665742021-02-11 11:08:44 +01001467 uint32_t int_opts;
Radek Krejci1798aae2020-07-14 13:26:06 +02001468
Michal Vaskoe0665742021-02-11 11:08:44 +01001469 rc = lyd_parse_json_init(ctx, in, parse_opts, val_opts, &lydctx, &status);
1470 LY_CHECK_GOTO(rc || status == LYJSON_END || status == LYJSON_OBJECT_EMPTY, cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +02001471
Radek Krejcicd5f6222020-11-12 08:54:13 +01001472 assert(status == LYJSON_OBJECT);
Radek Krejci1798aae2020-07-14 13:26:06 +02001473
Michal Vaskoe0665742021-02-11 11:08:44 +01001474 switch (data_type) {
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001475 case LYD_TYPE_DATA_YANG:
Michal Vaskoe0665742021-02-11 11:08:44 +01001476 int_opts = LYD_INTOPT_WITH_SIBLINGS;
1477 break;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001478 case LYD_TYPE_RPC_YANG:
Michal Vaskoe0665742021-02-11 11:08:44 +01001479 int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NO_SIBLINGS;
1480 break;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001481 case LYD_TYPE_NOTIF_YANG:
Michal Vaskoe0665742021-02-11 11:08:44 +01001482 int_opts = LYD_INTOPT_NOTIF | LYD_INTOPT_NO_SIBLINGS;
1483 break;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001484 case LYD_TYPE_REPLY_YANG:
Michal Vaskoe0665742021-02-11 11:08:44 +01001485 int_opts = LYD_INTOPT_REPLY | LYD_INTOPT_NO_SIBLINGS;
1486 break;
1487 default:
1488 LOGINT(ctx);
1489 rc = LY_EINT;
1490 goto cleanup;
1491 }
1492 lydctx->int_opts = int_opts;
Radek Krejcif16e2542021-02-17 15:39:23 +01001493 lydctx->ext = ext;
Michal Vaskoe0665742021-02-11 11:08:44 +01001494
1495 /* find the operation node if it exists already */
1496 LY_CHECK_GOTO(rc = lyd_parser_find_operation(parent, int_opts, &lydctx->op_node), cleanup);
1497
Radek Krejci1798aae2020-07-14 13:26:06 +02001498 /* read subtree(s) */
Michal Vaskoe0665742021-02-11 11:08:44 +01001499 while (lydctx->jsonctx->in->current[0] && (status != LYJSON_OBJECT_CLOSED)) {
1500 rc = lydjson_subtree_r(lydctx, parent, first_p, parsed);
1501 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +02001502
1503 status = lyjson_ctx_status(lydctx->jsonctx, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +01001504
1505 if (!(int_opts & LYD_INTOPT_WITH_SIBLINGS)) {
1506 break;
1507 }
1508 }
1509
1510 if ((int_opts & LYD_INTOPT_NO_SIBLINGS) && lydctx->jsonctx->in->current[0] &&
1511 (lyjson_ctx_status(lydctx->jsonctx, 0) != LYJSON_OBJECT_CLOSED)) {
1512 LOGVAL(ctx, LYVE_SYNTAX, "Unexpected sibling node.");
1513 rc = LY_EVALID;
1514 goto cleanup;
1515 }
1516 if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NOTIF | LYD_INTOPT_REPLY)) && !lydctx->op_node) {
1517 LOGVAL(ctx, LYVE_DATA, "Missing the operation node.");
1518 rc = LY_EVALID;
1519 goto cleanup;
Radek Krejci1798aae2020-07-14 13:26:06 +02001520 }
1521
1522 /* finish linking metadata */
Michal Vaskoe0665742021-02-11 11:08:44 +01001523 rc = lydjson_metadata_finish(lydctx, parent ? lyd_node_child_p(parent) : first_p);
1524 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +02001525
1526cleanup:
1527 /* there should be no unresolved types stored */
Michal Vaskoe0665742021-02-11 11:08:44 +01001528 assert(!(parse_opts & LYD_PARSE_ONLY) || (!lydctx->node_types.count && !lydctx->meta_types.count &&
Michal Vasko49c39d82020-11-06 17:20:27 +01001529 !lydctx->node_when.count));
Radek Krejci1798aae2020-07-14 13:26:06 +02001530
Michal Vaskoe0665742021-02-11 11:08:44 +01001531 if (rc) {
Radek Krejci1798aae2020-07-14 13:26:06 +02001532 lyd_json_ctx_free((struct lyd_ctx *)lydctx);
Radek Krejci1798aae2020-07-14 13:26:06 +02001533 } else {
1534 *lydctx_p = (struct lyd_ctx *)lydctx;
1535 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001536 return rc;
Michal Vasko90932a92020-02-12 14:33:03 +01001537}