blob: 307dde7627f9356ec68b6f94e6dc313621400390 [file] [log] [blame]
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001/**
2 * @file context.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vasko19a09022021-06-15 11:54:08 +02004 * @author Michal Vasko <mvasko@cesnet.cz>
Radek Krejci0af5f5d2018-09-07 15:00:30 +02005 * @brief Context implementations
6 *
Michal Vasko88ccd582023-03-30 11:50:57 +02007 * Copyright (c) 2015 - 2023 CESNET, z.s.p.o.
Radek Krejci0af5f5d2018-09-07 15:00:30 +02008 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
Christian Hopps32874e12021-05-01 09:43:54 -040015#define _GNU_SOURCE /* asprintf, strdup */
Radek Krejcid43298b2021-03-25 16:17:15 +010016#if defined (__NetBSD__) || defined (__OpenBSD__)
Christian Hoppsf9b87412021-04-12 16:56:15 -040017/* realpath */
18#define _XOPEN_SOURCE 1
19#define _XOPEN_SOURCE_EXTENDED 1
Christian Hopps6f326212021-03-23 12:37:29 -040020#endif
21
Radek Krejci535ea9f2020-05-29 16:01:05 +020022#include "context.h"
Radek Krejcib7db73a2018-10-24 14:18:40 +020023
Michal Vaskodf6319c2021-06-10 14:41:05 +020024#include <assert.h>
Radek Krejci0af5f5d2018-09-07 15:00:30 +020025#include <errno.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include <pthread.h>
Radek Krejci0aa1f702021-04-01 16:16:19 +020027#include <stdarg.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020028#include <stddef.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020029#include <stdio.h>
Radek Krejci7ada9a02018-09-07 15:34:05 +020030#include <stdlib.h>
31#include <string.h>
Radek Krejci0e212402018-09-20 11:29:38 +020032#include <sys/stat.h>
Radek Krejci0af5f5d2018-09-07 15:00:30 +020033#include <unistd.h>
34
Radek Krejciaa45bda2020-07-20 07:43:38 +020035#include "compat.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020036#include "hash_table.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020037#include "in.h"
Michal Vasko8f702ee2024-02-20 15:44:24 +010038#include "ly_common.h"
Radek Krejci7931b192020-06-25 17:05:03 +020039#include "parser_data.h"
Radek Krejci3e6632f2021-03-22 22:08:21 +010040#include "plugins_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020041#include "plugins_types.h"
Michal Vasko405cc9e2020-12-01 12:01:27 +010042#include "schema_compile.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020043#include "set.h"
44#include "tree.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020045#include "tree_data.h"
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +020046#include "tree_data_internal.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020047#include "tree_schema.h"
Michal Vaskoc636ea42022-09-16 10:20:31 +020048#include "tree_schema_free.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020049#include "tree_schema_internal.h"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020050
Michal Vaskocf296c82020-05-27 11:16:45 +020051#include "../models/ietf-datastores@2018-02-14.h"
Michal Vasko69730152020-10-09 16:30:07 +020052#include "../models/ietf-inet-types@2013-07-15.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020053#include "../models/ietf-yang-library@2019-01-04.h"
Michal Vasko69730152020-10-09 16:30:07 +020054#include "../models/ietf-yang-metadata@2016-08-05.h"
tadeas-vintrlik2aa36b42021-11-03 13:07:34 +010055#include "../models/ietf-yang-schema-mount@2019-01-14.h"
Michal Vaskoedb0fa52022-10-04 10:36:00 +020056#include "../models/ietf-yang-structure-ext@2020-06-17.h"
Michal Vasko69730152020-10-09 16:30:07 +020057#include "../models/ietf-yang-types@2013-07-15.h"
Michal Vasko79a7a872022-06-17 09:00:48 +020058#include "../models/yang@2022-06-16.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020059#define IETF_YANG_LIB_REV "2019-01-04"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020060
Radek Krejci0af5f5d2018-09-07 15:00:30 +020061static struct internal_modules_s {
62 const char *name;
63 const char *revision;
64 const char *data;
Radek Krejci857189e2020-09-01 13:26:36 +020065 ly_bool implemented;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020066 LYS_INFORMAT format;
Michal Vaskode79e222020-08-10 11:55:46 +020067} internal_modules[] = {
Michal Vasko1de593f2020-11-23 16:11:41 +010068 {"ietf-yang-metadata", "2016-08-05", (const char *)ietf_yang_metadata_2016_08_05_yang, 0, LYS_IN_YANG},
Michal Vasko79a7a872022-06-17 09:00:48 +020069 {"yang", "2022-06-16", (const char *)yang_2022_06_16_yang, 1, LYS_IN_YANG},
Michal Vasko22df3f02020-08-24 13:29:22 +020070 {"ietf-inet-types", "2013-07-15", (const char *)ietf_inet_types_2013_07_15_yang, 0, LYS_IN_YANG},
71 {"ietf-yang-types", "2013-07-15", (const char *)ietf_yang_types_2013_07_15_yang, 0, LYS_IN_YANG},
tadeas-vintrlik2aa36b42021-11-03 13:07:34 +010072 {"ietf-yang-schema-mount", "2019-01-14", (const char *)ietf_yang_schema_mount_2019_01_14_yang, 1, LYS_IN_YANG},
Michal Vaskoedb0fa52022-10-04 10:36:00 +020073 {"ietf-yang-structure-ext", "2020-06-17", (const char *)ietf_yang_structure_ext_2020_06_17_yang, 0, LYS_IN_YANG},
Radek Krejci0af5f5d2018-09-07 15:00:30 +020074 /* ietf-datastores and ietf-yang-library must be right here at the end of the list! */
Michal Vasko22df3f02020-08-24 13:29:22 +020075 {"ietf-datastores", "2018-02-14", (const char *)ietf_datastores_2018_02_14_yang, 1, LYS_IN_YANG},
76 {"ietf-yang-library", IETF_YANG_LIB_REV, (const char *)ietf_yang_library_2019_01_04_yang, 1, LYS_IN_YANG}
Radek Krejci0af5f5d2018-09-07 15:00:30 +020077};
78
Michal Vaskode79e222020-08-10 11:55:46 +020079#define LY_INTERNAL_MODS_COUNT sizeof(internal_modules) / sizeof(struct internal_modules_s)
80
Jan Kundrátc53a7ec2021-12-09 16:01:19 +010081LIBYANG_API_DEF LY_ERR
Radek Krejci0af5f5d2018-09-07 15:00:30 +020082ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir)
83{
Radek Krejci0e212402018-09-20 11:29:38 +020084 struct stat st;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020085 char *new_dir = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020086
87 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
88
89 if (search_dir) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +020090 new_dir = realpath(search_dir, NULL);
Radek Krejcia77e0e12018-09-20 12:39:15 +020091 LY_CHECK_ERR_RET(!new_dir,
Michal Vasko69730152020-10-09 16:30:07 +020092 LOGERR(ctx, LY_ESYS, "Unable to use search directory \"%s\" (%s).", search_dir, strerror(errno)),
93 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020094 if (strcmp(search_dir, new_dir)) {
Michal Vasko6e63ca92021-06-24 09:22:44 +020095 LOGVRB("Search directory string \"%s\" canonized to \"%s\".", search_dir, new_dir);
Radek Krejci3a077b92019-04-09 17:10:35 +020096 }
97 LY_CHECK_ERR_RET(access(new_dir, R_OK | X_OK),
Michal Vasko69730152020-10-09 16:30:07 +020098 LOGERR(ctx, LY_ESYS, "Unable to fully access search directory \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
99 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +0200100 LY_CHECK_ERR_RET(stat(new_dir, &st),
Michal Vasko69730152020-10-09 16:30:07 +0200101 LOGERR(ctx, LY_ESYS, "stat() failed for \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
102 LY_ESYS);
Radek Krejci3a077b92019-04-09 17:10:35 +0200103 LY_CHECK_ERR_RET(!S_ISDIR(st.st_mode),
Michal Vasko69730152020-10-09 16:30:07 +0200104 LOGERR(ctx, LY_ESYS, "Given search directory \"%s\" is not a directory.", new_dir); free(new_dir),
105 LY_EINVAL);
Radek Krejci0e212402018-09-20 11:29:38 +0200106 /* avoid path duplication */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200107 for (uint32_t u = 0; u < ctx->search_paths.count; ++u) {
Radek Krejci14946ab2018-09-20 13:42:06 +0200108 if (!strcmp(new_dir, ctx->search_paths.objs[u])) {
Radek Krejci0e212402018-09-20 11:29:38 +0200109 free(new_dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200110 return LY_EEXIST;
Radek Krejci0e212402018-09-20 11:29:38 +0200111 }
112 }
Radek Krejci3d92e442020-10-12 12:48:13 +0200113 if (ly_set_add(&ctx->search_paths, new_dir, 1, NULL)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200114 free(new_dir);
115 return LY_EMEM;
116 }
117
Michal Vaskod9ad7a32024-01-22 11:05:43 +0100118 /* new searchdir - reset latests flags (possibly new revisions available) */
119 for (uint32_t v = 0; v < ctx->list.count; ++v) {
120 struct lys_module *mod = ctx->list.objs[v];
121
122 mod->latest_revision &= ~LYS_MOD_LATEST_SEARCHDIRS;
123 if (mod->parsed && mod->parsed->includes) {
124 for (LY_ARRAY_COUNT_TYPE u = 0; u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
125 mod->parsed->includes[u].submodule->latest_revision &= ~LYS_MOD_LATEST_SEARCHDIRS;
126 }
127 }
128 }
Radek Krejcie9e987e2018-10-31 12:50:27 +0100129
Radek Krejci0e212402018-09-20 11:29:38 +0200130 return LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200131 } else {
132 /* consider that no change is not actually an error */
133 return LY_SUCCESS;
134 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200135}
136
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100137LIBYANG_API_DEF const char * const *
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200138ly_ctx_get_searchdirs(const struct ly_ctx *ctx)
139{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100140#define LY_CTX_SEARCHDIRS_SIZE_STEP 8
Radek Krejci05026432018-09-20 12:13:43 +0200141 void **new;
142
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200143 LY_CHECK_ARG_RET(ctx, ctx, NULL);
Radek Krejci05026432018-09-20 12:13:43 +0200144
145 if (ctx->search_paths.count == ctx->search_paths.size) {
146 /* not enough space for terminating NULL byte */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100147 new = realloc(((struct ly_ctx *)ctx)->search_paths.objs,
148 (ctx->search_paths.size + LY_CTX_SEARCHDIRS_SIZE_STEP) * sizeof *ctx->search_paths.objs);
Radek Krejci05026432018-09-20 12:13:43 +0200149 LY_CHECK_ERR_RET(!new, LOGMEM(NULL), NULL);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100150 ((struct ly_ctx *)ctx)->search_paths.size += LY_CTX_SEARCHDIRS_SIZE_STEP;
Radek Krejci05026432018-09-20 12:13:43 +0200151 ((struct ly_ctx *)ctx)->search_paths.objs = new;
152 }
153 /* set terminating NULL byte to the strings list */
154 ctx->search_paths.objs[ctx->search_paths.count] = NULL;
155
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200156 return (const char * const *)ctx->search_paths.objs;
157}
158
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100159LIBYANG_API_DEF LY_ERR
Radek Krejcie58f97f2020-08-18 11:45:08 +0200160ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200161{
Radek Krejcicd649072018-09-20 12:14:45 +0200162 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Radek Krejcicd649072018-09-20 12:14:45 +0200163
Michal Vaskob34480a2018-09-17 10:34:45 +0200164 if (!ctx->search_paths.count) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200165 return LY_SUCCESS;
166 }
167
Radek Krejci0759b792018-09-20 13:53:15 +0200168 if (value) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200169 /* remove specific search directory */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200170 uint32_t index;
171
Radek Krejci0759b792018-09-20 13:53:15 +0200172 for (index = 0; index < ctx->search_paths.count; ++index) {
173 if (!strcmp(value, ctx->search_paths.objs[index])) {
174 break;
175 }
176 }
177 if (index == ctx->search_paths.count) {
178 LOGARG(ctx, value);
179 return LY_EINVAL;
180 } else {
181 return ly_set_rm_index(&ctx->search_paths, index, free);
182 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200183 } else {
184 /* remove them all */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200185 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200186 memset(&ctx->search_paths, 0, sizeof ctx->search_paths);
187 }
188
189 return LY_SUCCESS;
190}
191
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100192LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200193ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count)
Radek Krejcied5acc52019-04-25 15:57:04 +0200194{
195 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
196
Radek Krejcie58f97f2020-08-18 11:45:08 +0200197 for ( ; count > 0 && ctx->search_paths.count; --count) {
198 LY_CHECK_RET(ly_set_rm_index(&ctx->search_paths, ctx->search_paths.count - 1, free))
Radek Krejcied5acc52019-04-25 15:57:04 +0200199 }
200
201 return LY_SUCCESS;
202}
203
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100204LIBYANG_API_DEF struct lys_module *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100205ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision, const char **features)
Radek Krejcied5acc52019-04-25 15:57:04 +0200206{
Michal Vasko88497502021-06-10 14:41:51 +0200207 struct lys_module *mod = NULL;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100208 LY_ERR ret = LY_SUCCESS;
Radek Krejcied5acc52019-04-25 15:57:04 +0200209
210 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
211
Michal Vaskodd992582021-06-10 14:34:57 +0200212 /* load and parse */
Michal Vasko22b26222021-07-30 11:16:47 +0200213 ret = lys_parse_load(ctx, name, revision, &ctx->unres.creating, &mod);
Michal Vaskodd992582021-06-10 14:34:57 +0200214 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko4e205e82021-06-08 14:01:47 +0200215
216 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +0200217 ret = _lys_set_implemented(mod, features, &ctx->unres);
Michal Vasko65333882021-06-10 14:12:16 +0200218 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100219
Michal Vaskof4258e12021-06-15 12:11:42 +0200220 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
221 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +0200222 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +0200223
Michal Vasko709f9a52021-07-21 10:51:59 +0200224 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +0200225 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
226
227 /* unres resolved */
228 lys_unres_glob_erase(&ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +0200229 }
230
Michal Vasko405cc9e2020-12-01 12:01:27 +0100231cleanup:
232 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +0200233 lys_unres_glob_revert(ctx, &ctx->unres);
234 lys_unres_glob_erase(&ctx->unres);
Michal Vaskodf6319c2021-06-10 14:41:05 +0200235 mod = NULL;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100236 }
Michal Vaskodf6319c2021-06-10 14:41:05 +0200237 return mod;
Radek Krejcied5acc52019-04-25 15:57:04 +0200238}
239
Michal Vasko88ccd582023-03-30 11:50:57 +0200240/**
241 * @brief Hash table value-equal callback for comparing context error hash table record.
242 */
243static ly_bool
244ly_ctx_ht_err_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
245{
246 struct ly_ctx_err_rec *err1 = val1_p, *err2 = val2_p;
247
Michal Vasko98447572023-03-30 12:08:29 +0200248 return !memcmp(&err1->tid, &err2->tid, sizeof err1->tid);
Michal Vasko88ccd582023-03-30 11:50:57 +0200249}
250
stewegf9041a22024-01-18 13:29:12 +0100251/**
252 * @brief Hash table value-equal callback for comparing leafref links hash table record.
253 */
254static ly_bool
255ly_ctx_ht_leafref_links_equal_cb(void *val1_p, void *val2_p, ly_bool UNUSED(mod), void *UNUSED(cb_data))
256{
257 struct lyd_leafref_links_rec *rec1 = val1_p, *rec2 = val2_p;
258
259 return rec1->node == rec2->node;
260}
261
262/**
263 * @brief Callback for freeing leafref links recorcd internal resources.
264 *
265 * @param[in] val_p Pointer to leafref links record
266 */
267static void
268ly_ctx_ht_leafref_links_rec_free(void *val_p)
269{
270 struct lyd_leafref_links_rec *rec = val_p;
271
272 lyd_free_leafref_links_rec(rec);
273}
274
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100275LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200276ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200277{
278 struct ly_ctx *ctx = NULL;
279 struct lys_module *module;
Michal Vaskoc56d6372021-10-19 12:29:00 +0200280 char *search_dir_list, *sep, *dir;
281 const char **imp_f, *all_f[] = {"*", NULL};
Michal Vaskode79e222020-08-10 11:55:46 +0200282 uint32_t i;
Michal Vasko63f3d842020-07-08 10:10:14 +0200283 struct ly_in *in = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200284 LY_ERR rc = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100285 struct lys_glob_unres unres = {0};
stewegd4cde642024-02-21 08:34:16 +0100286 ly_bool builtin_plugins_only;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200287
Radek Krejcied5acc52019-04-25 15:57:04 +0200288 LY_CHECK_ARG_RET(NULL, new_ctx, LY_EINVAL);
289
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200290 ctx = calloc(1, sizeof *ctx);
Michal Vasko88497502021-06-10 14:41:51 +0200291 LY_CHECK_ERR_GOTO(!ctx, LOGMEM(NULL); rc = LY_EMEM, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200292
293 /* dictionary */
294 lydict_init(&ctx->dict);
295
296 /* plugins */
stewegd4cde642024-02-21 08:34:16 +0100297 builtin_plugins_only = (options & LY_CTX_BUILTIN_PLUGINS_ONLY) ? 1 : 0;
298 LY_CHECK_ERR_GOTO(lyplg_init(builtin_plugins_only), LOGINT(NULL); rc = LY_EINT, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200299
stewegf9041a22024-01-18 13:29:12 +0100300 if (options & LY_CTX_LEAFREF_LINKING) {
301 ctx->leafref_links_ht = lyht_new(1, sizeof(struct lyd_leafref_links_rec), ly_ctx_ht_leafref_links_equal_cb, NULL, 1);
302 LY_CHECK_ERR_GOTO(!ctx->leafref_links_ht, rc = LY_EMEM, cleanup);
303 }
304
Michal Vasko88ccd582023-03-30 11:50:57 +0200305 /* initialize thread-specific error hash table */
306 ctx->err_ht = lyht_new(1, sizeof(struct ly_ctx_err_rec), ly_ctx_ht_err_equal_cb, NULL, 1);
307 LY_CHECK_ERR_GOTO(!ctx->err_ht, rc = LY_EMEM, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200308
Michal Vasko11f76c82021-04-15 14:36:14 +0200309 /* init LYB hash lock */
310 pthread_mutex_init(&ctx->lyb_hash_lock, NULL);
311
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200312 /* models list */
313 ctx->flags = options;
314 if (search_dir) {
315 search_dir_list = strdup(search_dir);
Michal Vasko88497502021-06-10 14:41:51 +0200316 LY_CHECK_ERR_GOTO(!search_dir_list, LOGMEM(NULL); rc = LY_EMEM, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200317
Jan Kundrát34bb9282021-12-13 18:45:50 +0100318 for (dir = search_dir_list; (sep = strchr(dir, PATH_SEPARATOR[0])) != NULL && rc == LY_SUCCESS; dir = sep + 1) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200319 *sep = 0;
320 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200321 if (rc == LY_EEXIST) {
322 /* ignore duplication */
323 rc = LY_SUCCESS;
324 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200325 }
Michal Vasko69730152020-10-09 16:30:07 +0200326 if (*dir && (rc == LY_SUCCESS)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200327 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200328 if (rc == LY_EEXIST) {
329 /* ignore duplication */
330 rc = LY_SUCCESS;
331 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200332 }
333 free(search_dir_list);
334
335 /* If ly_ctx_set_searchdir() failed, the error is already logged. Just exit */
Michal Vasko88497502021-06-10 14:41:51 +0200336 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200337 }
Michal Vasko794ab4b2021-03-31 09:42:19 +0200338 ctx->change_count = 1;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200339
Michal Vasko9434ec52021-04-19 11:30:55 +0200340 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
341 /* use it for creating the initial context */
342 ctx->flags |= LY_CTX_EXPLICIT_COMPILE;
343 }
344
Michal Vasko63f3d842020-07-08 10:10:14 +0200345 /* create dummy in */
346 rc = ly_in_new_memory(internal_modules[0].data, &in);
Michal Vasko88497502021-06-10 14:41:51 +0200347 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko63f3d842020-07-08 10:10:14 +0200348
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200349 /* load internal modules */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200350 for (i = 0; i < ((options & LY_CTX_NO_YANGLIBRARY) ? (LY_INTERNAL_MODS_COUNT - 2) : LY_INTERNAL_MODS_COUNT); i++) {
Michal Vasko63f3d842020-07-08 10:10:14 +0200351 ly_in_memory(in, internal_modules[i].data);
Michal Vaskodd992582021-06-10 14:34:57 +0200352 LY_CHECK_GOTO(rc = lys_parse_in(ctx, in, internal_modules[i].format, NULL, NULL, &unres.creating, &module), cleanup);
Michal Vasko4e205e82021-06-08 14:01:47 +0200353 if (internal_modules[i].implemented || (ctx->flags & LY_CTX_ALL_IMPLEMENTED)) {
Michal Vaskoc56d6372021-10-19 12:29:00 +0200354 imp_f = (ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
355 LY_CHECK_GOTO(rc = lys_implement(module, imp_f, &unres), cleanup);
Michal Vasko4e205e82021-06-08 14:01:47 +0200356 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200357 }
358
Michal Vasko9434ec52021-04-19 11:30:55 +0200359 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
360 /* compile now */
Michal Vasko88497502021-06-10 14:41:51 +0200361 LY_CHECK_GOTO(rc = ly_ctx_compile(ctx), cleanup);
Michal Vasko9434ec52021-04-19 11:30:55 +0200362 ctx->flags &= ~LY_CTX_EXPLICIT_COMPILE;
363 }
364
Michal Vasko88497502021-06-10 14:41:51 +0200365cleanup:
Michal Vasko63f3d842020-07-08 10:10:14 +0200366 ly_in_free(in, 0);
Michal Vaskof4258e12021-06-15 12:11:42 +0200367 lys_unres_glob_erase(&unres);
Michal Vaskodf6319c2021-06-10 14:41:05 +0200368 if (rc) {
369 ly_ctx_destroy(ctx);
370 } else {
371 *new_ctx = ctx;
372 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200373 return rc;
374}
Radek Krejci0f969882020-08-21 16:56:47 +0200375
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200376static LY_ERR
Michal Vaskoddd76592022-01-17 13:34:48 +0100377ly_ctx_new_yl_legacy(struct ly_ctx *ctx, const struct lyd_node *yltree)
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200378{
379 struct lyd_node *module, *node;
380 struct ly_set *set;
381 const char **feature_arr = NULL;
382 const char *name = NULL, *revision = NULL;
383 struct ly_set features = {0};
384 ly_bool imported = 0;
385 const struct lys_module *mod;
386 LY_ERR ret = LY_SUCCESS;
Michal Vaskoddd76592022-01-17 13:34:48 +0100387 uint32_t i, j;
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200388
389 LY_CHECK_RET(ret = lyd_find_xpath(yltree, "/ietf-yang-library:yang-library/modules-state/module", &set));
390
391 /* process the data tree */
Michal Vaskoddd76592022-01-17 13:34:48 +0100392 for (i = 0; i < set->count; ++i) {
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200393 module = set->dnodes[i];
394
395 /* initiate */
396 revision = NULL;
397 name = NULL;
398 imported = 0;
399
400 LY_LIST_FOR(lyd_child(module), node) {
401 if (!strcmp(node->schema->name, "name")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200402 name = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200403 } else if (!strcmp(node->schema->name, "revision")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200404 revision = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200405 } else if (!strcmp(node->schema->name, "feature")) {
406 LY_CHECK_GOTO(ret = ly_set_add(&features, node, 0, NULL), cleanup);
407 } else if (!strcmp(node->schema->name, "conformance-type") &&
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200408 !strcmp(lyd_get_value(node), "import")) {
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200409 /* imported module - skip it, it will be loaded as a side effect
410 * of loading another module */
411 imported = 1;
412 break;
413 }
414 }
415
416 if (imported) {
417 continue;
418 }
419
420 feature_arr = malloc((features.count + 1) * sizeof *feature_arr);
421 LY_CHECK_ERR_GOTO(!feature_arr, ret = LY_EMEM, cleanup);
422
423 /* Parse features into an array of strings */
Michal Vaskoddd76592022-01-17 13:34:48 +0100424 for (j = 0; j < features.count; ++j) {
425 feature_arr[j] = lyd_get_value(features.dnodes[j]);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200426 }
427 feature_arr[features.count] = NULL;
428 ly_set_clean(&features, free);
429
430 /* use the gathered data to load the module */
431 mod = ly_ctx_load_module(ctx, name, revision, feature_arr);
432 free(feature_arr);
433 if (!mod) {
434 LOGERR(ctx, LY_EINVAL, "Unable to load module specified by yang library data.");
435 ly_set_free(set, free);
436 return LY_EINVAL;
437 }
438 }
439
440cleanup:
441 ly_set_clean(&features, free);
442 ly_set_free(set, free);
443 return ret;
444}
445
Michal Vaskoddd76592022-01-17 13:34:48 +0100446LIBYANG_API_DEF LY_ERR
447ly_ctx_new_ylpath(const char *search_dir, const char *path, LYD_FORMAT format, int options, struct ly_ctx **ctx)
448{
449 LY_ERR ret = LY_SUCCESS;
450 struct ly_ctx *ctx_yl = NULL;
451 struct lyd_node *data_yl = NULL;
452
453 LY_CHECK_ARG_RET(NULL, path, ctx, LY_EINVAL);
454
455 /* create a seperate context for the data */
456 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, 0, &ctx_yl), cleanup);
457
458 /* parse yang library data tree */
459 LY_CHECK_GOTO(ret = lyd_parse_data_path(ctx_yl, path, format, 0, LYD_VALIDATE_PRESENT, &data_yl), cleanup);
460
461 /* create the new context */
462 ret = ly_ctx_new_yldata(search_dir, data_yl, options, ctx);
463
464cleanup:
465 lyd_free_all(data_yl);
466 ly_ctx_destroy(ctx_yl);
467 return ret;
468}
469
470LIBYANG_API_DEF LY_ERR
471ly_ctx_new_ylmem(const char *search_dir, const char *data, LYD_FORMAT format, int options, struct ly_ctx **ctx)
472{
473 LY_ERR ret = LY_SUCCESS;
474 struct ly_ctx *ctx_yl = NULL;
475 struct lyd_node *data_yl = NULL;
476
477 LY_CHECK_ARG_RET(NULL, data, ctx, LY_EINVAL);
478
479 /* create a seperate context for the data */
480 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, 0, &ctx_yl), cleanup);
481
482 /* parse yang library data tree */
483 LY_CHECK_GOTO(ret = lyd_parse_data_mem(ctx_yl, data, format, 0, LYD_VALIDATE_PRESENT, &data_yl), cleanup);
484
485 /* create the new context */
486 ret = ly_ctx_new_yldata(search_dir, data_yl, options, ctx);
487
488cleanup:
489 lyd_free_all(data_yl);
490 ly_ctx_destroy(ctx_yl);
491 return ret;
492}
493
494LIBYANG_API_DEF LY_ERR
495ly_ctx_new_yldata(const char *search_dir, const struct lyd_node *tree, int options, struct ly_ctx **ctx)
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200496{
497 const char *name = NULL, *revision = NULL;
498 struct lyd_node *module, *node;
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200499 struct ly_set *set = NULL;
500 const char **feature_arr = NULL;
501 struct ly_set features = {0};
502 LY_ERR ret = LY_SUCCESS;
503 const struct lys_module *mod;
Michal Vaskoddd76592022-01-17 13:34:48 +0100504 struct ly_ctx *ctx_new = NULL;
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200505 ly_bool no_expl_compile = 0;
Michal Vaskoddd76592022-01-17 13:34:48 +0100506 uint32_t i, j;
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200507
Michal Vaskoddd76592022-01-17 13:34:48 +0100508 LY_CHECK_ARG_RET(NULL, tree, ctx, LY_EINVAL);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200509
Michal Vaskoddd76592022-01-17 13:34:48 +0100510 /* create a new context */
ekinzie0ab8b302022-10-10 03:03:57 -0400511 if (*ctx == NULL) {
512 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, options, &ctx_new), cleanup);
513 } else {
514 ctx_new = *ctx;
515 }
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200516
517 /* redundant to compile modules one-by-one */
518 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
519 ctx_new->flags |= LY_CTX_EXPLICIT_COMPILE;
520 no_expl_compile = 1;
521 }
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200522
Michal Vaskoddd76592022-01-17 13:34:48 +0100523 LY_CHECK_GOTO(ret = lyd_find_xpath(tree, "/ietf-yang-library:yang-library/module-set[1]/module", &set), cleanup);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200524 if (set->count == 0) {
525 /* perhaps a legacy data tree? */
Michal Vaskoddd76592022-01-17 13:34:48 +0100526 LY_CHECK_GOTO(ret = ly_ctx_new_yl_legacy(ctx_new, tree), cleanup);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200527 } else {
528 /* process the data tree */
Michal Vaskoddd76592022-01-17 13:34:48 +0100529 for (i = 0; i < set->count; ++i) {
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200530 module = set->dnodes[i];
531
532 /* initiate */
533 name = NULL;
534 revision = NULL;
535
Michal Vaskoddd76592022-01-17 13:34:48 +0100536 /* iterate over data */
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200537 LY_LIST_FOR(lyd_child(module), node) {
538 if (!strcmp(node->schema->name, "name")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200539 name = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200540 } else if (!strcmp(node->schema->name, "revision")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200541 revision = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200542 } else if (!strcmp(node->schema->name, "feature")) {
543 LY_CHECK_GOTO(ret = ly_set_add(&features, node, 0, NULL), cleanup);
544 }
545 }
546
547 feature_arr = malloc((features.count + 1) * sizeof *feature_arr);
548 LY_CHECK_ERR_GOTO(!feature_arr, ret = LY_EMEM, cleanup);
549
Michal Vaskoddd76592022-01-17 13:34:48 +0100550 /* parse features into an array of strings */
551 for (j = 0; j < features.count; ++j) {
552 feature_arr[j] = lyd_get_value(features.dnodes[j]);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200553 }
554 feature_arr[features.count] = NULL;
555 ly_set_clean(&features, NULL);
556
557 /* use the gathered data to load the module */
558 mod = ly_ctx_load_module(ctx_new, name, revision, feature_arr);
559 free(feature_arr);
560 if (!mod) {
Michal Vasko22e01fa2022-11-02 12:15:15 +0100561 LOGERR(*ctx ? *ctx : LYD_CTX(tree), LY_EINVAL, "Unable to load module %s@%s specified by yang library data.",
562 name, revision ? revision : "<none>");
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200563 ret = LY_EINVAL;
564 goto cleanup;
565 }
566 }
567 }
568
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200569 /* compile */
570 LY_CHECK_GOTO(ret = ly_ctx_compile(ctx_new), cleanup);
571
572 if (no_expl_compile) {
573 /* unset flag */
574 ctx_new->flags &= ~LY_CTX_EXPLICIT_COMPILE;
575 }
576
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200577cleanup:
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200578 ly_set_free(set, NULL);
579 ly_set_erase(&features, NULL);
ekinzie0ab8b302022-10-10 03:03:57 -0400580 if (*ctx == NULL) {
581 *ctx = ctx_new;
582 if (ret) {
583 ly_ctx_destroy(*ctx);
584 *ctx = NULL;
585 }
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200586 }
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200587 return ret;
588}
589
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100590LIBYANG_API_DEF LY_ERR
Michal Vasko01db7de2021-04-16 12:23:30 +0200591ly_ctx_compile(struct ly_ctx *ctx)
592{
Michal Vaskod39bea42021-06-14 10:42:49 +0200593 LY_ERR ret = LY_SUCCESS;
Michal Vasko01db7de2021-04-16 12:23:30 +0200594
595 LY_CHECK_ARG_RET(NULL, ctx, LY_EINVAL);
596
Michal Vaskof4258e12021-06-15 12:11:42 +0200597 /* create dep sets and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +0200598 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, NULL), cleanup);
Michal Vaskod39bea42021-06-14 10:42:49 +0200599
Michal Vaskof4258e12021-06-15 12:11:42 +0200600 /* (re)compile all the dep sets */
Michal Vasko22b26222021-07-30 11:16:47 +0200601 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
Michal Vasko01db7de2021-04-16 12:23:30 +0200602
Michal Vaskod39bea42021-06-14 10:42:49 +0200603cleanup:
Michal Vaskof4258e12021-06-15 12:11:42 +0200604 if (ret) {
605 /* revert changes of modules */
Michal Vasko22b26222021-07-30 11:16:47 +0200606 lys_unres_glob_revert(ctx, &ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +0200607 }
Michal Vasko22b26222021-07-30 11:16:47 +0200608 lys_unres_glob_erase(&ctx->unres);
Michal Vaskod39bea42021-06-14 10:42:49 +0200609 return ret;
Michal Vasko01db7de2021-04-16 12:23:30 +0200610}
611
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100612LIBYANG_API_DEF uint16_t
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200613ly_ctx_get_options(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200614{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200615 LY_CHECK_ARG_RET(ctx, ctx, 0);
Michal Vasko28f1ffe2021-06-15 11:57:23 +0200616
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200617 return ctx->flags;
618}
619
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100620LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200621ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200622{
Michal Vasko01db7de2021-04-16 12:23:30 +0200623 LY_ERR lyrc = LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200624 struct lys_module *mod;
625 uint32_t i;
Radek Krejciddbc4812021-04-13 21:18:02 +0200626
Radek Krejcica828d92018-09-20 14:19:43 +0200627 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vaskoaecb11f2021-10-19 14:02:42 +0200628 LY_CHECK_ERR_RET((option & LY_CTX_NO_YANGLIBRARY) && !(ctx->flags & LY_CTX_NO_YANGLIBRARY),
629 LOGARG(ctx, option), LY_EINVAL);
aPiecek9922ea92021-04-12 07:59:20 +0200630
Michal Vasko9bd131d2024-02-21 09:54:18 +0100631 if (!(ctx->flags & LY_CTX_BUILTIN_PLUGINS_ONLY) && (option & LY_CTX_BUILTIN_PLUGINS_ONLY)) {
632 LOGERR(ctx, LY_EINVAL,
633 "Invalid argument %s (LY_CTX_BUILTIN_PLUGINS_ONLY can be set only when creating a new context) (%s()).",
634 "option", __func__);
635 return LY_EINVAL;
636 }
637
stewegf9041a22024-01-18 13:29:12 +0100638 if (!(ctx->flags & LY_CTX_LEAFREF_LINKING) && (option & LY_CTX_LEAFREF_LINKING)) {
639 ctx->leafref_links_ht = lyht_new(1, sizeof(struct lyd_leafref_links_rec), ly_ctx_ht_leafref_links_equal_cb, NULL, 1);
640 LY_CHECK_ERR_RET(!ctx->leafref_links_ht, LOGARG(ctx, option), LY_EMEM);
641 }
642
aPiecek9922ea92021-04-12 07:59:20 +0200643 if (!(ctx->flags & LY_CTX_SET_PRIV_PARSED) && (option & LY_CTX_SET_PRIV_PARSED)) {
644 ctx->flags |= LY_CTX_SET_PRIV_PARSED;
Michal Vasko7213ac52021-06-15 11:52:13 +0200645 /* recompile the whole context to set the priv pointers */
646 for (i = 0; i < ctx->list.count; ++i) {
647 mod = ctx->list.objs[i];
648 if (mod->implemented) {
649 mod->to_compile = 1;
650 }
651 }
652 lyrc = ly_ctx_compile(ctx);
Michal Vasko01db7de2021-04-16 12:23:30 +0200653 if (lyrc) {
aPiecek9922ea92021-04-12 07:59:20 +0200654 ly_ctx_unset_options(ctx, LY_CTX_SET_PRIV_PARSED);
655 }
656 }
Radek Krejcica828d92018-09-20 14:19:43 +0200657
658 /* set the option(s) */
aPiecek9922ea92021-04-12 07:59:20 +0200659 if (!lyrc) {
660 ctx->flags |= option;
661 }
Radek Krejcica828d92018-09-20 14:19:43 +0200662
aPiecek9922ea92021-04-12 07:59:20 +0200663 return lyrc;
664}
665
666static LY_ERR
667lysc_node_clear_priv_dfs_cb(struct lysc_node *node, void *UNUSED(data), ly_bool *UNUSED(dfs_continue))
668{
669 node->priv = NULL;
Radek Krejcica828d92018-09-20 14:19:43 +0200670 return LY_SUCCESS;
671}
672
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100673LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200674ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200675{
Michal Vasko193dacd2022-10-13 08:43:05 +0200676 LY_ARRAY_COUNT_TYPE u, v;
677 const struct lysc_ext_instance *ext;
678 struct lysc_node *root;
679
Radek Krejcica828d92018-09-20 14:19:43 +0200680 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200681 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200682
stewegf9041a22024-01-18 13:29:12 +0100683 if ((ctx->flags & LY_CTX_LEAFREF_LINKING) && (option & LY_CTX_LEAFREF_LINKING)) {
684 lyht_free(ctx->leafref_links_ht, ly_ctx_ht_leafref_links_rec_free);
685 ctx->leafref_links_ht = NULL;
686 }
687
aPiecek9922ea92021-04-12 07:59:20 +0200688 if ((ctx->flags & LY_CTX_SET_PRIV_PARSED) && (option & LY_CTX_SET_PRIV_PARSED)) {
689 struct lys_module *mod;
690 uint32_t index;
691
692 index = 0;
Michal Vaskoa51ef072021-07-02 10:40:30 +0200693 while ((mod = ly_ctx_get_module_iter(ctx, &index))) {
Michal Vasko193dacd2022-10-13 08:43:05 +0200694 if (!mod->compiled) {
695 continue;
696 }
697
698 /* set NULL for all ::lysc_node.priv pointers in module */
699 lysc_module_dfs_full(mod, lysc_node_clear_priv_dfs_cb, NULL);
700
701 /* set NULL for all ::lysc_node.priv pointers in compiled extension instances */
702 LY_ARRAY_FOR(mod->compiled->exts, u) {
703 ext = &mod->compiled->exts[u];
704 LY_ARRAY_FOR(ext->substmts, v) {
705 if (ext->substmts[v].stmt & LY_STMT_DATA_NODE_MASK) {
706 LY_LIST_FOR(*(struct lysc_node **)ext->substmts[v].storage, root) {
707 lysc_tree_dfs_full(root, lysc_node_clear_priv_dfs_cb, NULL);
708 }
709 }
710 }
711 }
aPiecek9922ea92021-04-12 07:59:20 +0200712 }
713 }
714
Radek Krejcica828d92018-09-20 14:19:43 +0200715 /* unset the option(s) */
716 ctx->flags &= ~option;
717
718 return LY_SUCCESS;
719}
720
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100721LIBYANG_API_DEF uint16_t
Michal Vasko794ab4b2021-03-31 09:42:19 +0200722ly_ctx_get_change_count(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200723{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200724 LY_CHECK_ARG_RET(ctx, ctx, 0);
Michal Vasko794ab4b2021-03-31 09:42:19 +0200725
726 return ctx->change_count;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200727}
728
Michal Vaskof9943e42023-03-22 07:29:37 +0100729LIBYANG_API_DEF uint32_t
730ly_ctx_get_modules_hash(const struct ly_ctx *ctx)
731{
732 const struct lys_module *mod;
Michal Vaskof332f032023-04-11 13:44:52 +0200733 uint32_t i = ly_ctx_internal_modules_count(ctx), hash = 0, fi = 0;
734 struct lysp_feature *f = NULL;
Michal Vaskof9943e42023-03-22 07:29:37 +0100735
736 LY_CHECK_ARG_RET(ctx, ctx, 0);
737
738 while ((mod = ly_ctx_get_module_iter(ctx, &i))) {
Michal Vaskof332f032023-04-11 13:44:52 +0200739 /* name */
Michal Vaskoae130f52023-04-20 14:25:16 +0200740 hash = lyht_hash_multi(hash, mod->name, strlen(mod->name));
Michal Vaskof332f032023-04-11 13:44:52 +0200741
742 /* revision */
Michal Vaskof9943e42023-03-22 07:29:37 +0100743 if (mod->revision) {
Michal Vaskoae130f52023-04-20 14:25:16 +0200744 hash = lyht_hash_multi(hash, mod->revision, strlen(mod->revision));
Michal Vaskof9943e42023-03-22 07:29:37 +0100745 }
Michal Vaskof332f032023-04-11 13:44:52 +0200746
747 /* enabled features */
748 while ((f = lysp_feature_next(f, mod->parsed, &fi))) {
749 if (f->flags & LYS_FENABLED) {
Michal Vaskoae130f52023-04-20 14:25:16 +0200750 hash = lyht_hash_multi(hash, f->name, strlen(f->name));
Michal Vaskof332f032023-04-11 13:44:52 +0200751 }
752 }
753
754 /* imported/implemented */
Michal Vaskoae130f52023-04-20 14:25:16 +0200755 hash = lyht_hash_multi(hash, (char *)&mod->implemented, sizeof mod->implemented);
Michal Vaskof9943e42023-03-22 07:29:37 +0100756 }
757
Michal Vaskoae130f52023-04-20 14:25:16 +0200758 hash = lyht_hash_multi(hash, NULL, 0);
Michal Vaskof9943e42023-03-22 07:29:37 +0100759 return hash;
760}
761
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100762LIBYANG_API_DEF ly_module_imp_clb
Radek Krejcid33273d2018-10-25 14:55:52 +0200763ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data)
764{
765 LY_CHECK_ARG_RET(ctx, ctx, NULL);
766
767 if (user_data) {
768 *user_data = ctx->imp_clb_data;
769 }
770 return ctx->imp_clb;
771}
772
Michal Vaskoddd76592022-01-17 13:34:48 +0100773LIBYANG_API_DEF void
774ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data)
775{
776 LY_CHECK_ARG_RET(ctx, ctx, );
777
778 ctx->imp_clb = clb;
779 ctx->imp_clb_data = user_data;
Michal Vaskod9ad7a32024-01-22 11:05:43 +0100780
781 /* new import callback - reset latests flags (possibly new revisions available) */
782 for (uint32_t v = 0; v < ctx->list.count; ++v) {
783 struct lys_module *mod = ctx->list.objs[v];
784
785 mod->latest_revision &= ~LYS_MOD_LATEST_IMPCLB;
786 if (mod->parsed && mod->parsed->includes) {
787 for (LY_ARRAY_COUNT_TYPE u = 0; u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
788 mod->parsed->includes[u].submodule->latest_revision &= ~LYS_MOD_LATEST_IMPCLB;
789 }
790 }
791 }
Michal Vaskoddd76592022-01-17 13:34:48 +0100792}
793
794LIBYANG_API_DEF ly_ext_data_clb
795ly_ctx_set_ext_data_clb(struct ly_ctx *ctx, ly_ext_data_clb clb, void *user_data)
796{
797 ly_ext_data_clb prev;
798
799 LY_CHECK_ARG_RET(ctx, ctx, NULL);
800
801 prev = ctx->ext_clb;
802 ctx->ext_clb = clb;
803 ctx->ext_clb_data = user_data;
804
805 return prev;
806}
807
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100808LIBYANG_API_DEF struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200809ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index)
Radek Krejcied5acc52019-04-25 15:57:04 +0200810{
811 LY_CHECK_ARG_RET(ctx, ctx, index, NULL);
812
Michal Vasko2307ff82021-04-16 11:51:18 +0200813 if (*index < ctx->list.count) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200814 return ctx->list.objs[(*index)++];
Radek Krejci2390fb52019-04-30 13:27:43 +0200815 } else {
816 return NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200817 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200818}
819
Radek Krejcib7db73a2018-10-24 14:18:40 +0200820/**
821 * @brief Iterate over the modules in the given context. Returned modules must match the given key at the offset of
822 * lysp_module and lysc_module structures (they are supposed to be placed at the same offset in both structures).
823 *
824 * @param[in] ctx Context where to iterate.
825 * @param[in] key Key value to search for.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200826 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100827 * @param[in] key_offset Key's offset in struct lys_module to get value from the context's modules to match with the key.
Radek Krejcib7db73a2018-10-24 14:18:40 +0200828 * @param[in,out] Iterator to pass between the function calls. On the first call, the variable is supposed to be
829 * initiated to 0. After each call returning a module, the value is greater by 1 than the index of the returned
830 * module in the context.
831 * @return Module matching the given key, NULL if no such module found.
832 */
Radek Krejci0af46292019-01-11 16:02:31 +0100833static struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200834ly_ctx_get_module_by_iter(const struct ly_ctx *ctx, const char *key, size_t key_size, size_t key_offset, uint32_t *index)
Radek Krejcib7db73a2018-10-24 14:18:40 +0200835{
Radek Krejci0af46292019-01-11 16:02:31 +0100836 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200837 const char *value;
838
Michal Vaskod989ba02020-08-24 10:59:24 +0200839 for ( ; *index < ctx->list.count; ++(*index)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200840 mod = ctx->list.objs[*index];
Michal Vasko22df3f02020-08-24 13:29:22 +0200841 value = *(const char **)(((int8_t *)(mod)) + key_offset);
Michal Vasko69730152020-10-09 16:30:07 +0200842 if ((!key_size && !strcmp(key, value)) || (key_size && !strncmp(key, value, key_size) && (value[key_size] == '\0'))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200843 /* increment index for the next run */
844 ++(*index);
845 return mod;
846 }
847 }
848 /* done */
849 return NULL;
850}
851
852/**
853 * @brief Unifying function for ly_ctx_get_module() and ly_ctx_get_module_ns()
854 * @param[in] ctx Context where to search.
855 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100856 * @param[in] key_offset Key's offset in struct lys_module to get value from the context's modules to match with the key.
Radek Krejcib7db73a2018-10-24 14:18:40 +0200857 * @param[in] revision Revision date to match. If NULL, the matching module must have no revision. To search for the latest
858 * revision module, use ly_ctx_get_module_latest_by().
859 * @return Matching module if any.
860 */
Radek Krejci0af46292019-01-11 16:02:31 +0100861static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200862ly_ctx_get_module_by(const struct ly_ctx *ctx, const char *key, size_t key_offset, const char *revision)
863{
Radek Krejci0af46292019-01-11 16:02:31 +0100864 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200865 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200866
Radek Krejci0ad51f12020-07-16 12:08:12 +0200867 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200868 if (!revision) {
Radek Krejci0af46292019-01-11 16:02:31 +0100869 if (!mod->revision) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200870 /* found requested module without revision */
871 return mod;
872 }
873 } else {
Radek Krejci0af46292019-01-11 16:02:31 +0100874 if (mod->revision && !strcmp(mod->revision, revision)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200875 /* found requested module of the specific revision */
876 return mod;
877 }
878 }
879 }
880
881 return NULL;
882}
883
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100884LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200885ly_ctx_get_module_ns(const struct ly_ctx *ctx, const char *ns, const char *revision)
886{
887 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100888 return ly_ctx_get_module_by(ctx, ns, offsetof(struct lys_module, ns), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200889}
890
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100891LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200892ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision)
893{
894 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100895 return ly_ctx_get_module_by(ctx, name, offsetof(struct lys_module, name), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200896}
897
898/**
899 * @brief Unifying function for ly_ctx_get_module_latest() and ly_ctx_get_module_latest_ns()
900 * @param[in] ctx Context where to search.
901 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100902 * @param[in] key_offset Key's offset in struct lys_module to get value from the context's modules to match with the key.
Radek Krejcib7db73a2018-10-24 14:18:40 +0200903 * @return Matching module if any.
904 */
Radek Krejci0af46292019-01-11 16:02:31 +0100905static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200906ly_ctx_get_module_latest_by(const struct ly_ctx *ctx, const char *key, size_t key_offset)
907{
Radek Krejci0af46292019-01-11 16:02:31 +0100908 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200909 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200910
Radek Krejci0ad51f12020-07-16 12:08:12 +0200911 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
aPiecek94d330b2021-08-04 11:57:31 +0200912 if (mod->latest_revision & LYS_MOD_LATEST_REV) {
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200913 return mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200914 }
915 }
916
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200917 return NULL;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200918}
919
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100920LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200921ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name)
922{
923 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100924 return ly_ctx_get_module_latest_by(ctx, name, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200925}
926
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100927LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200928ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns)
929{
930 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100931 return ly_ctx_get_module_latest_by(ctx, ns, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200932}
933
934/**
935 * @brief Unifying function for ly_ctx_get_module_implemented() and ly_ctx_get_module_implemented_ns()
936 * @param[in] ctx Context where to search.
937 * @param[in] key Name or Namespace as a search key.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200938 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100939 * @param[in] key_offset Key's offset in struct lys_module to get value from the context's modules to match with the key.
Radek Krejcib7db73a2018-10-24 14:18:40 +0200940 * @return Matching module if any.
941 */
Radek Krejci0af46292019-01-11 16:02:31 +0100942static struct lys_module *
Radek Krejci0ad51f12020-07-16 12:08:12 +0200943ly_ctx_get_module_implemented_by(const struct ly_ctx *ctx, const char *key, size_t key_size, size_t key_offset)
Radek Krejcib7db73a2018-10-24 14:18:40 +0200944{
Radek Krejci0af46292019-01-11 16:02:31 +0100945 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200946 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200947
Radek Krejci0ad51f12020-07-16 12:08:12 +0200948 while ((mod = ly_ctx_get_module_by_iter(ctx, key, key_size, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100949 if (mod->implemented) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200950 return mod;
951 }
952 }
953
954 return NULL;
955}
956
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100957LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200958ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name)
959{
960 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200961 return ly_ctx_get_module_implemented_by(ctx, name, 0, offsetof(struct lys_module, name));
962}
963
964struct lys_module *
965ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len)
966{
967 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
968 return ly_ctx_get_module_implemented_by(ctx, name, name_len, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200969}
970
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100971LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200972ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns)
973{
974 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200975 return ly_ctx_get_module_implemented_by(ctx, ns, 0, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200976}
977
Michal Vasko8dc31992021-02-22 10:30:47 +0100978/**
979 * @brief Try to find a submodule in a module.
980 *
981 * @param[in] module Module where to search in.
982 * @param[in] submodule Name of the submodule to find.
983 * @param[in] revision Revision of the submodule to find. NULL for submodule with no revision.
984 * @param[in] latest Ignore @p revision and look for the latest revision.
985 * @return Pointer to the specified submodule if it is present in the context.
986 */
987static const struct lysp_submodule *
988_ly_ctx_get_submodule2(const struct lys_module *module, const char *submodule, const char *revision, ly_bool latest)
Radek Krejcid33273d2018-10-25 14:55:52 +0200989{
Radek Krejcid33273d2018-10-25 14:55:52 +0200990 struct lysp_include *inc;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200991 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid33273d2018-10-25 14:55:52 +0200992
Michal Vasko8dc31992021-02-22 10:30:47 +0100993 LY_CHECK_ARG_RET(NULL, module, module->parsed, submodule, NULL);
Michal Vaskoc3781c32020-10-06 14:04:08 +0200994
Michal Vasko8dc31992021-02-22 10:30:47 +0100995 LY_ARRAY_FOR(module->parsed->includes, u) {
996 if (module->parsed->includes[u].submodule && !strcmp(submodule, module->parsed->includes[u].submodule->name)) {
997 inc = &module->parsed->includes[u];
998
999 if (latest && inc->submodule->latest_revision) {
1000 /* latest revision */
1001 return inc->submodule;
1002 } else if (!revision && !inc->submodule->revs) {
1003 /* no revision */
1004 return inc->submodule;
1005 } else if (revision && inc->submodule->revs && !strcmp(revision, inc->submodule->revs[0].date)) {
1006 /* specific revision */
1007 return inc->submodule;
1008 }
Michal Vaskoc3781c32020-10-06 14:04:08 +02001009 }
Michal Vaskoc3781c32020-10-06 14:04:08 +02001010 }
Radek Krejcifaa1eac2018-10-30 14:34:55 +01001011
Michal Vasko8dc31992021-02-22 10:30:47 +01001012 return NULL;
1013}
1014
1015/**
1016 * @brief Try to find a submodule in the context.
1017 *
1018 * @param[in] ctx Context where to search in.
1019 * @param[in] submodule Name of the submodule to find.
1020 * @param[in] revision Revision of the submodule to find. NULL for submodule with no revision.
1021 * @param[in] latest Ignore @p revision and look for the latest revision.
1022 * @return Pointer to the specified submodule if it is present in the context.
1023 */
1024static const struct lysp_submodule *
1025_ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision, ly_bool latest)
1026{
1027 const struct lys_module *mod;
1028 const struct lysp_submodule *submod = NULL;
1029 uint32_t v;
1030
1031 LY_CHECK_ARG_RET(ctx, ctx, submodule, NULL);
1032
Radek Krejcifaa1eac2018-10-30 14:34:55 +01001033 for (v = 0; v < ctx->list.count; ++v) {
1034 mod = ctx->list.objs[v];
Radek Krejcid33273d2018-10-25 14:55:52 +02001035 if (!mod->parsed) {
1036 continue;
1037 }
1038
Michal Vasko8dc31992021-02-22 10:30:47 +01001039 submod = _ly_ctx_get_submodule2(mod, submodule, revision, latest);
1040 if (submod) {
Michal Vaskoc3781c32020-10-06 14:04:08 +02001041 break;
1042 }
Radek Krejcid33273d2018-10-25 14:55:52 +02001043 }
1044
Michal Vasko8dc31992021-02-22 10:30:47 +01001045 return submod;
1046}
1047
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001048LIBYANG_API_DEF const struct lysp_submodule *
Michal Vasko8dc31992021-02-22 10:30:47 +01001049ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision)
1050{
1051 return _ly_ctx_get_submodule(ctx, submodule, revision, 0);
1052}
1053
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001054LIBYANG_API_DEF const struct lysp_submodule *
Michal Vasko8dc31992021-02-22 10:30:47 +01001055ly_ctx_get_submodule_latest(const struct ly_ctx *ctx, const char *submodule)
1056{
1057 return _ly_ctx_get_submodule(ctx, submodule, NULL, 1);
1058}
1059
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001060LIBYANG_API_DEF const struct lysp_submodule *
Michal Vasko8dc31992021-02-22 10:30:47 +01001061ly_ctx_get_submodule2(const struct lys_module *module, const char *submodule, const char *revision)
1062{
1063 return _ly_ctx_get_submodule2(module, submodule, revision, 0);
1064}
1065
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001066LIBYANG_API_DEF const struct lysp_submodule *
Michal Vasko8dc31992021-02-22 10:30:47 +01001067ly_ctx_get_submodule2_latest(const struct lys_module *module, const char *submodule)
1068{
1069 return _ly_ctx_get_submodule2(module, submodule, NULL, 1);
Radek Krejcid33273d2018-10-25 14:55:52 +02001070}
1071
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001072LIBYANG_API_DEF uint32_t
Radek Krejci0a60f1d2020-10-26 22:24:43 +01001073ly_ctx_internal_modules_count(const struct ly_ctx *ctx)
Michal Vaskode79e222020-08-10 11:55:46 +02001074{
1075 if (!ctx) {
1076 return 0;
1077 }
1078
Michal Vasko25d6ad02020-10-22 12:20:22 +02001079 if (ctx->flags & LY_CTX_NO_YANGLIBRARY) {
Michal Vaskode79e222020-08-10 11:55:46 +02001080 return LY_INTERNAL_MODS_COUNT - 2;
1081 } else {
1082 return LY_INTERNAL_MODS_COUNT;
1083 }
1084}
1085
Michal Vasko57c10cd2020-05-27 15:57:11 +02001086static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001087ylib_feature(struct lyd_node *parent, const struct lysp_module *pmod)
Michal Vasko57c10cd2020-05-27 15:57:11 +02001088{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001089 LY_ARRAY_COUNT_TYPE u;
1090 struct lysp_feature *f;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001091
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001092 if (!pmod->mod->implemented) {
Michal Vasko57c10cd2020-05-27 15:57:11 +02001093 /* no features can be enabled */
1094 return LY_SUCCESS;
1095 }
1096
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001097 LY_ARRAY_FOR(pmod->features, struct lysp_feature, f) {
1098 if (!(f->flags & LYS_FENABLED)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +02001099 continue;
1100 }
1101
Radek Krejci41ac9942020-11-02 14:47:56 +01001102 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001103 }
1104
1105 LY_ARRAY_FOR(pmod->includes, u) {
1106 LY_ARRAY_FOR(pmod->includes[u].submodule->features, struct lysp_feature, f) {
1107 if (!(f->flags & LYS_FENABLED)) {
1108 continue;
1109 }
1110
Radek Krejci41ac9942020-11-02 14:47:56 +01001111 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001112 }
Michal Vasko57c10cd2020-05-27 15:57:11 +02001113 }
1114
1115 return LY_SUCCESS;
1116}
1117
1118static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001119ylib_deviation(struct lyd_node *parent, const struct lys_module *cur_mod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +02001120{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001121 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001122 struct lys_module *mod;
1123
1124 if (!cur_mod->implemented) {
1125 /* no deviations of the module for certain */
1126 return LY_SUCCESS;
1127 }
1128
Michal Vasko7f45cf22020-10-01 12:49:44 +02001129 LY_ARRAY_FOR(cur_mod->deviated_by, i) {
1130 mod = cur_mod->deviated_by[i];
Michal Vasko57c10cd2020-05-27 15:57:11 +02001131
1132 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001133 LY_CHECK_RET(lyd_new_term(parent, NULL, "deviation", mod->name, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001134 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001135 LY_CHECK_RET(lyd_new_list(parent, NULL, "deviation", 0, NULL, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001136 (mod->parsed->revs ? mod->parsed->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001137 }
1138 }
1139
1140 return LY_SUCCESS;
1141}
1142
1143static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001144ylib_submodules(struct lyd_node *parent, const struct lysp_module *pmod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +02001145{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001146 LY_ERR ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001147 LY_ARRAY_COUNT_TYPE i;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001148 struct lyd_node *cont;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001149 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001150 int r;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001151 char *str;
1152
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001153 LY_ARRAY_FOR(pmod->includes, i) {
1154 submod = pmod->includes[i].submodule;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001155
1156 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001157 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001158
1159 if (submod->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001160 LY_CHECK_RET(lyd_new_term(cont, NULL, "revision", submod->revs[0].date, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001161 }
1162 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001163 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001164 (submod->revs ? submod->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001165 }
1166
1167 if (submod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001168 r = asprintf(&str, "file://%s", submod->filepath);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001169 LY_CHECK_ERR_RET(r == -1, LOGMEM(pmod->mod->ctx), LY_EMEM);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001170
Radek Krejci41ac9942020-11-02 14:47:56 +01001171 ret = lyd_new_term(cont, NULL, bis ? "location" : "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001172 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001173 LY_CHECK_RET(ret);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001174 }
1175 }
1176
1177 return LY_SUCCESS;
1178}
1179
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001180LIBYANG_API_DEF LY_ERR
Michal Vasko794ab4b2021-03-31 09:42:19 +02001181ly_ctx_get_yanglib_data(const struct ly_ctx *ctx, struct lyd_node **root_p, const char *content_id_format, ...)
Michal Vasko57c10cd2020-05-27 15:57:11 +02001182{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001183 LY_ERR ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001184 uint32_t i;
Radek Krejci857189e2020-09-01 13:26:36 +02001185 ly_bool bis = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001186 int r;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001187 char *str;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001188 const struct lys_module *mod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001189 struct lyd_node *root = NULL, *root_bis = NULL, *cont, *set_bis = NULL;
Michal Vasko794ab4b2021-03-31 09:42:19 +02001190 va_list ap;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001191
Michal Vasko3a41dff2020-07-15 14:30:28 +02001192 LY_CHECK_ARG_RET(ctx, ctx, root_p, LY_EINVAL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001193
1194 mod = ly_ctx_get_module_implemented(ctx, "ietf-yang-library");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001195 LY_CHECK_ERR_RET(!mod, LOGERR(ctx, LY_EINVAL, "Module \"ietf-yang-library\" is not implemented."), LY_EINVAL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001196
1197 if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, "2016-06-21")) {
1198 bis = 0;
1199 } else if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, IETF_YANG_LIB_REV)) {
1200 bis = 1;
1201 } else {
1202 LOGERR(ctx, LY_EINVAL, "Incompatible ietf-yang-library version in context.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001203 return LY_EINVAL;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001204 }
1205
Radek Krejci41ac9942020-11-02 14:47:56 +01001206 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "modules-state", 0, &root), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001207
1208 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001209 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "yang-library", 0, &root_bis), error);
1210 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "module-set", 0, &set_bis, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001211 }
1212
1213 for (i = 0; i < ctx->list.count; ++i) {
1214 mod = ctx->list.objs[i];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001215 if (!mod->parsed) {
1216 LOGERR(ctx, LY_ENOTFOUND, "Parsed module \"%s\" missing in the context.", mod->name);
1217 goto error;
1218 }
Michal Vasko57c10cd2020-05-27 15:57:11 +02001219
1220 /*
1221 * deprecated legacy
1222 */
Radek Krejci41ac9942020-11-02 14:47:56 +01001223 LY_CHECK_GOTO(ret = lyd_new_list(root, NULL, "module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001224 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001225
1226 /* schema */
1227 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001228 r = asprintf(&str, "file://%s", mod->filepath);
1229 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001230
Radek Krejci41ac9942020-11-02 14:47:56 +01001231 ret = lyd_new_term(cont, NULL, "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001232 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001233 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001234 }
1235
1236 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +01001237 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001238
1239 /* feature leaf-list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001240 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001241
1242 /* deviation list */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001243 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001244
1245 /* conformance-type */
stewegd4cde642024-02-21 08:34:16 +01001246 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "conformance-type", mod->implemented ? "implement" : "import", 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001247
1248 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001249 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001250
1251 /*
1252 * current revision
1253 */
1254 if (bis) {
1255 /* name and revision */
1256 if (mod->implemented) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001257 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "module", 0, &cont, mod->name), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001258
1259 if (mod->parsed->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001260 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "revision", mod->parsed->revs[0].date, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001261 }
1262 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001263 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "import-only-module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001264 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001265 }
1266
1267 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +01001268 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001269
1270 /* location */
1271 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001272 r = asprintf(&str, "file://%s", mod->filepath);
1273 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001274
Radek Krejcid68ba1b2020-11-09 17:40:11 +01001275 ret = lyd_new_term(cont, NULL, "location", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001276 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001277 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001278 }
1279
1280 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001281 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001282
1283 /* feature list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001284 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001285
1286 /* deviation */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001287 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001288 }
1289 }
1290
1291 /* IDs */
Michal Vasko794ab4b2021-03-31 09:42:19 +02001292 va_start(ap, content_id_format);
1293 r = vasprintf(&str, content_id_format, ap);
1294 va_end(ap);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001295 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
1296 ret = lyd_new_term(root, NULL, "module-set-id", str, 0, NULL);
1297 LY_CHECK_ERR_GOTO(ret, free(str), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001298
1299 if (bis) {
1300 /* create one complete schema */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001301 LY_CHECK_ERR_GOTO(ret = lyd_new_list(root_bis, NULL, "schema", 0, &cont, "complete"), free(str), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001302
Radek Krejcif13b87b2020-12-01 22:02:17 +01001303 LY_CHECK_ERR_GOTO(ret = lyd_new_term(cont, NULL, "module-set", "complete", 0, NULL), free(str), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001304
1305 /* content-id */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001306 LY_CHECK_ERR_GOTO(ret = lyd_new_term(root_bis, NULL, "content-id", str, 0, NULL), free(str), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001307 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001308 free(str);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001309
1310 if (root_bis) {
Michal Vaskob104f112020-07-17 09:54:54 +02001311 if (lyd_insert_sibling(root, root_bis, &root)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +02001312 goto error;
1313 }
Michal Vaskob104f112020-07-17 09:54:54 +02001314 root_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001315 }
1316
Michal Vasko3a41dff2020-07-15 14:30:28 +02001317 LY_CHECK_GOTO(ret = lyd_validate_all(&root, NULL, LYD_VALIDATE_PRESENT, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001318
Michal Vasko3a41dff2020-07-15 14:30:28 +02001319 *root_p = root;
1320 return LY_SUCCESS;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001321
1322error:
1323 lyd_free_all(root);
1324 lyd_free_all(root_bis);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001325 return ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001326}
1327
Michal Vasko88ccd582023-03-30 11:50:57 +02001328/**
1329 * @brief Callback for freeing context error hash table values.
1330 *
1331 * @param[in] val_p Pointer to a pointer to an error item to free with all the siblings.
1332 */
1333static void
1334ly_ctx_ht_err_rec_free(void *val_p)
1335{
1336 struct ly_ctx_err_rec *err = val_p;
1337
1338 ly_err_free(err->err);
1339}
1340
Jan Kundrátc53a7ec2021-12-09 16:01:19 +01001341LIBYANG_API_DEF void
Radek Krejci90ed21e2021-04-12 14:47:46 +02001342ly_ctx_destroy(struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001343{
Michal Vaskoc636ea42022-09-16 10:20:31 +02001344 struct lysf_ctx fctx = {.ctx = ctx};
Michal Vasko65333882021-06-10 14:12:16 +02001345
Radek Krejci418823a2018-09-20 16:42:13 +02001346 if (!ctx) {
1347 return;
1348 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001349
1350 /* models list */
Michal Vaskod989ba02020-08-24 10:59:24 +02001351 for ( ; ctx->list.count; ctx->list.count--) {
Michal Vaskoc636ea42022-09-16 10:20:31 +02001352 fctx.mod = ctx->list.objs[ctx->list.count - 1];
Michal Vasko65333882021-06-10 14:12:16 +02001353
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001354 /* remove the module */
Michal Vaskoc636ea42022-09-16 10:20:31 +02001355 if (fctx.mod->implemented) {
1356 fctx.mod->implemented = 0;
1357 lysc_module_free(&fctx, fctx.mod->compiled);
1358 fctx.mod->compiled = NULL;
Michal Vasko65333882021-06-10 14:12:16 +02001359 }
Michal Vaskoc636ea42022-09-16 10:20:31 +02001360 lys_module_free(&fctx, fctx.mod, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001361 }
1362 free(ctx->list.objs);
1363
Michal Vaskoc636ea42022-09-16 10:20:31 +02001364 /* free extensions */
1365 lysf_ctx_erase(&fctx);
1366
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001367 /* search paths list */
Radek Krejcia40f21b2018-09-18 10:42:08 +02001368 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001369
Michal Vasko22b26222021-07-30 11:16:47 +02001370 /* leftover unres */
1371 lys_unres_glob_erase(&ctx->unres);
1372
stewegf9041a22024-01-18 13:29:12 +01001373 /* clean the leafref links hash table */
1374 if (ctx->leafref_links_ht) {
1375 lyht_free(ctx->leafref_links_ht, ly_ctx_ht_leafref_links_rec_free);
1376 }
1377
Michal Vasko88ccd582023-03-30 11:50:57 +02001378 /* clean the error hash table */
1379 lyht_free(ctx->err_ht, ly_ctx_ht_err_rec_free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001380
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001381 /* dictionary */
1382 lydict_clean(&ctx->dict);
1383
Michal Vasko11f76c82021-04-15 14:36:14 +02001384 /* LYB hash lock */
1385 pthread_mutex_destroy(&ctx->lyb_hash_lock);
1386
stewegf7aeeae2024-04-02 13:15:52 +02001387 /* context specific plugins */
1388 ly_set_erase(&ctx->plugins_types, NULL);
1389 ly_set_erase(&ctx->plugins_extensions, NULL);
1390
1391 /* shared plugins - will be removed only if this is the last context */
Radek Krejci3e6632f2021-03-22 22:08:21 +01001392 lyplg_clean();
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001393
1394 free(ctx);
1395}