schema: add lysc_node_lref_xpath_targets() helper

There is currently no way to retrieve leafref target xpaths
from a schema node.  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.

The `struct lyxp_expr` that contains the xpath is not public, so
external users have no way to access this data.

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);