blob: 412c8fa96ed5301755a21421ac7cdc9aef246748 [file] [log] [blame]
Michal Vasko60ea6352020-06-29 13:39:39 +02001/**
2 * @file parser_lyb.c
3 * @author Michal Vasko <mvasko@cesnet.cz>
4 * @brief LYB data parser for libyang
5 *
6 * Copyright (c) 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#include "lyb.h"
16
17#include <assert.h>
Radek Krejciad97c5f2020-06-30 09:19:28 +020018#include <stdint.h>
Michal Vasko60ea6352020-06-29 13:39:39 +020019#include <stdio.h>
20#include <stdlib.h>
21#include <string.h>
22
23#include "common.h"
24#include "compat.h"
Radek Krejciad97c5f2020-06-30 09:19:28 +020025#include "context.h"
26#include "dict.h"
Radek Krejci47fab892020-11-05 17:02:41 +010027#include "hash_table.h"
28#include "in.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020029#include "in_internal.h"
Radek Krejciad97c5f2020-06-30 09:19:28 +020030#include "log.h"
Radek Krejci7931b192020-06-25 17:05:03 +020031#include "parser_data.h"
32#include "parser_internal.h"
Radek Krejciad97c5f2020-06-30 09:19:28 +020033#include "tree.h"
Radek Krejci47fab892020-11-05 17:02:41 +010034#include "tree_data.h"
Michal Vasko60ea6352020-06-29 13:39:39 +020035#include "tree_data_internal.h"
36#include "tree_schema.h"
37#include "validation.h"
38
Radek Krejci1798aae2020-07-14 13:26:06 +020039void
40lylyb_ctx_free(struct lylyb_ctx *ctx)
41{
42 LY_ARRAY_COUNT_TYPE u;
43
44 LY_ARRAY_FREE(ctx->subtrees);
45 LY_ARRAY_FREE(ctx->models);
46
47 LY_ARRAY_FOR(ctx->sib_hts, u) {
48 lyht_free(ctx->sib_hts[u].ht);
49 }
50 LY_ARRAY_FREE(ctx->sib_hts);
51
52 free(ctx);
53}
54
55void
56lyd_lyb_ctx_free(struct lyd_ctx *lydctx)
57{
58 struct lyd_lyb_ctx *ctx = (struct lyd_lyb_ctx *)lydctx;
59
60 lyd_ctx_free(lydctx);
61 lylyb_ctx_free(ctx->lybctx);
62 free(ctx);
63}
64
Michal Vasko60ea6352020-06-29 13:39:39 +020065/**
66 * @brief Read YANG data from LYB input. Metadata are handled transparently and not returned.
67 *
68 * @param[in] buf Destination buffer.
69 * @param[in] count Number of bytes to read.
70 * @param[in] lybctx LYB context.
71 */
72static void
Radek Krejci1798aae2020-07-14 13:26:06 +020073lyb_read(uint8_t *buf, size_t count, struct lylyb_ctx *lybctx)
Michal Vasko60ea6352020-06-29 13:39:39 +020074{
Michal Vaskofd69e1d2020-07-03 11:57:17 +020075 LY_ARRAY_COUNT_TYPE u;
Michal Vasko60ea6352020-06-29 13:39:39 +020076 struct lyd_lyb_subtree *empty;
77 size_t to_read;
78 uint8_t meta_buf[LYB_META_BYTES];
79
80 assert(lybctx);
81
82 while (1) {
83 /* check for fully-read (empty) data chunks */
84 to_read = count;
85 empty = NULL;
86 LY_ARRAY_FOR(lybctx->subtrees, u) {
87 /* we want the innermost chunks resolved first, so replace previous empty chunks,
88 * also ignore chunks that are completely finished, there is nothing for us to do */
89 if ((lybctx->subtrees[u].written <= to_read) && lybctx->subtrees[u].position) {
90 /* empty chunk, do not read more */
91 to_read = lybctx->subtrees[u].written;
92 empty = &lybctx->subtrees[u];
93 }
94 }
95
96 if (!empty && !count) {
97 break;
98 }
99
100 /* we are actually reading some data, not just finishing another chunk */
101 if (to_read) {
102 if (buf) {
Michal Vasko63f3d842020-07-08 10:10:14 +0200103 ly_in_read(lybctx->in, buf, to_read);
104 } else {
105 ly_in_skip(lybctx->in, to_read);
Michal Vasko60ea6352020-06-29 13:39:39 +0200106 }
107
108 LY_ARRAY_FOR(lybctx->subtrees, u) {
109 /* decrease all written counters */
110 lybctx->subtrees[u].written -= to_read;
111 assert(lybctx->subtrees[u].written <= LYB_SIZE_MAX);
112 }
113 /* decrease count/buf */
114 count -= to_read;
115 if (buf) {
116 buf += to_read;
117 }
Michal Vasko60ea6352020-06-29 13:39:39 +0200118 }
119
120 if (empty) {
121 /* read the next chunk meta information */
Michal Vasko63f3d842020-07-08 10:10:14 +0200122 ly_in_read(lybctx->in, meta_buf, LYB_META_BYTES);
Michal Vasko60ea6352020-06-29 13:39:39 +0200123 empty->written = meta_buf[0];
124 empty->inner_chunks = meta_buf[1];
125
126 /* remember whether there is a following chunk or not */
127 empty->position = (empty->written == LYB_SIZE_MAX ? 1 : 0);
Michal Vasko60ea6352020-06-29 13:39:39 +0200128 }
129 }
Michal Vasko60ea6352020-06-29 13:39:39 +0200130}
131
132/**
133 * @brief Read a number.
134 *
135 * @param[in] num Destination buffer.
136 * @param[in] num_size Size of @p num.
137 * @param[in] bytes Number of bytes to read.
138 * @param[in] lybctx LYB context.
139 */
140static void
Radek Krejci1798aae2020-07-14 13:26:06 +0200141lyb_read_number(void *num, size_t num_size, size_t bytes, struct lylyb_ctx *lybctx)
Michal Vasko60ea6352020-06-29 13:39:39 +0200142{
143 uint64_t buf = 0;
144
145 lyb_read((uint8_t *)&buf, bytes, lybctx);
146
147 /* correct byte order */
148 buf = le64toh(buf);
149
150 switch (num_size) {
151 case 1:
152 *((uint8_t *)num) = buf;
153 break;
154 case 2:
155 *((uint16_t *)num) = buf;
156 break;
157 case 4:
158 *((uint32_t *)num) = buf;
159 break;
160 case 8:
161 *((uint64_t *)num) = buf;
162 break;
163 default:
164 LOGINT(lybctx->ctx);
165 }
166}
167
168/**
169 * @brief Read a string.
170 *
171 * @param[in] str Destination buffer, is allocated.
172 * @param[in] with_length Whether the string is preceded with its length or it ends at the end of this subtree.
173 * @param[in] lybctx LYB context.
174 * @return LY_ERR value.
175 */
176static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200177lyb_read_string(char **str, ly_bool with_length, struct lylyb_ctx *lybctx)
Michal Vasko60ea6352020-06-29 13:39:39 +0200178{
Radek Krejci857189e2020-09-01 13:26:36 +0200179 ly_bool next_chunk = 0;
Michal Vasko60ea6352020-06-29 13:39:39 +0200180 size_t len = 0, cur_len;
181
182 *str = NULL;
183
184 if (with_length) {
185 lyb_read_number(&len, sizeof len, 2, lybctx);
186 } else {
187 /* read until the end of this subtree */
188 len = LYB_LAST_SUBTREE(lybctx).written;
189 if (LYB_LAST_SUBTREE(lybctx).position) {
190 next_chunk = 1;
191 }
192 }
193
194 *str = malloc((len + 1) * sizeof **str);
195 LY_CHECK_ERR_RET(!*str, LOGMEM(lybctx->ctx), LY_EMEM);
196
197 lyb_read((uint8_t *)*str, len, lybctx);
198
199 while (next_chunk) {
200 cur_len = LYB_LAST_SUBTREE(lybctx).written;
201 if (LYB_LAST_SUBTREE(lybctx).position) {
202 next_chunk = 1;
203 } else {
204 next_chunk = 0;
205 }
206
207 *str = ly_realloc(*str, (len + cur_len + 1) * sizeof **str);
208 LY_CHECK_ERR_RET(!*str, LOGMEM(lybctx->ctx), LY_EMEM);
209
210 lyb_read(((uint8_t *)*str) + len, cur_len, lybctx);
211
212 len += cur_len;
213 }
214
215 ((char *)*str)[len] = '\0';
216 return LY_SUCCESS;
217}
218
219/**
220 * @brief Stop the current subtree - change LYB context state.
221 *
222 * @param[in] lybctx LYB context.
223 * @return LY_ERR value.
224 */
225static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200226lyb_read_stop_subtree(struct lylyb_ctx *lybctx)
Michal Vasko60ea6352020-06-29 13:39:39 +0200227{
228 if (LYB_LAST_SUBTREE(lybctx).written) {
229 LOGINT_RET(lybctx->ctx);
230 }
231
232 LY_ARRAY_DECREMENT(lybctx->subtrees);
233 return LY_SUCCESS;
234}
235
236/**
237 * @brief Start a new subtree - change LYB context state but also read the expected metadata.
238 *
239 * @param[in] lybctx LYB context.
240 * @return LY_ERR value.
241 */
242static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200243lyb_read_start_subtree(struct lylyb_ctx *lybctx)
Michal Vasko60ea6352020-06-29 13:39:39 +0200244{
245 uint8_t meta_buf[LYB_META_BYTES];
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200246 LY_ARRAY_COUNT_TYPE u;
Michal Vasko60ea6352020-06-29 13:39:39 +0200247
248 if (!lybctx->subtrees) {
Radek Krejcif6d14cb2020-07-02 16:11:45 +0200249 assert(lybctx->subtree_size == 0);
Michal Vasko60ea6352020-06-29 13:39:39 +0200250 u = 0;
251 } else {
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200252 u = LY_ARRAY_COUNT(lybctx->subtrees);
Michal Vasko60ea6352020-06-29 13:39:39 +0200253 }
254 if (u == lybctx->subtree_size) {
255 LY_ARRAY_CREATE_RET(lybctx->ctx, lybctx->subtrees, u + LYB_SUBTREE_STEP, LY_EMEM);
256 lybctx->subtree_size = u + LYB_SUBTREE_STEP;
257 }
258
Michal Vasko63f3d842020-07-08 10:10:14 +0200259 LY_CHECK_RET(ly_in_read(lybctx->in, meta_buf, LYB_META_BYTES));
Michal Vasko60ea6352020-06-29 13:39:39 +0200260
261 LY_ARRAY_INCREMENT(lybctx->subtrees);
262 LYB_LAST_SUBTREE(lybctx).written = meta_buf[0];
263 LYB_LAST_SUBTREE(lybctx).inner_chunks = meta_buf[LYB_SIZE_BYTES];
264 LYB_LAST_SUBTREE(lybctx).position = (LYB_LAST_SUBTREE(lybctx).written == LYB_SIZE_MAX ? 1 : 0);
265
Michal Vasko60ea6352020-06-29 13:39:39 +0200266 return LY_SUCCESS;
267}
268
269/**
270 * @brief Parse YANG model info.
271 *
272 * @param[in] lybctx LYB context.
273 * @param[out] mod Parsed module.
274 * @return LY_ERR value.
275 */
276static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200277lyb_parse_model(struct lylyb_ctx *lybctx, uint32_t parse_options, const struct lys_module **mod)
Michal Vasko60ea6352020-06-29 13:39:39 +0200278{
279 LY_ERR ret = LY_SUCCESS;
280 char *mod_name = NULL, mod_rev[11];
281 uint16_t rev;
282
283 /* model name */
284 ret = lyb_read_string(&mod_name, 1, lybctx);
285 LY_CHECK_GOTO(ret, cleanup);
286
287 /* revision */
288 lyb_read_number(&rev, sizeof rev, 2, lybctx);
289
290 if (!mod_name[0]) {
291 /* opaq node, no module */
292 *mod = NULL;
293 goto cleanup;
294 }
295
296 if (rev) {
297 sprintf(mod_rev, "%04u-%02u-%02u", ((rev & 0xFE00) >> 9) + 2000, (rev & 0x01E0) >> 5, rev & 0x001Fu);
298 *mod = ly_ctx_get_module(lybctx->ctx, mod_name, mod_rev);
Radek Krejci1798aae2020-07-14 13:26:06 +0200299 if ((parse_options & LYD_PARSE_LYB_MOD_UPDATE) && !(*mod)) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200300 /* try to use an updated module */
301 *mod = ly_ctx_get_module_implemented(lybctx->ctx, mod_name);
302 if (*mod && (!(*mod)->revision || (strcmp((*mod)->revision, mod_rev) < 0))) {
303 /* not an implemented module in a newer revision */
304 *mod = NULL;
305 }
306 }
307 } else {
308 *mod = ly_ctx_get_module_latest(lybctx->ctx, mod_name);
309 }
310 /* TODO data_clb supported?
311 if (lybctx->ctx->data_clb) {
312 if (!*mod) {
313 *mod = lybctx->ctx->data_clb(lybctx->ctx, mod_name, NULL, 0, lybctx->ctx->data_clb_data);
314 } else if (!(*mod)->implemented) {
315 *mod = lybctx->ctx->data_clb(lybctx->ctx, mod_name, (*mod)->ns, LY_MODCLB_NOT_IMPLEMENTED, lybctx->ctx->data_clb_data);
316 }
317 }*/
318
319 if (!*mod || !(*mod)->implemented) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200320 if (parse_options & LYD_PARSE_STRICT) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200321 if (!*mod) {
322 LOGERR(lybctx->ctx, LY_EINVAL, "Invalid context for LYB data parsing, missing module \"%s%s%s\".",
Michal Vasko69730152020-10-09 16:30:07 +0200323 mod_name, rev ? "@" : "", rev ? mod_rev : "");
Michal Vasko60ea6352020-06-29 13:39:39 +0200324 } else if (!(*mod)->implemented) {
325 LOGERR(lybctx->ctx, LY_EINVAL, "Invalid context for LYB data parsing, module \"%s%s%s\" not implemented.",
Michal Vasko69730152020-10-09 16:30:07 +0200326 mod_name, rev ? "@" : "", rev ? mod_rev : "");
Michal Vasko60ea6352020-06-29 13:39:39 +0200327 }
328 ret = LY_EINVAL;
329 goto cleanup;
330 }
331
332 }
333
334cleanup:
335 free(mod_name);
336 return ret;
337}
338
339/**
340 * @brief Parse YANG node metadata.
341 *
342 * @param[in] lybctx LYB context.
Michal Vasko60ea6352020-06-29 13:39:39 +0200343 * @param[out] meta Parsed metadata.
344 * @return LY_ERR value.
345 */
346static LY_ERR
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200347lyb_parse_metadata(struct lyd_lyb_ctx *lybctx, struct lyd_meta **meta)
Michal Vasko60ea6352020-06-29 13:39:39 +0200348{
349 LY_ERR ret = LY_SUCCESS;
Radek Krejci857189e2020-09-01 13:26:36 +0200350 ly_bool dynamic;
Michal Vasko60ea6352020-06-29 13:39:39 +0200351 uint8_t i, count = 0;
Michal Vasko1e5d5612020-07-03 13:29:26 +0200352 char *meta_name = NULL, *meta_value;
Michal Vasko60ea6352020-06-29 13:39:39 +0200353 const struct lys_module *mod;
354
355 /* read number of attributes stored */
Radek Krejci1798aae2020-07-14 13:26:06 +0200356 lyb_read(&count, 1, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200357
358 /* read attributes */
359 for (i = 0; i < count; ++i) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200360 ret = lyb_read_start_subtree(lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200361 LY_CHECK_GOTO(ret, cleanup);
362
363 /* find model */
Radek Krejci1798aae2020-07-14 13:26:06 +0200364 ret = lyb_parse_model(lybctx->lybctx, lybctx->parse_options, &mod);
Michal Vasko60ea6352020-06-29 13:39:39 +0200365 LY_CHECK_GOTO(ret, cleanup);
366
367 if (!mod) {
368 /* skip it */
369 do {
Radek Krejci1798aae2020-07-14 13:26:06 +0200370 lyb_read(NULL, LYB_LAST_SUBTREE(lybctx->lybctx).written, lybctx->lybctx);
371 } while (LYB_LAST_SUBTREE(lybctx->lybctx).written);
Michal Vasko60ea6352020-06-29 13:39:39 +0200372 goto stop_subtree;
373 }
374
375 /* meta name */
Radek Krejci1798aae2020-07-14 13:26:06 +0200376 ret = lyb_read_string(&meta_name, 1, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200377 LY_CHECK_GOTO(ret, cleanup);
378
379 /* meta value */
Radek Krejci1798aae2020-07-14 13:26:06 +0200380 ret = lyb_read_string(&meta_value, 0, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200381 LY_CHECK_GOTO(ret, cleanup);
382 dynamic = 1;
383
384 /* create metadata */
Michal Vaskoc8a230d2020-08-14 12:17:10 +0200385 ret = lyd_parser_create_meta((struct lyd_ctx *)lybctx, NULL, meta, mod, meta_name, strlen(meta_name), meta_value,
Michal Vasko69730152020-10-09 16:30:07 +0200386 ly_strlen(meta_value), &dynamic, LY_PREF_JSON, NULL, LYD_HINT_DATA);
Michal Vasko60ea6352020-06-29 13:39:39 +0200387
388 /* free strings */
389 free(meta_name);
390 meta_name = NULL;
391 if (dynamic) {
392 free(meta_value);
393 dynamic = 0;
394 }
Michal Vasko60ea6352020-06-29 13:39:39 +0200395
Radek Krejci1798aae2020-07-14 13:26:06 +0200396 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +0200397
398stop_subtree:
Radek Krejci1798aae2020-07-14 13:26:06 +0200399 ret = lyb_read_stop_subtree(lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200400 LY_CHECK_GOTO(ret, cleanup);
401 }
402
403cleanup:
404 free(meta_name);
Michal Vasko60ea6352020-06-29 13:39:39 +0200405 if (ret) {
Michal Vasko3a41dff2020-07-15 14:30:28 +0200406 lyd_free_meta_siblings(*meta);
Michal Vasko60ea6352020-06-29 13:39:39 +0200407 *meta = NULL;
408 }
409 return ret;
410}
411
412/**
413 * @brief Parse opaque prefixes structure.
414 *
415 * @param[in] lybctx LYB context.
416 * @param[out] prefs Parsed prefixes.
417 * @return LY_ERR value.
418 */
419static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200420lyb_parse_opaq_prefixes(struct lylyb_ctx *lybctx, struct ly_prefix **prefs)
Michal Vasko60ea6352020-06-29 13:39:39 +0200421{
422 LY_ERR ret = LY_SUCCESS;
423 uint8_t count, i;
424 char *str;
425
426 /* read count */
427 lyb_read(&count, 1, lybctx);
428 if (!count) {
429 return LY_SUCCESS;
430 }
431
432 LY_ARRAY_CREATE_RET(lybctx->ctx, *prefs, count, LY_EMEM);
433 for (i = 0; i < count; ++i) {
434 LY_ARRAY_INCREMENT(*prefs);
435
436 /* prefix */
Radek Krejci011e4aa2020-09-04 15:22:31 +0200437 LY_CHECK_GOTO(ret = lyb_read_string(&str, 1, lybctx), cleanup);
438 LY_CHECK_GOTO(ret = lydict_insert_zc(lybctx->ctx, str, &(*prefs)[i].id), cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +0200439
Radek Krejci1798aae2020-07-14 13:26:06 +0200440 /* module reference is the same as JSON name */
Radek Krejci011e4aa2020-09-04 15:22:31 +0200441 LY_CHECK_GOTO(ret = lyb_read_string(&str, 1, lybctx), cleanup);
442 LY_CHECK_GOTO(ret = lydict_insert_zc(lybctx->ctx, str, &(*prefs)[i].module_name), cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +0200443 }
444
445cleanup:
446 if (ret) {
447 ly_free_val_prefs(lybctx->ctx, *prefs);
448 *prefs = NULL;
449 }
450 return ret;
451}
452
453/**
454 * @brief Parse opaque attributes.
455 *
456 * @param[in] lybctx LYB context.
457 * @param[out] attr Parsed attributes.
458 * @return LY_ERR value.
459 */
460static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200461lyb_parse_attributes(struct lylyb_ctx *lybctx, struct lyd_attr **attr)
Michal Vasko60ea6352020-06-29 13:39:39 +0200462{
463 LY_ERR ret = LY_SUCCESS;
464 uint8_t count, i;
Radek Krejci1798aae2020-07-14 13:26:06 +0200465 struct lyd_attr *attr2;
466 char *prefix = NULL, *module_name = NULL, *name = NULL, *value = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200467 ly_bool dynamic = 0;
Michal Vasko60ea6352020-06-29 13:39:39 +0200468 LYD_FORMAT format = 0;
469 struct ly_prefix *val_prefs = NULL;
470
471 /* read count */
472 lyb_read(&count, 1, lybctx);
473
474 /* read attributes */
475 for (i = 0; i < count; ++i) {
476 ret = lyb_read_start_subtree(lybctx);
477 LY_CHECK_GOTO(ret, cleanup);
478
479 /* prefix, may be emtpy */
480 ret = lyb_read_string(&prefix, 1, lybctx);
481 LY_CHECK_GOTO(ret, cleanup);
482 if (!prefix[0]) {
483 free(prefix);
484 prefix = NULL;
485 }
486
487 /* namespace, may be empty */
Radek Krejci1798aae2020-07-14 13:26:06 +0200488 ret = lyb_read_string(&module_name, 1, lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200489 LY_CHECK_GOTO(ret, cleanup);
Radek Krejci1798aae2020-07-14 13:26:06 +0200490 if (!module_name[0]) {
491 free(module_name);
492 module_name = NULL;
Michal Vasko60ea6352020-06-29 13:39:39 +0200493 }
494
495 /* name */
496 ret = lyb_read_string(&name, 1, lybctx);
497 LY_CHECK_GOTO(ret, cleanup);
498
499 /* value prefixes */
500 ret = lyb_parse_opaq_prefixes(lybctx, &val_prefs);
501 LY_CHECK_GOTO(ret, cleanup);
502
503 /* format */
504 lyb_read((uint8_t *)&format, 1, lybctx);
505
506 /* value */
507 ret = lyb_read_string(&value, 0, lybctx);
Radek Krejcid46e46a2020-09-15 14:22:42 +0200508 LY_CHECK_ERR_GOTO(ret, ly_free_val_prefs(lybctx->ctx, val_prefs), cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +0200509 dynamic = 1;
510
511 /* attr2 is always changed to the created attribute */
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200512 ret = lyd_create_attr(NULL, &attr2, lybctx->ctx, name, strlen(name), value, ly_strlen(value), &dynamic, format,
Michal Vasko69730152020-10-09 16:30:07 +0200513 0, val_prefs, prefix, ly_strlen(prefix), module_name, ly_strlen(module_name));
Michal Vasko60ea6352020-06-29 13:39:39 +0200514 LY_CHECK_GOTO(ret, cleanup);
515
516 free(prefix);
517 prefix = NULL;
Radek Krejci1798aae2020-07-14 13:26:06 +0200518 free(module_name);
519 module_name = NULL;
Michal Vasko60ea6352020-06-29 13:39:39 +0200520 free(name);
521 name = NULL;
Michal Vasko60ea6352020-06-29 13:39:39 +0200522 assert(!dynamic);
523 value = NULL;
524
525 if (!*attr) {
526 *attr = attr2;
527 }
528
529 ret = lyb_read_stop_subtree(lybctx);
530 LY_CHECK_GOTO(ret, cleanup);
531 }
532
533cleanup:
534 free(prefix);
Radek Krejci1798aae2020-07-14 13:26:06 +0200535 free(module_name);
Michal Vasko60ea6352020-06-29 13:39:39 +0200536 free(name);
537 if (dynamic) {
538 free(value);
539 }
Michal Vasko60ea6352020-06-29 13:39:39 +0200540 if (ret) {
Radek Krejci011e4aa2020-09-04 15:22:31 +0200541 lyd_free_attr_siblings(lybctx->ctx, *attr);
Michal Vasko60ea6352020-06-29 13:39:39 +0200542 *attr = NULL;
543 }
544 return ret;
545}
546
547/**
548 * @brief Check whether a schema node matches a hash(es).
549 *
550 * @param[in] sibling Schema node to check.
551 * @param[in] hash Hash array to check.
552 * @param[in] hash_count Number of hashes in @p hash.
553 * @return non-zero if matches,
554 * @return 0 if not.
555 */
556static int
557lyb_is_schema_hash_match(struct lysc_node *sibling, LYB_HASH *hash, uint8_t hash_count)
558{
559 LYB_HASH sibling_hash;
560 uint8_t i;
561
562 /* compare all the hashes starting from collision ID 0 */
563 for (i = 0; i < hash_count; ++i) {
564 sibling_hash = lyb_hash(sibling, i);
565 if (sibling_hash != hash[i]) {
566 return 0;
567 }
568 }
569
570 return 1;
571}
572
573/**
Michal Vasko60ea6352020-06-29 13:39:39 +0200574 * @brief Parse schema node hash.
575 *
576 * @param[in] lybctx LYB context.
577 * @param[in] sparent Schema parent, must be set if @p mod is not.
578 * @param[in] mod Module of the top-level node, must be set if @p sparent is not.
579 * @param[out] snode Parsed found schema node, may be NULL if opaque.
580 * @return LY_ERR value.
581 */
582static LY_ERR
583lyb_parse_schema_hash(struct lyd_lyb_ctx *lybctx, const struct lysc_node *sparent, const struct lys_module *mod,
Radek Krejci0f969882020-08-21 16:56:47 +0200584 const struct lysc_node **snode)
Michal Vasko60ea6352020-06-29 13:39:39 +0200585{
586 LY_ERR ret;
587 uint8_t i, j;
588 const struct lysc_node *sibling;
589 LYB_HASH hash[LYB_HASH_BITS - 1];
Radek Krejci1deb5be2020-08-26 16:43:36 +0200590 uint32_t getnext_opts;
Michal Vasko60ea6352020-06-29 13:39:39 +0200591
592 *snode = NULL;
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100593 getnext_opts = lybctx->int_opts & LYD_INTOPT_REPLY ? LYS_GETNEXT_OUTPUT : 0;
Michal Vasko60ea6352020-06-29 13:39:39 +0200594
595 /* read the first hash */
Radek Krejci1798aae2020-07-14 13:26:06 +0200596 lyb_read(&hash[0], sizeof *hash, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200597
598 if (!hash[0]) {
599 /* opaque node */
600 return LY_SUCCESS;
601 }
602
603 /* based on the first hash read all the other ones, if any */
604 for (i = 0; !(hash[0] & (LYB_HASH_COLLISION_ID >> i)); ++i) {
605 if (i > LYB_HASH_BITS) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200606 LOGINT_RET(lybctx->lybctx->ctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200607 }
608 }
609
610 /* move the first hash on its accurate position */
611 hash[i] = hash[0];
612
613 /* read the rest of hashes */
614 for (j = i; j; --j) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200615 lyb_read(&hash[j - 1], sizeof *hash, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200616
617 /* correct collision ID */
618 assert(hash[j - 1] & (LYB_HASH_COLLISION_ID >> (j - 1)));
619 /* preceded with zeros */
620 assert(!(hash[j - 1] & (LYB_HASH_MASK << (LYB_HASH_BITS - (j - 1)))));
621 }
622
623 /* find our node with matching hashes */
624 sibling = NULL;
625 while ((sibling = lys_getnext(sibling, sparent, mod ? mod->compiled : NULL, getnext_opts))) {
626 /* skip schema nodes from models not present during printing */
Michal Vasko69730152020-10-09 16:30:07 +0200627 if (lyb_has_schema_model(sibling, lybctx->lybctx->models) &&
628 lyb_is_schema_hash_match((struct lysc_node *)sibling, hash, i + 1)) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200629 /* match found */
630 break;
631 }
632 }
633
Radek Krejci7931b192020-06-25 17:05:03 +0200634 if (!sibling && (lybctx->parse_options & LYD_PARSE_STRICT)) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200635 if (mod) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200636 LOGVAL(lybctx->lybctx->ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "Failed to find matching hash for a top-level node"
Michal Vasko69730152020-10-09 16:30:07 +0200637 " from \"%s\".", mod->name);
Michal Vasko60ea6352020-06-29 13:39:39 +0200638 } else {
Radek Krejci1798aae2020-07-14 13:26:06 +0200639 LOGVAL(lybctx->lybctx->ctx, LY_VLOG_LYSC, sparent, LYVE_REFERENCE, "Failed to find matching hash for a child node"
Michal Vasko69730152020-10-09 16:30:07 +0200640 " of \"%s\".", sparent->name);
Michal Vasko60ea6352020-06-29 13:39:39 +0200641 }
642 return LY_EVALID;
Radek Krejci1798aae2020-07-14 13:26:06 +0200643 } else if (sibling && (ret = lyd_parser_check_schema((struct lyd_ctx *)lybctx, sibling))) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200644 return ret;
645 }
646
647 *snode = sibling;
648 return LY_SUCCESS;
649}
650
651/**
652 * @brief Read until the end of the current subtree.
653 *
654 * @param[in] lybctx LYB context.
655 */
656static void
Radek Krejci1798aae2020-07-14 13:26:06 +0200657lyb_skip_subtree(struct lylyb_ctx *lybctx)
Michal Vasko60ea6352020-06-29 13:39:39 +0200658{
Michal Vasko60ea6352020-06-29 13:39:39 +0200659 do {
660 /* first skip any meta information inside */
Michal Vasko63f3d842020-07-08 10:10:14 +0200661 ly_in_skip(lybctx->in, LYB_LAST_SUBTREE(lybctx).inner_chunks * LYB_META_BYTES);
Michal Vasko60ea6352020-06-29 13:39:39 +0200662
663 /* then read data */
664 lyb_read(NULL, LYB_LAST_SUBTREE(lybctx).written, lybctx);
665 } while (LYB_LAST_SUBTREE(lybctx).written);
666}
667
668/**
669 * @brief Parse LYB subtree.
670 *
671 * @param[in] lybctx LYB context.
672 * @param[in] parent Data parent of the subtree, must be set if @p first is not.
673 * @param[in,out] first First top-level sibling, must be set if @p parent is not.
674 * @return LY_ERR value.
675 */
676static LY_ERR
677lyb_parse_subtree_r(struct lyd_lyb_ctx *lybctx, struct lyd_node_inner *parent, struct lyd_node **first)
678{
679 LY_ERR ret = LY_SUCCESS;
680 struct lyd_node *node = NULL, *tree;
681 const struct lys_module *mod;
682 const struct lysc_node *snode = NULL;
683 struct lyd_meta *meta = NULL, *m;
Radek Krejci1798aae2020-07-14 13:26:06 +0200684 struct lyd_attr *attr = NULL, *a;
Michal Vasko60ea6352020-06-29 13:39:39 +0200685 struct ly_prefix *val_prefs = NULL;
686 LYD_ANYDATA_VALUETYPE value_type;
Radek Krejci1798aae2020-07-14 13:26:06 +0200687 char *value = NULL, *name = NULL, *prefix = NULL, *module_key = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200688 ly_bool dynamic = 0;
Michal Vasko60ea6352020-06-29 13:39:39 +0200689 LYD_FORMAT format = 0;
Michal Vaskoc5e866a2020-11-04 17:09:26 +0100690 uint32_t prev_lo, flags;
Radek Krejci1798aae2020-07-14 13:26:06 +0200691 const struct ly_ctx *ctx = lybctx->lybctx->ctx;
Michal Vasko60ea6352020-06-29 13:39:39 +0200692
693 /* register a new subtree */
Radek Krejci1798aae2020-07-14 13:26:06 +0200694 LY_CHECK_GOTO(ret = lyb_read_start_subtree(lybctx->lybctx), cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +0200695
696 if (!parent) {
697 /* top-level, read module name */
Radek Krejci1798aae2020-07-14 13:26:06 +0200698 ret = lyb_parse_model(lybctx->lybctx, lybctx->parse_options, &mod);
Michal Vasko60ea6352020-06-29 13:39:39 +0200699 LY_CHECK_GOTO(ret, cleanup);
700
701 /* read hash, find the schema node starting from mod */
702 ret = lyb_parse_schema_hash(lybctx, NULL, mod, &snode);
703 LY_CHECK_GOTO(ret, cleanup);
704 } else {
705 /* read hash, find the schema node starting from parent schema */
706 ret = lyb_parse_schema_hash(lybctx, parent->schema, NULL, &snode);
707 LY_CHECK_GOTO(ret, cleanup);
708 }
709
Radek Krejci0f969882020-08-21 16:56:47 +0200710 if (!snode && !(lybctx->parse_options & LYD_PARSE_OPAQ)) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200711 /* unknown data, skip them */
Radek Krejci1798aae2020-07-14 13:26:06 +0200712 lyb_skip_subtree(lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200713 goto stop_subtree;
Radek Krejci0f969882020-08-21 16:56:47 +0200714 }
Michal Vasko60ea6352020-06-29 13:39:39 +0200715
716 /* create metadata/attributes */
717 if (snode) {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200718 ret = lyb_parse_metadata(lybctx, &meta);
Michal Vasko60ea6352020-06-29 13:39:39 +0200719 LY_CHECK_GOTO(ret, cleanup);
720 } else {
Radek Krejci1798aae2020-07-14 13:26:06 +0200721 ret = lyb_parse_attributes(lybctx->lybctx, &attr);
Michal Vasko60ea6352020-06-29 13:39:39 +0200722 LY_CHECK_GOTO(ret, cleanup);
723 }
724
Michal Vaskoc5e866a2020-11-04 17:09:26 +0100725 /* read flags */
726 lyb_read_number(&flags, sizeof flags, sizeof flags, lybctx->lybctx);
727
Michal Vasko60ea6352020-06-29 13:39:39 +0200728 if (!snode) {
729 /* parse prefix */
Radek Krejci1798aae2020-07-14 13:26:06 +0200730 ret = lyb_read_string(&prefix, 1, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200731 LY_CHECK_GOTO(ret, cleanup);
732
Radek Krejci1798aae2020-07-14 13:26:06 +0200733 /* parse module key */
734 ret = lyb_read_string(&module_key, 1, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200735 LY_CHECK_GOTO(ret, cleanup);
736
737 /* parse name */
Radek Krejci1798aae2020-07-14 13:26:06 +0200738 ret = lyb_read_string(&name, 1, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200739 LY_CHECK_GOTO(ret, cleanup);
740
741 /* parse value prefixes */
Radek Krejci1798aae2020-07-14 13:26:06 +0200742 ret = lyb_parse_opaq_prefixes(lybctx->lybctx, &val_prefs);
Michal Vasko60ea6352020-06-29 13:39:39 +0200743 LY_CHECK_GOTO(ret, cleanup);
744
745 /* parse format */
Radek Krejci1798aae2020-07-14 13:26:06 +0200746 lyb_read((uint8_t *)&format, 1, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200747
748 /* parse value */
Radek Krejci1798aae2020-07-14 13:26:06 +0200749 ret = lyb_read_string(&value, 0, lybctx->lybctx);
Radek Krejcid46e46a2020-09-15 14:22:42 +0200750 LY_CHECK_ERR_GOTO(ret, ly_free_val_prefs(ctx, val_prefs), cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +0200751 dynamic = 1;
752
753 /* create node */
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200754 ret = lyd_create_opaq(ctx, name, strlen(name), value, strlen(value), &dynamic, format, 0, val_prefs, prefix,
Michal Vasko69730152020-10-09 16:30:07 +0200755 ly_strlen(prefix), module_key, ly_strlen(module_key), &node);
Michal Vasko60ea6352020-06-29 13:39:39 +0200756 LY_CHECK_GOTO(ret, cleanup);
757
758 /* process children */
Radek Krejci1798aae2020-07-14 13:26:06 +0200759 while (LYB_LAST_SUBTREE(lybctx->lybctx).written) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200760 ret = lyb_parse_subtree_r(lybctx, (struct lyd_node_inner *)node, NULL);
761 LY_CHECK_GOTO(ret, cleanup);
762 }
763 } else if (snode->nodetype & LYD_NODE_TERM) {
764 /* parse value */
Radek Krejci1798aae2020-07-14 13:26:06 +0200765 ret = lyb_read_string(&value, 0, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200766 LY_CHECK_GOTO(ret, cleanup);
767 dynamic = 1;
768
769 /* create node */
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200770 ret = lyd_parser_create_term((struct lyd_ctx *)lybctx, snode, value, ly_strlen(value), &dynamic, LY_PREF_JSON,
Michal Vasko69730152020-10-09 16:30:07 +0200771 NULL, LYD_HINT_DATA, &node);
Michal Vasko60ea6352020-06-29 13:39:39 +0200772 if (dynamic) {
773 free(value);
774 dynamic = 0;
775 }
776 value = NULL;
Radek Krejci1798aae2020-07-14 13:26:06 +0200777 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +0200778 } else if (snode->nodetype & LYD_NODE_INNER) {
779 /* create node */
780 ret = lyd_create_inner(snode, &node);
781 LY_CHECK_GOTO(ret, cleanup);
782
783 /* process children */
Radek Krejci1798aae2020-07-14 13:26:06 +0200784 while (LYB_LAST_SUBTREE(lybctx->lybctx).written) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200785 ret = lyb_parse_subtree_r(lybctx, (struct lyd_node_inner *)node, NULL);
786 LY_CHECK_GOTO(ret, cleanup);
787 }
788
Radek Krejci7931b192020-06-25 17:05:03 +0200789 if (!(lybctx->parse_options & LYD_PARSE_ONLY)) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200790 /* new node validation, autodelete CANNOT occur, all nodes are new */
Michal Vasko8104fd42020-07-13 11:09:51 +0200791 ret = lyd_validate_new(lyd_node_children_p(node), snode, NULL, NULL);
Michal Vasko60ea6352020-06-29 13:39:39 +0200792 LY_CHECK_GOTO(ret, cleanup);
793
794 /* add any missing default children */
Michal Vaskoa6669ba2020-08-06 16:14:26 +0200795 ret = lyd_new_implicit_r(node, lyd_node_children_p(node), NULL, NULL, &lybctx->unres_node_type,
Michal Vasko69730152020-10-09 16:30:07 +0200796 &lybctx->when_check, (lybctx->validate_options & LYD_VALIDATE_NO_STATE) ?
797 LYD_IMPLICIT_NO_STATE : 0, NULL);
Michal Vasko60ea6352020-06-29 13:39:39 +0200798 LY_CHECK_GOTO(ret, cleanup);
799 }
800
Michal Vasko751cb4d2020-07-14 12:25:28 +0200801 if (snode->nodetype & (LYS_RPC | LYS_ACTION | LYS_NOTIF)) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200802 /* rememeber the RPC/action/notification */
Radek Krejci1798aae2020-07-14 13:26:06 +0200803 lybctx->op_node = node;
Michal Vasko60ea6352020-06-29 13:39:39 +0200804 }
805 } else if (snode->nodetype & LYD_NODE_ANY) {
806 /* parse value type */
Radek Krejci1798aae2020-07-14 13:26:06 +0200807 lyb_read((uint8_t *)&value_type, sizeof value_type, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200808 if (value_type == LYD_ANYDATA_DATATREE) {
809 /* invalid situation */
Radek Krejci1798aae2020-07-14 13:26:06 +0200810 LOGINT(ctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200811 goto cleanup;
812 }
813
814 /* read anydata content */
Radek Krejci1798aae2020-07-14 13:26:06 +0200815 ret = lyb_read_string(&value, 0, lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200816 LY_CHECK_GOTO(ret, cleanup);
817 dynamic = 1;
818
819 if (value_type == LYD_ANYDATA_LYB) {
820 /* turn logging off */
821 prev_lo = ly_log_options(0);
822
823 /* try to parse LYB into a data tree */
Radek Krejci1798aae2020-07-14 13:26:06 +0200824 if (lyd_parse_data_mem(ctx, value, LYD_LYB, LYD_PARSE_ONLY | LYD_PARSE_OPAQ | LYD_PARSE_STRICT, 0, &tree) == LY_SUCCESS) {
Michal Vasko60ea6352020-06-29 13:39:39 +0200825 /* successfully parsed */
826 free(value);
827 value = (char *)tree;
828 value_type = LYD_ANYDATA_DATATREE;
829 }
Radek Krejci7931b192020-06-25 17:05:03 +0200830
831 /* turn logging on again */
832 ly_log_options(prev_lo);
Michal Vasko60ea6352020-06-29 13:39:39 +0200833 }
834
835 /* create node */
836 ret = lyd_create_any(snode, value, value_type, &node);
837 LY_CHECK_GOTO(ret, cleanup);
838
839 dynamic = 0;
840 value = NULL;
841 }
842 assert(node);
843
Michal Vaskoc5e866a2020-11-04 17:09:26 +0100844 /* set flags */
845 node->flags = flags;
Michal Vasko60ea6352020-06-29 13:39:39 +0200846
847 /* add metadata/attributes */
848 if (snode) {
849 LY_LIST_FOR(meta, m) {
850 m->parent = node;
851 }
852 node->meta = meta;
853 meta = NULL;
854 } else {
855 assert(!node->schema);
856 LY_LIST_FOR(attr, a) {
857 a->parent = (struct lyd_node_opaq *)node;
858 }
859 ((struct lyd_node_opaq *)node)->attr = attr;
860 attr = NULL;
861 }
862
Michal Vaskob104f112020-07-17 09:54:54 +0200863 /* insert, keep first pointer correct */
Michal Vasko60ea6352020-06-29 13:39:39 +0200864 lyd_insert_node((struct lyd_node *)parent, first, node);
Michal Vaskob104f112020-07-17 09:54:54 +0200865 while (!parent && (*first)->prev->next) {
866 *first = (*first)->prev;
867 }
Michal Vasko60ea6352020-06-29 13:39:39 +0200868 node = NULL;
869
870stop_subtree:
871 /* end the subtree */
Radek Krejci1798aae2020-07-14 13:26:06 +0200872 ret = lyb_read_stop_subtree(lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +0200873 LY_CHECK_GOTO(ret, cleanup);
874
875cleanup:
876 free(prefix);
Radek Krejci1798aae2020-07-14 13:26:06 +0200877 free(module_key);
Michal Vasko60ea6352020-06-29 13:39:39 +0200878 free(name);
879 if (dynamic) {
880 free(value);
881 }
Michal Vasko60ea6352020-06-29 13:39:39 +0200882
Michal Vasko3a41dff2020-07-15 14:30:28 +0200883 lyd_free_meta_siblings(meta);
Radek Krejci011e4aa2020-09-04 15:22:31 +0200884 lyd_free_attr_siblings(ctx, attr);
Michal Vasko60ea6352020-06-29 13:39:39 +0200885 lyd_free_tree(node);
886 return ret;
887}
888
889/**
890 * @brief Parse used YANG data models.
891 *
892 * @param[in] lybctx LYB context.
893 * @return LY_ERR value.
894 */
895static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200896lyb_parse_data_models(struct lylyb_ctx *lybctx, uint32_t parse_options)
Michal Vasko60ea6352020-06-29 13:39:39 +0200897{
898 LY_ERR ret;
899 uint32_t count;
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200900 LY_ARRAY_COUNT_TYPE u;
Michal Vasko60ea6352020-06-29 13:39:39 +0200901
902 /* read model count */
903 lyb_read_number(&count, sizeof count, 2, lybctx);
904
905 if (count) {
906 LY_ARRAY_CREATE_RET(lybctx->ctx, lybctx->models, count, LY_EMEM);
907
908 /* read modules */
909 for (u = 0; u < count; ++u) {
Radek Krejci1798aae2020-07-14 13:26:06 +0200910 ret = lyb_parse_model(lybctx, parse_options, &lybctx->models[u]);
Michal Vasko60ea6352020-06-29 13:39:39 +0200911 LY_CHECK_RET(ret);
912 LY_ARRAY_INCREMENT(lybctx->models);
913 }
914 }
915
916 return LY_SUCCESS;
917}
918
919/**
920 * @brief Parse LYB magic number.
921 *
922 * @param[in] lybctx LYB context.
923 * @return LY_ERR value.
924 */
925static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200926lyb_parse_magic_number(struct lylyb_ctx *lybctx)
Michal Vasko60ea6352020-06-29 13:39:39 +0200927{
928 char magic_byte = 0;
929
930 lyb_read((uint8_t *)&magic_byte, 1, lybctx);
931 if (magic_byte != 'l') {
932 LOGERR(lybctx->ctx, LY_EINVAL, "Invalid first magic number byte \"0x%02x\".", magic_byte);
933 return LY_EINVAL;
934 }
935
936 lyb_read((uint8_t *)&magic_byte, 1, lybctx);
937 if (magic_byte != 'y') {
938 LOGERR(lybctx->ctx, LY_EINVAL, "Invalid second magic number byte \"0x%02x\".", magic_byte);
939 return LY_EINVAL;
940 }
941
942 lyb_read((uint8_t *)&magic_byte, 1, lybctx);
943 if (magic_byte != 'b') {
944 LOGERR(lybctx->ctx, LY_EINVAL, "Invalid third magic number byte \"0x%02x\".", magic_byte);
945 return LY_EINVAL;
946 }
947
948 return LY_SUCCESS;
949}
950
951/**
952 * @brief Parse LYB header.
953 *
954 * @param[in] lybctx LYB context.
955 * @return LY_ERR value.
956 */
957static LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +0200958lyb_parse_header(struct lylyb_ctx *lybctx)
Michal Vasko60ea6352020-06-29 13:39:39 +0200959{
960 uint8_t byte = 0;
961
962 /* version, future flags */
963 lyb_read((uint8_t *)&byte, sizeof byte, lybctx);
964
965 if ((byte & LYB_VERSION_MASK) != LYB_VERSION_NUM) {
966 LOGERR(lybctx->ctx, LY_EINVAL, "Invalid LYB format version \"0x%02x\", expected \"0x%02x\".",
Michal Vasko69730152020-10-09 16:30:07 +0200967 byte & LYB_VERSION_MASK, LYB_VERSION_NUM);
Michal Vasko60ea6352020-06-29 13:39:39 +0200968 return LY_EINVAL;
969 }
970
971 return LY_SUCCESS;
972}
973
Michal Vaskoee38a5d2020-11-09 21:02:18 +0100974/**
Radek Krejci1798aae2020-07-14 13:26:06 +0200975 * @param[in] ctx libyang context for logging
Michal Vaskoee38a5d2020-11-09 21:02:18 +0100976 * @param[in] parent Parent node where to connect the parsed data, required for reply where the reply data are connected
977 * with the request operation
Radek Krejci1798aae2020-07-14 13:26:06 +0200978 * @param[in] in Input structure.
979 * @param[in] parse_options Options for parser, see @ref dataparseroptions.
980 * @param[in] validate_options Options for the validation phase, see @ref datavalidationoptions.
981 * @param[in] data_type Internal data parser flag to distnguish type of the data to parse (RPC/Reply/Notification/regular data].
982 * @param[out] tree_p Parsed data tree. Note that NULL can be a valid result.
983 * @param[out] op_p Optional pointer to the actual operation. Useful for action and inner notifications.
984 * @param[out] lydctx_p Data parser context to finish validation.
985 */
986static LY_ERR
Michal Vaskoee38a5d2020-11-09 21:02:18 +0100987lyd_parse_lyb_(const struct ly_ctx *ctx, struct lyd_node_inner **parent, struct ly_in *in, uint32_t parse_options,
988 uint32_t validate_options, uint32_t data_type, struct lyd_node **tree_p, struct lyd_node **op_p,
989 struct lyd_ctx **lydctx_p)
Michal Vasko60ea6352020-06-29 13:39:39 +0200990{
991 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +0200992 struct lyd_lyb_ctx *lybctx;
993 struct lyd_node *tree = NULL;
Michal Vasko60ea6352020-06-29 13:39:39 +0200994
Radek Krejci7931b192020-06-25 17:05:03 +0200995 assert(!(parse_options & ~LYD_PARSE_OPTS_MASK));
996 assert(!(validate_options & ~LYD_VALIDATE_OPTS_MASK));
997
Radek Krejci1798aae2020-07-14 13:26:06 +0200998 lybctx = calloc(1, sizeof *lybctx);
999 LY_CHECK_ERR_RET(!lybctx, LOGMEM(ctx), LY_EMEM);
1000 lybctx->lybctx = calloc(1, sizeof *lybctx->lybctx);
Michal Vasko9acaf492020-08-13 09:05:58 +02001001 LY_CHECK_ERR_GOTO(!lybctx->lybctx, LOGMEM(ctx); ret = LY_EMEM, cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +02001002
Radek Krejci1798aae2020-07-14 13:26:06 +02001003 lybctx->lybctx->in = in;
1004 lybctx->lybctx->ctx = ctx;
1005 lybctx->parse_options = parse_options;
1006 lybctx->validate_options = validate_options;
1007 lybctx->int_opts = data_type;
1008 lybctx->free = lyd_lyb_ctx_free;
Michal Vasko60ea6352020-06-29 13:39:39 +02001009
1010 /* read magic number */
Radek Krejci1798aae2020-07-14 13:26:06 +02001011 ret = lyb_parse_magic_number(lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001012 LY_CHECK_GOTO(ret, cleanup);
1013
1014 /* read header */
Radek Krejci1798aae2020-07-14 13:26:06 +02001015 ret = lyb_parse_header(lybctx->lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001016 LY_CHECK_GOTO(ret, cleanup);
1017
1018 /* read used models */
Radek Krejci1798aae2020-07-14 13:26:06 +02001019 ret = lyb_parse_data_models(lybctx->lybctx, lybctx->parse_options);
Michal Vasko60ea6352020-06-29 13:39:39 +02001020 LY_CHECK_GOTO(ret, cleanup);
1021
1022 /* read subtree(s) */
Radek Krejci1798aae2020-07-14 13:26:06 +02001023 while (lybctx->lybctx->in->current[0]) {
1024 ret = lyb_parse_subtree_r(lybctx, parent ? *parent : NULL, &tree);
Michal Vasko60ea6352020-06-29 13:39:39 +02001025 LY_CHECK_GOTO(ret, cleanup);
1026 }
1027
1028 /* read the last zero, parsing finished */
Radek Krejci1798aae2020-07-14 13:26:06 +02001029 ly_in_skip(lybctx->lybctx->in, 1);
Michal Vasko60ea6352020-06-29 13:39:39 +02001030
Radek Krejci1798aae2020-07-14 13:26:06 +02001031 if (data_type == LYD_INTOPT_RPC) {
1032 /* make sure we have parsed some operation */
1033 if (!lybctx->op_node) {
1034 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_DATA, "Missing the \"rpc\"/\"action\" node.");
1035 ret = LY_EVALID;
1036 goto cleanup;
1037 }
1038
1039 if (op_p) {
1040 *op_p = lybctx->op_node;
1041 }
1042 assert(tree);
1043 } else if (data_type == LYD_INTOPT_REPLY) {
1044 struct lyd_node_inner *iter;
1045
1046 assert(parent);
1047
1048 if (op_p) {
Michal Vasko22df3f02020-08-24 13:29:22 +02001049 *op_p = (struct lyd_node *)(*parent);
Radek Krejci1798aae2020-07-14 13:26:06 +02001050 }
Radek Krejci1e008d22020-08-17 11:37:37 +02001051 for (iter = *parent; iter->parent; iter = iter->parent) {}
Radek Krejci1798aae2020-07-14 13:26:06 +02001052 tree = (struct lyd_node *)iter;
1053 *parent = NULL;
1054
1055 } else if (data_type == LYD_INTOPT_NOTIF) {
1056 /* make sure we have parsed some notification */
1057 if (!lybctx->op_node) {
1058 LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_DATA, "Missing the \"notification\" node.");
1059 ret = LY_EVALID;
1060 goto cleanup;
1061 }
1062
1063 if (op_p) {
1064 *op_p = lybctx->op_node;
1065 }
1066 assert(tree);
1067 }
Michal Vasko60ea6352020-06-29 13:39:39 +02001068
1069cleanup:
Radek Krejci1798aae2020-07-14 13:26:06 +02001070 if (ret || !lydctx_p) {
1071 lyd_lyb_ctx_free((struct lyd_ctx *)lybctx);
1072 if (ret) {
1073 lyd_free_all(tree);
1074 }
1075 } else {
1076 *lydctx_p = (struct lyd_ctx *)lybctx;
1077 if (tree_p) {
1078 *tree_p = tree;
1079 }
Michal Vasko60ea6352020-06-29 13:39:39 +02001080 }
1081 return ret;
1082}
1083
1084LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +02001085lyd_parse_lyb_data(const struct ly_ctx *ctx, struct ly_in *in, uint32_t parse_options, uint32_t validate_options,
Radek Krejci0f969882020-08-21 16:56:47 +02001086 struct lyd_node **tree_p, struct lyd_ctx **lydctx_p)
Michal Vasko60ea6352020-06-29 13:39:39 +02001087{
Radek Krejci1798aae2020-07-14 13:26:06 +02001088 return lyd_parse_lyb_(ctx, NULL, in, parse_options, validate_options, 0, tree_p, NULL, lydctx_p);
Michal Vasko60ea6352020-06-29 13:39:39 +02001089}
1090
1091LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +02001092lyd_parse_lyb_rpc(const struct ly_ctx *ctx, struct ly_in *in, struct lyd_node **tree_p, struct lyd_node **op_p)
Michal Vasko60ea6352020-06-29 13:39:39 +02001093{
Radek Krejci1798aae2020-07-14 13:26:06 +02001094 return lyd_parse_lyb_(ctx, NULL, in, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, LYD_INTOPT_RPC, tree_p, op_p, NULL);
Michal Vasko60ea6352020-06-29 13:39:39 +02001095}
1096
1097LY_ERR
Radek Krejci1798aae2020-07-14 13:26:06 +02001098lyd_parse_lyb_notif(const struct ly_ctx *ctx, struct ly_in *in, struct lyd_node **tree_p, struct lyd_node **ntf_p)
Michal Vasko60ea6352020-06-29 13:39:39 +02001099{
Radek Krejci1798aae2020-07-14 13:26:06 +02001100 return lyd_parse_lyb_(ctx, NULL, in, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0, LYD_INTOPT_NOTIF, tree_p, ntf_p, NULL);
1101}
Michal Vasko60ea6352020-06-29 13:39:39 +02001102
Radek Krejci1798aae2020-07-14 13:26:06 +02001103LY_ERR
1104lyd_parse_lyb_reply(const struct lyd_node *request, struct ly_in *in, struct lyd_node **tree_p, struct lyd_node **op_p)
1105{
1106 LY_ERR ret;
1107 struct lyd_node *req_op, *rep_op = NULL;
Michal Vaskob7be7a82020-08-20 09:09:04 +02001108 const struct ly_ctx *ctx = LYD_CTX(request);
Michal Vasko60ea6352020-06-29 13:39:39 +02001109
1110 /* find request OP */
Michal Vasko56daf732020-08-10 10:57:18 +02001111 LYD_TREE_DFS_BEGIN((struct lyd_node *)request, req_op) {
Michal Vasko60ea6352020-06-29 13:39:39 +02001112 if (req_op->schema->nodetype & (LYS_RPC | LYS_ACTION)) {
1113 break;
1114 }
Michal Vasko56daf732020-08-10 10:57:18 +02001115 LYD_TREE_DFS_END(request, req_op);
Michal Vasko60ea6352020-06-29 13:39:39 +02001116 }
1117 if (!(req_op->schema->nodetype & (LYS_RPC | LYS_ACTION))) {
Michal Vaskob7be7a82020-08-20 09:09:04 +02001118 LOGERR(LYD_CTX(request), LY_EINVAL, "No RPC/action in the request found.");
Radek Krejci1798aae2020-07-14 13:26:06 +02001119 return LY_EINVAL;
Michal Vasko60ea6352020-06-29 13:39:39 +02001120 }
1121
1122 /* duplicate request OP with parents */
Radek Krejci1798aae2020-07-14 13:26:06 +02001123 LY_CHECK_RET(lyd_dup_single(req_op, NULL, LYD_DUP_WITH_PARENTS, &rep_op));
Michal Vasko60ea6352020-06-29 13:39:39 +02001124
Michal Vaskoee38a5d2020-11-09 21:02:18 +01001125 ret = lyd_parse_lyb_(ctx, (struct lyd_node_inner **)&rep_op, in, LYD_PARSE_ONLY | LYD_PARSE_STRICT, 0,
1126 LYD_INTOPT_REPLY, tree_p, op_p, NULL);
Michal Vasko60ea6352020-06-29 13:39:39 +02001127
Michal Vasko60ea6352020-06-29 13:39:39 +02001128 lyd_free_all(rep_op);
Michal Vasko60ea6352020-06-29 13:39:39 +02001129
Michal Vasko60ea6352020-06-29 13:39:39 +02001130 return ret;
1131}
1132
1133API int
1134lyd_lyb_data_length(const char *data)
1135{
1136 LY_ERR ret = LY_SUCCESS;
Radek Krejci1798aae2020-07-14 13:26:06 +02001137 struct lylyb_ctx *lybctx;
Michal Vasko60ea6352020-06-29 13:39:39 +02001138 int count, i;
1139 size_t len;
1140 uint8_t buf[LYB_SIZE_MAX];
1141
1142 if (!data) {
1143 return -1;
1144 }
1145
Radek Krejci1798aae2020-07-14 13:26:06 +02001146 lybctx = calloc(1, sizeof *lybctx);
1147 LY_CHECK_ERR_RET(!lybctx, LOGMEM(NULL), LY_EMEM);
1148 ret = ly_in_new_memory(data, &lybctx->in);
Michal Vasko63f3d842020-07-08 10:10:14 +02001149 LY_CHECK_GOTO(ret, cleanup);
Michal Vasko60ea6352020-06-29 13:39:39 +02001150
1151 /* read magic number */
Radek Krejci1798aae2020-07-14 13:26:06 +02001152 ret = lyb_parse_magic_number(lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001153 LY_CHECK_GOTO(ret, cleanup);
1154
1155 /* read header */
Radek Krejci1798aae2020-07-14 13:26:06 +02001156 ret = lyb_parse_header(lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001157 LY_CHECK_GOTO(ret, cleanup);
1158
1159 /* read model count */
Radek Krejci1798aae2020-07-14 13:26:06 +02001160 lyb_read_number(&count, sizeof count, 2, lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001161
1162 /* read all models */
1163 for (i = 0; i < count; ++i) {
1164 /* module name length */
1165 len = 0;
Radek Krejci1798aae2020-07-14 13:26:06 +02001166 lyb_read_number(&len, sizeof len, 2, lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001167
1168 /* model name */
Radek Krejci1798aae2020-07-14 13:26:06 +02001169 lyb_read(buf, len, lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001170
1171 /* revision */
Radek Krejci1798aae2020-07-14 13:26:06 +02001172 lyb_read(buf, 2, lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001173 }
1174
Radek Krejci1798aae2020-07-14 13:26:06 +02001175 while (lybctx->in->current[0]) {
Michal Vasko60ea6352020-06-29 13:39:39 +02001176 /* register a new subtree */
Radek Krejci1798aae2020-07-14 13:26:06 +02001177 ret = lyb_read_start_subtree(lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001178 LY_CHECK_GOTO(ret, cleanup);
1179
1180 /* skip it */
Radek Krejci1798aae2020-07-14 13:26:06 +02001181 lyb_skip_subtree(lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001182
1183 /* subtree finished */
Radek Krejci1798aae2020-07-14 13:26:06 +02001184 ret = lyb_read_stop_subtree(lybctx);
Michal Vasko60ea6352020-06-29 13:39:39 +02001185 LY_CHECK_GOTO(ret, cleanup);
1186 }
1187
1188 /* read the last zero, parsing finished */
Radek Krejci1798aae2020-07-14 13:26:06 +02001189 ly_in_skip(lybctx->in, 1);
Michal Vasko60ea6352020-06-29 13:39:39 +02001190
1191cleanup:
Radek Krejci1798aae2020-07-14 13:26:06 +02001192 count = lybctx->in->current - lybctx->in->start;
Michal Vasko63f3d842020-07-08 10:10:14 +02001193
Radek Krejci1798aae2020-07-14 13:26:06 +02001194 ly_in_free(lybctx->in, 0);
1195 lylyb_ctx_free(lybctx);
1196
Michal Vasko63f3d842020-07-08 10:10:14 +02001197 return ret ? -1 : count;
Michal Vasko60ea6352020-06-29 13:39:39 +02001198}