blob: 049cce27bfaaf81e908ed8a0d3fc543578bc6cf7 [file] [log] [blame]
Radek Krejcie7b95092019-05-15 11:03:07 +02001/**
2 * @file parser_xml.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vasko8cc3f662022-03-29 11:25:51 +02004 * @author Michal Vasko <mvasko@cesnet.cz>
Radek Krejcie7b95092019-05-15 11:03:07 +02005 * @brief XML data parser for libyang
6 *
Michal Vasko8cc3f662022-03-29 11:25:51 +02007 * Copyright (c) 2019 - 2022 CESNET, z.s.p.o.
Radek Krejcie7b95092019-05-15 11:03:07 +02008 *
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
Michal Vasko742a5b12022-02-24 16:07:27 +010016#define _GNU_SOURCE
17
Michal Vasko69730152020-10-09 16:30:07 +020018#include <assert.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <stdint.h>
20#include <stdlib.h>
21#include <string.h>
22
Radek Krejci535ea9f2020-05-29 16:01:05 +020023#include "common.h"
Michal Vasko742a5b12022-02-24 16:07:27 +010024#include "compat.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020025#include "context.h"
Radek Krejci77114102021-03-10 15:21:57 +010026#include "dict.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020027#include "in_internal.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020028#include "log.h"
Radek Krejci7931b192020-06-25 17:05:03 +020029#include "parser_data.h"
30#include "parser_internal.h"
tadeas-vintrlik2aa36b42021-11-03 13:07:34 +010031#include "plugins_exts.h"
Michal Vasko51de7b72022-04-29 09:50:22 +020032#include "plugins_internal.h"
33#include "schema_compile_node.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020034#include "set.h"
Radek Krejci77114102021-03-10 15:21:57 +010035#include "tree.h"
Radek Krejci47fab892020-11-05 17:02:41 +010036#include "tree_data.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020037#include "tree_data_internal.h"
38#include "tree_schema.h"
Radek Krejci77114102021-03-10 15:21:57 +010039#include "tree_schema_internal.h"
Michal Vaskocde73ac2019-11-14 16:10:27 +010040#include "validation.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020041#include "xml.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020042
Radek Krejci1798aae2020-07-14 13:26:06 +020043void
44lyd_xml_ctx_free(struct lyd_ctx *lydctx)
45{
46 struct lyd_xml_ctx *ctx = (struct lyd_xml_ctx *)lydctx;
47
48 lyd_ctx_free(lydctx);
49 lyxml_ctx_free(ctx->xmlctx);
50 free(ctx);
51}
52
Michal Vasko45791ad2021-06-17 08:45:03 +020053/**
54 * @brief Parse and create XML metadata.
55 *
56 * @param[in] lydctx XML data parser context.
Michal Vaskoddd76592022-01-17 13:34:48 +010057 * @param[in] sparent Schema node of the parent.
Michal Vasko45791ad2021-06-17 08:45:03 +020058 * @param[out] meta List of created metadata instances.
59 * @return LY_ERR value.
60 */
Radek Krejcie7b95092019-05-15 11:03:07 +020061static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +010062lydxml_metadata(struct lyd_xml_ctx *lydctx, const struct lysc_node *sparent, struct lyd_meta **meta)
Radek Krejcie7b95092019-05-15 11:03:07 +020063{
aPiecek1c4da362021-04-29 14:26:34 +020064 LY_ERR ret = LY_SUCCESS;
Radek Krejci28681fa2019-09-06 13:08:45 +020065 const struct lyxml_ns *ns;
66 struct lys_module *mod;
Michal Vaskob36053d2020-03-26 15:49:30 +010067 const char *name;
68 size_t name_len;
Michal Vasko45791ad2021-06-17 08:45:03 +020069 LY_ARRAY_COUNT_TYPE u;
70 ly_bool filter_attrs = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +020071 struct lyxml_ctx *xmlctx = lydctx->xmlctx;
Radek Krejci28681fa2019-09-06 13:08:45 +020072
Michal Vaskob36053d2020-03-26 15:49:30 +010073 *meta = NULL;
Radek Krejci28681fa2019-09-06 13:08:45 +020074
Michal Vasko45791ad2021-06-17 08:45:03 +020075 /* check for NETCONF filter unqualified attributes */
Michal Vaskoddd76592022-01-17 13:34:48 +010076 LY_ARRAY_FOR(sparent->exts, u) {
77 if (!strcmp(sparent->exts[u].def->name, "get-filter-element-attributes") &&
78 !strcmp(sparent->exts[u].def->module->name, "ietf-netconf")) {
Michal Vasko45791ad2021-06-17 08:45:03 +020079 filter_attrs = 1;
80 break;
81 }
82 }
83
Michal Vaskob36053d2020-03-26 15:49:30 +010084 while (xmlctx->status == LYXML_ATTRIBUTE) {
85 if (!xmlctx->prefix_len) {
Michal Vasko45791ad2021-06-17 08:45:03 +020086 /* in XML all attributes must be prefixed except NETCONF filter ones marked by an extension */
87 if (filter_attrs && (!ly_strncmp("type", xmlctx->name, xmlctx->name_len) ||
88 !ly_strncmp("select", xmlctx->name, xmlctx->name_len))) {
89 mod = ly_ctx_get_module_implemented(xmlctx->ctx, "ietf-netconf");
90 if (!mod) {
91 LOGVAL(xmlctx->ctx, LYVE_REFERENCE,
92 "Missing (or not implemented) YANG module \"ietf-netconf\" for special filter attributes.");
93 ret = LY_ENOTFOUND;
94 goto cleanup;
95 }
96 goto create_meta;
97 }
98
Michal Vaskoe0665742021-02-11 11:08:44 +010099 if (lydctx->parse_opts & LYD_PARSE_STRICT) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100100 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Missing mandatory prefix for XML metadata \"%.*s\".",
Radek Krejci422afb12021-03-04 16:38:16 +0100101 (int)xmlctx->name_len, xmlctx->name);
Michal Vasko45791ad2021-06-17 08:45:03 +0200102 ret = LY_EVALID;
Michal Vaskob36053d2020-03-26 15:49:30 +0100103 goto cleanup;
Radek Krejci28681fa2019-09-06 13:08:45 +0200104 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100105
Michal Vasko45791ad2021-06-17 08:45:03 +0200106 /* skip attr */
Michal Vaskob36053d2020-03-26 15:49:30 +0100107 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
108 assert(xmlctx->status == LYXML_ATTR_CONTENT);
109 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
Radek Krejci28681fa2019-09-06 13:08:45 +0200110 continue;
111 }
112
113 /* get namespace of the attribute to find its annotation definition */
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200114 ns = lyxml_ns_get(&xmlctx->ns, xmlctx->prefix, xmlctx->prefix_len);
Radek Krejci28681fa2019-09-06 13:08:45 +0200115 if (!ns) {
Michal Vasko52927e22020-03-16 17:26:14 +0100116 /* unknown namespace, XML error */
Radek Krejci422afb12021-03-04 16:38:16 +0100117 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Unknown XML prefix \"%.*s\".", (int)xmlctx->prefix_len, xmlctx->prefix);
Michal Vasko45791ad2021-06-17 08:45:03 +0200118 ret = LY_ENOTFOUND;
Radek Krejci28681fa2019-09-06 13:08:45 +0200119 goto cleanup;
120 }
Michal Vasko45791ad2021-06-17 08:45:03 +0200121
122 /* get the module with metadata definition */
Michal Vasko52927e22020-03-16 17:26:14 +0100123 mod = ly_ctx_get_module_implemented_ns(xmlctx->ctx, ns->uri);
Radek Krejci28681fa2019-09-06 13:08:45 +0200124 if (!mod) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100125 if (lydctx->parse_opts & LYD_PARSE_STRICT) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100126 LOGVAL(xmlctx->ctx, LYVE_REFERENCE,
Michal Vasko69730152020-10-09 16:30:07 +0200127 "Unknown (or not implemented) YANG module with namespace \"%s\" for metadata \"%.*s%s%.*s\".",
Radek Krejci422afb12021-03-04 16:38:16 +0100128 ns->uri, (int)xmlctx->prefix_len, xmlctx->prefix, xmlctx->prefix_len ? ":" : "",
129 (int)xmlctx->name_len, xmlctx->name);
Michal Vasko45791ad2021-06-17 08:45:03 +0200130 ret = LY_ENOTFOUND;
Michal Vaskob36053d2020-03-26 15:49:30 +0100131 goto cleanup;
Radek Krejci28681fa2019-09-06 13:08:45 +0200132 }
Michal Vasko45791ad2021-06-17 08:45:03 +0200133
134 /* skip attr */
135 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
136 assert(xmlctx->status == LYXML_ATTR_CONTENT);
137 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
138 continue;
Radek Krejci28681fa2019-09-06 13:08:45 +0200139 }
140
Michal Vasko45791ad2021-06-17 08:45:03 +0200141create_meta:
Michal Vasko60ea6352020-06-29 13:39:39 +0200142 /* remember meta name and get its content */
Michal Vaskob36053d2020-03-26 15:49:30 +0100143 name = xmlctx->name;
144 name_len = xmlctx->name_len;
145 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
146 assert(xmlctx->status == LYXML_ATTR_CONTENT);
147
148 /* create metadata */
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200149 ret = lyd_parser_create_meta((struct lyd_ctx *)lydctx, NULL, meta, mod, name, name_len, xmlctx->value,
Michal Vaskoddd76592022-01-17 13:34:48 +0100150 xmlctx->value_len, &xmlctx->dynamic, LY_VALUE_XML, &xmlctx->ns, LYD_HINT_DATA, sparent);
Radek Krejci1798aae2020-07-14 13:26:06 +0200151 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100152
153 /* next attribute */
154 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
Radek Krejcie7b95092019-05-15 11:03:07 +0200155 }
Michal Vasko52927e22020-03-16 17:26:14 +0100156
Radek Krejcie7b95092019-05-15 11:03:07 +0200157cleanup:
Michal Vaskob36053d2020-03-26 15:49:30 +0100158 if (ret) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200159 lyd_free_meta_siblings(*meta);
Michal Vaskob36053d2020-03-26 15:49:30 +0100160 *meta = NULL;
Radek Krejci38d85362019-09-05 16:26:38 +0200161 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200162 return ret;
163}
164
Michal Vasko52927e22020-03-16 17:26:14 +0100165static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200166lydxml_attrs(struct lyxml_ctx *xmlctx, struct lyd_attr **attr)
Michal Vasko52927e22020-03-16 17:26:14 +0100167{
168 LY_ERR ret = LY_SUCCESS;
169 const struct lyxml_ns *ns;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100170 void *val_prefix_data;
Radek Krejci8df109d2021-04-23 12:19:08 +0200171 LY_VALUE_FORMAT format;
Radek Krejci1798aae2020-07-14 13:26:06 +0200172 struct lyd_attr *attr2;
Michal Vaskob36053d2020-03-26 15:49:30 +0100173 const char *name, *prefix;
174 size_t name_len, prefix_len;
Michal Vasko52927e22020-03-16 17:26:14 +0100175
176 assert(attr);
Michal Vaskob36053d2020-03-26 15:49:30 +0100177 *attr = NULL;
Michal Vasko52927e22020-03-16 17:26:14 +0100178
Michal Vaskob36053d2020-03-26 15:49:30 +0100179 while (xmlctx->status == LYXML_ATTRIBUTE) {
Michal Vasko52927e22020-03-16 17:26:14 +0100180 if (*attr) {
181 attr2 = *attr;
182 } else {
183 attr2 = NULL;
184 }
185
Michal Vaskob36053d2020-03-26 15:49:30 +0100186 /* remember attr prefix, name, and get its content */
187 prefix = xmlctx->prefix;
188 prefix_len = xmlctx->prefix_len;
189 name = xmlctx->name;
190 name_len = xmlctx->name_len;
191 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
192 assert(xmlctx->status == LYXML_ATTR_CONTENT);
193
Michal Vaskoe137fc42021-07-22 11:53:13 +0200194 /* handle special "xml" attribute prefix */
195 if ((prefix_len == 3) && !strncmp(prefix, "xml", 3)) {
196 name = prefix;
197 name_len += 1 + prefix_len;
198 prefix = NULL;
199 prefix_len = 0;
200 }
201
202 /* find namespace of the attribute, if any */
203 ns = NULL;
204 if (prefix_len) {
205 ns = lyxml_ns_get(&xmlctx->ns, prefix, prefix_len);
206 if (!ns) {
207 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Unknown XML prefix \"%.*s\".", (int)prefix_len, prefix);
208 ret = LY_EVALID;
209 goto cleanup;
210 }
211 }
212
Michal Vasko52927e22020-03-16 17:26:14 +0100213 /* get value prefixes */
Michal Vaskofc2cd072021-02-24 13:17:17 +0100214 val_prefix_data = NULL;
Radek Krejci8df109d2021-04-23 12:19:08 +0200215 LY_CHECK_GOTO(ret = ly_store_prefix_data(xmlctx->ctx, xmlctx->value, xmlctx->value_len, LY_VALUE_XML,
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100216 &xmlctx->ns, &format, &val_prefix_data), cleanup);
Michal Vasko52927e22020-03-16 17:26:14 +0100217
218 /* attr2 is always changed to the created attribute */
Michal Vasko501af032020-11-11 20:27:44 +0100219 ret = lyd_create_attr(NULL, &attr2, xmlctx->ctx, name, name_len, prefix, prefix_len, ns ? ns->uri : NULL,
Michal Vaskoe5e49e92022-02-01 13:15:08 +0100220 ns ? strlen(ns->uri) : 0, xmlctx->value, xmlctx->value_len, &xmlctx->dynamic, format, val_prefix_data,
221 LYD_HINT_DATA);
Michal Vasko52927e22020-03-16 17:26:14 +0100222 LY_CHECK_GOTO(ret, cleanup);
223
224 if (!*attr) {
225 *attr = attr2;
226 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100227
228 /* next attribute */
229 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
Michal Vasko52927e22020-03-16 17:26:14 +0100230 }
231
232cleanup:
Michal Vaskob36053d2020-03-26 15:49:30 +0100233 if (ret) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200234 lyd_free_attr_siblings(xmlctx->ctx, *attr);
Michal Vaskob36053d2020-03-26 15:49:30 +0100235 *attr = NULL;
Michal Vasko52927e22020-03-16 17:26:14 +0100236 }
Michal Vasko52927e22020-03-16 17:26:14 +0100237 return ret;
238}
239
Michal Vasko44685da2020-03-17 15:38:06 +0100240static LY_ERR
Michal Vaskob36053d2020-03-26 15:49:30 +0100241lydxml_check_list(struct lyxml_ctx *xmlctx, const struct lysc_node *list)
Michal Vasko44685da2020-03-17 15:38:06 +0100242{
Michal Vaskob36053d2020-03-26 15:49:30 +0100243 LY_ERR ret = LY_SUCCESS, r;
244 enum LYXML_PARSER_STATUS next;
Michal Vasko44685da2020-03-17 15:38:06 +0100245 struct ly_set key_set = {0};
246 const struct lysc_node *snode;
Michal Vaskob36053d2020-03-26 15:49:30 +0100247 uint32_t i, parents_count;
Michal Vasko44685da2020-03-17 15:38:06 +0100248
249 assert(list && (list->nodetype == LYS_LIST));
250
251 /* get all keys into a set (keys do not have if-features or anything) */
252 snode = NULL;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100253 while ((snode = lys_getnext(snode, list, NULL, 0)) && (snode->flags & LYS_KEY)) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200254 ret = ly_set_add(&key_set, (void *)snode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200255 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko44685da2020-03-17 15:38:06 +0100256 }
257
Michal Vasko12d809c2021-03-03 16:34:32 +0100258 /* remember parent count */
259 parents_count = xmlctx->elements.count;
260
Michal Vaskob36053d2020-03-26 15:49:30 +0100261 while (xmlctx->status == LYXML_ELEMENT) {
Michal Vasko44685da2020-03-17 15:38:06 +0100262 /* find key definition */
263 for (i = 0; i < key_set.count; ++i) {
264 snode = (const struct lysc_node *)key_set.objs[i];
Michal Vaskob36053d2020-03-26 15:49:30 +0100265 if (!ly_strncmp(snode->name, xmlctx->name, xmlctx->name_len)) {
Michal Vasko44685da2020-03-17 15:38:06 +0100266 break;
267 }
268 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100269 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
Michal Vasko44685da2020-03-17 15:38:06 +0100270
271 /* skip attributes */
272 while (xmlctx->status == LYXML_ATTRIBUTE) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100273 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
274 assert(xmlctx->status == LYXML_ATTR_CONTENT);
275 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
Michal Vasko44685da2020-03-17 15:38:06 +0100276 }
277
Michal Vaskob36053d2020-03-26 15:49:30 +0100278 assert(xmlctx->status == LYXML_ELEM_CONTENT);
279 if (i < key_set.count) {
280 /* validate the value */
Radek Krejci8df109d2021-04-23 12:19:08 +0200281 r = lys_value_validate(NULL, snode, xmlctx->value, xmlctx->value_len, LY_VALUE_XML, &xmlctx->ns);
Michal Vaskob36053d2020-03-26 15:49:30 +0100282 if (!r) {
283 /* key with a valid value, remove from the set */
284 ly_set_rm_index(&key_set, i, NULL);
Michal Vasko44685da2020-03-17 15:38:06 +0100285 }
286 }
287
Michal Vaskob36053d2020-03-26 15:49:30 +0100288 /* parser next */
289 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
Michal Vasko44685da2020-03-17 15:38:06 +0100290
Michal Vaskob36053d2020-03-26 15:49:30 +0100291 /* skip any children, resursively */
Michal Vasko12d809c2021-03-03 16:34:32 +0100292 while (xmlctx->status == LYXML_ELEMENT) {
293 while (parents_count < xmlctx->elements.count) {
294 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
295 }
296 assert(xmlctx->status == LYXML_ELEM_CLOSE);
Michal Vaskob36053d2020-03-26 15:49:30 +0100297 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
298 }
299
300 /* parser next, but do not parse closing element of the list because it would remove its namespaces */
301 assert(xmlctx->status == LYXML_ELEM_CLOSE);
302 LY_CHECK_GOTO(ret = lyxml_ctx_peek(xmlctx, &next), cleanup);
303 if (next != LYXML_ELEM_CLOSE) {
304 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), cleanup);
305 }
Michal Vasko44685da2020-03-17 15:38:06 +0100306 }
307
308 if (key_set.count) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100309 /* some keys are missing/did not validate */
Michal Vasko44685da2020-03-17 15:38:06 +0100310 ret = LY_ENOT;
Michal Vasko44685da2020-03-17 15:38:06 +0100311 }
312
313cleanup:
314 ly_set_erase(&key_set, NULL);
315 return ret;
316}
317
Michal Vasko5c24ed12021-06-09 09:27:32 +0200318/**
319 * @brief Skip an element with all its descendants.
320 *
321 * @param[in] xmlctx XML parser context.
322 * @return LY_ERR value.
323 */
Michal Vasko1bf09392020-03-27 12:38:10 +0100324static LY_ERR
325lydxml_data_skip(struct lyxml_ctx *xmlctx)
326{
327 uint32_t parents_count;
328
329 /* remember current number of parents */
330 parents_count = xmlctx->elements.count;
aPiecek9cdb9e62021-05-18 09:46:20 +0200331 assert(parents_count);
Michal Vasko1bf09392020-03-27 12:38:10 +0100332
333 /* skip after the content */
334 while (xmlctx->status != LYXML_ELEM_CONTENT) {
335 LY_CHECK_RET(lyxml_ctx_next(xmlctx));
336 }
337 LY_CHECK_RET(lyxml_ctx_next(xmlctx));
338
339 /* skip all children elements, recursively, if any */
aPiecek9cdb9e62021-05-18 09:46:20 +0200340 while (parents_count <= xmlctx->elements.count) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100341 LY_CHECK_RET(lyxml_ctx_next(xmlctx));
342 }
343
344 /* close element */
345 assert(xmlctx->status == LYXML_ELEM_CLOSE);
346 LY_CHECK_RET(lyxml_ctx_next(xmlctx));
347
348 return LY_SUCCESS;
349}
350
Michal Vasko5c24ed12021-06-09 09:27:32 +0200351/**
352 * @brief Check that the current element can be parsed as a data node.
353 *
354 * @param[in] lydctx XML data parser context.
355 * @param[in,out] snode Found schema node, set to NULL if data node cannot be created.
356 * @return LY_ERR value.
357 */
Michal Vasko1bf09392020-03-27 12:38:10 +0100358static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200359lydxml_data_check_opaq(struct lyd_xml_ctx *lydctx, const struct lysc_node **snode)
Michal Vasko1bf09392020-03-27 12:38:10 +0100360{
361 LY_ERR ret = LY_SUCCESS;
Michal Vaskoda8fbbf2021-06-16 11:44:44 +0200362 struct lyxml_ctx *xmlctx = lydctx->xmlctx, pxmlctx;
Michal Vasko1bf09392020-03-27 12:38:10 +0100363
Radek IÅ¡a3930fd72021-03-08 10:48:40 +0100364 if (!(lydctx->parse_opts & LYD_PARSE_OPAQ)) {
365 /* only checks specific to opaque nodes */
366 return LY_SUCCESS;
367 }
368
Michal Vasko13854662021-06-09 09:27:50 +0200369 if (!((*snode)->nodetype & (LYD_NODE_TERM | LYD_NODE_INNER))) {
370 /* nothing to check */
371 return LY_SUCCESS;
372 }
Michal Vasko1bf09392020-03-27 12:38:10 +0100373
Michal Vaskoda8fbbf2021-06-16 11:44:44 +0200374 assert(xmlctx->elements.count);
375
Michal Vasko13854662021-06-09 09:27:50 +0200376 /* backup parser */
Michal Vaskoda8fbbf2021-06-16 11:44:44 +0200377 LY_CHECK_RET(lyxml_ctx_backup(xmlctx, &pxmlctx));
Michal Vasko1bf09392020-03-27 12:38:10 +0100378
Michal Vasko13854662021-06-09 09:27:50 +0200379 /* skip attributes */
380 while (xmlctx->status == LYXML_ATTRIBUTE) {
381 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), restore);
382 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), restore);
383 }
Michal Vasko1bf09392020-03-27 12:38:10 +0100384
Michal Vasko13854662021-06-09 09:27:50 +0200385 if ((*snode)->nodetype & LYD_NODE_TERM) {
386 /* value may not be valid in which case we parse it as an opaque node */
387 if (lys_value_validate(NULL, *snode, xmlctx->value, xmlctx->value_len, LY_VALUE_XML, &xmlctx->ns)) {
Michal Vaskod0237d42021-07-12 14:49:46 +0200388 LOGVRB("Parsing opaque term node \"%s\" with invalid value \"%.*s\".", (*snode)->name, xmlctx->value_len,
389 xmlctx->value);
Michal Vasko13854662021-06-09 09:27:50 +0200390 *snode = NULL;
Michal Vasko1bf09392020-03-27 12:38:10 +0100391 }
Michal Vasko13854662021-06-09 09:27:50 +0200392 } else if ((*snode)->nodetype == LYS_LIST) {
393 /* skip content */
394 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), restore);
Michal Vasko1bf09392020-03-27 12:38:10 +0100395
Michal Vasko13854662021-06-09 09:27:50 +0200396 if (lydxml_check_list(xmlctx, *snode)) {
397 /* invalid list, parse as opaque if it missing/has invalid some keys */
Michal Vaskod0237d42021-07-12 14:49:46 +0200398 LOGVRB("Parsing opaque list node \"%s\" with missing/invalid keys.", (*snode)->name);
Michal Vasko13854662021-06-09 09:27:50 +0200399 *snode = NULL;
Michal Vasko1bf09392020-03-27 12:38:10 +0100400 }
Michal Vasko13854662021-06-09 09:27:50 +0200401 } else {
Radek IÅ¡a3930fd72021-03-08 10:48:40 +0100402 /* if there is a non-WS value, it cannot be parsed as an inner node */
403 assert(xmlctx->status == LYXML_ELEM_CONTENT);
404 if (!xmlctx->ws_only) {
405 *snode = NULL;
406 }
Michal Vasko1bf09392020-03-27 12:38:10 +0100407 }
408
Michal Vasko13854662021-06-09 09:27:50 +0200409restore:
410 /* restore parser */
Michal Vaskoda8fbbf2021-06-16 11:44:44 +0200411 lyxml_ctx_restore(xmlctx, &pxmlctx);
Michal Vasko1bf09392020-03-27 12:38:10 +0100412 return ret;
413}
414
Radek Krejcie7b95092019-05-15 11:03:07 +0200415/**
Michal Vaskocea58712022-04-01 14:37:08 +0200416 * @brief Get sensible data hints for an opaque node.
417 *
418 * @param[in] name Node name.
419 * @param[in] name_len Length of @p name.
420 * @param[in] value Node value.
421 * @param[in] value_len Length of @p value.
422 * @param[in] first Node first sibling.
423 * @param[in] ns Node module namespace.
424 * @param[out] hints Data hints to use.
425 * @param[out] anchor Anchor to insert after in case of a list.
426 */
427static void
428lydxml_get_hints_opaq(const char *name, size_t name_len, const char *value, size_t value_len, struct lyd_node *first,
429 const char *ns, uint32_t *hints, struct lyd_node **anchor)
430{
431 struct lyd_node_opaq *opaq;
432 char *ptr;
433 long num;
434
435 *hints = 0;
436 *anchor = NULL;
437
438 if (!value_len) {
439 /* no value */
440 *hints |= LYD_VALHINT_EMPTY;
441 } else if (!strncmp(value, "true", value_len) || !strncmp(value, "false", value_len)) {
442 /* boolean value */
443 *hints |= LYD_VALHINT_BOOLEAN;
444 } else {
445 num = strtol(value, &ptr, 10);
446 if ((unsigned)(ptr - value) == value_len) {
447 /* number value */
448 *hints |= LYD_VALHINT_DECNUM;
449 if ((num < INT32_MIN) || (num > UINT32_MAX)) {
450 /* large number */
451 *hints |= LYD_VALHINT_NUM64;
452 }
453 } else {
454 /* string value */
455 *hints |= LYD_VALHINT_STRING;
456 }
457 }
458
459 if (!first) {
460 return;
461 }
462
463 /* search backwards to find the last instance */
464 do {
465 first = first->prev;
466 if (first->schema) {
467 continue;
468 }
469
470 opaq = (struct lyd_node_opaq *)first;
471 assert(opaq->format == LY_VALUE_XML);
472 if (!ly_strncmp(opaq->name.name, name, name_len) && !strcmp(opaq->name.module_ns, ns)) {
473 if (opaq->value && opaq->value[0]) {
474 /* leaf-list nodes */
475 opaq->hints |= LYD_NODEHINT_LEAFLIST;
476 *hints |= LYD_NODEHINT_LEAFLIST;
477 } else {
478 /* list nodes */
479 opaq->hints |= LYD_NODEHINT_LIST;
480 *hints |= LYD_NODEHINT_LIST;
481 }
482 *anchor = first;
483 break;
484 }
485 } while (first->prev->next);
486}
487
488/**
Michal Vasko8cc3f662022-03-29 11:25:51 +0200489 * @brief Get schema node for the current element.
Michal Vaskoddd76592022-01-17 13:34:48 +0100490 *
491 * @param[in] lydctx XML data parser context.
Michal Vasko8cc3f662022-03-29 11:25:51 +0200492 * @param[in] parent Parsed parent data node, if any.
493 * @param[in] prefix Element prefix, if any.
494 * @param[in] prefix_len Length of @p prefix.
495 * @param[in] name Element name.
496 * @param[in] name_len Length of @p name.
497 * @param[out] snode Found schema node, NULL if no suitable was found.
498 * @param[out] ext Extension instance that provided @p snode, if any.
Michal Vaskoddd76592022-01-17 13:34:48 +0100499 * @return LY_SUCCESS on success;
Michal Vaskoddd76592022-01-17 13:34:48 +0100500 * @return LY_ERR on error.
501 */
502static LY_ERR
Michal Vasko8cc3f662022-03-29 11:25:51 +0200503lydxml_subtree_snode(struct lyd_xml_ctx *lydctx, const struct lyd_node *parent, const char *prefix, size_t prefix_len,
504 const char *name, size_t name_len, const struct lysc_node **snode, struct lysc_ext_instance **ext)
Michal Vaskoddd76592022-01-17 13:34:48 +0100505{
506 LY_ERR r;
Michal Vaskob36053d2020-03-26 15:49:30 +0100507 struct lyxml_ctx *xmlctx;
508 const struct ly_ctx *ctx;
Radek Krejcie7b95092019-05-15 11:03:07 +0200509 const struct lyxml_ns *ns;
Radek Krejcie7b95092019-05-15 11:03:07 +0200510 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200511 uint32_t getnext_opts;
Michal Vaskoe0665742021-02-11 11:08:44 +0100512
Michal Vaskob36053d2020-03-26 15:49:30 +0100513 xmlctx = lydctx->xmlctx;
514 ctx = xmlctx->ctx;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100515 getnext_opts = lydctx->int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0;
Michal Vasko6f4cbb62020-02-28 11:15:47 +0100516
Michal Vasko8cc3f662022-03-29 11:25:51 +0200517 *snode = NULL;
518 *ext = NULL;
Michal Vaskoddd76592022-01-17 13:34:48 +0100519
Michal Vasko8cc3f662022-03-29 11:25:51 +0200520 /* get current namespace */
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200521 ns = lyxml_ns_get(&xmlctx->ns, prefix, prefix_len);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200522 if (!ns) {
Radek Krejci422afb12021-03-04 16:38:16 +0100523 LOGVAL(ctx, LYVE_REFERENCE, "Unknown XML prefix \"%.*s\".", (int)prefix_len, prefix);
Michal Vasko8cc3f662022-03-29 11:25:51 +0200524 return LY_EVALID;
Michal Vaskoa5da3292020-08-12 13:10:50 +0200525 }
Michal Vasko8cc3f662022-03-29 11:25:51 +0200526
527 /* get the element module, use parent context if possible because of extensions */
528 mod = ly_ctx_get_module_implemented_ns(parent ? LYD_CTX(parent) : ctx, ns->uri);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200529 if (!mod) {
Michal Vaskoddd76592022-01-17 13:34:48 +0100530 /* check for extension data */
Michal Vasko8cc3f662022-03-29 11:25:51 +0200531 r = ly_nested_ext_schema(parent, NULL, prefix, prefix_len, LY_VALUE_XML, &lydctx->xmlctx->ns, name, name_len,
532 snode, ext);
533 if (r != LY_ENOT) {
534 /* success or error */
Michal Vaskoddd76592022-01-17 13:34:48 +0100535 return r;
Michal Vaskoddd76592022-01-17 13:34:48 +0100536 }
537
538 /* unknown module */
Michal Vaskoe0665742021-02-11 11:08:44 +0100539 if (lydctx->parse_opts & LYD_PARSE_STRICT) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100540 LOGVAL(ctx, LYVE_REFERENCE, "No module with namespace \"%s\" in the context.", ns->uri);
Michal Vasko8cc3f662022-03-29 11:25:51 +0200541 return LY_EVALID;
Radek Krejcie7b95092019-05-15 11:03:07 +0200542 }
Michal Vasko8cc3f662022-03-29 11:25:51 +0200543 return LY_SUCCESS;
Radek Krejcie7b95092019-05-15 11:03:07 +0200544 }
545
Michal Vaskoa5da3292020-08-12 13:10:50 +0200546 /* get the schema node */
Michal Vasko81008a52021-07-21 16:06:12 +0200547 if (mod) {
Radek Krejcif16e2542021-02-17 15:39:23 +0100548 if (!parent && lydctx->ext) {
Michal Vasko8cc3f662022-03-29 11:25:51 +0200549 *snode = lysc_ext_find_node(lydctx->ext, mod, name, name_len, 0, getnext_opts);
Radek Krejcif16e2542021-02-17 15:39:23 +0100550 } else {
Michal Vasko8cc3f662022-03-29 11:25:51 +0200551 *snode = lys_find_child(parent ? parent->schema : NULL, mod, name, name_len, 0, getnext_opts);
Radek Krejcif16e2542021-02-17 15:39:23 +0100552 }
Michal Vasko8cc3f662022-03-29 11:25:51 +0200553 if (!*snode) {
Michal Vaskoddd76592022-01-17 13:34:48 +0100554 /* check for extension data */
Michal Vasko8cc3f662022-03-29 11:25:51 +0200555 r = ly_nested_ext_schema(parent, NULL, prefix, prefix_len, LY_VALUE_XML, &lydctx->xmlctx->ns, name,
556 name_len, snode, ext);
557 if (r != LY_ENOT) {
558 /* success or error */
Michal Vaskoddd76592022-01-17 13:34:48 +0100559 return r;
tadeas-vintrlik2aa36b42021-11-03 13:07:34 +0100560 }
Michal Vaskoddd76592022-01-17 13:34:48 +0100561
562 /* unknown data node */
Michal Vaskoe0665742021-02-11 11:08:44 +0100563 if (lydctx->parse_opts & LYD_PARSE_STRICT) {
564 if (parent) {
Radek Krejci422afb12021-03-04 16:38:16 +0100565 LOGVAL(ctx, LYVE_REFERENCE, "Node \"%.*s\" not found as a child of \"%s\" node.",
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100566 (int)name_len, name, LYD_NAME(parent));
Radek Krejcif16e2542021-02-17 15:39:23 +0100567 } else if (lydctx->ext) {
568 if (lydctx->ext->argument) {
Radek Krejci422afb12021-03-04 16:38:16 +0100569 LOGVAL(ctx, LYVE_REFERENCE, "Node \"%.*s\" not found in the \"%s\" %s extension instance.",
570 (int)name_len, name, lydctx->ext->argument, lydctx->ext->def->name);
Radek Krejcif16e2542021-02-17 15:39:23 +0100571 } else {
Radek Krejci422afb12021-03-04 16:38:16 +0100572 LOGVAL(ctx, LYVE_REFERENCE, "Node \"%.*s\" not found in the %s extension instance.",
573 (int)name_len, name, lydctx->ext->def->name);
Radek Krejcif16e2542021-02-17 15:39:23 +0100574 }
Michal Vaskoe0665742021-02-11 11:08:44 +0100575 } else {
Radek Krejci422afb12021-03-04 16:38:16 +0100576 LOGVAL(ctx, LYVE_REFERENCE, "Node \"%.*s\" not found in the \"%s\" module.",
577 (int)name_len, name, mod->name);
Michal Vaskoe0665742021-02-11 11:08:44 +0100578 }
Michal Vasko8cc3f662022-03-29 11:25:51 +0200579 return LY_EVALID;
Michal Vaskoa5da3292020-08-12 13:10:50 +0200580 }
Michal Vasko8cc3f662022-03-29 11:25:51 +0200581 return LY_SUCCESS;
Michal Vaskoa5da3292020-08-12 13:10:50 +0200582 } else {
583 /* check that schema node is valid and can be used */
Michal Vasko8cc3f662022-03-29 11:25:51 +0200584 LY_CHECK_RET(lyd_parser_check_schema((struct lyd_ctx *)lydctx, *snode));
585 LY_CHECK_RET(lydxml_data_check_opaq(lydctx, snode));
Michal Vaskoa5da3292020-08-12 13:10:50 +0200586 }
587 }
588
Michal Vasko8cc3f662022-03-29 11:25:51 +0200589 return LY_SUCCESS;
590}
591
592/**
593 * @brief Parse XML subtree.
594 *
595 * @param[in] lydctx XML YANG data parser context.
596 * @param[in,out] parent Parent node where the children are inserted. NULL in case of parsing top-level elements.
597 * @param[in,out] first_p Pointer to the first (@p parent or top-level) child. In case there were already some siblings,
598 * this may point to a previously existing node.
599 * @param[in,out] parsed Optional set to add all the parsed siblings into.
600 * @return LY_ERR value.
601 */
602static LY_ERR
603lydxml_subtree_r(struct lyd_xml_ctx *lydctx, struct lyd_node *parent, struct lyd_node **first_p, struct ly_set *parsed)
604{
605 LY_ERR ret = LY_SUCCESS;
606 const char *prefix, *name;
607 size_t prefix_len, name_len;
608 struct lyxml_ctx *xmlctx;
609 const struct ly_ctx *ctx;
610 const struct lyxml_ns *ns;
611 struct lyd_meta *meta = NULL;
612 struct lyd_attr *attr = NULL;
613 const struct lysc_node *snode;
614 struct lysc_ext_instance *ext;
Michal Vaskocea58712022-04-01 14:37:08 +0200615 uint32_t prev_parse_opts, orig_parse_opts, prev_int_opts, hints;
616 struct lyd_node *node = NULL, *anchor, *insert_anchor = NULL;
Michal Vasko8cc3f662022-03-29 11:25:51 +0200617 void *val_prefix_data = NULL;
618 LY_VALUE_FORMAT format;
619 ly_bool parse_subtree;
620 char *val;
621
622 assert(parent || first_p);
623
624 xmlctx = lydctx->xmlctx;
625 ctx = xmlctx->ctx;
626
627 parse_subtree = lydctx->parse_opts & LYD_PARSE_SUBTREE ? 1 : 0;
628 /* all descendants should be parsed */
629 lydctx->parse_opts &= ~LYD_PARSE_SUBTREE;
630 orig_parse_opts = lydctx->parse_opts;
631
632 assert(xmlctx->status == LYXML_ELEMENT);
633
634 /* remember element prefix and name */
635 prefix = xmlctx->prefix;
636 prefix_len = xmlctx->prefix_len;
637 name = xmlctx->name;
638 name_len = xmlctx->name_len;
639
640 /* parser next */
641 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), error);
642
643 /* get the schema node */
644 LY_CHECK_GOTO(ret = lydxml_subtree_snode(lydctx, parent, prefix, prefix_len, name, name_len, &snode, &ext), error);
645
646 if (!snode && !(lydctx->parse_opts & LYD_PARSE_OPAQ)) {
647 LOGVRB("Skipping parsing of unknown node \"%.*s\".", name_len, name);
648
649 /* skip element with children */
650 LY_CHECK_GOTO(ret = lydxml_data_skip(xmlctx), error);
651 return LY_SUCCESS;
652 }
653
Michal Vaskoa5da3292020-08-12 13:10:50 +0200654 /* create metadata/attributes */
655 if (xmlctx->status == LYXML_ATTRIBUTE) {
656 if (snode) {
Michal Vaskoddd76592022-01-17 13:34:48 +0100657 ret = lydxml_metadata(lydctx, snode, &meta);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200658 LY_CHECK_GOTO(ret, error);
659 } else {
Michal Vaskoe0665742021-02-11 11:08:44 +0100660 assert(lydctx->parse_opts & LYD_PARSE_OPAQ);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200661 ret = lydxml_attrs(xmlctx, &attr);
662 LY_CHECK_GOTO(ret, error);
663 }
664 }
665
666 assert(xmlctx->status == LYXML_ELEM_CONTENT);
667 if (!snode) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100668 assert(lydctx->parse_opts & LYD_PARSE_OPAQ);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200669
670 if (xmlctx->ws_only) {
671 /* ignore WS-only value */
Radek IÅ¡a017270d2021-02-16 10:26:15 +0100672 if (xmlctx->dynamic) {
Michal Vaskocea58712022-04-01 14:37:08 +0200673 free((char *)xmlctx->value);
Radek IÅ¡a017270d2021-02-16 10:26:15 +0100674 }
675 xmlctx->dynamic = 0;
676 xmlctx->value = "";
Michal Vaskoa5da3292020-08-12 13:10:50 +0200677 xmlctx->value_len = 0;
Radek Krejci8df109d2021-04-23 12:19:08 +0200678 format = LY_VALUE_XML;
Michal Vaskoa5da3292020-08-12 13:10:50 +0200679 } else {
680 /* get value prefixes */
Radek Krejci8df109d2021-04-23 12:19:08 +0200681 ret = ly_store_prefix_data(xmlctx->ctx, xmlctx->value, xmlctx->value_len, LY_VALUE_XML,
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100682 &xmlctx->ns, &format, &val_prefix_data);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200683 LY_CHECK_GOTO(ret, error);
684 }
685
Michal Vaskoda8fbbf2021-06-16 11:44:44 +0200686 /* get NS again, it may have been backed up and restored */
687 ns = lyxml_ns_get(&xmlctx->ns, prefix, prefix_len);
688 assert(ns);
689
Michal Vaskocea58712022-04-01 14:37:08 +0200690 /* get best-effort node hints */
691 lydxml_get_hints_opaq(name, name_len, xmlctx->value, xmlctx->value_len, parent ? lyd_child(parent) : *first_p,
692 ns->uri, &hints, &insert_anchor);
693
Michal Vaskoa5da3292020-08-12 13:10:50 +0200694 /* create node */
Michal Vasko501af032020-11-11 20:27:44 +0100695 ret = lyd_create_opaq(ctx, name, name_len, prefix, prefix_len, ns->uri, strlen(ns->uri), xmlctx->value,
Michal Vaskocea58712022-04-01 14:37:08 +0200696 xmlctx->value_len, &xmlctx->dynamic, format, val_prefix_data, hints, &node);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200697 LY_CHECK_GOTO(ret, error);
698
699 /* parser next */
700 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), error);
701
702 /* process children */
703 while (xmlctx->status == LYXML_ELEMENT) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100704 ret = lydxml_subtree_r(lydctx, node, lyd_node_child_p(node), NULL);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200705 LY_CHECK_GOTO(ret, error);
706 }
707 } else if (snode->nodetype & LYD_NODE_TERM) {
708 /* create node */
Michal Vasko22df3f02020-08-24 13:29:22 +0200709 LY_CHECK_GOTO(ret = lyd_parser_create_term((struct lyd_ctx *)lydctx, snode, xmlctx->value, xmlctx->value_len,
Radek Krejci8df109d2021-04-23 12:19:08 +0200710 &xmlctx->dynamic, LY_VALUE_XML, &xmlctx->ns, LYD_HINT_DATA, &node), error);
Radek Krejciddace2c2021-01-08 11:30:56 +0100711 LOG_LOCSET(snode, node, NULL, NULL);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200712
713 if (parent && (node->schema->flags & LYS_KEY)) {
714 /* check the key order, the anchor must never be a key */
Michal Vaskoe0665742021-02-11 11:08:44 +0100715 anchor = lyd_insert_get_next_anchor(lyd_child(parent), node);
Michal Vasko441e0fa2022-03-03 13:45:00 +0100716 if (anchor && anchor->schema && (anchor->schema->flags & LYS_KEY)) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100717 if (lydctx->parse_opts & LYD_PARSE_STRICT) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100718 LOGVAL(ctx, LYVE_DATA, "Invalid position of the key \"%s\" in a list.", node->schema->name);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200719 ret = LY_EVALID;
720 goto error;
721 } else {
722 LOGWRN(ctx, "Invalid position of the key \"%s\" in a list.", node->schema->name);
723 }
724 }
725 }
726
727 /* parser next */
728 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), error);
729
730 /* no children expected */
731 if (xmlctx->status == LYXML_ELEMENT) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100732 LOGVAL(ctx, LYVE_SYNTAX, "Child element \"%.*s\" inside a terminal node \"%s\" found.",
Radek Krejci422afb12021-03-04 16:38:16 +0100733 (int)xmlctx->name_len, xmlctx->name, snode->name);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200734 ret = LY_EVALID;
735 goto error;
736 }
737 } else if (snode->nodetype & LYD_NODE_INNER) {
738 if (!xmlctx->ws_only) {
739 /* value in inner node */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100740 LOGVAL(ctx, LYVE_SYNTAX, "Text value \"%.*s\" inside an inner node \"%s\" found.",
Radek Krejci422afb12021-03-04 16:38:16 +0100741 (int)xmlctx->value_len, xmlctx->value, snode->name);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200742 ret = LY_EVALID;
743 goto error;
744 }
745
746 /* create node */
747 ret = lyd_create_inner(snode, &node);
748 LY_CHECK_GOTO(ret, error);
749
Radek Krejciddace2c2021-01-08 11:30:56 +0100750 LOG_LOCSET(snode, node, NULL, NULL);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100751
Michal Vaskoa5da3292020-08-12 13:10:50 +0200752 /* parser next */
753 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), error);
754
Michal Vasko8cc3f662022-03-29 11:25:51 +0200755 prev_parse_opts = lydctx->parse_opts;
756 if (ext) {
757 /* only parse these extension data and validate afterwards */
758 lydctx->parse_opts |= LYD_PARSE_ONLY;
759 }
760
Michal Vaskoa5da3292020-08-12 13:10:50 +0200761 /* process children */
762 while (xmlctx->status == LYXML_ELEMENT) {
Michal Vaskoe0665742021-02-11 11:08:44 +0100763 ret = lydxml_subtree_r(lydctx, node, lyd_node_child_p(node), NULL);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200764 LY_CHECK_GOTO(ret, error);
765 }
766
Michal Vasko8cc3f662022-03-29 11:25:51 +0200767 /* restore options */
768 lydctx->parse_opts = prev_parse_opts;
769
Michal Vaskoa5da3292020-08-12 13:10:50 +0200770 if (snode->nodetype == LYS_LIST) {
771 /* check all keys exist */
772 LY_CHECK_GOTO(ret = lyd_parse_check_keys(node), error);
773 }
774
Michal Vaskoe0665742021-02-11 11:08:44 +0100775 if (!(lydctx->parse_opts & LYD_PARSE_ONLY)) {
Michal Vaskoa5da3292020-08-12 13:10:50 +0200776 /* new node validation, autodelete CANNOT occur, all nodes are new */
Michal Vaskoe0665742021-02-11 11:08:44 +0100777 ret = lyd_validate_new(lyd_node_child_p(node), snode, NULL, NULL);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200778 LY_CHECK_GOTO(ret, error);
779
780 /* add any missing default children */
Michal Vaskoddd76592022-01-17 13:34:48 +0100781 ret = lyd_new_implicit_r(node, lyd_node_child_p(node), NULL, NULL, &lydctx->node_when, &lydctx->node_types,
782 (lydctx->val_opts & LYD_VALIDATE_NO_STATE) ? LYD_IMPLICIT_NO_STATE : 0, NULL);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200783 LY_CHECK_GOTO(ret, error);
784 }
785
786 if (snode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) {
787 /* rememeber the RPC/action/notification */
788 lydctx->op_node = node;
789 }
790 } else if (snode->nodetype & LYD_NODE_ANY) {
Michal Vasko27c4dce2021-03-04 15:50:50 +0100791 if ((snode->nodetype == LYS_ANYDATA) && !xmlctx->ws_only) {
792 /* value in anydata node, we expect a tree */
793 LOGVAL(ctx, LYVE_SYNTAX, "Text value \"%.*s\" inside an anydata node \"%s\" found.",
Radek Krejci422afb12021-03-04 16:38:16 +0100794 (int)xmlctx->value_len < 20 ? xmlctx->value_len : 20, xmlctx->value, snode->name);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200795 ret = LY_EVALID;
796 goto error;
797 }
798
Michal Vasko27c4dce2021-03-04 15:50:50 +0100799 if (!xmlctx->ws_only) {
800 /* use an arbitrary text value for anyxml */
Michal Vasko742a5b12022-02-24 16:07:27 +0100801 val = strndup(xmlctx->value, xmlctx->value_len);
802 LY_CHECK_ERR_GOTO(!val, LOGMEM(xmlctx->ctx); ret = LY_EMEM, error);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200803
Michal Vasko27c4dce2021-03-04 15:50:50 +0100804 /* parser next */
Michal Vaskoa04107f2022-03-29 12:09:50 +0200805 LY_CHECK_ERR_GOTO(ret = lyxml_ctx_next(xmlctx), free(val), error);
Michal Vasko27c4dce2021-03-04 15:50:50 +0100806
807 /* create node */
808 ret = lyd_create_any(snode, val, LYD_ANYDATA_STRING, 1, &node);
Michal Vasko742a5b12022-02-24 16:07:27 +0100809 LY_CHECK_ERR_GOTO(ret, free(val), error);
Michal Vasko27c4dce2021-03-04 15:50:50 +0100810 } else {
811 /* parser next */
812 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), error);
813
Michal Vaskoa98e3ea2021-06-03 09:13:33 +0200814 /* update options so that generic data can be parsed */
815 prev_parse_opts = lydctx->parse_opts;
Michal Vasko27c4dce2021-03-04 15:50:50 +0100816 lydctx->parse_opts &= ~LYD_PARSE_STRICT;
Michal Vasko8cc3f662022-03-29 11:25:51 +0200817 lydctx->parse_opts |= LYD_PARSE_OPAQ | (ext ? LYD_PARSE_ONLY : 0);
Michal Vaskoa98e3ea2021-06-03 09:13:33 +0200818 prev_int_opts = lydctx->int_opts;
Michal Vasko02ed9d82021-07-15 14:58:04 +0200819 lydctx->int_opts |= LYD_INTOPT_ANY | LYD_INTOPT_WITH_SIBLINGS;
Michal Vaskoa98e3ea2021-06-03 09:13:33 +0200820
821 /* parse any data tree */
Michal Vasko27c4dce2021-03-04 15:50:50 +0100822 anchor = NULL;
823 while (xmlctx->status == LYXML_ELEMENT) {
824 ret = lydxml_subtree_r(lydctx, NULL, &anchor, NULL);
Michal Vaskoa98e3ea2021-06-03 09:13:33 +0200825 if (ret) {
Michal Vaskocc53c582022-04-01 12:07:44 +0200826 lyd_free_siblings(anchor);
Michal Vaskoa98e3ea2021-06-03 09:13:33 +0200827 break;
828 }
Michal Vasko27c4dce2021-03-04 15:50:50 +0100829 }
Michal Vaskoa98e3ea2021-06-03 09:13:33 +0200830
831 /* restore options */
832 lydctx->parse_opts = prev_parse_opts;
833 lydctx->int_opts = prev_int_opts;
834
835 LY_CHECK_GOTO(ret, error);
Michal Vasko27c4dce2021-03-04 15:50:50 +0100836
837 /* create node */
838 ret = lyd_create_any(snode, anchor, LYD_ANYDATA_DATATREE, 1, &node);
839 LY_CHECK_GOTO(ret, error);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200840 }
Michal Vaskoa5da3292020-08-12 13:10:50 +0200841 }
842 assert(node);
843
844 /* add/correct flags */
845 if (snode) {
Michal Vasko8cc3f662022-03-29 11:25:51 +0200846 LY_CHECK_GOTO(ret = lyd_parse_set_data_flags(node, &meta, (struct lyd_ctx *)lydctx, ext), error);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200847 }
848
849 /* parser next */
850 assert(xmlctx->status == LYXML_ELEM_CLOSE);
Michal Vaskoddd76592022-01-17 13:34:48 +0100851 if (!parse_subtree) {
852 LY_CHECK_GOTO(ret = lyxml_ctx_next(xmlctx), error);
853 }
Michal Vaskoa5da3292020-08-12 13:10:50 +0200854
855 /* add metadata/attributes */
856 if (snode) {
Michal Vasko871a0252020-11-11 18:35:24 +0100857 lyd_insert_meta(node, meta, 0);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200858 } else {
859 lyd_insert_attr(node, attr);
860 }
861
862 /* insert, keep first pointer correct */
Michal Vaskocea58712022-04-01 14:37:08 +0200863 if (insert_anchor) {
864 lyd_insert_after(insert_anchor, node);
865 } else if (ext) {
Michal Vasko8cc3f662022-03-29 11:25:51 +0200866 LY_CHECK_GOTO(ret = lyd_insert_ext(parent, node), error);
867 } else {
868 lyd_insert_node(parent, first_p, node, lydctx->parse_opts & LYD_PARSE_ORDERED ? 1 : 0);
869 }
Michal Vaskoa5da3292020-08-12 13:10:50 +0200870 while (!parent && (*first_p)->prev->next) {
871 *first_p = (*first_p)->prev;
872 }
873
Michal Vaskoe0665742021-02-11 11:08:44 +0100874 /* rememeber a successfully parsed node */
875 if (parsed) {
876 ly_set_add(parsed, node, 1, NULL);
877 }
878
Michal Vasko8cc3f662022-03-29 11:25:51 +0200879 lydctx->parse_opts = orig_parse_opts;
Radek Krejciddace2c2021-01-08 11:30:56 +0100880 LOG_LOCBACK(node ? 1 : 0, node ? 1 : 0, 0, 0);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200881 return LY_SUCCESS;
882
883error:
Michal Vasko8cc3f662022-03-29 11:25:51 +0200884 lydctx->parse_opts = orig_parse_opts;
Radek Krejciddace2c2021-01-08 11:30:56 +0100885 LOG_LOCBACK(node ? 1 : 0, node ? 1 : 0, 0, 0);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200886 lyd_free_meta_siblings(meta);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200887 lyd_free_attr_siblings(ctx, attr);
Michal Vaskoa5da3292020-08-12 13:10:50 +0200888 lyd_free_tree(node);
Radek Krejcie7b95092019-05-15 11:03:07 +0200889 return ret;
890}
891
Michal Vaskoe0665742021-02-11 11:08:44 +0100892/**
893 * @brief Parse a specific XML element into an opaque node.
894 *
895 * @param[in] xmlctx XML parser context.
896 * @param[in] name Name of the element.
897 * @param[in] uri URI of the element.
898 * @param[in] value Whether a value is expected in the element.
899 * @param[out] evnp Parsed envelope (opaque node).
900 * @return LY_SUCCESS on success.
901 * @return LY_ENOT if the specified element did not match.
902 * @return LY_ERR value on error.
903 */
Michal Vasko1bf09392020-03-27 12:38:10 +0100904static LY_ERR
Michal Vaskoe0665742021-02-11 11:08:44 +0100905lydxml_envelope(struct lyxml_ctx *xmlctx, const char *name, const char *uri, ly_bool value, struct lyd_node **envp)
Michal Vasko1bf09392020-03-27 12:38:10 +0100906{
Michal Vaskoe0665742021-02-11 11:08:44 +0100907 LY_ERR rc = LY_SUCCESS;
908 const struct lyxml_ns *ns;
Radek Krejci1798aae2020-07-14 13:26:06 +0200909 struct lyd_attr *attr = NULL;
Michal Vasko1bf09392020-03-27 12:38:10 +0100910 const char *prefix;
911 size_t prefix_len;
912
Michal Vasko1bf09392020-03-27 12:38:10 +0100913 assert(xmlctx->status == LYXML_ELEMENT);
914 if (ly_strncmp(name, xmlctx->name, xmlctx->name_len)) {
915 /* not the expected element */
Michal Vaskoe0665742021-02-11 11:08:44 +0100916 return LY_ENOT;
Michal Vaskoa8edff02020-03-27 14:47:01 +0100917 }
918
919 prefix = xmlctx->prefix;
920 prefix_len = xmlctx->prefix_len;
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200921 ns = lyxml_ns_get(&xmlctx->ns, prefix, prefix_len);
Michal Vaskoa8edff02020-03-27 14:47:01 +0100922 if (!ns) {
Radek Krejci422afb12021-03-04 16:38:16 +0100923 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Unknown XML prefix \"%.*s\".", (int)prefix_len, prefix);
Michal Vaskoe0665742021-02-11 11:08:44 +0100924 return LY_EVALID;
925 } else if (strcmp(ns->uri, uri)) {
926 /* different namespace */
927 return LY_ENOT;
Michal Vaskoa8edff02020-03-27 14:47:01 +0100928 }
929
930 LY_CHECK_RET(lyxml_ctx_next(xmlctx));
931
932 /* create attributes */
933 if (xmlctx->status == LYXML_ATTRIBUTE) {
934 LY_CHECK_RET(lydxml_attrs(xmlctx, &attr));
935 }
936
Michal Vaskoe0665742021-02-11 11:08:44 +0100937 assert(xmlctx->status == LYXML_ELEM_CONTENT);
938 if (!value && !xmlctx->ws_only) {
939 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Unexpected value \"%.*s\" in the \"%s\" element.",
Radek Krejci422afb12021-03-04 16:38:16 +0100940 (int)xmlctx->value_len, xmlctx->value, name);
Michal Vaskoe0665742021-02-11 11:08:44 +0100941 rc = LY_EVALID;
Michal Vaskoa8edff02020-03-27 14:47:01 +0100942 goto cleanup;
Michal Vaskoe0665742021-02-11 11:08:44 +0100943 }
Michal Vaskoa8edff02020-03-27 14:47:01 +0100944
945 /* create node */
Michal Vaskoe0665742021-02-11 11:08:44 +0100946 rc = lyd_create_opaq(xmlctx->ctx, name, strlen(name), prefix, prefix_len, uri, strlen(uri), xmlctx->value,
Radek Krejci8df109d2021-04-23 12:19:08 +0200947 xmlctx->ws_only ? 0 : xmlctx->value_len, NULL, LY_VALUE_XML, NULL, 0, envp);
Michal Vaskoe0665742021-02-11 11:08:44 +0100948 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoa8edff02020-03-27 14:47:01 +0100949
950 /* assign atributes */
Michal Vaskoe0665742021-02-11 11:08:44 +0100951 ((struct lyd_node_opaq *)(*envp))->attr = attr;
Michal Vaskoa8edff02020-03-27 14:47:01 +0100952 attr = NULL;
953
Michal Vaskoe0665742021-02-11 11:08:44 +0100954 /* parser next element */
955 LY_CHECK_GOTO(rc = lyxml_ctx_next(xmlctx), cleanup);
Michal Vaskoa8edff02020-03-27 14:47:01 +0100956
Michal Vaskoe0665742021-02-11 11:08:44 +0100957cleanup:
958 lyd_free_attr_siblings(xmlctx->ctx, attr);
959 if (rc) {
960 lyd_free_tree(*envp);
961 *envp = NULL;
962 }
963 return rc;
964}
965
966/**
967 * @brief Parse all expected non-data XML elements of a NETCONF rpc message.
968 *
969 * @param[in] xmlctx XML parser context.
970 * @param[out] evnp Parsed envelope(s) (opaque node).
971 * @param[out] int_opts Internal options for parsing the rest of YANG data.
972 * @param[out] close_elem Number of parsed opened elements that need to be closed.
973 * @return LY_SUCCESS on success.
974 * @return LY_ERR value on error.
975 */
976static LY_ERR
977lydxml_env_netconf_rpc(struct lyxml_ctx *xmlctx, struct lyd_node **envp, uint32_t *int_opts, uint32_t *close_elem)
978{
979 LY_ERR rc = LY_SUCCESS, r;
980 struct lyd_node *child;
981
982 assert(envp && !*envp);
983
Michal Vasko50375272022-04-26 12:07:46 +0200984 if (xmlctx->status != LYXML_ELEMENT) {
985 /* nothing to parse */
986 assert(xmlctx->status == LYXML_END);
987 goto cleanup;
988 }
989
Michal Vaskoe0665742021-02-11 11:08:44 +0100990 /* parse "rpc" */
991 r = lydxml_envelope(xmlctx, "rpc", "urn:ietf:params:xml:ns:netconf:base:1.0", 0, envp);
Michal Vaskoe0665742021-02-11 11:08:44 +0100992 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
993
994 /* parse "action", if any */
995 r = lydxml_envelope(xmlctx, "action", "urn:ietf:params:xml:ns:yang:1", 0, &child);
996 if (r == LY_SUCCESS) {
997 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +0200998 lyd_insert_node(*envp, NULL, child, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +0100999
1000 /* NETCONF action */
1001 *int_opts = LYD_INTOPT_NO_SIBLINGS | LYD_INTOPT_ACTION;
1002 *close_elem = 2;
1003 } else if (r == LY_ENOT) {
1004 /* NETCONF RPC */
1005 *int_opts = LYD_INTOPT_NO_SIBLINGS | LYD_INTOPT_RPC;
1006 *close_elem = 1;
1007 } else {
1008 rc = r;
1009 goto cleanup;
1010 }
1011
1012cleanup:
1013 if (rc) {
1014 lyd_free_tree(*envp);
1015 *envp = NULL;
1016 }
1017 return rc;
1018}
1019
1020/**
Michal Vasko51de7b72022-04-29 09:50:22 +02001021 * @brief Validate eventTime date-and-time value.
1022 *
1023 * @param[in] node Opaque eventTime node.
1024 * @return LY_SUCCESS on success.
1025 * @return LY_ERR value on error.
1026 */
1027static LY_ERR
1028lydxml_env_netconf_eventtime_validate(const struct lyd_node *node)
1029{
1030 LY_ERR rc = LY_SUCCESS;
1031 struct ly_ctx *ctx = (struct ly_ctx *)LYD_CTX(node);
1032 struct lysc_ctx cctx = {.ctx = ctx};
1033 const struct lys_module *mod;
1034 LY_ARRAY_COUNT_TYPE u;
1035 struct ly_err_item *err = NULL;
Michal Vaskoab36a7e2022-04-29 10:25:56 +02001036 struct lysp_type *type_p = NULL;
Michal Vasko51de7b72022-04-29 09:50:22 +02001037 struct lysc_pattern **patterns = NULL;
1038 const char *value;
1039
1040 /* get date-and-time parsed type */
1041 mod = ly_ctx_get_module_latest(ctx, "ietf-yang-types");
Michal Vaskoab36a7e2022-04-29 10:25:56 +02001042 assert(mod);
Michal Vasko51de7b72022-04-29 09:50:22 +02001043 LY_ARRAY_FOR(mod->parsed->typedefs, u) {
1044 if (!strcmp(mod->parsed->typedefs[u].name, "date-and-time")) {
1045 type_p = &mod->parsed->typedefs[u].type;
1046 break;
1047 }
1048 }
1049 assert(type_p);
1050
1051 /* compile patterns */
1052 assert(type_p->patterns);
1053 LY_CHECK_GOTO(rc = lys_compile_type_patterns(&cctx, type_p->patterns, NULL, &patterns), cleanup);
1054
1055 /* validate */
1056 value = lyd_get_value(node);
1057 rc = lyplg_type_validate_patterns(patterns, value, strlen(value), &err);
1058
1059cleanup:
1060 FREE_ARRAY(ctx, patterns, lysc_pattern_free);
1061 if (rc && err) {
1062 LOGVAL_ERRITEM(ctx, err);
1063 ly_err_free(err);
1064 LOGVAL(ctx, LYVE_DATA, "Invalid \"eventTime\" in the notification.");
1065 }
1066 return rc;
1067}
1068
1069/**
Michal Vaskoe0665742021-02-11 11:08:44 +01001070 * @brief Parse all expected non-data XML elements of a NETCONF notification message.
1071 *
1072 * @param[in] xmlctx XML parser context.
1073 * @param[out] evnp Parsed envelope(s) (opaque node).
1074 * @param[out] int_opts Internal options for parsing the rest of YANG data.
1075 * @param[out] close_elem Number of parsed opened elements that need to be closed.
1076 * @return LY_SUCCESS on success.
1077 * @return LY_ERR value on error.
1078 */
1079static LY_ERR
1080lydxml_env_netconf_notif(struct lyxml_ctx *xmlctx, struct lyd_node **envp, uint32_t *int_opts, uint32_t *close_elem)
1081{
1082 LY_ERR rc = LY_SUCCESS, r;
1083 struct lyd_node *child;
1084
1085 assert(envp && !*envp);
1086
Michal Vasko50375272022-04-26 12:07:46 +02001087 if (xmlctx->status != LYXML_ELEMENT) {
1088 /* nothing to parse */
1089 assert(xmlctx->status == LYXML_END);
1090 goto cleanup;
1091 }
1092
Michal Vaskoe0665742021-02-11 11:08:44 +01001093 /* parse "notification" */
1094 r = lydxml_envelope(xmlctx, "notification", "urn:ietf:params:xml:ns:netconf:notification:1.0", 0, envp);
Michal Vaskoe0665742021-02-11 11:08:44 +01001095 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
1096
1097 /* parse "eventTime" */
1098 r = lydxml_envelope(xmlctx, "eventTime", "urn:ietf:params:xml:ns:netconf:notification:1.0", 1, &child);
1099 if (r == LY_ENOT) {
Radek Krejci422afb12021-03-04 16:38:16 +01001100 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Unexpected element \"%.*s\" instead of \"eventTime\".",
1101 (int)xmlctx->name_len, xmlctx->name);
Michal Vaskoe0665742021-02-11 11:08:44 +01001102 r = LY_EVALID;
1103 }
1104 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
1105
1106 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +02001107 lyd_insert_node(*envp, NULL, child, 0);
Michal Vaskoe0665742021-02-11 11:08:44 +01001108
1109 /* validate value */
Michal Vasko51de7b72022-04-29 09:50:22 +02001110 r = lydxml_env_netconf_eventtime_validate(child);
1111 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001112
1113 /* finish child parsing */
Michal Vaskoa8edff02020-03-27 14:47:01 +01001114 if (xmlctx->status != LYXML_ELEM_CLOSE) {
1115 assert(xmlctx->status == LYXML_ELEMENT);
Michal Vaskoe0665742021-02-11 11:08:44 +01001116 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Unexpected child element \"%.*s\" of \"eventTime\".",
Radek Krejci422afb12021-03-04 16:38:16 +01001117 (int)xmlctx->name_len, xmlctx->name);
Michal Vaskoe0665742021-02-11 11:08:44 +01001118 rc = LY_EVALID;
Michal Vaskoa8edff02020-03-27 14:47:01 +01001119 goto cleanup;
1120 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001121 LY_CHECK_GOTO(rc = lyxml_ctx_next(xmlctx), cleanup);
1122
1123 /* NETCONF notification */
1124 *int_opts = LYD_INTOPT_NO_SIBLINGS | LYD_INTOPT_NOTIF;
1125 *close_elem = 1;
Michal Vaskoa8edff02020-03-27 14:47:01 +01001126
1127cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +01001128 if (rc) {
Michal Vaskoa8edff02020-03-27 14:47:01 +01001129 lyd_free_tree(*envp);
Michal Vaskoe0665742021-02-11 11:08:44 +01001130 *envp = NULL;
Michal Vaskoa8edff02020-03-27 14:47:01 +01001131 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001132 return rc;
Michal Vaskoa8edff02020-03-27 14:47:01 +01001133}
Michal Vasko79135ae2020-12-16 10:08:35 +01001134
Michal Vaskoe0665742021-02-11 11:08:44 +01001135/**
1136 * @brief Parse an XML element as an opaque node subtree.
1137 *
1138 * @param[in] xmlctx XML parser context.
1139 * @param[in] parent Parent to append nodes to.
1140 * @return LY_ERR value.
1141 */
1142static LY_ERR
1143lydxml_opaq_r(struct lyxml_ctx *xmlctx, struct lyd_node *parent)
Michal Vaskoa8edff02020-03-27 14:47:01 +01001144{
Michal Vaskoe0665742021-02-11 11:08:44 +01001145 LY_ERR rc = LY_SUCCESS;
1146 const struct lyxml_ns *ns;
1147 struct lyd_attr *attr = NULL;
1148 struct lyd_node *child = NULL;
1149 const char *name, *prefix;
1150 size_t name_len, prefix_len;
Michal Vaskoa8edff02020-03-27 14:47:01 +01001151
Michal Vaskoe0665742021-02-11 11:08:44 +01001152 assert(xmlctx->status == LYXML_ELEMENT);
Michal Vaskoa8edff02020-03-27 14:47:01 +01001153
Michal Vaskoe0665742021-02-11 11:08:44 +01001154 name = xmlctx->name;
1155 name_len = xmlctx->name_len;
1156 prefix = xmlctx->prefix;
1157 prefix_len = xmlctx->prefix_len;
1158 ns = lyxml_ns_get(&xmlctx->ns, prefix, prefix_len);
1159 if (!ns) {
Radek Krejci422afb12021-03-04 16:38:16 +01001160 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Unknown XML prefix \"%.*s\".", (int)prefix_len, prefix);
Michal Vaskoe0665742021-02-11 11:08:44 +01001161 return LY_EVALID;
1162 }
Michal Vaskoa8edff02020-03-27 14:47:01 +01001163
Michal Vaskoe0665742021-02-11 11:08:44 +01001164 LY_CHECK_RET(lyxml_ctx_next(xmlctx));
Michal Vaskoa8edff02020-03-27 14:47:01 +01001165
Michal Vaskoe0665742021-02-11 11:08:44 +01001166 /* create attributes */
1167 if (xmlctx->status == LYXML_ATTRIBUTE) {
1168 LY_CHECK_RET(lydxml_attrs(xmlctx, &attr));
1169 }
1170
1171 /* create node */
1172 assert(xmlctx->status == LYXML_ELEM_CONTENT);
1173 rc = lyd_create_opaq(xmlctx->ctx, name, name_len, prefix, prefix_len, ns->uri, strlen(ns->uri), xmlctx->value,
Radek Krejci8df109d2021-04-23 12:19:08 +02001174 xmlctx->ws_only ? 0 : xmlctx->value_len, NULL, LY_VALUE_XML, NULL, 0, &child);
Michal Vaskoe0665742021-02-11 11:08:44 +01001175 LY_CHECK_GOTO(rc, cleanup);
1176
1177 /* assign atributes */
1178 ((struct lyd_node_opaq *)child)->attr = attr;
1179 attr = NULL;
1180
1181 /* parser next element */
1182 LY_CHECK_GOTO(rc = lyxml_ctx_next(xmlctx), cleanup);
1183
1184 /* parse all the descendants */
1185 while (xmlctx->status == LYXML_ELEMENT) {
1186 rc = lydxml_opaq_r(xmlctx, child);
1187 LY_CHECK_GOTO(rc, cleanup);
1188 }
1189
1190 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +02001191 lyd_insert_node(parent, NULL, child, 1);
Michal Vaskoe0665742021-02-11 11:08:44 +01001192
1193cleanup:
1194 lyd_free_attr_siblings(xmlctx->ctx, attr);
1195 if (rc) {
1196 lyd_free_tree(child);
1197 }
1198 return rc;
1199}
1200
1201/**
1202 * @brief Parse all expected non-data XML elements of the error-info element in NETCONF rpc-reply message.
1203 *
1204 * @param[in] xmlctx XML parser context.
1205 * @param[in] parent Parent to append nodes to.
1206 * @return LY_ERR value.
1207 */
1208static LY_ERR
1209lydxml_env_netconf_rpc_reply_error_info(struct lyxml_ctx *xmlctx, struct lyd_node *parent)
1210{
1211 LY_ERR r;
1212 struct lyd_node *child, *iter;
Michal Vaskoe0665742021-02-11 11:08:44 +01001213 ly_bool no_dup;
1214
1215 /* there must be some child */
1216 if (xmlctx->status == LYXML_ELEM_CLOSE) {
1217 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Missing child elements of \"error-info\".");
1218 return LY_EVALID;
1219 }
1220
1221 while (xmlctx->status == LYXML_ELEMENT) {
1222 child = NULL;
1223
1224 /*
1225 * session-id
1226 */
1227 r = lydxml_envelope(xmlctx, "session-id", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1228 if (r == LY_SUCCESS) {
1229 no_dup = 1;
1230 goto check_child;
1231 } else if (r != LY_ENOT) {
1232 goto error;
1233 }
1234
1235 /*
1236 * bad-attribute
1237 */
1238 r = lydxml_envelope(xmlctx, "bad-attribute", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1239 if (r == LY_SUCCESS) {
1240 no_dup = 1;
1241 goto check_child;
1242 } else if (r != LY_ENOT) {
1243 goto error;
1244 }
1245
1246 /*
1247 * bad-element
1248 */
1249 r = lydxml_envelope(xmlctx, "bad-element", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1250 if (r == LY_SUCCESS) {
1251 no_dup = 1;
1252 goto check_child;
1253 } else if (r != LY_ENOT) {
1254 goto error;
1255 }
1256
1257 /*
1258 * bad-namespace
1259 */
1260 r = lydxml_envelope(xmlctx, "bad-namespace", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1261 if (r == LY_SUCCESS) {
1262 no_dup = 1;
1263 goto check_child;
1264 } else if (r != LY_ENOT) {
1265 goto error;
1266 }
1267
1268 if (r == LY_ENOT) {
1269 assert(xmlctx->status == LYXML_ELEMENT);
1270
Michal Vaskoe0665742021-02-11 11:08:44 +01001271 /* custom elements */
1272 r = lydxml_opaq_r(xmlctx, parent);
1273 LY_CHECK_GOTO(r, error);
Michal Vasko6398eaf2022-01-10 10:12:30 +01001274 continue;
Michal Vaskoe0665742021-02-11 11:08:44 +01001275 }
1276
1277check_child:
1278 /* check for duplicates */
1279 if (no_dup) {
1280 LY_LIST_FOR(lyd_child(parent), iter) {
1281 if ((((struct lyd_node_opaq *)iter)->name.name == ((struct lyd_node_opaq *)child)->name.name) &&
1282 (((struct lyd_node_opaq *)iter)->name.module_ns == ((struct lyd_node_opaq *)child)->name.module_ns)) {
1283 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Duplicate element \"%s\" in \"error-info\".",
1284 ((struct lyd_node_opaq *)child)->name.name);
1285 r = LY_EVALID;
1286 goto error;
1287 }
1288 }
1289 }
1290
1291 /* finish child parsing */
1292 if (xmlctx->status != LYXML_ELEM_CLOSE) {
1293 assert(xmlctx->status == LYXML_ELEMENT);
1294 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Unexpected child element \"%.*s\" of \"error-info\".",
Radek Krejci422afb12021-03-04 16:38:16 +01001295 (int)xmlctx->name_len, xmlctx->name);
Michal Vaskoe0665742021-02-11 11:08:44 +01001296 r = LY_EVALID;
1297 goto error;
1298 }
1299 LY_CHECK_GOTO(r = lyxml_ctx_next(xmlctx), error);
1300
1301 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +02001302 lyd_insert_node(parent, NULL, child, 1);
Michal Vaskoe0665742021-02-11 11:08:44 +01001303 }
1304
1305 return LY_SUCCESS;
1306
1307error:
1308 lyd_free_tree(child);
1309 return r;
1310}
1311
1312/**
1313 * @brief Parse all expected non-data XML elements of the rpc-error element in NETCONF rpc-reply message.
1314 *
1315 * @param[in] xmlctx XML parser context.
1316 * @param[in] parent Parent to append nodes to.
1317 * @return LY_ERR value.
1318 */
1319static LY_ERR
1320lydxml_env_netconf_rpc_reply_error(struct lyxml_ctx *xmlctx, struct lyd_node *parent)
1321{
1322 LY_ERR r;
1323 struct lyd_node *child, *iter;
1324 const char *val;
1325 ly_bool no_dup;
1326
1327 /* there must be some child */
1328 if (xmlctx->status == LYXML_ELEM_CLOSE) {
1329 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Missing child elements of \"rpc-error\".");
1330 return LY_EVALID;
1331 }
1332
1333 while (xmlctx->status == LYXML_ELEMENT) {
1334 child = NULL;
1335
1336 /*
1337 * error-type
1338 */
1339 r = lydxml_envelope(xmlctx, "error-type", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1340 if (r == LY_SUCCESS) {
1341 val = ((struct lyd_node_opaq *)child)->value;
1342 if (strcmp(val, "transport") && strcmp(val, "rpc") && strcmp(val, "protocol") && strcmp(val, "application")) {
1343 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Invalid value \"%s\" of element \"%s\".", val,
1344 ((struct lyd_node_opaq *)child)->name.name);
1345 r = LY_EVALID;
1346 goto error;
1347 }
1348
1349 no_dup = 1;
1350 goto check_child;
1351 } else if (r != LY_ENOT) {
1352 goto error;
1353 }
1354
1355 /*
1356 * error-tag
1357 */
1358 r = lydxml_envelope(xmlctx, "error-tag", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1359 if (r == LY_SUCCESS) {
1360 val = ((struct lyd_node_opaq *)child)->value;
1361 if (strcmp(val, "in-use") && strcmp(val, "invalid-value") && strcmp(val, "too-big") &&
1362 strcmp(val, "missing-attribute") && strcmp(val, "bad-attribute") &&
1363 strcmp(val, "unknown-attribute") && strcmp(val, "missing-element") && strcmp(val, "bad-element") &&
1364 strcmp(val, "unknown-element") && strcmp(val, "unknown-namespace") && strcmp(val, "access-denied") &&
1365 strcmp(val, "lock-denied") && strcmp(val, "resource-denied") && strcmp(val, "rollback-failed") &&
1366 strcmp(val, "data-exists") && strcmp(val, "data-missing") && strcmp(val, "operation-not-supported") &&
1367 strcmp(val, "operation-failed") && strcmp(val, "malformed-message")) {
1368 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Invalid value \"%s\" of element \"%s\".", val,
1369 ((struct lyd_node_opaq *)child)->name.name);
1370 r = LY_EVALID;
1371 goto error;
1372 }
1373
1374 no_dup = 1;
1375 goto check_child;
1376 } else if (r != LY_ENOT) {
1377 goto error;
1378 }
1379
1380 /*
1381 * error-severity
1382 */
1383 r = lydxml_envelope(xmlctx, "error-severity", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1384 if (r == LY_SUCCESS) {
1385 val = ((struct lyd_node_opaq *)child)->value;
1386 if (strcmp(val, "error") && strcmp(val, "warning")) {
1387 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Invalid value \"%s\" of element \"%s\".", val,
1388 ((struct lyd_node_opaq *)child)->name.name);
1389 r = LY_EVALID;
1390 goto error;
1391 }
1392
1393 no_dup = 1;
1394 goto check_child;
1395 } else if (r != LY_ENOT) {
1396 goto error;
1397 }
1398
1399 /*
1400 * error-app-tag
1401 */
1402 r = lydxml_envelope(xmlctx, "error-app-tag", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1403 if (r == LY_SUCCESS) {
1404 no_dup = 1;
1405 goto check_child;
1406 } else if (r != LY_ENOT) {
1407 goto error;
1408 }
1409
1410 /*
1411 * error-path
1412 */
1413 r = lydxml_envelope(xmlctx, "error-path", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1414 if (r == LY_SUCCESS) {
1415 no_dup = 1;
1416 goto check_child;
1417 } else if (r != LY_ENOT) {
1418 goto error;
1419 }
1420
1421 /*
1422 * error-message
1423 */
1424 r = lydxml_envelope(xmlctx, "error-message", "urn:ietf:params:xml:ns:netconf:base:1.0", 1, &child);
1425 if (r == LY_SUCCESS) {
1426 no_dup = 1;
1427 goto check_child;
1428 } else if (r != LY_ENOT) {
1429 goto error;
1430 }
1431
1432 /* error-info */
1433 r = lydxml_envelope(xmlctx, "error-info", "urn:ietf:params:xml:ns:netconf:base:1.0", 0, &child);
1434 if (r == LY_SUCCESS) {
1435 /* parse all the descendants */
1436 LY_CHECK_GOTO(r = lydxml_env_netconf_rpc_reply_error_info(xmlctx, child), error);
1437
1438 no_dup = 0;
1439 goto check_child;
1440 } else if (r != LY_ENOT) {
1441 goto error;
1442 }
1443
1444 if (r == LY_ENOT) {
1445 assert(xmlctx->status == LYXML_ELEMENT);
1446 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Unexpected child element \"%.*s\" of \"rpc-error\".",
Radek Krejci422afb12021-03-04 16:38:16 +01001447 (int)xmlctx->name_len, xmlctx->name);
Michal Vaskoe0665742021-02-11 11:08:44 +01001448 r = LY_EVALID;
1449 goto error;
1450 }
1451
1452check_child:
1453 /* check for duplicates */
1454 if (no_dup) {
1455 LY_LIST_FOR(lyd_child(parent), iter) {
1456 if ((((struct lyd_node_opaq *)iter)->name.name == ((struct lyd_node_opaq *)child)->name.name) &&
1457 (((struct lyd_node_opaq *)iter)->name.module_ns == ((struct lyd_node_opaq *)child)->name.module_ns)) {
1458 LOGVAL(xmlctx->ctx, LYVE_REFERENCE, "Duplicate element \"%s\" in \"rpc-error\".",
1459 ((struct lyd_node_opaq *)child)->name.name);
1460 r = LY_EVALID;
1461 goto error;
1462 }
1463 }
1464 }
1465
1466 /* finish child parsing */
1467 if (xmlctx->status != LYXML_ELEM_CLOSE) {
1468 assert(xmlctx->status == LYXML_ELEMENT);
1469 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Unexpected child element \"%.*s\" of \"rpc-error\".",
Radek Krejci422afb12021-03-04 16:38:16 +01001470 (int)xmlctx->name_len, xmlctx->name);
Michal Vaskoe0665742021-02-11 11:08:44 +01001471 r = LY_EVALID;
1472 goto error;
1473 }
1474 LY_CHECK_GOTO(r = lyxml_ctx_next(xmlctx), error);
1475
1476 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +02001477 lyd_insert_node(parent, NULL, child, 1);
Michal Vaskoe0665742021-02-11 11:08:44 +01001478 }
1479
1480 return LY_SUCCESS;
1481
1482error:
1483 lyd_free_tree(child);
1484 return r;
1485}
1486
1487/**
1488 * @brief Parse all expected non-data XML elements of a NETCONF rpc-reply message.
1489 *
1490 * @param[in] xmlctx XML parser context.
1491 * @param[out] evnp Parsed envelope(s) (opaque node).
1492 * @param[out] int_opts Internal options for parsing the rest of YANG data.
1493 * @param[out] close_elem Number of parsed opened elements that need to be closed.
1494 * @return LY_SUCCESS on success.
1495 * @return LY_ERR value on error.
1496 */
1497static LY_ERR
1498lydxml_env_netconf_reply(struct lyxml_ctx *xmlctx, struct lyd_node **envp, uint32_t *int_opts, uint32_t *close_elem)
1499{
1500 LY_ERR rc = LY_SUCCESS, r;
1501 struct lyd_node *child = NULL;
1502 const char *parsed_elem = NULL;
1503
1504 assert(envp && !*envp);
1505
Michal Vasko50375272022-04-26 12:07:46 +02001506 if (xmlctx->status != LYXML_ELEMENT) {
1507 /* nothing to parse */
1508 assert(xmlctx->status == LYXML_END);
1509 goto cleanup;
1510 }
1511
Michal Vaskoe0665742021-02-11 11:08:44 +01001512 /* parse "rpc-reply" */
1513 r = lydxml_envelope(xmlctx, "rpc-reply", "urn:ietf:params:xml:ns:netconf:base:1.0", 0, envp);
Michal Vaskoe0665742021-02-11 11:08:44 +01001514 LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
1515
1516 /* there must be some child */
1517 if (xmlctx->status == LYXML_ELEM_CLOSE) {
1518 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Missing child elements of \"rpc-reply\".");
1519 rc = LY_EVALID;
Michal Vaskocf770e22020-08-12 13:21:43 +02001520 goto cleanup;
Michal Vaskoa8edff02020-03-27 14:47:01 +01001521 }
1522
Michal Vaskoe0665742021-02-11 11:08:44 +01001523 /* try to parse "ok" */
1524 r = lydxml_envelope(xmlctx, "ok", "urn:ietf:params:xml:ns:netconf:base:1.0", 0, &child);
1525 if (r == LY_SUCCESS) {
1526 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +02001527 lyd_insert_node(*envp, NULL, child, 1);
Michal Vaskoe0665742021-02-11 11:08:44 +01001528
1529 /* finish child parsing */
1530 if (xmlctx->status != LYXML_ELEM_CLOSE) {
1531 assert(xmlctx->status == LYXML_ELEMENT);
1532 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Unexpected child element \"%.*s\" of \"ok\".",
Radek Krejci422afb12021-03-04 16:38:16 +01001533 (int)xmlctx->name_len, xmlctx->name);
Michal Vaskoe0665742021-02-11 11:08:44 +01001534 rc = LY_EVALID;
1535 goto cleanup;
1536 }
1537 LY_CHECK_GOTO(rc = lyxml_ctx_next(xmlctx), cleanup);
1538
1539 /* success */
1540 parsed_elem = "ok";
1541 goto finish;
1542 } else if (r != LY_ENOT) {
1543 rc = r;
1544 goto cleanup;
Michal Vasko2552ea32020-12-08 15:32:34 +01001545 }
1546
Michal Vaskoe0665742021-02-11 11:08:44 +01001547 /* try to parse all "rpc-error" elements */
1548 while (xmlctx->status == LYXML_ELEMENT) {
1549 r = lydxml_envelope(xmlctx, "rpc-error", "urn:ietf:params:xml:ns:netconf:base:1.0", 0, &child);
1550 if (r == LY_ENOT) {
1551 break;
1552 } else if (r) {
1553 rc = r;
1554 goto cleanup;
1555 }
1556
1557 /* insert */
Michal Vasko6ee6f432021-07-16 09:49:14 +02001558 lyd_insert_node(*envp, NULL, child, 1);
Michal Vaskoe0665742021-02-11 11:08:44 +01001559
1560 /* parse all children of "rpc-error" */
1561 LY_CHECK_GOTO(rc = lydxml_env_netconf_rpc_reply_error(xmlctx, child), cleanup);
1562
1563 /* finish child parsing */
1564 assert(xmlctx->status == LYXML_ELEM_CLOSE);
1565 LY_CHECK_GOTO(rc = lyxml_ctx_next(xmlctx), cleanup);
1566
1567 parsed_elem = "rpc-error";
Michal Vasko2552ea32020-12-08 15:32:34 +01001568 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001569
1570finish:
1571 if (parsed_elem) {
1572 /* NETCONF rpc-reply with no data */
1573 if (xmlctx->status != LYXML_ELEM_CLOSE) {
1574 assert(xmlctx->status == LYXML_ELEMENT);
1575 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Unexpected sibling element \"%.*s\" of \"%s\".",
Radek Krejci422afb12021-03-04 16:38:16 +01001576 (int)xmlctx->name_len, xmlctx->name, parsed_elem);
Michal Vaskoe0665742021-02-11 11:08:44 +01001577 rc = LY_EVALID;
1578 goto cleanup;
1579 }
1580 }
1581
1582 /* NETCONF rpc-reply */
Michal Vasko1d991fd2021-07-09 13:14:40 +02001583 *int_opts = LYD_INTOPT_WITH_SIBLINGS | LYD_INTOPT_REPLY;
Michal Vaskoe0665742021-02-11 11:08:44 +01001584 *close_elem = 1;
1585
1586cleanup:
1587 if (rc) {
1588 lyd_free_tree(*envp);
1589 *envp = NULL;
1590 }
1591 return rc;
1592}
1593
Michal Vasko2552ea32020-12-08 15:32:34 +01001594LY_ERR
Radek Krejcif16e2542021-02-17 15:39:23 +01001595lyd_parse_xml(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, struct lyd_node *parent,
1596 struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts, enum lyd_type data_type,
Michal Vaskoddd76592022-01-17 13:34:48 +01001597 struct lyd_node **envp, struct ly_set *parsed, ly_bool *subtree_sibling, struct lyd_ctx **lydctx_p)
Michal Vasko2552ea32020-12-08 15:32:34 +01001598{
Michal Vaskoe0665742021-02-11 11:08:44 +01001599 LY_ERR rc = LY_SUCCESS;
1600 struct lyd_xml_ctx *lydctx;
Michal Vasko2ca9f9e2021-07-02 09:21:36 +02001601 uint32_t i, int_opts = 0, close_elem = 0;
Michal Vaskoe0665742021-02-11 11:08:44 +01001602 ly_bool parsed_data_nodes = 0;
Michal Vaskoddd76592022-01-17 13:34:48 +01001603 enum LYXML_PARSER_STATUS status;
Michal Vasko2552ea32020-12-08 15:32:34 +01001604
Michal Vaskoe0665742021-02-11 11:08:44 +01001605 assert(ctx && in && lydctx_p);
1606 assert(!(parse_opts & ~LYD_PARSE_OPTS_MASK));
1607 assert(!(val_opts & ~LYD_VALIDATE_OPTS_MASK));
Michal Vasko2552ea32020-12-08 15:32:34 +01001608
Michal Vaskoe0665742021-02-11 11:08:44 +01001609 /* init context */
1610 lydctx = calloc(1, sizeof *lydctx);
1611 LY_CHECK_ERR_RET(!lydctx, LOGMEM(ctx), LY_EMEM);
1612 LY_CHECK_GOTO(rc = lyxml_ctx_new(ctx, in, &lydctx->xmlctx), cleanup);
1613 lydctx->parse_opts = parse_opts;
1614 lydctx->val_opts = val_opts;
1615 lydctx->free = lyd_xml_ctx_free;
Radek Krejcif16e2542021-02-17 15:39:23 +01001616 lydctx->ext = ext;
Michal Vasko2552ea32020-12-08 15:32:34 +01001617
Michal Vaskoe0665742021-02-11 11:08:44 +01001618 switch (data_type) {
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001619 case LYD_TYPE_DATA_YANG:
Michal Vaskoddd76592022-01-17 13:34:48 +01001620 if (!(parse_opts & LYD_PARSE_SUBTREE)) {
1621 int_opts = LYD_INTOPT_WITH_SIBLINGS;
1622 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001623 break;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001624 case LYD_TYPE_RPC_YANG:
Michal Vaskoe0665742021-02-11 11:08:44 +01001625 int_opts = LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NO_SIBLINGS;
1626 break;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001627 case LYD_TYPE_NOTIF_YANG:
Michal Vaskoe0665742021-02-11 11:08:44 +01001628 int_opts = LYD_INTOPT_NOTIF | LYD_INTOPT_NO_SIBLINGS;
1629 break;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001630 case LYD_TYPE_REPLY_YANG:
Michal Vaskoe0665742021-02-11 11:08:44 +01001631 int_opts = LYD_INTOPT_REPLY | LYD_INTOPT_NO_SIBLINGS;
1632 break;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001633 case LYD_TYPE_RPC_NETCONF:
Michal Vaskoe0665742021-02-11 11:08:44 +01001634 assert(!parent);
Michal Vaskod71c2d42022-04-29 09:50:44 +02001635 rc = lydxml_env_netconf_rpc(lydctx->xmlctx, envp, &int_opts, &close_elem);
1636 if (rc == LY_ENOT) {
1637 LOGVAL(ctx, LYVE_DATA, "Missing NETCONF <rpc> envelope or in incorrect namespace.");
1638 }
1639 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001640 break;
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001641 case LYD_TYPE_NOTIF_NETCONF:
1642 assert(!parent);
Michal Vaskod71c2d42022-04-29 09:50:44 +02001643 rc = lydxml_env_netconf_notif(lydctx->xmlctx, envp, &int_opts, &close_elem);
1644 if (rc == LY_ENOT) {
1645 LOGVAL(ctx, LYVE_DATA, "Missing NETCONF <notification> envelope or in incorrect namespace.");
1646 }
1647 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko1e4c68e2021-02-18 15:03:01 +01001648 break;
1649 case LYD_TYPE_REPLY_NETCONF:
Michal Vaskoe0665742021-02-11 11:08:44 +01001650 assert(parent);
Michal Vaskod71c2d42022-04-29 09:50:44 +02001651 rc = lydxml_env_netconf_reply(lydctx->xmlctx, envp, &int_opts, &close_elem);
1652 if (rc == LY_ENOT) {
1653 LOGVAL(ctx, LYVE_DATA, "Missing NETCONF <rpc-reply> envelope or in incorrect namespace.");
1654 }
1655 LY_CHECK_GOTO(rc, cleanup);
Michal Vaskoe0665742021-02-11 11:08:44 +01001656 break;
1657 }
1658 lydctx->int_opts = int_opts;
1659
1660 /* find the operation node if it exists already */
1661 LY_CHECK_GOTO(rc = lyd_parser_find_operation(parent, int_opts, &lydctx->op_node), cleanup);
1662
1663 /* parse XML data */
1664 while (lydctx->xmlctx->status == LYXML_ELEMENT) {
1665 LY_CHECK_GOTO(rc = lydxml_subtree_r(lydctx, parent, first_p, parsed), cleanup);
1666 parsed_data_nodes = 1;
1667
1668 if (!(int_opts & LYD_INTOPT_WITH_SIBLINGS)) {
1669 break;
1670 }
Michal Vasko2552ea32020-12-08 15:32:34 +01001671 }
1672
Michal Vaskoe0665742021-02-11 11:08:44 +01001673 /* close all opened elements */
1674 for (i = 0; i < close_elem; ++i) {
1675 if (lydctx->xmlctx->status != LYXML_ELEM_CLOSE) {
1676 assert(lydctx->xmlctx->status == LYXML_ELEMENT);
Radek Krejci422afb12021-03-04 16:38:16 +01001677 LOGVAL(lydctx->xmlctx->ctx, LYVE_SYNTAX, "Unexpected child element \"%.*s\".",
1678 (int)lydctx->xmlctx->name_len, lydctx->xmlctx->name);
Michal Vaskoe0665742021-02-11 11:08:44 +01001679 rc = LY_EVALID;
1680 goto cleanup;
1681 }
1682
1683 LY_CHECK_GOTO(rc = lyxml_ctx_next(lydctx->xmlctx), cleanup);
Michal Vasko4189c0f2020-08-13 09:05:22 +02001684 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001685
1686 /* check final state */
1687 if ((int_opts & LYD_INTOPT_NO_SIBLINGS) && (lydctx->xmlctx->status == LYXML_ELEMENT)) {
1688 LOGVAL(ctx, LYVE_SYNTAX, "Unexpected sibling node.");
1689 rc = LY_EVALID;
1690 goto cleanup;
1691 }
Michal Vaskoc939fdd2022-01-03 11:35:13 +01001692 if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NOTIF | LYD_INTOPT_REPLY)) && !lydctx->op_node) {
Michal Vaskoe0665742021-02-11 11:08:44 +01001693 LOGVAL(ctx, LYVE_DATA, "Missing the operation node.");
1694 rc = LY_EVALID;
1695 goto cleanup;
1696 }
1697
1698 if (!parsed_data_nodes) {
1699 /* no data nodes were parsed */
1700 lydctx->op_node = NULL;
Michal Vaskoa8edff02020-03-27 14:47:01 +01001701 }
1702
Michal Vaskoddd76592022-01-17 13:34:48 +01001703 if (parse_opts & LYD_PARSE_SUBTREE) {
1704 /* check for a sibling element */
1705 assert(subtree_sibling);
1706 if (!lyxml_ctx_peek(lydctx->xmlctx, &status) && (status == LYXML_ELEMENT)) {
1707 *subtree_sibling = 1;
1708 } else {
1709 *subtree_sibling = 0;
1710 }
1711 }
1712
Michal Vaskoa8edff02020-03-27 14:47:01 +01001713cleanup:
Michal Vaskoe0665742021-02-11 11:08:44 +01001714 /* there should be no unres stored if validation should be skipped */
1715 assert(!(parse_opts & LYD_PARSE_ONLY) || (!lydctx->node_types.count && !lydctx->meta_types.count &&
Michal Vaskoddd76592022-01-17 13:34:48 +01001716 !lydctx->node_when.count));
Michal Vaskoe0665742021-02-11 11:08:44 +01001717
1718 if (rc) {
1719 lyd_xml_ctx_free((struct lyd_ctx *)lydctx);
1720 } else {
1721 *lydctx_p = (struct lyd_ctx *)lydctx;
1722
1723 /* the XML context is no more needed, freeing it also stops logging line numbers which would be confusing now */
1724 lyxml_ctx_free(lydctx->xmlctx);
1725 lydctx->xmlctx = NULL;
Michal Vasko1ce933a2020-03-30 12:38:22 +02001726 }
Michal Vaskoe0665742021-02-11 11:08:44 +01001727 return rc;
Michal Vasko1ce933a2020-03-30 12:38:22 +02001728}