ctdb-daemon: Rename struct ctdb_tcp_connection to ctdb_connection

Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>

7 files changed, 84 insertions, 93 deletions

diff --git a/ctdb/client/ctdb_client.c b/ctdb/client/ctdb_client.c
index ec83cea3bb6..7ab0545a56a 100644
--- a/ctdb/client/ctdb_client.c
+++ b/ctdb/client/ctdb_client.c
@@ -3113,13 +3113,13 @@ int ctdb_ctrl_del_public_ip(struct ctdb_context *ctdb,
 int ctdb_ctrl_killtcp(struct ctdb_context *ctdb, 
 		      struct timeval timeout, 
 		      uint32_t destnode,
-		      struct ctdb_tcp_connection *killtcp)
+		      struct ctdb_connection *killtcp)
 {
 	TDB_DATA data;
 	int32_t res;
 	int ret;
 
-	data.dsize = sizeof(struct ctdb_tcp_connection);
+	data.dsize = sizeof(struct ctdb_connection);
 	data.dptr  = (unsigned char *)killtcp;
 
 	ret = ctdb_control(ctdb, destnode, 0, CTDB_CONTROL_KILL_TCP, 0, data, NULL,
diff --git a/ctdb/include/ctdb_client.h b/ctdb/include/ctdb_client.h
index cf3203a34ac..2138b916f59 100644
--- a/ctdb/include/ctdb_client.h
+++ b/ctdb/include/ctdb_client.h
@@ -408,7 +408,7 @@ int ctdb_ctrl_del_public_ip(struct ctdb_context *ctdb,
 
 int ctdb_ctrl_killtcp(struct ctdb_context *ctdb,
 		      struct timeval timeout, uint32_t destnode,
-		      struct ctdb_tcp_connection *killtcp);
+		      struct ctdb_connection *killtcp);
 
 int ctdb_ctrl_gratious_arp(struct ctdb_context *ctdb,
 			   struct timeval timeout, uint32_t destnode,
diff --git a/ctdb/include/ctdb_private.h b/ctdb/include/ctdb_private.h
index f87c4f368d9..372375a2d05 100644
--- a/ctdb/include/ctdb_private.h
+++ b/ctdb/include/ctdb_private.h
@@ -28,7 +28,7 @@
  */
 struct ctdb_tcp_array {
 	uint32_t num;
-	struct ctdb_tcp_connection *connections;
+	struct ctdb_connection *connections;
 };
 
 /*
diff --git a/ctdb/include/ctdb_protocol.h b/ctdb/include/ctdb_protocol.h
index 36bc3852da4..82910ebaffd 100644
--- a/ctdb/include/ctdb_protocol.h
+++ b/ctdb/include/ctdb_protocol.h
@@ -837,19 +837,10 @@ struct srvid_request_data {
 	uint32_t data;
 };
 
-/*
-  a tcp connection description
-  also used by tcp_add and tcp_remove controls
- */
-struct ctdb_tcp_connection {
-	ctdb_sock_addr src_addr;
-	ctdb_sock_addr dst_addr;
-};
-
 /* the wire representation for a tcp tickle array */
 struct ctdb_tcp_wire_array {
 	uint32_t num;
-	struct ctdb_tcp_connection connections[1];
+	struct ctdb_connection connections[1];
 };
 
 /* the list of tcp tickles used by get/set tcp tickle list */
diff --git a/ctdb/server/ctdb_control.c b/ctdb/server/ctdb_control.c
index b87f9d9df6c..2dc64f80be2 100644
--- a/ctdb/server/ctdb_control.c
+++ b/ctdb/server/ctdb_control.c
@@ -383,15 +383,15 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
 		return ctdb_control_startup(ctdb, srcnode);
 
 	case CTDB_CONTROL_TCP_ADD: 
-		CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection));
+		CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
 		return ctdb_control_tcp_add(ctdb, indata, false);
 
 	case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE: 
-		CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection));
+		CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
 		return ctdb_control_tcp_add(ctdb, indata, true);
 
 	case CTDB_CONTROL_TCP_REMOVE: 
-		CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection));
+		CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
 		return ctdb_control_tcp_remove(ctdb, indata);
 
 	case CTDB_CONTROL_SET_TUNABLE:
@@ -408,7 +408,7 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
 		return ctdb_control_modflags(ctdb, indata);
 
 	case CTDB_CONTROL_KILL_TCP: 
-		CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection));
+		CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
 		return ctdb_control_kill_tcp(ctdb, indata);
 
 	case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
diff --git a/ctdb/server/ctdb_takeover.c b/ctdb/server/ctdb_takeover.c
index 353877175e6..362bd31f571 100644
--- a/ctdb/server/ctdb_takeover.c
+++ b/ctdb/server/ctdb_takeover.c
@@ -299,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;
 };
 
 /*
@@ -335,20 +335,20 @@ static void ctdb_control_send_arp(struct tevent_context *ev,
 	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)));
 			}
 		}
 	}
@@ -2815,7 +2815,7 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
 	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;
@@ -2876,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->dst;
+	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->dst;
+	t.src = tcp_sock->src;
+	t.dst = tcp_sock->dst;
 
 	data.dptr = (uint8_t *)&t;
 	data.dsize = sizeof(t);
@@ -2920,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;
 
@@ -2930,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];
 		}
 	}
@@ -2947,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 */
@@ -2957,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;
 	}
