/** * @file tree_schema.c * @author Radek Krejci * @brief Schema tree implementation * * Copyright (c) 2015 - 2018 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 */ #define _GNU_SOURCE /* asprintf, strdup */ #include "tree_schema.h" #include #include #include #include #include #include #include #include #include #include #include "common.h" #include "compat.h" #include "context.h" #include "dict.h" #include "in.h" #include "in_internal.h" #include "log.h" #include "parser_internal.h" #include "parser_schema.h" #include "path.h" #include "plugins_internal.h" #include "schema_compile.h" #include "schema_compile_amend.h" #include "schema_features.h" #include "set.h" #include "tree.h" #include "tree_edit.h" #include "tree_schema_free.h" #include "tree_schema_internal.h" #include "xpath.h" const char * const ly_devmod_list[] = { [LYS_DEV_NOT_SUPPORTED] = "not-supported", [LYS_DEV_ADD] = "add", [LYS_DEV_DELETE] = "delete", [LYS_DEV_REPLACE] = "replace", }; LIBYANG_API_DEF LY_ERR lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data) { struct lysc_node *elem, *elem2; const struct lysc_node_action *action; const struct lysc_node_notif *notif; LY_CHECK_ARG_RET(NULL, root, dfs_clb, LY_EINVAL); LYSC_TREE_DFS_BEGIN(root, elem) { /* schema node */ LY_CHECK_RET(dfs_clb(elem, data, &LYSC_TREE_DFS_continue)); LY_LIST_FOR(lysc_node_actions(elem), action) { LYSC_TREE_DFS_BEGIN(action, elem2) { /* action subtree */ LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue)); LYSC_TREE_DFS_END(action, elem2); } } LY_LIST_FOR(lysc_node_notifs(elem), notif) { LYSC_TREE_DFS_BEGIN(notif, elem2) { /* notification subtree */ LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue)); LYSC_TREE_DFS_END(notif, elem2); } } LYSC_TREE_DFS_END(root, elem); } return LY_SUCCESS; } LIBYANG_API_DEF LY_ERR lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data) { const struct lysc_node *root; LY_CHECK_ARG_RET(NULL, mod, mod->compiled, dfs_clb, LY_EINVAL); /* schema nodes */ LY_LIST_FOR(mod->compiled->data, root) { LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data)); } /* RPCs */ LY_LIST_FOR((const struct lysc_node *)mod->compiled->rpcs, root) { LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data)); } /* notifications */ LY_LIST_FOR((const struct lysc_node *)mod->compiled->notifs, root) { LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data)); } return LY_SUCCESS; } static void lys_getnext_into_case(const struct lysc_node_case *first_case, const struct lysc_node **last, const struct lysc_node **next) { for ( ; first_case; first_case = (const struct lysc_node_case *)first_case->next) { if (first_case->child) { /* there is something to return */ (*next) = first_case->child; return; } } /* no children in choice's cases, so go to the choice's sibling instead of into it */ (*last) = (*next); (*next) = (*next)->next; } /** * @brief Generic getnext function for ::lys_getnext() and ::lys_getnext_ext(). * * Gets next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can * be from an augment. If the @p ext is provided, the function is locked inside the schema tree defined in the * extension instance. * * ::lys_getnext_() is supposed to be called sequentially. In the first call, the @p last parameter is usually NULL * and function starts returning i) the first @p parent's child or ii) the first top level element specified in the * given extension (if provided) or iii) the first top level element of the @p module. * Consequent calls suppose to provide the previously returned node as the @p last parameter and still the same * @p parent and @p module parameters. * * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding * data nodes in a data tree. By setting some @p options the behavior can be modified to the extent that * all the schema nodes are iteratively returned. * * @param[in] last Previously returned schema tree node, or NULL in case of the first call. * @param[in] parent Parent of the subtree where the function starts processing. * @param[in] module In case of iterating on top level elements, the @p parent is NULL and * module must be specified. * @param[in] ext The extension instance to provide a separate schema tree. To consider the top level elements in the tree, * the @p parent must be NULL. Anyway, at least one of @p parent, @p module and @p ext parameters must be specified. * @param[in] options [ORed options](@ref sgetnextflags). * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element. */ static const struct lysc_node * lys_getnext_(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, const struct lysc_ext_instance *ext, uint32_t options) { const struct lysc_node *next = NULL; ly_bool action_flag = 0, notif_flag = 0; LY_CHECK_ARG_RET(NULL, parent || module || ext, NULL); next: if (!last) { /* first call */ /* get know where to start */ if (parent) { /* schema subtree */ next = last = lysc_node_child(parent); } else { /* top level data */ if (ext) { lyplg_ext_get_storage(ext, LY_STMT_DATA_NODE_MASK, sizeof last, (const void **)&last); next = last; } else { next = last = module->data; } } if (!next) { /* try to get action or notification */ goto repeat; } /* test if the next can be returned */ goto check; } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) { action_flag = 1; next = last->next; } else if (last->nodetype == LYS_NOTIF) { action_flag = notif_flag = 1; next = last->next; } else { next = last->next; } repeat: if (!next) { /* possibly go back to parent */ if (last && (last->parent != parent)) { last = last->parent; goto next; } else if (!action_flag) { action_flag = 1; if (ext) { lyplg_ext_get_storage(ext, LY_STMT_OP_MASK, sizeof next, (const void **)&next); } else if (parent) { next = (struct lysc_node *)lysc_node_actions(parent); } else { next = (struct lysc_node *)module->rpcs; } } else if (!notif_flag) { notif_flag = 1; if (ext) { lyplg_ext_get_storage(ext, LY_STMT_NOTIFICATION, sizeof next, (const void **)&next); } else if (parent) { next = (struct lysc_node *)lysc_node_notifs(parent); } else { next = (struct lysc_node *)module->notifs; } } else { return NULL; } goto repeat; } check: switch (next->nodetype) { case LYS_RPC: case LYS_ACTION: case LYS_NOTIF: case LYS_LEAF: case LYS_ANYXML: case LYS_ANYDATA: case LYS_LIST: case LYS_LEAFLIST: break; case LYS_CASE: if (options & LYS_GETNEXT_WITHCASE) { break; } else { /* go into */ lys_getnext_into_case((const struct lysc_node_case *)next, &last, &next); } goto repeat; case LYS_CONTAINER: if (!(next->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) { if (lysc_node_child(next)) { /* go into */ next = lysc_node_child(next); } else { last = next; next = next->next; } goto repeat; } break; case LYS_CHOICE: if (options & LYS_GETNEXT_WITHCHOICE) { break; } else if ((options & LYS_GETNEXT_NOCHOICE) || !lysc_node_child(next)) { next = next->next; } else { if (options & LYS_GETNEXT_WITHCASE) { next = lysc_node_child(next); } else { /* go into */ lys_getnext_into_case(((struct lysc_node_choice *)next)->cases, &last, &next); } } goto repeat; case LYS_INPUT: if (options & LYS_GETNEXT_OUTPUT) { /* skip */ next = next->next; } else { /* go into */ next = lysc_node_child(next); } goto repeat; case LYS_OUTPUT: if (!(options & LYS_GETNEXT_OUTPUT)) { /* skip */ next = next->next; } else { /* go into */ next = lysc_node_child(next); } goto repeat; default: /* we should not be here */ LOGINT(module ? module->mod->ctx : parent ? parent->module->ctx : ext->module->ctx); return NULL; } return next; } LIBYANG_API_DEF const struct lysc_node * lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, uint32_t options) { return lys_getnext_(last, parent, module, NULL, options); } LIBYANG_API_DEF const struct lysc_node * lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_ext_instance *ext, uint32_t options) { return lys_getnext_(last, parent, NULL, ext, options); } const struct lysc_node * lysc_ext_find_node(const struct lysc_ext_instance *ext, const struct lys_module *module, const char *name, size_t name_len, uint16_t nodetype, uint32_t options) { const struct lysc_node *node = NULL; LY_CHECK_ARG_RET(NULL, ext, name, NULL); if (!nodetype) { nodetype = LYS_NODETYPE_MASK; } if (module && (module != ext->module)) { return NULL; } while ((node = lys_getnext_ext(node, NULL, ext, options))) { if (!(node->nodetype & nodetype)) { continue; } if (name_len) { if (!ly_strncmp(node->name, name, name_len)) { return node; } } else { if (!strcmp(node->name, name)) { return node; } } } return NULL; } LIBYANG_API_DEF const struct lysc_node * lys_find_child(const struct lysc_node *parent, const struct lys_module *module, const char *name, size_t name_len, uint16_t nodetype, uint32_t options) { const struct lysc_node *node = NULL; LY_CHECK_ARG_RET(NULL, module, name, NULL); LY_CHECK_CTX_EQUAL_RET(parent ? parent->module->ctx : NULL, module->ctx, NULL); if (!nodetype) { nodetype = LYS_NODETYPE_MASK; } while ((node = lys_getnext(node, parent, module->compiled, options))) { if (!(node->nodetype & nodetype)) { continue; } if (node->module != module) { continue; } if (name_len) { if (!ly_strncmp(node->name, name, name_len)) { return node; } } else { if (!strcmp(node->name, name)) { return node; } } } return NULL; } LIBYANG_API_DEF LY_ERR lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options, struct ly_set **set) { LY_ERR ret = LY_SUCCESS; struct lyxp_set xp_set; struct lyxp_expr *exp = NULL; uint32_t i; LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL); LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL); if (!(options & LYXP_SCNODE_ALL)) { options |= LYXP_SCNODE; } if (!ctx) { ctx = ctx_node->module->ctx; } memset(&xp_set, 0, sizeof xp_set); /* compile expression */ ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp); LY_CHECK_GOTO(ret, cleanup); /* atomize expression */ ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, ctx_node, &xp_set, options); LY_CHECK_GOTO(ret, cleanup); /* allocate return set */ ret = ly_set_new(set); LY_CHECK_GOTO(ret, cleanup); /* transform into ly_set */ (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs); LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup); (*set)->size = xp_set.used; for (i = 0; i < xp_set.used; ++i) { if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) { ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL); LY_CHECK_GOTO(ret, cleanup); } } cleanup: lyxp_set_free_content(&xp_set); lyxp_expr_free(ctx, exp); return ret; } LIBYANG_API_DEF LY_ERR lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr, const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set) { LY_ERR ret = LY_SUCCESS; struct lyxp_set xp_set = {0}; uint32_t i; LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL); LY_CHECK_CTX_EQUAL_RET(ctx_node ? ctx_node->module->ctx : NULL, cur_mod->ctx, LY_EINVAL); if (!(options & LYXP_SCNODE_ALL)) { options = LYXP_SCNODE; } /* atomize expression */ ret = lyxp_atomize(cur_mod->ctx, expr, cur_mod, LY_VALUE_SCHEMA_RESOLVED, (void *)prefixes, ctx_node, ctx_node, &xp_set, options); LY_CHECK_GOTO(ret, cleanup); /* allocate return set */ ret = ly_set_new(set); LY_CHECK_GOTO(ret, cleanup); /* transform into ly_set */ (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs); LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup); (*set)->size = xp_set.used; for (i = 0; i < xp_set.used; ++i) { if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM_NODE)) { assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) || (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL) || (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX)); ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL); LY_CHECK_GOTO(ret, cleanup); } } cleanup: lyxp_set_free_content(&xp_set); if (ret) { ly_set_free(*set, NULL); *set = NULL; } return ret; } LIBYANG_API_DEF LY_ERR lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options, struct ly_set **set) { LY_ERR ret = LY_SUCCESS; struct lyxp_set xp_set = {0}; struct lyxp_expr *exp = NULL; uint32_t i; LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL); LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL); if (!(options & LYXP_SCNODE_ALL)) { options = LYXP_SCNODE; } if (!ctx) { ctx = ctx_node->module->ctx; } /* compile expression */ ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp); LY_CHECK_GOTO(ret, cleanup); /* atomize expression */ ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, ctx_node, &xp_set, options); LY_CHECK_GOTO(ret, cleanup); /* allocate return set */ ret = ly_set_new(set); LY_CHECK_GOTO(ret, cleanup); /* transform into ly_set */ (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs); LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup); (*set)->size = xp_set.used; for (i = 0; i < xp_set.used; ++i) { if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX)) { ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL); LY_CHECK_GOTO(ret, cleanup); } } cleanup: lyxp_set_free_content(&xp_set); lyxp_expr_free(ctx, exp); if (ret) { ly_set_free(*set, NULL); *set = NULL; } return ret; } LIBYANG_API_DEF LY_ERR lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set) { LY_ERR ret = LY_SUCCESS; LY_ARRAY_COUNT_TYPE u, v; LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL); /* allocate return set */ LY_CHECK_RET(ly_set_new(set)); LY_ARRAY_FOR(path, u) { /* add nodes from the path */ LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup); if (path[u].pred_type == LY_PATH_PREDTYPE_LIST) { LY_ARRAY_FOR(path[u].predicates, v) { /* add all the keys in a predicate */ LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup); } } } cleanup: if (ret) { ly_set_free(*set, NULL); *set = NULL; } return ret; } LIBYANG_API_DEF LY_ERR lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output, struct ly_set **set) { LY_ERR ret = LY_SUCCESS; uint8_t oper; struct lyxp_expr *expr = NULL; struct ly_path *p = NULL; LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL); LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL); if (!ctx) { ctx = ctx_node->module->ctx; } /* parse */ ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &expr); LY_CHECK_GOTO(ret, cleanup); /* compile */ oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT; ret = ly_path_compile(ctx, NULL, ctx_node, NULL, expr, oper, LY_PATH_TARGET_MANY, 0, LY_VALUE_JSON, NULL, &p); LY_CHECK_GOTO(ret, cleanup); /* resolve */ ret = lys_find_lypath_atoms(p, set); cleanup: ly_path_free(ctx, p); lyxp_expr_free(ctx, expr); return ret; } LIBYANG_API_DEF const struct lysc_node * lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output) { const struct lysc_node *snode = NULL; struct lyxp_expr *exp = NULL; struct ly_path *p = NULL; LY_ERR ret; uint8_t oper; LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL); LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, NULL); if (!ctx) { ctx = ctx_node->module->ctx; } /* parse */ ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp); LY_CHECK_GOTO(ret, cleanup); /* compile */ oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT; ret = ly_path_compile(ctx, NULL, ctx_node, NULL, exp, oper, LY_PATH_TARGET_MANY, 0, LY_VALUE_JSON, NULL, &p); LY_CHECK_GOTO(ret, cleanup); /* get last node */ snode = p[LY_ARRAY_COUNT(p) - 1].node; cleanup: ly_path_free(ctx, p); lyxp_expr_free(ctx, exp); return snode; } char * lysc_path_until(const struct lysc_node *node, const struct lysc_node *parent, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen) { const struct lysc_node *iter, *par, *key; char *path = NULL; int len = 0; ly_bool skip_schema; if (buffer) { LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL); buffer[0] = '\0'; } if ((pathtype == LYSC_PATH_DATA) || (pathtype == LYSC_PATH_DATA_PATTERN)) { /* skip schema-only nodes */ skip_schema = 1; } else { skip_schema = 0; } for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) { char *s; const char *slash; if (skip_schema && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) { /* schema-only node */ continue; } if ((pathtype == LYSC_PATH_DATA_PATTERN) && (iter->nodetype == LYS_LIST)) { key = NULL; while ((key = lys_getnext(key, iter, NULL, 0)) && lysc_is_key(key)) { s = buffer ? strdup(buffer) : path; /* print key predicate */ if (buffer) { len = snprintf(buffer, buflen, "[%s='%%s']%s", key->name, s ? s : ""); } else { len = asprintf(&path, "[%s='%%s']%s", key->name, s ? s : ""); } free(s); if (buffer && (buflen <= (size_t)len)) { /* not enough space in buffer */ break; } } } s = buffer ? strdup(buffer) : path; if (parent && (iter->parent == parent)) { slash = ""; } else { slash = "/"; } if (skip_schema) { par = lysc_data_parent(iter); } else { par = iter->parent; } if (!par || (par->module != iter->module)) { /* print prefix */ if (buffer) { len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, iter->name, s ? s : ""); } else { len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, iter->name, s ? s : ""); } } else { /* prefix is the same as in parent */ if (buffer) { len = snprintf(buffer, buflen, "%s%s%s", slash, iter->name, s ? s : ""); } else { len = asprintf(&path, "%s%s%s", slash, iter->name, s ? s : ""); } } free(s); if (buffer && (buflen <= (size_t)len)) { /* not enough space in buffer */ break; } } if (len < 0) { free(path); path = NULL; } else if (len == 0) { if (buffer) { strcpy(buffer, "/"); } else { path = strdup("/"); } } if (buffer) { return buffer; } else { return path; } } LIBYANG_API_DEF char * lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen) { return lysc_path_until(node, NULL, pathtype, buffer, buflen); } LY_ERR _lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres) { LY_ERR ret = LY_SUCCESS, r; struct lys_module *mod_iter; const char **imp_f, *all_f[] = {"*", NULL}; uint32_t i; if (mod->implemented) { /* mod is already implemented, set the features */ r = lys_set_features(mod->parsed, features); if (r == LY_EEXIST) { /* no changes */ return LY_SUCCESS; } else if (!r) { /* mark the module as changed */ mod->to_compile = 1; } return r; } /* implement, ignore recompilation because it must always take place later */ r = lys_implement(mod, features, unres); LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup); if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) { /* implement all the imports as well */ for (i = 0; i < unres->creating.count; ++i) { mod = unres->creating.objs[i]; if (mod->implemented) { continue; } imp_f = (mod->ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL; r = lys_implement(mod, imp_f, unres); LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup); } } /* Try to find module with LYS_MOD_IMPORTED_REV flag. */ i = 0; while ((mod_iter = ly_ctx_get_module_iter(mod->ctx, &i))) { if (!strcmp(mod_iter->name, mod->name) && (mod_iter != mod) && (mod_iter->latest_revision & LYS_MOD_IMPORTED_REV)) { LOGVRB("Implemented module \"%s@%s\" was not and will not be imported if the revision-date is missing" " in the import statement. Instead, the revision \"%s\" is imported.", mod->name, mod->revision, mod_iter->revision); break; } } cleanup: return ret; } /** * @brief Check whether it may be needed to (re)compile a module from a particular dependency set * and if so, add it into its dep set. * * Dependency set includes all modules that need to be (re)compiled in case any of the module(s) * in the dep set are (re)compiled. * * The reason for recompilation is possible disabled nodes and updating * leafref targets to point to the newly compiled modules. Using the import relation, the * dependency is reflexive because of possible foreign augments and deviations, which are compiled * during the target module compilation. * * - every module must belong to exactly one dep set * - implement flag must be ignored because it can be changed during dep set compilation * * @param[in] mod Module to process. * @param[in,out] ctx_set Set with all not-yet-processed modules. * @param[in,out] dep_set Current dependency set to update. * @param[in] aux_set Set of traversed non-compiled modules, should be empty on first call. * @return LY_ERR value. */ static LY_ERR lys_unres_dep_sets_create_mod_r(struct lys_module *mod, struct ly_set *ctx_set, struct ly_set *dep_set, struct ly_set *aux_set) { struct lys_module *mod2; struct lysp_import *imports; uint32_t i; LY_ARRAY_COUNT_TYPE u, v; ly_bool found; if (LYS_IS_SINGLE_DEP_SET(mod)) { /* is already in a separate dep set */ if (!lys_has_dep_mods(mod)) { /* break the dep set here, no modules depend on this one */ return LY_SUCCESS; } if (ly_set_contains(aux_set, mod, NULL)) { /* it was traversed */ return LY_SUCCESS; } /* add a new auxiliary module */ LY_CHECK_RET(ly_set_add(aux_set, mod, 1, NULL)); } else { if (!ly_set_contains(ctx_set, mod, &i)) { /* it was already processed */ return LY_SUCCESS; } /* remove it from the set, we are processing it now */ ly_set_rm_index(ctx_set, i, NULL); /* add a new dependent module into the dep set */ LY_CHECK_RET(ly_set_add(dep_set, mod, 1, NULL)); } /* process imports of the module and submodules */ imports = mod->parsed->imports; LY_ARRAY_FOR(imports, u) { mod2 = imports[u].module; LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set)); } LY_ARRAY_FOR(mod->parsed->includes, v) { imports = mod->parsed->includes[v].submodule->imports; LY_ARRAY_FOR(imports, u) { mod2 = imports[u].module; if (LYS_IS_SINGLE_DEP_SET(mod2) && !lys_has_dep_mods(mod2)) { /* break the dep set here, no modules depend on this one */ continue; } LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(imports[u].module, ctx_set, dep_set, aux_set)); } } /* process modules and submodules importing this module */ for (i = 0; i < mod->ctx->list.count; ++i) { mod2 = mod->ctx->list.objs[i]; found = 0; imports = mod2->parsed->imports; LY_ARRAY_FOR(imports, u) { if (imports[u].module == mod) { found = 1; break; } } if (!found) { LY_ARRAY_FOR(mod2->parsed->includes, v) { imports = mod2->parsed->includes[v].submodule->imports; LY_ARRAY_FOR(imports, u) { if (imports[u].module == mod) { found = 1; break; } } if (found) { break; } } } if (found) { LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set)); } } return LY_SUCCESS; } /** * @brief Add all simple modules (that have nothing to (re)compile) into separate dep sets. * * @param[in,out] ctx_set Set with all not-yet-processed modules. * @param[in,out] main_set Set of dependency module sets. * @return LY_ERR value. */ static LY_ERR lys_unres_dep_sets_create_single(struct ly_set *ctx_set, struct ly_set *main_set) { LY_ERR ret = LY_SUCCESS; struct lys_module *m; uint32_t i = 0; struct ly_set *dep_set = NULL; while (i < ctx_set->count) { m = ctx_set->objs[i]; if (LYS_IS_SINGLE_DEP_SET(m)) { /* remove it from the set, we are processing it now */ ly_set_rm_index(ctx_set, i, NULL); /* this module can be in a separate dep set (but there still may be modules importing this one * that depend on imports of this one in case it defines groupings) */ LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup); LY_CHECK_GOTO(ret = ly_set_add(dep_set, m, 1, NULL), cleanup); LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup); dep_set = NULL; } else { ++i; } } cleanup: ly_set_free(dep_set, NULL); return ret; } LY_ERR lys_unres_dep_sets_create(struct ly_ctx *ctx, struct ly_set *main_set, struct lys_module *mod) { LY_ERR ret = LY_SUCCESS; struct lys_module *m; struct ly_set *dep_set = NULL, *ctx_set = NULL, aux_set = {0}; uint32_t i; ly_bool found; assert(!main_set->count); /* start with a duplicate set of modules that we will remove from */ LY_CHECK_GOTO(ret = ly_set_dup(&ctx->list, NULL, &ctx_set), cleanup); /* first create all dep sets with single modules */ LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_single(ctx_set, main_set), cleanup); if (mod && !ly_set_contains(ctx_set, mod, NULL)) { /* dep set for this module has already been created, nothing else to do */ goto cleanup; } while (ctx_set->count) { /* create new dep set */ LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup); if (mod) { /* use the module create a dep set with the rest of its dependent modules */ LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_mod_r(mod, ctx_set, dep_set, &aux_set), cleanup); } else { /* use first ctx mod to create a dep set with the rest of its dependent modules */ LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_mod_r(ctx_set->objs[0], ctx_set, dep_set, &aux_set), cleanup); } ly_set_erase(&aux_set, NULL); assert(dep_set->count); /* check whether there is any module that will be (re)compiled */ found = 0; for (i = 0; i < dep_set->count; ++i) { m = dep_set->objs[i]; if (m->to_compile) { found = 1; break; } } if (found) { /* if there is, all the implemented modules need to be recompiled */ for (i = 0; i < dep_set->count; ++i) { m = dep_set->objs[i]; if (m->implemented) { m->to_compile = 1; } } } /* add the dep set into main set */ LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup); dep_set = NULL; if (mod) { /* we need dep set only for this module */ break; } } #ifndef NDEBUG LOGDBG(LY_LDGDEPSETS, "dep sets created (%" PRIu32 "):", main_set->count); for (i = 0; i < main_set->count; ++i) { struct ly_set *iter_set = main_set->objs[i]; LOGDBG(LY_LDGDEPSETS, "dep set #%" PRIu32 ":", i); for (uint32_t j = 0; j < iter_set->count; ++j) { m = iter_set->objs[j]; LOGDBG(LY_LDGDEPSETS, "\t%s", m->name); } } #endif cleanup: assert(ret || main_set->objs); ly_set_erase(&aux_set, NULL); ly_set_free(dep_set, NULL); ly_set_free(ctx_set, NULL); return ret; } void lys_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres) { uint32_t i, j, idx, temp_lo = 0; struct lysf_ctx fctx = {.ctx = ctx}; struct ly_set *dep_set; LY_ERR ret; for (i = 0; i < unres->implementing.count; ++i) { fctx.mod = unres->implementing.objs[i]; assert(fctx.mod->implemented); /* make the module correctly non-implemented again */ fctx.mod->implemented = 0; lys_precompile_augments_deviations_revert(ctx, fctx.mod); lysc_module_free(&fctx, fctx.mod->compiled); fctx.mod->compiled = NULL; /* should not be made implemented */ fctx.mod->to_compile = 0; } for (i = 0; i < unres->creating.count; ++i) { fctx.mod = unres->creating.objs[i]; /* remove the module from the context */ ly_set_rm(&ctx->list, fctx.mod, NULL); /* remove it also from dep sets */ for (j = 0; j < unres->dep_sets.count; ++j) { dep_set = unres->dep_sets.objs[j]; if (ly_set_contains(dep_set, fctx.mod, &idx)) { ly_set_rm_index(dep_set, idx, NULL); break; } } /* free the module */ lys_module_free(&fctx, fctx.mod, 1); } /* remove the extensions as well */ lysf_ctx_erase(&fctx); if (unres->implementing.count) { /* recompile previous context because some implemented modules are no longer implemented, * we can reuse the current to_compile flags */ ly_temp_log_options(&temp_lo); ret = lys_compile_depset_all(ctx, &ctx->unres); ly_temp_log_options(NULL); if (ret) { LOGINT(ctx); } } } void lys_unres_glob_erase(struct lys_glob_unres *unres) { uint32_t i; for (i = 0; i < unres->dep_sets.count; ++i) { ly_set_free(unres->dep_sets.objs[i], NULL); } ly_set_erase(&unres->dep_sets, NULL); ly_set_erase(&unres->implementing, NULL); ly_set_erase(&unres->creating, NULL); assert(!unres->ds_unres.whens.count); assert(!unres->ds_unres.musts.count); assert(!unres->ds_unres.leafrefs.count); assert(!unres->ds_unres.disabled_leafrefs.count); assert(!unres->ds_unres.dflts.count); assert(!unres->ds_unres.disabled.count); } LIBYANG_API_DEF LY_ERR lys_set_implemented(struct lys_module *mod, const char **features) { LY_ERR ret = LY_SUCCESS; struct lys_glob_unres *unres = &mod->ctx->unres; LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL); /* implement */ ret = _lys_set_implemented(mod, features, unres); LY_CHECK_GOTO(ret, cleanup); if (!(mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE)) { /* create dep set for the module and mark all the modules that will be (re)compiled */ LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(mod->ctx, &unres->dep_sets, mod), cleanup); /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */ LY_CHECK_GOTO(ret = lys_compile_depset_all(mod->ctx, unres), cleanup); /* unres resolved */ lys_unres_glob_erase(unres); } cleanup: if (ret) { lys_unres_glob_revert(mod->ctx, unres); lys_unres_glob_erase(unres); } return ret; } /** * @brief Resolve (find) all imported and included modules. * * @param[in] pctx Parser context. * @param[in] pmod Parsed module to resolve. * @param[out] new_mods Set with all the newly loaded modules. * @return LY_ERR value. */ static LY_ERR lysp_resolve_import_include(struct lysp_ctx *pctx, struct lysp_module *pmod, struct ly_set *new_mods) { struct lysp_import *imp; LY_ARRAY_COUNT_TYPE u, v; pmod->parsing = 1; LY_ARRAY_FOR(pmod->imports, u) { imp = &pmod->imports[u]; if (!imp->module) { LY_CHECK_RET(lys_parse_load(PARSER_CTX(pctx), imp->name, imp->rev[0] ? imp->rev : NULL, new_mods, &imp->module)); if (!imp->rev[0]) { /* This module must be selected for the next similar * import without revision-date to avoid incorrect * derived identities in the ::lys_module.identities. */ imp->module->latest_revision |= LYS_MOD_IMPORTED_REV; } } /* check for importing the same module twice */ for (v = 0; v < u; ++v) { if (imp->module == pmod->imports[v].module) { LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name); } } } LY_CHECK_RET(lysp_load_submodules(pctx, pmod, new_mods)); pmod->parsing = 0; return LY_SUCCESS; } /** * @brief Generate path of the given paresed node. * * @param[in] node Schema path of this node will be generated. * @param[in] parent Build relative path only until this parent is found. If NULL, the full absolute path is printed. * @return NULL in case of memory allocation error, path of the node otherwise. * In case the @p buffer is NULL, the returned string is dynamically allocated and caller is responsible to free it. */ static char * lysp_path_until(const struct lysp_node *node, const struct lysp_node *parent, const struct lysp_module *pmod) { const struct lysp_node *iter, *par; char *path = NULL, *s; const char *slash; int len = 0; for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) { if (parent && (iter->parent == parent)) { slash = ""; } else { slash = "/"; } s = path; par = iter->parent; if (!par) { /* print prefix */ len = asprintf(&path, "%s%s:%s%s", slash, pmod->mod->name, iter->name, s ? s : ""); } else { /* prefix is the same as in parent */ len = asprintf(&path, "%s%s%s", slash, iter->name, s ? s : ""); } free(s); } if (len < 0) { free(path); path = NULL; } else if (len == 0) { path = strdup("/"); } return path; } /** * @brief Build log path for a parsed extension instance. * * @param[in] pcxt Parse context. * @param[in] ext Parsed extension instance. * @param[out] path Generated path. * @return LY_ERR value. */ static LY_ERR lysp_resolve_ext_instance_log_path(const struct lysp_ctx *pctx, const struct lysp_ext_instance *ext, char **path) { char *buf = NULL; uint32_t used = 0, size = 0; if (ext->parent_stmt & LY_STMT_NODE_MASK) { /* parsed node path */ buf = lysp_path_until(ext->parent, NULL, PARSER_CUR_PMOD(pctx)); LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM); size = used = strlen(buf); /* slash */ size += 1; buf = realloc(buf, size + 1); LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM); used += sprintf(buf + used, "/"); } else { /* module */ size += 1 + strlen(PARSER_CUR_PMOD(pctx)->mod->name) + 1; buf = realloc(buf, size + 1); LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM); used += sprintf(buf + used, "/%s:", PARSER_CUR_PMOD(pctx)->mod->name); } /* extension name */ size += 12 + strlen(ext->name) + 2; buf = realloc(buf, size + 1); LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM); used += sprintf(buf + used, "{extension='%s'}", ext->name); /* extension argument */ if (ext->argument) { size += 1 + strlen(ext->argument); buf = realloc(buf, size + 1); LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM); used += sprintf(buf + used, "/%s", ext->argument); } *path = buf; return LY_SUCCESS; } /** * @brief Resolve (find) all extension instance records and finish their parsing. * * @param[in] pctx Parse context with all the parsed extension instances. * @return LY_ERR value. */ static LY_ERR lysp_resolve_ext_instance_records(struct lysp_ctx *pctx) { LY_ERR r; struct lysf_ctx fctx = {.ctx = PARSER_CTX(pctx)}; struct lysp_ext_instance *exts, *ext; const struct lys_module *mod; uint32_t i; LY_ARRAY_COUNT_TYPE u; char *path = NULL; /* first finish parsing all extension instances ... */ for (i = 0; i < pctx->ext_inst.count; ++i) { exts = pctx->ext_inst.objs[i]; LY_ARRAY_FOR(exts, u) { ext = &exts[u]; /* find the extension definition */ LY_CHECK_RET(lysp_ext_find_definition(PARSER_CTX(pctx), ext, &mod, &ext->def)); /* resolve the argument, if needed */ LY_CHECK_RET(lysp_ext_instance_resolve_argument(PARSER_CTX(pctx), ext)); /* find the extension record, if any */ ext->record = lyplg_ext_record_find(mod->name, mod->revision, ext->def->name); } } /* ... then call the parse callback */ for (i = 0; i < pctx->ext_inst.count; ++i) { exts = pctx->ext_inst.objs[i]; u = 0; while (u < LY_ARRAY_COUNT(exts)) { ext = &exts[u]; if (!ext->record || !ext->record->plugin.parse) { goto next_iter; } /* set up log path */ if ((r = lysp_resolve_ext_instance_log_path(pctx, ext, &path))) { return r; } LOG_LOCSET(NULL, NULL, path, NULL); /* parse */ r = ext->record->plugin.parse(pctx, ext); LOG_LOCBACK(0, 0, 1, 0); free(path); if (r == LY_ENOT) { /* instance should be ignored, remove it */ lysp_ext_instance_free(&fctx, ext); LY_ARRAY_DECREMENT(exts); if (u < LY_ARRAY_COUNT(exts)) { /* replace by the last item */ *ext = exts[LY_ARRAY_COUNT(exts)]; } /* else if there are no more items, leave the empty array, we are not able to free it */ continue; } else if (r) { /* error */ return r; } next_iter: ++u; } } return LY_SUCCESS; } LY_ERR lys_parse_submodule(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, struct lysp_ctx *main_ctx, LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *), void *check_data, struct ly_set *new_mods, struct lysp_submodule **submodule) { LY_ERR ret; struct lysp_submodule *submod = NULL, *latest_sp; struct lysp_yang_ctx *yangctx = NULL; struct lysp_yin_ctx *yinctx = NULL; struct lysp_ctx *pctx; struct lysf_ctx fctx = {.ctx = ctx}; LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL); switch (format) { case LYS_IN_YIN: ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod); pctx = (struct lysp_ctx *)yinctx; break; case LYS_IN_YANG: ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod); pctx = (struct lysp_ctx *)yangctx; break; default: LOGERR(ctx, LY_EINVAL, "Invalid schema input format."); ret = LY_EINVAL; break; } LY_CHECK_GOTO(ret, error); assert(submod); /* make sure that the newest revision is at position 0 */ lysp_sort_revisions(submod->revs); /* decide the latest revision */ latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name); if (latest_sp) { if (submod->revs) { if (!latest_sp->revs) { /* latest has no revision, so mod is anyway newer */ submod->latest_revision = latest_sp->latest_revision; /* the latest_sp is zeroed later when the new module is being inserted into the context */ } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) { submod->latest_revision = latest_sp->latest_revision; /* the latest_sp is zeroed later when the new module is being inserted into the context */ } else { latest_sp = NULL; } } else { latest_sp = NULL; } } else { submod->latest_revision = 1; } if (custom_check) { LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error); } if (latest_sp) { latest_sp->latest_revision = 0; } lys_parser_fill_filepath(ctx, in, &submod->filepath); /* resolve imports and includes */ LY_CHECK_GOTO(ret = lysp_resolve_import_include(pctx, (struct lysp_module *)submod, new_mods), error); if (format == LYS_IN_YANG) { lysp_yang_ctx_free(yangctx); } else { lysp_yin_ctx_free(yinctx); } *submodule = submod; return LY_SUCCESS; error: if (!submod || !submod->name) { LOGERR(ctx, ret, "Parsing submodule failed."); } else { LOGERR(ctx, ret, "Parsing submodule \"%s\" failed.", submod->name); } lysp_module_free(&fctx, (struct lysp_module *)submod); if (format == LYS_IN_YANG) { lysp_yang_ctx_free(yangctx); } else { lysp_yin_ctx_free(yinctx); } return ret; } /** * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added. * * @param[in] pctx Parse context. * @param[in] mod Parsed module to add to. * @return LY_SUCCESS on success. * @return LY_ERR on error. */ static LY_ERR lysp_add_internal_ietf_netconf(struct lysp_ctx *pctx, struct lysp_module *mod) { struct lysp_ext_instance *extp; struct lysp_stmt *stmt; struct lysp_import *imp; /* * 1) edit-config's operation */ LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, extp, LY_EMEM); LY_CHECK_ERR_RET(!extp, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &extp->name)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &extp->argument)); extp->format = LY_VALUE_SCHEMA; extp->prefix_data = mod; extp->parent = mod; extp->parent_stmt = LY_STMT_MODULE; extp->flags = LYS_INTERNAL; extp->child = stmt = calloc(1, sizeof *extp->child); LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_TYPE; stmt->child = calloc(1, sizeof *stmt->child); stmt = stmt->child; LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_ENUM; stmt->next = calloc(1, sizeof *stmt->child); stmt = stmt->next; LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_ENUM; stmt->next = calloc(1, sizeof *stmt->child); stmt = stmt->next; LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_ENUM; stmt->next = calloc(1, sizeof *stmt->child); stmt = stmt->next; LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_ENUM; stmt->next = calloc(1, sizeof *stmt->child); stmt = stmt->next; LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_ENUM; /* * 2) filter's type */ LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, extp, LY_EMEM); LY_CHECK_ERR_RET(!extp, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &extp->name)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &extp->argument)); extp->format = LY_VALUE_SCHEMA; extp->prefix_data = mod; extp->parent = mod; extp->parent_stmt = LY_STMT_MODULE; extp->flags = LYS_INTERNAL; extp->child = stmt = calloc(1, sizeof *extp->child); LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_TYPE; stmt->child = calloc(1, sizeof *stmt->child); stmt = stmt->child; LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_ENUM; stmt->next = calloc(1, sizeof *stmt->child); stmt = stmt->next; LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_ENUM; /* if-feature for enum allowed only for YANG 1.1 modules */ if (mod->version >= LYS_VERSION_1_1) { stmt->child = calloc(1, sizeof *stmt->child); stmt = stmt->child; LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_IF_FEATURE; } /* * 3) filter's select */ LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, extp, LY_EMEM); LY_CHECK_ERR_RET(!extp, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &extp->name)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &extp->argument)); extp->format = LY_VALUE_SCHEMA; extp->prefix_data = mod; extp->parent = mod; extp->parent_stmt = LY_STMT_MODULE; extp->flags = LYS_INTERNAL; extp->child = stmt = calloc(1, sizeof *extp->child); LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_TYPE; if (LY_ARRAY_COUNT(mod->exts) == 3) { /* first extension instances */ assert(pctx->main_ctx == pctx); LY_CHECK_RET(ly_set_add(&pctx->ext_inst, mod->exts, 1, NULL)); } /* create new imports for the used prefixes */ LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix)); imp->flags = LYS_INTERNAL; LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix)); imp->flags = LYS_INTERNAL; return LY_SUCCESS; } /** * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module. * * @param[in] pctx Parse context. * @param[in] mod Parsed module to add to. * @return LY_SUCCESS on success. * @return LY_ERR on error. */ static LY_ERR lysp_add_internal_ietf_netconf_with_defaults(struct lysp_ctx *pctx, struct lysp_module *mod) { struct lysp_ext_instance *extp; struct lysp_stmt *stmt; struct lysp_import *imp; /* add new extension instance */ LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, extp, LY_EMEM); /* fill in the extension instance fields */ LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &extp->name)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &extp->argument)); extp->format = LY_VALUE_SCHEMA; extp->prefix_data = mod; extp->parent = mod; extp->parent_stmt = LY_STMT_MODULE; extp->flags = LYS_INTERNAL; extp->child = stmt = calloc(1, sizeof *extp->child); LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg)); stmt->format = LY_VALUE_SCHEMA; stmt->prefix_data = mod; stmt->kw = LY_STMT_TYPE; if (LY_ARRAY_COUNT(mod->exts) == 1) { /* first extension instance */ assert(pctx->main_ctx == pctx); LY_CHECK_RET(ly_set_add(&pctx->ext_inst, mod->exts, 1, NULL)); } /* create new import for the used prefix */ LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name)); LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix)); imp->flags = LYS_INTERNAL; return LY_SUCCESS; } LY_ERR lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, LY_ERR (*custom_check)(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data), void *check_data, struct ly_set *new_mods, struct lys_module **module) { struct lys_module *mod = NULL, *latest, *mod_dup = NULL; LY_ERR ret; struct lysp_yang_ctx *yangctx = NULL; struct lysp_yin_ctx *yinctx = NULL; struct lysp_ctx *pctx = NULL; struct lysf_ctx fctx = {.ctx = ctx}; char *filename, *rev, *dot; size_t len; ly_bool module_created = 0; assert(ctx && in && new_mods); if (module) { *module = NULL; } mod = calloc(1, sizeof *mod); LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM); mod->ctx = ctx; /* parse */ switch (format) { case LYS_IN_YIN: ret = yin_parse_module(&yinctx, in, mod); pctx = (struct lysp_ctx *)yinctx; break; case LYS_IN_YANG: ret = yang_parse_module(&yangctx, in, mod); pctx = (struct lysp_ctx *)yangctx; break; default: LOGERR(ctx, LY_EINVAL, "Invalid schema input format."); ret = LY_EINVAL; break; } LY_CHECK_GOTO(ret, cleanup); /* make sure that the newest revision is at position 0 */ lysp_sort_revisions(mod->parsed->revs); if (mod->parsed->revs) { LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), cleanup); } /* decide the latest revision */ latest = ly_ctx_get_module_latest(ctx, mod->name); if (latest) { if (mod->revision) { if (!latest->revision) { /* latest has no revision, so mod is anyway newer */ mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS); /* the latest is zeroed later when the new module is being inserted into the context */ } else if (strcmp(mod->revision, latest->revision) > 0) { mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS); /* the latest is zeroed later when the new module is being inserted into the context */ } else { latest = NULL; } } else { latest = NULL; } } else { mod->latest_revision = LYS_MOD_LATEST_REV; } if (custom_check) { LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), cleanup); } /* check whether it is not already in the context in the same revision */ mod_dup = ly_ctx_get_module(ctx, mod->name, mod->revision); if (mod_dup) { /* nothing to do */ LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name, mod_dup->revision ? mod_dup->revision : ""); goto cleanup; } /* check whether there is not a namespace collision */ mod_dup = ly_ctx_get_module_latest_ns(ctx, mod->ns); if (mod_dup && (mod_dup->revision == mod->revision)) { LOGERR(ctx, LY_EINVAL, "Two different modules (\"%s\" and \"%s\") have the same namespace \"%s\".", mod_dup->name, mod->name, mod->ns); ret = LY_EINVAL; goto cleanup; } switch (in->type) { case LY_IN_FILEPATH: /* check that name and revision match filename */ filename = strrchr(in->method.fpath.filepath, '/'); if (!filename) { filename = in->method.fpath.filepath; } else { filename++; } rev = strchr(filename, '@'); dot = strrchr(filename, '.'); /* name */ len = strlen(mod->name); if (strncmp(filename, mod->name, len) || ((rev && (rev != &filename[len])) || (!rev && (dot != &filename[len])))) { LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, mod->name); } if (rev) { len = dot - ++rev; if (!mod->parsed->revs || (len != LY_REV_SIZE - 1) || strncmp(mod->parsed->revs[0].date, rev, len)) { LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename, mod->parsed->revs ? mod->parsed->revs[0].date : "none"); } } break; case LY_IN_FD: case LY_IN_FILE: case LY_IN_MEMORY: /* nothing special to do */ break; case LY_IN_ERROR: LOGINT(ctx); ret = LY_EINT; goto cleanup; } lys_parser_fill_filepath(ctx, in, &mod->filepath); if (latest) { latest->latest_revision &= ~(LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS); } /* add internal data in case specific modules were parsed */ if (!strcmp(mod->name, "ietf-netconf")) { LY_CHECK_GOTO(ret = lysp_add_internal_ietf_netconf(pctx, mod->parsed), cleanup); } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) { LY_CHECK_GOTO(ret = lysp_add_internal_ietf_netconf_with_defaults(pctx, mod->parsed), cleanup); } /* add the module into newly created module set, will also be freed from there on any error */ LY_CHECK_GOTO(ret = ly_set_add(new_mods, mod, 1, NULL), cleanup); module_created = 1; /* add into context */ ret = ly_set_add(&ctx->list, mod, 1, NULL); LY_CHECK_GOTO(ret, cleanup); ctx->change_count++; /* resolve includes and all imports */ LY_CHECK_GOTO(ret = lysp_resolve_import_include(pctx, mod->parsed, new_mods), cleanup); /* resolve extension instance plugin records */ LY_CHECK_GOTO(ret = lysp_resolve_ext_instance_records(pctx), cleanup); /* check name collisions */ LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup); LY_CHECK_GOTO(ret = lysp_check_dup_groupings(pctx, mod->parsed), cleanup); LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup); LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup); /* compile features */ LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup); /* compile identities */ LY_CHECK_GOTO(ret = lys_compile_identities(mod), cleanup); cleanup: if (ret && (ret != LY_EEXIST)) { if (mod && mod->name) { /* there are cases when path is not available for parsing error, so this additional * message tries to add information about the module where the error occurred */ struct ly_err_item *e = ly_err_last(ctx); if (e && (!e->path || !strncmp(e->path, "Line ", ly_strlen_const("Line ")))) { LOGERR(ctx, ret, "Parsing module \"%s\" failed.", mod->name); } } } if (!module_created) { fctx.mod = mod; lys_module_free(&fctx, mod, 0); lysf_ctx_erase(&fctx); mod = mod_dup; } if (format == LYS_IN_YANG) { lysp_yang_ctx_free(yangctx); } else { lysp_yin_ctx_free(yinctx); } if (!ret && module) { *module = mod; } return ret; } static LYS_INFORMAT lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format) { if (!format && (in->type == LY_IN_FILEPATH)) { /* unknown format - try to detect it from filename's suffix */ const char *path = in->method.fpath.filepath; size_t len = strlen(path); /* ignore trailing whitespaces */ for ( ; len > 0 && isspace(path[len - 1]); len--) {} if ((len >= LY_YANG_SUFFIX_LEN + 1) && !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) { format = LYS_IN_YANG; } else if ((len >= LY_YIN_SUFFIX_LEN + 1) && !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) { format = LYS_IN_YIN; } /* else still unknown */ } return format; } LIBYANG_API_DEF LY_ERR lys_parse(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, const char **features, struct lys_module **module) { LY_ERR ret = LY_SUCCESS; struct lys_module *mod; if (module) { *module = NULL; } LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL); format = lys_parse_get_format(in, format); LY_CHECK_ARG_RET(ctx, format, LY_EINVAL); /* remember input position */ in->func_start = in->current; /* parse */ ret = lys_parse_in(ctx, in, format, NULL, NULL, &ctx->unres.creating, &mod); LY_CHECK_GOTO(ret, cleanup); /* implement */ ret = _lys_set_implemented(mod, features, &ctx->unres); LY_CHECK_GOTO(ret, cleanup); if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) { /* create dep set for the module and mark all the modules that will be (re)compiled */ LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, mod), cleanup); /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */ LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup); /* unres resolved */ lys_unres_glob_erase(&ctx->unres); } cleanup: if (ret) { lys_unres_glob_revert(ctx, &ctx->unres); lys_unres_glob_erase(&ctx->unres); } else if (module) { *module = mod; } return ret; } LIBYANG_API_DEF LY_ERR lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_module **module) { LY_ERR ret; struct ly_in *in = NULL; LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL); LY_CHECK_ERR_RET(ret = ly_in_new_memory(data, &in), LOGERR(ctx, ret, "Unable to create input handler."), ret); ret = lys_parse(ctx, in, format, NULL, module); ly_in_free(in, 0); return ret; } LIBYANG_API_DEF LY_ERR lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, struct lys_module **module) { LY_ERR ret; struct ly_in *in = NULL; LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL); LY_CHECK_ERR_RET(ret = ly_in_new_fd(fd, &in), LOGERR(ctx, ret, "Unable to create input handler."), ret); ret = lys_parse(ctx, in, format, NULL, module); ly_in_free(in, 0); return ret; } LIBYANG_API_DEF LY_ERR lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, struct lys_module **module) { LY_ERR ret; struct ly_in *in = NULL; LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL); LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in), LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret); ret = lys_parse(ctx, in, format, NULL, module); ly_in_free(in, 0); return ret; } LIBYANG_API_DEF LY_ERR lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision, char **localfile, LYS_INFORMAT *format) { LY_ERR ret = LY_EMEM; size_t len, flen, match_len = 0, dir_len; ly_bool implicit_cwd = 0; char *wd, *wn = NULL; DIR *dir = NULL; struct dirent *file; char *match_name = NULL; LYS_INFORMAT format_aux, match_format = 0; struct ly_set *dirs; struct stat st; LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL); /* start to fill the dir fifo with the context's search path (if set) * and the current working directory */ LY_CHECK_RET(ly_set_new(&dirs)); len = strlen(name); if (cwd) { wd = get_current_dir_name(); if (!wd) { LOGMEM(NULL); goto cleanup; } else { /* add implicit current working directory (./) to be searched, * this directory is not searched recursively */ ret = ly_set_add(dirs, wd, 0, NULL); LY_CHECK_GOTO(ret, cleanup); implicit_cwd = 1; } } if (searchpaths) { for (uint64_t i = 0; searchpaths[i]; i++) { /* check for duplicities with the implicit current working directory */ if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) { implicit_cwd = 0; continue; } wd = strdup(searchpaths[i]); if (!wd) { LOGMEM(NULL); goto cleanup; } else { ret = ly_set_add(dirs, wd, 0, NULL); LY_CHECK_GOTO(ret, cleanup); } } } wd = NULL; /* start searching */ while (dirs->count) { free(wd); free(wn); wn = NULL; dirs->count--; wd = (char *)dirs->objs[dirs->count]; dirs->objs[dirs->count] = NULL; LOGVRB("Searching for \"%s\" in \"%s\".", name, wd); if (dir) { closedir(dir); } dir = opendir(wd); dir_len = strlen(wd); if (!dir) { LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno)); } else { while ((file = readdir(dir))) { if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) { /* skip . and .. */ continue; } free(wn); if (asprintf(&wn, "%s/%s", wd, file->d_name) == -1) { LOGMEM(NULL); goto cleanup; } if (stat(wn, &st) == -1) { LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)", file->d_name, wd, strerror(errno)); continue; } if (S_ISDIR(st.st_mode) && (dirs->count || !implicit_cwd)) { /* we have another subdirectory in searchpath to explore, * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */ ret = ly_set_add(dirs, wn, 0, NULL); LY_CHECK_GOTO(ret, cleanup); /* continue with the next item in current directory */ wn = NULL; continue; } else if (!S_ISREG(st.st_mode)) { /* not a regular file (note that we see the target of symlinks instead of symlinks */ continue; } /* here we know that the item is a file which can contain a module */ if (strncmp(name, file->d_name, len) || ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) { /* different filename than the module we search for */ continue; } /* get type according to filename suffix */ flen = strlen(file->d_name); if ((flen >= LY_YANG_SUFFIX_LEN + 1) && !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) { format_aux = LYS_IN_YANG; } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) && !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) { format_aux = LYS_IN_YIN; } else { /* not supportde suffix/file format */ continue; } if (revision) { /* we look for the specific revision, try to get it from the filename */ if (file->d_name[len] == '@') { /* check revision from the filename */ if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) { /* another revision */ continue; } else { /* exact revision */ free(match_name); match_name = wn; wn = NULL; match_len = dir_len + 1 + len; match_format = format_aux; goto success; } } else { /* continue trying to find exact revision match, use this only if not found */ free(match_name); match_name = wn; wn = NULL; match_len = dir_len + 1 + len; match_format = format_aux; continue; } } else { /* remember the revision and try to find the newest one */ if (match_name) { if ((file->d_name[len] != '@') || lysp_check_date(NULL, &file->d_name[len + 1], flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) { continue; } else if ((match_name[match_len] == '@') && (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) { continue; } free(match_name); } match_name = wn; wn = NULL; match_len = dir_len + 1 + len; match_format = format_aux; continue; } } } } success: (*localfile) = match_name; match_name = NULL; if (format) { (*format) = match_format; } ret = LY_SUCCESS; cleanup: free(wn); free(wd); if (dir) { closedir(dir); } free(match_name); ly_set_free(dirs, free); return ret; }