blob: d284a83b2ee4d77ff1704b36b4c92cef7ec83225 [file] [log] [blame]
Radek Krejci3f5e3db2018-10-11 15:57:47 +02001/**
2 * @file tree_schema.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Schema tree implementation
5 *
6 * Copyright (c) 2015 - 2018 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 */
Radek Krejcib7db73a2018-10-24 14:18:40 +020014
Christian Hopps32874e12021-05-01 09:43:54 -040015#define _GNU_SOURCE /* asprintf, strdup */
Radek Krejci535ea9f2020-05-29 16:01:05 +020016
Radek Krejcica376bd2020-06-11 16:04:06 +020017#include "tree_schema.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020018
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <assert.h>
Radek Krejci545b4872020-11-15 10:15:12 +010020#include <ctype.h>
Radek Krejcid33273d2018-10-25 14:55:52 +020021#include <dirent.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020022#include <errno.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020023#include <stdint.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020024#include <stdio.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020025#include <stdlib.h>
26#include <string.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020027#include <sys/stat.h>
Radek Krejci86d106e2018-10-18 09:53:19 +020028#include <unistd.h>
Radek Krejci3f5e3db2018-10-11 15:57:47 +020029
Radek Krejcica376bd2020-06-11 16:04:06 +020030#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020031#include "compat.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020032#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020033#include "dict.h"
Radek Krejci47fab892020-11-05 17:02:41 +010034#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020035#include "in_internal.h"
Radek Krejci47fab892020-11-05 17:02:41 +010036#include "log.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020037#include "parser_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020038#include "parser_schema.h"
Michal Vasko40308e72020-10-20 16:38:40 +020039#include "path.h"
Michal Vaskoe482bb92023-02-01 11:41:41 +010040#include "plugins_exts.h"
Michal Vaskoc0c64ae2022-10-06 10:15:23 +020041#include "plugins_internal.h"
Michal Vasko1a7a7bd2020-10-16 14:39:15 +020042#include "schema_compile.h"
Michal Vaskof4258e12021-06-15 12:11:42 +020043#include "schema_compile_amend.h"
Michal Vasko7b1ad1a2020-11-02 15:41:27 +010044#include "schema_features.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020045#include "set.h"
46#include "tree.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010047#include "tree_edit.h"
Michal Vaskoc636ea42022-09-16 10:20:31 +020048#include "tree_schema_free.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020049#include "tree_schema_internal.h"
50#include "xpath.h"
Radek Krejci3f5e3db2018-10-11 15:57:47 +020051
Radek Krejcieccf6602021-02-05 19:42:54 +010052const char * const ly_devmod_list[] = {
53 [LYS_DEV_NOT_SUPPORTED] = "not-supported",
54 [LYS_DEV_ADD] = "add",
55 [LYS_DEV_DELETE] = "delete",
56 [LYS_DEV_REPLACE] = "replace",
57};
58
Jan Kundrátc53a7ec2021-12-09 16:01:19 +010059LIBYANG_API_DEF LY_ERR
Michal Vaskof1ab44f2020-10-22 08:58:32 +020060lysc_tree_dfs_full(const struct lysc_node *root, lysc_dfs_clb dfs_clb, void *data)
61{
Michal Vasko1d972ca2020-11-03 17:16:56 +010062 struct lysc_node *elem, *elem2;
Radek Krejci2a9fc652021-01-22 17:44:34 +010063 const struct lysc_node_action *action;
64 const struct lysc_node_notif *notif;
Michal Vaskof1ab44f2020-10-22 08:58:32 +020065
66 LY_CHECK_ARG_RET(NULL, root, dfs_clb, LY_EINVAL);
67
68 LYSC_TREE_DFS_BEGIN(root, elem) {
69 /* schema node */
70 LY_CHECK_RET(dfs_clb(elem, data, &LYSC_TREE_DFS_continue));
71
Radek Krejci2a9fc652021-01-22 17:44:34 +010072 LY_LIST_FOR(lysc_node_actions(elem), action) {
73 LYSC_TREE_DFS_BEGIN(action, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +020074 /* action subtree */
75 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
76
Radek Krejci2a9fc652021-01-22 17:44:34 +010077 LYSC_TREE_DFS_END(action, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +020078 }
79 }
80
Radek Krejci2a9fc652021-01-22 17:44:34 +010081 LY_LIST_FOR(lysc_node_notifs(elem), notif) {
82 LYSC_TREE_DFS_BEGIN(notif, elem2) {
Michal Vaskof1ab44f2020-10-22 08:58:32 +020083 /* notification subtree */
84 LY_CHECK_RET(dfs_clb(elem2, data, &LYSC_TREE_DFS_continue));
85
Radek Krejci2a9fc652021-01-22 17:44:34 +010086 LYSC_TREE_DFS_END(notif, elem2);
Michal Vaskof1ab44f2020-10-22 08:58:32 +020087 }
88 }
89
90 LYSC_TREE_DFS_END(root, elem);
91 }
92
93 return LY_SUCCESS;
94}
95
Jan Kundrátc53a7ec2021-12-09 16:01:19 +010096LIBYANG_API_DEF LY_ERR
Michal Vaskof1ab44f2020-10-22 08:58:32 +020097lysc_module_dfs_full(const struct lys_module *mod, lysc_dfs_clb dfs_clb, void *data)
98{
Michal Vasko2336cf52020-11-03 17:18:15 +010099 const struct lysc_node *root;
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200100
101 LY_CHECK_ARG_RET(NULL, mod, mod->compiled, dfs_clb, LY_EINVAL);
102
103 /* schema nodes */
Michal Vasko2336cf52020-11-03 17:18:15 +0100104 LY_LIST_FOR(mod->compiled->data, root) {
105 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
106 }
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200107
108 /* RPCs */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100109 LY_LIST_FOR((const struct lysc_node *)mod->compiled->rpcs, root) {
110 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200111 }
112
113 /* notifications */
Radek Krejci2a9fc652021-01-22 17:44:34 +0100114 LY_LIST_FOR((const struct lysc_node *)mod->compiled->notifs, root) {
115 LY_CHECK_RET(lysc_tree_dfs_full(root, dfs_clb, data));
Michal Vaskof1ab44f2020-10-22 08:58:32 +0200116 }
117
118 return LY_SUCCESS;
119}
120
Radek Krejcib93bd412020-11-02 13:23:11 +0100121static void
122lys_getnext_into_case(const struct lysc_node_case *first_case, const struct lysc_node **last, const struct lysc_node **next)
123{
Radek Krejcic5b54a02020-11-05 17:13:18 +0100124 for ( ; first_case; first_case = (const struct lysc_node_case *)first_case->next) {
Radek Krejcib93bd412020-11-02 13:23:11 +0100125 if (first_case->child) {
126 /* there is something to return */
127 (*next) = first_case->child;
128 return;
129 }
130 }
131
132 /* no children in choice's cases, so go to the choice's sibling instead of into it */
133 (*last) = (*next);
134 (*next) = (*next)->next;
135}
136
Radek Krejci035dacf2021-02-12 18:25:53 +0100137/**
138 * @brief Generic getnext function for ::lys_getnext() and ::lys_getnext_ext().
139 *
140 * Gets next schema tree (sibling) node element that can be instantiated in a data tree. Returned node can
141 * be from an augment. If the @p ext is provided, the function is locked inside the schema tree defined in the
142 * extension instance.
143 *
Michal Vasko193dacd2022-10-13 08:43:05 +0200144 * ::lys_getnext_() is supposed to be called sequentially. In the first call, the @p last parameter is usually NULL
145 * and function starts returning i) the first @p parent's child or ii) the first top level element specified in the
146 * given extension (if provided) or iii) the first top level element of the @p module.
147 * Consequent calls suppose to provide the previously returned node as the @p last parameter and still the same
148 * @p parent and @p module parameters.
Radek Krejci035dacf2021-02-12 18:25:53 +0100149 *
150 * Without options, the function is used to traverse only the schema nodes that can be paired with corresponding
Michal Vasko193dacd2022-10-13 08:43:05 +0200151 * data nodes in a data tree. By setting some @p options the behavior can be modified to the extent that
Radek Krejci035dacf2021-02-12 18:25:53 +0100152 * all the schema nodes are iteratively returned.
153 *
154 * @param[in] last Previously returned schema tree node, or NULL in case of the first call.
155 * @param[in] parent Parent of the subtree where the function starts processing.
Michal Vasko193dacd2022-10-13 08:43:05 +0200156 * @param[in] module In case of iterating on top level elements, the @p parent is NULL and
Radek Krejci035dacf2021-02-12 18:25:53 +0100157 * module must be specified.
158 * @param[in] ext The extension instance to provide a separate schema tree. To consider the top level elements in the tree,
Michal Vasko193dacd2022-10-13 08:43:05 +0200159 * the @p parent must be NULL. Anyway, at least one of @p parent, @p module and @p ext parameters must be specified.
Radek Krejci035dacf2021-02-12 18:25:53 +0100160 * @param[in] options [ORed options](@ref sgetnextflags).
161 * @return Next schema tree node that can be instantiated in a data tree, NULL in case there is no such element.
162 */
163static const struct lysc_node *
164lys_getnext_(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module,
165 const struct lysc_ext_instance *ext, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100166{
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100167 const struct lysc_node *next = NULL;
Michal Vaskoe482bb92023-02-01 11:41:41 +0100168 ly_bool action_flag = 0, notif_flag = 0, sm_flag = options & LYS_GETNEXT_WITHSCHEMAMOUNT ? 0 : 1;
169 LY_ARRAY_COUNT_TYPE u;
170 struct ly_ctx *sm_ctx = NULL;
171 const struct lys_module *mod;
172 uint32_t idx;
Radek Krejcia3045382018-11-22 14:30:31 +0100173
Radek Krejci035dacf2021-02-12 18:25:53 +0100174 LY_CHECK_ARG_RET(NULL, parent || module || ext, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100175
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200176next:
Radek Krejcia3045382018-11-22 14:30:31 +0100177 if (!last) {
178 /* first call */
179
Michal Vaskoe482bb92023-02-01 11:41:41 +0100180 /* learn where to start */
Radek Krejcia3045382018-11-22 14:30:31 +0100181 if (parent) {
182 /* schema subtree */
Michal Vasko544e58a2021-01-28 14:33:41 +0100183 next = last = lysc_node_child(parent);
Radek Krejcia3045382018-11-22 14:30:31 +0100184 } else {
185 /* top level data */
Radek Krejci035dacf2021-02-12 18:25:53 +0100186 if (ext) {
Michal Vaskofbd037c2022-11-08 10:34:20 +0100187 lyplg_ext_get_storage(ext, LY_STMT_DATA_NODE_MASK, sizeof last, (const void **)&last);
Michal Vasko193dacd2022-10-13 08:43:05 +0200188 next = last;
Radek Krejci035dacf2021-02-12 18:25:53 +0100189 } else {
190 next = last = module->data;
191 }
Radek Krejcia3045382018-11-22 14:30:31 +0100192 }
193 if (!next) {
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100194 /* try to get action or notification */
195 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100196 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100197 /* test if the next can be returned */
198 goto check;
199
Michal Vasko1bf09392020-03-27 12:38:10 +0100200 } else if (last->nodetype & (LYS_RPC | LYS_ACTION)) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100201 action_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100202 next = last->next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100203 } else if (last->nodetype == LYS_NOTIF) {
Radek Krejci05b774b2019-02-25 13:26:18 +0100204 action_flag = notif_flag = 1;
Radek Krejci2a9fc652021-01-22 17:44:34 +0100205 next = last->next;
Michal Vasko20424b42020-08-31 12:29:38 +0200206 } else {
207 next = last->next;
Radek Krejcia3045382018-11-22 14:30:31 +0100208 }
209
Radek Krejcia3045382018-11-22 14:30:31 +0100210repeat:
211 if (!next) {
Michal Vaskoe482bb92023-02-01 11:41:41 +0100212 if (last && !sm_flag && parent && (last->module->ctx != parent->module->ctx)) {
213 sm_flag = 1;
214
215 /* find the module of last */
216 sm_ctx = last->module->ctx;
217 idx = 0;
218 while ((mod = ly_ctx_get_module_iter(sm_ctx, &idx))) {
219 if (mod == last->module) {
220 break;
221 }
222 }
223 assert(mod);
224
225 /* get node from the next mounted module */
226 while (!next && (mod = ly_ctx_get_module_iter(sm_ctx, &idx))) {
227 if (!mod->implemented) {
228 continue;
229 }
230
231 next = lys_getnext(NULL, NULL, mod->compiled, options & ~LYS_GETNEXT_WITHSCHEMAMOUNT);
232 }
233 } else if (last && (last->parent != parent)) {
234 /* go back to parent */
Radek Krejcia9026eb2018-12-12 16:04:47 +0100235 last = last->parent;
Radek Krejcid5a2b9d2019-04-12 10:39:30 +0200236 goto next;
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100237 } else if (!action_flag) {
238 action_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100239 if (ext) {
Michal Vaskofbd037c2022-11-08 10:34:20 +0100240 lyplg_ext_get_storage(ext, LY_STMT_OP_MASK, sizeof next, (const void **)&next);
Radek Krejci035dacf2021-02-12 18:25:53 +0100241 } else if (parent) {
242 next = (struct lysc_node *)lysc_node_actions(parent);
243 } else {
244 next = (struct lysc_node *)module->rpcs;
245 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100246 } else if (!notif_flag) {
247 notif_flag = 1;
Radek Krejci035dacf2021-02-12 18:25:53 +0100248 if (ext) {
Michal Vaskofbd037c2022-11-08 10:34:20 +0100249 lyplg_ext_get_storage(ext, LY_STMT_NOTIFICATION, sizeof next, (const void **)&next);
Radek Krejci035dacf2021-02-12 18:25:53 +0100250 } else if (parent) {
251 next = (struct lysc_node *)lysc_node_notifs(parent);
252 } else {
253 next = (struct lysc_node *)module->notifs;
254 }
Michal Vaskoe482bb92023-02-01 11:41:41 +0100255 } else if (!sm_flag) {
256 sm_flag = 1;
257 if (parent) {
258 LY_ARRAY_FOR(parent->exts, u) {
259 if (!strcmp(parent->exts[u].def->name, "mount-point") &&
260 !strcmp(parent->exts[u].def->module->name, "ietf-yang-schema-mount")) {
261 lyplg_ext_schema_mount_create_context(&parent->exts[u], &sm_ctx);
262 if (sm_ctx) {
263 /* some usable context created */
264 break;
265 }
266 }
267 }
268 if (sm_ctx) {
269 /* get the first node from the first usable module */
270 idx = 0;
271 while (!next && (mod = ly_ctx_get_module_iter(sm_ctx, &idx))) {
272 if (!mod->implemented) {
273 continue;
274 }
275
276 next = lys_getnext(NULL, NULL, mod->compiled, options & ~LYS_GETNEXT_WITHSCHEMAMOUNT);
277 }
278 if (!next) {
279 /* no nodes found */
280 ly_ctx_destroy(sm_ctx);
281 }
282 }
283 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100284 } else {
285 return NULL;
Radek Krejcia9026eb2018-12-12 16:04:47 +0100286 }
Radek Krejci6eeb58f2019-02-22 16:29:37 +0100287 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100288 }
Radek Krejci05b774b2019-02-25 13:26:18 +0100289check:
Radek Krejcia3045382018-11-22 14:30:31 +0100290 switch (next->nodetype) {
Michal Vasko1bf09392020-03-27 12:38:10 +0100291 case LYS_RPC:
Radek Krejcia3045382018-11-22 14:30:31 +0100292 case LYS_ACTION:
293 case LYS_NOTIF:
294 case LYS_LEAF:
295 case LYS_ANYXML:
296 case LYS_ANYDATA:
297 case LYS_LIST:
298 case LYS_LEAFLIST:
299 break;
Michal Vasko20424b42020-08-31 12:29:38 +0200300 case LYS_CASE:
301 if (options & LYS_GETNEXT_WITHCASE) {
302 break;
303 } else {
304 /* go into */
Radek Krejcib93bd412020-11-02 13:23:11 +0100305 lys_getnext_into_case((const struct lysc_node_case *)next, &last, &next);
Michal Vasko20424b42020-08-31 12:29:38 +0200306 }
307 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100308 case LYS_CONTAINER:
Michal Vasko14ed9cd2021-01-28 14:16:25 +0100309 if (!(next->flags & LYS_PRESENCE) && (options & LYS_GETNEXT_INTONPCONT)) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100310 if (lysc_node_child(next)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100311 /* go into */
Michal Vasko544e58a2021-01-28 14:33:41 +0100312 next = lysc_node_child(next);
Radek Krejcia3045382018-11-22 14:30:31 +0100313 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100314 last = next;
Radek Krejcia3045382018-11-22 14:30:31 +0100315 next = next->next;
316 }
317 goto repeat;
318 }
319 break;
320 case LYS_CHOICE:
321 if (options & LYS_GETNEXT_WITHCHOICE) {
Michal Vasko20424b42020-08-31 12:29:38 +0200322 break;
Michal Vasko544e58a2021-01-28 14:33:41 +0100323 } else if ((options & LYS_GETNEXT_NOCHOICE) || !lysc_node_child(next)) {
Radek Krejci9bb94eb2018-12-04 16:48:35 +0100324 next = next->next;
325 } else {
Radek Krejcia9026eb2018-12-12 16:04:47 +0100326 if (options & LYS_GETNEXT_WITHCASE) {
Michal Vasko544e58a2021-01-28 14:33:41 +0100327 next = lysc_node_child(next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100328 } else {
Radek Krejcib93bd412020-11-02 13:23:11 +0100329 /* go into */
330 lys_getnext_into_case(((struct lysc_node_choice *)next)->cases, &last, &next);
Radek Krejcia9026eb2018-12-12 16:04:47 +0100331 }
Radek Krejcia3045382018-11-22 14:30:31 +0100332 }
333 goto repeat;
Michal Vasko544e58a2021-01-28 14:33:41 +0100334 case LYS_INPUT:
335 if (options & LYS_GETNEXT_OUTPUT) {
336 /* skip */
337 next = next->next;
338 } else {
339 /* go into */
340 next = lysc_node_child(next);
341 }
342 goto repeat;
343 case LYS_OUTPUT:
344 if (!(options & LYS_GETNEXT_OUTPUT)) {
345 /* skip */
346 next = next->next;
347 } else {
348 /* go into */
349 next = lysc_node_child(next);
350 }
351 goto repeat;
Radek Krejcia3045382018-11-22 14:30:31 +0100352 default:
353 /* we should not be here */
Radek Krejci035dacf2021-02-12 18:25:53 +0100354 LOGINT(module ? module->mod->ctx : parent ? parent->module->ctx : ext->module->ctx);
Radek Krejcia3045382018-11-22 14:30:31 +0100355 return NULL;
356 }
357
Radek Krejcia3045382018-11-22 14:30:31 +0100358 return next;
359}
360
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100361LIBYANG_API_DEF const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100362lys_getnext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_module *module, uint32_t options)
363{
364 return lys_getnext_(last, parent, module, NULL, options);
365}
366
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100367LIBYANG_API_DEF const struct lysc_node *
Radek Krejci035dacf2021-02-12 18:25:53 +0100368lys_getnext_ext(const struct lysc_node *last, const struct lysc_node *parent, const struct lysc_ext_instance *ext, uint32_t options)
369{
370 return lys_getnext_(last, parent, NULL, ext, options);
371}
372
Radek Krejcif16e2542021-02-17 15:39:23 +0100373const struct lysc_node *
Radek Krejciba05eab2021-03-10 13:19:29 +0100374lysc_ext_find_node(const struct lysc_ext_instance *ext, const struct lys_module *module, const char *name, size_t name_len,
Radek Krejcif16e2542021-02-17 15:39:23 +0100375 uint16_t nodetype, uint32_t options)
376{
377 const struct lysc_node *node = NULL;
378
379 LY_CHECK_ARG_RET(NULL, ext, name, NULL);
380 if (!nodetype) {
381 nodetype = LYS_NODETYPE_MASK;
382 }
383
384 if (module && (module != ext->module)) {
385 return NULL;
386 }
387
388 while ((node = lys_getnext_ext(node, NULL, ext, options))) {
389 if (!(node->nodetype & nodetype)) {
390 continue;
391 }
392
393 if (name_len) {
394 if (!ly_strncmp(node->name, name, name_len)) {
395 return node;
396 }
397 } else {
398 if (!strcmp(node->name, name)) {
399 return node;
400 }
401 }
402 }
403 return NULL;
404}
405
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100406LIBYANG_API_DEF const struct lysc_node *
Michal Vaskoe444f752020-02-10 12:20:06 +0100407lys_find_child(const struct lysc_node *parent, const struct lys_module *module, const char *name, size_t name_len,
Radek Krejci1deb5be2020-08-26 16:43:36 +0200408 uint16_t nodetype, uint32_t options)
Radek Krejcia3045382018-11-22 14:30:31 +0100409{
410 const struct lysc_node *node = NULL;
411
412 LY_CHECK_ARG_RET(NULL, module, name, NULL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100413 LY_CHECK_CTX_EQUAL_RET(parent ? parent->module->ctx : NULL, module->ctx, NULL);
Radek Krejcia3045382018-11-22 14:30:31 +0100414 if (!nodetype) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100415 nodetype = LYS_NODETYPE_MASK;
Radek Krejcia3045382018-11-22 14:30:31 +0100416 }
417
418 while ((node = lys_getnext(node, parent, module->compiled, options))) {
419 if (!(node->nodetype & nodetype)) {
420 continue;
421 }
422 if (node->module != module) {
423 continue;
424 }
425
426 if (name_len) {
Radek Krejci7f9b6512019-09-18 13:11:09 +0200427 if (!ly_strncmp(node->name, name, name_len)) {
Radek Krejcia3045382018-11-22 14:30:31 +0100428 return node;
429 }
430 } else {
431 if (!strcmp(node->name, name)) {
432 return node;
433 }
434 }
435 }
Michal Vaskoddd76592022-01-17 13:34:48 +0100436
Radek Krejcia3045382018-11-22 14:30:31 +0100437 return NULL;
438}
439
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100440LIBYANG_API_DEF LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100441lys_find_xpath_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
442 struct ly_set **set)
Michal Vasko519fd602020-05-26 12:17:39 +0200443{
444 LY_ERR ret = LY_SUCCESS;
Michal Vasko0b1d0762023-07-10 10:11:22 +0200445 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200446 struct lyxp_expr *exp = NULL;
Michal Vasko519fd602020-05-26 12:17:39 +0200447 uint32_t i;
448
Michal Vasko26512682021-01-11 11:35:40 +0100449 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100450 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Michal Vasko519fd602020-05-26 12:17:39 +0200451 if (!(options & LYXP_SCNODE_ALL)) {
Michal Vasko4ad69e72021-10-26 16:25:55 +0200452 options |= LYXP_SCNODE;
Michal Vasko519fd602020-05-26 12:17:39 +0200453 }
Michal Vasko26512682021-01-11 11:35:40 +0100454 if (!ctx) {
455 ctx = ctx_node->module->ctx;
456 }
Michal Vasko519fd602020-05-26 12:17:39 +0200457
Michal Vasko0b1d0762023-07-10 10:11:22 +0200458 /* allocate return set */
459 ret = ly_set_new(set);
460 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200461
462 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100463 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200464 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200465
466 /* atomize expression */
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200467 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, ctx_node, &xp_set, options);
Michal Vasko519fd602020-05-26 12:17:39 +0200468 LY_CHECK_GOTO(ret, cleanup);
469
Michal Vasko519fd602020-05-26 12:17:39 +0200470 /* transform into ly_set */
471 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100472 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200473 (*set)->size = xp_set.used;
474
475 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko004d3152020-06-11 19:59:22 +0200476 if (xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200477 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200478 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko519fd602020-05-26 12:17:39 +0200479 }
480 }
481
482cleanup:
483 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100484 lyxp_expr_free(ctx, exp);
Michal Vasko519fd602020-05-26 12:17:39 +0200485 return ret;
486}
487
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100488LIBYANG_API_DEF LY_ERR
Michal Vasko40308e72020-10-20 16:38:40 +0200489lys_find_expr_atoms(const struct lysc_node *ctx_node, const struct lys_module *cur_mod, const struct lyxp_expr *expr,
490 const struct lysc_prefix *prefixes, uint32_t options, struct ly_set **set)
491{
492 LY_ERR ret = LY_SUCCESS;
493 struct lyxp_set xp_set = {0};
494 uint32_t i;
495
496 LY_CHECK_ARG_RET(NULL, cur_mod, expr, prefixes, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100497 LY_CHECK_CTX_EQUAL_RET(ctx_node ? ctx_node->module->ctx : NULL, cur_mod->ctx, LY_EINVAL);
Michal Vasko40308e72020-10-20 16:38:40 +0200498 if (!(options & LYXP_SCNODE_ALL)) {
499 options = LYXP_SCNODE;
500 }
501
Michal Vasko0b1d0762023-07-10 10:11:22 +0200502 /* allocate return set */
503 ret = ly_set_new(set);
504 LY_CHECK_GOTO(ret, cleanup);
505
Michal Vasko40308e72020-10-20 16:38:40 +0200506 /* atomize expression */
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200507 ret = lyxp_atomize(cur_mod->ctx, expr, cur_mod, LY_VALUE_SCHEMA_RESOLVED, (void *)prefixes, ctx_node, ctx_node,
508 &xp_set, options);
Michal Vasko40308e72020-10-20 16:38:40 +0200509 LY_CHECK_GOTO(ret, cleanup);
510
Michal Vasko40308e72020-10-20 16:38:40 +0200511 /* transform into ly_set */
512 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
513 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(cur_mod->ctx); ret = LY_EMEM, cleanup);
514 (*set)->size = xp_set.used;
515
516 for (i = 0; i < xp_set.used; ++i) {
Michal Vasko1a09b212021-05-06 13:00:10 +0200517 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx >= LYXP_SET_SCNODE_ATOM_NODE)) {
518 assert((xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_NODE) ||
519 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_VAL) ||
Michal Vaskod97959c2020-12-10 12:18:28 +0100520 (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX));
Michal Vasko40308e72020-10-20 16:38:40 +0200521 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
522 LY_CHECK_GOTO(ret, cleanup);
523 }
524 }
525
526cleanup:
527 lyxp_set_free_content(&xp_set);
528 if (ret) {
529 ly_set_free(*set, NULL);
530 *set = NULL;
531 }
532 return ret;
533}
534
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100535LIBYANG_API_DEF LY_ERR
Michal Vasko26512682021-01-11 11:35:40 +0100536lys_find_xpath(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *xpath, uint32_t options,
537 struct ly_set **set)
Michal Vasko072de482020-08-05 13:27:21 +0200538{
539 LY_ERR ret = LY_SUCCESS;
Michal Vasko40308e72020-10-20 16:38:40 +0200540 struct lyxp_set xp_set = {0};
Radek Krejcif03a9e22020-09-18 20:09:31 +0200541 struct lyxp_expr *exp = NULL;
Michal Vasko072de482020-08-05 13:27:21 +0200542 uint32_t i;
543
Michal Vasko26512682021-01-11 11:35:40 +0100544 LY_CHECK_ARG_RET(NULL, ctx || ctx_node, xpath, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100545 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Michal Vasko072de482020-08-05 13:27:21 +0200546 if (!(options & LYXP_SCNODE_ALL)) {
547 options = LYXP_SCNODE;
548 }
Michal Vasko26512682021-01-11 11:35:40 +0100549 if (!ctx) {
550 ctx = ctx_node->module->ctx;
551 }
Michal Vasko072de482020-08-05 13:27:21 +0200552
Michal Vasko0b1d0762023-07-10 10:11:22 +0200553 /* allocate return set */
554 ret = ly_set_new(set);
555 LY_CHECK_GOTO(ret, cleanup);
556
Michal Vasko072de482020-08-05 13:27:21 +0200557 /* compile expression */
Michal Vasko26512682021-01-11 11:35:40 +0100558 ret = lyxp_expr_parse(ctx, xpath, 0, 1, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200559 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200560
561 /* atomize expression */
Michal Vaskoa3e92bc2022-07-29 14:56:23 +0200562 ret = lyxp_atomize(ctx, exp, NULL, LY_VALUE_JSON, NULL, ctx_node, ctx_node, &xp_set, options);
Michal Vasko072de482020-08-05 13:27:21 +0200563 LY_CHECK_GOTO(ret, cleanup);
564
Michal Vasko072de482020-08-05 13:27:21 +0200565 /* transform into ly_set */
566 (*set)->objs = malloc(xp_set.used * sizeof *(*set)->objs);
Michal Vasko26512682021-01-11 11:35:40 +0100567 LY_CHECK_ERR_GOTO(!(*set)->objs, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200568 (*set)->size = xp_set.used;
569
570 for (i = 0; i < xp_set.used; ++i) {
Radek Krejcif13b87b2020-12-01 22:02:17 +0100571 if ((xp_set.val.scnodes[i].type == LYXP_NODE_ELEM) && (xp_set.val.scnodes[i].in_ctx == LYXP_SET_SCNODE_ATOM_CTX)) {
Radek Krejci3d92e442020-10-12 12:48:13 +0200572 ret = ly_set_add(*set, xp_set.val.scnodes[i].scnode, 1, NULL);
Radek Krejciba03a5a2020-08-27 14:40:41 +0200573 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko072de482020-08-05 13:27:21 +0200574 }
575 }
576
577cleanup:
578 lyxp_set_free_content(&xp_set);
Michal Vasko26512682021-01-11 11:35:40 +0100579 lyxp_expr_free(ctx, exp);
Michal Vaskoae159662020-10-21 11:57:24 +0200580 if (ret) {
Michal Vasko40308e72020-10-20 16:38:40 +0200581 ly_set_free(*set, NULL);
582 *set = NULL;
583 }
Michal Vasko072de482020-08-05 13:27:21 +0200584 return ret;
585}
586
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100587LIBYANG_API_DEF LY_ERR
Radek Krejcibc5644c2020-10-27 14:53:17 +0100588lys_find_lypath_atoms(const struct ly_path *path, struct ly_set **set)
589{
590 LY_ERR ret = LY_SUCCESS;
591 LY_ARRAY_COUNT_TYPE u, v;
592
593 LY_CHECK_ARG_RET(NULL, path, set, LY_EINVAL);
594
595 /* allocate return set */
596 LY_CHECK_RET(ly_set_new(set));
597
598 LY_ARRAY_FOR(path, u) {
599 /* add nodes from the path */
600 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].node, 0, NULL), cleanup);
Michal Vasko90189962023-02-28 12:10:34 +0100601 LY_ARRAY_FOR(path[u].predicates, v) {
602 if ((path[u].predicates[v].type == LY_PATH_PREDTYPE_LIST) || (path[u].predicates[v].type == LY_PATH_PREDTYPE_LIST_VAR)) {
Radek Krejcibc5644c2020-10-27 14:53:17 +0100603 /* add all the keys in a predicate */
604 LY_CHECK_GOTO(ret = ly_set_add(*set, (void *)path[u].predicates[v].key, 0, NULL), cleanup);
605 }
606 }
607 }
608
609cleanup:
610 if (ret) {
611 ly_set_free(*set, NULL);
612 *set = NULL;
613 }
614 return ret;
615}
616
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100617LIBYANG_API_DEF LY_ERR
Radek Krejcibc5644c2020-10-27 14:53:17 +0100618lys_find_path_atoms(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output,
619 struct ly_set **set)
620{
621 LY_ERR ret = LY_SUCCESS;
622 uint8_t oper;
623 struct lyxp_expr *expr = NULL;
624 struct ly_path *p = NULL;
625
626 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, path, set, LY_EINVAL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100627 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, LY_EINVAL);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100628
629 if (!ctx) {
630 ctx = ctx_node->module->ctx;
631 }
632
633 /* parse */
Michal Vasko4f7c53d2023-04-17 08:45:53 +0200634 ret = ly_path_parse(ctx, ctx_node, path, strlen(path), 0, LY_PATH_BEGIN_EITHER, LY_PATH_PREFIX_FIRST,
635 LY_PATH_PRED_SIMPLE, &expr);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100636 LY_CHECK_GOTO(ret, cleanup);
637
638 /* compile */
639 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko0884d212021-10-14 09:21:46 +0200640 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, expr, oper, LY_PATH_TARGET_MANY, 0, LY_VALUE_JSON, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100641 LY_CHECK_GOTO(ret, cleanup);
642
643 /* resolve */
644 ret = lys_find_lypath_atoms(p, set);
645
646cleanup:
647 ly_path_free(ctx, p);
648 lyxp_expr_free(ctx, expr);
649 return ret;
650}
651
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100652LIBYANG_API_DEF const struct lysc_node *
Radek Krejcibc5644c2020-10-27 14:53:17 +0100653lys_find_path(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
654{
655 const struct lysc_node *snode = NULL;
Michal Vasko4f7c53d2023-04-17 08:45:53 +0200656 struct lyxp_expr *expr = NULL;
Radek Krejcibc5644c2020-10-27 14:53:17 +0100657 struct ly_path *p = NULL;
658 LY_ERR ret;
659 uint8_t oper;
660
661 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
Michal Vasko892f5bf2021-11-24 10:41:05 +0100662 LY_CHECK_CTX_EQUAL_RET(ctx, ctx_node ? ctx_node->module->ctx : NULL, NULL);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100663
664 if (!ctx) {
665 ctx = ctx_node->module->ctx;
666 }
667
668 /* parse */
Michal Vasko4f7c53d2023-04-17 08:45:53 +0200669 ret = ly_path_parse(ctx, ctx_node, path, strlen(path), 0, LY_PATH_BEGIN_EITHER, LY_PATH_PREFIX_FIRST,
670 LY_PATH_PRED_SIMPLE, &expr);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100671 LY_CHECK_GOTO(ret, cleanup);
672
673 /* compile */
674 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
Michal Vasko4f7c53d2023-04-17 08:45:53 +0200675 ret = ly_path_compile(ctx, NULL, ctx_node, NULL, expr, oper, LY_PATH_TARGET_MANY, 0, LY_VALUE_JSON, NULL, &p);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100676 LY_CHECK_GOTO(ret, cleanup);
677
678 /* get last node */
679 snode = p[LY_ARRAY_COUNT(p) - 1].node;
680
681cleanup:
682 ly_path_free(ctx, p);
Michal Vasko4f7c53d2023-04-17 08:45:53 +0200683 lyxp_expr_free(ctx, expr);
Radek Krejcibc5644c2020-10-27 14:53:17 +0100684 return snode;
685}
686
Michal Vasko14654712020-02-06 08:35:21 +0100687char *
688lysc_path_until(const struct lysc_node *node, const struct lysc_node *parent, LYSC_PATH_TYPE pathtype, char *buffer,
Radek Krejci0f969882020-08-21 16:56:47 +0200689 size_t buflen)
Radek Krejci327de162019-06-14 12:52:07 +0200690{
Michal Vaskobde22b62022-03-22 15:32:56 +0100691 const struct lysc_node *iter, *par, *key;
Radek Krejci327de162019-06-14 12:52:07 +0200692 char *path = NULL;
693 int len = 0;
Michal Vaskobde22b62022-03-22 15:32:56 +0100694 ly_bool skip_schema;
Radek Krejci327de162019-06-14 12:52:07 +0200695
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200696 if (buffer) {
697 LY_CHECK_ARG_RET(node->module->ctx, buflen > 1, NULL);
Michal Vasko770d3fc2021-01-26 09:14:35 +0100698 buffer[0] = '\0';
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200699 }
700
Michal Vaskobde22b62022-03-22 15:32:56 +0100701 if ((pathtype == LYSC_PATH_DATA) || (pathtype == LYSC_PATH_DATA_PATTERN)) {
702 /* skip schema-only nodes */
703 skip_schema = 1;
704 } else {
705 skip_schema = 0;
706 }
Radek Krejci327de162019-06-14 12:52:07 +0200707
Michal Vaskobde22b62022-03-22 15:32:56 +0100708 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
709 char *s;
710 const char *slash;
Michal Vasko65de0402020-08-03 16:34:19 +0200711
Michal Vaskobde22b62022-03-22 15:32:56 +0100712 if (skip_schema && (iter->nodetype & (LYS_CHOICE | LYS_CASE | LYS_INPUT | LYS_OUTPUT))) {
713 /* schema-only node */
714 continue;
715 }
Michal Vasko87dd1342021-08-23 16:17:55 +0200716
Michal Vaskobde22b62022-03-22 15:32:56 +0100717 if ((pathtype == LYSC_PATH_DATA_PATTERN) && (iter->nodetype == LYS_LIST)) {
718 key = NULL;
719 while ((key = lys_getnext(key, iter, NULL, 0)) && lysc_is_key(key)) {
720 s = buffer ? strdup(buffer) : path;
Michal Vasko87dd1342021-08-23 16:17:55 +0200721
Michal Vaskobde22b62022-03-22 15:32:56 +0100722 /* print key predicate */
Radek Krejci1c0c3442019-07-23 16:08:47 +0200723 if (buffer) {
Michal Vaskobde22b62022-03-22 15:32:56 +0100724 len = snprintf(buffer, buflen, "[%s='%%s']%s", key->name, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200725 } else {
Michal Vaskobde22b62022-03-22 15:32:56 +0100726 len = asprintf(&path, "[%s='%%s']%s", key->name, s ? s : "");
Radek Krejci1c0c3442019-07-23 16:08:47 +0200727 }
Michal Vaskobde22b62022-03-22 15:32:56 +0100728 free(s);
Michal Vasko28d03812022-03-24 15:26:11 +0100729
730 if (buffer && (buflen <= (size_t)len)) {
731 /* not enough space in buffer */
732 break;
733 }
Radek Krejci1c0c3442019-07-23 16:08:47 +0200734 }
Radek Krejci327de162019-06-14 12:52:07 +0200735 }
736
Michal Vaskobde22b62022-03-22 15:32:56 +0100737 s = buffer ? strdup(buffer) : path;
738 if (parent && (iter->parent == parent)) {
739 slash = "";
740 } else {
741 slash = "/";
742 }
743
744 if (skip_schema) {
745 par = lysc_data_parent(iter);
746 } else {
747 par = iter->parent;
748 }
749
750 if (!par || (par->module != iter->module)) {
751 /* print prefix */
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200752 if (buffer) {
Michal Vaskobde22b62022-03-22 15:32:56 +0100753 len = snprintf(buffer, buflen, "%s%s:%s%s", slash, iter->module->name, iter->name, s ? s : "");
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200754 } else {
Michal Vaskobde22b62022-03-22 15:32:56 +0100755 len = asprintf(&path, "%s%s:%s%s", slash, iter->module->name, iter->name, s ? s : "");
756 }
757 } else {
758 /* prefix is the same as in parent */
759 if (buffer) {
760 len = snprintf(buffer, buflen, "%s%s%s", slash, iter->name, s ? s : "");
761 } else {
762 len = asprintf(&path, "%s%s%s", slash, iter->name, s ? s : "");
Radek Krejci3bbd93e2019-07-24 09:57:23 +0200763 }
Radek Krejci327de162019-06-14 12:52:07 +0200764 }
Michal Vaskobde22b62022-03-22 15:32:56 +0100765 free(s);
766
767 if (buffer && (buflen <= (size_t)len)) {
768 /* not enough space in buffer */
769 break;
770 }
771 }
772
773 if (len < 0) {
774 free(path);
775 path = NULL;
776 } else if (len == 0) {
777 if (buffer) {
778 strcpy(buffer, "/");
779 } else {
780 path = strdup("/");
781 }
Radek Krejci327de162019-06-14 12:52:07 +0200782 }
783
Radek Krejci1c0c3442019-07-23 16:08:47 +0200784 if (buffer) {
785 return buffer;
786 } else {
787 return path;
788 }
Radek Krejci327de162019-06-14 12:52:07 +0200789}
790
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100791LIBYANG_API_DEF char *
Michal Vasko14654712020-02-06 08:35:21 +0100792lysc_path(const struct lysc_node *node, LYSC_PATH_TYPE pathtype, char *buffer, size_t buflen)
793{
794 return lysc_path_until(node, NULL, pathtype, buffer, buflen);
795}
796
Michal Vasko405cc9e2020-12-01 12:01:27 +0100797LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +0200798_lys_set_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres)
Michal Vasko405cc9e2020-12-01 12:01:27 +0100799{
800 LY_ERR ret = LY_SUCCESS, r;
aPiecek6b3d5422021-07-30 15:55:43 +0200801 struct lys_module *mod_iter;
Michal Vaskoc56d6372021-10-19 12:29:00 +0200802 const char **imp_f, *all_f[] = {"*", NULL};
Michal Vasko65333882021-06-10 14:12:16 +0200803 uint32_t i;
Michal Vasko916aefb2020-11-02 15:43:16 +0100804
Michal Vasko405cc9e2020-12-01 12:01:27 +0100805 if (mod->implemented) {
806 /* mod is already implemented, set the features */
807 r = lys_set_features(mod->parsed, features);
808 if (r == LY_EEXIST) {
809 /* no changes */
810 return LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200811 } else if (!r) {
812 /* mark the module as changed */
Michal Vasko01db7de2021-04-16 12:23:30 +0200813 mod->to_compile = 1;
Michal Vasko01db7de2021-04-16 12:23:30 +0200814 }
Michal Vasko7213ac52021-06-15 11:52:13 +0200815
816 return r;
Michal Vasko89b5c072020-10-06 13:52:44 +0200817 }
Michal Vasko08c8b272020-11-24 18:11:30 +0100818
Michal Vasko7213ac52021-06-15 11:52:13 +0200819 /* implement, ignore recompilation because it must always take place later */
820 r = lys_implement(mod, features, unres);
821 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200822
823 if (mod->ctx->flags & LY_CTX_ALL_IMPLEMENTED) {
824 /* implement all the imports as well */
825 for (i = 0; i < unres->creating.count; ++i) {
826 mod = unres->creating.objs[i];
827 if (mod->implemented) {
828 continue;
829 }
830
Michal Vaskoc56d6372021-10-19 12:29:00 +0200831 imp_f = (mod->ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
832 r = lys_implement(mod, imp_f, unres);
Michal Vasko7213ac52021-06-15 11:52:13 +0200833 LY_CHECK_ERR_GOTO(r && (r != LY_ERECOMPILE), ret = r, cleanup);
Michal Vasko65333882021-06-10 14:12:16 +0200834 }
835 }
836
aPiecek6b3d5422021-07-30 15:55:43 +0200837 /* Try to find module with LYS_MOD_IMPORTED_REV flag. */
838 i = 0;
839 while ((mod_iter = ly_ctx_get_module_iter(mod->ctx, &i))) {
Michal Vaskoe8b085b2021-09-02 08:20:08 +0200840 if (!strcmp(mod_iter->name, mod->name) && (mod_iter != mod) && (mod_iter->latest_revision & LYS_MOD_IMPORTED_REV)) {
841 LOGVRB("Implemented module \"%s@%s\" was not and will not be imported if the revision-date is missing"
842 " in the import statement. Instead, the revision \"%s\" is imported.", mod->name, mod->revision,
843 mod_iter->revision);
aPiecek6b3d5422021-07-30 15:55:43 +0200844 break;
845 }
846 }
847
Michal Vasko65333882021-06-10 14:12:16 +0200848cleanup:
849 return ret;
850}
851
Michal Vaskof4258e12021-06-15 12:11:42 +0200852/**
Michal Vasko7ee5be22021-06-16 17:03:34 +0200853 * @brief Check whether it may be needed to (re)compile a module from a particular dependency set
854 * and if so, add it into its dep set.
855 *
856 * Dependency set includes all modules that need to be (re)compiled in case any of the module(s)
857 * in the dep set are (re)compiled.
858 *
859 * The reason for recompilation is possible disabled nodes and updating
860 * leafref targets to point to the newly compiled modules. Using the import relation, the
861 * dependency is reflexive because of possible foreign augments and deviations, which are compiled
862 * during the target module compilation.
863 *
864 * - every module must belong to exactly one dep set
865 * - implement flag must be ignored because it can be changed during dep set compilation
Michal Vaskof4258e12021-06-15 12:11:42 +0200866 *
867 * @param[in] mod Module to process.
868 * @param[in,out] ctx_set Set with all not-yet-processed modules.
869 * @param[in,out] dep_set Current dependency set to update.
Michal Vasko775fbd02021-07-28 08:25:29 +0200870 * @param[in] aux_set Set of traversed non-compiled modules, should be empty on first call.
Michal Vaskof4258e12021-06-15 12:11:42 +0200871 * @return LY_ERR value.
872 */
873static LY_ERR
Michal Vasko775fbd02021-07-28 08:25:29 +0200874lys_unres_dep_sets_create_mod_r(struct lys_module *mod, struct ly_set *ctx_set, struct ly_set *dep_set,
875 struct ly_set *aux_set)
Michal Vaskof4258e12021-06-15 12:11:42 +0200876{
877 struct lys_module *mod2;
878 struct lysp_import *imports;
879 uint32_t i;
880 LY_ARRAY_COUNT_TYPE u, v;
881 ly_bool found;
882
Michal Vasko0bccbf12021-11-22 09:59:57 +0100883 if (LYS_IS_SINGLE_DEP_SET(mod)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200884 /* is already in a separate dep set */
Michal Vasko87cfdba2022-02-22 14:13:45 +0100885 if (!lys_has_dep_mods(mod)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200886 /* break the dep set here, no modules depend on this one */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200887 return LY_SUCCESS;
888 }
Michal Vasko775fbd02021-07-28 08:25:29 +0200889
890 if (ly_set_contains(aux_set, mod, NULL)) {
891 /* it was traversed */
892 return LY_SUCCESS;
893 }
894
895 /* add a new auxiliary module */
896 LY_CHECK_RET(ly_set_add(aux_set, mod, 1, NULL));
Michal Vasko7ee5be22021-06-16 17:03:34 +0200897 } else {
Michal Vasko709f9a52021-07-21 10:51:59 +0200898 if (!ly_set_contains(ctx_set, mod, &i)) {
899 /* it was already processed */
900 return LY_SUCCESS;
901 }
902
903 /* remove it from the set, we are processing it now */
904 ly_set_rm_index(ctx_set, i, NULL);
905
Michal Vasko7ee5be22021-06-16 17:03:34 +0200906 /* add a new dependent module into the dep set */
907 LY_CHECK_RET(ly_set_add(dep_set, mod, 1, NULL));
Michal Vaskof4258e12021-06-15 12:11:42 +0200908 }
909
910 /* process imports of the module and submodules */
911 imports = mod->parsed->imports;
912 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200913 mod2 = imports[u].module;
Michal Vasko775fbd02021-07-28 08:25:29 +0200914 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200915 }
916 LY_ARRAY_FOR(mod->parsed->includes, v) {
917 imports = mod->parsed->includes[v].submodule->imports;
918 LY_ARRAY_FOR(imports, u) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200919 mod2 = imports[u].module;
Michal Vasko87cfdba2022-02-22 14:13:45 +0100920 if (LYS_IS_SINGLE_DEP_SET(mod2) && !lys_has_dep_mods(mod2)) {
921 /* break the dep set here, no modules depend on this one */
922 continue;
Michal Vasko709f9a52021-07-21 10:51:59 +0200923 }
924
Michal Vasko775fbd02021-07-28 08:25:29 +0200925 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(imports[u].module, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200926 }
927 }
928
929 /* process modules and submodules importing this module */
Michal Vasko7ee5be22021-06-16 17:03:34 +0200930 for (i = 0; i < mod->ctx->list.count; ++i) {
931 mod2 = mod->ctx->list.objs[i];
Michal Vaskof4258e12021-06-15 12:11:42 +0200932 found = 0;
933
934 imports = mod2->parsed->imports;
935 LY_ARRAY_FOR(imports, u) {
936 if (imports[u].module == mod) {
937 found = 1;
938 break;
939 }
940 }
941
942 if (!found) {
943 LY_ARRAY_FOR(mod2->parsed->includes, v) {
944 imports = mod2->parsed->includes[v].submodule->imports;
945 LY_ARRAY_FOR(imports, u) {
946 if (imports[u].module == mod) {
947 found = 1;
948 break;
949 }
950 }
951
952 if (found) {
953 break;
954 }
955 }
956 }
957
958 if (found) {
Michal Vasko775fbd02021-07-28 08:25:29 +0200959 LY_CHECK_RET(lys_unres_dep_sets_create_mod_r(mod2, ctx_set, dep_set, aux_set));
Michal Vaskof4258e12021-06-15 12:11:42 +0200960 }
961 }
962
963 return LY_SUCCESS;
964}
965
Michal Vasko709f9a52021-07-21 10:51:59 +0200966/**
967 * @brief Add all simple modules (that have nothing to (re)compile) into separate dep sets.
968 *
969 * @param[in,out] ctx_set Set with all not-yet-processed modules.
970 * @param[in,out] main_set Set of dependency module sets.
971 * @return LY_ERR value.
972 */
973static LY_ERR
974lys_unres_dep_sets_create_single(struct ly_set *ctx_set, struct ly_set *main_set)
975{
976 LY_ERR ret = LY_SUCCESS;
977 struct lys_module *m;
978 uint32_t i = 0;
979 struct ly_set *dep_set = NULL;
980
981 while (i < ctx_set->count) {
982 m = ctx_set->objs[i];
Michal Vasko0bccbf12021-11-22 09:59:57 +0100983 if (LYS_IS_SINGLE_DEP_SET(m)) {
Michal Vasko709f9a52021-07-21 10:51:59 +0200984 /* remove it from the set, we are processing it now */
985 ly_set_rm_index(ctx_set, i, NULL);
986
987 /* this module can be in a separate dep set (but there still may be modules importing this one
988 * that depend on imports of this one in case it defines groupings) */
989 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
990 LY_CHECK_GOTO(ret = ly_set_add(dep_set, m, 1, NULL), cleanup);
991 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
992 dep_set = NULL;
993 } else {
994 ++i;
995 }
996 }
997
998cleanup:
999 ly_set_free(dep_set, NULL);
1000 return ret;
1001}
1002
Michal Vaskof4258e12021-06-15 12:11:42 +02001003LY_ERR
Michal Vasko50bc09a2021-06-17 17:31:56 +02001004lys_unres_dep_sets_create(struct ly_ctx *ctx, struct ly_set *main_set, struct lys_module *mod)
Michal Vaskof4258e12021-06-15 12:11:42 +02001005{
1006 LY_ERR ret = LY_SUCCESS;
1007 struct lys_module *m;
Michal Vasko775fbd02021-07-28 08:25:29 +02001008 struct ly_set *dep_set = NULL, *ctx_set = NULL, aux_set = {0};
Michal Vaskof4258e12021-06-15 12:11:42 +02001009 uint32_t i;
Michal Vasko7ee5be22021-06-16 17:03:34 +02001010 ly_bool found;
Michal Vaskof4258e12021-06-15 12:11:42 +02001011
Michal Vasko22b26222021-07-30 11:16:47 +02001012 assert(!main_set->count);
1013
Michal Vaskof4258e12021-06-15 12:11:42 +02001014 /* start with a duplicate set of modules that we will remove from */
1015 LY_CHECK_GOTO(ret = ly_set_dup(&ctx->list, NULL, &ctx_set), cleanup);
1016
Michal Vasko709f9a52021-07-21 10:51:59 +02001017 /* first create all dep sets with single modules */
1018 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_single(ctx_set, main_set), cleanup);
1019
1020 if (mod && !ly_set_contains(ctx_set, mod, NULL)) {
1021 /* dep set for this module has already been created, nothing else to do */
1022 goto cleanup;
1023 }
1024
Michal Vaskof4258e12021-06-15 12:11:42 +02001025 while (ctx_set->count) {
1026 /* create new dep set */
1027 LY_CHECK_GOTO(ret = ly_set_new(&dep_set), cleanup);
1028
1029 if (mod) {
1030 /* use the module create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001031 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_mod_r(mod, ctx_set, dep_set, &aux_set), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001032 } else {
1033 /* use first ctx mod to create a dep set with the rest of its dependent modules */
Michal Vasko775fbd02021-07-28 08:25:29 +02001034 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create_mod_r(ctx_set->objs[0], ctx_set, dep_set, &aux_set), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001035 }
Michal Vasko775fbd02021-07-28 08:25:29 +02001036 ly_set_erase(&aux_set, NULL);
Michal Vasko7ee5be22021-06-16 17:03:34 +02001037 assert(dep_set->count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001038
1039 /* check whether there is any module that will be (re)compiled */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001040 found = 0;
Michal Vaskof4258e12021-06-15 12:11:42 +02001041 for (i = 0; i < dep_set->count; ++i) {
1042 m = dep_set->objs[i];
1043 if (m->to_compile) {
Michal Vasko7ee5be22021-06-16 17:03:34 +02001044 found = 1;
Michal Vaskof4258e12021-06-15 12:11:42 +02001045 break;
1046 }
1047 }
1048
Michal Vasko7ee5be22021-06-16 17:03:34 +02001049 if (found) {
Michal Vaskof4258e12021-06-15 12:11:42 +02001050 /* if there is, all the implemented modules need to be recompiled */
1051 for (i = 0; i < dep_set->count; ++i) {
1052 m = dep_set->objs[i];
1053 if (m->implemented) {
1054 m->to_compile = 1;
1055 }
1056 }
1057 }
1058
Michal Vasko7ee5be22021-06-16 17:03:34 +02001059 /* add the dep set into main set */
1060 LY_CHECK_GOTO(ret = ly_set_add(main_set, dep_set, 1, NULL), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001061 dep_set = NULL;
1062
1063 if (mod) {
1064 /* we need dep set only for this module */
1065 break;
1066 }
1067 }
1068
Michal Vaskoe558f792021-07-28 08:20:15 +02001069#ifndef NDEBUG
1070 LOGDBG(LY_LDGDEPSETS, "dep sets created (%" PRIu32 "):", main_set->count);
1071 for (i = 0; i < main_set->count; ++i) {
1072 struct ly_set *iter_set = main_set->objs[i];
1073
1074 LOGDBG(LY_LDGDEPSETS, "dep set #%" PRIu32 ":", i);
1075 for (uint32_t j = 0; j < iter_set->count; ++j) {
1076 m = iter_set->objs[j];
1077 LOGDBG(LY_LDGDEPSETS, "\t%s", m->name);
1078 }
1079 }
1080#endif
1081
Michal Vaskof4258e12021-06-15 12:11:42 +02001082cleanup:
Michal Vaskobd65c2e2021-06-16 11:49:45 +02001083 assert(ret || main_set->objs);
Michal Vasko775fbd02021-07-28 08:25:29 +02001084 ly_set_erase(&aux_set, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001085 ly_set_free(dep_set, NULL);
1086 ly_set_free(ctx_set, NULL);
1087 return ret;
1088}
1089
1090void
1091lys_unres_glob_revert(struct ly_ctx *ctx, struct lys_glob_unres *unres)
1092{
Michal Vaskod4a6d042022-12-08 08:34:29 +01001093 uint32_t i, j, idx, temp_lo = 0;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001094 struct lysf_ctx fctx = {.ctx = ctx};
Michal Vaskof4258e12021-06-15 12:11:42 +02001095 struct ly_set *dep_set;
Michal Vaskof4258e12021-06-15 12:11:42 +02001096 LY_ERR ret;
1097
1098 for (i = 0; i < unres->implementing.count; ++i) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001099 fctx.mod = unres->implementing.objs[i];
1100 assert(fctx.mod->implemented);
Michal Vaskof4258e12021-06-15 12:11:42 +02001101
1102 /* make the module correctly non-implemented again */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001103 fctx.mod->implemented = 0;
1104 lys_precompile_augments_deviations_revert(ctx, fctx.mod);
1105 lysc_module_free(&fctx, fctx.mod->compiled);
1106 fctx.mod->compiled = NULL;
Michal Vaskof4258e12021-06-15 12:11:42 +02001107
1108 /* should not be made implemented */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001109 fctx.mod->to_compile = 0;
Michal Vaskof4258e12021-06-15 12:11:42 +02001110 }
1111
1112 for (i = 0; i < unres->creating.count; ++i) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001113 fctx.mod = unres->creating.objs[i];
Michal Vaskof4258e12021-06-15 12:11:42 +02001114
Michal Vaskod297f2a2021-06-16 11:51:28 +02001115 /* remove the module from the context */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001116 ly_set_rm(&ctx->list, fctx.mod, NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001117
Michal Vasko22b26222021-07-30 11:16:47 +02001118 /* remove it also from dep sets */
Michal Vasko7ee5be22021-06-16 17:03:34 +02001119 for (j = 0; j < unres->dep_sets.count; ++j) {
1120 dep_set = unres->dep_sets.objs[j];
Michal Vaskoc636ea42022-09-16 10:20:31 +02001121 if (ly_set_contains(dep_set, fctx.mod, &idx)) {
Michal Vasko7ee5be22021-06-16 17:03:34 +02001122 ly_set_rm_index(dep_set, idx, NULL);
1123 break;
Michal Vaskof4258e12021-06-15 12:11:42 +02001124 }
Michal Vaskof4258e12021-06-15 12:11:42 +02001125 }
Michal Vaskod297f2a2021-06-16 11:51:28 +02001126
1127 /* free the module */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001128 lys_module_free(&fctx, fctx.mod, 1);
Michal Vaskof4258e12021-06-15 12:11:42 +02001129 }
1130
Michal Vaskoc636ea42022-09-16 10:20:31 +02001131 /* remove the extensions as well */
1132 lysf_ctx_erase(&fctx);
1133
Michal Vaskof4258e12021-06-15 12:11:42 +02001134 if (unres->implementing.count) {
1135 /* recompile previous context because some implemented modules are no longer implemented,
1136 * we can reuse the current to_compile flags */
Michal Vaskod4a6d042022-12-08 08:34:29 +01001137 ly_temp_log_options(&temp_lo);
Michal Vasko22b26222021-07-30 11:16:47 +02001138 ret = lys_compile_depset_all(ctx, &ctx->unres);
Michal Vaskod4a6d042022-12-08 08:34:29 +01001139 ly_temp_log_options(NULL);
Michal Vaskof4258e12021-06-15 12:11:42 +02001140 if (ret) {
1141 LOGINT(ctx);
1142 }
1143 }
1144}
1145
1146void
1147lys_unres_glob_erase(struct lys_glob_unres *unres)
1148{
1149 uint32_t i;
1150
1151 for (i = 0; i < unres->dep_sets.count; ++i) {
1152 ly_set_free(unres->dep_sets.objs[i], NULL);
1153 }
1154 ly_set_erase(&unres->dep_sets, NULL);
1155 ly_set_erase(&unres->implementing, NULL);
1156 ly_set_erase(&unres->creating, NULL);
1157
Michal Vaskoc130e162021-10-19 11:30:00 +02001158 assert(!unres->ds_unres.whens.count);
1159 assert(!unres->ds_unres.musts.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001160 assert(!unres->ds_unres.leafrefs.count);
aPiecekc6526b42021-07-12 15:21:39 +02001161 assert(!unres->ds_unres.disabled_leafrefs.count);
Michal Vaskof4258e12021-06-15 12:11:42 +02001162 assert(!unres->ds_unres.dflts.count);
1163 assert(!unres->ds_unres.disabled.count);
1164}
1165
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001166LIBYANG_API_DEF LY_ERR
Michal Vasko65333882021-06-10 14:12:16 +02001167lys_set_implemented(struct lys_module *mod, const char **features)
1168{
1169 LY_ERR ret = LY_SUCCESS;
Michal Vasko22b26222021-07-30 11:16:47 +02001170 struct lys_glob_unres *unres = &mod->ctx->unres;
Michal Vasko65333882021-06-10 14:12:16 +02001171
1172 LY_CHECK_ARG_RET(NULL, mod, LY_EINVAL);
1173
1174 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001175 ret = _lys_set_implemented(mod, features, unres);
Michal Vasko65333882021-06-10 14:12:16 +02001176 LY_CHECK_GOTO(ret, cleanup);
1177
Michal Vaskof4258e12021-06-15 12:11:42 +02001178 if (!(mod->ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1179 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001180 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(mod->ctx, &unres->dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001181
Michal Vasko709f9a52021-07-21 10:51:59 +02001182 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001183 LY_CHECK_GOTO(ret = lys_compile_depset_all(mod->ctx, unres), cleanup);
1184
1185 /* unres resolved */
1186 lys_unres_glob_erase(unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001187 }
1188
Michal Vasko65333882021-06-10 14:12:16 +02001189cleanup:
Michal Vasko405cc9e2020-12-01 12:01:27 +01001190 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001191 lys_unres_glob_revert(mod->ctx, unres);
1192 lys_unres_glob_erase(unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001193 }
Michal Vasko89b5c072020-10-06 13:52:44 +02001194 return ret;
Radek Krejci77a8bcd2019-09-11 11:20:02 +02001195}
1196
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001197/**
1198 * @brief Resolve (find) all imported and included modules.
1199 *
1200 * @param[in] pctx Parser context.
1201 * @param[in] pmod Parsed module to resolve.
1202 * @param[out] new_mods Set with all the newly loaded modules.
1203 * @return LY_ERR value.
1204 */
Michal Vasko7c8439f2020-08-05 13:25:19 +02001205static LY_ERR
Michal Vaskod0625d72022-10-06 15:02:50 +02001206lysp_resolve_import_include(struct lysp_ctx *pctx, struct lysp_module *pmod, struct ly_set *new_mods)
Michal Vasko7c8439f2020-08-05 13:25:19 +02001207{
1208 struct lysp_import *imp;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001209 LY_ARRAY_COUNT_TYPE u, v;
1210
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001211 pmod->parsing = 1;
1212 LY_ARRAY_FOR(pmod->imports, u) {
1213 imp = &pmod->imports[u];
Michal Vasko7c8439f2020-08-05 13:25:19 +02001214 if (!imp->module) {
aPiecekc3e26142021-06-22 14:25:49 +02001215 LY_CHECK_RET(lys_parse_load(PARSER_CTX(pctx), imp->name, imp->rev[0] ? imp->rev : NULL, new_mods, &imp->module));
aPiecekd4911ee2021-07-30 07:40:24 +02001216
1217 if (!imp->rev[0]) {
1218 /* This module must be selected for the next similar
1219 * import without revision-date to avoid incorrect
1220 * derived identities in the ::lys_module.identities.
1221 */
1222 imp->module->latest_revision |= LYS_MOD_IMPORTED_REV;
1223 }
Michal Vasko7c8439f2020-08-05 13:25:19 +02001224 }
1225 /* check for importing the same module twice */
1226 for (v = 0; v < u; ++v) {
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001227 if (imp->module == pmod->imports[v].module) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001228 LOGWRN(PARSER_CTX(pctx), "Single revision of the module \"%s\" imported twice.", imp->name);
1229 }
1230 }
1231 }
aPiecekc3e26142021-06-22 14:25:49 +02001232 LY_CHECK_RET(lysp_load_submodules(pctx, pmod, new_mods));
Radek Krejci771928a2021-01-19 13:42:36 +01001233
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001234 pmod->parsing = 0;
Michal Vasko7c8439f2020-08-05 13:25:19 +02001235
1236 return LY_SUCCESS;
1237}
1238
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001239/**
Michal Vasko193dacd2022-10-13 08:43:05 +02001240 * @brief Generate path of the given paresed node.
1241 *
1242 * @param[in] node Schema path of this node will be generated.
1243 * @param[in] parent Build relative path only until this parent is found. If NULL, the full absolute path is printed.
1244 * @return NULL in case of memory allocation error, path of the node otherwise.
1245 * In case the @p buffer is NULL, the returned string is dynamically allocated and caller is responsible to free it.
1246 */
1247static char *
1248lysp_path_until(const struct lysp_node *node, const struct lysp_node *parent, const struct lysp_module *pmod)
1249{
1250 const struct lysp_node *iter, *par;
1251 char *path = NULL, *s;
1252 const char *slash;
1253 int len = 0;
1254
1255 for (iter = node; iter && (iter != parent) && (len >= 0); iter = iter->parent) {
1256 if (parent && (iter->parent == parent)) {
1257 slash = "";
1258 } else {
1259 slash = "/";
1260 }
1261
1262 s = path;
1263 par = iter->parent;
1264 if (!par) {
1265 /* print prefix */
1266 len = asprintf(&path, "%s%s:%s%s", slash, pmod->mod->name, iter->name, s ? s : "");
1267 } else {
1268 /* prefix is the same as in parent */
1269 len = asprintf(&path, "%s%s%s", slash, iter->name, s ? s : "");
1270 }
1271 free(s);
1272 }
1273
1274 if (len < 0) {
1275 free(path);
1276 path = NULL;
1277 } else if (len == 0) {
1278 path = strdup("/");
1279 }
1280
1281 return path;
1282}
1283
1284/**
1285 * @brief Build log path for a parsed extension instance.
1286 *
1287 * @param[in] pcxt Parse context.
1288 * @param[in] ext Parsed extension instance.
1289 * @param[out] path Generated path.
1290 * @return LY_ERR value.
1291 */
1292static LY_ERR
1293lysp_resolve_ext_instance_log_path(const struct lysp_ctx *pctx, const struct lysp_ext_instance *ext, char **path)
1294{
1295 char *buf = NULL;
1296 uint32_t used = 0, size = 0;
1297
1298 if (ext->parent_stmt & LY_STMT_NODE_MASK) {
1299 /* parsed node path */
1300 buf = lysp_path_until(ext->parent, NULL, PARSER_CUR_PMOD(pctx));
1301 LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM);
1302 size = used = strlen(buf);
1303
1304 /* slash */
1305 size += 1;
1306 buf = realloc(buf, size + 1);
1307 LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM);
1308 used += sprintf(buf + used, "/");
1309 } else {
1310 /* module */
1311 size += 1 + strlen(PARSER_CUR_PMOD(pctx)->mod->name) + 1;
1312 buf = realloc(buf, size + 1);
1313 LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM);
1314 used += sprintf(buf + used, "/%s:", PARSER_CUR_PMOD(pctx)->mod->name);
1315 }
1316
1317 /* extension name */
1318 size += 12 + strlen(ext->name) + 2;
1319 buf = realloc(buf, size + 1);
1320 LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM);
1321 used += sprintf(buf + used, "{extension='%s'}", ext->name);
1322
1323 /* extension argument */
1324 if (ext->argument) {
1325 size += 1 + strlen(ext->argument);
1326 buf = realloc(buf, size + 1);
1327 LY_CHECK_ERR_RET(!buf, LOGMEM(PARSER_CTX(pctx)), LY_EMEM);
1328 used += sprintf(buf + used, "/%s", ext->argument);
1329 }
1330
1331 *path = buf;
1332 return LY_SUCCESS;
1333}
1334
1335/**
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001336 * @brief Resolve (find) all extension instance records and finish their parsing.
1337 *
1338 * @param[in] pctx Parse context with all the parsed extension instances.
1339 * @return LY_ERR value.
1340 */
1341static LY_ERR
Michal Vaskod0625d72022-10-06 15:02:50 +02001342lysp_resolve_ext_instance_records(struct lysp_ctx *pctx)
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001343{
Michal Vasko193dacd2022-10-13 08:43:05 +02001344 LY_ERR r;
1345 struct lysf_ctx fctx = {.ctx = PARSER_CTX(pctx)};
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001346 struct lysp_ext_instance *exts, *ext;
1347 const struct lys_module *mod;
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001348 uint32_t i;
1349 LY_ARRAY_COUNT_TYPE u;
Michal Vasko193dacd2022-10-13 08:43:05 +02001350 char *path = NULL;
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001351
Michal Vasko193dacd2022-10-13 08:43:05 +02001352 /* first finish parsing all extension instances ... */
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001353 for (i = 0; i < pctx->ext_inst.count; ++i) {
1354 exts = pctx->ext_inst.objs[i];
1355 LY_ARRAY_FOR(exts, u) {
1356 ext = &exts[u];
1357
Michal Vasko193dacd2022-10-13 08:43:05 +02001358 /* find the extension definition */
1359 LY_CHECK_RET(lysp_ext_find_definition(PARSER_CTX(pctx), ext, &mod, &ext->def));
1360
1361 /* resolve the argument, if needed */
1362 LY_CHECK_RET(lysp_ext_instance_resolve_argument(PARSER_CTX(pctx), ext));
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001363
1364 /* find the extension record, if any */
Michal Vasko193dacd2022-10-13 08:43:05 +02001365 ext->record = lyplg_ext_record_find(mod->name, mod->revision, ext->def->name);
1366 }
1367 }
1368
1369 /* ... then call the parse callback */
1370 for (i = 0; i < pctx->ext_inst.count; ++i) {
1371 exts = pctx->ext_inst.objs[i];
1372 u = 0;
1373 while (u < LY_ARRAY_COUNT(exts)) {
1374 ext = &exts[u];
1375 if (!ext->record || !ext->record->plugin.parse) {
1376 goto next_iter;
1377 }
1378
1379 /* set up log path */
1380 if ((r = lysp_resolve_ext_instance_log_path(pctx, ext, &path))) {
1381 return r;
1382 }
Michal Vaskof8ebf132022-11-21 14:06:48 +01001383 LOG_LOCSET(NULL, NULL, path, NULL);
Michal Vasko193dacd2022-10-13 08:43:05 +02001384
1385 /* parse */
1386 r = ext->record->plugin.parse(pctx, ext);
1387
1388 LOG_LOCBACK(0, 0, 1, 0);
1389 free(path);
1390
1391 if (r == LY_ENOT) {
1392 /* instance should be ignored, remove it */
1393 lysp_ext_instance_free(&fctx, ext);
1394 LY_ARRAY_DECREMENT(exts);
1395 if (u < LY_ARRAY_COUNT(exts)) {
1396 /* replace by the last item */
1397 *ext = exts[LY_ARRAY_COUNT(exts)];
1398 } /* else if there are no more items, leave the empty array, we are not able to free it */
1399 continue;
1400 } else if (r) {
1401 /* error */
1402 return r;
1403 }
1404
1405next_iter:
1406 ++u;
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001407 }
1408 }
1409
1410 return LY_SUCCESS;
1411}
1412
Michal Vasko3a41dff2020-07-15 14:30:28 +02001413LY_ERR
Michal Vaskod0625d72022-10-06 15:02:50 +02001414lys_parse_submodule(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, struct lysp_ctx *main_ctx,
Michal Vasko22df3f02020-08-24 13:29:22 +02001415 LY_ERR (*custom_check)(const struct ly_ctx *, struct lysp_module *, struct lysp_submodule *, void *),
aPiecekc3e26142021-06-22 14:25:49 +02001416 void *check_data, struct ly_set *new_mods, struct lysp_submodule **submodule)
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001417{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001418 LY_ERR ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001419 struct lysp_submodule *submod = NULL, *latest_sp;
Michal Vaskod0625d72022-10-06 15:02:50 +02001420 struct lysp_yang_ctx *yangctx = NULL;
1421 struct lysp_yin_ctx *yinctx = NULL;
1422 struct lysp_ctx *pctx;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001423 struct lysf_ctx fctx = {.ctx = ctx};
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001424
Michal Vasko3a41dff2020-07-15 14:30:28 +02001425 LY_CHECK_ARG_RET(ctx, ctx, in, LY_EINVAL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001426
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001427 switch (format) {
1428 case LYS_IN_YIN:
Michal Vasko63f3d842020-07-08 10:10:14 +02001429 ret = yin_parse_submodule(&yinctx, ctx, main_ctx, in, &submod);
Michal Vaskod0625d72022-10-06 15:02:50 +02001430 pctx = (struct lysp_ctx *)yinctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001431 break;
1432 case LYS_IN_YANG:
Michal Vasko63f3d842020-07-08 10:10:14 +02001433 ret = yang_parse_submodule(&yangctx, ctx, main_ctx, in, &submod);
Michal Vaskod0625d72022-10-06 15:02:50 +02001434 pctx = (struct lysp_ctx *)yangctx;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001435 break;
1436 default:
David Sedlák4f2f5ba2019-08-15 13:18:48 +02001437 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Radek Krejci82fa8d42020-07-11 22:00:59 +02001438 ret = LY_EINVAL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001439 break;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001440 }
Radek Krejcif6923e82020-07-02 16:36:53 +02001441 LY_CHECK_GOTO(ret, error);
Radek Krejcif027df72020-09-15 13:00:28 +02001442 assert(submod);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001443
1444 /* make sure that the newest revision is at position 0 */
1445 lysp_sort_revisions(submod->revs);
1446
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001447 /* decide the latest revision */
Michal Vasko8dc31992021-02-22 10:30:47 +01001448 latest_sp = (struct lysp_submodule *)ly_ctx_get_submodule2_latest(submod->mod, submod->name);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001449 if (latest_sp) {
1450 if (submod->revs) {
1451 if (!latest_sp->revs) {
1452 /* latest has no revision, so mod is anyway newer */
1453 submod->latest_revision = latest_sp->latest_revision;
Radek Krejcib3289d62019-09-18 12:21:39 +02001454 /* the latest_sp is zeroed later when the new module is being inserted into the context */
1455 } else if (strcmp(submod->revs[0].date, latest_sp->revs[0].date) > 0) {
1456 submod->latest_revision = latest_sp->latest_revision;
1457 /* the latest_sp is zeroed later when the new module is being inserted into the context */
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001458 } else {
Radek Krejcib3289d62019-09-18 12:21:39 +02001459 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001460 }
Radek Krejcib3289d62019-09-18 12:21:39 +02001461 } else {
1462 latest_sp = NULL;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001463 }
1464 } else {
1465 submod->latest_revision = 1;
1466 }
1467
Radek Krejcib3289d62019-09-18 12:21:39 +02001468 if (custom_check) {
Michal Vasko7c8439f2020-08-05 13:25:19 +02001469 LY_CHECK_GOTO(ret = custom_check(ctx, NULL, submod, check_data), error);
Radek Krejcib3289d62019-09-18 12:21:39 +02001470 }
1471
1472 if (latest_sp) {
1473 latest_sp->latest_revision = 0;
1474 }
1475
Michal Vasko7a0b0762020-09-02 16:37:01 +02001476 lys_parser_fill_filepath(ctx, in, &submod->filepath);
1477
Michal Vasko7c8439f2020-08-05 13:25:19 +02001478 /* resolve imports and includes */
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001479 LY_CHECK_GOTO(ret = lysp_resolve_import_include(pctx, (struct lysp_module *)submod, new_mods), error);
1480
David Sedlák1b623122019-08-05 15:27:49 +02001481 if (format == LYS_IN_YANG) {
Michal Vaskod0625d72022-10-06 15:02:50 +02001482 lysp_yang_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001483 } else {
Michal Vaskod0625d72022-10-06 15:02:50 +02001484 lysp_yin_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001485 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001486 *submodule = submod;
1487 return LY_SUCCESS;
David Sedlák1b623122019-08-05 15:27:49 +02001488
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001489error:
Radek Krejcic64661b2020-08-15 15:42:26 +02001490 if (!submod || !submod->name) {
1491 LOGERR(ctx, ret, "Parsing submodule failed.");
1492 } else {
1493 LOGERR(ctx, ret, "Parsing submodule \"%s\" failed.", submod->name);
1494 }
Michal Vaskoc636ea42022-09-16 10:20:31 +02001495 lysp_module_free(&fctx, (struct lysp_module *)submod);
David Sedlák1b623122019-08-05 15:27:49 +02001496 if (format == LYS_IN_YANG) {
Michal Vaskod0625d72022-10-06 15:02:50 +02001497 lysp_yang_ctx_free(yangctx);
David Sedlák1b623122019-08-05 15:27:49 +02001498 } else {
Michal Vaskod0625d72022-10-06 15:02:50 +02001499 lysp_yin_ctx_free(yinctx);
David Sedlák1b623122019-08-05 15:27:49 +02001500 }
Michal Vasko3a41dff2020-07-15 14:30:28 +02001501 return ret;
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001502}
1503
Michal Vasko45b521c2020-11-04 17:14:39 +01001504/**
1505 * @brief Add ietf-netconf metadata to the parsed module. Operation, filter, and select are added.
1506 *
Michal Vasko193dacd2022-10-13 08:43:05 +02001507 * @param[in] pctx Parse context.
Michal Vasko45b521c2020-11-04 17:14:39 +01001508 * @param[in] mod Parsed module to add to.
1509 * @return LY_SUCCESS on success.
1510 * @return LY_ERR on error.
1511 */
1512static LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +02001513lysp_add_internal_ietf_netconf(struct lysp_ctx *pctx, struct lysp_module *mod)
Michal Vasko45b521c2020-11-04 17:14:39 +01001514{
Michal Vasko125b07c2023-04-28 09:07:14 +02001515 struct lysp_ext_instance *extp, *prev_exts = mod->exts;
Michal Vasko45b521c2020-11-04 17:14:39 +01001516 struct lysp_stmt *stmt;
1517 struct lysp_import *imp;
Michal Vasko125b07c2023-04-28 09:07:14 +02001518 uint32_t idx;
Michal Vasko45b521c2020-11-04 17:14:39 +01001519
1520 /*
1521 * 1) edit-config's operation
1522 */
Michal Vasko193dacd2022-10-13 08:43:05 +02001523 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, extp, LY_EMEM);
1524 LY_CHECK_ERR_RET(!extp, LOGMEM(mod->mod->ctx), LY_EMEM);
1525 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &extp->name));
1526 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "operation", 0, &extp->argument));
1527 extp->format = LY_VALUE_SCHEMA;
1528 extp->prefix_data = mod;
1529 extp->parent = mod;
1530 extp->parent_stmt = LY_STMT_MODULE;
1531 extp->flags = LYS_INTERNAL;
Michal Vasko45b521c2020-11-04 17:14:39 +01001532
Michal Vasko193dacd2022-10-13 08:43:05 +02001533 extp->child = stmt = calloc(1, sizeof *extp->child);
Michal Vasko45b521c2020-11-04 17:14:39 +01001534 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1535 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1536 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001537 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001538 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001539 stmt->kw = LY_STMT_TYPE;
1540
1541 stmt->child = calloc(1, sizeof *stmt->child);
1542 stmt = stmt->child;
1543 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1544 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1545 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "merge", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001546 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001547 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001548 stmt->kw = LY_STMT_ENUM;
1549
1550 stmt->next = calloc(1, sizeof *stmt->child);
1551 stmt = stmt->next;
1552 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1553 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1554 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "replace", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001555 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001556 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001557 stmt->kw = LY_STMT_ENUM;
1558
1559 stmt->next = calloc(1, sizeof *stmt->child);
1560 stmt = stmt->next;
1561 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1562 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1563 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "create", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001564 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001565 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001566 stmt->kw = LY_STMT_ENUM;
1567
1568 stmt->next = calloc(1, sizeof *stmt->child);
1569 stmt = stmt->next;
1570 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1571 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1572 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "delete", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001573 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001574 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001575 stmt->kw = LY_STMT_ENUM;
1576
1577 stmt->next = calloc(1, sizeof *stmt->child);
1578 stmt = stmt->next;
1579 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1580 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1581 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "remove", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001582 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001583 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001584 stmt->kw = LY_STMT_ENUM;
1585
1586 /*
1587 * 2) filter's type
1588 */
Michal Vasko193dacd2022-10-13 08:43:05 +02001589 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, extp, LY_EMEM);
1590 LY_CHECK_ERR_RET(!extp, LOGMEM(mod->mod->ctx), LY_EMEM);
1591 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &extp->name));
1592 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &extp->argument));
1593 extp->format = LY_VALUE_SCHEMA;
1594 extp->prefix_data = mod;
1595 extp->parent = mod;
1596 extp->parent_stmt = LY_STMT_MODULE;
1597 extp->flags = LYS_INTERNAL;
Michal Vasko45b521c2020-11-04 17:14:39 +01001598
Michal Vasko193dacd2022-10-13 08:43:05 +02001599 extp->child = stmt = calloc(1, sizeof *extp->child);
Michal Vasko45b521c2020-11-04 17:14:39 +01001600 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1601 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1602 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enumeration", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001603 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001604 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001605 stmt->kw = LY_STMT_TYPE;
1606
1607 stmt->child = calloc(1, sizeof *stmt->child);
1608 stmt = stmt->child;
1609 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1610 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1611 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "subtree", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001612 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001613 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001614 stmt->kw = LY_STMT_ENUM;
1615
1616 stmt->next = calloc(1, sizeof *stmt->child);
1617 stmt = stmt->next;
1618 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1619 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "enum", 0, &stmt->stmt));
1620 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001621 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001622 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001623 stmt->kw = LY_STMT_ENUM;
1624
1625 /* if-feature for enum allowed only for YANG 1.1 modules */
1626 if (mod->version >= LYS_VERSION_1_1) {
1627 stmt->child = calloc(1, sizeof *stmt->child);
1628 stmt = stmt->child;
1629 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1630 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "if-feature", 0, &stmt->stmt));
1631 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "xpath", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001632 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001633 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001634 stmt->kw = LY_STMT_IF_FEATURE;
1635 }
1636
1637 /*
1638 * 3) filter's select
1639 */
Michal Vasko193dacd2022-10-13 08:43:05 +02001640 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, extp, LY_EMEM);
1641 LY_CHECK_ERR_RET(!extp, LOGMEM(mod->mod->ctx), LY_EMEM);
1642 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &extp->name));
1643 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "select", 0, &extp->argument));
1644 extp->format = LY_VALUE_SCHEMA;
1645 extp->prefix_data = mod;
1646 extp->parent = mod;
1647 extp->parent_stmt = LY_STMT_MODULE;
1648 extp->flags = LYS_INTERNAL;
Michal Vasko45b521c2020-11-04 17:14:39 +01001649
Michal Vasko193dacd2022-10-13 08:43:05 +02001650 extp->child = stmt = calloc(1, sizeof *extp->child);
Michal Vasko45b521c2020-11-04 17:14:39 +01001651 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1652 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1653 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_:xpath1.0", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001654 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001655 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001656 stmt->kw = LY_STMT_TYPE;
1657
Michal Vasko125b07c2023-04-28 09:07:14 +02001658 if (!prev_exts) {
Michal Vasko193dacd2022-10-13 08:43:05 +02001659 /* first extension instances */
Michal Vaskoc8806c82022-12-06 10:31:24 +01001660 assert(pctx->main_ctx == pctx);
Michal Vasko193dacd2022-10-13 08:43:05 +02001661 LY_CHECK_RET(ly_set_add(&pctx->ext_inst, mod->exts, 1, NULL));
Michal Vasko125b07c2023-04-28 09:07:14 +02001662 } else {
1663 /* replace previously stored extension instances */
1664 if (!ly_set_contains(&pctx->ext_inst, prev_exts, &idx)) {
1665 LOGINT_RET(mod->mod->ctx);
1666 }
1667 pctx->ext_inst.objs[idx] = mod->exts;
Michal Vasko193dacd2022-10-13 08:43:05 +02001668 }
1669
Michal Vasko45b521c2020-11-04 17:14:39 +01001670 /* create new imports for the used prefixes */
1671 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
Michal Vasko45b521c2020-11-04 17:14:39 +01001672 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1673 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1674 imp->flags = LYS_INTERNAL;
1675
1676 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
Michal Vasko45b521c2020-11-04 17:14:39 +01001677 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-types", 0, &imp->name));
1678 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "yang_", 0, &imp->prefix));
1679 imp->flags = LYS_INTERNAL;
1680
1681 return LY_SUCCESS;
1682}
1683
1684/**
1685 * @brief Add ietf-netconf-with-defaults "default" metadata to the parsed module.
1686 *
Michal Vasko193dacd2022-10-13 08:43:05 +02001687 * @param[in] pctx Parse context.
Michal Vasko45b521c2020-11-04 17:14:39 +01001688 * @param[in] mod Parsed module to add to.
1689 * @return LY_SUCCESS on success.
1690 * @return LY_ERR on error.
1691 */
1692static LY_ERR
Michal Vasko193dacd2022-10-13 08:43:05 +02001693lysp_add_internal_ietf_netconf_with_defaults(struct lysp_ctx *pctx, struct lysp_module *mod)
Michal Vasko45b521c2020-11-04 17:14:39 +01001694{
Michal Vasko125b07c2023-04-28 09:07:14 +02001695 struct lysp_ext_instance *extp, *prev_exts = mod->exts;
Michal Vasko45b521c2020-11-04 17:14:39 +01001696 struct lysp_stmt *stmt;
1697 struct lysp_import *imp;
Michal Vasko125b07c2023-04-28 09:07:14 +02001698 uint32_t idx;
Michal Vasko45b521c2020-11-04 17:14:39 +01001699
1700 /* add new extension instance */
Michal Vasko193dacd2022-10-13 08:43:05 +02001701 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->exts, extp, LY_EMEM);
Michal Vasko45b521c2020-11-04 17:14:39 +01001702
1703 /* fill in the extension instance fields */
Michal Vasko193dacd2022-10-13 08:43:05 +02001704 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_:annotation", 0, &extp->name));
1705 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "default", 0, &extp->argument));
1706 extp->format = LY_VALUE_SCHEMA;
1707 extp->prefix_data = mod;
1708 extp->parent = mod;
1709 extp->parent_stmt = LY_STMT_MODULE;
1710 extp->flags = LYS_INTERNAL;
Michal Vasko45b521c2020-11-04 17:14:39 +01001711
Michal Vasko193dacd2022-10-13 08:43:05 +02001712 extp->child = stmt = calloc(1, sizeof *extp->child);
Michal Vasko45b521c2020-11-04 17:14:39 +01001713 LY_CHECK_ERR_RET(!stmt, LOGMEM(mod->mod->ctx), LY_EMEM);
1714 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "type", 0, &stmt->stmt));
1715 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "boolean", 0, &stmt->arg));
Radek Krejci8df109d2021-04-23 12:19:08 +02001716 stmt->format = LY_VALUE_SCHEMA;
Michal Vaskofc2cd072021-02-24 13:17:17 +01001717 stmt->prefix_data = mod;
Michal Vasko45b521c2020-11-04 17:14:39 +01001718 stmt->kw = LY_STMT_TYPE;
1719
Michal Vasko125b07c2023-04-28 09:07:14 +02001720 if (!prev_exts) {
1721 /* first extension instances */
Michal Vaskoc8806c82022-12-06 10:31:24 +01001722 assert(pctx->main_ctx == pctx);
Michal Vasko193dacd2022-10-13 08:43:05 +02001723 LY_CHECK_RET(ly_set_add(&pctx->ext_inst, mod->exts, 1, NULL));
Michal Vasko125b07c2023-04-28 09:07:14 +02001724 } else {
1725 /* replace previously stored extension instances */
1726 if (!ly_set_contains(&pctx->ext_inst, prev_exts, &idx)) {
1727 LOGINT_RET(mod->mod->ctx);
1728 }
1729 pctx->ext_inst.objs[idx] = mod->exts;
Michal Vasko193dacd2022-10-13 08:43:05 +02001730 }
1731
Michal Vasko45b521c2020-11-04 17:14:39 +01001732 /* create new import for the used prefix */
1733 LY_ARRAY_NEW_RET(mod->mod->ctx, mod->imports, imp, LY_EMEM);
Michal Vasko45b521c2020-11-04 17:14:39 +01001734 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "ietf-yang-metadata", 0, &imp->name));
1735 LY_CHECK_RET(lydict_insert(mod->mod->ctx, "md_", 0, &imp->prefix));
1736 imp->flags = LYS_INTERNAL;
1737
1738 return LY_SUCCESS;
1739}
1740
Michal Vasko3a41dff2020-07-15 14:30:28 +02001741LY_ERR
Michal Vasko4e205e82021-06-08 14:01:47 +02001742lys_parse_in(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format,
Radek Krejci1deb5be2020-08-26 16:43:36 +02001743 LY_ERR (*custom_check)(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data),
Michal Vaskodd992582021-06-10 14:34:57 +02001744 void *check_data, struct ly_set *new_mods, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001745{
Michal Vaskoa9309bb2021-07-09 09:31:55 +02001746 struct lys_module *mod = NULL, *latest, *mod_dup = NULL;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001747 LY_ERR ret;
Michal Vaskod0625d72022-10-06 15:02:50 +02001748 struct lysp_yang_ctx *yangctx = NULL;
1749 struct lysp_yin_ctx *yinctx = NULL;
1750 struct lysp_ctx *pctx = NULL;
Michal Vaskoc636ea42022-09-16 10:20:31 +02001751 struct lysf_ctx fctx = {.ctx = ctx};
Radek Krejcic64661b2020-08-15 15:42:26 +02001752 ly_bool module_created = 0;
Radek Krejci86d106e2018-10-18 09:53:19 +02001753
Michal Vaskodd992582021-06-10 14:34:57 +02001754 assert(ctx && in && new_mods);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001755
Michal Vasko7a0b0762020-09-02 16:37:01 +02001756 if (module) {
1757 *module = NULL;
1758 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001759
1760 mod = calloc(1, sizeof *mod);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001761 LY_CHECK_ERR_RET(!mod, LOGMEM(ctx), LY_EMEM);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001762 mod->ctx = ctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001763
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001764 /* parse */
Radek Krejci86d106e2018-10-18 09:53:19 +02001765 switch (format) {
1766 case LYS_IN_YIN:
aPiecekc3e26142021-06-22 14:25:49 +02001767 ret = yin_parse_module(&yinctx, in, mod);
Michal Vaskod0625d72022-10-06 15:02:50 +02001768 pctx = (struct lysp_ctx *)yinctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001769 break;
1770 case LYS_IN_YANG:
aPiecekc3e26142021-06-22 14:25:49 +02001771 ret = yang_parse_module(&yangctx, in, mod);
Michal Vaskod0625d72022-10-06 15:02:50 +02001772 pctx = (struct lysp_ctx *)yangctx;
Radek Krejci86d106e2018-10-18 09:53:19 +02001773 break;
1774 default:
1775 LOGERR(ctx, LY_EINVAL, "Invalid schema input format.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001776 ret = LY_EINVAL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001777 break;
1778 }
Radek Krejcic64661b2020-08-15 15:42:26 +02001779 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci9f5e6fb2018-10-25 09:26:12 +02001780
1781 /* make sure that the newest revision is at position 0 */
1782 lysp_sort_revisions(mod->parsed->revs);
Radek Krejci0af46292019-01-11 16:02:31 +01001783 if (mod->parsed->revs) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001784 LY_CHECK_GOTO(ret = lydict_insert(ctx, mod->parsed->revs[0].date, 0, &mod->revision), cleanup);
Radek Krejci0af46292019-01-11 16:02:31 +01001785 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001786
Radek Krejcib3289d62019-09-18 12:21:39 +02001787 /* decide the latest revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001788 latest = ly_ctx_get_module_latest(ctx, mod->name);
Radek Krejcib3289d62019-09-18 12:21:39 +02001789 if (latest) {
1790 if (mod->revision) {
1791 if (!latest->revision) {
1792 /* latest has no revision, so mod is anyway newer */
aPiecek8ca21bd2021-07-26 14:31:01 +02001793 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001794 /* the latest is zeroed later when the new module is being inserted into the context */
1795 } else if (strcmp(mod->revision, latest->revision) > 0) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001796 mod->latest_revision = latest->latest_revision & (LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Radek Krejcib3289d62019-09-18 12:21:39 +02001797 /* the latest is zeroed later when the new module is being inserted into the context */
1798 } else {
1799 latest = NULL;
1800 }
1801 } else {
1802 latest = NULL;
1803 }
1804 } else {
aPiecek8ca21bd2021-07-26 14:31:01 +02001805 mod->latest_revision = LYS_MOD_LATEST_REV;
Radek Krejcib3289d62019-09-18 12:21:39 +02001806 }
1807
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001808 if (custom_check) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001809 LY_CHECK_GOTO(ret = custom_check(ctx, mod->parsed, NULL, check_data), cleanup);
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001810 }
1811
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001812 /* check whether it is not already in the context in the same revision */
Michal Vaskoa51ef072021-07-02 10:40:30 +02001813 mod_dup = ly_ctx_get_module(ctx, mod->name, mod->revision);
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001814 if (mod_dup) {
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001815 /* nothing to do */
1816 LOGVRB("Module \"%s@%s\" is already present in the context.", mod_dup->name,
1817 mod_dup->revision ? mod_dup->revision : "<none>");
Radek Krejcic64661b2020-08-15 15:42:26 +02001818 goto cleanup;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001819 }
Radek Krejci86d106e2018-10-18 09:53:19 +02001820
Michal Vaskob24145d2022-07-13 18:34:39 +02001821 /* check whether there is not a namespace collision */
1822 mod_dup = ly_ctx_get_module_latest_ns(ctx, mod->ns);
1823 if (mod_dup && (mod_dup->revision == mod->revision)) {
1824 LOGERR(ctx, LY_EINVAL, "Two different modules (\"%s\" and \"%s\") have the same namespace \"%s\".",
1825 mod_dup->name, mod->name, mod->ns);
1826 ret = LY_EINVAL;
1827 goto cleanup;
1828 }
1829
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001830 switch (in->type) {
1831 case LY_IN_FILEPATH:
Jan Kundrát026737b2023-09-05 13:03:30 +02001832 ly_check_module_filename(ctx, mod->name, mod->parsed->revs ? mod->parsed->revs[0].date : NULL, in->method.fpath.filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001833 break;
1834 case LY_IN_FD:
1835 case LY_IN_FILE:
1836 case LY_IN_MEMORY:
1837 /* nothing special to do */
1838 break;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001839 case LY_IN_ERROR:
1840 LOGINT(ctx);
1841 ret = LY_EINT;
Radek Krejcic64661b2020-08-15 15:42:26 +02001842 goto cleanup;
Radek Krejci096235c2019-01-11 11:12:19 +01001843 }
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001844 lys_parser_fill_filepath(ctx, in, &mod->filepath);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001845
Michal Vasko7a0b0762020-09-02 16:37:01 +02001846 if (latest) {
aPiecek8ca21bd2021-07-26 14:31:01 +02001847 latest->latest_revision &= ~(LYS_MOD_LATEST_REV | LYS_MOD_LATEST_SEARCHDIRS);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001848 }
1849
Michal Vasko45b521c2020-11-04 17:14:39 +01001850 /* add internal data in case specific modules were parsed */
1851 if (!strcmp(mod->name, "ietf-netconf")) {
Michal Vasko193dacd2022-10-13 08:43:05 +02001852 LY_CHECK_GOTO(ret = lysp_add_internal_ietf_netconf(pctx, mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001853 } else if (!strcmp(mod->name, "ietf-netconf-with-defaults")) {
Michal Vasko193dacd2022-10-13 08:43:05 +02001854 LY_CHECK_GOTO(ret = lysp_add_internal_ietf_netconf_with_defaults(pctx, mod->parsed), cleanup);
Michal Vasko45b521c2020-11-04 17:14:39 +01001855 }
1856
Michal Vasko405cc9e2020-12-01 12:01:27 +01001857 /* add the module into newly created module set, will also be freed from there on any error */
Radek Krejcic64661b2020-08-15 15:42:26 +02001858 LY_CHECK_GOTO(ret = ly_set_add(new_mods, mod, 1, NULL), cleanup);
1859 module_created = 1;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001860
Michal Vasko7a0b0762020-09-02 16:37:01 +02001861 /* add into context */
Radek Krejci3d92e442020-10-12 12:48:13 +02001862 ret = ly_set_add(&ctx->list, mod, 1, NULL);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001863 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko794ab4b2021-03-31 09:42:19 +02001864 ctx->change_count++;
Michal Vasko7a0b0762020-09-02 16:37:01 +02001865
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001866 /* resolve includes and all imports */
Michal Vaskoc0c64ae2022-10-06 10:15:23 +02001867 LY_CHECK_GOTO(ret = lysp_resolve_import_include(pctx, mod->parsed, new_mods), cleanup);
1868
1869 /* resolve extension instance plugin records */
1870 LY_CHECK_GOTO(ret = lysp_resolve_ext_instance_records(pctx), cleanup);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001871
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001872 /* check name collisions */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001873 LY_CHECK_GOTO(ret = lysp_check_dup_typedefs(pctx, mod->parsed), cleanup);
aPiecek63e080d2021-06-29 13:53:28 +02001874 LY_CHECK_GOTO(ret = lysp_check_dup_groupings(pctx, mod->parsed), cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001875 LY_CHECK_GOTO(ret = lysp_check_dup_features(pctx, mod->parsed), cleanup);
1876 LY_CHECK_GOTO(ret = lysp_check_dup_identities(pctx, mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001877
1878 /* compile features */
Michal Vasko405cc9e2020-12-01 12:01:27 +01001879 LY_CHECK_GOTO(ret = lys_compile_feature_iffeatures(mod->parsed), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001880
aPiecek6b3d5422021-07-30 15:55:43 +02001881 /* compile identities */
1882 LY_CHECK_GOTO(ret = lys_compile_identities(mod), cleanup);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001883
Radek Krejcic64661b2020-08-15 15:42:26 +02001884cleanup:
Michal Vaskobe04af42021-07-16 10:48:43 +02001885 if (ret && (ret != LY_EEXIST)) {
Radek Krejcic64661b2020-08-15 15:42:26 +02001886 if (mod && mod->name) {
1887 /* there are cases when path is not available for parsing error, so this additional
1888 * message tries to add information about the module where the error occurred */
1889 struct ly_err_item *e = ly_err_last(ctx);
Michal Vasko26bbb272022-08-02 14:54:33 +02001890
Radek Krejcic64661b2020-08-15 15:42:26 +02001891 if (e && (!e->path || !strncmp(e->path, "Line ", ly_strlen_const("Line ")))) {
1892 LOGERR(ctx, ret, "Parsing module \"%s\" failed.", mod->name);
1893 }
1894 }
1895 }
1896 if (!module_created) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001897 fctx.mod = mod;
1898 lys_module_free(&fctx, mod, 0);
1899 lysf_ctx_erase(&fctx);
1900
Michal Vasko0e02e8e2021-02-26 15:01:55 +01001901 mod = mod_dup;
1902 }
Michal Vasko8a69a1b2020-12-03 14:19:02 +01001903
Michal Vasko7a0b0762020-09-02 16:37:01 +02001904 if (format == LYS_IN_YANG) {
Michal Vaskod0625d72022-10-06 15:02:50 +02001905 lysp_yang_ctx_free(yangctx);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001906 } else {
Michal Vaskod0625d72022-10-06 15:02:50 +02001907 lysp_yin_ctx_free(yinctx);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001908 }
1909
Michal Vasko405cc9e2020-12-01 12:01:27 +01001910 if (!ret && module) {
1911 *module = mod;
1912 }
Michal Vasko7a0b0762020-09-02 16:37:01 +02001913 return ret;
1914}
1915
Radek Krejci545b4872020-11-15 10:15:12 +01001916static LYS_INFORMAT
1917lys_parse_get_format(const struct ly_in *in, LYS_INFORMAT format)
1918{
1919 if (!format && (in->type == LY_IN_FILEPATH)) {
1920 /* unknown format - try to detect it from filename's suffix */
1921 const char *path = in->method.fpath.filepath;
1922 size_t len = strlen(path);
1923
1924 /* ignore trailing whitespaces */
1925 for ( ; len > 0 && isspace(path[len - 1]); len--) {}
1926
Radek Krejcif13b87b2020-12-01 22:02:17 +01001927 if ((len >= LY_YANG_SUFFIX_LEN + 1) &&
1928 !strncmp(&path[len - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX, LY_YANG_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001929 format = LYS_IN_YANG;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001930 } else if ((len >= LY_YIN_SUFFIX_LEN + 1) &&
1931 !strncmp(&path[len - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX, LY_YIN_SUFFIX_LEN)) {
Radek Krejci545b4872020-11-15 10:15:12 +01001932 format = LYS_IN_YIN;
1933 } /* else still unknown */
1934 }
1935
1936 return format;
1937}
1938
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001939LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001940lys_parse(struct ly_ctx *ctx, struct ly_in *in, LYS_INFORMAT format, const char **features, struct lys_module **module)
Michal Vasko7a0b0762020-09-02 16:37:01 +02001941{
Michal Vasko65333882021-06-10 14:12:16 +02001942 LY_ERR ret = LY_SUCCESS;
Michal Vasko4e205e82021-06-08 14:01:47 +02001943 struct lys_module *mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001944
Michal Vasko7a0b0762020-09-02 16:37:01 +02001945 if (module) {
1946 *module = NULL;
1947 }
Radek Krejci545b4872020-11-15 10:15:12 +01001948 LY_CHECK_ARG_RET(NULL, ctx, in, LY_EINVAL);
1949
1950 format = lys_parse_get_format(in, format);
1951 LY_CHECK_ARG_RET(ctx, format, LY_EINVAL);
Michal Vasko7a0b0762020-09-02 16:37:01 +02001952
1953 /* remember input position */
1954 in->func_start = in->current;
1955
Michal Vasko4e205e82021-06-08 14:01:47 +02001956 /* parse */
Michal Vasko22b26222021-07-30 11:16:47 +02001957 ret = lys_parse_in(ctx, in, format, NULL, NULL, &ctx->unres.creating, &mod);
Michal Vasko4e205e82021-06-08 14:01:47 +02001958 LY_CHECK_GOTO(ret, cleanup);
1959
1960 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +02001961 ret = _lys_set_implemented(mod, features, &ctx->unres);
Michal Vasko405cc9e2020-12-01 12:01:27 +01001962 LY_CHECK_GOTO(ret, cleanup);
1963
Michal Vaskof4258e12021-06-15 12:11:42 +02001964 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
1965 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +02001966 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +02001967
Michal Vasko709f9a52021-07-21 10:51:59 +02001968 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +02001969 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
1970
1971 /* unres resolved */
1972 lys_unres_glob_erase(&ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +02001973 }
1974
Michal Vasko405cc9e2020-12-01 12:01:27 +01001975cleanup:
1976 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +02001977 lys_unres_glob_revert(ctx, &ctx->unres);
1978 lys_unres_glob_erase(&ctx->unres);
Michal Vasko87f1cf02021-06-08 14:02:47 +02001979 } else if (module) {
1980 *module = mod;
Michal Vasko405cc9e2020-12-01 12:01:27 +01001981 }
Michal Vasko405cc9e2020-12-01 12:01:27 +01001982 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02001983}
1984
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001985LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02001986lys_parse_mem(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02001987{
Radek Krejci0f969882020-08-21 16:56:47 +02001988 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001989 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02001990
Michal Vasko3a41dff2020-07-15 14:30:28 +02001991 LY_CHECK_ARG_RET(ctx, data, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci65639b92018-11-27 10:51:37 +01001992
Michal Vasko3a41dff2020-07-15 14:30:28 +02001993 LY_CHECK_ERR_RET(ret = ly_in_new_memory(data, &in), LOGERR(ctx, ret, "Unable to create input handler."), ret);
Radek Krejci86d106e2018-10-18 09:53:19 +02001994
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001995 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02001996 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02001997
Michal Vasko3a41dff2020-07-15 14:30:28 +02001998 return ret;
Radek Krejci0bcdaed2019-01-10 10:21:34 +01001999}
2000
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002001LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02002002lys_parse_fd(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, struct lys_module **module)
Radek Krejci86d106e2018-10-18 09:53:19 +02002003{
Radek Krejci0f969882020-08-21 16:56:47 +02002004 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02002005 struct ly_in *in = NULL;
Radek Krejci86d106e2018-10-18 09:53:19 +02002006
Michal Vasko3a41dff2020-07-15 14:30:28 +02002007 LY_CHECK_ARG_RET(ctx, fd > -1, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejci86d106e2018-10-18 09:53:19 +02002008
Michal Vasko3a41dff2020-07-15 14:30:28 +02002009 LY_CHECK_ERR_RET(ret = ly_in_new_fd(fd, &in), LOGERR(ctx, ret, "Unable to create input handler."), ret);
Radek Krejci86d106e2018-10-18 09:53:19 +02002010
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002011 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02002012 ly_in_free(in, 0);
Radek Krejci86d106e2018-10-18 09:53:19 +02002013
Michal Vasko3a41dff2020-07-15 14:30:28 +02002014 return ret;
Radek Krejci86d106e2018-10-18 09:53:19 +02002015}
2016
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002017LIBYANG_API_DEF LY_ERR
Michal Vasko4de7d072021-07-09 09:13:18 +02002018lys_parse_path(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, struct lys_module **module)
Radek Krejcid33273d2018-10-25 14:55:52 +02002019{
Radek Krejci0f969882020-08-21 16:56:47 +02002020 LY_ERR ret;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02002021 struct ly_in *in = NULL;
Radek Krejcif0e1ba52020-05-22 15:14:35 +02002022
Michal Vasko3a41dff2020-07-15 14:30:28 +02002023 LY_CHECK_ARG_RET(ctx, path, format != LYS_IN_UNKNOWN, LY_EINVAL);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02002024
Michal Vasko3a41dff2020-07-15 14:30:28 +02002025 LY_CHECK_ERR_RET(ret = ly_in_new_filepath(path, 0, &in),
Michal Vasko69730152020-10-09 16:30:07 +02002026 LOGERR(ctx, ret, "Unable to create input handler for filepath %s.", path), ret);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02002027
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01002028 ret = lys_parse(ctx, in, format, NULL, module);
Radek Krejcif0e1ba52020-05-22 15:14:35 +02002029 ly_in_free(in, 0);
2030
Michal Vasko3a41dff2020-07-15 14:30:28 +02002031 return ret;
Radek Krejcid33273d2018-10-25 14:55:52 +02002032}
2033
Michal Vasko9c49d882024-01-23 11:34:56 +01002034/**
2035 * @brief Check file type of a file.
2036 *
2037 * @param[in] file Dirent file to check.
2038 * @param[in] wd Working directory.
2039 * @param[in,out] dirs Set with searched directories to add to.
2040 * @param[in] implicit_cwd Whether implicit CWD is used.
2041 * @param[out] skip Whether to skip this file.
2042 * @return LY_ERR value.
2043 */
2044static LY_ERR
2045lys_search_localfile_file_type(const struct dirent *file, const char *wd, struct ly_set *dirs, ly_bool implicit_cwd,
2046 ly_bool *skip)
2047{
2048 LY_ERR rc = LY_SUCCESS;
2049 char *str = NULL;
2050 ly_bool is_dir = 0, is_reg = 0;
2051 struct stat st;
2052
2053 *skip = 0;
2054
2055 if (file->d_type == DT_UNKNOWN) {
2056 /* FS does not support this field, need to call stat */
2057 if (asprintf(&str, "%s/%s", wd, file->d_name) == -1) {
2058 LOGMEM(NULL);
2059 rc = LY_EMEM;
2060 goto cleanup;
2061 }
2062 if (stat(str, &st)) {
2063 LOGWRN(NULL, "Unable to get information about \"%s\" file in \"%s\" when searching for (sub)modules (%s)",
2064 file->d_name, wd, strerror(errno));
2065 } else if (S_ISDIR(st.st_mode)) {
2066 /* stat - dir */
2067 is_dir = 1;
2068 } else if (S_ISREG(st.st_mode)) {
2069 /* stat - file */
2070 is_reg = 1;
2071 }
2072 } else if (file->d_type == DT_DIR) {
2073 /* dirent - dir */
2074 is_dir = 1;
2075 } else if (file->d_type == DT_REG) {
2076 /* dirent - file */
2077 is_reg = 1;
2078 }
2079
2080 if (is_dir && (dirs->count || !implicit_cwd)) {
2081 /* we have another subdirectory in searchpath to explore,
2082 * subdirectories are not taken into account in current working dir (dirs->set.g[0]) */
2083 if (!str && (asprintf(&str, "%s/%s", wd, file->d_name) == -1)) {
2084 LOGMEM(NULL);
2085 rc = LY_EMEM;
2086 goto cleanup;
2087 }
2088 if ((rc = ly_set_add(dirs, str, 0, NULL))) {
2089 goto cleanup;
2090 }
2091 str = NULL;
2092
2093 /* continue with the next item in current directory */
2094 *skip = 1;
2095 } else if (!is_reg) {
2096 /* not a regular file (note that we see the target of symlinks instead of symlinks */
2097 *skip = 1;
2098 }
2099
2100cleanup:
2101 free(str);
2102 return rc;
2103}
2104
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01002105LIBYANG_API_DEF LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02002106lys_search_localfile(const char * const *searchpaths, ly_bool cwd, const char *name, const char *revision,
Radek Krejci0f969882020-08-21 16:56:47 +02002107 char **localfile, LYS_INFORMAT *format)
Radek Krejcid33273d2018-10-25 14:55:52 +02002108{
Radek Krejci1deb5be2020-08-26 16:43:36 +02002109 LY_ERR ret = LY_EMEM;
Radek Krejcid33273d2018-10-25 14:55:52 +02002110 size_t len, flen, match_len = 0, dir_len;
Michal Vasko9c49d882024-01-23 11:34:56 +01002111 ly_bool implicit_cwd = 0, skip;
2112 char *wd;
Radek Krejcid33273d2018-10-25 14:55:52 +02002113 DIR *dir = NULL;
2114 struct dirent *file;
2115 char *match_name = NULL;
2116 LYS_INFORMAT format_aux, match_format = 0;
2117 struct ly_set *dirs;
Radek Krejcid33273d2018-10-25 14:55:52 +02002118
2119 LY_CHECK_ARG_RET(NULL, localfile, LY_EINVAL);
2120
2121 /* start to fill the dir fifo with the context's search path (if set)
2122 * and the current working directory */
Radek Krejciba03a5a2020-08-27 14:40:41 +02002123 LY_CHECK_RET(ly_set_new(&dirs));
Radek Krejcid33273d2018-10-25 14:55:52 +02002124
2125 len = strlen(name);
2126 if (cwd) {
2127 wd = get_current_dir_name();
2128 if (!wd) {
2129 LOGMEM(NULL);
2130 goto cleanup;
2131 } else {
2132 /* add implicit current working directory (./) to be searched,
2133 * this directory is not searched recursively */
Radek Krejciba03a5a2020-08-27 14:40:41 +02002134 ret = ly_set_add(dirs, wd, 0, NULL);
2135 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02002136 implicit_cwd = 1;
2137 }
2138 }
2139 if (searchpaths) {
Radek Krejci1deb5be2020-08-26 16:43:36 +02002140 for (uint64_t i = 0; searchpaths[i]; i++) {
Radek Krejcid33273d2018-10-25 14:55:52 +02002141 /* check for duplicities with the implicit current working directory */
2142 if (implicit_cwd && !strcmp(dirs->objs[0], searchpaths[i])) {
2143 implicit_cwd = 0;
2144 continue;
2145 }
2146 wd = strdup(searchpaths[i]);
2147 if (!wd) {
2148 LOGMEM(NULL);
2149 goto cleanup;
Radek Krejciba03a5a2020-08-27 14:40:41 +02002150 } else {
2151 ret = ly_set_add(dirs, wd, 0, NULL);
2152 LY_CHECK_GOTO(ret, cleanup);
Radek Krejcid33273d2018-10-25 14:55:52 +02002153 }
2154 }
2155 }
2156 wd = NULL;
2157
2158 /* start searching */
2159 while (dirs->count) {
2160 free(wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02002161
2162 dirs->count--;
2163 wd = (char *)dirs->objs[dirs->count];
2164 dirs->objs[dirs->count] = NULL;
Radek Krejcieeee95c2021-01-19 10:57:22 +01002165 LOGVRB("Searching for \"%s\" in \"%s\".", name, wd);
Radek Krejcid33273d2018-10-25 14:55:52 +02002166
2167 if (dir) {
2168 closedir(dir);
2169 }
2170 dir = opendir(wd);
2171 dir_len = strlen(wd);
2172 if (!dir) {
2173 LOGWRN(NULL, "Unable to open directory \"%s\" for searching (sub)modules (%s).", wd, strerror(errno));
Michal Vaskob89abc02024-01-19 09:36:13 +01002174 continue;
2175 }
2176
2177 /* search the directory */
2178 while ((file = readdir(dir))) {
2179 if (!strcmp(".", file->d_name) || !strcmp("..", file->d_name)) {
2180 /* skip . and .. */
2181 continue;
2182 }
2183
Michal Vasko9c49d882024-01-23 11:34:56 +01002184 /* check whether file type is */
2185 if ((ret = lys_search_localfile_file_type(file, wd, dirs, implicit_cwd, &skip))) {
2186 goto cleanup;
Michal Vaskob89abc02024-01-19 09:36:13 +01002187 }
Radek Krejcid33273d2018-10-25 14:55:52 +02002188
Michal Vaskob89abc02024-01-19 09:36:13 +01002189 /* here we know that the item is a file which can contain a module */
2190 if (strncmp(name, file->d_name, len) || ((file->d_name[len] != '.') && (file->d_name[len] != '@'))) {
2191 /* different filename than the module we search for */
2192 continue;
2193 }
Radek Krejcid33273d2018-10-25 14:55:52 +02002194
Michal Vaskob89abc02024-01-19 09:36:13 +01002195 /* get type according to filename suffix */
2196 flen = strlen(file->d_name);
2197 if ((flen >= LY_YANG_SUFFIX_LEN + 1) && !strcmp(&file->d_name[flen - LY_YANG_SUFFIX_LEN], LY_YANG_SUFFIX)) {
2198 format_aux = LYS_IN_YANG;
2199 } else if ((flen >= LY_YIN_SUFFIX_LEN + 1) && !strcmp(&file->d_name[flen - LY_YIN_SUFFIX_LEN], LY_YIN_SUFFIX)) {
2200 format_aux = LYS_IN_YIN;
2201 } else {
2202 /* not supported suffix/file format */
2203 continue;
2204 }
2205
2206 if (revision) {
2207 /* we look for the specific revision, try to get it from the filename */
2208 if (file->d_name[len] == '@') {
2209 /* check revision from the filename */
2210 if (strncmp(revision, &file->d_name[len + 1], strlen(revision))) {
2211 /* another revision */
2212 continue;
Radek Krejcid33273d2018-10-25 14:55:52 +02002213 } else {
Michal Vaskob89abc02024-01-19 09:36:13 +01002214 /* exact revision */
Radek Krejcid33273d2018-10-25 14:55:52 +02002215 free(match_name);
Michal Vaskob89abc02024-01-19 09:36:13 +01002216 if (asprintf(&match_name, "%s/%s", wd, file->d_name) == -1) {
2217 LOGMEM(NULL);
2218 goto cleanup;
2219 }
Michal Vasko44f3d2c2020-08-24 09:49:38 +02002220 match_len = dir_len + 1 + len;
Radek Krejcid33273d2018-10-25 14:55:52 +02002221 match_format = format_aux;
Michal Vaskob89abc02024-01-19 09:36:13 +01002222 goto success;
Radek Krejcid33273d2018-10-25 14:55:52 +02002223 }
2224 } else {
Michal Vaskob89abc02024-01-19 09:36:13 +01002225 /* continue trying to find exact revision match, use this only if not found */
2226 free(match_name);
2227 if (asprintf(&match_name, "%s/%s", wd, file->d_name) == -1) {
2228 LOGMEM(NULL);
2229 goto cleanup;
Radek Krejcid33273d2018-10-25 14:55:52 +02002230 }
Radek Krejcid33273d2018-10-25 14:55:52 +02002231 match_len = dir_len + 1 + len;
2232 match_format = format_aux;
2233 continue;
2234 }
Michal Vaskob89abc02024-01-19 09:36:13 +01002235 } else {
2236 /* remember the revision and try to find the newest one */
2237 if (match_name) {
2238 if ((file->d_name[len] != '@') ||
2239 lysp_check_date(NULL, &file->d_name[len + 1],
2240 flen - ((format_aux == LYS_IN_YANG) ? LY_YANG_SUFFIX_LEN : LY_YIN_SUFFIX_LEN) - len - 1, NULL)) {
2241 continue;
2242 } else if ((match_name[match_len] == '@') &&
2243 (strncmp(&match_name[match_len + 1], &file->d_name[len + 1], LY_REV_SIZE - 1) >= 0)) {
2244 continue;
2245 }
2246 free(match_name);
2247 }
2248
2249 if (asprintf(&match_name, "%s/%s", wd, file->d_name) == -1) {
2250 LOGMEM(NULL);
2251 goto cleanup;
2252 }
2253 match_len = dir_len + 1 + len;
2254 match_format = format_aux;
2255 continue;
Radek Krejcid33273d2018-10-25 14:55:52 +02002256 }
2257 }
2258 }
2259
2260success:
2261 (*localfile) = match_name;
2262 match_name = NULL;
2263 if (format) {
2264 (*format) = match_format;
2265 }
Radek Krejci1deb5be2020-08-26 16:43:36 +02002266 ret = LY_SUCCESS;
Radek Krejcid33273d2018-10-25 14:55:52 +02002267
2268cleanup:
Radek Krejcid33273d2018-10-25 14:55:52 +02002269 free(wd);
2270 if (dir) {
2271 closedir(dir);
2272 }
2273 free(match_name);
2274 ly_set_free(dirs, free);
2275
2276 return ret;
2277}