blob: 15043d3ca07e7a03047878f89075fe8a617d824a [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 Vasko19a09022021-06-15 11:54:08 +02007 * Copyright (c) 2015 - 2021 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 Krejci535ea9f2020-05-29 16:01:05 +020035#include "common.h"
Radek Krejciaa45bda2020-07-20 07:43:38 +020036#include "compat.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020037#include "hash_table.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020038#include "in.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"
Radek Krejci86d106e2018-10-18 09:53:19 +020048#include "tree_schema_internal.h"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020049
Michal Vaskocf296c82020-05-27 11:16:45 +020050#include "../models/ietf-datastores@2018-02-14.h"
Michal Vasko69730152020-10-09 16:30:07 +020051#include "../models/ietf-inet-types@2013-07-15.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020052#include "../models/ietf-yang-library@2019-01-04.h"
Michal Vasko69730152020-10-09 16:30:07 +020053#include "../models/ietf-yang-metadata@2016-08-05.h"
tadeas-vintrlikbf8aa6e2021-11-03 13:07:34 +010054#include "../models/ietf-yang-schema-mount@2019-01-14.h"
Michal Vasko69730152020-10-09 16:30:07 +020055#include "../models/ietf-yang-types@2013-07-15.h"
Michal Vaskoe78faec2021-04-08 17:24:43 +020056#include "../models/yang@2021-04-07.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020057#define IETF_YANG_LIB_REV "2019-01-04"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020058
Radek Krejci0af5f5d2018-09-07 15:00:30 +020059static struct internal_modules_s {
60 const char *name;
61 const char *revision;
62 const char *data;
Radek Krejci857189e2020-09-01 13:26:36 +020063 ly_bool implemented;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020064 LYS_INFORMAT format;
Michal Vaskode79e222020-08-10 11:55:46 +020065} internal_modules[] = {
Michal Vasko1de593f2020-11-23 16:11:41 +010066 {"ietf-yang-metadata", "2016-08-05", (const char *)ietf_yang_metadata_2016_08_05_yang, 0, LYS_IN_YANG},
Michal Vaskoe78faec2021-04-08 17:24:43 +020067 {"yang", "2021-04-07", (const char *)yang_2021_04_07_yang, 1, LYS_IN_YANG},
Michal Vasko22df3f02020-08-24 13:29:22 +020068 {"ietf-inet-types", "2013-07-15", (const char *)ietf_inet_types_2013_07_15_yang, 0, LYS_IN_YANG},
69 {"ietf-yang-types", "2013-07-15", (const char *)ietf_yang_types_2013_07_15_yang, 0, LYS_IN_YANG},
tadeas-vintrlikbf8aa6e2021-11-03 13:07:34 +010070 {"ietf-yang-schema-mount", "2019-01-14", (const char *)ietf_yang_schema_mount_2019_01_14_yang, 1, LYS_IN_YANG},
Radek Krejci0af5f5d2018-09-07 15:00:30 +020071 /* ietf-datastores and ietf-yang-library must be right here at the end of the list! */
Michal Vasko22df3f02020-08-24 13:29:22 +020072 {"ietf-datastores", "2018-02-14", (const char *)ietf_datastores_2018_02_14_yang, 1, LYS_IN_YANG},
73 {"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 +020074};
75
Michal Vaskode79e222020-08-10 11:55:46 +020076#define LY_INTERNAL_MODS_COUNT sizeof(internal_modules) / sizeof(struct internal_modules_s)
77
Jan Kundrátc6e39de2021-12-09 16:01:19 +010078LIBYANG_API_DEF LY_ERR
Radek Krejci0af5f5d2018-09-07 15:00:30 +020079ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir)
80{
Radek Krejci0e212402018-09-20 11:29:38 +020081 struct stat st;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020082 char *new_dir = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020083
84 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
85
86 if (search_dir) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +020087 new_dir = realpath(search_dir, NULL);
Radek Krejcia77e0e12018-09-20 12:39:15 +020088 LY_CHECK_ERR_RET(!new_dir,
Michal Vasko69730152020-10-09 16:30:07 +020089 LOGERR(ctx, LY_ESYS, "Unable to use search directory \"%s\" (%s).", search_dir, strerror(errno)),
90 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020091 if (strcmp(search_dir, new_dir)) {
Michal Vasko6e63ca92021-06-24 09:22:44 +020092 LOGVRB("Search directory string \"%s\" canonized to \"%s\".", search_dir, new_dir);
Radek Krejci3a077b92019-04-09 17:10:35 +020093 }
94 LY_CHECK_ERR_RET(access(new_dir, R_OK | X_OK),
Michal Vasko69730152020-10-09 16:30:07 +020095 LOGERR(ctx, LY_ESYS, "Unable to fully access search directory \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
96 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020097 LY_CHECK_ERR_RET(stat(new_dir, &st),
Michal Vasko69730152020-10-09 16:30:07 +020098 LOGERR(ctx, LY_ESYS, "stat() failed for \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
99 LY_ESYS);
Radek Krejci3a077b92019-04-09 17:10:35 +0200100 LY_CHECK_ERR_RET(!S_ISDIR(st.st_mode),
Michal Vasko69730152020-10-09 16:30:07 +0200101 LOGERR(ctx, LY_ESYS, "Given search directory \"%s\" is not a directory.", new_dir); free(new_dir),
102 LY_EINVAL);
Radek Krejci0e212402018-09-20 11:29:38 +0200103 /* avoid path duplication */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200104 for (uint32_t u = 0; u < ctx->search_paths.count; ++u) {
Radek Krejci14946ab2018-09-20 13:42:06 +0200105 if (!strcmp(new_dir, ctx->search_paths.objs[u])) {
Radek Krejci0e212402018-09-20 11:29:38 +0200106 free(new_dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200107 return LY_EEXIST;
Radek Krejci0e212402018-09-20 11:29:38 +0200108 }
109 }
Radek Krejci3d92e442020-10-12 12:48:13 +0200110 if (ly_set_add(&ctx->search_paths, new_dir, 1, NULL)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200111 free(new_dir);
112 return LY_EMEM;
113 }
114
Radek Krejcie9e987e2018-10-31 12:50:27 +0100115 /* new searchdir - possibly more latest revision available */
116 ly_ctx_reset_latests(ctx);
117
Radek Krejci0e212402018-09-20 11:29:38 +0200118 return LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200119 } else {
120 /* consider that no change is not actually an error */
121 return LY_SUCCESS;
122 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200123}
124
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100125LIBYANG_API_DEF const char * const *
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200126ly_ctx_get_searchdirs(const struct ly_ctx *ctx)
127{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100128#define LY_CTX_SEARCHDIRS_SIZE_STEP 8
Radek Krejci05026432018-09-20 12:13:43 +0200129 void **new;
130
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200131 LY_CHECK_ARG_RET(ctx, ctx, NULL);
Radek Krejci05026432018-09-20 12:13:43 +0200132
133 if (ctx->search_paths.count == ctx->search_paths.size) {
134 /* not enough space for terminating NULL byte */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100135 new = realloc(((struct ly_ctx *)ctx)->search_paths.objs,
136 (ctx->search_paths.size + LY_CTX_SEARCHDIRS_SIZE_STEP) * sizeof *ctx->search_paths.objs);
Radek Krejci05026432018-09-20 12:13:43 +0200137 LY_CHECK_ERR_RET(!new, LOGMEM(NULL), NULL);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100138 ((struct ly_ctx *)ctx)->search_paths.size += LY_CTX_SEARCHDIRS_SIZE_STEP;
Radek Krejci05026432018-09-20 12:13:43 +0200139 ((struct ly_ctx *)ctx)->search_paths.objs = new;
140 }
141 /* set terminating NULL byte to the strings list */
142 ctx->search_paths.objs[ctx->search_paths.count] = NULL;
143
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200144 return (const char * const *)ctx->search_paths.objs;
145}
146
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100147LIBYANG_API_DEF LY_ERR
Radek Krejcie58f97f2020-08-18 11:45:08 +0200148ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200149{
Radek Krejcicd649072018-09-20 12:14:45 +0200150 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Radek Krejcicd649072018-09-20 12:14:45 +0200151
Michal Vaskob34480a2018-09-17 10:34:45 +0200152 if (!ctx->search_paths.count) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200153 return LY_SUCCESS;
154 }
155
Radek Krejci0759b792018-09-20 13:53:15 +0200156 if (value) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200157 /* remove specific search directory */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200158 uint32_t index;
159
Radek Krejci0759b792018-09-20 13:53:15 +0200160 for (index = 0; index < ctx->search_paths.count; ++index) {
161 if (!strcmp(value, ctx->search_paths.objs[index])) {
162 break;
163 }
164 }
165 if (index == ctx->search_paths.count) {
166 LOGARG(ctx, value);
167 return LY_EINVAL;
168 } else {
169 return ly_set_rm_index(&ctx->search_paths, index, free);
170 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200171 } else {
172 /* remove them all */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200173 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200174 memset(&ctx->search_paths, 0, sizeof ctx->search_paths);
175 }
176
177 return LY_SUCCESS;
178}
179
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100180LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200181ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count)
Radek Krejcied5acc52019-04-25 15:57:04 +0200182{
183 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
184
Radek Krejcie58f97f2020-08-18 11:45:08 +0200185 for ( ; count > 0 && ctx->search_paths.count; --count) {
186 LY_CHECK_RET(ly_set_rm_index(&ctx->search_paths, ctx->search_paths.count - 1, free))
Radek Krejcied5acc52019-04-25 15:57:04 +0200187 }
188
189 return LY_SUCCESS;
190}
191
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100192LIBYANG_API_DEF struct lys_module *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100193ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision, const char **features)
Radek Krejcied5acc52019-04-25 15:57:04 +0200194{
Michal Vasko88497502021-06-10 14:41:51 +0200195 struct lys_module *mod = NULL;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100196 LY_ERR ret = LY_SUCCESS;
Radek Krejcied5acc52019-04-25 15:57:04 +0200197
198 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
199
Michal Vaskodd992582021-06-10 14:34:57 +0200200 /* load and parse */
Michal Vasko22b26222021-07-30 11:16:47 +0200201 ret = lys_parse_load(ctx, name, revision, &ctx->unres.creating, &mod);
Michal Vaskodd992582021-06-10 14:34:57 +0200202 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko4e205e82021-06-08 14:01:47 +0200203
204 /* implement */
Michal Vasko22b26222021-07-30 11:16:47 +0200205 ret = _lys_set_implemented(mod, features, &ctx->unres);
Michal Vasko65333882021-06-10 14:12:16 +0200206 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100207
Michal Vaskof4258e12021-06-15 12:11:42 +0200208 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
209 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +0200210 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +0200211
Michal Vasko709f9a52021-07-21 10:51:59 +0200212 /* (re)compile the whole dep set (other dep sets will have no modules marked for compilation) */
Michal Vasko22b26222021-07-30 11:16:47 +0200213 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
214
215 /* unres resolved */
216 lys_unres_glob_erase(&ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +0200217 }
218
Michal Vasko405cc9e2020-12-01 12:01:27 +0100219cleanup:
220 if (ret) {
Michal Vasko22b26222021-07-30 11:16:47 +0200221 lys_unres_glob_revert(ctx, &ctx->unres);
222 lys_unres_glob_erase(&ctx->unres);
Michal Vaskodf6319c2021-06-10 14:41:05 +0200223 mod = NULL;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100224 }
Michal Vaskodf6319c2021-06-10 14:41:05 +0200225 return mod;
Radek Krejcied5acc52019-04-25 15:57:04 +0200226}
227
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100228LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200229ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200230{
231 struct ly_ctx *ctx = NULL;
232 struct lys_module *module;
Michal Vaskoc56d6372021-10-19 12:29:00 +0200233 char *search_dir_list, *sep, *dir;
234 const char **imp_f, *all_f[] = {"*", NULL};
Michal Vaskode79e222020-08-10 11:55:46 +0200235 uint32_t i;
Michal Vasko63f3d842020-07-08 10:10:14 +0200236 struct ly_in *in = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200237 LY_ERR rc = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100238 struct lys_glob_unres unres = {0};
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200239
Radek Krejcied5acc52019-04-25 15:57:04 +0200240 LY_CHECK_ARG_RET(NULL, new_ctx, LY_EINVAL);
241
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200242 ctx = calloc(1, sizeof *ctx);
Michal Vasko88497502021-06-10 14:41:51 +0200243 LY_CHECK_ERR_GOTO(!ctx, LOGMEM(NULL); rc = LY_EMEM, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200244
245 /* dictionary */
246 lydict_init(&ctx->dict);
247
248 /* plugins */
Michal Vasko88497502021-06-10 14:41:51 +0200249 LY_CHECK_ERR_GOTO(lyplg_init(), LOGINT(NULL); rc = LY_EINT, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200250
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100251 /* initialize thread-specific keys */
Radek Krejci1e008d22020-08-17 11:37:37 +0200252 while ((pthread_key_create(&ctx->errlist_key, ly_err_free)) == EAGAIN) {}
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200253
Michal Vasko11f76c82021-04-15 14:36:14 +0200254 /* init LYB hash lock */
255 pthread_mutex_init(&ctx->lyb_hash_lock, NULL);
256
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200257 /* models list */
258 ctx->flags = options;
259 if (search_dir) {
260 search_dir_list = strdup(search_dir);
Michal Vasko88497502021-06-10 14:41:51 +0200261 LY_CHECK_ERR_GOTO(!search_dir_list, LOGMEM(NULL); rc = LY_EMEM, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200262
Jan Kundráta3ea1932021-12-13 18:45:50 +0100263 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 +0200264 *sep = 0;
265 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200266 if (rc == LY_EEXIST) {
267 /* ignore duplication */
268 rc = LY_SUCCESS;
269 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200270 }
Michal Vasko69730152020-10-09 16:30:07 +0200271 if (*dir && (rc == LY_SUCCESS)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200272 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200273 if (rc == LY_EEXIST) {
274 /* ignore duplication */
275 rc = LY_SUCCESS;
276 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200277 }
278 free(search_dir_list);
279
280 /* If ly_ctx_set_searchdir() failed, the error is already logged. Just exit */
Michal Vasko88497502021-06-10 14:41:51 +0200281 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200282 }
Michal Vasko794ab4b2021-03-31 09:42:19 +0200283 ctx->change_count = 1;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200284
Michal Vasko9434ec52021-04-19 11:30:55 +0200285 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
286 /* use it for creating the initial context */
287 ctx->flags |= LY_CTX_EXPLICIT_COMPILE;
288 }
289
Michal Vasko63f3d842020-07-08 10:10:14 +0200290 /* create dummy in */
291 rc = ly_in_new_memory(internal_modules[0].data, &in);
Michal Vasko88497502021-06-10 14:41:51 +0200292 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko63f3d842020-07-08 10:10:14 +0200293
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200294 /* load internal modules */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200295 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 +0200296 ly_in_memory(in, internal_modules[i].data);
Michal Vaskodd992582021-06-10 14:34:57 +0200297 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 +0200298 if (internal_modules[i].implemented || (ctx->flags & LY_CTX_ALL_IMPLEMENTED)) {
Michal Vaskoc56d6372021-10-19 12:29:00 +0200299 imp_f = (ctx->flags & LY_CTX_ENABLE_IMP_FEATURES) ? all_f : NULL;
300 LY_CHECK_GOTO(rc = lys_implement(module, imp_f, &unres), cleanup);
Michal Vasko4e205e82021-06-08 14:01:47 +0200301 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200302 }
303
Michal Vasko9434ec52021-04-19 11:30:55 +0200304 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
305 /* compile now */
Michal Vasko88497502021-06-10 14:41:51 +0200306 LY_CHECK_GOTO(rc = ly_ctx_compile(ctx), cleanup);
Michal Vasko9434ec52021-04-19 11:30:55 +0200307 ctx->flags &= ~LY_CTX_EXPLICIT_COMPILE;
308 }
309
Michal Vasko88497502021-06-10 14:41:51 +0200310cleanup:
Michal Vasko63f3d842020-07-08 10:10:14 +0200311 ly_in_free(in, 0);
Michal Vaskof4258e12021-06-15 12:11:42 +0200312 lys_unres_glob_erase(&unres);
Michal Vaskodf6319c2021-06-10 14:41:05 +0200313 if (rc) {
314 ly_ctx_destroy(ctx);
315 } else {
316 *new_ctx = ctx;
317 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200318 return rc;
319}
Radek Krejci0f969882020-08-21 16:56:47 +0200320
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200321static LY_ERR
Michal Vaskoaac267d2022-01-17 13:34:48 +0100322ly_ctx_new_yl_legacy(struct ly_ctx *ctx, const struct lyd_node *yltree)
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200323{
324 struct lyd_node *module, *node;
325 struct ly_set *set;
326 const char **feature_arr = NULL;
327 const char *name = NULL, *revision = NULL;
328 struct ly_set features = {0};
329 ly_bool imported = 0;
330 const struct lys_module *mod;
331 LY_ERR ret = LY_SUCCESS;
Michal Vaskoaac267d2022-01-17 13:34:48 +0100332 uint32_t i, j;
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200333
334 LY_CHECK_RET(ret = lyd_find_xpath(yltree, "/ietf-yang-library:yang-library/modules-state/module", &set));
335
336 /* process the data tree */
Michal Vaskoaac267d2022-01-17 13:34:48 +0100337 for (i = 0; i < set->count; ++i) {
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200338 module = set->dnodes[i];
339
340 /* initiate */
341 revision = NULL;
342 name = NULL;
343 imported = 0;
344
345 LY_LIST_FOR(lyd_child(module), node) {
346 if (!strcmp(node->schema->name, "name")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200347 name = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200348 } else if (!strcmp(node->schema->name, "revision")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200349 revision = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200350 } else if (!strcmp(node->schema->name, "feature")) {
351 LY_CHECK_GOTO(ret = ly_set_add(&features, node, 0, NULL), cleanup);
352 } else if (!strcmp(node->schema->name, "conformance-type") &&
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200353 !strcmp(lyd_get_value(node), "import")) {
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200354 /* imported module - skip it, it will be loaded as a side effect
355 * of loading another module */
356 imported = 1;
357 break;
358 }
359 }
360
361 if (imported) {
362 continue;
363 }
364
365 feature_arr = malloc((features.count + 1) * sizeof *feature_arr);
366 LY_CHECK_ERR_GOTO(!feature_arr, ret = LY_EMEM, cleanup);
367
368 /* Parse features into an array of strings */
Michal Vaskoaac267d2022-01-17 13:34:48 +0100369 for (j = 0; j < features.count; ++j) {
370 feature_arr[j] = lyd_get_value(features.dnodes[j]);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200371 }
372 feature_arr[features.count] = NULL;
373 ly_set_clean(&features, free);
374
375 /* use the gathered data to load the module */
376 mod = ly_ctx_load_module(ctx, name, revision, feature_arr);
377 free(feature_arr);
378 if (!mod) {
379 LOGERR(ctx, LY_EINVAL, "Unable to load module specified by yang library data.");
380 ly_set_free(set, free);
381 return LY_EINVAL;
382 }
383 }
384
385cleanup:
386 ly_set_clean(&features, free);
387 ly_set_free(set, free);
388 return ret;
389}
390
Michal Vaskoaac267d2022-01-17 13:34:48 +0100391LIBYANG_API_DEF LY_ERR
392ly_ctx_new_ylpath(const char *search_dir, const char *path, LYD_FORMAT format, int options, struct ly_ctx **ctx)
393{
394 LY_ERR ret = LY_SUCCESS;
395 struct ly_ctx *ctx_yl = NULL;
396 struct lyd_node *data_yl = NULL;
397
398 LY_CHECK_ARG_RET(NULL, path, ctx, LY_EINVAL);
399
400 /* create a seperate context for the data */
401 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, 0, &ctx_yl), cleanup);
402
403 /* parse yang library data tree */
404 LY_CHECK_GOTO(ret = lyd_parse_data_path(ctx_yl, path, format, 0, LYD_VALIDATE_PRESENT, &data_yl), cleanup);
405
406 /* create the new context */
407 ret = ly_ctx_new_yldata(search_dir, data_yl, options, ctx);
408
409cleanup:
410 lyd_free_all(data_yl);
411 ly_ctx_destroy(ctx_yl);
412 return ret;
413}
414
415LIBYANG_API_DEF LY_ERR
416ly_ctx_new_ylmem(const char *search_dir, const char *data, LYD_FORMAT format, int options, struct ly_ctx **ctx)
417{
418 LY_ERR ret = LY_SUCCESS;
419 struct ly_ctx *ctx_yl = NULL;
420 struct lyd_node *data_yl = NULL;
421
422 LY_CHECK_ARG_RET(NULL, data, ctx, LY_EINVAL);
423
424 /* create a seperate context for the data */
425 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, 0, &ctx_yl), cleanup);
426
427 /* parse yang library data tree */
428 LY_CHECK_GOTO(ret = lyd_parse_data_mem(ctx_yl, data, format, 0, LYD_VALIDATE_PRESENT, &data_yl), cleanup);
429
430 /* create the new context */
431 ret = ly_ctx_new_yldata(search_dir, data_yl, options, ctx);
432
433cleanup:
434 lyd_free_all(data_yl);
435 ly_ctx_destroy(ctx_yl);
436 return ret;
437}
438
439LIBYANG_API_DEF LY_ERR
440ly_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 +0200441{
442 const char *name = NULL, *revision = NULL;
443 struct lyd_node *module, *node;
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200444 struct ly_set *set = NULL;
445 const char **feature_arr = NULL;
446 struct ly_set features = {0};
447 LY_ERR ret = LY_SUCCESS;
448 const struct lys_module *mod;
Michal Vaskoaac267d2022-01-17 13:34:48 +0100449 struct ly_ctx *ctx_new = NULL;
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200450 ly_bool no_expl_compile = 0;
Michal Vaskoaac267d2022-01-17 13:34:48 +0100451 uint32_t i, j;
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200452
Michal Vaskoaac267d2022-01-17 13:34:48 +0100453 LY_CHECK_ARG_RET(NULL, tree, ctx, LY_EINVAL);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200454
Michal Vaskoaac267d2022-01-17 13:34:48 +0100455 /* create a new context */
456 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, options, &ctx_new), cleanup);
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200457
458 /* redundant to compile modules one-by-one */
459 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
460 ctx_new->flags |= LY_CTX_EXPLICIT_COMPILE;
461 no_expl_compile = 1;
462 }
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200463
Michal Vaskoaac267d2022-01-17 13:34:48 +0100464 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 +0200465 if (set->count == 0) {
466 /* perhaps a legacy data tree? */
Michal Vaskoaac267d2022-01-17 13:34:48 +0100467 LY_CHECK_GOTO(ret = ly_ctx_new_yl_legacy(ctx_new, tree), cleanup);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200468 } else {
469 /* process the data tree */
Michal Vaskoaac267d2022-01-17 13:34:48 +0100470 for (i = 0; i < set->count; ++i) {
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200471 module = set->dnodes[i];
472
473 /* initiate */
474 name = NULL;
475 revision = NULL;
476
Michal Vaskoaac267d2022-01-17 13:34:48 +0100477 /* iterate over data */
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200478 LY_LIST_FOR(lyd_child(module), node) {
479 if (!strcmp(node->schema->name, "name")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200480 name = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200481 } else if (!strcmp(node->schema->name, "revision")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200482 revision = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200483 } else if (!strcmp(node->schema->name, "feature")) {
484 LY_CHECK_GOTO(ret = ly_set_add(&features, node, 0, NULL), cleanup);
485 }
486 }
487
488 feature_arr = malloc((features.count + 1) * sizeof *feature_arr);
489 LY_CHECK_ERR_GOTO(!feature_arr, ret = LY_EMEM, cleanup);
490
Michal Vaskoaac267d2022-01-17 13:34:48 +0100491 /* parse features into an array of strings */
492 for (j = 0; j < features.count; ++j) {
493 feature_arr[j] = lyd_get_value(features.dnodes[j]);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200494 }
495 feature_arr[features.count] = NULL;
496 ly_set_clean(&features, NULL);
497
498 /* use the gathered data to load the module */
499 mod = ly_ctx_load_module(ctx_new, name, revision, feature_arr);
500 free(feature_arr);
501 if (!mod) {
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200502 LOGERR(NULL, LY_EINVAL, "Unable to load module %s@%s specified by yang library data.", name,
503 revision ? revision : "<none>");
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200504 ret = LY_EINVAL;
505 goto cleanup;
506 }
507 }
508 }
509
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200510 /* compile */
511 LY_CHECK_GOTO(ret = ly_ctx_compile(ctx_new), cleanup);
512
513 if (no_expl_compile) {
514 /* unset flag */
515 ctx_new->flags &= ~LY_CTX_EXPLICIT_COMPILE;
516 }
517
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200518cleanup:
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200519 ly_set_free(set, NULL);
520 ly_set_erase(&features, NULL);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200521 *ctx = ctx_new;
522 if (ret) {
Radek Krejci90ed21e2021-04-12 14:47:46 +0200523 ly_ctx_destroy(*ctx);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200524 *ctx = NULL;
525 }
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200526 return ret;
527}
528
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100529LIBYANG_API_DEF LY_ERR
Michal Vasko01db7de2021-04-16 12:23:30 +0200530ly_ctx_compile(struct ly_ctx *ctx)
531{
Michal Vaskod39bea42021-06-14 10:42:49 +0200532 LY_ERR ret = LY_SUCCESS;
Michal Vasko01db7de2021-04-16 12:23:30 +0200533
534 LY_CHECK_ARG_RET(NULL, ctx, LY_EINVAL);
535
Michal Vaskof4258e12021-06-15 12:11:42 +0200536 /* create dep sets and mark all the modules that will be (re)compiled */
Michal Vasko22b26222021-07-30 11:16:47 +0200537 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &ctx->unres.dep_sets, NULL), cleanup);
Michal Vaskod39bea42021-06-14 10:42:49 +0200538
Michal Vaskof4258e12021-06-15 12:11:42 +0200539 /* (re)compile all the dep sets */
Michal Vasko22b26222021-07-30 11:16:47 +0200540 LY_CHECK_GOTO(ret = lys_compile_depset_all(ctx, &ctx->unres), cleanup);
Michal Vasko01db7de2021-04-16 12:23:30 +0200541
Michal Vaskod39bea42021-06-14 10:42:49 +0200542cleanup:
Michal Vaskof4258e12021-06-15 12:11:42 +0200543 if (ret) {
544 /* revert changes of modules */
Michal Vasko22b26222021-07-30 11:16:47 +0200545 lys_unres_glob_revert(ctx, &ctx->unres);
Michal Vaskof4258e12021-06-15 12:11:42 +0200546 }
Michal Vasko22b26222021-07-30 11:16:47 +0200547 lys_unres_glob_erase(&ctx->unres);
Michal Vaskod39bea42021-06-14 10:42:49 +0200548 return ret;
Michal Vasko01db7de2021-04-16 12:23:30 +0200549}
550
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100551LIBYANG_API_DEF uint16_t
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200552ly_ctx_get_options(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200553{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200554 LY_CHECK_ARG_RET(ctx, ctx, 0);
Michal Vasko28f1ffe2021-06-15 11:57:23 +0200555
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200556 return ctx->flags;
557}
558
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100559LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200560ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200561{
Michal Vasko01db7de2021-04-16 12:23:30 +0200562 LY_ERR lyrc = LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200563 struct lys_module *mod;
564 uint32_t i;
Radek Krejciddbc4812021-04-13 21:18:02 +0200565
Radek Krejcica828d92018-09-20 14:19:43 +0200566 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vaskoaecb11f2021-10-19 14:02:42 +0200567 LY_CHECK_ERR_RET((option & LY_CTX_NO_YANGLIBRARY) && !(ctx->flags & LY_CTX_NO_YANGLIBRARY),
568 LOGARG(ctx, option), LY_EINVAL);
aPiecek9922ea92021-04-12 07:59:20 +0200569
570 if (!(ctx->flags & LY_CTX_SET_PRIV_PARSED) && (option & LY_CTX_SET_PRIV_PARSED)) {
571 ctx->flags |= LY_CTX_SET_PRIV_PARSED;
Michal Vasko7213ac52021-06-15 11:52:13 +0200572 /* recompile the whole context to set the priv pointers */
573 for (i = 0; i < ctx->list.count; ++i) {
574 mod = ctx->list.objs[i];
575 if (mod->implemented) {
576 mod->to_compile = 1;
577 }
578 }
579 lyrc = ly_ctx_compile(ctx);
Michal Vasko01db7de2021-04-16 12:23:30 +0200580 if (lyrc) {
aPiecek9922ea92021-04-12 07:59:20 +0200581 ly_ctx_unset_options(ctx, LY_CTX_SET_PRIV_PARSED);
582 }
583 }
Radek Krejcica828d92018-09-20 14:19:43 +0200584
585 /* set the option(s) */
aPiecek9922ea92021-04-12 07:59:20 +0200586 if (!lyrc) {
587 ctx->flags |= option;
588 }
Radek Krejcica828d92018-09-20 14:19:43 +0200589
aPiecek9922ea92021-04-12 07:59:20 +0200590 return lyrc;
591}
592
593static LY_ERR
594lysc_node_clear_priv_dfs_cb(struct lysc_node *node, void *UNUSED(data), ly_bool *UNUSED(dfs_continue))
595{
596 node->priv = NULL;
Radek Krejcica828d92018-09-20 14:19:43 +0200597 return LY_SUCCESS;
598}
599
aPiecek60d9d672021-04-27 15:49:57 +0200600static void
601lysc_node_clear_all_priv(struct lys_module *mod)
602{
603 LY_ARRAY_COUNT_TYPE u, v;
604
aPiecekafe9ba22021-05-07 10:41:57 +0200605 if (!mod->compiled) {
606 return;
aPiecek60d9d672021-04-27 15:49:57 +0200607 }
608
aPiecekafe9ba22021-05-07 10:41:57 +0200609 /* set NULL for all ::lysc_node.priv pointers in module */
610 lysc_module_dfs_full(mod, lysc_node_clear_priv_dfs_cb, NULL);
611
aPiecek60d9d672021-04-27 15:49:57 +0200612 /* only lys_compile_extension_instance()
613 * can set ::lysp_ext_instance.parsed
614 */
615 if (mod->parsed) {
616 struct lysp_ext_instance *exts_p;
617 exts_p = mod->parsed->exts;
618 LY_ARRAY_FOR(exts_p, u) {
619 if (exts_p[u].parsed) {
620 /* lys_compile_extension_instance() was called */
621 struct lysc_ext_substmt *substmts;
622 struct lysc_node *root;
623 /* set NULL for all ::lysc_node.priv pointers in extensions */
624 substmts = mod->compiled->exts[u].substmts;
625 LY_ARRAY_FOR(substmts, v) {
626 root = *(struct lysc_node **)substmts[v].storage;
627 lysc_tree_dfs_full(root, lysc_node_clear_priv_dfs_cb, NULL);
628 }
629 }
630 }
631 }
632}
633
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100634LIBYANG_API_DEF LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200635ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200636{
637 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200638 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200639
aPiecek9922ea92021-04-12 07:59:20 +0200640 if ((ctx->flags & LY_CTX_SET_PRIV_PARSED) && (option & LY_CTX_SET_PRIV_PARSED)) {
641 struct lys_module *mod;
642 uint32_t index;
643
644 index = 0;
Michal Vaskoa51ef072021-07-02 10:40:30 +0200645 while ((mod = ly_ctx_get_module_iter(ctx, &index))) {
aPiecek60d9d672021-04-27 15:49:57 +0200646 lysc_node_clear_all_priv(mod);
aPiecek9922ea92021-04-12 07:59:20 +0200647 }
648 }
649
Radek Krejcica828d92018-09-20 14:19:43 +0200650 /* unset the option(s) */
651 ctx->flags &= ~option;
652
653 return LY_SUCCESS;
654}
655
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100656LIBYANG_API_DEF uint16_t
Michal Vasko794ab4b2021-03-31 09:42:19 +0200657ly_ctx_get_change_count(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200658{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200659 LY_CHECK_ARG_RET(ctx, ctx, 0);
Michal Vasko794ab4b2021-03-31 09:42:19 +0200660
661 return ctx->change_count;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200662}
663
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100664LIBYANG_API_DEF ly_module_imp_clb
Radek Krejcid33273d2018-10-25 14:55:52 +0200665ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data)
666{
667 LY_CHECK_ARG_RET(ctx, ctx, NULL);
668
669 if (user_data) {
670 *user_data = ctx->imp_clb_data;
671 }
672 return ctx->imp_clb;
673}
674
Michal Vaskoaac267d2022-01-17 13:34:48 +0100675LIBYANG_API_DEF void
676ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data)
677{
678 LY_CHECK_ARG_RET(ctx, ctx, );
679
680 ctx->imp_clb = clb;
681 ctx->imp_clb_data = user_data;
682}
683
684LIBYANG_API_DEF ly_ext_data_clb
685ly_ctx_set_ext_data_clb(struct ly_ctx *ctx, ly_ext_data_clb clb, void *user_data)
686{
687 ly_ext_data_clb prev;
688
689 LY_CHECK_ARG_RET(ctx, ctx, NULL);
690
691 prev = ctx->ext_clb;
692 ctx->ext_clb = clb;
693 ctx->ext_clb_data = user_data;
694
695 return prev;
696}
697
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100698LIBYANG_API_DEF struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200699ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index)
Radek Krejcied5acc52019-04-25 15:57:04 +0200700{
701 LY_CHECK_ARG_RET(ctx, ctx, index, NULL);
702
Michal Vasko2307ff82021-04-16 11:51:18 +0200703 if (*index < ctx->list.count) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200704 return ctx->list.objs[(*index)++];
Radek Krejci2390fb52019-04-30 13:27:43 +0200705 } else {
706 return NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200707 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200708}
709
Radek Krejcib7db73a2018-10-24 14:18:40 +0200710/**
711 * @brief Iterate over the modules in the given context. Returned modules must match the given key at the offset of
712 * lysp_module and lysc_module structures (they are supposed to be placed at the same offset in both structures).
713 *
714 * @param[in] ctx Context where to iterate.
715 * @param[in] key Key value to search for.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200716 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100717 * @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 +0200718 * @param[in,out] Iterator to pass between the function calls. On the first call, the variable is supposed to be
719 * initiated to 0. After each call returning a module, the value is greater by 1 than the index of the returned
720 * module in the context.
721 * @return Module matching the given key, NULL if no such module found.
722 */
Radek Krejci0af46292019-01-11 16:02:31 +0100723static struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200724ly_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 +0200725{
Radek Krejci0af46292019-01-11 16:02:31 +0100726 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200727 const char *value;
728
Michal Vaskod989ba02020-08-24 10:59:24 +0200729 for ( ; *index < ctx->list.count; ++(*index)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200730 mod = ctx->list.objs[*index];
Michal Vasko22df3f02020-08-24 13:29:22 +0200731 value = *(const char **)(((int8_t *)(mod)) + key_offset);
Michal Vasko69730152020-10-09 16:30:07 +0200732 if ((!key_size && !strcmp(key, value)) || (key_size && !strncmp(key, value, key_size) && (value[key_size] == '\0'))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200733 /* increment index for the next run */
734 ++(*index);
735 return mod;
736 }
737 }
738 /* done */
739 return NULL;
740}
741
742/**
743 * @brief Unifying function for ly_ctx_get_module() and ly_ctx_get_module_ns()
744 * @param[in] ctx Context where to search.
745 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100746 * @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 +0200747 * @param[in] revision Revision date to match. If NULL, the matching module must have no revision. To search for the latest
748 * revision module, use ly_ctx_get_module_latest_by().
749 * @return Matching module if any.
750 */
Radek Krejci0af46292019-01-11 16:02:31 +0100751static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200752ly_ctx_get_module_by(const struct ly_ctx *ctx, const char *key, size_t key_offset, const char *revision)
753{
Radek Krejci0af46292019-01-11 16:02:31 +0100754 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200755 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200756
Radek Krejci0ad51f12020-07-16 12:08:12 +0200757 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200758 if (!revision) {
Radek Krejci0af46292019-01-11 16:02:31 +0100759 if (!mod->revision) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200760 /* found requested module without revision */
761 return mod;
762 }
763 } else {
Radek Krejci0af46292019-01-11 16:02:31 +0100764 if (mod->revision && !strcmp(mod->revision, revision)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200765 /* found requested module of the specific revision */
766 return mod;
767 }
768 }
769 }
770
771 return NULL;
772}
773
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100774LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200775ly_ctx_get_module_ns(const struct ly_ctx *ctx, const char *ns, const char *revision)
776{
777 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100778 return ly_ctx_get_module_by(ctx, ns, offsetof(struct lys_module, ns), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200779}
780
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100781LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200782ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision)
783{
784 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100785 return ly_ctx_get_module_by(ctx, name, offsetof(struct lys_module, name), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200786}
787
788/**
789 * @brief Unifying function for ly_ctx_get_module_latest() and ly_ctx_get_module_latest_ns()
790 * @param[in] ctx Context where to search.
791 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100792 * @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 +0200793 * @return Matching module if any.
794 */
Radek Krejci0af46292019-01-11 16:02:31 +0100795static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200796ly_ctx_get_module_latest_by(const struct ly_ctx *ctx, const char *key, size_t key_offset)
797{
Radek Krejci0af46292019-01-11 16:02:31 +0100798 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200799 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200800
Radek Krejci0ad51f12020-07-16 12:08:12 +0200801 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
aPiecek94d330b2021-08-04 11:57:31 +0200802 if (mod->latest_revision & LYS_MOD_LATEST_REV) {
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200803 return mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200804 }
805 }
806
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200807 return NULL;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200808}
809
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100810LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200811ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name)
812{
813 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100814 return ly_ctx_get_module_latest_by(ctx, name, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200815}
816
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100817LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200818ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns)
819{
820 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100821 return ly_ctx_get_module_latest_by(ctx, ns, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200822}
823
824/**
825 * @brief Unifying function for ly_ctx_get_module_implemented() and ly_ctx_get_module_implemented_ns()
826 * @param[in] ctx Context where to search.
827 * @param[in] key Name or Namespace as a search key.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200828 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100829 * @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 +0200830 * @return Matching module if any.
831 */
Radek Krejci0af46292019-01-11 16:02:31 +0100832static struct lys_module *
Radek Krejci0ad51f12020-07-16 12:08:12 +0200833ly_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 +0200834{
Radek Krejci0af46292019-01-11 16:02:31 +0100835 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200836 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200837
Radek Krejci0ad51f12020-07-16 12:08:12 +0200838 while ((mod = ly_ctx_get_module_by_iter(ctx, key, key_size, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100839 if (mod->implemented) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200840 return mod;
841 }
842 }
843
844 return NULL;
845}
846
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100847LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200848ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name)
849{
850 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200851 return ly_ctx_get_module_implemented_by(ctx, name, 0, offsetof(struct lys_module, name));
852}
853
854struct lys_module *
855ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len)
856{
857 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
858 return ly_ctx_get_module_implemented_by(ctx, name, name_len, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200859}
860
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100861LIBYANG_API_DEF struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200862ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns)
863{
864 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200865 return ly_ctx_get_module_implemented_by(ctx, ns, 0, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200866}
867
Michal Vasko8dc31992021-02-22 10:30:47 +0100868/**
869 * @brief Try to find a submodule in a module.
870 *
871 * @param[in] module Module where to search in.
872 * @param[in] submodule Name of the submodule to find.
873 * @param[in] revision Revision of the submodule to find. NULL for submodule with no revision.
874 * @param[in] latest Ignore @p revision and look for the latest revision.
875 * @return Pointer to the specified submodule if it is present in the context.
876 */
877static const struct lysp_submodule *
878_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 +0200879{
Radek Krejcid33273d2018-10-25 14:55:52 +0200880 struct lysp_include *inc;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200881 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid33273d2018-10-25 14:55:52 +0200882
Michal Vasko8dc31992021-02-22 10:30:47 +0100883 LY_CHECK_ARG_RET(NULL, module, module->parsed, submodule, NULL);
Michal Vaskoc3781c32020-10-06 14:04:08 +0200884
Michal Vasko8dc31992021-02-22 10:30:47 +0100885 LY_ARRAY_FOR(module->parsed->includes, u) {
886 if (module->parsed->includes[u].submodule && !strcmp(submodule, module->parsed->includes[u].submodule->name)) {
887 inc = &module->parsed->includes[u];
888
889 if (latest && inc->submodule->latest_revision) {
890 /* latest revision */
891 return inc->submodule;
892 } else if (!revision && !inc->submodule->revs) {
893 /* no revision */
894 return inc->submodule;
895 } else if (revision && inc->submodule->revs && !strcmp(revision, inc->submodule->revs[0].date)) {
896 /* specific revision */
897 return inc->submodule;
898 }
Michal Vaskoc3781c32020-10-06 14:04:08 +0200899 }
Michal Vaskoc3781c32020-10-06 14:04:08 +0200900 }
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100901
Michal Vasko8dc31992021-02-22 10:30:47 +0100902 return NULL;
903}
904
905/**
906 * @brief Try to find a submodule in the context.
907 *
908 * @param[in] ctx Context where to search in.
909 * @param[in] submodule Name of the submodule to find.
910 * @param[in] revision Revision of the submodule to find. NULL for submodule with no revision.
911 * @param[in] latest Ignore @p revision and look for the latest revision.
912 * @return Pointer to the specified submodule if it is present in the context.
913 */
914static const struct lysp_submodule *
915_ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision, ly_bool latest)
916{
917 const struct lys_module *mod;
918 const struct lysp_submodule *submod = NULL;
919 uint32_t v;
920
921 LY_CHECK_ARG_RET(ctx, ctx, submodule, NULL);
922
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100923 for (v = 0; v < ctx->list.count; ++v) {
924 mod = ctx->list.objs[v];
Radek Krejcid33273d2018-10-25 14:55:52 +0200925 if (!mod->parsed) {
926 continue;
927 }
928
Michal Vasko8dc31992021-02-22 10:30:47 +0100929 submod = _ly_ctx_get_submodule2(mod, submodule, revision, latest);
930 if (submod) {
Michal Vaskoc3781c32020-10-06 14:04:08 +0200931 break;
932 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200933 }
934
Michal Vasko8dc31992021-02-22 10:30:47 +0100935 return submod;
936}
937
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100938LIBYANG_API_DEF const struct lysp_submodule *
Michal Vasko8dc31992021-02-22 10:30:47 +0100939ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision)
940{
941 return _ly_ctx_get_submodule(ctx, submodule, revision, 0);
942}
943
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100944LIBYANG_API_DEF const struct lysp_submodule *
Michal Vasko8dc31992021-02-22 10:30:47 +0100945ly_ctx_get_submodule_latest(const struct ly_ctx *ctx, const char *submodule)
946{
947 return _ly_ctx_get_submodule(ctx, submodule, NULL, 1);
948}
949
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100950LIBYANG_API_DEF const struct lysp_submodule *
Michal Vasko8dc31992021-02-22 10:30:47 +0100951ly_ctx_get_submodule2(const struct lys_module *module, const char *submodule, const char *revision)
952{
953 return _ly_ctx_get_submodule2(module, submodule, revision, 0);
954}
955
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100956LIBYANG_API_DEF const struct lysp_submodule *
Michal Vasko8dc31992021-02-22 10:30:47 +0100957ly_ctx_get_submodule2_latest(const struct lys_module *module, const char *submodule)
958{
959 return _ly_ctx_get_submodule2(module, submodule, NULL, 1);
Radek Krejcid33273d2018-10-25 14:55:52 +0200960}
961
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100962LIBYANG_API_DEF void
Radek Krejcie9e987e2018-10-31 12:50:27 +0100963ly_ctx_reset_latests(struct ly_ctx *ctx)
964{
Radek Krejcie9e987e2018-10-31 12:50:27 +0100965 struct lys_module *mod;
966
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200967 for (uint32_t v = 0; v < ctx->list.count; ++v) {
968 mod = ctx->list.objs[v];
Michal Vasko3cb9fb22022-01-12 14:02:35 +0100969 mod->latest_revision &= ~(LYS_MOD_LATEST_SEARCHDIRS | LYS_MOD_LATEST_IMPCLB);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100970 if (mod->parsed && mod->parsed->includes) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200971 for (LY_ARRAY_COUNT_TYPE u = 0; u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
Michal Vasko3cb9fb22022-01-12 14:02:35 +0100972 mod->parsed->includes[u].submodule->latest_revision &= ~(LYS_MOD_LATEST_SEARCHDIRS | LYS_MOD_LATEST_IMPCLB);
Radek Krejcie9e987e2018-10-31 12:50:27 +0100973 }
974 }
975 }
976}
977
Jan Kundrátc6e39de2021-12-09 16:01:19 +0100978LIBYANG_API_DEF uint32_t
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100979ly_ctx_internal_modules_count(const struct ly_ctx *ctx)
Michal Vaskode79e222020-08-10 11:55:46 +0200980{
981 if (!ctx) {
982 return 0;
983 }
984
Michal Vasko25d6ad02020-10-22 12:20:22 +0200985 if (ctx->flags & LY_CTX_NO_YANGLIBRARY) {
Michal Vaskode79e222020-08-10 11:55:46 +0200986 return LY_INTERNAL_MODS_COUNT - 2;
987 } else {
988 return LY_INTERNAL_MODS_COUNT;
989 }
990}
991
Michal Vasko57c10cd2020-05-27 15:57:11 +0200992static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100993ylib_feature(struct lyd_node *parent, const struct lysp_module *pmod)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200994{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100995 LY_ARRAY_COUNT_TYPE u;
996 struct lysp_feature *f;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200997
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100998 if (!pmod->mod->implemented) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200999 /* no features can be enabled */
1000 return LY_SUCCESS;
1001 }
1002
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001003 LY_ARRAY_FOR(pmod->features, struct lysp_feature, f) {
1004 if (!(f->flags & LYS_FENABLED)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +02001005 continue;
1006 }
1007
Radek Krejci41ac9942020-11-02 14:47:56 +01001008 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001009 }
1010
1011 LY_ARRAY_FOR(pmod->includes, u) {
1012 LY_ARRAY_FOR(pmod->includes[u].submodule->features, struct lysp_feature, f) {
1013 if (!(f->flags & LYS_FENABLED)) {
1014 continue;
1015 }
1016
Radek Krejci41ac9942020-11-02 14:47:56 +01001017 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001018 }
Michal Vasko57c10cd2020-05-27 15:57:11 +02001019 }
1020
1021 return LY_SUCCESS;
1022}
1023
1024static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +02001025ylib_deviation(struct lyd_node *parent, const struct lys_module *cur_mod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +02001026{
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001027 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001028 struct lys_module *mod;
1029
1030 if (!cur_mod->implemented) {
1031 /* no deviations of the module for certain */
1032 return LY_SUCCESS;
1033 }
1034
Michal Vasko7f45cf22020-10-01 12:49:44 +02001035 LY_ARRAY_FOR(cur_mod->deviated_by, i) {
1036 mod = cur_mod->deviated_by[i];
Michal Vasko57c10cd2020-05-27 15:57:11 +02001037
1038 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001039 LY_CHECK_RET(lyd_new_term(parent, NULL, "deviation", mod->name, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001040 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001041 LY_CHECK_RET(lyd_new_list(parent, NULL, "deviation", 0, NULL, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001042 (mod->parsed->revs ? mod->parsed->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001043 }
1044 }
1045
1046 return LY_SUCCESS;
1047}
1048
1049static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001050ylib_submodules(struct lyd_node *parent, const struct lysp_module *pmod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +02001051{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001052 LY_ERR ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001053 LY_ARRAY_COUNT_TYPE i;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001054 struct lyd_node *cont;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001055 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001056 int r;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001057 char *str;
1058
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001059 LY_ARRAY_FOR(pmod->includes, i) {
1060 submod = pmod->includes[i].submodule;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001061
1062 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001063 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001064
1065 if (submod->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001066 LY_CHECK_RET(lyd_new_term(cont, NULL, "revision", submod->revs[0].date, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001067 }
1068 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001069 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001070 (submod->revs ? submod->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001071 }
1072
1073 if (submod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001074 r = asprintf(&str, "file://%s", submod->filepath);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001075 LY_CHECK_ERR_RET(r == -1, LOGMEM(pmod->mod->ctx), LY_EMEM);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001076
Radek Krejci41ac9942020-11-02 14:47:56 +01001077 ret = lyd_new_term(cont, NULL, bis ? "location" : "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001078 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001079 LY_CHECK_RET(ret);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001080 }
1081 }
1082
1083 return LY_SUCCESS;
1084}
1085
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001086LIBYANG_API_DEF LY_ERR
Michal Vasko794ab4b2021-03-31 09:42:19 +02001087ly_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 +02001088{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001089 LY_ERR ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001090 uint32_t i;
Radek Krejci857189e2020-09-01 13:26:36 +02001091 ly_bool bis = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001092 int r;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001093 char *str;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001094 const struct lys_module *mod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001095 struct lyd_node *root = NULL, *root_bis = NULL, *cont, *set_bis = NULL;
Michal Vasko794ab4b2021-03-31 09:42:19 +02001096 va_list ap;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001097
Michal Vasko3a41dff2020-07-15 14:30:28 +02001098 LY_CHECK_ARG_RET(ctx, ctx, root_p, LY_EINVAL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001099
1100 mod = ly_ctx_get_module_implemented(ctx, "ietf-yang-library");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001101 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 +02001102
1103 if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, "2016-06-21")) {
1104 bis = 0;
1105 } else if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, IETF_YANG_LIB_REV)) {
1106 bis = 1;
1107 } else {
1108 LOGERR(ctx, LY_EINVAL, "Incompatible ietf-yang-library version in context.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001109 return LY_EINVAL;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001110 }
1111
Radek Krejci41ac9942020-11-02 14:47:56 +01001112 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "modules-state", 0, &root), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001113
1114 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001115 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "yang-library", 0, &root_bis), error);
1116 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "module-set", 0, &set_bis, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001117 }
1118
1119 for (i = 0; i < ctx->list.count; ++i) {
1120 mod = ctx->list.objs[i];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001121 if (!mod->parsed) {
1122 LOGERR(ctx, LY_ENOTFOUND, "Parsed module \"%s\" missing in the context.", mod->name);
1123 goto error;
1124 }
Michal Vasko57c10cd2020-05-27 15:57:11 +02001125
1126 /*
1127 * deprecated legacy
1128 */
Radek Krejci41ac9942020-11-02 14:47:56 +01001129 LY_CHECK_GOTO(ret = lyd_new_list(root, NULL, "module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001130 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001131
1132 /* schema */
1133 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001134 r = asprintf(&str, "file://%s", mod->filepath);
1135 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001136
Radek Krejci41ac9942020-11-02 14:47:56 +01001137 ret = lyd_new_term(cont, NULL, "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001138 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001139 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001140 }
1141
1142 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +01001143 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001144
1145 /* feature leaf-list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001146 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001147
1148 /* deviation list */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001149 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001150
1151 /* conformance-type */
Radek Krejci41ac9942020-11-02 14:47:56 +01001152 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "conformance-type", mod->implemented ? "implement" : "import", 0,
Michal Vasko69730152020-10-09 16:30:07 +02001153 NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001154
1155 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001156 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001157
1158 /*
1159 * current revision
1160 */
1161 if (bis) {
1162 /* name and revision */
1163 if (mod->implemented) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001164 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "module", 0, &cont, mod->name), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001165
1166 if (mod->parsed->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001167 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 +02001168 }
1169 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001170 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "import-only-module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001171 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001172 }
1173
1174 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +01001175 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001176
1177 /* location */
1178 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001179 r = asprintf(&str, "file://%s", mod->filepath);
1180 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001181
Radek Krejcid68ba1b2020-11-09 17:40:11 +01001182 ret = lyd_new_term(cont, NULL, "location", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001183 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001184 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001185 }
1186
1187 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001188 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001189
1190 /* feature list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001191 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001192
1193 /* deviation */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001194 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001195 }
1196 }
1197
1198 /* IDs */
Michal Vasko794ab4b2021-03-31 09:42:19 +02001199 va_start(ap, content_id_format);
1200 r = vasprintf(&str, content_id_format, ap);
1201 va_end(ap);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001202 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
1203 ret = lyd_new_term(root, NULL, "module-set-id", str, 0, NULL);
1204 LY_CHECK_ERR_GOTO(ret, free(str), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001205
1206 if (bis) {
1207 /* create one complete schema */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001208 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 +02001209
Radek Krejcif13b87b2020-12-01 22:02:17 +01001210 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 +02001211
1212 /* content-id */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001213 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 +02001214 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001215 free(str);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001216
1217 if (root_bis) {
Michal Vaskob104f112020-07-17 09:54:54 +02001218 if (lyd_insert_sibling(root, root_bis, &root)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +02001219 goto error;
1220 }
Michal Vaskob104f112020-07-17 09:54:54 +02001221 root_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001222 }
1223
Michal Vasko3a41dff2020-07-15 14:30:28 +02001224 LY_CHECK_GOTO(ret = lyd_validate_all(&root, NULL, LYD_VALIDATE_PRESENT, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001225
Michal Vasko3a41dff2020-07-15 14:30:28 +02001226 *root_p = root;
1227 return LY_SUCCESS;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001228
1229error:
1230 lyd_free_all(root);
1231 lyd_free_all(root_bis);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001232 return ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001233}
1234
Jan Kundrátc6e39de2021-12-09 16:01:19 +01001235LIBYANG_API_DEF void
Radek Krejci90ed21e2021-04-12 14:47:46 +02001236ly_ctx_destroy(struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001237{
Michal Vasko65333882021-06-10 14:12:16 +02001238 struct lys_module *mod;
1239
Radek Krejci418823a2018-09-20 16:42:13 +02001240 if (!ctx) {
1241 return;
1242 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001243
1244 /* models list */
Michal Vaskod989ba02020-08-24 10:59:24 +02001245 for ( ; ctx->list.count; ctx->list.count--) {
Michal Vasko65333882021-06-10 14:12:16 +02001246 mod = ctx->list.objs[ctx->list.count - 1];
1247
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001248 /* remove the module */
Michal Vasko65333882021-06-10 14:12:16 +02001249 if (mod->implemented) {
1250 mod->implemented = 0;
1251 lysc_module_free(mod->compiled);
1252 mod->compiled = NULL;
1253 }
Radek Krejci90ed21e2021-04-12 14:47:46 +02001254 lys_module_free(ctx->list.objs[ctx->list.count - 1]);
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001255 }
1256 free(ctx->list.objs);
1257
1258 /* search paths list */
Radek Krejcia40f21b2018-09-18 10:42:08 +02001259 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001260
Michal Vasko22b26222021-07-30 11:16:47 +02001261 /* leftover unres */
1262 lys_unres_glob_erase(&ctx->unres);
1263
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001264 /* clean the error list */
1265 ly_err_clean(ctx, 0);
1266 pthread_key_delete(ctx->errlist_key);
1267
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001268 /* dictionary */
1269 lydict_clean(&ctx->dict);
1270
Michal Vasko11f76c82021-04-15 14:36:14 +02001271 /* LYB hash lock */
1272 pthread_mutex_destroy(&ctx->lyb_hash_lock);
1273
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001274 /* plugins - will be removed only if this is the last context */
Radek Krejci3e6632f2021-03-22 22:08:21 +01001275 lyplg_clean();
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001276
1277 free(ctx);
1278}