Merge pull request #20208 from LabNConsulting/chopps/rpc-restconf-format

Handle RESTCONF RPC/Action input format

Author: donaldsharp

lib/mgmt_be_client.c

@@ -837,16 +837,10 @@ static void be_client_handle_rpc(struct mgmt_be_client *client, uint64_t txn_id,
 		return;
 	}
 
-	if (data) {
-		err = yang_parse_rpc(xpath, rpc_msg->request_type, data, false,
-				     &input);
-		if (err) {
-			be_client_send_error(client, txn_id, rpc_msg->req_id,
-					     false, -EINVAL,
-					     "Can't parse RPC data for: %s",
-					     xpath);
-			return;
-		}
+	if (data && rpc_msg->restconf) {
+		err = yang_parse_restconf_rpc(xpath, rpc_msg->request_type, data, false, &input);
+	} else if (data) {
+		err = yang_parse_rpc(xpath, rpc_msg->request_type, data, false, &input);
 	} else {
 		/*
 		 * If there's no input data, create an empty input container.
@@ -855,13 +849,11 @@ static void be_client_handle_rpc(struct mgmt_be_client *client, uint64_t txn_id,
 		 */
 		err = lyd_new_path2(NULL, ly_native_ctx, xpath, NULL, 0, 0, 0,
 				    NULL, &input);
-		if (err) {
-			be_client_send_error(client, txn_id, rpc_msg->req_id,
-					     false, -EINVAL,
-					     "Can't create input node for RPC: %s",
-					     xpath);
-			return;
-		}
+	}
+	if (err) {
+		be_client_send_error(client, txn_id, rpc_msg->req_id, false, -EINVAL,
+				     "Can't parse RPC data for: %s", xpath);
+		return;
 	}
 
 	err = lyd_new_path2(NULL, ly_native_ctx, xpath, NULL, 0, 0, 0, NULL,

lib/mgmt_msg_native.h

@@ -448,30 +448,34 @@ _Static_assert(sizeof(struct mgmt_msg_edit_reply) ==
  * struct mgmt_msg_rpc - RPC/action request.
  *
  * @request_type: ``LYD_FORMAT`` for the @data.
+ * @restconf: If true the and tree data is present it is in RESTCONF format
+ * (i.e., the topmost node is `input`)
  * @data: the xpath followed by the tree data for the operation.
  */
 struct mgmt_msg_rpc {
 	struct mgmt_msg_header;
 	uint8_t request_type;
-	uint8_t resv2[7];
+	uint8_t restconf;
+	uint8_t resv2[6];
 
 	alignas(8) char data[];
 };
 
-_Static_assert(sizeof(struct mgmt_msg_rpc) ==
-		       offsetof(struct mgmt_msg_rpc, data),
-	       "Size mismatch");
+_Static_assert(sizeof(struct mgmt_msg_rpc) == offsetof(struct mgmt_msg_rpc, data), "Size mismatch");
 
 /**
  * struct mgmt_msg_rpc_reply - RPC/action reply.
  *
  * @result_type: ``LYD_FORMAT`` for the @data.
+ * @restconf: If true the and tree data is present it is in RESTCONF format
+ * (i.e., the topmost node is `output`)
  * @data: the tree data for the reply.
  */
 struct mgmt_msg_rpc_reply {
 	struct mgmt_msg_header;
 	uint8_t result_type;
-	uint8_t resv2[7];
+	uint8_t restconf;
+	uint8_t resv2[6];
 
 	alignas(8) char data[];
 };

lib/yang.c

@@ -979,8 +979,56 @@ LY_ERR yang_parse_notification(const char *xpath, LYD_FORMAT format,
 	return LY_SUCCESS;
 }
 
-LY_ERR yang_parse_rpc(const char *xpath, LYD_FORMAT format, const char *data,
-		      bool reply, struct lyd_node **rpc)
+LY_ERR yang_parse_restconf_rpc(const char *xpath, LYD_FORMAT format, const char *data, bool reply,
+			       struct lyd_node **rpc)
+{
+	const struct lysc_node *snode;
+	struct lyd_node *dnode = NULL;
+	struct ly_in *in = NULL;
+	LY_ERR err;
+
+	snode = lys_find_path(ly_native_ctx, NULL, xpath, 0);
+	if (!snode) {
+		zlog_err("Failed to find RPC/action schema node: %s", xpath);
+		return LY_ENOTFOUND;
+	}
+	if (snode->nodetype != LYS_RPC && snode->nodetype != LYS_ACTION) {
+		zlog_err("Node '%s' is not an RPC/action", xpath);
+		return LY_ENOTFOUND;
+	}
+	/* Get the tree for the RPC/Action */
+	err = lyd_new_path2(NULL, ly_native_ctx, xpath, NULL, 0, 0, 0, NULL, &dnode);
+	if (err) {
+		zlog_err("Failed to create parent node for action: %s", ly_last_errmsg());
+		goto done;
+	}
+
+	if (!data)
+		goto done;
+
+	err = ly_in_new_memory(data, &in);
+	if (err) {
+		zlog_err("Failed to initialize ly_in: %s", ly_last_errmsg());
+		goto done;
+	}
+
+	err = lyd_parse_op(ly_native_ctx, dnode, in, format,
+			   reply ? LYD_TYPE_REPLY_RESTCONF : LYD_TYPE_RPC_RESTCONF, NULL, NULL);
+	ly_in_free(in, 0);
+	if (err) {
+		zlog_err("Failed to parse RPC/action: %s", ly_last_errmsg());
+		goto done;
+	}
+done:
+	if (err)
+		lyd_free_all(dnode);
+	else
+		*rpc = dnode;
+	return err;
+}
+
+LY_ERR yang_parse_rpc(const char *xpath, LYD_FORMAT format, const char *data, bool reply,
+		      struct lyd_node **rpc)
 {
 	const struct lysc_node *snode;
 	struct lyd_node *parent = NULL;

lib/yang.h

@@ -736,6 +736,8 @@ extern LY_ERR yang_parse_notification(const char *xpath, LYD_FORMAT format,
  */
 LY_ERR yang_parse_rpc(const char *xpath, LYD_FORMAT format, const char *data,
 		      bool reply, struct lyd_node **rpc);
+LY_ERR yang_parse_restconf_rpc(const char *xpath, LYD_FORMAT format, const char *data, bool reply,
+			       struct lyd_node **rpc);
 
 /*
  * "Print" the yang tree in `root` into dynamic sized array.
@@ -748,8 +750,7 @@ LY_ERR yang_parse_rpc(const char *xpath, LYD_FORMAT format, const char *data,
  * Return:
  *	A darr dynamic array with the "printed" output or NULL on failure.
  */
-extern uint8_t *yang_print_tree(const struct lyd_node *root, LYD_FORMAT format,
-				uint32_t options);
+extern uint8_t *yang_print_tree(const struct lyd_node *root, LYD_FORMAT format, uint32_t options);
 
 
 /**

mgmtd/mgmt_fe_adapter.c

@@ -842,10 +842,16 @@ static void fe_session_handle_get_data(struct mgmt_fe_session_ctx *session, void
 					      "Error getting yang-library data, session-id: %" PRIu64
 					      " error: %s",
 					      session->session_id, ly_last_errmsg());
+			goto done;
 		} else if (nb_oper_is_yang_lib_query(msg->xpath)) {
+			struct lyd_node *result;
+
 			yang_lyd_trim_xpath(&ylib, msg->xpath);
+			result = ylib;
+			if (CHECK_FLAG(msg->flags, GET_DATA_FLAG_EXACT))
+				result = yang_dnode_get(result, msg->xpath);
 			(void)fe_session_send_tree_data(session, req_id, false, msg->result_type,
-							wd_options, ylib, 0);
+							wd_options, result, 0);
 			goto done;
 		}
 	}
@@ -1241,7 +1247,8 @@ static void fe_session_handle_notify_select(struct mgmt_fe_session_ctx *session,
 /* ----------- */
 
 static int fe_session_send_rpc_reply(struct mgmt_fe_session_ctx *session, uint64_t req_id,
-				     uint8_t result_type, const struct lyd_node *result)
+				     uint8_t result_type, bool restconf,
+				     const struct lyd_node *result)
 {
 	struct mgmt_msg_rpc_reply *msg;
 	uint8_t **darrp = NULL;
@@ -1252,6 +1259,7 @@ static int fe_session_send_rpc_reply(struct mgmt_fe_session_ctx *session, uint64
 	msg->req_id = req_id;
 	msg->code = MGMT_MSG_CODE_RPC_REPLY;
 	msg->result_type = result_type;
+	msg->restconf = restconf;
 
 	if (result) {
 		darrp = mgmt_msg_native_get_darrp(msg);
@@ -1276,7 +1284,8 @@ static int fe_session_send_rpc_reply(struct mgmt_fe_session_ctx *session, uint64
 }
 
 void mgmt_fe_adapter_send_rpc_reply(uint64_t session_id, uint64_t txn_id, uint64_t req_id,
-				    LYD_FORMAT result_type, const struct lyd_node *result)
+				    LYD_FORMAT result_type, bool restconf,
+				    const struct lyd_node *result)
 {
 	struct mgmt_fe_session_ctx *session;
 
@@ -1287,7 +1296,7 @@ void mgmt_fe_adapter_send_rpc_reply(uint64_t session_id, uint64_t txn_id, uint64
 	/* XXXchopps why do we care about this? Why not allow multple? */
 	assert(session->txn_id == txn_id);
 
-	if (fe_session_send_rpc_reply(session, req_id, result_type, result))
+	if (fe_session_send_rpc_reply(session, req_id, result_type, restconf, result))
 		fe_session_send_error(session, req_id, false, -EIO, "Failed sending RPC reply");
 
 	mgmt_destroy_txn(&session->txn_id);
@@ -1354,8 +1363,8 @@ static void fe_session_handle_rpc(struct mgmt_fe_session_ctx *session, void *_ms
 	     session->session_id);
 
 	/* Create an RPC request under the transaction */
-	mgmt_txn_send_rpc(session->txn_id, req_id, clients, msg->request_type, xpath, data,
-			  mgmt_msg_native_data_len_decode(msg, msg_len));
+	mgmt_txn_send_rpc(session->txn_id, req_id, clients, msg->request_type, msg->restconf,
+			  xpath, data, mgmt_msg_native_data_len_decode(msg, msg_len));
 }
 
 /* -------------------- */

mgmtd/mgmt_fe_adapter.h

@@ -87,10 +87,12 @@ extern void mgmt_fe_adapter_send_tree_data(uint64_t session_id, uint64_t txn_id,
  *	txn_id: the txn_id this data pertains to
  *	req_id: the req id for the rpc message
  *	result_type: the format of the result data.
+ *	restconf: true if the RPC is formatted from RESTCONF operation.
  *	result: the results.
  */
 extern void mgmt_fe_adapter_send_rpc_reply(uint64_t session_id, uint64_t txn_id, uint64_t req_id,
-					   LYD_FORMAT result_type, const struct lyd_node *result);
+					   LYD_FORMAT result_type, bool restconf,
+					   const struct lyd_node *result);
 
 /**
  * Send edit reply back to client. If error is not 0, a native error is sent.

mgmtd/mgmt_txn.c

@@ -45,6 +45,7 @@ struct txn_req_rpc {
 	uint64_t clients;      /* Bitmask of clients sent req to */
 	uint64_t clients_wait; /* Bitmask of clients waiting for reply from */
 	uint8_t result_type;   /* LYD_FORMAT for results */
+	uint8_t restconf;      /* if restconf formatted data */
 	struct lyd_node *client_results; /* result tree from clients */
 };
 #define as_rpc(txn_req)                                                                           \
@@ -433,7 +434,8 @@ static void txn_rpc_done(struct txn_req_rpc *rpc)
 					  txn_req->err_info);
 	else
 		mgmt_fe_adapter_send_rpc_reply(txn->session_id, txn->txn_id, req_id,
-					       rpc->result_type, rpc->client_results);
+					       rpc->result_type, rpc->restconf,
+					       rpc->client_results);
 
 	/* we're done with the request */
 	txn_req_free(txn_req);
@@ -521,7 +523,7 @@ void mgmt_txn_handle_rpc_reply(struct mgmt_be_client_adapter *adapter,
 }
 
 void mgmt_txn_send_rpc(uint64_t txn_id, uint64_t req_id, uint64_t clients, LYD_FORMAT result_type,
-		       const char *xpath, const char *data, size_t data_len)
+		       bool restconf, const char *xpath, const char *data, size_t data_len)
 {
 	struct mgmt_be_client_adapter *adapter;
 	struct mgmt_txn *txn;
@@ -536,13 +538,15 @@ void mgmt_txn_send_rpc(uint64_t txn_id, uint64_t req_id, uint64_t clients, LYD_F
 	rpc = txn_req_rpc_alloc(txn, req_id);
 	rpc->xpath = XSTRDUP(MTYPE_MGMTD_XPATH, xpath);
 	rpc->result_type = result_type;
+	rpc->restconf = restconf;
 
 	msg = mgmt_msg_native_alloc_msg(struct mgmt_msg_rpc, 0,
 					MTYPE_MSG_NATIVE_RPC);
 	msg->refer_id = txn_id;
 	msg->req_id = req_id;
 	msg->code = MGMT_MSG_CODE_RPC;
 	msg->request_type = result_type;
+	msg->restconf = restconf;
 
 	mgmt_msg_native_xpath_encode(msg, xpath);
 	if (data)

mgmtd/mgmt_txn.h

@@ -145,13 +145,14 @@ extern int mgmt_txn_send_get_tree(uint64_t txn_id, uint64_t req_id, uint64_t cli
  * @req_id: FE client request identifier.
  * @clients: Bitmask of clients to send RPC to.
  * @result_type: LYD_FORMAT result format.
+ * @restconf: true if the RPC is formatted from RESTCONF operation.
  * @xpath: The xpath of the RPC.
  * @data: The input parameters data tree.
  * @data_len: The length of the input parameters data.
  */
 extern void mgmt_txn_send_rpc(uint64_t txn_id, uint64_t req_id, uint64_t clients,
-			      LYD_FORMAT result_type, const char *xpath, const char *data,
-			      size_t data_len);
+			      LYD_FORMAT result_type, bool restconf, const char *xpath,
+			      const char *data, size_t data_len);
 
 /**
  * mgmt_txn_send_notify_selectors() - Send NOTIFY SELECT request.