Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 1 | /** |
| 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 | */ |
| 36 | struct 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 Krejci | e553e6d | 2019-06-07 15:33:18 +0200 | [diff] [blame] | 47 | struct ly_set incomplete_type_validation; /**< set of nodes validated with LY_EINCOMPLETE result */ |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 48 | }; |
| 49 | |
| 50 | /** |
Radek Krejci | aca7403 | 2019-06-04 08:53:06 +0200 | [diff] [blame] | 51 | * @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 | */ |
| 54 | static const struct lys_module * |
| 55 | lydxml_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 Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 69 | * @brief Parse XML attributes of the XML element of YANG data. |
| 70 | * |
| 71 | * @param[in] ctx XML YANG data parser context. |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 72 | * @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 | */ |
| 77 | static LY_ERR |
Radek Krejci | 17a78d8 | 2019-05-15 15:49:55 +0200 | [diff] [blame] | 78 | lydxml_attributes(struct lyd_xml_ctx *ctx, const char **data, struct lyd_attr **attributes) |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 79 | { |
| 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 Krejci | 17a78d8 | 2019-05-15 15:49:55 +0200 | [diff] [blame] | 99 | if (!name) { |
| 100 | /* seems like all the attrributes were internally processed as namespace definitions */ |
| 101 | continue; |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 102 | } |
Radek Krejci | 17a78d8 | 2019-05-15 15:49:55 +0200 | [diff] [blame] | 103 | |
| 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 Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 127 | } |
| 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 | |
| 138 | cleanup: |
| 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 | */ |
| 153 | static LY_ERR |
| 154 | lydxml_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 Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 158 | 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 Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 173 | if (ctx->elements.count < parents_count) { |
| 174 | /* all siblings parsed */ |
| 175 | break; |
| 176 | } else { |
| 177 | continue; |
| 178 | } |
| 179 | } |
| 180 | attributes = NULL; |
Radek Krejci | 1f05b6a | 2019-07-18 16:15:06 +0200 | [diff] [blame^] | 181 | if (ctx->status == LYXML_ATTRIBUTE) { |
| 182 | LY_CHECK_GOTO(lydxml_attributes(ctx, data, &attributes), cleanup); |
| 183 | } |
| 184 | |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 185 | 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 Krejci | e92210c | 2019-05-17 15:53:35 +0200 | [diff] [blame] | 225 | 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 Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 232 | 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 Krejci | 339e2de | 2019-05-17 14:28:24 +0200 | [diff] [blame] | 249 | 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 Krejci | e92210c | 2019-05-17 15:53:35 +0200 | [diff] [blame] | 255 | } else { |
| 256 | /* no content - validate empty value */ |
| 257 | value = ""; |
| 258 | value_len = 0; |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 259 | } |
Radek Krejci | 3c9758d | 2019-07-11 16:49:10 +0200 | [diff] [blame] | 260 | ret = lyd_value_parse((struct lyd_node_term*)cur, value, value_len, dynamic, 0, lydxml_resolve_prefix, ctx, LYD_XML, NULL); |
Radek Krejci | e553e6d | 2019-06-07 15:33:18 +0200 | [diff] [blame] | 261 | 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 Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 269 | } 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 Krejci | e553e6d | 2019-06-07 15:33:18 +0200 | [diff] [blame] | 276 | if (r != LY_EINVAL && (r != LY_SUCCESS || value_len != 0)) { |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 277 | LOGINT(ctx->ctx); |
| 278 | goto cleanup; |
| 279 | } |
| 280 | } |
Radek Krejci | ee4cab2 | 2019-07-17 17:07:47 +0200 | [diff] [blame] | 281 | /* process children */ |
Radek Krejci | e553e6d | 2019-06-07 15:33:18 +0200 | [diff] [blame] | 282 | if (ctx->status == LYXML_ELEMENT && parents_count != ctx->elements.count) { |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 283 | ret = lydxml_nodes(ctx, (struct lyd_node_inner*)cur, data, lyd_node_children_p(cur)); |
Radek Krejci | e92210c | 2019-05-17 15:53:35 +0200 | [diff] [blame] | 284 | LY_CHECK_GOTO(ret, cleanup); |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 285 | } |
Radek Krejci | ee4cab2 | 2019-07-17 17:07:47 +0200 | [diff] [blame] | 286 | } 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 Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 321 | } |
Radek Krejci | 1f05b6a | 2019-07-18 16:15:06 +0200 | [diff] [blame^] | 322 | |
| 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 Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 326 | } |
| 327 | |
| 328 | cleanup: |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 329 | lyd_free_attr(ctx->ctx, attributes, 1); |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 330 | return ret; |
| 331 | } |
| 332 | |
| 333 | LY_ERR |
| 334 | lyd_parse_xml(struct ly_ctx *ctx, const char *data, int options, struct lyd_node **result) |
| 335 | { |
| 336 | LY_ERR ret; |
| 337 | struct lyd_xml_ctx xmlctx = {0}; |
| 338 | |
| 339 | xmlctx.options = options; |
| 340 | xmlctx.ctx = ctx; |
| 341 | xmlctx.line = 1; |
| 342 | |
| 343 | ret = lydxml_nodes(&xmlctx, NULL, &data, result); |
Radek Krejci | e92210c | 2019-05-17 15:53:35 +0200 | [diff] [blame] | 344 | if (ret) { |
| 345 | lyd_free_all(*result); |
| 346 | *result = NULL; |
Radek Krejci | e553e6d | 2019-06-07 15:33:18 +0200 | [diff] [blame] | 347 | } else { |
| 348 | /* finish incompletely validated terminal values */ |
| 349 | for (unsigned int u = 0; u < xmlctx.incomplete_type_validation.count; u++) { |
| 350 | struct lyd_node_term *node = (struct lyd_node_term*)xmlctx.incomplete_type_validation.objs[u]; |
Radek Krejci | 576b23f | 2019-07-12 14:06:32 +0200 | [diff] [blame] | 351 | const struct lyd_node **trees = NULL; |
Radek Krejci | e72c043 | 2019-06-10 10:17:03 +0200 | [diff] [blame] | 352 | |
| 353 | /* prepare sized array for validator */ |
| 354 | if (*result) { |
Radek Krejci | 576b23f | 2019-07-12 14:06:32 +0200 | [diff] [blame] | 355 | trees = lyd_trees_new(1, *result); |
Radek Krejci | e553e6d | 2019-06-07 15:33:18 +0200 | [diff] [blame] | 356 | } |
Radek Krejci | e72c043 | 2019-06-10 10:17:03 +0200 | [diff] [blame] | 357 | /* validate and store the value of the node */ |
Radek Krejci | 3c9758d | 2019-07-11 16:49:10 +0200 | [diff] [blame] | 358 | ret = lyd_value_parse(node, node->value.canonized, node->value.canonized ? strlen(node->value.canonized) : 0, 0, 1, |
Radek Krejci | 084289f | 2019-07-09 17:35:30 +0200 | [diff] [blame] | 359 | lydxml_resolve_prefix, ctx, LYD_XML, trees); |
Radek Krejci | 576b23f | 2019-07-12 14:06:32 +0200 | [diff] [blame] | 360 | lyd_trees_free(trees, 0); |
Radek Krejci | e553e6d | 2019-06-07 15:33:18 +0200 | [diff] [blame] | 361 | if (ret) { |
| 362 | lyd_free_all(*result); |
| 363 | *result = NULL; |
| 364 | break; |
| 365 | } |
| 366 | } |
Radek Krejci | e92210c | 2019-05-17 15:53:35 +0200 | [diff] [blame] | 367 | } |
Radek Krejci | e553e6d | 2019-06-07 15:33:18 +0200 | [diff] [blame] | 368 | |
| 369 | ly_set_erase(&xmlctx.incomplete_type_validation, NULL); |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 370 | lyxml_context_clear((struct lyxml_context*)&xmlctx); |
| 371 | return ret; |
| 372 | } |