blob: 6250e9acdec02c4a2015d7d4a3c6bc0da3c0e858 [file] [log] [blame]
Radek Krejci7931b192020-06-25 17:05:03 +02001/**
2 * @file parser_data.h
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Data parsers for libyang
5 *
6 * Copyright (c) 2015-2020 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
15#ifndef LY_PARSER_DATA_H_
16#define LY_PARSER_DATA_H_
17
18#include "tree_data.h"
19
20#ifdef __cplusplus
21extern "C" {
22#endif
23
24struct ly_in;
25
26/**
Radek Krejci8678fa42020-08-18 16:07:28 +020027 * @page howtoDataParsers Parsing Data
28 *
29 * Data parser allows to read instances from a specific format. libyang supports the following data formats:
30 *
31 * - XML
32 *
33 * Original data format used in NETCONF protocol. XML mapping is part of the YANG specification
34 * ([RFC 6020](http://tools.ietf.org/html/rfc6020)).
35 *
36 * - JSON
37 *
38 * The alternative data format available in RESTCONF protocol. Specification of JSON encoding of data modeled by YANG
39 * can be found in [RFC 7951](http://tools.ietf.org/html/rfc7951). The specification does not cover RPCs, actions and
40 * Notifications, so the representation of these data trees is proprietary and corresponds to the representation of these
41 * trees in XML.
42 *
43 * While the parsers themselves process the input data only syntactically, all the parser functions actually incorporate
44 * the [common validator](@ref howtoDataValidation) checking the input data semantically. Therefore, the parser functions
45 * accepts two groups of options - @ref dataparseroptions and @ref datavalidationoptions.
46 *
47 * In contrast to the schema parser, data parser also accepts empty input data if such an empty data tree is valid
48 * according to the schemas in the libyang context (i.e. there are no top level mandatory nodes).
49 *
50 * There are individual functions to process different types of the data instances trees:
51 * - ::lyd_parse_data() is intended for standard configuration data trees. According to the given
52 * [parser options](@ref dataparseroptions), the caller can further specify which kind of data tree is expected:
53 * - *complete :running datastore*: this is the default case, possibly with the use of (some of) the
54 * ::LYD_PARSE_STRICT, ::LYD_PARSE_OPAQ or ::LYD_VALIDATE_PRESENT options.
55 * - *complete configuration-only datastore* (such as :startup): in this case it is necessary to except all state data
56 * using ::LYD_PARSE_NO_STATE option.
57 * - *incomplete datastore*: there are situation when the data tree is incomplete or invalid by specification. For
58 * example the *:operational* datastore is not necessarily valid and results of the NETCONF's \<get\> or \<get-config\>
59 * oprations used with filters will be incomplete (and thus invalid). This can be allowed using ::LYD_PARSE_ONLY,
60 * the ::LYD_PARSE_NO_STATE should be used for the data returned by \<get-config\> operation.
Radek Krejcif16e2542021-02-17 15:39:23 +010061 * - ::lyd_parse_ext_data() is used for parsing configuration data trees defined inside extension instances, such as
62 * instances of yang-data extension specified in [RFC 8040](http://tools.ietf.org/html/rfc8040).
Michal Vaskoe0665742021-02-11 11:08:44 +010063 * - ::lyd_parse_op() is used for parsing RPCs/actions, replies, and notifications. Even NETCONF rpc, rpc-reply, and
Radek Krejcif16e2542021-02-17 15:39:23 +010064 * notification messages are supported.
65 * - ::lyd_parse_ext_op() is used for parsing RPCs/actions, replies, and notifications defined inside extension instances.
Radek Krejci8678fa42020-08-18 16:07:28 +020066 *
67 * Further information regarding the processing input instance data can be found on the following pages.
68 * - @subpage howtoDataValidation
69 * - @subpage howtoDataWD
70 *
71 * Functions List
72 * --------------
73 * - ::lyd_parse_data()
74 * - ::lyd_parse_data_mem()
75 * - ::lyd_parse_data_fd()
76 * - ::lyd_parse_data_path()
Radek Krejcif16e2542021-02-17 15:39:23 +010077 * - ::lyd_parse_ext_data()
Michal Vaskoe0665742021-02-11 11:08:44 +010078 * - ::lyd_parse_op()
Radek Krejcif16e2542021-02-17 15:39:23 +010079 * - ::lyd_parse_ext_op()
Radek Krejci8678fa42020-08-18 16:07:28 +020080 */
81
82/**
83 * @page howtoDataValidation Validating Data
84 *
85 * Data validation is performed implicitly to the input data processed by the [parser](@ref howtoDataParsers) and
86 * on demand via the lyd_validate_*() functions. The explicit validation process is supposed to be used when a (complex or
87 * simple) change is done on the data tree (via [data manipulation](@ref howtoDataManipulation) functions) and the data
88 * tree is expected to be valid (it doesn't make sense to validate modified result of filtered \<get\> operation).
89 *
90 * Similarly to the [data parser](@ref howtoDataParsers), there are individual functions to validate standard data tree
91 * (::lyd_validate_all()) and RPC, Action and Notification (::lyd_validate_op()). For the standard data trees, it is possible
92 * to modify the validation process by @ref datavalidationoptions. This way the state data can be prohibited
93 * (::LYD_VALIDATE_NO_STATE) and checking for mandatory nodes can be limited to the YANG modules with already present data
94 * instances (::LYD_VALIDATE_PRESENT). Validation of the standard data tree can be also limited with ::lyd_validate_module()
95 * function, which scopes only to a specified single YANG module.
96 *
97 * Since the operation data trees (RPCs, Actions or Notifications) can reference (leafref, instance-identifier, when/must
98 * expressions) data from a datastore tree, ::lyd_validate_op() may require additional data tree to be provided. This is a
99 * difference in contrast to the parsing process, when the data are loaded from an external source and invalid reference
100 * outside the operation tree is acceptable.
101 *
102 * Functions List
103 * --------------
104 * - ::lyd_validate_all()
105 * - ::lyd_validate_module()
106 * - ::lyd_validate_op()
107 */
108
109/**
Radek Krejci7931b192020-06-25 17:05:03 +0200110 * @addtogroup datatree
111 * @{
112 */
113
114/**
Radek Krejci8678fa42020-08-18 16:07:28 +0200115 * @ingroup datatree
Radek Krejci7931b192020-06-25 17:05:03 +0200116 * @defgroup dataparseroptions Data parser options
117 *
118 * Various options to change the data tree parsers behavior.
119 *
120 * Default parser behavior:
121 * - complete input file is always parsed. In case of XML, even not well-formed XML document (multiple top-level
122 * elements) is parsed in its entirety,
123 * - parser silently ignores data without matching schema node definition,
124 * - list instances are checked whether they have all the keys, error is raised if not.
125 *
126 * Default parser validation behavior:
127 * - the provided data are expected to provide complete datastore content (both the configuration and state data)
128 * and performs data validation according to all YANG rules, specifics follow,
129 * - list instances are expected to have all the keys (it is not checked),
130 * - instantiated (status) obsolete data print a warning,
131 * - all types are fully resolved (leafref/instance-identifier targets, unions) and must be valid (lists have
132 * all the keys, leaf(-lists) correct values),
133 * - when statements on existing nodes are evaluated, if not satisfied, a validation error is raised,
Radek Krejci7931b192020-06-25 17:05:03 +0200134 * - invalid multiple data instances/data from several cases cause a validation error,
Michal Vaskoa6669ba2020-08-06 16:14:26 +0200135 * - implicit nodes (NP containers and default values) are added.
Radek Krejci7931b192020-06-25 17:05:03 +0200136 * @{
137 */
138/* note: keep the lower 16bits free for use by LYD_VALIDATE_ flags. They are not supposed to be combined together,
139 * but since they are used (as a separate parameter) together in some functions, we want to keep them in a separated
140 * range to be able detect that the caller put wrong flags into the parser/validate options parameter. */
141#define LYD_PARSE_ONLY 0x010000 /**< Data will be only parsed and no validation will be performed. When statements
Michal Vaskoa65c72c2022-02-17 16:20:18 +0100142 are kept unevaluated, union types may not be fully resolved, and
143 default values are not added (only the ones parsed are present). */
Michal Vasko0f3377d2020-11-09 20:56:11 +0100144#define LYD_PARSE_STRICT 0x020000 /**< Instead of silently ignoring data without schema definition raise an error.
Michal Vasko369f7a62021-02-01 08:59:36 +0100145 Do not combine with ::LYD_PARSE_OPAQ (except for ::LYD_LYB). */
Michal Vasko0f3377d2020-11-09 20:56:11 +0100146#define LYD_PARSE_OPAQ 0x040000 /**< Instead of silently ignoring data without definition, parse them into
Michal Vasko369f7a62021-02-01 08:59:36 +0100147 an opaq node. Do not combine with ::LYD_PARSE_STRICT (except for ::LYD_LYB). */
148#define LYD_PARSE_NO_STATE 0x080000 /**< Forbid state data in the parsed data. Usually used with ::LYD_VALIDATE_NO_STATE. */
Radek Krejci7931b192020-06-25 17:05:03 +0200149
Michal Vasko0f3377d2020-11-09 20:56:11 +0100150#define LYD_PARSE_LYB_MOD_UPDATE 0x100000 /**< Only for LYB format, allow parsing data printed using a specific module
Radek Krejci7931b192020-06-25 17:05:03 +0200151 revision to be loaded even with a module with the same name but newer
152 revision. */
Michal Vasko6ee6f432021-07-16 09:49:14 +0200153#define LYD_PARSE_ORDERED 0x200000 /**< Do not search for the correct place of each node but instead expect
154 that the nodes are being parsed in the correct schema-based order,
155 which is always true if the data were printed by libyang and not
156 modified manually. If this flag is used incorrectly (for unordered data),
157 the behavior is undefined and most functions executed with these
158 data will not work correctly. */
Michal Vaskoddd76592022-01-17 13:34:48 +0100159#define LYD_PARSE_SUBTREE 0x400000 /**< Parse only the current data subtree with any descendants, no siblings.
160 Also, a new return value ::LY_ENOT is returned if there is a sibling
161 subtree following in the input data. */
Michal Vaskoafac7822020-10-20 14:22:26 +0200162
163#define LYD_PARSE_OPTS_MASK 0xFFFF0000 /**< Mask for all the LYD_PARSE_ options. */
164
Radek Krejci7931b192020-06-25 17:05:03 +0200165/** @} dataparseroptions */
166
Radek Krejci7931b192020-06-25 17:05:03 +0200167/**
Radek Krejci7931b192020-06-25 17:05:03 +0200168 * @ingroup datatree
Radek Krejci8678fa42020-08-18 16:07:28 +0200169 * @defgroup datavalidationoptions Data validation options
Radek Krejci7931b192020-06-25 17:05:03 +0200170 *
171 * Various options to change data validation behaviour, both for the parser and separate validation.
172 *
173 * Default separate validation behavior:
174 * - the provided data are expected to provide complete datastore content (both the configuration and state data)
175 * and performs data validation according to all YANG rules, specifics follow,
176 * - instantiated (status) obsolete data print a warning,
177 * - all types are fully resolved (leafref/instance-identifier targets, unions) and must be valid (lists have
178 * all the keys, leaf(-lists) correct values),
179 * - when statements on existing nodes are evaluated. Depending on the previous when state (from previous validation
180 * or parsing), the node is silently auto-deleted if the state changed from true to false, otherwise a validation error
181 * is raised if it evaluates to false,
182 * - if-feature statements are evaluated,
183 * - data from several cases behave based on their previous state (from previous validation or parsing). If there existed
184 * already a case and another one was added, the previous one is silently auto-deleted. Otherwise (if data from 2 or
185 * more cases were created) a validation error is raised,
186 * - default values are added.
187 *
188 * @{
189 */
Michal Vasko369f7a62021-02-01 08:59:36 +0100190#define LYD_VALIDATE_NO_STATE 0x0001 /**< Consider state data not allowed and raise an error if they are found.
191 Also, no implicit state data are added. */
Michal Vaskoafac7822020-10-20 14:22:26 +0200192#define LYD_VALIDATE_PRESENT 0x0002 /**< Validate only modules whose data actually exist. */
193
194#define LYD_VALIDATE_OPTS_MASK 0x0000FFFF /**< Mask for all the LYD_VALIDATE_* options. */
Radek Krejci7931b192020-06-25 17:05:03 +0200195
196/** @} datavalidationoptions */
197
198/**
Radek Krejci7931b192020-06-25 17:05:03 +0200199 * @brief Parse (and validate) data from the input handler as a YANG data tree.
200 *
201 * @param[in] ctx Context to connect with the tree being built here.
Michal Vaskoe0665742021-02-11 11:08:44 +0100202 * @param[in] parent Optional parent to connect the parsed nodes to.
Radek Krejci7931b192020-06-25 17:05:03 +0200203 * @param[in] in The input handle to provide the dumped data in the specified @p format to parse (and validate).
204 * @param[in] format Format of the input data to be parsed. Can be 0 to try to detect format from the input handler.
205 * @param[in] parse_options Options for parser, see @ref dataparseroptions.
206 * @param[in] validate_options Options for the validation phase, see @ref datavalidationoptions.
Michal Vaskoe0665742021-02-11 11:08:44 +0100207 * @param[out] tree Full parsed data tree, note that NULL can be a valid tree. If @p parent is set, set to NULL.
Radek Krejci7931b192020-06-25 17:05:03 +0200208 * @return LY_SUCCESS in case of successful parsing (and validation).
Michal Vasko6d497662020-07-08 10:42:57 +0200209 * @return LY_ERR value in case of error. Additional error information can be obtained from the context using ly_err* functions.
Radek Krejci7931b192020-06-25 17:05:03 +0200210 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100211LIBYANG_API_DECL LY_ERR lyd_parse_data(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
Michal Vaskoe0665742021-02-11 11:08:44 +0100212 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200213
214/**
215 * @brief Parse (and validate) input data as a YANG data tree.
216 *
Michal Vaskoe0665742021-02-11 11:08:44 +0100217 * Wrapper around ::lyd_parse_data() hiding work with the input handler and some obscure options.
Radek Krejci7931b192020-06-25 17:05:03 +0200218 *
219 * @param[in] ctx Context to connect with the tree being built here.
220 * @param[in] data The input data in the specified @p format to parse (and validate).
Michal Vasko107c8162021-09-23 11:21:53 +0200221 * @param[in] format Format of the input data to be parsed.
Radek Krejci7931b192020-06-25 17:05:03 +0200222 * @param[in] parse_options Options for parser, see @ref dataparseroptions.
223 * @param[in] validate_options Options for the validation phase, see @ref datavalidationoptions.
Michal Vaskoe0665742021-02-11 11:08:44 +0100224 * @param[out] tree Full parsed data tree, note that NULL can be a valid tree
Radek Krejci7931b192020-06-25 17:05:03 +0200225 * @return LY_SUCCESS in case of successful parsing (and validation).
Michal Vasko6d497662020-07-08 10:42:57 +0200226 * @return LY_ERR value in case of error. Additional error information can be obtained from the context using ly_err* functions.
Radek Krejci7931b192020-06-25 17:05:03 +0200227 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100228LIBYANG_API_DECL LY_ERR lyd_parse_data_mem(const struct ly_ctx *ctx, const char *data, LYD_FORMAT format, uint32_t parse_options,
Radek Krejci1deb5be2020-08-26 16:43:36 +0200229 uint32_t validate_options, struct lyd_node **tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200230
231/**
232 * @brief Parse (and validate) input data as a YANG data tree.
233 *
Michal Vaskoe0665742021-02-11 11:08:44 +0100234 * Wrapper around ::lyd_parse_data() hiding work with the input handler and some obscure options.
Radek Krejci7931b192020-06-25 17:05:03 +0200235 *
236 * @param[in] ctx Context to connect with the tree being built here.
Michal Vaskoe0665742021-02-11 11:08:44 +0100237 * @param[in] fd File descriptor of a regular file (e.g. sockets are not supported) containing the input data in the
238 * specified @p format to parse.
Michal Vasko107c8162021-09-23 11:21:53 +0200239 * @param[in] format Format of the input data to be parsed.
Radek Krejci7931b192020-06-25 17:05:03 +0200240 * @param[in] parse_options Options for parser, see @ref dataparseroptions.
241 * @param[in] validate_options Options for the validation phase, see @ref datavalidationoptions.
Michal Vaskoe0665742021-02-11 11:08:44 +0100242 * @param[out] tree Full parsed data tree, note that NULL can be a valid tree
Radek Krejci7931b192020-06-25 17:05:03 +0200243 * @return LY_SUCCESS in case of successful parsing (and validation).
Michal Vasko6d497662020-07-08 10:42:57 +0200244 * @return LY_ERR value in case of error. Additional error information can be obtained from the context using ly_err* functions.
Radek Krejci7931b192020-06-25 17:05:03 +0200245 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100246LIBYANG_API_DECL LY_ERR lyd_parse_data_fd(const struct ly_ctx *ctx, int fd, LYD_FORMAT format, uint32_t parse_options,
Michal Vaskoe0665742021-02-11 11:08:44 +0100247 uint32_t validate_options, struct lyd_node **tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200248
249/**
250 * @brief Parse (and validate) input data as a YANG data tree.
251 *
Michal Vaskoe0665742021-02-11 11:08:44 +0100252 * Wrapper around ::lyd_parse_data() hiding work with the input handler and some obscure options.
Radek Krejci7931b192020-06-25 17:05:03 +0200253 *
254 * @param[in] ctx Context to connect with the tree being built here.
255 * @param[in] path Path to the file with the input data in the specified @p format to parse (and validate).
Michal Vasko107c8162021-09-23 11:21:53 +0200256 * @param[in] format Format of the input data to be parsed. Can be 0 to try to detect format from @p path extension.
Radek Krejci7931b192020-06-25 17:05:03 +0200257 * @param[in] parse_options Options for parser, see @ref dataparseroptions.
258 * @param[in] validate_options Options for the validation phase, see @ref datavalidationoptions.
Michal Vaskoe0665742021-02-11 11:08:44 +0100259 * @param[out] tree Full parsed data tree, note that NULL can be a valid tree
Radek Krejci7931b192020-06-25 17:05:03 +0200260 * @return LY_SUCCESS in case of successful parsing (and validation).
Michal Vasko6d497662020-07-08 10:42:57 +0200261 * @return LY_ERR value in case of error. Additional error information can be obtained from the context using ly_err* functions.
Radek Krejci7931b192020-06-25 17:05:03 +0200262 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100263LIBYANG_API_DECL LY_ERR lyd_parse_data_path(const struct ly_ctx *ctx, const char *path, LYD_FORMAT format,
264 uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree);
Radek Krejci7931b192020-06-25 17:05:03 +0200265
266/**
Radek Krejci75104122021-04-01 15:37:45 +0200267 * @brief Parse (and validate) data from the input handler as an extension data tree following the schema tree of the given
Radek Krejcif16e2542021-02-17 15:39:23 +0100268 * extension instance.
269 *
270 * Note that the data being parsed are limited only to the schema tree specified by the given extension, it does not allow
271 * to mix them with the standard data from any module.
272 *
Radek Krejci75104122021-04-01 15:37:45 +0200273 * Directly applicable to data defined as [yang-data](@ref howtoDataYangdata).
274 *
Radek Krejcif16e2542021-02-17 15:39:23 +0100275 * @param[in] ext Extension instance providing the specific schema tree to match with the data being parsed.
276 * @param[in] parent Optional parent to connect the parsed nodes to.
277 * @param[in] in The input handle to provide the dumped data in the specified @p format to parse (and validate).
278 * @param[in] format Format of the input data to be parsed. Can be 0 to try to detect format from the input handler.
279 * @param[in] parse_options Options for parser, see @ref dataparseroptions.
280 * @param[in] validate_options Options for the validation phase, see @ref datavalidationoptions.
281 * @param[out] tree Full parsed data tree, note that NULL can be a valid tree. If @p parent is set, set to NULL.
282 * @return LY_SUCCESS in case of successful parsing (and validation).
283 * @return LY_ERR value in case of error. Additional error information can be obtained from the context using ly_err* functions.
284 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100285LIBYANG_API_DECL LY_ERR lyd_parse_ext_data(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in,
286 LYD_FORMAT format, uint32_t parse_options, uint32_t validate_options, struct lyd_node **tree);
Radek Krejcif16e2542021-02-17 15:39:23 +0100287
288/**
Michal Vaskoe0665742021-02-11 11:08:44 +0100289 * @ingroup datatree
290 * @defgroup datatype Data operation type
Radek Krejci7931b192020-06-25 17:05:03 +0200291 *
Michal Vaskoe0665742021-02-11 11:08:44 +0100292 * Operation provided to ::lyd_validate_op() to validate.
293 *
294 * The operation cannot be determined automatically since RPC/action and a reply to it share the common top level node
295 * referencing the RPC/action schema node and may not have any input/output children to use for distinction.
296 *
297 * @{
Radek Krejci7931b192020-06-25 17:05:03 +0200298 */
Michal Vaskoe0665742021-02-11 11:08:44 +0100299enum lyd_type {
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100300 LYD_TYPE_DATA_YANG = 0, /* generic YANG instance data */
301 LYD_TYPE_RPC_YANG, /* instance of a YANG RPC/action request with only "input" data children,
302 including all parents in case of an action */
303 LYD_TYPE_NOTIF_YANG, /* instance of a YANG notification , including all parents in case of a nested one */
304 LYD_TYPE_REPLY_YANG, /* instance of a YANG RPC/action reply with only "output" data children,
305 including all parents in case of an action */
306
307 LYD_TYPE_RPC_NETCONF, /* complete NETCONF RPC invocation as defined for
308 [RPC](https://tools.ietf.org/html/rfc7950#section-7.14.4) and
309 [action](https://tools.ietf.org/html/rfc7950#section-7.15.2) */
310 LYD_TYPE_NOTIF_NETCONF, /* complete NETCONF notification message as defined for
311 [notification](https://tools.ietf.org/html/rfc7950#section-7.16.2) */
312 LYD_TYPE_REPLY_NETCONF /* complete NETCONF RPC reply as defined for
313 [RPC](https://tools.ietf.org/html/rfc7950#section-7.14.4) and
314 [action](https://tools.ietf.org/html/rfc7950#section-7.15.2) */
Michal Vaskoe0665742021-02-11 11:08:44 +0100315};
316/** @} datatype */
Radek Krejci7931b192020-06-25 17:05:03 +0200317
318/**
Michal Vaskoe0665742021-02-11 11:08:44 +0100319 * @brief Parse YANG data into an operation data tree.
Radek Krejci7931b192020-06-25 17:05:03 +0200320 *
Michal Vaskoe0665742021-02-11 11:08:44 +0100321 * At least one of @p parent, @p tree, or @p op must always be set.
Radek Krejci7931b192020-06-25 17:05:03 +0200322 *
Michal Vaskoe0665742021-02-11 11:08:44 +0100323 * Specific @p data_type values have different parameter meaning as follows:
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100324 * - ::LYD_TYPE_RPC_NETCONF:
Michal Vaskoe0665742021-02-11 11:08:44 +0100325 * - @p parent - must be NULL, the whole RPC is expected;
326 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
327 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
Michal Vasko299d5d12021-02-16 16:36:37 +0100328 * a separate opaque data tree, even if the function fails, this may be returned;
Michal Vaskoe0665742021-02-11 11:08:44 +0100329 * - @p op - must be provided, the RPC/action data tree itself will be returned here, pointing to the operation;
330 *
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100331 * - ::LYD_TYPE_NOTIF_NETCONF:
332 * - @p parent - must be NULL, the whole notification is expected;
333 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
334 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
Michal Vaskof4da8892021-02-19 09:15:18 +0100335 * a separate opaque data tree, even if the function fails, this may be returned;
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100336 * - @p op - must be provided, the notification data tree itself will be returned here, pointing to the operation;
337 *
338 * - ::LYD_TYPE_REPLY_NETCONF:
Michal Vaskoe0665742021-02-11 11:08:44 +0100339 * - @p parent - must be set, pointing to the invoked RPC operation (RPC or action) node;
340 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
341 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
Michal Vaskof4da8892021-02-19 09:15:18 +0100342 * a separate opaque data tree, even if the function fails, this may be returned;
Michal Vasko1e4c68e2021-02-18 15:03:01 +0100343 * - @p op - must be NULL, the reply is appended to the RPC;
344 * Note that there are 3 kinds of NETCONF replies - ok, error, and data. Only data reply appends any nodes to the RPC.
Michal Vaskoe0665742021-02-11 11:08:44 +0100345 *
346 * @param[in] ctx libyang context.
347 * @param[in] parent Optional parent to connect the parsed nodes to.
348 * @param[in] in Input handle to read the input from.
349 * @param[in] format Expected format of the data in @p in.
350 * @param[in] data_type Expected operation to parse (@ref datatype).
351 * @param[out] tree Optional full parsed data tree. If @p parent is set, set to NULL.
Michal Vasko438b5292021-06-09 14:31:25 +0200352 * @param[out] op Optional pointer to the operation (action/RPC) node.
Michal Vaskoe0665742021-02-11 11:08:44 +0100353 * @return LY_ERR value.
Michal Vaskob7dba862021-02-18 16:10:02 +0100354 * @return LY_ENOT if @p data_type is a NETCONF message and the root XML element is not the expected one.
Radek Krejci7931b192020-06-25 17:05:03 +0200355 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100356LIBYANG_API_DECL LY_ERR lyd_parse_op(const struct ly_ctx *ctx, struct lyd_node *parent, struct ly_in *in, LYD_FORMAT format,
Michal Vaskoe0665742021-02-11 11:08:44 +0100357 enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op);
Radek Krejci7931b192020-06-25 17:05:03 +0200358
359/**
Radek Krejci75104122021-04-01 15:37:45 +0200360 * @brief Parse extension data into an operation data tree following only the specification from the given extension instance.
361 *
362 * Directly applicable to data defined as [yang-data](@ref howtoDataYangdata).
Radek Krejcif16e2542021-02-17 15:39:23 +0100363 *
364 * At least one of @p parent, @p tree, or @p op must always be set.
365 *
366 * Specific @p data_type values have different parameter meaning as follows:
367 * - ::LYD_TYPE_RPC_NETCONF:
368 * - @p parent - must be NULL, the whole RPC is expected;
369 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
370 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
371 * a separate opaque data tree, even if the function fails, this may be returned;
372 * - @p op - must be provided, the RPC/action data tree itself will be returned here, pointing to the operation;
373 *
374 * - ::LYD_TYPE_NOTIF_NETCONF:
375 * - @p parent - must be NULL, the whole notification is expected;
376 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
377 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
378 * a separate opaque data tree, even if the function fails, this may be returned;
379 * - @p op - must be provided, the notification data tree itself will be returned here, pointing to the operation;
380 *
381 * - ::LYD_TYPE_REPLY_NETCONF:
382 * - @p parent - must be set, pointing to the invoked RPC operation (RPC or action) node;
383 * - @p format - must be ::LYD_XML, NETCONF supports only this format;
384 * - @p tree - must be provided, all the NETCONF-specific XML envelopes will be returned here as
385 * a separate opaque data tree, even if the function fails, this may be returned;
386 * - @p op - must be NULL, the reply is appended to the RPC;
387 * Note that there are 3 kinds of NETCONF replies - ok, error, and data. Only data reply appends any nodes to the RPC.
388 *
389 * @param[in] ext Extension instance providing the specific schema tree to match with the data being parsed.
390 * @param[in] parent Optional parent to connect the parsed nodes to.
391 * @param[in] in Input handle to read the input from.
392 * @param[in] format Expected format of the data in @p in.
393 * @param[in] data_type Expected operation to parse (@ref datatype).
394 * @param[out] tree Optional full parsed data tree. If @p parent is set, set to NULL.
Michal Vasko438b5292021-06-09 14:31:25 +0200395 * @param[out] op Optional pointer to the operation (action/RPC) node.
Radek Krejcif16e2542021-02-17 15:39:23 +0100396 * @return LY_ERR value.
397 * @return LY_ENOT if @p data_type is a NETCONF message and the root XML element is not the expected one.
398 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100399LIBYANG_API_DECL LY_ERR lyd_parse_ext_op(const struct lysc_ext_instance *ext, struct lyd_node *parent, struct ly_in *in,
400 LYD_FORMAT format, enum lyd_type data_type, struct lyd_node **tree, struct lyd_node **op);
Radek Krejcif16e2542021-02-17 15:39:23 +0100401
402/**
Radek Krejci7931b192020-06-25 17:05:03 +0200403 * @brief Fully validate a data tree.
404 *
Michal Vaskoddd76592022-01-17 13:34:48 +0100405 * The data tree is modified in-place. As a result of the validation, some data might be removed
Jan Kundrát94747632021-10-14 16:23:09 +0200406 * from the tree. In that case, the removed items are freed, not just unlinked.
407 *
408 * @param[in,out] tree Data tree to recursively validate. May be changed by validation, might become NULL.
Radek Krejci7931b192020-06-25 17:05:03 +0200409 * @param[in] ctx libyang context. Can be NULL if @p tree is set.
410 * @param[in] val_opts Validation options (@ref datavalidationoptions).
Michal Vasko8104fd42020-07-13 11:09:51 +0200411 * @param[out] diff Optional diff with any changes made by the validation.
Radek Krejci7931b192020-06-25 17:05:03 +0200412 * @return LY_SUCCESS on success.
413 * @return LY_ERR error on error.
414 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100415LIBYANG_API_DECL LY_ERR lyd_validate_all(struct lyd_node **tree, const struct ly_ctx *ctx, uint32_t val_opts,
416 struct lyd_node **diff);
Radek Krejci7931b192020-06-25 17:05:03 +0200417
418/**
Michal Vasko26e80012020-07-08 10:55:46 +0200419 * @brief Fully validate a data tree of a module.
Radek Krejci7931b192020-06-25 17:05:03 +0200420 *
Michal Vaskoddd76592022-01-17 13:34:48 +0100421 * The data tree is modified in-place. As a result of the validation, some data might be removed
Jan Kundrát94747632021-10-14 16:23:09 +0200422 * from the tree. In that case, the removed items are freed, not just unlinked.
423 *
424 * @param[in,out] tree Data tree to recursively validate. May be changed by validation, might become NULL.
Michal Vasko26e80012020-07-08 10:55:46 +0200425 * @param[in] module Module whose data (and schema restrictions) to validate.
Radek Krejci7931b192020-06-25 17:05:03 +0200426 * @param[in] val_opts Validation options (@ref datavalidationoptions).
Michal Vasko8104fd42020-07-13 11:09:51 +0200427 * @param[out] diff Optional diff with any changes made by the validation.
Radek Krejci7931b192020-06-25 17:05:03 +0200428 * @return LY_SUCCESS on success.
429 * @return LY_ERR error on error.
430 */
Michal Vaskoddd76592022-01-17 13:34:48 +0100431LIBYANG_API_DECL LY_ERR lyd_validate_module(struct lyd_node **tree, const struct lys_module *module, uint32_t val_opts,
432 struct lyd_node **diff);
Radek Krejci7931b192020-06-25 17:05:03 +0200433
434/**
Michal Vasko0bec3222022-04-22 07:46:00 +0200435 * @brief Validate an RPC/action request, reply, or notification. Only the operation data tree (input/output/notif)
436 * is validate, any parents are ignored.
Radek Krejci7931b192020-06-25 17:05:03 +0200437 *
438 * @param[in,out] op_tree Operation tree with any parents. It can point to the operation itself or any of
439 * its parents, only the operation subtree is actually validated.
Michal Vaskoe0665742021-02-11 11:08:44 +0100440 * @param[in] dep_tree Tree to be used for validating references from the operation subtree.
441 * @param[in] data_type Operation type to validate (only YANG operations are accepted, @ref datatype).
Michal Vasko8104fd42020-07-13 11:09:51 +0200442 * @param[out] diff Optional diff with any changes made by the validation.
Radek Krejci7931b192020-06-25 17:05:03 +0200443 * @return LY_SUCCESS on success.
444 * @return LY_ERR error on error.
445 */
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100446LIBYANG_API_DECL LY_ERR lyd_validate_op(struct lyd_node *op_tree, const struct lyd_node *dep_tree, enum lyd_type data_type,
Michal Vaskoe0665742021-02-11 11:08:44 +0100447 struct lyd_node **diff);
Radek Krejci7931b192020-06-25 17:05:03 +0200448
449/** @} datatree */
450
451#ifdef __cplusplus
452}
453#endif
454
455#endif /* LY_PARSER_DATA_H_ */