blob: f13da5f4a6f1b1d662bfecd674f275bebcd5ea5f [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 Krejcif8dc59a2020-11-25 13:47:44 +010015#define _POSIX_C_SOURCE 200809L /* strdup */
Radek Krejci0af5f5d2018-09-07 15:00:30 +020016
Radek Krejci535ea9f2020-05-29 16:01:05 +020017#include "context.h"
Radek Krejcib7db73a2018-10-24 14:18:40 +020018
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <assert.h>
Radek Krejci0af5f5d2018-09-07 15:00:30 +020020#include <errno.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020021#include <pthread.h>
22#include <stddef.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020023#include <stdio.h>
Radek Krejci7ada9a02018-09-07 15:34:05 +020024#include <stdlib.h>
25#include <string.h>
Radek Krejci0e212402018-09-20 11:29:38 +020026#include <sys/stat.h>
Radek Krejci0af5f5d2018-09-07 15:00:30 +020027#include <unistd.h>
28
Radek Krejci535ea9f2020-05-29 16:01:05 +020029#include "common.h"
Radek Krejciaa45bda2020-07-20 07:43:38 +020030#include "compat.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020031#include "hash_table.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020032#include "in.h"
Radek Krejci7931b192020-06-25 17:05:03 +020033#include "parser_data.h"
Michal Vasko308d0a72020-08-03 11:56:25 +020034#include "path.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020035#include "plugins_types.h"
Michal Vasko405cc9e2020-12-01 12:01:27 +010036#include "schema_compile.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020037#include "set.h"
38#include "tree.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020039#include "tree_data.h"
Radek Krejcica376bd2020-06-11 16:04:06 +020040#include "tree_schema.h"
Radek Krejci86d106e2018-10-18 09:53:19 +020041#include "tree_schema_internal.h"
Michal Vasko308d0a72020-08-03 11:56:25 +020042#include "xpath.h"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020043
Michal Vaskocf296c82020-05-27 11:16:45 +020044#include "../models/ietf-datastores@2018-02-14.h"
Michal Vasko69730152020-10-09 16:30:07 +020045#include "../models/ietf-inet-types@2013-07-15.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020046#include "../models/ietf-yang-library@2019-01-04.h"
Michal Vasko69730152020-10-09 16:30:07 +020047#include "../models/ietf-yang-metadata@2016-08-05.h"
48#include "../models/ietf-yang-types@2013-07-15.h"
49#include "../models/yang@2020-06-17.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020050#define IETF_YANG_LIB_REV "2019-01-04"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020051
Radek Krejci0af5f5d2018-09-07 15:00:30 +020052static struct internal_modules_s {
53 const char *name;
54 const char *revision;
55 const char *data;
Radek Krejci857189e2020-09-01 13:26:36 +020056 ly_bool implemented;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020057 LYS_INFORMAT format;
Michal Vaskode79e222020-08-10 11:55:46 +020058} internal_modules[] = {
Michal Vasko1de593f2020-11-23 16:11:41 +010059 {"ietf-yang-metadata", "2016-08-05", (const char *)ietf_yang_metadata_2016_08_05_yang, 0, LYS_IN_YANG},
Michal Vasko22df3f02020-08-24 13:29:22 +020060 {"yang", "2020-06-17", (const char *)yang_2020_06_17_yang, 1, LYS_IN_YANG},
61 {"ietf-inet-types", "2013-07-15", (const char *)ietf_inet_types_2013_07_15_yang, 0, LYS_IN_YANG},
62 {"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 +020063 /* ietf-datastores and ietf-yang-library must be right here at the end of the list! */
Michal Vasko22df3f02020-08-24 13:29:22 +020064 {"ietf-datastores", "2018-02-14", (const char *)ietf_datastores_2018_02_14_yang, 1, LYS_IN_YANG},
65 {"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 +020066};
67
Michal Vaskode79e222020-08-10 11:55:46 +020068#define LY_INTERNAL_MODS_COUNT sizeof(internal_modules) / sizeof(struct internal_modules_s)
69
Radek Krejci0af5f5d2018-09-07 15:00:30 +020070API LY_ERR
71ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir)
72{
Radek Krejci0e212402018-09-20 11:29:38 +020073 struct stat st;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020074 char *new_dir = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020075
76 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
77
78 if (search_dir) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +020079 new_dir = realpath(search_dir, NULL);
Radek Krejcia77e0e12018-09-20 12:39:15 +020080 LY_CHECK_ERR_RET(!new_dir,
Michal Vasko69730152020-10-09 16:30:07 +020081 LOGERR(ctx, LY_ESYS, "Unable to use search directory \"%s\" (%s).", search_dir, strerror(errno)),
82 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020083 if (strcmp(search_dir, new_dir)) {
84 LOGVRB("Canonicalizing search directory string from \"%s\" to \"%s\".", search_dir, new_dir);
85 }
86 LY_CHECK_ERR_RET(access(new_dir, R_OK | X_OK),
Michal Vasko69730152020-10-09 16:30:07 +020087 LOGERR(ctx, LY_ESYS, "Unable to fully access search directory \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
88 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020089 LY_CHECK_ERR_RET(stat(new_dir, &st),
Michal Vasko69730152020-10-09 16:30:07 +020090 LOGERR(ctx, LY_ESYS, "stat() failed for \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
91 LY_ESYS);
Radek Krejci3a077b92019-04-09 17:10:35 +020092 LY_CHECK_ERR_RET(!S_ISDIR(st.st_mode),
Michal Vasko69730152020-10-09 16:30:07 +020093 LOGERR(ctx, LY_ESYS, "Given search directory \"%s\" is not a directory.", new_dir); free(new_dir),
94 LY_EINVAL);
Radek Krejci0e212402018-09-20 11:29:38 +020095 /* avoid path duplication */
Radek Krejci1deb5be2020-08-26 16:43:36 +020096 for (uint32_t u = 0; u < ctx->search_paths.count; ++u) {
Radek Krejci14946ab2018-09-20 13:42:06 +020097 if (!strcmp(new_dir, ctx->search_paths.objs[u])) {
Radek Krejci0e212402018-09-20 11:29:38 +020098 free(new_dir);
Radek Krejci14946ab2018-09-20 13:42:06 +020099 return LY_EEXIST;
Radek Krejci0e212402018-09-20 11:29:38 +0200100 }
101 }
Radek Krejci3d92e442020-10-12 12:48:13 +0200102 if (ly_set_add(&ctx->search_paths, new_dir, 1, NULL)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200103 free(new_dir);
104 return LY_EMEM;
105 }
106
Radek Krejcie9e987e2018-10-31 12:50:27 +0100107 /* new searchdir - possibly more latest revision available */
108 ly_ctx_reset_latests(ctx);
109
Radek Krejci0e212402018-09-20 11:29:38 +0200110 return LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200111 } else {
112 /* consider that no change is not actually an error */
113 return LY_SUCCESS;
114 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200115}
116
117API const char * const *
118ly_ctx_get_searchdirs(const struct ly_ctx *ctx)
119{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100120#define LY_CTX_SEARCHDIRS_SIZE_STEP 8
Radek Krejci05026432018-09-20 12:13:43 +0200121 void **new;
122
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200123 LY_CHECK_ARG_RET(ctx, ctx, NULL);
Radek Krejci05026432018-09-20 12:13:43 +0200124
125 if (ctx->search_paths.count == ctx->search_paths.size) {
126 /* not enough space for terminating NULL byte */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100127 new = realloc(((struct ly_ctx *)ctx)->search_paths.objs,
128 (ctx->search_paths.size + LY_CTX_SEARCHDIRS_SIZE_STEP) * sizeof *ctx->search_paths.objs);
Radek Krejci05026432018-09-20 12:13:43 +0200129 LY_CHECK_ERR_RET(!new, LOGMEM(NULL), NULL);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100130 ((struct ly_ctx *)ctx)->search_paths.size += LY_CTX_SEARCHDIRS_SIZE_STEP;
Radek Krejci05026432018-09-20 12:13:43 +0200131 ((struct ly_ctx *)ctx)->search_paths.objs = new;
132 }
133 /* set terminating NULL byte to the strings list */
134 ctx->search_paths.objs[ctx->search_paths.count] = NULL;
135
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200136 return (const char * const *)ctx->search_paths.objs;
137}
138
139API LY_ERR
Radek Krejcie58f97f2020-08-18 11:45:08 +0200140ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200141{
Radek Krejcicd649072018-09-20 12:14:45 +0200142 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Radek Krejcicd649072018-09-20 12:14:45 +0200143
Michal Vaskob34480a2018-09-17 10:34:45 +0200144 if (!ctx->search_paths.count) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200145 return LY_SUCCESS;
146 }
147
Radek Krejci0759b792018-09-20 13:53:15 +0200148 if (value) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200149 /* remove specific search directory */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200150 uint32_t index;
151
Radek Krejci0759b792018-09-20 13:53:15 +0200152 for (index = 0; index < ctx->search_paths.count; ++index) {
153 if (!strcmp(value, ctx->search_paths.objs[index])) {
154 break;
155 }
156 }
157 if (index == ctx->search_paths.count) {
158 LOGARG(ctx, value);
159 return LY_EINVAL;
160 } else {
161 return ly_set_rm_index(&ctx->search_paths, index, free);
162 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200163 } else {
164 /* remove them all */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200165 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200166 memset(&ctx->search_paths, 0, sizeof ctx->search_paths);
167 }
168
169 return LY_SUCCESS;
170}
171
172API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200173ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count)
Radek Krejcied5acc52019-04-25 15:57:04 +0200174{
175 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
176
Radek Krejcie58f97f2020-08-18 11:45:08 +0200177 for ( ; count > 0 && ctx->search_paths.count; --count) {
178 LY_CHECK_RET(ly_set_rm_index(&ctx->search_paths, ctx->search_paths.count - 1, free))
Radek Krejcied5acc52019-04-25 15:57:04 +0200179 }
180
181 return LY_SUCCESS;
182}
183
184API const struct lys_module *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100185ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision, const char **features)
Radek Krejcied5acc52019-04-25 15:57:04 +0200186{
187 struct lys_module *result = NULL;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100188 struct lys_glob_unres unres = {0};
189 LY_ERR ret = LY_SUCCESS;
Radek Krejcied5acc52019-04-25 15:57:04 +0200190
191 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
192
Michal Vasko405cc9e2020-12-01 12:01:27 +0100193 LY_CHECK_GOTO(ret = lysp_load_module(ctx, name, revision, 1, features, &unres, &result), cleanup);
194
195 /* resolve unres and revert, if needed */
196 LY_CHECK_GOTO(ret = lys_compile_unres_glob(ctx, &unres), cleanup);
197
198cleanup:
199 if (ret) {
200 lys_compile_unres_glob_revert(ctx, &unres);
201 result = NULL;
202 }
203 lys_compile_unres_glob_erase(ctx, &unres);
Radek Krejcied5acc52019-04-25 15:57:04 +0200204 return result;
205}
206
207API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200208ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200209{
210 struct ly_ctx *ctx = NULL;
211 struct lys_module *module;
212 char *search_dir_list;
213 char *sep, *dir;
Michal Vaskode79e222020-08-10 11:55:46 +0200214 uint32_t i;
Michal Vasko63f3d842020-07-08 10:10:14 +0200215 struct ly_in *in = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200216 LY_ERR rc = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100217 struct lys_glob_unres unres = {0};
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200218
Radek Krejcied5acc52019-04-25 15:57:04 +0200219 LY_CHECK_ARG_RET(NULL, new_ctx, LY_EINVAL);
220
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200221 ctx = calloc(1, sizeof *ctx);
Radek Krejciad573502018-09-07 15:26:55 +0200222 LY_CHECK_ERR_RET(!ctx, LOGMEM(NULL), LY_EMEM);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200223
224 /* dictionary */
225 lydict_init(&ctx->dict);
226
Radek Krejciad573502018-09-07 15:26:55 +0200227#if 0 /* TODO when plugins implemented */
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200228 /* plugins */
229 ly_load_plugins();
Radek Krejciad573502018-09-07 15:26:55 +0200230#endif
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200231
232 /* initialize thread-specific key */
Radek Krejci1e008d22020-08-17 11:37:37 +0200233 while ((pthread_key_create(&ctx->errlist_key, ly_err_free)) == EAGAIN) {}
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200234
235 /* models list */
236 ctx->flags = options;
237 if (search_dir) {
238 search_dir_list = strdup(search_dir);
239 LY_CHECK_ERR_GOTO(!search_dir_list, LOGMEM(NULL); rc = LY_EMEM, error);
240
241 for (dir = search_dir_list; (sep = strchr(dir, ':')) != NULL && rc == LY_SUCCESS; dir = sep + 1) {
242 *sep = 0;
243 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200244 if (rc == LY_EEXIST) {
245 /* ignore duplication */
246 rc = LY_SUCCESS;
247 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200248 }
Michal Vasko69730152020-10-09 16:30:07 +0200249 if (*dir && (rc == LY_SUCCESS)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200250 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200251 if (rc == LY_EEXIST) {
252 /* ignore duplication */
253 rc = LY_SUCCESS;
254 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200255 }
256 free(search_dir_list);
257
258 /* If ly_ctx_set_searchdir() failed, the error is already logged. Just exit */
259 if (rc != LY_SUCCESS) {
260 goto error;
261 }
262 }
263 ctx->module_set_id = 1;
264
Michal Vasko63f3d842020-07-08 10:10:14 +0200265 /* create dummy in */
266 rc = ly_in_new_memory(internal_modules[0].data, &in);
267 LY_CHECK_GOTO(rc, error);
268
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200269 /* load internal modules */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200270 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 +0200271 ly_in_memory(in, internal_modules[i].data);
Michal Vasko7a0b0762020-09-02 16:37:01 +0200272 LY_CHECK_GOTO(rc = lys_create_module(ctx, in, internal_modules[i].format, internal_modules[i].implemented,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100273 NULL, NULL, NULL, &unres, &module), error);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200274 }
275
Michal Vasko405cc9e2020-12-01 12:01:27 +0100276 /* resolve global unres */
277 LY_CHECK_GOTO(rc = lys_compile_unres_glob(ctx, &unres), error);
278
Michal Vasko63f3d842020-07-08 10:10:14 +0200279 ly_in_free(in, 0);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100280 lys_compile_unres_glob_erase(ctx, &unres);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200281 *new_ctx = ctx;
282 return rc;
283
284error:
Michal Vasko63f3d842020-07-08 10:10:14 +0200285 ly_in_free(in, 0);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100286 lys_compile_unres_glob_erase(ctx, &unres);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200287 ly_ctx_destroy(ctx, NULL);
288 return rc;
289}
Radek Krejci0f969882020-08-21 16:56:47 +0200290
Radek Krejci1deb5be2020-08-26 16:43:36 +0200291API uint16_t
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200292ly_ctx_get_options(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200293{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200294 LY_CHECK_ARG_RET(ctx, ctx, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200295 return ctx->flags;
296}
297
Radek Krejcica828d92018-09-20 14:19:43 +0200298API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200299ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200300{
301 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200302 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200303
304 /* set the option(s) */
305 ctx->flags |= option;
306
307 return LY_SUCCESS;
308}
309
310API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200311ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200312{
313 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200314 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200315
316 /* unset the option(s) */
317 ctx->flags &= ~option;
318
319 return LY_SUCCESS;
320}
321
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200322API uint16_t
323ly_ctx_get_module_set_id(const struct ly_ctx *ctx)
324{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200325 LY_CHECK_ARG_RET(ctx, ctx, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200326 return ctx->module_set_id;
327}
328
Radek Krejcid33273d2018-10-25 14:55:52 +0200329API void
330ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data)
331{
Michal Vaskod989ba02020-08-24 10:59:24 +0200332 LY_CHECK_ARG_RET(ctx, ctx, );
Radek Krejcid33273d2018-10-25 14:55:52 +0200333
334 ctx->imp_clb = clb;
335 ctx->imp_clb_data = user_data;
336}
337
338API ly_module_imp_clb
339ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data)
340{
341 LY_CHECK_ARG_RET(ctx, ctx, NULL);
342
343 if (user_data) {
344 *user_data = ctx->imp_clb_data;
345 }
346 return ctx->imp_clb;
347}
348
Radek Krejcied5acc52019-04-25 15:57:04 +0200349API const struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200350ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index)
Radek Krejcied5acc52019-04-25 15:57:04 +0200351{
352 LY_CHECK_ARG_RET(ctx, ctx, index, NULL);
353
Radek Krejci2390fb52019-04-30 13:27:43 +0200354 if (*index < (unsigned)ctx->list.count) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200355 return ctx->list.objs[(*index)++];
Radek Krejci2390fb52019-04-30 13:27:43 +0200356 } else {
357 return NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200358 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200359}
360
Radek Krejcib7db73a2018-10-24 14:18:40 +0200361/**
362 * @brief Iterate over the modules in the given context. Returned modules must match the given key at the offset of
363 * lysp_module and lysc_module structures (they are supposed to be placed at the same offset in both structures).
364 *
365 * @param[in] ctx Context where to iterate.
366 * @param[in] key Key value to search for.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200367 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100368 * @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 +0200369 * @param[in,out] Iterator to pass between the function calls. On the first call, the variable is supposed to be
370 * initiated to 0. After each call returning a module, the value is greater by 1 than the index of the returned
371 * module in the context.
372 * @return Module matching the given key, NULL if no such module found.
373 */
Radek Krejci0af46292019-01-11 16:02:31 +0100374static struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200375ly_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 +0200376{
Radek Krejci0af46292019-01-11 16:02:31 +0100377 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200378 const char *value;
379
Michal Vaskod989ba02020-08-24 10:59:24 +0200380 for ( ; *index < ctx->list.count; ++(*index)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200381 mod = ctx->list.objs[*index];
Michal Vasko22df3f02020-08-24 13:29:22 +0200382 value = *(const char **)(((int8_t *)(mod)) + key_offset);
Michal Vasko69730152020-10-09 16:30:07 +0200383 if ((!key_size && !strcmp(key, value)) || (key_size && !strncmp(key, value, key_size) && (value[key_size] == '\0'))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200384 /* increment index for the next run */
385 ++(*index);
386 return mod;
387 }
388 }
389 /* done */
390 return NULL;
391}
392
393/**
394 * @brief Unifying function for ly_ctx_get_module() and ly_ctx_get_module_ns()
395 * @param[in] ctx Context where to search.
396 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100397 * @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 +0200398 * @param[in] revision Revision date to match. If NULL, the matching module must have no revision. To search for the latest
399 * revision module, use ly_ctx_get_module_latest_by().
400 * @return Matching module if any.
401 */
Radek Krejci0af46292019-01-11 16:02:31 +0100402static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200403ly_ctx_get_module_by(const struct ly_ctx *ctx, const char *key, size_t key_offset, const char *revision)
404{
Radek Krejci0af46292019-01-11 16:02:31 +0100405 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200406 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200407
Radek Krejci0ad51f12020-07-16 12:08:12 +0200408 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200409 if (!revision) {
Radek Krejci0af46292019-01-11 16:02:31 +0100410 if (!mod->revision) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200411 /* found requested module without revision */
412 return mod;
413 }
414 } else {
Radek Krejci0af46292019-01-11 16:02:31 +0100415 if (mod->revision && !strcmp(mod->revision, revision)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200416 /* found requested module of the specific revision */
417 return mod;
418 }
419 }
420 }
421
422 return NULL;
423}
424
Radek Krejci0af46292019-01-11 16:02:31 +0100425API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200426ly_ctx_get_module_ns(const struct ly_ctx *ctx, const char *ns, const char *revision)
427{
428 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100429 return ly_ctx_get_module_by(ctx, ns, offsetof(struct lys_module, ns), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200430}
431
Radek Krejci0af46292019-01-11 16:02:31 +0100432API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200433ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision)
434{
435 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100436 return ly_ctx_get_module_by(ctx, name, offsetof(struct lys_module, name), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200437}
438
439/**
440 * @brief Unifying function for ly_ctx_get_module_latest() and ly_ctx_get_module_latest_ns()
441 * @param[in] ctx Context where to search.
442 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100443 * @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 +0200444 * @return Matching module if any.
445 */
Radek Krejci0af46292019-01-11 16:02:31 +0100446static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200447ly_ctx_get_module_latest_by(const struct ly_ctx *ctx, const char *key, size_t key_offset)
448{
Radek Krejci0af46292019-01-11 16:02:31 +0100449 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200450 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200451
Radek Krejci0ad51f12020-07-16 12:08:12 +0200452 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100453 if (mod->latest_revision) {
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200454 return mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200455 }
456 }
457
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200458 return NULL;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200459}
460
Radek Krejci0af46292019-01-11 16:02:31 +0100461API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200462ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name)
463{
464 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100465 return ly_ctx_get_module_latest_by(ctx, name, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200466}
467
Radek Krejci0af46292019-01-11 16:02:31 +0100468API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200469ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns)
470{
471 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100472 return ly_ctx_get_module_latest_by(ctx, ns, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200473}
474
475/**
476 * @brief Unifying function for ly_ctx_get_module_implemented() and ly_ctx_get_module_implemented_ns()
477 * @param[in] ctx Context where to search.
478 * @param[in] key Name or Namespace as a search key.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200479 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100480 * @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 +0200481 * @return Matching module if any.
482 */
Radek Krejci0af46292019-01-11 16:02:31 +0100483static struct lys_module *
Radek Krejci0ad51f12020-07-16 12:08:12 +0200484ly_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 +0200485{
Radek Krejci0af46292019-01-11 16:02:31 +0100486 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200487 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200488
Radek Krejci0ad51f12020-07-16 12:08:12 +0200489 while ((mod = ly_ctx_get_module_by_iter(ctx, key, key_size, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100490 if (mod->implemented) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200491 return mod;
492 }
493 }
494
495 return NULL;
496}
497
Radek Krejci0af46292019-01-11 16:02:31 +0100498API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200499ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name)
500{
501 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200502 return ly_ctx_get_module_implemented_by(ctx, name, 0, offsetof(struct lys_module, name));
503}
504
505struct lys_module *
506ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len)
507{
508 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
509 return ly_ctx_get_module_implemented_by(ctx, name, name_len, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200510}
511
Radek Krejci0af46292019-01-11 16:02:31 +0100512API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200513ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns)
514{
515 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200516 return ly_ctx_get_module_implemented_by(ctx, ns, 0, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200517}
518
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100519struct lysp_submodule *
Michal Vaskoc3781c32020-10-06 14:04:08 +0200520ly_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 +0200521{
522 const struct lys_module *mod;
523 struct lysp_include *inc;
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200524 uint32_t v;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200525 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid33273d2018-10-25 14:55:52 +0200526
Michal Vaskoc3781c32020-10-06 14:04:08 +0200527 assert((ctx || module) && submodule);
528
529 if (module) {
530 if (!module->parsed) {
531 return NULL;
532 }
533
534 /* check only this module */
535 mod = module;
536 goto check_mod;
537 }
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100538
539 for (v = 0; v < ctx->list.count; ++v) {
540 mod = ctx->list.objs[v];
Radek Krejcid33273d2018-10-25 14:55:52 +0200541 if (!mod->parsed) {
542 continue;
543 }
544
Michal Vaskoc3781c32020-10-06 14:04:08 +0200545check_mod:
Radek Krejcid33273d2018-10-25 14:55:52 +0200546 LY_ARRAY_FOR(mod->parsed->includes, u) {
Radek Krejci086c7132018-10-26 15:29:04 +0200547 if (mod->parsed->includes[u].submodule && !strcmp(submodule, mod->parsed->includes[u].submodule->name)) {
Radek Krejcid33273d2018-10-25 14:55:52 +0200548 inc = &mod->parsed->includes[u];
549 if (!revision) {
550 if (inc->submodule->latest_revision) {
551 return inc->submodule;
552 }
553 } else if (inc->submodule->revs && !strcmp(revision, inc->submodule->revs[0].date)) {
554 return inc->submodule;
555 }
556 }
557 }
Michal Vaskoc3781c32020-10-06 14:04:08 +0200558
559 if (module) {
560 /* do not check other modules */
561 break;
562 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200563 }
564
565 return NULL;
566}
567
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200568API void
Radek Krejcie9e987e2018-10-31 12:50:27 +0100569ly_ctx_reset_latests(struct ly_ctx *ctx)
570{
Radek Krejcie9e987e2018-10-31 12:50:27 +0100571 struct lys_module *mod;
572
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200573 for (uint32_t v = 0; v < ctx->list.count; ++v) {
574 mod = ctx->list.objs[v];
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100575 if (mod->latest_revision == 2) {
576 mod->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100577 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100578 if (mod->parsed && mod->parsed->includes) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200579 for (LY_ARRAY_COUNT_TYPE u = 0; u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200580 if (mod->parsed->includes[u].submodule->latest_revision == 2) {
581 mod->parsed->includes[u].submodule->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100582 }
583 }
584 }
585 }
586}
587
Michal Vaskode79e222020-08-10 11:55:46 +0200588API uint32_t
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100589ly_ctx_internal_modules_count(const struct ly_ctx *ctx)
Michal Vaskode79e222020-08-10 11:55:46 +0200590{
591 if (!ctx) {
592 return 0;
593 }
594
Michal Vasko25d6ad02020-10-22 12:20:22 +0200595 if (ctx->flags & LY_CTX_NO_YANGLIBRARY) {
Michal Vaskode79e222020-08-10 11:55:46 +0200596 return LY_INTERNAL_MODS_COUNT - 2;
597 } else {
598 return LY_INTERNAL_MODS_COUNT;
599 }
600}
601
Michal Vasko57c10cd2020-05-27 15:57:11 +0200602static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100603ylib_feature(struct lyd_node *parent, const struct lysp_module *pmod)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200604{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100605 LY_ARRAY_COUNT_TYPE u;
606 struct lysp_feature *f;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200607
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100608 if (!pmod->mod->implemented) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200609 /* no features can be enabled */
610 return LY_SUCCESS;
611 }
612
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100613 LY_ARRAY_FOR(pmod->features, struct lysp_feature, f) {
614 if (!(f->flags & LYS_FENABLED)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200615 continue;
616 }
617
Radek Krejci41ac9942020-11-02 14:47:56 +0100618 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100619 }
620
621 LY_ARRAY_FOR(pmod->includes, u) {
622 LY_ARRAY_FOR(pmod->includes[u].submodule->features, struct lysp_feature, f) {
623 if (!(f->flags & LYS_FENABLED)) {
624 continue;
625 }
626
Radek Krejci41ac9942020-11-02 14:47:56 +0100627 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100628 }
Michal Vasko57c10cd2020-05-27 15:57:11 +0200629 }
630
631 return LY_SUCCESS;
632}
633
634static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200635ylib_deviation(struct lyd_node *parent, const struct lys_module *cur_mod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200636{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200637 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200638 struct lys_module *mod;
639
640 if (!cur_mod->implemented) {
641 /* no deviations of the module for certain */
642 return LY_SUCCESS;
643 }
644
Michal Vasko7f45cf22020-10-01 12:49:44 +0200645 LY_ARRAY_FOR(cur_mod->deviated_by, i) {
646 mod = cur_mod->deviated_by[i];
Michal Vasko57c10cd2020-05-27 15:57:11 +0200647
648 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100649 LY_CHECK_RET(lyd_new_term(parent, NULL, "deviation", mod->name, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200650 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +0100651 LY_CHECK_RET(lyd_new_list(parent, NULL, "deviation", 0, NULL, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200652 (mod->parsed->revs ? mod->parsed->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200653 }
654 }
655
656 return LY_SUCCESS;
657}
658
659static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100660ylib_submodules(struct lyd_node *parent, const struct lysp_module *pmod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200661{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200662 LY_ERR ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200663 LY_ARRAY_COUNT_TYPE i;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200664 struct lyd_node *cont;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200665 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200666 int r;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200667 char *str;
668
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100669 LY_ARRAY_FOR(pmod->includes, i) {
670 submod = pmod->includes[i].submodule;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200671
672 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100673 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200674
675 if (submod->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100676 LY_CHECK_RET(lyd_new_term(cont, NULL, "revision", submod->revs[0].date, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200677 }
678 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +0100679 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200680 (submod->revs ? submod->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200681 }
682
683 if (submod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200684 r = asprintf(&str, "file://%s", submod->filepath);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100685 LY_CHECK_ERR_RET(r == -1, LOGMEM(pmod->mod->ctx), LY_EMEM);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200686
Radek Krejci41ac9942020-11-02 14:47:56 +0100687 ret = lyd_new_term(cont, NULL, bis ? "location" : "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200688 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200689 LY_CHECK_RET(ret);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200690 }
691 }
692
693 return LY_SUCCESS;
694}
695
696API uint16_t
697ly_ctx_get_yanglib_id(const struct ly_ctx *ctx)
698{
699 return ctx->module_set_id;
700}
701
Michal Vasko3a41dff2020-07-15 14:30:28 +0200702API LY_ERR
703ly_ctx_get_yanglib_data(const struct ly_ctx *ctx, struct lyd_node **root_p)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200704{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200705 LY_ERR ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200706 uint32_t i;
Radek Krejci857189e2020-09-01 13:26:36 +0200707 ly_bool bis = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200708 int r;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100709 char *str;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200710 const struct lys_module *mod;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200711 struct lyd_node *root = NULL, *root_bis = NULL, *cont, *set_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200712
Michal Vasko3a41dff2020-07-15 14:30:28 +0200713 LY_CHECK_ARG_RET(ctx, ctx, root_p, LY_EINVAL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200714
715 mod = ly_ctx_get_module_implemented(ctx, "ietf-yang-library");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200716 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 +0200717
718 if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, "2016-06-21")) {
719 bis = 0;
720 } else if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, IETF_YANG_LIB_REV)) {
721 bis = 1;
722 } else {
723 LOGERR(ctx, LY_EINVAL, "Incompatible ietf-yang-library version in context.");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200724 return LY_EINVAL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200725 }
726
Radek Krejci41ac9942020-11-02 14:47:56 +0100727 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "modules-state", 0, &root), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200728
729 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100730 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "yang-library", 0, &root_bis), error);
731 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "module-set", 0, &set_bis, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200732 }
733
734 for (i = 0; i < ctx->list.count; ++i) {
735 mod = ctx->list.objs[i];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100736 if (!mod->parsed) {
737 LOGERR(ctx, LY_ENOTFOUND, "Parsed module \"%s\" missing in the context.", mod->name);
738 goto error;
739 }
Michal Vasko57c10cd2020-05-27 15:57:11 +0200740
741 /*
742 * deprecated legacy
743 */
Radek Krejci41ac9942020-11-02 14:47:56 +0100744 LY_CHECK_GOTO(ret = lyd_new_list(root, NULL, "module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200745 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200746
747 /* schema */
748 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200749 r = asprintf(&str, "file://%s", mod->filepath);
750 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200751
Radek Krejci41ac9942020-11-02 14:47:56 +0100752 ret = lyd_new_term(cont, NULL, "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200753 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200754 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200755 }
756
757 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +0100758 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200759
760 /* feature leaf-list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100761 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200762
763 /* deviation list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200764 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200765
766 /* conformance-type */
Radek Krejci41ac9942020-11-02 14:47:56 +0100767 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "conformance-type", mod->implemented ? "implement" : "import", 0,
Michal Vasko69730152020-10-09 16:30:07 +0200768 NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200769
770 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100771 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200772
773 /*
774 * current revision
775 */
776 if (bis) {
777 /* name and revision */
778 if (mod->implemented) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100779 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "module", 0, &cont, mod->name), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200780
781 if (mod->parsed->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100782 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 +0200783 }
784 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +0100785 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "import-only-module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200786 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200787 }
788
789 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +0100790 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200791
792 /* location */
793 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200794 r = asprintf(&str, "file://%s", mod->filepath);
795 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200796
Radek Krejcid68ba1b2020-11-09 17:40:11 +0100797 ret = lyd_new_term(cont, NULL, "location", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200798 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200799 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200800 }
801
802 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100803 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200804
805 /* feature list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100806 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200807
808 /* deviation */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200809 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200810 }
811 }
812
813 /* IDs */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100814 r = asprintf(&str, "%u", ctx->module_set_id);
815 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
816 ret = lyd_new_term(root, NULL, "module-set-id", str, 0, NULL);
817 LY_CHECK_ERR_GOTO(ret, free(str), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200818
819 if (bis) {
820 /* create one complete schema */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100821 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 +0200822
Radek Krejcif13b87b2020-12-01 22:02:17 +0100823 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 +0200824
825 /* content-id */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100826 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 +0200827 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100828 free(str);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200829
830 if (root_bis) {
Michal Vaskob104f112020-07-17 09:54:54 +0200831 if (lyd_insert_sibling(root, root_bis, &root)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200832 goto error;
833 }
Michal Vaskob104f112020-07-17 09:54:54 +0200834 root_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200835 }
836
Michal Vasko3a41dff2020-07-15 14:30:28 +0200837 LY_CHECK_GOTO(ret = lyd_validate_all(&root, NULL, LYD_VALIDATE_PRESENT, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200838
Michal Vasko3a41dff2020-07-15 14:30:28 +0200839 *root_p = root;
840 return LY_SUCCESS;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200841
842error:
843 lyd_free_all(root);
844 lyd_free_all(root_bis);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200845 return ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200846}
847
Radek Krejcie9e987e2018-10-31 12:50:27 +0100848API void
Radek Krejciad573502018-09-07 15:26:55 +0200849ly_ctx_destroy(struct ly_ctx *ctx, void (*private_destructor)(const struct lysc_node *node, void *priv))
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200850{
Radek Krejci418823a2018-09-20 16:42:13 +0200851 if (!ctx) {
852 return;
853 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200854
855 /* models list */
Michal Vaskod989ba02020-08-24 10:59:24 +0200856 for ( ; ctx->list.count; ctx->list.count--) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200857 /* remove the module */
Radek Krejci86d106e2018-10-18 09:53:19 +0200858 lys_module_free(ctx->list.objs[ctx->list.count - 1], private_destructor);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200859 }
860 free(ctx->list.objs);
861
862 /* search paths list */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200863 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200864
865 /* clean the error list */
866 ly_err_clean(ctx, 0);
867 pthread_key_delete(ctx->errlist_key);
868
869 /* dictionary */
870 lydict_clean(&ctx->dict);
871
872#if 0 /* TODO when plugins implemented */
873 /* plugins - will be removed only if this is the last context */
874 ly_clean_plugins();
875#endif
876
877 free(ctx);
878}