blob: e9334c964e0fbcdccd9e7189ae1498e572c952ec [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
Michal Vasko3a41dff2020-07-15 14:30:28 +020028struct lyd_node;
Radek Krejci77114102021-03-10 15:21:57 +010029struct lys_module;
Radek Krejcica376bd2020-06-11 16:04:06 +020030struct lysc_node;
31
Radek Krejci5aeea3a2018-09-05 13:29:36 +020032/**
Radek Krejci8678fa42020-08-18 16:07:28 +020033 * @page howtoContext Context
Radek Krejci52785a22019-09-11 12:57:26 +020034 *
Radek Krejci8678fa42020-08-18 16:07:28 +020035 * The context concept allows callers to work in environments with different sets of YANG modules.
Radek Krejci52785a22019-09-11 12:57:26 +020036 *
Radek Krejci8678fa42020-08-18 16:07:28 +020037 * The first step with libyang is to create a new context using ::ly_ctx_new(). It returns a handler used in the following work.
38 * 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 +020039 * a complete context and after starting working with the data, the context and its content should not change. If it does,
40 * in most cases it leads to the context being recompiled and any parsed data invalid. Despite the API not enforcing this
41 * 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 +020042 * optimization of data manipulation. Also note that modules cannot be removed from their context. If you need to change the set
43 * 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 +020044 *
Radek Krejci8678fa42020-08-18 16:07:28 +020045 * The context has [several options](@ref contextoptions) changing behavior when processing YANG modules being inserted. The
46 * specific behavior is mentioned below. All the options can be set as a parameter when the context is being created or later
47 * with ::ly_ctx_set_options().
48 *
49 * When creating a new context, another optional parameter is search_dir It provide directory where libyang
50 * will automatically search for YANG modules being imported or included. There is actually a set of search paths which can be later
51 * modified using ::ly_ctx_set_searchdir(), ::ly_ctx_unset_searchdir() and ::ly_ctx_unset_searchdir_last() functions. Before the values
52 * in the set are used, also the current working directory is (non-recursively) searched. For the case of the explicitly set
53 * search directories, they are searched recursively - all their subdirectories (and symlinks) are taken into account. Searching
54 * 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 +020055 * 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 +020056 * ::LY_CTX_DISABLE_SEARCHDIRS option (or via ::ly_ctx_set_options()). This automatic searching can be preceded
57 * by a custom module searching callback (::ly_module_imp_clb) set via ::ly_ctx_set_module_imp_clb(). The algorithm of
58 * searching in search dirs is also available via API as ::lys_search_localfile() function.
Radek Krejci52785a22019-09-11 12:57:26 +020059 *
Radek Krejci8678fa42020-08-18 16:07:28 +020060 * YANG modules are added into the context using [parser functions](@ref howtoSchemaParsers) - \b lys_parse*().
61 * Alternatively, also ::ly_ctx_load_module() can be used - in that case the ::ly_module_imp_clb or automatic
62 * search in search directories and in the current working directory is used, as described above. YANG submodules cannot be loaded
63 * or even validated directly, they are loaded always only as includes of YANG modules. Explicitly parsed/loaded modules are
64 * handled as implemented - libyang is able to instantiate data representing such a module. The modules loaded implicitly, are
65 * not implemented and serve only as a source of grouping or typedef definitions. Context can hold multiple revisions of the same
66 * 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 +020067 * can be found on @ref howtoSchema page. This behavior can be changed with the context's ::LY_CTX_ALL_IMPLEMENTED option, which
68 * causes that all the parsed modules, whether loaded explicitly or implicitly, are set to be implemented. Note, that as
69 * a consequence of this option, only a single revision of any module can be present in the context in this case. Also, a less
70 * 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 +020071 *
72 * When loading/importing a module without revision, the latest revision of the required module is supposed to load.
73 * For a context, the first time the latest revision of a module is requested, it is properly searched for and loaded.
74 * However, when this module is requested (without revision) the second time, the one found previously is returned.
Radek Krejci8678fa42020-08-18 16:07:28 +020075 * This has the advantage of not searching for the module repeatedly but there is a drawback in case the content of search
76 * directories is updated and a later revision become available. However, to force libyang to re-search the
77 * latest revision, ::ly_ctx_reset_latests() can be used (note that it applies to all the modules in the context).
Radek Krejci52785a22019-09-11 12:57:26 +020078 *
Radek Krejci8678fa42020-08-18 16:07:28 +020079 * Context holds all the schema modules internally. To get a specific module, use ::ly_ctx_get_module() (or some of its
80 * variants). If you need to do something with all the modules in the context, it is advised to iterate over them using
81 * ::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
82 * 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 +020083 *
Radek Krejci8678fa42020-08-18 16:07:28 +020084 * YANG data can be parsed by \b lyd_parse_*() functions. Note, that functions for schema have \b lys_
85 * prefix (or \b lysp_ for the parsed and \b lysc_ for the compiled schema - for details see @ref howtoSchema page) while
86 * functions for instance data have \b lyd_ prefix. Details about data formats or handling data without the appropriate
87 * YANG module in context can be found on @ref howtoData page.
Radek Krejci52785a22019-09-11 12:57:26 +020088 *
Radek Krejci8678fa42020-08-18 16:07:28 +020089 * Besides the YANG modules, context holds also [error information](@ref howtoErrors) and
90 * [database of strings](@ref howtoContextDict), both connected with the processed YANG modules and data.
91 *
92 * - @subpage howtoErrors
93 * - @subpage howtoContextDict
Radek Krejci52785a22019-09-11 12:57:26 +020094 *
95 * \note API for this group of functions is available in the [context module](@ref context).
96 *
97 * Functions List
98 * --------------
Radek Krejci8678fa42020-08-18 16:07:28 +020099 *
Radek Krejci52785a22019-09-11 12:57:26 +0200100 * - ::ly_ctx_new()
Radek Krejci8678fa42020-08-18 16:07:28 +0200101 * - ::ly_ctx_destroy()
102 *
Radek Krejci52785a22019-09-11 12:57:26 +0200103 * - ::ly_ctx_set_searchdir()
Radek Krejci52785a22019-09-11 12:57:26 +0200104 * - ::ly_ctx_get_searchdirs()
Radek Krejci8678fa42020-08-18 16:07:28 +0200105 * - ::ly_ctx_unset_searchdir()
106 * - ::ly_ctx_unset_searchdir_last()
107 *
108 * - ::ly_ctx_set_options()
109 * - ::ly_ctx_get_options()
110 * - ::ly_ctx_unset_options()
111 *
Radek Krejci52785a22019-09-11 12:57:26 +0200112 * - ::ly_ctx_set_module_imp_clb()
113 * - ::ly_ctx_get_module_imp_clb()
Radek Krejci8678fa42020-08-18 16:07:28 +0200114 *
Radek Krejci52785a22019-09-11 12:57:26 +0200115 * - ::ly_ctx_load_module()
Radek Krejci52785a22019-09-11 12:57:26 +0200116 * - ::ly_ctx_get_module_iter()
117 * - ::ly_ctx_get_module()
118 * - ::ly_ctx_get_module_ns()
119 * - ::ly_ctx_get_module_implemented()
120 * - ::ly_ctx_get_module_implemented_ns()
121 * - ::ly_ctx_get_module_latest()
122 * - ::ly_ctx_get_module_latest_ns()
Michal Vasko8dc31992021-02-22 10:30:47 +0100123 * - ::ly_ctx_get_submodule()
124 * - ::ly_ctx_get_submodule_latest()
125 * - ::ly_ctx_get_submodule2()
126 * - ::ly_ctx_get_submodule2_latest()
Radek Krejci52785a22019-09-11 12:57:26 +0200127 * - ::ly_ctx_reset_latests()
Radek Krejci8678fa42020-08-18 16:07:28 +0200128 *
129 * - ::ly_ctx_get_yanglib_data()
Radek Krejci8678fa42020-08-18 16:07:28 +0200130 *
Michal Vasko794ab4b2021-03-31 09:42:19 +0200131 * - ::ly_ctx_get_change_count()
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100132 * - ::ly_ctx_internal_modules_count()
Radek Krejci8678fa42020-08-18 16:07:28 +0200133 *
Radek Krejci52785a22019-09-11 12:57:26 +0200134 * - ::lys_search_localfile()
Radek Krejci8678fa42020-08-18 16:07:28 +0200135 * - ::lys_set_implemented()
136 *
137 */
138
139/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200140 * @defgroup context Context
141 * @{
142 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200143 * Structures and functions to manipulate with the libyang context containers.
144 *
145 * The \em context concept allows callers to work in environments with different sets of YANG schemas.
146 * More detailed information can be found at @ref howtoContext page.
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200147 */
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200148
149/**
150 * @struct ly_ctx
151 * @brief libyang context handler.
152 */
153struct ly_ctx;
154
155/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200156 * @ingroup context
Radek Krejci8678fa42020-08-18 16:07:28 +0200157 * @defgroup contextoptions Context options
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200158 *
159 * Options to change context behavior.
Radek Krejci474f9b82019-07-24 11:36:37 +0200160 *
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200161 * @{
162 */
163
Michal Vasko25d6ad02020-10-22 12:20:22 +0200164#define LY_CTX_ALL_IMPLEMENTED 0x01 /**< All the imported modules of the schema being parsed are implemented. */
165#define LY_CTX_REF_IMPLEMENTED 0x02 /**< Implement all imported modules "referenced" from an implemented module.
166 Normally, leafrefs, augment and deviation targets are implemented as
167 specified by YANG 1.1. In addition to this, implement any modules of
168 nodes referenced by when and must conditions and by any default values.
169 Generally, only if all these modules are implemented, the explicitly
170 implemented modules can be properly used and instantiated in data. */
171#define LY_CTX_NO_YANGLIBRARY 0x04 /**< Do not internally implement ietf-yang-library module. The option
Radek Krejci8678fa42020-08-18 16:07:28 +0200172 causes that function ::ly_ctx_get_yanglib_data() does not work (returns ::LY_EINVAL) until
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200173 the ietf-yang-library module is loaded manually. While any revision
174 of this schema can be loaded with this option, note that the only
Radek Krejci8678fa42020-08-18 16:07:28 +0200175 revisions implemented by ::ly_ctx_get_yanglib_data() are 2016-06-21 and 2019-01-04.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200176 This option cannot be changed on existing context. */
177#define LY_CTX_DISABLE_SEARCHDIRS 0x08 /**< Do not search for schemas in context's searchdirs neither in current
178 working directory. It is entirely skipped and the only way to get
Radek Krejci8678fa42020-08-18 16:07:28 +0200179 schema data for imports or for ::ly_ctx_load_module() is to use the
180 callbacks provided by caller via ::ly_ctx_set_module_imp_clb() */
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200181#define LY_CTX_DISABLE_SEARCHDIR_CWD 0x10 /**< Do not automatically search for schemas in current working
182 directory, which is by default searched automatically (despite not
183 recursively). */
184#define LY_CTX_PREFER_SEARCHDIRS 0x20 /**< When searching for schema, prefer searchdirs instead of user callback. */
aPiecek9922ea92021-04-12 07:59:20 +0200185#define LY_CTX_SET_PRIV_PARSED 0x40 /**< For all compiled nodes, their private objects (::lysc_node.priv) are used
186 by libyang as a reference to the corresponding parsed node (::lysp_node).
aPiecek082c7dc2021-05-20 08:55:07 +0200187 The exception are \"case\" statements, which are ommitted (shorthand),
188 in that case the private objects are set to NULL.
aPiecek9922ea92021-04-12 07:59:20 +0200189 So if this option is set, the user must not change private objects.
190 Setting this option by ::ly_ctx_set_options() may result in context recompilation.
191 Resetting this option by ::ly_ctx_unset_options() cause that private
192 objects will be set to NULL. */
Michal Vasko01db7de2021-04-16 12:23:30 +0200193#define LY_CTX_EXPLICIT_COMPILE 0x80 /**< If this flag is set, the compiled modules and their schema nodes are
194 not automatically updated (compiled) on any context changes. In other words, they do
195 not immediately take effect. To do that, call ::ly_ctx_compile(). Changes
196 requiring compilation include adding new modules, changing their features,
197 and implementing parsed-only modules. This option allows efficient compiled
198 context creation without redundant recompilations. */
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 *
217 * @param[in] search_dir Directory where libyang will search for the imported or included modules
218 * and submodules. If no such directory is available, NULL is accepted.
219 * @param[in] options Context options, see @ref contextoptions.
220 * @param[out] new_ctx Pointer to the created libyang context if LY_SUCCESS returned.
221 * @return LY_ERR return value.
222 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200223LY_ERR ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200224
225/**
Tadeáš Vintrlík390b2722021-04-07 13:52:45 +0200226 * @brief Create libyang context according to the content of the given yang-library data.
227 *
228 * This function loads the yang-library data from the given path. If you need to pass the data as
229 * string, use ::::ly_ctx_new_ylmem(). Both functions extend functionality of ::ly_ctx_new() by loading
230 * modules specified in the ietf-yang-library form into the context being created.
231 * The preferred tree model revision is 2019-01-04. However, only the first module-set is processed and loaded
232 * into the context. If there are no matching nodes from this tree, the legacy tree (originally from model revision 2016-04-09)
233 * 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
234 * yang-library data are ignored and the modules are loaded from the context's search locations. On the other hand, YANG features
235 * of the modules are set as specified in the yang-library data.
236 * To get yang library data from a libyang context, use ::ly_ctx_get_yanglib_data().
237 *
238 * @param[in] search_dir Directory where libyang will search for the imported or included modules and submodules.
239 * If no such directory is available, NULL is accepted.
240 * @param[in] path Path to the file containing yang-library-data in the specified format
241 * @param[in] format Format of the data in the provided file.
242 * @param[in] options Context options, see @ref contextoptions.
243 * @param[out] ctx Pointer to the created libyang context if LY_SUCCESS returned.
244 * @return LY_ERR return value
245 */
246LY_ERR ly_ctx_new_ylpath(const char *search_dir, const char *path, LYD_FORMAT format, int options, struct ly_ctx **ctx);
247
248/**
249 * @brief Create libyang context according to the content of the given yang-library data.
250 *
251 * This function loads the yang-library data from the given string. If you need to pass the data as
252 * path to a file holding the data, use ::ly_ctx_new_ylpath(). Both functions extend functionality of
253 * ::ly_ctx_new() by loading modules specified in the ietf-yang-library form into the context being created.
254 * The preferred tree model revision is 2019-01-04. However, only the first module-set is processed and loaded
255 * into the context. If there are no matching nodes from this tree, the legacy tree (originally from model revision 2016-04-09)
256 * 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
257 * yang-library data are ignored and the modules are loaded from the context's search locations. On the other hand, YANG features
258 * of the modules are set as specified in the yang-library data.
259 * To get yang library data from a libyang context, use ::ly_ctx_get_yanglib_data().
260 *
261 * @param[in] search_dir Directory where libyang will search for the imported or included modules and submodules.
262 * If no such directory is available, NULL is accepted.
263 * @param[in] data String containing yang-library data in the specified format.
264 * @param[in] format Format of the data in the provided file.
265 * @param[in] options Context options, see @ref contextoptions.
266 * @param[out] ctx Pointer to the created libyang context if LY_SUCCESS returned.
267 * @return LY_ERR return value
268 */
269LY_ERR ly_ctx_new_ylmem(const char *search_dir, const char *data, LYD_FORMAT format, int options, struct ly_ctx **ctx);
270
271/**
Michal Vasko01db7de2021-04-16 12:23:30 +0200272 * @brief Compile (recompile) the context applying all the performed changes after the last context compilation.
273 * Should be used only if ::LY_CTX_EXPLICIT_COMPILE option is set, has no effect otherwise.
274 *
275 * @param[in] ctx Context to compile.
276 * @return LY_ERR return value.
277 */
278LY_ERR ly_ctx_compile(struct ly_ctx *ctx);
279
280/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200281 * @brief Add the search path into libyang context
282 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200283 * To reset search paths set in the context, use ::ly_ctx_unset_searchdir() and then
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200284 * set search paths again.
285 *
286 * @param[in] ctx Context to be modified.
287 * @param[in] search_dir New search path to add to the current paths previously set in ctx.
288 * @return LY_ERR return value.
289 */
290LY_ERR ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir);
291
292/**
293 * @brief Clean the search path(s) from the libyang context
294 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200295 * To remove the recently added search path(s), use ::ly_ctx_unset_searchdir_last().
Radek Krejcied5acc52019-04-25 15:57:04 +0200296 *
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200297 * @param[in] ctx Context to be modified.
298 * @param[in] value Searchdir to be removed, use NULL to remove them all.
299 * @return LY_ERR return value
300 */
Radek Krejcie58f97f2020-08-18 11:45:08 +0200301LY_ERR ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200302
303/**
Radek Krejcie58f97f2020-08-18 11:45:08 +0200304 * @brief Remove the least recently added search path(s) from the libyang context.
Radek Krejcied5acc52019-04-25 15:57:04 +0200305 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200306 * To remove a specific search path by its value, use ::ly_ctx_unset_searchdir().
Radek Krejcied5acc52019-04-25 15:57:04 +0200307 *
308 * @param[in] ctx Context to be modified.
Radek Krejcie58f97f2020-08-18 11:45:08 +0200309 * @param[in] count Number of the searchdirs to be removed (starting by the least recently added).
310 * If the value is higher then the actual number of search paths, all paths are removed and no error is returned.
311 * Value 0 does not change the search path set.
Radek Krejcied5acc52019-04-25 15:57:04 +0200312 * @return LY_ERR return value
313 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200314LY_ERR ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count);
Radek Krejcied5acc52019-04-25 15:57:04 +0200315
316/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200317 * @brief Get the NULL-terminated list of the search paths in libyang context. Do not modify the result!
318 *
319 * @param[in] ctx Context to query.
320 * @return NULL-terminated list (array) of the search paths, NULL if no searchpath was set.
321 * Do not modify the provided data in any way!
322 */
323const char * const *ly_ctx_get_searchdirs(const struct ly_ctx *ctx);
324
325/**
326 * @brief Get the currently set context's options.
327 *
328 * @param[in] ctx Context to query.
329 * @return Combination of all the currently set context's options, see @ref contextoptions.
330 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200331uint16_t ly_ctx_get_options(const struct ly_ctx *ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200332
333/**
334 * @brief Set some of the context's options, see @ref contextoptions.
335 * @param[in] ctx Context to be modified.
336 * @param[in] option Combination of the context's options to be set, see @ref contextoptions.
aPiecek9922ea92021-04-12 07:59:20 +0200337 * If there is to be a change to ::LY_CTX_SET_PRIV_PARSED, the context will be recompiled
338 * and all ::lysc_node.priv in the modules will be overwritten, see ::LY_CTX_SET_PRIV_PARSED.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200339 * @return LY_ERR value.
340 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200341LY_ERR ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200342
343/**
344 * @brief Unset some of the context's options, see @ref contextoptions.
345 * @param[in] ctx Context to be modified.
346 * @param[in] option Combination of the context's options to be unset, see @ref contextoptions.
347 * @return LY_ERR value.
348 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200349LY_ERR ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200350
351/**
Michal Vasko794ab4b2021-03-31 09:42:19 +0200352 * @brief Get the change count of the context (module set) during its life-time.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200353 *
354 * @param[in] ctx Context to be examined.
Michal Vasko794ab4b2021-03-31 09:42:19 +0200355 * @return Context change count.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200356 */
Michal Vasko794ab4b2021-03-31 09:42:19 +0200357uint16_t ly_ctx_get_change_count(const struct ly_ctx *ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200358
359/**
Michal Vaskob2786d72020-08-24 13:19:52 +0200360 * @brief Callback for freeing returned module data in #ly_module_imp_clb.
361 *
362 * @param[in] module_data Data to free.
363 * @param[in] user_data User-supplied callback data, same as for #ly_module_imp_clb.
364 */
365typedef void (*ly_module_imp_data_free_clb)(void *module_data, void *user_data);
366
367/**
Radek Krejcid33273d2018-10-25 14:55:52 +0200368 * @brief Callback for retrieving missing included or imported models in a custom way.
369 *
Radek Krejcibb9d2242021-01-04 10:51:31 +0100370 * 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 +0200371 * the module name without its revision is provided).
372 *
373 * If an @arg free_module_data callback is provided, it will be used later to free the allegedly const data
374 * which were returned by this callback.
375 *
376 * @param[in] mod_name Missing module name.
Radek Krejci086c7132018-10-26 15:29:04 +0200377 * @param[in] mod_rev Optional missing module revision. If NULL and submod_name is not provided, the latest revision is
378 * requested, the parsed module is then marked by the latest_revision flag.
Radek Krejcid33273d2018-10-25 14:55:52 +0200379 * @param[in] submod_name Optional missing submodule name.
Radek Krejci086c7132018-10-26 15:29:04 +0200380 * @param[in] submod_rev Optional missing submodule revision. If NULL and submod_name is provided, the latest revision is
381 * requested, the parsed submodule is then marked by the latest_revision flag.
Radek Krejcid33273d2018-10-25 14:55:52 +0200382 * @param[in] user_data User-supplied callback data.
383 * @param[out] format Format of the returned module data.
384 * @param[out] module_data Requested module data.
385 * @param[out] free_module_data Callback for freeing the returned module data. If not set, the data will be left untouched.
386 * @return LY_ERR value. If the returned value differs from LY_SUCCESS, libyang continue in trying to get the module data
387 * according to the settings of its mechanism to search for the imported/included schemas.
388 */
Radek Krejcibb9d2242021-01-04 10:51:31 +0100389typedef 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 +0200390 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 +0200391
392/**
393 * @brief Get the custom callback for missing import/include module retrieval.
394 *
395 * @param[in] ctx Context to read from.
396 * @param[in] user_data Optional pointer for getting the user-supplied callback data.
397 * @return Callback or NULL if not set.
398 */
399ly_module_imp_clb ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data);
400
401/**
402 * @brief Set missing include or import module callback. It is meant to be used when the models
403 * are not locally available (such as when downloading modules from a NETCONF server), it should
404 * not be required in other cases.
405 *
406 * @param[in] ctx Context that will use this callback.
407 * @param[in] clb Callback responsible for returning the missing model.
408 * @param[in] user_data Arbitrary data that will always be passed to the callback \p clb.
409 */
410void ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data);
411
412/**
Radek Krejcib7db73a2018-10-24 14:18:40 +0200413 * @brief Get YANG module of the given name and revision.
414 *
415 * @param[in] ctx Context to work in.
416 * @param[in] name Name of the YANG module to get.
417 * @param[in] revision Requested revision date of the YANG module to get. If not specified,
418 * the schema with no revision is returned, if it is present in the context.
419 * @return Pointer to the YANG module, NULL if no schema in the context follows the name and revision requirements.
420 */
Radek Krejci0af46292019-01-11 16:02:31 +0100421struct lys_module *ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200422
423/**
424 * @brief Get the latest revision of the YANG module specified by its name.
425 *
426 * YANG modules with no revision are supposed to be the oldest one.
427 *
428 * @param[in] ctx Context where to search.
429 * @param[in] name Name of the YANG module to get.
430 * @return The latest revision of the specified YANG module in the given context, NULL if no YANG module of the
431 * given name is present in the context.
432 */
Radek Krejci0af46292019-01-11 16:02:31 +0100433struct lys_module *ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200434
435/**
436 * @brief Get the (only) implemented YANG module specified by its name.
437 *
438 * @param[in] ctx Context where to search.
439 * @param[in] name Name of the YANG module to get.
440 * @return The only implemented YANG module revision of the given name in the given context. NULL if there is no
441 * implemented module of the given name.
442 */
Radek Krejci0af46292019-01-11 16:02:31 +0100443struct lys_module *ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200444
445/**
Radek Krejcied5acc52019-04-25 15:57:04 +0200446 * @brief Iterate over all modules in the given context.
447 *
448 * @param[in] ctx Context with the modules.
449 * @param[in,out] index Index of the next module to get. Value of 0 starts from the beginning.
450 * The value is updated with each call, so to iterate over all modules the same variable is supposed
451 * to be used in all calls starting with value 0.
452 * @return Next context module, NULL if the last was already returned.
453 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200454const struct lys_module *ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index);
Radek Krejcied5acc52019-04-25 15:57:04 +0200455
456/**
Radek Krejcib7db73a2018-10-24 14:18:40 +0200457 * @brief Get YANG module of the given namespace and revision.
458 *
459 * @param[in] ctx Context to work in.
460 * @param[in] ns Namespace of the YANG module to get.
461 * @param[in] revision Requested revision date of the YANG module to get. If not specified,
462 * the schema with no revision is returned, if it is present in the context.
463 * @return Pointer to the YANG module, NULL if no schema in the context follows the namespace and revision requirements.
464 */
Radek Krejci0af46292019-01-11 16:02:31 +0100465struct 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 +0200466
467/**
468 * @brief Get the latest revision of the YANG module specified by its namespace.
469 *
470 * YANG modules with no revision are supposed to be the oldest one.
471 *
472 * @param[in] ctx Context where to search.
473 * @param[in] ns Namespace of the YANG module to get.
474 * @return The latest revision of the specified YANG module in the given context, NULL if no YANG module of the
475 * given namespace is present in the context.
476 */
Radek Krejci0af46292019-01-11 16:02:31 +0100477struct lys_module *ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200478
479/**
480 * @brief Get the (only) implemented YANG module specified by its namespace.
481 *
482 * @param[in] ctx Context where to search.
483 * @param[in] ns Namespace of the YANG module to get.
484 * @return The only implemented YANG module revision of the given namespace in the given context. NULL if there is no
485 * implemented module of the given namespace.
486 */
Radek Krejci0af46292019-01-11 16:02:31 +0100487struct lys_module *ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200488
489/**
Michal Vasko8dc31992021-02-22 10:30:47 +0100490 * @brief Get a specific submodule from context. If its belongs-to module is known, use ::ly_ctx_get_submodule2().
491 *
492 * @param[in] ctx libyang context to search in.
493 * @param[in] submodule Submodule name to find.
494 * @param[in] revision Revision of the submodule to find, NULL for a submodule without a revision.
495 * @return Found submodule, NULL if there is none.
496 */
497const struct lysp_submodule *ly_ctx_get_submodule(const struct ly_ctx *ctx, const char *submodule, const char *revision);
498
499/**
500 * @brief Get the latests revision of a submodule from context. If its belongs-to module is known,
501 * use ::ly_ctx_get_submodule2_latest().
502 *
503 * @param[in] ctx libyang context to search in.
504 * @param[in] submodule Submodule name to find.
505 * @return Found submodule, NULL if there is none.
506 */
507const struct lysp_submodule *ly_ctx_get_submodule_latest(const struct ly_ctx *ctx, const char *submodule);
508
509/**
510 * @brief Get a specific submodule from a module. If the belongs-to module is not known, use ::ly_ctx_get_submodule().
511 *
512 * @param[in] module Belongs-to module to search in.
513 * @param[in] submodule Submodule name to find.
514 * @param[in] revision Revision of the submodule to find, NULL for a submodule without a revision.
515 * @return Found submodule, NULL if there is none.
516 */
517const struct lysp_submodule *ly_ctx_get_submodule2(const struct lys_module *module, const char *submodule,
518 const char *revision);
519
520/**
521 * @brief Get the latest revision of a submodule from a module. If the belongs-to module is not known,
522 * use ::ly_ctx_get_submodule_latest().
523 *
524 * @param[in] module Belongs-to module to search in.
525 * @param[in] submodule Submodule name to find.
526 * @return Found submodule, NULL if there is none.
527 */
528const struct lysp_submodule *ly_ctx_get_submodule2_latest(const struct lys_module *module, const char *submodule);
529
530/**
Radek Krejcie9e987e2018-10-31 12:50:27 +0100531 * @brief Reset cached latest revision information of the schemas in the context.
532 *
533 * When a (sub)module is imported/included without revision, the latest revision is
534 * searched. libyang searches for the latest revision in searchdirs and/or via provided
Radek Krejci8678fa42020-08-18 16:07:28 +0200535 * import callback ::ly_module_imp_clb() just once. Then it is expected that the content
Radek Krejcie9e987e2018-10-31 12:50:27 +0100536 * of searchdirs or data returned by the callback does not change. So when it changes,
537 * it is necessary to force searching for the latest revision in case of loading another
538 * module, which what this function does.
539 *
540 * The latest revision information is also reset when the searchdirs set changes via
Radek Krejci8678fa42020-08-18 16:07:28 +0200541 * ::ly_ctx_set_searchdir().
Radek Krejcie9e987e2018-10-31 12:50:27 +0100542 *
543 * @param[in] ctx libyang context where the latest revision information is going to be reset.
544 */
545void ly_ctx_reset_latests(struct ly_ctx *ctx);
546
547/**
Michal Vaskode79e222020-08-10 11:55:46 +0200548 * @brief Learn the number of internal modules of a context. Internal modules
549 * is considered one that was loaded during the context creation.
550 *
551 * @param[in] ctx libyang context to examine.
552 * @return Number of internal modules.
553 */
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100554uint32_t ly_ctx_internal_modules_count(const struct ly_ctx *ctx);
Michal Vaskode79e222020-08-10 11:55:46 +0200555
556/**
Radek Krejcied5acc52019-04-25 15:57:04 +0200557 * @brief Try to find the model in the searchpaths of \p ctx and load it into it. If custom missing
558 * module callback is set, it is used instead.
559 *
560 * The context itself is searched for the requested module first. If \p revision is not specified
561 * (the module of the latest revision is requested) and there is implemented revision of the requested
562 * module in the context, this implemented revision is returned despite there might be a newer revision.
563 * This behavior is cause by the fact that it is not possible to have multiple implemented revisions of
564 * the same module in the context.
565 *
566 * @param[in] ctx Context to add to.
567 * @param[in] name Name of the module to load.
568 * @param[in] revision Optional revision date of the module. If not specified, the latest revision is loaded.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100569 * @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 +0100570 * The feature string '*' enables all and array of length 1 with only the terminating NULL explicitly disables all
571 * the features. In case the parameter is NULL, the features are untouched - left disabled in newly loaded module or
572 * with the current features settings in case the module is already present in the context.
Radek Krejcied5acc52019-04-25 15:57:04 +0200573 * @return Pointer to the data model structure, NULL if not found or some error occurred.
574 */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100575const struct lys_module *ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision,
576 const char **features);
Radek Krejcied5acc52019-04-25 15:57:04 +0200577
578/**
Michal Vasko57c10cd2020-05-27 15:57:11 +0200579 * @brief Get data of the internal ietf-yang-library module with information about all the loaded modules.
580 * ietf-yang-library module must be loaded.
581 *
Michal Vasko794ab4b2021-03-31 09:42:19 +0200582 * Note that "/ietf-yang-library:yang-library/datastore" list instances are not created and should be
583 * appended by the caller. There is a single "/ietf-yang-library:yang-library/schema" instance created
584 * with the key value "complete".
585 *
586 * If the data identifier can be limited to the existence and changes of this context, the following
587 * last 2 parameters can be used:
588 *
589 * "%u" as @p content_id_format and ::ly_ctx_get_change_count() as its parameter.
590 *
Michal Vasko57c10cd2020-05-27 15:57:11 +0200591 * @param[in] ctx Context with the modules.
Michal Vasko3a41dff2020-07-15 14:30:28 +0200592 * @param[out] root Generated yang-library data.
Michal Vasko794ab4b2021-03-31 09:42:19 +0200593 * @param[in] content_id_format Format string (printf-like) for the yang-library data identifier, which is
594 * the "content_id" node in the 2019-01-04 revision of ietf-yang-library.
595 * @param[in] ... Parameters for @p content_id_format.
Michal Vasko3a41dff2020-07-15 14:30:28 +0200596 * @return LY_ERR value
Michal Vasko57c10cd2020-05-27 15:57:11 +0200597 */
Michal Vasko794ab4b2021-03-31 09:42:19 +0200598LY_ERR ly_ctx_get_yanglib_data(const struct ly_ctx *ctx, struct lyd_node **root, const char *content_id_format, ...);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200599
600/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200601 * @brief Free all internal structures of the specified context.
602 *
603 * The function should be used before terminating the application to destroy
604 * and free all structures internally used by libyang. If the caller uses
605 * multiple contexts, the function should be called for each used context.
606 *
607 * All instance data are supposed to be freed before destroying the context.
Radek Krejci8678fa42020-08-18 16:07:28 +0200608 * Data models are destroyed automatically as part of ::ly_ctx_destroy() call.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200609 *
Radek Krejci90ed21e2021-04-12 14:47:46 +0200610 * Note that the data stored by user into the ::lysc_node.priv pointer are kept
611 * untouched and the caller is responsible for freeing this private data.
612 *
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200613 * @param[in] ctx libyang context to destroy
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200614 */
Radek Krejci90ed21e2021-04-12 14:47:46 +0200615void ly_ctx_destroy(struct ly_ctx *ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200616
617/** @} context */
618
619#ifdef __cplusplus
620}
621#endif
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200622
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200623#endif /* LY_CONTEXT_H_ */