schema: add lysc_node_lref_xpath_targets() helper

The lysc_node_lref_targets() helper returns a node in the schema,
but if the xpath itself had added restrictions such as only
matching certain list keys, then there was no way to retrieve
that information.

This adds the appropriate helper, sharing as much code as possible
with lysc_node_lref_targets() and also adds a test case to check
for this.

Signed-off-by: Brad House <[email protected]>

Author: bradh352

src/tree_schema.h

@@ -1927,6 +1927,18 @@ LIBYANG_API_DECL const struct lysc_node *lysc_node_lref_target(const struct lysc
  */
 LIBYANG_API_DECL LY_ERR lysc_node_lref_targets(const struct lysc_node *node, struct ly_set **set);
 
+/**
+ * @brief Get the target xpath(s) of a leafref node or union node with leafrefs.
+ *
+ * @param[in] node Term node to use.
+ * @param[out] set Set with all the leafref target xpaths, may be empty if the node is a different type or the targets
+ * are not found.  The set is filled with NULL-terminated "const char *" strings which can be retrieved via the
+ * objs member.
+ * @return LY_SUCCESS on success.
+ * @return LY_ERR value on error.
+ */
+LIBYANG_API_DECL LY_ERR lysc_node_lref_xpath_targets(const struct lysc_node *node, struct ly_set **set);
+
 /**
  * @brief Get all the leafref (or union with leafrefs) nodes that target a specific node.
  *

src/tree_schema_common.c

@@ -40,6 +40,7 @@
 #include "tree_edit.h"
 #include "tree_schema.h"
 #include "tree_schema_internal.h"
+#include "xpath.h"
 
 LY_ERR
 lysp_check_prefix(struct lysp_ctx *ctx, struct lysp_import *imports, const char *module_prefix, const char **value)
@@ -1847,8 +1848,8 @@ lysc_node_lref_target(const struct lysc_node *node)
     return lysc_type_lref_target(node, ((struct lysc_node_leaf *)node)->type);
 }
 
-LIBYANG_API_DEF LY_ERR
-lysc_node_lref_targets(const struct lysc_node *node, struct ly_set **set)
+static LY_ERR
+lysc_node_lref_targets_fetch(const struct lysc_node *node, struct ly_set **set, ly_bool return_xpaths)
 {
     LY_ERR rc = LY_SUCCESS;
     struct lysc_type *type;
@@ -1871,16 +1872,32 @@ lysc_node_lref_targets(const struct lysc_node *node, struct ly_set **set)
                 continue;
             }
 
-            target = lysc_type_lref_target(node, type_un->types[u]);
-            if (target) {
-                LY_CHECK_GOTO(rc = ly_set_add(*set, target, 1, NULL), cleanup);
+            if (return_xpaths) {
+                struct lysc_type_leafref *lref_type = (struct lysc_type_leafref *)type_un->types[u];
+
+                if (lref_type->path && lref_type->path->expr) {
+                    LY_CHECK_GOTO(rc = ly_set_add(*set, lref_type->path->expr, 1, NULL), cleanup);
+                }
+            } else {
+                target = lysc_type_lref_target(node, type_un->types[u]);
+                if (target) {
+                    LY_CHECK_GOTO(rc = ly_set_add(*set, target, 1, NULL), cleanup);
+                }
             }
         }
     } else if (type->basetype == LY_TYPE_LEAFREF) {
         /* leafref */
-        target = lysc_type_lref_target(node, type);
-        if (target) {
-            LY_CHECK_GOTO(rc = ly_set_add(*set, target, 1, NULL), cleanup);
+        if (return_xpaths) {
+            struct lysc_type_leafref *lref_type = (struct lysc_type_leafref *)type;
+
+            if (lref_type->path && lref_type->path->expr) {
+                LY_CHECK_GOTO(rc = ly_set_add(*set, lref_type->path->expr, 1, NULL), cleanup);
+            }
+        } else {
+            target = lysc_type_lref_target(node, type);
+            if (target) {
+                LY_CHECK_GOTO(rc = ly_set_add(*set, target, 1, NULL), cleanup);
+            }
         }
     }
 
@@ -1892,6 +1909,18 @@ lysc_node_lref_targets(const struct lysc_node *node, struct ly_set **set)
     return rc;
 }
 
+LIBYANG_API_DEF LY_ERR
+lysc_node_lref_targets(const struct lysc_node *node, struct ly_set **set)
+{
+    return lysc_node_lref_targets_fetch(node, set, 0);
+}
+
+LIBYANG_API_DEF LY_ERR
+lysc_node_lref_xpath_targets(const struct lysc_node *node, struct ly_set **set)
+{
+    return lysc_node_lref_targets_fetch(node, set, 1);
+}
+
 struct lysc_node_lref_backlings_arg {
     const struct lysc_node *node;
     ly_bool match_ancestors;

tests/utests/schema/test_schema.c

@@ -2106,6 +2106,105 @@ test_lysc_backlinks(void **state)
     }
 }
 
