blob: 491e33edc4498afdd59d623ef02447a774381067 [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 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"
Radek Krejcica376bd2020-06-11 16:04:06 +020033#include "plugins_types.h"
Michal Vasko405cc9e2020-12-01 12:01:27 +010034#include "schema_compile.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"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020040
Michal Vaskocf296c82020-05-27 11:16:45 +020041#include "../models/ietf-datastores@2018-02-14.h"
Michal Vasko69730152020-10-09 16:30:07 +020042#include "../models/ietf-inet-types@2013-07-15.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020043#include "../models/ietf-yang-library@2019-01-04.h"
Michal Vasko69730152020-10-09 16:30:07 +020044#include "../models/ietf-yang-metadata@2016-08-05.h"
45#include "../models/ietf-yang-types@2013-07-15.h"
46#include "../models/yang@2020-06-17.h"
Michal Vaskocf296c82020-05-27 11:16:45 +020047#define IETF_YANG_LIB_REV "2019-01-04"
Radek Krejci0af5f5d2018-09-07 15:00:30 +020048
Radek Krejci0af5f5d2018-09-07 15:00:30 +020049static struct internal_modules_s {
50 const char *name;
51 const char *revision;
52 const char *data;
Radek Krejci857189e2020-09-01 13:26:36 +020053 ly_bool implemented;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020054 LYS_INFORMAT format;
Michal Vaskode79e222020-08-10 11:55:46 +020055} internal_modules[] = {
Michal Vasko1de593f2020-11-23 16:11:41 +010056 {"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 +020057 {"yang", "2020-06-17", (const char *)yang_2020_06_17_yang, 1, LYS_IN_YANG},
58 {"ietf-inet-types", "2013-07-15", (const char *)ietf_inet_types_2013_07_15_yang, 0, LYS_IN_YANG},
59 {"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 +020060 /* ietf-datastores and ietf-yang-library must be right here at the end of the list! */
Michal Vasko22df3f02020-08-24 13:29:22 +020061 {"ietf-datastores", "2018-02-14", (const char *)ietf_datastores_2018_02_14_yang, 1, LYS_IN_YANG},
62 {"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 +020063};
64
Michal Vaskode79e222020-08-10 11:55:46 +020065#define LY_INTERNAL_MODS_COUNT sizeof(internal_modules) / sizeof(struct internal_modules_s)
66
Radek Krejci0af5f5d2018-09-07 15:00:30 +020067API LY_ERR
68ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir)
69{
Radek Krejci0e212402018-09-20 11:29:38 +020070 struct stat st;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020071 char *new_dir = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +020072
73 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
74
75 if (search_dir) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +020076 new_dir = realpath(search_dir, NULL);
Radek Krejcia77e0e12018-09-20 12:39:15 +020077 LY_CHECK_ERR_RET(!new_dir,
Michal Vasko69730152020-10-09 16:30:07 +020078 LOGERR(ctx, LY_ESYS, "Unable to use search directory \"%s\" (%s).", search_dir, strerror(errno)),
79 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020080 if (strcmp(search_dir, new_dir)) {
81 LOGVRB("Canonicalizing search directory string from \"%s\" to \"%s\".", search_dir, new_dir);
82 }
83 LY_CHECK_ERR_RET(access(new_dir, R_OK | X_OK),
Michal Vasko69730152020-10-09 16:30:07 +020084 LOGERR(ctx, LY_ESYS, "Unable to fully access search directory \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
85 LY_EINVAL);
Radek Krejci3a077b92019-04-09 17:10:35 +020086 LY_CHECK_ERR_RET(stat(new_dir, &st),
Michal Vasko69730152020-10-09 16:30:07 +020087 LOGERR(ctx, LY_ESYS, "stat() failed for \"%s\" (%s).", new_dir, strerror(errno)); free(new_dir),
88 LY_ESYS);
Radek Krejci3a077b92019-04-09 17:10:35 +020089 LY_CHECK_ERR_RET(!S_ISDIR(st.st_mode),
Michal Vasko69730152020-10-09 16:30:07 +020090 LOGERR(ctx, LY_ESYS, "Given search directory \"%s\" is not a directory.", new_dir); free(new_dir),
91 LY_EINVAL);
Radek Krejci0e212402018-09-20 11:29:38 +020092 /* avoid path duplication */
Radek Krejci1deb5be2020-08-26 16:43:36 +020093 for (uint32_t u = 0; u < ctx->search_paths.count; ++u) {
Radek Krejci14946ab2018-09-20 13:42:06 +020094 if (!strcmp(new_dir, ctx->search_paths.objs[u])) {
Radek Krejci0e212402018-09-20 11:29:38 +020095 free(new_dir);
Radek Krejci14946ab2018-09-20 13:42:06 +020096 return LY_EEXIST;
Radek Krejci0e212402018-09-20 11:29:38 +020097 }
98 }
Radek Krejci3d92e442020-10-12 12:48:13 +020099 if (ly_set_add(&ctx->search_paths, new_dir, 1, NULL)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200100 free(new_dir);
101 return LY_EMEM;
102 }
103
Radek Krejcie9e987e2018-10-31 12:50:27 +0100104 /* new searchdir - possibly more latest revision available */
105 ly_ctx_reset_latests(ctx);
106
Radek Krejci0e212402018-09-20 11:29:38 +0200107 return LY_SUCCESS;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200108 } else {
109 /* consider that no change is not actually an error */
110 return LY_SUCCESS;
111 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200112}
113
114API const char * const *
115ly_ctx_get_searchdirs(const struct ly_ctx *ctx)
116{
Radek Krejcif13b87b2020-12-01 22:02:17 +0100117#define LY_CTX_SEARCHDIRS_SIZE_STEP 8
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 */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100124 new = realloc(((struct ly_ctx *)ctx)->search_paths.objs,
125 (ctx->search_paths.size + LY_CTX_SEARCHDIRS_SIZE_STEP) * sizeof *ctx->search_paths.objs);
Radek Krejci05026432018-09-20 12:13:43 +0200126 LY_CHECK_ERR_RET(!new, LOGMEM(NULL), NULL);
Radek Krejcif13b87b2020-12-01 22:02:17 +0100127 ((struct ly_ctx *)ctx)->search_paths.size += LY_CTX_SEARCHDIRS_SIZE_STEP;
Radek Krejci05026432018-09-20 12:13:43 +0200128 ((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 Krejcie58f97f2020-08-18 11:45:08 +0200137ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200138{
Radek Krejcicd649072018-09-20 12:14:45 +0200139 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Radek Krejcicd649072018-09-20 12:14:45 +0200140
Michal Vaskob34480a2018-09-17 10:34:45 +0200141 if (!ctx->search_paths.count) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200142 return LY_SUCCESS;
143 }
144
Radek Krejci0759b792018-09-20 13:53:15 +0200145 if (value) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200146 /* remove specific search directory */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200147 uint32_t index;
148
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 Krejci1deb5be2020-08-26 16:43:36 +0200170ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count)
Radek Krejcied5acc52019-04-25 15:57:04 +0200171{
172 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
173
Radek Krejcie58f97f2020-08-18 11:45:08 +0200174 for ( ; count > 0 && ctx->search_paths.count; --count) {
175 LY_CHECK_RET(ly_set_rm_index(&ctx->search_paths, ctx->search_paths.count - 1, free))
Radek Krejcied5acc52019-04-25 15:57:04 +0200176 }
177
178 return LY_SUCCESS;
179}
180
181API const struct lys_module *
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100182ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision, const char **features)
Radek Krejcied5acc52019-04-25 15:57:04 +0200183{
184 struct lys_module *result = NULL;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100185 struct lys_glob_unres unres = {0};
186 LY_ERR ret = LY_SUCCESS;
Radek Krejcied5acc52019-04-25 15:57:04 +0200187
188 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
189
Michal Vasko405cc9e2020-12-01 12:01:27 +0100190 LY_CHECK_GOTO(ret = lysp_load_module(ctx, name, revision, 1, features, &unres, &result), cleanup);
191
192 /* resolve unres and revert, if needed */
193 LY_CHECK_GOTO(ret = lys_compile_unres_glob(ctx, &unres), cleanup);
194
195cleanup:
196 if (ret) {
197 lys_compile_unres_glob_revert(ctx, &unres);
198 result = NULL;
199 }
200 lys_compile_unres_glob_erase(ctx, &unres);
Radek Krejcied5acc52019-04-25 15:57:04 +0200201 return result;
202}
203
204API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200205ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200206{
207 struct ly_ctx *ctx = NULL;
208 struct lys_module *module;
209 char *search_dir_list;
210 char *sep, *dir;
Michal Vaskode79e222020-08-10 11:55:46 +0200211 uint32_t i;
Michal Vasko63f3d842020-07-08 10:10:14 +0200212 struct ly_in *in = NULL;
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200213 LY_ERR rc = LY_SUCCESS;
Michal Vasko405cc9e2020-12-01 12:01:27 +0100214 struct lys_glob_unres unres = {0};
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200215
Radek Krejcied5acc52019-04-25 15:57:04 +0200216 LY_CHECK_ARG_RET(NULL, new_ctx, LY_EINVAL);
217
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200218 ctx = calloc(1, sizeof *ctx);
Radek Krejciad573502018-09-07 15:26:55 +0200219 LY_CHECK_ERR_RET(!ctx, LOGMEM(NULL), LY_EMEM);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200220
221 /* dictionary */
222 lydict_init(&ctx->dict);
223
Radek Krejciad573502018-09-07 15:26:55 +0200224#if 0 /* TODO when plugins implemented */
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200225 /* plugins */
226 ly_load_plugins();
Radek Krejciad573502018-09-07 15:26:55 +0200227#endif
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200228
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100229 /* initialize thread-specific keys */
Radek Krejci1e008d22020-08-17 11:37:37 +0200230 while ((pthread_key_create(&ctx->errlist_key, ly_err_free)) == EAGAIN) {}
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200231
232 /* models list */
233 ctx->flags = options;
234 if (search_dir) {
235 search_dir_list = strdup(search_dir);
236 LY_CHECK_ERR_GOTO(!search_dir_list, LOGMEM(NULL); rc = LY_EMEM, error);
237
238 for (dir = search_dir_list; (sep = strchr(dir, ':')) != NULL && rc == LY_SUCCESS; dir = sep + 1) {
239 *sep = 0;
240 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200241 if (rc == LY_EEXIST) {
242 /* ignore duplication */
243 rc = LY_SUCCESS;
244 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200245 }
Michal Vasko69730152020-10-09 16:30:07 +0200246 if (*dir && (rc == LY_SUCCESS)) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200247 rc = ly_ctx_set_searchdir(ctx, dir);
Radek Krejci14946ab2018-09-20 13:42:06 +0200248 if (rc == LY_EEXIST) {
249 /* ignore duplication */
250 rc = LY_SUCCESS;
251 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200252 }
253 free(search_dir_list);
254
255 /* If ly_ctx_set_searchdir() failed, the error is already logged. Just exit */
256 if (rc != LY_SUCCESS) {
257 goto error;
258 }
259 }
260 ctx->module_set_id = 1;
261
Michal Vasko63f3d842020-07-08 10:10:14 +0200262 /* create dummy in */
263 rc = ly_in_new_memory(internal_modules[0].data, &in);
264 LY_CHECK_GOTO(rc, error);
265
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200266 /* load internal modules */
Michal Vasko25d6ad02020-10-22 12:20:22 +0200267 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 +0200268 ly_in_memory(in, internal_modules[i].data);
Michal Vasko7a0b0762020-09-02 16:37:01 +0200269 LY_CHECK_GOTO(rc = lys_create_module(ctx, in, internal_modules[i].format, internal_modules[i].implemented,
Michal Vasko405cc9e2020-12-01 12:01:27 +0100270 NULL, NULL, NULL, &unres, &module), error);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200271 }
272
Michal Vasko405cc9e2020-12-01 12:01:27 +0100273 /* resolve global unres */
274 LY_CHECK_GOTO(rc = lys_compile_unres_glob(ctx, &unres), error);
275
Michal Vasko63f3d842020-07-08 10:10:14 +0200276 ly_in_free(in, 0);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100277 lys_compile_unres_glob_erase(ctx, &unres);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200278 *new_ctx = ctx;
279 return rc;
280
281error:
Michal Vasko63f3d842020-07-08 10:10:14 +0200282 ly_in_free(in, 0);
Michal Vasko405cc9e2020-12-01 12:01:27 +0100283 lys_compile_unres_glob_erase(ctx, &unres);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200284 ly_ctx_destroy(ctx, NULL);
285 return rc;
286}
Radek Krejci0f969882020-08-21 16:56:47 +0200287
Radek Krejci1deb5be2020-08-26 16:43:36 +0200288API uint16_t
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200289ly_ctx_get_options(const struct ly_ctx *ctx)
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200290{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200291 LY_CHECK_ARG_RET(ctx, ctx, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200292 return ctx->flags;
293}
294
Radek Krejcica828d92018-09-20 14:19:43 +0200295API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200296ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200297{
298 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200299 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200300
301 /* set the option(s) */
302 ctx->flags |= option;
303
304 return LY_SUCCESS;
305}
306
307API LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200308ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option)
Radek Krejcica828d92018-09-20 14:19:43 +0200309{
310 LY_CHECK_ARG_RET(ctx, ctx, LY_EINVAL);
Michal Vasko25d6ad02020-10-22 12:20:22 +0200311 LY_CHECK_ERR_RET(option & LY_CTX_NO_YANGLIBRARY, LOGARG(ctx, option), LY_EINVAL);
Radek Krejcica828d92018-09-20 14:19:43 +0200312
313 /* unset the option(s) */
314 ctx->flags &= ~option;
315
316 return LY_SUCCESS;
317}
318
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200319API uint16_t
320ly_ctx_get_module_set_id(const struct ly_ctx *ctx)
321{
Radek Krejci3fbe89a2018-09-20 13:54:46 +0200322 LY_CHECK_ARG_RET(ctx, ctx, 0);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200323 return ctx->module_set_id;
324}
325
Radek Krejcid33273d2018-10-25 14:55:52 +0200326API void
327ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data)
328{
Michal Vaskod989ba02020-08-24 10:59:24 +0200329 LY_CHECK_ARG_RET(ctx, ctx, );
Radek Krejcid33273d2018-10-25 14:55:52 +0200330
331 ctx->imp_clb = clb;
332 ctx->imp_clb_data = user_data;
333}
334
335API ly_module_imp_clb
336ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data)
337{
338 LY_CHECK_ARG_RET(ctx, ctx, NULL);
339
340 if (user_data) {
341 *user_data = ctx->imp_clb_data;
342 }
343 return ctx->imp_clb;
344}
345
Radek Krejcied5acc52019-04-25 15:57:04 +0200346API const struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200347ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index)
Radek Krejcied5acc52019-04-25 15:57:04 +0200348{
349 LY_CHECK_ARG_RET(ctx, ctx, index, NULL);
350
Radek Krejci2390fb52019-04-30 13:27:43 +0200351 if (*index < (unsigned)ctx->list.count) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200352 return ctx->list.objs[(*index)++];
Radek Krejci2390fb52019-04-30 13:27:43 +0200353 } else {
354 return NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200355 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200356}
357
Radek Krejcib7db73a2018-10-24 14:18:40 +0200358/**
359 * @brief Iterate over the modules in the given context. Returned modules must match the given key at the offset of
360 * lysp_module and lysc_module structures (they are supposed to be placed at the same offset in both structures).
361 *
362 * @param[in] ctx Context where to iterate.
363 * @param[in] key Key value to search for.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200364 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100365 * @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 +0200366 * @param[in,out] Iterator to pass between the function calls. On the first call, the variable is supposed to be
367 * initiated to 0. After each call returning a module, the value is greater by 1 than the index of the returned
368 * module in the context.
369 * @return Module matching the given key, NULL if no such module found.
370 */
Radek Krejci0af46292019-01-11 16:02:31 +0100371static struct lys_module *
Radek Krejci1deb5be2020-08-26 16:43:36 +0200372ly_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 +0200373{
Radek Krejci0af46292019-01-11 16:02:31 +0100374 struct lys_module *mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200375 const char *value;
376
Michal Vaskod989ba02020-08-24 10:59:24 +0200377 for ( ; *index < ctx->list.count; ++(*index)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200378 mod = ctx->list.objs[*index];
Michal Vasko22df3f02020-08-24 13:29:22 +0200379 value = *(const char **)(((int8_t *)(mod)) + key_offset);
Michal Vasko69730152020-10-09 16:30:07 +0200380 if ((!key_size && !strcmp(key, value)) || (key_size && !strncmp(key, value, key_size) && (value[key_size] == '\0'))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200381 /* increment index for the next run */
382 ++(*index);
383 return mod;
384 }
385 }
386 /* done */
387 return NULL;
388}
389
390/**
391 * @brief Unifying function for ly_ctx_get_module() and ly_ctx_get_module_ns()
392 * @param[in] ctx Context where to search.
393 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100394 * @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 +0200395 * @param[in] revision Revision date to match. If NULL, the matching module must have no revision. To search for the latest
396 * revision module, use ly_ctx_get_module_latest_by().
397 * @return Matching module if any.
398 */
Radek Krejci0af46292019-01-11 16:02:31 +0100399static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200400ly_ctx_get_module_by(const struct ly_ctx *ctx, const char *key, size_t key_offset, const char *revision)
401{
Radek Krejci0af46292019-01-11 16:02:31 +0100402 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200403 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200404
Radek Krejci0ad51f12020-07-16 12:08:12 +0200405 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200406 if (!revision) {
Radek Krejci0af46292019-01-11 16:02:31 +0100407 if (!mod->revision) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200408 /* found requested module without revision */
409 return mod;
410 }
411 } else {
Radek Krejci0af46292019-01-11 16:02:31 +0100412 if (mod->revision && !strcmp(mod->revision, revision)) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200413 /* found requested module of the specific revision */
414 return mod;
415 }
416 }
417 }
418
419 return NULL;
420}
421
Radek Krejci0af46292019-01-11 16:02:31 +0100422API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200423ly_ctx_get_module_ns(const struct ly_ctx *ctx, const char *ns, const char *revision)
424{
425 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100426 return ly_ctx_get_module_by(ctx, ns, offsetof(struct lys_module, ns), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200427}
428
Radek Krejci0af46292019-01-11 16:02:31 +0100429API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200430ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision)
431{
432 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100433 return ly_ctx_get_module_by(ctx, name, offsetof(struct lys_module, name), revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200434}
435
436/**
437 * @brief Unifying function for ly_ctx_get_module_latest() and ly_ctx_get_module_latest_ns()
438 * @param[in] ctx Context where to search.
439 * @param[in] key Name or Namespace as a search key.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100440 * @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 +0200441 * @return Matching module if any.
442 */
Radek Krejci0af46292019-01-11 16:02:31 +0100443static struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200444ly_ctx_get_module_latest_by(const struct ly_ctx *ctx, const char *key, size_t key_offset)
445{
Radek Krejci0af46292019-01-11 16:02:31 +0100446 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200447 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200448
Radek Krejci0ad51f12020-07-16 12:08:12 +0200449 while ((mod = ly_ctx_get_module_by_iter(ctx, key, 0, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100450 if (mod->latest_revision) {
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200451 return mod;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200452 }
453 }
454
Radek Krejci9f5e6fb2018-10-25 09:26:12 +0200455 return NULL;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200456}
457
Radek Krejci0af46292019-01-11 16:02:31 +0100458API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200459ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name)
460{
461 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100462 return ly_ctx_get_module_latest_by(ctx, name, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200463}
464
Radek Krejci0af46292019-01-11 16:02:31 +0100465API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200466ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns)
467{
468 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100469 return ly_ctx_get_module_latest_by(ctx, ns, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200470}
471
472/**
473 * @brief Unifying function for ly_ctx_get_module_implemented() and ly_ctx_get_module_implemented_ns()
474 * @param[in] ctx Context where to search.
475 * @param[in] key Name or Namespace as a search key.
Radek Krejci0ad51f12020-07-16 12:08:12 +0200476 * @param[in] key_size Optional length of the @p key. If zero, NULL-terminated key is expected.
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100477 * @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 +0200478 * @return Matching module if any.
479 */
Radek Krejci0af46292019-01-11 16:02:31 +0100480static struct lys_module *
Radek Krejci0ad51f12020-07-16 12:08:12 +0200481ly_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 +0200482{
Radek Krejci0af46292019-01-11 16:02:31 +0100483 struct lys_module *mod;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200484 uint32_t index = 0;
Radek Krejcib7db73a2018-10-24 14:18:40 +0200485
Radek Krejci0ad51f12020-07-16 12:08:12 +0200486 while ((mod = ly_ctx_get_module_by_iter(ctx, key, key_size, key_offset, &index))) {
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100487 if (mod->implemented) {
Radek Krejcib7db73a2018-10-24 14:18:40 +0200488 return mod;
489 }
490 }
491
492 return NULL;
493}
494
Radek Krejci0af46292019-01-11 16:02:31 +0100495API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200496ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name)
497{
498 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200499 return ly_ctx_get_module_implemented_by(ctx, name, 0, offsetof(struct lys_module, name));
500}
501
502struct lys_module *
503ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len)
504{
505 LY_CHECK_ARG_RET(ctx, ctx, name, NULL);
506 return ly_ctx_get_module_implemented_by(ctx, name, name_len, offsetof(struct lys_module, name));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200507}
508
Radek Krejci0af46292019-01-11 16:02:31 +0100509API struct lys_module *
Radek Krejcib7db73a2018-10-24 14:18:40 +0200510ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns)
511{
512 LY_CHECK_ARG_RET(ctx, ctx, ns, NULL);
Radek Krejci0ad51f12020-07-16 12:08:12 +0200513 return ly_ctx_get_module_implemented_by(ctx, ns, 0, offsetof(struct lys_module, ns));
Radek Krejcib7db73a2018-10-24 14:18:40 +0200514}
515
Michal Vasko8dc31992021-02-22 10:30:47 +0100516/**
517 * @brief Try to find a submodule in a module.
518 *
519 * @param[in] module Module where to search in.
520 * @param[in] submodule Name of the submodule to find.
521 * @param[in] revision Revision of the submodule to find. NULL for submodule with no revision.
522 * @param[in] latest Ignore @p revision and look for the latest revision.
523 * @return Pointer to the specified submodule if it is present in the context.
524 */
525static const struct lysp_submodule *
526_ly_ctx_get_submodule2(const struct lys_module *module, const char *submodule, const char *revision, ly_bool latest)
Radek Krejcid33273d2018-10-25 14:55:52 +0200527{
Radek Krejcid33273d2018-10-25 14:55:52 +0200528 struct lysp_include *inc;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200529 LY_ARRAY_COUNT_TYPE u;
Radek Krejcid33273d2018-10-25 14:55:52 +0200530
Michal Vasko8dc31992021-02-22 10:30:47 +0100531 LY_CHECK_ARG_RET(NULL, module, module->parsed, submodule, NULL);
Michal Vaskoc3781c32020-10-06 14:04:08 +0200532
Michal Vasko8dc31992021-02-22 10:30:47 +0100533 LY_ARRAY_FOR(module->parsed->includes, u) {
534 if (module->parsed->includes[u].submodule && !strcmp(submodule, module->parsed->includes[u].submodule->name)) {
535 inc = &module->parsed->includes[u];
536
537 if (latest && inc->submodule->latest_revision) {
538 /* latest revision */
539 return inc->submodule;
540 } else if (!revision && !inc->submodule->revs) {
541 /* no revision */
542 return inc->submodule;
543 } else if (revision && inc->submodule->revs && !strcmp(revision, inc->submodule->revs[0].date)) {
544 /* specific revision */
545 return inc->submodule;
546 }
Michal Vaskoc3781c32020-10-06 14:04:08 +0200547 }
Michal Vaskoc3781c32020-10-06 14:04:08 +0200548 }
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100549
Michal Vasko8dc31992021-02-22 10:30:47 +0100550 return NULL;
551}
552
553/**
554 * @brief Try to find a submodule in the context.
555 *
556 * @param[in] ctx Context where to search in.
557 * @param[in] submodule Name of the submodule to find.
558 * @param[in] revision Revision of the submodule to find. NULL for submodule with no revision.
559 * @param[in] latest Ignore @p revision and look for the latest revision.
560 * @return Pointer to the specified submodule if it is present in the context.
561 */
562static const struct lysp_submodule *
563_ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision, ly_bool latest)
564{
565 const struct lys_module *mod;
566 const struct lysp_submodule *submod = NULL;
567 uint32_t v;
568
569 LY_CHECK_ARG_RET(ctx, ctx, submodule, NULL);
570
Radek Krejcifaa1eac2018-10-30 14:34:55 +0100571 for (v = 0; v < ctx->list.count; ++v) {
572 mod = ctx->list.objs[v];
Radek Krejcid33273d2018-10-25 14:55:52 +0200573 if (!mod->parsed) {
574 continue;
575 }
576
Michal Vasko8dc31992021-02-22 10:30:47 +0100577 submod = _ly_ctx_get_submodule2(mod, submodule, revision, latest);
578 if (submod) {
Michal Vaskoc3781c32020-10-06 14:04:08 +0200579 break;
580 }
Radek Krejcid33273d2018-10-25 14:55:52 +0200581 }
582
Michal Vasko8dc31992021-02-22 10:30:47 +0100583 return submod;
584}
585
586API const struct lysp_submodule *
587ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision)
588{
589 return _ly_ctx_get_submodule(ctx, submodule, revision, 0);
590}
591
592API const struct lysp_submodule *
593ly_ctx_get_submodule_latest(const struct ly_ctx *ctx, const char *submodule)
594{
595 return _ly_ctx_get_submodule(ctx, submodule, NULL, 1);
596}
597
598API const struct lysp_submodule *
599ly_ctx_get_submodule2(const struct lys_module *module, const char *submodule, const char *revision)
600{
601 return _ly_ctx_get_submodule2(module, submodule, revision, 0);
602}
603
604API const struct lysp_submodule *
605ly_ctx_get_submodule2_latest(const struct lys_module *module, const char *submodule)
606{
607 return _ly_ctx_get_submodule2(module, submodule, NULL, 1);
Radek Krejcid33273d2018-10-25 14:55:52 +0200608}
609
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200610API void
Radek Krejcie9e987e2018-10-31 12:50:27 +0100611ly_ctx_reset_latests(struct ly_ctx *ctx)
612{
Radek Krejcie9e987e2018-10-31 12:50:27 +0100613 struct lys_module *mod;
614
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200615 for (uint32_t v = 0; v < ctx->list.count; ++v) {
616 mod = ctx->list.objs[v];
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100617 if (mod->latest_revision == 2) {
618 mod->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100619 }
Radek Krejci0bcdaed2019-01-10 10:21:34 +0100620 if (mod->parsed && mod->parsed->includes) {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200621 for (LY_ARRAY_COUNT_TYPE u = 0; u < LY_ARRAY_COUNT(mod->parsed->includes); ++u) {
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200622 if (mod->parsed->includes[u].submodule->latest_revision == 2) {
623 mod->parsed->includes[u].submodule->latest_revision = 1;
Radek Krejcie9e987e2018-10-31 12:50:27 +0100624 }
625 }
626 }
627 }
628}
629
Michal Vaskode79e222020-08-10 11:55:46 +0200630API uint32_t
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100631ly_ctx_internal_modules_count(const struct ly_ctx *ctx)
Michal Vaskode79e222020-08-10 11:55:46 +0200632{
633 if (!ctx) {
634 return 0;
635 }
636
Michal Vasko25d6ad02020-10-22 12:20:22 +0200637 if (ctx->flags & LY_CTX_NO_YANGLIBRARY) {
Michal Vaskode79e222020-08-10 11:55:46 +0200638 return LY_INTERNAL_MODS_COUNT - 2;
639 } else {
640 return LY_INTERNAL_MODS_COUNT;
641 }
642}
643
Michal Vasko57c10cd2020-05-27 15:57:11 +0200644static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100645ylib_feature(struct lyd_node *parent, const struct lysp_module *pmod)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200646{
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100647 LY_ARRAY_COUNT_TYPE u;
648 struct lysp_feature *f;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200649
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100650 if (!pmod->mod->implemented) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200651 /* no features can be enabled */
652 return LY_SUCCESS;
653 }
654
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100655 LY_ARRAY_FOR(pmod->features, struct lysp_feature, f) {
656 if (!(f->flags & LYS_FENABLED)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200657 continue;
658 }
659
Radek Krejci41ac9942020-11-02 14:47:56 +0100660 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100661 }
662
663 LY_ARRAY_FOR(pmod->includes, u) {
664 LY_ARRAY_FOR(pmod->includes[u].submodule->features, struct lysp_feature, f) {
665 if (!(f->flags & LYS_FENABLED)) {
666 continue;
667 }
668
Radek Krejci41ac9942020-11-02 14:47:56 +0100669 LY_CHECK_RET(lyd_new_term(parent, NULL, "feature", f->name, 0, NULL));
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100670 }
Michal Vasko57c10cd2020-05-27 15:57:11 +0200671 }
672
673 return LY_SUCCESS;
674}
675
676static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200677ylib_deviation(struct lyd_node *parent, const struct lys_module *cur_mod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200678{
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200679 LY_ARRAY_COUNT_TYPE i;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200680 struct lys_module *mod;
681
682 if (!cur_mod->implemented) {
683 /* no deviations of the module for certain */
684 return LY_SUCCESS;
685 }
686
Michal Vasko7f45cf22020-10-01 12:49:44 +0200687 LY_ARRAY_FOR(cur_mod->deviated_by, i) {
688 mod = cur_mod->deviated_by[i];
Michal Vasko57c10cd2020-05-27 15:57:11 +0200689
690 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100691 LY_CHECK_RET(lyd_new_term(parent, NULL, "deviation", mod->name, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200692 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +0100693 LY_CHECK_RET(lyd_new_list(parent, NULL, "deviation", 0, NULL, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200694 (mod->parsed->revs ? mod->parsed->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200695 }
696 }
697
698 return LY_SUCCESS;
699}
700
701static LY_ERR
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100702ylib_submodules(struct lyd_node *parent, const struct lysp_module *pmod, ly_bool bis)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200703{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200704 LY_ERR ret;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200705 LY_ARRAY_COUNT_TYPE i;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200706 struct lyd_node *cont;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200707 struct lysp_submodule *submod;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200708 int r;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200709 char *str;
710
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100711 LY_ARRAY_FOR(pmod->includes, i) {
712 submod = pmod->includes[i].submodule;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200713
714 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100715 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200716
717 if (submod->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100718 LY_CHECK_RET(lyd_new_term(cont, NULL, "revision", submod->revs[0].date, 0, NULL));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200719 }
720 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +0100721 LY_CHECK_RET(lyd_new_list(parent, NULL, "submodule", 0, &cont, submod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200722 (submod->revs ? submod->revs[0].date : "")));
Michal Vasko57c10cd2020-05-27 15:57:11 +0200723 }
724
725 if (submod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200726 r = asprintf(&str, "file://%s", submod->filepath);
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100727 LY_CHECK_ERR_RET(r == -1, LOGMEM(pmod->mod->ctx), LY_EMEM);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200728
Radek Krejci41ac9942020-11-02 14:47:56 +0100729 ret = lyd_new_term(cont, NULL, bis ? "location" : "schema", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200730 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200731 LY_CHECK_RET(ret);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200732 }
733 }
734
735 return LY_SUCCESS;
736}
737
738API uint16_t
739ly_ctx_get_yanglib_id(const struct ly_ctx *ctx)
740{
741 return ctx->module_set_id;
742}
743
Michal Vasko3a41dff2020-07-15 14:30:28 +0200744API LY_ERR
745ly_ctx_get_yanglib_data(const struct ly_ctx *ctx, struct lyd_node **root_p)
Michal Vasko57c10cd2020-05-27 15:57:11 +0200746{
Michal Vasko3a41dff2020-07-15 14:30:28 +0200747 LY_ERR ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200748 uint32_t i;
Radek Krejci857189e2020-09-01 13:26:36 +0200749 ly_bool bis = 0;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200750 int r;
Radek Krejcif13b87b2020-12-01 22:02:17 +0100751 char *str;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200752 const struct lys_module *mod;
Michal Vasko3a41dff2020-07-15 14:30:28 +0200753 struct lyd_node *root = NULL, *root_bis = NULL, *cont, *set_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200754
Michal Vasko3a41dff2020-07-15 14:30:28 +0200755 LY_CHECK_ARG_RET(ctx, ctx, root_p, LY_EINVAL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200756
757 mod = ly_ctx_get_module_implemented(ctx, "ietf-yang-library");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200758 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 +0200759
760 if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, "2016-06-21")) {
761 bis = 0;
762 } else if (mod->parsed->revs && !strcmp(mod->parsed->revs[0].date, IETF_YANG_LIB_REV)) {
763 bis = 1;
764 } else {
765 LOGERR(ctx, LY_EINVAL, "Incompatible ietf-yang-library version in context.");
Michal Vasko3a41dff2020-07-15 14:30:28 +0200766 return LY_EINVAL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200767 }
768
Radek Krejci41ac9942020-11-02 14:47:56 +0100769 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "modules-state", 0, &root), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200770
771 if (bis) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100772 LY_CHECK_GOTO(ret = lyd_new_inner(NULL, mod, "yang-library", 0, &root_bis), error);
773 LY_CHECK_GOTO(ret = lyd_new_list(root_bis, NULL, "module-set", 0, &set_bis, "complete"), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200774 }
775
776 for (i = 0; i < ctx->list.count; ++i) {
777 mod = ctx->list.objs[i];
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100778 if (!mod->parsed) {
779 LOGERR(ctx, LY_ENOTFOUND, "Parsed module \"%s\" missing in the context.", mod->name);
780 goto error;
781 }
Michal Vasko57c10cd2020-05-27 15:57:11 +0200782
783 /*
784 * deprecated legacy
785 */
Radek Krejci41ac9942020-11-02 14:47:56 +0100786 LY_CHECK_GOTO(ret = lyd_new_list(root, NULL, "module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200787 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200788
789 /* schema */
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
Radek Krejci41ac9942020-11-02 14:47:56 +0100794 ret = lyd_new_term(cont, NULL, "schema", str, 0, 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 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +0100800 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200801
802 /* feature leaf-list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100803 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200804
805 /* deviation list */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200806 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200807
808 /* conformance-type */
Radek Krejci41ac9942020-11-02 14:47:56 +0100809 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "conformance-type", mod->implemented ? "implement" : "import", 0,
Michal Vasko69730152020-10-09 16:30:07 +0200810 NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200811
812 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100813 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 0), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200814
815 /*
816 * current revision
817 */
818 if (bis) {
819 /* name and revision */
820 if (mod->implemented) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100821 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "module", 0, &cont, mod->name), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200822
823 if (mod->parsed->revs) {
Radek Krejci41ac9942020-11-02 14:47:56 +0100824 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 +0200825 }
826 } else {
Radek Krejci41ac9942020-11-02 14:47:56 +0100827 LY_CHECK_GOTO(ret = lyd_new_list(set_bis, NULL, "import-only-module", 0, &cont, mod->name,
Radek Krejci0f969882020-08-21 16:56:47 +0200828 (mod->parsed->revs ? mod->parsed->revs[0].date : "")), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200829 }
830
831 /* namespace */
Radek Krejci41ac9942020-11-02 14:47:56 +0100832 LY_CHECK_GOTO(ret = lyd_new_term(cont, NULL, "namespace", mod->ns, 0, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200833
834 /* location */
835 if (mod->filepath) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200836 r = asprintf(&str, "file://%s", mod->filepath);
837 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200838
Radek Krejcid68ba1b2020-11-09 17:40:11 +0100839 ret = lyd_new_term(cont, NULL, "location", str, 0, NULL);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200840 free(str);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200841 LY_CHECK_GOTO(ret, error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200842 }
843
844 /* submodule list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100845 LY_CHECK_GOTO(ret = ylib_submodules(cont, mod->parsed, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200846
847 /* feature list */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100848 LY_CHECK_GOTO(ret = ylib_feature(cont, mod->parsed), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200849
850 /* deviation */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200851 LY_CHECK_GOTO(ret = ylib_deviation(cont, mod, 1), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200852 }
853 }
854
855 /* IDs */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100856 r = asprintf(&str, "%u", ctx->module_set_id);
857 LY_CHECK_ERR_GOTO(r == -1, LOGMEM(ctx); ret = LY_EMEM, error);
858 ret = lyd_new_term(root, NULL, "module-set-id", str, 0, NULL);
859 LY_CHECK_ERR_GOTO(ret, free(str), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200860
861 if (bis) {
862 /* create one complete schema */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100863 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 +0200864
Radek Krejcif13b87b2020-12-01 22:02:17 +0100865 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 +0200866
867 /* content-id */
Radek Krejcif13b87b2020-12-01 22:02:17 +0100868 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 +0200869 }
Radek Krejcif13b87b2020-12-01 22:02:17 +0100870 free(str);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200871
872 if (root_bis) {
Michal Vaskob104f112020-07-17 09:54:54 +0200873 if (lyd_insert_sibling(root, root_bis, &root)) {
Michal Vasko57c10cd2020-05-27 15:57:11 +0200874 goto error;
875 }
Michal Vaskob104f112020-07-17 09:54:54 +0200876 root_bis = NULL;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200877 }
878
Michal Vasko3a41dff2020-07-15 14:30:28 +0200879 LY_CHECK_GOTO(ret = lyd_validate_all(&root, NULL, LYD_VALIDATE_PRESENT, NULL), error);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200880
Michal Vasko3a41dff2020-07-15 14:30:28 +0200881 *root_p = root;
882 return LY_SUCCESS;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200883
884error:
885 lyd_free_all(root);
886 lyd_free_all(root_bis);
Michal Vasko3a41dff2020-07-15 14:30:28 +0200887 return ret;
Michal Vasko57c10cd2020-05-27 15:57:11 +0200888}
889
Radek Krejcie9e987e2018-10-31 12:50:27 +0100890API void
Radek Krejciad573502018-09-07 15:26:55 +0200891ly_ctx_destroy(struct ly_ctx *ctx, void (*private_destructor)(const struct lysc_node *node, void *priv))
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200892{
Radek Krejci418823a2018-09-20 16:42:13 +0200893 if (!ctx) {
894 return;
895 }
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200896
897 /* models list */
Michal Vaskod989ba02020-08-24 10:59:24 +0200898 for ( ; ctx->list.count; ctx->list.count--) {
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200899 /* remove the module */
Radek Krejci86d106e2018-10-18 09:53:19 +0200900 lys_module_free(ctx->list.objs[ctx->list.count - 1], private_destructor);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200901 }
902 free(ctx->list.objs);
903
904 /* search paths list */
Radek Krejcia40f21b2018-09-18 10:42:08 +0200905 ly_set_erase(&ctx->search_paths, free);
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200906
907 /* clean the error list */
908 ly_err_clean(ctx, 0);
909 pthread_key_delete(ctx->errlist_key);
910
Radek Krejci0af5f5d2018-09-07 15:00:30 +0200911 /* dictionary */
912 lydict_clean(&ctx->dict);
913
914#if 0 /* TODO when plugins implemented */
915 /* plugins - will be removed only if this is the last context */
916 ly_clean_plugins();
917#endif
918
919 free(ctx);
920}