X-Git-Url: http://git.samba.org/?p=metze%2Fsamba%2Fwip.git;a=blobdiff_plain;f=ctdb%2Fserver%2Fctdb_takeover.c;h=6462de8aa4348c8386e59f790013be6ba9e2ffe7;hp=510c8835aaaf8a51be255da930ff6490baaf75b4;hb=c315fce17ef11a23c24fc92b7475ac3a3ac55032;hpb=7d0a4ab6229b19ee55f79cdcf6de811b429e4657

diff --git a/ctdb/server/ctdb_takeover.c b/ctdb/server/ctdb_takeover.c
index 510c8835aaaf..6462de8aa434 100644
--- a/ctdb/server/ctdb_takeover.c
+++ b/ctdb/server/ctdb_takeover.c
@@ -18,14 +18,27 @@
    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 "includes.h"
-#include "tdb.h"
-#include "lib/util/dlinklist.h"
+#include "replace.h"
 #include "system/network.h"
 #include "system/filesys.h"
+#include "system/time.h"
 #include "system/wait.h"
-#include "../include/ctdb_private.h"
-#include "../common/rb_tree.h"
+
+#include <talloc.h>
+#include <tevent.h>
+
+#include "lib/util/dlinklist.h"
+#include "lib/util/debug.h"
+#include "lib/util/samba_util.h"
+
+#include "ctdb_private.h"
+#include "ctdb_client.h"
+#include "ctdb_logging.h"
+
+#include "common/rb_tree.h"
+#include "common/reqid.h"
+#include "common/system.h"
+#include "common/common.h"
 
 
 #define TAKEOVER_TIMEOUT() timeval_current_ofs(ctdb->tunable.takeover_timeout,0)
@@ -40,8 +53,8 @@ struct ctdb_ipflags {
 	enum ctdb_runstate runstate;
 };
 
