Adding upstream version 2:4.20.0+dfsg.upstream/2%4.20.0+dfsg

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

1 files changed, 2352 insertions, 0 deletions

diff --git a/ctdb/protocol/protocol_client.c b/ctdb/protocol/protocol_client.c
new file mode 100644
index 0000000..9ca2d4e
--- /dev/null
+++ b/ctdb/protocol/protocol_client.c
@@ -0,0 +1,2352 @@
+/*
+   CTDB protocol marshalling
+
+   Copyright (C) Amitay Isaacs  2015
+
+   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 3 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; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "replace.h"
+#include "system/network.h"
+
+#include <talloc.h>
+#include <tdb.h>
+
+#include "protocol.h"
+#include "protocol_api.h"
+#include "protocol_private.h"
+
+/*
+void ctdb_req_call_fill(struct ctdb_req_call *c,
+			uint32_t db_id, uint32_t flags,
+			uint32_t call_id, TDB_DATA key)
+{
+	request->flags = flags;
+	c->db_id = db_id;
+	c->call_id = call_id;
+	c->key = key;
+	c->calldata = tdb_null;
+}
+*/
+
+static int ctdb_reply_control_generic(struct ctdb_reply_control *reply,
+				      uint32_t opcode)
+{
+	if (reply->rdata.opcode != opcode) {
+		return EPROTO;
+	}
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_PROCESS_EXISTS */
+
+void ctdb_req_control_process_exists(struct ctdb_req_control *request,
+				     pid_t pid)
+{
+	request->opcode = CTDB_CONTROL_PROCESS_EXISTS;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_PROCESS_EXISTS;
+	request->rdata.data.pid = pid;
+
+}
+
+int ctdb_reply_control_process_exists(struct ctdb_reply_control *reply,
+				      int *status)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_PROCESS_EXISTS) {
+		return EPROTO;
+	}
+
+	*status = reply->status;
+	reply->status = 0;
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_STATISTICS */
+
+void ctdb_req_control_statistics(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_STATISTICS;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_STATISTICS;
+}
+
+int ctdb_reply_control_statistics(struct ctdb_reply_control *reply,
+				  TALLOC_CTX *mem_ctx,
+				  struct ctdb_statistics **stats)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_STATISTICS) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*stats = talloc_steal(mem_ctx, reply->rdata.data.stats);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_PING */
+
+void ctdb_req_control_ping(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_PING;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_PING;
+}
+
+int ctdb_reply_control_ping(struct ctdb_reply_control *reply,
+			    int *num_clients)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_PING) {
+		return EPROTO;
+	}
+
+	if (reply->status >= 0) {
+		*num_clients = reply->status;
+		reply->status = 0;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_GETDBPATH */
+
+void ctdb_req_control_getdbpath(struct ctdb_req_control *request,
+				uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_GETDBPATH;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GETDBPATH;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_getdbpath(struct ctdb_reply_control *reply,
+				 TALLOC_CTX *mem_ctx, const char **db_path)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GETDBPATH) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*db_path = talloc_steal(mem_ctx, reply->rdata.data.db_path);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_GETVNNMAP */
+
+void ctdb_req_control_getvnnmap(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GETVNNMAP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GETVNNMAP;
+}
+
+int ctdb_reply_control_getvnnmap(struct ctdb_reply_control *reply,
+				 TALLOC_CTX *mem_ctx,
+				 struct ctdb_vnn_map **vnnmap)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GETVNNMAP) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*vnnmap = talloc_steal(mem_ctx, reply->rdata.data.vnnmap);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_SETVNNMAP */
+
+void ctdb_req_control_setvnnmap(struct ctdb_req_control *request,
+				struct ctdb_vnn_map *vnnmap)
+{
+	request->opcode = CTDB_CONTROL_SETVNNMAP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SETVNNMAP;
+	request->rdata.data.vnnmap = vnnmap;
+}
+
+int ctdb_reply_control_setvnnmap(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SETVNNMAP);
+}
+
+/* CTDB_CONTROL_GET_DEBUG */
+
+void ctdb_req_control_get_debug(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_DEBUG;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_DEBUG;
+}
+
+int ctdb_reply_control_get_debug(struct ctdb_reply_control *reply,
+				 int *loglevel)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_DEBUG) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*loglevel = (int)reply->rdata.data.loglevel;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_SET_DEBUG */
+
+void ctdb_req_control_set_debug(struct ctdb_req_control *request,
+				int loglevel)
+{
+	request->opcode = CTDB_CONTROL_SET_DEBUG;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_DEBUG;
+	request->rdata.data.loglevel = (uint32_t)loglevel;
+}
+
+int ctdb_reply_control_set_debug(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DEBUG);
+}
+
+/* CTDB_CONTROL_GET_DBMAP */
+
+void ctdb_req_control_get_dbmap(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_DBMAP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_DBMAP;
+}
+
+int ctdb_reply_control_get_dbmap(struct ctdb_reply_control *reply,
+				 TALLOC_CTX *mem_ctx,
+				 struct ctdb_dbid_map **dbmap)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_DBMAP) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*dbmap = talloc_steal(mem_ctx, reply->rdata.data.dbmap);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_GET_RECMODE */
+
+void ctdb_req_control_get_recmode(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_RECMODE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_RECMODE;
+}
+
+int ctdb_reply_control_get_recmode(struct ctdb_reply_control *reply,
+				   int *recmode)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_RECMODE) {
+		return EPROTO;
+	}
+
+	if (reply->status >= 0) {
+		*recmode = reply->status;
+		reply->status = 0;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_SET_RECMODE */
+
+void ctdb_req_control_set_recmode(struct ctdb_req_control *request,
+				  int recmode)
+{
+	request->opcode = CTDB_CONTROL_SET_RECMODE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_RECMODE;
+	request->rdata.data.recmode = recmode;
+}
+
+int ctdb_reply_control_set_recmode(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_RECMODE);
+}
+
+/* CTDB_CONTROL_STATISTICS_RESET */
+
+void ctdb_req_control_statistics_reset(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_STATISTICS_RESET;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_STATISTICS_RESET;
+}
+
+int ctdb_reply_control_statistics_reset(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_STATISTICS_RESET);
+}
+
+/* CTDB_CONTROL_DB_ATTACH */
+
+void ctdb_req_control_db_attach(struct ctdb_req_control *request,
+				const char *db_name)
+{
+	request->opcode = CTDB_CONTROL_DB_ATTACH;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_ATTACH;
+	request->rdata.data.db_name = db_name;
+}
+
+int ctdb_reply_control_db_attach(struct ctdb_reply_control *reply,
+				 uint32_t *db_id)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*db_id = reply->rdata.data.db_id;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_TRAVERSE_START */
+
+void ctdb_req_control_traverse_start(struct ctdb_req_control *request,
+				     struct ctdb_traverse_start *traverse)
+{
+	request->opcode = CTDB_CONTROL_TRAVERSE_START;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TRAVERSE_START;
+	request->rdata.data.traverse_start = traverse;
+}
+
+int ctdb_reply_control_traverse_start(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRAVERSE_START);
+}
+
+/* CTDB_CONTROL_TRAVERSE_ALL */
+/* CTDB_CONTROL_TRAVERSE_DATA */
+
+/* CTDB_CONTROL_REGISTER_SRVID */
+
+void ctdb_req_control_register_srvid(struct ctdb_req_control *request,
+				     uint64_t srvid)
+{
+	request->opcode = CTDB_CONTROL_REGISTER_SRVID;
+	request->pad = 0;
+	request->srvid = srvid;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_REGISTER_SRVID;
+}
+
+int ctdb_reply_control_register_srvid(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_REGISTER_SRVID);
+}
+
+/* CTDB_CONTROL_DEREGISTER_SRVID */
+
+void ctdb_req_control_deregister_srvid(struct ctdb_req_control *request,
+				       uint64_t srvid)
+{
+	request->opcode = CTDB_CONTROL_DEREGISTER_SRVID;
+	request->pad = 0;
+	request->srvid = srvid;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DEREGISTER_SRVID;
+}
+
+int ctdb_reply_control_deregister_srvid(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_DEREGISTER_SRVID);
+}
+
+/* CTDB_CONTROL_GET_DBNAME */
+
+void ctdb_req_control_get_dbname(struct ctdb_req_control *request,
+				 uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_GET_DBNAME;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_DBNAME;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_get_dbname(struct ctdb_reply_control *reply,
+				  TALLOC_CTX *mem_ctx, const char **db_name)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_DBNAME) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*db_name = talloc_steal(mem_ctx, reply->rdata.data.db_name);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_ENABLE_SEQNUM */
+
+void ctdb_req_control_enable_seqnum(struct ctdb_req_control *request,
+				    uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_ENABLE_SEQNUM;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_ENABLE_SEQNUM;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_enable_seqnum(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_ENABLE_SEQNUM);
+}
+
+/* CTDB_CONTROL_UPDATE_SEQNUM */
+
+void ctdb_req_control_update_seqnum(struct ctdb_req_control *request,
+				    uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_UPDATE_SEQNUM;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_UPDATE_SEQNUM;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_update_seqnum(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_UPDATE_SEQNUM);
+}
+
+/* CTDB_CONTROL_DUMP_MEMORY */
+
+void ctdb_req_control_dump_memory(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_DUMP_MEMORY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DUMP_MEMORY;
+}
+
+int ctdb_reply_control_dump_memory(struct ctdb_reply_control *reply,
+				   TALLOC_CTX *mem_ctx, const char **mem_str)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DUMP_MEMORY) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*mem_str = talloc_steal(mem_ctx, reply->rdata.data.mem_str);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_GET_PID */
+
+void ctdb_req_control_get_pid(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_PID;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_PID;
+}
+
+int ctdb_reply_control_get_pid(struct ctdb_reply_control *reply,
+			       pid_t *pid)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_PID) {
+		return EPROTO;
+	}
+
+	*pid = reply->status;
+	reply->status = 0;
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_FREEZE */
+
+void ctdb_req_control_freeze(struct ctdb_req_control *request,
+			     uint32_t priority)
+{
+	request->opcode = CTDB_CONTROL_FREEZE;
+	request->pad = 0;
+	request->srvid = priority;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_FREEZE;
+}
+
+int ctdb_reply_control_freeze(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_FREEZE);
+}
+
+/* CTDB_CONTROL_GET_PNN */
+
+void ctdb_req_control_get_pnn(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_PNN;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_PNN;
+}
+
+int ctdb_reply_control_get_pnn(struct ctdb_reply_control *reply,
+			       uint32_t *pnn)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_PNN) {
+		return EPROTO;
+	}
+
+	if (reply->status >= 0) {
+		*pnn = reply->status;
+		reply->status = 0;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_SHUTDOWN */
+
+void ctdb_req_control_shutdown(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_SHUTDOWN;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = CTDB_CTRL_FLAG_NOREPLY;
+
+	request->rdata.opcode = CTDB_CONTROL_SHUTDOWN;
+}
+
+int ctdb_reply_control_shutdown(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SHUTDOWN);
+}
+
+/* CTDB_CONTROL_TCP_CLIENT */
+
+void ctdb_req_control_tcp_client(struct ctdb_req_control *request,
+				 struct ctdb_connection *conn)
+{
+	request->opcode = CTDB_CONTROL_TCP_CLIENT;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TCP_CLIENT;
+	request->rdata.data.conn = conn;
+}
+
+int ctdb_reply_control_tcp_client(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_CLIENT);
+}
+
+/* CTDB_CONTROL_TCP_ADD */
+
+void ctdb_req_control_tcp_add(struct ctdb_req_control *request,
+			      struct ctdb_connection *conn)
+{
+	request->opcode = CTDB_CONTROL_TCP_ADD;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TCP_ADD;
+	request->rdata.data.conn = conn;
+}
+
+int ctdb_reply_control_tcp_add(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_ADD);
+}
+
+/* CTDB_CONTROL_TCP_REMOVE */
+
+void ctdb_req_control_tcp_remove(struct ctdb_req_control *request,
+				 struct ctdb_connection *conn)
+{
+	request->opcode = CTDB_CONTROL_TCP_REMOVE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TCP_REMOVE;
+	request->rdata.data.conn = conn;
+}
+
+int ctdb_reply_control_tcp_remove(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_REMOVE);
+}
+
+/* CTDB_CONTROL_STARTUP */
+
+void ctdb_req_control_startup(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_STARTUP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_STARTUP;
+}
+
+int ctdb_reply_control_startup(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_STARTUP);
+}
+
+/* CTDB_CONTROL_SET_TUNABLE */
+
+void ctdb_req_control_set_tunable(struct ctdb_req_control *request,
+				  struct ctdb_tunable *tunable)
+{
+	request->opcode = CTDB_CONTROL_SET_TUNABLE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_TUNABLE;
+	request->rdata.data.tunable = tunable;
+}
+
+int ctdb_reply_control_set_tunable(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_TUNABLE);
+}
+
+/* CTDB_CONTROL_GET_TUNABLE */
+
+void ctdb_req_control_get_tunable(struct ctdb_req_control *request,
+				  const char *name)
+{
+	request->opcode = CTDB_CONTROL_GET_TUNABLE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_TUNABLE;
+	request->rdata.data.tun_var = discard_const(name);
+}
+
+int ctdb_reply_control_get_tunable(struct ctdb_reply_control *reply,
+				   uint32_t *value)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_TUNABLE) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*value = reply->rdata.data.tun_value;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_LIST_TUNABLES */
+
+void ctdb_req_control_list_tunables(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_LIST_TUNABLES;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_LIST_TUNABLES;
+}
+
+int ctdb_reply_control_list_tunables(struct ctdb_reply_control *reply,
+				     TALLOC_CTX *mem_ctx,
+				     struct ctdb_var_list **tun_var_list)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_LIST_TUNABLES) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*tun_var_list = talloc_steal(mem_ctx,
+					     reply->rdata.data.tun_var_list);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_MODIFY_FLAGS */
+
+void ctdb_req_control_modify_flags(struct ctdb_req_control *request,
+				   struct ctdb_node_flag_change *flag_change)
+{
+	request->opcode = CTDB_CONTROL_MODIFY_FLAGS;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_MODIFY_FLAGS;
+	request->rdata.data.flag_change = flag_change;
+}
+
+int ctdb_reply_control_modify_flags(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_MODIFY_FLAGS);
+}
+
+/* CTDB_CONTROL_GET_ALL_TUNABLES */
+
+void ctdb_req_control_get_all_tunables(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_ALL_TUNABLES;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_ALL_TUNABLES;
+}
+
+int ctdb_reply_control_get_all_tunables(struct ctdb_reply_control *reply,
+					TALLOC_CTX *mem_ctx,
+					struct ctdb_tunable_list **tun_list)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_ALL_TUNABLES) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*tun_list = talloc_steal(mem_ctx, reply->rdata.data.tun_list);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_GET_TCP_TICKLE_LIST */
+
+void ctdb_req_control_get_tcp_tickle_list(struct ctdb_req_control *request,
+					  ctdb_sock_addr *addr)
+{
+	request->opcode = CTDB_CONTROL_GET_TCP_TICKLE_LIST;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_TCP_TICKLE_LIST;
+	request->rdata.data.addr = addr;
+}
+
+int ctdb_reply_control_get_tcp_tickle_list(struct ctdb_reply_control *reply,
+					   TALLOC_CTX *mem_ctx,
+					   struct ctdb_tickle_list **tickles)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_TCP_TICKLE_LIST) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*tickles = talloc_steal(mem_ctx, reply->rdata.data.tickles);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_SET_TCP_TICKLE_LIST */
+
+void ctdb_req_control_set_tcp_tickle_list(struct ctdb_req_control *request,
+					  struct ctdb_tickle_list *tickles)
+{
+	request->opcode = CTDB_CONTROL_SET_TCP_TICKLE_LIST;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_TCP_TICKLE_LIST;
+	request->rdata.data.tickles = tickles;
+}
+
+int ctdb_reply_control_set_tcp_tickle_list(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_SET_TCP_TICKLE_LIST);
+}
+
+/* CTDB_CONTROL_DB_ATTACH_PERSISTENT */
+
+void ctdb_req_control_db_attach_persistent(struct ctdb_req_control *request,
+					   const char *db_name)
+{
+	request->opcode = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
+	request->rdata.data.db_name = db_name;
+}
+
+int ctdb_reply_control_db_attach_persistent(struct ctdb_reply_control *reply,
+					    uint32_t *db_id)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH_PERSISTENT) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*db_id = reply->rdata.data.db_id;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_UPDATE_RECORD */
+
+void ctdb_req_control_update_record(struct ctdb_req_control *request,
+				    struct ctdb_rec_buffer *recbuf)
+{
+	request->opcode = CTDB_CONTROL_UPDATE_RECORD;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_UPDATE_RECORD;
+	request->rdata.data.recbuf = recbuf;
+}
+
+int ctdb_reply_control_update_record(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_UPDATE_RECORD);
+}
+
+/* CTDB_CONTROL_SEND_GRATUITOUS_ARP */
+
+void ctdb_req_control_send_gratuitous_arp(struct ctdb_req_control *request,
+					  struct ctdb_addr_info *addr_info)
+{
+	request->opcode = CTDB_CONTROL_SEND_GRATUITOUS_ARP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SEND_GRATUITOUS_ARP;
+	request->rdata.data.addr_info = addr_info;
+}
+
+int ctdb_reply_control_send_gratuitous_arp(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_SEND_GRATUITOUS_ARP);
+}
+
+/* CTDB_CONTROL_WIPE_DATABASE */
+
+void ctdb_req_control_wipe_database(struct ctdb_req_control *request,
+				    struct ctdb_transdb *transdb)
+{
+	request->opcode = CTDB_CONTROL_WIPE_DATABASE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_WIPE_DATABASE;
+	request->rdata.data.transdb = transdb;
+}
+
+int ctdb_reply_control_wipe_database(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_WIPE_DATABASE);
+}
+
+/* CTDB_CONTROL_UPTIME */
+
+void ctdb_req_control_uptime(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_UPTIME;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_UPTIME;
+}
+
+int ctdb_reply_control_uptime(struct ctdb_reply_control *reply,
+			      TALLOC_CTX *mem_ctx, struct ctdb_uptime **uptime)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_UPTIME) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*uptime = talloc_steal(mem_ctx, reply->rdata.data.uptime);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_START_RECOVERY */
+
+void ctdb_req_control_start_recovery(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_START_RECOVERY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_START_RECOVERY;
+}
+
+int ctdb_reply_control_start_recovery(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_START_RECOVERY);
+}
+
+/* CTDB_CONTROL_END_RECOVERY */
+
+void ctdb_req_control_end_recovery(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_END_RECOVERY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_END_RECOVERY;
+}
+
+int ctdb_reply_control_end_recovery(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_END_RECOVERY);
+}
+
+/* CTDB_CONTROL_RELOAD_NODES_FILE */
+
+void ctdb_req_control_reload_nodes_file(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_RELOAD_NODES_FILE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_RELOAD_NODES_FILE;
+}
+
+int ctdb_reply_control_reload_nodes_file(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_RELOAD_NODES_FILE);
+}
+
+/* CTDB_CONTROL_TRY_DELETE_RECORDS */
+
+void ctdb_req_control_try_delete_records(struct ctdb_req_control *request,
+					 struct ctdb_rec_buffer *recbuf)
+{
+	request->opcode = CTDB_CONTROL_TRY_DELETE_RECORDS;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TRY_DELETE_RECORDS;
+	request->rdata.data.recbuf = recbuf;
+}
+
+int ctdb_reply_control_try_delete_records(struct ctdb_reply_control *reply,
+					  TALLOC_CTX *mem_ctx,
+					  struct ctdb_rec_buffer **recbuf)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_TRY_DELETE_RECORDS) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*recbuf = talloc_steal(mem_ctx, reply->rdata.data.recbuf);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_ADD_PUBLIC_IP */
+
+void ctdb_req_control_add_public_ip(struct ctdb_req_control *request,
+				    struct ctdb_addr_info *addr_info)
+{
+	request->opcode = CTDB_CONTROL_ADD_PUBLIC_IP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_ADD_PUBLIC_IP;
+	request->rdata.data.addr_info = addr_info;
+}
+
+int ctdb_reply_control_add_public_ip(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_ADD_PUBLIC_IP);
+}
+
+/* CTDB_CONTROL_DEL_PUBLIC_IP */
+
+void ctdb_req_control_del_public_ip(struct ctdb_req_control *request,
+				    struct ctdb_addr_info *addr_info)
+{
+	request->opcode = CTDB_CONTROL_DEL_PUBLIC_IP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DEL_PUBLIC_IP;
+	request->rdata.data.addr_info = addr_info;
+}
+
+int ctdb_reply_control_del_public_ip(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_DEL_PUBLIC_IP);
+}
+
+/* CTDB_CONTROL_GET_CAPABILITIES */
+
+void ctdb_req_control_get_capabilities(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_CAPABILITIES;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_CAPABILITIES;
+}
+
+int ctdb_reply_control_get_capabilities(struct ctdb_reply_control *reply,
+					uint32_t *caps)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_CAPABILITIES) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*caps = reply->rdata.data.caps;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_RECD_PING */
+
+void ctdb_req_control_recd_ping(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_RECD_PING;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_RECD_PING;
+}
+
+int ctdb_reply_control_recd_ping(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_RECD_PING);
+}
+
+/* CTDB_CONTROL_RELEASE_IP */
+
+void ctdb_req_control_release_ip(struct ctdb_req_control *request,
+				 struct ctdb_public_ip *pubip)
+{
+	request->opcode = CTDB_CONTROL_RELEASE_IP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_RELEASE_IP;
+	request->rdata.data.pubip = pubip;
+}
+
+int ctdb_reply_control_release_ip(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_RELEASE_IP);
+}
+
+/* CTDB_CONTROL_TAKEOVER_IP */
+
+void ctdb_req_control_takeover_ip(struct ctdb_req_control *request,
+				  struct ctdb_public_ip *pubip)
+{
+	request->opcode = CTDB_CONTROL_TAKEOVER_IP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TAKEOVER_IP;
+	request->rdata.data.pubip = pubip;
+}
+
+int ctdb_reply_control_takeover_ip(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_TAKEOVER_IP);
+}
+
+/* CTDB_CONTROL_GET_PUBLIC_IPS */
+
+void ctdb_req_control_get_public_ips(struct ctdb_req_control *request,
+				     bool available_only)
+{
+	request->opcode = CTDB_CONTROL_GET_PUBLIC_IPS;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_PUBLIC_IPS;
+	if (available_only) {
+		request->flags = CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE;
+	}
+}
+
+int ctdb_reply_control_get_public_ips(struct ctdb_reply_control *reply,
+				      TALLOC_CTX *mem_ctx,
+				      struct ctdb_public_ip_list **pubip_list)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_PUBLIC_IPS) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*pubip_list = talloc_steal(mem_ctx,
+					   reply->rdata.data.pubip_list);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_GET_NODEMAP */
+
+void ctdb_req_control_get_nodemap(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_NODEMAP;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_NODEMAP;
+}
+
+int ctdb_reply_control_get_nodemap(struct ctdb_reply_control *reply,
+				   TALLOC_CTX *mem_ctx,
+				   struct ctdb_node_map **nodemap)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_NODEMAP) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*nodemap = talloc_steal(mem_ctx, reply->rdata.data.nodemap);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_TRAVERSE_KILL */
+
+void ctdb_req_control_traverse_kill(struct ctdb_req_control *request,
+				    struct ctdb_traverse_start *traverse)
+{
+	request->opcode = CTDB_CONTROL_TRAVERSE_KILL;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TRAVERSE_KILL;
+	request->rdata.data.traverse_start = traverse;
+}
+
+int ctdb_reply_control_traverse_kill(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRAVERSE_KILL);
+}
+
+/* CTDB_CONTROL_RECD_RECLOCK_LATENCY */
+
+void ctdb_req_control_recd_reclock_latency(struct ctdb_req_control *request,
+					   double reclock_latency)
+{
+	request->opcode = CTDB_CONTROL_RECD_RECLOCK_LATENCY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_RECD_RECLOCK_LATENCY;
+	request->rdata.data.reclock_latency = reclock_latency;
+}
+
+int ctdb_reply_control_recd_reclock_latency(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_RECD_RECLOCK_LATENCY);
+}
+
+/* CTDB_CONTROL_GET_RECLOCK_FILE */
+
+void ctdb_req_control_get_reclock_file(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_RECLOCK_FILE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_RECLOCK_FILE;
+}
+
+int ctdb_reply_control_get_reclock_file(struct ctdb_reply_control *reply,
+					TALLOC_CTX *mem_ctx,
+					const char **reclock_file)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_RECLOCK_FILE) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*reclock_file = talloc_steal(mem_ctx,
+					     reply->rdata.data.reclock_file);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_STOP_NODE */
+
+void ctdb_req_control_stop_node(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_STOP_NODE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_STOP_NODE;
+}
+
+int ctdb_reply_control_stop_node(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_STOP_NODE);
+}
+
+/* CTDB_CONTROL_CONTINUE_NODE */
+
+void ctdb_req_control_continue_node(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_CONTINUE_NODE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_CONTINUE_NODE;
+}
+
+int ctdb_reply_control_continue_node(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_CONTINUE_NODE);
+}
+
+/* CTDB_CONTROL_SET_LMASTERROLE */
+
+void ctdb_req_control_set_lmasterrole(struct ctdb_req_control *request,
+				      uint32_t lmaster_role)
+{
+	request->opcode = CTDB_CONTROL_SET_LMASTERROLE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_LMASTERROLE;
+	request->rdata.data.role = lmaster_role;
+}
+
+int ctdb_reply_control_set_lmasterrole(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_LMASTERROLE);
+}
+
+/* CTDB_CONTROL_SET_RECMASTERROLE */
+
+void ctdb_req_control_set_recmasterrole(struct ctdb_req_control *request,
+					uint32_t recmaster_role)
+{
+	request->opcode = CTDB_CONTROL_SET_RECMASTERROLE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_RECMASTERROLE;
+	request->rdata.data.role = recmaster_role;
+}
+
+int ctdb_reply_control_set_recmasterrole(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_SET_RECMASTERROLE);
+}
+
+/* CTDB_CONTROL_SET_BAN_STATE */
+
+void ctdb_req_control_set_ban_state(struct ctdb_req_control *request,
+				    struct ctdb_ban_state *ban_state)
+{
+	request->opcode = CTDB_CONTROL_SET_BAN_STATE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_BAN_STATE;
+	request->rdata.data.ban_state = ban_state;
+}
+
+int ctdb_reply_control_set_ban_state(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_BAN_STATE);
+}
+
+/* CTDB_CONTROL_GET_BAN_STATE */
+
+void ctdb_req_control_get_ban_state(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_BAN_STATE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_BAN_STATE;
+}
+
+int ctdb_reply_control_get_ban_state(struct ctdb_reply_control *reply,
+				     TALLOC_CTX *mem_ctx,
+				     struct ctdb_ban_state **ban_state)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_BAN_STATE) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*ban_state = talloc_steal(mem_ctx,
+					  reply->rdata.data.ban_state);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_REGISTER_NOTIFY */
+
+void ctdb_req_control_register_notify(struct ctdb_req_control *request,
+				      struct ctdb_notify_data *notify)
+{
+	request->opcode = CTDB_CONTROL_REGISTER_NOTIFY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_REGISTER_NOTIFY;
+	request->rdata.data.notify = notify;
+}
+
+int ctdb_reply_control_register_notify(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_REGISTER_NOTIFY);
+}
+
+/* CTDB_CONTROL_DEREGISTER_NOTIFY */
+
+void ctdb_req_control_deregister_notify(struct ctdb_req_control *request,
+					uint64_t srvid)
+{
+	request->opcode = CTDB_CONTROL_DEREGISTER_NOTIFY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DEREGISTER_NOTIFY;
+	request->rdata.data.srvid = srvid;
+}
+
+int ctdb_reply_control_deregister_notify(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_DEREGISTER_NOTIFY);
+}
+
+/* CTDB_CONTROL_TRANS3_COMMIT */
+
+void ctdb_req_control_trans3_commit(struct ctdb_req_control *request,
+				    struct ctdb_rec_buffer *recbuf)
+{
+	request->opcode = CTDB_CONTROL_TRANS3_COMMIT;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TRANS3_COMMIT;
+	request->rdata.data.recbuf = recbuf;
+}
+
+int ctdb_reply_control_trans3_commit(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRANS3_COMMIT);
+}
+
+/* CTDB_CONTROL_GET_DB_SEQNUM */
+
+void ctdb_req_control_get_db_seqnum(struct ctdb_req_control *request,
+				    uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_GET_DB_SEQNUM;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_DB_SEQNUM;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_get_db_seqnum(struct ctdb_reply_control *reply,
+				     uint64_t *seqnum)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_DB_SEQNUM) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*seqnum = reply->rdata.data.seqnum;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_DB_SET_HEALTHY */
+
+void ctdb_req_control_db_set_healthy(struct ctdb_req_control *request,
+				     uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_DB_SET_HEALTHY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_SET_HEALTHY;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_db_set_healthy(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_SET_HEALTHY);
+}
+
+/* CTDB_CONTROL_DB_GET_HEALTH */
+
+void ctdb_req_control_db_get_health(struct ctdb_req_control *request,
+				    uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_DB_GET_HEALTH;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_GET_HEALTH;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_db_get_health(struct ctdb_reply_control *reply,
+				     TALLOC_CTX *mem_ctx, const char **reason)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DB_GET_HEALTH) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*reason = talloc_steal(mem_ctx, reply->rdata.data.reason);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_GET_PUBLIC_IP_INFO */
+
+void ctdb_req_control_get_public_ip_info(struct ctdb_req_control *request,
+					 ctdb_sock_addr *addr)
+{
+	request->opcode = CTDB_CONTROL_GET_PUBLIC_IP_INFO;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_PUBLIC_IP_INFO;
+	request->rdata.data.addr = addr;
+}
+
+int ctdb_reply_control_get_public_ip_info(struct ctdb_reply_control *reply,
+					  TALLOC_CTX *mem_ctx,
+					  struct ctdb_public_ip_info **ipinfo)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_PUBLIC_IP_INFO) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*ipinfo = talloc_steal(mem_ctx, reply->rdata.data.ipinfo);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_GET_IFACES */
+
+void ctdb_req_control_get_ifaces(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_IFACES;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_IFACES;
+}
+
+int ctdb_reply_control_get_ifaces(struct ctdb_reply_control *reply,
+				  TALLOC_CTX *mem_ctx,
+				  struct ctdb_iface_list **iface_list)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_IFACES) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*iface_list = talloc_steal(mem_ctx,
+					   reply->rdata.data.iface_list);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_SET_IFACE_LINK_STATE */
+
+void ctdb_req_control_set_iface_link_state(struct ctdb_req_control *request,
+					   struct ctdb_iface *iface)
+{
+	request->opcode = CTDB_CONTROL_SET_IFACE_LINK_STATE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_IFACE_LINK_STATE;
+	request->rdata.data.iface = iface;
+}
+
+int ctdb_reply_control_set_iface_link_state(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_SET_IFACE_LINK_STATE);
+}
+
+/* CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE */
+
+void ctdb_req_control_tcp_add_delayed_update(struct ctdb_req_control *request,
+					     struct ctdb_connection *conn)
+{
+	request->opcode = CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE;
+	request->rdata.data.conn = conn;
+}
+
+int ctdb_reply_control_tcp_add_delayed_update(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE);
+}
+
+/* CTDB_CONTROL_GET_STAT_HISTORY */
+
+void ctdb_req_control_get_stat_history(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_STAT_HISTORY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_STAT_HISTORY;
+}
+
+int ctdb_reply_control_get_stat_history(struct ctdb_reply_control *reply,
+					TALLOC_CTX *mem_ctx,
+					struct ctdb_statistics_list **stats_list)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_STAT_HISTORY) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*stats_list = talloc_steal(mem_ctx,
+					   reply->rdata.data.stats_list);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_SCHEDULE_FOR_DELETION */
+
+void ctdb_req_control_schedule_for_deletion(struct ctdb_req_control *request,
+					    struct ctdb_key_data *key)
+{
+	request->opcode = CTDB_CONTROL_SCHEDULE_FOR_DELETION;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SCHEDULE_FOR_DELETION;
+	request->rdata.data.key = key;
+}
+
+int ctdb_reply_control_schedule_for_deletion(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_SCHEDULE_FOR_DELETION);
+}
+
+/* CTDB_CONTROL_SET_DB_READONLY */
+
+void ctdb_req_control_set_db_readonly(struct ctdb_req_control *request,
+				      uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_SET_DB_READONLY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_DB_READONLY;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_set_db_readonly(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DB_READONLY);
+}
+
+/* CTDB_CONTROL_TRAVERSE_START_EXT */
+
+void ctdb_req_control_traverse_start_ext(struct ctdb_req_control *request,
+					 struct ctdb_traverse_start_ext *traverse)
+{
+	request->opcode = CTDB_CONTROL_TRAVERSE_START_EXT;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TRAVERSE_START_EXT;
+	request->rdata.data.traverse_start_ext = traverse;
+}
+
+int ctdb_reply_control_traverse_start_ext(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_TRAVERSE_START_EXT);
+}
+
+/* CTDB_CONTROL_GET_DB_STATISTICS */
+
+void ctdb_req_control_get_db_statistics(struct ctdb_req_control *request,
+					uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_GET_DB_STATISTICS;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_DB_STATISTICS;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_get_db_statistics(struct ctdb_reply_control *reply,
+					 TALLOC_CTX *mem_ctx,
+					 struct ctdb_db_statistics **dbstats)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_DB_STATISTICS) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*dbstats = talloc_steal(mem_ctx, reply->rdata.data.dbstats);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_SET_DB_STICKY */
+
+void ctdb_req_control_set_db_sticky(struct ctdb_req_control *request,
+				    uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_SET_DB_STICKY;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_SET_DB_STICKY;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_set_db_sticky(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DB_STICKY);
+}
+
+/* CTDB_CONTROL_RELOAD_PUBLIC_IPS */
+
+void ctdb_req_control_reload_public_ips(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_RELOAD_PUBLIC_IPS;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_RELOAD_PUBLIC_IPS;
+}
+
+int ctdb_reply_control_reload_public_ips(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_RELOAD_PUBLIC_IPS);
+}
+
+/* CTDB_CONTROL_TRAVERSE_ALL_EXT */
+
+/* CTDB_CONTROL_IPREALLOCATED */
+
+void ctdb_req_control_ipreallocated(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_IPREALLOCATED;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_IPREALLOCATED;
+}
+
+int ctdb_reply_control_ipreallocated(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_IPREALLOCATED);
+}
+
+/* CTDB_CONTROL_GET_RUNSTATE */
+
+void ctdb_req_control_get_runstate(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_RUNSTATE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_RUNSTATE;
+}
+
+int ctdb_reply_control_get_runstate(struct ctdb_reply_control *reply,
+				    enum ctdb_runstate *runstate)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_RUNSTATE) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*runstate = reply->rdata.data.runstate;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_DB_DETACH */
+
+void ctdb_req_control_db_detach(struct ctdb_req_control *request,
+				uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_DB_DETACH;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_DETACH;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_db_detach(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_DETACH);
+}
+
+/* CTDB_CONTROL_GET_NODES_FILE */
+
+void ctdb_req_control_get_nodes_file(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_GET_NODES_FILE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_GET_NODES_FILE;
+}
+
+int ctdb_reply_control_get_nodes_file(struct ctdb_reply_control *reply,
+				      TALLOC_CTX *mem_ctx,
+				      struct ctdb_node_map **nodemap)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_GET_NODES_FILE) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*nodemap = talloc_steal(mem_ctx, reply->rdata.data.nodemap);
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_DB_FREEZE */
+
+void ctdb_req_control_db_freeze(struct ctdb_req_control *request,
+				uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_DB_FREEZE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_FREEZE;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_db_freeze(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_FREEZE);
+}
+
+/* CTDB_CONTROL_DB_THAW */
+
+void ctdb_req_control_db_thaw(struct ctdb_req_control *request,
+			      uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_DB_THAW;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_THAW;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_db_thaw(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_THAW);
+}
+
+/* CTDB_CONTROL_DB_TRANSACTION_START */
+
+void ctdb_req_control_db_transaction_start(struct ctdb_req_control *request,
+					   struct ctdb_transdb *transdb)
+{
+	request->opcode = CTDB_CONTROL_DB_TRANSACTION_START;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_START;
+	request->rdata.data.transdb = transdb;
+}
+
+int ctdb_reply_control_db_transaction_start(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_DB_TRANSACTION_START);
+}
+
+/* CTDB_CONTROL_DB_TRANSACTION_COMMIT */
+
+void ctdb_req_control_db_transaction_commit(struct ctdb_req_control *request,
+					    struct ctdb_transdb *transdb)
+{
+	request->opcode = CTDB_CONTROL_DB_TRANSACTION_COMMIT;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_COMMIT;
+	request->rdata.data.transdb = transdb;
+}
+
+int ctdb_reply_control_db_transaction_commit(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_DB_TRANSACTION_COMMIT);
+}
+
+/* CTDB_CONTROL_DB_TRANSACTION_CANCEL */
+
+void ctdb_req_control_db_transaction_cancel(struct ctdb_req_control *request,
+					    uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_DB_TRANSACTION_CANCEL;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_CANCEL;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_db_transaction_cancel(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply,
+					  CTDB_CONTROL_DB_TRANSACTION_CANCEL);
+}
+
+/* CTDB_CONTROL_DB_PULL */
+
+void ctdb_req_control_db_pull(struct ctdb_req_control *request,
+			      struct ctdb_pulldb_ext *pulldb_ext)
+{
+	request->opcode = CTDB_CONTROL_DB_PULL;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_PULL;
+	request->rdata.data.pulldb_ext = pulldb_ext;
+}
+
+int ctdb_reply_control_db_pull(struct ctdb_reply_control *reply,
+			       uint32_t *num_records)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DB_PULL) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*num_records = reply->rdata.data.num_records;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_DB_PUSH_START */
+
+void ctdb_req_control_db_push_start(struct ctdb_req_control *request,
+				    struct ctdb_pulldb_ext *pulldb_ext)
+{
+	request->opcode = CTDB_CONTROL_DB_PUSH_START;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_PUSH_START;
+	request->rdata.data.pulldb_ext = pulldb_ext;
+}
+
+int ctdb_reply_control_db_push_start(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_PUSH_START);
+}
+
+/* CTDB_CONTROL_DB_PUSH_CONFIRM */
+
+void ctdb_req_control_db_push_confirm(struct ctdb_req_control *request,
+				      uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_db_push_confirm(struct ctdb_reply_control *reply,
+				       uint32_t *num_records)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DB_PUSH_CONFIRM) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*num_records = reply->rdata.data.num_records;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_DB_OPEN_FLAGS */
+
+void ctdb_req_control_db_open_flags(struct ctdb_req_control *request,
+				    uint32_t db_id)
+{
+	request->opcode = CTDB_CONTROL_DB_OPEN_FLAGS;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_OPEN_FLAGS;
+	request->rdata.data.db_id = db_id;
+}
+
+int ctdb_reply_control_db_open_flags(struct ctdb_reply_control *reply,
+				     int *tdb_flags)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DB_OPEN_FLAGS) {
+		return EPROTO;
+	}
+
+	if (reply->status == 0) {
+		*tdb_flags = reply->rdata.data.tdb_flags;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_DB_ATTACH_REPLICATED */
+
+void ctdb_req_control_db_attach_replicated(struct ctdb_req_control *request,
+					   const char *db_name)
+{
+	request->opcode = CTDB_CONTROL_DB_ATTACH_REPLICATED;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_ATTACH_REPLICATED;
+	request->rdata.data.db_name = db_name;
+}
+
+int ctdb_reply_control_db_attach_replicated(struct ctdb_reply_control *reply,
+					    uint32_t *db_id)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH_REPLICATED) {
+		return EPROTO;
+	}
+	if (reply->status == 0) {
+		*db_id = reply->rdata.data.db_id;
+	}
+	return reply->status;
+}
+
+/* CTDB_CONTROL_CHECK_PID_SRVID */
+
+void ctdb_req_control_check_pid_srvid(struct ctdb_req_control *request,
+				      struct ctdb_pid_srvid *pid_srvid)
+{
+	request->opcode = CTDB_CONTROL_CHECK_PID_SRVID;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_CHECK_PID_SRVID;
+	request->rdata.data.pid_srvid = pid_srvid;
+}
+
+int ctdb_reply_control_check_pid_srvid(struct ctdb_reply_control *reply,
+				       int *status)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_CHECK_PID_SRVID) {
+		return EPROTO;
+	}
+
+	*status = reply->status;
+	reply->status = 0;
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_TUNNEL_REGISTER */
+
+void ctdb_req_control_tunnel_register(struct ctdb_req_control *request,
+				      uint64_t tunnel_id)
+{
+	request->opcode = CTDB_CONTROL_TUNNEL_REGISTER;
+	request->pad = 0;
+	request->srvid = tunnel_id;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TUNNEL_REGISTER;
+}
+
+int ctdb_reply_control_tunnel_register(struct ctdb_reply_control *reply)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_TUNNEL_REGISTER) {
+		return EPROTO;
+	}
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_TUNNEL_DEREGISTER */
+
+void ctdb_req_control_tunnel_deregister(struct ctdb_req_control *request,
+					uint64_t tunnel_id)
+{
+	request->opcode = CTDB_CONTROL_TUNNEL_DEREGISTER;
+	request->pad = 0;
+	request->srvid = tunnel_id;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_TUNNEL_DEREGISTER;
+}
+
+int ctdb_reply_control_tunnel_deregister(struct ctdb_reply_control *reply)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_TUNNEL_DEREGISTER) {
+		return EPROTO;
+	}
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_VACUUM_FETCH */
+
+void ctdb_req_control_vacuum_fetch(struct ctdb_req_control *request,
+				   struct ctdb_rec_buffer *recbuf)
+{
+	request->opcode = CTDB_CONTROL_VACUUM_FETCH;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_VACUUM_FETCH;
+	request->rdata.data.recbuf = recbuf;
+}
+
+int ctdb_reply_control_vacuum_fetch(struct ctdb_reply_control *reply)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_VACUUM_FETCH) {
+		return EPROTO;
+	}
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_DB_VACUUM */
+
+void ctdb_req_control_db_vacuum(struct ctdb_req_control *request,
+				struct ctdb_db_vacuum *db_vacuum)
+{
+	request->opcode = CTDB_CONTROL_DB_VACUUM;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DB_VACUUM;
+	request->rdata.data.db_vacuum = db_vacuum;
+}
+
+int ctdb_reply_control_db_vacuum(struct ctdb_reply_control *reply)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_DB_VACUUM) {
+		return EPROTO;
+	}
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_ECHO_DATA */
+
+void ctdb_req_control_echo_data(struct ctdb_req_control *request,
+				struct ctdb_echo_data *echo_data)
+{
+	request->opcode = CTDB_CONTROL_ECHO_DATA;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_ECHO_DATA;
+	request->rdata.data.echo_data = echo_data;
+}
+
+int ctdb_reply_control_echo_data(struct ctdb_reply_control *reply)
+{
+	if (reply->rdata.opcode != CTDB_CONTROL_ECHO_DATA) {
+		return EPROTO;
+	}
+
+	return reply->status;
+}
+
+/* CTDB_CONTROL_DISABLE_NODE */
+
+void ctdb_req_control_disable_node(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_DISABLE_NODE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_DISABLE_NODE;
+}
+
+int ctdb_reply_control_disable_node(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_DISABLE_NODE);
+}
+
+/* CTDB_CONTROL_ENABLE_NODE */
+
+void ctdb_req_control_enable_node(struct ctdb_req_control *request)
+{
+	request->opcode = CTDB_CONTROL_ENABLE_NODE;
+	request->pad = 0;
+	request->srvid = 0;
+	request->client_id = 0;
+	request->flags = 0;
+
+	request->rdata.opcode = CTDB_CONTROL_ENABLE_NODE;
+}
+
+int ctdb_reply_control_enable_node(struct ctdb_reply_control *reply)
+{
+	return ctdb_reply_control_generic(reply, CTDB_CONTROL_ENABLE_NODE);
+}