blob: 714b1fd69feee2b25cfabf1b0cb4794f18cdaaca [file] [log] [blame]
Radek Krejcie7b95092019-05-15 11:03:07 +02001/**
2 * @file tree_data_helpers.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief Parsing and validation helper functions for data 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 */
Michal Vasko43297a02021-05-19 11:12:37 +020014
15#define _GNU_SOURCE /* asprintf, strdup */
Radek Krejcie7b95092019-05-15 11:03:07 +020016
17#include <assert.h>
Michal Vasko43297a02021-05-19 11:12:37 +020018#include <ctype.h>
Radek Krejci535ea9f2020-05-29 16:01:05 +020019#include <stdint.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020020#include <stdlib.h>
Radek Krejciad97c5f2020-06-30 09:19:28 +020021#include <string.h>
Michal Vasko43297a02021-05-19 11:12:37 +020022#include <time.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020023
Radek Krejci535ea9f2020-05-29 16:01:05 +020024#include "common.h"
Michal Vasko6b5cb2a2020-11-11 19:11:21 +010025#include "compat.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020026#include "context.h"
Radek Krejci47fab892020-11-05 17:02:41 +010027#include "dict.h"
Radek Krejciad97c5f2020-06-30 09:19:28 +020028#include "hash_table.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020029#include "log.h"
Radek Krejciad97c5f2020-06-30 09:19:28 +020030#include "lyb.h"
Radek Krejci7931b192020-06-25 17:05:03 +020031#include "parser_data.h"
Michal Vaskoa820c312021-02-05 16:33:00 +010032#include "printer_data.h"
Radek Krejciad97c5f2020-06-30 09:19:28 +020033#include "set.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020034#include "tree.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020035#include "tree_data.h"
Michal Vasko60ea6352020-06-29 13:39:39 +020036#include "tree_data_internal.h"
Radek Krejci859a15a2021-03-05 20:56:59 +010037#include "tree_edit.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020038#include "tree_schema.h"
Radek Krejci0aa1f702021-04-01 16:16:19 +020039#include "tree_schema_internal.h"
Radek Krejci4f2e3e52021-03-30 14:20:28 +020040#include "validation.h"
Radek Krejci77114102021-03-10 15:21:57 +010041#include "xml.h"
aPiecekdf23eee2021-10-07 12:21:50 +020042#include "xpath.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020043
Michal Vaskod7c048c2021-05-18 16:12:55 +020044/**
45 * @brief Find an entry in duplicate instance cache for an instance. Create it if it does not exist.
46 *
47 * @param[in] first_inst Instance of the cache entry.
48 * @param[in,out] dup_inst_cache Duplicate instance cache.
49 * @return Instance cache entry.
50 */
51static struct lyd_dup_inst *
52lyd_dup_inst_get(const struct lyd_node *first_inst, struct lyd_dup_inst **dup_inst_cache)
53{
54 struct lyd_dup_inst *item;
55 LY_ARRAY_COUNT_TYPE u;
56
57 LY_ARRAY_FOR(*dup_inst_cache, u) {
58 if ((*dup_inst_cache)[u].inst_set->dnodes[0] == first_inst) {
59 return &(*dup_inst_cache)[u];
60 }
61 }
62
63 /* it was not added yet, add it now */
64 LY_ARRAY_NEW_RET(LYD_CTX(first_inst), *dup_inst_cache, item, NULL);
65
66 return item;
67}
68
69LY_ERR
70lyd_dup_inst_next(struct lyd_node **inst, const struct lyd_node *siblings, struct lyd_dup_inst **dup_inst_cache)
71{
72 struct lyd_dup_inst *dup_inst;
73
74 if (!*inst || !lysc_is_dup_inst_list((*inst)->schema)) {
75 /* no match or not dup-inst list, inst is unchanged */
76 return LY_SUCCESS;
77 }
78
79 /* there can be more exact same instances and we must make sure we do not match a single node more times */
80 dup_inst = lyd_dup_inst_get(*inst, dup_inst_cache);
81 LY_CHECK_ERR_RET(!dup_inst, LOGMEM(LYD_CTX(siblings)), LY_EMEM);
82
83 if (!dup_inst->used) {
84 /* we did not cache these instances yet, do so */
85 lyd_find_sibling_dup_inst_set(siblings, *inst, &dup_inst->inst_set);
86 assert(dup_inst->inst_set->count && (dup_inst->inst_set->dnodes[0] == *inst));
87 }
88
89 if (dup_inst->used == dup_inst->inst_set->count) {
90 /* we have used all the instances */
91 *inst = NULL;
92 } else {
93 assert(dup_inst->used < dup_inst->inst_set->count);
94
95 /* use another instance */
96 *inst = dup_inst->inst_set->dnodes[dup_inst->used];
97 ++dup_inst->used;
98 }
99
100 return LY_SUCCESS;
101}
102
103void
104lyd_dup_inst_free(struct lyd_dup_inst *dup_inst)
105{
106 LY_ARRAY_COUNT_TYPE u;
107
108 LY_ARRAY_FOR(dup_inst, u) {
109 ly_set_free(dup_inst[u].inst_set, NULL);
110 }
111 LY_ARRAY_FREE(dup_inst);
112}
113
Michal Vaskoa6669ba2020-08-06 16:14:26 +0200114struct lyd_node *
115lys_getnext_data(const struct lyd_node *last, const struct lyd_node *sibling, const struct lysc_node **slast,
Radek Krejci0f969882020-08-21 16:56:47 +0200116 const struct lysc_node *parent, const struct lysc_module *module)
Michal Vaskoa6669ba2020-08-06 16:14:26 +0200117{
118 const struct lysc_node *siter = NULL;
119 struct lyd_node *match = NULL;
120
121 assert(parent || module);
122 assert(!last || (slast && *slast));
123
124 if (slast) {
125 siter = *slast;
126 }
127
128 if (last && last->next && (last->next->schema == siter)) {
129 /* return next data instance */
130 return last->next;
131 }
132
133 /* find next schema node data instance */
134 while ((siter = lys_getnext(siter, parent, module, 0))) {
135 if (!lyd_find_sibling_val(sibling, siter, NULL, 0, &match)) {
136 break;
137 }
138 }
139
140 if (slast) {
141 *slast = siter;
142 }
143 return match;
144}
145
Radek Krejcie7b95092019-05-15 11:03:07 +0200146struct lyd_node **
Michal Vaskoe0665742021-02-11 11:08:44 +0100147lyd_node_child_p(struct lyd_node *node)
Radek Krejcie7b95092019-05-15 11:03:07 +0200148{
149 assert(node);
Michal Vasko52927e22020-03-16 17:26:14 +0100150
151 if (!node->schema) {
152 return &((struct lyd_node_opaq *)node)->child;
153 } else {
154 switch (node->schema->nodetype) {
155 case LYS_CONTAINER:
156 case LYS_LIST:
Michal Vasko1bf09392020-03-27 12:38:10 +0100157 case LYS_RPC:
Michal Vasko52927e22020-03-16 17:26:14 +0100158 case LYS_ACTION:
159 case LYS_NOTIF:
160 return &((struct lyd_node_inner *)node)->child;
161 default:
162 return NULL;
163 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200164 }
165}
166
aPiecekdf23eee2021-10-07 12:21:50 +0200167API LY_ERR
168lyxp_vars_set(struct lyxp_var **vars, const char *name, const char *value)
169{
170 LY_ERR ret = LY_SUCCESS;
171 char *var_name = NULL, *var_value = NULL;
172 struct lyxp_var *item;
173
174 if (!vars || !name || !value) {
175 return LY_EINVAL;
176 }
177
178 /* If variable is already defined then change its value. */
179 if (*vars && !lyxp_vars_find(*vars, name, 0, &item)) {
180 var_value = strdup(value);
181 LY_CHECK_RET(!var_value, LY_EMEM);
182
183 /* Set new value. */
184 free(item->value);
185 item->value = var_value;
186 } else {
187 var_name = strdup(name);
188 var_value = strdup(value);
189 LY_CHECK_ERR_GOTO(!var_name || !var_value, ret = LY_EMEM, error);
190
191 /* Add new variable. */
192 LY_ARRAY_NEW_GOTO(NULL, *vars, item, ret, error);
193 item->name = var_name;
194 item->value = var_value;
195 }
196
197 return LY_SUCCESS;
198
199error:
200 free(var_name);
201 free(var_value);
202 return ret;
203}
204
205API void
206lyxp_vars_free(struct lyxp_var *vars)
207{
208 LY_ARRAY_COUNT_TYPE u;
209
210 if (!vars) {
211 return;
212 }
213
214 LY_ARRAY_FOR(vars, u) {
215 free(vars[u].name);
216 free(vars[u].value);
217 }
218
219 LY_ARRAY_FREE(vars);
220}
221
Radek Krejcidae0ee82020-05-06 16:53:24 +0200222API struct lyd_node *
Radek Krejcia1c1e542020-09-29 16:06:52 +0200223lyd_child_no_keys(const struct lyd_node *node)
224{
225 struct lyd_node **children;
226
227 if (!node) {
228 return NULL;
229 }
230
231 if (!node->schema) {
232 /* opaq node */
Michal Vasko9e685082021-01-29 14:49:09 +0100233 return ((struct lyd_node_opaq *)node)->child;
Radek Krejcia1c1e542020-09-29 16:06:52 +0200234 }
235
Michal Vaskoe0665742021-02-11 11:08:44 +0100236 children = lyd_node_child_p((struct lyd_node *)node);
Radek Krejcia1c1e542020-09-29 16:06:52 +0200237 if (children) {
238 struct lyd_node *child = *children;
239 while (child && child->schema && (child->schema->flags & LYS_KEY)) {
240 child = child->next;
Michal Vasko5bfd4be2020-06-23 13:26:19 +0200241 }
242 return child;
Radek Krejcie7b95092019-05-15 11:03:07 +0200243 } else {
244 return NULL;
245 }
246}
Michal Vasko9b368d32020-02-14 13:53:31 +0100247
Michal Vaskoc193ce92020-03-06 11:04:48 +0100248API const struct lys_module *
249lyd_owner_module(const struct lyd_node *node)
Michal Vasko9b368d32020-02-14 13:53:31 +0100250{
Michal Vaskod5cfa6e2020-11-23 16:56:08 +0100251 const struct lyd_node_opaq *opaq;
Michal Vasko9b368d32020-02-14 13:53:31 +0100252
Michal Vaskod5cfa6e2020-11-23 16:56:08 +0100253 if (!node) {
Michal Vaskoc193ce92020-03-06 11:04:48 +0100254 return NULL;
255 }
Michal Vasko9b368d32020-02-14 13:53:31 +0100256
Michal Vaskod5cfa6e2020-11-23 16:56:08 +0100257 if (!node->schema) {
258 opaq = (struct lyd_node_opaq *)node;
259 switch (opaq->format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200260 case LY_VALUE_XML:
Michal Vaskod5cfa6e2020-11-23 16:56:08 +0100261 return ly_ctx_get_module_implemented_ns(LYD_CTX(node), opaq->name.module_ns);
Radek Krejci8df109d2021-04-23 12:19:08 +0200262 case LY_VALUE_JSON:
Michal Vaskod5cfa6e2020-11-23 16:56:08 +0100263 return ly_ctx_get_module_implemented(LYD_CTX(node), opaq->name.module_name);
264 default:
265 return NULL;
266 }
267 }
268
Michal Vaskoef53c812021-10-13 10:21:03 +0200269 return lysc_owner_module(node->schema);
Michal Vasko9b368d32020-02-14 13:53:31 +0100270}
Michal Vaskob1b5c262020-03-05 14:29:47 +0100271
Michal Vasko598063b2021-07-19 11:39:05 +0200272void
273lyd_first_module_sibling(struct lyd_node **node, const struct lys_module *mod)
274{
275 int cmp;
276 struct lyd_node *first;
277
278 assert(node && mod);
279
280 if (!*node) {
281 return;
282 }
283
284 first = *node;
285 cmp = strcmp(lyd_owner_module(first)->name, mod->name);
286 if (cmp > 0) {
287 /* there may be some preceding data */
288 while (first->prev->next) {
289 first = first->prev;
290 if (lyd_owner_module(first) == mod) {
291 cmp = 0;
292 break;
293 }
294 }
295 }
296
297 if (cmp == 0) {
298 /* there may be some preceding data belonging to this module */
299 while (first->prev->next) {
300 if (lyd_owner_module(first->prev) != mod) {
301 break;
302 }
303 first = first->prev;
304 }
305 }
306
307 if (cmp < 0) {
308 /* there may be some following data */
309 LY_LIST_FOR(first, first) {
310 if (lyd_owner_module(first) == mod) {
311 cmp = 0;
312 break;
313 }
314 }
315 }
316
317 if (cmp == 0) {
318 /* we have found the first module data node */
319 *node = first;
320 }
321}
322
Michal Vaskob1b5c262020-03-05 14:29:47 +0100323const struct lys_module *
Michal Vasko26e80012020-07-08 10:55:46 +0200324lyd_mod_next_module(struct lyd_node *tree, const struct lys_module *module, const struct ly_ctx *ctx, uint32_t *i,
Radek Krejci0f969882020-08-21 16:56:47 +0200325 struct lyd_node **first)
Michal Vaskob1b5c262020-03-05 14:29:47 +0100326{
327 struct lyd_node *iter;
328 const struct lys_module *mod;
329
330 /* get the next module */
Michal Vasko26e80012020-07-08 10:55:46 +0200331 if (module) {
332 if (*i) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100333 mod = NULL;
Michal Vasko26e80012020-07-08 10:55:46 +0200334 } else {
335 mod = module;
336 ++(*i);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100337 }
338 } else {
339 do {
340 mod = ly_ctx_get_module_iter(ctx, i);
341 } while (mod && !mod->implemented);
342 }
343
344 /* find its data */
345 *first = NULL;
346 if (mod) {
347 LY_LIST_FOR(tree, iter) {
Michal Vaskoc193ce92020-03-06 11:04:48 +0100348 if (lyd_owner_module(iter) == mod) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100349 *first = iter;
350 break;
351 }
352 }
353 }
354
355 return mod;
356}
357
358const struct lys_module *
359lyd_data_next_module(struct lyd_node **next, struct lyd_node **first)
360{
361 const struct lys_module *mod;
362
363 if (!*next) {
364 /* all data traversed */
365 *first = NULL;
366 return NULL;
367 }
368
369 *first = *next;
370
371 /* prepare next */
Michal Vaskoc193ce92020-03-06 11:04:48 +0100372 mod = lyd_owner_module(*next);
Michal Vaskob1b5c262020-03-05 14:29:47 +0100373 LY_LIST_FOR(*next, *next) {
Michal Vaskoc193ce92020-03-06 11:04:48 +0100374 if (lyd_owner_module(*next) != mod) {
Michal Vaskob1b5c262020-03-05 14:29:47 +0100375 break;
376 }
377 }
378
379 return mod;
380}
Michal Vasko9f96a052020-03-10 09:41:45 +0100381
382LY_ERR
383lyd_parse_check_keys(struct lyd_node *node)
384{
385 const struct lysc_node *skey = NULL;
386 const struct lyd_node *key;
387
388 assert(node->schema->nodetype == LYS_LIST);
389
Radek Krejcia1c1e542020-09-29 16:06:52 +0200390 key = lyd_child(node);
Michal Vasko9f96a052020-03-10 09:41:45 +0100391 while ((skey = lys_getnext(skey, node->schema, NULL, 0)) && (skey->flags & LYS_KEY)) {
392 if (!key || (key->schema != skey)) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100393 LOGVAL(LYD_CTX(node), LY_VCODE_NOKEY, skey->name);
Michal Vasko9f96a052020-03-10 09:41:45 +0100394 return LY_EVALID;
395 }
396
397 key = key->next;
398 }
399
400 return LY_SUCCESS;
401}
Michal Vasko60ea6352020-06-29 13:39:39 +0200402
403void
Michal Vaskof9b68342021-07-23 13:50:59 +0200404lyd_parse_set_data_flags(struct lyd_node *node, struct ly_set *node_when, struct ly_set *node_exts, struct lyd_meta **meta,
405 uint32_t parse_opts)
Michal Vasko60ea6352020-06-29 13:39:39 +0200406{
407 struct lyd_meta *meta2, *prev_meta = NULL;
408
Michal Vaskoa5705e52020-12-09 18:15:14 +0100409 if (lysc_has_when(node->schema)) {
Michal Vaskof9b68342021-07-23 13:50:59 +0200410 if (!(parse_opts & LYD_PARSE_ONLY)) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200411 /* remember we need to evaluate this node's when */
Michal Vaskof9b68342021-07-23 13:50:59 +0200412 LY_CHECK_RET(ly_set_add(node_when, node, 1, NULL), );
Michal Vasko60ea6352020-06-29 13:39:39 +0200413 }
414 }
Michal Vaskof9b68342021-07-23 13:50:59 +0200415 LY_CHECK_RET(lysc_node_ext_tovalidate(node_exts, node), );
Michal Vasko60ea6352020-06-29 13:39:39 +0200416
Michal Vasko60ea6352020-06-29 13:39:39 +0200417 LY_LIST_FOR(*meta, meta2) {
Michal Vasko69730152020-10-09 16:30:07 +0200418 if (!strcmp(meta2->name, "default") && !strcmp(meta2->annotation->module->name, "ietf-netconf-with-defaults") &&
419 meta2->value.boolean) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200420 /* node is default according to the metadata */
421 node->flags |= LYD_DEFAULT;
422
423 /* delete the metadata */
424 if (prev_meta) {
425 prev_meta->next = meta2->next;
426 } else {
427 *meta = (*meta)->next;
428 }
Michal Vasko3a41dff2020-07-15 14:30:28 +0200429 lyd_free_meta_single(meta2);
Michal Vasko60ea6352020-06-29 13:39:39 +0200430 break;
431 }
432
433 prev_meta = meta2;
434 }
435}
436
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200437API const char *
Christian Hopps46bd21b2021-04-27 09:43:58 -0400438lyd_value_get_canonical(const struct ly_ctx *ctx, const struct lyd_value *value)
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200439{
Michal Vaskoab40e7e2021-04-28 17:04:24 +0200440 LY_CHECK_ARG_RET(ctx, ctx, value, NULL);
441
Michal Vasko33876022021-04-27 16:42:24 +0200442 return value->_canonical ? value->_canonical :
443 (const char *)value->realtype->plugin->print(ctx, value, LY_VALUE_CANON, NULL, NULL, NULL);
Radek Krejci6d5ba0c2021-04-26 07:49:59 +0200444}
445
Michal Vaskoc0004272020-08-06 08:32:34 +0200446API LY_ERR
Michal Vaskoa820c312021-02-05 16:33:00 +0100447lyd_any_value_str(const struct lyd_node *any, char **value_str)
448{
449 const struct lyd_node_any *a;
450 struct lyd_node *tree = NULL;
451 const char *str = NULL;
452 ly_bool dynamic = 0;
453 LY_ERR ret = LY_SUCCESS;
454
455 LY_CHECK_ARG_RET(NULL, any, value_str, LY_EINVAL);
Radek Krejci71877df2021-04-06 17:24:06 +0200456 LY_CHECK_ARG_RET(NULL, any->schema, any->schema->nodetype & LYS_ANYDATA, LY_EINVAL);
Michal Vaskoa820c312021-02-05 16:33:00 +0100457
458 a = (struct lyd_node_any *)any;
459 *value_str = NULL;
460
461 if (!a->value.str) {
462 /* there is no value in the union */
463 return LY_SUCCESS;
464 }
465
466 switch (a->value_type) {
467 case LYD_ANYDATA_LYB:
468 /* parse into a data tree */
469 ret = lyd_parse_data_mem(LYD_CTX(any), a->value.mem, LYD_LYB, LYD_PARSE_ONLY, 0, &tree);
470 LY_CHECK_GOTO(ret, cleanup);
471 dynamic = 1;
472 break;
473 case LYD_ANYDATA_DATATREE:
474 tree = a->value.tree;
475 break;
476 case LYD_ANYDATA_STRING:
477 case LYD_ANYDATA_XML:
478 case LYD_ANYDATA_JSON:
479 /* simply use the string */
480 str = a->value.str;
481 break;
482 }
483
484 if (tree) {
485 /* print into a string */
486 ret = lyd_print_mem(value_str, tree, LYD_XML, LYD_PRINT_WITHSIBLINGS);
487 LY_CHECK_GOTO(ret, cleanup);
488 } else {
489 assert(str);
490 *value_str = strdup(str);
491 LY_CHECK_ERR_GOTO(!*value_str, LOGMEM(LYD_CTX(any)), cleanup);
492 }
493
494 /* success */
495
496cleanup:
497 if (dynamic) {
498 lyd_free_all(tree);
499 }
500 return ret;
501}
502
503API LY_ERR
Michal Vasko61551fa2020-07-09 15:45:45 +0200504lyd_any_copy_value(struct lyd_node *trg, const union lyd_any_value *value, LYD_ANYDATA_VALUETYPE value_type)
505{
506 struct lyd_node_any *t;
Michal Vasko61551fa2020-07-09 15:45:45 +0200507
Michal Vaskoa820c312021-02-05 16:33:00 +0100508 LY_CHECK_ARG_RET(NULL, trg, LY_EINVAL);
Radek Krejci71877df2021-04-06 17:24:06 +0200509 LY_CHECK_ARG_RET(NULL, trg->schema, trg->schema->nodetype & LYS_ANYDATA, LY_EINVAL);
Michal Vasko61551fa2020-07-09 15:45:45 +0200510
511 t = (struct lyd_node_any *)trg;
512
513 /* free trg */
514 switch (t->value_type) {
515 case LYD_ANYDATA_DATATREE:
516 lyd_free_all(t->value.tree);
517 break;
518 case LYD_ANYDATA_STRING:
519 case LYD_ANYDATA_XML:
520 case LYD_ANYDATA_JSON:
Michal Vaskoe180ed02021-02-05 16:31:20 +0100521 lydict_remove(LYD_CTX(trg), t->value.str);
Michal Vasko61551fa2020-07-09 15:45:45 +0200522 break;
523 case LYD_ANYDATA_LYB:
524 free(t->value.mem);
525 break;
526 }
527 t->value.str = NULL;
528
529 if (!value) {
530 /* only free value in this case */
531 return LY_SUCCESS;
532 }
533
534 /* copy src */
535 t->value_type = value_type;
536 switch (value_type) {
537 case LYD_ANYDATA_DATATREE:
538 if (value->tree) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200539 LY_CHECK_RET(lyd_dup_siblings(value->tree, NULL, LYD_DUP_RECURSIVE, &t->value.tree));
Michal Vasko61551fa2020-07-09 15:45:45 +0200540 }
541 break;
542 case LYD_ANYDATA_STRING:
543 case LYD_ANYDATA_XML:
544 case LYD_ANYDATA_JSON:
545 if (value->str) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200546 LY_CHECK_RET(lydict_insert(LYD_CTX(trg), value->str, 0, &t->value.str));
Michal Vasko61551fa2020-07-09 15:45:45 +0200547 }
548 break;
549 case LYD_ANYDATA_LYB:
550 if (value->mem) {
Radek Krejci1deb5be2020-08-26 16:43:36 +0200551 int len = lyd_lyb_data_length(value->mem);
Radek Krejci82fa8d42020-07-11 22:00:59 +0200552 LY_CHECK_RET(len == -1, LY_EINVAL);
Michal Vasko61551fa2020-07-09 15:45:45 +0200553 t->value.mem = malloc(len);
Michal Vaskob7be7a82020-08-20 09:09:04 +0200554 LY_CHECK_ERR_RET(!t->value.mem, LOGMEM(LYD_CTX(trg)), LY_EMEM);
Michal Vasko61551fa2020-07-09 15:45:45 +0200555 memcpy(t->value.mem, value->mem, len);
556 }
557 break;
558 }
559
560 return LY_SUCCESS;
561}
562
Michal Vasko106f0862021-11-02 11:49:27 +0100563const struct lysc_node *
564lyd_node_schema(const struct lyd_node *node)
565{
566 const struct lysc_node *schema = NULL;
567 const struct lyd_node *prev_iter = NULL, *iter;
568 const struct lys_module *mod;
569
570 if (!node) {
571 return NULL;
572 } else if (node->schema) {
573 return node->schema;
574 }
575
576 /* get schema node of an opaque node */
577 do {
578 /* get next data node */
579 for (iter = node; lyd_parent(iter) != prev_iter; iter = lyd_parent(iter)) {}
580
581 /* get equivalent schema node */
582 if (iter->schema) {
583 schema = iter->schema;
584 } else {
585 /* get module */
586 mod = lyd_owner_module(iter);
Michal Vaskoa41826a2021-11-02 12:13:03 +0100587 if (!mod && !schema) {
588 /* top-level opaque node has unknown module */
589 break;
590 }
Michal Vasko106f0862021-11-02 11:49:27 +0100591
592 /* get schema node */
593 schema = lys_find_child(schema, mod ? mod : schema->module, LYD_NAME(iter), 0, 0, 0);
594 }
Michal Vaskod2f404f2021-11-04 15:37:11 +0100595
596 /* remember to move to the descendant */
597 prev_iter = iter;
Michal Vasko106f0862021-11-02 11:49:27 +0100598 } while (schema && (iter != node));
599
600 return schema;
601}
602
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100603void
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100604lyd_del_move_root(struct lyd_node **root, const struct lyd_node *to_del, const struct lys_module *mod)
605{
606 if (*root && (lyd_owner_module(*root) != mod)) {
607 /* there are no data of mod so this is simply the first top-level sibling */
608 mod = NULL;
609 }
610
611 if ((*root != to_del) || (*root)->parent) {
612 return;
613 }
614
Michal Vasko598063b2021-07-19 11:39:05 +0200615 if (mod && (*root)->prev->next && (!(*root)->next || (lyd_owner_module(to_del) != lyd_owner_module((*root)->next)))) {
616 /* there are no more nodes from mod, simply get the first top-level sibling */
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100617 *root = lyd_first_sibling(*root);
Michal Vasko598063b2021-07-19 11:39:05 +0200618 } else {
619 *root = (*root)->next;
Michal Vaskod3bb12f2020-12-04 14:33:09 +0100620 }
621}
622
623void
Radek Krejci8df109d2021-04-23 12:19:08 +0200624ly_free_prefix_data(LY_VALUE_FORMAT format, void *prefix_data)
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100625{
626 struct ly_set *ns_list;
627 struct lysc_prefix *prefixes;
628 uint32_t i;
629 LY_ARRAY_COUNT_TYPE u;
630
631 if (!prefix_data) {
632 return;
633 }
634
635 switch (format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200636 case LY_VALUE_XML:
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100637 ns_list = prefix_data;
638 for (i = 0; i < ns_list->count; ++i) {
639 free(((struct lyxml_ns *)ns_list->objs[i])->prefix);
640 free(((struct lyxml_ns *)ns_list->objs[i])->uri);
641 }
642 ly_set_free(ns_list, free);
643 break;
Radek Krejci8df109d2021-04-23 12:19:08 +0200644 case LY_VALUE_SCHEMA_RESOLVED:
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100645 prefixes = prefix_data;
646 LY_ARRAY_FOR(prefixes, u) {
647 free(prefixes[u].prefix);
648 }
649 LY_ARRAY_FREE(prefixes);
650 break;
Radek Krejci224d4b42021-04-23 13:54:59 +0200651 case LY_VALUE_CANON:
Radek Krejci8df109d2021-04-23 12:19:08 +0200652 case LY_VALUE_SCHEMA:
653 case LY_VALUE_JSON:
Radek Krejcif9943642021-04-26 10:18:21 +0200654 case LY_VALUE_LYB:
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100655 break;
656 }
657}
658
659LY_ERR
Radek Krejci8df109d2021-04-23 12:19:08 +0200660ly_dup_prefix_data(const struct ly_ctx *ctx, LY_VALUE_FORMAT format, const void *prefix_data,
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100661 void **prefix_data_p)
662{
663 LY_ERR ret = LY_SUCCESS;
664 struct lyxml_ns *ns;
665 struct lysc_prefix *prefixes = NULL, *orig_pref;
666 struct ly_set *ns_list, *orig_ns;
667 uint32_t i;
668 LY_ARRAY_COUNT_TYPE u;
669
670 assert(!*prefix_data_p);
671
672 switch (format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200673 case LY_VALUE_SCHEMA:
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100674 *prefix_data_p = (void *)prefix_data;
675 break;
Radek Krejci8df109d2021-04-23 12:19:08 +0200676 case LY_VALUE_SCHEMA_RESOLVED:
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100677 /* copy all the value prefixes */
678 orig_pref = (struct lysc_prefix *)prefix_data;
679 LY_ARRAY_CREATE_GOTO(ctx, prefixes, LY_ARRAY_COUNT(orig_pref), ret, cleanup);
680 *prefix_data_p = prefixes;
681
682 LY_ARRAY_FOR(orig_pref, u) {
683 if (orig_pref[u].prefix) {
684 prefixes[u].prefix = strdup(orig_pref[u].prefix);
685 LY_CHECK_ERR_GOTO(!prefixes[u].prefix, LOGMEM(ctx); ret = LY_EMEM, cleanup);
686 }
687 prefixes[u].mod = orig_pref[u].mod;
688 LY_ARRAY_INCREMENT(prefixes);
689 }
690 break;
Radek Krejci8df109d2021-04-23 12:19:08 +0200691 case LY_VALUE_XML:
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100692 /* copy all the namespaces */
693 LY_CHECK_GOTO(ret = ly_set_new(&ns_list), cleanup);
694 *prefix_data_p = ns_list;
695
696 orig_ns = (struct ly_set *)prefix_data;
697 for (i = 0; i < orig_ns->count; ++i) {
698 ns = calloc(1, sizeof *ns);
699 LY_CHECK_ERR_GOTO(!ns, LOGMEM(ctx); ret = LY_EMEM, cleanup);
700 LY_CHECK_GOTO(ret = ly_set_add(ns_list, ns, 1, NULL), cleanup);
701
702 if (((struct lyxml_ns *)orig_ns->objs[i])->prefix) {
703 ns->prefix = strdup(((struct lyxml_ns *)orig_ns->objs[i])->prefix);
704 LY_CHECK_ERR_GOTO(!ns->prefix, LOGMEM(ctx); ret = LY_EMEM, cleanup);
705 }
706 ns->uri = strdup(((struct lyxml_ns *)orig_ns->objs[i])->uri);
707 LY_CHECK_ERR_GOTO(!ns->uri, LOGMEM(ctx); ret = LY_EMEM, cleanup);
708 }
709 break;
Radek Krejci224d4b42021-04-23 13:54:59 +0200710 case LY_VALUE_CANON:
Radek Krejci8df109d2021-04-23 12:19:08 +0200711 case LY_VALUE_JSON:
Radek Krejcif9943642021-04-26 10:18:21 +0200712 case LY_VALUE_LYB:
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100713 assert(!prefix_data);
714 *prefix_data_p = NULL;
715 break;
716 }
717
718cleanup:
719 if (ret) {
720 ly_free_prefix_data(format, *prefix_data_p);
721 *prefix_data_p = NULL;
722 }
723 return ret;
724}
725
726LY_ERR
Radek Krejcif9943642021-04-26 10:18:21 +0200727ly_store_prefix_data(const struct ly_ctx *ctx, const void *value, size_t value_len, LY_VALUE_FORMAT format,
Radek Krejci8df109d2021-04-23 12:19:08 +0200728 const void *prefix_data, LY_VALUE_FORMAT *format_p, void **prefix_data_p)
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100729{
730 LY_ERR ret = LY_SUCCESS;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100731 const struct lys_module *mod;
Michal Vaskofc2cd072021-02-24 13:17:17 +0100732 const struct lyxml_ns *ns;
733 struct lyxml_ns *new_ns;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100734 struct ly_set *ns_list;
735 struct lysc_prefix *prefixes = NULL, *val_pref;
aPiecek83436bc2021-03-30 12:20:45 +0200736 const char *value_iter, *value_next, *value_end;
737 uint32_t substr_len;
738 ly_bool is_prefix;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100739
740 switch (format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200741 case LY_VALUE_SCHEMA:
Michal Vaskofc2cd072021-02-24 13:17:17 +0100742 /* copy all referenced modules as prefix - module pairs */
743 if (!*prefix_data_p) {
744 /* new prefix data */
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100745 LY_ARRAY_CREATE_GOTO(ctx, prefixes, 0, ret, cleanup);
Radek Krejci8df109d2021-04-23 12:19:08 +0200746 *format_p = LY_VALUE_SCHEMA_RESOLVED;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100747 *prefix_data_p = prefixes;
Michal Vaskofc2cd072021-02-24 13:17:17 +0100748 } else {
749 /* reuse prefix data */
Radek Krejci8df109d2021-04-23 12:19:08 +0200750 assert(*format_p == LY_VALUE_SCHEMA_RESOLVED);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100751 prefixes = *prefix_data_p;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100752 }
753
754 /* add all used prefixes */
Michal Vasko59e90fc2021-09-22 12:17:08 +0200755 value_end = (char *)value + value_len;
aPiecek83436bc2021-03-30 12:20:45 +0200756 for (value_iter = value; value_iter; value_iter = value_next) {
aPieceke3f828d2021-05-10 15:34:41 +0200757 LY_CHECK_GOTO(ret = ly_value_prefix_next(value_iter, value_end, &substr_len, &is_prefix, &value_next), cleanup);
aPiecek83436bc2021-03-30 12:20:45 +0200758 if (is_prefix) {
759 /* we have a possible prefix. Do we already have the prefix? */
760 mod = ly_resolve_prefix(ctx, value_iter, substr_len, *format_p, *prefix_data_p);
761 if (!mod) {
762 mod = ly_resolve_prefix(ctx, value_iter, substr_len, format, prefix_data);
763 if (mod) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200764 assert(*format_p == LY_VALUE_SCHEMA_RESOLVED);
aPiecek83436bc2021-03-30 12:20:45 +0200765 /* store a new prefix - module pair */
766 LY_ARRAY_NEW_GOTO(ctx, prefixes, val_pref, ret, cleanup);
767 *prefix_data_p = prefixes;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100768
aPiecek83436bc2021-03-30 12:20:45 +0200769 val_pref->prefix = strndup(value_iter, substr_len);
770 LY_CHECK_ERR_GOTO(!val_pref->prefix, LOGMEM(ctx); ret = LY_EMEM, cleanup);
771 val_pref->mod = mod;
772 } /* else it is not even defined */
773 } /* else the prefix is already present */
Michal Vaskofc2cd072021-02-24 13:17:17 +0100774 }
775 }
776 break;
Radek Krejci8df109d2021-04-23 12:19:08 +0200777 case LY_VALUE_XML:
Michal Vaskofc2cd072021-02-24 13:17:17 +0100778 /* copy all referenced namespaces as prefix - namespace pairs */
779 if (!*prefix_data_p) {
780 /* new prefix data */
781 LY_CHECK_GOTO(ret = ly_set_new(&ns_list), cleanup);
Radek Krejci8df109d2021-04-23 12:19:08 +0200782 *format_p = LY_VALUE_XML;
Michal Vaskofc2cd072021-02-24 13:17:17 +0100783 *prefix_data_p = ns_list;
784 } else {
785 /* reuse prefix data */
Radek Krejci8df109d2021-04-23 12:19:08 +0200786 assert(*format_p == LY_VALUE_XML);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100787 ns_list = *prefix_data_p;
788 }
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100789
Michal Vaskofc2cd072021-02-24 13:17:17 +0100790 /* add all used prefixes */
Michal Vasko59e90fc2021-09-22 12:17:08 +0200791 value_end = (char *)value + value_len;
aPiecek83436bc2021-03-30 12:20:45 +0200792 for (value_iter = value; value_iter; value_iter = value_next) {
aPieceke3f828d2021-05-10 15:34:41 +0200793 LY_CHECK_GOTO(ret = ly_value_prefix_next(value_iter, value_end, &substr_len, &is_prefix, &value_next), cleanup);
aPiecek83436bc2021-03-30 12:20:45 +0200794 if (is_prefix) {
795 /* we have a possible prefix. Do we already have the prefix? */
796 ns = lyxml_ns_get(ns_list, value_iter, substr_len);
797 if (!ns) {
798 ns = lyxml_ns_get(prefix_data, value_iter, substr_len);
799 if (ns) {
800 /* store a new prefix - namespace pair */
801 new_ns = calloc(1, sizeof *new_ns);
802 LY_CHECK_ERR_GOTO(!new_ns, LOGMEM(ctx); ret = LY_EMEM, cleanup);
803 LY_CHECK_GOTO(ret = ly_set_add(ns_list, new_ns, 1, NULL), cleanup);
Michal Vaskofc2cd072021-02-24 13:17:17 +0100804
aPiecek83436bc2021-03-30 12:20:45 +0200805 new_ns->prefix = strndup(value_iter, substr_len);
806 LY_CHECK_ERR_GOTO(!new_ns->prefix, LOGMEM(ctx); ret = LY_EMEM, cleanup);
807 new_ns->uri = strdup(ns->uri);
808 LY_CHECK_ERR_GOTO(!new_ns->uri, LOGMEM(ctx); ret = LY_EMEM, cleanup);
809 } /* else it is not even defined */
810 } /* else the prefix is already present */
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100811 }
812 }
813 break;
Radek Krejci224d4b42021-04-23 13:54:59 +0200814 case LY_VALUE_CANON:
Radek Krejci8df109d2021-04-23 12:19:08 +0200815 case LY_VALUE_SCHEMA_RESOLVED:
816 case LY_VALUE_JSON:
Radek Krejcif9943642021-04-26 10:18:21 +0200817 case LY_VALUE_LYB:
Michal Vaskofc2cd072021-02-24 13:17:17 +0100818 if (!*prefix_data_p) {
819 /* new prefix data - simply copy all the prefix data */
820 *format_p = format;
821 LY_CHECK_GOTO(ret = ly_dup_prefix_data(ctx, format, prefix_data, prefix_data_p), cleanup);
822 } /* else reuse prefix data - the prefix data are always the same, nothing to do */
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100823 break;
824 }
825
826cleanup:
827 if (ret) {
828 ly_free_prefix_data(*format_p, *prefix_data_p);
829 *prefix_data_p = NULL;
830 }
831 return ret;
832}
Michal Vasko7ed1fcb2020-12-03 14:15:22 +0100833
834const char *
Radek Krejci8df109d2021-04-23 12:19:08 +0200835ly_format2str(LY_VALUE_FORMAT format)
Michal Vasko7ed1fcb2020-12-03 14:15:22 +0100836{
837 switch (format) {
Radek Krejci224d4b42021-04-23 13:54:59 +0200838 case LY_VALUE_CANON:
839 return "canonical";
Radek Krejci8df109d2021-04-23 12:19:08 +0200840 case LY_VALUE_SCHEMA:
Michal Vasko7ed1fcb2020-12-03 14:15:22 +0100841 return "schema imports";
Radek Krejci8df109d2021-04-23 12:19:08 +0200842 case LY_VALUE_SCHEMA_RESOLVED:
Michal Vasko7ed1fcb2020-12-03 14:15:22 +0100843 return "schema stored mapping";
Radek Krejci8df109d2021-04-23 12:19:08 +0200844 case LY_VALUE_XML:
Michal Vasko7ed1fcb2020-12-03 14:15:22 +0100845 return "XML prefixes";
Radek Krejci8df109d2021-04-23 12:19:08 +0200846 case LY_VALUE_JSON:
Michal Vasko7ed1fcb2020-12-03 14:15:22 +0100847 return "JSON module names";
Radek Krejcif9943642021-04-26 10:18:21 +0200848 case LY_VALUE_LYB:
849 return "LYB prefixes";
Michal Vasko7ed1fcb2020-12-03 14:15:22 +0100850 default:
851 break;
852 }
853
854 return NULL;
855}
Michal Vasko43297a02021-05-19 11:12:37 +0200856
857API LY_ERR
858ly_time_str2time(const char *value, time_t *time, char **fractions_s)
859{
860 struct tm tm = {0};
861 uint32_t i, frac_len;
862 const char *frac;
863 int64_t shift, shift_m;
864 time_t t;
865
866 LY_CHECK_ARG_RET(NULL, value, time, LY_EINVAL);
867
868 tm.tm_year = atoi(&value[0]) - 1900;
869 tm.tm_mon = atoi(&value[5]) - 1;
870 tm.tm_mday = atoi(&value[8]);
871 tm.tm_hour = atoi(&value[11]);
872 tm.tm_min = atoi(&value[14]);
873 tm.tm_sec = atoi(&value[17]);
874
875 t = timegm(&tm);
876 i = 19;
877
878 /* fractions of a second */
879 if (value[i] == '.') {
880 ++i;
881 frac = &value[i];
882 for (frac_len = 0; isdigit(frac[frac_len]); ++frac_len) {}
883
884 i += frac_len;
Michal Vasko43297a02021-05-19 11:12:37 +0200885 } else {
886 frac = NULL;
887 }
888
889 /* apply offset */
890 if ((value[i] == 'Z') || (value[i] == 'z')) {
891 /* zero shift */
892 shift = 0;
893 } else {
894 shift = strtol(&value[i], NULL, 10);
895 shift = shift * 60 * 60; /* convert from hours to seconds */
896 shift_m = strtol(&value[i + 4], NULL, 10) * 60; /* includes conversion from minutes to seconds */
897 /* correct sign */
898 if (shift < 0) {
899 shift_m *= -1;
900 }
901 /* connect hours and minutes of the shift */
902 shift = shift + shift_m;
903 }
904
905 /* we have to shift to the opposite way to correct the time */
906 t -= shift;
907
908 *time = t;
909 if (fractions_s) {
910 if (frac) {
911 *fractions_s = strndup(frac, frac_len);
912 LY_CHECK_RET(!*fractions_s, LY_EMEM);
913 } else {
914 *fractions_s = NULL;
915 }
916 }
917 return LY_SUCCESS;
918}
919
920API LY_ERR
921ly_time_time2str(time_t time, const char *fractions_s, char **str)
922{
923 struct tm tm;
Michal Vasko143ffa82021-05-20 11:11:39 +0200924 char zoneshift[8];
Michal Vasko43297a02021-05-19 11:12:37 +0200925 int32_t zonediff_h, zonediff_m;
926
927 LY_CHECK_ARG_RET(NULL, str, LY_EINVAL);
928
929 /* initialize the local timezone */
930 tzset();
931
932 /* convert */
933 if (!localtime_r(&time, &tm)) {
934 return LY_ESYS;
935 }
936
937 /* get timezone offset */
938 if (tm.tm_gmtoff == 0) {
939 /* time is Zulu (UTC) */
940 zonediff_h = 0;
941 zonediff_m = 0;
942 } else {
943 /* timezone offset */
944 zonediff_h = tm.tm_gmtoff / 60 / 60;
945 zonediff_m = tm.tm_gmtoff / 60 % 60;
946 }
947 sprintf(zoneshift, "%+03d:%02d", zonediff_h, zonediff_m);
948
949 /* print */
950 if (asprintf(str, "%04d-%02d-%02dT%02d:%02d:%02d%s%s%s",
951 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,
952 fractions_s ? "." : "", fractions_s ? fractions_s : "", zoneshift) == -1) {
953 return LY_EMEM;
954 }
955
956 return LY_SUCCESS;
957}
958
959API LY_ERR
960ly_time_str2ts(const char *value, struct timespec *ts)
961{
962 LY_ERR rc;
Michal Vasko72975062021-08-25 08:13:04 +0200963 char *fractions_s, frac_buf[10];
Michal Vasko43297a02021-05-19 11:12:37 +0200964 int frac_len;
965
966 LY_CHECK_ARG_RET(NULL, value, ts, LY_EINVAL);
967
968 rc = ly_time_str2time(value, &ts->tv_sec, &fractions_s);
969 LY_CHECK_RET(rc);
970
971 /* convert fractions of a second to nanoseconds */
972 if (fractions_s) {
Michal Vasko72975062021-08-25 08:13:04 +0200973 /* init frac_buf with zeroes */
974 memset(frac_buf, '0', 9);
975 frac_buf[9] = '\0';
976
Michal Vasko43297a02021-05-19 11:12:37 +0200977 frac_len = strlen(fractions_s);
978 memcpy(frac_buf, fractions_s, frac_len > 9 ? 9 : frac_len);
979 ts->tv_nsec = atol(frac_buf);
980 free(fractions_s);
981 } else {
982 ts->tv_nsec = 0;
983 }
984
985 return LY_SUCCESS;
986}
987
988API LY_ERR
989ly_time_ts2str(const struct timespec *ts, char **str)
990{
991 char frac_buf[10];
992
Jan Kundrátbd157002021-08-30 14:02:22 +0200993 LY_CHECK_ARG_RET(NULL, ts, str, ((ts->tv_nsec <= 999999999) && (ts->tv_nsec >= 0)), LY_EINVAL);
Michal Vasko43297a02021-05-19 11:12:37 +0200994
995 /* convert nanoseconds to fractions of a second */
996 if (ts->tv_nsec) {
997 sprintf(frac_buf, "%09ld", ts->tv_nsec);
998 }
999
1000 return ly_time_time2str(ts->tv_sec, ts->tv_nsec ? frac_buf : NULL, str);
1001}