ctdb-daemon: Move interface addition into interface parsing
[metze/samba/wip.git] / ctdb / server / ctdb_takeover.c
index f263fce296c7b0970a29829481802d6286bcf064..f34803217f0b3b79c28e5920eda7199a2929bc5f 100644 (file)
 #include "common/common.h"
 #include "common/logging.h"
 
+#include "server/ipalloc.h"
 
 #define TAKEOVER_TIMEOUT() timeval_current_ofs(ctdb->tunable.takeover_timeout,0)
 
 #define CTDB_ARP_INTERVAL 1
 #define CTDB_ARP_REPEAT   3
 
-/* Flags used in IP allocation algorithms. */
-struct ctdb_ipflags {
-       bool noiptakeover;
-       bool noiphost;
+struct ctdb_interface {
+       struct ctdb_interface *prev, *next;
+       const char *name;
+       bool link_up;
+       uint32_t references;
 };
 
-enum ipalloc_algorithm {
-       IPALLOC_DETERMINISTIC,
-       IPALLOC_NONDETERMINISTIC,
-       IPALLOC_LCP2,
-};
+/* state associated with a public ip address */
+struct ctdb_vnn {
+       struct ctdb_vnn *prev, *next;
 
-struct ipalloc_state {
-       uint32_t num;
+       struct ctdb_interface *iface;
+       const char **ifaces;
+       ctdb_sock_addr public_address;
+       uint8_t public_netmask_bits;
 
-       /* Arrays with data for each node */
-       struct ctdb_public_ip_list_old **known_public_ips;
-       struct ctdb_public_ip_list_old **available_public_ips;
+       /* the node number that is serving this public address, if any.
+          If no node serves this ip it is set to -1 */
+       int32_t pnn;
 
-       enum ipalloc_algorithm algorithm;
-       uint32_t no_ip_failback;
-};
+       /* List of clients to tickle for this public address */
+       struct ctdb_tcp_array *tcp_array;
 
-struct ctdb_interface {
-       struct ctdb_interface *prev, *next;
-       const char *name;
-       bool link_up;
-       uint32_t references;
+       /* whether we need to update the other nodes with changes to our list
+          of connected clients */
+       bool tcp_update_needed;
+
+       /* a context to hang sending gratious arp events off */
+       TALLOC_CTX *takeover_ctx;
+
+       /* Set to true any time an update to this VNN is in flight.
+          This helps to avoid races. */
+       bool update_in_flight;
+
+       /* If CTDB_CONTROL_DEL_PUBLIC_IP is received for this IP
+        * address then this flag is set.  It will be deleted in the
+        * release IP callback. */
+       bool delete_pending;
 };
 
-static const char *ctdb_vnn_iface_string(const struct ctdb_vnn *vnn)
+static const char *iface_string(const struct ctdb_interface *iface)
 {
-       if (vnn->iface) {
-               return vnn->iface->name;
-       }
+       return (iface != NULL ? iface->name : "__none__");
+}
 
-       return "__none__";
+static const char *ctdb_vnn_iface_string(const struct ctdb_vnn *vnn)
+{
+       return iface_string(vnn->iface);
 }
 
 static int ctdb_add_local_iface(struct ctdb_context *ctdb, const char *iface)
 {
        struct ctdb_interface *i;
 
+       if (strlen(iface) > CTDB_IFACE_SIZE) {
+               DEBUG(DEBUG_ERR, ("Interface name too long \"%s\"\n", iface));
+               return -1;
+       }
+
        /* 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) {
@@ -99,9 +116,16 @@ 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_interface);
-       CTDB_NO_MEMORY_FATAL(ctdb, i);
+       if (i == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               return -1;
+       }
        i->name = talloc_strdup(i, iface);
-       CTDB_NO_MEMORY(ctdb, i->name);
+       if (i->name == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               talloc_free(i);
+               return -1;
+       }
 
        i->link_up = true;
 
@@ -131,10 +155,9 @@ static bool vnn_has_interface_with_name(struct ctdb_vnn *vnn,
  * foolproof.  One alternative is reference counting, where the logic
  * is distributed and can, therefore, be broken in multiple places.
  * Another alternative is to build a red-black tree of interfaces that
- * can have addresses (by walking ctdb->vnn and ctdb->single_ip_vnn
- * once) and then walking ctdb->ifaces once and deleting those not in
- * the tree.  Let's go to one of those if the naive implementation
- * causes problems...  :-)
+ * can have addresses (by walking ctdb->vnn once) and then walking
+ * ctdb->ifaces once and deleting those not in the tree.  Let's go to
+ * one of those if the naive implementation causes problems...  :-)
  */
 static void ctdb_remove_orphaned_ifaces(struct ctdb_context *ctdb,
                                        struct ctdb_vnn *vnn)
@@ -152,13 +175,6 @@ static void ctdb_remove_orphaned_ifaces(struct ctdb_context *ctdb,
                        continue;
                }
 
-               /* Is the "single IP" on this interface? */
-               if ((ctdb->single_ip_vnn != NULL) &&
-                   (ctdb->single_ip_vnn->ifaces[0] != NULL) &&
-                   (strcmp(i->name, ctdb->single_ip_vnn->ifaces[0]) == 0)) {
-                       /* Found, next interface please... */
-                       continue;
-               }
                /* Search for a vnn with this interface. */
                found = false;
                for (tv=ctdb->vnn; tv; tv=tv->next) {
@@ -425,12 +441,6 @@ static int32_t ctdb_announce_vnn_iface(struct ctdb_context *ctdb,
        return 0;
 }
 
-struct takeover_callback_state {
-       struct ctdb_req_control_old *c;
-       ctdb_sock_addr *addr;
-       struct ctdb_vnn *vnn;
-};
-
 struct ctdb_do_takeip_state {
        struct ctdb_req_control_old *c;
        struct ctdb_vnn *vnn;
@@ -448,8 +458,6 @@ static void ctdb_do_takeip_callback(struct ctdb_context *ctdb, int status,
        TDB_DATA data;
 
        if (status != 0) {
-               struct ctdb_node *node = ctdb->nodes[ctdb->pnn];
-       
                if (status == -ETIME) {
                        ctdb_ban_self(ctdb);
                }
@@ -458,7 +466,6 @@ static void ctdb_do_takeip_callback(struct ctdb_context *ctdb, int status,
                                 ctdb_vnn_iface_string(state->vnn)));
                ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
 
-               node->flags |= NODE_FLAGS_UNHEALTHY;
                talloc_free(state);
                return;
        }
@@ -523,7 +530,7 @@ static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
        state = talloc(vnn, struct ctdb_do_takeip_state);
        CTDB_NO_MEMORY(ctdb, state);
 
-       state->c = talloc_steal(ctdb, c);
+       state->c = NULL;
        state->vnn   = vnn;
 
        vnn->update_in_flight = true;
@@ -552,6 +559,7 @@ static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
                return -1;
        }
 
+       state->c = talloc_steal(ctdb, c);
        return 0;
 }
 
@@ -575,10 +583,11 @@ static void ctdb_do_updateip_callback(struct ctdb_context *ctdb, int status,
                if (status == -ETIME) {
                        ctdb_ban_self(ctdb);
                }
-               DEBUG(DEBUG_ERR,(__location__ " Failed to move IP %s from interface %s to %s\n",
-                       ctdb_addr_to_str(&state->vnn->public_address),
-                       state->old->name,
-                       ctdb_vnn_iface_string(state->vnn)));
+               DEBUG(DEBUG_ERR,
+                     ("Failed update of IP %s from interface %s to %s\n",
+                      ctdb_addr_to_str(&state->vnn->public_address),
+                      iface_string(state->old),
+                      ctdb_vnn_iface_string(state->vnn)));
 
                /*
                 * All we can do is reset the old interface
@@ -626,6 +635,7 @@ static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
        int ret;
        struct ctdb_do_updateip_state *state;
        struct ctdb_interface *old = vnn->iface;
+       const char *old_name = iface_string(old);
        const char *new_name;
 
        if (vnn->update_in_flight) {
@@ -639,16 +649,17 @@ static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
        ctdb_vnn_unassign_iface(ctdb, vnn);
        ret = ctdb_vnn_assign_iface(ctdb, vnn);
        if (ret != 0) {
-               DEBUG(DEBUG_ERR,("update of IP %s/%u failed to "
-                                "assin a usable interface (old iface '%s')\n",
+               DEBUG(DEBUG_ERR,("Update of IP %s/%u failed to "
+                                "assign a usable interface (old iface '%s')\n",
                                 ctdb_addr_to_str(&vnn->public_address),
                                 vnn->public_netmask_bits,
-                                old->name));
+                                old_name));
                return -1;
        }
 
        new_name = ctdb_vnn_iface_string(vnn);
-       if (old->name != NULL && new_name != NULL && !strcmp(old->name, new_name)) {
+       if (old_name != NULL && new_name != NULL &&
+           strcmp(old_name, new_name) == 0) {
                /* A benign update from one interface onto itself.
                 * no need to run the eventscripts in this case, just return
                 * success.
@@ -660,7 +671,7 @@ static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
        state = talloc(vnn, struct ctdb_do_updateip_state);
        CTDB_NO_MEMORY(ctdb, state);
 
-       state->c = talloc_steal(ctdb, c);
+       state->c = NULL;
        state->old = old;
        state->vnn = vnn;
 
@@ -671,7 +682,7 @@ static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
                            "interface %s to %s\n",
                            ctdb_addr_to_str(&vnn->public_address),
                            vnn->public_netmask_bits,
-                           old->name,
+                           old_name,
                            new_name));
 
        ret = ctdb_event_script_callback(ctdb,
@@ -680,18 +691,20 @@ static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
                                         state,
                                         CTDB_EVENT_UPDATE_IP,
                                         "%s %s %s %u",
-                                        state->old->name,
+                                        old_name,
                                         new_name,
                                         ctdb_addr_to_str(&vnn->public_address),
                                         vnn->public_netmask_bits);
        if (ret != 0) {
-               DEBUG(DEBUG_ERR,(__location__ " Failed update IP %s from interface %s to %s\n",
-                                ctdb_addr_to_str(&vnn->public_address),
-                                old->name, new_name));
+               DEBUG(DEBUG_ERR,
+                     ("Failed update IP %s from interface %s to %s\n",
+                      ctdb_addr_to_str(&vnn->public_address),
+                      old_name, new_name));
                talloc_free(state);
                return -1;
        }
 
+       state->c = talloc_steal(ctdb, c);
        return 0;
 }
 
@@ -758,19 +771,6 @@ int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
                return -1;
        }
 
-       if (vnn->iface == NULL && vnn->pnn == -1 && have_ip && best_iface != NULL) {
-               DEBUG(DEBUG_ERR,("Taking over newly created ip\n"));
-               have_ip = false;
-       }
-
-
-       if (vnn->iface == NULL && have_ip) {
-               DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
-                                 "but we have no interface assigned, has someone manually configured it? Ignore for now.\n",
-                                ctdb_addr_to_str(&vnn->public_address)));
-               return 0;
-       }
-
        if (vnn->pnn != ctdb->pnn && have_ip && vnn->pnn != -1) {
                DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
                                  "and we have it on iface[%s], but it was assigned to node %d"
@@ -782,12 +782,16 @@ int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
        }
 
        if (vnn->pnn == -1 && have_ip) {
-               vnn->pnn = ctdb->pnn;
-               DEBUG(DEBUG_CRIT,(__location__ " takeoverip of IP %s is known to the kernel, "
-                                 "and we already have it on iface[%s], update local daemon\n",
-                                ctdb_addr_to_str(&vnn->public_address),
-                                 ctdb_vnn_iface_string(vnn)));
-               return 0;
+               /* This will cause connections to be reset and
+                * reestablished.  However, this is a very unusual
+                * situation and doing this will completely repair the
+                * inconsistency in the VNN.
+                */
+               DEBUG(DEBUG_WARNING,
+                     (__location__
+                      " Doing updateip for IP %s already on an interface\n",
+                      ctdb_addr_to_str(&vnn->public_address)));
+               do_updateip = true;
        }
 
        if (vnn->iface) {
@@ -837,44 +841,6 @@ int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
        return 0;
 }
 
-/*
-  kill any clients that are registered with a IP that is being released
- */
-static void release_kill_clients(struct ctdb_context *ctdb, ctdb_sock_addr *addr)
-{
-       struct ctdb_client_ip *ip;
-
-       DEBUG(DEBUG_INFO,("release_kill_clients for ip %s\n",
-               ctdb_addr_to_str(addr)));
-
-       for (ip=ctdb->client_ip_list; ip; ip=ip->next) {
-               ctdb_sock_addr tmp_addr;
-
-               tmp_addr = ip->addr;
-               DEBUG(DEBUG_INFO,("checking for client %u with IP %s\n", 
-                       ip->client_id,
-                       ctdb_addr_to_str(&ip->addr)));
-
-               if (ctdb_same_ip(&tmp_addr, addr)) {
-                       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),
-                               client->pid));
-
-                       if (client->pid != 0) {
-                               DEBUG(DEBUG_INFO,(__location__ " Killing client pid %u for IP %s on client_id %u\n",
-                                       (unsigned)client->pid,
-                                       ctdb_addr_to_str(addr),
-                                       ip->client_id));
-                               kill(client->pid, SIGKILL);
-                       }
-               }
-       }
-}
-
 static void do_delete_ip(struct ctdb_context *ctdb, struct ctdb_vnn *vnn)
 {
        DLIST_REMOVE(ctdb->vnn, vnn);
@@ -883,15 +849,47 @@ static void do_delete_ip(struct ctdb_context *ctdb, struct ctdb_vnn *vnn)
        talloc_free(vnn);
 }
 
+static struct ctdb_vnn *release_ip_post(struct ctdb_context *ctdb,
+                                       struct ctdb_vnn *vnn,
+                                       ctdb_sock_addr *addr)
+{
+       TDB_DATA data;
+
+       /* Send a message to all clients of this node telling them
+        * that the cluster has been reconfigured and they should
+        * close any connections on this IP address
+        */
+       data.dptr = (uint8_t *)ctdb_addr_to_str(addr);
+       data.dsize = strlen((char *)data.dptr)+1;
+       DEBUG(DEBUG_INFO, ("Sending RELEASE_IP message for %s\n", data.dptr));
+       ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_RELEASE_IP, data);
+
+       ctdb_vnn_unassign_iface(ctdb, vnn);
+
+       /* Process the IP if it has been marked for deletion */
+       if (vnn->delete_pending) {
+               do_delete_ip(ctdb, vnn);
+               return NULL;
+       }
+
+       return vnn;
+}
+
+struct release_ip_callback_state {
+       struct ctdb_req_control_old *c;
+       ctdb_sock_addr *addr;
+       struct ctdb_vnn *vnn;
+       uint32_t target_pnn;
+};
+
 /*
   called when releaseip event finishes
  */