-struct ctdb_iface {
-	struct ctdb_iface *prev, *next;
+struct ctdb_interface {
+	struct ctdb_interface *prev, *next;
 	const char *name;
 	bool link_up;
 	uint32_t references;
@@ -58,9 +71,9 @@ static const char *ctdb_vnn_iface_string(const struct ctdb_vnn *vnn)
 
 static int ctdb_add_local_iface(struct ctdb_context *ctdb, const char *iface)
 {
-	struct ctdb_iface *i;
+	struct ctdb_interface *i;
 
-	/* Verify that we dont have an entry for this ip yet */
+	/* Verify that we don't have an entry for this ip yet */
 	for (i=ctdb->ifaces;i;i=i->next) {
 		if (strcmp(i->name, iface) == 0) {
 			return 0;
@@ -68,7 +81,7 @@ static int ctdb_add_local_iface(struct ctdb_context *ctdb, const char *iface)
 	}
 
 	/* create a new structure for this interface */
-	i = talloc_zero(ctdb, struct ctdb_iface);
+	i = talloc_zero(ctdb, struct ctdb_interface);
 	CTDB_NO_MEMORY_FATAL(ctdb, i);
 	i->name = talloc_strdup(i, iface);
 	CTDB_NO_MEMORY(ctdb, i->name);
@@ -109,7 +122,7 @@ static bool vnn_has_interface_with_name(struct ctdb_vnn *vnn,
 static void ctdb_remove_orphaned_ifaces(struct ctdb_context *ctdb,
 					struct ctdb_vnn *vnn)
 {
-	struct ctdb_iface *i, *next;
+	struct ctdb_interface *i, *next;
 
 	/* For each interface, check if there's an IP using it. */
 	for (i = ctdb->ifaces; i != NULL; i = next) {
@@ -147,10 +160,10 @@ static void ctdb_remove_orphaned_ifaces(struct ctdb_context *ctdb,
 }
 
 
-static struct ctdb_iface *ctdb_find_iface(struct ctdb_context *ctdb,
-					  const char *iface)
+static struct ctdb_interface *ctdb_find_iface(struct ctdb_context *ctdb,
+					      const char *iface)
 {
-	struct ctdb_iface *i;
+	struct ctdb_interface *i;
 
 	for (i=ctdb->ifaces;i;i=i->next) {
 		if (strcmp(i->name, iface) == 0) {
@@ -161,12 +174,12 @@ static struct ctdb_iface *ctdb_find_iface(struct ctdb_context *ctdb,
 	return NULL;
 }
 
-static struct ctdb_iface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
-					      struct ctdb_vnn *vnn)
+static struct ctdb_interface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
+						  struct ctdb_vnn *vnn)
 {
 	int i;
-	struct ctdb_iface *cur = NULL;
-	struct ctdb_iface *best = NULL;
+	struct ctdb_interface *cur = NULL;
+	struct ctdb_interface *best = NULL;
 
 	for (i=0; vnn->ifaces[i]; i++) {
 
@@ -196,7 +209,7 @@ static struct ctdb_iface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
 static int32_t ctdb_vnn_assign_iface(struct ctdb_context *ctdb,
 				     struct ctdb_vnn *vnn)
 {
-	struct ctdb_iface *best = NULL;
+	struct ctdb_interface *best = NULL;
 
 	if (vnn->iface) {
 		DEBUG(DEBUG_INFO, (__location__ " public address '%s' "
@@ -257,7 +270,7 @@ static bool ctdb_vnn_available(struct ctdb_context *ctdb,
 	}
 
 	for (i=0; vnn->ifaces[i]; i++) {
-		struct ctdb_iface *cur;
+		struct ctdb_interface *cur;
 
 		cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
 		if (cur == NULL) {
@@ -286,7 +299,7 @@ struct ctdb_takeover_arp {
  */
 struct ctdb_tcp_list {
 	struct ctdb_tcp_list *prev, *next;
-	struct ctdb_tcp_connection connection;
+	struct ctdb_connection connection;
 };
 
 /*
@@ -303,7 +316,8 @@ struct ctdb_client_ip {
 /*
   send a gratuitous arp
  */
-static void ctdb_control_send_arp(struct event_context *ev, struct timed_event *te, 
+static void ctdb_control_send_arp(struct tevent_context *ev,
+				  struct tevent_timer *te,
 				  struct timeval t, void *private_data)
 {
 	struct ctdb_takeover_arp *arp = talloc_get_type(private_data, 
@@ -321,20 +335,20 @@ static void ctdb_control_send_arp(struct event_context *ev, struct timed_event *
 	tcparray = arp->tcparray;
 	if (tcparray) {
 		for (i=0;i<tcparray->num;i++) {
-			struct ctdb_tcp_connection *tcon;
+			struct ctdb_connection *tcon;
 
 			tcon = &tcparray->connections[i];
 			DEBUG(DEBUG_INFO,("sending tcp tickle ack for %u->%s:%u\n",
-				(unsigned)ntohs(tcon->dst_addr.ip.sin_port), 
-				ctdb_addr_to_str(&tcon->src_addr),
-				(unsigned)ntohs(tcon->src_addr.ip.sin_port)));
+				(unsigned)ntohs(tcon->dst.ip.sin_port),
+				ctdb_addr_to_str(&tcon->src),
+				(unsigned)ntohs(tcon->src.ip.sin_port)));
 			ret = ctdb_sys_send_tcp(
-				&tcon->src_addr, 
-				&tcon->dst_addr,
+				&tcon->src,
+				&tcon->dst,
 				0, 0, 0);
 			if (ret != 0) {
 				DEBUG(DEBUG_CRIT,(__location__ " Failed to send tcp tickle ack for %s\n",
-					ctdb_addr_to_str(&tcon->src_addr)));
+					ctdb_addr_to_str(&tcon->src)));
 			}
 		}
 	}
@@ -346,9 +360,9 @@ static void ctdb_control_send_arp(struct event_context *ev, struct timed_event *
 		return;
 	}
 
-	event_add_timed(arp->ctdb->ev, arp->vnn->takeover_ctx, 
-			timeval_current_ofs(CTDB_ARP_INTERVAL, 100000), 
-			ctdb_control_send_arp, arp);
+	tevent_add_timer(arp->ctdb->ev, arp->vnn->takeover_ctx,
+			 timeval_current_ofs(CTDB_ARP_INTERVAL, 100000),
+			 ctdb_control_send_arp, arp);
 }
 
 static int32_t ctdb_announce_vnn_iface(struct ctdb_context *ctdb,
@@ -383,20 +397,20 @@ static int32_t ctdb_announce_vnn_iface(struct ctdb_context *ctdb,
 		vnn->tcp_update_needed = true;
 	}
 
-	event_add_timed(arp->ctdb->ev, vnn->takeover_ctx,
-			timeval_zero(), ctdb_control_send_arp, arp);
+	tevent_add_timer(arp->ctdb->ev, vnn->takeover_ctx,
+			 timeval_zero(), ctdb_control_send_arp, arp);
 
 	return 0;
 }
 
 struct takeover_callback_state {
-	struct ctdb_req_control *c;
+	struct ctdb_req_control_old *c;
 	ctdb_sock_addr *addr;
 	struct ctdb_vnn *vnn;
 };
 
 struct ctdb_do_takeip_state {
-	struct ctdb_req_control *c;
+	struct ctdb_req_control_old *c;
 	struct ctdb_vnn *vnn;
 };
 
@@ -461,7 +475,7 @@ static int ctdb_takeip_destructor(struct ctdb_do_takeip_state *state)
   take over an ip address
  */
 static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
-			      struct ctdb_req_control *c,
+			      struct ctdb_req_control_old *c,
 			      struct ctdb_vnn *vnn)
 {
 	int ret;
@@ -520,8 +534,8 @@ static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
 }
 
 struct ctdb_do_updateip_state {
-	struct ctdb_req_control *c;
-	struct ctdb_iface *old;
+	struct ctdb_req_control_old *c;
+	struct ctdb_interface *old;
 	struct ctdb_vnn *vnn;
 };
 
@@ -584,12 +598,12 @@ static int ctdb_updateip_destructor(struct ctdb_do_updateip_state *state)
   update (move) an ip address
  */
 static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
-				struct ctdb_req_control *c,
+				struct ctdb_req_control_old *c,
 				struct ctdb_vnn *vnn)
 {
 	int ret;
 	struct ctdb_do_updateip_state *state;
-	struct ctdb_iface *old = vnn->iface;
+	struct ctdb_interface *old = vnn->iface;
 	const char *new_name;
 
 	if (vnn->update_in_flight) {
@@ -680,7 +694,7 @@ static struct ctdb_vnn *find_public_ip_vnn(struct ctdb_context *ctdb, ctdb_sock_
   take over an ip address
  */
 int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
-				 struct ctdb_req_control *c,
+				 struct ctdb_req_control_old *c,
 				 TDB_DATA indata,
 				 bool *async_reply)
 {
@@ -690,7 +704,7 @@ int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
 	bool have_ip = false;
 	bool do_updateip = false;
 	bool do_takeip = false;
-	struct ctdb_iface *best_iface = NULL;
+	struct ctdb_interface *best_iface = NULL;
 
 	if (pip->pnn != ctdb->pnn) {
 		DEBUG(DEBUG_ERR,(__location__" takeoverip called for an ip '%s' "
@@ -820,9 +834,9 @@ static void release_kill_clients(struct ctdb_context *ctdb, ctdb_sock_addr *addr
 			ctdb_addr_to_str(&ip->addr)));
 
 		if (ctdb_same_ip(&tmp_addr, addr)) {
-			struct ctdb_client *client = ctdb_reqid_find(ctdb, 
-								     ip->client_id, 
-								     struct ctdb_client);
+			struct ctdb_client *client = reqid_find(ctdb->idr,
+								ip->client_id,
+								struct ctdb_client);
 			DEBUG(DEBUG_INFO,("matched client %u with IP %s and pid %u\n", 
 				ip->client_id,
 				ctdb_addr_to_str(&ip->addr),
@@ -912,7 +926,7 @@ static int ctdb_releaseip_destructor(struct takeover_callback_state *state)
   release an ip address
  */
 int32_t ctdb_control_release_ip(struct ctdb_context *ctdb, 
-				struct ctdb_req_control *c,
+				struct ctdb_req_control_old *c,
 				TDB_DATA indata, 
 				bool *async_reply)
 {
@@ -1045,7 +1059,7 @@ static int ctdb_add_public_address(struct ctdb_context *ctdb,
 	}
 	free(tmp);
 
-	/* Verify that we dont have an entry for this ip yet */
+	/* Verify that we don't have an entry for this ip yet */
 	for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
 		if (ctdb_same_sockaddr(addr, &vnn->public_address)) {
 			DEBUG(DEBUG_CRIT,("Same ip '%s' specified multiple times in the public address list \n", 
@@ -1167,7 +1181,7 @@ int ctdb_set_single_public_ip(struct ctdb_context *ctdb,
 			      const char *ip)
 {
 	struct ctdb_vnn *svnn;
-	struct ctdb_iface *cur = NULL;
+	struct ctdb_interface *cur = NULL;
 	bool ok;
 	int ret;
 
@@ -1214,8 +1228,8 @@ int ctdb_set_single_public_ip(struct ctdb_context *ctdb,
 	return 0;
 }
 
-struct ctdb_public_ip_list {
-	struct ctdb_public_ip_list *next;
+struct public_ip_list {
+	struct public_ip_list *next;
 	uint32_t pnn;
 	ctdb_sock_addr addr;
 };
@@ -1223,9 +1237,8 @@ struct ctdb_public_ip_list {
 /* Given a physical node, return the number of
    public addresses that is currently assigned to this node.
 */
-static int node_ip_coverage(struct ctdb_context *ctdb, 
-	int32_t pnn,
-	struct ctdb_public_ip_list *ips)
+static int node_ip_coverage(struct ctdb_context *ctdb, int32_t pnn,
+			    struct public_ip_list *ips)
 {
 	int num=0;
 
@@ -1241,11 +1254,11 @@ static int node_ip_coverage(struct ctdb_context *ctdb,
 /* Can the given node host the given IP: is the public IP known to the
  * node and is NOIPHOST unset?
 */
-static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn, 
+static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
 			     struct ctdb_ipflags ipflags,
-			     struct ctdb_public_ip_list *ip)
+			     struct public_ip_list *ip)
 {
-	struct ctdb_all_public_ips *public_ips;
+	struct ctdb_public_ip_list_old *public_ips;
 	int i;
 
 	if (ipflags.noiphost) {
@@ -1268,9 +1281,9 @@ static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
 	return false;
 }
 
-static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn, 
+static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
 				 struct ctdb_ipflags ipflags,
-				 struct ctdb_public_ip_list *ip)
+				 struct public_ip_list *ip)
 {
 	if (ipflags.noiptakeover) {
 		return false;
@@ -1283,10 +1296,10 @@ static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
    pick the node that currently are serving the least number of ips
    so that the ips get spread out evenly.
 */
-static int find_takeover_node(struct ctdb_context *ctdb, 
-		struct ctdb_ipflags *ipflags,
-		struct ctdb_public_ip_list *ip,
-		struct ctdb_public_ip_list *all_ips)
+static int find_takeover_node(struct ctdb_context *ctdb,
+			      struct ctdb_ipflags *ipflags,
+			      struct public_ip_list *ip,
+			      struct public_ip_list *all_ips)
 {
 	int pnn, min=0, num;
 	int i, numnodes;
@@ -1352,8 +1365,8 @@ static uint32_t *ip_key(ctdb_sock_addr *ip)
 
 static void *add_ip_callback(void *parm, void *data)
 {
-	struct ctdb_public_ip_list *this_ip = parm; 
-	struct ctdb_public_ip_list *prev_ip = data; 
+	struct public_ip_list *this_ip = parm;
+	struct public_ip_list *prev_ip = data;
 
 	if (prev_ip == NULL) {
 		return parm;
@@ -1367,20 +1380,20 @@ static void *add_ip_callback(void *parm, void *data)
 
 static int getips_count_callback(void *param, void *data)
 {
-	struct ctdb_public_ip_list **ip_list = (struct ctdb_public_ip_list **)param;
-	struct ctdb_public_ip_list *new_ip = (struct ctdb_public_ip_list *)data;
+	struct public_ip_list **ip_list = (struct public_ip_list **)param;
+	struct public_ip_list *new_ip = (struct public_ip_list *)data;
 
 	new_ip->next = *ip_list;
 	*ip_list     = new_ip;
 	return 0;
 }
 
-static struct ctdb_public_ip_list *
+static struct public_ip_list *
 create_merged_ip_list(struct ctdb_context *ctdb)
 {
 	int i, j;
-	struct ctdb_public_ip_list *ip_list;
-	struct ctdb_all_public_ips *public_ips;
+	struct public_ip_list *ip_list;
+	struct ctdb_public_ip_list_old *public_ips;
 
 	if (ctdb->ip_tree != NULL) {
 		talloc_free(ctdb->ip_tree);
@@ -1401,9 +1414,9 @@ create_merged_ip_list(struct ctdb_context *ctdb)
 		}		
 
 		for (j=0;j<public_ips->num;j++) {
-			struct ctdb_public_ip_list *tmp_ip; 
+			struct public_ip_list *tmp_ip;
 
-			tmp_ip = talloc_zero(ctdb->ip_tree, struct ctdb_public_ip_list);
+			tmp_ip = talloc_zero(ctdb->ip_tree, struct public_ip_list);
 			CTDB_NO_MEMORY_NULL(ctdb, tmp_ip);
 			/* Do not use information about IP addresses hosted
 			 * on other nodes, it may not be accurate */
@@ -1472,10 +1485,10 @@ static uint32_t ip_distance(ctdb_sock_addr *ip1, ctdb_sock_addr *ip2)
    used in the main part of the algorithm.
  */
 static uint32_t ip_distance_2_sum(ctdb_sock_addr *ip,
-				  struct ctdb_public_ip_list *ips,
+				  struct public_ip_list *ips,
 				  int pnn)
 {
-	struct ctdb_public_ip_list *t;
+	struct public_ip_list *t;
 	uint32_t d;
 
 	uint32_t sum = 0;
@@ -1508,9 +1521,9 @@ static uint32_t ip_distance_2_sum(ctdb_sock_addr *ip,
 /* Return the LCP2 imbalance metric for addresses currently assigned
    to the given node.
  */
-static uint32_t lcp2_imbalance(struct ctdb_public_ip_list * all_ips, int pnn)
+static uint32_t lcp2_imbalance(struct public_ip_list * all_ips, int pnn)
 {
-	struct ctdb_public_ip_list *t;
+	struct public_ip_list *t;
 
 	uint32_t imbalance = 0;
 
@@ -1532,9 +1545,9 @@ static uint32_t lcp2_imbalance(struct ctdb_public_ip_list * all_ips, int pnn)
  */
 static void basic_allocate_unassigned(struct ctdb_context *ctdb,
 				      struct ctdb_ipflags *ipflags,
-				      struct ctdb_public_ip_list *all_ips)
+				      struct public_ip_list *all_ips)
 {
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *tmp_ip;
 
 	/* loop over all ip's and find a physical node to cover for 
 	   each unassigned ip.
@@ -1553,12 +1566,12 @@ static void basic_allocate_unassigned(struct ctdb_context *ctdb,
  */
 static void basic_failback(struct ctdb_context *ctdb,
 			   struct ctdb_ipflags *ipflags,
-			   struct ctdb_public_ip_list *all_ips,
+			   struct public_ip_list *all_ips,
 			   int num_ips)
 {
 	int i, numnodes;
 	int maxnode, maxnum, minnode, minnum, num, retries;
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *tmp_ip;
 
 	numnodes = talloc_array_length(ipflags);
 	retries = 0;
@@ -1624,7 +1637,7 @@ try_again:
 		*/
 		if ( (maxnum > minnum+1)
 		     && (retries < (num_ips + 5)) ){
-			struct ctdb_public_ip_list *tmp;
+			struct public_ip_list *tmp;
 
 			/* Reassign one of maxnode's VNNs */
 			for (tmp=all_ips;tmp;tmp=tmp->next) {
@@ -1640,13 +1653,13 @@ try_again:
 
 static void lcp2_init(struct ctdb_context *tmp_ctx,
 		      struct ctdb_ipflags *ipflags,
-		      struct ctdb_public_ip_list *all_ips,
+		      struct public_ip_list *all_ips,
 		      uint32_t *force_rebalance_nodes,
 		      uint32_t **lcp2_imbalances,
 		      bool **rebalance_candidates)
 {
 	int i, numnodes;
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *tmp_ip;
 
 	numnodes = talloc_array_length(ipflags);
 
@@ -1698,15 +1711,15 @@ static void lcp2_init(struct ctdb_context *tmp_ctx,
  */
 static void lcp2_allocate_unassigned(struct ctdb_context *ctdb,
 				     struct ctdb_ipflags *ipflags,
-				     struct ctdb_public_ip_list *all_ips,
+				     struct public_ip_list *all_ips,
 				     uint32_t *lcp2_imbalances)
 {
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *tmp_ip;
 	int dstnode, numnodes;
 
 	int minnode;
 	uint32_t mindsum, dstdsum, dstimbl, minimbl;
-	struct ctdb_public_ip_list *minip;
+	struct public_ip_list *minip;
 
 	bool should_loop = true;
 	bool have_unassigned = true;
@@ -1796,7 +1809,7 @@ static void lcp2_allocate_unassigned(struct ctdb_context *ctdb,
  */
 static bool lcp2_failback_candidate(struct ctdb_context *ctdb,
 				    struct ctdb_ipflags *ipflags,
-				    struct ctdb_public_ip_list *all_ips,
+				    struct public_ip_list *all_ips,
 				    int srcnode,
 				    uint32_t *lcp2_imbalances,
 				    bool *rebalance_candidates)
@@ -1804,8 +1817,8 @@ static bool lcp2_failback_candidate(struct ctdb_context *ctdb,
 	int dstnode, mindstnode, numnodes;
 	uint32_t srcimbl, srcdsum, dstimbl, dstdsum;
 	uint32_t minsrcimbl, mindstimbl;
-	struct ctdb_public_ip_list *minip;
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *minip;
+	struct public_ip_list *tmp_ip;
 
 	/* Find an IP and destination node that best reduces imbalance. */
 	srcimbl = 0;
@@ -1913,7 +1926,7 @@ static int lcp2_cmp_imbalance_pnn(const void * a, const void * b)
  */
 static void lcp2_failback(struct ctdb_context *ctdb,
 			  struct ctdb_ipflags *ipflags,
-			  struct ctdb_public_ip_list *all_ips,
+			  struct public_ip_list *all_ips,
 			  uint32_t *lcp2_imbalances,
 			  bool *rebalance_candidates)
 {
@@ -1967,9 +1980,9 @@ try_again:
 
 static void unassign_unsuitable_ips(struct ctdb_context *ctdb,
 				    struct ctdb_ipflags *ipflags,
-				    struct ctdb_public_ip_list *all_ips)
+				    struct public_ip_list *all_ips)
 {
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *tmp_ip;
 
 	/* verify that the assigned nodes can serve that public ip
 	   and set it to -1 if not
@@ -1991,9 +2004,9 @@ static void unassign_unsuitable_ips(struct ctdb_context *ctdb,
 
 static void ip_alloc_deterministic_ips(struct ctdb_context *ctdb,
 				       struct ctdb_ipflags *ipflags,
-				       struct ctdb_public_ip_list *all_ips)
+				       struct public_ip_list *all_ips)
 {
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *tmp_ip;
 	int i, numnodes;
 
 	numnodes = talloc_array_length(ipflags);
@@ -2025,10 +2038,10 @@ static void ip_alloc_deterministic_ips(struct ctdb_context *ctdb,
 
 static void ip_alloc_nondeterministic_ips(struct ctdb_context *ctdb,
 					  struct ctdb_ipflags *ipflags,
-					  struct ctdb_public_ip_list *all_ips)
+					  struct public_ip_list *all_ips)
 {
 	/* This should be pushed down into basic_failback. */
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *tmp_ip;
 	int num_ips = 0;
 	for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
 		num_ips++;
@@ -2051,7 +2064,7 @@ static void ip_alloc_nondeterministic_ips(struct ctdb_context *ctdb,
 
 static void ip_alloc_lcp2(struct ctdb_context *ctdb,
 			  struct ctdb_ipflags *ipflags,
-			  struct ctdb_public_ip_list *all_ips,
+			  struct public_ip_list *all_ips,
 			  uint32_t *force_rebalance_nodes)
 {
 	uint32_t *lcp2_imbalances;
@@ -2097,7 +2110,7 @@ finished:
 	talloc_free(tmp_ctx);
 }
 
-static bool all_nodes_are_disabled(struct ctdb_node_map *nodemap)
+static bool all_nodes_are_disabled(struct ctdb_node_map_old *nodemap)
 {
 	int i;
 
@@ -2114,7 +2127,7 @@ static bool all_nodes_are_disabled(struct ctdb_node_map *nodemap)
 /* The calculation part of the IP allocation algorithm. */
 static void ctdb_takeover_run_core(struct ctdb_context *ctdb,
 				   struct ctdb_ipflags *ipflags,
-				   struct ctdb_public_ip_list **all_ips_p,
+				   struct public_ip_list **all_ips_p,
 				   uint32_t *force_rebalance_nodes)
 {
 	/* since nodes only know about those public addresses that
@@ -2210,7 +2223,7 @@ static void get_tunable_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
 
 static uint32_t *get_tunable_from_nodes(struct ctdb_context *ctdb,
 					TALLOC_CTX *tmp_ctx,
-					struct ctdb_node_map *nodemap,
+					struct ctdb_node_map_old *nodemap,
 					const char *tunable,
 					uint32_t default_value)
 {
@@ -2312,7 +2325,7 @@ static void get_runstate_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
 
 static enum ctdb_runstate * get_runstate_from_nodes(struct ctdb_context *ctdb,
 						    TALLOC_CTX *tmp_ctx,
-						    struct ctdb_node_map *nodemap,
+						    struct ctdb_node_map_old *nodemap,
 						    enum ctdb_runstate default_value)
 {
 	uint32_t *nodes;
@@ -2358,7 +2371,7 @@ static enum ctdb_runstate * get_runstate_from_nodes(struct ctdb_context *ctdb,
 static struct ctdb_ipflags *
 set_ipflags_internal(struct ctdb_context *ctdb,
 		     TALLOC_CTX *tmp_ctx,
-		     struct ctdb_node_map *nodemap,
+		     struct ctdb_node_map_old *nodemap,
 		     uint32_t *tval_noiptakeover,
 		     uint32_t *tval_noiphostonalldisabled,
 		     enum ctdb_runstate *runstate)
@@ -2414,7 +2427,7 @@ set_ipflags_internal(struct ctdb_context *ctdb,
 
 static struct ctdb_ipflags *set_ipflags(struct ctdb_context *ctdb,
 					TALLOC_CTX *tmp_ctx,
-					struct ctdb_node_map *nodemap)
+					struct ctdb_node_map_old *nodemap)
 {
 	uint32_t *tval_noiptakeover;
 	uint32_t *tval_noiphostonalldisabled;
@@ -2464,7 +2477,7 @@ struct iprealloc_callback_data {
 	int retry_count;
 	client_async_callback fail_callback;
 	void *fail_callback_data;
-	struct ctdb_node_map *nodemap;
+	struct ctdb_node_map_old *nodemap;
 };
 
 static void iprealloc_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
@@ -2525,7 +2538,7 @@ struct takeover_callback_data {
 	bool *node_failed;
 	client_async_callback fail_callback;
 	void *fail_callback_data;
-	struct ctdb_node_map *nodemap;
+	struct ctdb_node_map_old *nodemap;
 };
 
 static void takeover_run_fail_callback(struct ctdb_context *ctdb,
@@ -2558,14 +2571,14 @@ static void takeover_run_fail_callback(struct ctdb_context *ctdb,
 /*
   make any IP alias changes for public addresses that are necessary 
  */
-int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap,
+int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodemap,
 		      uint32_t *force_rebalance_nodes,
 		      client_async_callback fail_callback, void *callback_data)
 {
 	int i, j, ret;
 	struct ctdb_public_ip ip;
 	uint32_t *nodes;
-	struct ctdb_public_ip_list *all_ips, *tmp_ip;
+	struct public_ip_list *all_ips, *tmp_ip;
 	TDB_DATA data;
 	struct timeval timeout;
 	struct client_async_data *async_data;
@@ -2645,7 +2658,7 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap,
 		for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
 			if (tmp_ip->pnn == nodemap->nodes[i].pnn) {
 				/* This node should be serving this
-				   vnn so dont tell it to release the ip
+				   vnn so don't tell it to release the ip
 				*/
 				continue;
 			}
@@ -2799,10 +2812,10 @@ static int ctdb_client_ip_destructor(struct ctdb_client_ip *ip)
 int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
 				TDB_DATA indata)
 {
-	struct ctdb_client *client = ctdb_reqid_find(ctdb, client_id, struct ctdb_client);
-	struct ctdb_control_tcp_addr *tcp_sock = NULL;
+	struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
+	struct ctdb_connection *tcp_sock = NULL;
 	struct ctdb_tcp_list *tcp;
-	struct ctdb_tcp_connection t;
+	struct ctdb_connection t;
 	int ret;
 	TDB_DATA data;
 	struct ctdb_client_ip *ip;
@@ -2814,15 +2827,15 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
 		return 0;
 	}
 
-	tcp_sock = (struct ctdb_control_tcp_addr *)indata.dptr;
+	tcp_sock = (struct ctdb_connection *)indata.dptr;
 
 	addr = tcp_sock->src;
 	ctdb_canonicalize_ip(&addr,  &tcp_sock->src);
-	addr = tcp_sock->dest;
-	ctdb_canonicalize_ip(&addr, &tcp_sock->dest);
+	addr = tcp_sock->dst;
+	ctdb_canonicalize_ip(&addr, &tcp_sock->dst);
 
 	ZERO_STRUCT(addr);
-	memcpy(&addr, &tcp_sock->dest, sizeof(addr));
+	memcpy(&addr, &tcp_sock->dst, sizeof(addr));
 	vnn = find_public_ip_vnn(ctdb, &addr);
 	if (vnn == NULL) {
 		switch (addr.sa.sa_family) {
@@ -2863,13 +2876,13 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
 	tcp = talloc(client, struct ctdb_tcp_list);
 	CTDB_NO_MEMORY(ctdb, tcp);
 
-	tcp->connection.src_addr = tcp_sock->src;
-	tcp->connection.dst_addr = tcp_sock->dest;
+	tcp->connection.src = tcp_sock->src;
+	tcp->connection.dst = tcp_sock->dst;
 
 	DLIST_ADD(client->tcp_list, tcp);
 
-	t.src_addr = tcp_sock->src;
-	t.dst_addr = tcp_sock->dest;
+	t.src = tcp_sock->src;
+	t.dst = tcp_sock->dst;
 
 	data.dptr = (uint8_t *)&t;
 	data.dsize = sizeof(t);
@@ -2877,13 +2890,13 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
 	switch (addr.sa.sa_family) {
 	case AF_INET:
 		DEBUG(DEBUG_INFO,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
-			(unsigned)ntohs(tcp_sock->dest.ip.sin_port), 
+			(unsigned)ntohs(tcp_sock->dst.ip.sin_port),
 			ctdb_addr_to_str(&tcp_sock->src),
 			(unsigned)ntohs(tcp_sock->src.ip.sin_port), client_id, client->pid));
 		break;
 	case AF_INET6:
 		DEBUG(DEBUG_INFO,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
-			(unsigned)ntohs(tcp_sock->dest.ip6.sin6_port), 
+			(unsigned)ntohs(tcp_sock->dst.ip6.sin6_port),
 			ctdb_addr_to_str(&tcp_sock->src),
 			(unsigned)ntohs(tcp_sock->src.ip6.sin6_port), client_id, client->pid));
 		break;
@@ -2907,8 +2920,8 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
 /*
   find a tcp address on a list
  */
-static struct ctdb_tcp_connection *ctdb_tcp_find(struct ctdb_tcp_array *array, 
-					   struct ctdb_tcp_connection *tcp)
+static struct ctdb_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
+					   struct ctdb_connection *tcp)
 {
 	int i;
 
@@ -2917,8 +2930,8 @@ static struct ctdb_tcp_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
 	}
 
 	for (i=0;i<array->num;i++) {
-		if (ctdb_same_sockaddr(&array->connections[i].src_addr, &tcp->src_addr) &&
-		    ctdb_same_sockaddr(&array->connections[i].dst_addr, &tcp->dst_addr)) {
+		if (ctdb_same_sockaddr(&array->connections[i].src, &tcp->src) &&
+		    ctdb_same_sockaddr(&array->connections[i].dst, &tcp->dst)) {
 			return &array->connections[i];
 		}
 	}
@@ -2934,9 +2947,9 @@ static struct ctdb_tcp_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
  */
 int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tcp_update_needed)
 {
-	struct ctdb_tcp_connection *p = (struct ctdb_tcp_connection *)indata.dptr;
+	struct ctdb_connection *p = (struct ctdb_connection *)indata.dptr;
 	struct ctdb_tcp_array *tcparray;
-	struct ctdb_tcp_connection tcp;
+	struct ctdb_connection tcp;
 	struct ctdb_vnn *vnn;
 
 	/* If we don't have public IPs, tickles are useless */
@@ -2944,10 +2957,10 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
 		return 0;
 	}
 
-	vnn = find_public_ip_vnn(ctdb, &p->dst_addr);
+	vnn = find_public_ip_vnn(ctdb, &p->dst);
 	if (vnn == NULL) {
 		DEBUG(DEBUG_INFO,(__location__ " got TCP_ADD control for an address which is not a public address '%s'\n",
-			ctdb_addr_to_str(&p->dst_addr)));
+			ctdb_addr_to_str(&p->dst)));
 
 		return -1;
 	}
@@ -2962,11 +2975,11 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
 		vnn->tcp_array = tcparray;
 
 		tcparray->num = 0;
-		tcparray->connections = talloc_size(tcparray, sizeof(struct ctdb_tcp_connection));
+		tcparray->connections = talloc_size(tcparray, sizeof(struct ctdb_connection));
 		CTDB_NO_MEMORY(ctdb, tcparray->connections);
 
-		tcparray->connections[tcparray->num].src_addr = p->src_addr;
-		tcparray->connections[tcparray->num].dst_addr = p->dst_addr;
+		tcparray->connections[tcparray->num].src = p->src;
+		tcparray->connections[tcparray->num].dst = p->dst;
 		tcparray->num++;
 
 		if (tcp_update_needed) {
@@ -2977,29 +2990,29 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
 
 
 	/* Do we already have this tickle ?*/
-	tcp.src_addr = p->src_addr;
-	tcp.dst_addr = p->dst_addr;
+	tcp.src = p->src;
+	tcp.dst = p->dst;
 	if (ctdb_tcp_find(tcparray, &tcp) != NULL) {
 		DEBUG(DEBUG_DEBUG,("Already had tickle info for %s:%u for vnn:%u\n",
-			ctdb_addr_to_str(&tcp.dst_addr),
-			ntohs(tcp.dst_addr.ip.sin_port),
+			ctdb_addr_to_str(&tcp.dst),
+			ntohs(tcp.dst.ip.sin_port),
 			vnn->pnn));
 		return 0;
 	}
 
 	/* A new tickle, we must add it to the array */
 	tcparray->connections = talloc_realloc(tcparray, tcparray->connections,
-					struct ctdb_tcp_connection,
+					struct ctdb_connection,
 					tcparray->num+1);
 	CTDB_NO_MEMORY(ctdb, tcparray->connections);
 
-	tcparray->connections[tcparray->num].src_addr = p->src_addr;
-	tcparray->connections[tcparray->num].dst_addr = p->dst_addr;
+	tcparray->connections[tcparray->num].src = p->src;
+	tcparray->connections[tcparray->num].dst = p->dst;
 	tcparray->num++;
 
 	DEBUG(DEBUG_INFO,("Added tickle info for %s:%u from vnn %u\n",
-		ctdb_addr_to_str(&tcp.dst_addr),
-		ntohs(tcp.dst_addr.ip.sin_port),
+		ctdb_addr_to_str(&tcp.dst),
+		ntohs(tcp.dst.ip.sin_port),
 		vnn->pnn));
 
 	if (tcp_update_needed) {
@@ -3015,36 +3028,36 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
   clients managing that should tickled with an ACK when IP takeover is
   done
  */
-static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tcp_connection *conn)
+static void ctdb_remove_connection(struct ctdb_context *ctdb, struct ctdb_connection *conn)
 {
-	struct ctdb_tcp_connection *tcpp;
-	struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, &conn->dst_addr);
+	struct ctdb_connection *tcpp;
+	struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, &conn->dst);
 
 	if (vnn == NULL) {
 		DEBUG(DEBUG_ERR,(__location__ " unable to find public address %s\n",
-			ctdb_addr_to_str(&conn->dst_addr)));
+			ctdb_addr_to_str(&conn->dst)));
 		return;
 	}
 
 	/* if the array is empty we cant remove it
-	   and we dont need to do anything
+	   and we don't need to do anything
 	 */
 	if (vnn->tcp_array == NULL) {
 		DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
-			ctdb_addr_to_str(&conn->dst_addr),
-			ntohs(conn->dst_addr.ip.sin_port)));
+			ctdb_addr_to_str(&conn->dst),
+			ntohs(conn->dst.ip.sin_port)));
 		return;
 	}
 
 
 	/* See if we know this connection
-	   if we dont know this connection  then we dont need to do anything
+	   if we don't know this connection  then we dont need to do anything
 	 */
 	tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
 	if (tcpp == NULL) {
 		DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist %s:%u\n",
-			ctdb_addr_to_str(&conn->dst_addr),
-			ntohs(conn->dst_addr.ip.sin_port)));
+			ctdb_addr_to_str(&conn->dst),
+			ntohs(conn->dst.ip.sin_port)));
 		return;
 	}
 
@@ -3068,8 +3081,8 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
 	vnn->tcp_update_needed = true;
 
 	DEBUG(DEBUG_INFO,("Removed tickle info for %s:%u\n",
-		ctdb_addr_to_str(&conn->src_addr),
-		ntohs(conn->src_addr.ip.sin_port)));
+		ctdb_addr_to_str(&conn->src),
+		ntohs(conn->src.ip.sin_port)));
 }
 
 
@@ -3079,14 +3092,14 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
  */
 int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata)
 {
-	struct ctdb_tcp_connection *conn = (struct ctdb_tcp_connection *)indata.dptr;
+	struct ctdb_connection *conn = (struct ctdb_connection *)indata.dptr;
 
 	/* If we don't have public IPs, tickles are useless */
 	if (ctdb->vnn == NULL) {
 		return 0;
 	}
 
-	ctdb_remove_tcp_connection(ctdb, conn);
+	ctdb_remove_connection(ctdb, conn);
 
 	return 0;
 }
@@ -3123,14 +3136,11 @@ void ctdb_takeover_client_destructor_hook(struct ctdb_client *client)
 	while (client->tcp_list) {
 		struct ctdb_tcp_list *tcp = client->tcp_list;
 		DLIST_REMOVE(client->tcp_list, tcp);
-		ctdb_remove_tcp_connection(client->ctdb, &tcp->connection);
+		ctdb_remove_connection(client->ctdb, &tcp->connection);
 	}
 }
 
 
-/*
-  release all IPs on shutdown
- */
 void ctdb_release_all_ips(struct ctdb_context *ctdb)
 {
 	struct ctdb_vnn *vnn;
@@ -3149,6 +3159,20 @@ void ctdb_release_all_ips(struct ctdb_context *ctdb)
 			continue;
 		}
 
+		/* Don't allow multiple releases at once.  Some code,
+		 * particularly ctdb_tickle_sentenced_connections() is
+		 * not re-entrant */
+		if (vnn->update_in_flight) {
+			DEBUG(DEBUG_WARNING,
+			      (__location__
+			       " Not releasing IP %s/%u on interface %s, an update is already in progess\n",
+				    ctdb_addr_to_str(&vnn->public_address),
+				    vnn->public_netmask_bits,
+				    ctdb_vnn_iface_string(vnn)));
+			continue;
+		}
+		vnn->update_in_flight = true;
+
 		DEBUG(DEBUG_INFO,("Release of IP %s/%u on interface %s node:-1\n",
 				    ctdb_addr_to_str(&vnn->public_address),
 				    vnn->public_netmask_bits,
@@ -3160,6 +3184,7 @@ void ctdb_release_all_ips(struct ctdb_context *ctdb)
 				  vnn->public_netmask_bits);
 		release_kill_clients(ctdb, &vnn->public_address);
 		ctdb_vnn_unassign_iface(ctdb, vnn);
+		vnn->update_in_flight = false;
 		count++;
 	}
 
@@ -3171,10 +3196,10 @@ void ctdb_release_all_ips(struct ctdb_context *ctdb)
   get list of public IPs
  */
 int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb, 
-				    struct ctdb_req_control *c, TDB_DATA *outdata)
+				    struct ctdb_req_control_old *c, TDB_DATA *outdata)
 {
 	int i, num, len;
-	struct ctdb_all_public_ips *ips;
+	struct ctdb_public_ip_list_old *ips;
 	struct ctdb_vnn *vnn;
 	bool only_available = false;
 
@@ -3188,7 +3213,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
 		num++;
 	}
 
-	len = offsetof(struct ctdb_all_public_ips, ips) + 
+	len = offsetof(struct ctdb_public_ip_list_old, ips) +
 		num*sizeof(struct ctdb_public_ip);
 	ips = talloc_zero_size(outdata, len);
 	CTDB_NO_MEMORY(ctdb, ips);
@@ -3203,7 +3228,7 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
 		i++;
 	}
 	ips->num = i;
-	len = offsetof(struct ctdb_all_public_ips, ips) +
+	len = offsetof(struct ctdb_public_ip_list_old, ips) +
 		i*sizeof(struct ctdb_public_ip);
 
 	outdata->dsize = len;
@@ -3214,13 +3239,13 @@ int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
 
 
 int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
-					struct ctdb_req_control *c,
+					struct ctdb_req_control_old *c,
 					TDB_DATA indata,
 					TDB_DATA *outdata)
 {
 	int i, num, len;
 	ctdb_sock_addr *addr;
-	struct ctdb_control_public_ip_info *info;
+	struct ctdb_public_ip_info_old *info;
 	struct ctdb_vnn *vnn;
 
 	addr = (ctdb_sock_addr *)indata.dptr;
@@ -3247,8 +3272,8 @@ int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
 		num++;
 	}
 
-	len = offsetof(struct ctdb_control_public_ip_info, ifaces) +
-		num*sizeof(struct ctdb_control_iface_info);
+	len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
+		num*sizeof(struct ctdb_iface);
 	info = talloc_zero_size(outdata, len);
 	CTDB_NO_MEMORY(ctdb, info);
 
@@ -3257,7 +3282,7 @@ int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
 	info->active_idx = 0xFFFFFFFF;
 
 	for (i=0; vnn->ifaces[i]; i++) {
-		struct ctdb_iface *cur;
+		struct ctdb_interface *cur;
 
 		cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
 		if (cur == NULL) {
@@ -3273,8 +3298,8 @@ int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
 		info->ifaces[i].references = cur->references;
 	}
 	info->num = i;
-	len = offsetof(struct ctdb_control_public_ip_info, ifaces) +
-		i*sizeof(struct ctdb_control_iface_info);
+	len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
+		i*sizeof(struct ctdb_iface);
 
 	outdata->dsize = len;
 	outdata->dptr  = (uint8_t *)info;
@@ -3283,12 +3308,12 @@ int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
 }
 
 int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
-				struct ctdb_req_control *c,
+				struct ctdb_req_control_old *c,
 				TDB_DATA *outdata)
 {
 	int i, num, len;
-	struct ctdb_control_get_ifaces *ifaces;
-	struct ctdb_iface *cur;
+	struct ctdb_iface_list_old *ifaces;
+	struct ctdb_interface *cur;
 
 	/* count how many public ip structures we have */
 	num = 0;
@@ -3296,8 +3321,8 @@ int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
 		num++;
 	}
 
-	len = offsetof(struct ctdb_control_get_ifaces, ifaces) +
-		num*sizeof(struct ctdb_control_iface_info);
+	len = offsetof(struct ctdb_iface_list_old, ifaces) +
+		num*sizeof(struct ctdb_iface);
 	ifaces = talloc_zero_size(outdata, len);
 	CTDB_NO_MEMORY(ctdb, ifaces);
 
@@ -3309,8 +3334,8 @@ int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
 		i++;
 	}
 	ifaces->num = i;
-	len = offsetof(struct ctdb_control_get_ifaces, ifaces) +
-		i*sizeof(struct ctdb_control_iface_info);
+	len = offsetof(struct ctdb_iface_list_old, ifaces) +
+		i*sizeof(struct ctdb_iface);
 
 	outdata->dsize = len;
 	outdata->dptr  = (uint8_t *)ifaces;
@@ -3319,14 +3344,14 @@ int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
 }
 
 int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
-				    struct ctdb_req_control *c,
+				    struct ctdb_req_control_old *c,
 				    TDB_DATA indata)
 {
-	struct ctdb_control_iface_info *info;
-	struct ctdb_iface *iface;
+	struct ctdb_iface *info;
+	struct ctdb_interface *iface;
 	bool link_up = false;
 
-	info = (struct ctdb_control_iface_info *)indata.dptr;
+	info = (struct ctdb_iface *)indata.dptr;
 
 	if (info->name[CTDB_IFACE_SIZE] != '\0') {
 		int len = strnlen(info->name, CTDB_IFACE_SIZE);
@@ -3382,7 +3407,7 @@ struct ctdb_kill_tcp {
 	struct ctdb_vnn *vnn;
 	struct ctdb_context *ctdb;
 	int capture_fd;
-	struct fd_event *fde;
+	struct tevent_fd *fde;
 	trbt_tree_t *connections;
 	void *private_data;
 };
@@ -3449,7 +3474,8 @@ static uint32_t *killtcp_key(ctdb_sock_addr *src, ctdb_sock_addr *dst)
 /*
   called when we get a read event on the raw socket
  */
-static void capture_tcp_handler(struct event_context *ev, struct fd_event *fde, 
+static void capture_tcp_handler(struct tevent_context *ev,
+				struct tevent_fd *fde,
 				uint16_t flags, void *private_data)
 {
 	struct ctdb_kill_tcp *killtcp = talloc_get_type(private_data, struct ctdb_kill_tcp);
@@ -3457,7 +3483,7 @@ static void capture_tcp_handler(struct event_context *ev, struct fd_event *fde,
 	ctdb_sock_addr src, dst;
 	uint32_t ack_seq, seq;
 
-	if (!(flags & EVENT_FD_READ)) {
+	if (!(flags & TEVENT_FD_READ)) {
 		return;
 	}
 
@@ -3521,7 +3547,8 @@ static int tickle_connection_traverse(void *param, void *data)
 /* 
    called every second until all sentenced connections have been reset
  */
-static void ctdb_tickle_sentenced_connections(struct event_context *ev, struct timed_event *te, 
+static void ctdb_tickle_sentenced_connections(struct tevent_context *ev,
+					      struct tevent_timer *te,
 					      struct timeval t, void *private_data)
 {
 	struct ctdb_kill_tcp *killtcp = talloc_get_type(private_data, struct ctdb_kill_tcp);
@@ -3544,8 +3571,9 @@ static void ctdb_tickle_sentenced_connections(struct event_context *ev, struct t
 
 	/* try tickling them again in a seconds time
 	 */
-	event_add_timed(killtcp->ctdb->ev, killtcp, timeval_current_ofs(1, 0), 
-			ctdb_tickle_sentenced_connections, killtcp);
+	tevent_add_timer(killtcp->ctdb->ev, killtcp,
+			 timeval_current_ofs(1, 0),
+			 ctdb_tickle_sentenced_connections, killtcp);
 }
 
 /*
@@ -3579,7 +3607,7 @@ static int ctdb_killtcp_destructor(struct ctdb_kill_tcp *killtcp)
 /* nothing fancy here, just unconditionally replace any existing
    connection structure with the new one.
 
-   dont even free the old one if it did exist, that one is talloc_stolen
+   don't even free the old one if it did exist, that one is talloc_stolen
    by the same node in the tree anyway and will be deleted when the new data 
    is deleted
 */
@@ -3656,7 +3684,7 @@ static int ctdb_killtcp_add_connection(struct ctdb_context *ctdb,
 			add_killtcp_callback, con);
 
 	/* 
-	   If we dont have a socket to listen on yet we must create it
+	   If we don't have a socket to listen on yet we must create it
 	 */
 	if (killtcp->capture_fd == -1) {
 		const char *iface = ctdb_vnn_iface_string(vnn);
@@ -3671,16 +3699,17 @@ static int ctdb_killtcp_add_connection(struct ctdb_context *ctdb,
 
 
 	if (killtcp->fde == NULL) {
-		killtcp->fde = event_add_fd(ctdb->ev, killtcp, killtcp->capture_fd, 
-					    EVENT_FD_READ,
-					    capture_tcp_handler, killtcp);
+		killtcp->fde = tevent_add_fd(ctdb->ev, killtcp,
+					     killtcp->capture_fd,
+					     TEVENT_FD_READ,
+					     capture_tcp_handler, killtcp);
 		tevent_fd_set_auto_close(killtcp->fde);
 
 		/* We also need to set up some events to tickle all these connections
 		   until they are all reset
 		*/
-		event_add_timed(ctdb->ev, killtcp, timeval_current_ofs(1, 0), 
-				ctdb_tickle_sentenced_connections, killtcp);
+		tevent_add_timer(ctdb->ev, killtcp, timeval_current_ofs(1, 0),
+				 ctdb_tickle_sentenced_connections, killtcp);
 	}
 
 	/* tickle him once now */
@@ -3702,9 +3731,9 @@ failed:
  */
 int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata)
 {
-	struct ctdb_control_killtcp *killtcp = (struct ctdb_control_killtcp *)indata.dptr;
+	struct ctdb_connection *killtcp = (struct ctdb_connection *)indata.dptr;
 
-	return ctdb_killtcp_add_connection(ctdb, &killtcp->src_addr, &killtcp->dst_addr);
+	return ctdb_killtcp_add_connection(ctdb, &killtcp->src, &killtcp->dst);
 }
 
 /*
@@ -3715,25 +3744,22 @@ int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata)
  */
 int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata)
 {
-	struct ctdb_control_tcp_tickle_list *list = (struct ctdb_control_tcp_tickle_list *)indata.dptr;
+	struct ctdb_tickle_list_old *list = (struct ctdb_tickle_list_old *)indata.dptr;
 	struct ctdb_tcp_array *tcparray;
 	struct ctdb_vnn *vnn;
 
 	/* We must at least have tickles.num or else we cant verify the size
 	   of the received data blob
 	 */
-	if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list, 
-					tickles.connections)) {
-		DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_set_tcp_tickle_list. Not enough data for the tickle.num field\n"));
+	if (indata.dsize < offsetof(struct ctdb_tickle_list_old, connections)) {
+		DEBUG(DEBUG_ERR,("Bad indata in ctdb_tickle_list. Not enough data for the tickle.num field\n"));
 		return -1;
 	}
 
 	/* verify that the size of data matches what we expect */
-	if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list, 
-				tickles.connections)
-			 + sizeof(struct ctdb_tcp_connection)
-				 * list->tickles.num) {
-		DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_set_tcp_tickle_list\n"));
+	if (indata.dsize < offsetof(struct ctdb_tickle_list_old, connections)
+			 + sizeof(struct ctdb_connection) * list->num) {
+		DEBUG(DEBUG_ERR,("Bad indata in ctdb_tickle_list\n"));
 		return -1;
 	}
 
@@ -3755,13 +3781,13 @@ int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
 	tcparray = talloc(vnn, struct ctdb_tcp_array);
 	CTDB_NO_MEMORY(ctdb, tcparray);
 
-	tcparray->num = list->tickles.num;
+	tcparray->num = list->num;
 
-	tcparray->connections = talloc_array(tcparray, struct ctdb_tcp_connection, tcparray->num);
+	tcparray->connections = talloc_array(tcparray, struct ctdb_connection, tcparray->num);
 	CTDB_NO_MEMORY(ctdb, tcparray->connections);
 
-	memcpy(tcparray->connections, &list->tickles.connections[0],
-	       sizeof(struct ctdb_tcp_connection)*tcparray->num);
+	memcpy(tcparray->connections, &list->connections[0],
+	       sizeof(struct ctdb_connection)*tcparray->num);
 
 	/* We now have a new fresh tickle list array for this vnn */
 	vnn->tcp_array = tcparray;
@@ -3776,7 +3802,7 @@ int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
 int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata)
 {
 	ctdb_sock_addr *addr = (ctdb_sock_addr *)indata.dptr;
-	struct ctdb_control_tcp_tickle_list *list;
+	struct ctdb_tickle_list_old *list;
 	struct ctdb_tcp_array *tcparray;
 	int num;
 	struct ctdb_vnn *vnn;
@@ -3796,19 +3822,18 @@ int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
 		num = 0;
 	}
 
-	outdata->dsize = offsetof(struct ctdb_control_tcp_tickle_list, 
-				tickles.connections)
-			+ sizeof(struct ctdb_tcp_connection) * num;
+	outdata->dsize = offsetof(struct ctdb_tickle_list_old, connections)
+			+ sizeof(struct ctdb_connection) * num;
 
 	outdata->dptr  = talloc_size(outdata, outdata->dsize);
 	CTDB_NO_MEMORY(ctdb, outdata->dptr);
-	list = (struct ctdb_control_tcp_tickle_list *)outdata->dptr;
+	list = (struct ctdb_tickle_list_old *)outdata->dptr;
 
 	list->addr = *addr;
-	list->tickles.num = num;
+	list->num = num;
 	if (num) {
-		memcpy(&list->tickles.connections[0], tcparray->connections, 
-			sizeof(struct ctdb_tcp_connection) * num);
+		memcpy(&list->connections[0], tcparray->connections,
+			sizeof(struct ctdb_connection) * num);
 	}
 
 	return 0;
@@ -3824,7 +3849,7 @@ static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
 {
 	int ret, num;
 	TDB_DATA data;
-	struct ctdb_control_tcp_tickle_list *list;
+	struct ctdb_tickle_list_old *list;
 
 	if (tcparray) {
 		num = tcparray->num;
@@ -3832,17 +3857,16 @@ static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
 		num = 0;
 	}
 
-	data.dsize = offsetof(struct ctdb_control_tcp_tickle_list, 
-				tickles.connections) +
-			sizeof(struct ctdb_tcp_connection) * num;
+	data.dsize = offsetof(struct ctdb_tickle_list_old, connections) +
+			sizeof(struct ctdb_connection) * num;
 	data.dptr = talloc_size(ctdb, data.dsize);
 	CTDB_NO_MEMORY(ctdb, data.dptr);
 
-	list = (struct ctdb_control_tcp_tickle_list *)data.dptr;
+	list = (struct ctdb_tickle_list_old *)data.dptr;
 	list->addr = *addr;
-	list->tickles.num = num;
+	list->num = num;
 	if (tcparray) {
-		memcpy(&list->tickles.connections[0], tcparray->connections, sizeof(struct ctdb_tcp_connection) * num);
+		memcpy(&list->connections[0], tcparray->connections, sizeof(struct ctdb_connection) * num);
 	}
 
 	ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_ALL, 0,
@@ -3862,9 +3886,9 @@ static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
 /*
   perform tickle updates if required
  */
-static void ctdb_update_tcp_tickles(struct event_context *ev, 
-				struct timed_event *te, 
-				struct timeval t, void *private_data)
+static void ctdb_update_tcp_tickles(struct tevent_context *ev,
+				    struct tevent_timer *te,
+				    struct timeval t, void *private_data)
 {
 	struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);
 	int ret;
@@ -3895,11 +3919,10 @@ static void ctdb_update_tcp_tickles(struct event_context *ev,
 		}
 	}
 
-	event_add_timed(ctdb->ev, ctdb->tickle_update_context,
-			     timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0), 
-			     ctdb_update_tcp_tickles, ctdb);
-}		
-	
+	tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
+			 timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
+			 ctdb_update_tcp_tickles, ctdb);
+}
 
 /*
   start periodic update of tcp tickles
@@ -3908,9 +3931,9 @@ void ctdb_start_tcp_tickle_update(struct ctdb_context *ctdb)
 {
 	ctdb->tickle_update_context = talloc_new(ctdb);
 
-	event_add_timed(ctdb->ev, ctdb->tickle_update_context,
-			     timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0), 
-			     ctdb_update_tcp_tickles, ctdb);
+	tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
+			 timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
+			 ctdb_update_tcp_tickles, ctdb);
 }
 
 
@@ -3926,8 +3949,9 @@ struct control_gratious_arp {
 /*
   send a control_gratuitous arp
  */
-static void send_gratious_arp(struct event_context *ev, struct timed_event *te, 
-				  struct timeval t, void *private_data)
+static void send_gratious_arp(struct tevent_context *ev,
+			      struct tevent_timer *te,
+			      struct timeval t, void *private_data)
 {
 	int ret;
 	struct control_gratious_arp *arp = talloc_get_type(private_data, 
@@ -3946,9 +3970,9 @@ static void send_gratious_arp(struct event_context *ev, struct timed_event *te,
 		return;
 	}
 
-	event_add_timed(arp->ctdb->ev, arp, 
-			timeval_current_ofs(CTDB_ARP_INTERVAL, 0), 
-			send_gratious_arp, arp);
+	tevent_add_timer(arp->ctdb->ev, arp,
+			 timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
+			 send_gratious_arp, arp);
 }
 
 
@@ -3957,24 +3981,24 @@ static void send_gratious_arp(struct event_context *ev, struct timed_event *te,
  */
 int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb, TDB_DATA indata)
 {
-	struct ctdb_control_gratious_arp *gratious_arp = (struct ctdb_control_gratious_arp *)indata.dptr;
+	struct ctdb_addr_info_old *gratious_arp = (struct ctdb_addr_info_old *)indata.dptr;
 	struct control_gratious_arp *arp;
 
 	/* verify the size of indata */
-	if (indata.dsize < offsetof(struct ctdb_control_gratious_arp, iface)) {
+	if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
 		DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_control_gratious_arp structure. Got %u require %u bytes\n", 
 				 (unsigned)indata.dsize, 
-				 (unsigned)offsetof(struct ctdb_control_gratious_arp, iface)));
+				 (unsigned)offsetof(struct ctdb_addr_info_old, iface)));
 		return -1;
 	}
 	if (indata.dsize != 
-		( offsetof(struct ctdb_control_gratious_arp, iface)
+		( offsetof(struct ctdb_addr_info_old, iface)
 		+ gratious_arp->len ) ){
 
 		DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
 			"but should be %u bytes\n", 
 			 (unsigned)indata.dsize, 
-			 (unsigned)(offsetof(struct ctdb_control_gratious_arp, iface)+gratious_arp->len)));
+			 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+gratious_arp->len)));
 		return -1;
 	}
 
@@ -3987,31 +4011,31 @@ int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb, TDB_DATA indat
 	arp->iface = talloc_strdup(arp, gratious_arp->iface);
 	CTDB_NO_MEMORY(ctdb, arp->iface);
 	arp->count = 0;
-	
-	event_add_timed(arp->ctdb->ev, arp, 
-			timeval_zero(), send_gratious_arp, arp);
+
+	tevent_add_timer(arp->ctdb->ev, arp,
+			 timeval_zero(), send_gratious_arp, arp);
 
 	return 0;
 }
 
 int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
 {
-	struct ctdb_control_ip_iface *pub = (struct ctdb_control_ip_iface *)indata.dptr;
+	struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
 	int ret;
 
 	/* verify the size of indata */
-	if (indata.dsize < offsetof(struct ctdb_control_ip_iface, iface)) {
-		DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_control_ip_iface structure\n"));
+	if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
+		DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_addr_info structure\n"));
 		return -1;
 	}
 	if (indata.dsize != 
-		( offsetof(struct ctdb_control_ip_iface, iface)
+		( offsetof(struct ctdb_addr_info_old, iface)
 		+ pub->len ) ){
 
 		DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
 			"but should be %u bytes\n", 
 			 (unsigned)indata.dsize, 
-			 (unsigned)(offsetof(struct ctdb_control_ip_iface, iface)+pub->len)));
+			 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+pub->len)));
 		return -1;
 	}
 
@@ -4028,7 +4052,7 @@ int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA inda
 }
 
 struct delete_ip_callback_state {
-	struct ctdb_req_control *c;
+	struct ctdb_req_control_old *c;
 };
 
 /*
@@ -4048,25 +4072,25 @@ static void delete_ip_callback(struct ctdb_context *ctdb,
 }
 
 int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
-					struct ctdb_req_control *c,
+					struct ctdb_req_control_old *c,
 					TDB_DATA indata, bool *async_reply)
 {
-	struct ctdb_control_ip_iface *pub = (struct ctdb_control_ip_iface *)indata.dptr;
+	struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
 	struct ctdb_vnn *vnn;
 
 	/* verify the size of indata */
-	if (indata.dsize < offsetof(struct ctdb_control_ip_iface, iface)) {
-		DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_control_ip_iface structure\n"));
+	if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
+		DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_addr_info structure\n"));
 		return -1;
 	}
 	if (indata.dsize != 
-		( offsetof(struct ctdb_control_ip_iface, iface)
+		( offsetof(struct ctdb_addr_info_old, iface)
 		+ pub->len ) ){
 
 		DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
 			"but should be %u bytes\n", 
 			 (unsigned)indata.dsize, 
-			 (unsigned)(offsetof(struct ctdb_control_ip_iface, iface)+pub->len)));
+			 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+pub->len)));
 		return -1;
 	}
 
@@ -4137,7 +4161,7 @@ int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
 
 
 struct ipreallocated_callback_state {
-	struct ctdb_req_control *c;
+	struct ctdb_req_control_old *c;
 };
 
 static void ctdb_ipreallocated_callback(struct ctdb_context *ctdb,
@@ -4161,7 +4185,7 @@ static void ctdb_ipreallocated_callback(struct ctdb_context *ctdb,
 
 /* A control to run the ipreallocated event */
 int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
-				   struct ctdb_req_control *c,
+				   struct ctdb_req_control_old *c,
 				   bool *async_reply)
 {
 	int ret;
@@ -4196,14 +4220,14 @@ int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
    This is verified against ctdb->ip_tree
 */
 int verify_remote_ip_allocation(struct ctdb_context *ctdb,
-				struct ctdb_all_public_ips *ips,
+				struct ctdb_public_ip_list_old *ips,
 				uint32_t pnn)
 {
-	struct ctdb_public_ip_list *tmp_ip; 
+	struct public_ip_list *tmp_ip;
 	int i;
 
 	if (ctdb->ip_tree == NULL) {
-		/* dont know the expected allocation yet, assume remote node
+		/* don't know the expected allocation yet, assume remote node
 		   is correct. */
 		return 0;
 	}
@@ -4238,7 +4262,7 @@ int verify_remote_ip_allocation(struct ctdb_context *ctdb,
 
 int update_ip_assignment_tree(struct ctdb_context *ctdb, struct ctdb_public_ip *ip)
 {
-	struct ctdb_public_ip_list *tmp_ip;
+	struct public_ip_list *tmp_ip;
 
 	/* IP tree is never built if DisableIPFailover is set */
 	if (ctdb->tunable.disable_ip_failover != 0) {
@@ -4262,14 +4286,18 @@ int update_ip_assignment_tree(struct ctdb_context *ctdb, struct ctdb_public_ip *
 	return 0;
 }
 
+void clear_ip_assignment_tree(struct ctdb_context *ctdb)
+{
+	TALLOC_FREE(ctdb->ip_tree);
+}
 
 struct ctdb_reloadips_handle {
 	struct ctdb_context *ctdb;
-	struct ctdb_req_control *c;
+	struct ctdb_req_control_old *c;
 	int status;
 	int fd[2];
 	pid_t child;
-	struct fd_event *fde;
+	struct tevent_fd *fde;
 };
 
 static int ctdb_reloadips_destructor(struct ctdb_reloadips_handle *h)
@@ -4285,17 +4313,18 @@ static int ctdb_reloadips_destructor(struct ctdb_reloadips_handle *h)
 	return 0;
 }
 
-static void ctdb_reloadips_timeout_event(struct event_context *ev,
-				struct timed_event *te,
-				struct timeval t, void *private_data)
+static void ctdb_reloadips_timeout_event(struct tevent_context *ev,
+					 struct tevent_timer *te,
+					 struct timeval t, void *private_data)
 {
 	struct ctdb_reloadips_handle *h = talloc_get_type(private_data, struct ctdb_reloadips_handle);
 
 	talloc_free(h);
-}	
+}
 
-static void ctdb_reloadips_child_handler(struct event_context *ev, struct fd_event *fde, 
-			     uint16_t flags, void *private_data)
+static void ctdb_reloadips_child_handler(struct tevent_context *ev,
+					 struct tevent_fd *fde,
+					 uint16_t flags, void *private_data)
 {
 	struct ctdb_reloadips_handle *h = talloc_get_type(private_data, struct ctdb_reloadips_handle);
 
@@ -4315,7 +4344,7 @@ static void ctdb_reloadips_child_handler(struct event_context *ev, struct fd_eve
 static int ctdb_reloadips_child(struct ctdb_context *ctdb)
 {
 	TALLOC_CTX *mem_ctx = talloc_new(NULL);
-	struct ctdb_all_public_ips *ips;
+	struct ctdb_public_ip_list_old *ips;
 	struct ctdb_vnn *vnn;
 	struct client_async_data *async_data;
 	struct timeval timeout;
@@ -4360,14 +4389,13 @@ static int ctdb_reloadips_child(struct ctdb_context *ctdb)
 
 		if (vnn == NULL) {
 			/* Delete IP ips->ips[i] */
-			struct ctdb_control_ip_iface *pub;
+			struct ctdb_addr_info_old *pub;
 
 			DEBUG(DEBUG_NOTICE,
 			      ("IP %s no longer configured, deleting it\n",
 			       ctdb_addr_to_str(&ips->ips[i].addr)));
 
-			pub = talloc_zero(mem_ctx,
-					  struct ctdb_control_ip_iface);
+			pub = talloc_zero(mem_ctx, struct ctdb_addr_info_old);
 			CTDB_NO_MEMORY(ctdb, pub);
 
 			pub->addr  = ips->ips[i].addr;
@@ -4376,7 +4404,7 @@ static int ctdb_reloadips_child(struct ctdb_context *ctdb)
 
 			timeout = TAKEOVER_TIMEOUT();
 
-			data.dsize = offsetof(struct ctdb_control_ip_iface,
+			data.dsize = offsetof(struct ctdb_addr_info_old,
 					      iface) + pub->len;
 			data.dptr = (uint8_t *)pub;
 
@@ -4407,7 +4435,7 @@ static int ctdb_reloadips_child(struct ctdb_context *ctdb)
 		}
 		if (i == ips->num) {
 			/* Add IP ips->ips[i] */
-			struct ctdb_control_ip_iface *pub;
+			struct ctdb_addr_info_old *pub;
 			const char *ifaces = NULL;
 			uint32_t len;
 			int iface = 0;
@@ -4444,7 +4472,7 @@ static int ctdb_reloadips_child(struct ctdb_context *ctdb)
 
 			len   = strlen(ifaces) + 1;
 			pub = talloc_zero_size(mem_ctx,
-					       offsetof(struct ctdb_control_ip_iface, iface) + len);
+					       offsetof(struct ctdb_addr_info_old, iface) + len);
 			CTDB_NO_MEMORY(ctdb, pub);
 
 			pub->addr  = vnn->public_address;
@@ -4454,7 +4482,7 @@ static int ctdb_reloadips_child(struct ctdb_context *ctdb)
 
 			timeout = TAKEOVER_TIMEOUT();
 
-			data.dsize = offsetof(struct ctdb_control_ip_iface,
+			data.dsize = offsetof(struct ctdb_addr_info_old,
 					      iface) + pub->len;
 			data.dptr = (uint8_t *)pub;
 
@@ -4490,7 +4518,7 @@ failed:
    and drop any addresses we should nnot longer host, and add new addresses
    that we are now able to host
 */
-int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply)
+int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control_old *c, bool *async_reply)
 {
 	struct ctdb_reloadips_handle *h;
 	pid_t parent = getpid();
@@ -4555,14 +4583,12 @@ int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_re
 	talloc_set_destructor(h, ctdb_reloadips_destructor);
 
 
-	h->fde = event_add_fd(ctdb->ev, h, h->fd[0],
-			EVENT_FD_READ, ctdb_reloadips_child_handler,
-			(void *)h);
+	h->fde = tevent_add_fd(ctdb->ev, h, h->fd[0], TEVENT_FD_READ,
+			       ctdb_reloadips_child_handler, (void *)h);
 	tevent_fd_set_auto_close(h->fde);
 
-	event_add_timed(ctdb->ev, h,
-			timeval_current_ofs(120, 0),
-			ctdb_reloadips_timeout_event, h);
+	tevent_add_timer(ctdb->ev, h, timeval_current_ofs(120, 0),
+			 ctdb_reloadips_timeout_event, h);
 
 	/* we reply later */
 	*async_reply = true;