blob: ec5ac3b48ac242f16ece9395feaa5210b613735b [file] [log] [blame]
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001/**
2 * @file context.h
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief internal context structures and functions
5 *
Michal Vasko25d6ad02020-10-22 12:20:22 +02006 * Copyright (c) 2015 - 2020 CESNET, z.s.p.o.
Radek Krejci5aeea3a2018-09-05 13:29:36 +02007 *
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 */
14
15#ifndef LY_CONTEXT_H_
16#define LY_CONTEXT_H_
17
Radek Krejcie7b95092019-05-15 11:03:07 +020018#include <stdint.h>
19
Radek Krejci6caa6ab2018-10-24 10:04:48 +020020#include "log.h"
Radek Krejcif0e1ba52020-05-22 15:14:35 +020021#include "parser_schema.h"
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +020022#include "tree_data.h"
Radek Krejci5aeea3a2018-09-05 13:29:36 +020023
Radek Krejci6caa6ab2018-10-24 10:04:48 +020024#ifdef __cplusplus
25extern "C" {
26#endif
27
Radek Krejci77114102021-03-10 15:21:57 +010028struct lys_module;
Radek Krejcica376bd2020-06-11 16:04:06 +020029
Radek Krejci5aeea3a2018-09-05 13:29:36 +020030/**
Radek Krejci8678fa42020-08-18 16:07:28 +020031 * @page howtoContext Context
Radek Krejci52785a22019-09-11 12:57:26 +020032 *
Radek Krejci8678fa42020-08-18 16:07:28 +020033 * The context concept allows callers to work in environments with different sets of YANG modules.
Radek Krejci52785a22019-09-11 12:57:26 +020034 *
Radek Krejci8678fa42020-08-18 16:07:28 +020035 * The first step with libyang is to create a new context using ::ly_ctx_new(). It returns a handler used in the following work.
36 * Note that the context is supposed to provide a stable environment for work with the data. Therefore the caller should prepare
Michal Vasko5a5e7f82021-04-15 11:11:03 +020037 * a complete context and after starting working with the data, the context and its content should not change. If it does,
38 * in most cases it leads to the context being recompiled and any parsed data invalid. Despite the API not enforcing this
39 * approach, it may change in future versions in the form of a locking mechanism which would allow further
Radek Krejci8678fa42020-08-18 16:07:28 +020040 * optimization of data manipulation. Also note that modules cannot be removed from their context. If you need to change the set
41 * of the schema modules in the context, the recommended way is to create a new context. To remove the context, there is ::ly_ctx_destroy() function.
Radek Krejci52785a22019-09-11 12:57:26 +020042 *
Radek Krejci8678fa42020-08-18 16:07:28 +020043 * The context has [several options](@ref contextoptions) changing behavior when processing YANG modules being inserted. The
44 * specific behavior is mentioned below. All the options can be set as a parameter when the context is being created or later
45 * with ::ly_ctx_set_options().
46 *
47 * When creating a new context, another optional parameter is search_dir It provide directory where libyang
48 * will automatically search for YANG modules being imported or included. There is actually a set of search paths which can be later
49 * modified using ::ly_ctx_set_searchdir(), ::ly_ctx_unset_searchdir() and ::ly_ctx_unset_searchdir_last() functions. Before the values
50 * in the set are used, also the current working directory is (non-recursively) searched. For the case of the explicitly set
51 * search directories, they are searched recursively - all their subdirectories (and symlinks) are taken into account. Searching
52 * in the current working directory can be avoided with the context's ::LY_CTX_DISABLE_SEARCHDIR_CWD option.
Radek Krejci52785a22019-09-11 12:57:26 +020053 * Searching in all the context's search dirs (without removing them) can be avoided with the context's
Radek Krejci8678fa42020-08-18 16:07:28 +020054 * ::LY_CTX_DISABLE_SEARCHDIRS option (or via ::ly_ctx_set_options()). This automatic searching can be preceded
55 * by a custom module searching callback (::ly_module_imp_clb) set via ::ly_ctx_set_module_imp_clb(). The algorithm of
56 * searching in search dirs is also available via API as ::lys_search_localfile() function.
Radek Krejci52785a22019-09-11 12:57:26 +020057 *
Radek Krejci8678fa42020-08-18 16:07:28 +020058 * YANG modules are added into the context using [parser functions](@ref howtoSchemaParsers) - \b lys_parse*().
59 * Alternatively, also ::ly_ctx_load_module() can be used - in that case the ::ly_module_imp_clb or automatic
60 * search in search directories and in the current working directory is used, as described above. YANG submodules cannot be loaded
61 * or even validated directly, they are loaded always only as includes of YANG modules. Explicitly parsed/loaded modules are
62 * handled as implemented - libyang is able to instantiate data representing such a module. The modules loaded implicitly, are
63 * not implemented and serve only as a source of grouping or typedef definitions. Context can hold multiple revisions of the same
64 * YANG module, but only one of them can be implemented. Details about the difference between implemented and imported modules
Michal Vasko25d6ad02020-10-22 12:20:22 +020065 * can be found on @ref howtoSchema page. This behavior can be changed with the context's ::LY_CTX_ALL_IMPLEMENTED option, which
66 * causes that all the parsed modules, whether loaded explicitly or implicitly, are set to be implemented. Note, that as
67 * a consequence of this option, only a single revision of any module can be present in the context in this case. Also, a less
68 * crude option ::LY_CTX_REF_IMPLEMENTED can be used to implement only referenced modules that should also be implemented.
Radek Krejci52785a22019-09-11 12:57:26 +020069 *
70 * When loading/importing a module without revision, the latest revision of the required module is supposed to load.
71 * For a context, the first time the latest revision of a module is requested, it is properly searched for and loaded.
72 * However, when this module is requested (without revision) the second time, the one found previously is returned.
Radek Krejci8678fa42020-08-18 16:07:28 +020073 * This has the advantage of not searching for the module repeatedly but there is a drawback in case the content of search
aPiecekd4911ee2021-07-30 07:40:24 +020074 * directories is updated and a later revision become available.
Radek Krejci52785a22019-09-11 12:57:26 +020075 *
Radek Krejci8678fa42020-08-18 16:07:28 +020076 * Context holds all the schema modules internally. To get a specific module, use ::ly_ctx_get_module() (or some of its
77 * variants). If you need to do something with all the modules in the context, it is advised to iterate over them using
78 * ::ly_ctx_get_module_iter(). Alternatively, the ::ly_ctx_get_yanglib_data() function can be used to get complex information about the schemas in the context
79 * in the form of data tree defined by <a href="https://tools.ietf.org/html/rfc7895">ietf-yang-library</a> module.
Radek Krejci52785a22019-09-11 12:57:26 +020080 *
Radek Krejci8678fa42020-08-18 16:07:28 +020081 * YANG data can be parsed by \b lyd_parse_*() functions. Note, that functions for schema have \b lys_
82 * prefix (or \b lysp_ for the parsed and \b lysc_ for the compiled schema - for details see @ref howtoSchema page) while
83 * functions for instance data have \b lyd_ prefix. Details about data formats or handling data without the appropriate
84 * YANG module in context can be found on @ref howtoData page.
Radek Krejci52785a22019-09-11 12:57:26 +020085 *
Radek Krejci8678fa42020-08-18 16:07:28 +020086 * Besides the YANG modules, context holds also [error information](@ref howtoErrors) and
87 * [database of strings](@ref howtoContextDict), both connected with the processed YANG modules and data.
88 *
89 * - @subpage howtoErrors
90 * - @subpage howtoContextDict
Radek Krejci52785a22019-09-11 12:57:26 +020091 *
92 * \note API for this group of functions is available in the [context module](@ref context).
93 *
94 * Functions List
95 * --------------
Radek Krejci8678fa42020-08-18 16:07:28 +020096 *
Radek Krejci52785a22019-09-11 12:57:26 +020097 * - ::ly_ctx_new()
Radek Krejci8678fa42020-08-18 16:07:28 +020098 * - ::ly_ctx_destroy()
99 *
Radek Krejci52785a22019-09-11 12:57:26 +0200100 * - ::ly_ctx_set_searchdir()
Radek Krejci52785a22019-09-11 12:57:26 +0200101 * - ::ly_ctx_get_searchdirs()
Radek Krejci8678fa42020-08-18 16:07:28 +0200102 * - ::ly_ctx_unset_searchdir()
103 * - ::ly_ctx_unset_searchdir_last()
104 *
105 * - ::ly_ctx_set_options()
106 * - ::ly_ctx_get_options()
107 * - ::ly_ctx_unset_options()
108 *
Radek Krejci52785a22019-09-11 12:57:26 +0200109 * - ::ly_ctx_set_module_imp_clb()
110 * - ::ly_ctx_get_module_imp_clb()
Radek Krejci8678fa42020-08-18 16:07:28 +0200111 *
Radek Krejci52785a22019-09-11 12:57:26 +0200112 * - ::ly_ctx_load_module()
Radek Krejci52785a22019-09-11 12:57:26 +0200113 * - ::ly_ctx_get_module_iter()
114 * - ::ly_ctx_get_module()
115 * - ::ly_ctx_get_module_ns()
116 * - ::ly_ctx_get_module_implemented()
117 * - ::ly_ctx_get_module_implemented_ns()
118 * - ::ly_ctx_get_module_latest()
119 * - ::ly_ctx_get_module_latest_ns()
Michal Vasko8dc31992021-02-22 10:30:47 +0100120 * - ::ly_ctx_get_submodule()
121 * - ::ly_ctx_get_submodule_latest()
122 * - ::ly_ctx_get_submodule2()
123 * - ::ly_ctx_get_submodule2_latest()
Radek Krejci52785a22019-09-11 12:57:26 +0200124 * - ::ly_ctx_reset_latests()
Radek Krejci8678fa42020-08-18 16:07:28 +0200125 *
126 * - ::ly_ctx_get_yanglib_data()
Radek Krejci8678fa42020-08-18 16:07:28 +0200127 *
Michal Vasko794ab4b2021-03-31 09:42:19 +0200128 * - ::ly_ctx_get_change_count()
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100129 * - ::ly_ctx_internal_modules_count()
Radek Krejci8678fa42020-08-18 16:07:28 +0200130 *
Radek Krejci52785a22019-09-11 12:57:26 +0200131 * - ::lys_search_localfile()
Radek Krejci8678fa42020-08-18 16:07:28 +0200132 * - ::lys_set_implemented()
133 *
134 */
135
136/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200137 * @defgroup context Context
138 * @{
139 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200140 * Structures and functions to manipulate with the libyang context containers.
141 *
142 * The \em context concept allows callers to work in environments with different sets of YANG schemas.
143 * More detailed information can be found at @ref howtoContext page.
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200144 */
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200145
146/**
147 * @struct ly_ctx
148 * @brief libyang context handler.
149 */
150struct ly_ctx;
151
152/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200153 * @ingroup context
Radek Krejci8678fa42020-08-18 16:07:28 +0200154 * @defgroup contextoptions Context options
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200155 *
156 * Options to change context behavior.
Radek Krejci474f9b82019-07-24 11:36:37 +0200157 *
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200158 * @{
159 */
160
Michal Vasko25d6ad02020-10-22 12:20:22 +0200161#define LY_CTX_ALL_IMPLEMENTED 0x01 /**< All the imported modules of the schema being parsed are implemented. */
162#define LY_CTX_REF_IMPLEMENTED 0x02 /**< Implement all imported modules "referenced" from an implemented module.
163 Normally, leafrefs, augment and deviation targets are implemented as
164 specified by YANG 1.1. In addition to this, implement any modules of
165 nodes referenced by when and must conditions and by any default values.
166 Generally, only if all these modules are implemented, the explicitly
167 implemented modules can be properly used and instantiated in data. */
168#define LY_CTX_NO_YANGLIBRARY 0x04 /**< Do not internally implement ietf-yang-library module. The option
Radek Krejci8678fa42020-08-18 16:07:28 +0200169 causes that function ::ly_ctx_get_yanglib_data() does not work (returns ::LY_EINVAL) until
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200170 the ietf-yang-library module is loaded manually. While any revision
171 of this schema can be loaded with this option, note that the only
Radek Krejci8678fa42020-08-18 16:07:28 +0200172 revisions implemented by ::ly_ctx_get_yanglib_data() are 2016-06-21 and 2019-01-04.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200173 This option cannot be changed on existing context. */
174#define LY_CTX_DISABLE_SEARCHDIRS 0x08 /**< Do not search for schemas in context's searchdirs neither in current
175 working directory. It is entirely skipped and the only way to get
Radek Krejci8678fa42020-08-18 16:07:28 +0200176 schema data for imports or for ::ly_ctx_load_module() is to use the
177 callbacks provided by caller via ::ly_ctx_set_module_imp_clb() */
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200178#define LY_CTX_DISABLE_SEARCHDIR_CWD 0x10 /**< Do not automatically search for schemas in current working
179 directory, which is by default searched automatically (despite not
180 recursively). */
181#define LY_CTX_PREFER_SEARCHDIRS 0x20 /**< When searching for schema, prefer searchdirs instead of user callback. */
aPiecek9922ea92021-04-12 07:59:20 +0200182#define LY_CTX_SET_PRIV_PARSED 0x40 /**< For all compiled nodes, their private objects (::lysc_node.priv) are used
183 by libyang as a reference to the corresponding parsed node (::lysp_node).
aPiecekb0445f22021-06-24 11:34:07 +0200184 The exception are \"case\" statements, which are omitted (shorthand),
aPiecek082c7dc2021-05-20 08:55:07 +0200185 in that case the private objects are set to NULL.
aPiecek9922ea92021-04-12 07:59:20 +0200186 So if this option is set, the user must not change private objects.
187 Setting this option by ::ly_ctx_set_options() may result in context recompilation.
188 Resetting this option by ::ly_ctx_unset_options() cause that private
189 objects will be set to NULL. */
Michal Vasko01db7de2021-04-16 12:23:30 +0200190#define LY_CTX_EXPLICIT_COMPILE 0x80 /**< If this flag is set, the compiled modules and their schema nodes are
191 not automatically updated (compiled) on any context changes. In other words, they do
192 not immediately take effect. To do that, call ::ly_ctx_compile(). Changes
193 requiring compilation include adding new modules, changing their features,
194 and implementing parsed-only modules. This option allows efficient compiled
195 context creation without redundant recompilations. */
Michal Vaskoc56d6372021-10-19 12:29:00 +0200196#define LY_CTX_ENABLE_IMP_FEATURES 0x0100 /**< By default, all features of newly implemented imported modules of
197 a module that is being loaded are disabled. With this flag they all become
198 enabled. */
Radek Krejci0af46292019-01-11 16:02:31 +0100199
Michal Vaskob36053d2020-03-26 15:49:30 +0100200/** @} contextoptions */
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200201
202/**
203 * @brief Create libyang context.
204 *
205 * Context is used to hold all information about schemas. Usually, the application is supposed
206 * to work with a single context in which libyang is holding all schemas (and other internal
207 * information) according to which the data trees will be processed and validated. So, the schema
208 * trees are tightly connected with the specific context and they are held by the context internally
Radek Krejci8678fa42020-08-18 16:07:28 +0200209 * - caller does not need to keep pointers to the schemas returned by ::lys_parse(), context knows
210 * about them. The data trees created with \b lyd_parse_*() are still connected with the specific context,
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200211 * but they are not internally held by the context. The data tree just points and lean on some data
212 * held by the context (schema tree, string dictionary, etc.). Therefore, in case of data trees, caller
Radek Krejci8678fa42020-08-18 16:07:28 +0200213 * is supposed to keep pointers returned by the \b lyd_parse_*() functions and manage the data tree on its own. This
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200214 * also affects the number of instances of both tree types. While you can have only one instance of
215 * specific schema connected with a single context, number of data tree instances is not connected.
216 *
Jan Kundrát34bb9282021-12-13 18:45:50 +0100217 * @param[in] search_dir Directory (or directories) where libyang will search for the imported or included modules
218 * and submodules. If no such directory is available, NULL is accepted. Several directories can be specified,
219 * delimited by colon ":" (on Windows, use semicolon ";" instead).
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200220 * @param[in] options Context options, see @ref contextoptions.
221 * @param[out] new_ctx Pointer to the created libyang context if LY_SUCCESS returned.
222 * @return LY_ERR return value.
223 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100224LIBYANG_API_DECL LY_ERR ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200225
226/**
Michal Vaskoddd76592022-01-17 13:34:48 +0100227 * @brief Create libyang context according to the provided yang-library data in a file.
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200228 *
229 * This function loads the yang-library data from the given path. If you need to pass the data as
230 * string, use ::::ly_ctx_new_ylmem(). Both functions extend functionality of ::ly_ctx_new() by loading
231 * modules specified in the ietf-yang-library form into the context being created.
232 * The preferred tree model revision is 2019-01-04. However, only the first module-set is processed and loaded
233 * into the context. If there are no matching nodes from this tree, the legacy tree (originally from model revision 2016-04-09)
234 * is processed. Note, that the modules are loaded the same way as in case of ::ly_ctx_load_module(), so the schema paths in the
235 * yang-library data are ignored and the modules are loaded from the context's search locations. On the other hand, YANG features
236 * of the modules are set as specified in the yang-library data.
237 * To get yang library data from a libyang context, use ::ly_ctx_get_yanglib_data().
238 *
239 * @param[in] search_dir Directory where libyang will search for the imported or included modules and submodules.
240 * If no such directory is available, NULL is accepted.
241 * @param[in] path Path to the file containing yang-library-data in the specified format
242 * @param[in] format Format of the data in the provided file.
243 * @param[in] options Context options, see @ref contextoptions.
ekinzie0ab8b302022-10-10 03:03:57 -0400244 * @param[in,out] ctx If *ctx is not NULL, the existing libyang context is modified. Otherwise, a pointer to a
245 * newly created context is returned here if LY_SUCCESS.
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200246 * @return LY_ERR return value
247 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100248LIBYANG_API_DECL LY_ERR ly_ctx_new_ylpath(const char *search_dir, const char *path, LYD_FORMAT format, int options,
249 struct ly_ctx **ctx);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200250
251/**
Michal Vaskoddd76592022-01-17 13:34:48 +0100252 * @brief Create libyang context according to the provided yang-library data in a string.
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200253 *
Michal Vaskoddd76592022-01-17 13:34:48 +0100254 * Details in ::ly_ctx_new_ylpath().
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200255 *
256 * @param[in] search_dir Directory where libyang will search for the imported or included modules and submodules.
257 * If no such directory is available, NULL is accepted.
258 * @param[in] data String containing yang-library data in the specified format.
259 * @param[in] format Format of the data in the provided file.
260 * @param[in] options Context options, see @ref contextoptions.
ekinzie0ab8b302022-10-10 03:03:57 -0400261 * @param[in,out] ctx If *ctx is not NULL, the existing libyang context is modified. Otherwise, a pointer to a
262 * newly created context is returned here if LY_SUCCESS.
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200263 * @return LY_ERR return value
264 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100265LIBYANG_API_DECL LY_ERR ly_ctx_new_ylmem(const char *search_dir, const char *data, LYD_FORMAT format, int options,
266 struct ly_ctx **ctx);
267
268/**
269 * @brief Create libyang context according to the provided yang-library data in a data tree.
270 *
271 * Details in ::ly_ctx_new_ylpath().
272 *
273 * @param[in] search_dir Directory where libyang will search for the imported or included modules and submodules.
274 * If no such directory is available, NULL is accepted.
275 * @param[in] tree Data tree containing yang-library data.
276 * @param[in] options Context options, see @ref contextoptions.
ekinzie0ab8b302022-10-10 03:03:57 -0400277 * @param[in,out] ctx If *ctx is not NULL, the existing libyang context is modified. Otherwise, a pointer to a
278 * newly created context is returned here if LY_SUCCESS.
Michal Vaskoddd76592022-01-17 13:34:48 +0100279 * @return LY_ERR return value
280 */
281LIBYANG_API_DECL LY_ERR ly_ctx_new_yldata(const char *search_dir, const struct lyd_node *tree, int options,
282 struct ly_ctx **ctx);
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200283
284/**
Michal Vasko01db7de2021-04-16 12:23:30 +0200285 * @brief Compile (recompile) the context applying all the performed changes after the last context compilation.
286 * Should be used only if ::LY_CTX_EXPLICIT_COMPILE option is set, has no effect otherwise.
287 *
288 * @param[in] ctx Context to compile.
289 * @return LY_ERR return value.
290 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100291LIBYANG_API_DECL LY_ERR ly_ctx_compile(struct ly_ctx *ctx);
Michal Vasko01db7de2021-04-16 12:23:30 +0200292
293/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200294 * @brief Add the search path into libyang context
295 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200296 * To reset search paths set in the context, use ::ly_ctx_unset_searchdir() and then
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200297 * set search paths again.
298 *
299 * @param[in] ctx Context to be modified.
300 * @param[in] search_dir New search path to add to the current paths previously set in ctx.
301 * @return LY_ERR return value.
302 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100303LIBYANG_API_DECL LY_ERR ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200304
305/**
306 * @brief Clean the search path(s) from the libyang context
307 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200308 * To remove the recently added search path(s), use ::ly_ctx_unset_searchdir_last().
Radek Krejcied5acc52019-04-25 15:57:04 +0200309 *
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200310 * @param[in] ctx Context to be modified.
311 * @param[in] value Searchdir to be removed, use NULL to remove them all.
312 * @return LY_ERR return value
313 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100314LIBYANG_API_DECL LY_ERR ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200315
316/**
Radek Krejcie58f97f2020-08-18 11:45:08 +0200317 * @brief Remove the least recently added search path(s) from the libyang context.
Radek Krejcied5acc52019-04-25 15:57:04 +0200318 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200319 * To remove a specific search path by its value, use ::ly_ctx_unset_searchdir().
Radek Krejcied5acc52019-04-25 15:57:04 +0200320 *
321 * @param[in] ctx Context to be modified.
Radek Krejcie58f97f2020-08-18 11:45:08 +0200322 * @param[in] count Number of the searchdirs to be removed (starting by the least recently added).
323 * If the value is higher then the actual number of search paths, all paths are removed and no error is returned.
324 * Value 0 does not change the search path set.
Radek Krejcied5acc52019-04-25 15:57:04 +0200325 * @return LY_ERR return value
326 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100327LIBYANG_API_DECL LY_ERR ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count);
Radek Krejcied5acc52019-04-25 15:57:04 +0200328
329/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200330 * @brief Get the NULL-terminated list of the search paths in libyang context. Do not modify the result!
331 *
332 * @param[in] ctx Context to query.
333 * @return NULL-terminated list (array) of the search paths, NULL if no searchpath was set.
334 * Do not modify the provided data in any way!
335 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100336LIBYANG_API_DECL const char * const *ly_ctx_get_searchdirs(const struct ly_ctx *ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200337
338/**
339 * @brief Get the currently set context's options.
340 *
341 * @param[in] ctx Context to query.
342 * @return Combination of all the currently set context's options, see @ref contextoptions.
343 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100344LIBYANG_API_DECL uint16_t ly_ctx_get_options(const struct ly_ctx *ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200345
346/**
347 * @brief Set some of the context's options, see @ref contextoptions.
348 * @param[in] ctx Context to be modified.
349 * @param[in] option Combination of the context's options to be set, see @ref contextoptions.
aPiecek9922ea92021-04-12 07:59:20 +0200350 * If there is to be a change to ::LY_CTX_SET_PRIV_PARSED, the context will be recompiled
351 * and all ::lysc_node.priv in the modules will be overwritten, see ::LY_CTX_SET_PRIV_PARSED.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200352 * @return LY_ERR value.
353 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100354LIBYANG_API_DECL LY_ERR ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200355
356/**
357 * @brief Unset some of the context's options, see @ref contextoptions.
358 * @param[in] ctx Context to be modified.
359 * @param[in] option Combination of the context's options to be unset, see @ref contextoptions.
360 * @return LY_ERR value.
361 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100362LIBYANG_API_DECL LY_ERR ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200363
364/**
Michal Vasko794ab4b2021-03-31 09:42:19 +0200365 * @brief Get the change count of the context (module set) during its life-time.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200366 *
367 * @param[in] ctx Context to be examined.
Michal Vasko794ab4b2021-03-31 09:42:19 +0200368 * @return Context change count.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200369 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100370LIBYANG_API_DECL uint16_t ly_ctx_get_change_count(const struct ly_ctx *ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200371
372/**
Michal Vaskof9943e42023-03-22 07:29:37 +0100373 * @brief Get the hash of all the modules in the context with their revision. Since order of the modules is significant,
374 * even when 2 contexts have the same modules but loaded in a different order, the hash will differ.
375 *
376 * @param[in] ctx Context to be examined.
377 * @return Context modules hash.
378 */
379LIBYANG_API_DECL uint32_t ly_ctx_get_modules_hash(const struct ly_ctx *ctx);
380
381/**
Michal Vaskob2786d72020-08-24 13:19:52 +0200382 * @brief Callback for freeing returned module data in #ly_module_imp_clb.
383 *
384 * @param[in] module_data Data to free.
385 * @param[in] user_data User-supplied callback data, same as for #ly_module_imp_clb.
386 */
387typedef void (*ly_module_imp_data_free_clb)(void *module_data, void *user_data);
388
389/**
Radek Krejcid33273d2018-10-25 14:55:52 +0200390 * @brief Callback for retrieving missing included or imported models in a custom way.
391 *
Radek Krejcibb9d2242021-01-04 10:51:31 +0100392 * When @p submod_name is provided, the submodule is requested instead of the module (in this case only
Radek Krejcid33273d2018-10-25 14:55:52 +0200393 * the module name without its revision is provided).
394 *
395 * If an @arg free_module_data callback is provided, it will be used later to free the allegedly const data
396 * which were returned by this callback.
397 *
398 * @param[in] mod_name Missing module name.
Radek Krejci086c7132018-10-26 15:29:04 +0200399 * @param[in] mod_rev Optional missing module revision. If NULL and submod_name is not provided, the latest revision is
400 * requested, the parsed module is then marked by the latest_revision flag.
Radek Krejcid33273d2018-10-25 14:55:52 +0200401 * @param[in] submod_name Optional missing submodule name.
Radek Krejci086c7132018-10-26 15:29:04 +0200402 * @param[in] submod_rev Optional missing submodule revision. If NULL and submod_name is provided, the latest revision is
403 * requested, the parsed submodule is then marked by the latest_revision flag.
Radek Krejcid33273d2018-10-25 14:55:52 +0200404 * @param[in] user_data User-supplied callback data.
405 * @param[out] format Format of the returned module data.
406 * @param[out] module_data Requested module data.
407 * @param[out] free_module_data Callback for freeing the returned module data. If not set, the data will be left untouched.
408 * @return LY_ERR value. If the returned value differs from LY_SUCCESS, libyang continue in trying to get the module data
409 * according to the settings of its mechanism to search for the imported/included schemas.
410 */
Radek Krejcibb9d2242021-01-04 10:51:31 +0100411typedef LY_ERR (*ly_module_imp_clb)(const char *mod_name, const char *mod_rev, const char *submod_name, const char *submod_rev,
Michal Vaskob2786d72020-08-24 13:19:52 +0200412 void *user_data, LYS_INFORMAT *format, const char **module_data, ly_module_imp_data_free_clb *free_module_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200413
414/**
415 * @brief Get the custom callback for missing import/include module retrieval.
416 *
417 * @param[in] ctx Context to read from.
418 * @param[in] user_data Optional pointer for getting the user-supplied callback data.
419 * @return Callback or NULL if not set.
420 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100421LIBYANG_API_DECL ly_module_imp_clb ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200422
423/**
424 * @brief Set missing include or import module callback. It is meant to be used when the models
425 * are not locally available (such as when downloading modules from a NETCONF server), it should
426 * not be required in other cases.
427 *
428 * @param[in] ctx Context that will use this callback.
429 * @param[in] clb Callback responsible for returning the missing model.
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100430 * @param[in] user_data Arbitrary data that will always be passed to the callback @p clb.
Radek Krejcid33273d2018-10-25 14:55:52 +0200431 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100432LIBYANG_API_DECL void ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200433
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100434/**
435 * @brief Callback for getting arbitrary run-time data required by an extension instance.
436 *
437 * @param[in] ext Compiled extension instance.
438 * @param[in] user_data User-supplied callback data.
439 * @param[out] ext_data Provided extension instance data.
440 * @param[out] ext_data_free Whether the extension instance should free @p ext_data or not.
441 * @return LY_ERR value.
442 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100443typedef LY_ERR (*ly_ext_data_clb)(const struct lysc_ext_instance *ext, void *user_data, void **ext_data,
444 ly_bool *ext_data_free);
445
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100446/**
447 * @brief Set callback providing run-time extension instance data. The expected data depend on the extension.
448 * Data expected by internal extensions:
449 *
450 * - *ietf-yang-schema-mount:mount-point* (struct lyd_node \*\*ext_data)\n
451 * Operational data tree with at least `ietf-yang-library` data describing the mounted schema and
452 * `ietf-yang-schema-mount` **validated** data describing the specific mount point
453 * ([ref](https://datatracker.ietf.org/doc/html/rfc8528#section-3.3)).
454 *
455 * @param[in] ctx Context that will use this callback.
456 * @param[in] clb Callback responsible for returning the extension instance data.
457 * @param[in] user_data Arbitrary data that will always be passed to the callback @p clb.
458 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100459LIBYANG_API_DECL ly_ext_data_clb ly_ctx_set_ext_data_clb(struct ly_ctx *ctx, ly_ext_data_clb clb, void *user_data);
460
Radek Krejcid33273d2018-10-25 14:55:52 +0200461/**
Radek Krejcib7db73a2018-10-24 14:18:40 +0200462 * @brief Get YANG module of the given name and revision.
463 *
464 * @param[in] ctx Context to work in.
465 * @param[in] name Name of the YANG module to get.
466 * @param[in] revision Requested revision date of the YANG module to get. If not specified,
467 * the schema with no revision is returned, if it is present in the context.
468 * @return Pointer to the YANG module, NULL if no schema in the context follows the name and revision requirements.
469 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100470LIBYANG_API_DECL struct lys_module *ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200471
472/**
473 * @brief Get the latest revision of the YANG module specified by its name.
474 *
475 * YANG modules with no revision are supposed to be the oldest one.
476 *
477 * @param[in] ctx Context where to search.
478 * @param[in] name Name of the YANG module to get.
479 * @return The latest revision of the specified YANG module in the given context, NULL if no YANG module of the
480 * given name is present in the context.
481 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100482LIBYANG_API_DECL struct lys_module *ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200483
484/**
485 * @brief Get the (only) implemented YANG module specified by its name.
486 *
487 * @param[in] ctx Context where to search.
488 * @param[in] name Name of the YANG module to get.
489 * @return The only implemented YANG module revision of the given name in the given context. NULL if there is no
490 * implemented module of the given name.
491 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100492LIBYANG_API_DECL struct lys_module *ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200493
494/**
Radek Krejcied5acc52019-04-25 15:57:04 +0200495 * @brief Iterate over all modules in the given context.
496 *
497 * @param[in] ctx Context with the modules.
498 * @param[in,out] index Index of the next module to get. Value of 0 starts from the beginning.
499 * The value is updated with each call, so to iterate over all modules the same variable is supposed
500 * to be used in all calls starting with value 0.
501 * @return Next context module, NULL if the last was already returned.
502 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100503LIBYANG_API_DECL struct lys_module *ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index);
Radek Krejcied5acc52019-04-25 15:57:04 +0200504
505/**
Radek Krejcib7db73a2018-10-24 14:18:40 +0200506 * @brief Get YANG module of the given namespace and revision.
507 *
508 * @param[in] ctx Context to work in.
509 * @param[in] ns Namespace of the YANG module to get.
510 * @param[in] revision Requested revision date of the YANG module to get. If not specified,
511 * the schema with no revision is returned, if it is present in the context.
512 * @return Pointer to the YANG module, NULL if no schema in the context follows the namespace and revision requirements.
513 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100514LIBYANG_API_DECL struct lys_module *ly_ctx_get_module_ns(const struct ly_ctx *ctx, const char *ns, const char *revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200515
516/**
517 * @brief Get the latest revision of the YANG module specified by its namespace.
518 *
519 * YANG modules with no revision are supposed to be the oldest one.
520 *
521 * @param[in] ctx Context where to search.
522 * @param[in] ns Namespace of the YANG module to get.
523 * @return The latest revision of the specified YANG module in the given context, NULL if no YANG module of the
524 * given namespace is present in the context.
525 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100526LIBYANG_API_DECL struct lys_module *ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200527
528/**
529 * @brief Get the (only) implemented YANG module specified by its namespace.
530 *
531 * @param[in] ctx Context where to search.
532 * @param[in] ns Namespace of the YANG module to get.
533 * @return The only implemented YANG module revision of the given namespace in the given context. NULL if there is no
534 * implemented module of the given namespace.
535 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100536LIBYANG_API_DECL struct lys_module *ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200537
538/**
Michal Vasko8dc31992021-02-22 10:30:47 +0100539 * @brief Get a specific submodule from context. If its belongs-to module is known, use ::ly_ctx_get_submodule2().
540 *
541 * @param[in] ctx libyang context to search in.
542 * @param[in] submodule Submodule name to find.
543 * @param[in] revision Revision of the submodule to find, NULL for a submodule without a revision.
544 * @return Found submodule, NULL if there is none.
545 */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100546LIBYANG_API_DECL const struct lysp_submodule *ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule,
547 const char *revision);
Michal Vasko8dc31992021-02-22 10:30:47 +0100548
549/**
550 * @brief Get the latests revision of a submodule from context. If its belongs-to module is known,
551 * use ::ly_ctx_get_submodule2_latest().
552 *
553 * @param[in] ctx libyang context to search in.
554 * @param[in] submodule Submodule name to find.
555 * @return Found submodule, NULL if there is none.
556 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100557LIBYANG_API_DECL const struct lysp_submodule *ly_ctx_get_submodule_latest(const struct ly_ctx *ctx, const char *submodule);
Michal Vasko8dc31992021-02-22 10:30:47 +0100558
559/**
560 * @brief Get a specific submodule from a module. If the belongs-to module is not known, use ::ly_ctx_get_submodule().
561 *
562 * @param[in] module Belongs-to module to search in.
563 * @param[in] submodule Submodule name to find.
564 * @param[in] revision Revision of the submodule to find, NULL for a submodule without a revision.
565 * @return Found submodule, NULL if there is none.
566 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100567LIBYANG_API_DECL const struct lysp_submodule *ly_ctx_get_submodule2(const struct lys_module *module, const char *submodule,
Michal Vasko8dc31992021-02-22 10:30:47 +0100568 const char *revision);
569
570/**
571 * @brief Get the latest revision of a submodule from a module. If the belongs-to module is not known,
572 * use ::ly_ctx_get_submodule_latest().
573 *
574 * @param[in] module Belongs-to module to search in.
575 * @param[in] submodule Submodule name to find.
576 * @return Found submodule, NULL if there is none.
577 */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100578LIBYANG_API_DECL const struct lysp_submodule *ly_ctx_get_submodule2_latest(const struct lys_module *module,
579 const char *submodule);
Michal Vasko8dc31992021-02-22 10:30:47 +0100580
581/**
Radek Krejcie9e987e2018-10-31 12:50:27 +0100582 * @brief Reset cached latest revision information of the schemas in the context.
583 *
aPiecekd4911ee2021-07-30 07:40:24 +0200584 * This function is deprecated and should not be used.
585 *
Radek Krejcie9e987e2018-10-31 12:50:27 +0100586 * When a (sub)module is imported/included without revision, the latest revision is
587 * searched. libyang searches for the latest revision in searchdirs and/or via provided
Radek Krejci8678fa42020-08-18 16:07:28 +0200588 * import callback ::ly_module_imp_clb() just once. Then it is expected that the content
Radek Krejcie9e987e2018-10-31 12:50:27 +0100589 * of searchdirs or data returned by the callback does not change. So when it changes,
590 * it is necessary to force searching for the latest revision in case of loading another
591 * module, which what this function does.
592 *
593 * The latest revision information is also reset when the searchdirs set changes via
Radek Krejci8678fa42020-08-18 16:07:28 +0200594 * ::ly_ctx_set_searchdir().
Radek Krejcie9e987e2018-10-31 12:50:27 +0100595 *
596 * @param[in] ctx libyang context where the latest revision information is going to be reset.
597 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100598LIBYANG_API_DECL void ly_ctx_reset_latests(struct ly_ctx *ctx);
Radek Krejcie9e987e2018-10-31 12:50:27 +0100599
600/**
Michal Vaskode79e222020-08-10 11:55:46 +0200601 * @brief Learn the number of internal modules of a context. Internal modules
602 * is considered one that was loaded during the context creation.
603 *
604 * @param[in] ctx libyang context to examine.
605 * @return Number of internal modules.
606 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100607LIBYANG_API_DECL uint32_t ly_ctx_internal_modules_count(const struct ly_ctx *ctx);
Michal Vaskode79e222020-08-10 11:55:46 +0200608
609/**
Radek Krejcied5acc52019-04-25 15:57:04 +0200610 * @brief Try to find the model in the searchpaths of \p ctx and load it into it. If custom missing
611 * module callback is set, it is used instead.
612 *
613 * The context itself is searched for the requested module first. If \p revision is not specified
614 * (the module of the latest revision is requested) and there is implemented revision of the requested
615 * module in the context, this implemented revision is returned despite there might be a newer revision.
616 * This behavior is cause by the fact that it is not possible to have multiple implemented revisions of
617 * the same module in the context.
618 *
619 * @param[in] ctx Context to add to.
620 * @param[in] name Name of the module to load.
621 * @param[in] revision Optional revision date of the module. If not specified, the latest revision is loaded.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100622 * @param[in] features Optional array of features ended with NULL to be enabled if the module is being implemented.
Radek Krejci2415f882021-01-20 16:27:09 +0100623 * The feature string '*' enables all and array of length 1 with only the terminating NULL explicitly disables all
624 * the features. In case the parameter is NULL, the features are untouched - left disabled in newly loaded module or
625 * with the current features settings in case the module is already present in the context.
Radek Krejcied5acc52019-04-25 15:57:04 +0200626 * @return Pointer to the data model structure, NULL if not found or some error occurred.
627 */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100628LIBYANG_API_DECL struct lys_module *ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision,
629 const char **features);
Radek Krejcied5acc52019-04-25 15:57:04 +0200630
631/**
Michal Vasko57c10cd2020-05-27 15:57:11 +0200632 * @brief Get data of the internal ietf-yang-library module with information about all the loaded modules.
633 * ietf-yang-library module must be loaded.
634 *
Michal Vasko794ab4b2021-03-31 09:42:19 +0200635 * Note that "/ietf-yang-library:yang-library/datastore" list instances are not created and should be
636 * appended by the caller. There is a single "/ietf-yang-library:yang-library/schema" instance created
637 * with the key value "complete".
638 *
639 * If the data identifier can be limited to the existence and changes of this context, the following
640 * last 2 parameters can be used:
641 *
Michal Vaskof9943e42023-03-22 07:29:37 +0100642 * "%u" as @p content_id_format and ::ly_ctx_get_change_count() as its parameter;
643 * "%u" as @p content_id_format and ::ly_ctx_get_modules_hash() as its parameter.
Michal Vasko794ab4b2021-03-31 09:42:19 +0200644 *
Michal Vasko57c10cd2020-05-27 15:57:11 +0200645 * @param[in] ctx Context with the modules.
Michal Vasko3a41dff2020-07-15 14:30:28 +0200646 * @param[out] root Generated yang-library data.
Michal Vasko794ab4b2021-03-31 09:42:19 +0200647 * @param[in] content_id_format Format string (printf-like) for the yang-library data identifier, which is
648 * the "content_id" node in the 2019-01-04 revision of ietf-yang-library.
649 * @param[in] ... Parameters for @p content_id_format.
Michal Vasko3a41dff2020-07-15 14:30:28 +0200650 * @return LY_ERR value
Michal Vasko57c10cd2020-05-27 15:57:11 +0200651 */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100652LIBYANG_API_DECL LY_ERR ly_ctx_get_yanglib_data(const struct ly_ctx *ctx, struct lyd_node **root,
653 const char *content_id_format, ...);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200654
655/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200656 * @brief Free all internal structures of the specified context.
657 *
658 * The function should be used before terminating the application to destroy
659 * and free all structures internally used by libyang. If the caller uses
660 * multiple contexts, the function should be called for each used context.
661 *
Michal Vasko1817df82021-11-12 10:21:54 +0100662 * All instance data are supposed to be freed before destroying the context using ::lyd_free_all(), for example.
663 * Data models (schemas) are destroyed automatically as part of ::ly_ctx_destroy() call.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200664 *
Radek Krejci90ed21e2021-04-12 14:47:46 +0200665 * Note that the data stored by user into the ::lysc_node.priv pointer are kept
666 * untouched and the caller is responsible for freeing this private data.
667 *
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200668 * @param[in] ctx libyang context to destroy
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200669 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100670LIBYANG_API_DECL void ly_ctx_destroy(struct ly_ctx *ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200671
672/** @} context */
673
674#ifdef __cplusplus
675}
676#endif
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200677
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200678#endif /* LY_CONTEXT_H_ */