blob: 9457436b5aaaa4a438ef0c18488cb168e3545372 [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 Vaskoafac7822020-10-20 14:22:26 +020031#include "in.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
Michal Vaskocf296c82020-05-27 11:16:45 +020042#include "../models/ietf-datastores@2018-02-14.h"
Michal Vasko69730152020-10-09 16:30:07 +020043#include "../models/ietf-inet-types@2013-07-15.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020044#include "../models/ietf-yang-library@2019-01-04.h"
Michal Vasko69730152020-10-09 16:30:07 +020045#include "../models/ietf-yang-metadata@2016-08-05.h"
46#include "../models/ietf-yang-types@2013-07-15.h"
47#include "../models/yang@2020-06-17.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020048#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;
Radek Krejci857189e2020-09-01 13:26:36 +020054 ly_bool implemented;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020055 LYS_INFORMAT format;
Michal Vaskode79e222020-08-10 11:55:46 +020056} internal_modules[] = {
Michal Vasko22df3f02020-08-24 13:29:22 +020057 {"ietf-yang-metadata", "2016-08-05", (const char *)ietf_yang_metadata_2016_08_05_yang, 1, LYS_IN_YANG},
58 {"yang", "2020-06-17", (const char *)yang_2020_06_17_yang, 1, LYS_IN_YANG},
59 {"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 Vasko22df3f02020-08-24 13:29:22 +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 Krejci0af5f5d2018-09-07 15:00:30 +020073
74 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
75
76 if (search_dir) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +020077 new_dir = realpath(search_dir, NULL);
Radek Krejcia77e0e12018-09-20 12:39:15 +020078 LY_CHECK_ERR_RET(!new_dir,
Michal Vasko69730152020-10-09 16:30:07 +020079 LOGERR(ctx, LY_ESYS, "Unable to use search directory \"%s\" (%s).", search_dir, strerror(errno)),
80 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020081 if (strcmp(search_dir, new_dir)) {
82 LOGVRB("Canonicalizing search directory string from \"%s\" to \"%s\".", search_dir, new_dir);
83 }
84 LY_CHECK_ERR_RET(access(new_dir, R_OK | X_OK),
Michal Vasko69730152020-10-09 16:30:07 +020085 LOGERR(ctx, LY_ESYS, "Unable to fully access search directory \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
86 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020087 LY_CHECK_ERR_RET(stat(new_dir, &st),
Michal Vasko69730152020-10-09 16:30:07 +020088 LOGERR(ctx, LY_ESYS, "stat() failed for \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
89 LY_ESYS);
Radek Krejci3a077b92019-04-09 17:10:35 +020090 LY_CHECK_ERR_RET(!S_ISDIR(st.st_mode),
Michal Vasko69730152020-10-09 16:30:07 +020091 LOGERR(ctx, LY_ESYS, "Given search directory \"%s\" is not a directory.", new_dir); free(new_dir),
92 LY_EINVAL);
Radek Krejci0e212402018-09-20 11:29:38 +020093 /* avoid path duplication */
Radek Krejci1deb5be2020-08-26 16:43:36 +020094 for (uint32_t u = 0; u < ctx->search_paths.count; ++u) {
Radek Krejci14946ab2018-09-20 13:42:06 +020095 if (!strcmp(new_dir, ctx->search_paths.objs[u])) {
Radek Krejci0e212402018-09-20 11:29:38 +020096 free(new_dir);
Radek Krejci14946ab2018-09-20 13:42:06 +020097 return LY_EEXIST;
Radek Krejci0e212402018-09-20 11:29:38 +020098 }
99 }
Radek Krejci3d92e442020-10-12 12:48:13 +0200100 if (ly_set_add(&ctx->search_paths, new_dir, 1, NULL)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200101 free(new_dir);
102 return LY_EMEM;
103 }
104
Radek Krejcie9e987e2018-10-31 12:50:27 +0100105 /* new searchdir - possibly more latest revision available */
106 ly_ctx_reset_latests(ctx);
107
Radek Krejci0e212402018-09-20 11:29:38 +0200108 return LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200109 } else {
110 /* consider that no change is not actually an error */
111 return LY_SUCCESS;
112 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200113}
114
115API const char * const *
116ly_ctx_get_searchdirs(const struct ly_ctx *ctx)
117{
Radek Krejci05026432018-09-20 12:13:43 +0200118 void **new;
119
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200120 LY_CHECK_ARG_RET(ctx, ctx, NULL);
Radek Krejci05026432018-09-20 12:13:43 +0200121
122 if (ctx->search_paths.count == ctx->search_paths.size) {
123 /* not enough space for terminating NULL byte */
124 new = realloc(((struct ly_ctx *)ctx)->search_paths.objs, (ctx->search_paths.size + 8) * sizeof *ctx->search_paths.objs);
125 LY_CHECK_ERR_RET(!new, LOGMEM(NULL), NULL);
126 ((struct ly_ctx *)ctx)->search_paths.size += 8;
127 ((struct ly_ctx *)ctx)->search_paths.objs = new;
128 }
129 /* set terminating NULL byte to the strings list */
130 ctx->search_paths.objs[ctx->search_paths.count] = NULL;
131
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200132 return (const char * const *)ctx->search_paths.objs;
133}
134
135API LY_ERR
Radek Krejcie58f97f2020-08-18 11:45:08 +0200136ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200137{
Radek Krejcicd649072018-09-20 12:14:45 +0200138 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Radek Krejcicd649072018-09-20 12:14:45 +0200139
Michal Vaskob34480a2018-09-17 10:34:45 +0200140 if (!ctx->search_paths.count) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200141 return LY_SUCCESS;
142 }
143
Radek Krejci0759b792018-09-20 13:53:15 +0200144 if (value) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200145 /* remove specific search directory */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200146 uint32_t index;
147
Radek Krejci0759b792018-09-20 13:53:15 +0200148 for (index = 0; index < ctx->search_paths.count; ++index) {
149 if (!strcmp(value, ctx->search_paths.objs[index])) {
150 break;
151 }
152 }
153 if (index == ctx->search_paths.count) {
154 LOGARG(ctx, value);
155 return LY_EINVAL;
156 } else {
157 return ly_set_rm_index(&ctx->search_paths, index, free);
158 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200159 } else {
160 /* remove them all */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200161 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200162 memset(&ctx->search_paths, 0, sizeof ctx->search_paths);
163 }
164
165 return LY_SUCCESS;
166}
167
168API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200169ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count)
Radek Krejcied5acc52019-04-25 15:57:04 +0200170{
171 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
172
Radek Krejcie58f97f2020-08-18 11:45:08 +0200173 for ( ; count > 0 && ctx->search_paths.count; --count) {
174 LY_CHECK_RET(ly_set_rm_index(&ctx->search_paths, ctx->search_paths.count - 1, free))
Radek Krejcied5acc52019-04-25 15:57:04 +0200175 }
176
177 return LY_SUCCESS;
178}
179
180API const struct lys_module *
181ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision)
182{
183 struct lys_module *result = NULL;
184
185 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
186
187 LY_CHECK_RET(lysp_load_module(ctx, name, revision, 1, 0, &result), NULL);
188 return result;
189}
190
191API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200192ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200193{
194 struct ly_ctx *ctx = NULL;
195 struct lys_module *module;
196 char *search_dir_list;
197 char *sep, *dir;
Michal Vaskode79e222020-08-10 11:55:46 +0200198 uint32_t i;
Michal Vasko63f3d842020-07-08 10:10:14 +0200199 struct ly_in *in = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200200 LY_ERR rc = LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200201
Radek Krejcied5acc52019-04-25 15:57:04 +0200202 LY_CHECK_ARG_RET(NULL, new_ctx, LY_EINVAL);
203
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200204 ctx = calloc(1, sizeof *ctx);
Radek Krejciad573502018-09-07 15:26:55 +0200205 LY_CHECK_ERR_RET(!ctx, LOGMEM(NULL), LY_EMEM);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200206
207 /* dictionary */
208 lydict_init(&ctx->dict);
209
Radek Krejciad573502018-09-07 15:26:55 +0200210#if 0 /* TODO when plugins implemented */
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200211 /* plugins */
212 ly_load_plugins();
Radek Krejciad573502018-09-07 15:26:55 +0200213#endif
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200214
215 /* initialize thread-specific key */
Radek Krejci1e008d22020-08-17 11:37:37 +0200216 while ((pthread_key_create(&ctx->errlist_key, ly_err_free)) == EAGAIN) {}
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200217
218 /* models list */
219 ctx->flags = options;
220 if (search_dir) {
221 search_dir_list = strdup(search_dir);
222 LY_CHECK_ERR_GOTO(!search_dir_list, LOGMEM(NULL); rc = LY_EMEM, error);
223
224 for (dir = search_dir_list; (sep = strchr(dir, ':')) != NULL && rc == LY_SUCCESS; dir = sep + 1) {
225 *sep = 0;
226 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200227 if (rc == LY_EEXIST) {
228 /* ignore duplication */
229 rc = LY_SUCCESS;
230 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200231 }
Michal Vasko69730152020-10-09 16:30:07 +0200232 if (*dir && (rc == LY_SUCCESS)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200233 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200234 if (rc == LY_EEXIST) {
235 /* ignore duplication */
236 rc = LY_SUCCESS;
237 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200238 }
239 free(search_dir_list);
240
241 /* If ly_ctx_set_searchdir() failed, the error is already logged. Just exit */
242 if (rc != LY_SUCCESS) {
243 goto error;
244 }
245 }
246 ctx->module_set_id = 1;
247
Michal Vasko63f3d842020-07-08 10:10:14 +0200248 /* create dummy in */
249 rc = ly_in_new_memory(internal_modules[0].data, &in);
250 LY_CHECK_GOTO(rc, error);
251
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200252 /* load internal modules */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200253 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 +0200254 ly_in_memory(in, internal_modules[i].data);
Michal Vasko7a0b0762020-09-02 16:37:01 +0200255 LY_CHECK_GOTO(rc = lys_create_module(ctx, in, internal_modules[i].format, internal_modules[i].implemented,
Michal Vasko69730152020-10-09 16:30:07 +0200256 NULL, NULL, &module), error);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200257 }
258
Michal Vasko63f3d842020-07-08 10:10:14 +0200259 ly_in_free(in, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200260 *new_ctx = ctx;
261 return rc;
262
263error:
Michal Vasko63f3d842020-07-08 10:10:14 +0200264 ly_in_free(in, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200265 ly_ctx_destroy(ctx, NULL);
266 return rc;
267}
Radek Krejci0f969882020-08-21 16:56:47 +0200268
Radek Krejci1deb5be2020-08-26 16:43:36 +0200269API uint16_t
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200270ly_ctx_get_options(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200271{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200272 LY_CHECK_ARG_RET(ctx, ctx, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200273 return ctx->flags;
274}
275
Radek Krejcica828d92018-09-20 14:19:43 +0200276API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200277ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200278{
279 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200280 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200281
282 /* set the option(s) */
283 ctx->flags |= option;
284
285 return LY_SUCCESS;
286}
287
288API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200289ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200290{
291 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200292 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200293
294 /* unset the option(s) */
295 ctx->flags &= ~option;
296
297 return LY_SUCCESS;
298}
299
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200300API uint16_t
301ly_ctx_get_module_set_id(const struct ly_ctx *ctx)
302{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200303 LY_CHECK_ARG_RET(ctx, ctx, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200304 return ctx->module_set_id;
305}
306
Radek Krejcid33273d2018-10-25 14:55:52 +0200307API void
308ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data)
309{
Michal Vaskod989ba02020-08-24 10:59:24 +0200310 LY_CHECK_ARG_RET(ctx, ctx, );
Radek Krejcid33273d2018-10-25 14:55:52 +0200311
312 ctx->imp_clb = clb;
313 ctx->imp_clb_data = user_data;
314}
315
316API ly_module_imp_clb
317ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data)
318{
319 LY_CHECK_ARG_RET(ctx, ctx, NULL);
320
321 if (user_data) {
322 *user_data = ctx->imp_clb_data;
323 }
324 return ctx->imp_clb;
325}
326
Radek Krejcied5acc52019-04-25 15:57:04 +0200327API const struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200328ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index)
Radek Krejcied5acc52019-04-25 15:57:04 +0200329{
330 LY_CHECK_ARG_RET(ctx, ctx, index, NULL);
331
Radek Krejci2390fb52019-04-30 13:27:43 +0200332 if (*index < (unsigned)ctx->list.count) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200333 return ctx->list.objs[(*index)++];
Radek Krejci2390fb52019-04-30 13:27:43 +0200334 } else {
335 return NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200336 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200337}
338
Radek Krejcib7db73a2018-10-24 14:18:40 +0200339/**
340 * @brief Iterate over the modules in the given context. Returned modules must match the given key at the offset of
341 * lysp_module and lysc_module structures (they are supposed to be placed at the same offset in both structures).
342 *
343 * @param[in] ctx Context where to iterate.
344 * @param[in] key Key value to search for.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200345 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100346 * @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 +0200347 * @param[in,out] Iterator to pass between the function calls. On the first call, the variable is supposed to be
348 * initiated to 0. After each call returning a module, the value is greater by 1 than the index of the returned
349 * module in the context.
350 * @return Module matching the given key, NULL if no such module found.
351 */
Radek Krejci0af46292019-01-11 16:02:31 +0100352static struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200353ly_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 +0200354{
Radek Krejci0af46292019-01-11 16:02:31 +0100355 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200356 const char *value;
357
Michal Vaskod989ba02020-08-24 10:59:24 +0200358 for ( ; *index < ctx->list.count; ++(*index)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200359 mod = ctx->list.objs[*index];
Michal Vasko22df3f02020-08-24 13:29:22 +0200360 value = *(const char **)(((int8_t *)(mod)) + key_offset);
Michal Vasko69730152020-10-09 16:30:07 +0200361 if ((!key_size && !strcmp(key, value)) || (key_size && !strncmp(key, value, key_size) && (value[key_size] == '\0'))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200362 /* increment index for the next run */
363 ++(*index);
364 return mod;
365 }
366 }
367 /* done */
368 return NULL;
369}
370
371/**
372 * @brief Unifying function for ly_ctx_get_module() and ly_ctx_get_module_ns()
373 * @param[in] ctx Context where to search.
374 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100375 * @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 +0200376 * @param[in] revision Revision date to match. If NULL, the matching module must have no revision. To search for the latest
377 * revision module, use ly_ctx_get_module_latest_by().
378 * @return Matching module if any.
379 */
Radek Krejci0af46292019-01-11 16:02:31 +0100380static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200381ly_ctx_get_module_by(const struct ly_ctx *ctx, const char *key, size_t key_offset, const char *revision)
382{
Radek Krejci0af46292019-01-11 16:02:31 +0100383 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200384 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200385
Radek Krejci0ad51f12020-07-16 12:08:12 +0200386 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200387 if (!revision) {
Radek Krejci0af46292019-01-11 16:02:31 +0100388 if (!mod->revision) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200389 /* found requested module without revision */
390 return mod;
391 }
392 } else {
Radek Krejci0af46292019-01-11 16:02:31 +0100393 if (mod->revision && !strcmp(mod->revision, revision)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200394 /* found requested module of the specific revision */
395 return mod;
396 }
397 }
398 }
399
400 return NULL;
401}
402
Radek Krejci0af46292019-01-11 16:02:31 +0100403API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200404ly_ctx_get_module_ns(const struct ly_ctx *ctx, const char *ns, const char *revision)
405{
406 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100407 return ly_ctx_get_module_by(ctx, ns, offsetof(struct lys_module, ns), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200408}
409
Radek Krejci0af46292019-01-11 16:02:31 +0100410API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200411ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision)
412{
413 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100414 return ly_ctx_get_module_by(ctx, name, offsetof(struct lys_module, name), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200415}
416
417/**
418 * @brief Unifying function for ly_ctx_get_module_latest() and ly_ctx_get_module_latest_ns()
419 * @param[in] ctx Context where to search.
420 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100421 * @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 +0200422 * @return Matching module if any.
423 */
Radek Krejci0af46292019-01-11 16:02:31 +0100424static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200425ly_ctx_get_module_latest_by(const struct ly_ctx *ctx, const char *key, size_t key_offset)
426{
Radek Krejci0af46292019-01-11 16:02:31 +0100427 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200428 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200429
Radek Krejci0ad51f12020-07-16 12:08:12 +0200430 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100431 if (mod->latest_revision) {
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200432 return mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200433 }
434 }
435
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200436 return NULL;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200437}
438
Radek Krejci0af46292019-01-11 16:02:31 +0100439API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200440ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name)
441{
442 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100443 return ly_ctx_get_module_latest_by(ctx, name, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200444}
445
Radek Krejci0af46292019-01-11 16:02:31 +0100446API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200447ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns)
448{
449 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100450 return ly_ctx_get_module_latest_by(ctx, ns, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200451}
452
453/**
454 * @brief Unifying function for ly_ctx_get_module_implemented() and ly_ctx_get_module_implemented_ns()
455 * @param[in] ctx Context where to search.
456 * @param[in] key Name or Namespace as a search key.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200457 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100458 * @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 +0200459 * @return Matching module if any.
460 */
Radek Krejci0af46292019-01-11 16:02:31 +0100461static struct lys_module *
Radek Krejci0ad51f12020-07-16 12:08:12 +0200462ly_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 +0200463{
Radek Krejci0af46292019-01-11 16:02:31 +0100464 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200465 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200466
Radek Krejci0ad51f12020-07-16 12:08:12 +0200467 while ((mod = ly_ctx_get_module_by_iter(ctx, key, key_size, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100468 if (mod->implemented) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200469 return mod;
470 }
471 }
472
473 return NULL;
474}
475
Radek Krejci0af46292019-01-11 16:02:31 +0100476API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200477ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name)
478{
479 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200480 return ly_ctx_get_module_implemented_by(ctx, name, 0, offsetof(struct lys_module, name));
481}
482
483struct lys_module *
484ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len)
485{
486 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
487 return ly_ctx_get_module_implemented_by(ctx, name, name_len, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200488}
489
Radek Krejci0af46292019-01-11 16:02:31 +0100490API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200491ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns)
492{
493 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200494 return ly_ctx_get_module_implemented_by(ctx, ns, 0, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200495}
496
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100497struct lysp_submodule *
Michal Vaskoc3781c32020-10-06 14:04:08 +0200498ly_ctx_get_submodule(const struct ly_ctx *ctx, const struct lys_module *module, const char *submodule, const char *revision)
Radek Krejcid33273d2018-10-25 14:55:52 +0200499{
500 const struct lys_module *mod;
501 struct lysp_include *inc;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200502 uint32_t v;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200503 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid33273d2018-10-25 14:55:52 +0200504
Michal Vaskoc3781c32020-10-06 14:04:08 +0200505 assert((ctx || module) && submodule);
506
507 if (module) {
508 if (!module->parsed) {
509 return NULL;
510 }
511
512 /* check only this module */
513 mod = module;
514 goto check_mod;
515 }
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100516
517 for (v = 0; v < ctx->list.count; ++v) {
518 mod = ctx->list.objs[v];
Radek Krejcid33273d2018-10-25 14:55:52 +0200519 if (!mod->parsed) {
520 continue;
521 }
522
Michal Vaskoc3781c32020-10-06 14:04:08 +0200523check_mod:
Radek Krejcid33273d2018-10-25 14:55:52 +0200524 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 }
Michal Vaskoc3781c32020-10-06 14:04:08 +0200536
537 if (module) {
538 /* do not check other modules */
539 break;
540 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200541 }
542
543 return NULL;
544}
545
Michal Vasko308d0a72020-08-03 11:56:25 +0200546API const struct lysc_node *
Michal Vasko6229db02020-10-07 08:54:15 +0200547ly_ctx_get_node(const struct ly_ctx *ctx, const struct lysc_node *ctx_node, const char *path, ly_bool output)
Michal Vasko308d0a72020-08-03 11:56:25 +0200548{
549 const struct lysc_node *snode = NULL;
550 struct lyxp_expr *exp = NULL;
551 struct ly_path *p = NULL;
552 LY_ERR ret;
553 uint8_t oper;
554
555 LY_CHECK_ARG_RET(ctx, ctx || ctx_node, NULL);
556
557 if (!ctx) {
558 ctx = ctx_node->module->ctx;
559 }
560
561 /* parse */
Michal Vasko6229db02020-10-07 08:54:15 +0200562 ret = lyxp_expr_parse(ctx, path, strlen(path), 0, &exp);
Radek Krejcif03a9e22020-09-18 20:09:31 +0200563 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko308d0a72020-08-03 11:56:25 +0200564
565 /* compile */
566 oper = output ? LY_PATH_OPER_OUTPUT : LY_PATH_OPER_INPUT;
567 ret = ly_path_compile(ctx, NULL, ctx_node, exp, LY_PATH_LREF_FALSE, oper, LY_PATH_TARGET_MANY,
Michal Vasko69730152020-10-09 16:30:07 +0200568 LY_PREF_JSON, NULL, &p);
Michal Vasko308d0a72020-08-03 11:56:25 +0200569 LY_CHECK_GOTO(ret, cleanup);
570
571 /* get last node */
572 snode = p[LY_ARRAY_COUNT(p) - 1].node;
573
574cleanup:
575 ly_path_free(ctx, p);
576 lyxp_expr_free(ctx, exp);
577 return snode;
578}
579
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200580API void
Radek Krejcie9e987e2018-10-31 12:50:27 +0100581ly_ctx_reset_latests(struct ly_ctx *ctx)
582{
Radek Krejcie9e987e2018-10-31 12:50:27 +0100583 struct lys_module *mod;
584
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200585 for (uint32_t v = 0; v < ctx->list.count; ++v) {
586 mod = ctx->list.objs[v];
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100587 if (mod->latest_revision == 2) {
588 mod->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100589 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100590 if (mod->parsed && mod->parsed->includes) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200591 for (LY_ARRAY_COUNT_TYPE u = 0; u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200592 if (mod->parsed->includes[u].submodule->latest_revision == 2) {
593 mod->parsed->includes[u].submodule->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100594 }
595 }
596 }
597 }
598}
599
Michal Vaskode79e222020-08-10 11:55:46 +0200600API uint32_t
601ly_ctx_internal_module_count(const struct ly_ctx *ctx)
602{
603 if (!ctx) {
604 return 0;
605 }
606
Michal Vasko25d6ad02020-10-22 12:20:22 +0200607 if (ctx->flags & LY_CTX_NO_YANGLIBRARY) {
Michal Vaskode79e222020-08-10 11:55:46 +0200608 return LY_INTERNAL_MODS_COUNT - 2;
609 } else {
610 return LY_INTERNAL_MODS_COUNT;
611 }
612}
613
Michal Vasko57c10cd2020-05-27 15:57:11 +0200614static LY_ERR
615ylib_feature(struct lyd_node *parent, const struct lys_module *cur_mod)
616{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200617 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200618
619 if (!cur_mod->implemented) {
620 /* no features can be enabled */
621 return LY_SUCCESS;
622 }
623
Radek Krejci14915cc2020-09-14 17:28:13 +0200624 LY_ARRAY_FOR(cur_mod->features, i) {
625 if (!(cur_mod->features[i].flags & LYS_FENABLED)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200626 continue;
627 }
628
Radek Krejci14915cc2020-09-14 17:28:13 +0200629 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", cur_mod->features[i].name, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200630 }
631
632 return LY_SUCCESS;
633}
634
635static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200636ylib_deviation(struct lyd_node *parent, const struct lys_module *cur_mod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200637{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200638 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200639 struct lys_module *mod;
640
641 if (!cur_mod->implemented) {
642 /* no deviations of the module for certain */
643 return LY_SUCCESS;
644 }
645
Michal Vasko7f45cf22020-10-01 12:49:44 +0200646 LY_ARRAY_FOR(cur_mod->deviated_by, i) {
647 mod = cur_mod->deviated_by[i];
Michal Vasko57c10cd2020-05-27 15:57:11 +0200648
649 if (bis) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200650 LY_CHECK_RET(lyd_new_term(parent, NULL, "deviation", mod->name, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200651 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200652 LY_CHECK_RET(lyd_new_list(parent, NULL, "deviation", NULL, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200653 (mod->parsed->revs ? mod->parsed->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200654 }
655 }
656
657 return LY_SUCCESS;
658}
659
660static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200661ylib_submodules(struct lyd_node *parent, const struct lys_module *cur_mod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200662{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200663 LY_ERR ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200664 LY_ARRAY_COUNT_TYPE i;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200665 struct lyd_node *cont;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200666 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200667 int r;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200668 char *str;
669
670 LY_ARRAY_FOR(cur_mod->parsed->includes, i) {
671 submod = cur_mod->parsed->includes[i].submodule;
672
673 if (bis) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200674 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", &cont, submod->name));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200675
676 if (submod->revs) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200677 LY_CHECK_RET(lyd_new_term(cont, NULL, "revision", submod->revs[0].date, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200678 }
679 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200680 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", &cont, submod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200681 (submod->revs ? submod->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200682 }
683
684 if (submod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200685 r = asprintf(&str, "file://%s", submod->filepath);
686 LY_CHECK_ERR_RET(r == -1, LOGMEM(cur_mod->ctx), LY_EMEM);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200687
Michal Vasko3a41dff2020-07-15 14:30:28 +0200688 ret = lyd_new_term(cont, NULL, bis ? "location" : "schema", str, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200689 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200690 LY_CHECK_RET(ret);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200691 }
692 }
693
694 return LY_SUCCESS;
695}
696
697API uint16_t
698ly_ctx_get_yanglib_id(const struct ly_ctx *ctx)
699{
700 return ctx->module_set_id;
701}
702
Michal Vasko3a41dff2020-07-15 14:30:28 +0200703API LY_ERR
704ly_ctx_get_yanglib_data(const struct ly_ctx *ctx, struct lyd_node **root_p)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200705{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200706 LY_ERR ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200707 uint32_t i;
Radek Krejci857189e2020-09-01 13:26:36 +0200708 ly_bool bis = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200709 int r;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200710 char id[8], *str;
711 const struct lys_module *mod;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200712 struct lyd_node *root = NULL, *root_bis = NULL, *cont, *set_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200713
Michal Vasko3a41dff2020-07-15 14:30:28 +0200714 LY_CHECK_ARG_RET(ctx, ctx, root_p, LY_EINVAL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200715
716 mod = ly_ctx_get_module_implemented(ctx, "ietf-yang-library");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200717 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 +0200718
719 if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, "2016-06-21")) {
720 bis = 0;
721 } else if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, IETF_YANG_LIB_REV)) {
722 bis = 1;
723 } else {
724 LOGERR(ctx, LY_EINVAL, "Incompatible ietf-yang-library version in context.");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200725 return LY_EINVAL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200726 }
727
Michal Vasko3a41dff2020-07-15 14:30:28 +0200728 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "modules-state", &root), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200729
730 if (bis) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200731 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "yang-library", &root_bis), error);
732 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "module-set", &set_bis, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200733 }
734
735 for (i = 0; i < ctx->list.count; ++i) {
736 mod = ctx->list.objs[i];
737
738 /*
739 * deprecated legacy
740 */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200741 LY_CHECK_GOTO(ret = lyd_new_list(root, NULL, "module", &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200742 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200743
744 /* schema */
745 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200746 r = asprintf(&str, "file://%s", mod->filepath);
747 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200748
Michal Vasko3a41dff2020-07-15 14:30:28 +0200749 ret = lyd_new_term(cont, NULL, "schema", str, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200750 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200751 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200752 }
753
754 /* namespace */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200755 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200756
757 /* feature leaf-list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200758 LY_CHECK_GOTO(ret = ylib_feature(cont, mod), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200759
760 /* deviation list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200761 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200762
763 /* conformance-type */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200764 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "conformance-type", mod->implemented ? "implement" : "import",
Michal Vasko69730152020-10-09 16:30:07 +0200765 NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200766
767 /* submodule list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200768 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200769
770 /*
771 * current revision
772 */
773 if (bis) {
774 /* name and revision */
775 if (mod->implemented) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200776 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "module", &cont, mod->name), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200777
778 if (mod->parsed->revs) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200779 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "revision", mod->parsed->revs[0].date, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200780 }
781 } else {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200782 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "import-only-module", &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200783 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200784 }
785
786 /* namespace */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200787 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200788
789 /* location */
790 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200791 r = asprintf(&str, "file://%s", mod->filepath);
792 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200793
Michal Vasko3a41dff2020-07-15 14:30:28 +0200794 ret = lyd_new_term(cont, NULL, "schema", str, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200795 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200796 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200797 }
798
799 /* submodule list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200800 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200801
802 /* feature list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200803 LY_CHECK_GOTO(ret = ylib_feature(cont, mod), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200804
805 /* deviation */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200806 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200807 }
808 }
809
810 /* IDs */
811 sprintf(id, "%u", ctx->module_set_id);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200812 LY_CHECK_GOTO(ret = lyd_new_term(root, NULL, "module-set-id", id, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200813
814 if (bis) {
815 /* create one complete schema */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200816 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "schema", &cont, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200817
Michal Vasko3a41dff2020-07-15 14:30:28 +0200818 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "module-set", "complete", NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200819
820 /* content-id */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200821 LY_CHECK_GOTO(ret = lyd_new_term(root_bis, NULL, "content-id", id, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200822 }
823
824 if (root_bis) {
Michal Vaskob104f112020-07-17 09:54:54 +0200825 if (lyd_insert_sibling(root, root_bis, &root)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200826 goto error;
827 }
Michal Vaskob104f112020-07-17 09:54:54 +0200828 root_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200829 }
830
Michal Vasko3a41dff2020-07-15 14:30:28 +0200831 LY_CHECK_GOTO(ret = lyd_validate_all(&root, NULL, LYD_VALIDATE_PRESENT, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200832
Michal Vasko3a41dff2020-07-15 14:30:28 +0200833 *root_p = root;
834 return LY_SUCCESS;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200835
836error:
837 lyd_free_all(root);
838 lyd_free_all(root_bis);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200839 return ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200840}
841
Radek Krejcie9e987e2018-10-31 12:50:27 +0100842API void
Radek Krejciad573502018-09-07 15:26:55 +0200843ly_ctx_destroy(struct ly_ctx *ctx, void (*private_destructor)(const struct lysc_node *node, void *priv))
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200844{
Radek Krejci418823a2018-09-20 16:42:13 +0200845 if (!ctx) {
846 return;
847 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200848
849 /* models list */
Michal Vaskod989ba02020-08-24 10:59:24 +0200850 for ( ; ctx->list.count; ctx->list.count--) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200851 /* remove the module */
Radek Krejci86d106e2018-10-18 09:53:19 +0200852 lys_module_free(ctx->list.objs[ctx->list.count - 1], private_destructor);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200853 }
854 free(ctx->list.objs);
855
856 /* search paths list */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200857 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200858
859 /* clean the error list */
860 ly_err_clean(ctx, 0);
861 pthread_key_delete(ctx->errlist_key);
862
863 /* dictionary */
864 lydict_clean(&ctx->dict);
865
866#if 0 /* TODO when plugins implemented */
867 /* plugins - will be removed only if this is the last context */
868 ly_clean_plugins();
869#endif
870
871 free(ctx);
872}