summaryrefslogtreecommitdiffstats
path: root/lib/northbound.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 04:24:32 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 04:24:32 +0000
commit35cadacd2bb9383686753731e31bd7e145fb2506 (patch)
tree4489adbde75a837989533837185b2b8369a0bf68 /lib/northbound.c
parentAdding debian version 9.1-0.1. (diff)
downloadfrr-35cadacd2bb9383686753731e31bd7e145fb2506.tar.xz
frr-35cadacd2bb9383686753731e31bd7e145fb2506.zip
Merging upstream version 10.0.
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'lib/northbound.c')
-rw-r--r--lib/northbound.c1067
1 files changed, 425 insertions, 642 deletions
diff --git a/lib/northbound.c b/lib/northbound.c
index 6ff5c24..487f225 100644
--- a/lib/northbound.c
+++ b/lib/northbound.c
@@ -6,6 +6,7 @@
#include <zebra.h>
+#include "darr.h"
#include "libfrr.h"
#include "log.h"
#include "lib_errors.h"
@@ -70,12 +71,6 @@ static int nb_transaction_process(enum nb_event event,
char *errmsg, size_t errmsg_len);
static void nb_transaction_apply_finish(struct nb_transaction *transaction,
char *errmsg, size_t errmsg_len);
-static int nb_oper_data_iter_node(const struct lysc_node *snode,
- const char *xpath, const void *list_entry,
- const struct yang_list_keys *list_keys,
- struct yang_translator *translator,
- bool first, uint32_t flags,
- nb_oper_data_cb cb, void *arg);
static int nb_node_check_config_only(const struct lysc_node *snode, void *arg)
{
@@ -130,8 +125,8 @@ static int nb_node_new_cb(const struct lysc_node *snode, void *arg)
assert(snode->priv == NULL);
((struct lysc_node *)snode)->priv = nb_node;
- if (module && module->ignore_cbs)
- SET_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS);
+ if (module && module->ignore_cfg_cbs)
+ SET_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS);
return YANG_ITER_CONTINUE;
}
@@ -162,18 +157,45 @@ void nb_nodes_delete(void)
struct nb_node *nb_node_find(const char *path)
{
const struct lysc_node *snode;
+ uint32_t llopts = 0;
/*
* Use libyang to find the schema node associated to the path and get
- * the northbound node from there (snode private pointer).
+ * the northbound node from there (snode private pointer). We need to
+ * disable logging temporarily to avoid libyang from logging an error
+ * message when the node is not found.
*/
+ ly_temp_log_options(&llopts);
+
snode = yang_find_snode(ly_native_ctx, path, 0);
+
+ ly_temp_log_options(NULL);
if (!snode)
return NULL;
return snode->priv;
}
+struct nb_node **nb_nodes_find(const char *xpath)
+{
+ struct lysc_node **snodes = NULL;
+ struct nb_node **nb_nodes = NULL;
+ bool simple;
+ LY_ERR err;
+ uint i;
+
+ err = yang_resolve_snode_xpath(ly_native_ctx, xpath, &snodes, &simple);
+ if (err)
+ return NULL;
+
+ darr_ensure_i(nb_nodes, darr_lasti(snodes));
+ darr_foreach_i (snodes, i)
+ nb_nodes[i] = snodes[i]->priv;
+ darr_free(snodes);
+ return nb_nodes;
+}
+
+
void nb_node_set_dependency_cbs(const char *dependency_xpath,
const char *dependant_xpath,
struct nb_dependency_callbacks *cbs)
@@ -194,12 +216,12 @@ bool nb_node_has_dependency(struct nb_node *node)
}
static int nb_node_validate_cb(const struct nb_node *nb_node,
- enum nb_operation operation,
+ enum nb_cb_operation operation,
int callback_implemented, bool optional)
{
bool valid;
- valid = nb_operation_is_valid(operation, nb_node->snode);
+ valid = nb_cb_operation_is_valid(operation, nb_node->snode);
/*
* Add an exception for operational data callbacks. A rw list usually
@@ -211,15 +233,15 @@ static int nb_node_validate_cb(const struct nb_node *nb_node,
* depends on context (e.g. some daemons might augment "frr-interface"
* while others don't).
*/
- if (!valid && callback_implemented && operation != NB_OP_GET_NEXT
- && operation != NB_OP_GET_KEYS && operation != NB_OP_LOOKUP_ENTRY)
+ if (!valid && callback_implemented && operation != NB_CB_GET_NEXT
+ && operation != NB_CB_GET_KEYS && operation != NB_CB_LOOKUP_ENTRY)
flog_warn(EC_LIB_NB_CB_UNNEEDED,
"unneeded '%s' callback for '%s'",
- nb_operation_name(operation), nb_node->xpath);
+ nb_cb_operation_name(operation), nb_node->xpath);
if (!optional && valid && !callback_implemented) {
flog_err(EC_LIB_NB_CB_MISSING, "missing '%s' callback for '%s'",
- nb_operation_name(operation), nb_node->xpath);
+ nb_cb_operation_name(operation), nb_node->xpath);
return 1;
}
@@ -235,31 +257,33 @@ static unsigned int nb_node_validate_cbs(const struct nb_node *nb_node)
{
unsigned int error = 0;
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return error;
- error += nb_node_validate_cb(nb_node, NB_OP_CREATE,
+ error += nb_node_validate_cb(nb_node, NB_CB_CREATE,
!!nb_node->cbs.create, false);
- error += nb_node_validate_cb(nb_node, NB_OP_MODIFY,
+ error += nb_node_validate_cb(nb_node, NB_CB_MODIFY,
!!nb_node->cbs.modify, false);
- error += nb_node_validate_cb(nb_node, NB_OP_DESTROY,
+ error += nb_node_validate_cb(nb_node, NB_CB_DESTROY,
!!nb_node->cbs.destroy, false);
- error += nb_node_validate_cb(nb_node, NB_OP_MOVE, !!nb_node->cbs.move,
+ error += nb_node_validate_cb(nb_node, NB_CB_MOVE, !!nb_node->cbs.move,
false);
- error += nb_node_validate_cb(nb_node, NB_OP_PRE_VALIDATE,
+ error += nb_node_validate_cb(nb_node, NB_CB_PRE_VALIDATE,
!!nb_node->cbs.pre_validate, true);
- error += nb_node_validate_cb(nb_node, NB_OP_APPLY_FINISH,
+ error += nb_node_validate_cb(nb_node, NB_CB_APPLY_FINISH,
!!nb_node->cbs.apply_finish, true);
- error += nb_node_validate_cb(nb_node, NB_OP_GET_ELEM,
+ error += nb_node_validate_cb(nb_node, NB_CB_GET_ELEM,
!!nb_node->cbs.get_elem, false);
- error += nb_node_validate_cb(nb_node, NB_OP_GET_NEXT,
+ error += nb_node_validate_cb(nb_node, NB_CB_GET_NEXT,
!!nb_node->cbs.get_next, false);
- error += nb_node_validate_cb(nb_node, NB_OP_GET_KEYS,
+ error += nb_node_validate_cb(nb_node, NB_CB_GET_KEYS,
!!nb_node->cbs.get_keys, false);
- error += nb_node_validate_cb(nb_node, NB_OP_LOOKUP_ENTRY,
+ error += nb_node_validate_cb(nb_node, NB_CB_LOOKUP_ENTRY,
!!nb_node->cbs.lookup_entry, false);
- error += nb_node_validate_cb(nb_node, NB_OP_RPC, !!nb_node->cbs.rpc,
+ error += nb_node_validate_cb(nb_node, NB_CB_RPC, !!nb_node->cbs.rpc,
false);
+ error += nb_node_validate_cb(nb_node, NB_CB_NOTIFY,
+ !!nb_node->cbs.notify, true);
return error;
}
@@ -305,8 +329,6 @@ struct nb_config *nb_config_new(struct lyd_node *dnode)
config->dnode = yang_dnode_new(ly_native_ctx, true);
config->version = 0;
- RB_INIT(nb_config_cbs, &config->cfg_chgs);
-
return config;
}
@@ -314,7 +336,7 @@ void nb_config_free(struct nb_config *config)
{
if (config->dnode)
yang_dnode_free(config->dnode);
- nb_config_diff_del_changes(&config->cfg_chgs);
+
XFREE(MTYPE_NB_CONFIG, config);
}
@@ -326,8 +348,6 @@ struct nb_config *nb_config_dup(const struct nb_config *config)
dup->dnode = yang_dnode_dup(config->dnode);
dup->version = config->version;
- RB_INIT(nb_config_cbs, &dup->cfg_chgs);
-
return dup;
}
@@ -369,13 +389,29 @@ void nb_config_replace(struct nb_config *config_dst,
static inline int nb_config_cb_compare(const struct nb_config_cb *a,
const struct nb_config_cb *b)
{
- /* Sort by priority first. */
- if (a->nb_node->priority < b->nb_node->priority)
+ bool a_destroy = a->operation == NB_CB_DESTROY;
+ bool b_destroy = b->operation == NB_CB_DESTROY;
+
+ /*
+ * Sort by operation first. All "destroys" must come first, to correctly
+ * process the change of a "case" inside a "choice". The old "case" must
+ * be deleted before the new "case" is created.
+ */
+ if (a_destroy && !b_destroy)
return -1;
- if (a->nb_node->priority > b->nb_node->priority)
+ if (!a_destroy && b_destroy)
return 1;
/*
+ * Then sort by priority. If the operation is "destroy", reverse the
+ * order, so that the dependants are deleted before the dependencies.
+ */
+ if (a->nb_node->priority < b->nb_node->priority)
+ return !a_destroy ? -1 : 1;
+ if (a->nb_node->priority > b->nb_node->priority)
+ return !a_destroy ? 1 : -1;
+
+ /*
* Preserve the order of the configuration changes as told by libyang.
*/
if (a->seq < b->seq)
@@ -397,10 +433,9 @@ static inline int nb_config_cb_compare(const struct nb_config_cb *a,
}
RB_GENERATE(nb_config_cbs, nb_config_cb, entry, nb_config_cb_compare);
-static void nb_config_diff_add_change(struct nb_config_cbs *changes,
- enum nb_operation operation,
- uint32_t *seq,
- const struct lyd_node *dnode)
+void nb_config_diff_add_change(struct nb_config_cbs *changes,
+ enum nb_cb_operation operation, uint32_t *seq,
+ const struct lyd_node *dnode)
{
struct nb_config_change *change;
@@ -438,7 +473,7 @@ void nb_config_diff_del_changes(struct nb_config_cbs *changes)
void nb_config_diff_created(const struct lyd_node *dnode, uint32_t *seq,
struct nb_config_cbs *changes)
{
- enum nb_operation operation;
+ enum nb_cb_operation operation;
struct lyd_node *child;
/* Ignore unimplemented nodes. */
@@ -451,10 +486,10 @@ void nb_config_diff_created(const struct lyd_node *dnode, uint32_t *seq,
if (lyd_is_default(dnode))
break;
- if (nb_operation_is_valid(NB_OP_CREATE, dnode->schema))
- operation = NB_OP_CREATE;
- else if (nb_operation_is_valid(NB_OP_MODIFY, dnode->schema))
- operation = NB_OP_MODIFY;
+ if (nb_cb_operation_is_valid(NB_CB_CREATE, dnode->schema))
+ operation = NB_CB_CREATE;
+ else if (nb_cb_operation_is_valid(NB_CB_MODIFY, dnode->schema))
+ operation = NB_CB_MODIFY;
else
return;
@@ -462,8 +497,8 @@ void nb_config_diff_created(const struct lyd_node *dnode, uint32_t *seq,
break;
case LYS_CONTAINER:
case LYS_LIST:
- if (nb_operation_is_valid(NB_OP_CREATE, dnode->schema))
- nb_config_diff_add_change(changes, NB_OP_CREATE, seq,
+ if (nb_cb_operation_is_valid(NB_CB_CREATE, dnode->schema))
+ nb_config_diff_add_change(changes, NB_CB_CREATE, seq,
dnode);
/* Process child nodes recursively. */
@@ -483,8 +518,8 @@ static void nb_config_diff_deleted(const struct lyd_node *dnode, uint32_t *seq,
if (!dnode->schema->priv)
return;
- if (nb_operation_is_valid(NB_OP_DESTROY, dnode->schema))
- nb_config_diff_add_change(changes, NB_OP_DESTROY, seq, dnode);
+ if (nb_cb_operation_is_valid(NB_CB_DESTROY, dnode->schema))
+ nb_config_diff_add_change(changes, NB_CB_DESTROY, seq, dnode);
else if (CHECK_FLAG(dnode->schema->nodetype, LYS_CONTAINER)) {
struct lyd_node *child;
@@ -633,7 +668,7 @@ void nb_config_diff(const struct nb_config *config1,
/* either moving an entry or changing a value */
target = yang_dnode_get(config2->dnode, path);
assert(target);
- nb_config_diff_add_change(changes, NB_OP_MODIFY,
+ nb_config_diff_add_change(changes, NB_CB_MODIFY,
&seq, target);
break;
case 'n': /* none */
@@ -648,44 +683,54 @@ void nb_config_diff(const struct nb_config *config1,
lyd_free_all(diff);
}
-int nb_candidate_edit(struct nb_config *candidate,
- const struct nb_node *nb_node,
+static int dnode_create(struct nb_config *candidate, const char *xpath,
+ const char *value, uint32_t options,
+ struct lyd_node **new_dnode)
+{
+ struct lyd_node *dnode;
+ LY_ERR err;
+
+ err = lyd_new_path(candidate->dnode, ly_native_ctx, xpath, value,
+ options, &dnode);
+ if (err) {
+ flog_warn(EC_LIB_LIBYANG, "%s: lyd_new_path(%s) failed: %d",
+ __func__, xpath, err);
+ return NB_ERR;
+ } else if (dnode) {
+ err = lyd_new_implicit_tree(dnode, LYD_IMPLICIT_NO_STATE, NULL);
+ if (err) {
+ flog_warn(EC_LIB_LIBYANG,
+ "%s: lyd_new_implicit_all failed: %d",
+ __func__, err);
+ }
+ }
+ if (new_dnode)
+ *new_dnode = dnode;
+ return NB_OK;
+}
+
+int nb_candidate_edit(struct nb_config *candidate, const struct nb_node *nb_node,
enum nb_operation operation, const char *xpath,
const struct yang_data *previous,
const struct yang_data *data)
{
- struct lyd_node *dnode, *dep_dnode;
- char xpath_edit[XPATH_MAXLEN];
+ struct lyd_node *dnode, *dep_dnode, *old_dnode;
char dep_xpath[XPATH_MAXLEN];
+ struct lyd_node *parent = NULL;
+ uint32_t options = 0;
LY_ERR err;
- /* Use special notation for leaf-lists (RFC 6020, section 9.13.5). */
- if (nb_node->snode->nodetype == LYS_LEAFLIST)
- snprintf(xpath_edit, sizeof(xpath_edit), "%s[.='%s']", xpath,
- data->value);
- else
- strlcpy(xpath_edit, xpath, sizeof(xpath_edit));
-
switch (operation) {
case NB_OP_CREATE:
case NB_OP_MODIFY:
- err = lyd_new_path(candidate->dnode, ly_native_ctx, xpath_edit,
- (void *)data->value, LYD_NEW_PATH_UPDATE,
+ options = LYD_NEW_PATH_UPDATE;
+ fallthrough;
+ case NB_OP_CREATE_EXCL:
+ err = dnode_create(candidate, xpath, data->value, options,
&dnode);
if (err) {
- flog_warn(EC_LIB_LIBYANG,
- "%s: lyd_new_path(%s) failed: %d", __func__,
- xpath_edit, err);
- return NB_ERR;
+ return err;
} else if (dnode) {
- /* Create default nodes */
- LY_ERR err = lyd_new_implicit_tree(
- dnode, LYD_IMPLICIT_NO_STATE, NULL);
- if (err) {
- flog_warn(EC_LIB_LIBYANG,
- "%s: lyd_new_implicit_all failed: %d",
- __func__, err);
- }
/*
* create dependency
*
@@ -697,33 +742,24 @@ int nb_candidate_edit(struct nb_config *candidate,
nb_node->dep_cbs.get_dependency_xpath(
dnode, dep_xpath);
- err = lyd_new_path(candidate->dnode,
- ly_native_ctx, dep_xpath,
- NULL, LYD_NEW_PATH_UPDATE,
- &dep_dnode);
- /* Create default nodes */
- if (!err && dep_dnode)
- err = lyd_new_implicit_tree(
- dep_dnode,
- LYD_IMPLICIT_NO_STATE, NULL);
+ err = dnode_create(candidate, dep_xpath, NULL,
+ LYD_NEW_PATH_UPDATE, NULL);
if (err) {
- flog_warn(
- EC_LIB_LIBYANG,
- "%s: dependency: lyd_new_path(%s) failed: %d",
- __func__, dep_xpath, err);
- return NB_ERR;
+ lyd_free_tree(dnode);
+ return err;
}
}
}
break;
case NB_OP_DESTROY:
- dnode = yang_dnode_get(candidate->dnode, xpath_edit);
- if (!dnode)
- /*
- * Return a special error code so the caller can choose
- * whether to ignore it or not.
- */
- return NB_ERR_NOT_FOUND;
+ case NB_OP_DELETE:
+ dnode = yang_dnode_get(candidate->dnode, xpath);
+ if (!dnode) {
+ if (operation == NB_OP_DELETE)
+ return NB_ERR;
+ else
+ return NB_OK;
+ }
/* destroy dependant */
if (nb_node->dep_cbs.get_dependant_xpath) {
nb_node->dep_cbs.get_dependant_xpath(dnode, dep_xpath);
@@ -734,103 +770,88 @@ int nb_candidate_edit(struct nb_config *candidate,
}
lyd_free_tree(dnode);
break;
+ case NB_OP_REPLACE:
+ old_dnode = yang_dnode_get(candidate->dnode, xpath);
+ if (old_dnode) {
+ parent = lyd_parent(old_dnode);
+ lyd_unlink_tree(old_dnode);
+ }
+ err = dnode_create(candidate, xpath, data->value, options,
+ &dnode);
+ if (!err && dnode && !old_dnode) {
+ /* create dependency if the node didn't exist */
+ nb_node = dnode->schema->priv;
+ if (nb_node->dep_cbs.get_dependency_xpath) {
+ nb_node->dep_cbs.get_dependency_xpath(
+ dnode, dep_xpath);
+
+ err = dnode_create(candidate, dep_xpath, NULL,
+ LYD_NEW_PATH_UPDATE, NULL);
+ if (err)
+ lyd_free_tree(dnode);
+ }
+ }
+ if (old_dnode) {
+ /* restore original node on error, free it otherwise */
+ if (err) {
+ if (parent)
+ lyd_insert_child(parent, old_dnode);
+ else
+ lyd_insert_sibling(candidate->dnode,
+ old_dnode, NULL);
+ return err;
+ }
+
+ lyd_free_tree(old_dnode);
+ }
+ break;
case NB_OP_MOVE:
/* TODO: update configuration. */
break;
- case NB_OP_PRE_VALIDATE:
- case NB_OP_APPLY_FINISH:
- case NB_OP_GET_ELEM:
- case NB_OP_GET_NEXT:
- case NB_OP_GET_KEYS:
- case NB_OP_LOOKUP_ENTRY:
- case NB_OP_RPC:
- flog_warn(EC_LIB_DEVELOPMENT,
- "%s: unknown operation (%u) [xpath %s]", __func__,
- operation, xpath_edit);
- return NB_ERR;
}
return NB_OK;
}
-static void nb_update_candidate_changes(struct nb_config *candidate,
- struct nb_cfg_change *change,
- uint32_t *seq)
+const char *nb_operation_name(enum nb_operation operation)
{
- enum nb_operation oper = change->operation;
- char *xpath = change->xpath;
- struct lyd_node *root = NULL;
- struct lyd_node *dnode;
- struct nb_config_cbs *cfg_chgs = &candidate->cfg_chgs;
- int op;
-
- switch (oper) {
+ switch (operation) {
+ case NB_OP_CREATE_EXCL:
+ return "create exclusive";
case NB_OP_CREATE:
+ return "create";
case NB_OP_MODIFY:
- root = yang_dnode_get(candidate->dnode, xpath);
- break;
+ return "modify";
case NB_OP_DESTROY:
- root = yang_dnode_get(running_config->dnode, xpath);
- /* code */
- break;
+ return "destroy";
+ case NB_OP_DELETE:
+ return "delete";
+ case NB_OP_REPLACE:
+ return "replace";
case NB_OP_MOVE:
- case NB_OP_PRE_VALIDATE:
- case NB_OP_APPLY_FINISH:
- case NB_OP_GET_ELEM:
- case NB_OP_GET_NEXT:
- case NB_OP_GET_KEYS:
- case NB_OP_LOOKUP_ENTRY:
- case NB_OP_RPC:
- break;
- default:
- assert(!"non-enum value, invalid");
+ return "move";
}
- if (!root)
- return;
-
- LYD_TREE_DFS_BEGIN (root, dnode) {
- op = nb_lyd_diff_get_op(dnode);
- switch (op) {
- case 'c': /* create */
- nb_config_diff_created(dnode, seq, cfg_chgs);
- LYD_TREE_DFS_continue = 1;
- break;
- case 'd': /* delete */
- nb_config_diff_deleted(dnode, seq, cfg_chgs);
- LYD_TREE_DFS_continue = 1;
- break;
- case 'r': /* replace */
- nb_config_diff_add_change(cfg_chgs, NB_OP_MODIFY, seq,
- dnode);
- break;
- case 'n': /* none */
- default:
- break;
- }
- LYD_TREE_DFS_END(root, dnode);
- }
+ assert(!"Reached end of function we should never hit");
}
-static bool nb_is_operation_allowed(struct nb_node *nb_node,
- struct nb_cfg_change *change)
+bool nb_is_operation_allowed(struct nb_node *nb_node, enum nb_operation oper)
{
- enum nb_operation oper = change->operation;
-
if (lysc_is_key(nb_node->snode)) {
- if (oper == NB_OP_MODIFY || oper == NB_OP_DESTROY)
+ if (oper == NB_OP_MODIFY || oper == NB_OP_DESTROY
+ || oper == NB_OP_DELETE || oper == NB_OP_REPLACE)
return false;
}
return true;
}
-void nb_candidate_edit_config_changes(
- struct nb_config *candidate_config, struct nb_cfg_change cfg_changes[],
- size_t num_cfg_changes, const char *xpath_base, const char *curr_xpath,
- int xpath_index, char *err_buf, int err_bufsize, bool *error)
+void nb_candidate_edit_config_changes(struct nb_config *candidate_config,
+ struct nb_cfg_change cfg_changes[],
+ size_t num_cfg_changes,
+ const char *xpath_base, bool in_backend,
+ char *err_buf, int err_bufsize,
+ bool *error)
{
- uint32_t seq = 0;
-
if (error)
*error = false;
@@ -841,38 +862,38 @@ void nb_candidate_edit_config_changes(
for (size_t i = 0; i < num_cfg_changes; i++) {
struct nb_cfg_change *change = &cfg_changes[i];
struct nb_node *nb_node;
+ char *change_xpath = change->xpath;
char xpath[XPATH_MAXLEN];
const char *value;
struct yang_data *data;
int ret;
- /* Handle relative XPaths. */
memset(xpath, 0, sizeof(xpath));
- if (xpath_index > 0 &&
- (xpath_base[0] == '.' || change->xpath[0] == '.'))
- strlcpy(xpath, curr_xpath, sizeof(xpath));
- if (xpath_base[0]) {
- if (xpath_base[0] == '.')
- strlcat(xpath, xpath_base + 1, sizeof(xpath));
- else
- strlcat(xpath, xpath_base, sizeof(xpath));
+ /* If change xpath is relative, prepend base xpath. */
+ if (change_xpath[0] == '.') {
+ strlcpy(xpath, xpath_base, sizeof(xpath));
+ change_xpath++; /* skip '.' */
}
- if (change->xpath[0] == '.')
- strlcat(xpath, change->xpath + 1, sizeof(xpath));
- else
- strlcpy(xpath, change->xpath, sizeof(xpath));
+ strlcat(xpath, change_xpath, sizeof(xpath));
/* Find the northbound node associated to the data path. */
nb_node = nb_node_find(xpath);
if (!nb_node) {
- flog_warn(EC_LIB_YANG_UNKNOWN_DATA_PATH,
- "%s: unknown data path: %s", __func__, xpath);
- if (error)
- *error = true;
+ if (in_backend)
+ DEBUGD(&nb_dbg_cbs_config,
+ "%s: ignoring non-handled path: %s",
+ __func__, xpath);
+ else {
+ flog_warn(EC_LIB_YANG_UNKNOWN_DATA_PATH,
+ "%s: unknown data path: %s", __func__,
+ xpath);
+ if (error)
+ *error = true;
+ }
continue;
}
/* Find if the node to be edited is not a key node */
- if (!nb_is_operation_allowed(nb_node, change)) {
+ if (!nb_is_operation_allowed(nb_node, change->operation)) {
zlog_err(" Xpath %s points to key node", xpath);
if (error)
*error = true;
@@ -892,7 +913,7 @@ void nb_candidate_edit_config_changes(
ret = nb_candidate_edit(candidate_config, nb_node,
change->operation, xpath, NULL, data);
yang_data_free(data);
- if (ret != NB_OK && ret != NB_ERR_NOT_FOUND) {
+ if (ret != NB_OK) {
flog_warn(
EC_LIB_NB_CANDIDATE_EDIT_ERROR,
"%s: failed to edit candidate configuration: operation [%s] xpath [%s]",
@@ -902,17 +923,11 @@ void nb_candidate_edit_config_changes(
*error = true;
continue;
}
- nb_update_candidate_changes(candidate_config, change, &seq);
}
if (error && *error) {
char buf[BUFSIZ];
- /*
- * Failure to edit the candidate configuration should never
- * happen in practice, unless there's a bug in the code. When
- * that happens, log the error but otherwise ignore it.
- */
snprintf(err_buf, err_bufsize,
"%% Failed to edit configuration.\n\n%s",
yang_print_errors(ly_native_ctx, buf, sizeof(buf)));
@@ -949,9 +964,19 @@ int nb_candidate_update(struct nb_config *candidate)
int nb_candidate_validate_yang(struct nb_config *candidate, bool no_state,
char *errmsg, size_t errmsg_len)
{
- if (lyd_validate_all(&candidate->dnode, ly_native_ctx,
- no_state ? LYD_VALIDATE_NO_STATE
- : LYD_VALIDATE_PRESENT,
+ uint32_t options = 0;
+
+#ifdef LYD_VALIDATE_MULTI_ERROR
+ /* libyang 2.1.36+ */
+ options |= LYD_VALIDATE_MULTI_ERROR;
+#endif
+
+ if (no_state)
+ SET_FLAG(options, LYD_VALIDATE_NO_STATE);
+ else
+ SET_FLAG(options, LYD_VALIDATE_PRESENT);
+
+ if (lyd_validate_all(&candidate->dnode, ly_native_ctx, options,
NULL) != 0) {
yang_print_errors(ly_native_ctx, errmsg, errmsg_len);
return NB_ERR_VALIDATION;
@@ -1193,7 +1218,7 @@ int nb_running_lock_check(enum nb_client client, const void *user)
}
static void nb_log_config_callback(const enum nb_event event,
- enum nb_operation operation,
+ enum nb_cb_operation operation,
const struct lyd_node *dnode)
{
const char *value;
@@ -1210,7 +1235,7 @@ static void nb_log_config_callback(const enum nb_event event,
zlog_debug(
"northbound callback: event [%s] op [%s] xpath [%s] value [%s]",
- nb_event_name(event), nb_operation_name(operation), xpath,
+ nb_event_name(event), nb_cb_operation_name(operation), xpath,
value);
}
@@ -1224,9 +1249,9 @@ static int nb_callback_create(struct nb_context *context,
bool unexpected_error = false;
int ret;
- assert(!CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS));
+ assert(!CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS));
- nb_log_config_callback(event, NB_OP_CREATE, dnode);
+ nb_log_config_callback(event, NB_CB_CREATE, dnode);
args.context = context;
args.event = event;
@@ -1275,9 +1300,9 @@ static int nb_callback_modify(struct nb_context *context,
bool unexpected_error = false;
int ret;
- assert(!CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS));
+ assert(!CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS));
- nb_log_config_callback(event, NB_OP_MODIFY, dnode);
+ nb_log_config_callback(event, NB_CB_MODIFY, dnode);
args.context = context;
args.event = event;
@@ -1326,9 +1351,9 @@ static int nb_callback_destroy(struct nb_context *context,
bool unexpected_error = false;
int ret;
- assert(!CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS));
+ assert(!CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS));
- nb_log_config_callback(event, NB_OP_DESTROY, dnode);
+ nb_log_config_callback(event, NB_CB_DESTROY, dnode);
args.context = context;
args.event = event;
@@ -1371,9 +1396,9 @@ static int nb_callback_move(struct nb_context *context,
bool unexpected_error = false;
int ret;
- assert(!CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS));
+ assert(!CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS));
- nb_log_config_callback(event, NB_OP_MOVE, dnode);
+ nb_log_config_callback(event, NB_CB_MOVE, dnode);
args.context = context;
args.event = event;
@@ -1416,10 +1441,10 @@ static int nb_callback_pre_validate(struct nb_context *context,
bool unexpected_error = false;
int ret;
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return 0;
- nb_log_config_callback(NB_EV_VALIDATE, NB_OP_PRE_VALIDATE, dnode);
+ nb_log_config_callback(NB_EV_VALIDATE, NB_CB_PRE_VALIDATE, dnode);
args.dnode = dnode;
args.errmsg = errmsg;
@@ -1450,10 +1475,10 @@ static void nb_callback_apply_finish(struct nb_context *context,
{
struct nb_cb_apply_finish_args args = {};
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return;
- nb_log_config_callback(NB_EV_APPLY, NB_OP_APPLY_FINISH, dnode);
+ nb_log_config_callback(NB_EV_APPLY, NB_CB_APPLY_FINISH, dnode);
args.context = context;
args.dnode = dnode;
@@ -1468,7 +1493,7 @@ struct yang_data *nb_callback_get_elem(const struct nb_node *nb_node,
{
struct nb_cb_get_elem_args args = {};
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return NULL;
DEBUGD(&nb_dbg_cbs_state,
@@ -1486,7 +1511,7 @@ const void *nb_callback_get_next(const struct nb_node *nb_node,
{
struct nb_cb_get_next_args args = {};
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return NULL;
DEBUGD(&nb_dbg_cbs_state,
@@ -1503,7 +1528,7 @@ int nb_callback_get_keys(const struct nb_node *nb_node, const void *list_entry,
{
struct nb_cb_get_keys_args args = {};
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return 0;
DEBUGD(&nb_dbg_cbs_state,
@@ -1521,7 +1546,7 @@ const void *nb_callback_lookup_entry(const struct nb_node *nb_node,
{
struct nb_cb_lookup_entry_args args = {};
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return NULL;
DEBUGD(&nb_dbg_cbs_state,
@@ -1533,13 +1558,57 @@ const void *nb_callback_lookup_entry(const struct nb_node *nb_node,
return nb_node->cbs.lookup_entry(&args);
}
+const void *nb_callback_lookup_node_entry(struct lyd_node *node,
+ const void *parent_list_entry)
+{
+ struct yang_list_keys keys;
+ struct nb_cb_lookup_entry_args args = {};
+ const struct nb_node *nb_node = node->schema->priv;
+
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
+ return NULL;
+
+ if (yang_get_node_keys(node, &keys)) {
+ flog_warn(EC_LIB_LIBYANG,
+ "%s: can't get keys for lookup from existing data node %s",
+ __func__, node->schema->name);
+ return NULL;
+ }
+
+ DEBUGD(&nb_dbg_cbs_state,
+ "northbound callback (lookup_node_entry): node [%s] parent_list_entry [%p]",
+ nb_node->xpath, parent_list_entry);
+
+ args.parent_list_entry = parent_list_entry;
+ args.keys = &keys;
+ return nb_node->cbs.lookup_entry(&args);
+}
+
+const void *nb_callback_lookup_next(const struct nb_node *nb_node,
+ const void *parent_list_entry,
+ const struct yang_list_keys *keys)
+{
+ struct nb_cb_lookup_entry_args args = {};
+
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
+ return NULL;
+
+ DEBUGD(&nb_dbg_cbs_state,
+ "northbound callback (lookup_entry): node [%s] parent_list_entry [%p]",
+ nb_node->xpath, parent_list_entry);
+
+ args.parent_list_entry = parent_list_entry;
+ args.keys = keys;
+ return nb_node->cbs.lookup_next(&args);
+}
+
int nb_callback_rpc(const struct nb_node *nb_node, const char *xpath,
const struct list *input, struct list *output, char *errmsg,
size_t errmsg_len)
{
struct nb_cb_rpc_args args = {};
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return 0;
DEBUGD(&nb_dbg_cbs_rpc, "northbound RPC: %s", xpath);
@@ -1552,6 +1621,18 @@ int nb_callback_rpc(const struct nb_node *nb_node, const char *xpath,
return nb_node->cbs.rpc(&args);
}
+void nb_callback_notify(const struct nb_node *nb_node, const char *xpath,
+ struct lyd_node *dnode)
+{
+ struct nb_cb_notify_args args = {};
+
+ DEBUGD(&nb_dbg_cbs_notify, "northbound notify: %s", xpath);
+
+ args.xpath = xpath;
+ args.dnode = dnode;
+ nb_node->cbs.notify(&args);
+}
+
/*
* Call the northbound configuration callback associated to a given
* configuration change.
@@ -1561,14 +1642,14 @@ static int nb_callback_configuration(struct nb_context *context,
struct nb_config_change *change,
char *errmsg, size_t errmsg_len)
{
- enum nb_operation operation = change->cb.operation;
+ enum nb_cb_operation operation = change->cb.operation;
char xpath[XPATH_MAXLEN];
const struct nb_node *nb_node = change->cb.nb_node;
const struct lyd_node *dnode = change->cb.dnode;
union nb_resource *resource;
int ret = NB_ERR;
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CBS))
+ if (CHECK_FLAG(nb_node->flags, F_NB_NODE_IGNORE_CFG_CBS))
return NB_OK;
if (event == NB_EV_VALIDATE)
@@ -1577,29 +1658,30 @@ static int nb_callback_configuration(struct nb_context *context,
resource = &change->resource;
switch (operation) {
- case NB_OP_CREATE:
+ case NB_CB_CREATE:
ret = nb_callback_create(context, nb_node, event, dnode,
resource, errmsg, errmsg_len);
break;
- case NB_OP_MODIFY:
+ case NB_CB_MODIFY:
ret = nb_callback_modify(context, nb_node, event, dnode,
resource, errmsg, errmsg_len);
break;
- case NB_OP_DESTROY:
+ case NB_CB_DESTROY:
ret = nb_callback_destroy(context, nb_node, event, dnode,
errmsg, errmsg_len);
break;
- case NB_OP_MOVE:
+ case NB_CB_MOVE:
ret = nb_callback_move(context, nb_node, event, dnode, errmsg,
errmsg_len);
break;
- case NB_OP_PRE_VALIDATE:
- case NB_OP_APPLY_FINISH:
- case NB_OP_GET_ELEM:
- case NB_OP_GET_NEXT:
- case NB_OP_GET_KEYS:
- case NB_OP_LOOKUP_ENTRY:
- case NB_OP_RPC:
+ case NB_CB_PRE_VALIDATE:
+ case NB_CB_APPLY_FINISH:
+ case NB_CB_GET_ELEM:
+ case NB_CB_GET_NEXT:
+ case NB_CB_GET_KEYS:
+ case NB_CB_LOOKUP_ENTRY:
+ case NB_CB_RPC:
+ case NB_CB_NOTIFY:
yang_dnode_get_path(dnode, xpath, sizeof(xpath));
flog_err(EC_LIB_DEVELOPMENT,
"%s: unknown operation (%u) [xpath %s]", __func__,
@@ -1615,28 +1697,28 @@ static int nb_callback_configuration(struct nb_context *context,
flog_warn(EC_LIB_NB_CB_CONFIG_VALIDATE,
"error processing configuration change: error [%s] event [%s] operation [%s] xpath [%s]%s%s",
nb_err_name(ret), nb_event_name(event),
- nb_operation_name(operation), xpath,
+ nb_cb_operation_name(operation), xpath,
errmsg[0] ? " message: " : "", errmsg);
break;
case NB_EV_PREPARE:
flog_warn(EC_LIB_NB_CB_CONFIG_PREPARE,
"error processing configuration change: error [%s] event [%s] operation [%s] xpath [%s]%s%s",
nb_err_name(ret), nb_event_name(event),
- nb_operation_name(operation), xpath,
+ nb_cb_operation_name(operation), xpath,
errmsg[0] ? " message: " : "", errmsg);
break;
case NB_EV_ABORT:
flog_warn(EC_LIB_NB_CB_CONFIG_ABORT,
"error processing configuration change: error [%s] event [%s] operation [%s] xpath [%s]%s%s",
nb_err_name(ret), nb_event_name(event),
- nb_operation_name(operation), xpath,
+ nb_cb_operation_name(operation), xpath,
errmsg[0] ? " message: " : "", errmsg);
break;
case NB_EV_APPLY:
flog_err(EC_LIB_NB_CB_CONFIG_APPLY,
"error processing configuration change: error [%s] event [%s] operation [%s] xpath [%s]%s%s",
nb_err_name(ret), nb_event_name(event),
- nb_operation_name(operation), xpath,
+ nb_cb_operation_name(operation), xpath,
errmsg[0] ? " message: " : "", errmsg);
break;
default:
@@ -1743,6 +1825,7 @@ nb_apply_finish_cb_new(struct nb_config_cbs *cbs, const struct nb_node *nb_node,
struct nb_config_cb *cb;
cb = XCALLOC(MTYPE_TMP, sizeof(*cb));
+ cb->operation = NB_CB_APPLY_FINISH;
cb->nb_node = nb_node;
cb->dnode = dnode;
RB_INSERT(nb_config_cbs, cbs, cb);
@@ -1757,6 +1840,7 @@ nb_apply_finish_cb_find(struct nb_config_cbs *cbs,
{
struct nb_config_cb s;
+ s.operation = NB_CB_APPLY_FINISH;
s.seq = 0;
s.nb_node = nb_node;
s.dnode = dnode;
@@ -1784,12 +1868,12 @@ static void nb_transaction_apply_finish(struct nb_transaction *transaction,
* (the 'apply_finish' callbacks from the node ancestors should
* be called though).
*/
- if (change->cb.operation == NB_OP_DESTROY) {
+ if (change->cb.operation == NB_CB_DESTROY) {
char xpath[XPATH_MAXLEN];
dnode = lyd_parent(dnode);
if (!dnode)
- break;
+ continue;
/*
* The dnode from 'delete' callbacks point to elements
@@ -1835,394 +1919,15 @@ static void nb_transaction_apply_finish(struct nb_transaction *transaction,
}
}
-static int nb_oper_data_iter_children(const struct lysc_node *snode,
- const char *xpath, const void *list_entry,
- const struct yang_list_keys *list_keys,
- struct yang_translator *translator,
- bool first, uint32_t flags,
- nb_oper_data_cb cb, void *arg)
-{
- const struct lysc_node *child;
-
- LY_LIST_FOR (lysc_node_child(snode), child) {
- int ret;
-
- ret = nb_oper_data_iter_node(child, xpath, list_entry,
- list_keys, translator, false,
- flags, cb, arg);
- if (ret != NB_OK)
- return ret;
- }
-
- return NB_OK;
-}
-
-static int nb_oper_data_iter_leaf(const struct nb_node *nb_node,
- const char *xpath, const void *list_entry,
- const struct yang_list_keys *list_keys,
- struct yang_translator *translator,
- uint32_t flags, nb_oper_data_cb cb, void *arg)
-{
- struct yang_data *data;
-
- if (CHECK_FLAG(nb_node->snode->flags, LYS_CONFIG_W))
- return NB_OK;
-
- /* Ignore list keys. */
- if (lysc_is_key(nb_node->snode))
- return NB_OK;
-
- data = nb_callback_get_elem(nb_node, xpath, list_entry);
- if (data == NULL)
- /* Leaf of type "empty" is not present. */
- return NB_OK;
-
- return (*cb)(nb_node->snode, translator, data, arg);
-}
-
-static int nb_oper_data_iter_container(const struct nb_node *nb_node,
- const char *xpath,
- const void *list_entry,
- const struct yang_list_keys *list_keys,
- struct yang_translator *translator,
- uint32_t flags, nb_oper_data_cb cb,
- void *arg)
-{
- const struct lysc_node *snode = nb_node->snode;
-
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY))
- return NB_OK;
-
- /* Read-only presence containers. */
- if (nb_node->cbs.get_elem) {
- struct yang_data *data;
- int ret;
-
- data = nb_callback_get_elem(nb_node, xpath, list_entry);
- if (data == NULL)
- /* Presence container is not present. */
- return NB_OK;
-
- ret = (*cb)(snode, translator, data, arg);
- if (ret != NB_OK)
- return ret;
- }
-
- /* Read-write presence containers. */
- if (CHECK_FLAG(snode->flags, LYS_CONFIG_W)) {
- struct lysc_node_container *scontainer;
-
- scontainer = (struct lysc_node_container *)snode;
- if (CHECK_FLAG(scontainer->flags, LYS_PRESENCE)
- && !yang_dnode_get(running_config->dnode, xpath))
- return NB_OK;
- }
-
- /* Iterate over the child nodes. */
- return nb_oper_data_iter_children(snode, xpath, list_entry, list_keys,
- translator, false, flags, cb, arg);
-}
-
-static int
-nb_oper_data_iter_leaflist(const struct nb_node *nb_node, const char *xpath,
- const void *parent_list_entry,
- const struct yang_list_keys *parent_list_keys,
- struct yang_translator *translator, uint32_t flags,
- nb_oper_data_cb cb, void *arg)
-{
- const void *list_entry = NULL;
-
- if (CHECK_FLAG(nb_node->snode->flags, LYS_CONFIG_W))
- return NB_OK;
-
- do {
- struct yang_data *data;
- int ret;
-
- list_entry = nb_callback_get_next(nb_node, parent_list_entry,
- list_entry);
- if (!list_entry)
- /* End of the list. */
- break;
-
- data = nb_callback_get_elem(nb_node, xpath, list_entry);
- if (data == NULL)
- continue;
-
- ret = (*cb)(nb_node->snode, translator, data, arg);
- if (ret != NB_OK)
- return ret;
- } while (list_entry);
-
- return NB_OK;
-}
-
-static int nb_oper_data_iter_list(const struct nb_node *nb_node,
- const char *xpath_list,
- const void *parent_list_entry,
- const struct yang_list_keys *parent_list_keys,
- struct yang_translator *translator,
- uint32_t flags, nb_oper_data_cb cb, void *arg)
-{
- const struct lysc_node *snode = nb_node->snode;
- const void *list_entry = NULL;
- uint32_t position = 1;
-
- if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY))
- return NB_OK;
-
- /* Iterate over all list entries. */
- do {
- const struct lysc_node_leaf *skey;
- struct yang_list_keys list_keys = {};
- char xpath[XPATH_MAXLEN * 2];
- int ret;
-
- /* Obtain list entry. */
- list_entry = nb_callback_get_next(nb_node, parent_list_entry,
- list_entry);
- if (!list_entry)
- /* End of the list. */
- break;
-
- if (!CHECK_FLAG(nb_node->flags, F_NB_NODE_KEYLESS_LIST)) {
- /* Obtain the list entry keys. */
- if (nb_callback_get_keys(nb_node, list_entry,
- &list_keys)
- != NB_OK) {
- flog_warn(EC_LIB_NB_CB_STATE,
- "%s: failed to get list keys",
- __func__);
- return NB_ERR;
- }
-
- /* Build XPath of the list entry. */
- strlcpy(xpath, xpath_list, sizeof(xpath));
- unsigned int i = 0;
- LY_FOR_KEYS (snode, skey) {
- assert(i < list_keys.num);
- snprintf(xpath + strlen(xpath),
- sizeof(xpath) - strlen(xpath),
- "[%s='%s']", skey->name,
- list_keys.key[i]);
- i++;
- }
- assert(i == list_keys.num);
- } else {
- /*
- * Keyless list - build XPath using a positional index.
- */
- snprintf(xpath, sizeof(xpath), "%s[%u]", xpath_list,
- position);
- position++;
- }
-
- /* Iterate over the child nodes. */
- ret = nb_oper_data_iter_children(
- nb_node->snode, xpath, list_entry, &list_keys,
- translator, false, flags, cb, arg);
- if (ret != NB_OK)
- return ret;
- } while (list_entry);
-
- return NB_OK;
-}
-
-static int nb_oper_data_iter_node(const struct lysc_node *snode,
- const char *xpath_parent,
- const void *list_entry,
- const struct yang_list_keys *list_keys,
- struct yang_translator *translator,
- bool first, uint32_t flags,
- nb_oper_data_cb cb, void *arg)
-{
- struct nb_node *nb_node;
- char xpath[XPATH_MAXLEN];
- int ret = NB_OK;
-
- if (!first && CHECK_FLAG(flags, NB_OPER_DATA_ITER_NORECURSE)
- && CHECK_FLAG(snode->nodetype, LYS_CONTAINER | LYS_LIST))
- return NB_OK;
-
- /* Update XPath. */
- strlcpy(xpath, xpath_parent, sizeof(xpath));
- if (!first && snode->nodetype != LYS_USES) {
- struct lysc_node *parent;
-
- /* Get the real parent. */
- parent = snode->parent;
-
- /*
- * When necessary, include the namespace of the augmenting
- * module.
- */
- if (parent && parent->module != snode->module)
- snprintf(xpath + strlen(xpath),
- sizeof(xpath) - strlen(xpath), "/%s:%s",
- snode->module->name, snode->name);
- else
- snprintf(xpath + strlen(xpath),
- sizeof(xpath) - strlen(xpath), "/%s",
- snode->name);
- }
-
- nb_node = snode->priv;
- switch (snode->nodetype) {
- case LYS_CONTAINER:
- ret = nb_oper_data_iter_container(nb_node, xpath, list_entry,
- list_keys, translator, flags,
- cb, arg);
- break;
- case LYS_LEAF:
- ret = nb_oper_data_iter_leaf(nb_node, xpath, list_entry,
- list_keys, translator, flags, cb,
- arg);
- break;
- case LYS_LEAFLIST:
- ret = nb_oper_data_iter_leaflist(nb_node, xpath, list_entry,
- list_keys, translator, flags,
- cb, arg);
- break;
- case LYS_LIST:
- ret = nb_oper_data_iter_list(nb_node, xpath, list_entry,
- list_keys, translator, flags, cb,
- arg);
- break;
- case LYS_USES:
- ret = nb_oper_data_iter_children(snode, xpath, list_entry,
- list_keys, translator, false,
- flags, cb, arg);
- break;
- default:
- break;
- }
-
- return ret;
-}
-
-int nb_oper_data_iterate(const char *xpath, struct yang_translator *translator,
- uint32_t flags, nb_oper_data_cb cb, void *arg)
-{
- struct nb_node *nb_node;
- const void *list_entry = NULL;
- struct yang_list_keys list_keys;
- struct list *list_dnodes;
- struct lyd_node *dnode, *dn;
- struct listnode *ln;
- int ret;
-
- nb_node = nb_node_find(xpath);
- if (!nb_node) {
- flog_warn(EC_LIB_YANG_UNKNOWN_DATA_PATH,
- "%s: unknown data path: %s", __func__, xpath);
- return NB_ERR;
- }
-
- /* For now this function works only with containers and lists. */
- if (!CHECK_FLAG(nb_node->snode->nodetype, LYS_CONTAINER | LYS_LIST)) {
- flog_warn(
- EC_LIB_NB_OPERATIONAL_DATA,
- "%s: can't iterate over YANG leaf or leaf-list [xpath %s]",
- __func__, xpath);
- return NB_ERR;
- }
-
- /*
- * Create a data tree from the XPath so that we can parse the keys of
- * all YANG lists (if any).
- */
-
- LY_ERR err = lyd_new_path2(NULL, ly_native_ctx, xpath, NULL, 0, 0,
- LYD_NEW_PATH_UPDATE, NULL, &dnode);
- if (err || !dnode) {
- const char *errmsg =
- err ? ly_errmsg(ly_native_ctx) : "node not found";
- flog_warn(EC_LIB_LIBYANG, "%s: lyd_new_path() failed %s",
- __func__, errmsg);
- return NB_ERR;
- }
-
- /*
- * Create a linked list to sort the data nodes starting from the root.
- */
- list_dnodes = list_new();
- for (dn = dnode; dn; dn = lyd_parent(dn)) {
- if (dn->schema->nodetype != LYS_LIST || !lyd_child(dn))
- continue;
- listnode_add_head(list_dnodes, dn);
- }
- /*
- * Use the northbound callbacks to find list entry pointer corresponding
- * to the given XPath.
- */
- for (ALL_LIST_ELEMENTS_RO(list_dnodes, ln, dn)) {
- struct lyd_node *child;
- struct nb_node *nn;
- unsigned int n = 0;
-
- /* Obtain the list entry keys. */
- memset(&list_keys, 0, sizeof(list_keys));
- LY_LIST_FOR (lyd_child(dn), child) {
- if (!lysc_is_key(child->schema))
- break;
- strlcpy(list_keys.key[n],
- yang_dnode_get_string(child, NULL),
- sizeof(list_keys.key[n]));
- n++;
- }
- list_keys.num = n;
- if (list_keys.num != yang_snode_num_keys(dn->schema)) {
- list_delete(&list_dnodes);
- yang_dnode_free(dnode);
- return NB_ERR_NOT_FOUND;
- }
-
- /* Find the list entry pointer. */
- nn = dn->schema->priv;
- if (!nn->cbs.lookup_entry) {
- flog_warn(
- EC_LIB_NB_OPERATIONAL_DATA,
- "%s: data path doesn't support iteration over operational data: %s",
- __func__, xpath);
- list_delete(&list_dnodes);
- yang_dnode_free(dnode);
- return NB_ERR;
- }
-
- list_entry =
- nb_callback_lookup_entry(nn, list_entry, &list_keys);
- if (list_entry == NULL) {
- list_delete(&list_dnodes);
- yang_dnode_free(dnode);
- return NB_ERR_NOT_FOUND;
- }
- }
-
- /* If a list entry was given, iterate over that list entry only. */
- if (dnode->schema->nodetype == LYS_LIST && lyd_child(dnode))
- ret = nb_oper_data_iter_children(
- nb_node->snode, xpath, list_entry, &list_keys,
- translator, true, flags, cb, arg);
- else
- ret = nb_oper_data_iter_node(nb_node->snode, xpath, list_entry,
- &list_keys, translator, true,
- flags, cb, arg);
-
- list_delete(&list_dnodes);
- yang_dnode_free(dnode);
-
- return ret;
-}
-
-bool nb_operation_is_valid(enum nb_operation operation,
- const struct lysc_node *snode)
+bool nb_cb_operation_is_valid(enum nb_cb_operation operation,
+ const struct lysc_node *snode)
{
struct nb_node *nb_node = snode->priv;
struct lysc_node_container *scontainer;
struct lysc_node_leaf *sleaf;
switch (operation) {
- case NB_OP_CREATE:
+ case NB_CB_CREATE:
if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
return false;
@@ -2233,6 +1938,8 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
break;
case LYS_CONTAINER:
+ if (snode->parent && snode->parent->nodetype == LYS_CASE)
+ return true;
scontainer = (struct lysc_node_container *)snode;
if (!CHECK_FLAG(scontainer->flags, LYS_PRESENCE))
return false;
@@ -2244,7 +1951,7 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
}
return true;
- case NB_OP_MODIFY:
+ case NB_CB_MODIFY:
if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
return false;
@@ -2262,7 +1969,7 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
}
return true;
- case NB_OP_DESTROY:
+ case NB_CB_DESTROY:
if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
return false;
@@ -2287,6 +1994,8 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
break;
case LYS_CONTAINER:
+ if (snode->parent && snode->parent->nodetype == LYS_CASE)
+ return true;
scontainer = (struct lysc_node_container *)snode;
if (!CHECK_FLAG(scontainer->flags, LYS_PRESENCE))
return false;
@@ -2298,7 +2007,7 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
}
return true;
- case NB_OP_MOVE:
+ case NB_CB_MOVE:
if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
return false;
@@ -2312,12 +2021,12 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
}
return true;
- case NB_OP_PRE_VALIDATE:
- case NB_OP_APPLY_FINISH:
+ case NB_CB_PRE_VALIDATE:
+ case NB_CB_APPLY_FINISH:
if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W))
return false;
return true;
- case NB_OP_GET_ELEM:
+ case NB_CB_GET_ELEM:
if (!CHECK_FLAG(snode->flags, LYS_CONFIG_R))
return false;
@@ -2334,7 +2043,7 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
}
return true;
- case NB_OP_GET_NEXT:
+ case NB_CB_GET_NEXT:
switch (snode->nodetype) {
case LYS_LIST:
if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY))
@@ -2348,8 +2057,8 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
}
return true;
- case NB_OP_GET_KEYS:
- case NB_OP_LOOKUP_ENTRY:
+ case NB_CB_GET_KEYS:
+ case NB_CB_LOOKUP_ENTRY:
switch (snode->nodetype) {
case LYS_LIST:
if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY))
@@ -2361,7 +2070,7 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
}
return true;
- case NB_OP_RPC:
+ case NB_CB_RPC:
if (CHECK_FLAG(snode->flags, LYS_CONFIG_W | LYS_CONFIG_R))
return false;
@@ -2373,6 +2082,10 @@ bool nb_operation_is_valid(enum nb_operation operation,
return false;
}
return true;
+ case NB_CB_NOTIFY:
+ if (snode->nodetype != LYS_NOTIF)
+ return false;
+ return true;
default:
return false;
}
@@ -2383,17 +2096,81 @@ DEFINE_HOOK(nb_notification_send, (const char *xpath, struct list *arguments),
int nb_notification_send(const char *xpath, struct list *arguments)
{
+ struct lyd_node *root = NULL;
+ struct lyd_node *dnode;
+ struct yang_data *data;
+ struct listnode *ln;
+ LY_ERR err;
int ret;
DEBUGD(&nb_dbg_notif, "northbound notification: %s", xpath);
+ /*
+ * Call old hook functions
+ */
ret = hook_call(nb_notification_send, xpath, arguments);
+
+ if (!hook_have_hooks(nb_notification_tree_send))
+ goto done;
+ /*
+ * Convert yang data arguments list to a libyang data tree for new hook
+ * functions.
+ */
+ for (ALL_LIST_ELEMENTS_RO(arguments, ln, data)) {
+ err = lyd_new_path(root, ly_native_ctx, data->xpath,
+ data->value, LYD_NEW_PATH_UPDATE, &dnode);
+ if (err != LY_SUCCESS)
+ goto lyerr;
+ if (!root) {
+ root = dnode;
+ while (root->parent)
+ root = lyd_parent(root);
+ }
+ }
+
+ if (!root) {
+ err = lyd_new_path(NULL, ly_native_ctx, xpath, "", 0, &root);
+ if (err) {
+lyerr:
+ flog_err(EC_LIB_LIBYANG,
+ "%s: error creating notification data: %s",
+ __func__, ly_strerrcode(err));
+ ret += 1;
+ goto done;
+ }
+ }
+
+ /*
+ * Call new hook functions
+ */
+ ret += nb_notification_tree_send(xpath, root);
+
+done:
+ if (root)
+ lyd_free_all(root);
if (arguments)
list_delete(&arguments);
return ret;
}
+DEFINE_HOOK(nb_notification_tree_send,
+ (const char *xpath, const struct lyd_node *tree), (xpath, tree));
+
+int nb_notification_tree_send(const char *xpath, const struct lyd_node *tree)
+{
+ int ret;
+
+ assert(tree);
+
+ DEBUGD(&nb_dbg_notif, "northbound tree notification: %s",
+ tree->schema->name);
+
+ ret = hook_call(nb_notification_tree_send, xpath, tree);
+
+ return ret;
+}
+
/* Running configuration user pointers management. */
struct nb_config_entry {
char xpath[XPATH_MAXLEN];
@@ -2563,31 +2340,33 @@ const char *nb_event_name(enum nb_event event)
assert(!"Reached end of function we should never hit");
}
-const char *nb_operation_name(enum nb_operation operation)
+const char *nb_cb_operation_name(enum nb_cb_operation operation)
{
switch (operation) {
- case NB_OP_CREATE:
+ case NB_CB_CREATE:
return "create";
- case NB_OP_MODIFY:
+ case NB_CB_MODIFY:
return "modify";
- case NB_OP_DESTROY:
+ case NB_CB_DESTROY:
return "destroy";
- case NB_OP_MOVE:
+ case NB_CB_MOVE:
return "move";
- case NB_OP_PRE_VALIDATE:
+ case NB_CB_PRE_VALIDATE:
return "pre_validate";
- case NB_OP_APPLY_FINISH:
+ case NB_CB_APPLY_FINISH:
return "apply_finish";
- case NB_OP_GET_ELEM:
+ case NB_CB_GET_ELEM:
return "get_elem";
- case NB_OP_GET_NEXT:
+ case NB_CB_GET_NEXT:
return "get_next";
- case NB_OP_GET_KEYS:
+ case NB_CB_GET_KEYS:
return "get_keys";
- case NB_OP_LOOKUP_ENTRY:
+ case NB_CB_LOOKUP_ENTRY:
return "lookup_entry";
- case NB_OP_RPC:
+ case NB_CB_RPC:
return "rpc";
+ case NB_CB_NOTIFY:
+ return "notify";
}
assert(!"Reached end of function we should never hit");
@@ -2612,6 +2391,8 @@ const char *nb_err_name(enum nb_error error)
return "failed to allocate resource";
case NB_ERR_INCONSISTENCY:
return "internal inconsistency";
+ case NB_YIELD:
+ return "should yield";
}
assert(!"Reached end of function we should never hit");
@@ -2643,10 +2424,6 @@ const char *nb_client_name(enum nb_client client)
static void nb_load_callbacks(const struct frr_yang_module_info *module)
{
-
- if (module->ignore_cbs)
- return;
-
for (size_t i = 0; module->nodes[i].xpath; i++) {
struct nb_node *nb_node;
uint32_t priority;
@@ -2712,7 +2489,8 @@ void nb_init(struct event_loop *tm,
for (size_t i = 0; i < nmodules; i++) {
DEBUGD(&nb_dbg_events, "northbound: loading %s.yang",
modules[i]->name);
- *loadedp++ = yang_module_load(modules[i]->name);
+ *loadedp++ = yang_module_load(modules[i]->name,
+ modules[i]->features);
}
if (explicit_compile)
@@ -2737,10 +2515,15 @@ void nb_init(struct event_loop *tm,
/* Initialize the northbound CLI. */
nb_cli_init(tm);
+
+ /* Initialize oper-state */
+ nb_oper_init(tm);
}
void nb_terminate(void)
{
+ nb_oper_terminate();
+
/* Terminate the northbound CLI. */
nb_cli_terminate();