-static void release_ip_callback(struct ctdb_context *ctdb, int status, 
+static void release_ip_callback(struct ctdb_context *ctdb, int status,
                                void *private_data)
 {
-       struct takeover_callback_state *state = 
-               talloc_get_type(private_data, struct takeover_callback_state);
-       TDB_DATA data;
+       struct release_ip_callback_state *state =
+               talloc_get_type(private_data, struct release_ip_callback_state);
 
        if (status == -ETIME) {
                ctdb_ban_self(ctdb);
@@ -909,34 +907,15 @@ static void release_ip_callback(struct ctdb_context *ctdb, int status,
                }
        }
 
-       /* send a message to all clients of this node telling them
-          that the cluster has been reconfigured and they should
-          release any sockets on this IP */
-       data.dptr = (uint8_t *)talloc_strdup(state, ctdb_addr_to_str(state->addr));
-       CTDB_NO_MEMORY_VOID(ctdb, data.dptr);
-       data.dsize = strlen((char *)data.dptr)+1;
-
-       DEBUG(DEBUG_INFO,(__location__ " sending RELEASE_IP for '%s'\n", data.dptr));
-
-       ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_RELEASE_IP, data);
-
-       /* kill clients that have registered with this IP */
-       release_kill_clients(ctdb, state->addr);
-
-       ctdb_vnn_unassign_iface(ctdb, state->vnn);
-
-       /* Process the IP if it has been marked for deletion */
-       if (state->vnn->delete_pending) {
-               do_delete_ip(ctdb, state->vnn);
-               state->vnn = NULL;
-       }
+       state->vnn->pnn = state->target_pnn;
+       state->vnn = release_ip_post(ctdb, state->vnn, state->addr);
 
        /* the control succeeded */
        ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
        talloc_free(state);
 }
 
-static int ctdb_releaseip_destructor(struct takeover_callback_state *state)
+static int ctdb_releaseip_destructor(struct release_ip_callback_state *state)
 {
        if (state->vnn != NULL) {
                state->vnn->update_in_flight = false;
@@ -953,10 +932,10 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
                                bool *async_reply)
 {
        int ret;
-       struct takeover_callback_state *state;
+       struct release_ip_callback_state *state;
        struct ctdb_public_ip *pip = (struct ctdb_public_ip *)indata.dptr;
        struct ctdb_vnn *vnn;
-       char *iface;
+       const char *iface;
 
        /* update our vnn list */
        vnn = find_public_ip_vnn(ctdb, &pip->addr);
@@ -965,16 +944,20 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
                        ctdb_addr_to_str(&pip->addr)));
                return 0;
        }
-       vnn->pnn = pip->pnn;
 
        /* stop any previous arps */
        talloc_free(vnn->takeover_ctx);
        vnn->takeover_ctx = NULL;
 
-       /* Some ctdb tool commands (e.g. moveip, rebalanceip) send
-        * lazy multicast to drop an IP from any node that isn't the
-        * intended new node.  The following causes makes ctdbd ignore
-        * a release for any address it doesn't host.
+       /* RELEASE_IP controls are sent to all nodes that should not
+        * be hosting a particular IP.  This serves 2 purposes.  The
+        * first is to help resolve any inconsistencies.  If a node
+        * does unexpectly host an IP then it will be released.  The
+        * 2nd is to use a "redundant release" to tell non-takeover
+        * nodes where an IP is moving to.  This is how "ctdb ip" can
+        * report the (likely) location of an IP by only asking the
+        * local node.  Redundant releases need to update the PNN but
+        * are otherwise ignored.
         */
        if (ctdb->tunable.disable_ip_failover == 0 && ctdb->do_checkpublicip) {
                if (!ctdb_sys_have_ip(&pip->addr)) {
@@ -982,6 +965,7 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
                                ctdb_addr_to_str(&pip->addr),
                                vnn->public_netmask_bits,
                                ctdb_vnn_iface_string(vnn)));
+                       vnn->pnn = pip->pnn;
                        ctdb_vnn_unassign_iface(ctdb, vnn);
                        return 0;
                }
@@ -990,6 +974,7 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
                        DEBUG(DEBUG_DEBUG,("Redundant release of IP %s/%u (ip not held)\n",
                                           ctdb_addr_to_str(&pip->addr),
                                           vnn->public_netmask_bits));
+                       vnn->pnn = pip->pnn;
                        return 0;
                }
        }
@@ -1007,7 +992,7 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
                return -1;
        }
 
-       iface = strdup(ctdb_vnn_iface_string(vnn));
+       iface = ctdb_vnn_iface_string(vnn);
 
        DEBUG(DEBUG_NOTICE,("Release of IP %s/%u on interface %s  node:%d\n",
                ctdb_addr_to_str(&pip->addr),
@@ -1015,24 +1000,23 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
                iface,
                pip->pnn));
 
-       state = talloc(ctdb, struct takeover_callback_state);
+       state = talloc(ctdb, struct release_ip_callback_state);
        if (state == NULL) {
                ctdb_set_error(ctdb, "Out of memory at %s:%d",
                               __FILE__, __LINE__);
-               free(iface);
                return -1;
        }
 
-       state->c = talloc_steal(state, c);
-       state->addr = talloc(state, ctdb_sock_addr);       
+       state->c = NULL;
+       state->addr = talloc(state, ctdb_sock_addr);
        if (state->addr == NULL) {
                ctdb_set_error(ctdb, "Out of memory at %s:%d",
                               __FILE__, __LINE__);
-               free(iface);
                talloc_free(state);
                return -1;
        }
        *state->addr = pip->addr;
+       state->target_pnn = pip->pnn;
        state->vnn   = vnn;
 
        vnn->update_in_flight = true;
@@ -1045,7 +1029,6 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
                                         iface,
                                         ctdb_addr_to_str(&pip->addr),
                                         vnn->public_netmask_bits);
-       free(iface);
        if (ret != 0) {
                DEBUG(DEBUG_ERR,(__location__ " Failed to release IP %s on interface %s\n",
                        ctdb_addr_to_str(&pip->addr),
@@ -1056,6 +1039,7 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
 
        /* tell the control that we will be reply asynchronously */
        *async_reply = true;
+       state->c = talloc_steal(state, c);
        return 0;
 }
 
@@ -1068,39 +1052,67 @@ static int ctdb_add_public_address(struct ctdb_context *ctdb,
        uint32_t num = 0;
        char *tmp;
        const char *iface;
-       int i;
        int ret;
 
-       tmp = strdup(ifaces);
-       for (iface = strtok(tmp, ","); iface; iface = strtok(NULL, ",")) {
-               if (!ctdb_sys_check_iface_exists(iface)) {
-                       DEBUG(DEBUG_CRIT,("Interface %s does not exist. Can not add public-address : %s\n", iface, ctdb_addr_to_str(addr)));
-                       free(tmp);
-                       return -1;
-               }
-       }
-       free(tmp);
-
-       /* Verify that we don't have an entry for this ip yet */
-       for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
+       /* Verify that we don't have an entry for this IP yet */
+       for (vnn = ctdb->vnn; vnn != NULL; 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", 
-                               ctdb_addr_to_str(addr)));
+                       DEBUG(DEBUG_ERR,
+                             ("Duplicate public IP address '%s'\n",
+                              ctdb_addr_to_str(addr)));
                        return -1;
-               }               
+               }
        }
 
-       /* create a new vnn structure for this ip address */
+       /* Create a new VNN structure for this IP address */
        vnn = talloc_zero(ctdb, struct ctdb_vnn);
-       CTDB_NO_MEMORY_FATAL(ctdb, vnn);
+       if (vnn == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               return -1;
+       }
        vnn->ifaces = talloc_array(vnn, const char *, num + 2);
+       if (vnn->ifaces == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               talloc_free(vnn);
+               return -1;
+       }
        tmp = talloc_strdup(vnn, ifaces);
-       CTDB_NO_MEMORY_FATAL(ctdb, tmp);
+       if (tmp == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               talloc_free(vnn);
+               return -1;
+       }
        for (iface = strtok(tmp, ","); iface; iface = strtok(NULL, ",")) {
+               if (!ctdb_sys_check_iface_exists(iface)) {
+                       DEBUG(DEBUG_ERR,
+                             ("Unknown interface %s for public address %s\n",
+                              iface, ctdb_addr_to_str(addr)));
+                       talloc_free(vnn);
+                       return -1;
+               }
+
+               ret = ctdb_add_local_iface(ctdb, iface);
+               if (ret != 0) {
+                       DEBUG(DEBUG_ERR,
+                             ("Failed to add interface '%s' "
+                              "for public address %s\n",
+                              iface, ctdb_addr_to_str(addr)));
+                       talloc_free(vnn);
+                       return -1;
+               }
+
                vnn->ifaces = talloc_realloc(vnn, vnn->ifaces, const char *, num + 2);
-               CTDB_NO_MEMORY_FATAL(ctdb, vnn->ifaces);
+               if (vnn->ifaces == NULL) {
+                       DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+                       talloc_free(vnn);
+                       return -1;
+               }
                vnn->ifaces[num] = talloc_strdup(vnn, iface);
-               CTDB_NO_MEMORY_FATAL(ctdb, vnn->ifaces[num]);
+               if (vnn->ifaces[num] == NULL) {
+                       DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+                       talloc_free(vnn);
+                       return -1;
+               }
                num++;
        }
        talloc_free(tmp);
@@ -1108,23 +1120,6 @@ static int ctdb_add_public_address(struct ctdb_context *ctdb,
        vnn->public_address      = *addr;
        vnn->public_netmask_bits = mask;
        vnn->pnn                 = -1;
-       if (check_address) {
-               if (ctdb_sys_have_ip(addr)) {
-                       DEBUG(DEBUG_ERR,("We are already hosting public address '%s'. setting PNN to ourself:%d\n", ctdb_addr_to_str(addr), ctdb->pnn));
-                       vnn->pnn = ctdb->pnn;
-               }
-       }
-
-       for (i=0; vnn->ifaces[i]; i++) {
-               ret = ctdb_add_local_iface(ctdb, vnn->ifaces[i]);
-               if (ret != 0) {
-                       DEBUG(DEBUG_CRIT, (__location__ " failed to add iface[%s] "
-                                          "for public_address[%s]\n",
-                                          vnn->ifaces[i], ctdb_addr_to_str(addr)));
-                       talloc_free(vnn);
-                       return -1;
-               }
-       }
 
        DLIST_ADD(ctdb->vnn, vnn);
 
@@ -1198,1103 +1193,125 @@ int ctdb_set_public_addresses(struct ctdb_context *ctdb, bool check_addresses)
        return 0;
 }
 
