blob: 05cbf07e3d7c22bee332c29343bc0a0778358703 [file] [log] [blame]
Radek Krejci0af5f5d2018-09-07 15:00:30 +02001/**
2 * @file context.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Context implementations
5 *
6 * Copyright (c) 2015 - 2018 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
Radek Krejci535ea9f2020-05-29 16:01:05 +020014#define _GNU_SOURCE /* asprintf */
Radek Krejci0af5f5d2018-09-07 15:00:30 +020015
Radek Krejci535ea9f2020-05-29 16:01:05 +020016#include "context.h"
Radek Krejcib7db73a2018-10-24 14:18:40 +020017
Radek Krejcie7b95092019-05-15 11:03:07 +020018#include <assert.h>
Radek Krejci0af5f5d2018-09-07 15:00:30 +020019#include <errno.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020020#include <pthread.h>
21#include <stddef.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020022#include <stdio.h>
Radek Krejci7ada9a02018-09-07 15:34:05 +020023#include <stdlib.h>
24#include <string.h>
Radek Krejci0e212402018-09-20 11:29:38 +020025#include <sys/stat.h>
Radek Krejci0af5f5d2018-09-07 15:00:30 +020026#include <unistd.h>
27
Radek Krejci535ea9f2020-05-29 16:01:05 +020028#include "common.h"
Radek Krejciaa45bda2020-07-20 07:43:38 +020029#include "compat.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020030#include "hash_table.h"
Michal Vasko63f3d842020-07-08 10:10:14 +020031#include "parser.h"
Radek Krejci7931b192020-06-25 17:05:03 +020032#include "parser_data.h"
Michal Vasko308d0a72020-08-03 11:56:25 +020033#include "path.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020034#include "plugins_types.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020035#include "set.h"
36#include "tree.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020037#include "tree_data.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020038#include "tree_schema.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020039#include "tree_schema_internal.h"
Michal Vasko308d0a72020-08-03 11:56:25 +020040#include "xpath.h"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020041
Radek Krejcif3f47842018-11-15 11:22:15 +010042#include "../models/ietf-yang-metadata@2016-08-05.h"
Michal Vaskoe893ddd2020-06-23 13:35:20 +020043#include "../models/yang@2020-06-17.h"
Radek Krejcif3f47842018-11-15 11:22:15 +010044#include "../models/ietf-inet-types@2013-07-15.h"
45#include "../models/ietf-yang-types@2013-07-15.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020046#include "../models/ietf-datastores@2018-02-14.h"
47#include "../models/ietf-yang-library@2019-01-04.h"
48#define IETF_YANG_LIB_REV "2019-01-04"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020049
Radek Krejci0af5f5d2018-09-07 15:00:30 +020050static struct internal_modules_s {
51 const char *name;
52 const char *revision;
53 const char *data;
54 uint8_t implemented;
55 LYS_INFORMAT format;
Michal Vaskode79e222020-08-10 11:55:46 +020056} internal_modules[] = {
Radek Krejci335332a2019-09-05 13:03:35 +020057 {"ietf-yang-metadata", "2016-08-05", (const char*)ietf_yang_metadata_2016_08_05_yang, 1, LYS_IN_YANG},
Michal Vaskoe893ddd2020-06-23 13:35:20 +020058 {"yang", "2020-06-17", (const char*)yang_2020_06_17_yang, 1, LYS_IN_YANG},
Radek Krejci86d106e2018-10-18 09:53:19 +020059 {"ietf-inet-types", "2013-07-15", (const char*)ietf_inet_types_2013_07_15_yang, 0, LYS_IN_YANG},
60 {"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 +020061 /* ietf-datastores and ietf-yang-library must be right here at the end of the list! */
Michal Vaskocf296c82020-05-27 11:16:45 +020062 {"ietf-datastores", "2018-02-14", (const char*)ietf_datastores_2018_02_14_yang, 1, LYS_IN_YANG},
63 {"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 +020064};
65
Michal Vaskode79e222020-08-10 11:55:46 +020066#define LY_INTERNAL_MODS_COUNT sizeof(internal_modules) / sizeof(struct internal_modules_s)
67
Radek Krejci0af5f5d2018-09-07 15:00:30 +020068API LY_ERR
69ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir)
70{
Radek Krejci0e212402018-09-20 11:29:38 +020071 struct stat st;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020072 char *new_dir = NULL;
Radek Krejci0e212402018-09-20 11:29:38 +020073 unsigned int u;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020074
75 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
76
77 if (search_dir) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +020078 new_dir = realpath(search_dir, NULL);
Radek Krejcia77e0e12018-09-20 12:39:15 +020079 LY_CHECK_ERR_RET(!new_dir,
Radek Krejci3a077b92019-04-09 17:10:35 +020080 LOGERR(ctx, LY_ESYS, "Unable to use search directory \"%s\" (%s).", search_dir, strerror(errno)),
81 LY_EINVAL);
82 if (strcmp(search_dir, new_dir)) {
83 LOGVRB("Canonicalizing search directory string from \"%s\" to \"%s\".", search_dir, new_dir);
84 }
85 LY_CHECK_ERR_RET(access(new_dir, R_OK | X_OK),
86 LOGERR(ctx, LY_ESYS, "Unable to fully access search directory \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
87 LY_EINVAL);
88 LY_CHECK_ERR_RET(stat(new_dir, &st),
89 LOGERR(ctx, LY_ESYS, "stat() failed for \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
Radek Krejcia77e0e12018-09-20 12:39:15 +020090 LY_ESYS);
Radek Krejci3a077b92019-04-09 17:10:35 +020091 LY_CHECK_ERR_RET(!S_ISDIR(st.st_mode),
92 LOGERR(ctx, LY_ESYS, "Given search directory \"%s\" is not a directory.", new_dir); free(new_dir),
93 LY_EINVAL);
Radek Krejci0e212402018-09-20 11:29:38 +020094 /* avoid path duplication */
95 for (u = 0; u < ctx->search_paths.count; ++u) {
Radek Krejci14946ab2018-09-20 13:42:06 +020096 if (!strcmp(new_dir, ctx->search_paths.objs[u])) {
Radek Krejci0e212402018-09-20 11:29:38 +020097 free(new_dir);
Radek Krejci14946ab2018-09-20 13:42:06 +020098 return LY_EEXIST;
Radek Krejci0e212402018-09-20 11:29:38 +020099 }
100 }
101 if (ly_set_add(&ctx->search_paths, new_dir, LY_SET_OPT_USEASLIST) == -1) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200102 free(new_dir);
103 return LY_EMEM;
104 }
105
Radek Krejcie9e987e2018-10-31 12:50:27 +0100106 /* new searchdir - possibly more latest revision available */
107 ly_ctx_reset_latests(ctx);
108
Radek Krejci0e212402018-09-20 11:29:38 +0200109 return LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200110 } else {
111 /* consider that no change is not actually an error */
112 return LY_SUCCESS;
113 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200114}
115
116API const char * const *
117ly_ctx_get_searchdirs(const struct ly_ctx *ctx)
118{
Radek Krejci05026432018-09-20 12:13:43 +0200119 void **new;
120
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200121 LY_CHECK_ARG_RET(ctx, ctx, NULL);
Radek Krejci05026432018-09-20 12:13:43 +0200122
123 if (ctx->search_paths.count == ctx->search_paths.size) {
124 /* not enough space for terminating NULL byte */
125 new = realloc(((struct ly_ctx *)ctx)->search_paths.objs, (ctx->search_paths.size + 8) * sizeof *ctx->search_paths.objs);
126 LY_CHECK_ERR_RET(!new, LOGMEM(NULL), NULL);
127 ((struct ly_ctx *)ctx)->search_paths.size += 8;
128 ((struct ly_ctx *)ctx)->search_paths.objs = new;
129 }
130 /* set terminating NULL byte to the strings list */
131 ctx->search_paths.objs[ctx->search_paths.count] = NULL;
132
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200133 return (const char * const *)ctx->search_paths.objs;
134}
135
136API LY_ERR
Radek Krejci0759b792018-09-20 13:53:15 +0200137ly_ctx_unset_searchdirs(struct ly_ctx *ctx, const char *value)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200138{
Radek Krejci0759b792018-09-20 13:53:15 +0200139 unsigned int index;
140
Radek Krejcicd649072018-09-20 12:14:45 +0200141 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Radek Krejcicd649072018-09-20 12:14:45 +0200142
Michal Vaskob34480a2018-09-17 10:34:45 +0200143 if (!ctx->search_paths.count) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200144 return LY_SUCCESS;
145 }
146
Radek Krejci0759b792018-09-20 13:53:15 +0200147 if (value) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200148 /* remove specific search directory */
Radek Krejci0759b792018-09-20 13:53:15 +0200149 for (index = 0; index < ctx->search_paths.count; ++index) {
150 if (!strcmp(value, ctx->search_paths.objs[index])) {
151 break;
152 }
153 }
154 if (index == ctx->search_paths.count) {
155 LOGARG(ctx, value);
156 return LY_EINVAL;
157 } else {
158 return ly_set_rm_index(&ctx->search_paths, index, free);
159 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200160 } else {
161 /* remove them all */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200162 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200163 memset(&ctx->search_paths, 0, sizeof ctx->search_paths);
164 }
165
166 return LY_SUCCESS;
167}
168
169API LY_ERR
Radek Krejcied5acc52019-04-25 15:57:04 +0200170ly_ctx_unset_searchdir(struct ly_ctx *ctx, unsigned int index)
171{
172 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
173
174 if (!ctx->search_paths.count) {
175 return LY_SUCCESS;
176 }
177
178 if (index >= ctx->search_paths.count) {
Radek Krejci5a5d2922020-08-15 15:34:36 +0200179 LOGARG(ctx, index);
Radek Krejcied5acc52019-04-25 15:57:04 +0200180 return LY_EINVAL;
181 } else {
182 return ly_set_rm_index(&ctx->search_paths, index, free);
183 }
184
185 return LY_SUCCESS;
186}
187
188API const struct lys_module *
189ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision)
190{
191 struct lys_module *result = NULL;
192
193 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
194
195 LY_CHECK_RET(lysp_load_module(ctx, name, revision, 1, 0, &result), NULL);
196 return result;
197}
198
199API LY_ERR
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200200ly_ctx_new(const char *search_dir, int options, struct ly_ctx **new_ctx)
201{
202 struct ly_ctx *ctx = NULL;
203 struct lys_module *module;
204 char *search_dir_list;
205 char *sep, *dir;
Michal Vaskode79e222020-08-10 11:55:46 +0200206 uint32_t i;
Michal Vasko63f3d842020-07-08 10:10:14 +0200207 struct ly_in *in = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200208 LY_ERR rc = LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200209
Radek Krejcied5acc52019-04-25 15:57:04 +0200210 LY_CHECK_ARG_RET(NULL, new_ctx, LY_EINVAL);
211
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200212 ctx = calloc(1, sizeof *ctx);
Radek Krejciad573502018-09-07 15:26:55 +0200213 LY_CHECK_ERR_RET(!ctx, LOGMEM(NULL), LY_EMEM);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200214
215 /* dictionary */
216 lydict_init(&ctx->dict);
217
Radek Krejciad573502018-09-07 15:26:55 +0200218#if 0 /* TODO when plugins implemented */
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200219 /* plugins */
220 ly_load_plugins();
Radek Krejciad573502018-09-07 15:26:55 +0200221#endif
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200222
223 /* initialize thread-specific key */
Radek Krejciad573502018-09-07 15:26:55 +0200224 while ((pthread_key_create(&ctx->errlist_key, ly_err_free)) == EAGAIN);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200225
226 /* models list */
227 ctx->flags = options;
228 if (search_dir) {
229 search_dir_list = strdup(search_dir);
230 LY_CHECK_ERR_GOTO(!search_dir_list, LOGMEM(NULL); rc = LY_EMEM, error);
231
232 for (dir = search_dir_list; (sep = strchr(dir, ':')) != NULL && rc == LY_SUCCESS; dir = sep + 1) {
233 *sep = 0;
234 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200235 if (rc == LY_EEXIST) {
236 /* ignore duplication */
237 rc = LY_SUCCESS;
238 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200239 }
240 if (*dir && rc == LY_SUCCESS) {
241 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200242 if (rc == LY_EEXIST) {
243 /* ignore duplication */
244 rc = LY_SUCCESS;
245 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200246 }
247 free(search_dir_list);
248
249 /* If ly_ctx_set_searchdir() failed, the error is already logged. Just exit */
250 if (rc != LY_SUCCESS) {
251 goto error;
252 }
253 }
254 ctx->module_set_id = 1;
255
Michal Vasko63f3d842020-07-08 10:10:14 +0200256 /* create dummy in */
257 rc = ly_in_new_memory(internal_modules[0].data, &in);
258 LY_CHECK_GOTO(rc, error);
259
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200260 /* load internal modules */
Radek Krejci86d106e2018-10-18 09:53:19 +0200261 for (i = 0; i < ((options & LY_CTX_NOYANGLIBRARY) ? (LY_INTERNAL_MODS_COUNT - 2) : LY_INTERNAL_MODS_COUNT); i++) {
Michal Vasko63f3d842020-07-08 10:10:14 +0200262 ly_in_memory(in, internal_modules[i].data);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200263 LY_CHECK_GOTO(rc = lys_parse_mem_module(ctx, in, internal_modules[i].format, internal_modules[i].implemented,
264 NULL, NULL, &module), error);
265 LY_CHECK_GOTO(rc = lys_compile(&module, 0), error);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200266 }
267
Michal Vasko63f3d842020-07-08 10:10:14 +0200268 ly_in_free(in, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200269 *new_ctx = ctx;
270 return rc;
271
272error:
Michal Vasko63f3d842020-07-08 10:10:14 +0200273 ly_in_free(in, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200274 ly_ctx_destroy(ctx, NULL);
275 return rc;
276}
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200277API int
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200278ly_ctx_get_options(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200279{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200280 LY_CHECK_ARG_RET(ctx, ctx, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200281 return ctx->flags;
282}
283
Radek Krejcica828d92018-09-20 14:19:43 +0200284API LY_ERR
Radek Krejci3fa46b62019-09-11 10:47:30 +0200285ly_ctx_set_options(struct ly_ctx *ctx, int option)
Radek Krejcica828d92018-09-20 14:19:43 +0200286{
287 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
288 LY_CHECK_ERR_RET(option & LY_CTX_NOYANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
289
290 /* set the option(s) */
291 ctx->flags |= option;
292
293 return LY_SUCCESS;
294}
295
296API LY_ERR
Radek Krejci3fa46b62019-09-11 10:47:30 +0200297ly_ctx_unset_options(struct ly_ctx *ctx, int option)
Radek Krejcica828d92018-09-20 14:19:43 +0200298{
299 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
300 LY_CHECK_ERR_RET(option & LY_CTX_NOYANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
301
302 /* unset the option(s) */
303 ctx->flags &= ~option;
304
305 return LY_SUCCESS;
306}
307
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200308API uint16_t
309ly_ctx_get_module_set_id(const struct ly_ctx *ctx)
310{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200311 LY_CHECK_ARG_RET(ctx, ctx, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200312 return ctx->module_set_id;
313}
314
Radek Krejcid33273d2018-10-25 14:55:52 +0200315API void
316ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data)
317{
318 LY_CHECK_ARG_RET(ctx, ctx,);
319
320 ctx->imp_clb = clb;
321 ctx->imp_clb_data = user_data;
322}
323
324API ly_module_imp_clb
325ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data)
326{
327 LY_CHECK_ARG_RET(ctx, ctx, NULL);
328
329 if (user_data) {
330 *user_data = ctx->imp_clb_data;
331 }
332 return ctx->imp_clb;
333}
334
Radek Krejcied5acc52019-04-25 15:57:04 +0200335API const struct lys_module *
336ly_ctx_get_module_iter(const struct ly_ctx *ctx, unsigned int *index)
337{
338 LY_CHECK_ARG_RET(ctx, ctx, index, NULL);
339
Radek Krejci2390fb52019-04-30 13:27:43 +0200340 if (*index < (unsigned)ctx->list.count) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200341 return ctx->list.objs[(*index)++];
Radek Krejci2390fb52019-04-30 13:27:43 +0200342 } else {
343 return NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200344 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200345}
346
Radek Krejcib7db73a2018-10-24 14:18:40 +0200347/**
348 * @brief Iterate over the modules in the given context. Returned modules must match the given key at the offset of
349 * lysp_module and lysc_module structures (they are supposed to be placed at the same offset in both structures).
350 *
351 * @param[in] ctx Context where to iterate.
352 * @param[in] key Key value to search for.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200353 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100354 * @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 +0200355 * @param[in,out] Iterator to pass between the function calls. On the first call, the variable is supposed to be
356 * initiated to 0. After each call returning a module, the value is greater by 1 than the index of the returned
357 * module in the context.
358 * @return Module matching the given key, NULL if no such module found.
359 */
Radek Krejci0af46292019-01-11 16:02:31 +0100360static struct lys_module *
Radek Krejci0ad51f12020-07-16 12:08:12 +0200361ly_ctx_get_module_by_iter(const struct ly_ctx *ctx, const char *key, size_t key_size, size_t key_offset, unsigned int *index)
Radek Krejcib7db73a2018-10-24 14:18:40 +0200362{
Radek Krejci0af46292019-01-11 16:02:31 +0100363 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200364 const char *value;
365
366 for (; *index < ctx->list.count; ++(*index)) {
367 mod = ctx->list.objs[*index];
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100368 value = *(const char**)(((int8_t*)(mod)) + key_offset);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200369 if ((!key_size && !strcmp(key, value)) || (key_size && !strncmp(key, value, key_size) && value[key_size] == '\0')) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200370 /* increment index for the next run */
371 ++(*index);
372 return mod;
373 }
374 }
375 /* done */
376 return NULL;
377}
378
379/**
380 * @brief Unifying function for ly_ctx_get_module() and ly_ctx_get_module_ns()
381 * @param[in] ctx Context where to search.
382 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100383 * @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 +0200384 * @param[in] revision Revision date to match. If NULL, the matching module must have no revision. To search for the latest
385 * revision module, use ly_ctx_get_module_latest_by().
386 * @return Matching module if any.
387 */
Radek Krejci0af46292019-01-11 16:02:31 +0100388static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200389ly_ctx_get_module_by(const struct ly_ctx *ctx, const char *key, size_t key_offset, const char *revision)
390{
Radek Krejci0af46292019-01-11 16:02:31 +0100391 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200392 unsigned int index = 0;
393
Radek Krejci0ad51f12020-07-16 12:08:12 +0200394 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200395 if (!revision) {
Radek Krejci0af46292019-01-11 16:02:31 +0100396 if (!mod->revision) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200397 /* found requested module without revision */
398 return mod;
399 }
400 } else {
Radek Krejci0af46292019-01-11 16:02:31 +0100401 if (mod->revision && !strcmp(mod->revision, revision)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200402 /* found requested module of the specific revision */
403 return mod;
404 }
405 }
406 }
407
408 return NULL;
409}
410
Radek Krejci0af46292019-01-11 16:02:31 +0100411API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200412ly_ctx_get_module_ns(const struct ly_ctx *ctx, const char *ns, const char *revision)
413{
414 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100415 return ly_ctx_get_module_by(ctx, ns, offsetof(struct lys_module, ns), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200416}
417
Radek Krejci0af46292019-01-11 16:02:31 +0100418API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200419ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision)
420{
421 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100422 return ly_ctx_get_module_by(ctx, name, offsetof(struct lys_module, name), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200423}
424
425/**
426 * @brief Unifying function for ly_ctx_get_module_latest() and ly_ctx_get_module_latest_ns()
427 * @param[in] ctx Context where to search.
428 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100429 * @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 +0200430 * @return Matching module if any.
431 */
Radek Krejci0af46292019-01-11 16:02:31 +0100432static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200433ly_ctx_get_module_latest_by(const struct ly_ctx *ctx, const char *key, size_t key_offset)
434{
Radek Krejci0af46292019-01-11 16:02:31 +0100435 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200436 unsigned int index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200437
Radek Krejci0ad51f12020-07-16 12:08:12 +0200438 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100439 if (mod->latest_revision) {
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200440 return mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200441 }
442 }
443
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200444 return NULL;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200445}
446
Radek Krejci0af46292019-01-11 16:02:31 +0100447API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200448ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name)
449{
450 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100451 return ly_ctx_get_module_latest_by(ctx, name, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200452}
453
Radek Krejci0af46292019-01-11 16:02:31 +0100454API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200455ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns)
456{
457 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100458 return ly_ctx_get_module_latest_by(ctx, ns, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200459}
460
461/**
462 * @brief Unifying function for ly_ctx_get_module_implemented() and ly_ctx_get_module_implemented_ns()
463 * @param[in] ctx Context where to search.
464 * @param[in] key Name or Namespace as a search key.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200465 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100466 * @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 +0200467 * @return Matching module if any.
468 */
Radek Krejci0af46292019-01-11 16:02:31 +0100469static struct lys_module *
Radek Krejci0ad51f12020-07-16 12:08:12 +0200470ly_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 +0200471{
Radek Krejci0af46292019-01-11 16:02:31 +0100472 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200473 unsigned int index = 0;
474
Radek Krejci0ad51f12020-07-16 12:08:12 +0200475 while ((mod = ly_ctx_get_module_by_iter(ctx, key, key_size, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100476 if (mod->implemented) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200477 return mod;
478 }
479 }
480
481 return NULL;
482}
483
Radek Krejci0af46292019-01-11 16:02:31 +0100484API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200485ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name)
486{
487 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200488 return ly_ctx_get_module_implemented_by(ctx, name, 0, offsetof(struct lys_module, name));
489}
490
491struct lys_module *
492ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len)
493{
494 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
495 return ly_ctx_get_module_implemented_by(ctx, name, name_len, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200496}
497
Radek Krejci0af46292019-01-11 16:02:31 +0100498API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200499ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns)
500{
501 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200502 return ly_ctx_get_module_implemented_by(ctx, ns, 0, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200503}
504
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100505struct lysp_submodule *
Radek Krejcid33273d2018-10-25 14:55:52 +0200506ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *module, const char *submodule, const char *revision)
507{
508 const struct lys_module *mod;
509 struct lysp_include *inc;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200510 uint32_t v;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200511 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid33273d2018-10-25 14:55:52 +0200512
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100513 assert(submodule);
514
515 for (v = 0; v < ctx->list.count; ++v) {
516 mod = ctx->list.objs[v];
Radek Krejcid33273d2018-10-25 14:55:52 +0200517 if (!mod->parsed) {
518 continue;
519 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100520 if (module && strcmp(module, mod->name)) {
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100521 continue;
522 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200523
524 LY_ARRAY_FOR(mod->parsed->includes, u) {
Radek Krejci086c7132018-10-26 15:29:04 +0200525 if (mod->parsed->includes[u].submodule && !strcmp(submodule, mod->parsed->includes[u].submodule->name)) {
Radek Krejcid33273d2018-10-25 14:55:52 +0200526 inc = &mod->parsed->includes[u];
527 if (!revision) {
528 if (inc->submodule->latest_revision) {
529 return inc->submodule;
530 }
531 } else if (inc->submodule->revs && !strcmp(revision, inc->submodule->revs[0].date)) {
532 return inc->submodule;
533 }
534 }
535 }
536 }
537
538 return NULL;
539}
540
Michal Vasko308d0a72020-08-03 11:56:25 +0200541API const struct lysc_node *
542ly_ctx_get_node(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *data_path, int output)
543{
544 const struct lysc_node *snode = NULL;
545 struct lyxp_expr *exp = NULL;
546 struct ly_path *p = NULL;
547 LY_ERR ret;
548 uint8_t oper;
549
550 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
551
552 if (!ctx) {
553 ctx = ctx_node->module->ctx;
554 }
555
556 /* parse */
557 exp = lyxp_expr_parse(ctx, data_path, strlen(data_path), 0);
558 LY_CHECK_GOTO(!exp, cleanup);
559
560 /* compile */
561 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
562 ret = ly_path_compile(ctx, NULL, ctx_node, exp, LY_PATH_LREF_FALSE, oper, LY_PATH_TARGET_MANY,
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200563 LY_PREF_JSON, NULL, &p);
Michal Vasko308d0a72020-08-03 11:56:25 +0200564 LY_CHECK_GOTO(ret, cleanup);
565
566 /* get last node */
567 snode = p[LY_ARRAY_COUNT(p) - 1].node;
568
569cleanup:
570 ly_path_free(ctx, p);
571 lyxp_expr_free(ctx, exp);
572 return snode;
573}
574
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200575API void
Radek Krejcie9e987e2018-10-31 12:50:27 +0100576ly_ctx_reset_latests(struct ly_ctx *ctx)
577{
Radek Krejcie9e987e2018-10-31 12:50:27 +0100578 struct lys_module *mod;
579
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200580 for (uint32_t v = 0; v < ctx->list.count; ++v) {
581 mod = ctx->list.objs[v];
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100582 if (mod->latest_revision == 2) {
583 mod->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100584 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100585 if (mod->parsed && mod->parsed->includes) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200586 for (LY_ARRAY_COUNT_TYPE u = 0; u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200587 if (mod->parsed->includes[u].submodule->latest_revision == 2) {
588 mod->parsed->includes[u].submodule->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100589 }
590 }
591 }
592 }
593}
594
Michal Vaskode79e222020-08-10 11:55:46 +0200595API uint32_t
596ly_ctx_internal_module_count(const struct ly_ctx *ctx)
597{
598 if (!ctx) {
599 return 0;
600 }
601
602 if (ctx->flags & LY_CTX_NOYANGLIBRARY) {
603 return LY_INTERNAL_MODS_COUNT - 2;
604 } else {
605 return LY_INTERNAL_MODS_COUNT;
606 }
607}
608
Michal Vasko57c10cd2020-05-27 15:57:11 +0200609static LY_ERR
610ylib_feature(struct lyd_node *parent, const struct lys_module *cur_mod)
611{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200612 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200613
614 if (!cur_mod->implemented) {
615 /* no features can be enabled */
616 return LY_SUCCESS;
617 }
618
619 LY_ARRAY_FOR(cur_mod->compiled->features, i) {
620 if (!(cur_mod->compiled->features[i].flags & LYS_FENABLED)) {
621 continue;
622 }
623
Michal Vasko3a41dff2020-07-15 14:30:28 +0200624 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", cur_mod->compiled->features[i].name, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200625 }
626
627 return LY_SUCCESS;
628}
629
630static LY_ERR
631ylib_deviation(struct lyd_node *parent, const struct lys_module *cur_mod, int bis)
632{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200633 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200634 struct lys_module *mod;
635
636 if (!cur_mod->implemented) {
637 /* no deviations of the module for certain */
638 return LY_SUCCESS;
639 }
640
641 LY_ARRAY_FOR(cur_mod->compiled->deviated_by, i) {
642 mod = cur_mod->compiled->deviated_by[i];
643
644 if (bis) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200645 LY_CHECK_RET(lyd_new_term(parent, NULL, "deviation", mod->name, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200646 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200647 LY_CHECK_RET(lyd_new_list(parent, NULL, "deviation", NULL, mod->name,
648 (mod->parsed->revs ? mod->parsed->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200649 }
650 }
651
652 return LY_SUCCESS;
653}
654
655static LY_ERR
656ylib_submodules(struct lyd_node *parent, const struct lys_module *cur_mod, int bis)
657{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200658 LY_ERR ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200659 LY_ARRAY_COUNT_TYPE i;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200660 struct lyd_node *cont;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200661 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200662 int r;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200663 char *str;
664
665 LY_ARRAY_FOR(cur_mod->parsed->includes, i) {
666 submod = cur_mod->parsed->includes[i].submodule;
667
668 if (bis) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200669 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", &cont, submod->name));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200670
671 if (submod->revs) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200672 LY_CHECK_RET(lyd_new_term(cont, NULL, "revision", submod->revs[0].date, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200673 }
674 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200675 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", &cont, submod->name,
676 (submod->revs ? submod->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200677 }
678
679 if (submod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200680 r = asprintf(&str, "file://%s", submod->filepath);
681 LY_CHECK_ERR_RET(r == -1, LOGMEM(cur_mod->ctx), LY_EMEM);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200682
Michal Vasko3a41dff2020-07-15 14:30:28 +0200683 ret = lyd_new_term(cont, NULL, bis ? "location" : "schema", str, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200684 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200685 LY_CHECK_RET(ret);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200686 }
687 }
688
689 return LY_SUCCESS;
690}
691
692API uint16_t
693ly_ctx_get_yanglib_id(const struct ly_ctx *ctx)
694{
695 return ctx->module_set_id;
696}
697
Michal Vasko3a41dff2020-07-15 14:30:28 +0200698API LY_ERR
699ly_ctx_get_yanglib_data(const struct ly_ctx *ctx, struct lyd_node **root_p)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200700{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200701 LY_ERR ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200702 uint32_t i;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200703 int bis = 0, r;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200704 char id[8], *str;
705 const struct lys_module *mod;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200706 struct lyd_node *root = NULL, *root_bis = NULL, *cont, *set_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200707
Michal Vasko3a41dff2020-07-15 14:30:28 +0200708 LY_CHECK_ARG_RET(ctx, ctx, root_p, LY_EINVAL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200709
710 mod = ly_ctx_get_module_implemented(ctx, "ietf-yang-library");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200711 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 +0200712
713 if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, "2016-06-21")) {
714 bis = 0;
715 } else if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, IETF_YANG_LIB_REV)) {
716 bis = 1;
717 } else {
718 LOGERR(ctx, LY_EINVAL, "Incompatible ietf-yang-library version in context.");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200719 return LY_EINVAL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200720 }
721
Michal Vasko3a41dff2020-07-15 14:30:28 +0200722 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "modules-state", &root), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200723
724 if (bis) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200725 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "yang-library", &root_bis), error);
726 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "module-set", &set_bis, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200727 }
728
729 for (i = 0; i < ctx->list.count; ++i) {
730 mod = ctx->list.objs[i];
731
732 /*
733 * deprecated legacy
734 */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200735 LY_CHECK_GOTO(ret = lyd_new_list(root, NULL, "module", &cont, mod->name,
736 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200737
738 /* schema */
739 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200740 r = asprintf(&str, "file://%s", mod->filepath);
741 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200742
Michal Vasko3a41dff2020-07-15 14:30:28 +0200743 ret = lyd_new_term(cont, NULL, "schema", str, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200744 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200745 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200746 }
747
748 /* namespace */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200749 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200750
751 /* feature leaf-list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200752 LY_CHECK_GOTO(ret = ylib_feature(cont, mod), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200753
754 /* deviation list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200755 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200756
757 /* conformance-type */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200758 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "conformance-type", mod->implemented ? "implement" : "import",
759 NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200760
761 /* submodule list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200762 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200763
764 /*
765 * current revision
766 */
767 if (bis) {
768 /* name and revision */
769 if (mod->implemented) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200770 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "module", &cont, mod->name), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200771
772 if (mod->parsed->revs) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200773 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "revision", mod->parsed->revs[0].date, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200774 }
775 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200776 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "import-only-module", &cont, mod->name,
777 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200778 }
779
780 /* namespace */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200781 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200782
783 /* location */
784 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200785 r = asprintf(&str, "file://%s", mod->filepath);
786 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200787
Michal Vasko3a41dff2020-07-15 14:30:28 +0200788 ret = lyd_new_term(cont, NULL, "schema", str, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200789 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200790 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200791 }
792
793 /* submodule list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200794 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200795
796 /* feature list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200797 LY_CHECK_GOTO(ret = ylib_feature(cont, mod), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200798
799 /* deviation */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200800 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200801 }
802 }
803
804 /* IDs */
805 sprintf(id, "%u", ctx->module_set_id);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200806 LY_CHECK_GOTO(ret = lyd_new_term(root, NULL, "module-set-id", id, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200807
808 if (bis) {
809 /* create one complete schema */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200810 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "schema", &cont, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200811
Michal Vasko3a41dff2020-07-15 14:30:28 +0200812 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "module-set", "complete", NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200813
814 /* content-id */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200815 LY_CHECK_GOTO(ret = lyd_new_term(root_bis, NULL, "content-id", id, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200816 }
817
818 if (root_bis) {
Michal Vaskob104f112020-07-17 09:54:54 +0200819 if (lyd_insert_sibling(root, root_bis, &root)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200820 goto error;
821 }
Michal Vaskob104f112020-07-17 09:54:54 +0200822 root_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200823 }
824
Michal Vasko3a41dff2020-07-15 14:30:28 +0200825 LY_CHECK_GOTO(ret = lyd_validate_all(&root, NULL, LYD_VALIDATE_PRESENT, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200826
Michal Vasko3a41dff2020-07-15 14:30:28 +0200827 *root_p = root;
828 return LY_SUCCESS;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200829
830error:
831 lyd_free_all(root);
832 lyd_free_all(root_bis);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200833 return ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200834}
835
Radek Krejcie9e987e2018-10-31 12:50:27 +0100836API void
Radek Krejciad573502018-09-07 15:26:55 +0200837ly_ctx_destroy(struct ly_ctx *ctx, void (*private_destructor)(const struct lysc_node *node, void *priv))
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200838{
Radek Krejci418823a2018-09-20 16:42:13 +0200839 if (!ctx) {
840 return;
841 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200842
843 /* models list */
Michal Vaskob34480a2018-09-17 10:34:45 +0200844 for (; ctx->list.count; ctx->list.count--) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200845 /* remove the module */
Radek Krejci86d106e2018-10-18 09:53:19 +0200846 lys_module_free(ctx->list.objs[ctx->list.count - 1], private_destructor);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200847 }
848 free(ctx->list.objs);
849
850 /* search paths list */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200851 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200852
853 /* clean the error list */
854 ly_err_clean(ctx, 0);
855 pthread_key_delete(ctx->errlist_key);
856
857 /* dictionary */
858 lydict_clean(&ctx->dict);
859
860#if 0 /* TODO when plugins implemented */
861 /* plugins - will be removed only if this is the last context */
862 ly_clean_plugins();
863#endif
864
865 free(ctx);
866}