blob: 373b00051d095ecfc8ab272e8e25b55836898bd2 [file] [log] [blame]
Radek Krejci70853c52018-10-15 14:46:16 +02001/**
2 * @file tree_schema_internal.h
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief internal functions for YANG schema trees.
5 *
6 * Copyright (c) 2015 - 2018 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
15#ifndef LY_TREE_SCHEMA_INTERNAL_H_
16#define LY_TREE_SCHEMA_INTERNAL_H_
17
Radek Krejcid33273d2018-10-25 14:55:52 +020018#define LOGVAL_YANG(CTX, ...) LOGVAL((CTX)->ctx, LY_VLOG_LINE, &(CTX)->line, __VA_ARGS__)
19
Radek Krejci70853c52018-10-15 14:46:16 +020020/**
Radek Krejcie3846472018-10-15 15:24:51 +020021 * @brief List of YANG statement groups - the (sub)module's substatements
22 */
23enum yang_module_stmt {
24 Y_MOD_MODULE_HEADER,
25 Y_MOD_LINKAGE,
26 Y_MOD_META,
27 Y_MOD_REVISION,
28 Y_MOD_BODY
29};
30
31/**
32 * @brief Types of arguments of YANG statements
33 */
34enum yang_arg {
35 Y_IDENTIF_ARG, /**< YANG "identifier-arg-str" rule */
36 Y_PREF_IDENTIF_ARG, /**< YANG "identifier-ref-arg-str" rule */
37 Y_STR_ARG, /**< YANG "string" rule */
38 Y_MAYBE_STR_ARG /**< optional YANG "string" rule */
39};
40
41/**
Radek Krejci70853c52018-10-15 14:46:16 +020042 * @brief internal context for schema parsers
43 */
44struct ly_parser_ctx {
45 struct ly_ctx *ctx;
Radek Krejcifaa1eac2018-10-30 14:34:55 +010046 struct lysp_module *mod;
Radek Krejcibbe09a92018-11-08 09:36:54 +010047 struct ly_set tpdfs_nodes;
48 struct ly_set grps_nodes;
49 uint64_t line; /**< line number */
50 uint64_t indent; /**< current position on the line for YANG indentation */
Radek Krejci70853c52018-10-15 14:46:16 +020051};
52
53/**
Radek Krejci4f28eda2018-11-12 11:46:16 +010054 * @brief internal context for compilation
55 */
56struct lysc_ctx {
57 struct ly_ctx *ctx;
58 struct lys_module *mod;
Radek Krejcia3045382018-11-22 14:30:31 +010059 struct ly_set unres; /* to validate leafref's target and xpath of when/must */
Radek Krejci4f28eda2018-11-12 11:46:16 +010060 uint16_t path_len;
61#define LYSC_CTX_BUFSIZE 4078
62 char path[LYSC_CTX_BUFSIZE];
63};
64
65/**
Radek Krejci70853c52018-10-15 14:46:16 +020066 * @brief Check the currently present prefixes in the module for collision with the new one.
67 *
Radek Krejcibbe09a92018-11-08 09:36:54 +010068 * @param[in] ctx Context for logging.
Radek Krejci70853c52018-10-15 14:46:16 +020069 * @param[in] module Schema tree to check.
70 * @param[in] value Newly added prefix value (including its location to distinguish collision with itself).
71 * @return LY_EEXIST when prefix is already used in the module, LY_SUCCESS otherwise
72 */
73LY_ERR lysp_check_prefix(struct ly_parser_ctx *ctx, struct lysp_module *module, const char **value);
74
Radek Krejci86d106e2018-10-18 09:53:19 +020075/**
76 * @brief Check date string (4DIGIT "-" 2DIGIT "-" 2DIGIT)
77 *
Radek Krejcibbe09a92018-11-08 09:36:54 +010078 * @param[in] ctx Optional context for logging.
Radek Krejci86d106e2018-10-18 09:53:19 +020079 * @param[in] date Date string to check (non-necessarily terminated by \0)
80 * @param[in] date_len Length of the date string, 10 expected.
81 * @param[in] stmt Statement name for error message.
82 * @return LY_ERR value.
83 */
Radek Krejcibbe09a92018-11-08 09:36:54 +010084LY_ERR lysp_check_date(struct ly_parser_ctx *ctx, const char *date, int date_len, const char *stmt);
85
86/**
87 * @brief Check names of typedefs in the parsed module to detect collisions.
88 *
89 * @param[in] ctx Parser context, module where the type is being defined is taken from here.
90 * @return LY_ERR value.
91 */
92LY_ERR lysp_check_typedefs(struct ly_parser_ctx *ctx);
Radek Krejci86d106e2018-10-18 09:53:19 +020093
94/**
95 * @brief Just move the newest revision into the first position, does not sort the rest
96 * @param[in] revs Sized-array of the revisions in a printable schema tree.
97 */
98void lysp_sort_revisions(struct lysp_revision *revs);
99
100/**
Radek Krejcibbe09a92018-11-08 09:36:54 +0100101 * @brief Find type specified type definition
102 *
103 * @param[in] id Name of the type including possible prefix. Module where the prefix is being searched is start_module.
104 * @param[in] start_node Context node where the type is being instantiated to be able to search typedefs in parents.
105 * @param[in] start_module Module where the type is being instantiated for search for typedefs.
Radek Krejci4f28eda2018-11-12 11:46:16 +0100106 * @param[out] type Built-in type identifier of the id. If #LY_TYPE_UNKNOWN, tpdf is expected to contain found YANG schema typedef statement.
Radek Krejcibbe09a92018-11-08 09:36:54 +0100107 * @param[out] tpdf Found type definition.
108 * @param[out] node Node where the found typedef is defined, NULL in case of a top-level typedef.
109 * @param[out] module Module where the found typedef is being defined, NULL in case of built-in YANG types.
110 */
111LY_ERR lysp_type_find(const char *id, struct lysp_node *start_node, struct lysp_module *start_module,
Radek Krejci4f28eda2018-11-12 11:46:16 +0100112 LY_DATA_TYPE *type, const struct lysp_tpdf **tpdf, struct lysp_node **node, struct lysp_module **module);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100113
114/**
Radek Krejci086c7132018-10-26 15:29:04 +0200115 * @brief Find and parse module of the given name.
116 *
117 * @param[in] ctx libyang context.
118 * @param[in] name Name of the module to load.
119 * @param[in] revison Optional revision of the module to load. If NULL, the newest revision is loaded.
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100120 * @param[in] implement Flag if the loaded module is supposed to be marked as implemented.
121 * @param[in] require_parsed Flag to require parsed module structure in case the module is already in the context,
122 * but only the compiled structure is available.
Radek Krejci086c7132018-10-26 15:29:04 +0200123 * @param[out] mod Parsed module structure.
124 * @return LY_ERR value.
125 */
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100126LY_ERR lysp_load_module(struct ly_ctx *ctx, const char *name, const char *revision, int implement, int require_parsed, struct lys_module **mod);
Radek Krejci086c7132018-10-26 15:29:04 +0200127
128/**
Radek Krejcid33273d2018-10-25 14:55:52 +0200129 * @brief Parse included submodule into the simply parsed YANG module.
130 *
Radek Krejci3b1f9292018-11-08 10:58:35 +0100131 * @param[in] ctx parser context
Radek Krejcid33273d2018-10-25 14:55:52 +0200132 * @param[in] mod Module including a submodule.
Radek Krejcid33273d2018-10-25 14:55:52 +0200133 * @param[in,out] inc Include structure holding all available information about the include statement, the parsed
134 * submodule is stored into this structure.
135 * @return LY_ERR value.
136 */
Radek Krejci3b1f9292018-11-08 10:58:35 +0100137LY_ERR lysp_load_submodule(struct ly_parser_ctx *ctx, struct lysp_module *mod, struct lysp_include *inc);
Radek Krejcid33273d2018-10-25 14:55:52 +0200138
139/**
Radek Krejcibbe09a92018-11-08 09:36:54 +0100140 * @brief Get address of a node's typedefs list if any.
141 *
142 * Decides the node's type and in case it has an typedefs list, returns its address.
143 * @param[in] node Node to check.
144 * @return Address of the node's tpdf member if any, NULL otherwise.
145 */
146struct lysp_tpdf **lysp_node_typedefs(struct lysp_node *node);
147
148/**
149 * @brief Get address of a node's actions list if any.
150 *
151 * Decides the node's type and in case it has an actions list, returns its address.
152 * @param[in] node Node to check.
153 * @return Address of the node's actions member if any, NULL otherwise.
154 */
155struct lysp_action **lysp_node_actions(struct lysp_node *node);
156
157/**
158 * @brief Get address of a node's notifications list if any.
159 *
160 * Decides the node's type and in case it has a notifications list, returns its address.
161 * @param[in] node Node to check.
162 * @return Address of the node's notifs member if any, NULL otherwise.
163 */
164struct lysp_notif **lysp_node_notifs(struct lysp_node *node);
165
166/**
167 * @brief Get address of a node's child pointer if any.
168 *
169 * Decides the node's type and in case it has a children list, returns its address.
170 * @param[in] node Node to check.
171 * @return Address of the node's child member if any, NULL otherwise.
172 */
173struct lysp_node **lysp_node_children(struct lysp_node *node);
174
175/**
176 * @brief Get address of a node's child pointer if any.
177 *
178 * Decides the node's type and in case it has a children list, returns its address.
179 * @param[in] node Node to check.
180 * @return Address of the node's child member if any, NULL otherwise.
181 */
Radek Krejcia3045382018-11-22 14:30:31 +0100182struct lysc_node **lysc_node_children(const struct lysc_node *node);
183
184/**
185 * @brief Get address of a node's iffeatures pointer if any.
186 * @param[in] node Node to check.
187 * @return Address of the node's iffeature member if any, NULL otherwise.
188 */
189struct lysc_iffeature **lysc_node_iff(const struct lysc_node *node);
Radek Krejcibbe09a92018-11-08 09:36:54 +0100190
191/**
Radek Krejci96a0bfd2018-11-22 15:25:06 +0100192 * @brief Get the covering schema module structure for the given parsed module structure.
193 * @param[in] ctx libyang context to search.
194 * @param[in] mod Parsed schema structure.
195 * @return Corresponding lys_module structure for the given parsed schema structure.
196 */
197struct lys_module *lysp_find_module(struct ly_ctx *ctx, const struct lysp_module *mod);
198
199/**
Radek Krejcice8c1592018-10-29 15:35:51 +0100200 * @brief Find the module referenced by prefix in the provided parsed mod.
201 *
202 * @param[in] mod Schema module where the prefix was used.
203 * @param[in] prefix Prefix used to reference a module.
204 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
205 * @return Pointer to the module or NULL if the module is not found.
206 */
Radek Krejcia3045382018-11-22 14:30:31 +0100207struct lysp_module *lysp_module_find_prefix(const struct lysp_module *mod, const char *prefix, size_t len);
Radek Krejcice8c1592018-10-29 15:35:51 +0100208
209/**
210 * @brief Find the module referenced by prefix in the provided compiled mod.
211 *
212 * @param[in] mod Schema module where the prefix was used.
213 * @param[in] prefix Prefix used to reference a module.
214 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
215 * @return Pointer to the module or NULL if the module is not found.
216 */
Radek Krejcia3045382018-11-22 14:30:31 +0100217struct lysc_module *lysc_module_find_prefix(const struct lysc_module *mod, const char *prefix, size_t len);
Radek Krejcice8c1592018-10-29 15:35:51 +0100218
219/**
Radek Krejci4f28eda2018-11-12 11:46:16 +0100220 * @brief Check statement's status for invalid combination.
221 *
222 * The modX parameters are used just to determine if both flags are in the same module,
223 * so any of the schema module structure can be used, but both modules must be provided
224 * in the same type.
225 *
226 * @param[in] ctx Compile context for logging.
227 * @param[in] flags1 Flags of the referencing node.
228 * @param[in] mod1 Module of the referencing node,
229 * @param[in] name1 Schema node name of the referencing node.
230 * @param[in] flags2 Flags of the referenced node.
231 * @param[in] mod2 Module of the referenced node,
232 * @param[in] name2 Schema node name of the referenced node.
233 * @return LY_ERR value
234 */
235LY_ERR lysc_check_status(struct lysc_ctx *ctx,
236 uint16_t flags1, void *mod1, const char *name1,
237 uint16_t flags2, void *mod2, const char *name2);
238
239/**
Radek Krejcia3045382018-11-22 14:30:31 +0100240 * @brief Parse a node-identifier.
241 *
242 * node-identifier = [prefix ":"] identifier
243 *
244 * @param[in, out] id Identifier to parse. When returned, it points to the first character which is not part of the identifier.
245 * @param[out] prefix Node's prefix, NULL if there is not any.
246 * @param[out] prefix_len Length of the node's prefix, 0 if there is not any.
247 * @param[out] name Node's name.
248 * @param[out] nam_len Length of the node's name.
249 * @return LY_ERR value: LY_SUCCESS or LY_EINVAL in case of invalid character in the id.
250 */
251LY_ERR lys_parse_nodeid(const char **id, const char **prefix, size_t *prefix_len, const char **name, size_t *name_len);
252
253/**
Radek Krejci151a5b72018-10-19 14:21:44 +0200254 * @brief Find the module referenced by prefix in the provided mod.
255 *
256 * @param[in] mod Schema module where the prefix was used.
257 * @param[in] prefix Prefix used to reference a module.
258 * @param[in] len Length of the prefix since it is not necessary NULL-terminated.
259 * @return Pointer to the module or NULL if the module is not found.
260 */
Radek Krejcia3045382018-11-22 14:30:31 +0100261struct lys_module *lys_module_find_prefix(const struct lys_module *mod, const char *prefix, size_t len);
262
263/**
264 * @brief Stringify schema nodetype.
265 * @param[in] nodetype Nodetype to stringify.
266 * @return Constant string with the name of the node's type.
267 */
268const char *lys_nodetype2str(uint16_t nodetype);
Radek Krejci151a5b72018-10-19 14:21:44 +0200269
270/**
Radek Krejcid33273d2018-10-25 14:55:52 +0200271 * @brief Parse YANG module and submodule from a string.
272 *
273 * In contrast to public lys_parse_mem(), also submodules can be parsed here. However,
274 * while the modules are added into the context, submodules not. The latest_revision
275 * flag is updated in both cases.
276 *
277 * @param[in] ctx libyang context where to process the data model.
278 * @param[in] data The string containing the dumped data model in the specified
279 * format.
280 * @param[in] format Format of the input data (YANG or YIN).
Radek Krejcid33273d2018-10-25 14:55:52 +0200281 * @param[in] implement Flag if the schema is supposed to be marked as implemented.
Radek Krejci3b1f9292018-11-08 10:58:35 +0100282 * @param[in] main_ctx Parser context of the main module in case of parsing submodule.
Radek Krejci9ed7a192018-10-31 16:23:51 +0100283 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
284 * @param[in] check_data Caller's data to pass to the custom_check callback.
Radek Krejcid33273d2018-10-25 14:55:52 +0200285 * @return Pointer to the data model structure or NULL on error.
286 */
Radek Krejci3b1f9292018-11-08 10:58:35 +0100287struct lys_module *lys_parse_mem_(struct ly_ctx *ctx, const char *data, LYS_INFORMAT format, int implement, struct ly_parser_ctx *main_ctx,
Radek Krejci9ed7a192018-10-31 16:23:51 +0100288 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, void *data), void *check_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200289
290/**
291 * @brief Parse YANG module and submodule from a file descriptor.
292 *
293 * In contrast to public lys_parse_mem(), also submodules can be parsed here. However,
294 * while the modules are added into the context, submodules not. The latest_revision
295 * flag is updated in both cases.
296 *
297 * \note Current implementation supports only reading data from standard (disk) file, not from sockets, pipes, etc.
298 *
299 * @param[in] ctx libyang context where to process the data model.
300 * @param[in] fd File descriptor of a regular file (e.g. sockets are not supported) containing the schema
301 * in the specified format.
302 * @param[in] format Format of the input data (YANG or YIN).
Radek Krejcid33273d2018-10-25 14:55:52 +0200303 * @param[in] implement Flag if the schema is supposed to be marked as implemented.
Radek Krejci3b1f9292018-11-08 10:58:35 +0100304 * @param[in] main_ctx Parser context of the main module in case of parsing submodule.
Radek Krejci9ed7a192018-10-31 16:23:51 +0100305 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
306 * @param[in] check_data Caller's data to pass to the custom_check callback.
Radek Krejcid33273d2018-10-25 14:55:52 +0200307 * @return Pointer to the data model structure or NULL on error.
308 */
Radek Krejci3b1f9292018-11-08 10:58:35 +0100309struct lys_module *lys_parse_fd_(struct ly_ctx *ctx, int fd, LYS_INFORMAT format, int implement, struct ly_parser_ctx *main_ctx,
Radek Krejci9ed7a192018-10-31 16:23:51 +0100310 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, void *data), void *check_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200311
312/**
313 * @brief Parse YANG module and submodule from a file descriptor.
314 *
315 * In contrast to public lys_parse_mem(), also submodules can be parsed here. However,
316 * while the modules are added into the context, submodules not. The latest_revision
317 * flag is updated in both cases.
318 *
319 * \note Current implementation supports only reading data from standard (disk) file, not from sockets, pipes, etc.
320 *
321 * @brief REad a schema into the specified context from a file.
322 *
323 * @param[in] ctx libyang context where to process the data model.
324 * @param[in] path Path to the file with the model in the specified format.
325 * @param[in] format Format of the input data (YANG or YIN).
Radek Krejcid33273d2018-10-25 14:55:52 +0200326 * @param[in] implement Flag if the schema is supposed to be marked as implemented.
Radek Krejci3b1f9292018-11-08 10:58:35 +0100327 * @param[in] main_ctx Parser context of the main module in case of parsing submodule.
Radek Krejci9ed7a192018-10-31 16:23:51 +0100328 * @param[in] custom_check Callback to check the parsed schema before it is accepted.
329 * @param[in] check_data Caller's data to pass to the custom_check callback.
Radek Krejcid33273d2018-10-25 14:55:52 +0200330 * @return Pointer to the data model structure or NULL on error.
331 */
Radek Krejci3b1f9292018-11-08 10:58:35 +0100332struct lys_module *lys_parse_path_(struct ly_ctx *ctx, const char *path, LYS_INFORMAT format, int implement, struct ly_parser_ctx *main_ctx,
Radek Krejci9ed7a192018-10-31 16:23:51 +0100333 LY_ERR (*custom_check)(struct ly_ctx *ctx, struct lysp_module *mod, void *data), void *check_data);
Radek Krejcid33273d2018-10-25 14:55:52 +0200334
335/**
336 * @brief Load the (sub)module into the context.
337 *
338 * This function does not check the presence of the (sub)module in context, it should be done before calling this function.
339 *
340 * module_name and submodule_name are alternatives - only one of the
341 *
342 * @param[in] ctx libyang context where to work.
343 * @param[in] name Name of the (sub)module to load.
344 * @param[in] revision Optional revision of the (sub)module to load, if NULL the newest revision is being loaded.
345 * @param[in] implement Flag if the (sub)module is supposed to be marked as implemented.
Radek Krejci3b1f9292018-11-08 10:58:35 +0100346 * @param[in] main_ctx Parser context of the main module in case of loading submodule.
Radek Krejcid33273d2018-10-25 14:55:52 +0200347 * @param[out] result Parsed YANG schema tree of the requested module. If it is a module, it is already in the context!
348 * @return LY_ERR value, in case of LY_SUCCESS, the \arg result is always provided.
349 */
Radek Krejci3b1f9292018-11-08 10:58:35 +0100350LY_ERR lys_module_localfile(struct ly_ctx *ctx, const char *name, const char *revision, int implement, struct ly_parser_ctx *main_ctx,
351 struct lys_module **result);
Radek Krejci086c7132018-10-26 15:29:04 +0200352
353/**
354 * @brief Make the module implemented.
355 * Does not check for collision in context, it must be done before calling the function, this is a simple switch.
356 * @param[in] mod Module to make implemented.
357 */
358void lys_module_implement(struct lys_module *mod);
359
Radek Krejcid33273d2018-10-25 14:55:52 +0200360/**
Radek Krejcicdfecd92018-11-26 11:27:32 +0100361 * @brief Free the compiled type structure.
362 * @param[in] ctx libyang context where the string data resides in a dictionary.
363 * @param[in,out] type Compiled type structure to be freed. The structure has refcount, so it is freed only in case the value is decreased to 0.
364 */
365void lysc_type_free(struct ly_ctx *ctx, struct lysc_type *type);
366
367/**
Radek Krejci19a96102018-11-15 13:38:09 +0100368 * @brief Free the compiled node structure.
369 * @param[in] ctx libyang context where the string data resides in a dictionary.
370 * @param[in,out] node Compiled node structure to be freed.
371 */
372void lysc_node_free(struct ly_ctx *ctx, struct lysc_node *node);
373
374/**
375 * @brief Free the compiled schema structure.
376 * @param[in,out] module Compiled schema module structure to free.
377 * @param[in] private_destructor Function to remove private data from the compiled schema tree.
378 */
379void lysc_module_free(struct lysc_module *module, void (*private_destructor)(const struct lysc_node *node, void *priv));
380
381/**
Radek Krejci86d106e2018-10-18 09:53:19 +0200382 * @brief Free the schema structure. It just frees, it does not remove the schema from its context.
383 * @param[in,out] module Schema module structure to free.
384 * @param[in] private_destructor Function to remove private data from the compiled schema tree.
385 */
386void lys_module_free(struct lys_module *module, void (*private_destructor)(const struct lysc_node *node, void *priv));
387
388/**
389 * @brief
390 */
Radek Krejcibbe09a92018-11-08 09:36:54 +0100391LY_ERR yang_parse(struct ly_parser_ctx *ctx, const char *data, struct lysp_module **mod_p);
Radek Krejci86d106e2018-10-18 09:53:19 +0200392
Radek Krejci70853c52018-10-15 14:46:16 +0200393#endif /* LY_TREE_SCHEMA_INTERNAL_H_ */