@@ -2975,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) {
@@ -2990,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) {
@@ -3028,14 +3028,14 @@ 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;
 	}
 
@@ -3044,8 +3044,8 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
 	 */
 	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;
 	}
 
@@ -3056,8 +3056,8 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
 	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;
 	}
 
@@ -3081,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)));
 }
 
 
@@ -3092,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;
 }
@@ -3136,7 +3136,7 @@ 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);
 	}
 }
 
@@ -3731,9 +3731,9 @@ failed:
  */
 int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata)
 {
-	struct ctdb_tcp_connection *killtcp = (struct ctdb_tcp_connection *)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);
 }
 
 /*
@@ -3760,7 +3760,7 @@ int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
 	/* 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)
+			 + sizeof(struct ctdb_connection)
 				 * list->tickles.num) {
 		DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_set_tcp_tickle_list\n"));
 		return -1;
@@ -3786,11 +3786,11 @@ int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
 
 	tcparray->num = list->tickles.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);
+	       sizeof(struct ctdb_connection)*tcparray->num);
 
 	/* We now have a new fresh tickle list array for this vnn */
 	vnn->tcp_array = tcparray;
@@ -3827,7 +3827,7 @@ int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
 
 	outdata->dsize = offsetof(struct ctdb_control_tcp_tickle_list, 
 				tickles.connections)
-			+ sizeof(struct ctdb_tcp_connection) * num;
+			+ sizeof(struct ctdb_connection) * num;
 
 	outdata->dptr  = talloc_size(outdata, outdata->dsize);
 	CTDB_NO_MEMORY(ctdb, outdata->dptr);
@@ -3837,7 +3837,7 @@ int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
 	list->tickles.num = num;
 	if (num) {
 		memcpy(&list->tickles.connections[0], tcparray->connections, 
-			sizeof(struct ctdb_tcp_connection) * num);
+			sizeof(struct ctdb_connection) * num);
 	}
 
 	return 0;
@@ -3863,7 +3863,7 @@ static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
 
 	data.dsize = offsetof(struct ctdb_control_tcp_tickle_list, 
 				tickles.connections) +
-			sizeof(struct ctdb_tcp_connection) * num;
+			sizeof(struct ctdb_connection) * num;
 	data.dptr = talloc_size(ctdb, data.dsize);
 	CTDB_NO_MEMORY(ctdb, data.dptr);
 
@@ -3871,7 +3871,7 @@ static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
 	list->addr = *addr;
 	list->tickles.num = num;
 	if (tcparray) {
-		memcpy(&list->tickles.connections[0], tcparray->connections, sizeof(struct ctdb_tcp_connection) * num);
+		memcpy(&list->tickles.connections[0], tcparray->connections, sizeof(struct ctdb_connection) * num);
 	}
 
 	ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_ALL, 0,
diff --git a/ctdb/tools/ctdb.c b/ctdb/tools/ctdb.c
index ca0a7f5e4c7..2c148b02ce4 100644
--- a/ctdb/tools/ctdb.c
+++ b/ctdb/tools/ctdb.c
@@ -1615,7 +1615,7 @@ static int control_recmaster(struct ctdb_context *ctdb, int argc, const char **a
  */
 static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **argv)
 {
-	struct ctdb_tcp_connection t;
+	struct ctdb_connection t;
 	TDB_DATA data;
 	int ret;
 
@@ -1625,11 +1625,11 @@ static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **
 		usage();
 	}
 
-	if (parse_ip_port(argv[0], &t.src_addr) == 0) {
+	if (parse_ip_port(argv[0], &t.src) == 0) {
 		DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
 		return -1;
 	}
-	if (parse_ip_port(argv[1], &t.dst_addr) == 0) {
+	if (parse_ip_port(argv[1], &t.dst) == 0) {
 		DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1]));
 		return -1;
 	}
@@ -1654,7 +1654,7 @@ static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **
  */
 static int control_del_tickle(struct ctdb_context *ctdb, int argc, const char **argv)
 {
-	struct ctdb_tcp_connection t;
+	struct ctdb_connection t;
 	TDB_DATA data;
 	int ret;
 
@@ -1664,11 +1664,11 @@ static int control_del_tickle(struct ctdb_context *ctdb, int argc, const char **
 		usage();
 	}
 
-	if (parse_ip_port(argv[0], &t.src_addr) == 0) {
+	if (parse_ip_port(argv[0], &t.src) == 0) {
 		DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
 		return -1;
 	}
-	if (parse_ip_port(argv[1], &t.dst_addr) == 0) {
+	if (parse_ip_port(argv[1], &t.dst) == 0) {
 		DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1]));
 		return -1;
 	}
