parser data UPDATE flag for parsing LYB with non-matching ctx

Refs #2443

Author: michalvasko

src/parser_data.h

@@ -4,7 +4,7 @@
  * @author Michal Vasko <[email protected]>
  * @brief Data parsers for libyang
  *
- * Copyright (c) 2015-2023 CESNET, z.s.p.o.
+ * Copyright (c) 2015 - 2025 CESNET, z.s.p.o.
  *
  * This source code is licensed under BSD 3-Clause License (the "License").
  * You may not use this file except in compliance with the License.
@@ -149,7 +149,21 @@ struct ly_in;
 #define LYD_PARSE_OPAQ      0x040000        /**< Instead of silently ignoring data without definition, parse them into
                                                  an opaq node. Do not combine with ::LYD_PARSE_STRICT (except for ::LYD_LYB). */
 #define LYD_PARSE_NO_STATE  0x080000        /**< Forbid state data in the parsed data. Usually used with ::LYD_VALIDATE_NO_STATE. */
-#define LYD_PARSE_LYB_MOD_UPDATE  0x100000  /**< Deprecated, ignored. */
+#define LYD_PARSE_LYB_SKIP_CTX_CHECK 0x100000   /**< Normally, when printing LYB data, the context hash is written into
+                                                     the data that describes the context (see ::ly_ctx_get_modules_hash()).
+                                                     Then, when parsing the data, the hash is compared with the current
+                                                     context and an error is generated if they do not match. The reason
+                                                     for that is that the data may be parsed incorrectly possibly
+                                                     leading to a crash. However, this hash restriction is too severe
+                                                     and the hash must match only with regard to the modules with actual
+                                                     YANG data in the LYB data to guarantee correct data parsing. In other
+                                                     words, if there is a module A in the printing context but no data
+                                                     of this module in the LYB data, the parsing context does not have
+                                                     to have module A loaded but the hash check will fail in that case.
+                                                     So, if you are able to guarantee that the parsing context will
+                                                     have all the required YANG modules in the same state as in the
+                                                     printed context you can use this flag to effectively soften the
+                                                     context restriction. */
 #define LYD_PARSE_ORDERED 0x200000          /**< Do not search for the correct place of each node but instead expect
                                                  that the nodes are being parsed in the correct schema-based order,
                                                  which is always true if the data were printed by libyang and not

src/parser_lyb.c

@@ -1503,49 +1503,50 @@ lyb_parse_siblings(struct lyd_lyb_ctx *lybctx, struct lyd_node *parent, ly_bool
  * @return LY_ERR value.
  */
 static LY_ERR
-lyb_parse_header(struct lylyb_parse_ctx *lybctx)
+lyb_parse_header(struct lyd_lyb_ctx *lybctx)
 {
     uint8_t byte;
     uint32_t data_hash, cur_hash;
+    struct lylyb_parse_ctx *pctx = lybctx->parse_ctx;
 
     /* version */
     byte = 0;
-    lyb_read(&byte, LYB_HEADER_VERSION_BITS, lybctx);
+    lyb_read(&byte, LYB_HEADER_VERSION_BITS, pctx);
     if (byte != LYB_HEADER_VERSION_NUM) {
-        LOGERR(lybctx->ctx, LY_EINVAL, "Invalid LYB format version \"0x%" PRIx8 "\", expected \"0x%x\".",
+        LOGERR(pctx->ctx, LY_EINVAL, "Invalid LYB format version \"0x%" PRIx8 "\", expected \"0x%x\".",
                 byte, LYB_HEADER_VERSION_NUM);
         return LY_EINVAL;
     }
 
     /* hash algorithm */
     byte = 0;
-    lyb_read(&byte, LYB_HEADER_HASH_ALG_BITS, lybctx);
+    lyb_read(&byte, LYB_HEADER_HASH_ALG_BITS, pctx);
     if (byte != LYB_HEADER_HASH_ALG_NUM) {
-        LOGERR(lybctx->ctx, LY_EINVAL, "Different LYB format hash algorithm \"0x%" PRIx8 "\" used, expected \"0x%x\".",
+        LOGERR(pctx->ctx, LY_EINVAL, "Different LYB format hash algorithm \"0x%" PRIx8 "\" used, expected \"0x%x\".",
                 byte, LYB_HEADER_HASH_ALG_NUM);
         return LY_EINVAL;
     }
 
     /* shrink */
     byte = 0;
-    lyb_read(&byte, LYB_HEADER_SHRINK_FLAG_BITS, lybctx);
+    lyb_read(&byte, LYB_HEADER_SHRINK_FLAG_BITS, pctx);
     if (byte) {
-        lybctx->shrink = 1;
+        pctx->shrink = 1;
     }
 
     /* context hash */
     data_hash = 0;
-    lyb_read((uint8_t *)&data_hash, LYB_HEADER_CTX_HASH_BITS, lybctx);
+    lyb_read((uint8_t *)&data_hash, LYB_HEADER_CTX_HASH_BITS, pctx);
 
     if (!data_hash) {
         /* fine for no data */
-        lybctx->empty_hash = 1;
-    } else {
+        pctx->empty_hash = 1;
+    } else if (!(lybctx->parse_opts & LYD_PARSE_LYB_SKIP_CTX_CHECK)) {
         /* truncate context hash to the same bit size */
-        cur_hash = lyb_truncate_hash_nonzero(ly_ctx_get_modules_hash(lybctx->ctx), LYB_HEADER_CTX_HASH_BITS);
+        cur_hash = lyb_truncate_hash_nonzero(ly_ctx_get_modules_hash(pctx->ctx), LYB_HEADER_CTX_HASH_BITS);
 
         if (data_hash != cur_hash) {
-            LOGERR(lybctx->ctx, LY_EINVAL, "Different current LYB context modules hash compared to the one stored in the "
+            LOGERR(pctx->ctx, LY_EINVAL, "Different current LYB context modules hash compared to the one stored in the "
                     "LYB data (0x%" PRIx32 " != 0x%" PRIx32 ").", data_hash, cur_hash);
             return LY_EINVAL;
         }
@@ -1593,7 +1594,7 @@ lyd_parse_lyb(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, str
     LY_CHECK_GOTO(rc = lyd_parser_find_operation(parent, int_opts, &lybctx->op_node), cleanup);
 
     /* read header */
-    rc = lyb_parse_header(lybctx->parse_ctx);
+    rc = lyb_parse_header(lybctx);
     LY_CHECK_GOTO(rc, cleanup);
 
     /* read sibling(s) */