schema compile BUGFIX leafref circular chain with a union

Author: michalvasko

src/schema_compile.c

@@ -810,6 +810,49 @@ lys_compile_unres_disabled_bitenum(struct lysc_ctx *ctx, struct lysc_node_leaf *
     return LY_SUCCESS;
 }
 
+/**
+ * @brief Check a leafref for circular references.
+ *
+ * @param[in] type Referenced type, is checked recursively for other leafrefs.
+ * @param[in] lref Initial leafref type that cannot be referenced.
+ * @return LY_SUCCESS on success;
+ * @return LY_EVALID on a circular chein of leafrefs.
+ */
+static LY_ERR
+lys_compile_leafref_circ_check(const struct lysc_type *type, const struct lysc_type *lref)
+{
+    const struct lysc_type_union *un;
+    LY_ARRAY_COUNT_TYPE u;
+
+    if (!type) {
+        /* not resolved yet */
+        return LY_SUCCESS;
+    }
+
+    if (type == lref) {
+        /* circular chain detected */
+        return LY_EVALID;
+    }
+
+    switch (type->basetype) {
+    case LY_TYPE_LEAFREF:
+        /* check the referenced type */
+        LY_CHECK_RET(lys_compile_leafref_circ_check(((struct lysc_type_leafref *)type)->realtype, lref));
+        break;
+    case LY_TYPE_UNION:
+        /* check all the union types */
+        un = (struct lysc_type_union *)type;
+        LY_ARRAY_FOR(un->types, u) {
+            LY_CHECK_RET(lys_compile_leafref_circ_check(un->types[u], lref));
+        }
+    default:
+        /* no more leafref references */
+        break;
+    }
+
+    return LY_SUCCESS;
+}
+
 /**
  * @brief Check leafref for its target existence on a complete compiled schema tree.
  *
@@ -825,7 +868,6 @@ lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, st
 {
     const struct lysc_node *target = NULL;
     struct ly_path *p;
-    struct lysc_type *type;
     uint16_t flg;
 
     assert(node->nodetype & (LYS_LEAF | LYS_LEAFLIST));
@@ -881,17 +923,12 @@ lys_compile_unres_leafref(struct lysc_ctx *ctx, const struct lysc_node *node, st
     }
 
     /* check for circular chain of leafrefs */
-    for (type = ((struct lysc_node_leaf *)target)->type;
-            type && (type->basetype == LY_TYPE_LEAFREF);
-            type = ((struct lysc_type_leafref *)type)->realtype) {
-        if (type == (struct lysc_type *)lref) {
-            /* circular chain detected */
-            LOG_LOCSET(node);
-            LOGVAL(ctx->ctx, NULL, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
-                    lref->path->expr);
-            LOG_LOCBACK(1);
-            return LY_EVALID;
-        }
+    if (lys_compile_leafref_circ_check(((struct lysc_node_leaf *)target)->type, (struct lysc_type *)lref)) {
+        LOG_LOCSET(node);
+        LOGVAL(ctx->ctx, NULL, LYVE_REFERENCE, "Invalid leafref path \"%s\" - circular chain of leafrefs detected.",
+                lref->path->expr);
+        LOG_LOCBACK(1);
+        return LY_EVALID;
     }
 
     /* store the type */

tests/utests/schema/test_tree_schema_compile.c

@@ -2081,6 +2081,23 @@ test_type_leafref(void **state)
             "leaf ref3 {type leafref {path /ref4;}}\n"
             "leaf ref4 {type leafref {path /ref1;}}}", LYS_IN_YANG, &mod));
     CHECK_LOG_CTX("Invalid leafref path \"/ref1\" - circular chain of leafrefs detected.", "/aaa:ref4", 0);
+
+    assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, "module leafref-unions {\n"
+            "    namespace \"http://example.com/leafref-unions\"; prefix \"lu\";\n"
+            "    \n"
+            "    container config {\n"
+            "        leaf circular-ref-1 {\n"
+            "            type union {\n"
+            "                type leafref {\n"
+            "                    path \"../circular-ref-1\";\n"
+            "                }\n"
+            "            }\n"
+            "            default \"circular-value\";\n"
+            "        }\n"
+            "    }\n"
+            "}", LYS_IN_YANG, NULL));
+    CHECK_LOG_CTX("Invalid leafref path \"../circular-ref-1\" - circular chain of leafrefs detected.",
+            "/leafref-unions:config/circular-ref-1", 0);
 }
 
 static void