+static void
+test_lysc_lref_xpath_targets(void **state)
+{
+    const char *expect1[] = {
+        "/sbg:sonic-bgp-global/sbg:BGP_GLOBALS/sbg:BGP_GLOBALS_LIST[sbg:vrf_name=current()/../vrf_name]/sbg:local_asn",
+        "/sbg:sonic-bgp-global/sbg:BGP_GLOBALS/sbg:any_asn",
+        NULL
+    };
+
+    struct {
+        const char *xpath;
+        const char **expected_paths;
+    } tests[] = {
+        {"/sonic-device-metadata:sonic-device-metadata/DEVICE_METADATA/DEVICE_METADATA_LIST/bgp_asn", expect1},
+    };
+    const char *str;
+    uint32_t i;
+
+    str = "module sonic-bgp-global {"
+            "    namespace \"http://github.com/Azure/sonic-bgp-global\";\n"
+            "    prefix sbgpg;\n"
+            "    container sonic-bgp-global {\n"
+            "        container BGP_GLOBALS {\n"
+            "            list BGP_GLOBALS_LIST {\n"
+            "                key \"vrf_name\";\n"
+            "                leaf vrf_name {\n"
+            "                    type string;\n"
+            "                }\n"
+            "                leaf local_asn {\n"
+            "                    type uint32;\n"
+            "                }\n"
+            "            }\n"
+            "            leaf any_asn {\n"
+            "                type uint32;\n"
+            "            }\n"
+            "        }\n"
+            "    }\n"
+            "}\n";
+
+
+    assert_int_equal(lys_parse_mem(UTEST_LYCTX, str, LYS_IN_YANG, NULL), LY_SUCCESS);
+    CHECK_LOG_CTX(NULL, NULL, 0);
+
+    str = "module sonic-device-metadata {\n"
+            "    namespace \"http://github.com/Azure/sonic-device-metadata\";\n"
+            "    prefix sdm;\n"
+            "    import sonic-bgp-global {\n"
+            "        prefix sbg;\n"
+            "    }\n"
+            "    container sonic-device-metadata {\n"
+            "        container DEVICE_METADATA {\n"
+            "            list DEVICE_METADATA_LIST {\n"
+            "                key \"name\";\n"
+            "                max-elements 1;\n"
+            "                leaf name {\n"
+            "                    type string;\n"
+            "                }\n"
+            "                leaf vrf_name {\n"
+            "                    type string;\n"
+            "                    default default;\n"
+            "                }\n"
+            "                leaf bgp_asn {\n"
+            "                    type union {\n"
+            "                        type leafref {\n"
+            "                            path \"/sbg:sonic-bgp-global/sbg:BGP_GLOBALS/sbg:BGP_GLOBALS_LIST[sbg:vrf_name=current()/../vrf_name]/sbg:local_asn\";\n"
+            "                        }\n"
+            "                        type leafref {\n"
+            "                            path \"/sbg:sonic-bgp-global/sbg:BGP_GLOBALS/sbg:any_asn\";\n"
+            "                        }\n"
+            "                        type string {\n"
+            "                            pattern \"none\";\n"
+            "                        }\n"
+            "                    }\n"
+            "                }\n"
+            "            }\n"
+            "        }\n"
+            "    }\n"
+            "}\n";
+
+    assert_int_equal(lys_parse_mem(UTEST_LYCTX, str, LYS_IN_YANG, NULL), LY_SUCCESS);
+    CHECK_LOG_CTX(NULL, NULL, 0);
+
+    for (i = 0; i < sizeof tests / sizeof *tests; i++) {
+        const struct lysc_node *node = NULL;
+        struct ly_set *expected = NULL, *received = NULL;
+
+        node = lys_find_path(UTEST_LYCTX, NULL, tests[i].xpath, 0);
+        assert_non_null(node);
+
+        assert_int_equal(LY_SUCCESS, lysc_node_lref_xpath_targets(node, &received));
+
+        expected = strlist_to_pathset(tests[i].expected_paths);
+        assert_int_equal(1, compare_str_nodeset(expected, received));
+
+        ly_set_free(expected, NULL);
+        ly_set_free(received, NULL);
+    }
+}
+
 int
 main(void)
 {
@@ -2129,6 +2228,7 @@ main(void)
         UTEST(test_ext_recursive),
         UTEST(test_lysc_path),
         UTEST(test_lysc_backlinks),
+        UTEST(test_lysc_lref_xpath_targets)
     };
 
     return cmocka_run_group_tests(tests, NULL, NULL);