@@ -1722,21 +1722,21 @@ static int control_get_tickles(struct ctdb_context *ctdb, int argc, const char *
 	if (options.machinereadable){
 		printm(":source ip:port:destination ip:port:\n");
 		for (i=0;i<list->tickles.num;i++) {
-			if (port && port != ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)) {
+			if (port && port != ntohs(list->tickles.connections[i].dst.ip.sin_port)) {
 				continue;
 			}
-			printm(":%s:%u", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port));
-			printm(":%s:%u:\n", ctdb_addr_to_str(&list->tickles.connections[i].dst_addr), ntohs(list->tickles.connections[i].dst_addr.ip.sin_port));
+			printm(":%s:%u", ctdb_addr_to_str(&list->tickles.connections[i].src), ntohs(list->tickles.connections[i].src.ip.sin_port));
+			printm(":%s:%u:\n", ctdb_addr_to_str(&list->tickles.connections[i].dst), ntohs(list->tickles.connections[i].dst.ip.sin_port));
 		}
 	} else {
 		printf("Tickles for ip:%s\n", ctdb_addr_to_str(&list->addr));
 		printf("Num tickles:%u\n", list->tickles.num);
 		for (i=0;i<list->tickles.num;i++) {
-			if (port && port != ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)) {
+			if (port && port != ntohs(list->tickles.connections[i].dst.ip.sin_port)) {
 				continue;
 			}
-			printf("SRC: %s:%u   ", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port));
-			printf("DST: %s:%u\n", ctdb_addr_to_str(&list->tickles.connections[i].dst_addr), ntohs(list->tickles.connections[i].dst_addr.ip.sin_port));
+			printf("SRC: %s:%u   ", ctdb_addr_to_str(&list->tickles.connections[i].src), ntohs(list->tickles.connections[i].src.ip.sin_port));
+			printf("DST: %s:%u\n", ctdb_addr_to_str(&list->tickles.connections[i].dst), ntohs(list->tickles.connections[i].dst.ip.sin_port));
 		}
 	}
 
@@ -2619,7 +2619,7 @@ static int control_delip(struct ctdb_context *ctdb, int argc, const char **argv)
 static int kill_tcp_from_file(struct ctdb_context *ctdb,
 			      int argc, const char **argv)
 {
-	struct ctdb_tcp_connection *killtcp;
+	struct ctdb_connection *killtcp;
 	int max_entries, current, i;
 	struct timeval timeout;
 	char line[128], src[128], dst[128];
@@ -2656,19 +2656,19 @@ static int kill_tcp_from_file(struct ctdb_context *ctdb,
 		if (current >= max_entries) {
 			max_entries += 1024;
 			killtcp = talloc_realloc(ctdb, killtcp,
-						 struct ctdb_tcp_connection,
+						 struct ctdb_connection,
 						 max_entries);
 			CTDB_NO_MEMORY(ctdb, killtcp);
 		}
 
-		if (!parse_ip_port(src, &killtcp[current].src_addr)) {
+		if (!parse_ip_port(src, &killtcp[current].src)) {
 			DEBUG(DEBUG_ERR, ("Bad IP:port on line [%d]: '%s'\n",
 					  linenum, src));
 			talloc_free(killtcp);
 			return -1;
 		}
 
-		if (!parse_ip_port(dst, &killtcp[current].dst_addr)) {
+		if (!parse_ip_port(dst, &killtcp[current].dst)) {
 			DEBUG(DEBUG_ERR, ("Bad IP:port on line [%d]: '%s'\n",
 					  linenum, dst));
 			talloc_free(killtcp);
@@ -2686,7 +2686,7 @@ static int kill_tcp_from_file(struct ctdb_context *ctdb,
 
 	for (i = 0; i < current; i++) {
 
-		data.dsize = sizeof(struct ctdb_tcp_connection);
+		data.dsize = sizeof(struct ctdb_connection);
 		data.dptr  = (unsigned char *)&killtcp[i];
 
 		timeout = TIMELIMIT();
@@ -2722,7 +2722,7 @@ static int kill_tcp_from_file(struct ctdb_context *ctdb,
 static int kill_tcp(struct ctdb_context *ctdb, int argc, const char **argv)
 {
 	int ret;
-	struct ctdb_tcp_connection killtcp;
+	struct ctdb_connection killtcp;
 
 	assert_single_node_only();
 
@@ -2734,12 +2734,12 @@ static int kill_tcp(struct ctdb_context *ctdb, int argc, const char **argv)
 		usage();
 	}
 
-	if (!parse_ip_port(argv[0], &killtcp.src_addr)) {
+	if (!parse_ip_port(argv[0], &killtcp.src)) {
 		DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[0]));
 		return -1;
 	}
 
-	if (!parse_ip_port(argv[1], &killtcp.dst_addr)) {
+	if (!parse_ip_port(argv[1], &killtcp.dst)) {
 		DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[1]));
 		return -1;
 	}