-int ctdb_set_single_public_ip(struct ctdb_context *ctdb,
-                             const char *iface,
-                             const char *ip)
+static struct ctdb_public_ip_list *
+ctdb_fetch_remote_public_ips(struct ctdb_context *ctdb,
+                            TALLOC_CTX *mem_ctx,
+                            struct ctdb_node_map_old *nodemap,
+                            uint32_t public_ip_flags)
 {
-       struct ctdb_vnn *svnn;
-       struct ctdb_interface *cur = NULL;
-       bool ok;
-       int ret;
-
-       svnn = talloc_zero(ctdb, struct ctdb_vnn);
-       CTDB_NO_MEMORY(ctdb, svnn);
-
-       svnn->ifaces = talloc_array(svnn, const char *, 2);
-       CTDB_NO_MEMORY(ctdb, svnn->ifaces);
-       svnn->ifaces[0] = talloc_strdup(svnn->ifaces, iface);
-       CTDB_NO_MEMORY(ctdb, svnn->ifaces[0]);
-       svnn->ifaces[1] = NULL;
-
-       ok = parse_ip(ip, iface, 0, &svnn->public_address);
-       if (!ok) {
-               talloc_free(svnn);
-               return -1;
-       }
+       int j, ret;
+       struct ctdb_public_ip_list_old *ip_list;
+       struct ctdb_public_ip_list *public_ips;
 
-       ret = ctdb_add_local_iface(ctdb, svnn->ifaces[0]);
-       if (ret != 0) {
-               DEBUG(DEBUG_CRIT, (__location__ " failed to add iface[%s] "
-                                  "for single_ip[%s]\n",
-                                  svnn->ifaces[0],
-                                  ctdb_addr_to_str(&svnn->public_address)));
-               talloc_free(svnn);
-               return -1;
+       public_ips = talloc_zero_array(mem_ctx,
+                                      struct ctdb_public_ip_list,
+                                      nodemap->num);
+       if (public_ips == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               return NULL;
        }
 
-       /* assume the single public ip interface is initially "good" */
-       cur = ctdb_find_iface(ctdb, iface);
-       if (cur == NULL) {
-               DEBUG(DEBUG_CRIT,("Can not find public interface %s used by --single-public-ip", iface));
-               return -1;
-       }
-       cur->link_up = true;
+       for (j = 0; j < nodemap->num; j++) {
+               if (nodemap->nodes[j].flags & NODE_FLAGS_INACTIVE) {
+                       continue;
+               }
 
-       ret = ctdb_vnn_assign_iface(ctdb, svnn);
-       if (ret != 0) {
-               talloc_free(svnn);
-               return -1;
+               /* Retrieve the list of public IPs from the
+                * node. Flags says whether it is known or
+                * available. */
+               ret = ctdb_ctrl_get_public_ips_flags(
+                       ctdb, TAKEOVER_TIMEOUT(), j, public_ips,
+                       public_ip_flags, &ip_list);
+               if (ret != 0) {
+                       DEBUG(DEBUG_ERR,
+                             ("Failed to read public IPs from node: %u\n", j));
+                       talloc_free(public_ips);
+                       return NULL;
+               }
+               public_ips[j].num = ip_list->num;
+               if (ip_list->num == 0) {
+                       talloc_free(ip_list);
+                       continue;
+               }
+               public_ips[j].ip = talloc_zero_array(public_ips,
+                                                    struct ctdb_public_ip,
+                                                    ip_list->num);
+               if (public_ips[j].ip == NULL) {
+                       DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+                       talloc_free(public_ips);
+                       return NULL;
+               }
+               memcpy(public_ips[j].ip, &ip_list->ips[0],
+                      sizeof(struct ctdb_public_ip) * ip_list->num);
+               talloc_free(ip_list);
        }
 
-       ctdb->single_ip_vnn = svnn;
-       return 0;
+       return public_ips;
 }
 
-struct public_ip_list {
-       struct public_ip_list *next;
-       uint32_t pnn;
-       ctdb_sock_addr addr;
+struct get_tunable_callback_data {
+       const char *tunable;
+       uint32_t *out;
+       bool fatal;
 };
 
-/* Given a physical node, return the number of
-   public addresses that is currently assigned to this node.
-*/
-static int node_ip_coverage(int32_t pnn, struct public_ip_list *ips)
-{
-       int num=0;
-
-       for (;ips;ips=ips->next) {
-               if (ips->pnn == pnn) {
-                       num++;
-               }
-       }
-       return num;
-}
-
-
-/* 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,
-                            struct ctdb_ipflags ipflags,
-                            struct public_ip_list *ip)
+static void get_tunable_callback(struct ctdb_context *ctdb, uint32_t pnn,
+                                int32_t res, TDB_DATA outdata,
+                                void *callback)
 {
-       struct ctdb_public_ip_list_old *public_ips;
-       int i;
-
-       if (ipflags.noiphost) {
-               return false;
-       }
-
-       public_ips = ctdb->ipalloc_state->available_public_ips[pnn];
+       struct get_tunable_callback_data *cd =
+               (struct get_tunable_callback_data *)callback;
+       int size;
 
-       if (public_ips == NULL) {
-               return false;
+       if (res != 0) {
+               /* Already handled in fail callback */
+               return;
        }
 
-       for (i=0; i<public_ips->num; i++) {
-               if (ctdb_same_ip(&ip->addr, &public_ips->ips[i].addr)) {
-                       /* yes, this node can serve this public ip */
-                       return true;
-               }
+       if (outdata.dsize != sizeof(uint32_t)) {
+               DEBUG(DEBUG_ERR,("Wrong size of returned data when reading \"%s\" tunable from node %d. Expected %d bytes but received %d bytes\n",
+                                cd->tunable, pnn, (int)sizeof(uint32_t),
+                                (int)outdata.dsize));
+               cd->fatal = true;
+               return;
        }
 
-       return false;
-}
-
-static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
-                                struct ctdb_ipflags ipflags,
-                                struct public_ip_list *ip)
-{
-       if (ipflags.noiptakeover) {
-               return false;
+       size = talloc_array_length(cd->out);
+       if (pnn >= size) {
+               DEBUG(DEBUG_ERR,("Got %s reply from node %d but nodemap only has %d entries\n",
+                                cd->tunable, pnn, size));
+               return;
        }
 
-       return can_node_host_ip(ctdb, pnn, ipflags, ip);
+               
+       cd->out[pnn] = *(uint32_t *)outdata.dptr;
 }
 
-/* search the node lists list for a node to takeover this ip.
-   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 public_ip_list *ip,
-                             struct public_ip_list *all_ips)
+static void get_tunable_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
+                                      int32_t res, TDB_DATA outdata,
+                                      void *callback)
 {
-       int pnn, min=0, num;
-       int i, numnodes;
-
-       numnodes = talloc_array_length(ipflags);
-       pnn    = -1;
-       for (i=0; i<numnodes; i++) {
-               /* verify that this node can serve this ip */
-               if (!can_node_takeover_ip(ctdb, i, ipflags[i], ip)) {
-                       /* no it couldnt   so skip to the next node */
-                       continue;
-               }
-
-               num = node_ip_coverage(i, all_ips);
-               /* was this the first node we checked ? */
-               if (pnn == -1) {
-                       pnn = i;
-                       min  = num;
-               } else {
-                       if (num < min) {
-                               pnn = i;
-                               min  = num;
-                       }
-               }
-       }       
-       if (pnn == -1) {
-               DEBUG(DEBUG_WARNING,(__location__ " Could not find node to take over public address '%s'\n",
-                       ctdb_addr_to_str(&ip->addr)));
+       struct get_tunable_callback_data *cd =
+               (struct get_tunable_callback_data *)callback;
 
-               return -1;
-       }
-
-       ip->pnn = pnn;
-       return 0;
-}
-
-#define IP_KEYLEN      4
-static uint32_t *ip_key(ctdb_sock_addr *ip)
-{
-       static uint32_t key[IP_KEYLEN];
-
-       bzero(key, sizeof(key));
-
-       switch (ip->sa.sa_family) {
-       case AF_INET:
-               key[3]  = htonl(ip->ip.sin_addr.s_addr);
-               break;
-       case AF_INET6: {
-               uint32_t *s6_a32 = (uint32_t *)&(ip->ip6.sin6_addr.s6_addr);
-               key[0]  = htonl(s6_a32[0]);
-               key[1]  = htonl(s6_a32[1]);
-               key[2]  = htonl(s6_a32[2]);
-               key[3]  = htonl(s6_a32[3]);
-               break;
-       }
-       default:
-               DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family passed :%u\n", ip->sa.sa_family));
-               return key;
-       }
-
-       return key;
-}
-
-static void *add_ip_callback(void *parm, void *data)
-{
-       struct public_ip_list *this_ip = parm;
-       struct public_ip_list *prev_ip = data;
-
-       if (prev_ip == NULL) {
-               return parm;
-       }
-       if (this_ip->pnn == -1) {
-               this_ip->pnn = prev_ip->pnn;
-       }
-
-       return parm;
-}
-
-static int getips_count_callback(void *param, void *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 int verify_remote_ip_allocation(struct ctdb_context *ctdb,
-                                      struct ctdb_public_ip_list_old *ips,
-                                      uint32_t pnn);
-
-static int ctdb_reload_remote_public_ips(struct ctdb_context *ctdb,
-                                        struct ipalloc_state *ipalloc_state,
-                                        struct ctdb_node_map_old *nodemap)
-{
-       int j;
-       int ret;
-
-       if (ipalloc_state->num != nodemap->num) {
-               DEBUG(DEBUG_ERR,
-                     (__location__
-                      " ipalloc_state->num (%d) != nodemap->num (%d) invalid param\n",
-                      ipalloc_state->num, nodemap->num));
-               return -1;
-       }
-
-       for (j=0; j<nodemap->num; j++) {
-               if (nodemap->nodes[j].flags & NODE_FLAGS_INACTIVE) {
-                       continue;
-               }
-
-               /* Retrieve the list of known public IPs from the node */
-               ret = ctdb_ctrl_get_public_ips_flags(ctdb,
-                                       TAKEOVER_TIMEOUT(),
-                                       j,
-                                       ctdb->nodes,
-                                       0,
-                                       &ipalloc_state->known_public_ips[j]);
-               if (ret != 0) {
-                       DEBUG(DEBUG_ERR,
-                             ("Failed to read known public IPs from node: %u\n",
-                              j));
-                       return -1;
-               }
-
-               if (ctdb->do_checkpublicip) {
-                       verify_remote_ip_allocation(ctdb,
-                                                   ipalloc_state->known_public_ips[j],
-                                                   j);
-               }
-
-               /* Retrieve the list of available public IPs from the node */
-               ret = ctdb_ctrl_get_public_ips_flags(ctdb,
-                                       TAKEOVER_TIMEOUT(),
-                                       j,
-                                       ctdb->nodes,
-                                       CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE,
-                                       &ipalloc_state->available_public_ips[j]);
-               if (ret != 0) {
-                       DEBUG(DEBUG_ERR,
-                             ("Failed to read available public IPs from node: %u\n",
-                              j));
-                       return -1;
-               }
-       }
-
-       return 0;
-}
-
-static struct public_ip_list *
-create_merged_ip_list(struct ctdb_context *ctdb)
-{
-       int i, j;
-       struct public_ip_list *ip_list;
-       struct ctdb_public_ip_list_old *public_ips;
-
-       if (ctdb->ip_tree != NULL) {
-               talloc_free(ctdb->ip_tree);
-               ctdb->ip_tree = NULL;
-       }
-       ctdb->ip_tree = trbt_create(ctdb, 0);
-
-       for (i=0;i<ctdb->num_nodes;i++) {
-               public_ips = ctdb->ipalloc_state->known_public_ips[i];
-
-               if (ctdb->nodes[i]->flags & NODE_FLAGS_DELETED) {
-                       continue;
-               }
-
-               /* there were no public ips for this node */
-               if (public_ips == NULL) {
-                       continue;
-               }               
-
-               for (j=0;j<public_ips->num;j++) {
-                       struct public_ip_list *tmp_ip;
-
-                       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 */
-                       if (public_ips->ips[j].pnn == ctdb->nodes[i]->pnn) {
-                               tmp_ip->pnn = public_ips->ips[j].pnn;
-                       } else {
-                               tmp_ip->pnn = -1;
-                       }
-                       tmp_ip->addr = public_ips->ips[j].addr;
-                       tmp_ip->next = NULL;
-
-                       trbt_insertarray32_callback(ctdb->ip_tree,
-                               IP_KEYLEN, ip_key(&public_ips->ips[j].addr),
-                               add_ip_callback,
-                               tmp_ip);
-               }
-       }
-
-       ip_list = NULL;
-       trbt_traversearray32(ctdb->ip_tree, IP_KEYLEN, getips_count_callback, &ip_list);
-
-       return ip_list;
-}
-
-/* 
- * This is the length of the longtest common prefix between the IPs.
- * It is calculated by XOR-ing the 2 IPs together and counting the
- * number of leading zeroes.  The implementation means that all
- * addresses end up being 128 bits long.
- *
- * FIXME? Should we consider IPv4 and IPv6 separately given that the
- * 12 bytes of 0 prefix padding will hurt the algorithm if there are
- * lots of nodes and IP addresses?
- */
-static uint32_t ip_distance(ctdb_sock_addr *ip1, ctdb_sock_addr *ip2)
-{
-       uint32_t ip1_k[IP_KEYLEN];
-       uint32_t *t;
-       int i;
-       uint32_t x;
-
-       uint32_t distance = 0;
-
-       memcpy(ip1_k, ip_key(ip1), sizeof(ip1_k));
-       t = ip_key(ip2);
-       for (i=0; i<IP_KEYLEN; i++) {
-               x = ip1_k[i] ^ t[i];
-               if (x == 0) {
-                       distance += 32;
-               } else {
-                       /* Count number of leading zeroes. 
-                        * FIXME? This could be optimised...
-                        */
-                       while ((x & (1 << 31)) == 0) {
-                               x <<= 1;
-                               distance += 1;
-                       }
-               }
-       }
-
-       return distance;
-}
-
-/* Calculate the IP distance for the given IP relative to IPs on the
-   given node.  The ips argument is generally the all_ips variable
-   used in the main part of the algorithm.
- */
-static uint32_t ip_distance_2_sum(ctdb_sock_addr *ip,
-                                 struct public_ip_list *ips,
-                                 int pnn)
-{
-       struct public_ip_list *t;
-       uint32_t d;
-
-       uint32_t sum = 0;
-
-       for (t=ips; t != NULL; t=t->next) {
-               if (t->pnn != pnn) {
-                       continue;
-               }
-
-               /* Optimisation: We never calculate the distance
-                * between an address and itself.  This allows us to
-                * calculate the effect of removing an address from a
-                * node by simply calculating the distance between
-                * that address and all of the exitsing addresses.
-                * Moreover, we assume that we're only ever dealing
-                * with addresses from all_ips so we can identify an
-                * address via a pointer rather than doing a more
-                * expensive address comparison. */
-               if (&(t->addr) == ip) {
-                       continue;
-               }
-
-               d = ip_distance(ip, &(t->addr));
-               sum += d * d;  /* Cheaper than pulling in math.h :-) */
-       }
-
-       return sum;
-}
-
-/* Return the LCP2 imbalance metric for addresses currently assigned
-   to the given node.
- */
-static uint32_t lcp2_imbalance(struct public_ip_list * all_ips, int pnn)
-{
-       struct public_ip_list *t;
-
-       uint32_t imbalance = 0;
-
-       for (t=all_ips; t!=NULL; t=t->next) {
-               if (t->pnn != pnn) {
-                       continue;
-               }
-               /* Pass the rest of the IPs rather than the whole
-                  all_ips input list.
-               */
-               imbalance += ip_distance_2_sum(&(t->addr), t->next, pnn);
-       }
-
-       return imbalance;
-}
-
-/* Allocate any unassigned IPs just by looping through the IPs and
- * finding the best node for each.
- */
-static void basic_allocate_unassigned(struct ctdb_context *ctdb,
-                                     struct ctdb_ipflags *ipflags,
-                                     struct public_ip_list *all_ips)
-{
-       struct public_ip_list *tmp_ip;
-
-       /* loop over all ip's and find a physical node to cover for 
-          each unassigned ip.
-       */
-       for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
-               if (tmp_ip->pnn == -1) {
-                       if (find_takeover_node(ctdb, ipflags, tmp_ip, all_ips)) {
-                               DEBUG(DEBUG_WARNING,("Failed to find node to cover ip %s\n",
-                                       ctdb_addr_to_str(&tmp_ip->addr)));
-                       }
-               }
-       }
-}
-
-/* Basic non-deterministic rebalancing algorithm.
- */
-static void basic_failback(struct ctdb_context *ctdb,
-                          struct ctdb_ipflags *ipflags,
-                          struct public_ip_list *all_ips,
-                          int num_ips)
-{
-       int i, numnodes;
-       int maxnode, maxnum, minnode, minnum, num, retries;
-       struct public_ip_list *tmp_ip;
-
-       numnodes = talloc_array_length(ipflags);
-       retries = 0;
-
-try_again:
-       maxnum=0;
-       minnum=0;
-
-       /* for each ip address, loop over all nodes that can serve
-          this ip and make sure that the difference between the node
-          serving the most and the node serving the least ip's are
-          not greater than 1.
-       */
-       for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
-               if (tmp_ip->pnn == -1) {
-                       continue;
-               }
-
-               /* Get the highest and lowest number of ips's served by any 
-                  valid node which can serve this ip.
-               */
-               maxnode = -1;
-               minnode = -1;
-               for (i=0; i<numnodes; i++) {
-                       /* only check nodes that can actually serve this ip */
-                       if (!can_node_takeover_ip(ctdb, i, ipflags[i], tmp_ip)) {
-                               /* no it couldnt   so skip to the next node */
-                               continue;
-                       }
-
-                       num = node_ip_coverage(i, all_ips);
-                       if (maxnode == -1) {
-                               maxnode = i;
-                               maxnum  = num;
-                       } else {
-                               if (num > maxnum) {
-                                       maxnode = i;
-                                       maxnum  = num;
-                               }
-                       }
-                       if (minnode == -1) {
-                               minnode = i;
-                               minnum  = num;
-                       } else {
-                               if (num < minnum) {
-                                       minnode = i;
-                                       minnum  = num;
-                               }
-                       }
-               }
-               if (maxnode == -1) {
-                       DEBUG(DEBUG_WARNING,(__location__ " Could not find maxnode. May not be able to serve ip '%s'\n",
-                               ctdb_addr_to_str(&tmp_ip->addr)));
-
-                       continue;
-               }
-
-               /* if the spread between the smallest and largest coverage by
-                  a node is >=2 we steal one of the ips from the node with
-                  most coverage to even things out a bit.
-                  try to do this a limited number of times since we dont
-                  want to spend too much time balancing the ip coverage.
-               */
-               if ( (maxnum > minnum+1)
-                    && (retries < (num_ips + 5)) ){
-                       struct public_ip_list *tmp;
-
-                       /* Reassign one of maxnode's VNNs */
-                       for (tmp=all_ips;tmp;tmp=tmp->next) {
-                               if (tmp->pnn == maxnode) {
-                                       (void)find_takeover_node(ctdb, ipflags, tmp, all_ips);
-                                       retries++;
-                                       goto try_again;;
-                               }
-                       }
-               }
-       }
-}
-
-static void lcp2_init(struct ctdb_context *tmp_ctx,
-                     struct ctdb_ipflags *ipflags,
-                     struct public_ip_list *all_ips,
-                     uint32_t *force_rebalance_nodes,
-                     uint32_t **lcp2_imbalances,
-                     bool **rebalance_candidates)
-{
-       int i, numnodes;
-       struct public_ip_list *tmp_ip;
-
-       numnodes = talloc_array_length(ipflags);
-
-       *rebalance_candidates = talloc_array(tmp_ctx, bool, numnodes);
-       CTDB_NO_MEMORY_FATAL(tmp_ctx, *rebalance_candidates);
-       *lcp2_imbalances = talloc_array(tmp_ctx, uint32_t, numnodes);
-       CTDB_NO_MEMORY_FATAL(tmp_ctx, *lcp2_imbalances);
-
-       for (i=0; i<numnodes; i++) {
-               (*lcp2_imbalances)[i] = lcp2_imbalance(all_ips, i);
-               /* First step: assume all nodes are candidates */
-               (*rebalance_candidates)[i] = true;
-       }
-
-       /* 2nd step: if a node has IPs assigned then it must have been
-        * healthy before, so we remove it from consideration.  This
-        * is overkill but is all we have because we don't maintain
-        * state between takeover runs.  An alternative would be to
-        * keep state and invalidate it every time the recovery master
-        * changes.
-        */
-       for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
-               if (tmp_ip->pnn != -1) {
-                       (*rebalance_candidates)[tmp_ip->pnn] = false;
-               }
-       }
-
-       /* 3rd step: if a node is forced to re-balance then
-          we allow failback onto the node */
-       if (force_rebalance_nodes == NULL) {
-               return;
-       }
-       for (i = 0; i < talloc_array_length(force_rebalance_nodes); i++) {
-               uint32_t pnn = force_rebalance_nodes[i];
-               if (pnn >= numnodes) {
-                       DEBUG(DEBUG_ERR,
-                             (__location__ "unknown node %u\n", pnn));
-                       continue;
-               }
-
-               DEBUG(DEBUG_NOTICE,
-                     ("Forcing rebalancing of IPs to node %u\n", pnn));
-               (*rebalance_candidates)[pnn] = true;
-       }
-}
-
-/* Allocate any unassigned addresses using the LCP2 algorithm to find
- * the IP/node combination that will cost the least.
- */
-static void lcp2_allocate_unassigned(struct ctdb_context *ctdb,
-                                    struct ctdb_ipflags *ipflags,
-                                    struct public_ip_list *all_ips,
-                                    uint32_t *lcp2_imbalances)
-{
-       struct public_ip_list *tmp_ip;
-       int dstnode, numnodes;
-
-       int minnode;
-       uint32_t mindsum, dstdsum, dstimbl, minimbl;
-       struct public_ip_list *minip;
-
-       bool should_loop = true;
-       bool have_unassigned = true;
-
-       numnodes = talloc_array_length(ipflags);
-
-       while (have_unassigned && should_loop) {
-               should_loop = false;
-
-               DEBUG(DEBUG_DEBUG,(" ----------------------------------------\n"));
-               DEBUG(DEBUG_DEBUG,(" CONSIDERING MOVES (UNASSIGNED)\n"));
-
-               minnode = -1;
-               mindsum = 0;
-               minip = NULL;
-
-               /* loop over each unassigned ip. */
-               for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
-                       if (tmp_ip->pnn != -1) {
-                               continue;
-                       }
-
-                       for (dstnode=0; dstnode<numnodes; dstnode++) {
-                               /* only check nodes that can actually takeover this ip */
-                               if (!can_node_takeover_ip(ctdb, dstnode,
-                                                         ipflags[dstnode],
-                                                         tmp_ip)) {
-                                       /* no it couldnt   so skip to the next node */
-                                       continue;
-                               }
-
-                               dstdsum = ip_distance_2_sum(&(tmp_ip->addr), all_ips, dstnode);
-                               dstimbl = lcp2_imbalances[dstnode] + dstdsum;
-                               DEBUG(DEBUG_DEBUG,(" %s -> %d [+%d]\n",
-                                                  ctdb_addr_to_str(&(tmp_ip->addr)),
-                                                  dstnode,
-                                                  dstimbl - lcp2_imbalances[dstnode]));
-
-
-                               if ((minnode == -1) || (dstdsum < mindsum)) {
-                                       minnode = dstnode;
-                                       minimbl = dstimbl;
-                                       mindsum = dstdsum;
-                                       minip = tmp_ip;
-                                       should_loop = true;
-                               }
-                       }
-               }
-
-               DEBUG(DEBUG_DEBUG,(" ----------------------------------------\n"));
-
-               /* If we found one then assign it to the given node. */
-               if (minnode != -1) {
-                       minip->pnn = minnode;
-                       lcp2_imbalances[minnode] = minimbl;
-                       DEBUG(DEBUG_INFO,(" %s -> %d [+%d]\n",
-                                         ctdb_addr_to_str(&(minip->addr)),
-                                         minnode,
-                                         mindsum));
-               }
-
-               /* There might be a better way but at least this is clear. */
-               have_unassigned = false;
-               for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
-                       if (tmp_ip->pnn == -1) {
-                               have_unassigned = true;
-                       }
-               }
-       }
-
-       /* We know if we have an unassigned addresses so we might as
-        * well optimise.
-        */
-       if (have_unassigned) {
-               for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
-                       if (tmp_ip->pnn == -1) {
-                               DEBUG(DEBUG_WARNING,("Failed to find node to cover ip %s\n",
-                                                    ctdb_addr_to_str(&tmp_ip->addr)));
-                       }
-               }
-       }
-}
-
-/* LCP2 algorithm for rebalancing the cluster.  Given a candidate node
- * to move IPs from, determines the best IP/destination node
- * combination to move from the source node.
- */
-static bool lcp2_failback_candidate(struct ctdb_context *ctdb,
-                                   struct ctdb_ipflags *ipflags,
-                                   struct public_ip_list *all_ips,
-                                   int srcnode,
-                                   uint32_t *lcp2_imbalances,
-                                   bool *rebalance_candidates)
-{
-       int dstnode, mindstnode, numnodes;
-       uint32_t srcimbl, srcdsum, dstimbl, dstdsum;
-       uint32_t minsrcimbl, mindstimbl;
-       struct public_ip_list *minip;
-       struct public_ip_list *tmp_ip;
-
-       /* Find an IP and destination node that best reduces imbalance. */
-       srcimbl = 0;
-       minip = NULL;
-       minsrcimbl = 0;
-       mindstnode = -1;
-       mindstimbl = 0;
-
-       numnodes = talloc_array_length(ipflags);
-
-       DEBUG(DEBUG_DEBUG,(" ----------------------------------------\n"));
-       DEBUG(DEBUG_DEBUG,(" CONSIDERING MOVES FROM %d [%d]\n",
-                          srcnode, lcp2_imbalances[srcnode]));
-
-       for (tmp_ip=all_ips; tmp_ip; tmp_ip=tmp_ip->next) {
-               /* Only consider addresses on srcnode. */
-               if (tmp_ip->pnn != srcnode) {
-                       continue;
-               }
-
-               /* What is this IP address costing the source node? */
-               srcdsum = ip_distance_2_sum(&(tmp_ip->addr), all_ips, srcnode);
-               srcimbl = lcp2_imbalances[srcnode] - srcdsum;
-
-               /* Consider this IP address would cost each potential
-                * destination node.  Destination nodes are limited to
-                * those that are newly healthy, since we don't want
-                * to do gratuitous failover of IPs just to make minor
-                * balance improvements.
-                */
-               for (dstnode=0; dstnode<numnodes; dstnode++) {
-                       if (!rebalance_candidates[dstnode]) {
-                               continue;
-                       }
-
-                       /* only check nodes that can actually takeover this ip */
-                       if (!can_node_takeover_ip(ctdb, dstnode,
-                                                 ipflags[dstnode], tmp_ip)) {
-                               /* no it couldnt   so skip to the next node */
-                               continue;
-                       }
-
-                       dstdsum = ip_distance_2_sum(&(tmp_ip->addr), all_ips, dstnode);
-                       dstimbl = lcp2_imbalances[dstnode] + dstdsum;
-                       DEBUG(DEBUG_DEBUG,(" %d [%d] -> %s -> %d [+%d]\n",
-                                          srcnode, -srcdsum,
-                                          ctdb_addr_to_str(&(tmp_ip->addr)),
-                                          dstnode, dstdsum));
-
-                       if ((dstimbl < lcp2_imbalances[srcnode]) &&
-                           (dstdsum < srcdsum) &&                      \
-                           ((mindstnode == -1) ||                              \
-                            ((srcimbl + dstimbl) < (minsrcimbl + mindstimbl)))) {
-
-                               minip = tmp_ip;
-                               minsrcimbl = srcimbl;
-                               mindstnode = dstnode;
-                               mindstimbl = dstimbl;
-                       }
-               }
-       }
-       DEBUG(DEBUG_DEBUG,(" ----------------------------------------\n"));
-
-        if (mindstnode != -1) {
-               /* We found a move that makes things better... */
-               DEBUG(DEBUG_INFO,("%d [%d] -> %s -> %d [+%d]\n",
-                                 srcnode, minsrcimbl - lcp2_imbalances[srcnode],
-                                 ctdb_addr_to_str(&(minip->addr)),
-                                 mindstnode, mindstimbl - lcp2_imbalances[mindstnode]));
-
-
-               lcp2_imbalances[srcnode] = minsrcimbl;
-               lcp2_imbalances[mindstnode] = mindstimbl;
-               minip->pnn = mindstnode;
-
-               return true;
-       }
-
-        return false;
-       
-}
-
-struct lcp2_imbalance_pnn {
-       uint32_t imbalance;
-       int pnn;
-};
-
-static int lcp2_cmp_imbalance_pnn(const void * a, const void * b)
-{
-       const struct lcp2_imbalance_pnn * lipa = (const struct lcp2_imbalance_pnn *) a;
-       const struct lcp2_imbalance_pnn * lipb = (const struct lcp2_imbalance_pnn *) b;
-
-       if (lipa->imbalance > lipb->imbalance) {
-               return -1;
-       } else if (lipa->imbalance == lipb->imbalance) {
-               return 0;
-       } else {
-               return 1;
-       }
-}
-
-/* LCP2 algorithm for rebalancing the cluster.  This finds the source
- * node with the highest LCP2 imbalance, and then determines the best
- * IP/destination node combination to move from the source node.
- */
-static void lcp2_failback(struct ctdb_context *ctdb,
-                         struct ctdb_ipflags *ipflags,
-                         struct public_ip_list *all_ips,
-                         uint32_t *lcp2_imbalances,
-                         bool *rebalance_candidates)
-{
-       int i, numnodes;
-       struct lcp2_imbalance_pnn * lips;
-       bool again;
-
-       numnodes = talloc_array_length(ipflags);
-
-try_again:
-       /* Put the imbalances and nodes into an array, sort them and
-        * iterate through candidates.  Usually the 1st one will be
-        * used, so this doesn't cost much...
-        */
-       DEBUG(DEBUG_DEBUG,("+++++++++++++++++++++++++++++++++++++++++\n"));
-       DEBUG(DEBUG_DEBUG,("Selecting most imbalanced node from:\n"));
-       lips = talloc_array(ctdb, struct lcp2_imbalance_pnn, numnodes);
-       for (i=0; i<numnodes; i++) {
-               lips[i].imbalance = lcp2_imbalances[i];
-               lips[i].pnn = i;
-               DEBUG(DEBUG_DEBUG,(" %d [%d]\n", i, lcp2_imbalances[i]));
-       }
-       qsort(lips, numnodes, sizeof(struct lcp2_imbalance_pnn),
-             lcp2_cmp_imbalance_pnn);
-
-       again = false;
-       for (i=0; i<numnodes; i++) {
-               /* This means that all nodes had 0 or 1 addresses, so
-                * can't be imbalanced.
-                */
-               if (lips[i].imbalance == 0) {
-                       break;
-               }
-
-               if (lcp2_failback_candidate(ctdb,
-                                           ipflags,
-                                           all_ips,
-                                           lips[i].pnn,
-                                           lcp2_imbalances,
-                                           rebalance_candidates)) {
-                       again = true;
-                       break;
-               }
-       }
-
-       talloc_free(lips);
-       if (again) {
-               goto try_again;
-       }
-}
-
-static void unassign_unsuitable_ips(struct ctdb_context *ctdb,
-                                   struct ctdb_ipflags *ipflags,
-                                   struct public_ip_list *all_ips)
-{
-       struct public_ip_list *tmp_ip;
-
-       /* verify that the assigned nodes can serve that public ip
-          and set it to -1 if not
-       */
-       for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
-               if (tmp_ip->pnn == -1) {
-                       continue;
-               }
-               if (!can_node_host_ip(ctdb, tmp_ip->pnn,
-                                     ipflags[tmp_ip->pnn], tmp_ip) != 0) {
-                       /* this node can not serve this ip. */
-                       DEBUG(DEBUG_DEBUG,("Unassign IP: %s from %d\n",
-                                          ctdb_addr_to_str(&(tmp_ip->addr)),
-                                          tmp_ip->pnn));
-                       tmp_ip->pnn = -1;
-               }
-       }
-}
-
-static void ip_alloc_deterministic_ips(struct ctdb_context *ctdb,
-                                      struct ctdb_ipflags *ipflags,
-                                      struct public_ip_list *all_ips)
-{
-       struct public_ip_list *tmp_ip;
-       int i, numnodes;
-
-       numnodes = talloc_array_length(ipflags);
-
-       DEBUG(DEBUG_NOTICE,("Deterministic IPs enabled. Resetting all ip allocations\n"));
-       /* Allocate IPs to nodes in a modulo fashion so that IPs will
-        *  always be allocated the same way for a specific set of
-        *  available/unavailable nodes.
-       */
-
-       for (i=0,tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next,i++) {
-               tmp_ip->pnn = i % numnodes;
-       }
-
-       /* IP failback doesn't make sense with deterministic
-        * IPs, since the modulo step above implicitly fails
-        * back IPs to their "home" node.
-        */
-       if (1 == ctdb->ipalloc_state->no_ip_failback) {
-               DEBUG(DEBUG_WARNING, ("WARNING: 'NoIPFailback' set but ignored - incompatible with 'DeterministicIPs\n"));
-       }
-
-       unassign_unsuitable_ips(ctdb, ipflags, all_ips);
-
-       basic_allocate_unassigned(ctdb, ipflags, all_ips);
-
-       /* No failback here! */
-}
-
-static void ip_alloc_nondeterministic_ips(struct ctdb_context *ctdb,
-                                         struct ctdb_ipflags *ipflags,
-                                         struct public_ip_list *all_ips)
-{
-       /* This should be pushed down into basic_failback. */
-       struct public_ip_list *tmp_ip;
-       int num_ips = 0;
-       for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
-               num_ips++;
-       }
-
-       unassign_unsuitable_ips(ctdb, ipflags, all_ips);
-
-       basic_allocate_unassigned(ctdb, ipflags, all_ips);
-
-       /* If we don't want IPs to fail back then don't rebalance IPs. */
-       if (1 == ctdb->ipalloc_state->no_ip_failback) {
-               return;
-       }
-
-       /* Now, try to make sure the ip adresses are evenly distributed
-          across the nodes.
-       */
-       basic_failback(ctdb, ipflags, all_ips, num_ips);
-}
-
-static void ip_alloc_lcp2(struct ctdb_context *ctdb,
-                         struct ctdb_ipflags *ipflags,
-                         struct public_ip_list *all_ips,
-                         uint32_t *force_rebalance_nodes)
-{
-       uint32_t *lcp2_imbalances;
-       bool *rebalance_candidates;
-       int numnodes, num_rebalance_candidates, i;
-
-       TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
-
-       unassign_unsuitable_ips(ctdb, ipflags, all_ips);
-
-       lcp2_init(tmp_ctx, ipflags, all_ips,force_rebalance_nodes,
-                 &lcp2_imbalances, &rebalance_candidates);
-
-       lcp2_allocate_unassigned(ctdb, ipflags, all_ips, lcp2_imbalances);
-
-       /* If we don't want IPs to fail back then don't rebalance IPs. */
-       if (1 == ctdb->ipalloc_state->no_ip_failback) {
-               goto finished;
-       }
-
-       /* It is only worth continuing if we have suitable target
-        * nodes to transfer IPs to.  This check is much cheaper than
-        * continuing on...
-        */
-       numnodes = talloc_array_length(ipflags);
-       num_rebalance_candidates = 0;
-       for (i=0; i<numnodes; i++) {
-               if (rebalance_candidates[i]) {
-                       num_rebalance_candidates++;
-               }
-       }
-       if (num_rebalance_candidates == 0) {
-               goto finished;
-       }
-
-       /* Now, try to make sure the ip adresses are evenly distributed
-          across the nodes.
-       */
-       lcp2_failback(ctdb, ipflags, all_ips,
-                     lcp2_imbalances, rebalance_candidates);
-
-finished:
-       talloc_free(tmp_ctx);
-}
-
-static bool all_nodes_are_disabled(struct ctdb_node_map_old *nodemap)
-{
-       int i;
-
-       for (i=0;i<nodemap->num;i++) {
-               if (!(nodemap->nodes[i].flags & (NODE_FLAGS_INACTIVE|NODE_FLAGS_DISABLED))) {
-                       /* Found one completely healthy node */
-                       return false;
-               }
-       }
-
-       return true;
-}
-
-/* The calculation part of the IP allocation algorithm. */
-static void ctdb_takeover_run_core(struct ctdb_context *ctdb,
-                                  struct ctdb_ipflags *ipflags,
-                                  struct public_ip_list *all_ips,
-                                  uint32_t *force_rebalance_nodes)
-{
-       switch (ctdb->ipalloc_state->algorithm) {
-       case IPALLOC_LCP2:
-               ip_alloc_lcp2(ctdb, ipflags, all_ips, force_rebalance_nodes);
-               break;
-       case IPALLOC_DETERMINISTIC:
-               ip_alloc_deterministic_ips(ctdb, ipflags, all_ips);
-               break;
-       case IPALLOC_NONDETERMINISTIC:
-               ip_alloc_nondeterministic_ips(ctdb, ipflags, all_ips);
-               break;
-       }
-
-       /* at this point ->pnn is the node which will own each IP
-          or -1 if there is no node that can cover this ip
-       */
-
-       return;
-}
-
-struct get_tunable_callback_data {
-       const char *tunable;
-       uint32_t *out;
-       bool fatal;
-};
-
-static void get_tunable_callback(struct ctdb_context *ctdb, uint32_t pnn,
-                                int32_t res, TDB_DATA outdata,
-                                void *callback)
-{
-       struct get_tunable_callback_data *cd =
-               (struct get_tunable_callback_data *)callback;
-       int size;
-
-       if (res != 0) {
-               /* Already handled in fail callback */
-               return;
-       }
-
-       if (outdata.dsize != sizeof(uint32_t)) {
-               DEBUG(DEBUG_ERR,("Wrong size of returned data when reading \"%s\" tunable from node %d. Expected %d bytes but received %d bytes\n",
-                                cd->tunable, pnn, (int)sizeof(uint32_t),
-                                (int)outdata.dsize));
-               cd->fatal = true;
-               return;
-       }
-
-       size = talloc_array_length(cd->out);
-       if (pnn >= size) {
-               DEBUG(DEBUG_ERR,("Got %s reply from node %d but nodemap only has %d entries\n",
-                                cd->tunable, pnn, size));
-               return;
-       }
-
-               
-       cd->out[pnn] = *(uint32_t *)outdata.dptr;
-}
-
-static void get_tunable_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
-                                      int32_t res, TDB_DATA outdata,
-                                      void *callback)
-{
-       struct get_tunable_callback_data *cd =
-               (struct get_tunable_callback_data *)callback;
-
-       switch (res) {
-       case -ETIME:
-               DEBUG(DEBUG_ERR,
-                     ("Timed out getting tunable \"%s\" from node %d\n",
-                      cd->tunable, pnn));
-               cd->fatal = true;
-               break;
-       case -EINVAL:
-       case -1:
-               DEBUG(DEBUG_WARNING,
-                     ("Tunable \"%s\" not implemented on node %d\n",
-                      cd->tunable, pnn));
-               break;
-       default:
-               DEBUG(DEBUG_ERR,
-                     ("Unexpected error getting tunable \"%s\" from node %d\n",
-                      cd->tunable, pnn));
-               cd->fatal = true;
+       switch (res) {
+       case -ETIME:
+               DEBUG(DEBUG_ERR,
+                     ("Timed out getting tunable \"%s\" from node %d\n",
+                      cd->tunable, pnn));
+               cd->fatal = true;
+               break;
+       case -EINVAL:
+       case -1:
+               DEBUG(DEBUG_WARNING,
+                     ("Tunable \"%s\" not implemented on node %d\n",
+                      cd->tunable, pnn));
+               break;
+       default:
+               DEBUG(DEBUG_ERR,
+                     ("Unexpected error getting tunable \"%s\" from node %d\n",
+                      cd->tunable, pnn));
+               cd->fatal = true;
        }
 }
 
@@ -2344,208 +1361,106 @@ static uint32_t *get_tunable_from_nodes(struct ctdb_context *ctdb,
        return tvals;
 }
 
-/* Set internal flags for IP allocation:
- *   Clear ip flags
- *   Set NOIPTAKOVER ip flags from per-node NoIPTakeover tunable
- *   Set NOIPHOST ip flag for each INACTIVE node
- *   if all nodes are disabled:
- *     Set NOIPHOST ip flags from per-node NoIPHostOnAllDisabled tunable
- *   else
- *     Set NOIPHOST ip flags for disabled nodes
- */
-static struct ctdb_ipflags *
-set_ipflags_internal(struct ctdb_context *ctdb,
-                    TALLOC_CTX *tmp_ctx,
-                    struct ctdb_node_map_old *nodemap,
-                    uint32_t *tval_noiptakeover,
-                    uint32_t *tval_noiphostonalldisabled)
+static struct ctdb_node_map *
+ctdb_node_map_old_to_new(TALLOC_CTX *mem_ctx,
+                        const struct ctdb_node_map_old *old)
 {
-       int i;
-       struct ctdb_ipflags *ipflags;
-
-       /* Clear IP flags - implicit due to talloc_zero */
-       ipflags = talloc_zero_array(tmp_ctx, struct ctdb_ipflags, nodemap->num);
-       CTDB_NO_MEMORY_NULL(ctdb, ipflags);
-
-       for (i=0;i<nodemap->num;i++) {
-               /* Can not take IPs on node with NoIPTakeover set */
-               if (tval_noiptakeover[i] != 0) {
-                       ipflags[i].noiptakeover = true;
-               }
-
-               /* Can not host IPs on INACTIVE node */
-               if (nodemap->nodes[i].flags & NODE_FLAGS_INACTIVE) {
-                       ipflags[i].noiphost = true;
-               }
-       }
+       struct ctdb_node_map *new;
 
-       if (all_nodes_are_disabled(nodemap)) {
-               /* If all nodes are disabled, can not host IPs on node
-                * with NoIPHostOnAllDisabled set
-                */
-               for (i=0;i<nodemap->num;i++) {
-                       if (tval_noiphostonalldisabled[i] != 0) {
-                               ipflags[i].noiphost = true;
-                       }
-               }
-       } else {
-               /* If some nodes are not disabled, then can not host
-                * IPs on DISABLED node
-                */
-               for (i=0;i<nodemap->num;i++) {
-                       if (nodemap->nodes[i].flags & NODE_FLAGS_DISABLED) {
-                               ipflags[i].noiphost = true;
-                       }
-               }
+       new = talloc(mem_ctx, struct ctdb_node_map);
+       if (new == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               return NULL;
        }
+       new->num = old->num;
+       new->node = talloc_zero_array(new,
+                                     struct ctdb_node_and_flags, new->num);
+       memcpy(new->node, &old->nodes[0],
+              sizeof(struct ctdb_node_and_flags) * new->num);
 
-       return ipflags;
+       return new;
 }
 
-static struct ctdb_ipflags *set_ipflags(struct ctdb_context *ctdb,
-                                       TALLOC_CTX *tmp_ctx,
-                                       struct ctdb_node_map_old *nodemap)
+
+static bool set_ipflags(struct ctdb_context *ctdb,
+                       struct ipalloc_state *ipalloc_state,
+                       struct ctdb_node_map_old *nodemap)
 {
        uint32_t *tval_noiptakeover;
        uint32_t *tval_noiphostonalldisabled;
-       struct ctdb_ipflags *ipflags;
-
+       struct ctdb_node_map *new;
 
-       tval_noiptakeover = get_tunable_from_nodes(ctdb, tmp_ctx, nodemap,
+       tval_noiptakeover = get_tunable_from_nodes(ctdb, ipalloc_state, nodemap,
                                                   "NoIPTakeover", 0);
        if (tval_noiptakeover == NULL) {
-               return NULL;
+               return false;
        }
 
        tval_noiphostonalldisabled =
-               get_tunable_from_nodes(ctdb, tmp_ctx, nodemap,
+               get_tunable_from_nodes(ctdb, ipalloc_state, nodemap,
                                       "NoIPHostOnAllDisabled", 0);
        if (tval_noiphostonalldisabled == NULL) {
                /* Caller frees tmp_ctx */
-               return NULL;
+               return false;
        }
 
-       ipflags = set_ipflags_internal(ctdb, tmp_ctx, nodemap,
-                                      tval_noiptakeover,
-                                      tval_noiphostonalldisabled);
+       new = ctdb_node_map_old_to_new(ipalloc_state, nodemap);
+       if (new == NULL) {
+               return false;
+       }
+
+       ipalloc_set_node_flags(ipalloc_state, new,
+                            tval_noiptakeover,
+                            tval_noiphostonalldisabled);
 
        talloc_free(tval_noiptakeover);
        talloc_free(tval_noiphostonalldisabled);
+       talloc_free(new);
 
-       return ipflags;
+       return true;
 }
 
-static struct ipalloc_state * ipalloc_state_init(struct ctdb_context *ctdb,
-                                                TALLOC_CTX *mem_ctx)
+static enum ipalloc_algorithm
+determine_algorithm(const struct ctdb_tunable_list *tunables)
 {
-       struct ipalloc_state *ipalloc_state =
-               talloc_zero(mem_ctx, struct ipalloc_state);
-       if (ipalloc_state == NULL) {
-               DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
-               return NULL;
-       }
-
-       ipalloc_state->num = ctdb->num_nodes;
-       ipalloc_state->known_public_ips =
-               talloc_zero_array(ipalloc_state,
-                                 struct ctdb_public_ip_list_old *,
-                                 ipalloc_state->num);
-       if (ipalloc_state->known_public_ips == NULL) {
-               DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
-               talloc_free(ipalloc_state);
-               return NULL;
-       }
-       ipalloc_state->available_public_ips =
-               talloc_zero_array(ipalloc_state,
-                                 struct ctdb_public_ip_list_old *,
-                                 ipalloc_state->num);
-       if (ipalloc_state->available_public_ips == NULL) {
-               DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
-               talloc_free(ipalloc_state);
-               return NULL;
-       }
-
-       if (1 == ctdb->tunable.lcp2_public_ip_assignment) {
-               ipalloc_state->algorithm = IPALLOC_LCP2;
-       } else if (1 == ctdb->tunable.deterministic_public_ips) {
-               ipalloc_state->algorithm = IPALLOC_DETERMINISTIC;
+       if (1 == tunables->lcp2_public_ip_assignment) {
+               return IPALLOC_LCP2;
+       } else if (1 == tunables->deterministic_public_ips) {
+               return IPALLOC_DETERMINISTIC;
        } else {
-               ipalloc_state->algorithm = IPALLOC_NONDETERMINISTIC;
+               return IPALLOC_NONDETERMINISTIC;
        }
-
-       ipalloc_state->no_ip_failback = ctdb->tunable.no_ip_failback;
-
-       return ipalloc_state;
 }
 
-struct iprealloc_callback_data {
-       bool *retry_nodes;
-       int retry_count;
-       client_async_callback fail_callback;
-       void *fail_callback_data;
-       struct ctdb_node_map_old *nodemap;
+struct takeover_callback_data {
+       uint32_t num_nodes;
+       unsigned int *fail_count;
 };
 
-static void iprealloc_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
-                                       int32_t res, TDB_DATA outdata,
-                                       void *callback)
+static struct takeover_callback_data *
+takeover_callback_data_init(TALLOC_CTX *mem_ctx,
+                           uint32_t num_nodes)
 {
-       int numnodes;
-       struct iprealloc_callback_data *cd =
-               (struct iprealloc_callback_data *)callback;
+       static struct takeover_callback_data *takeover_data;
 
-       numnodes = talloc_array_length(cd->retry_nodes);
-       if (pnn > numnodes) {
-               DEBUG(DEBUG_ERR,
-                     ("ipreallocated failure from node %d, "
-                      "but only %d nodes in nodemap\n",
-                      pnn, numnodes));
-               return;
+       takeover_data = talloc_zero(mem_ctx, struct takeover_callback_data);
+       if (takeover_data == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               return NULL;
        }
 
-       /* Can't run the "ipreallocated" event on a INACTIVE node */
-       if (cd->nodemap->nodes[pnn].flags & NODE_FLAGS_INACTIVE) {
-               DEBUG(DEBUG_WARNING,
-                     ("ipreallocated failed on inactive node %d, ignoring\n",
-                      pnn));
-               return;
+       takeover_data->fail_count = talloc_zero_array(takeover_data,
+                                                     unsigned int, num_nodes);
+       if (takeover_data->fail_count == NULL) {
+               DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
+               talloc_free(takeover_data);
+               return NULL;
        }
 
-       switch (res) {
-       case -ETIME:
-               /* If the control timed out then that's a real error,
-                * so call the real fail callback
-                */
-               if (cd->fail_callback) {
-                       cd->fail_callback(ctdb, pnn, res, outdata,
-                                         cd->fail_callback_data);
-               } else {
-                       DEBUG(DEBUG_WARNING,
-                             ("iprealloc timed out but no callback registered\n"));
-               }
-               break;
-       default:
-               /* If not a timeout then either the ipreallocated
-                * eventscript (or some setup) failed.  This might
-                * have failed because the IPREALLOCATED control isn't
-                * implemented - right now there is no way of knowing
-                * because the error codes are all folded down to -1.
-                * Consider retrying using EVENTSCRIPT control...
-                */
-               DEBUG(DEBUG_WARNING,
-                     ("ipreallocated failure from node %d, flagging retry\n",
-                      pnn));
-               cd->retry_nodes[pnn] = true;
-               cd->retry_count++;
-       }
-}
+       takeover_data->num_nodes = num_nodes;
 
-struct takeover_callback_data {
-       bool *node_failed;
-       client_async_callback fail_callback;
-       void *fail_callback_data;
-       struct ctdb_node_map_old *nodemap;
-};
+       return takeover_data;
+}
 
 static void takeover_run_fail_callback(struct ctdb_context *ctdb,
                                       uint32_t node_pnn, int32_t res,
@@ -2554,34 +1469,86 @@ static void takeover_run_fail_callback(struct ctdb_context *ctdb,
        struct takeover_callback_data *cd =
                talloc_get_type_abort(callback_data,
                                      struct takeover_callback_data);
-       int i;
-
-       for (i = 0; i < cd->nodemap->num; i++) {
-               if (node_pnn == cd->nodemap->nodes[i].pnn) {
-                       break;
-               }
-       }
 
-       if (i == cd->nodemap->num) {
+       if (node_pnn >= cd->num_nodes) {
                DEBUG(DEBUG_ERR, (__location__ " invalid PNN %u\n", node_pnn));
                return;
        }
 
-       if (!cd->node_failed[i]) {
-               cd->node_failed[i] = true;
-               cd->fail_callback(ctdb, node_pnn, res, outdata,
-                                 cd->fail_callback_data);
+       if (cd->fail_count[node_pnn] == 0) {
+               DEBUG(DEBUG_ERR,
+                     ("Node %u failed the takeover run\n", node_pnn));
+       }
+
+       cd->fail_count[node_pnn]++;
+}
+
+static void takeover_run_process_failures(struct ctdb_context *ctdb,
+                                         struct takeover_callback_data *tcd)
+{
+       unsigned int max_fails = 0;
+       uint32_t max_pnn = -1;
+       uint32_t i;
+
+       for (i = 0; i < tcd->num_nodes; i++) {
+               if (tcd->fail_count[i] > max_fails) {
+                       max_pnn = i;
+                       max_fails = tcd->fail_count[i];
+               }
+       }
+
+       if (max_fails > 0) {
+               int ret;
+               TDB_DATA data;
+
+               DEBUG(DEBUG_ERR,
+                     ("Sending banning credits to %u with fail count %u\n",
+                      max_pnn, max_fails));
+
+               data.dptr = (uint8_t *)&max_pnn;
+               data.dsize = sizeof(uint32_t);
+               ret = ctdb_client_send_message(ctdb,
+                                              CTDB_BROADCAST_CONNECTED,
+                                              CTDB_SRVID_BANNING,
+                                              data);
+               if (ret != 0) {
+                       DEBUG(DEBUG_ERR,
+                             ("Failed to set banning credits for node %u\n",
+                              max_pnn));
+               }
        }
 }
 
 /*
-  make any IP alias changes for public addresses that are necessary 
+ * Recalculate the allocation of public IPs to nodes and have the
+ * nodes host their allocated addresses.
+ *
+ * - Initialise IP allocation state.  Pass:
+     + algorithm to be used;
+     + whether IP rebalancing ("failback") should be done (this uses a
+       cluster-wide configuration variable and only the value form the
+       master node is used); and
+ *   + list of nodes to force rebalance (internal structure, currently
+ *     no way to fetch, only used by LCP2 for nodes that have had new
+ *     IP addresses added).
+ * - Set IP flags for IP allocation based on node map and tunables
+ *   NoIPTakeover/NoIPHostOnAllDisabled from all connected nodes
+ *   (tunable fetching done separately so values can be faked in unit
+ *   testing)
+ * - Retrieve known and available IP addresses (done separately so
+ *   values can be faked in unit testing)
+ * - Use ipalloc_set_public_ips() to set known and available IP
+     addresses for allocation
+ * - If cluster can't host IP addresses then early exit
+ * - Run IP allocation algorithm
+ * - Send RELEASE_IP to all nodes for IPs they should not host
+ * - Send TAKE_IP to all nodes for IPs they should host
+ * - Send IPREALLOCATED to all nodes (with backward compatibility hack)
  */
 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)
+                     uint32_t *force_rebalance_nodes)
 {
-       int i, j, ret;
+       int i, ret;
        struct ctdb_public_ip ip;
        uint32_t *nodes;
        struct public_ip_list *all_ips, *tmp_ip;
@@ -2590,12 +1557,24 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
        struct client_async_data *async_data;
        struct ctdb_client_control_state *state;
        TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
-       struct ctdb_ipflags *ipflags;
        struct ipalloc_state *ipalloc_state;
+       struct ctdb_public_ip_list *known_ips, *available_ips;
        struct takeover_callback_data *takeover_data;
-       struct iprealloc_callback_data iprealloc_data;
-       bool *retry_data;
-       bool can_host_ips;
+
+       /* Initialise fail callback data to be used with
+        * takeover_run_fail_callback().  A failure in any of the
+        * following steps will cause an early return, so this can be
+        * reused for each of those steps without re-initialising. */
+       takeover_data = takeover_callback_data_init(tmp_ctx,
+                                                   nodemap->num);
+       if (takeover_data == NULL) {
+               talloc_free(tmp_ctx);
+               return -1;
+       }
+
+       /* Default timeout for early jump to IPREALLOCATED.  See below
+        * for explanation of 3 times... */
+       timeout = timeval_current_ofs(3 * ctdb->tunable.takeover_timeout, 0);
 
        /*
         * ip failover is completely disabled, just send out the 
@@ -2605,66 +1584,62 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
                goto ipreallocated;
        }
 
-       ipalloc_state = ipalloc_state_init(ctdb, tmp_ctx);
+       ipalloc_state = ipalloc_state_init(tmp_ctx, ctdb->num_nodes,
+                                          determine_algorithm(&ctdb->tunable),
+                                          (ctdb->tunable.no_ip_failback != 0),
+                                          force_rebalance_nodes);
        if (ipalloc_state == NULL) {
                talloc_free(tmp_ctx);
                return -1;
        }
-       ctdb->ipalloc_state = ipalloc_state;
 
-       ipflags = set_ipflags(ctdb, tmp_ctx, nodemap);
-       if (ipflags == NULL) {
-               DEBUG(DEBUG_ERR,("Failed to set IP flags - aborting takeover run\n"));
+       if (!set_ipflags(ctdb, ipalloc_state, nodemap)) {
+               DEBUG(DEBUG_ERR,
+                     ("Failed to set IP flags - aborting takeover run\n"));
                talloc_free(tmp_ctx);
                return -1;
        }
 
        /* Fetch known/available public IPs from each active node */
-       ret = ctdb_reload_remote_public_ips(ctdb, ipalloc_state, nodemap);
-       if (ret != 0) {
+       /* Fetch lists of known public IPs from all nodes */
+       known_ips = ctdb_fetch_remote_public_ips(ctdb, ipalloc_state,
+                                                nodemap, 0);
+       if (known_ips == NULL) {
+               DEBUG(DEBUG_ERR, ("Failed to read known public IPs\n"));
+               talloc_free(tmp_ctx);
+               return -1;
+       }
+       available_ips = ctdb_fetch_remote_public_ips(
+               ctdb, ipalloc_state, nodemap,
+               CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE);
+       if (available_ips == NULL) {
+               DEBUG(DEBUG_ERR, ("Failed to read available public IPs\n"));
                talloc_free(tmp_ctx);
                return -1;
        }
 
-       /* Short-circuit IP allocation if no node has available IPs */
-       can_host_ips = false;
-       for (i=0; i < ipalloc_state->num; i++) {
-               if (ipalloc_state->available_public_ips[i] != NULL) {
-                       can_host_ips = true;
-               }
+       if (! ipalloc_set_public_ips(ipalloc_state, known_ips, available_ips)) {
+               DEBUG(DEBUG_ERR, ("Failed to set public IPs\n"));
+               talloc_free(tmp_ctx);
+               return -1;
        }
-       if (!can_host_ips) {
+
+       if (! ipalloc_can_host_ips(ipalloc_state)) {
                DEBUG(DEBUG_WARNING,("No nodes available to host public IPs yet\n"));
-               return 0;
+               goto ipreallocated;
        }
 
-       /* since nodes only know about those public addresses that
-          can be served by that particular node, no single node has
-          a full list of all public addresses that exist in the cluster.
-          Walk over all node structures and create a merged list of
-          all public addresses that exist in the cluster.
-
-          keep the tree of ips around as ctdb->ip_tree
-       */
-       all_ips = create_merged_ip_list(ctdb);
-
        /* Do the IP reassignment calculations */
-       ctdb_takeover_run_core(ctdb, ipflags, all_ips, force_rebalance_nodes);
+       all_ips = ipalloc(ipalloc_state);
+       if (all_ips == NULL) {
+               talloc_free(tmp_ctx);
+               return -1;
+       }
 
        /* Now tell all nodes to release any public IPs should not
         * host.  This will be a NOOP on nodes that don't currently
         * hold the given IP.
         */
-       takeover_data = talloc_zero(tmp_ctx, struct takeover_callback_data);
-       CTDB_NO_MEMORY_FATAL(ctdb, takeover_data);
-
-       takeover_data->node_failed = talloc_zero_array(tmp_ctx,
-                                                      bool, nodemap->num);
-       CTDB_NO_MEMORY_FATAL(ctdb, takeover_data->node_failed);
-       takeover_data->fail_callback = fail_callback;
-       takeover_data->fail_callback_data = callback_data;
-       takeover_data->nodemap = nodemap;
-
        async_data = talloc_zero(tmp_ctx, struct client_async_data);
        CTDB_NO_MEMORY_FATAL(ctdb, async_data);
 
@@ -2673,6 +1648,20 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
 
        ZERO_STRUCT(ip); /* Avoid valgrind warnings for union */
 
+       /* Each of the following stages (RELEASE_IP, TAKEOVER_IP,
+        * IPREALLOCATED) notionally has a timeout of TakeoverTimeout
+        * seconds.  However, RELEASE_IP can take longer due to TCP
+        * connection killing, so sometimes needs more time.
+        * Therefore, use a cumulative timeout of TakeoverTimeout * 3
+        * seconds across all 3 stages.  No explicit expiry checks are
+        * needed before each stage because tevent is smart enough to
+        * fire the timeouts even if they are in the past.  Initialise
+        * this here so it explicitly covers the stages we're
+        * interested in but, in particular, not the time taken by the
+        * ipalloc().
+        */
+       timeout = timeval_current_ofs(3 * ctdb->tunable.takeover_timeout, 0);
+
        /* Send a RELEASE_IP to all nodes that should not be hosting
         * each IP.  For each IP, all but one of these will be
         * redundant.  However, the redundant ones are used to tell
@@ -2695,7 +1684,6 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
                        ip.pnn  = tmp_ip->pnn;
                        ip.addr = tmp_ip->addr;
 
-                       timeout = TAKEOVER_TIMEOUT();
                        data.dsize = sizeof(ip);
                        data.dptr  = (uint8_t *)&ip;
                        state = ctdb_control_send(ctdb, nodemap->nodes[i].pnn,
@@ -2712,9 +1700,9 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
                }
        }
        if (ctdb_client_async_wait(ctdb, async_data) != 0) {
-               DEBUG(DEBUG_ERR,(__location__ " Async control CTDB_CONTROL_RELEASE_IP failed\n"));
-               talloc_free(tmp_ctx);
-               return -1;
+               DEBUG(DEBUG_ERR,
+                     ("Async control CTDB_CONTROL_RELEASE_IP failed\n"));
+               goto fail;
        }
        talloc_free(async_data);
 
@@ -2726,8 +1714,8 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
        async_data = talloc_zero(tmp_ctx, struct client_async_data);
        CTDB_NO_MEMORY_FATAL(ctdb, async_data);
 
-       async_data->fail_callback = fail_callback;
-       async_data->callback_data = callback_data;
+       async_data->fail_callback = takeover_run_fail_callback;
+       async_data->callback_data = takeover_data;
 
        for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
                if (tmp_ip->pnn == -1) {
@@ -2738,7 +1726,6 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
                ip.pnn  = tmp_ip->pnn;
                ip.addr = tmp_ip->addr;
 
-               timeout = TAKEOVER_TIMEOUT();
                data.dsize = sizeof(ip);
                data.dptr  = (uint8_t *)&ip;
                state = ctdb_control_send(ctdb, tmp_ip->pnn,
@@ -2753,9 +1740,9 @@ int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodem
                ctdb_client_async_add(async_data, state);
        }
        if (ctdb_client_async_wait(ctdb, async_data) != 0) {
-               DEBUG(DEBUG_ERR,(__location__ " Async control CTDB_CONTROL_TAKEOVER_IP failed\n"));
-               talloc_free(tmp_ctx);
-               return -1;
+               DEBUG(DEBUG_ERR,
+                     ("Async control CTDB_CONTROL_TAKEOVER_IP failed\n"));
+               goto fail;
        }
 
 ipreallocated:
@@ -2766,58 +1753,25 @@ ipreallocated:
         * IPs have moved.  Once upon a time this event only used to
         * update natgw.
         */
-       retry_data = talloc_zero_array(tmp_ctx, bool, nodemap->num);
-       CTDB_NO_MEMORY_FATAL(ctdb, retry_data);
-       iprealloc_data.retry_nodes = retry_data;
-       iprealloc_data.retry_count = 0;
-       iprealloc_data.fail_callback = fail_callback;
-       iprealloc_data.fail_callback_data = callback_data;
-       iprealloc_data.nodemap = nodemap;
-
        nodes = list_of_connected_nodes(ctdb, nodemap, tmp_ctx, true);
        ret = ctdb_client_async_control(ctdb, CTDB_CONTROL_IPREALLOCATED,
-                                       nodes, 0, TAKEOVER_TIMEOUT(),
+                                       nodes, 0, timeout,
                                        false, tdb_null,
-                                       NULL, iprealloc_fail_callback,
-                                       &iprealloc_data);
+                                       NULL, takeover_run_fail_callback,
+                                       takeover_data);
        if (ret != 0) {
-               /* If the control failed then we should retry to any
-                * nodes flagged by iprealloc_fail_callback using the
-                * EVENTSCRIPT control.  This is a best-effort at
-                * backward compatiblity when running a mixed cluster
-                * where some nodes have not yet been upgraded to
-                * support the IPREALLOCATED control.
-                */
-               DEBUG(DEBUG_WARNING,
-                     ("Retry ipreallocated to some nodes using eventscript control\n"));
-
-               nodes = talloc_array(tmp_ctx, uint32_t,
-                                    iprealloc_data.retry_count);
-               CTDB_NO_MEMORY_FATAL(ctdb, nodes);
-
-               j = 0;
-               for (i=0; i<nodemap->num; i++) {
-                       if (iprealloc_data.retry_nodes[i]) {
-                               nodes[j] = i;
-                               j++;
-                       }
-               }
-
-               data.dptr  = discard_const("ipreallocated");
-               data.dsize = strlen((char *)data.dptr) + 1; 
-               ret = ctdb_client_async_control(ctdb,
-                                               CTDB_CONTROL_RUN_EVENTSCRIPTS,
-                                               nodes, 0, TAKEOVER_TIMEOUT(),
-                                               false, data,
-                                               NULL, fail_callback,
-                                               callback_data);
-               if (ret != 0) {
-                       DEBUG(DEBUG_ERR, (__location__ " failed to send control to run eventscripts with \"ipreallocated\"\n"));
-               }
+               DEBUG(DEBUG_ERR,
+                     ("Async CTDB_CONTROL_IPREALLOCATED control failed\n"));
+               goto fail;
        }
 
        talloc_free(tmp_ctx);
        return ret;
+
+fail:
+       takeover_run_process_failures(ctdb, takeover_data);
+       talloc_free(tmp_ctx);
+       return -1;
 }
 
 
@@ -3049,23 +2003,15 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
                vnn->tcp_update_needed = true;
        }
 
-       return 0;
-}
-
-
-/*
-  called by a daemon to inform us of a TCP connection that one of its
-  clients managing that should tickled with an ACK when IP takeover is
-  done
- */
-static void ctdb_remove_connection(struct ctdb_context *ctdb, struct ctdb_connection *conn)
+       return 0;
+}
+
+
+static void ctdb_remove_connection(struct ctdb_vnn *vnn, struct ctdb_connection *conn)
 {
        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)));
                return;
        }
 
@@ -3122,6 +2068,7 @@ static void ctdb_remove_connection(struct ctdb_context *ctdb, struct ctdb_connec
  */
 int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata)
 {
+       struct ctdb_vnn *vnn;
        struct ctdb_connection *conn = (struct ctdb_connection *)indata.dptr;
 
        /* If we don't have public IPs, tickles are useless */
@@ -3129,7 +2076,15 @@ int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata)
                return 0;
        }
 
-       ctdb_remove_connection(ctdb, conn);
+       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)));
+               return 0;
+       }
+
+       ctdb_remove_connection(vnn, conn);
 
        return 0;
 }
