context UPDATE module order matters for hash

Because it matters for LYB data where the
absolute index of a module is stored to
identify it.

Refs #2443

Author: michalvasko

src/context.c

@@ -751,77 +751,38 @@ ly_ctx_get_modules_hash(const struct ly_ctx *ctx)
     return ctx->mod_hash;
 }
 
-/**
- * @brief qsort() alphabetical compare of modules.
- */
-static int
-ly_ctx_mod_cmp_cb(const void *ptr1, const void *ptr2)
-{
-    const struct lys_module *mod1, *mod2;
-    int r;
-
-    mod1 = *(struct lys_module **)ptr1;
-    mod2 = *(struct lys_module **)ptr2;
-
-    /* module name */
-    r = strcmp(mod1->name, mod2->name);
-    if (!r) {
-        /* revision */
-        if (mod1->revision && !mod2->revision) {
-            r = 1;
-        } else if (!mod1->revision && mod2->revision) {
-            r = -1;
-        } else if (mod1->revision && mod2->revision) {
-            r = strcmp(mod1->revision, mod2->revision);
-        }
-    }
-
-    return r;
-}
-
 void
 ly_ctx_new_change(struct ly_ctx *ctx)
 {
-    uint32_t i, hash = 0;
-    const struct lys_module **mods = NULL;
+    const struct lys_module *mod;
+    uint32_t i = ly_ctx_internal_modules_count(ctx), hash = 0;
     LY_ARRAY_COUNT_TYPE u;
 
     /* change counter */
     ctx->change_count++;
 
-    /* collect modules into an array */
-    mods = malloc(ctx->modules.count * sizeof *mods);
-    LY_CHECK_ERR_GOTO(!mods, LOGMEM(ctx), cleanup);
-    memcpy(mods, ctx->modules.objs, ctx->modules.count * sizeof *mods);
-
-    /* sort modules alphabetically */
-    qsort(mods, ctx->modules.count, sizeof *mods, ly_ctx_mod_cmp_cb);
-
-    /* calculate module hash */
-    for (i = 0; i < ctx->modules.count; ++i) {
+    /* module hash */
+    while ((mod = ly_ctx_get_module_iter(ctx, &i))) {
         /* name */
-        hash = lyht_hash_multi(hash, mods[i]->name, strlen(mods[i]->name));
+        hash = lyht_hash_multi(hash, mod->name, strlen(mod->name));
 
         /* revision */
-        if (mods[i]->revision) {
-            hash = lyht_hash_multi(hash, mods[i]->revision, strlen(mods[i]->revision));
+        if (mod->revision) {
+            hash = lyht_hash_multi(hash, mod->revision, strlen(mod->revision));
         }
 
         /* enabled features */
-        if (mods[i]->implemented) {
-            LY_ARRAY_FOR(mods[i]->compiled->features, u) {
-                hash = lyht_hash_multi(hash, mods[i]->compiled->features[u], strlen(mods[i]->compiled->features[u]));
+        if (mod->implemented) {
+            LY_ARRAY_FOR(mod->compiled->features, u) {
+                hash = lyht_hash_multi(hash, mod->compiled->features[u], strlen(mod->compiled->features[u]));
             }
         }
 
         /* imported/implemented */
-        hash = lyht_hash_multi(hash, (char *)&mods[i]->implemented, sizeof mods[i]->implemented);
+        hash = lyht_hash_multi(hash, (char *)&mod->implemented, sizeof mod->implemented);
     }
 
     ctx->mod_hash = lyht_hash_multi(hash, NULL, 0);
-
-cleanup:
-    free(mods);
 }
 
 LIBYANG_API_DEF ly_module_imp_clb

src/context.h

@@ -414,10 +414,14 @@ LIBYANG_API_DECL LY_ERR ly_ctx_unset_options(struct ly_ctx *ctx, uint32_t option
 LIBYANG_API_DECL uint16_t ly_ctx_get_change_count(const struct ly_ctx *ctx);
 
 /**
- * @brief Get the hash of all the modules in the context.
+ * @brief Get the hash of all the modules in the context. Since order of the modules is significant,
+ * even when 2 contexts have the same modules but loaded in a different order, the hash will differ.
+ *
+ * Modules are added into the context in the order they are loaded in, imports following the modules
+ * that imported them.
  *
  * Hash consists of all module names (1), their revisions (2), all enabled features (3), and their
- * imported/implemented state (4). Context module order is not significant.
+ * imported/implemented state (4).
  *
  * @param[in] ctx Context to be examined.
  * @return Context modules hash.

src/parser_data.h

@@ -156,14 +156,16 @@ struct ly_in;
                                                      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.
+                                                     YANG data in the LYB data and their equal absolute order in the
+                                                     context 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 and any YANG data belong to modules
+                                                     before the module A, the parsing context does not have
+                                                     to have module A loaded but the hash check will fail without it.
                                                      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. */
+                                                     have all the required YANG modules in the same state and absolute
+                                                     order 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

@@ -408,8 +408,15 @@ lyb_parse_module_idx(struct lylyb_parse_ctx *lybctx, const struct lys_module **m
     /* read module index */
     lyb_read_count(&idx, lybctx);
 
+    /* check the read index */
+    if (idx >= lybctx->ctx->modules.count) {
+        LOGERR(lybctx->ctx, LY_EINT, "Invalid context for LYB data parsing, module with index %" PRIu32 " not found.",
+                idx);
+        rc = LY_EINT;
+        goto cleanup;
+    }
+
     /* get the module */
-    assert(idx < lybctx->ctx->modules.count);
     m = lybctx->ctx->modules.objs[idx];
     if (!m->implemented) {
         LOGERR(lybctx->ctx, LY_EINT, "Invalid context for LYB data parsing, module \"%s%s%s\" not implemented.",