blob: 48ddf736d7b4da164b1226e20bb71778d089afa4 [file] [log] [blame]
Radek Krejcie7b95092019-05-15 11:03:07 +02001/**
2 * @file parser_xml.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief XML data parser for libyang
5 *
6 * Copyright (c) 2019 CESNET, z.s.p.o.
7 *
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
15#include "common.h"
16
17#include <stdint.h>
18#include <stdlib.h>
19#include <string.h>
20
21#include "context.h"
22#include "dict.h"
23#include "log.h"
24#include "plugins_types.h"
25#include "set.h"
26#include "tree_data.h"
27#include "tree_data_internal.h"
28#include "tree_schema.h"
29#include "xml.h"
30
31/**
32 * @brief internal context for XML YANG data parser.
33 *
34 * The leading part is compatible with the struct lyxml_context
35 */
36struct lyd_xml_ctx {
37 struct ly_ctx *ctx; /**< libyang context */
38 uint64_t line; /**< number of the line being currently processed */
39 enum LYXML_PARSER_STATUS status; /**< status providing information about the next expected object in input data */
40 struct ly_set elements; /**< list of not-yet-closed elements */
41 struct ly_set ns; /**< handled with LY_SET_OPT_USEASLIST */
42
43 uint16_t options; /**< various @ref dataparseroptions. */
44 uint16_t path_len; /**< used bytes in the path buffer */
45#define LYD_PARSER_BUFSIZE 4078
46 char path[LYD_PARSER_BUFSIZE]; /**< buffer for the generated path */
Radek Krejcie553e6d2019-06-07 15:33:18 +020047 struct ly_set incomplete_type_validation; /**< set of nodes validated with LY_EINCOMPLETE result */
Radek Krejcie7b95092019-05-15 11:03:07 +020048};
49
50/**
Radek Krejciaca74032019-06-04 08:53:06 +020051 * @brief XML-parser's implementation of ly_type_resolve_prefix() callback to provide mapping between prefixes used in the values to the schema
52 * via XML namespaces.
53 */
54static const struct lys_module *
55lydxml_resolve_prefix(struct ly_ctx *ctx, const char *prefix, size_t prefix_len, void *parser)
56{
57 const struct lyxml_ns *ns;
58 struct lyxml_context *xmlctx = (struct lyxml_context*)parser;
59
60 ns = lyxml_ns_get(xmlctx, prefix, prefix_len);
61 if (!ns) {
62 return NULL;
63 }
64
65 return ly_ctx_get_module_implemented_ns(ctx, ns->uri);
66}
67
68/**
Radek Krejcie7b95092019-05-15 11:03:07 +020069 * @brief Parse XML attributes of the XML element of YANG data.
70 *
71 * @param[in] ctx XML YANG data parser context.
Radek Krejcie7b95092019-05-15 11:03:07 +020072 * @param[in,out] data Pointer to the XML string representation of the YANG data to parse.
73 * @param[out] attributes Resulting list of the parsed attributes. XML namespace definitions are not parsed
74 * as attributes, they are stored internally in the parser context.
75 * @reutn LY_ERR value.
76 */
77static LY_ERR
Radek Krejci17a78d82019-05-15 15:49:55 +020078lydxml_attributes(struct lyd_xml_ctx *ctx, const char **data, struct lyd_attr **attributes)
Radek Krejcie7b95092019-05-15 11:03:07 +020079{
80 LY_ERR ret = LY_SUCCESS;
81 unsigned int u;
82 const char *prefix, *name;
83 size_t prefix_len, name_len;
84 struct lyd_attr *attr = NULL, *last = NULL;
85 const struct lyxml_ns *ns;
86 struct ly_set attr_prefixes = {0};
87 struct attr_prefix_s {
88 const char *prefix;
89 size_t prefix_len;
90 } *attr_prefix;
91 struct lys_module *mod;
92
93 while(ctx->status == LYXML_ATTRIBUTE &&
94 lyxml_get_attribute((struct lyxml_context*)ctx, data, &prefix, &prefix_len, &name, &name_len) == LY_SUCCESS) {
95 int dynamic = 0;
96 char *buffer = NULL, *value;
97 size_t buffer_size = 0, value_len;
98
Radek Krejci17a78d82019-05-15 15:49:55 +020099 if (!name) {
100 /* seems like all the attrributes were internally processed as namespace definitions */
101 continue;
Radek Krejcie7b95092019-05-15 11:03:07 +0200102 }
Radek Krejci17a78d82019-05-15 15:49:55 +0200103
104 /* get attribute value */
105 ret = lyxml_get_string((struct lyxml_context *)ctx, data, &buffer, &buffer_size, &value, &value_len, &dynamic);
106 LY_CHECK_GOTO(ret, cleanup);
107
108 attr = calloc(1, sizeof *attr);
109 LY_CHECK_ERR_GOTO(!attr, LOGMEM(ctx->ctx); ret = LY_EMEM, cleanup);
110
111 attr->name = lydict_insert(ctx->ctx, name, name_len);
112 /* auxiliary store the prefix information and wait with resolving prefix to the time when all the namespaces,
113 * defined in this element, are parsed, so we will get the correct namespace for this prefix */
114 attr_prefix = malloc(sizeof *attr_prefix);
115 attr_prefix->prefix = prefix;
116 attr_prefix->prefix_len = prefix_len;
117 ly_set_add(&attr_prefixes, attr_prefix, LY_SET_OPT_USEASLIST);
118
119 /* TODO process value */
120
121 if (last) {
122 last->next = attr;
123 } else {
124 (*attributes) = attr;
125 }
126 last = attr;
Radek Krejcie7b95092019-05-15 11:03:07 +0200127 }
128
129 /* resolve annotation pointers in all the attributes */
130 for (last = *attributes, u = 0; u < attr_prefixes.count && last; u++, last = last->next) {
131 attr_prefix = (struct attr_prefix_s*)attr_prefixes.objs[u];
132 ns = lyxml_ns_get((struct lyxml_context *)ctx, attr_prefix->prefix, attr_prefix->prefix_len);
133 mod = ly_ctx_get_module_implemented_ns(ctx->ctx, ns->uri);
134
135 /* TODO get annotation */
136 }
137
138cleanup:
139
140 ly_set_erase(&attr_prefixes, free);
141 return ret;
142}
143
144/**
145 * @brief Parse XML elements as children YANG data node of the specified parent node.
146 *
147 * @param[in] ctx XML YANG data parser context.
148 * @param[in] parent Parent node where the children are inserted. NULL in case of parsing top-level elements.
149 * @param[in,out] data Pointer to the XML string representation of the YANG data to parse.
150 * @param[out] node Resulting list of the parsed nodes.
151 * @reutn LY_ERR value.
152 */
153static LY_ERR
154lydxml_nodes(struct lyd_xml_ctx *ctx, struct lyd_node_inner *parent, const char **data, struct lyd_node **node)
155{
156 LY_ERR ret = LY_SUCCESS;
157 const char *prefix, *name;
Radek Krejcie7b95092019-05-15 11:03:07 +0200158 size_t prefix_len, name_len;
159 struct lyd_attr *attributes = NULL;
160 const struct lyxml_ns *ns;
161 const struct lysc_node *snode;
162 struct lys_module *mod;
163 unsigned int parents_count = ctx->elements.count;
164 struct lyd_node *cur = NULL, *prev = NULL;
165
166 (*node) = NULL;
167
168 while(ctx->status == LYXML_ELEMENT) {
169 ret = lyxml_get_element((struct lyxml_context *)ctx, data, &prefix, &prefix_len, &name, &name_len);
170 LY_CHECK_GOTO(ret, cleanup);
171 if (!name) {
172 /* closing previous element */
Radek Krejcie7b95092019-05-15 11:03:07 +0200173 if (ctx->elements.count < parents_count) {
174 /* all siblings parsed */
175 break;
176 } else {
177 continue;
178 }
179 }
180 attributes = NULL;
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200181 if (ctx->status == LYXML_ATTRIBUTE) {
182 LY_CHECK_GOTO(lydxml_attributes(ctx, data, &attributes), cleanup);
183 }
184
Radek Krejcie7b95092019-05-15 11:03:07 +0200185 ns = lyxml_ns_get((struct lyxml_context *)ctx, prefix, prefix_len);
186 if (!ns) {
187 LOGVAL(ctx->ctx, LY_VLOG_LINE, &ctx->line, LYVE_REFERENCE, "Unknown XML prefix \"%*.s\".", prefix_len, prefix);
188 goto cleanup;
189 }
190 mod = ly_ctx_get_module_implemented_ns(ctx->ctx, ns->uri);
191 if (!mod) {
192 LOGVAL(ctx->ctx, LY_VLOG_LINE, &ctx->line, LYVE_REFERENCE, "No module with namespace \"%s\" in the context.", ns->uri);
193 goto cleanup;
194 }
195 snode = lys_child(parent ? parent->schema : NULL, mod, name, name_len, 0, (ctx->options & LYD_OPT_RPCREPLY) ? LYS_GETNEXT_OUTPUT : 0);
196 if (!snode) {
197 LOGVAL(ctx->ctx, LY_VLOG_LINE, &ctx->line, LYVE_REFERENCE, "Element \"%.*s\" not found in the \"%s\" module.", name_len, name, mod->name);
198 goto cleanup;
199 }
200
201 /* allocate new node */
202 switch (snode->nodetype) {
203 case LYS_CONTAINER:
204 case LYS_LIST:
205 cur = calloc(1, sizeof(struct lyd_node_inner));
206 break;
207 case LYS_LEAF:
208 case LYS_LEAFLIST:
209 cur = calloc(1, sizeof(struct lyd_node_term));
210 break;
211 case LYS_ANYDATA:
212 case LYS_ANYXML:
213 cur = calloc(1, sizeof(struct lyd_node_any));
214 break;
215 /* TODO LYS_ACTION, LYS_NOTIF */
216 default:
217 LOGINT(ctx->ctx);
218 goto cleanup;
219 }
220 if (!(*node)) {
221 (*node) = cur;
222 }
223 cur->schema = snode;
224 cur->parent = parent;
Radek Krejcie92210c2019-05-17 15:53:35 +0200225 if (parent) {
226 parent->child->prev = cur;
227 } else if (prev) {
228 struct lyd_node *iter;
229 for (iter = prev; iter->prev->next; iter = iter->prev);
230 iter->prev = cur;
231 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200232 if (prev) {
233 cur->prev = prev;
234 prev->next = cur;
235 } else {
236 cur->prev = cur;
237 }
238 prev = cur;
239 cur->attr = attributes;
240 attributes = NULL;
241
242 if (snode->nodetype & LYD_NODE_TERM) {
243 int dynamic = 0;
244 char *buffer = NULL, *value;
245 size_t buffer_size = 0, value_len;
246
247 if (ctx->status == LYXML_ELEM_CONTENT) {
248 /* get the value */
Radek Krejci339e2de2019-05-17 14:28:24 +0200249 LY_ERR r = lyxml_get_string((struct lyxml_context *)ctx, data, &buffer, &buffer_size, &value, &value_len, &dynamic);
250 if (r == LY_EINVAL) {
251 /* just indentation of a child element found */
252 LOGVAL(ctx->ctx, LY_VLOG_LINE, &ctx->line, LYVE_SYNTAX, "Child element inside terminal node \"%s\" found.", cur->schema->name);
253 goto cleanup;
254 }
Radek Krejcie92210c2019-05-17 15:53:35 +0200255 } else {
256 /* no content - validate empty value */
257 value = "";
258 value_len = 0;
Radek Krejcie7b95092019-05-15 11:03:07 +0200259 }
Radek Krejci3c9758d2019-07-11 16:49:10 +0200260 ret = lyd_value_parse((struct lyd_node_term*)cur, value, value_len, dynamic, 0, lydxml_resolve_prefix, ctx, LYD_XML, NULL);
Radek Krejcie553e6d2019-06-07 15:33:18 +0200261 if (ret == LY_EINCOMPLETE) {
262 ly_set_add(&ctx->incomplete_type_validation, cur, LY_SET_OPT_USEASLIST);
263 } else if (ret) {
264 if (dynamic){
265 free(value);
266 }
267 goto cleanup;
268 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200269 } else if (snode->nodetype & LYD_NODE_INNER) {
270 int dynamic = 0;
271 char *buffer = NULL, *value;
272 size_t buffer_size = 0, value_len;
273
274 if (ctx->status == LYXML_ELEM_CONTENT) {
275 LY_ERR r = lyxml_get_string((struct lyxml_context *)ctx, data, &buffer, &buffer_size, &value, &value_len, &dynamic);
Radek Krejcie553e6d2019-06-07 15:33:18 +0200276 if (r != LY_EINVAL && (r != LY_SUCCESS || value_len != 0)) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200277 LOGINT(ctx->ctx);
278 goto cleanup;
279 }
280 }
Radek Krejciee4cab22019-07-17 17:07:47 +0200281 /* process children */
Radek Krejcie553e6d2019-06-07 15:33:18 +0200282 if (ctx->status == LYXML_ELEMENT && parents_count != ctx->elements.count) {
Radek Krejcie7b95092019-05-15 11:03:07 +0200283 ret = lydxml_nodes(ctx, (struct lyd_node_inner*)cur, data, lyd_node_children_p(cur));
Radek Krejcie92210c2019-05-17 15:53:35 +0200284 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcie7b95092019-05-15 11:03:07 +0200285 }
Radek Krejciee4cab22019-07-17 17:07:47 +0200286 } else if (snode->nodetype & LYD_NODE_ANY) {
287 unsigned int cur_element_index = ctx->elements.count;
288 const char *start = *data, *stop;
289 const char *p, *n;
290 size_t p_len, n_len;
291
292 /* skip children data and store them as a string */
293 while (cur_element_index <= ctx->elements.count) {
294 switch (ctx->status) {
295 case LYXML_ELEMENT:
296 ret = lyxml_get_element((struct lyxml_context *)ctx, data, &p, &p_len, &n, &n_len);
297 break;
298 case LYXML_ATTRIBUTE:
299 lyxml_get_attribute((struct lyxml_context*)ctx, data, &p, &p_len, &n, &n_len);
300 break;
301 case LYXML_ELEM_CONTENT:
302 case LYXML_ATTR_CONTENT:
303 ret = lyxml_get_string((struct lyxml_context *)ctx, data, NULL, NULL, NULL, NULL, NULL);
304 if (ret == LY_EINVAL) {
305 /* not an error, just incorrect XML parser status */
306 ret = LY_SUCCESS;
307 }
308 break;
309 case LYXML_END:
310 /* unexpected end of data */
311 LOGINT(ctx->ctx);
312 goto cleanup;
313 }
314 LY_CHECK_GOTO(ret, cleanup);
315 }
316 /* data now points after the anydata's closing element tag, we need just end of its content */
317 for (stop = *data - 1; *stop != '<'; --stop);
318
319 ((struct lyd_node_any*)cur)->value_type = LYD_ANYDATA_XML;
320 ((struct lyd_node_any*)cur)->value.xml = lydict_insert(ctx->ctx, start, stop - start);
Radek Krejcie7b95092019-05-15 11:03:07 +0200321 }
Radek Krejci1f05b6a2019-07-18 16:15:06 +0200322
323 /* calculate the hash and insert it into parent (list with keys is handled when its keys are inserted) */
324 lyd_hash(cur);
325 lyd_insert_hash(cur);
Radek Krejcib6f7ae52019-07-19 10:31:42 +0200326
327 /* if we have empty non-presence container, we keep it, but mark it as default */
328 if (cur->schema->nodetype == LYS_CONTAINER && !((struct lyd_node_inner*)cur)->child &&
329 !cur->attr && !(((struct lysc_node_container*)cur->schema)->flags & LYS_PRESENCE)) {
330 cur->flags |= LYD_DEFAULT;
331 }
332
333 /* TODO context validation */
Radek Krejcie7b95092019-05-15 11:03:07 +0200334 }
335
336cleanup:
Radek Krejcie7b95092019-05-15 11:03:07 +0200337 lyd_free_attr(ctx->ctx, attributes, 1);
Radek Krejcie7b95092019-05-15 11:03:07 +0200338 return ret;
339}
340
341LY_ERR
342lyd_parse_xml(struct ly_ctx *ctx, const char *data, int options, struct lyd_node **result)
343{
344 LY_ERR ret;
345 struct lyd_xml_ctx xmlctx = {0};
346
347 xmlctx.options = options;
348 xmlctx.ctx = ctx;
349 xmlctx.line = 1;
350
351 ret = lydxml_nodes(&xmlctx, NULL, &data, result);
Radek Krejcie92210c2019-05-17 15:53:35 +0200352 if (ret) {
353 lyd_free_all(*result);
354 *result = NULL;
Radek Krejcie553e6d2019-06-07 15:33:18 +0200355 } else {
356 /* finish incompletely validated terminal values */
357 for (unsigned int u = 0; u < xmlctx.incomplete_type_validation.count; u++) {
358 struct lyd_node_term *node = (struct lyd_node_term*)xmlctx.incomplete_type_validation.objs[u];
Radek Krejci576b23f2019-07-12 14:06:32 +0200359 const struct lyd_node **trees = NULL;
Radek Krejcie72c0432019-06-10 10:17:03 +0200360
361 /* prepare sized array for validator */
362 if (*result) {
Radek Krejci576b23f2019-07-12 14:06:32 +0200363 trees = lyd_trees_new(1, *result);
Radek Krejcie553e6d2019-06-07 15:33:18 +0200364 }
Radek Krejcie72c0432019-06-10 10:17:03 +0200365 /* validate and store the value of the node */
Radek Krejci3c9758d2019-07-11 16:49:10 +0200366 ret = lyd_value_parse(node, node->value.canonized, node->value.canonized ? strlen(node->value.canonized) : 0, 0, 1,
Radek Krejci084289f2019-07-09 17:35:30 +0200367 lydxml_resolve_prefix, ctx, LYD_XML, trees);
Radek Krejci576b23f2019-07-12 14:06:32 +0200368 lyd_trees_free(trees, 0);
Radek Krejcie553e6d2019-06-07 15:33:18 +0200369 if (ret) {
370 lyd_free_all(*result);
371 *result = NULL;
372 break;
373 }
374 }
Radek Krejcie92210c2019-05-17 15:53:35 +0200375 }
Radek Krejcie553e6d2019-06-07 15:33:18 +0200376
377 ly_set_erase(&xmlctx.incomplete_type_validation, NULL);
Radek Krejcie7b95092019-05-15 11:03:07 +0200378 lyxml_context_clear((struct lyxml_context*)&xmlctx);
379 return ret;
380}