@@ -3164,30 +2119,53 @@ int32_t ctdb_control_startup(struct ctdb_context *ctdb, uint32_t pnn)
 void ctdb_takeover_client_destructor_hook(struct ctdb_client *client)
 {
        while (client->tcp_list) {
+               struct ctdb_vnn *vnn;
                struct ctdb_tcp_list *tcp = client->tcp_list;
+               struct ctdb_connection *conn = &tcp->connection;
+
                DLIST_REMOVE(client->tcp_list, tcp);
-               ctdb_remove_connection(client->ctdb, &tcp->connection);
+
+               vnn = find_public_ip_vnn(client->ctdb,
+                                        &conn->dst);
+               if (vnn == NULL) {
+                       DEBUG(DEBUG_ERR,
+                             (__location__ " unable to find public address %s\n",
+                              ctdb_addr_to_str(&conn->dst)));
+                       continue;
+               }
+
+               /* If the IP address is hosted on this node then
+                * remove the connection. */
+               if (vnn->pnn == client->ctdb->pnn) {
+                       ctdb_remove_connection(vnn, conn);
+               }
+
+               /* Otherwise this function has been called because the
+                * server IP address has been released to another node
+                * and the client has exited.  This means that we
+                * should not delete the connection information.  The
+                * takeover node processes connections too. */
        }
 }
 
 
 void ctdb_release_all_ips(struct ctdb_context *ctdb)
 {
-       struct ctdb_vnn *vnn;
+       struct ctdb_vnn *vnn, *next;
        int count = 0;
 
        if (ctdb->tunable.disable_ip_failover == 1) {
                return;
        }
 
-       for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
+       for (vnn = ctdb->vnn; vnn != NULL; vnn = next) {
+               /* vnn can be freed below in release_ip_post() */
+               next = vnn->next;
+
                if (!ctdb_sys_have_ip(&vnn->public_address)) {
                        ctdb_vnn_unassign_iface(ctdb, vnn);
                        continue;
                }
-               if (!vnn->iface) {
-                       continue;
-               }
 
                /* Don't allow multiple releases at once.  Some code,
                 * particularly ctdb_tickle_sentenced_connections() is
@@ -3209,12 +2187,26 @@ void ctdb_release_all_ips(struct ctdb_context *ctdb)
                                    ctdb_vnn_iface_string(vnn)));
 
                ctdb_event_script_args(ctdb, CTDB_EVENT_RELEASE_IP, "%s %s %u",
-                                 ctdb_vnn_iface_string(vnn),
-                                 ctdb_addr_to_str(&vnn->public_address),
-                                 vnn->public_netmask_bits);
-               release_kill_clients(ctdb, &vnn->public_address);
-               ctdb_vnn_unassign_iface(ctdb, vnn);
-               vnn->update_in_flight = false;
+                                      ctdb_vnn_iface_string(vnn),
+                                      ctdb_addr_to_str(&vnn->public_address),
+                                      vnn->public_netmask_bits);
+               /* releaseip timeouts are converted to success, so to
+                * detect failures just check if the IP address is
+                * still there...
+                */
+               if (ctdb_sys_have_ip(&vnn->public_address)) {
+                       DEBUG(DEBUG_ERR,
+                             (__location__
+                              " IP address %s not released\n",
+                              ctdb_addr_to_str(&vnn->public_address)));
+                       vnn->update_in_flight = false;
+                       continue;
+               }
+
+               vnn = release_ip_post(ctdb, vnn, &vnn->public_address);
+               if (vnn != NULL) {
+                       vnn->update_in_flight = false;
+               }
                count++;
        }
 
@@ -3281,14 +2273,6 @@ int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
        addr = (ctdb_sock_addr *)indata.dptr;
 
        vnn = find_public_ip_vnn(ctdb, addr);
-       if (vnn == NULL) {
-               /* if it is not a public ip   it could be our 'single ip' */
-               if (ctdb->single_ip_vnn) {
-                       if (ctdb_same_ip(&ctdb->single_ip_vnn->public_address, addr)) {
-                               vnn = ctdb->single_ip_vnn;
-                       }
-               }
-       }
        if (vnn == NULL) {
                DEBUG(DEBUG_ERR,(__location__ " Could not get public ip info, "
                                 "'%s'not a public address\n",
@@ -3323,7 +2307,9 @@ int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
                if (vnn->iface == cur) {
                        info->active_idx = i;
                }
-               strncpy(info->ifaces[i].name, cur->name, sizeof(info->ifaces[i].name)-1);
+               strncpy(info->ifaces[i].name, cur->name,
+                       sizeof(info->ifaces[i].name));
+               info->ifaces[i].name[sizeof(info->ifaces[i].name)-1] = '\0';
                info->ifaces[i].link_state = cur->link_up;
                info->ifaces[i].references = cur->references;
        }
@@ -3358,7 +2344,9 @@ int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
 
        i = 0;
        for (cur=ctdb->ifaces;cur;cur=cur->next) {
-               strcpy(ifaces->ifaces[i].name, cur->name);
+               strncpy(ifaces->ifaces[i].name, cur->name,
+                       sizeof(ifaces->ifaces[i].name));
+               ifaces->ifaces[i].name[sizeof(ifaces->ifaces[i].name)-1] = '\0';
                ifaces->ifaces[i].link_state = cur->link_up;
                ifaces->ifaces[i].references = cur->references;
                i++;
@@ -3418,7 +2406,7 @@ int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
                return 0;
        }
 
-       DEBUG(iface->link_up?DEBUG_ERR:DEBUG_NOTICE,
+       DEBUG(DEBUG_ERR,
              ("iface[%s] has changed it's link status %s => %s\n",
               iface->name,
               iface->link_up?"up":"down",
@@ -3429,343 +2417,6 @@ int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
 }
 
 
-/* 
-   structure containing the listening socket and the list of tcp connections
-   that the ctdb daemon is to kill
-*/
-struct ctdb_kill_tcp {
-       struct ctdb_vnn *vnn;
-       struct ctdb_context *ctdb;
-       int capture_fd;
-       struct tevent_fd *fde;
-       trbt_tree_t *connections;
-       void *private_data;
-};
-
-/*
-  a tcp connection that is to be killed
- */
-struct ctdb_killtcp_con {
-       ctdb_sock_addr src_addr;
-       ctdb_sock_addr dst_addr;
-       int count;
-       struct ctdb_kill_tcp *killtcp;
-};
-
-/* this function is used to create a key to represent this socketpair
-   in the killtcp tree.
-   this key is used to insert and lookup matching socketpairs that are
-   to be tickled and RST
-*/
-#define KILLTCP_KEYLEN 10
-static uint32_t *killtcp_key(ctdb_sock_addr *src, ctdb_sock_addr *dst)
-{
-       static uint32_t key[KILLTCP_KEYLEN];
-
-       bzero(key, sizeof(key));
-
-       if (src->sa.sa_family != dst->sa.sa_family) {
-               DEBUG(DEBUG_ERR, (__location__ " ERROR, different families passed :%u vs %u\n", src->sa.sa_family, dst->sa.sa_family));
-               return key;
-       }
-       
-       switch (src->sa.sa_family) {
-       case AF_INET:
-               key[0]  = dst->ip.sin_addr.s_addr;
-               key[1]  = src->ip.sin_addr.s_addr;
-               key[2]  = dst->ip.sin_port;
-               key[3]  = src->ip.sin_port;
-               break;
-       case AF_INET6: {
-               uint32_t *dst6_addr32 =
-                       (uint32_t *)&(dst->ip6.sin6_addr.s6_addr);
-               uint32_t *src6_addr32 =
-                       (uint32_t *)&(src->ip6.sin6_addr.s6_addr);
-               key[0]  = dst6_addr32[3];
-               key[1]  = src6_addr32[3];
-               key[2]  = dst6_addr32[2];
-               key[3]  = src6_addr32[2];
-               key[4]  = dst6_addr32[1];
-               key[5]  = src6_addr32[1];
-               key[6]  = dst6_addr32[0];
-               key[7]  = src6_addr32[0];
-               key[8]  = dst->ip6.sin6_port;
-               key[9]  = src->ip6.sin6_port;
-               break;
-       }
-       default:
-               DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family passed :%u\n", src->sa.sa_family));
-               return key;
-       }
-
-       return key;
-}
-
-/*
-  called when we get a read event on the raw socket
- */
-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);
-       struct ctdb_killtcp_con *con;
-       ctdb_sock_addr src, dst;
-       uint32_t ack_seq, seq;
-
-       if (!(flags & TEVENT_FD_READ)) {
-               return;
-       }
-
-       if (ctdb_sys_read_tcp_packet(killtcp->capture_fd,
-                               killtcp->private_data,
-                               &src, &dst,
-                               &ack_seq, &seq) != 0) {
-               /* probably a non-tcp ACK packet */
-               return;
-       }
-
-       /* check if we have this guy in our list of connections
-          to kill
-       */
-       con = trbt_lookuparray32(killtcp->connections, 
-                       KILLTCP_KEYLEN, killtcp_key(&src, &dst));
-       if (con == NULL) {
-               /* no this was some other packet we can just ignore */
-               return;
-       }
-
-       /* This one has been tickled !
-          now reset him and remove him from the list.
-        */
-       DEBUG(DEBUG_INFO, ("sending a tcp reset to kill connection :%d -> %s:%d\n",
-               ntohs(con->dst_addr.ip.sin_port),
-               ctdb_addr_to_str(&con->src_addr),
-               ntohs(con->src_addr.ip.sin_port)));
-
-       ctdb_sys_send_tcp(&con->dst_addr, &con->src_addr, ack_seq, seq, 1);
-       talloc_free(con);
-}
-
-
-/* when traversing the list of all tcp connections to send tickle acks to
-   (so that we can capture the ack coming back and kill the connection
-    by a RST)
-   this callback is called for each connection we are currently trying to kill
-*/
-static int tickle_connection_traverse(void *param, void *data)
-{
-       struct ctdb_killtcp_con *con = talloc_get_type(data, struct ctdb_killtcp_con);
-
-       /* have tried too many times, just give up */
-       if (con->count >= 5) {
-               /* can't delete in traverse: reparent to delete_cons */
-               talloc_steal(param, con);
-               return 0;
-       }
-
-       /* othervise, try tickling it again */
-       con->count++;
-       ctdb_sys_send_tcp(
-               (ctdb_sock_addr *)&con->dst_addr,
-               (ctdb_sock_addr *)&con->src_addr,
-               0, 0, 0);
-       return 0;
-}
-
-
-/* 
-   called every second until all sentenced connections have been reset
- */
-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);
-       void *delete_cons = talloc_new(NULL);
-
-       /* loop over all connections sending tickle ACKs */
-       trbt_traversearray32(killtcp->connections, KILLTCP_KEYLEN, tickle_connection_traverse, delete_cons);
-
-       /* now we've finished traverse, it's safe to do deletion. */
-       talloc_free(delete_cons);
-
-       /* If there are no more connections to kill we can remove the
-          entire killtcp structure
-        */
-       if ( (killtcp->connections == NULL) || 
-            (killtcp->connections->root == NULL) ) {
-               talloc_free(killtcp);
-               return;
-       }
-
-       /* try tickling them again in a seconds time
-        */
-       tevent_add_timer(killtcp->ctdb->ev, killtcp,
-                        timeval_current_ofs(1, 0),
-                        ctdb_tickle_sentenced_connections, killtcp);
-}
-
-/*
-  destroy the killtcp structure
- */
-static int ctdb_killtcp_destructor(struct ctdb_kill_tcp *killtcp)
-{
-       struct ctdb_vnn *tmpvnn;
-
-       /* verify that this vnn is still active */
-       for (tmpvnn = killtcp->ctdb->vnn; tmpvnn; tmpvnn = tmpvnn->next) {
-               if (tmpvnn == killtcp->vnn) {
-                       break;
-               }
-       }
-
-       if (tmpvnn == NULL) {
-               return 0;
-       }
-
-       if (killtcp->vnn->killtcp != killtcp) {
-               return 0;
-       }
-
-       killtcp->vnn->killtcp = NULL;
-
-       return 0;
-}
-
-
-/* nothing fancy here, just unconditionally replace any existing
-   connection structure with the new one.
-
-   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
-*/
-static void *add_killtcp_callback(void *parm, void *data)
-{
-       return parm;
-}
-
-/*
-  add a tcp socket to the list of connections we want to RST
- */
-static int ctdb_killtcp_add_connection(struct ctdb_context *ctdb, 
-                                      ctdb_sock_addr *s,
-                                      ctdb_sock_addr *d)
-{
-       ctdb_sock_addr src, dst;
-       struct ctdb_kill_tcp *killtcp;
-       struct ctdb_killtcp_con *con;
-       struct ctdb_vnn *vnn;
-
-       ctdb_canonicalize_ip(s, &src);
-       ctdb_canonicalize_ip(d, &dst);
-
-       vnn = find_public_ip_vnn(ctdb, &dst);
-       if (vnn == NULL) {
-               vnn = find_public_ip_vnn(ctdb, &src);
-       }
-       if (vnn == NULL) {
-               /* if it is not a public ip   it could be our 'single ip' */
-               if (ctdb->single_ip_vnn) {
-                       if (ctdb_same_ip(&ctdb->single_ip_vnn->public_address, &dst)) {
-                               vnn = ctdb->single_ip_vnn;
-                       }
-               }
-       }
-       if (vnn == NULL) {
-               DEBUG(DEBUG_ERR,(__location__ " Could not killtcp, not a public address\n")); 
-               return -1;
-       }
-
-       killtcp = vnn->killtcp;
-       
-       /* If this is the first connection to kill we must allocate
-          a new structure
-        */
-       if (killtcp == NULL) {
-               killtcp = talloc_zero(vnn, struct ctdb_kill_tcp);
-               CTDB_NO_MEMORY(ctdb, killtcp);
-
-               killtcp->vnn         = vnn;
-               killtcp->ctdb        = ctdb;
-               killtcp->capture_fd  = -1;
-               killtcp->connections = trbt_create(killtcp, 0);
-
-               vnn->killtcp         = killtcp;
-               talloc_set_destructor(killtcp, ctdb_killtcp_destructor);
-       }
-
-
-
-       /* create a structure that describes this connection we want to
-          RST and store it in killtcp->connections
-       */
-       con = talloc(killtcp, struct ctdb_killtcp_con);
-       CTDB_NO_MEMORY(ctdb, con);
-       con->src_addr = src;
-       con->dst_addr = dst;
-       con->count    = 0;
-       con->killtcp  = killtcp;
-
-
-       trbt_insertarray32_callback(killtcp->connections,
-                       KILLTCP_KEYLEN, killtcp_key(&con->dst_addr, &con->src_addr),
-                       add_killtcp_callback, con);
-
-       /* 
-          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);
-               killtcp->capture_fd = ctdb_sys_open_capture_socket(iface, &killtcp->private_data);
-               if (killtcp->capture_fd == -1) {
-                       DEBUG(DEBUG_CRIT,(__location__ " Failed to open capturing "
-                                         "socket on iface '%s' for killtcp (%s)\n",
-                                         iface, strerror(errno)));
-                       goto failed;
-               }
-       }
-
-
-       if (killtcp->fde == NULL) {
-               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
-               */
-               tevent_add_timer(ctdb->ev, killtcp, timeval_current_ofs(1, 0),
-                                ctdb_tickle_sentenced_connections, killtcp);
-       }
-
-       /* tickle him once now */
-       ctdb_sys_send_tcp(
-               &con->dst_addr,
-               &con->src_addr,
-               0, 0, 0);
-
-       return 0;
-
-failed:
-       talloc_free(vnn->killtcp);
-       vnn->killtcp = NULL;
-       return -1;
-}
-
-/*
-  kill a TCP connection.
- */
-int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata)
-{
-       struct ctdb_connection *killtcp = (struct ctdb_connection *)indata.dptr;
-
-       return ctdb_killtcp_add_connection(ctdb, &killtcp->src, &killtcp->dst);
-}
-
 /*
   called by a daemon to inform us of the entire list of TCP tickles for
   a particular public address.
@@ -3804,6 +2455,13 @@ int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
                return 1;
        }
 
+       if (vnn->pnn == ctdb->pnn) {
+               DEBUG(DEBUG_INFO,
+                     ("Ignoring redundant set tcp tickle list, this node hosts '%s'\n",
+                      ctdb_addr_to_str(&list->addr)));
+               return 0;
+       }
+
        /* remove any old ticklelist we might have */
        talloc_free(vnn->tcp_array);
        vnn->tcp_array = NULL;
