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>

diff --git a/ctdb/client/ctdb_client.c b/ctdb/client/ctdb_client.c
index ec83cea3bb6f44211cc1d891e92770c50d26cf4a..7ab0545a56a874ac5bf570835ae97593156eb2b3 100644 (file)
--- 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 cf3203a34ac434d02f1fdf5c4335a652200fd2eb..2138b916f59a87df83113691521d279649760390 100644 (file)
--- 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 f87c4f368d97d518c1e1fb687a8d778a08096df6..372375a2d056fcdc25da3db735b1deaa6115242e 100644 (file)
--- 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 36bc3852da4cb3952c274aadd0a61c9cfea49280..82910ebaffdcb0139c98aac307b2ad28751a128f 100644 (file)
--- 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 b87f9d9df6cb507b83182014cd1b8b808115eb30..2dc64f80be230af53fe0b94b9f989790c4ce5556 100644 (file)
--- 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 353877175e6c5ebd6de81b853cef903826bf7ade..362bd31f571d061b62b634c10ba1767e784f77dc 100644 (file)
--- 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 ca0a7f5e4c72f06b10d986bd4442deb959b500ca..2c148b02ce4cba8b3edc6c8cb5e74d8889f536f3 100644 (file)
--- 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;
        }