blob: 1381b86d0c5fd095f7cbafd6a8c3f6f589cce320 [file] [log] [blame]
Radek Krejcid91dbaf2018-09-21 15:51:39 +02001/**
2 * @file xml.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vaskob36053d2020-03-26 15:49:30 +01004 * @author Michal Vasko <mvasko@cesnet.cz>
Radek Krejcid91dbaf2018-09-21 15:51:39 +02005 * @brief Generic XML parser implementation for libyang
6 *
7 * Copyright (c) 2015 - 2018 CESNET, z.s.p.o.
8 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
15
Radek Krejci535ea9f2020-05-29 16:01:05 +020016#define _GNU_SOURCE
17
18#include "xml.h"
Radek Krejci4b74d5e2018-09-26 14:30:55 +020019
Radek Krejcib1890642018-10-03 14:05:40 +020020#include <assert.h>
Radek Krejci7a7fa902018-09-25 17:08:21 +020021#include <ctype.h>
Radek Krejcid91dbaf2018-09-21 15:51:39 +020022#include <stdint.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020023#include <stdlib.h>
Radek Krejci4b74d5e2018-09-26 14:30:55 +020024#include <string.h>
Radek Krejcid91dbaf2018-09-21 15:51:39 +020025
Radek Krejci535ea9f2020-05-29 16:01:05 +020026#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020027#include "compat.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020028#include "in_internal.h"
29#include "out_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020030#include "tree.h"
Radek Krejci77114102021-03-10 15:21:57 +010031#include "tree_schema_internal.h"
Radek Krejcid91dbaf2018-09-21 15:51:39 +020032
Michal Vaskob36053d2020-03-26 15:49:30 +010033/* Move input p by s characters, if EOF log with lyxml_ctx c */
Radek Krejci2efc45b2020-12-22 16:25:44 +010034#define move_input(c, s) \
35 ly_in_skip(c->in, s); \
36 LY_CHECK_ERR_RET(!c->in->current[0], LOGVAL(c->ctx, LY_VCODE_EOF), LY_EVALID)
Radek Krejcid91dbaf2018-09-21 15:51:39 +020037
Radek Krejcib1890642018-10-03 14:05:40 +020038/* Ignore whitespaces in the input string p */
Radek Krejcidd713ce2021-01-04 23:12:12 +010039#define ign_xmlws(c) \
40 while (is_xmlws(*(c)->in->current)) { \
41 if (*(c)->in->current == '\n') { \
42 LY_IN_NEW_LINE((c)->in); \
43 } \
44 ly_in_skip(c->in, 1); \
45 }
Michal Vaskob36053d2020-03-26 15:49:30 +010046
Radek Krejci857189e2020-09-01 13:26:36 +020047static LY_ERR lyxml_next_attr_content(struct lyxml_ctx *xmlctx, const char **value, size_t *value_len, ly_bool *ws_only,
48 ly_bool *dynamic);
Radek Krejcid91dbaf2018-09-21 15:51:39 +020049
Radek Krejci4b74d5e2018-09-26 14:30:55 +020050/**
Radek Krejcidd713ce2021-01-04 23:12:12 +010051 * @brief Ignore and skip any characters until the delim of the size delim_len is read, including the delim
Radek Krejci4b74d5e2018-09-26 14:30:55 +020052 *
Radek Krejcidd713ce2021-01-04 23:12:12 +010053 * @param[in] xmlctx XML parser context to provide input handler and libyang context
54 * @param[in] in input handler to read the data, it is updated only in case the section is correctly terminated.
55 * @param[in] delim Delimiter to detect end of the section.
56 * @param[in] delim_len Length of the delimiter string to use.
57 * @param[in] sectname Section name to refer in error message.
Michal Vasko63f3d842020-07-08 10:10:14 +020058 */
Radek Krejcidd713ce2021-01-04 23:12:12 +010059LY_ERR
60skip_section(struct lyxml_ctx *xmlctx, const char *delim, size_t delim_len, const char *sectname)
Radek Krejcid91dbaf2018-09-21 15:51:39 +020061{
62 size_t i;
Radek Krejcidd713ce2021-01-04 23:12:12 +010063 register const char *input, *a, *b;
64 uint64_t parsed = 0, newlines = 0;
Radek Krejcid91dbaf2018-09-21 15:51:39 +020065
Radek Krejcidd713ce2021-01-04 23:12:12 +010066 for (input = xmlctx->in->current; *input; ++input, ++parsed) {
Radek Krejcid91dbaf2018-09-21 15:51:39 +020067 if (*input != *delim) {
Radek Krejcidd713ce2021-01-04 23:12:12 +010068 if (*input == '\n') {
69 ++newlines;
70 }
Radek Krejcid91dbaf2018-09-21 15:51:39 +020071 continue;
72 }
73 a = input;
74 b = delim;
75 for (i = 0; i < delim_len; ++i) {
76 if (*a++ != *b++) {
77 break;
78 }
79 }
80 if (i == delim_len) {
Michal Vasko63f3d842020-07-08 10:10:14 +020081 /* delim found */
Radek Krejcidd713ce2021-01-04 23:12:12 +010082 xmlctx->in->line += newlines;
83 ly_in_skip(xmlctx->in, parsed + delim_len);
84 return LY_SUCCESS;
Radek Krejcid91dbaf2018-09-21 15:51:39 +020085 }
86 }
Michal Vasko63f3d842020-07-08 10:10:14 +020087
Radek Krejcidd713ce2021-01-04 23:12:12 +010088 /* delim not found,
89 * do not update input handler to refer to the beginning of the section in error message */
90 LOGVAL(xmlctx->ctx, LY_VCODE_NTERM, sectname);
91 return LY_EVALID;
Radek Krejcid91dbaf2018-09-21 15:51:39 +020092}
93
Radek Krejci4b74d5e2018-09-26 14:30:55 +020094/**
Michal Vaskob36053d2020-03-26 15:49:30 +010095 * @brief Check/Get an XML identifier from the input string.
96 *
97 * The identifier must have at least one valid character complying the name start character constraints.
98 * The identifier is terminated by the first character, which does not comply to the name character constraints.
99 *
100 * See https://www.w3.org/TR/xml-names/#NT-NCName
101 *
102 * @param[in] xmlctx XML context.
103 * @param[out] start Pointer to the start of the identifier.
104 * @param[out] end Pointer ot the end of the identifier.
105 * @return LY_ERR value.
106 */
107static LY_ERR
108lyxml_parse_identifier(struct lyxml_ctx *xmlctx, const char **start, const char **end)
109{
110 const char *s, *in;
111 uint32_t c;
112 size_t parsed;
113 LY_ERR rc;
114
Michal Vasko63f3d842020-07-08 10:10:14 +0200115 in = s = xmlctx->in->current;
Michal Vaskob36053d2020-03-26 15:49:30 +0100116
117 /* check NameStartChar (minus colon) */
118 LY_CHECK_ERR_RET(ly_getutf8(&in, &c, &parsed),
Radek Krejci2efc45b2020-12-22 16:25:44 +0100119 LOGVAL(xmlctx->ctx, LY_VCODE_INCHAR, in[0]),
Michal Vasko69730152020-10-09 16:30:07 +0200120 LY_EVALID);
Michal Vaskob36053d2020-03-26 15:49:30 +0100121 LY_CHECK_ERR_RET(!is_xmlqnamestartchar(c),
Radek Krejci2efc45b2020-12-22 16:25:44 +0100122 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Identifier \"%s\" starts with an invalid character.", in - parsed),
Michal Vasko69730152020-10-09 16:30:07 +0200123 LY_EVALID);
Michal Vaskob36053d2020-03-26 15:49:30 +0100124
125 /* check rest of the identifier */
126 do {
127 /* move only successfully parsed bytes */
Michal Vasko63f3d842020-07-08 10:10:14 +0200128 ly_in_skip(xmlctx->in, parsed);
Michal Vaskob36053d2020-03-26 15:49:30 +0100129
130 rc = ly_getutf8(&in, &c, &parsed);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100131 LY_CHECK_ERR_RET(rc, LOGVAL(xmlctx->ctx, LY_VCODE_INCHAR, in[0]), LY_EVALID);
Michal Vaskob36053d2020-03-26 15:49:30 +0100132 } while (is_xmlqnamechar(c));
133
134 *start = s;
Michal Vasko63f3d842020-07-08 10:10:14 +0200135 *end = xmlctx->in->current;
Michal Vaskob36053d2020-03-26 15:49:30 +0100136 return LY_SUCCESS;
137}
138
139/**
140 * @brief Add namespace definition into XML context.
141 *
142 * Namespaces from a single element are supposed to be added sequentially together (not interleaved by a namespace from other
143 * element). This mimic namespace visibility, since the namespace defined in element E is not visible from its parents or
144 * siblings. On the other hand, namespace from a parent element can be redefined in a child element. This is also reflected
145 * by lyxml_ns_get() which returns the most recent namespace definition for the given prefix.
146 *
147 * When leaving processing of a subtree of some element (after it is removed from xmlctx->elements), caller is supposed to call
148 * lyxml_ns_rm() to remove all the namespaces defined in such an element from the context.
149 *
150 * @param[in] xmlctx XML context to work with.
151 * @param[in] prefix Pointer to the namespace prefix. Can be NULL for default namespace.
152 * @param[in] prefix_len Length of the prefix.
153 * @param[in] uri Namespace URI (value) to store directly. Value is always spent.
154 * @return LY_ERR values.
155 */
156LY_ERR
157lyxml_ns_add(struct lyxml_ctx *xmlctx, const char *prefix, size_t prefix_len, char *uri)
158{
Radek Krejciba03a5a2020-08-27 14:40:41 +0200159 LY_ERR ret = LY_SUCCESS;
Michal Vaskob36053d2020-03-26 15:49:30 +0100160 struct lyxml_ns *ns;
161
162 ns = malloc(sizeof *ns);
163 LY_CHECK_ERR_RET(!ns, LOGMEM(xmlctx->ctx), LY_EMEM);
164
165 /* we need to connect the depth of the element where the namespace is defined with the
166 * namespace record to be able to maintain (remove) the record when the parser leaves
167 * (to its sibling or back to the parent) the element where the namespace was defined */
168 ns->depth = xmlctx->elements.count;
169
170 ns->uri = uri;
171 if (prefix) {
172 ns->prefix = strndup(prefix, prefix_len);
173 LY_CHECK_ERR_RET(!ns->prefix, LOGMEM(xmlctx->ctx); free(ns->uri); free(ns), LY_EMEM);
174 } else {
175 ns->prefix = NULL;
176 }
177
Radek Krejci3d92e442020-10-12 12:48:13 +0200178 ret = ly_set_add(&xmlctx->ns, ns, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200179 LY_CHECK_ERR_RET(ret, free(ns->prefix); free(ns->uri); free(ns), ret);
180
Michal Vaskob36053d2020-03-26 15:49:30 +0100181 return LY_SUCCESS;
182}
183
184/**
185 * @brief Remove all the namespaces defined in the element recently closed (removed from the xmlctx->elements).
186 *
187 * @param[in] xmlctx XML context to work with.
188 */
189void
190lyxml_ns_rm(struct lyxml_ctx *xmlctx)
191{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200192 for (uint32_t u = xmlctx->ns.count - 1; u + 1 > 0; --u) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100193 if (((struct lyxml_ns *)xmlctx->ns.objs[u])->depth != xmlctx->elements.count + 1) {
194 /* we are done, the namespaces from a single element are supposed to be together */
195 break;
196 }
197 /* remove the ns structure */
198 free(((struct lyxml_ns *)xmlctx->ns.objs[u])->prefix);
199 free(((struct lyxml_ns *)xmlctx->ns.objs[u])->uri);
200 free(xmlctx->ns.objs[u]);
201 --xmlctx->ns.count;
202 }
203
204 if (!xmlctx->ns.count) {
205 /* cleanup the xmlctx's namespaces storage */
206 ly_set_erase(&xmlctx->ns, NULL);
207 }
208}
209
Michal Vaskob36053d2020-03-26 15:49:30 +0100210const struct lyxml_ns *
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200211lyxml_ns_get(const struct ly_set *ns_set, const char *prefix, size_t prefix_len)
Michal Vaskob36053d2020-03-26 15:49:30 +0100212{
Michal Vaskob36053d2020-03-26 15:49:30 +0100213 struct lyxml_ns *ns;
214
Radek Krejci1deb5be2020-08-26 16:43:36 +0200215 for (uint32_t u = ns_set->count - 1; u + 1 > 0; --u) {
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200216 ns = (struct lyxml_ns *)ns_set->objs[u];
Michal Vaskob36053d2020-03-26 15:49:30 +0100217 if (prefix && prefix_len) {
218 if (ns->prefix && !ly_strncmp(ns->prefix, prefix, prefix_len)) {
219 return ns;
220 }
221 } else if (!ns->prefix) {
222 /* default namespace */
223 return ns;
224 }
225 }
226
227 return NULL;
228}
229
Michal Vasko8cef5232020-06-15 17:59:47 +0200230/**
231 * @brief Skip in the input until EOF or just after the opening tag.
232 * Handles special XML constructs (comment, cdata, doctype).
233 *
234 * @param[in] xmlctx XML context to use.
235 * @return LY_ERR value.
236 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100237static LY_ERR
238lyxml_skip_until_end_or_after_otag(struct lyxml_ctx *xmlctx)
239{
240 const struct ly_ctx *ctx = xmlctx->ctx; /* shortcut */
Michal Vasko63f3d842020-07-08 10:10:14 +0200241 const char *endtag, *sectname;
Radek Krejcidd713ce2021-01-04 23:12:12 +0100242 size_t endtag_len;
Michal Vaskob36053d2020-03-26 15:49:30 +0100243
244 while (1) {
245 ign_xmlws(xmlctx);
246
Michal Vasko63f3d842020-07-08 10:10:14 +0200247 if (xmlctx->in->current[0] == '\0') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100248 /* EOF */
249 if (xmlctx->elements.count) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100250 LOGVAL(ctx, LY_VCODE_EOF);
Michal Vaskob36053d2020-03-26 15:49:30 +0100251 return LY_EVALID;
252 }
253 return LY_SUCCESS;
Michal Vasko63f3d842020-07-08 10:10:14 +0200254 } else if (xmlctx->in->current[0] != '<') {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100255 LOGVAL(ctx, LY_VCODE_INSTREXP, LY_VCODE_INSTREXP_len(xmlctx->in->current),
Michal Vasko69730152020-10-09 16:30:07 +0200256 xmlctx->in->current, "element tag start ('<')");
Michal Vaskob36053d2020-03-26 15:49:30 +0100257 return LY_EVALID;
258 }
259 move_input(xmlctx, 1);
260
Michal Vasko63f3d842020-07-08 10:10:14 +0200261 if (xmlctx->in->current[0] == '!') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100262 move_input(xmlctx, 1);
263 /* sections to ignore */
Michal Vasko63f3d842020-07-08 10:10:14 +0200264 if (!strncmp(xmlctx->in->current, "--", 2)) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100265 /* comment */
266 move_input(xmlctx, 2);
267 sectname = "Comment";
268 endtag = "-->";
Radek Krejcif13b87b2020-12-01 22:02:17 +0100269 endtag_len = ly_strlen_const("-->");
270 } else if (!strncmp(xmlctx->in->current, "[CDATA[", ly_strlen_const("[CDATA["))) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100271 /* CDATA section */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100272 move_input(xmlctx, ly_strlen_const("[CDATA["));
Michal Vaskob36053d2020-03-26 15:49:30 +0100273 sectname = "CData";
274 endtag = "]]>";
Radek Krejcif13b87b2020-12-01 22:02:17 +0100275 endtag_len = ly_strlen_const("]]>");
276 } else if (!strncmp(xmlctx->in->current, "DOCTYPE", ly_strlen_const("DOCTYPE"))) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100277 /* Document type declaration - not supported */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100278 LOGVAL(ctx, LY_VCODE_NSUPP, "Document Type Declaration");
Michal Vaskob36053d2020-03-26 15:49:30 +0100279 return LY_EVALID;
280 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100281 LOGVAL(ctx, LYVE_SYNTAX, "Unknown XML section \"%.20s\".", &xmlctx->in->current[-2]);
Michal Vaskob36053d2020-03-26 15:49:30 +0100282 return LY_EVALID;
283 }
Radek Krejcidd713ce2021-01-04 23:12:12 +0100284 LY_CHECK_RET(skip_section(xmlctx, endtag, endtag_len, sectname));
Michal Vasko63f3d842020-07-08 10:10:14 +0200285 } else if (xmlctx->in->current[0] == '?') {
Radek Krejcidd713ce2021-01-04 23:12:12 +0100286 LY_CHECK_RET(skip_section(xmlctx, "?>", 2, "Declaration"));
Michal Vaskob36053d2020-03-26 15:49:30 +0100287 } else {
288 /* other non-WS character */
289 break;
290 }
291 }
292
293 return LY_SUCCESS;
294}
295
Michal Vasko8cef5232020-06-15 17:59:47 +0200296/**
297 * @brief Parse QName.
298 *
299 * @param[in] xmlctx XML context to use.
300 * @param[out] prefix Parsed prefix, may be NULL.
301 * @param[out] prefix_len Length of @p prefix.
302 * @param[out] name Parsed name.
303 * @param[out] name_len Length of @p name.
304 * @return LY_ERR value.
305 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100306static LY_ERR
307lyxml_parse_qname(struct lyxml_ctx *xmlctx, const char **prefix, size_t *prefix_len, const char **name, size_t *name_len)
308{
309 const char *start, *end;
310
311 *prefix = NULL;
312 *prefix_len = 0;
313
314 LY_CHECK_RET(lyxml_parse_identifier(xmlctx, &start, &end));
315 if (end[0] == ':') {
316 /* we have prefixed identifier */
317 *prefix = start;
318 *prefix_len = end - start;
319
320 move_input(xmlctx, 1);
321 LY_CHECK_RET(lyxml_parse_identifier(xmlctx, &start, &end));
322 }
323
324 *name = start;
325 *name_len = end - start;
326 return LY_SUCCESS;
327}
328
329/**
Michal Vasko8cef5232020-06-15 17:59:47 +0200330 * @brief Parse XML text content (value).
331 *
332 * @param[in] xmlctx XML context to use.
333 * @param[in] endchar Expected character to mark value end.
334 * @param[out] value Parsed value.
335 * @param[out] length Length of @p value.
336 * @param[out] ws_only Whether the value is empty/white-spaces only.
337 * @param[out] dynamic Whether the value was dynamically allocated.
338 * @return LY_ERR value.
339 */
Radek Krejci4b74d5e2018-09-26 14:30:55 +0200340static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200341lyxml_parse_value(struct lyxml_ctx *xmlctx, char endchar, char **value, size_t *length, ly_bool *ws_only, ly_bool *dynamic)
Radek Krejcid91dbaf2018-09-21 15:51:39 +0200342{
Michal Vaskob36053d2020-03-26 15:49:30 +0100343#define BUFSIZE 24
344#define BUFSIZE_STEP 128
Radek Krejcid91dbaf2018-09-21 15:51:39 +0200345
Michal Vaskob36053d2020-03-26 15:49:30 +0100346 const struct ly_ctx *ctx = xmlctx->ctx; /* shortcut */
Michal Vasko63f3d842020-07-08 10:10:14 +0200347 const char *in = xmlctx->in->current, *start;
Michal Vaskob36053d2020-03-26 15:49:30 +0100348 char *buf = NULL;
Radek Krejci4ad42aa2019-07-23 16:55:58 +0200349 size_t offset; /* read offset in input buffer */
350 size_t len; /* length of the output string (write offset in output buffer) */
351 size_t size = 0; /* size of the output buffer */
Radek Krejci7a7fa902018-09-25 17:08:21 +0200352 void *p;
Radek Krejci117d2082018-09-26 10:05:14 +0200353 uint32_t n;
Michal Vaskob36053d2020-03-26 15:49:30 +0100354 size_t u;
Radek Krejci857189e2020-09-01 13:26:36 +0200355 ly_bool ws = 1;
Radek Krejci7a7fa902018-09-25 17:08:21 +0200356
Michal Vaskob36053d2020-03-26 15:49:30 +0100357 assert(xmlctx);
Radek Krejcib1890642018-10-03 14:05:40 +0200358
Radek Krejcid70d1072018-10-09 14:20:47 +0200359 /* init */
Michal Vaskob36053d2020-03-26 15:49:30 +0100360 start = in;
Radek Krejcid70d1072018-10-09 14:20:47 +0200361 offset = len = 0;
Radek Krejci7a7fa902018-09-25 17:08:21 +0200362
363 /* parse */
364 while (in[offset]) {
365 if (in[offset] == '&') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100366 /* non WS */
367 ws = 0;
Radek Krejcid70d1072018-10-09 14:20:47 +0200368
Michal Vaskob36053d2020-03-26 15:49:30 +0100369 if (!buf) {
370 /* prepare output buffer */
371 buf = malloc(BUFSIZE);
372 LY_CHECK_ERR_RET(!buf, LOGMEM(ctx), LY_EMEM);
373 size = BUFSIZE;
Radek Krejci7a7fa902018-09-25 17:08:21 +0200374 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100375
376 /* allocate enough for the offset and next character,
377 * we will need 4 bytes at most since we support only the predefined
378 * (one-char) entities and character references */
Juraj Vijtiukcb017cc2020-07-08 16:19:58 +0200379 while (len + offset + 4 >= size) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100380 buf = ly_realloc(buf, size + BUFSIZE_STEP);
381 LY_CHECK_ERR_RET(!buf, LOGMEM(ctx), LY_EMEM);
382 size += BUFSIZE_STEP;
383 }
384
385 if (offset) {
386 /* store what we have so far */
387 memcpy(&buf[len], in, offset);
388 len += offset;
389 in += offset;
390 offset = 0;
391 }
392
Radek Krejci7a7fa902018-09-25 17:08:21 +0200393 ++offset;
394 if (in[offset] != '#') {
395 /* entity reference - only predefined references are supported */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100396 if (!strncmp(&in[offset], "lt;", ly_strlen_const("lt;"))) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100397 buf[len++] = '<';
Radek Krejcif13b87b2020-12-01 22:02:17 +0100398 in += ly_strlen_const("&lt;");
399 } else if (!strncmp(&in[offset], "gt;", ly_strlen_const("gt;"))) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100400 buf[len++] = '>';
Radek Krejcif13b87b2020-12-01 22:02:17 +0100401 in += ly_strlen_const("&gt;");
402 } else if (!strncmp(&in[offset], "amp;", ly_strlen_const("amp;"))) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100403 buf[len++] = '&';
Radek Krejcif13b87b2020-12-01 22:02:17 +0100404 in += ly_strlen_const("&amp;");
405 } else if (!strncmp(&in[offset], "apos;", ly_strlen_const("apos;"))) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100406 buf[len++] = '\'';
Radek Krejcif13b87b2020-12-01 22:02:17 +0100407 in += ly_strlen_const("&apos;");
408 } else if (!strncmp(&in[offset], "quot;", ly_strlen_const("quot;"))) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100409 buf[len++] = '\"';
Radek Krejcif13b87b2020-12-01 22:02:17 +0100410 in += ly_strlen_const("&quot;");
Radek Krejci7a7fa902018-09-25 17:08:21 +0200411 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100412 LOGVAL(ctx, LYVE_SYNTAX, "Entity reference \"%.*s\" not supported, only predefined references allowed.",
413 10, &in[offset - 1]);
Radek Krejci7a7fa902018-09-25 17:08:21 +0200414 goto error;
415 }
416 offset = 0;
417 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100418 p = (void *)&in[offset - 1];
Radek Krejci7a7fa902018-09-25 17:08:21 +0200419 /* character reference */
420 ++offset;
421 if (isdigit(in[offset])) {
422 for (n = 0; isdigit(in[offset]); offset++) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100423 n = (LY_BASE_DEC * n) + (in[offset] - '0');
Radek Krejci7a7fa902018-09-25 17:08:21 +0200424 }
Michal Vasko69730152020-10-09 16:30:07 +0200425 } else if ((in[offset] == 'x') && isxdigit(in[offset + 1])) {
Radek Krejci7a7fa902018-09-25 17:08:21 +0200426 for (n = 0, ++offset; isxdigit(in[offset]); offset++) {
427 if (isdigit(in[offset])) {
428 u = (in[offset] - '0');
429 } else if (in[offset] > 'F') {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100430 u = LY_BASE_DEC + (in[offset] - 'a');
Radek Krejci7a7fa902018-09-25 17:08:21 +0200431 } else {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100432 u = LY_BASE_DEC + (in[offset] - 'A');
Radek Krejci7a7fa902018-09-25 17:08:21 +0200433 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100434 n = (LY_BASE_HEX * n) + u;
Radek Krejci7a7fa902018-09-25 17:08:21 +0200435 }
436 } else {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100437 LOGVAL(ctx, LYVE_SYNTAX, "Invalid character reference \"%.*s\".", 12, p);
Radek Krejci7a7fa902018-09-25 17:08:21 +0200438 goto error;
439
440 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100441
Radek Krejci7a7fa902018-09-25 17:08:21 +0200442 LY_CHECK_ERR_GOTO(in[offset] != ';',
Radek Krejci2efc45b2020-12-22 16:25:44 +0100443 LOGVAL(ctx, LY_VCODE_INSTREXP,
Michal Vasko69730152020-10-09 16:30:07 +0200444 LY_VCODE_INSTREXP_len(&in[offset]), &in[offset], ";"),
445 error);
Radek Krejci7a7fa902018-09-25 17:08:21 +0200446 ++offset;
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200447 LY_CHECK_ERR_GOTO(ly_pututf8(&buf[len], n, &u),
Radek Krejci2efc45b2020-12-22 16:25:44 +0100448 LOGVAL(ctx, LYVE_SYNTAX, "Invalid character reference \"%.*s\" (0x%08x).", 12, p, n),
Michal Vasko69730152020-10-09 16:30:07 +0200449 error);
Radek Krejci7a7fa902018-09-25 17:08:21 +0200450 len += u;
451 in += offset;
452 offset = 0;
453 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100454 } else if (in[offset] == endchar) {
Radek Krejci7a7fa902018-09-25 17:08:21 +0200455 /* end of string */
Radek Krejcid70d1072018-10-09 14:20:47 +0200456 if (buf) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100457 /* realloc exact size string */
458 buf = ly_realloc(buf, len + offset + 1);
459 LY_CHECK_ERR_RET(!buf, LOGMEM(ctx), LY_EMEM);
460 size = len + offset + 1;
Radek Krejcid70d1072018-10-09 14:20:47 +0200461 memcpy(&buf[len], in, offset);
Michal Vaskob36053d2020-03-26 15:49:30 +0100462
463 /* set terminating NULL byte */
464 buf[len + offset] = '\0';
Radek Krejci7a7fa902018-09-25 17:08:21 +0200465 }
Radek Krejci7a7fa902018-09-25 17:08:21 +0200466 len += offset;
Michal Vaskob36053d2020-03-26 15:49:30 +0100467 in += offset;
Radek Krejci7a7fa902018-09-25 17:08:21 +0200468 goto success;
469 } else {
Michal Vaskob36053d2020-03-26 15:49:30 +0100470 if (!is_xmlws(in[offset])) {
471 /* non WS */
472 ws = 0;
473 }
474
Radek Krejci7a7fa902018-09-25 17:08:21 +0200475 /* log lines */
476 if (in[offset] == '\n') {
Radek Krejcid54412f2020-12-17 20:25:35 +0100477 LY_IN_NEW_LINE(xmlctx->in);
Radek Krejci7a7fa902018-09-25 17:08:21 +0200478 }
479
480 /* continue */
481 ++offset;
482 }
483 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100484
485 /* EOF reached before endchar */
Radek Krejci2efc45b2020-12-22 16:25:44 +0100486 LOGVAL(ctx, LY_VCODE_EOF);
Michal Vaskob36053d2020-03-26 15:49:30 +0100487
Radek Krejci7a7fa902018-09-25 17:08:21 +0200488error:
Michal Vaskob36053d2020-03-26 15:49:30 +0100489 free(buf);
Radek Krejci7a7fa902018-09-25 17:08:21 +0200490 return LY_EVALID;
491
492success:
Radek Krejcid70d1072018-10-09 14:20:47 +0200493 if (buf) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100494 *value = buf;
495 *dynamic = 1;
496 } else {
497 *value = (char *)start;
498 *dynamic = 0;
Radek Krejci7a7fa902018-09-25 17:08:21 +0200499 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100500 *length = len;
501 *ws_only = ws;
Radek Krejci7a7fa902018-09-25 17:08:21 +0200502
Radek Krejcid54412f2020-12-17 20:25:35 +0100503 xmlctx->in->current = in;
Michal Vaskob36053d2020-03-26 15:49:30 +0100504 return LY_SUCCESS;
Radek Krejci7a7fa902018-09-25 17:08:21 +0200505
506#undef BUFSIZE
507#undef BUFSIZE_STEP
Radek Krejci7a7fa902018-09-25 17:08:21 +0200508}
509
Michal Vasko8cef5232020-06-15 17:59:47 +0200510/**
511 * @brief Parse XML closing element and match it to a stored starting element.
512 *
513 * @param[in] xmlctx XML context to use.
514 * @param[in] prefix Expected closing element prefix.
515 * @param[in] prefix_len Length of @p prefix.
516 * @param[in] name Expected closing element name.
517 * @param[in] name_len Length of @p name.
518 * @param[in] empty Whether we are parsing a special "empty" element (with joined starting and closing tag) with no value.
519 * @return LY_ERR value.
520 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100521static LY_ERR
522lyxml_close_element(struct lyxml_ctx *xmlctx, const char *prefix, size_t prefix_len, const char *name, size_t name_len,
Radek Krejci857189e2020-09-01 13:26:36 +0200523 ly_bool empty)
Radek Krejcid972c252018-09-25 13:23:39 +0200524{
Michal Vaskob36053d2020-03-26 15:49:30 +0100525 struct lyxml_elem *e;
Radek Krejcid972c252018-09-25 13:23:39 +0200526
Michal Vaskob36053d2020-03-26 15:49:30 +0100527 /* match opening and closing element tags */
528 if (!xmlctx->elements.count) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100529 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Stray closing element tag (\"%.*s\").",
Radek Krejci422afb12021-03-04 16:38:16 +0100530 (int)name_len, name);
Michal Vaskob36053d2020-03-26 15:49:30 +0100531 return LY_EVALID;
532 }
Radek Krejcid972c252018-09-25 13:23:39 +0200533
Michal Vaskob36053d2020-03-26 15:49:30 +0100534 e = (struct lyxml_elem *)xmlctx->elements.objs[xmlctx->elements.count - 1];
Michal Vasko69730152020-10-09 16:30:07 +0200535 if ((e->prefix_len != prefix_len) || (e->name_len != name_len) ||
536 (prefix_len && strncmp(prefix, e->prefix, e->prefix_len)) || strncmp(name, e->name, e->name_len)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100537 LOGVAL(xmlctx->ctx, LYVE_SYNTAX, "Opening (\"%.*s%s%.*s\") and closing (\"%.*s%s%.*s\") elements tag mismatch.",
Radek Krejci422afb12021-03-04 16:38:16 +0100538 (int)e->prefix_len, e->prefix ? e->prefix : "", e->prefix ? ":" : "", (int)e->name_len, e->name,
539 (int)prefix_len, prefix ? prefix : "", prefix ? ":" : "", (int)name_len, name);
Michal Vaskob36053d2020-03-26 15:49:30 +0100540 return LY_EVALID;
541 }
Radek Krejcid972c252018-09-25 13:23:39 +0200542
Michal Vaskob36053d2020-03-26 15:49:30 +0100543 /* opening and closing element tags matches, remove record from the opening tags list */
544 ly_set_rm_index(&xmlctx->elements, xmlctx->elements.count - 1, free);
Radek Krejcid972c252018-09-25 13:23:39 +0200545
Michal Vaskob36053d2020-03-26 15:49:30 +0100546 /* remove also the namespaces connected with the element */
547 lyxml_ns_rm(xmlctx);
Radek Krejcid972c252018-09-25 13:23:39 +0200548
Michal Vaskob36053d2020-03-26 15:49:30 +0100549 /* skip WS */
550 ign_xmlws(xmlctx);
Radek Krejcid972c252018-09-25 13:23:39 +0200551
Michal Vaskob36053d2020-03-26 15:49:30 +0100552 /* special "<elem/>" element */
Michal Vasko63f3d842020-07-08 10:10:14 +0200553 if (empty && (xmlctx->in->current[0] == '/')) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100554 move_input(xmlctx, 1);
555 }
Michal Vasko52927e22020-03-16 17:26:14 +0100556
Michal Vaskob36053d2020-03-26 15:49:30 +0100557 /* parse closing tag */
Michal Vasko63f3d842020-07-08 10:10:14 +0200558 if (xmlctx->in->current[0] != '>') {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100559 LOGVAL(xmlctx->ctx, LY_VCODE_INSTREXP, LY_VCODE_INSTREXP_len(xmlctx->in->current),
Michal Vasko69730152020-10-09 16:30:07 +0200560 xmlctx->in->current, "element tag termination ('>')");
Michal Vaskob36053d2020-03-26 15:49:30 +0100561 return LY_EVALID;
562 }
Michal Vasko52927e22020-03-16 17:26:14 +0100563
Michal Vaskob36053d2020-03-26 15:49:30 +0100564 /* move after closing tag without checking for EOF */
Michal Vasko63f3d842020-07-08 10:10:14 +0200565 ly_in_skip(xmlctx->in, 1);
Michal Vasko52927e22020-03-16 17:26:14 +0100566
Radek Krejcid972c252018-09-25 13:23:39 +0200567 return LY_SUCCESS;
568}
569
Michal Vasko8cef5232020-06-15 17:59:47 +0200570/**
571 * @brief Store parsed opening element and parse any included namespaces.
572 *
573 * @param[in] xmlctx XML context to use.
574 * @param[in] prefix Parsed starting element prefix.
575 * @param[in] prefix_len Length of @p prefix.
576 * @param[in] name Parsed starting element name.
577 * @param[in] name_len Length of @p name.
578 * @return LY_ERR value.
579 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100580static LY_ERR
581lyxml_open_element(struct lyxml_ctx *xmlctx, const char *prefix, size_t prefix_len, const char *name, size_t name_len)
Radek Krejcib1890642018-10-03 14:05:40 +0200582{
Michal Vaskob36053d2020-03-26 15:49:30 +0100583 LY_ERR ret = LY_SUCCESS;
584 struct lyxml_elem *e;
585 const char *prev_input;
586 char *value;
587 size_t parsed, value_len;
Radek Krejci857189e2020-09-01 13:26:36 +0200588 ly_bool ws_only, dynamic, is_ns;
Michal Vaskob36053d2020-03-26 15:49:30 +0100589 uint32_t c;
Radek Krejcib1890642018-10-03 14:05:40 +0200590
Michal Vaskob36053d2020-03-26 15:49:30 +0100591 /* store element opening tag information */
592 e = malloc(sizeof *e);
593 LY_CHECK_ERR_RET(!e, LOGMEM(xmlctx->ctx), LY_EMEM);
594 e->name = name;
595 e->prefix = prefix;
596 e->name_len = name_len;
597 e->prefix_len = prefix_len;
Radek Krejci3d92e442020-10-12 12:48:13 +0200598 LY_CHECK_RET(ly_set_add(&xmlctx->elements, e, 1, NULL));
Michal Vaskob36053d2020-03-26 15:49:30 +0100599
600 /* skip WS */
601 ign_xmlws(xmlctx);
602
603 /* parse and store all namespaces */
Michal Vasko63f3d842020-07-08 10:10:14 +0200604 prev_input = xmlctx->in->current;
Michal Vaskob36053d2020-03-26 15:49:30 +0100605 is_ns = 1;
Michal Vasko63f3d842020-07-08 10:10:14 +0200606 while ((xmlctx->in->current[0] != '\0') && !ly_getutf8(&xmlctx->in->current, &c, &parsed) && is_xmlqnamestartchar(c)) {
607 xmlctx->in->current -= parsed;
Michal Vaskob36053d2020-03-26 15:49:30 +0100608
609 /* parse attribute name */
610 LY_CHECK_GOTO(ret = lyxml_parse_qname(xmlctx, &prefix, &prefix_len, &name, &name_len), cleanup);
611
612 /* parse the value */
613 LY_CHECK_GOTO(ret = lyxml_next_attr_content(xmlctx, (const char **)&value, &value_len, &ws_only, &dynamic), cleanup);
614
615 /* store every namespace */
616 if ((prefix && !ly_strncmp("xmlns", prefix, prefix_len)) || (!prefix && !ly_strncmp("xmlns", name, name_len))) {
Radek IÅ¡a017270d2021-02-16 10:26:15 +0100617 ret = lyxml_ns_add(xmlctx, prefix ? name : NULL, prefix ? name_len : 0,
618 dynamic ? value : strndup(value, value_len));
Michal Vaskob36053d2020-03-26 15:49:30 +0100619 dynamic = 0;
Radek IÅ¡a017270d2021-02-16 10:26:15 +0100620 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100621 } else {
622 /* not a namespace */
623 is_ns = 0;
624 }
625 if (dynamic) {
626 free(value);
627 }
628
629 /* skip WS */
630 ign_xmlws(xmlctx);
631
632 if (is_ns) {
633 /* we can actually skip all the namespaces as there is no reason to parse them again */
Michal Vasko63f3d842020-07-08 10:10:14 +0200634 prev_input = xmlctx->in->current;
Michal Vaskob36053d2020-03-26 15:49:30 +0100635 }
Radek Krejcib1890642018-10-03 14:05:40 +0200636 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100637
638cleanup:
639 if (!ret) {
Michal Vasko63f3d842020-07-08 10:10:14 +0200640 xmlctx->in->current = prev_input;
Michal Vaskob36053d2020-03-26 15:49:30 +0100641 }
642 return ret;
643}
644
Michal Vasko8cef5232020-06-15 17:59:47 +0200645/**
646 * @brief Move parser to the attribute content and parse it.
647 *
648 * @param[in] xmlctx XML context to use.
649 * @param[out] value Parsed attribute value.
650 * @param[out] value_len Length of @p value.
651 * @param[out] ws_only Whether the value is empty/white-spaces only.
652 * @param[out] dynamic Whether the value was dynamically allocated.
653 * @return LY_ERR value.
654 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100655static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200656lyxml_next_attr_content(struct lyxml_ctx *xmlctx, const char **value, size_t *value_len, ly_bool *ws_only, ly_bool *dynamic)
Michal Vaskob36053d2020-03-26 15:49:30 +0100657{
658 char quot;
659
660 /* skip WS */
661 ign_xmlws(xmlctx);
662
663 /* skip '=' */
Michal Vasko63f3d842020-07-08 10:10:14 +0200664 if (xmlctx->in->current[0] == '\0') {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100665 LOGVAL(xmlctx->ctx, LY_VCODE_EOF);
Michal Vaskob36053d2020-03-26 15:49:30 +0100666 return LY_EVALID;
Michal Vasko63f3d842020-07-08 10:10:14 +0200667 } else if (xmlctx->in->current[0] != '=') {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100668 LOGVAL(xmlctx->ctx, LY_VCODE_INSTREXP, LY_VCODE_INSTREXP_len(xmlctx->in->current),
Michal Vasko69730152020-10-09 16:30:07 +0200669 xmlctx->in->current, "'='");
Michal Vaskob36053d2020-03-26 15:49:30 +0100670 return LY_EVALID;
671 }
672 move_input(xmlctx, 1);
673
674 /* skip WS */
675 ign_xmlws(xmlctx);
676
677 /* find quotes */
Michal Vasko63f3d842020-07-08 10:10:14 +0200678 if (xmlctx->in->current[0] == '\0') {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100679 LOGVAL(xmlctx->ctx, LY_VCODE_EOF);
Michal Vaskob36053d2020-03-26 15:49:30 +0100680 return LY_EVALID;
Michal Vasko63f3d842020-07-08 10:10:14 +0200681 } else if ((xmlctx->in->current[0] != '\'') && (xmlctx->in->current[0] != '\"')) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100682 LOGVAL(xmlctx->ctx, LY_VCODE_INSTREXP, LY_VCODE_INSTREXP_len(xmlctx->in->current),
Michal Vasko69730152020-10-09 16:30:07 +0200683 xmlctx->in->current, "either single or double quotation mark");
Michal Vaskob36053d2020-03-26 15:49:30 +0100684 return LY_EVALID;
685 }
686
687 /* remember quote */
Michal Vasko63f3d842020-07-08 10:10:14 +0200688 quot = xmlctx->in->current[0];
Michal Vaskob36053d2020-03-26 15:49:30 +0100689 move_input(xmlctx, 1);
690
691 /* parse attribute value */
692 LY_CHECK_RET(lyxml_parse_value(xmlctx, quot, (char **)value, value_len, ws_only, dynamic));
693
694 /* move after ending quote (without checking for EOF) */
Michal Vasko63f3d842020-07-08 10:10:14 +0200695 ly_in_skip(xmlctx->in, 1);
Michal Vaskob36053d2020-03-26 15:49:30 +0100696
697 return LY_SUCCESS;
698}
699
Michal Vasko8cef5232020-06-15 17:59:47 +0200700/**
701 * @brief Move parser to the next attribute and parse it.
702 *
703 * @param[in] xmlctx XML context to use.
704 * @param[out] prefix Parsed attribute prefix.
705 * @param[out] prefix_len Length of @p prefix.
706 * @param[out] name Parsed attribute name.
707 * @param[out] name_len Length of @p name.
708 * @return LY_ERR value.
709 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100710static LY_ERR
711lyxml_next_attribute(struct lyxml_ctx *xmlctx, const char **prefix, size_t *prefix_len, const char **name, size_t *name_len)
712{
713 const char *in;
714 char *value;
715 uint32_t c;
716 size_t parsed, value_len;
Radek Krejci857189e2020-09-01 13:26:36 +0200717 ly_bool ws_only, dynamic;
Michal Vaskob36053d2020-03-26 15:49:30 +0100718
719 /* skip WS */
720 ign_xmlws(xmlctx);
721
722 /* parse only possible attributes */
Michal Vasko63f3d842020-07-08 10:10:14 +0200723 while ((xmlctx->in->current[0] != '>') && (xmlctx->in->current[0] != '/')) {
724 in = xmlctx->in->current;
Michal Vaskob36053d2020-03-26 15:49:30 +0100725 if (in[0] == '\0') {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100726 LOGVAL(xmlctx->ctx, LY_VCODE_EOF);
Michal Vaskob36053d2020-03-26 15:49:30 +0100727 return LY_EVALID;
728 } else if ((ly_getutf8(&in, &c, &parsed) || !is_xmlqnamestartchar(c))) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100729 LOGVAL(xmlctx->ctx, LY_VCODE_INSTREXP, LY_VCODE_INSTREXP_len(in - parsed), in - parsed,
Michal Vasko69730152020-10-09 16:30:07 +0200730 "element tag end ('>' or '/>') or an attribute");
Michal Vaskob36053d2020-03-26 15:49:30 +0100731 return LY_EVALID;
732 }
733
734 /* parse attribute name */
735 LY_CHECK_RET(lyxml_parse_qname(xmlctx, prefix, prefix_len, name, name_len));
736
737 if ((!*prefix || ly_strncmp("xmlns", *prefix, *prefix_len)) && (*prefix || ly_strncmp("xmlns", *name, *name_len))) {
738 /* standard attribute */
739 break;
740 }
741
742 /* namespace, skip it */
743 LY_CHECK_RET(lyxml_next_attr_content(xmlctx, (const char **)&value, &value_len, &ws_only, &dynamic));
744 if (dynamic) {
745 free(value);
746 }
747
748 /* skip WS */
749 ign_xmlws(xmlctx);
750 }
751
752 return LY_SUCCESS;
753}
754
Michal Vasko8cef5232020-06-15 17:59:47 +0200755/**
756 * @brief Move parser to the next element and parse it.
757 *
758 * @param[in] xmlctx XML context to use.
759 * @param[out] prefix Parsed element prefix.
760 * @param[out] prefix_len Length of @p prefix.
761 * @param[out] name Parse element name.
762 * @param[out] name_len Length of @p name.
Radek Krejci1deb5be2020-08-26 16:43:36 +0200763 * @param[out] closing Flag if the element is closing (includes '/').
Michal Vasko8cef5232020-06-15 17:59:47 +0200764 * @return LY_ERR value.
765 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100766static LY_ERR
767lyxml_next_element(struct lyxml_ctx *xmlctx, const char **prefix, size_t *prefix_len, const char **name, size_t *name_len,
Radek Krejci857189e2020-09-01 13:26:36 +0200768 ly_bool *closing)
Michal Vaskob36053d2020-03-26 15:49:30 +0100769{
770 /* skip WS until EOF or after opening tag '<' */
771 LY_CHECK_RET(lyxml_skip_until_end_or_after_otag(xmlctx));
Michal Vasko63f3d842020-07-08 10:10:14 +0200772 if (xmlctx->in->current[0] == '\0') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100773 /* set return values */
774 *prefix = *name = NULL;
775 *prefix_len = *name_len = 0;
776 return LY_SUCCESS;
777 }
778
Michal Vasko63f3d842020-07-08 10:10:14 +0200779 if (xmlctx->in->current[0] == '/') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100780 move_input(xmlctx, 1);
781 *closing = 1;
782 } else {
783 *closing = 0;
784 }
785
786 /* skip WS */
787 ign_xmlws(xmlctx);
788
789 /* parse element name */
790 LY_CHECK_RET(lyxml_parse_qname(xmlctx, prefix, prefix_len, name, name_len));
791
792 return LY_SUCCESS;
793}
794
795LY_ERR
Michal Vasko63f3d842020-07-08 10:10:14 +0200796lyxml_ctx_new(const struct ly_ctx *ctx, struct ly_in *in, struct lyxml_ctx **xmlctx_p)
Michal Vaskob36053d2020-03-26 15:49:30 +0100797{
798 LY_ERR ret = LY_SUCCESS;
799 struct lyxml_ctx *xmlctx;
Radek Krejci857189e2020-09-01 13:26:36 +0200800 ly_bool closing;
Michal Vaskob36053d2020-03-26 15:49:30 +0100801
802 /* new context */
803 xmlctx = calloc(1, sizeof *xmlctx);
804 LY_CHECK_ERR_RET(!xmlctx, LOGMEM(ctx), LY_EMEM);
805 xmlctx->ctx = ctx;
Michal Vasko63f3d842020-07-08 10:10:14 +0200806 xmlctx->in = in;
Michal Vaskob36053d2020-03-26 15:49:30 +0100807
Radek Krejciddace2c2021-01-08 11:30:56 +0100808 LOG_LOCINIT(NULL, NULL, NULL, in);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100809
Michal Vaskob36053d2020-03-26 15:49:30 +0100810 /* parse next element, if any */
811 LY_CHECK_GOTO(ret = lyxml_next_element(xmlctx, &xmlctx->prefix, &xmlctx->prefix_len, &xmlctx->name,
Michal Vasko69730152020-10-09 16:30:07 +0200812 &xmlctx->name_len, &closing), cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100813
Michal Vasko63f3d842020-07-08 10:10:14 +0200814 if (xmlctx->in->current[0] == '\0') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100815 /* update status */
816 xmlctx->status = LYXML_END;
817 } else if (closing) {
Radek Krejci422afb12021-03-04 16:38:16 +0100818 LOGVAL(ctx, LYVE_SYNTAX, "Stray closing element tag (\"%.*s\").", (int)xmlctx->name_len, xmlctx->name);
Michal Vaskob36053d2020-03-26 15:49:30 +0100819 ret = LY_EVALID;
820 goto cleanup;
821 } else {
822 /* open an element, also parses all enclosed namespaces */
823 LY_CHECK_GOTO(ret = lyxml_open_element(xmlctx, xmlctx->prefix, xmlctx->prefix_len, xmlctx->name, xmlctx->name_len), cleanup);
824
825 /* update status */
826 xmlctx->status = LYXML_ELEMENT;
827 }
828
829cleanup:
830 if (ret) {
831 lyxml_ctx_free(xmlctx);
832 } else {
833 *xmlctx_p = xmlctx;
834 }
835 return ret;
836}
837
838LY_ERR
839lyxml_ctx_next(struct lyxml_ctx *xmlctx)
840{
841 LY_ERR ret = LY_SUCCESS;
Radek Krejci857189e2020-09-01 13:26:36 +0200842 ly_bool closing;
Michal Vaskob36053d2020-03-26 15:49:30 +0100843 struct lyxml_elem *e;
844
845 /* if the value was not used, free it */
846 if (((xmlctx->status == LYXML_ELEM_CONTENT) || (xmlctx->status == LYXML_ATTR_CONTENT)) && xmlctx->dynamic) {
847 free((char *)xmlctx->value);
848 xmlctx->value = NULL;
849 xmlctx->dynamic = 0;
850 }
851
852 switch (xmlctx->status) {
Michal Vaskob36053d2020-03-26 15:49:30 +0100853 case LYXML_ELEM_CONTENT:
Radek Krejcif13b87b2020-12-01 22:02:17 +0100854 /* content |</elem> */
855
Michal Vaskob36053d2020-03-26 15:49:30 +0100856 /* handle special case when empty content for "<elem/>" was returned */
Michal Vasko63f3d842020-07-08 10:10:14 +0200857 if (xmlctx->in->current[0] == '/') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100858 assert(xmlctx->elements.count);
859 e = (struct lyxml_elem *)xmlctx->elements.objs[xmlctx->elements.count - 1];
860
861 /* close the element (parses closing tag) */
Michal Vasko63f3d842020-07-08 10:10:14 +0200862 ret = lyxml_close_element(xmlctx, e->prefix, e->prefix_len, e->name, e->name_len, 1);
863 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100864
865 /* update status */
866 xmlctx->status = LYXML_ELEM_CLOSE;
867 break;
868 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100869 /* fall through */
Michal Vaskob36053d2020-03-26 15:49:30 +0100870 case LYXML_ELEM_CLOSE:
Radek Krejcif13b87b2020-12-01 22:02:17 +0100871 /* </elem>| <elem2>* */
872
Michal Vaskob36053d2020-03-26 15:49:30 +0100873 /* parse next element, if any */
Michal Vasko63f3d842020-07-08 10:10:14 +0200874 ret = lyxml_next_element(xmlctx, &xmlctx->prefix, &xmlctx->prefix_len, &xmlctx->name, &xmlctx->name_len, &closing);
875 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100876
Michal Vasko63f3d842020-07-08 10:10:14 +0200877 if (xmlctx->in->current[0] == '\0') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100878 /* update status */
879 xmlctx->status = LYXML_END;
880 } else if (closing) {
881 /* close an element (parses also closing tag) */
Michal Vasko63f3d842020-07-08 10:10:14 +0200882 ret = lyxml_close_element(xmlctx, xmlctx->prefix, xmlctx->prefix_len, xmlctx->name, xmlctx->name_len, 0);
883 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100884
885 /* update status */
886 xmlctx->status = LYXML_ELEM_CLOSE;
887 } else {
888 /* open an element, also parses all enclosed namespaces */
Michal Vasko63f3d842020-07-08 10:10:14 +0200889 ret = lyxml_open_element(xmlctx, xmlctx->prefix, xmlctx->prefix_len, xmlctx->name, xmlctx->name_len);
890 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100891
892 /* update status */
893 xmlctx->status = LYXML_ELEMENT;
894 }
895 break;
896
Michal Vaskob36053d2020-03-26 15:49:30 +0100897 case LYXML_ELEMENT:
Radek Krejcif13b87b2020-12-01 22:02:17 +0100898 /* <elem| attr='val'* > content */
Michal Vaskob36053d2020-03-26 15:49:30 +0100899 case LYXML_ATTR_CONTENT:
Radek Krejcif13b87b2020-12-01 22:02:17 +0100900 /* attr='val'| attr='val'* > content */
901
Michal Vaskob36053d2020-03-26 15:49:30 +0100902 /* parse attribute name, if any */
Michal Vasko63f3d842020-07-08 10:10:14 +0200903 ret = lyxml_next_attribute(xmlctx, &xmlctx->prefix, &xmlctx->prefix_len, &xmlctx->name, &xmlctx->name_len);
904 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100905
Michal Vasko63f3d842020-07-08 10:10:14 +0200906 if (xmlctx->in->current[0] == '>') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100907 /* no attributes but a closing tag */
Michal Vasko63f3d842020-07-08 10:10:14 +0200908 ly_in_skip(xmlctx->in, 1);
909 if (!xmlctx->in->current[0]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100910 LOGVAL(xmlctx->ctx, LY_VCODE_EOF);
Michal Vaskof55ae202020-06-30 15:49:36 +0200911 ret = LY_EVALID;
912 goto cleanup;
913 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100914
915 /* parse element content */
Michal Vasko63f3d842020-07-08 10:10:14 +0200916 ret = lyxml_parse_value(xmlctx, '<', (char **)&xmlctx->value, &xmlctx->value_len, &xmlctx->ws_only,
Michal Vasko69730152020-10-09 16:30:07 +0200917 &xmlctx->dynamic);
Michal Vasko63f3d842020-07-08 10:10:14 +0200918 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100919
920 if (!xmlctx->value_len) {
Radek IÅ¡a017270d2021-02-16 10:26:15 +0100921 /* empty value should by alocated staticaly, but check for in any case */
922 if (xmlctx->dynamic) {
923 free((char *) xmlctx->value);
924 }
Michal Vaskob36053d2020-03-26 15:49:30 +0100925 /* use empty value, easier to work with */
926 xmlctx->value = "";
Radek IÅ¡a017270d2021-02-16 10:26:15 +0100927 xmlctx->dynamic = 0;
Michal Vaskob36053d2020-03-26 15:49:30 +0100928 }
929
930 /* update status */
931 xmlctx->status = LYXML_ELEM_CONTENT;
Michal Vasko63f3d842020-07-08 10:10:14 +0200932 } else if (xmlctx->in->current[0] == '/') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100933 /* no content but we still return it */
934 xmlctx->value = "";
935 xmlctx->value_len = 0;
936 xmlctx->ws_only = 1;
937 xmlctx->dynamic = 0;
938
939 /* update status */
940 xmlctx->status = LYXML_ELEM_CONTENT;
941 } else {
942 /* update status */
943 xmlctx->status = LYXML_ATTRIBUTE;
944 }
945 break;
946
Michal Vaskob36053d2020-03-26 15:49:30 +0100947 case LYXML_ATTRIBUTE:
Radek Krejcif13b87b2020-12-01 22:02:17 +0100948 /* attr|='val' */
949
Michal Vaskob36053d2020-03-26 15:49:30 +0100950 /* skip formatting and parse value */
Michal Vasko63f3d842020-07-08 10:10:14 +0200951 ret = lyxml_next_attr_content(xmlctx, &xmlctx->value, &xmlctx->value_len, &xmlctx->ws_only, &xmlctx->dynamic);
952 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100953
954 /* update status */
955 xmlctx->status = LYXML_ATTR_CONTENT;
956 break;
957
Michal Vaskob36053d2020-03-26 15:49:30 +0100958 case LYXML_END:
Radek Krejcif13b87b2020-12-01 22:02:17 +0100959 /* </elem> |EOF */
Michal Vaskob36053d2020-03-26 15:49:30 +0100960 /* nothing to do */
961 break;
962 }
963
964cleanup:
965 if (ret) {
966 /* invalidate context */
967 xmlctx->status = LYXML_END;
968 }
969 return ret;
970}
971
972LY_ERR
973lyxml_ctx_peek(struct lyxml_ctx *xmlctx, enum LYXML_PARSER_STATUS *next)
974{
975 LY_ERR ret = LY_SUCCESS;
976 const char *prefix, *name, *prev_input;
977 size_t prefix_len, name_len;
Radek Krejci857189e2020-09-01 13:26:36 +0200978 ly_bool closing;
Michal Vaskob36053d2020-03-26 15:49:30 +0100979
Michal Vasko63f3d842020-07-08 10:10:14 +0200980 prev_input = xmlctx->in->current;
Michal Vaskob36053d2020-03-26 15:49:30 +0100981
982 switch (xmlctx->status) {
983 case LYXML_ELEM_CONTENT:
Michal Vasko63f3d842020-07-08 10:10:14 +0200984 if (xmlctx->in->current[0] == '/') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100985 *next = LYXML_ELEM_CLOSE;
986 break;
987 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100988 /* fall through */
Michal Vaskob36053d2020-03-26 15:49:30 +0100989 case LYXML_ELEM_CLOSE:
990 /* parse next element, if any */
Michal Vasko63f3d842020-07-08 10:10:14 +0200991 ret = lyxml_next_element(xmlctx, &prefix, &prefix_len, &name, &name_len, &closing);
992 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +0100993
Michal Vasko63f3d842020-07-08 10:10:14 +0200994 if (xmlctx->in->current[0] == '\0') {
Michal Vaskob36053d2020-03-26 15:49:30 +0100995 *next = LYXML_END;
996 } else if (closing) {
997 *next = LYXML_ELEM_CLOSE;
998 } else {
999 *next = LYXML_ELEMENT;
1000 }
1001 break;
1002 case LYXML_ELEMENT:
1003 case LYXML_ATTR_CONTENT:
1004 /* parse attribute name, if any */
Michal Vasko63f3d842020-07-08 10:10:14 +02001005 ret = lyxml_next_attribute(xmlctx, &prefix, &prefix_len, &name, &name_len);
1006 LY_CHECK_GOTO(ret, cleanup);
Michal Vaskob36053d2020-03-26 15:49:30 +01001007
Michal Vasko63f3d842020-07-08 10:10:14 +02001008 if ((xmlctx->in->current[0] == '>') || (xmlctx->in->current[0] == '/')) {
Michal Vaskob36053d2020-03-26 15:49:30 +01001009 *next = LYXML_ELEM_CONTENT;
1010 } else {
1011 *next = LYXML_ATTRIBUTE;
1012 }
1013 break;
1014 case LYXML_ATTRIBUTE:
1015 *next = LYXML_ATTR_CONTENT;
1016 break;
1017 case LYXML_END:
1018 *next = LYXML_END;
1019 break;
1020 }
1021
1022cleanup:
Michal Vasko63f3d842020-07-08 10:10:14 +02001023 xmlctx->in->current = prev_input;
Michal Vaskob36053d2020-03-26 15:49:30 +01001024 return ret;
1025}
1026
1027void
1028lyxml_ctx_free(struct lyxml_ctx *xmlctx)
1029{
1030 uint32_t u;
1031
1032 if (!xmlctx) {
1033 return;
1034 }
1035
Radek Krejciddace2c2021-01-08 11:30:56 +01001036 LOG_LOCBACK(0, 0, 0, 1);
Radek Krejci2efc45b2020-12-22 16:25:44 +01001037
Michal Vaskob36053d2020-03-26 15:49:30 +01001038 if (((xmlctx->status == LYXML_ELEM_CONTENT) || (xmlctx->status == LYXML_ATTR_CONTENT)) && xmlctx->dynamic) {
1039 free((char *)xmlctx->value);
1040 }
1041 ly_set_erase(&xmlctx->elements, free);
1042 for (u = xmlctx->ns.count - 1; u + 1 > 0; --u) {
1043 /* remove the ns structure */
1044 free(((struct lyxml_ns *)xmlctx->ns.objs[u])->prefix);
1045 free(((struct lyxml_ns *)xmlctx->ns.objs[u])->uri);
1046 free(xmlctx->ns.objs[u]);
1047 }
1048 ly_set_erase(&xmlctx->ns, NULL);
1049 free(xmlctx);
Radek Krejcib1890642018-10-03 14:05:40 +02001050}
Radek Krejcie7b95092019-05-15 11:03:07 +02001051
1052LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001053lyxml_dump_text(struct ly_out *out, const char *text, ly_bool attribute)
Radek Krejcie7b95092019-05-15 11:03:07 +02001054{
Michal Vasko5233e962020-08-14 14:26:20 +02001055 LY_ERR ret;
Radek Krejcie7b95092019-05-15 11:03:07 +02001056
1057 if (!text) {
1058 return 0;
1059 }
1060
Radek Krejci1deb5be2020-08-26 16:43:36 +02001061 for (uint64_t u = 0; text[u]; u++) {
Radek Krejcie7b95092019-05-15 11:03:07 +02001062 switch (text[u]) {
1063 case '&':
Michal Vasko5233e962020-08-14 14:26:20 +02001064 ret = ly_print_(out, "&amp;");
Radek Krejcie7b95092019-05-15 11:03:07 +02001065 break;
1066 case '<':
Michal Vasko5233e962020-08-14 14:26:20 +02001067 ret = ly_print_(out, "&lt;");
Radek Krejcie7b95092019-05-15 11:03:07 +02001068 break;
1069 case '>':
1070 /* not needed, just for readability */
Michal Vasko5233e962020-08-14 14:26:20 +02001071 ret = ly_print_(out, "&gt;");
Radek Krejcie7b95092019-05-15 11:03:07 +02001072 break;
1073 case '"':
1074 if (attribute) {
Michal Vasko5233e962020-08-14 14:26:20 +02001075 ret = ly_print_(out, "&quot;");
Radek Krejcie7b95092019-05-15 11:03:07 +02001076 break;
1077 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001078 /* fall through */
Radek Krejcie7b95092019-05-15 11:03:07 +02001079 default:
Michal Vasko5233e962020-08-14 14:26:20 +02001080 ret = ly_write_(out, &text[u], 1);
1081 break;
Radek Krejcie7b95092019-05-15 11:03:07 +02001082 }
Michal Vasko5233e962020-08-14 14:26:20 +02001083 LY_CHECK_RET(ret);
Radek Krejcie7b95092019-05-15 11:03:07 +02001084 }
1085
Michal Vasko5233e962020-08-14 14:26:20 +02001086 return LY_SUCCESS;
Radek Krejcie7b95092019-05-15 11:03:07 +02001087}
1088
Michal Vasko52927e22020-03-16 17:26:14 +01001089LY_ERR
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001090lyxml_value_compare(const struct ly_ctx *ctx, const char *value1, void *val_prefix_data1, const char *value2,
1091 void *val_prefix_data2)
Michal Vasko52927e22020-03-16 17:26:14 +01001092{
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001093 const char *ptr1, *ptr2, *end1, *end2;
1094 const struct lys_module *mod1, *mod2;
Michal Vasko52927e22020-03-16 17:26:14 +01001095
1096 if (!value1 && !value2) {
1097 return LY_SUCCESS;
1098 }
1099 if ((value1 && !value2) || (!value1 && value2)) {
1100 return LY_ENOT;
1101 }
1102
1103 ptr1 = value1;
1104 ptr2 = value2;
1105 while (ptr1[0] && ptr2[0]) {
1106 if (ptr1[0] != ptr2[0]) {
1107 /* it can be a start of prefix that maps to the same module */
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001108 mod1 = mod2 = NULL;
1109 if (val_prefix_data1 && (end1 = strchr(ptr1, ':'))) {
Michal Vasko52927e22020-03-16 17:26:14 +01001110 /* find module of the first prefix, if any */
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001111 mod1 = ly_resolve_prefix(ctx, ptr1, end1 - ptr1, LY_PREF_XML, val_prefix_data1);
Michal Vasko52927e22020-03-16 17:26:14 +01001112 }
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001113 if (val_prefix_data2 && (end2 = strchr(ptr2, ':'))) {
Michal Vasko52927e22020-03-16 17:26:14 +01001114 /* find module of the second prefix, if any */
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001115 mod2 = ly_resolve_prefix(ctx, ptr2, end2 - ptr2, LY_PREF_XML, val_prefix_data2);
Michal Vasko52927e22020-03-16 17:26:14 +01001116 }
1117
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001118 if (!mod1 || !mod2 || (mod1 != mod2)) {
Michal Vasko52927e22020-03-16 17:26:14 +01001119 /* not a prefix or maps to different namespaces */
1120 break;
1121 }
1122
1123 /* skip prefixes in both values (':' is skipped as iter) */
Michal Vasko6b5cb2a2020-11-11 19:11:21 +01001124 ptr1 = end1;
1125 ptr2 = end2;
Michal Vasko52927e22020-03-16 17:26:14 +01001126 }
1127
1128 ++ptr1;
1129 ++ptr2;
1130 }
1131 if (ptr1[0] || ptr2[0]) {
1132 /* not a match or simply different lengths */
1133 return LY_ENOT;
1134 }
1135
1136 return LY_SUCCESS;
1137}