Adding upstream version 10.0.upstream/10.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 426 insertions, 202 deletions

diff --git a/lib/mgmt_be_client.c b/lib/mgmt_be_client.c
index 7bd9980..f483d48 100644
--- a/lib/mgmt_be_client.c
+++ b/lib/mgmt_be_client.c
@@ -8,15 +8,18 @@
 #include <zebra.h>
 #include "debug.h"
 #include "compiler.h"
+#include "darr.h"
 #include "libfrr.h"
-#include "mgmtd/mgmt.h"
+#include "lib_errors.h"
 #include "mgmt_be_client.h"
 #include "mgmt_msg.h"
+#include "mgmt_msg_native.h"
 #include "mgmt_pb.h"
 #include "network.h"
 #include "northbound.h"
 #include "stream.h"
 #include "sockopt.h"
+#include "northbound_cli.h"
 
 #include "lib/mgmt_be_client_clippy.c"
 
@@ -24,11 +27,11 @@ DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_CLIENT, "backend client");
 DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_CLIENT_NAME, "backend client name");
 DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_BATCH, "backend transaction batch data");
 DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_TXN, "backend transaction data");
+DEFINE_MTYPE_STATIC(LIB, MGMTD_BE_GT_CB_ARGS, "backend get-tree cb args");
 
 enum mgmt_be_txn_event {
 	MGMTD_BE_TXN_PROC_SETCFG = 1,
 	MGMTD_BE_TXN_PROC_GETCFG,
-	MGMTD_BE_TXN_PROC_GETDATA
 };
 
 struct mgmt_be_set_cfg_req {
@@ -36,24 +39,20 @@ struct mgmt_be_set_cfg_req {
 	uint16_t num_cfg_changes;
 };
 
-struct mgmt_be_get_data_req {
-	char *xpaths[MGMTD_MAX_NUM_DATA_REQ_IN_BATCH];
-	uint16_t num_xpaths;
-};
-
 struct mgmt_be_txn_req {
 	enum mgmt_be_txn_event event;
 	union {
 		struct mgmt_be_set_cfg_req set_cfg;
-		struct mgmt_be_get_data_req get_data;
 	} req;
 };
 
+struct be_oper_iter_arg {
+	struct lyd_node *root; /* the tree we are building */
+	struct lyd_node *hint; /* last node added */
+};
+
 PREDECL_LIST(mgmt_be_batches);
 struct mgmt_be_batch_ctx {
-	/* Batch-Id as assigned by MGMTD */
-	uint64_t batch_id;
-
 	struct mgmt_be_txn_req txn_req;
 
 	uint32_t flags;
@@ -116,15 +115,22 @@ struct mgmt_be_client {
 #define FOREACH_BE_TXN_IN_LIST(client_ctx, txn)                                \
 	frr_each_safe (mgmt_be_txns, &(client_ctx)->txn_head, (txn))
 
-struct debug mgmt_dbg_be_client = {0, "Management backend client operations"};
-
-const char *mgmt_be_client_names[MGMTD_BE_CLIENT_ID_MAX + 1] = {
-#ifdef HAVE_STATICD
-	[MGMTD_BE_CLIENT_ID_STATICD] = "staticd",
-#endif
-	[MGMTD_BE_CLIENT_ID_MAX] = "Unknown/Invalid",
+struct debug mgmt_dbg_be_client = {
+	.desc = "Management backend client operations"
 };
 
+/* NOTE: only one client per proc for now. */
+static struct mgmt_be_client *__be_client;
+
+static int be_client_send_native_msg(struct mgmt_be_client *client_ctx,
+				     void *msg, size_t len,
+				     bool short_circuit_ok)
+{
+	return msg_conn_send_msg(&client_ctx->client.conn,
+				 MGMT_MSG_VERSION_NATIVE, msg, len, NULL,
+				 short_circuit_ok);
+}
+
 static int mgmt_be_client_send_msg(struct mgmt_be_client *client_ctx,
 				   Mgmtd__BeMessage *be_msg)
 {
@@ -135,37 +141,15 @@ static int mgmt_be_client_send_msg(struct mgmt_be_client *client_ctx,
 }
 
 static struct mgmt_be_batch_ctx *
-mgmt_be_find_batch_by_id(struct mgmt_be_txn_ctx *txn,
-			    uint64_t batch_id)
-{
-	struct mgmt_be_batch_ctx *batch = NULL;
-
-	FOREACH_BE_TXN_BATCH_IN_LIST (txn, batch) {
-		if (batch->batch_id == batch_id)
-			return batch;
-	}
-
-	return NULL;
-}
-
-static struct mgmt_be_batch_ctx *
-mgmt_be_batch_create(struct mgmt_be_txn_ctx *txn, uint64_t batch_id)
+mgmt_be_batch_create(struct mgmt_be_txn_ctx *txn)
 {
 	struct mgmt_be_batch_ctx *batch = NULL;
 
-	batch = mgmt_be_find_batch_by_id(txn, batch_id);
-	if (!batch) {
-		batch = XCALLOC(MTYPE_MGMTD_BE_BATCH,
-				sizeof(struct mgmt_be_batch_ctx));
-		assert(batch);
+	batch = XCALLOC(MTYPE_MGMTD_BE_BATCH, sizeof(struct mgmt_be_batch_ctx));
 
-		batch->batch_id = batch_id;
-		mgmt_be_batches_add_tail(&txn->cfg_batches, batch);
+	mgmt_be_batches_add_tail(&txn->cfg_batches, batch);
 
-		MGMTD_BE_CLIENT_DBG("Added new batch-id: %" PRIu64
-				    " to transaction",
-				    batch_id);
-	}
+	debug_be_client("Added new batch to transaction");
 
 	return batch;
 }
@@ -218,7 +202,8 @@ mgmt_be_find_txn_by_id(struct mgmt_be_client *client_ctx, uint64_t txn_id,
 		if (txn->txn_id == txn_id)
 			return txn;
 	if (warn)
-		MGMTD_BE_CLIENT_ERR("Unknown txn-id: %" PRIu64, txn_id);
+		log_err_be_client("client %s unkonwn txn-id: %" PRIu64,
+				  client_ctx->name, txn_id);
 
 	return NULL;
 }
@@ -230,8 +215,8 @@ mgmt_be_txn_create(struct mgmt_be_client *client_ctx, uint64_t txn_id)
 
 	txn = mgmt_be_find_txn_by_id(client_ctx, txn_id, false);
 	if (txn) {
-		MGMTD_BE_CLIENT_ERR("Can't create existing txn-id: %" PRIu64,
-				    txn_id);
+		log_err_be_client("Can't create existing txn-id: %" PRIu64,
+				  txn_id);
 		return NULL;
 	}
 
@@ -242,7 +227,7 @@ mgmt_be_txn_create(struct mgmt_be_client *client_ctx, uint64_t txn_id)
 	mgmt_be_batches_init(&txn->apply_cfgs);
 	mgmt_be_txns_add_tail(&client_ctx->txn_head, txn);
 
-	MGMTD_BE_CLIENT_DBG("Created new txn-id: %" PRIu64, txn_id);
+	debug_be_client("Created new txn-id: %" PRIu64, txn_id);
 
 	return txn;
 }
@@ -291,6 +276,84 @@ static void mgmt_be_cleanup_all_txns(struct mgmt_be_client *client_ctx)
 	}
 }
 
+
+/**
+ * Send an error back to MGMTD using native messaging.
+ *
+ * Args:
+ *	client: the BE client.
+ *	txn_id: the txn_id this error pertains to.
+ *	short_circuit_ok: True if OK to short-circuit the call.
+ *	error: An integer error value.
+ *	errfmt: An error format string (i.e., printfrr)
+ *      ...: args for use by the `errfmt` format string.
+ *
+ * Return:
+ *	the return value from the underlying send message function.
+ */
+static int be_client_send_error(struct mgmt_be_client *client, uint64_t txn_id,
+				uint64_t req_id, bool short_circuit_ok,
+				int16_t error, const char *errfmt, ...)
+	PRINTFRR(6, 7);
+
+static int be_client_send_error(struct mgmt_be_client *client, uint64_t txn_id,
+				uint64_t req_id, bool short_circuit_ok,
+				int16_t error, const char *errfmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, errfmt);
+	ret = vmgmt_msg_native_send_error(&client->client.conn, txn_id, req_id,
+					  short_circuit_ok, error, errfmt, ap);
+	va_end(ap);
+
+	return ret;
+}
+
+static int mgmt_be_send_notification(void *__be_client, const char *xpath,
+				     const struct lyd_node *tree)
+{
+	struct mgmt_be_client *client = __be_client;
+	struct mgmt_msg_notify_data *msg = NULL;
+	LYD_FORMAT format = LYD_JSON;
+	uint8_t **darrp;
+	LY_ERR err;
+	int ret = 0;
+
+	assert(tree);
+
+	debug_be_client("%s: sending YANG notification: %s", __func__,
+			tree->schema->name);
+	/*
+	 * Allocate a message and append the data to it using `format`
+	 */
+	msg = mgmt_msg_native_alloc_msg(struct mgmt_msg_notify_data, 0,
+					MTYPE_MSG_NATIVE_NOTIFY);
+	msg->code = MGMT_MSG_CODE_NOTIFY;
+	msg->result_type = format;
+
+	mgmt_msg_native_xpath_encode(msg, xpath);
+
+	darrp = mgmt_msg_native_get_darrp(msg);
+	err = yang_print_tree_append(darrp, tree, format,
+				     (LYD_PRINT_SHRINK | LYD_PRINT_WD_EXPLICIT |
+				      LYD_PRINT_WITHSIBLINGS));
+	if (err) {
+		flog_err(EC_LIB_LIBYANG,
+			 "%s: error creating notification data: %s", __func__,
+			 ly_strerrcode(err));
+		ret = 1;
+		goto done;
+	}
+
+	(void)be_client_send_native_msg(client, msg,
+					mgmt_msg_native_get_msg_len(msg), false);
+done:
+	mgmt_msg_native_free_msg(msg);
+	return ret;
+}
+
 static int mgmt_be_send_txn_reply(struct mgmt_be_client *client_ctx,
 				  uint64_t txn_id, bool create)
 {
@@ -306,7 +369,7 @@ static int mgmt_be_send_txn_reply(struct mgmt_be_client *client_ctx,
 	be_msg.message_case = MGMTD__BE_MESSAGE__MESSAGE_TXN_REPLY;
 	be_msg.txn_reply = &txn_reply;
 
-	MGMTD_BE_CLIENT_DBG("Sending TXN_REPLY txn-id %" PRIu64, txn_id);
+	debug_be_client("Sending TXN_REPLY txn-id %" PRIu64, txn_id);
 
 	return mgmt_be_client_send_msg(client_ctx, &be_msg);
 }
@@ -317,7 +380,7 @@ static int mgmt_be_process_txn_req(struct mgmt_be_client *client_ctx,
 	struct mgmt_be_txn_ctx *txn;
 
 	if (create) {
-		MGMTD_BE_CLIENT_DBG("Creating new txn-id %" PRIu64, txn_id);
+		debug_be_client("Creating new txn-id %" PRIu64, txn_id);
 
 		txn = mgmt_be_txn_create(client_ctx, txn_id);
 		if (!txn)
@@ -328,7 +391,7 @@ static int mgmt_be_process_txn_req(struct mgmt_be_client *client_ctx,
 						      client_ctx->user_data,
 						      &txn->client_data, false);
 	} else {
-		MGMTD_BE_CLIENT_DBG("Deleting txn-id: %" PRIu64, txn_id);
+		debug_be_client("Deleting txn-id: %" PRIu64, txn_id);
 		txn = mgmt_be_find_txn_by_id(client_ctx, txn_id, false);
 		if (txn)
 			mgmt_be_txn_delete(client_ctx, &txn);
@@ -342,8 +405,7 @@ failed:
 }
 
 static int mgmt_be_send_cfgdata_create_reply(struct mgmt_be_client *client_ctx,
-					     uint64_t txn_id, uint64_t batch_id,
-					     bool success,
+					     uint64_t txn_id, bool success,
 					     const char *error_if_any)
 {
 	Mgmtd__BeMessage be_msg;
@@ -351,7 +413,6 @@ static int mgmt_be_send_cfgdata_create_reply(struct mgmt_be_client *client_ctx,
 
 	mgmtd__be_cfg_data_create_reply__init(&cfgdata_reply);
 	cfgdata_reply.txn_id = (uint64_t)txn_id;
-	cfgdata_reply.batch_id = (uint64_t)batch_id;
 	cfgdata_reply.success = success;
 	if (error_if_any)
 		cfgdata_reply.error_if_any = (char *)error_if_any;
@@ -360,9 +421,7 @@ static int mgmt_be_send_cfgdata_create_reply(struct mgmt_be_client *client_ctx,
 	be_msg.message_case = MGMTD__BE_MESSAGE__MESSAGE_CFG_DATA_REPLY;
 	be_msg.cfg_data_reply = &cfgdata_reply;
 
-	MGMTD_BE_CLIENT_DBG("Sending CFGDATA_CREATE_REPLY txn-id: %" PRIu64
-			    " batch-id: %" PRIu64,
-			    txn_id, batch_id);
+	debug_be_client("Sending CFGDATA_CREATE_REPLY txn-id: %" PRIu64, txn_id);
 
 	return mgmt_be_client_send_msg(client_ctx, &be_msg);
 }
@@ -373,9 +432,8 @@ static void mgmt_be_txn_cfg_abort(struct mgmt_be_txn_ctx *txn)
 
 	assert(txn && txn->client);
 	if (txn->nb_txn) {
-		MGMTD_BE_CLIENT_ERR(
-			"Aborting configs after prep for txn-id: %" PRIu64,
-			txn->txn_id);
+		log_err_be_client("Aborting configs after prep for txn-id: %" PRIu64,
+				  txn->txn_id);
 		nb_candidate_commit_abort(txn->nb_txn, errmsg, sizeof(errmsg));
 		txn->nb_txn = 0;
 	}
@@ -386,9 +444,8 @@ static void mgmt_be_txn_cfg_abort(struct mgmt_be_txn_ctx *txn)
 	 * This is one txn ctx but the candidate_config is per client ctx, how
 	 * does that work?
 	 */
-	MGMTD_BE_CLIENT_DBG(
-		"Reset candidate configurations after abort of txn-id: %" PRIu64,
-		txn->txn_id);
+	debug_be_client("Reset candidate configurations after abort of txn-id: %" PRIu64,
+			txn->txn_id);
 	nb_config_replace(txn->client->candidate_config,
 			  txn->client->running_config, true);
 }
@@ -433,15 +490,12 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
 				client_ctx->candidate_config,
 				txn_req->req.set_cfg.cfg_changes,
 				(size_t)txn_req->req.set_cfg.num_cfg_changes,
-				NULL, NULL, 0, err_buf, sizeof(err_buf),
-				&error);
+				NULL, true, err_buf, sizeof(err_buf), &error);
 			if (error) {
 				err_buf[sizeof(err_buf) - 1] = 0;
-				MGMTD_BE_CLIENT_ERR(
-					"Failed to update configs for txn-id: %" PRIu64
-					" batch-id: %" PRIu64
-					" to candidate, err: '%s'",
-					txn->txn_id, batch->batch_id, err_buf);
+				log_err_be_client("Failed to update configs for txn-id: %" PRIu64
+						  " to candidate, err: '%s'",
+						  txn->txn_id, err_buf);
 				return -1;
 			}
 			gettimeofday(&edit_nb_cfg_end, NULL);
@@ -479,21 +533,19 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
 	if (err != NB_OK) {
 		err_buf[sizeof(err_buf) - 1] = 0;
 		if (err == NB_ERR_VALIDATION)
-			MGMTD_BE_CLIENT_ERR(
-				"Failed to validate configs txn-id: %" PRIu64
-				" %zu batches, err: '%s'",
-				txn->txn_id, num_processed, err_buf);
+			log_err_be_client("Failed to validate configs txn-id: %" PRIu64
+					  " %zu batches, err: '%s'",
+					  txn->txn_id, num_processed, err_buf);
 		else
-			MGMTD_BE_CLIENT_ERR(
-				"Failed to prepare configs for txn-id: %" PRIu64
-				" %zu batches, err: '%s'",
-				txn->txn_id, num_processed, err_buf);
+			log_err_be_client("Failed to prepare configs for txn-id: %" PRIu64
+					  " %zu batches, err: '%s'",
+					  txn->txn_id, num_processed, err_buf);
 		error = true;
 		SET_FLAG(txn->flags, MGMTD_BE_TXN_FLAGS_CFGPREP_FAILED);
 	} else
-		MGMTD_BE_CLIENT_DBG("Prepared configs for txn-id: %" PRIu64
-				    " %zu batches",
-				    txn->txn_id, num_processed);
+		debug_be_client("Prepared configs for txn-id: %" PRIu64
+				" %zu batches",
+				txn->txn_id, num_processed);
 
 	gettimeofday(&prep_nb_cfg_end, NULL);
 	prep_nb_cfg_tm = timeval_elapsed(prep_nb_cfg_end, prep_nb_cfg_start);
@@ -504,9 +556,6 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
 	client_ctx->num_prep_nb_cfg++;
 
 	FOREACH_BE_TXN_BATCH_IN_LIST (txn, batch) {
-		mgmt_be_send_cfgdata_create_reply(
-			client_ctx, txn->txn_id, batch->batch_id,
-			error ? false : true, error ? err_buf : NULL);
 		if (!error) {
 			SET_FLAG(batch->flags,
 				 MGMTD_BE_BATCH_FLAGS_CFG_PREPARED);
@@ -515,10 +564,12 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
 		}
 	}
 
-	MGMTD_BE_CLIENT_DBG(
-		"Avg-nb-edit-duration %lu uSec, nb-prep-duration %lu (avg: %lu) uSec, batch size %u",
-		client_ctx->avg_edit_nb_cfg_tm, prep_nb_cfg_tm,
-		client_ctx->avg_prep_nb_cfg_tm, (uint32_t)num_processed);
+	mgmt_be_send_cfgdata_create_reply(client_ctx, txn->txn_id,
+		error ? false : true, error ? err_buf : NULL);
+
+	debug_be_client("Avg-nb-edit-duration %lu uSec, nb-prep-duration %lu (avg: %lu) uSec, batch size %u",
+			client_ctx->avg_edit_nb_cfg_tm, prep_nb_cfg_tm,
+			client_ctx->avg_prep_nb_cfg_tm, (uint32_t)num_processed);
 
 	if (error)
 		mgmt_be_txn_cfg_abort(txn);
@@ -531,7 +582,6 @@ static int mgmt_be_txn_cfg_prepare(struct mgmt_be_txn_ctx *txn)
  */
 static int mgmt_be_update_setcfg_in_batch(struct mgmt_be_client *client_ctx,
 					  struct mgmt_be_txn_ctx *txn,
-					  uint64_t batch_id,
 					  Mgmtd__YangCfgDataReq *cfg_req[],
 					  int num_req)
 {
@@ -540,27 +590,39 @@ static int mgmt_be_update_setcfg_in_batch(struct mgmt_be_client *client_ctx,
 	int index;
 	struct nb_cfg_change *cfg_chg;
 
-	batch = mgmt_be_batch_create(txn, batch_id);
-	if (!batch) {
-		MGMTD_BE_CLIENT_ERR("Batch create failed!");
-		return -1;
-	}
+	batch = mgmt_be_batch_create(txn);
+	assert(batch);
 
 	txn_req = &batch->txn_req;
 	txn_req->event = MGMTD_BE_TXN_PROC_SETCFG;
-	MGMTD_BE_CLIENT_DBG("Created SETCFG request for batch-id: %" PRIu64
-			    " txn-id: %" PRIu64 " cfg-items:%d",
-			    batch_id, txn->txn_id, num_req);
+	debug_be_client("Created SETCFG request for txn-id: %" PRIu64
+			" cfg-items:%d",
+			txn->txn_id, num_req);
 
 	txn_req->req.set_cfg.num_cfg_changes = num_req;
 	for (index = 0; index < num_req; index++) {
 		cfg_chg = &txn_req->req.set_cfg.cfg_changes[index];
 
-		if (cfg_req[index]->req_type
-		    == MGMTD__CFG_DATA_REQ_TYPE__DELETE_DATA)
+		/*
+		 * Treat all operations as destroy or modify, because we don't
+		 * need additional existence checks on the backend. Everything
+		 * is already checked by mgmtd.
+		 */
+		switch (cfg_req[index]->req_type) {
+		case MGMTD__CFG_DATA_REQ_TYPE__DELETE_DATA:
+		case MGMTD__CFG_DATA_REQ_TYPE__REMOVE_DATA:
 			cfg_chg->operation = NB_OP_DESTROY;
-		else
-			cfg_chg->operation = NB_OP_CREATE;
+			break;
+		case MGMTD__CFG_DATA_REQ_TYPE__SET_DATA:
+		case MGMTD__CFG_DATA_REQ_TYPE__CREATE_DATA:
+		case MGMTD__CFG_DATA_REQ_TYPE__REPLACE_DATA:
+			cfg_chg->operation = NB_OP_MODIFY;
+			break;
+		case MGMTD__CFG_DATA_REQ_TYPE__REQ_TYPE_NONE:
+		case _MGMTD__CFG_DATA_REQ_TYPE_IS_INT_SIZE:
+		default:
+			continue;
+		}
 
 		strlcpy(cfg_chg->xpath, cfg_req[index]->data->xpath,
 			sizeof(cfg_chg->xpath));
@@ -584,7 +646,7 @@ static int mgmt_be_update_setcfg_in_batch(struct mgmt_be_client *client_ctx,
 }
 
 static int mgmt_be_process_cfgdata_req(struct mgmt_be_client *client_ctx,
-				       uint64_t txn_id, uint64_t batch_id,
+				       uint64_t txn_id,
 				       Mgmtd__YangCfgDataReq *cfg_req[],
 				       int num_req, bool end_of_data)
 {
@@ -594,11 +656,10 @@ static int mgmt_be_process_cfgdata_req(struct mgmt_be_client *client_ctx,
 	if (!txn)
 		goto failed;
 
-	mgmt_be_update_setcfg_in_batch(client_ctx, txn, batch_id, cfg_req,
-				       num_req);
+	mgmt_be_update_setcfg_in_batch(client_ctx, txn, cfg_req, num_req);
 
 	if (txn && end_of_data) {
-		MGMTD_BE_CLIENT_DBG("End of data; CFG_PREPARE_REQ processing");
+		debug_be_client("End of data; CFG_PREPARE_REQ processing");
 		if (mgmt_be_txn_cfg_prepare(txn))
 			goto failed;
 	}
@@ -610,8 +671,7 @@ failed:
 }
 
 static int mgmt_be_send_apply_reply(struct mgmt_be_client *client_ctx,
-				    uint64_t txn_id, uint64_t batch_ids[],
-				    size_t num_batch_ids, bool success,
+				    uint64_t txn_id, bool success,
 				    const char *error_if_any)
 {
 	Mgmtd__BeMessage be_msg;
@@ -620,8 +680,6 @@ static int mgmt_be_send_apply_reply(struct mgmt_be_client *client_ctx,
 	mgmtd__be_cfg_data_apply_reply__init(&apply_reply);
 	apply_reply.success = success;
 	apply_reply.txn_id = txn_id;
-	apply_reply.batch_ids = (uint64_t *)batch_ids;
-	apply_reply.n_batch_ids = num_batch_ids;
 
 	if (error_if_any)
 		apply_reply.error_if_any = (char *)error_if_any;
@@ -630,12 +688,7 @@ static int mgmt_be_send_apply_reply(struct mgmt_be_client *client_ctx,
 	be_msg.message_case = MGMTD__BE_MESSAGE__MESSAGE_CFG_APPLY_REPLY;
 	be_msg.cfg_apply_reply = &apply_reply;
 
-	MGMTD_BE_CLIENT_DBG(
-		"Sending CFG_APPLY_REPLY txn-id %" PRIu64
-		" %zu batch ids %" PRIu64 " - %" PRIu64,
-		txn_id, num_batch_ids,
-		success && num_batch_ids ? batch_ids[0] : 0,
-		success && num_batch_ids ? batch_ids[num_batch_ids - 1] : 0);
+	debug_be_client("Sending CFG_APPLY_REPLY txn-id %" PRIu64, txn_id);
 
 	return mgmt_be_client_send_msg(client_ctx, &be_msg);
 }
@@ -648,14 +701,11 @@ static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
 	unsigned long apply_nb_cfg_tm;
 	struct mgmt_be_batch_ctx *batch;
 	char err_buf[BUFSIZ];
-	size_t num_processed;
-	static uint64_t batch_ids[MGMTD_BE_MAX_BATCH_IDS_IN_REQ];
 
 	assert(txn && txn->client);
 	client_ctx = txn->client;
 
 	assert(txn->nb_txn);
-	num_processed = 0;
 
 	/*
 	 * Now apply all the batches we have applied in one go.
@@ -673,9 +723,6 @@ static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
 	client_ctx->num_apply_nb_cfg++;
 	txn->nb_txn = NULL;
 
-	/*
-	 * Send back CFG_APPLY_REPLY for all batches applied.
-	 */
 	FOREACH_BE_APPLY_BATCH_IN_LIST (txn, batch) {
 		/*
 		 * No need to delete the batch yet. Will be deleted during
@@ -684,22 +731,12 @@ static int mgmt_be_txn_proc_cfgapply(struct mgmt_be_txn_ctx *txn)
 		SET_FLAG(batch->flags, MGMTD_BE_TXN_FLAGS_CFG_APPLIED);
 		mgmt_be_batches_del(&txn->apply_cfgs, batch);
 		mgmt_be_batches_add_tail(&txn->cfg_batches, batch);
-
-		batch_ids[num_processed] = batch->batch_id;
-		num_processed++;
-		if (num_processed == MGMTD_BE_MAX_BATCH_IDS_IN_REQ) {
-			mgmt_be_send_apply_reply(client_ctx, txn->txn_id,
-						    batch_ids, num_processed,
-						    true, NULL);
-			num_processed = 0;
-		}
 	}
 
-	mgmt_be_send_apply_reply(client_ctx, txn->txn_id, batch_ids,
-				    num_processed, true, NULL);
+	mgmt_be_send_apply_reply(client_ctx, txn->txn_id, true, NULL);
 
-	MGMTD_BE_CLIENT_DBG("Nb-apply-duration %lu (avg: %lu) uSec",
-			    apply_nb_cfg_tm, client_ctx->avg_apply_nb_cfg_tm);
+	debug_be_client("Nb-apply-duration %lu (avg: %lu) uSec",
+			apply_nb_cfg_tm, client_ctx->avg_apply_nb_cfg_tm);
 
 	return 0;
 }
@@ -713,7 +750,7 @@ static int mgmt_be_process_cfg_apply(struct mgmt_be_client *client_ctx,
 	if (!txn)
 		goto failed;
 
-	MGMTD_BE_CLIENT_DBG("Trigger CFG_APPLY_REQ processing");
+	debug_be_client("Trigger CFG_APPLY_REQ processing");
 	if (mgmt_be_txn_proc_cfgapply(txn))
 		goto failed;
 
@@ -736,50 +773,45 @@ static int mgmt_be_client_handle_msg(struct mgmt_be_client *client_ctx,
 	 */
 	switch ((int)be_msg->message_case) {
 	case MGMTD__BE_MESSAGE__MESSAGE_SUBSCR_REPLY:
-		MGMTD_BE_CLIENT_DBG("Got SUBSCR_REPLY success %u",
-				    be_msg->subscr_reply->success);
+		debug_be_client("Got SUBSCR_REPLY success %u",
+				be_msg->subscr_reply->success);
+
+		if (client_ctx->cbs.subscr_done)
+			(*client_ctx->cbs.subscr_done)(client_ctx,
+						       client_ctx->user_data,
+						       be_msg->subscr_reply
+							       ->success);
 		break;
 	case MGMTD__BE_MESSAGE__MESSAGE_TXN_REQ:
-		MGMTD_BE_CLIENT_DBG("Got TXN_REQ %s txn-id: %" PRIu64,
-				    be_msg->txn_req->create ? "Create"
-							    : "Delete",
-				    be_msg->txn_req->txn_id);
+		debug_be_client("Got TXN_REQ %s txn-id: %" PRIu64,
+				be_msg->txn_req->create ? "Create" : "Delete",
+				be_msg->txn_req->txn_id);
 		mgmt_be_process_txn_req(client_ctx,
 					    be_msg->txn_req->txn_id,
 					    be_msg->txn_req->create);
 		break;
 	case MGMTD__BE_MESSAGE__MESSAGE_CFG_DATA_REQ:
-		MGMTD_BE_CLIENT_DBG("Got CFG_DATA_REQ txn-id: %" PRIu64
-				    " batch-id: %" PRIu64 " end-of-data %u",
-				    be_msg->cfg_data_req->txn_id,
-				    be_msg->cfg_data_req->batch_id,
-				    be_msg->cfg_data_req->end_of_data);
+		debug_be_client("Got CFG_DATA_REQ txn-id: %" PRIu64
+				" end-of-data %u",
+				be_msg->cfg_data_req->txn_id,
+				be_msg->cfg_data_req->end_of_data);
 		mgmt_be_process_cfgdata_req(
 			client_ctx, be_msg->cfg_data_req->txn_id,
-			be_msg->cfg_data_req->batch_id,
 			be_msg->cfg_data_req->data_req,
 			be_msg->cfg_data_req->n_data_req,
 			be_msg->cfg_data_req->end_of_data);
 		break;
 	case MGMTD__BE_MESSAGE__MESSAGE_CFG_APPLY_REQ:
-		MGMTD_BE_CLIENT_DBG("Got CFG_APPLY_REQ txn-id: %" PRIu64,
-				    be_msg->cfg_data_req->txn_id);
+		debug_be_client("Got CFG_APPLY_REQ txn-id: %" PRIu64,
+				be_msg->cfg_data_req->txn_id);
 		mgmt_be_process_cfg_apply(
 			client_ctx, (uint64_t)be_msg->cfg_apply_req->txn_id);
 		break;
-	case MGMTD__BE_MESSAGE__MESSAGE_GET_REQ:
-		MGMTD_BE_CLIENT_ERR("Got unhandled message type %u",
-				    be_msg->message_case);
-		/*
-		 * TODO: Add handling code in future.
-		 */
-		break;
 	/*
 	 * NOTE: The following messages are always sent from Backend
 	 * clients to MGMTd only and/or need not be handled here.
 	 */
 	case MGMTD__BE_MESSAGE__MESSAGE_SUBSCR_REQ:
-	case MGMTD__BE_MESSAGE__MESSAGE_GET_REPLY:
 	case MGMTD__BE_MESSAGE__MESSAGE_TXN_REPLY:
 	case MGMTD__BE_MESSAGE__MESSAGE_CFG_DATA_REPLY:
 	case MGMTD__BE_MESSAGE__MESSAGE_CFG_APPLY_REPLY:
@@ -797,6 +829,167 @@ static int mgmt_be_client_handle_msg(struct mgmt_be_client *client_ctx,
 	return 0;
 }
 
+struct be_client_tree_data_batch_args {
+	struct mgmt_be_client *client;
+	uint64_t txn_id;
+	uint64_t req_id;
+	LYD_FORMAT result_type;
+};
+
+/*
+ * Process the get-tree request on our local oper state
+ */
+static enum nb_error be_client_send_tree_data_batch(const struct lyd_node *tree,
+						    void *arg, enum nb_error ret)
+{
+	struct be_client_tree_data_batch_args *args = arg;
+	struct mgmt_be_client *client = args->client;
+	struct mgmt_msg_tree_data *tree_msg = NULL;
+	bool more = false;
+	uint8_t **darrp;
+	LY_ERR err;
+
+	if (ret == NB_YIELD) {
+		more = true;
+		ret = NB_OK;
+	}
+	if (ret != NB_OK)
+		goto done;
+
+	tree_msg = mgmt_msg_native_alloc_msg(struct mgmt_msg_tree_data, 0,
+					     MTYPE_MSG_NATIVE_TREE_DATA);
+	tree_msg->refer_id = args->txn_id;
+	tree_msg->req_id = args->req_id;
+	tree_msg->code = MGMT_MSG_CODE_TREE_DATA;
+	tree_msg->result_type = args->result_type;
+	tree_msg->more = more;
+
+	darrp = mgmt_msg_native_get_darrp(tree_msg);
+	err = yang_print_tree_append(darrp, tree, args->result_type,
+				     (LYD_PRINT_SHRINK | LYD_PRINT_WD_EXPLICIT |
+				      LYD_PRINT_WITHSIBLINGS));
+	if (err) {
+		ret = NB_ERR;
+		goto done;
+	}
+	(void)be_client_send_native_msg(client, tree_msg,
+					mgmt_msg_native_get_msg_len(tree_msg),
+					false);
+done:
+	mgmt_msg_native_free_msg(tree_msg);
+	if (ret)
+		be_client_send_error(client, args->txn_id, args->req_id, false,
+				     -EINVAL,
+				     "BE client %s txn-id %" PRIu64
+				     " error fetching oper state %d",
+				     client->name, args->txn_id, ret);
+	if (ret != NB_OK || !more)
+		XFREE(MTYPE_MGMTD_BE_GT_CB_ARGS, args);
+	return ret;
+}
+
+/*
+ * Process the get-tree request on our local oper state
+ */
+static void be_client_handle_get_tree(struct mgmt_be_client *client,
+				      uint64_t txn_id, void *msgbuf,
+				      size_t msg_len)
+{
+	struct mgmt_msg_get_tree *get_tree_msg = msgbuf;
+	struct be_client_tree_data_batch_args *args;
+
+	debug_be_client("Received get-tree request for client %s txn-id %" PRIu64
+			" req-id %" PRIu64,
+			client->name, txn_id, get_tree_msg->req_id);
+
+	/* NOTE: removed the translator, if put back merge with northbound_cli
+	 * code
+	 */
+
+	args = XMALLOC(MTYPE_MGMTD_BE_GT_CB_ARGS, sizeof(*args));
+	args->client = client;
+	args->txn_id = get_tree_msg->refer_id;
+	args->req_id = get_tree_msg->req_id;
+	args->result_type = get_tree_msg->result_type;
+	nb_oper_walk(get_tree_msg->xpath, NULL, 0, true, NULL, NULL,
+		   be_client_send_tree_data_batch, args);
+}
+
+/*
+ * Process the notification.
+ */
+static void be_client_handle_notify(struct mgmt_be_client *client, void *msgbuf,
+				    size_t msg_len)
+{
+	struct mgmt_msg_notify_data *notif_msg = msgbuf;
+	struct nb_node *nb_node;
+	struct lyd_node *dnode;
+	const char *data;
+	const char *notif;
+	LY_ERR err;
+
+	debug_be_client("Received notification for client %s", client->name);
+
+	notif = mgmt_msg_native_xpath_data_decode(notif_msg, msg_len, data);
+	if (!notif || !data) {
+		log_err_be_client("Corrupt notify msg");
+		return;
+	}
+
+	nb_node = nb_node_find(notif);
+	if (!nb_node) {
+		log_err_be_client("No schema found for notification: %s", notif);
+		return;
+	}
+
+	if (!nb_node->cbs.notify) {
+		debug_be_client("No notification callback for: %s", notif);
+		return;
+	}
+
+	err = yang_parse_notification(notif, notif_msg->result_type, data,
+				      &dnode);
+	if (err) {
+		log_err_be_client("Can't parse notification data for: %s",
+				  notif);
+		return;
+	}
+
+	nb_callback_notify(nb_node, notif, dnode);
+
+	lyd_free_all(dnode);
+}
+
+/*
+ * Handle a native encoded message
+ *
+ * We don't create transactions with native messaging.
+ */
+static void be_client_handle_native_msg(struct mgmt_be_client *client,
+					struct mgmt_msg_header *msg,
+					size_t msg_len)
+{
+	uint64_t txn_id = msg->refer_id;
+
+	switch (msg->code) {
+	case MGMT_MSG_CODE_GET_TREE:
+		be_client_handle_get_tree(client, txn_id, msg, msg_len);
+		break;
+	case MGMT_MSG_CODE_NOTIFY:
+		be_client_handle_notify(client, msg, msg_len);
+		break;
+	default:
+		log_err_be_client("unknown native message txn-id %" PRIu64
+				  " req-id %" PRIu64 " code %u to client %s",
+				  txn_id, msg->req_id, msg->code, client->name);
+		be_client_send_error(client, msg->refer_id, msg->req_id, false,
+				     -1,
+				     "BE client %s recv msg unknown txn-id %" PRIu64,
+				     client->name, txn_id);
+		break;
+	}
+}
+
 static void mgmt_be_client_process_msg(uint8_t version, uint8_t *data,
 				       size_t len, struct msg_conn *conn)
 {
@@ -807,43 +1000,53 @@ static void mgmt_be_client_process_msg(uint8_t version, uint8_t *data,
 	client = container_of(conn, struct msg_client, conn);
 	client_ctx = container_of(client, struct mgmt_be_client, client);
 
+	if (version == MGMT_MSG_VERSION_NATIVE) {
+		struct mgmt_msg_header *msg = (typeof(msg))data;
+
+		if (len >= sizeof(*msg))
+			be_client_handle_native_msg(client_ctx, msg, len);
+		else
+			log_err_be_client("native message to client %s too short %zu",
+					  client_ctx->name, len);
+		return;
+	}
+
 	be_msg = mgmtd__be_message__unpack(NULL, len, data);
 	if (!be_msg) {
-		MGMTD_BE_CLIENT_DBG("Failed to decode %zu bytes from server",
-				    len);
+		debug_be_client("Failed to decode %zu bytes from server", len);
 		return;
 	}
-	MGMTD_BE_CLIENT_DBG(
-		"Decoded %zu bytes of message(msg: %u/%u) from server", len,
-		be_msg->message_case, be_msg->message_case);
+	debug_be_client("Decoded %zu bytes of message(msg: %u/%u) from server",
+			len, be_msg->message_case, be_msg->message_case);
 	(void)mgmt_be_client_handle_msg(client_ctx, be_msg);
 	mgmtd__be_message__free_unpacked(be_msg, NULL);
 }
 
 int mgmt_be_send_subscr_req(struct mgmt_be_client *client_ctx,
-			    bool subscr_xpaths, int num_xpaths,
-			    char **reg_xpaths)
+			    int n_config_xpaths, char **config_xpaths,
+			    int n_oper_xpaths, char **oper_xpaths)
 {
 	Mgmtd__BeMessage be_msg;
 	Mgmtd__BeSubscribeReq subscr_req;
 
 	mgmtd__be_subscribe_req__init(&subscr_req);
 	subscr_req.client_name = client_ctx->name;
-	subscr_req.n_xpath_reg = num_xpaths;
-	if (num_xpaths)
-		subscr_req.xpath_reg = reg_xpaths;
-	else
-		subscr_req.xpath_reg = NULL;
-	subscr_req.subscribe_xpaths = subscr_xpaths;
+	subscr_req.n_config_xpaths = n_config_xpaths;
+	subscr_req.config_xpaths = config_xpaths;
+	subscr_req.n_oper_xpaths = n_oper_xpaths;
+	subscr_req.oper_xpaths = oper_xpaths;
+
+	/* See if we should register for notifications */
+	subscr_req.n_notif_xpaths = client_ctx->cbs.nnotif_xpaths;
+	subscr_req.notif_xpaths = (char **)client_ctx->cbs.notif_xpaths;
 
 	mgmtd__be_message__init(&be_msg);
 	be_msg.message_case = MGMTD__BE_MESSAGE__MESSAGE_SUBSCR_REQ;
 	be_msg.subscr_req = &subscr_req;
 
-	MGMTD_FE_CLIENT_DBG(
-		"Sending SUBSCR_REQ name: %s subscr_xpaths: %u num_xpaths: %zu",
-		subscr_req.client_name, subscr_req.subscribe_xpaths,
-		subscr_req.n_xpath_reg);
+	debug_be_client("Sending SUBSCR_REQ name: %s xpaths: config %zu oper: %zu notif: %zu",
+			subscr_req.client_name, subscr_req.n_config_xpaths,
+			subscr_req.n_oper_xpaths, subscr_req.n_notif_xpaths);
 
 	return mgmt_be_client_send_msg(client_ctx, &be_msg);
 }
@@ -857,15 +1060,16 @@ static int _notify_conenct_disconnect(struct msg_client *msg_client,
 
 	if (connected) {
 		assert(msg_client->conn.fd != -1);
-		ret = mgmt_be_send_subscr_req(client, false, 0, NULL);
+		ret = mgmt_be_send_subscr_req(client, 0, NULL, 0, NULL);
 		if (ret)
 			return ret;
 	}
 
 	/* Notify BE client through registered callback (if any) */
 	if (client->cbs.client_connect_notify)
-		(void)(*client->cbs.client_connect_notify)(
-			client, client->user_data, connected);
+		(void)(*client->cbs.client_connect_notify)(client,
+							   client->user_data,
+							   connected);
 
 	/* Cleanup any in-progress TXN on disconnect */
 	if (!connected)
@@ -890,44 +1094,48 @@ static int mgmt_be_client_notify_disconenct(struct msg_conn *conn)
  * Debug Flags
  */
 
-DEFPY(debug_mgmt_client_be, debug_mgmt_client_be_cmd,
-      "[no] debug mgmt client backend",
-      NO_STR DEBUG_STR MGMTD_STR
-      "client\n"
-      "backend\n")
+static void mgmt_debug_client_be_set(uint32_t flags, bool set)
 {
-	uint32_t mode = DEBUG_NODE2MODE(vty->node);
+	DEBUG_FLAGS_SET(&mgmt_dbg_be_client, flags, set);
 
-	DEBUG_MODE_SET(&mgmt_dbg_be_client, mode, !no);
+	if (!__be_client)
+		return;
 
-	return CMD_SUCCESS;
+	__be_client->client.conn.debug = DEBUG_MODE_CHECK(&mgmt_dbg_be_client,
+							  DEBUG_MODE_ALL);
 }
 
-static void mgmt_debug_client_be_set_all(uint32_t flags, bool set)
+DEFPY(debug_mgmt_client_be, debug_mgmt_client_be_cmd,
+      "[no] debug mgmt client backend",
+      NO_STR DEBUG_STR MGMTD_STR "client\n"
+				 "backend\n")
 {
-	DEBUG_FLAGS_SET(&mgmt_dbg_be_client, flags, set);
+	mgmt_debug_client_be_set(DEBUG_NODE2MODE(vty->node), !no);
+
+	return CMD_SUCCESS;
 }
 
 static int mgmt_debug_be_client_config_write(struct vty *vty)
 {
 	if (DEBUG_MODE_CHECK(&mgmt_dbg_be_client, DEBUG_MODE_CONF))
-		vty_out(vty, "debug mgmt client frontend\n");
+		vty_out(vty, "debug mgmt client backend\n");
 
 	return 1;
 }
 
 void mgmt_debug_be_client_show_debug(struct vty *vty)
 {
-	if (MGMTD_DBG_BE_CLIENT_CHECK())
+	if (debug_check_be_client())
 		vty_out(vty, "debug mgmt client backend\n");
 }
 
 static struct debug_callbacks mgmt_dbg_be_client_cbs = {
-	.debug_set_all = mgmt_debug_client_be_set_all};
+	.debug_set_all = mgmt_debug_client_be_set
+};
 
 static struct cmd_node mgmt_dbg_node = {
-	.name = "mgmt backend client",
-	.node = DEBUG_NODE,
+	.name = "debug mgmt client backend",
+	.node = MGMT_BE_DEBUG_NODE,
 	.prompt = "",
 	.config_write = mgmt_debug_be_client_config_write,
 };
@@ -937,26 +1145,39 @@ struct mgmt_be_client *mgmt_be_client_create(const char *client_name,
 					     uintptr_t user_data,
 					     struct event_loop *event_loop)
 {
-	struct mgmt_be_client *client =
-		XCALLOC(MTYPE_MGMTD_BE_CLIENT, sizeof(*client));
+	struct mgmt_be_client *client;
+	char server_path[MAXPATHLEN];
+
+	if (__be_client)
+		return NULL;
+
+	client = XCALLOC(MTYPE_MGMTD_BE_CLIENT, sizeof(*client));
+	__be_client = client;
 
 	/* Only call after frr_init() */
 	assert(running_config);
 
 	client->name = XSTRDUP(MTYPE_MGMTD_BE_CLIENT_NAME, client_name);
 	client->running_config = running_config;
-	client->candidate_config = nb_config_new(NULL);
+	client->candidate_config = vty_shared_candidate_config;
 	if (cbs)
 		client->cbs = *cbs;
 	mgmt_be_txns_init(&client->txn_head);
-	msg_client_init(&client->client, event_loop, MGMTD_BE_SERVER_PATH,
+
+	snprintf(server_path, sizeof(server_path), MGMTD_BE_SOCK_NAME);
+
+	msg_client_init(&client->client, event_loop, server_path,
 			mgmt_be_client_notify_conenct,
 			mgmt_be_client_notify_disconenct,
 			mgmt_be_client_process_msg, MGMTD_BE_MAX_NUM_MSG_PROC,
-			MGMTD_BE_MAX_NUM_MSG_WRITE, MGMTD_BE_MSG_MAX_LEN, false,
-			"BE-client", MGMTD_DBG_BE_CLIENT_CHECK());
+			MGMTD_BE_MAX_NUM_MSG_WRITE, MGMTD_BE_MAX_MSG_LEN, false,
+			"BE-client", debug_check_be_client());
+
+	/* Hook to receive notifications */
+	hook_register_arg(nb_notification_tree_send, mgmt_be_send_notification,
+			  client);
 
-	MGMTD_BE_CLIENT_DBG("Initialized client '%s'", client_name);
+	debug_be_client("Initialized client '%s'", client_name);
 
 	return client;
 }
@@ -972,14 +1193,17 @@ void mgmt_be_client_lib_vty_init(void)
 
 void mgmt_be_client_destroy(struct mgmt_be_client *client)
 {
-	MGMTD_BE_CLIENT_DBG("Destroying MGMTD Backend Client '%s'",
-			    client->name);
+	assert(client == __be_client);
 
+	debug_be_client("Destroying MGMTD Backend Client '%s'", client->name);
+
+	nb_oper_cancel_all_walks();
 	msg_client_cleanup(&client->client);
 	mgmt_be_cleanup_all_txns(client);
 	mgmt_be_txns_fini(&client->txn_head);
-	nb_config_free(client->candidate_config);
 
 	XFREE(MTYPE_MGMTD_BE_CLIENT_NAME, client->name);
 	XFREE(MTYPE_MGMTD_BE_CLIENT, client);
+
+	__be_client = NULL;
 }