@@ -3834,22 +2492,34 @@ int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
        ctdb_sock_addr *addr = (ctdb_sock_addr *)indata.dptr;
        struct ctdb_tickle_list_old *list;
        struct ctdb_tcp_array *tcparray;
-       int num;
+       int num, i;
        struct ctdb_vnn *vnn;
+       unsigned port;
 
        vnn = find_public_ip_vnn(ctdb, addr);
        if (vnn == NULL) {
-               DEBUG(DEBUG_ERR,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n", 
+               DEBUG(DEBUG_ERR,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n",
                        ctdb_addr_to_str(addr)));
 
                return 1;
        }
 
+       port = ctdb_addr_to_port(addr);
+
        tcparray = vnn->tcp_array;
-       if (tcparray) {
-               num = tcparray->num;
-       } else {
-               num = 0;
+       num = 0;
+       if (tcparray != NULL) {
+               if (port == 0) {
+                       /* All connections */
+                       num = tcparray->num;
+               } else {
+                       /* Count connections for port */
+                       for (i = 0; i < tcparray->num; i++) {
+                               if (port == ctdb_addr_to_port(&tcparray->connections[i].dst)) {
+                                       num++;
+                               }
+                       }
+               }
        }
 
        outdata->dsize = offsetof(struct ctdb_tickle_list_old, connections)
@@ -3861,9 +2531,18 @@ int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
 
        list->addr = *addr;
        list->num = num;
-       if (num) {
-               memcpy(&list->connections[0], tcparray->connections,
-                       sizeof(struct ctdb_connection) * num);
+
+       if (num == 0) {
+               return 0;
+       }
+
+       num = 0;
+       for (i = 0; i < tcparray->num; i++) {
+               if (port == 0 || \
+                   port == ctdb_addr_to_port(&tcparray->connections[i].dst)) {
+                       list->connections[num] = tcparray->connections[i];
+                       num++;
+               }
        }
 
        return 0;
@@ -4081,29 +2760,7 @@ int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA inda
        return 0;
 }
 
-struct delete_ip_callback_state {
-       struct ctdb_req_control_old *c;
-};
-
-/*
-  called when releaseip event finishes for del_public_address
- */
-static void delete_ip_callback(struct ctdb_context *ctdb,
-                              int32_t status, TDB_DATA data,
-                              const char *errormsg,
-                              void *private_data)
-{
-       struct delete_ip_callback_state *state =
-               talloc_get_type(private_data, struct delete_ip_callback_state);
-
-       /* If release failed then fail. */
-       ctdb_request_control_reply(ctdb, state->c, NULL, status, errormsg);
-       talloc_free(private_data);
-}
-
-int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
-                                       struct ctdb_req_control_old *c,
-                                       TDB_DATA indata, bool *async_reply)
+int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
 {
        struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
        struct ctdb_vnn *vnn;
@@ -4130,49 +2787,13 @@ int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
        for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
                if (ctdb_same_ip(&vnn->public_address, &pub->addr)) {
                        if (vnn->pnn == ctdb->pnn) {
-                               struct delete_ip_callback_state *state;
-                               struct ctdb_public_ip *ip;
-                               TDB_DATA data;
-                               int ret;
-
+                               /* This IP is currently being hosted.
+                                * Defer the deletion until the next
+                                * takeover run. "ctdb reloadips" will
+                                * always cause a takeover run.  "ctdb
+                                * delip" will now need an explicit
+                                * "ctdb ipreallocated" afterwards. */
                                vnn->delete_pending = true;
-
-                               state = talloc(ctdb,
-                                              struct delete_ip_callback_state);
-                               CTDB_NO_MEMORY(ctdb, state);
-                               state->c = c;
-
-                               ip = talloc(state, struct ctdb_public_ip);
-                               if (ip == NULL) {
-                                       DEBUG(DEBUG_ERR,
-                                             (__location__ " Out of memory\n"));
-                                       talloc_free(state);
-                                       return -1;
-                               }
-                               ip->pnn = -1;
-                               ip->addr = pub->addr;
-
-                               data.dsize = sizeof(struct ctdb_public_ip);
-                               data.dptr = (unsigned char *)ip;
-
-                               ret = ctdb_daemon_send_control(ctdb,
-                                                              ctdb_get_pnn(ctdb),
-                                                              0,
-                                                              CTDB_CONTROL_RELEASE_IP,
-                                                              0, 0,
-                                                              data,
-                                                              delete_ip_callback,
-                                                              state);
-                               if (ret == -1) {
-                                       DEBUG(DEBUG_ERR,
-                                             (__location__ "Unable to send "
-                                              "CTDB_CONTROL_RELEASE_IP\n"));
-                                       talloc_free(state);
-                                       return -1;
-                               }
-
-                               state->c = talloc_steal(state, c);
-                               *async_reply = true;
                        } else {
                                /* This IP is not hosted on the
                                 * current node so just delete it
@@ -4245,82 +2866,6 @@ int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
 }
 
 
-/* This function is called from the recovery daemon to verify that a remote
-   node has the expected ip allocation.
-   This is verified against ctdb->ip_tree
-*/
-static int verify_remote_ip_allocation(struct ctdb_context *ctdb,
-                                      struct ctdb_public_ip_list_old *ips,
-                                      uint32_t pnn)
-{
-       struct public_ip_list *tmp_ip;
-       int i;
-
-       if (ctdb->ip_tree == NULL) {
-               /* don't know the expected allocation yet, assume remote node
-                  is correct. */
-               return 0;
-       }
-
-       if (ips == NULL) {
-               return 0;
-       }
-
-       for (i=0; i<ips->num; i++) {
-               tmp_ip = trbt_lookuparray32(ctdb->ip_tree, IP_KEYLEN, ip_key(&ips->ips[i].addr));
-               if (tmp_ip == NULL) {
-                       DEBUG(DEBUG_ERR,("Node %u has new or unknown public IP %s\n", pnn, ctdb_addr_to_str(&ips->ips[i].addr)));
-                       return -1;
-               }
-
-               if (tmp_ip->pnn == -1 || ips->ips[i].pnn == -1) {
-                       continue;
-               }
-
-               if (tmp_ip->pnn != ips->ips[i].pnn) {
-                       DEBUG(DEBUG_ERR,
-                             ("Inconsistent IP allocation - node %u thinks %s is held by node %u while it is assigned to node %u\n",
-                              pnn,
-                              ctdb_addr_to_str(&ips->ips[i].addr),
-                              ips->ips[i].pnn, tmp_ip->pnn));
-                       return -1;
-               }
-       }
-
-       return 0;
-}
-
-int update_ip_assignment_tree(struct ctdb_context *ctdb, struct ctdb_public_ip *ip)
-{
-       struct public_ip_list *tmp_ip;
-
-       /* IP tree is never built if DisableIPFailover is set */
-       if (ctdb->tunable.disable_ip_failover != 0) {
-               return 0;
-       }
-
-       if (ctdb->ip_tree == NULL) {
-               DEBUG(DEBUG_ERR,("No ctdb->ip_tree yet. Failed to update ip assignment\n"));
-               return -1;
-       }
-
-       tmp_ip = trbt_lookuparray32(ctdb->ip_tree, IP_KEYLEN, ip_key(&ip->addr));
-       if (tmp_ip == NULL) {
-               DEBUG(DEBUG_ERR,(__location__ " Could not find record for address %s, update ip\n", ctdb_addr_to_str(&ip->addr)));
-               return -1;
-       }
-
-       DEBUG(DEBUG_NOTICE,("Updated ip assignment tree for ip : %s from node %u to node %u\n", ctdb_addr_to_str(&ip->addr), tmp_ip->pnn, ip->pnn));
-       tmp_ip->pnn = ip->pnn;
-
-       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_old *c;
@@ -4598,10 +3143,7 @@ int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_re
                }
 
                sys_write(h->fd[1], &res, 1);
-               /* make sure we die when our parent dies */
-               while (ctdb_kill(ctdb, parent, 0) == 0 || errno != ESRCH) {
-                       sleep(5);
-               }
+               ctdb_wait_for_process_to_exit(parent);
                _exit(0);
        }