blob: bdb2b5b075a4e8a49648df446d50d35b4d368792 [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"
Radek Krejci5aeea3a2018-09-05 13:29:36 +020022
Radek Krejci6caa6ab2018-10-24 10:04:48 +020023#ifdef __cplusplus
24extern "C" {
25#endif
26
Michal Vasko3a41dff2020-07-15 14:30:28 +020027struct lyd_node;
Radek Krejcica376bd2020-06-11 16:04:06 +020028struct lysc_node;
29
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
37 * a complete context and after starting working with the data, the context and its content should not change. Despite the API
38 * does not enforce this approach, it may change in future versions in the form of a locking mechanism which would allow further
39 * optimization of data manipulation. Also note that modules cannot be removed from their context. If you need to change the set
40 * 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 +020041 *
Radek Krejci8678fa42020-08-18 16:07:28 +020042 * The context has [several options](@ref contextoptions) changing behavior when processing YANG modules being inserted. The
43 * specific behavior is mentioned below. All the options can be set as a parameter when the context is being created or later
44 * with ::ly_ctx_set_options().
45 *
46 * When creating a new context, another optional parameter is search_dir It provide directory where libyang
47 * will automatically search for YANG modules being imported or included. There is actually a set of search paths which can be later
48 * modified using ::ly_ctx_set_searchdir(), ::ly_ctx_unset_searchdir() and ::ly_ctx_unset_searchdir_last() functions. Before the values
49 * in the set are used, also the current working directory is (non-recursively) searched. For the case of the explicitly set
50 * search directories, they are searched recursively - all their subdirectories (and symlinks) are taken into account. Searching
51 * 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 +020052 * 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 +020053 * ::LY_CTX_DISABLE_SEARCHDIRS option (or via ::ly_ctx_set_options()). This automatic searching can be preceded
54 * by a custom module searching callback (::ly_module_imp_clb) set via ::ly_ctx_set_module_imp_clb(). The algorithm of
55 * searching in search dirs is also available via API as ::lys_search_localfile() function.
Radek Krejci52785a22019-09-11 12:57:26 +020056 *
Radek Krejci8678fa42020-08-18 16:07:28 +020057 * YANG modules are added into the context using [parser functions](@ref howtoSchemaParsers) - \b lys_parse*().
58 * Alternatively, also ::ly_ctx_load_module() can be used - in that case the ::ly_module_imp_clb or automatic
59 * search in search directories and in the current working directory is used, as described above. YANG submodules cannot be loaded
60 * or even validated directly, they are loaded always only as includes of YANG modules. Explicitly parsed/loaded modules are
61 * handled as implemented - libyang is able to instantiate data representing such a module. The modules loaded implicitly, are
62 * not implemented and serve only as a source of grouping or typedef definitions. Context can hold multiple revisions of the same
63 * 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 +020064 * can be found on @ref howtoSchema page. This behavior can be changed with the context's ::LY_CTX_ALL_IMPLEMENTED option, which
65 * causes that all the parsed modules, whether loaded explicitly or implicitly, are set to be implemented. Note, that as
66 * a consequence of this option, only a single revision of any module can be present in the context in this case. Also, a less
67 * 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 +020068 *
69 * When loading/importing a module without revision, the latest revision of the required module is supposed to load.
70 * For a context, the first time the latest revision of a module is requested, it is properly searched for and loaded.
71 * However, when this module is requested (without revision) the second time, the one found previously is returned.
Radek Krejci8678fa42020-08-18 16:07:28 +020072 * This has the advantage of not searching for the module repeatedly but there is a drawback in case the content of search
73 * directories is updated and a later revision become available. However, to force libyang to re-search the
74 * 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 +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()
120 * - ::ly_ctx_reset_latests()
Radek Krejci8678fa42020-08-18 16:07:28 +0200121 *
122 * - ::ly_ctx_get_yanglib_data()
123 * - ::ly_ctx_get_yanglib_id()
124 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200125 * - ::ly_ctx_get_module_set_id()
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100126 * - ::ly_ctx_internal_modules_count()
Radek Krejci8678fa42020-08-18 16:07:28 +0200127 *
Radek Krejci52785a22019-09-11 12:57:26 +0200128 * - ::lys_search_localfile()
Radek Krejci8678fa42020-08-18 16:07:28 +0200129 * - ::lys_set_implemented()
130 *
131 */
132
133/**
134 *
Radek Krejci52785a22019-09-11 12:57:26 +0200135 */
136
137/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200138 * @defgroup context Context
139 * @{
140 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200141 * Structures and functions to manipulate with the libyang context containers.
142 *
143 * The \em context concept allows callers to work in environments with different sets of YANG schemas.
144 * More detailed information can be found at @ref howtoContext page.
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200145 */
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200146
147/**
148 * @struct ly_ctx
149 * @brief libyang context handler.
150 */
151struct ly_ctx;
152
153/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200154 * @ingroup context
Radek Krejci8678fa42020-08-18 16:07:28 +0200155 * @defgroup contextoptions Context options
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200156 *
157 * Options to change context behavior.
Radek Krejci474f9b82019-07-24 11:36:37 +0200158 *
159 * Note that the flags 0xFF00 are reserved for internal use.
160 *
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. */
Radek Krejci0af46292019-01-11 16:02:31 +0100185
Michal Vaskob36053d2020-03-26 15:49:30 +0100186/** @} contextoptions */
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200187
188/**
189 * @brief Create libyang context.
190 *
191 * Context is used to hold all information about schemas. Usually, the application is supposed
192 * to work with a single context in which libyang is holding all schemas (and other internal
193 * information) according to which the data trees will be processed and validated. So, the schema
194 * trees are tightly connected with the specific context and they are held by the context internally
Radek Krejci8678fa42020-08-18 16:07:28 +0200195 * - caller does not need to keep pointers to the schemas returned by ::lys_parse(), context knows
196 * about them. The data trees created with \b lyd_parse_*() are still connected with the specific context,
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200197 * but they are not internally held by the context. The data tree just points and lean on some data
198 * held by the context (schema tree, string dictionary, etc.). Therefore, in case of data trees, caller
Radek Krejci8678fa42020-08-18 16:07:28 +0200199 * 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 +0200200 * also affects the number of instances of both tree types. While you can have only one instance of
201 * specific schema connected with a single context, number of data tree instances is not connected.
202 *
203 * @param[in] search_dir Directory where libyang will search for the imported or included modules
204 * and submodules. If no such directory is available, NULL is accepted.
205 * @param[in] options Context options, see @ref contextoptions.
206 * @param[out] new_ctx Pointer to the created libyang context if LY_SUCCESS returned.
207 * @return LY_ERR return value.
208 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200209LY_ERR ly_ctx_new(const char *search_dir, uint16_t options, struct ly_ctx **new_ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200210
211/**
212 * @brief Add the search path into libyang context
213 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200214 * To reset search paths set in the context, use ::ly_ctx_unset_searchdir() and then
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200215 * set search paths again.
216 *
217 * @param[in] ctx Context to be modified.
218 * @param[in] search_dir New search path to add to the current paths previously set in ctx.
219 * @return LY_ERR return value.
220 */
221LY_ERR ly_ctx_set_searchdir(struct ly_ctx *ctx, const char *search_dir);
222
223/**
224 * @brief Clean the search path(s) from the libyang context
225 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200226 * To remove the recently added search path(s), use ::ly_ctx_unset_searchdir_last().
Radek Krejcied5acc52019-04-25 15:57:04 +0200227 *
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200228 * @param[in] ctx Context to be modified.
229 * @param[in] value Searchdir to be removed, use NULL to remove them all.
230 * @return LY_ERR return value
231 */
Radek Krejcie58f97f2020-08-18 11:45:08 +0200232LY_ERR ly_ctx_unset_searchdir(struct ly_ctx *ctx, const char *value);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200233
234/**
Radek Krejcie58f97f2020-08-18 11:45:08 +0200235 * @brief Remove the least recently added search path(s) from the libyang context.
Radek Krejcied5acc52019-04-25 15:57:04 +0200236 *
Radek Krejci8678fa42020-08-18 16:07:28 +0200237 * To remove a specific search path by its value, use ::ly_ctx_unset_searchdir().
Radek Krejcied5acc52019-04-25 15:57:04 +0200238 *
239 * @param[in] ctx Context to be modified.
Radek Krejcie58f97f2020-08-18 11:45:08 +0200240 * @param[in] count Number of the searchdirs to be removed (starting by the least recently added).
241 * If the value is higher then the actual number of search paths, all paths are removed and no error is returned.
242 * Value 0 does not change the search path set.
Radek Krejcied5acc52019-04-25 15:57:04 +0200243 * @return LY_ERR return value
244 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200245LY_ERR ly_ctx_unset_searchdir_last(struct ly_ctx *ctx, uint32_t count);
Radek Krejcied5acc52019-04-25 15:57:04 +0200246
247/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200248 * @brief Get the NULL-terminated list of the search paths in libyang context. Do not modify the result!
249 *
250 * @param[in] ctx Context to query.
251 * @return NULL-terminated list (array) of the search paths, NULL if no searchpath was set.
252 * Do not modify the provided data in any way!
253 */
254const char * const *ly_ctx_get_searchdirs(const struct ly_ctx *ctx);
255
256/**
257 * @brief Get the currently set context's options.
258 *
259 * @param[in] ctx Context to query.
260 * @return Combination of all the currently set context's options, see @ref contextoptions.
261 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200262uint16_t ly_ctx_get_options(const struct ly_ctx *ctx);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200263
264/**
265 * @brief Set some of the context's options, see @ref contextoptions.
266 * @param[in] ctx Context to be modified.
267 * @param[in] option Combination of the context's options to be set, see @ref contextoptions.
268 * @return LY_ERR value.
269 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200270LY_ERR ly_ctx_set_options(struct ly_ctx *ctx, uint16_t option);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200271
272/**
273 * @brief Unset some of the context's options, see @ref contextoptions.
274 * @param[in] ctx Context to be modified.
275 * @param[in] option Combination of the context's options to be unset, see @ref contextoptions.
276 * @return LY_ERR value.
277 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200278LY_ERR ly_ctx_unset_options(struct ly_ctx *ctx, uint16_t option);
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200279
280/**
281 * @brief Get current ID of the modules set. The value is available also
Radek Krejci8678fa42020-08-18 16:07:28 +0200282 * as module-set-id in ::ly_ctx_get_yanglib_data() result.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200283 *
284 * @param[in] ctx Context to be examined.
285 * @return Numeric identifier of the current context's modules set.
286 */
287uint16_t ly_ctx_get_module_set_id(const struct ly_ctx *ctx);
288
289/**
Michal Vaskob2786d72020-08-24 13:19:52 +0200290 * @brief Callback for freeing returned module data in #ly_module_imp_clb.
291 *
292 * @param[in] module_data Data to free.
293 * @param[in] user_data User-supplied callback data, same as for #ly_module_imp_clb.
294 */
295typedef void (*ly_module_imp_data_free_clb)(void *module_data, void *user_data);
296
297/**
Radek Krejcid33273d2018-10-25 14:55:52 +0200298 * @brief Callback for retrieving missing included or imported models in a custom way.
299 *
300 * When submod_name is provided, the submodule is requested instead of the module (in this case only
301 * the module name without its revision is provided).
302 *
303 * If an @arg free_module_data callback is provided, it will be used later to free the allegedly const data
304 * which were returned by this callback.
305 *
306 * @param[in] mod_name Missing module name.
Radek Krejci086c7132018-10-26 15:29:04 +0200307 * @param[in] mod_rev Optional missing module revision. If NULL and submod_name is not provided, the latest revision is
308 * requested, the parsed module is then marked by the latest_revision flag.
Radek Krejcid33273d2018-10-25 14:55:52 +0200309 * @param[in] submod_name Optional missing submodule name.
Radek Krejci086c7132018-10-26 15:29:04 +0200310 * @param[in] submod_rev Optional missing submodule revision. If NULL and submod_name is provided, the latest revision is
311 * requested, the parsed submodule is then marked by the latest_revision flag.
Radek Krejcid33273d2018-10-25 14:55:52 +0200312 * @param[in] user_data User-supplied callback data.
313 * @param[out] format Format of the returned module data.
314 * @param[out] module_data Requested module data.
315 * @param[out] free_module_data Callback for freeing the returned module data. If not set, the data will be left untouched.
316 * @return LY_ERR value. If the returned value differs from LY_SUCCESS, libyang continue in trying to get the module data
317 * according to the settings of its mechanism to search for the imported/included schemas.
318 */
319typedef LY_ERR (*ly_module_imp_clb)(const char *mod_name, const char *mod_rev, const char *submod_name, const char *sub_rev,
Michal Vaskob2786d72020-08-24 13:19:52 +0200320 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 +0200321
322/**
323 * @brief Get the custom callback for missing import/include module retrieval.
324 *
325 * @param[in] ctx Context to read from.
326 * @param[in] user_data Optional pointer for getting the user-supplied callback data.
327 * @return Callback or NULL if not set.
328 */
329ly_module_imp_clb ly_ctx_get_module_imp_clb(const struct ly_ctx *ctx, void **user_data);
330
331/**
332 * @brief Set missing include or import module callback. It is meant to be used when the models
333 * are not locally available (such as when downloading modules from a NETCONF server), it should
334 * not be required in other cases.
335 *
336 * @param[in] ctx Context that will use this callback.
337 * @param[in] clb Callback responsible for returning the missing model.
338 * @param[in] user_data Arbitrary data that will always be passed to the callback \p clb.
339 */
340void ly_ctx_set_module_imp_clb(struct ly_ctx *ctx, ly_module_imp_clb clb, void *user_data);
341
342/**
Radek Krejcib7db73a2018-10-24 14:18:40 +0200343 * @brief Get YANG module of the given name and revision.
344 *
345 * @param[in] ctx Context to work in.
346 * @param[in] name Name of the YANG module to get.
347 * @param[in] revision Requested revision date of the YANG module to get. If not specified,
348 * the schema with no revision is returned, if it is present in the context.
349 * @return Pointer to the YANG module, NULL if no schema in the context follows the name and revision requirements.
350 */
Radek Krejci0af46292019-01-11 16:02:31 +0100351struct lys_module *ly_ctx_get_module(const struct ly_ctx *ctx, const char *name, const char *revision);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200352
353/**
354 * @brief Get the latest revision of the YANG module specified by its name.
355 *
356 * YANG modules with no revision are supposed to be the oldest one.
357 *
358 * @param[in] ctx Context where to search.
359 * @param[in] name Name of the YANG module to get.
360 * @return The latest revision of the specified YANG module in the given context, NULL if no YANG module of the
361 * given name is present in the context.
362 */
Radek Krejci0af46292019-01-11 16:02:31 +0100363struct lys_module *ly_ctx_get_module_latest(const struct ly_ctx *ctx, const char *name);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200364
365/**
366 * @brief Get the (only) implemented YANG module specified by its name.
367 *
368 * @param[in] ctx Context where to search.
369 * @param[in] name Name of the YANG module to get.
370 * @return The only implemented YANG module revision of the given name in the given context. NULL if there is no
371 * implemented module of the given name.
372 */
Radek Krejci0af46292019-01-11 16:02:31 +0100373struct lys_module *ly_ctx_get_module_implemented(const struct ly_ctx *ctx, const char *name);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200374
375/**
Radek Krejcied5acc52019-04-25 15:57:04 +0200376 * @brief Iterate over all modules in the given context.
377 *
378 * @param[in] ctx Context with the modules.
379 * @param[in,out] index Index of the next module to get. Value of 0 starts from the beginning.
380 * The value is updated with each call, so to iterate over all modules the same variable is supposed
381 * to be used in all calls starting with value 0.
382 * @return Next context module, NULL if the last was already returned.
383 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200384const struct lys_module *ly_ctx_get_module_iter(const struct ly_ctx *ctx, uint32_t *index);
Radek Krejcied5acc52019-04-25 15:57:04 +0200385
386/**
Radek Krejcib7db73a2018-10-24 14:18:40 +0200387 * @brief Get YANG module of the given namespace and revision.
388 *
389 * @param[in] ctx Context to work in.
390 * @param[in] ns Namespace of the YANG module to get.
391 * @param[in] revision Requested revision date of the YANG module to get. If not specified,
392 * the schema with no revision is returned, if it is present in the context.
393 * @return Pointer to the YANG module, NULL if no schema in the context follows the namespace and revision requirements.
394 */
Radek Krejci0af46292019-01-11 16:02:31 +0100395struct 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 +0200396
397/**
398 * @brief Get the latest revision of the YANG module specified by its namespace.
399 *
400 * YANG modules with no revision are supposed to be the oldest one.
401 *
402 * @param[in] ctx Context where to search.
403 * @param[in] ns Namespace of the YANG module to get.
404 * @return The latest revision of the specified YANG module in the given context, NULL if no YANG module of the
405 * given namespace is present in the context.
406 */
Radek Krejci0af46292019-01-11 16:02:31 +0100407struct lys_module *ly_ctx_get_module_latest_ns(const struct ly_ctx *ctx, const char *ns);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200408
409/**
410 * @brief Get the (only) implemented YANG module specified by its namespace.
411 *
412 * @param[in] ctx Context where to search.
413 * @param[in] ns Namespace of the YANG module to get.
414 * @return The only implemented YANG module revision of the given namespace in the given context. NULL if there is no
415 * implemented module of the given namespace.
416 */
Radek Krejci0af46292019-01-11 16:02:31 +0100417struct lys_module *ly_ctx_get_module_implemented_ns(const struct ly_ctx *ctx, const char *ns);
Radek Krejcib7db73a2018-10-24 14:18:40 +0200418
419/**
Radek Krejcie9e987e2018-10-31 12:50:27 +0100420 * @brief Reset cached latest revision information of the schemas in the context.
421 *
422 * When a (sub)module is imported/included without revision, the latest revision is
423 * searched. libyang searches for the latest revision in searchdirs and/or via provided
Radek Krejci8678fa42020-08-18 16:07:28 +0200424 * import callback ::ly_module_imp_clb() just once. Then it is expected that the content
Radek Krejcie9e987e2018-10-31 12:50:27 +0100425 * of searchdirs or data returned by the callback does not change. So when it changes,
426 * it is necessary to force searching for the latest revision in case of loading another
427 * module, which what this function does.
428 *
429 * The latest revision information is also reset when the searchdirs set changes via
Radek Krejci8678fa42020-08-18 16:07:28 +0200430 * ::ly_ctx_set_searchdir().
Radek Krejcie9e987e2018-10-31 12:50:27 +0100431 *
432 * @param[in] ctx libyang context where the latest revision information is going to be reset.
433 */
434void ly_ctx_reset_latests(struct ly_ctx *ctx);
435
436/**
Michal Vaskode79e222020-08-10 11:55:46 +0200437 * @brief Learn the number of internal modules of a context. Internal modules
438 * is considered one that was loaded during the context creation.
439 *
440 * @param[in] ctx libyang context to examine.
441 * @return Number of internal modules.
442 */
Radek Krejci0a60f1d2020-10-26 22:24:43 +0100443uint32_t ly_ctx_internal_modules_count(const struct ly_ctx *ctx);
Michal Vaskode79e222020-08-10 11:55:46 +0200444
445/**
Radek Krejcied5acc52019-04-25 15:57:04 +0200446 * @brief Try to find the model in the searchpaths of \p ctx and load it into it. If custom missing
447 * module callback is set, it is used instead.
448 *
449 * The context itself is searched for the requested module first. If \p revision is not specified
450 * (the module of the latest revision is requested) and there is implemented revision of the requested
451 * module in the context, this implemented revision is returned despite there might be a newer revision.
452 * This behavior is cause by the fact that it is not possible to have multiple implemented revisions of
453 * the same module in the context.
454 *
455 * @param[in] ctx Context to add to.
456 * @param[in] name Name of the module to load.
457 * @param[in] revision Optional revision date of the module. If not specified, the latest revision is loaded.
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100458 * @param[in] features Optional array of features ended with NULL to be enabled if the module is being implemented.
459 * NULL for all features disabled and '*' for all enabled.
Radek Krejcied5acc52019-04-25 15:57:04 +0200460 * @return Pointer to the data model structure, NULL if not found or some error occurred.
461 */
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100462const struct lys_module *ly_ctx_load_module(struct ly_ctx *ctx, const char *name, const char *revision,
463 const char **features);
Radek Krejcied5acc52019-04-25 15:57:04 +0200464
465/**
Michal Vasko57c10cd2020-05-27 15:57:11 +0200466 * @brief Get current ID of the modules set. The value is available also
467 * as module-set-id in ::ly_ctx_get_yanglib_data() result.
468 *
469 * @param[in] ctx Context to be examined.
470 * @return Numeric identifier of the current context's modules set.
471 */
472uint16_t ly_ctx_get_yanglib_id(const struct ly_ctx *ctx);
473
474/**
475 * @brief Get data of the internal ietf-yang-library module with information about all the loaded modules.
476 * ietf-yang-library module must be loaded.
477 *
478 * @param[in] ctx Context with the modules.
Michal Vasko3a41dff2020-07-15 14:30:28 +0200479 * @param[out] root Generated yang-library data.
480 * @return LY_ERR value
Michal Vasko57c10cd2020-05-27 15:57:11 +0200481 */
Michal Vasko3a41dff2020-07-15 14:30:28 +0200482LY_ERR ly_ctx_get_yanglib_data(const struct ly_ctx *ctx, struct lyd_node **root);
Michal Vasko57c10cd2020-05-27 15:57:11 +0200483
484/**
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200485 * @brief Free all internal structures of the specified context.
486 *
487 * The function should be used before terminating the application to destroy
488 * and free all structures internally used by libyang. If the caller uses
489 * multiple contexts, the function should be called for each used context.
490 *
491 * All instance data are supposed to be freed before destroying the context.
Radek Krejci8678fa42020-08-18 16:07:28 +0200492 * Data models are destroyed automatically as part of ::ly_ctx_destroy() call.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200493 *
494 * @param[in] ctx libyang context to destroy
495 * @param[in] private_destructor Optional destructor function for private objects assigned
Radek Krejci8678fa42020-08-18 16:07:28 +0200496 * to the nodes via ::lysc_set_private(). If NULL, the private objects are not freed by libyang.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200497 * Remember the differences between the structures derived from ::lysc_node and always check
Radek Krejci8678fa42020-08-18 16:07:28 +0200498 * ::lysc_node.nodetype.
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200499 */
500void ly_ctx_destroy(struct ly_ctx *ctx, void (*private_destructor)(const struct lysc_node *node, void *priv));
501
502/** @} context */
503
504#ifdef __cplusplus
505}
506#endif
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200507
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200508#endif /* LY_CONTEXT_H_ */