blob: c13a82e79816029e9c90600da93d838f4c7262b0 [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"
54#include "../models/ietf-yang-types@2013-07-15.h"
Michal Vaskoe78faec2021-04-08 17:24:43 +020055#include "../models/yang@2021-04-07.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020056#define IETF_YANG_LIB_REV "2019-01-04"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020057
Radek Krejci0af5f5d2018-09-07 15:00:30 +020058static struct internal_modules_s {
59 const char *name;
60 const char *revision;
61 const char *data;
Radek Krejci857189e2020-09-01 13:26:36 +020062 ly_bool implemented;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020063 LYS_INFORMAT format;
Michal Vaskode79e222020-08-10 11:55:46 +020064} internal_modules[] = {
Michal Vasko1de593f2020-11-23 16:11:41 +010065 {"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 +020066 {"yang", "2021-04-07", (const char *)yang_2021_04_07_yang, 1, LYS_IN_YANG},
Michal Vasko22df3f02020-08-24 13:29:22 +020067 {"ietf-inet-types", "2013-07-15", (const char *)ietf_inet_types_2013_07_15_yang, 0, LYS_IN_YANG},
68 {"ietf-yang-types", "2013-07-15", (const char *)ietf_yang_types_2013_07_15_yang, 0, LYS_IN_YANG},
Radek Krejci0af5f5d2018-09-07 15:00:30 +020069 /* ietf-datastores and ietf-yang-library must be right here at the end of the list! */
Michal Vasko22df3f02020-08-24 13:29:22 +020070 {"ietf-datastores", "2018-02-14", (const char *)ietf_datastores_2018_02_14_yang, 1, LYS_IN_YANG},
71 {"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 +020072};
73
Michal Vaskode79e222020-08-10 11:55:46 +020074#define LY_INTERNAL_MODS_COUNT sizeof(internal_modules) / sizeof(struct internal_modules_s)
75
Radek Krejci0af5f5d2018-09-07 15:00:30 +020076API LY_ERR
77ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir)
78{
Radek Krejci0e212402018-09-20 11:29:38 +020079 struct stat st;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020080 char *new_dir = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020081
82 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
83
84 if (search_dir) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +020085 new_dir = realpath(search_dir, NULL);
Radek Krejcia77e0e12018-09-20 12:39:15 +020086 LY_CHECK_ERR_RET(!new_dir,
Michal Vasko69730152020-10-09 16:30:07 +020087 LOGERR(ctx, LY_ESYS, "Unable to use search directory \"%s\" (%s).", search_dir, strerror(errno)),
88 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020089 if (strcmp(search_dir, new_dir)) {
90 LOGVRB("Canonicalizing search directory string from \"%s\" to \"%s\".", search_dir, new_dir);
91 }
92 LY_CHECK_ERR_RET(access(new_dir, R_OK | X_OK),
Michal Vasko69730152020-10-09 16:30:07 +020093 LOGERR(ctx, LY_ESYS, "Unable to fully access search directory \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
94 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020095 LY_CHECK_ERR_RET(stat(new_dir, &st),
Michal Vasko69730152020-10-09 16:30:07 +020096 LOGERR(ctx, LY_ESYS, "stat() failed for \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
97 LY_ESYS);
Radek Krejci3a077b92019-04-09 17:10:35 +020098 LY_CHECK_ERR_RET(!S_ISDIR(st.st_mode),
Michal Vasko69730152020-10-09 16:30:07 +020099 LOGERR(ctx, LY_ESYS, "Given search directory \"%s\" is not a directory.", new_dir); free(new_dir),
100 LY_EINVAL);
Radek Krejci0e212402018-09-20 11:29:38 +0200101 /* avoid path duplication */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200102 for (uint32_t u = 0; u < ctx->search_paths.count; ++u) {
Radek Krejci14946ab2018-09-20 13:42:06 +0200103 if (!strcmp(new_dir, ctx->search_paths.objs[u])) {
Radek Krejci0e212402018-09-20 11:29:38 +0200104 free(new_dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200105 return LY_EEXIST;
Radek Krejci0e212402018-09-20 11:29:38 +0200106 }
107 }
Radek Krejci3d92e442020-10-12 12:48:13 +0200108 if (ly_set_add(&ctx->search_paths, new_dir, 1, NULL)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200109 free(new_dir);
110 return LY_EMEM;
111 }
112
Radek Krejcie9e987e2018-10-31 12:50:27 +0100113 /* new searchdir - possibly more latest revision available */
114 ly_ctx_reset_latests(ctx);
115
Radek Krejci0e212402018-09-20 11:29:38 +0200116 return LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200117 } else {
118 /* consider that no change is not actually an error */
119 return LY_SUCCESS;
120 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200121}
122
123API const char * const *
124ly_ctx_get_searchdirs(const struct ly_ctx *ctx)
125{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100126#define LY_CTX_SEARCHDIRS_SIZE_STEP 8
Radek Krejci05026432018-09-20 12:13:43 +0200127 void **new;
128
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200129 LY_CHECK_ARG_RET(ctx, ctx, NULL);
Radek Krejci05026432018-09-20 12:13:43 +0200130
131 if (ctx->search_paths.count == ctx->search_paths.size) {
132 /* not enough space for terminating NULL byte */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100133 new = realloc(((struct ly_ctx *)ctx)->search_paths.objs,
134 (ctx->search_paths.size + LY_CTX_SEARCHDIRS_SIZE_STEP) * sizeof *ctx->search_paths.objs);
Radek Krejci05026432018-09-20 12:13:43 +0200135 LY_CHECK_ERR_RET(!new, LOGMEM(NULL), NULL);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100136 ((struct ly_ctx *)ctx)->search_paths.size += LY_CTX_SEARCHDIRS_SIZE_STEP;
Radek Krejci05026432018-09-20 12:13:43 +0200137 ((struct ly_ctx *)ctx)->search_paths.objs = new;
138 }
139 /* set terminating NULL byte to the strings list */
140 ctx->search_paths.objs[ctx->search_paths.count] = NULL;
141
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200142 return (const char * const *)ctx->search_paths.objs;
143}
144
145API LY_ERR
Radek Krejcie58f97f2020-08-18 11:45:08 +0200146ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200147{
Radek Krejcicd649072018-09-20 12:14:45 +0200148 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Radek Krejcicd649072018-09-20 12:14:45 +0200149
Michal Vaskob34480a2018-09-17 10:34:45 +0200150 if (!ctx->search_paths.count) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200151 return LY_SUCCESS;
152 }
153
Radek Krejci0759b792018-09-20 13:53:15 +0200154 if (value) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200155 /* remove specific search directory */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200156 uint32_t index;
157
Radek Krejci0759b792018-09-20 13:53:15 +0200158 for (index = 0; index < ctx->search_paths.count; ++index) {
159 if (!strcmp(value, ctx->search_paths.objs[index])) {
160 break;
161 }
162 }
163 if (index == ctx->search_paths.count) {
164 LOGARG(ctx, value);
165 return LY_EINVAL;
166 } else {
167 return ly_set_rm_index(&ctx->search_paths, index, free);
168 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200169 } else {
170 /* remove them all */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200171 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200172 memset(&ctx->search_paths, 0, sizeof ctx->search_paths);
173 }
174
175 return LY_SUCCESS;
176}
177
178API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200179ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count)
Radek Krejcied5acc52019-04-25 15:57:04 +0200180{
181 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
182
Radek Krejcie58f97f2020-08-18 11:45:08 +0200183 for ( ; count > 0 && ctx->search_paths.count; --count) {
184 LY_CHECK_RET(ly_set_rm_index(&ctx->search_paths, ctx->search_paths.count - 1, free))
Radek Krejcied5acc52019-04-25 15:57:04 +0200185 }
186
187 return LY_SUCCESS;
188}
189
190API const struct lys_module *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100191ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision, const char **features)
Radek Krejcied5acc52019-04-25 15:57:04 +0200192{
Michal Vasko88497502021-06-10 14:41:51 +0200193 struct lys_module *mod = NULL;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100194 struct lys_glob_unres unres = {0};
195 LY_ERR ret = LY_SUCCESS;
Radek Krejcied5acc52019-04-25 15:57:04 +0200196
197 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
198
Michal Vaskodd992582021-06-10 14:34:57 +0200199 /* load and parse */
200 ret = lys_parse_load(ctx, name, revision, &unres.creating, &mod);
201 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko4e205e82021-06-08 14:01:47 +0200202
203 /* implement */
Michal Vasko65333882021-06-10 14:12:16 +0200204 ret = _lys_set_implemented(mod, features, &unres);
205 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100206
Michal Vaskof4258e12021-06-15 12:11:42 +0200207 if (!(ctx->flags & LY_CTX_EXPLICIT_COMPILE)) {
208 /* create dep set for the module and mark all the modules that will be (re)compiled */
Michal Vasko50bc09a2021-06-17 17:31:56 +0200209 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &unres.dep_sets, mod), cleanup);
Michal Vaskof4258e12021-06-15 12:11:42 +0200210
211 /* (re)compile the whole dep set */
212 LY_CHECK_GOTO(ret = lys_compile_dep_set_r(ctx, unres.dep_sets.objs[0], &unres), cleanup);
213 }
214
Michal Vasko405cc9e2020-12-01 12:01:27 +0100215cleanup:
216 if (ret) {
Michal Vaskof4258e12021-06-15 12:11:42 +0200217 lys_unres_glob_revert(ctx, &unres);
Michal Vaskodf6319c2021-06-10 14:41:05 +0200218 mod = NULL;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100219 }
Michal Vaskof4258e12021-06-15 12:11:42 +0200220 lys_unres_glob_erase(&unres);
Michal Vaskodf6319c2021-06-10 14:41:05 +0200221 return mod;
Radek Krejcied5acc52019-04-25 15:57:04 +0200222}
223
224API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200225ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200226{
227 struct ly_ctx *ctx = NULL;
228 struct lys_module *module;
229 char *search_dir_list;
230 char *sep, *dir;
Michal Vaskode79e222020-08-10 11:55:46 +0200231 uint32_t i;
Michal Vasko63f3d842020-07-08 10:10:14 +0200232 struct ly_in *in = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200233 LY_ERR rc = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100234 struct lys_glob_unres unres = {0};
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200235
Radek Krejcied5acc52019-04-25 15:57:04 +0200236 LY_CHECK_ARG_RET(NULL, new_ctx, LY_EINVAL);
237
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200238 ctx = calloc(1, sizeof *ctx);
Michal Vasko88497502021-06-10 14:41:51 +0200239 LY_CHECK_ERR_GOTO(!ctx, LOGMEM(NULL); rc = LY_EMEM, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200240
241 /* dictionary */
242 lydict_init(&ctx->dict);
243
244 /* plugins */
Michal Vasko88497502021-06-10 14:41:51 +0200245 LY_CHECK_ERR_GOTO(lyplg_init(), LOGINT(NULL); rc = LY_EINT, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200246
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100247 /* initialize thread-specific keys */
Radek Krejci1e008d22020-08-17 11:37:37 +0200248 while ((pthread_key_create(&ctx->errlist_key, ly_err_free)) == EAGAIN) {}
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200249
Michal Vasko11f76c82021-04-15 14:36:14 +0200250 /* init LYB hash lock */
251 pthread_mutex_init(&ctx->lyb_hash_lock, NULL);
252
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200253 /* models list */
254 ctx->flags = options;
255 if (search_dir) {
256 search_dir_list = strdup(search_dir);
Michal Vasko88497502021-06-10 14:41:51 +0200257 LY_CHECK_ERR_GOTO(!search_dir_list, LOGMEM(NULL); rc = LY_EMEM, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200258
259 for (dir = search_dir_list; (sep = strchr(dir, ':')) != NULL && rc == LY_SUCCESS; dir = sep + 1) {
260 *sep = 0;
261 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200262 if (rc == LY_EEXIST) {
263 /* ignore duplication */
264 rc = LY_SUCCESS;
265 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200266 }
Michal Vasko69730152020-10-09 16:30:07 +0200267 if (*dir && (rc == LY_SUCCESS)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200268 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200269 if (rc == LY_EEXIST) {
270 /* ignore duplication */
271 rc = LY_SUCCESS;
272 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200273 }
274 free(search_dir_list);
275
276 /* If ly_ctx_set_searchdir() failed, the error is already logged. Just exit */
Michal Vasko88497502021-06-10 14:41:51 +0200277 LY_CHECK_GOTO(rc, cleanup);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200278 }
Michal Vasko794ab4b2021-03-31 09:42:19 +0200279 ctx->change_count = 1;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200280
Michal Vasko9434ec52021-04-19 11:30:55 +0200281 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
282 /* use it for creating the initial context */
283 ctx->flags |= LY_CTX_EXPLICIT_COMPILE;
284 }
285
Michal Vasko63f3d842020-07-08 10:10:14 +0200286 /* create dummy in */
287 rc = ly_in_new_memory(internal_modules[0].data, &in);
Michal Vasko88497502021-06-10 14:41:51 +0200288 LY_CHECK_GOTO(rc, cleanup);
Michal Vasko63f3d842020-07-08 10:10:14 +0200289
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200290 /* load internal modules */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200291 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 +0200292 ly_in_memory(in, internal_modules[i].data);
Michal Vaskodd992582021-06-10 14:34:57 +0200293 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 +0200294 if (internal_modules[i].implemented || (ctx->flags & LY_CTX_ALL_IMPLEMENTED)) {
Michal Vasko88497502021-06-10 14:41:51 +0200295 LY_CHECK_GOTO(rc = lys_implement(module, NULL, &unres), cleanup);
Michal Vasko4e205e82021-06-08 14:01:47 +0200296 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200297 }
298
Michal Vasko9434ec52021-04-19 11:30:55 +0200299 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
300 /* compile now */
Michal Vasko88497502021-06-10 14:41:51 +0200301 LY_CHECK_GOTO(rc = ly_ctx_compile(ctx), cleanup);
Michal Vasko9434ec52021-04-19 11:30:55 +0200302 ctx->flags &= ~LY_CTX_EXPLICIT_COMPILE;
303 }
304
Michal Vasko88497502021-06-10 14:41:51 +0200305cleanup:
Michal Vasko63f3d842020-07-08 10:10:14 +0200306 ly_in_free(in, 0);
Michal Vaskof4258e12021-06-15 12:11:42 +0200307 lys_unres_glob_erase(&unres);
Michal Vaskodf6319c2021-06-10 14:41:05 +0200308 if (rc) {
309 ly_ctx_destroy(ctx);
310 } else {
311 *new_ctx = ctx;
312 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200313 return rc;
314}
Radek Krejci0f969882020-08-21 16:56:47 +0200315
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200316static LY_ERR
317ly_ctx_new_yl_legacy(struct ly_ctx *ctx, struct lyd_node *yltree)
318{
319 struct lyd_node *module, *node;
320 struct ly_set *set;
321 const char **feature_arr = NULL;
322 const char *name = NULL, *revision = NULL;
323 struct ly_set features = {0};
324 ly_bool imported = 0;
325 const struct lys_module *mod;
326 LY_ERR ret = LY_SUCCESS;
327
328 LY_CHECK_RET(ret = lyd_find_xpath(yltree, "/ietf-yang-library:yang-library/modules-state/module", &set));
329
330 /* process the data tree */
331 for (uint32_t i = 0; i < set->count; ++i) {
332 module = set->dnodes[i];
333
334 /* initiate */
335 revision = NULL;
336 name = NULL;
337 imported = 0;
338
339 LY_LIST_FOR(lyd_child(module), node) {
340 if (!strcmp(node->schema->name, "name")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200341 name = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200342 } else if (!strcmp(node->schema->name, "revision")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200343 revision = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200344 } else if (!strcmp(node->schema->name, "feature")) {
345 LY_CHECK_GOTO(ret = ly_set_add(&features, node, 0, NULL), cleanup);
346 } else if (!strcmp(node->schema->name, "conformance-type") &&
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200347 !strcmp(lyd_get_value(node), "import")) {
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200348 /* imported module - skip it, it will be loaded as a side effect
349 * of loading another module */
350 imported = 1;
351 break;
352 }
353 }
354
355 if (imported) {
356 continue;
357 }
358
359 feature_arr = malloc((features.count + 1) * sizeof *feature_arr);
360 LY_CHECK_ERR_GOTO(!feature_arr, ret = LY_EMEM, cleanup);
361
362 /* Parse features into an array of strings */
363 for (uint32_t u = 0; u < features.count; u++) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200364 feature_arr[u] = lyd_get_value(features.dnodes[u]);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200365 }
366 feature_arr[features.count] = NULL;
367 ly_set_clean(&features, free);
368
369 /* use the gathered data to load the module */
370 mod = ly_ctx_load_module(ctx, name, revision, feature_arr);
371 free(feature_arr);
372 if (!mod) {
373 LOGERR(ctx, LY_EINVAL, "Unable to load module specified by yang library data.");
374 ly_set_free(set, free);
375 return LY_EINVAL;
376 }
377 }
378
379cleanup:
380 ly_set_clean(&features, free);
381 ly_set_free(set, free);
382 return ret;
383}
384
385static LY_ERR
386ly_ctx_new_yl_common(const char *search_dir, const char *input, LYD_FORMAT format, int options,
387 LY_ERR (*parser_func)(const struct ly_ctx *, const char *, LYD_FORMAT, uint32_t, uint32_t, struct lyd_node **),
388 struct ly_ctx **ctx)
389{
390 const char *name = NULL, *revision = NULL;
391 struct lyd_node *module, *node;
392 struct lyd_node *yltree = NULL;
393 struct ly_set *set = NULL;
394 const char **feature_arr = NULL;
395 struct ly_set features = {0};
396 LY_ERR ret = LY_SUCCESS;
397 const struct lys_module *mod;
398 struct ly_ctx *ctx_yl = NULL, *ctx_new = NULL;
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200399 ly_bool no_expl_compile = 0;
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200400
401 /* create a seperate context in case it is LY_CTX_NO_YANGLIBRARY since it needs it for parsing */
402 if (options & LY_CTX_NO_YANGLIBRARY) {
403 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, 0, &ctx_yl), cleanup);
404 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, options, &ctx_new), cleanup);
405 } else {
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200406 LY_CHECK_GOTO(ret = ly_ctx_new(search_dir, options, &ctx_new), cleanup);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200407 }
408
409 /* parse yang library data tree */
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200410 LY_CHECK_GOTO(ret = parser_func(ctx_yl ? ctx_yl : ctx_new, input, format, 0, LYD_VALIDATE_PRESENT, &yltree), cleanup);
411
412 /* redundant to compile modules one-by-one */
413 if (!(options & LY_CTX_EXPLICIT_COMPILE)) {
414 ctx_new->flags |= LY_CTX_EXPLICIT_COMPILE;
415 no_expl_compile = 1;
416 }
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200417
418 LY_CHECK_GOTO(ret = lyd_find_xpath(yltree, "/ietf-yang-library:yang-library/module-set[1]/module", &set), cleanup);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200419 if (set->count == 0) {
420 /* perhaps a legacy data tree? */
421 LY_CHECK_GOTO(ret = ly_ctx_new_yl_legacy(ctx_new, yltree), cleanup);
422 } else {
423 /* process the data tree */
424 for (uint32_t i = 0; i < set->count; ++i) {
425 module = set->dnodes[i];
426
427 /* initiate */
428 name = NULL;
429 revision = NULL;
430
431 /* Iterate over data */
432 LY_LIST_FOR(lyd_child(module), node) {
433 if (!strcmp(node->schema->name, "name")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200434 name = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200435 } else if (!strcmp(node->schema->name, "revision")) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200436 revision = lyd_get_value(node);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200437 } else if (!strcmp(node->schema->name, "feature")) {
438 LY_CHECK_GOTO(ret = ly_set_add(&features, node, 0, NULL), cleanup);
439 }
440 }
441
442 feature_arr = malloc((features.count + 1) * sizeof *feature_arr);
443 LY_CHECK_ERR_GOTO(!feature_arr, ret = LY_EMEM, cleanup);
444
445 /* Parse features into an array of strings */
446 for (uint32_t u = 0; u < features.count; u++) {
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200447 feature_arr[u] = lyd_get_value(features.dnodes[u]);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200448 }
449 feature_arr[features.count] = NULL;
450 ly_set_clean(&features, NULL);
451
452 /* use the gathered data to load the module */
453 mod = ly_ctx_load_module(ctx_new, name, revision, feature_arr);
454 free(feature_arr);
455 if (!mod) {
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200456 LOGERR(NULL, LY_EINVAL, "Unable to load module %s@%s specified by yang library data.", name,
457 revision ? revision : "<none>");
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200458 ret = LY_EINVAL;
459 goto cleanup;
460 }
461 }
462 }
463
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200464 /* free data because their context may be recompiled */
465 lyd_free_all(yltree);
466 yltree = NULL;
467
468 /* compile */
469 LY_CHECK_GOTO(ret = ly_ctx_compile(ctx_new), cleanup);
470
471 if (no_expl_compile) {
472 /* unset flag */
473 ctx_new->flags &= ~LY_CTX_EXPLICIT_COMPILE;
474 }
475
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200476cleanup:
477 lyd_free_all(yltree);
478 ly_set_free(set, NULL);
479 ly_set_erase(&features, NULL);
Michal Vaskoad8d0f52021-04-26 13:21:24 +0200480 ly_ctx_destroy(ctx_yl);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200481 *ctx = ctx_new;
482 if (ret) {
Radek Krejci90ed21e2021-04-12 14:47:46 +0200483 ly_ctx_destroy(*ctx);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200484 *ctx = NULL;
485 }
486
487 return ret;
488}
489
490API LY_ERR
491ly_ctx_new_ylpath(const char *search_dir, const char *path, LYD_FORMAT format, int options, struct ly_ctx **ctx)
492{
Michal Vasko2104e072021-04-16 11:50:44 +0200493 LY_CHECK_ARG_RET(NULL, path, ctx, LY_EINVAL);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200494 return ly_ctx_new_yl_common(search_dir, path, format, options, lyd_parse_data_path, ctx);
495}
496
497API LY_ERR
498ly_ctx_new_ylmem(const char *search_dir, const char *data, LYD_FORMAT format, int options, struct ly_ctx **ctx)
499{
500 LY_CHECK_ARG_RET(NULL, data, ctx, LY_EINVAL);
501 return ly_ctx_new_yl_common(search_dir, data, format, options, lyd_parse_data_mem, ctx);
502}
503
Michal Vasko01db7de2021-04-16 12:23:30 +0200504API LY_ERR
505ly_ctx_compile(struct ly_ctx *ctx)
506{
Michal Vaskod39bea42021-06-14 10:42:49 +0200507 LY_ERR ret = LY_SUCCESS;
Michal Vasko01db7de2021-04-16 12:23:30 +0200508 uint32_t i;
Michal Vaskod39bea42021-06-14 10:42:49 +0200509 struct lys_glob_unres unres = {0};
Michal Vasko01db7de2021-04-16 12:23:30 +0200510
511 LY_CHECK_ARG_RET(NULL, ctx, LY_EINVAL);
512
Michal Vaskof4258e12021-06-15 12:11:42 +0200513 /* create dep sets and mark all the modules that will be (re)compiled */
Michal Vasko50bc09a2021-06-17 17:31:56 +0200514 LY_CHECK_GOTO(ret = lys_unres_dep_sets_create(ctx, &unres.dep_sets, NULL), cleanup);
Michal Vaskod39bea42021-06-14 10:42:49 +0200515
Michal Vaskof4258e12021-06-15 12:11:42 +0200516 /* (re)compile all the dep sets */
517 for (i = 0; i < unres.dep_sets.count; ++i) {
518 LY_CHECK_GOTO(ret = lys_compile_dep_set_r(ctx, unres.dep_sets.objs[i], &unres), cleanup);
Michal Vasko01db7de2021-04-16 12:23:30 +0200519 }
520
Michal Vaskod39bea42021-06-14 10:42:49 +0200521cleanup:
Michal Vaskof4258e12021-06-15 12:11:42 +0200522 if (ret) {
523 /* revert changes of modules */
524 lys_unres_glob_revert(ctx, &unres);
525 }
526 lys_unres_glob_erase(&unres);
Michal Vaskod39bea42021-06-14 10:42:49 +0200527 return ret;
Michal Vasko01db7de2021-04-16 12:23:30 +0200528}
529
Radek Krejci1deb5be2020-08-26 16:43:36 +0200530API uint16_t
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200531ly_ctx_get_options(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200532{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200533 LY_CHECK_ARG_RET(ctx, ctx, 0);
Michal Vasko28f1ffe2021-06-15 11:57:23 +0200534
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200535 return ctx->flags;
536}
537
Radek Krejcica828d92018-09-20 14:19:43 +0200538API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200539ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200540{
Michal Vasko01db7de2021-04-16 12:23:30 +0200541 LY_ERR lyrc = LY_SUCCESS;
Michal Vasko7213ac52021-06-15 11:52:13 +0200542 struct lys_module *mod;
543 uint32_t i;
Radek Krejciddbc4812021-04-13 21:18:02 +0200544
Radek Krejcica828d92018-09-20 14:19:43 +0200545 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200546 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
aPiecek9922ea92021-04-12 07:59:20 +0200547
548 if (!(ctx->flags & LY_CTX_SET_PRIV_PARSED) && (option & LY_CTX_SET_PRIV_PARSED)) {
549 ctx->flags |= LY_CTX_SET_PRIV_PARSED;
Michal Vasko7213ac52021-06-15 11:52:13 +0200550 /* recompile the whole context to set the priv pointers */
551 for (i = 0; i < ctx->list.count; ++i) {
552 mod = ctx->list.objs[i];
553 if (mod->implemented) {
554 mod->to_compile = 1;
555 }
556 }
557 lyrc = ly_ctx_compile(ctx);
Michal Vasko01db7de2021-04-16 12:23:30 +0200558 if (lyrc) {
aPiecek9922ea92021-04-12 07:59:20 +0200559 ly_ctx_unset_options(ctx, LY_CTX_SET_PRIV_PARSED);
560 }
561 }
Radek Krejcica828d92018-09-20 14:19:43 +0200562
563 /* set the option(s) */
aPiecek9922ea92021-04-12 07:59:20 +0200564 if (!lyrc) {
565 ctx->flags |= option;
566 }
Radek Krejcica828d92018-09-20 14:19:43 +0200567
aPiecek9922ea92021-04-12 07:59:20 +0200568 return lyrc;
569}
570
571static LY_ERR
572lysc_node_clear_priv_dfs_cb(struct lysc_node *node, void *UNUSED(data), ly_bool *UNUSED(dfs_continue))
573{
574 node->priv = NULL;
Radek Krejcica828d92018-09-20 14:19:43 +0200575 return LY_SUCCESS;
576}
577
aPiecek60d9d672021-04-27 15:49:57 +0200578static void
579lysc_node_clear_all_priv(struct lys_module *mod)
580{
581 LY_ARRAY_COUNT_TYPE u, v;
582
aPiecekafe9ba22021-05-07 10:41:57 +0200583 if (!mod->compiled) {
584 return;
aPiecek60d9d672021-04-27 15:49:57 +0200585 }
586
aPiecekafe9ba22021-05-07 10:41:57 +0200587 /* set NULL for all ::lysc_node.priv pointers in module */
588 lysc_module_dfs_full(mod, lysc_node_clear_priv_dfs_cb, NULL);
589
aPiecek60d9d672021-04-27 15:49:57 +0200590 /* only lys_compile_extension_instance()
591 * can set ::lysp_ext_instance.parsed
592 */
593 if (mod->parsed) {
594 struct lysp_ext_instance *exts_p;
595 exts_p = mod->parsed->exts;
596 LY_ARRAY_FOR(exts_p, u) {
597 if (exts_p[u].parsed) {
598 /* lys_compile_extension_instance() was called */
599 struct lysc_ext_substmt *substmts;
600 struct lysc_node *root;
601 /* set NULL for all ::lysc_node.priv pointers in extensions */
602 substmts = mod->compiled->exts[u].substmts;
603 LY_ARRAY_FOR(substmts, v) {
604 root = *(struct lysc_node **)substmts[v].storage;
605 lysc_tree_dfs_full(root, lysc_node_clear_priv_dfs_cb, NULL);
606 }
607 }
608 }
609 }
610}
611
Radek Krejcica828d92018-09-20 14:19:43 +0200612API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200613ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200614{
615 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200616 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200617
aPiecek9922ea92021-04-12 07:59:20 +0200618 if ((ctx->flags & LY_CTX_SET_PRIV_PARSED) && (option & LY_CTX_SET_PRIV_PARSED)) {
619 struct lys_module *mod;
620 uint32_t index;
621
622 index = 0;
623 while ((mod = (struct lys_module *)ly_ctx_get_module_iter(ctx, &index))) {
aPiecek60d9d672021-04-27 15:49:57 +0200624 lysc_node_clear_all_priv(mod);
aPiecek9922ea92021-04-12 07:59:20 +0200625 }
626 }
627
Radek Krejcica828d92018-09-20 14:19:43 +0200628 /* unset the option(s) */
629 ctx->flags &= ~option;
630
631 return LY_SUCCESS;
632}
633
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200634API uint16_t
Michal Vasko794ab4b2021-03-31 09:42:19 +0200635ly_ctx_get_change_count(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200636{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200637 LY_CHECK_ARG_RET(ctx, ctx, 0);
Michal Vasko794ab4b2021-03-31 09:42:19 +0200638
639 return ctx->change_count;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200640}
641
Radek Krejcid33273d2018-10-25 14:55:52 +0200642API void
643ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data)
644{
Michal Vaskod989ba02020-08-24 10:59:24 +0200645 LY_CHECK_ARG_RET(ctx, ctx, );
Radek Krejcid33273d2018-10-25 14:55:52 +0200646
647 ctx->imp_clb = clb;
648 ctx->imp_clb_data = user_data;
649}
650
651API ly_module_imp_clb
652ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data)
653{
654 LY_CHECK_ARG_RET(ctx, ctx, NULL);
655
656 if (user_data) {
657 *user_data = ctx->imp_clb_data;
658 }
659 return ctx->imp_clb;
660}
661
Radek Krejcied5acc52019-04-25 15:57:04 +0200662API const struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200663ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index)
Radek Krejcied5acc52019-04-25 15:57:04 +0200664{
665 LY_CHECK_ARG_RET(ctx, ctx, index, NULL);
666
Michal Vasko2307ff82021-04-16 11:51:18 +0200667 if (*index < ctx->list.count) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200668 return ctx->list.objs[(*index)++];
Radek Krejci2390fb52019-04-30 13:27:43 +0200669 } else {
670 return NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200671 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200672}
673
Radek Krejcib7db73a2018-10-24 14:18:40 +0200674/**
675 * @brief Iterate over the modules in the given context. Returned modules must match the given key at the offset of
676 * lysp_module and lysc_module structures (they are supposed to be placed at the same offset in both structures).
677 *
678 * @param[in] ctx Context where to iterate.
679 * @param[in] key Key value to search for.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200680 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100681 * @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 +0200682 * @param[in,out] Iterator to pass between the function calls. On the first call, the variable is supposed to be
683 * initiated to 0. After each call returning a module, the value is greater by 1 than the index of the returned
684 * module in the context.
685 * @return Module matching the given key, NULL if no such module found.
686 */
Radek Krejci0af46292019-01-11 16:02:31 +0100687static struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200688ly_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 +0200689{
Radek Krejci0af46292019-01-11 16:02:31 +0100690 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200691 const char *value;
692
Michal Vaskod989ba02020-08-24 10:59:24 +0200693 for ( ; *index < ctx->list.count; ++(*index)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200694 mod = ctx->list.objs[*index];
Michal Vasko22df3f02020-08-24 13:29:22 +0200695 value = *(const char **)(((int8_t *)(mod)) + key_offset);
Michal Vasko69730152020-10-09 16:30:07 +0200696 if ((!key_size && !strcmp(key, value)) || (key_size && !strncmp(key, value, key_size) && (value[key_size] == '\0'))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200697 /* increment index for the next run */
698 ++(*index);
699 return mod;
700 }
701 }
702 /* done */
703 return NULL;
704}
705
706/**
707 * @brief Unifying function for ly_ctx_get_module() and ly_ctx_get_module_ns()
708 * @param[in] ctx Context where to search.
709 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100710 * @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 +0200711 * @param[in] revision Revision date to match. If NULL, the matching module must have no revision. To search for the latest
712 * revision module, use ly_ctx_get_module_latest_by().
713 * @return Matching module if any.
714 */
Radek Krejci0af46292019-01-11 16:02:31 +0100715static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200716ly_ctx_get_module_by(const struct ly_ctx *ctx, const char *key, size_t key_offset, const char *revision)
717{
Radek Krejci0af46292019-01-11 16:02:31 +0100718 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200719 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200720
Radek Krejci0ad51f12020-07-16 12:08:12 +0200721 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200722 if (!revision) {
Radek Krejci0af46292019-01-11 16:02:31 +0100723 if (!mod->revision) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200724 /* found requested module without revision */
725 return mod;
726 }
727 } else {
Radek Krejci0af46292019-01-11 16:02:31 +0100728 if (mod->revision && !strcmp(mod->revision, revision)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200729 /* found requested module of the specific revision */
730 return mod;
731 }
732 }
733 }
734
735 return NULL;
736}
737
Radek Krejci0af46292019-01-11 16:02:31 +0100738API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200739ly_ctx_get_module_ns(const struct ly_ctx *ctx, const char *ns, const char *revision)
740{
741 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100742 return ly_ctx_get_module_by(ctx, ns, offsetof(struct lys_module, ns), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200743}
744
Radek Krejci0af46292019-01-11 16:02:31 +0100745API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200746ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision)
747{
748 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100749 return ly_ctx_get_module_by(ctx, name, offsetof(struct lys_module, name), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200750}
751
752/**
753 * @brief Unifying function for ly_ctx_get_module_latest() and ly_ctx_get_module_latest_ns()
754 * @param[in] ctx Context where to search.
755 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100756 * @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 +0200757 * @return Matching module if any.
758 */
Radek Krejci0af46292019-01-11 16:02:31 +0100759static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200760ly_ctx_get_module_latest_by(const struct ly_ctx *ctx, const char *key, size_t key_offset)
761{
Radek Krejci0af46292019-01-11 16:02:31 +0100762 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200763 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200764
Radek Krejci0ad51f12020-07-16 12:08:12 +0200765 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100766 if (mod->latest_revision) {
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200767 return mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200768 }
769 }
770
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200771 return NULL;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200772}
773
Radek Krejci0af46292019-01-11 16:02:31 +0100774API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200775ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name)
776{
777 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100778 return ly_ctx_get_module_latest_by(ctx, name, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200779}
780
Radek Krejci0af46292019-01-11 16:02:31 +0100781API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200782ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns)
783{
784 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100785 return ly_ctx_get_module_latest_by(ctx, ns, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200786}
787
788/**
789 * @brief Unifying function for ly_ctx_get_module_implemented() and ly_ctx_get_module_implemented_ns()
790 * @param[in] ctx Context where to search.
791 * @param[in] key Name or Namespace as a search key.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200792 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100793 * @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 +0200794 * @return Matching module if any.
795 */
Radek Krejci0af46292019-01-11 16:02:31 +0100796static struct lys_module *
Radek Krejci0ad51f12020-07-16 12:08:12 +0200797ly_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 +0200798{
Radek Krejci0af46292019-01-11 16:02:31 +0100799 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200800 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200801
Radek Krejci0ad51f12020-07-16 12:08:12 +0200802 while ((mod = ly_ctx_get_module_by_iter(ctx, key, key_size, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100803 if (mod->implemented) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200804 return mod;
805 }
806 }
807
808 return NULL;
809}
810
Radek Krejci0af46292019-01-11 16:02:31 +0100811API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200812ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name)
813{
814 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200815 return ly_ctx_get_module_implemented_by(ctx, name, 0, offsetof(struct lys_module, name));
816}
817
818struct lys_module *
819ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len)
820{
821 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
822 return ly_ctx_get_module_implemented_by(ctx, name, name_len, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200823}
824
Radek Krejci0af46292019-01-11 16:02:31 +0100825API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200826ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns)
827{
828 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200829 return ly_ctx_get_module_implemented_by(ctx, ns, 0, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200830}
831
Michal Vasko8dc31992021-02-22 10:30:47 +0100832/**
833 * @brief Try to find a submodule in a module.
834 *
835 * @param[in] module Module where to search in.
836 * @param[in] submodule Name of the submodule to find.
837 * @param[in] revision Revision of the submodule to find. NULL for submodule with no revision.
838 * @param[in] latest Ignore @p revision and look for the latest revision.
839 * @return Pointer to the specified submodule if it is present in the context.
840 */
841static const struct lysp_submodule *
842_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 +0200843{
Radek Krejcid33273d2018-10-25 14:55:52 +0200844 struct lysp_include *inc;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200845 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid33273d2018-10-25 14:55:52 +0200846
Michal Vasko8dc31992021-02-22 10:30:47 +0100847 LY_CHECK_ARG_RET(NULL, module, module->parsed, submodule, NULL);
Michal Vaskoc3781c32020-10-06 14:04:08 +0200848
Michal Vasko8dc31992021-02-22 10:30:47 +0100849 LY_ARRAY_FOR(module->parsed->includes, u) {
850 if (module->parsed->includes[u].submodule && !strcmp(submodule, module->parsed->includes[u].submodule->name)) {
851 inc = &module->parsed->includes[u];
852
853 if (latest && inc->submodule->latest_revision) {
854 /* latest revision */
855 return inc->submodule;
856 } else if (!revision && !inc->submodule->revs) {
857 /* no revision */
858 return inc->submodule;
859 } else if (revision && inc->submodule->revs && !strcmp(revision, inc->submodule->revs[0].date)) {
860 /* specific revision */
861 return inc->submodule;
862 }
Michal Vaskoc3781c32020-10-06 14:04:08 +0200863 }
Michal Vaskoc3781c32020-10-06 14:04:08 +0200864 }
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100865
Michal Vasko8dc31992021-02-22 10:30:47 +0100866 return NULL;
867}
868
869/**
870 * @brief Try to find a submodule in the context.
871 *
872 * @param[in] ctx Context where to search in.
873 * @param[in] submodule Name of the submodule to find.
874 * @param[in] revision Revision of the submodule to find. NULL for submodule with no revision.
875 * @param[in] latest Ignore @p revision and look for the latest revision.
876 * @return Pointer to the specified submodule if it is present in the context.
877 */
878static const struct lysp_submodule *
879_ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision, ly_bool latest)
880{
881 const struct lys_module *mod;
882 const struct lysp_submodule *submod = NULL;
883 uint32_t v;
884
885 LY_CHECK_ARG_RET(ctx, ctx, submodule, NULL);
886
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100887 for (v = 0; v < ctx->list.count; ++v) {
888 mod = ctx->list.objs[v];
Radek Krejcid33273d2018-10-25 14:55:52 +0200889 if (!mod->parsed) {
890 continue;
891 }
892
Michal Vasko8dc31992021-02-22 10:30:47 +0100893 submod = _ly_ctx_get_submodule2(mod, submodule, revision, latest);
894 if (submod) {
Michal Vaskoc3781c32020-10-06 14:04:08 +0200895 break;
896 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200897 }
898
Michal Vasko8dc31992021-02-22 10:30:47 +0100899 return submod;
900}
901
902API const struct lysp_submodule *
903ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision)
904{
905 return _ly_ctx_get_submodule(ctx, submodule, revision, 0);
906}
907
908API const struct lysp_submodule *
909ly_ctx_get_submodule_latest(const struct ly_ctx *ctx, const char *submodule)
910{
911 return _ly_ctx_get_submodule(ctx, submodule, NULL, 1);
912}
913
914API const struct lysp_submodule *
915ly_ctx_get_submodule2(const struct lys_module *module, const char *submodule, const char *revision)
916{
917 return _ly_ctx_get_submodule2(module, submodule, revision, 0);
918}
919
920API const struct lysp_submodule *
921ly_ctx_get_submodule2_latest(const struct lys_module *module, const char *submodule)
922{
923 return _ly_ctx_get_submodule2(module, submodule, NULL, 1);
Radek Krejcid33273d2018-10-25 14:55:52 +0200924}
925
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200926API void
Radek Krejcie9e987e2018-10-31 12:50:27 +0100927ly_ctx_reset_latests(struct ly_ctx *ctx)
928{
Radek Krejcie9e987e2018-10-31 12:50:27 +0100929 struct lys_module *mod;
930
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200931 for (uint32_t v = 0; v < ctx->list.count; ++v) {
932 mod = ctx->list.objs[v];
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100933 if (mod->latest_revision == 2) {
934 mod->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100935 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100936 if (mod->parsed && mod->parsed->includes) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200937 for (LY_ARRAY_COUNT_TYPE u = 0; u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200938 if (mod->parsed->includes[u].submodule->latest_revision == 2) {
939 mod->parsed->includes[u].submodule->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100940 }
941 }
942 }
943 }
944}
945
Michal Vaskode79e222020-08-10 11:55:46 +0200946API uint32_t
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100947ly_ctx_internal_modules_count(const struct ly_ctx *ctx)
Michal Vaskode79e222020-08-10 11:55:46 +0200948{
949 if (!ctx) {
950 return 0;
951 }
952
Michal Vasko25d6ad02020-10-22 12:20:22 +0200953 if (ctx->flags & LY_CTX_NO_YANGLIBRARY) {
Michal Vaskode79e222020-08-10 11:55:46 +0200954 return LY_INTERNAL_MODS_COUNT - 2;
955 } else {
956 return LY_INTERNAL_MODS_COUNT;
957 }
958}
959
Michal Vasko57c10cd2020-05-27 15:57:11 +0200960static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100961ylib_feature(struct lyd_node *parent, const struct lysp_module *pmod)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200962{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100963 LY_ARRAY_COUNT_TYPE u;
964 struct lysp_feature *f;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200965
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100966 if (!pmod->mod->implemented) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200967 /* no features can be enabled */
968 return LY_SUCCESS;
969 }
970
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100971 LY_ARRAY_FOR(pmod->features, struct lysp_feature, f) {
972 if (!(f->flags & LYS_FENABLED)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200973 continue;
974 }
975
Radek Krejci41ac9942020-11-02 14:47:56 +0100976 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100977 }
978
979 LY_ARRAY_FOR(pmod->includes, u) {
980 LY_ARRAY_FOR(pmod->includes[u].submodule->features, struct lysp_feature, f) {
981 if (!(f->flags & LYS_FENABLED)) {
982 continue;
983 }
984
Radek Krejci41ac9942020-11-02 14:47:56 +0100985 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100986 }
Michal Vasko57c10cd2020-05-27 15:57:11 +0200987 }
988
989 return LY_SUCCESS;
990}
991
992static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200993ylib_deviation(struct lyd_node *parent, const struct lys_module *cur_mod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200994{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200995 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200996 struct lys_module *mod;
997
998 if (!cur_mod->implemented) {
999 /* no deviations of the module for certain */
1000 return LY_SUCCESS;
1001 }
1002
Michal Vasko7f45cf22020-10-01 12:49:44 +02001003 LY_ARRAY_FOR(cur_mod->deviated_by, i) {
1004 mod = cur_mod->deviated_by[i];
Michal Vasko57c10cd2020-05-27 15:57:11 +02001005
1006 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001007 LY_CHECK_RET(lyd_new_term(parent, NULL, "deviation", mod->name, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001008 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001009 LY_CHECK_RET(lyd_new_list(parent, NULL, "deviation", 0, NULL, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001010 (mod->parsed->revs ? mod->parsed->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001011 }
1012 }
1013
1014 return LY_SUCCESS;
1015}
1016
1017static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001018ylib_submodules(struct lyd_node *parent, const struct lysp_module *pmod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +02001019{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001020 LY_ERR ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +02001021 LY_ARRAY_COUNT_TYPE i;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001022 struct lyd_node *cont;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001023 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001024 int r;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001025 char *str;
1026
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001027 LY_ARRAY_FOR(pmod->includes, i) {
1028 submod = pmod->includes[i].submodule;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001029
1030 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001031 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001032
1033 if (submod->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001034 LY_CHECK_RET(lyd_new_term(cont, NULL, "revision", submod->revs[0].date, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001035 }
1036 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001037 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001038 (submod->revs ? submod->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +02001039 }
1040
1041 if (submod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001042 r = asprintf(&str, "file://%s", submod->filepath);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001043 LY_CHECK_ERR_RET(r == -1, LOGMEM(pmod->mod->ctx), LY_EMEM);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001044
Radek Krejci41ac9942020-11-02 14:47:56 +01001045 ret = lyd_new_term(cont, NULL, bis ? "location" : "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001046 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001047 LY_CHECK_RET(ret);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001048 }
1049 }
1050
1051 return LY_SUCCESS;
1052}
1053
Michal Vasko3a41dff2020-07-15 14:30:28 +02001054API LY_ERR
Michal Vasko794ab4b2021-03-31 09:42:19 +02001055ly_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 +02001056{
Michal Vasko3a41dff2020-07-15 14:30:28 +02001057 LY_ERR ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001058 uint32_t i;
Radek Krejci857189e2020-09-01 13:26:36 +02001059 ly_bool bis = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +02001060 int r;
Radek Krejcif13b87b2020-12-01 22:02:17 +01001061 char *str;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001062 const struct lys_module *mod;
Michal Vasko3a41dff2020-07-15 14:30:28 +02001063 struct lyd_node *root = NULL, *root_bis = NULL, *cont, *set_bis = NULL;
Michal Vasko794ab4b2021-03-31 09:42:19 +02001064 va_list ap;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001065
Michal Vasko3a41dff2020-07-15 14:30:28 +02001066 LY_CHECK_ARG_RET(ctx, ctx, root_p, LY_EINVAL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001067
1068 mod = ly_ctx_get_module_implemented(ctx, "ietf-yang-library");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001069 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 +02001070
1071 if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, "2016-06-21")) {
1072 bis = 0;
1073 } else if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, IETF_YANG_LIB_REV)) {
1074 bis = 1;
1075 } else {
1076 LOGERR(ctx, LY_EINVAL, "Incompatible ietf-yang-library version in context.");
Michal Vasko3a41dff2020-07-15 14:30:28 +02001077 return LY_EINVAL;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001078 }
1079
Radek Krejci41ac9942020-11-02 14:47:56 +01001080 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "modules-state", 0, &root), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001081
1082 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001083 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "yang-library", 0, &root_bis), error);
1084 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "module-set", 0, &set_bis, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001085 }
1086
1087 for (i = 0; i < ctx->list.count; ++i) {
1088 mod = ctx->list.objs[i];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001089 if (!mod->parsed) {
1090 LOGERR(ctx, LY_ENOTFOUND, "Parsed module \"%s\" missing in the context.", mod->name);
1091 goto error;
1092 }
Michal Vasko57c10cd2020-05-27 15:57:11 +02001093
1094 /*
1095 * deprecated legacy
1096 */
Radek Krejci41ac9942020-11-02 14:47:56 +01001097 LY_CHECK_GOTO(ret = lyd_new_list(root, NULL, "module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001098 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001099
1100 /* schema */
1101 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001102 r = asprintf(&str, "file://%s", mod->filepath);
1103 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001104
Radek Krejci41ac9942020-11-02 14:47:56 +01001105 ret = lyd_new_term(cont, NULL, "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001106 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001107 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001108 }
1109
1110 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +01001111 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001112
1113 /* feature leaf-list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001114 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001115
1116 /* deviation list */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001117 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001118
1119 /* conformance-type */
Radek Krejci41ac9942020-11-02 14:47:56 +01001120 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "conformance-type", mod->implemented ? "implement" : "import", 0,
Michal Vasko69730152020-10-09 16:30:07 +02001121 NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001122
1123 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001124 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001125
1126 /*
1127 * current revision
1128 */
1129 if (bis) {
1130 /* name and revision */
1131 if (mod->implemented) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001132 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "module", 0, &cont, mod->name), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001133
1134 if (mod->parsed->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +01001135 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 +02001136 }
1137 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +01001138 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "import-only-module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +02001139 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), 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 /* location */
1146 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +02001147 r = asprintf(&str, "file://%s", mod->filepath);
1148 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001149
Radek Krejcid68ba1b2020-11-09 17:40:11 +01001150 ret = lyd_new_term(cont, NULL, "location", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001151 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001152 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001153 }
1154
1155 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001156 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001157
1158 /* feature list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +01001159 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001160
1161 /* deviation */
Michal Vasko3a41dff2020-07-15 14:30:28 +02001162 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001163 }
1164 }
1165
1166 /* IDs */
Michal Vasko794ab4b2021-03-31 09:42:19 +02001167 va_start(ap, content_id_format);
1168 r = vasprintf(&str, content_id_format, ap);
1169 va_end(ap);
Radek Krejcif13b87b2020-12-01 22:02:17 +01001170 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
1171 ret = lyd_new_term(root, NULL, "module-set-id", str, 0, NULL);
1172 LY_CHECK_ERR_GOTO(ret, free(str), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001173
1174 if (bis) {
1175 /* create one complete schema */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001176 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 +02001177
Radek Krejcif13b87b2020-12-01 22:02:17 +01001178 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 +02001179
1180 /* content-id */
Radek Krejcif13b87b2020-12-01 22:02:17 +01001181 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 +02001182 }
Radek Krejcif13b87b2020-12-01 22:02:17 +01001183 free(str);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001184
1185 if (root_bis) {
Michal Vaskob104f112020-07-17 09:54:54 +02001186 if (lyd_insert_sibling(root, root_bis, &root)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +02001187 goto error;
1188 }
Michal Vaskob104f112020-07-17 09:54:54 +02001189 root_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001190 }
1191
Michal Vasko3a41dff2020-07-15 14:30:28 +02001192 LY_CHECK_GOTO(ret = lyd_validate_all(&root, NULL, LYD_VALIDATE_PRESENT, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +02001193
Michal Vasko3a41dff2020-07-15 14:30:28 +02001194 *root_p = root;
1195 return LY_SUCCESS;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001196
1197error:
1198 lyd_free_all(root);
1199 lyd_free_all(root_bis);
Michal Vasko3a41dff2020-07-15 14:30:28 +02001200 return ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +02001201}
1202
Radek Krejcie9e987e2018-10-31 12:50:27 +01001203API void
Radek Krejci90ed21e2021-04-12 14:47:46 +02001204ly_ctx_destroy(struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001205{
Michal Vasko65333882021-06-10 14:12:16 +02001206 struct lys_module *mod;
1207
Radek Krejci418823a2018-09-20 16:42:13 +02001208 if (!ctx) {
1209 return;
1210 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001211
1212 /* models list */
Michal Vaskod989ba02020-08-24 10:59:24 +02001213 for ( ; ctx->list.count; ctx->list.count--) {
Michal Vasko65333882021-06-10 14:12:16 +02001214 mod = ctx->list.objs[ctx->list.count - 1];
1215
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001216 /* remove the module */
Michal Vasko65333882021-06-10 14:12:16 +02001217 if (mod->implemented) {
1218 mod->implemented = 0;
1219 lysc_module_free(mod->compiled);
1220 mod->compiled = NULL;
1221 }
Radek Krejci90ed21e2021-04-12 14:47:46 +02001222 lys_module_free(ctx->list.objs[ctx->list.count - 1]);
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001223 }
1224 free(ctx->list.objs);
1225
1226 /* search paths list */
Radek Krejcia40f21b2018-09-18 10:42:08 +02001227 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001228
1229 /* clean the error list */
1230 ly_err_clean(ctx, 0);
1231 pthread_key_delete(ctx->errlist_key);
1232
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001233 /* dictionary */
1234 lydict_clean(&ctx->dict);
1235
Michal Vasko11f76c82021-04-15 14:36:14 +02001236 /* LYB hash lock */
1237 pthread_mutex_destroy(&ctx->lyb_hash_lock);
1238
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001239 /* plugins - will be removed only if this is the last context */
Radek Krejci3e6632f2021-03-22 22:08:21 +01001240 lyplg_clean();
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001241
1242 free(ctx);
1243}