diff options
Diffstat (limited to '')
| -rw-r--r-- | lib/northbound.c | 2503 |
1 files changed, 2503 insertions, 0 deletions
diff --git a/lib/northbound.c b/lib/northbound.c new file mode 100644 index 0000000..ccfc384 --- /dev/null +++ b/lib/northbound.c @@ -0,0 +1,2503 @@ +/* + * Copyright (C) 2018 NetDEF, Inc. + * Renato Westphal + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; either version 2 of the License, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; see the file COPYING; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <zebra.h> + +#include "libfrr.h" +#include "log.h" +#include "lib_errors.h" +#include "hash.h" +#include "command.h" +#include "debug.h" +#include "db.h" +#include "frr_pthread.h" +#include "northbound.h" +#include "northbound_cli.h" +#include "northbound_db.h" +#include "frrstr.h" + +DEFINE_MTYPE_STATIC(LIB, NB_NODE, "Northbound Node"); +DEFINE_MTYPE_STATIC(LIB, NB_CONFIG, "Northbound Configuration"); +DEFINE_MTYPE_STATIC(LIB, NB_CONFIG_ENTRY, "Northbound Configuration Entry"); + +/* Running configuration - shouldn't be modified directly. */ +struct nb_config *running_config; + +/* Hash table of user pointers associated with configuration entries. */ +static struct hash *running_config_entries; + +/* Management lock for the running configuration. */ +static struct { + /* Mutex protecting this structure. */ + pthread_mutex_t mtx; + + /* Actual lock. */ + bool locked; + + /* Northbound client who owns this lock. */ + enum nb_client owner_client; + + /* Northbound user who owns this lock. */ + const void *owner_user; +} running_config_mgmt_lock; + +/* Knob to record config transaction */ +static bool nb_db_enabled; +/* + * Global lock used to prevent multiple configuration transactions from + * happening concurrently. + */ +static bool transaction_in_progress; + +static int nb_callback_pre_validate(struct nb_context *context, + const struct nb_node *nb_node, + const struct lyd_node *dnode, char *errmsg, + size_t errmsg_len); +static int nb_callback_configuration(struct nb_context *context, + const enum nb_event event, + struct nb_config_change *change, + char *errmsg, size_t errmsg_len); +static struct nb_transaction * +nb_transaction_new(struct nb_context *context, struct nb_config *config, + struct nb_config_cbs *changes, const char *comment, + char *errmsg, size_t errmsg_len); +static void nb_transaction_free(struct nb_transaction *transaction); +static int nb_transaction_process(enum nb_event event, + struct nb_transaction *transaction, + 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) +{ + bool *config_only = arg; + + if (CHECK_FLAG(snode->flags, LYS_CONFIG_R)) { + *config_only = false; + return YANG_ITER_STOP; + } + + return YANG_ITER_CONTINUE; +} + +static int nb_node_new_cb(const struct lysc_node *snode, void *arg) +{ + struct nb_node *nb_node; + struct lysc_node *sparent, *sparent_list; + + nb_node = XCALLOC(MTYPE_NB_NODE, sizeof(*nb_node)); + yang_snode_get_path(snode, YANG_PATH_DATA, nb_node->xpath, + sizeof(nb_node->xpath)); + nb_node->priority = NB_DFLT_PRIORITY; + sparent = yang_snode_real_parent(snode); + if (sparent) + nb_node->parent = sparent->priv; + sparent_list = yang_snode_parent_list(snode); + if (sparent_list) + nb_node->parent_list = sparent_list->priv; + + /* Set flags. */ + if (CHECK_FLAG(snode->nodetype, LYS_CONTAINER | LYS_LIST)) { + bool config_only = true; + + (void)yang_snodes_iterate_subtree(snode, NULL, + nb_node_check_config_only, 0, + &config_only); + if (config_only) + SET_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY); + } + if (CHECK_FLAG(snode->nodetype, LYS_LIST)) { + if (yang_snode_num_keys(snode) == 0) + SET_FLAG(nb_node->flags, F_NB_NODE_KEYLESS_LIST); + } + + /* + * Link the northbound node and the libyang schema node with one + * another. + */ + nb_node->snode = snode; + assert(snode->priv == NULL); + ((struct lysc_node *)snode)->priv = nb_node; + + return YANG_ITER_CONTINUE; +} + +static int nb_node_del_cb(const struct lysc_node *snode, void *arg) +{ + struct nb_node *nb_node; + + nb_node = snode->priv; + if (nb_node) { + ((struct lysc_node *)snode)->priv = NULL; + XFREE(MTYPE_NB_NODE, nb_node); + } + + return YANG_ITER_CONTINUE; +} + +void nb_nodes_create(void) +{ + yang_snodes_iterate(NULL, nb_node_new_cb, 0, NULL); +} + +void nb_nodes_delete(void) +{ + yang_snodes_iterate(NULL, nb_node_del_cb, 0, NULL); +} + +struct nb_node *nb_node_find(const char *path) +{ + const struct lysc_node *snode; + + /* + * Use libyang to find the schema node associated to the path and get + * the northbound node from there (snode private pointer). + */ + snode = lys_find_path(ly_native_ctx, NULL, path, 0); + if (!snode) + return NULL; + + return snode->priv; +} + +void nb_node_set_dependency_cbs(const char *dependency_xpath, + const char *dependant_xpath, + struct nb_dependency_callbacks *cbs) +{ + struct nb_node *dependency = nb_node_find(dependency_xpath); + struct nb_node *dependant = nb_node_find(dependant_xpath); + + if (!dependency || !dependant) + return; + + dependency->dep_cbs.get_dependant_xpath = cbs->get_dependant_xpath; + dependant->dep_cbs.get_dependency_xpath = cbs->get_dependency_xpath; +} + +bool nb_node_has_dependency(struct nb_node *node) +{ + return node->dep_cbs.get_dependency_xpath != NULL; +} + +static int nb_node_validate_cb(const struct nb_node *nb_node, + enum nb_operation operation, + int callback_implemented, bool optional) +{ + bool valid; + + valid = nb_operation_is_valid(operation, nb_node->snode); + + /* + * Add an exception for operational data callbacks. A rw list usually + * doesn't need any associated operational data callbacks. But if this + * rw list is augmented by another module which adds state nodes under + * it, then this list will need to have the 'get_next()', 'get_keys()' + * and 'lookup_entry()' callbacks. As such, never log a warning when + * these callbacks are implemented when they are not needed, since this + * 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) + flog_warn(EC_LIB_NB_CB_UNNEEDED, + "unneeded '%s' callback for '%s'", + nb_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); + return 1; + } + + return 0; +} + +/* + * Check if the required callbacks were implemented for the given northbound + * node. + */ +static unsigned int nb_node_validate_cbs(const struct nb_node *nb_node) + +{ + unsigned int error = 0; + + error += nb_node_validate_cb(nb_node, NB_OP_CREATE, + !!nb_node->cbs.create, false); + error += nb_node_validate_cb(nb_node, NB_OP_MODIFY, + !!nb_node->cbs.modify, false); + error += nb_node_validate_cb(nb_node, NB_OP_DESTROY, + !!nb_node->cbs.destroy, false); + error += nb_node_validate_cb(nb_node, NB_OP_MOVE, !!nb_node->cbs.move, + false); + error += nb_node_validate_cb(nb_node, NB_OP_PRE_VALIDATE, + !!nb_node->cbs.pre_validate, true); + error += nb_node_validate_cb(nb_node, NB_OP_APPLY_FINISH, + !!nb_node->cbs.apply_finish, true); + error += nb_node_validate_cb(nb_node, NB_OP_GET_ELEM, + !!nb_node->cbs.get_elem, false); + error += nb_node_validate_cb(nb_node, NB_OP_GET_NEXT, + !!nb_node->cbs.get_next, false); + error += nb_node_validate_cb(nb_node, NB_OP_GET_KEYS, + !!nb_node->cbs.get_keys, false); + error += nb_node_validate_cb(nb_node, NB_OP_LOOKUP_ENTRY, + !!nb_node->cbs.lookup_entry, false); + error += nb_node_validate_cb(nb_node, NB_OP_RPC, !!nb_node->cbs.rpc, + false); + + return error; +} + +static unsigned int nb_node_validate_priority(const struct nb_node *nb_node) +{ + /* Top-level nodes can have any priority. */ + if (!nb_node->parent) + return 0; + + if (nb_node->priority < nb_node->parent->priority) { + flog_err(EC_LIB_NB_CB_INVALID_PRIO, + "node has higher priority than its parent [xpath %s]", + nb_node->xpath); + return 1; + } + + return 0; +} + +static int nb_node_validate(const struct lysc_node *snode, void *arg) +{ + struct nb_node *nb_node = snode->priv; + unsigned int *errors = arg; + + /* Validate callbacks and priority. */ + if (nb_node) { + *errors += nb_node_validate_cbs(nb_node); + *errors += nb_node_validate_priority(nb_node); + } + + return YANG_ITER_CONTINUE; +} + +struct nb_config *nb_config_new(struct lyd_node *dnode) +{ + struct nb_config *config; + + config = XCALLOC(MTYPE_NB_CONFIG, sizeof(*config)); + if (dnode) + config->dnode = dnode; + else + config->dnode = yang_dnode_new(ly_native_ctx, true); + config->version = 0; + + return config; +} + +void nb_config_free(struct nb_config *config) +{ + if (config->dnode) + yang_dnode_free(config->dnode); + XFREE(MTYPE_NB_CONFIG, config); +} + +struct nb_config *nb_config_dup(const struct nb_config *config) +{ + struct nb_config *dup; + + dup = XCALLOC(MTYPE_NB_CONFIG, sizeof(*dup)); + dup->dnode = yang_dnode_dup(config->dnode); + dup->version = config->version; + + return dup; +} + +int nb_config_merge(struct nb_config *config_dst, struct nb_config *config_src, + bool preserve_source) +{ + int ret; + + ret = lyd_merge_siblings(&config_dst->dnode, config_src->dnode, 0); + if (ret != 0) + flog_warn(EC_LIB_LIBYANG, "%s: lyd_merge() failed", __func__); + + if (!preserve_source) + nb_config_free(config_src); + + return (ret == 0) ? NB_OK : NB_ERR; +} + +void nb_config_replace(struct nb_config *config_dst, + struct nb_config *config_src, bool preserve_source) +{ + /* Update version. */ + if (config_src->version != 0) + config_dst->version = config_src->version; + + /* Update dnode. */ + if (config_dst->dnode) + yang_dnode_free(config_dst->dnode); + if (preserve_source) { + config_dst->dnode = yang_dnode_dup(config_src->dnode); + } else { + config_dst->dnode = config_src->dnode; + config_src->dnode = NULL; + nb_config_free(config_src); + } +} + +/* Generate the nb_config_cbs tree. */ +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) + return -1; + if (a->nb_node->priority > b->nb_node->priority) + return 1; + + /* + * Preserve the order of the configuration changes as told by libyang. + */ + if (a->seq < b->seq) + return -1; + if (a->seq > b->seq) + return 1; + + /* + * All 'apply_finish' callbacks have their sequence number set to zero. + * In this case, compare them using their dnode pointers (the order + * doesn't matter for callbacks that have the same priority). + */ + if (a->dnode < b->dnode) + return -1; + if (a->dnode > b->dnode) + return 1; + + return 0; +} +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) +{ + struct nb_config_change *change; + + /* Ignore unimplemented nodes. */ + if (!dnode->schema->priv) + return; + + change = XCALLOC(MTYPE_TMP, sizeof(*change)); + change->cb.operation = operation; + change->cb.seq = *seq; + *seq = *seq + 1; + change->cb.nb_node = dnode->schema->priv; + change->cb.dnode = dnode; + + RB_INSERT(nb_config_cbs, changes, &change->cb); +} + +static void nb_config_diff_del_changes(struct nb_config_cbs *changes) +{ + while (!RB_EMPTY(nb_config_cbs, changes)) { + struct nb_config_change *change; + + change = (struct nb_config_change *)RB_ROOT(nb_config_cbs, + changes); + RB_REMOVE(nb_config_cbs, changes, &change->cb); + XFREE(MTYPE_TMP, change); + } +} + +/* + * Helper function used when calculating the delta between two different + * configurations. Given a new subtree, calculate all new YANG data nodes, + * excluding default leafs and leaf-lists. This is a recursive function. + */ +static void nb_config_diff_created(const struct lyd_node *dnode, uint32_t *seq, + struct nb_config_cbs *changes) +{ + enum nb_operation operation; + struct lyd_node *child; + + /* Ignore unimplemented nodes. */ + if (!dnode->schema->priv) + return; + + switch (dnode->schema->nodetype) { + case LYS_LEAF: + case LYS_LEAFLIST: + 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; + else + return; + + nb_config_diff_add_change(changes, operation, seq, dnode); + 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, + dnode); + + /* Process child nodes recursively. */ + LY_LIST_FOR (lyd_child(dnode), child) { + nb_config_diff_created(child, seq, changes); + } + break; + default: + break; + } +} + +static void nb_config_diff_deleted(const struct lyd_node *dnode, uint32_t *seq, + struct nb_config_cbs *changes) +{ + /* Ignore unimplemented nodes. */ + 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); + else if (CHECK_FLAG(dnode->schema->nodetype, LYS_CONTAINER)) { + struct lyd_node *child; + + /* + * Non-presence containers need special handling since they + * don't have "destroy" callbacks. In this case, what we need to + * do is to call the "destroy" callbacks of their child nodes + * when applicable (i.e. optional nodes). + */ + LY_LIST_FOR (lyd_child(dnode), child) { + nb_config_diff_deleted(child, seq, changes); + } + } +} + +static int nb_lyd_diff_get_op(const struct lyd_node *dnode) +{ + const struct lyd_meta *meta; + LY_LIST_FOR (dnode->meta, meta) { + if (strcmp(meta->name, "operation") + || strcmp(meta->annotation->module->name, "yang")) + continue; + return lyd_get_meta_value(meta)[0]; + } + return 'n'; +} + +#if 0 /* Used below in nb_config_diff inside normally disabled code */ +static inline void nb_config_diff_dnode_log_path(const char *context, + const char *path, + const struct lyd_node *dnode) +{ + if (dnode->schema->nodetype & LYD_NODE_TERM) + zlog_debug("nb_config_diff: %s: %s: %s", context, path, + lyd_get_value(dnode)); + else + zlog_debug("nb_config_diff: %s: %s", context, path); +} + +static inline void nb_config_diff_dnode_log(const char *context, + const struct lyd_node *dnode) +{ + if (!dnode) { + zlog_debug("nb_config_diff: %s: NULL", context); + return; + } + + char *path = lyd_path(dnode, LYD_PATH_STD, NULL, 0); + nb_config_diff_dnode_log_path(context, path, dnode); + free(path); +} +#endif + +/* Calculate the delta between two different configurations. */ +static void nb_config_diff(const struct nb_config *config1, + const struct nb_config *config2, + struct nb_config_cbs *changes) +{ + struct lyd_node *diff = NULL; + const struct lyd_node *root, *dnode; + struct lyd_node *target; + int op; + LY_ERR err; + char *path; + +#if 0 /* Useful (noisy) when debugging diff code, and for improving later */ + if (DEBUG_MODE_CHECK(&nb_dbg_cbs_config, DEBUG_MODE_ALL)) { + LY_LIST_FOR(config1->dnode, root) { + LYD_TREE_DFS_BEGIN(root, dnode) { + nb_config_diff_dnode_log("from", dnode); + LYD_TREE_DFS_END(root, dnode); + } + } + LY_LIST_FOR(config2->dnode, root) { + LYD_TREE_DFS_BEGIN(root, dnode) { + nb_config_diff_dnode_log("to", dnode); + LYD_TREE_DFS_END(root, dnode); + } + } + } +#endif + + err = lyd_diff_siblings(config1->dnode, config2->dnode, + LYD_DIFF_DEFAULTS, &diff); + assert(!err); + + if (diff && DEBUG_MODE_CHECK(&nb_dbg_cbs_config, DEBUG_MODE_ALL)) { + char *s; + + if (!lyd_print_mem(&s, diff, LYD_JSON, + LYD_PRINT_WITHSIBLINGS | LYD_PRINT_WD_ALL)) { + zlog_debug("%s: %s", __func__, s); + free(s); + } + } + + uint32_t seq = 0; + + LY_LIST_FOR (diff, root) { + LYD_TREE_DFS_BEGIN (root, dnode) { + op = nb_lyd_diff_get_op(dnode); + + path = lyd_path(dnode, LYD_PATH_STD, NULL, 0); + +#if 0 /* Useful (noisy) when debugging diff code, and for improving later */ + if (DEBUG_MODE_CHECK(&nb_dbg_cbs_config, DEBUG_MODE_ALL)) { + char context[80]; + snprintf(context, sizeof(context), + "iterating diff: oper: %c seq: %u", op, seq); + nb_config_diff_dnode_log_path(context, path, dnode); + } +#endif + switch (op) { + case 'c': /* create */ + /* + * This is rather inefficient, but when we use + * dnode from the diff instead of the + * candidate config node we get failures when + * looking up default values, etc, based on + * the diff tree. + */ + target = yang_dnode_get(config2->dnode, path); + assert(target); + nb_config_diff_created(target, &seq, changes); + + /* Skip rest of sub-tree, move to next sibling + */ + LYD_TREE_DFS_continue = 1; + break; + case 'd': /* delete */ + target = yang_dnode_get(config1->dnode, path); + assert(target); + nb_config_diff_deleted(target, &seq, changes); + + /* Skip rest of sub-tree, move to next sibling + */ + LYD_TREE_DFS_continue = 1; + break; + case 'r': /* replace */ + /* 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, + &seq, target); + break; + case 'n': /* none */ + default: + break; + } + free(path); + LYD_TREE_DFS_END(root, dnode); + } + } + + lyd_free_all(diff); +} + +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]; + char dep_xpath[XPATH_MAXLEN]; + 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, + &dnode); + if (err) { + flog_warn(EC_LIB_LIBYANG, + "%s: lyd_new_path(%s) failed: %d", __func__, + xpath_edit, err); + return NB_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 + * + * dnode returned by the lyd_new_path may be from a + * different schema, so we need to update the nb_node + */ + nb_node = dnode->schema->priv; + if (nb_node->dep_cbs.get_dependency_xpath) { + 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); + if (err) { + flog_warn( + EC_LIB_LIBYANG, + "%s: dependency: lyd_new_path(%s) failed: %d", + __func__, dep_xpath, err); + return NB_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; + /* destroy dependant */ + if (nb_node->dep_cbs.get_dependant_xpath) { + nb_node->dep_cbs.get_dependant_xpath(dnode, dep_xpath); + + dep_dnode = yang_dnode_get(candidate->dnode, dep_xpath); + if (dep_dnode) + lyd_free_tree(dep_dnode); + } + lyd_free_tree(dnode); + break; + case NB_OP_MOVE: + /* TODO: update configuration. */ + break; + default: + flog_warn(EC_LIB_DEVELOPMENT, + "%s: unknown operation (%u) [xpath %s]", __func__, + operation, xpath_edit); + return NB_ERR; + } + + return NB_OK; +} + +bool nb_candidate_needs_update(const struct nb_config *candidate) +{ + if (candidate->version < running_config->version) + return true; + + return false; +} + +int nb_candidate_update(struct nb_config *candidate) +{ + struct nb_config *updated_config; + + updated_config = nb_config_dup(running_config); + if (nb_config_merge(updated_config, candidate, true) != NB_OK) + return NB_ERR; + + nb_config_replace(candidate, updated_config, false); + + return NB_OK; +} + +/* + * Perform YANG syntactic and semantic validation. + * + * WARNING: lyd_validate() can change the configuration as part of the + * validation process. + */ +static int nb_candidate_validate_yang(struct nb_config *candidate, char *errmsg, + size_t errmsg_len) +{ + if (lyd_validate_all(&candidate->dnode, ly_native_ctx, + LYD_VALIDATE_NO_STATE, NULL) + != 0) { + yang_print_errors(ly_native_ctx, errmsg, errmsg_len); + return NB_ERR_VALIDATION; + } + + return NB_OK; +} + +/* Perform code-level validation using the northbound callbacks. */ +static int nb_candidate_validate_code(struct nb_context *context, + struct nb_config *candidate, + struct nb_config_cbs *changes, + char *errmsg, size_t errmsg_len) +{ + struct nb_config_cb *cb; + struct lyd_node *root, *child; + int ret; + + /* First validate the candidate as a whole. */ + LY_LIST_FOR (candidate->dnode, root) { + LYD_TREE_DFS_BEGIN (root, child) { + struct nb_node *nb_node; + + nb_node = child->schema->priv; + if (!nb_node || !nb_node->cbs.pre_validate) + goto next; + + ret = nb_callback_pre_validate(context, nb_node, child, + errmsg, errmsg_len); + if (ret != NB_OK) + return NB_ERR_VALIDATION; + + next: + LYD_TREE_DFS_END(root, child); + } + } + + /* Now validate the configuration changes. */ + RB_FOREACH (cb, nb_config_cbs, changes) { + struct nb_config_change *change = (struct nb_config_change *)cb; + + ret = nb_callback_configuration(context, NB_EV_VALIDATE, change, + errmsg, errmsg_len); + if (ret != NB_OK) + return NB_ERR_VALIDATION; + } + + return NB_OK; +} + +int nb_candidate_validate(struct nb_context *context, + struct nb_config *candidate, char *errmsg, + size_t errmsg_len) +{ + struct nb_config_cbs changes; + int ret; + + if (nb_candidate_validate_yang(candidate, errmsg, errmsg_len) != NB_OK) + return NB_ERR_VALIDATION; + + RB_INIT(nb_config_cbs, &changes); + nb_config_diff(running_config, candidate, &changes); + ret = nb_candidate_validate_code(context, candidate, &changes, errmsg, + errmsg_len); + nb_config_diff_del_changes(&changes); + + return ret; +} + +int nb_candidate_commit_prepare(struct nb_context *context, + struct nb_config *candidate, + const char *comment, + struct nb_transaction **transaction, + char *errmsg, size_t errmsg_len) +{ + struct nb_config_cbs changes; + + if (nb_candidate_validate_yang(candidate, errmsg, errmsg_len) + != NB_OK) { + flog_warn(EC_LIB_NB_CANDIDATE_INVALID, + "%s: failed to validate candidate configuration", + __func__); + return NB_ERR_VALIDATION; + } + + RB_INIT(nb_config_cbs, &changes); + nb_config_diff(running_config, candidate, &changes); + if (RB_EMPTY(nb_config_cbs, &changes)) { + snprintf( + errmsg, errmsg_len, + "No changes to apply were found during preparation phase"); + return NB_ERR_NO_CHANGES; + } + + if (nb_candidate_validate_code(context, candidate, &changes, errmsg, + errmsg_len) + != NB_OK) { + flog_warn(EC_LIB_NB_CANDIDATE_INVALID, + "%s: failed to validate candidate configuration", + __func__); + nb_config_diff_del_changes(&changes); + return NB_ERR_VALIDATION; + } + + *transaction = nb_transaction_new(context, candidate, &changes, comment, + errmsg, errmsg_len); + if (*transaction == NULL) { + flog_warn(EC_LIB_NB_TRANSACTION_CREATION_FAILED, + "%s: failed to create transaction: %s", __func__, + errmsg); + nb_config_diff_del_changes(&changes); + return NB_ERR_LOCKED; + } + + return nb_transaction_process(NB_EV_PREPARE, *transaction, errmsg, + errmsg_len); +} + +void nb_candidate_commit_abort(struct nb_transaction *transaction, char *errmsg, + size_t errmsg_len) +{ + (void)nb_transaction_process(NB_EV_ABORT, transaction, errmsg, + errmsg_len); + nb_transaction_free(transaction); +} + +void nb_candidate_commit_apply(struct nb_transaction *transaction, + bool save_transaction, uint32_t *transaction_id, + char *errmsg, size_t errmsg_len) +{ + (void)nb_transaction_process(NB_EV_APPLY, transaction, errmsg, + errmsg_len); + nb_transaction_apply_finish(transaction, errmsg, errmsg_len); + + /* Replace running by candidate. */ + transaction->config->version++; + nb_config_replace(running_config, transaction->config, true); + + /* Record transaction. */ + if (save_transaction && nb_db_enabled + && nb_db_transaction_save(transaction, transaction_id) != NB_OK) + flog_warn(EC_LIB_NB_TRANSACTION_RECORD_FAILED, + "%s: failed to record transaction", __func__); + + nb_transaction_free(transaction); +} + +int nb_candidate_commit(struct nb_context *context, struct nb_config *candidate, + bool save_transaction, const char *comment, + uint32_t *transaction_id, char *errmsg, + size_t errmsg_len) +{ + struct nb_transaction *transaction = NULL; + int ret; + + ret = nb_candidate_commit_prepare(context, candidate, comment, + &transaction, errmsg, errmsg_len); + /* + * Apply the changes if the preparation phase succeeded. Otherwise abort + * the transaction. + */ + if (ret == NB_OK) + nb_candidate_commit_apply(transaction, save_transaction, + transaction_id, errmsg, errmsg_len); + else if (transaction != NULL) + nb_candidate_commit_abort(transaction, errmsg, errmsg_len); + + return ret; +} + +int nb_running_lock(enum nb_client client, const void *user) +{ + int ret = -1; + + frr_with_mutex (&running_config_mgmt_lock.mtx) { + if (!running_config_mgmt_lock.locked) { + running_config_mgmt_lock.locked = true; + running_config_mgmt_lock.owner_client = client; + running_config_mgmt_lock.owner_user = user; + ret = 0; + } + } + + return ret; +} + +int nb_running_unlock(enum nb_client client, const void *user) +{ + int ret = -1; + + frr_with_mutex (&running_config_mgmt_lock.mtx) { + if (running_config_mgmt_lock.locked + && running_config_mgmt_lock.owner_client == client + && running_config_mgmt_lock.owner_user == user) { + running_config_mgmt_lock.locked = false; + running_config_mgmt_lock.owner_client = NB_CLIENT_NONE; + running_config_mgmt_lock.owner_user = NULL; + ret = 0; + } + } + + return ret; +} + +int nb_running_lock_check(enum nb_client client, const void *user) +{ + int ret = -1; + + frr_with_mutex (&running_config_mgmt_lock.mtx) { + if (!running_config_mgmt_lock.locked + || (running_config_mgmt_lock.owner_client == client + && running_config_mgmt_lock.owner_user == user)) + ret = 0; + } + + return ret; +} + +static void nb_log_config_callback(const enum nb_event event, + enum nb_operation operation, + const struct lyd_node *dnode) +{ + const char *value; + char xpath[XPATH_MAXLEN]; + + if (!DEBUG_MODE_CHECK(&nb_dbg_cbs_config, DEBUG_MODE_ALL)) + return; + + yang_dnode_get_path(dnode, xpath, sizeof(xpath)); + if (yang_snode_is_typeless_data(dnode->schema)) + value = "(none)"; + else + value = yang_dnode_get_string(dnode, NULL); + + zlog_debug( + "northbound callback: event [%s] op [%s] xpath [%s] value [%s]", + nb_event_name(event), nb_operation_name(operation), xpath, + value); +} + +static int nb_callback_create(struct nb_context *context, + const struct nb_node *nb_node, + enum nb_event event, const struct lyd_node *dnode, + union nb_resource *resource, char *errmsg, + size_t errmsg_len) +{ + struct nb_cb_create_args args = {}; + bool unexpected_error = false; + int ret; + + nb_log_config_callback(event, NB_OP_CREATE, dnode); + + args.context = context; + args.event = event; + args.dnode = dnode; + args.resource = resource; + args.errmsg = errmsg; + args.errmsg_len = errmsg_len; + ret = nb_node->cbs.create(&args); + + /* Detect and log unexpected errors. */ + switch (ret) { + case NB_OK: + case NB_ERR: + break; + case NB_ERR_VALIDATION: + if (event != NB_EV_VALIDATE) + unexpected_error = true; + break; + case NB_ERR_RESOURCE: + if (event != NB_EV_PREPARE) + unexpected_error = true; + break; + case NB_ERR_INCONSISTENCY: + if (event == NB_EV_VALIDATE) + unexpected_error = true; + break; + default: + unexpected_error = true; + break; + } + if (unexpected_error) + DEBUGD(&nb_dbg_cbs_config, + "northbound callback: unexpected return value: %s", + nb_err_name(ret)); + + return ret; +} + +static int nb_callback_modify(struct nb_context *context, + const struct nb_node *nb_node, + enum nb_event event, const struct lyd_node *dnode, + union nb_resource *resource, char *errmsg, + size_t errmsg_len) +{ + struct nb_cb_modify_args args = {}; + bool unexpected_error = false; + int ret; + + nb_log_config_callback(event, NB_OP_MODIFY, dnode); + + args.context = context; + args.event = event; + args.dnode = dnode; + args.resource = resource; + args.errmsg = errmsg; + args.errmsg_len = errmsg_len; + ret = nb_node->cbs.modify(&args); + + /* Detect and log unexpected errors. */ + switch (ret) { + case NB_OK: + case NB_ERR: + break; + case NB_ERR_VALIDATION: + if (event != NB_EV_VALIDATE) + unexpected_error = true; + break; + case NB_ERR_RESOURCE: + if (event != NB_EV_PREPARE) + unexpected_error = true; + break; + case NB_ERR_INCONSISTENCY: + if (event == NB_EV_VALIDATE) + unexpected_error = true; + break; + default: + unexpected_error = true; + break; + } + if (unexpected_error) + DEBUGD(&nb_dbg_cbs_config, + "northbound callback: unexpected return value: %s", + nb_err_name(ret)); + + return ret; +} + +static int nb_callback_destroy(struct nb_context *context, + const struct nb_node *nb_node, + enum nb_event event, + const struct lyd_node *dnode, char *errmsg, + size_t errmsg_len) +{ + struct nb_cb_destroy_args args = {}; + bool unexpected_error = false; + int ret; + + nb_log_config_callback(event, NB_OP_DESTROY, dnode); + + args.context = context; + args.event = event; + args.dnode = dnode; + args.errmsg = errmsg; + args.errmsg_len = errmsg_len; + ret = nb_node->cbs.destroy(&args); + + /* Detect and log unexpected errors. */ + switch (ret) { + case NB_OK: + case NB_ERR: + break; + case NB_ERR_VALIDATION: + if (event != NB_EV_VALIDATE) + unexpected_error = true; + break; + case NB_ERR_INCONSISTENCY: + if (event == NB_EV_VALIDATE) + unexpected_error = true; + break; + default: + unexpected_error = true; + break; + } + if (unexpected_error) + DEBUGD(&nb_dbg_cbs_config, + "northbound callback: unexpected return value: %s", + nb_err_name(ret)); + + return ret; +} + +static int nb_callback_move(struct nb_context *context, + const struct nb_node *nb_node, enum nb_event event, + const struct lyd_node *dnode, char *errmsg, + size_t errmsg_len) +{ + struct nb_cb_move_args args = {}; + bool unexpected_error = false; + int ret; + + nb_log_config_callback(event, NB_OP_MOVE, dnode); + + args.context = context; + args.event = event; + args.dnode = dnode; + args.errmsg = errmsg; + args.errmsg_len = errmsg_len; + ret = nb_node->cbs.move(&args); + + /* Detect and log unexpected errors. */ + switch (ret) { + case NB_OK: + case NB_ERR: + break; + case NB_ERR_VALIDATION: + if (event != NB_EV_VALIDATE) + unexpected_error = true; + break; + case NB_ERR_INCONSISTENCY: + if (event == NB_EV_VALIDATE) + unexpected_error = true; + break; + default: + unexpected_error = true; + break; + } + if (unexpected_error) + DEBUGD(&nb_dbg_cbs_config, + "northbound callback: unexpected return value: %s", + nb_err_name(ret)); + + return ret; +} + +static int nb_callback_pre_validate(struct nb_context *context, + const struct nb_node *nb_node, + const struct lyd_node *dnode, char *errmsg, + size_t errmsg_len) +{ + struct nb_cb_pre_validate_args args = {}; + bool unexpected_error = false; + int ret; + + nb_log_config_callback(NB_EV_VALIDATE, NB_OP_PRE_VALIDATE, dnode); + + args.dnode = dnode; + args.errmsg = errmsg; + args.errmsg_len = errmsg_len; + ret = nb_node->cbs.pre_validate(&args); + + /* Detect and log unexpected errors. */ + switch (ret) { + case NB_OK: + case NB_ERR_VALIDATION: + break; + default: + unexpected_error = true; + break; + } + if (unexpected_error) + DEBUGD(&nb_dbg_cbs_config, + "northbound callback: unexpected return value: %s", + nb_err_name(ret)); + + return ret; +} + +static void nb_callback_apply_finish(struct nb_context *context, + const struct nb_node *nb_node, + const struct lyd_node *dnode, char *errmsg, + size_t errmsg_len) +{ + struct nb_cb_apply_finish_args args = {}; + + nb_log_config_callback(NB_EV_APPLY, NB_OP_APPLY_FINISH, dnode); + + args.context = context; + args.dnode = dnode; + args.errmsg = errmsg; + args.errmsg_len = errmsg_len; + nb_node->cbs.apply_finish(&args); +} + +struct yang_data *nb_callback_get_elem(const struct nb_node *nb_node, + const char *xpath, + const void *list_entry) +{ + struct nb_cb_get_elem_args args = {}; + + DEBUGD(&nb_dbg_cbs_state, + "northbound callback (get_elem): xpath [%s] list_entry [%p]", + xpath, list_entry); + + args.xpath = xpath; + args.list_entry = list_entry; + return nb_node->cbs.get_elem(&args); +} + +const void *nb_callback_get_next(const struct nb_node *nb_node, + const void *parent_list_entry, + const void *list_entry) +{ + struct nb_cb_get_next_args args = {}; + + DEBUGD(&nb_dbg_cbs_state, + "northbound callback (get_next): node [%s] parent_list_entry [%p] list_entry [%p]", + nb_node->xpath, parent_list_entry, list_entry); + + args.parent_list_entry = parent_list_entry; + args.list_entry = list_entry; + return nb_node->cbs.get_next(&args); +} + +int nb_callback_get_keys(const struct nb_node *nb_node, const void *list_entry, + struct yang_list_keys *keys) +{ + struct nb_cb_get_keys_args args = {}; + + DEBUGD(&nb_dbg_cbs_state, + "northbound callback (get_keys): node [%s] list_entry [%p]", + nb_node->xpath, list_entry); + + args.list_entry = list_entry; + args.keys = keys; + return nb_node->cbs.get_keys(&args); +} + +const void *nb_callback_lookup_entry(const struct nb_node *nb_node, + const void *parent_list_entry, + const struct yang_list_keys *keys) +{ + struct nb_cb_lookup_entry_args args = {}; + + 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_entry(&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 = {}; + + DEBUGD(&nb_dbg_cbs_rpc, "northbound RPC: %s", xpath); + + args.xpath = xpath; + args.input = input; + args.output = output; + args.errmsg = errmsg; + args.errmsg_len = errmsg_len; + return nb_node->cbs.rpc(&args); +} + +/* + * Call the northbound configuration callback associated to a given + * configuration change. + */ +static int nb_callback_configuration(struct nb_context *context, + const enum nb_event event, + struct nb_config_change *change, + char *errmsg, size_t errmsg_len) +{ + enum nb_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 (event == NB_EV_VALIDATE) + resource = NULL; + else + resource = &change->resource; + + switch (operation) { + case NB_OP_CREATE: + ret = nb_callback_create(context, nb_node, event, dnode, + resource, errmsg, errmsg_len); + break; + case NB_OP_MODIFY: + ret = nb_callback_modify(context, nb_node, event, dnode, + resource, errmsg, errmsg_len); + break; + case NB_OP_DESTROY: + ret = nb_callback_destroy(context, nb_node, event, dnode, + errmsg, errmsg_len); + break; + case NB_OP_MOVE: + ret = nb_callback_move(context, nb_node, event, dnode, errmsg, + errmsg_len); + break; + default: + yang_dnode_get_path(dnode, xpath, sizeof(xpath)); + flog_err(EC_LIB_DEVELOPMENT, + "%s: unknown operation (%u) [xpath %s]", __func__, + operation, xpath); + exit(1); + } + + if (ret != NB_OK) { + yang_dnode_get_path(dnode, xpath, sizeof(xpath)); + + switch (event) { + case NB_EV_VALIDATE: + 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, + 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, + 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, + 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, + errmsg[0] ? " message: " : "", errmsg); + break; + default: + flog_err(EC_LIB_DEVELOPMENT, + "%s: unknown event (%u) [xpath %s]", __func__, + event, xpath); + exit(1); + } + } + + return ret; +} + +static struct nb_transaction * +nb_transaction_new(struct nb_context *context, struct nb_config *config, + struct nb_config_cbs *changes, const char *comment, + char *errmsg, size_t errmsg_len) +{ + struct nb_transaction *transaction; + + if (nb_running_lock_check(context->client, context->user)) { + strlcpy(errmsg, + "running configuration is locked by another client", + errmsg_len); + return NULL; + } + + if (transaction_in_progress) { + strlcpy(errmsg, + "there's already another transaction in progress", + errmsg_len); + return NULL; + } + transaction_in_progress = true; + + transaction = XCALLOC(MTYPE_TMP, sizeof(*transaction)); + transaction->context = context; + if (comment) + strlcpy(transaction->comment, comment, + sizeof(transaction->comment)); + transaction->config = config; + transaction->changes = *changes; + + return transaction; +} + +static void nb_transaction_free(struct nb_transaction *transaction) +{ + nb_config_diff_del_changes(&transaction->changes); + XFREE(MTYPE_TMP, transaction); + transaction_in_progress = false; +} + +/* Process all configuration changes associated to a transaction. */ +static int nb_transaction_process(enum nb_event event, + struct nb_transaction *transaction, + char *errmsg, size_t errmsg_len) +{ + struct nb_config_cb *cb; + + RB_FOREACH (cb, nb_config_cbs, &transaction->changes) { + struct nb_config_change *change = (struct nb_config_change *)cb; + int ret; + + /* + * Only try to release resources that were allocated + * successfully. + */ + if (event == NB_EV_ABORT && !change->prepare_ok) + break; + + /* Call the appropriate callback. */ + ret = nb_callback_configuration(transaction->context, event, + change, errmsg, errmsg_len); + switch (event) { + case NB_EV_PREPARE: + if (ret != NB_OK) + return ret; + change->prepare_ok = true; + break; + case NB_EV_ABORT: + case NB_EV_APPLY: + /* + * At this point it's not possible to reject the + * transaction anymore, so any failure here can lead to + * inconsistencies and should be treated as a bug. + * Operations prone to errors, like validations and + * resource allocations, should be performed during the + * 'prepare' phase. + */ + break; + default: + break; + } + } + + return NB_OK; +} + +static struct nb_config_cb * +nb_apply_finish_cb_new(struct nb_config_cbs *cbs, const struct nb_node *nb_node, + const struct lyd_node *dnode) +{ + struct nb_config_cb *cb; + + cb = XCALLOC(MTYPE_TMP, sizeof(*cb)); + cb->nb_node = nb_node; + cb->dnode = dnode; + RB_INSERT(nb_config_cbs, cbs, cb); + + return cb; +} + +static struct nb_config_cb * +nb_apply_finish_cb_find(struct nb_config_cbs *cbs, + const struct nb_node *nb_node, + const struct lyd_node *dnode) +{ + struct nb_config_cb s; + + s.seq = 0; + s.nb_node = nb_node; + s.dnode = dnode; + return RB_FIND(nb_config_cbs, cbs, &s); +} + +/* Call the 'apply_finish' callbacks. */ +static void nb_transaction_apply_finish(struct nb_transaction *transaction, + char *errmsg, size_t errmsg_len) +{ + struct nb_config_cbs cbs; + struct nb_config_cb *cb; + + /* Initialize tree of 'apply_finish' callbacks. */ + RB_INIT(nb_config_cbs, &cbs); + + /* Identify the 'apply_finish' callbacks that need to be called. */ + RB_FOREACH (cb, nb_config_cbs, &transaction->changes) { + struct nb_config_change *change = (struct nb_config_change *)cb; + const struct lyd_node *dnode = change->cb.dnode; + + /* + * Iterate up to the root of the data tree. When a node is being + * deleted, skip its 'apply_finish' callback if one is defined + * (the 'apply_finish' callbacks from the node ancestors should + * be called though). + */ + if (change->cb.operation == NB_OP_DESTROY) { + char xpath[XPATH_MAXLEN]; + + dnode = lyd_parent(dnode); + if (!dnode) + break; + + /* + * The dnode from 'delete' callbacks point to elements + * from the running configuration. Use yang_dnode_get() + * to get the corresponding dnode from the candidate + * configuration that is being committed. + */ + yang_dnode_get_path(dnode, xpath, sizeof(xpath)); + dnode = yang_dnode_get(transaction->config->dnode, + xpath); + } + while (dnode) { + struct nb_node *nb_node; + + nb_node = dnode->schema->priv; + if (!nb_node || !nb_node->cbs.apply_finish) + goto next; + + /* + * Don't call the callback more than once for the same + * data node. + */ + if (nb_apply_finish_cb_find(&cbs, nb_node, dnode)) + goto next; + + nb_apply_finish_cb_new(&cbs, nb_node, dnode); + + next: + dnode = lyd_parent(dnode); + } + } + + /* Call the 'apply_finish' callbacks, sorted by their priorities. */ + RB_FOREACH (cb, nb_config_cbs, &cbs) + nb_callback_apply_finish(transaction->context, cb->nb_node, + cb->dnode, errmsg, errmsg_len); + + /* Release memory. */ + while (!RB_EMPTY(nb_config_cbs, &cbs)) { + cb = RB_ROOT(nb_config_cbs, &cbs); + RB_REMOVE(nb_config_cbs, &cbs, cb); + XFREE(MTYPE_TMP, cb); + } +} + +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_path(NULL, ly_native_ctx, xpath, NULL, + LYD_NEW_PATH_UPDATE, &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) +{ + struct nb_node *nb_node = snode->priv; + struct lysc_node_container *scontainer; + struct lysc_node_leaf *sleaf; + + switch (operation) { + case NB_OP_CREATE: + if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W)) + return false; + + switch (snode->nodetype) { + case LYS_LEAF: + sleaf = (struct lysc_node_leaf *)snode; + if (sleaf->type->basetype != LY_TYPE_EMPTY) + return false; + break; + case LYS_CONTAINER: + scontainer = (struct lysc_node_container *)snode; + if (!CHECK_FLAG(scontainer->flags, LYS_PRESENCE)) + return false; + break; + case LYS_LIST: + case LYS_LEAFLIST: + break; + default: + return false; + } + return true; + case NB_OP_MODIFY: + if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W)) + return false; + + switch (snode->nodetype) { + case LYS_LEAF: + sleaf = (struct lysc_node_leaf *)snode; + if (sleaf->type->basetype == LY_TYPE_EMPTY) + return false; + + /* List keys can't be modified. */ + if (lysc_is_key(sleaf)) + return false; + break; + default: + return false; + } + return true; + case NB_OP_DESTROY: + if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W)) + return false; + + switch (snode->nodetype) { + case LYS_LEAF: + sleaf = (struct lysc_node_leaf *)snode; + + /* List keys can't be deleted. */ + if (lysc_is_key(sleaf)) + return false; + + /* + * Only optional leafs can be deleted, or leafs whose + * parent is a case statement. + */ + if (snode->parent->nodetype == LYS_CASE) + return true; + if (sleaf->when) + return true; + if (CHECK_FLAG(sleaf->flags, LYS_MAND_TRUE) + || sleaf->dflt) + return false; + break; + case LYS_CONTAINER: + scontainer = (struct lysc_node_container *)snode; + if (!CHECK_FLAG(scontainer->flags, LYS_PRESENCE)) + return false; + break; + case LYS_LIST: + case LYS_LEAFLIST: + break; + default: + return false; + } + return true; + case NB_OP_MOVE: + if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W)) + return false; + + switch (snode->nodetype) { + case LYS_LIST: + case LYS_LEAFLIST: + if (!CHECK_FLAG(snode->flags, LYS_ORDBY_USER)) + return false; + break; + default: + return false; + } + return true; + case NB_OP_PRE_VALIDATE: + case NB_OP_APPLY_FINISH: + if (!CHECK_FLAG(snode->flags, LYS_CONFIG_W)) + return false; + return true; + case NB_OP_GET_ELEM: + if (!CHECK_FLAG(snode->flags, LYS_CONFIG_R)) + return false; + + switch (snode->nodetype) { + case LYS_LEAF: + case LYS_LEAFLIST: + break; + case LYS_CONTAINER: + scontainer = (struct lysc_node_container *)snode; + if (!CHECK_FLAG(scontainer->flags, LYS_PRESENCE)) + return false; + break; + default: + return false; + } + return true; + case NB_OP_GET_NEXT: + switch (snode->nodetype) { + case LYS_LIST: + if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY)) + return false; + break; + case LYS_LEAFLIST: + if (CHECK_FLAG(snode->flags, LYS_CONFIG_W)) + return false; + break; + default: + return false; + } + return true; + case NB_OP_GET_KEYS: + case NB_OP_LOOKUP_ENTRY: + switch (snode->nodetype) { + case LYS_LIST: + if (CHECK_FLAG(nb_node->flags, F_NB_NODE_CONFIG_ONLY)) + return false; + if (CHECK_FLAG(nb_node->flags, F_NB_NODE_KEYLESS_LIST)) + return false; + break; + default: + return false; + } + return true; + case NB_OP_RPC: + if (CHECK_FLAG(snode->flags, LYS_CONFIG_W | LYS_CONFIG_R)) + return false; + + switch (snode->nodetype) { + case LYS_RPC: + case LYS_ACTION: + break; + default: + return false; + } + return true; + default: + return false; + } +} + +DEFINE_HOOK(nb_notification_send, (const char *xpath, struct list *arguments), + (xpath, arguments)); + +int nb_notification_send(const char *xpath, struct list *arguments) +{ + int ret; + + DEBUGD(&nb_dbg_notif, "northbound notification: %s", xpath); + + ret = hook_call(nb_notification_send, xpath, arguments); + if (arguments) + list_delete(&arguments); + + return ret; +} + +/* Running configuration user pointers management. */ +struct nb_config_entry { + char xpath[XPATH_MAXLEN]; + void *entry; +}; + +static bool running_config_entry_cmp(const void *value1, const void *value2) +{ + const struct nb_config_entry *c1 = value1; + const struct nb_config_entry *c2 = value2; + + return strmatch(c1->xpath, c2->xpath); +} + +static unsigned int running_config_entry_key_make(const void *value) +{ + return string_hash_make(value); +} + +static void *running_config_entry_alloc(void *p) +{ + struct nb_config_entry *new, *key = p; + + new = XCALLOC(MTYPE_NB_CONFIG_ENTRY, sizeof(*new)); + strlcpy(new->xpath, key->xpath, sizeof(new->xpath)); + + return new; +} + +static void running_config_entry_free(void *arg) +{ + XFREE(MTYPE_NB_CONFIG_ENTRY, arg); +} + +void nb_running_set_entry(const struct lyd_node *dnode, void *entry) +{ + struct nb_config_entry *config, s; + + yang_dnode_get_path(dnode, s.xpath, sizeof(s.xpath)); + config = hash_get(running_config_entries, &s, + running_config_entry_alloc); + config->entry = entry; +} + +void nb_running_move_tree(const char *xpath_from, const char *xpath_to) +{ + struct nb_config_entry *entry; + struct list *entries = hash_to_list(running_config_entries); + struct listnode *ln; + + for (ALL_LIST_ELEMENTS_RO(entries, ln, entry)) { + if (!frrstr_startswith(entry->xpath, xpath_from)) + continue; + + hash_release(running_config_entries, entry); + + char *newpath = + frrstr_replace(entry->xpath, xpath_from, xpath_to); + strlcpy(entry->xpath, newpath, sizeof(entry->xpath)); + XFREE(MTYPE_TMP, newpath); + + (void)hash_get(running_config_entries, entry, + hash_alloc_intern); + } + + list_delete(&entries); +} + +static void *nb_running_unset_entry_helper(const struct lyd_node *dnode) +{ + struct nb_config_entry *config, s; + struct lyd_node *child; + void *entry = NULL; + + yang_dnode_get_path(dnode, s.xpath, sizeof(s.xpath)); + config = hash_release(running_config_entries, &s); + if (config) { + entry = config->entry; + running_config_entry_free(config); + } + + /* Unset user pointers from the child nodes. */ + if (CHECK_FLAG(dnode->schema->nodetype, LYS_LIST | LYS_CONTAINER)) { + LY_LIST_FOR (lyd_child(dnode), child) { + (void)nb_running_unset_entry_helper(child); + } + } + + return entry; +} + +void *nb_running_unset_entry(const struct lyd_node *dnode) +{ + void *entry; + + entry = nb_running_unset_entry_helper(dnode); + assert(entry); + + return entry; +} + +static void *nb_running_get_entry_worker(const struct lyd_node *dnode, + const char *xpath, + bool abort_if_not_found, + bool rec_search) +{ + const struct lyd_node *orig_dnode = dnode; + char xpath_buf[XPATH_MAXLEN]; + bool rec_flag = true; + + assert(dnode || xpath); + + if (!dnode) + dnode = yang_dnode_get(running_config->dnode, xpath); + + while (rec_flag && dnode) { + struct nb_config_entry *config, s; + + yang_dnode_get_path(dnode, s.xpath, sizeof(s.xpath)); + config = hash_lookup(running_config_entries, &s); + if (config) + return config->entry; + + rec_flag = rec_search; + + dnode = lyd_parent(dnode); + } + + if (!abort_if_not_found) + return NULL; + + yang_dnode_get_path(orig_dnode, xpath_buf, sizeof(xpath_buf)); + flog_err(EC_LIB_YANG_DNODE_NOT_FOUND, + "%s: failed to find entry [xpath %s]", __func__, xpath_buf); + zlog_backtrace(LOG_ERR); + abort(); +} + +void *nb_running_get_entry(const struct lyd_node *dnode, const char *xpath, + bool abort_if_not_found) +{ + return nb_running_get_entry_worker(dnode, xpath, abort_if_not_found, + true); +} + +void *nb_running_get_entry_non_rec(const struct lyd_node *dnode, + const char *xpath, bool abort_if_not_found) +{ + return nb_running_get_entry_worker(dnode, xpath, abort_if_not_found, + false); +} + +/* Logging functions. */ +const char *nb_event_name(enum nb_event event) +{ + switch (event) { + case NB_EV_VALIDATE: + return "validate"; + case NB_EV_PREPARE: + return "prepare"; + case NB_EV_ABORT: + return "abort"; + case NB_EV_APPLY: + return "apply"; + default: + return "unknown"; + } +} + +const char *nb_operation_name(enum nb_operation operation) +{ + switch (operation) { + case NB_OP_CREATE: + return "create"; + case NB_OP_MODIFY: + return "modify"; + case NB_OP_DESTROY: + return "destroy"; + case NB_OP_MOVE: + return "move"; + case NB_OP_PRE_VALIDATE: + return "pre_validate"; + case NB_OP_APPLY_FINISH: + return "apply_finish"; + case NB_OP_GET_ELEM: + return "get_elem"; + case NB_OP_GET_NEXT: + return "get_next"; + case NB_OP_GET_KEYS: + return "get_keys"; + case NB_OP_LOOKUP_ENTRY: + return "lookup_entry"; + case NB_OP_RPC: + return "rpc"; + default: + return "unknown"; + } +} + +const char *nb_err_name(enum nb_error error) +{ + switch (error) { + case NB_OK: + return "ok"; + case NB_ERR: + return "generic error"; + case NB_ERR_NO_CHANGES: + return "no changes"; + case NB_ERR_NOT_FOUND: + return "element not found"; + case NB_ERR_LOCKED: + return "resource is locked"; + case NB_ERR_VALIDATION: + return "validation"; + case NB_ERR_RESOURCE: + return "failed to allocate resource"; + case NB_ERR_INCONSISTENCY: + return "internal inconsistency"; + default: + return "unknown"; + } +} + +const char *nb_client_name(enum nb_client client) +{ + switch (client) { + case NB_CLIENT_CLI: + return "CLI"; + case NB_CLIENT_CONFD: + return "ConfD"; + case NB_CLIENT_SYSREPO: + return "Sysrepo"; + case NB_CLIENT_GRPC: + return "gRPC"; + default: + return "unknown"; + } +} + +static void nb_load_callbacks(const struct frr_yang_module_info *module) +{ + for (size_t i = 0; module->nodes[i].xpath; i++) { + struct nb_node *nb_node; + uint32_t priority; + + if (i > YANG_MODULE_MAX_NODES) { + zlog_err( + "%s: %s.yang has more than %u nodes. Please increase YANG_MODULE_MAX_NODES to fix this problem.", + __func__, module->name, YANG_MODULE_MAX_NODES); + exit(1); + } + + nb_node = nb_node_find(module->nodes[i].xpath); + if (!nb_node) { + flog_warn(EC_LIB_YANG_UNKNOWN_DATA_PATH, + "%s: unknown data path: %s", __func__, + module->nodes[i].xpath); + continue; + } + + nb_node->cbs = module->nodes[i].cbs; + priority = module->nodes[i].priority; + if (priority != 0) + nb_node->priority = priority; + } +} + +void nb_validate_callbacks(void) +{ + unsigned int errors = 0; + + yang_snodes_iterate(NULL, nb_node_validate, 0, &errors); + if (errors > 0) { + flog_err( + EC_LIB_NB_CBS_VALIDATION, + "%s: failed to validate northbound callbacks: %u error(s)", + __func__, errors); + exit(1); + } +} + + +void nb_init(struct thread_master *tm, + const struct frr_yang_module_info *const modules[], + size_t nmodules, bool db_enabled) +{ + struct yang_module *loaded[nmodules], **loadedp = loaded; + bool explicit_compile; + + /* + * Currently using this explicit compile feature in libyang2 leads to + * incorrect behavior in FRR. The functionality suppresses the compiling + * of modules until they have all been loaded into the context. This + * avoids multiple recompiles of the same modules as they are + * imported/augmented etc. + */ + explicit_compile = false; + + nb_db_enabled = db_enabled; + + yang_init(true, explicit_compile); + + /* Load YANG modules and their corresponding northbound callbacks. */ + 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); + } + + if (explicit_compile) + yang_init_loading_complete(); + + /* Initialize the compiled nodes with northbound data */ + for (size_t i = 0; i < nmodules; i++) { + yang_snodes_iterate(loaded[i]->info, nb_node_new_cb, 0, NULL); + nb_load_callbacks(modules[i]); + } + + /* Validate northbound callbacks. */ + nb_validate_callbacks(); + + /* Create an empty running configuration. */ + running_config = nb_config_new(NULL); + running_config_entries = hash_create(running_config_entry_key_make, + running_config_entry_cmp, + "Running Configuration Entries"); + pthread_mutex_init(&running_config_mgmt_lock.mtx, NULL); + + /* Initialize the northbound CLI. */ + nb_cli_init(tm); +} + +void nb_terminate(void) +{ + /* Terminate the northbound CLI. */ + nb_cli_terminate(); + + /* Delete all nb_node's from all YANG modules. */ + nb_nodes_delete(); + + /* Delete the running configuration. */ + hash_clean(running_config_entries, running_config_entry_free); + hash_free(running_config_entries); + nb_config_free(running_config); + pthread_mutex_destroy(&running_config_mgmt_lock.mtx); +} |