| /** |
| * @file xml.c |
| * @author Radek Krejci <rkrejci@cesnet.cz> |
| * @brief XML data parser for libyang |
| * |
| * Copyright (c) 2015 CESNET, z.s.p.o. |
| * |
| * This source code is licensed under BSD 3-Clause License (the "License"). |
| * You may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * https://opensource.org/licenses/BSD-3-Clause |
| */ |
| |
| #include <assert.h> |
| #include <ctype.h> |
| #include <errno.h> |
| #include <stdarg.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <limits.h> |
| |
| #include "libyang.h" |
| #include "common.h" |
| #include "context.h" |
| #include "parser.h" |
| #include "tree_internal.h" |
| #include "validation.h" |
| #include "xml_internal.h" |
| |
| /* does not log */ |
| static struct lys_node * |
| xml_data_search_schemanode(struct lyxml_elem *xml, struct lys_node *start, int options) |
| { |
| struct lys_node *result, *aux; |
| |
| LY_TREE_FOR(start, result) { |
| /* skip groupings ... */ |
| if (result->nodetype == LYS_GROUPING) { |
| continue; |
| /* ... and output in case of RPC ... */ |
| } else if (result->nodetype == LYS_OUTPUT && (options & LYD_OPT_RPC)) { |
| continue; |
| /* ... and input in case of RPC reply */ |
| } else if (result->nodetype == LYS_INPUT && (options & LYD_OPT_RPCREPLY)) { |
| continue; |
| } |
| |
| /* go into cases, choices, uses and in RPCs into input and output */ |
| if (result->nodetype & (LYS_CHOICE | LYS_CASE | LYS_USES | LYS_INPUT | LYS_OUTPUT)) { |
| aux = xml_data_search_schemanode(xml, result->child, options); |
| if (aux) { |
| /* we have matching result */ |
| return aux; |
| } |
| /* else, continue with next schema node */ |
| continue; |
| } |
| |
| /* match data nodes */ |
| if (ly_strequal(result->name, xml->name, 1)) { |
| /* names matches, what about namespaces? */ |
| if (ly_strequal(result->module->ns, xml->ns->value, 1)) { |
| /* we have matching result */ |
| return result; |
| } |
| /* else, continue with next schema node */ |
| continue; |
| } |
| } |
| |
| /* no match */ |
| return NULL; |
| } |
| |
| /* logs directly */ |
| static int |
| xml_get_value(struct lyd_node *node, struct lyxml_elem *xml, int options) |
| { |
| struct lyd_node_leaf_list *leaf = (struct lyd_node_leaf_list *)node; |
| int resolve; |
| |
| assert(node && (node->schema->nodetype & (LYS_LEAFLIST | LYS_LEAF)) && xml); |
| |
| leaf->value_str = xml->content; |
| xml->content = NULL; |
| |
| /* will be changed in case of union */ |
| leaf->value_type = ((struct lys_node_leaf *)node->schema)->type.base; |
| |
| if (options & (LYD_OPT_EDIT | LYD_OPT_GET | LYD_OPT_GETCONFIG)) { |
| resolve = 0; |
| } else { |
| resolve = 1; |
| } |
| |
| if ((leaf->value_type == LY_TYPE_IDENT) || (leaf->value_type == LY_TYPE_INST)) { |
| /* convert the path from the XML form using XML namespaces into the JSON format |
| * using module names as namespaces |
| */ |
| xml->content = leaf->value_str; |
| leaf->value_str = transform_xml2json(leaf->schema->module->ctx, xml->content, xml, 1); |
| lydict_remove(leaf->schema->module->ctx, xml->content); |
| xml->content = NULL; |
| if (!leaf->value_str) { |
| return EXIT_FAILURE; |
| } |
| } |
| |
| if (lyp_parse_value(leaf, xml, resolve)) { |
| return EXIT_FAILURE; |
| } |
| |
| return EXIT_SUCCESS; |
| } |
| |
| /* logs directly */ |
| static int |
| xml_parse_data(struct ly_ctx *ctx, struct lyxml_elem *xml, const struct lys_node *schema_parent, struct lyd_node *parent, |
| struct lyd_node *prev, int options, struct unres_data *unres, struct lyd_node **result) |
| { |
| struct lyd_node *diter, *dlast, *first_sibling; |
| struct lys_node *schema = NULL; |
| struct lyd_attr *dattr, *dattr_iter; |
| struct lyxml_attr *attr; |
| struct lyxml_elem *child, *next; |
| int i, havechildren, r, flag; |
| int ret = 0; |
| const char *str = NULL; |
| |
| assert(xml); |
| assert(result); |
| *result = NULL; |
| |
| if (!xml->ns || !xml->ns->value) { |
| if (options & LYD_OPT_STRICT) { |
| LOGVAL(LYE_XML_MISS, LY_VLOG_XML, xml, "element's", "namespace"); |
| return -1; |
| } else { |
| return 0; |
| } |
| } |
| |
| /* find schema node */ |
| if (schema_parent) { |
| schema = xml_data_search_schemanode(xml, schema_parent->child, options); |
| } else if (!parent) { |
| /* starting in root */ |
| for (i = 0; i < ctx->models.used; i++) { |
| /* match data model based on namespace */ |
| if (ly_strequal(ctx->models.list[i]->ns, xml->ns->value, 1)) { |
| /* get the proper schema node */ |
| LY_TREE_FOR(ctx->models.list[i]->data, schema) { |
| /* skip nodes in module's data which are not expected here according to options' data type */ |
| if (options & LYD_OPT_RPC) { |
| if (schema->nodetype != LYS_RPC) { |
| continue; |
| } |
| } else if (options & LYD_OPT_NOTIF) { |
| if (schema->nodetype != LYS_NOTIF) { |
| continue; |
| } |
| } else if (!(options & LYD_OPT_RPCREPLY)) { |
| /* rest of the data types except RPCREPLY which cannot be here */ |
| if (schema->nodetype & (LYS_RPC | LYS_NOTIF)) { |
| continue; |
| } |
| } |
| if (ly_strequal(schema->name, xml->name, 1)) { |
| break; |
| } |
| } |
| break; |
| } |
| } |
| } else { |
| /* parsing some internal node, we start with parent's schema pointer */ |
| schema = xml_data_search_schemanode(xml, parent->schema->child, options); |
| } |
| if (!schema) { |
| if ((options & LYD_OPT_STRICT) || ly_ctx_get_module_by_ns(ctx, xml->ns->value, NULL)) { |
| LOGVAL(LYE_INELEM, LY_VLOG_LYD, parent, xml->name); |
| return -1; |
| } else { |
| return 0; |
| } |
| } |
| |
| /* create the element structure */ |
| switch (schema->nodetype) { |
| case LYS_CONTAINER: |
| case LYS_LIST: |
| case LYS_NOTIF: |
| case LYS_RPC: |
| *result = calloc(1, sizeof **result); |
| havechildren = 1; |
| break; |
| case LYS_LEAF: |
| case LYS_LEAFLIST: |
| *result = calloc(1, sizeof(struct lyd_node_leaf_list)); |
| havechildren = 0; |
| break; |
| case LYS_ANYXML: |
| *result = calloc(1, sizeof(struct lyd_node_anyxml)); |
| havechildren = 0; |
| break; |
| default: |
| LOGINT; |
| return -1; |
| } |
| if (!(*result)) { |
| LOGMEM; |
| return -1; |
| } |
| |
| (*result)->parent = parent; |
| if (parent && !parent->child) { |
| parent->child = *result; |
| } |
| if (prev) { |
| (*result)->prev = prev; |
| prev->next = *result; |
| |
| /* fix the "last" pointer */ |
| if (parent) { |
| diter = parent->child; |
| } else { |
| for (diter = prev; diter->prev != prev; diter = diter->prev); |
| } |
| diter->prev = *result; |
| first_sibling = diter; |
| } else { |
| (*result)->prev = *result; |
| first_sibling = *result; |
| } |
| (*result)->schema = schema; |
| (*result)->validity = LYD_VAL_NOT; |
| if (resolve_applies_when(*result)) { |
| (*result)->when_status = LYD_WHEN; |
| } |
| |
| /* check insert attribute and its values */ |
| if (options & LYD_OPT_EDIT) { |
| /* 0x01 - insert attribute present |
| * 0x02 - insert is relative (before or after) |
| * 0x04 - value attribute present |
| * 0x08 - key attribute present |
| * 0x10 - operation not allowing insert attribute |
| */ |
| i = 0; |
| for (attr = xml->attr; attr; attr = attr->next) { |
| if (attr->type != LYXML_ATTR_STD || !attr->ns) { |
| /* not interesting attribute or namespace declaration */ |
| continue; |
| } |
| |
| if (!strcmp(attr->name, "operation") && !strcmp(attr->ns->value, LY_NSNC)) { |
| if (i & 0x10) { |
| LOGVAL(LYE_TOOMANY, LY_VLOG_LYD, (*result), "operation attributes", xml->name); |
| return -1; |
| } |
| |
| if (!strcmp(attr->value, "delete") || !strcmp(attr->value, "remove")) { |
| i |= 0x10; |
| } else if (strcmp(attr->value, "create") && |
| strcmp(attr->value, "merge") && |
| strcmp(attr->value, "replace")) { |
| /* unknown operation */ |
| LOGVAL(LYE_INVALATTR, LY_VLOG_LYD, (*result), attr->value, attr->name); |
| return -1; |
| } |
| } else if (!strcmp(attr->name, "insert") && !strcmp(attr->ns->value, LY_NSYANG)) { |
| /* 'insert' attribute present */ |
| if (!(schema->flags & LYS_USERORDERED)) { |
| /* ... but it is not expected */ |
| LOGVAL(LYE_INATTR, LY_VLOG_LYD, (*result), "insert", schema->name); |
| return -1; |
| } |
| |
| if (i & 0x01) { |
| LOGVAL(LYE_TOOMANY, LY_VLOG_LYD, (*result), "insert attributes", xml->name); |
| return -1; |
| } |
| if (!strcmp(attr->value, "first") || !strcmp(attr->value, "last")) { |
| i |= 0x01; |
| } else if (!strcmp(attr->value, "before") || !strcmp(attr->value, "after")) { |
| i |= 0x01 | 0x02; |
| } else { |
| LOGVAL(LYE_INVALATTR, LY_VLOG_LYD, (*result), attr->value, attr->name); |
| return -1; |
| } |
| str = attr->name; |
| } else if (!strcmp(attr->name, "value") && !strcmp(attr->ns->value, LY_NSYANG)) { |
| if (i & 0x04) { |
| LOGVAL(LYE_TOOMANY, LY_VLOG_LYD, (*result), "value attributes", xml->name); |
| return -1; |
| } else if (schema->nodetype & LYS_LIST) { |
| LOGVAL(LYE_INATTR, LY_VLOG_LYD, (*result), attr->name, schema->name); |
| return -1; |
| } |
| i |= 0x04; |
| str = attr->name; |
| } else if (!strcmp(attr->name, "key") && !strcmp(attr->ns->value, LY_NSYANG)) { |
| if (i & 0x08) { |
| LOGVAL(LYE_TOOMANY, LY_VLOG_LYD, (*result), "key attributes", xml->name); |
| return -1; |
| } else if (schema->nodetype & LYS_LEAFLIST) { |
| LOGVAL(LYE_INATTR, LY_VLOG_LYD, (*result), attr->name, schema->name); |
| return -1; |
| } |
| i |= 0x08; |
| str = attr->name; |
| } |
| } |
| |
| /* report errors */ |
| if (i > 0x10 || (i && i < 0x10 && |
| (!(schema->nodetype & (LYS_LEAFLIST | LYS_LIST)) || !(schema->flags & LYS_USERORDERED)))) { |
| /* attributes in wrong elements */ |
| LOGVAL(LYE_INATTR, LY_VLOG_LYD, (*result), str, xml->name); |
| return -1; |
| } else if (i == 3) { |
| /* 0x01 | 0x02 - relative position, but value/key is missing */ |
| if (schema->nodetype & LYS_LIST) { |
| LOGVAL(LYE_MISSATTR, LY_VLOG_LYD, (*result), "key", xml->name); |
| } else { /* LYS_LEAFLIST */ |
| LOGVAL(LYE_MISSATTR, LY_VLOG_LYD, (*result), "value", xml->name); |
| } |
| return -1; |
| } else if ((i & (0x04 | 0x08)) && !(i & 0x02)) { |
| /* key/value without relative position */ |
| LOGVAL(LYE_INATTR, LY_VLOG_LYD, (*result), (i & 0x04) ? "value" : "key", schema->name); |
| return -1; |
| } |
| } |
| |
| /* type specific processing */ |
| if (schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) { |
| /* type detection and assigning the value */ |
| if (xml_get_value(*result, xml, options)) { |
| goto error; |
| } |
| } else if (schema->nodetype == LYS_ANYXML) { |
| /* store children values */ |
| if (xml->child) { |
| child = xml->child; |
| /* manually unlink all siblings and correct namespaces */ |
| xml->child = NULL; |
| LY_TREE_FOR(child, next) { |
| next->parent = NULL; |
| lyxml_correct_elem_ns(ctx, next, 1, 1); |
| } |
| |
| ((struct lyd_node_anyxml *)*result)->xml_struct = 1; |
| ((struct lyd_node_anyxml *)*result)->value.xml = child; |
| } else { |
| ((struct lyd_node_anyxml *)*result)->xml_struct = 0; |
| ((struct lyd_node_anyxml *)*result)->value.str = lydict_insert(ctx, xml->content, 0); |
| } |
| } |
| |
| /* first part of validation checks */ |
| if (!(options & LYD_OPT_TRUSTED) && lyv_data_context(*result, options, unres)) { |
| goto error; |
| } |
| |
| for (attr = xml->attr; attr; attr = attr->next) { |
| flag = 0; |
| if (attr->type != LYXML_ATTR_STD) { |
| continue; |
| } else if (!attr->ns) { |
| if ((*result)->schema->nodetype != LYS_ANYXML || |
| !ly_strequal((*result)->schema->name, "filter", 0) || |
| !ly_strequal((*result)->schema->module->name, "ietf-netconf", 0)) { |
| if (options & LYD_OPT_STRICT) { |
| LOGVAL(LYE_INATTR, LY_VLOG_LYD, (*result), attr->name, xml->name); |
| LOGVAL(LYE_SPEC, LY_VLOG_LYD, (*result), "Attribute \"%s\" with no namespace (schema).", |
| attr->name); |
| goto error; |
| } else { |
| LOGWRN("Ignoring \"%s\" attribute in \"%s\" element.", attr->name, xml->name); |
| continue; |
| } |
| } else { |
| /* exception for filter's attributes */ |
| flag = 1; |
| } |
| } |
| |
| dattr = malloc(sizeof *dattr); |
| if (!dattr) { |
| goto error; |
| } |
| dattr->next = NULL; |
| dattr->name = attr->name; |
| if (flag && ly_strequal(attr->name, "select", 0)) { |
| dattr->value = transform_xml2json(ctx, attr->value, xml, 1); |
| if (!dattr->value) { |
| free(dattr); |
| goto error; |
| } |
| lydict_remove(ctx, attr->value); |
| } else { |
| dattr->value = attr->value; |
| } |
| attr->name = NULL; |
| attr->value = NULL; |
| |
| if (!attr->ns) { |
| /* filter's attributes, it actually has no namespace, but we need some for internal representation */ |
| dattr->module = (*result)->schema->module; |
| } else { |
| dattr->module = (struct lys_module *)ly_ctx_get_module_by_ns(ctx, attr->ns->value, NULL); |
| } |
| if (!dattr->module) { |
| free(dattr); |
| if (options & LYD_OPT_STRICT) { |
| LOGVAL(LYE_INATTR, LY_VLOG_LYD, (*result), attr->name, xml->name); |
| LOGVAL(LYE_SPEC, LY_VLOG_LYD, (*result), "Attribute \"%s\" from unknown schema (\"%s\").", |
| attr->name, attr->ns->value); |
| goto error; |
| } else { |
| LOGWRN("Attribute \"%s\" from unknown schema (\"%s\") - skipping.", attr->name, attr->ns->value); |
| continue; |
| } |
| } |
| |
| if (!(*result)->attr) { |
| (*result)->attr = dattr; |
| } else { |
| for (dattr_iter = (*result)->attr; dattr_iter->next; dattr_iter = dattr_iter->next); |
| dattr_iter->next = dattr; |
| } |
| } |
| |
| /* process children */ |
| if (havechildren && xml->child) { |
| diter = dlast = NULL; |
| LY_TREE_FOR_SAFE(xml->child, next, child) { |
| if (schema->nodetype & (LYS_RPC | LYS_NOTIF)) { |
| r = xml_parse_data(ctx, child, NULL, *result, dlast, 0, unres, &diter); |
| } else { |
| r = xml_parse_data(ctx, child, NULL, *result, dlast, options, unres, &diter); |
| } |
| if (r) { |
| goto error; |
| } else if (options & LYD_OPT_DESTRUCT) { |
| lyxml_free(ctx, child); |
| } |
| if (diter) { |
| dlast = diter; |
| } |
| } |
| } |
| |
| /* if we have empty non-presence container, we can remove it */ |
| if (!(options & LYD_OPT_KEEPEMPTYCONT) && schema->nodetype == LYS_CONTAINER && !(*result)->child && |
| !(*result)->attr && !((struct lys_node_container *)schema)->presence) { |
| goto clear; |
| } |
| |
| /* rest of validation checks */ |
| ly_errno = 0; |
| if (!(options & LYD_OPT_TRUSTED) && |
| (lyv_data_content(*result, options, unres) || |
| lyv_multicases(*result, NULL, first_sibling == *result ? NULL : first_sibling, 0, NULL))) { |
| if (ly_errno) { |
| goto error; |
| } else { |
| goto clear; |
| } |
| } |
| |
| /* validation successful */ |
| (*result)->validity = LYD_VAL_OK; |
| |
| return ret; |
| |
| error: |
| ret--; |
| |
| clear: |
| /* cleanup */ |
| for (i = unres->count - 1; i >= 0; i--) { |
| /* remove unres items connected with the node being removed */ |
| if (unres->node[i] == *result) { |
| unres_data_del(unres, i); |
| } |
| } |
| lyd_free(*result); |
| *result = NULL; |
| |
| return ret; |
| } |
| |
| API struct lyd_node * |
| lyd_parse_xml(struct ly_ctx *ctx, struct lyxml_elem **root, int options, ...) |
| { |
| va_list ap; |
| int r; |
| struct unres_data *unres = NULL; |
| struct lys_node *rpc = NULL; |
| struct lyd_node *result = NULL, *iter, *last; |
| struct lyxml_elem *xmlstart, *xmlelem, *xmlaux; |
| |
| ly_errno = LY_SUCCESS; |
| |
| if (!ctx || !root) { |
| LOGERR(LY_EINVAL, "%s: Invalid parameter.", __func__); |
| return NULL; |
| } |
| |
| if (lyp_check_options(options)) { |
| LOGERR(LY_EINVAL, "%s: Invalid options (multiple data type flags set).", __func__); |
| return NULL; |
| } |
| |
| if (!(*root)) { |
| /* empty tree - no work is needed */ |
| lyd_validate(&result, options, ctx); |
| return result; |
| } |
| |
| unres = calloc(1, sizeof *unres); |
| if (!unres) { |
| LOGMEM; |
| return NULL; |
| } |
| |
| va_start(ap, options); |
| if (options & LYD_OPT_RPCREPLY) { |
| rpc = va_arg(ap, struct lys_node*); |
| if (!rpc || (rpc->nodetype != LYS_RPC)) { |
| LOGERR(LY_EINVAL, "%s: Invalid parameter.", __func__); |
| goto error; |
| } |
| } |
| |
| if (!(options & LYD_OPT_NOSIBLINGS)) { |
| /* locate the first root to process */ |
| if ((*root)->parent) { |
| xmlstart = (*root)->parent->child; |
| } else { |
| xmlstart = *root; |
| while(xmlstart->prev->next) { |
| xmlstart = xmlstart->prev; |
| } |
| } |
| } else { |
| xmlstart = *root; |
| } |
| iter = result = last = NULL; |
| |
| LY_TREE_FOR_SAFE(xmlstart, xmlaux, xmlelem) { |
| r = xml_parse_data(ctx, xmlelem, rpc, NULL, last, options, unres, &iter); |
| if (r) { |
| goto error; |
| } else if (options & LYD_OPT_DESTRUCT) { |
| lyxml_free(ctx, xmlelem); |
| *root = xmlaux; |
| } |
| if (iter) { |
| last = iter; |
| } |
| if (!result) { |
| result = iter; |
| } |
| |
| if (options & LYD_OPT_NOSIBLINGS) { |
| /* stop after the first processed root */ |
| break; |
| } |
| } |
| |
| if (options & LYD_OPT_RPCREPLY) { |
| last = result; |
| result = lyd_new_output(NULL, lys_node_module(rpc), rpc->name); |
| /* insert all the output parameters into RPC */ |
| do { |
| iter = last; |
| last = iter->next; |
| if (lyd_insert(result, iter)) { |
| LOGINT; |
| lyd_free_withsiblings(last); |
| goto error; |
| } |
| } while (last); |
| } |
| |
| /* check for missing top level mandatory nodes */ |
| if (lyd_check_topmandatory(result, ctx, options)) { |
| goto error; |
| } |
| |
| /* add/validate default values, unres */ |
| if (lyd_defaults_add_unres(&result, options, ctx, unres)) { |
| goto error; |
| } |
| |
| free(unres->node); |
| free(unres->type); |
| free(unres); |
| va_end(ap); |
| |
| return result; |
| |
| error: |
| lyd_free_withsiblings(result); |
| free(unres->node); |
| free(unres->type); |
| free(unres); |
| va_end(ap); |
| |
| return NULL; |
| } |