server/ctdb_takeover.c

   1 /*
   2    ctdb ip takeover code
   3
   4    Copyright (C) Ronnie Sahlberg  2007
   5    Copyright (C) Andrew Tridgell  2007
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, see <http://www.gnu.org/licenses/>.
  19 */
  20 #include "includes.h"
  21 #include "lib/events/events.h"
  22 #include "lib/tdb/include/tdb.h"
  23 #include "lib/util/dlinklist.h"
  24 #include "system/network.h"
  25 #include "system/filesys.h"
  26 #include "system/wait.h"
  27 #include "../include/ctdb_private.h"
  28 #include "../common/rb_tree.h"
  29
  30
  31 #define TAKEOVER_TIMEOUT() timeval_current_ofs(ctdb->tunable.takeover_timeout,0)
  32
  33 #define CTDB_ARP_INTERVAL 1
  34 #define CTDB_ARP_REPEAT   3
  35
  36 struct ctdb_takeover_arp {
  37         struct ctdb_context *ctdb;
  38         uint32_t count;
  39         struct sockaddr_in sin;
  40         struct ctdb_tcp_array *tcparray;
  41         struct ctdb_vnn *vnn;
  42 };
  43
  44
  45 /*
  46   lists of tcp endpoints
  47  */
  48 struct ctdb_tcp_list {
  49         struct ctdb_tcp_list *prev, *next;
  50         struct ctdb_tcp_connection connection;
  51 };
  52
  53 /*
  54   list of clients to kill on IP release
  55  */
  56 struct ctdb_client_ip {
  57         struct ctdb_client_ip *prev, *next;
  58         struct ctdb_context *ctdb;
  59         struct sockaddr_in ip;
  60         uint32_t client_id;
  61 };
  62
  63
  64 /*
  65   send a gratuitous arp
  66  */
  67 static void ctdb_control_send_arp(struct event_context *ev, struct timed_event *te,
  68                                   struct timeval t, void *private_data)
  69 {
  70         struct ctdb_takeover_arp *arp = talloc_get_type(private_data,
  71                                                         struct ctdb_takeover_arp);
  72         int i, s, ret;
  73         struct ctdb_tcp_array *tcparray;
  74
  75
  76         ret = ctdb_sys_send_arp(&arp->sin, arp->vnn->iface);
  77         if (ret != 0) {
  78                 DEBUG(0,(__location__ " sending of arp failed (%s)\n", strerror(errno)));
  79         }
  80
  81         s = ctdb_sys_open_sending_socket();
  82         if (s == -1) {
  83                 DEBUG(0,(__location__ " failed to open raw socket for sending tickles\n"));
  84                 return;
  85         }
  86
  87         tcparray = arp->tcparray;
  88         if (tcparray) {
  89                 for (i=0;i<tcparray->num;i++) {
  90                         DEBUG(2,("sending tcp tickle ack for %u->%s:%u\n",
  91                                  (unsigned)ntohs(tcparray->connections[i].daddr.sin_port),
  92                                  inet_ntoa(tcparray->connections[i].saddr.sin_addr),
  93                                  (unsigned)ntohs(tcparray->connections[i].saddr.sin_port)));
  94                         ret = ctdb_sys_send_tcp(s, &tcparray->connections[i].saddr,
  95                                                 &tcparray->connections[i].daddr, 0, 0, 0);
  96                         if (ret != 0) {
  97                                 DEBUG(0,(__location__ " Failed to send tcp tickle ack for %s\n",
  98                                          inet_ntoa(tcparray->connections[i].saddr.sin_addr)));
  99                         }
 100                 }
 101         }
 102
 103         close(s);
 104         arp->count++;
 105
 106         if (arp->count == CTDB_ARP_REPEAT) {
 107                 talloc_free(arp);
 108                 return;
 109         }
 110
 111         event_add_timed(arp->ctdb->ev, arp->vnn->takeover_ctx,
 112                         timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
 113                         ctdb_control_send_arp, arp);
 114 }
 115
 116 struct takeover_callback_state {
 117         struct ctdb_req_control *c;
 118         struct sockaddr_in *sin;
 119         struct ctdb_vnn *vnn;
 120 };
 121
 122 /*
 123   called when takeip event finishes
 124  */
 125 static void takeover_ip_callback(struct ctdb_context *ctdb, int status,
 126                                  void *private_data)
 127 {
 128         struct takeover_callback_state *state =
 129                 talloc_get_type(private_data, struct takeover_callback_state);
 130         struct ctdb_takeover_arp *arp;
 131         char *ip = inet_ntoa(state->sin->sin_addr);
 132         struct ctdb_tcp_array *tcparray;
 133
 134         ctdb_enable_monitoring(ctdb);
 135
 136         if (status != 0) {
 137                 DEBUG(0,(__location__ " Failed to takeover IP %s on interface %s\n",
 138                          ip, state->vnn->iface));
 139                 ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
 140                 talloc_free(state);
 141                 return;
 142         }
 143
 144         if (!state->vnn->takeover_ctx) {
 145                 state->vnn->takeover_ctx = talloc_new(ctdb);
 146                 if (!state->vnn->takeover_ctx) {
 147                         goto failed;
 148                 }
 149         }
 150
 151         arp = talloc_zero(state->vnn->takeover_ctx, struct ctdb_takeover_arp);
 152         if (!arp) goto failed;
 153
 154         arp->ctdb = ctdb;
 155         arp->sin = *state->sin;
 156         arp->vnn = state->vnn;
 157
 158         tcparray = state->vnn->tcp_array;
 159         if (tcparray) {
 160                 /* add all of the known tcp connections for this IP to the
 161                    list of tcp connections to send tickle acks for */
 162                 arp->tcparray = talloc_steal(arp, tcparray);
 163
 164                 state->vnn->tcp_array = NULL;
 165                 state->vnn->tcp_update_needed = true;
 166         }
 167
 168         event_add_timed(arp->ctdb->ev, state->vnn->takeover_ctx,
 169                         timeval_zero(), ctdb_control_send_arp, arp);
 170
 171         /* the control succeeded */
 172         ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
 173         talloc_free(state);
 174         return;
 175
 176 failed:
 177         ctdb_request_control_reply(ctdb, state->c, NULL, -1, NULL);
 178         talloc_free(state);
 179         return;
 180 }
 181
 182 /*
 183   Find the vnn of the node that has a public ip address
 184   returns -1 if the address is not known as a public address
 185  */
 186 static struct ctdb_vnn *find_public_ip_vnn(struct ctdb_context *ctdb, struct sockaddr_in ip)
 187 {
 188         struct ctdb_vnn *vnn;
 189
 190         for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
 191                 if (ctdb_same_ip(&vnn->public_address, &ip)) {
 192                         return vnn;
 193                 }
 194         }
 195
 196         return NULL;
 197 }
 198
 199
 200 /*
 201   take over an ip address
 202  */
 203 int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
 204                                  struct ctdb_req_control *c,
 205                                  TDB_DATA indata,
 206                                  bool *async_reply)
 207 {
 208         int ret;
 209         struct takeover_callback_state *state;
 210         struct ctdb_public_ip *pip = (struct ctdb_public_ip *)indata.dptr;
 211         struct ctdb_vnn *vnn;
 212
 213         /* update out vnn list */
 214         vnn = find_public_ip_vnn(ctdb, pip->sin);
 215         if (vnn == NULL) {
 216                 DEBUG(0,("takeoverip called for an ip '%s' that is not a public address\n",
 217                          inet_ntoa(pip->sin.sin_addr)));
 218                 return 0;
 219         }
 220         vnn->pnn = pip->pnn;
 221
 222         /* if our kernel already has this IP, do nothing */
 223         if (ctdb_sys_have_ip(pip->sin)) {
 224                 return 0;
 225         }
 226
 227         state = talloc(ctdb, struct takeover_callback_state);
 228         CTDB_NO_MEMORY(ctdb, state);
 229
 230         state->c = talloc_steal(ctdb, c);
 231         state->sin = talloc(ctdb, struct sockaddr_in);
 232         CTDB_NO_MEMORY(ctdb, state->sin);
 233         *state->sin = pip->sin;
 234
 235         state->vnn = vnn;
 236
 237         DEBUG(0,("Takeover of IP %s/%u on interface %s\n",
 238                  inet_ntoa(pip->sin.sin_addr), vnn->public_netmask_bits,
 239                  vnn->iface));
 240
 241         ctdb_disable_monitoring(ctdb);
 242
 243         ret = ctdb_event_script_callback(ctdb,
 244                                          timeval_current_ofs(ctdb->tunable.script_timeout, 0),
 245                                          state, takeover_ip_callback, state,
 246                                          "takeip %s %s %u",
 247                                          vnn->iface,
 248                                          inet_ntoa(pip->sin.sin_addr),
 249                                          vnn->public_netmask_bits);
 250
 251         if (ret != 0) {
 252                 ctdb_enable_monitoring(ctdb);
 253                 DEBUG(0,(__location__ " Failed to takeover IP %s on interface %s\n",
 254                          inet_ntoa(pip->sin.sin_addr), vnn->iface));
 255                 talloc_free(state);
 256                 return -1;
 257         }
 258
 259         /* tell ctdb_control.c that we will be replying asynchronously */
 260         *async_reply = true;
 261
 262         return 0;
 263 }
 264
 265 /*
 266   kill any clients that are registered with a IP that is being released
 267  */
 268 static void release_kill_clients(struct ctdb_context *ctdb, struct sockaddr_in in)
 269 {
 270         struct ctdb_client_ip *ip;
 271
 272         DEBUG(1,("release_kill_clients for ip %s\n", inet_ntoa(in.sin_addr)));
 273
 274         for (ip=ctdb->client_ip_list; ip; ip=ip->next) {
 275                 DEBUG(2,("checking for client %u with IP %s\n",
 276                          ip->client_id, inet_ntoa(ip->ip.sin_addr)));
 277                 if (ctdb_same_ip(&ip->ip, &in)) {
 278                         struct ctdb_client *client = ctdb_reqid_find(ctdb,
 279                                                                      ip->client_id,
 280                                                                      struct ctdb_client);
 281                         DEBUG(1,("matched client %u with IP %s and pid %u\n",
 282                                  ip->client_id, inet_ntoa(ip->ip.sin_addr), client->pid));
 283                         if (client->pid != 0) {
 284                                 DEBUG(0,(__location__ " Killing client pid %u for IP %s on client_id %u\n",
 285                                          (unsigned)client->pid, inet_ntoa(in.sin_addr),
 286                                          ip->client_id));
 287                                 kill(client->pid, SIGKILL);
 288                         }
 289                 }
 290         }
 291 }
 292
 293 /*
 294   called when releaseip event finishes
 295  */
 296 static void release_ip_callback(struct ctdb_context *ctdb, int status,
 297                                 void *private_data)
 298 {
 299         struct takeover_callback_state *state =
 300                 talloc_get_type(private_data, struct takeover_callback_state);
 301         char *ip = inet_ntoa(state->sin->sin_addr);
 302         TDB_DATA data;
 303
 304         ctdb_enable_monitoring(ctdb);
 305
 306         /* send a message to all clients of this node telling them
 307            that the cluster has been reconfigured and they should
 308            release any sockets on this IP */
 309         data.dptr = (uint8_t *)ip;
 310         data.dsize = strlen(ip)+1;
 311
 312         ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_RELEASE_IP, data);
 313
 314         /* kill clients that have registered with this IP */
 315         release_kill_clients(ctdb, *state->sin);
 316
 317         /* the control succeeded */
 318         ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
 319         talloc_free(state);
 320 }
 321
 322 /*
 323   release an ip address
 324  */
 325 int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
 326                                 struct ctdb_req_control *c,
 327                                 TDB_DATA indata,
 328                                 bool *async_reply)
 329 {
 330         int ret;
 331         struct takeover_callback_state *state;
 332         struct ctdb_public_ip *pip = (struct ctdb_public_ip *)indata.dptr;
 333         struct ctdb_vnn *vnn;
 334
 335         /* update our vnn list */
 336         vnn = find_public_ip_vnn(ctdb, pip->sin);
 337         if (vnn == NULL) {
 338                 DEBUG(0,("releaseip called for an ip '%s' that is not a public address\n",
 339                          inet_ntoa(pip->sin.sin_addr)));
 340                 return 0;
 341         }
 342         vnn->pnn = pip->pnn;
 343
 344         /* stop any previous arps */
 345         talloc_free(vnn->takeover_ctx);
 346         vnn->takeover_ctx = NULL;
 347
 348         if (!ctdb_sys_have_ip(pip->sin)) {
 349                 DEBUG(2,("Redundant release of IP %s/%u on interface %s (ip not held)\n",
 350                          inet_ntoa(pip->sin.sin_addr), vnn->public_netmask_bits,
 351                          vnn->iface));
 352                 return 0;
 353         }
 354
 355         DEBUG(0,("Release of IP %s/%u on interface %s\n",
 356                  inet_ntoa(pip->sin.sin_addr), vnn->public_netmask_bits,
 357                  vnn->iface));
 358
 359         state = talloc(ctdb, struct takeover_callback_state);
 360         CTDB_NO_MEMORY(ctdb, state);
 361
 362         state->c = talloc_steal(state, c);
 363         state->sin = talloc(state, struct sockaddr_in);
 364         CTDB_NO_MEMORY(ctdb, state->sin);
 365         *state->sin = pip->sin;
 366
 367         state->vnn = vnn;
 368
 369         ctdb_disable_monitoring(ctdb);
 370
 371         ret = ctdb_event_script_callback(ctdb,
 372                                          timeval_current_ofs(ctdb->tunable.script_timeout, 0),
 373                                          state, release_ip_callback, state,
 374                                          "releaseip %s %s %u",
 375                                          vnn->iface,
 376                                          inet_ntoa(pip->sin.sin_addr),
 377                                          vnn->public_netmask_bits);
 378         if (ret != 0) {
 379                 ctdb_enable_monitoring(ctdb);
 380
 381                 DEBUG(0,(__location__ " Failed to release IP %s on interface %s\n",
 382                          inet_ntoa(pip->sin.sin_addr), vnn->iface));
 383                 talloc_free(state);
 384                 return -1;
 385         }
 386
 387         /* tell the control that we will be reply asynchronously */
 388         *async_reply = true;
 389         return 0;
 390 }
 391
 392
 393
 394 static int add_public_address(struct ctdb_context *ctdb, struct sockaddr_in addr, unsigned mask, const char *iface)
 395 {
 396         struct ctdb_vnn      *vnn;
 397
 398         /* Verify that we dont have an entry for this ip yet */
 399         for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
 400                 if (ctdb_same_sockaddr(&addr, &vnn->public_address)) {
 401                         DEBUG(0,("Same ip '%s' specified multiple times in the public address list \n",
 402                                  inet_ntoa(addr.sin_addr)));
 403                         exit(1);
 404                 }
 405         }
 406
 407         /* create a new vnn structure for this ip address */
 408         vnn = talloc_zero(ctdb, struct ctdb_vnn);
 409         CTDB_NO_MEMORY_FATAL(ctdb, vnn);
 410         vnn->iface = talloc_strdup(vnn, iface);
 411         vnn->public_address      = addr;
 412         vnn->public_netmask_bits = mask;
 413         vnn->pnn                 = -1;
 414
 415         DLIST_ADD(ctdb->vnn, vnn);
 416
 417         return 0;
 418 }
 419
 420
 421 /*
 422   setup the event script directory
 423 */
 424 int ctdb_set_event_script_dir(struct ctdb_context *ctdb, const char *script_dir)
 425 {
 426         ctdb->event_script_dir = talloc_strdup(ctdb, script_dir);
 427         CTDB_NO_MEMORY(ctdb, ctdb->event_script_dir);
 428         return 0;
 429 }
 430
 431 /*
 432   setup the public address lists from a file
 433 */
 434 int ctdb_set_public_addresses(struct ctdb_context *ctdb, const char *alist)
 435 {
 436         char **lines;
 437         int nlines;
 438         int i;
 439
 440         lines = file_lines_load(alist, &nlines, ctdb);
 441         if (lines == NULL) {
 442                 ctdb_set_error(ctdb, "Failed to load public address list '%s'\n", alist);
 443                 return -1;
 444         }
 445         while (nlines > 0 && strcmp(lines[nlines-1], "") == 0) {
 446                 nlines--;
 447         }
 448
 449         for (i=0;i<nlines;i++) {
 450                 unsigned mask;
 451                 struct sockaddr_in addr;
 452                 const char *iface;
 453                 char *tok;
 454
 455                 tok = strtok(lines[i], " \t");
 456                 if (!tok || !parse_ip_mask(tok, &addr, &mask)) {
 457                         DEBUG(0,("Badly formed line %u in public address list\n", i+1));
 458                         talloc_free(lines);
 459                         return -1;
 460                 }
 461                 tok = strtok(NULL, " \t");
 462                 if (tok == NULL) {
 463                         if (NULL == ctdb->default_public_interface) {
 464                                 DEBUG(0,("No default public interface and no interface specified at line %u of public address list\n",
 465                                          i+1));
 466                                 talloc_free(lines);
 467                                 return -1;
 468                         }
 469                         iface = ctdb->default_public_interface;
 470                 } else {
 471                         iface = tok;
 472                 }
 473
 474                 if (add_public_address(ctdb, addr, mask, iface)) {
 475                         DEBUG(0,("Failed to add line %u to the public address list\n", i+1));
 476                         talloc_free(lines);
 477                         return -1;
 478                 }
 479         }
 480
 481         talloc_free(lines);
 482         return 0;
 483 }
 484
 485
 486
 487
 488 struct ctdb_public_ip_list {
 489         struct ctdb_public_ip_list *next;
 490         uint32_t pnn;
 491         struct sockaddr_in sin;
 492 };
 493
 494
 495 /* Given a physical node, return the number of
 496    public addresses that is currently assigned to this node.
 497 */
 498 static int node_ip_coverage(struct ctdb_context *ctdb,
 499         int32_t pnn,
 500         struct ctdb_public_ip_list *ips)
 501 {
 502         int num=0;
 503
 504         for (;ips;ips=ips->next) {
 505                 if (ips->pnn == pnn) {
 506                         num++;
 507                 }
 508         }
 509         return num;
 510 }
 511
 512
 513 /* Check if this is a public ip known to the node, i.e. can that
 514    node takeover this ip ?
 515 */
 516 static int can_node_serve_ip(struct ctdb_context *ctdb, int32_t pnn,
 517                 struct ctdb_public_ip_list *ip)
 518 {
 519         struct ctdb_all_public_ips *public_ips;
 520         int i;
 521
 522         public_ips = ctdb->nodes[pnn]->public_ips;
 523
 524         if (public_ips == NULL) {
 525                 return -1;
 526         }
 527
 528         for (i=0;i<public_ips->num;i++) {
 529                 if (ip->sin.sin_addr.s_addr == public_ips->ips[i].sin.sin_addr.s_addr) {
 530                         /* yes, this node can serve this public ip */
 531                         return 0;
 532                 }
 533         }
 534
 535         return -1;
 536 }
 537
 538
 539 /* search the node lists list for a node to takeover this ip.
 540    pick the node that currently are serving the least number of ips
 541    so that the ips get spread out evenly.
 542 */
 543 static int find_takeover_node(struct ctdb_context *ctdb,
 544                 struct ctdb_node_map *nodemap, uint32_t mask,
 545                 struct ctdb_public_ip_list *ip,
 546                 struct ctdb_public_ip_list *all_ips)
 547 {
 548         int pnn, min=0, num;
 549         int i;
 550
 551         pnn    = -1;
 552         for (i=0;i<nodemap->num;i++) {
 553                 if (nodemap->nodes[i].flags & mask) {
 554                         /* This node is not healty and can not be used to serve
 555                            a public address
 556                         */
 557                         continue;
 558                 }
 559
 560                 /* verify that this node can serve this ip */
 561                 if (can_node_serve_ip(ctdb, i, ip)) {
 562                         /* no it couldnt   so skip to the next node */
 563                         continue;
 564                 }
 565
 566                 num = node_ip_coverage(ctdb, i, all_ips);
 567                 /* was this the first node we checked ? */
 568                 if (pnn == -1) {
 569                         pnn = i;
 570                         min  = num;
 571                 } else {
 572                         if (num < min) {
 573                                 pnn = i;
 574                                 min  = num;
 575                         }
 576                 }
 577         }
 578         if (pnn == -1) {
 579                 DEBUG(0,(__location__ " Could not find node to take over public address '%s'\n", inet_ntoa(ip->sin.sin_addr)));
 580                 return -1;
 581         }
 582
 583         ip->pnn = pnn;
 584         return 0;
 585 }
 586
 587 struct ctdb_public_ip_list *
 588 add_ip_to_merged_list(struct ctdb_context *ctdb,
 589                         TALLOC_CTX *tmp_ctx,
 590                         struct ctdb_public_ip_list *ip_list,
 591                         struct ctdb_public_ip *ip)
 592 {
 593         struct ctdb_public_ip_list *tmp_ip;
 594
 595         /* do we already have this ip in our merged list ?*/
 596         for (tmp_ip=ip_list;tmp_ip;tmp_ip=tmp_ip->next) {
 597
 598                 /* we already  have this public ip in the list */
 599                 if (tmp_ip->sin.sin_addr.s_addr == ip->sin.sin_addr.s_addr) {
 600                         return ip_list;
 601                 }
 602         }
 603
 604         /* this is a new public ip, we must add it to the list */
 605         tmp_ip = talloc_zero(tmp_ctx, struct ctdb_public_ip_list);
 606         CTDB_NO_MEMORY_NULL(ctdb, tmp_ip);
 607         tmp_ip->pnn  = ip->pnn;
 608         tmp_ip->sin  = ip->sin;
 609         tmp_ip->next = ip_list;
 610
 611         return tmp_ip;
 612 }
 613
 614 struct ctdb_public_ip_list *
 615 create_merged_ip_list(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx)
 616 {
 617         int i, j;
 618         struct ctdb_public_ip_list *ip_list = NULL;
 619         struct ctdb_all_public_ips *public_ips;
 620
 621         for (i=0;i<ctdb->num_nodes;i++) {
 622                 public_ips = ctdb->nodes[i]->public_ips;
 623
 624                 /* there were no public ips for this node */
 625                 if (public_ips == NULL) {
 626                         continue;
 627                 }
 628
 629                 for (j=0;j<public_ips->num;j++) {
 630                         ip_list = add_ip_to_merged_list(ctdb, tmp_ctx,
 631                                         ip_list, &public_ips->ips[j]);
 632                 }
 633         }
 634
 635         return ip_list;
 636 }
 637
 638 /*
 639   make any IP alias changes for public addresses that are necessary
 640  */
 641 int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap)
 642 {
 643         int i, num_healthy, retries;
 644         int ret;
 645         struct ctdb_public_ip ip;
 646         uint32_t mask;
 647         struct ctdb_public_ip_list *all_ips, *tmp_ip;
 648         int maxnode, maxnum=0, minnode, minnum=0, num;
 649         TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
 650
 651
 652         ZERO_STRUCT(ip);
 653
 654         /* Count how many completely healthy nodes we have */
 655         num_healthy = 0;
 656         for (i=0;i<nodemap->num;i++) {
 657                 if (!(nodemap->nodes[i].flags & (NODE_FLAGS_INACTIVE|NODE_FLAGS_DISABLED))) {
 658                         num_healthy++;
 659                 }
 660         }
 661
 662         if (num_healthy > 0) {
 663                 /* We have healthy nodes, so only consider them for
 664                    serving public addresses
 665                 */
 666                 mask = NODE_FLAGS_INACTIVE|NODE_FLAGS_DISABLED;
 667         } else {
 668                 /* We didnt have any completely healthy nodes so
 669                    use "disabled" nodes as a fallback
 670                 */
 671                 mask = NODE_FLAGS_INACTIVE;
 672         }
 673
 674         /* since nodes only know about those public addresses that
 675            can be served by that particular node, no single node has
 676            a full list of all public addresses that exist in the cluster.
 677            Walk over all node structures and create a merged list of
 678            all public addresses that exist in the cluster.
 679         */
 680         all_ips = create_merged_ip_list(ctdb, tmp_ctx);
 681
 682         /* If we want deterministic ip allocations, i.e. that the ip addresses
 683            will always be allocated the same way for a specific set of
 684            available/unavailable nodes.
 685         */
 686         if (1 == ctdb->tunable.deterministic_public_ips) {
 687                 DEBUG(0,("Deterministic IPs enabled. Resetting all ip allocations\n"));
 688                 for (i=0,tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next,i++) {
 689                         tmp_ip->pnn = i%nodemap->num;
 690                 }
 691         }
 692
 693
 694         /* mark all public addresses with a masked node as being served by
 695            node -1
 696         */
 697         for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
 698                 if (tmp_ip->pnn == -1) {
 699                         continue;
 700                 }
 701                 if (nodemap->nodes[tmp_ip->pnn].flags & mask) {
 702                         tmp_ip->pnn = -1;
 703                 }
 704         }
 705
 706
 707         /* now we must redistribute all public addresses with takeover node
 708            -1 among the nodes available
 709         */
 710         retries = 0;
 711 try_again:
 712         /* loop over all ip's and find a physical node to cover for
 713            each unassigned ip.
 714         */
 715         for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
 716                 if (tmp_ip->pnn == -1) {
 717                         if (find_takeover_node(ctdb, nodemap, mask, tmp_ip, all_ips)) {
 718                                 DEBUG(0,("Failed to find node to cover ip %s\n", inet_ntoa(tmp_ip->sin.sin_addr)));
 719                         }
 720                 }
 721         }
 722
 723
 724         /* now, try to make sure the ip adresses are evenly distributed
 725            across the node.
 726            for each ip address, loop over all nodes that can serve this
 727            ip and make sure that the difference between the node
 728            serving the most and the node serving the least ip's are not greater
 729            than 1.
 730         */
 731         for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
 732                 if (tmp_ip->pnn == -1) {
 733                         continue;
 734                 }
 735
 736                 /* Get the highest and lowest number of ips's served by any
 737                    valid node which can serve this ip.
 738                 */
 739                 maxnode = -1;
 740                 minnode = -1;
 741                 for (i=0;i<nodemap->num;i++) {
 742                         if (nodemap->nodes[i].flags & mask) {
 743                                 continue;
 744                         }
 745
 746                         /* only check nodes that can actually serve this ip */
 747                         if (can_node_serve_ip(ctdb, i, tmp_ip)) {
 748                                 /* no it couldnt   so skip to the next node */
 749                                 continue;
 750                         }
 751
 752                         num = node_ip_coverage(ctdb, i, all_ips);
 753                         if (maxnode == -1) {
 754                                 maxnode = i;
 755                                 maxnum  = num;
 756                         } else {
 757                                 if (num > maxnum) {
 758                                         maxnode = i;
 759                                         maxnum  = num;
 760                                 }
 761                         }
 762                         if (minnode == -1) {
 763                                 minnode = i;
 764                                 minnum  = num;
 765                         } else {
 766                                 if (num < minnum) {
 767                                         minnode = i;
 768                                         minnum  = num;
 769                                 }
 770                         }
 771                 }
 772                 if (maxnode == -1) {
 773                         DEBUG(0,(__location__ " Could not find maxnode. May not be able to serve ip '%s'\n", inet_ntoa(tmp_ip->sin.sin_addr)));
 774                         continue;
 775                 }
 776
 777                 /* If we want deterministic IPs then dont try to reallocate
 778                    them to spread out the load.
 779                 */
 780                 if (1 == ctdb->tunable.deterministic_public_ips) {
 781                         continue;
 782                 }
 783
 784                 /* if the spread between the smallest and largest coverage by
 785                    a node is >=2 we steal one of the ips from the node with
 786                    most coverage to even things out a bit.
 787                    try to do this at most 5 times  since we dont want to spend
 788                    too much time balancing the ip coverage.
 789                 */
 790                 if ( (maxnum > minnum+1)
 791                   && (retries < 5) ){
 792                         struct ctdb_public_ip_list *tmp;
 793
 794                         /* mark one of maxnode's vnn's as unassigned and try
 795                            again
 796                         */
 797                         for (tmp=all_ips;tmp;tmp=tmp->next) {
 798                                 if (tmp->pnn == maxnode) {
 799                                         tmp->pnn = -1;
 800                                         retries++;
 801                                         goto try_again;
 802                                 }
 803                         }
 804                 }
 805         }
 806
 807
 808
 809         /* at this point ->pnn is the node which will own each IP
 810            or -1 if there is no node that can cover this ip
 811         */
 812
 813         /* now tell all nodes to delete any alias that they should not
 814            have.  This will be a NOOP on nodes that don't currently
 815            hold the given alias */
 816         for (i=0;i<nodemap->num;i++) {
 817                 /* don't talk to unconnected nodes, but do talk to banned nodes */
 818                 if (nodemap->nodes[i].flags & NODE_FLAGS_DISCONNECTED) {
 819                         continue;
 820                 }
 821
 822                 for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
 823                         if (tmp_ip->pnn == nodemap->nodes[i].pnn) {
 824                                 /* This node should be serving this
 825                                    vnn so dont tell it to release the ip
 826                                 */
 827                                 continue;
 828                         }
 829                         ip.pnn = tmp_ip->pnn;
 830                         ip.sin.sin_family = AF_INET;
 831                         ip.sin.sin_addr   = tmp_ip->sin.sin_addr;
 832
 833                         ret = ctdb_ctrl_release_ip(ctdb, TAKEOVER_TIMEOUT(),
 834                                                    nodemap->nodes[i].pnn,
 835                                                    &ip);
 836                         if (ret != 0) {
 837                                 DEBUG(0,("Failed to tell vnn %u to release IP %s\n",
 838                                          nodemap->nodes[i].pnn,
 839                                          inet_ntoa(tmp_ip->sin.sin_addr)));
 840                                 talloc_free(tmp_ctx);
 841                                 return -1;
 842                         }
 843                 }
 844         }
 845
 846
 847         /* tell all nodes to get their own IPs */
 848         for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
 849                 if (tmp_ip->pnn == -1) {
 850                         /* this IP won't be taken over */
 851                         continue;
 852                 }
 853                 ip.pnn = tmp_ip->pnn;
 854                 ip.sin.sin_family = AF_INET;
 855                 ip.sin.sin_addr = tmp_ip->sin.sin_addr;
 856
 857                 ret = ctdb_ctrl_takeover_ip(ctdb, TAKEOVER_TIMEOUT(),
 858                                             tmp_ip->pnn,
 859                                             &ip);
 860                 if (ret != 0) {
 861                         DEBUG(0,("Failed asking vnn %u to take over IP %s\n",
 862                                  tmp_ip->pnn,
 863                                  inet_ntoa(tmp_ip->sin.sin_addr)));
 864                         talloc_free(tmp_ctx);
 865                         return -1;
 866                 }
 867         }
 868
 869         talloc_free(tmp_ctx);
 870         return 0;
 871 }
 872
 873
 874 /*
 875   destroy a ctdb_client_ip structure
 876  */
 877 static int ctdb_client_ip_destructor(struct ctdb_client_ip *ip)
 878 {
 879         DEBUG(3,("destroying client tcp for %s:%u (client_id %u)\n",
 880                  inet_ntoa(ip->ip.sin_addr), ntohs(ip->ip.sin_port), ip->client_id));
 881         DLIST_REMOVE(ip->ctdb->client_ip_list, ip);
 882         return 0;
 883 }
 884
 885 /*
 886   called by a client to inform us of a TCP connection that it is managing
 887   that should tickled with an ACK when IP takeover is done
 888  */
 889 int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
 890                                 TDB_DATA indata)
 891 {
 892         struct ctdb_client *client = ctdb_reqid_find(ctdb, client_id, struct ctdb_client);
 893         struct ctdb_control_tcp *p = (struct ctdb_control_tcp *)indata.dptr;
 894         struct ctdb_tcp_list *tcp;
 895         struct ctdb_control_tcp_vnn t;
 896         int ret;
 897         TDB_DATA data;
 898         struct ctdb_client_ip *ip;
 899         struct ctdb_vnn *vnn;
 900
 901         vnn = find_public_ip_vnn(ctdb, p->dest);
 902         if (vnn == NULL) {
 903                 if (ntohl(p->dest.sin_addr.s_addr) != INADDR_LOOPBACK) {
 904                         DEBUG(0,("Could not add client IP %s. This is not a public address.\n",
 905                                  inet_ntoa(p->dest.sin_addr)));
 906                 }
 907                 return 0;
 908         }
 909
 910         if (vnn->pnn != ctdb->pnn) {
 911                 DEBUG(0,("Attempt to register tcp client for IP %s we don't hold - failing (client_id %u pid %u)\n",
 912                          inet_ntoa(p->dest.sin_addr),
 913                          client_id, client->pid));
 914                 /* failing this call will tell smbd to die */
 915                 return -1;
 916         }
 917
 918         ip = talloc(client, struct ctdb_client_ip);
 919         CTDB_NO_MEMORY(ctdb, ip);
 920
 921         ip->ctdb = ctdb;
 922         ip->ip = p->dest;
 923         ip->client_id = client_id;
 924         talloc_set_destructor(ip, ctdb_client_ip_destructor);
 925         DLIST_ADD(ctdb->client_ip_list, ip);
 926
 927         tcp = talloc(client, struct ctdb_tcp_list);
 928         CTDB_NO_MEMORY(ctdb, tcp);
 929
 930         tcp->connection.saddr = p->src;
 931         tcp->connection.daddr = p->dest;
 932
 933         DLIST_ADD(client->tcp_list, tcp);
 934
 935         t.src  = p->src;
 936         t.dest = p->dest;
 937
 938         data.dptr = (uint8_t *)&t;
 939         data.dsize = sizeof(t);
 940
 941         DEBUG(1,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
 942                  (unsigned)ntohs(p->dest.sin_port),
 943                  inet_ntoa(p->src.sin_addr),
 944                  (unsigned)ntohs(p->src.sin_port), client_id, client->pid));
 945
 946         /* tell all nodes about this tcp connection */
 947         ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_CONNECTED, 0,
 948                                        CTDB_CONTROL_TCP_ADD,
 949                                        0, CTDB_CTRL_FLAG_NOREPLY, data, NULL, NULL);
 950         if (ret != 0) {
 951                 DEBUG(0,(__location__ " Failed to send CTDB_CONTROL_TCP_ADD\n"));
 952                 return -1;
 953         }
 954
 955         return 0;
 956 }
 957
 958 /*
 959   see if two sockaddr_in are the same
 960  */
 961 static bool same_sockaddr_in(struct sockaddr_in *in1, struct sockaddr_in *in2)
 962 {
 963         return in1->sin_family == in2->sin_family &&
 964                 in1->sin_port == in2->sin_port &&
 965                 in1->sin_addr.s_addr == in2->sin_addr.s_addr;
 966 }
 967
 968 /*
 969   find a tcp address on a list
 970  */
 971 static struct ctdb_tcp_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
 972                                            struct ctdb_tcp_connection *tcp)
 973 {
 974         int i;
 975
 976         if (array == NULL) {
 977                 return NULL;
 978         }
 979
 980         for (i=0;i<array->num;i++) {
 981                 if (same_sockaddr_in(&array->connections[i].saddr, &tcp->saddr) &&
 982                     same_sockaddr_in(&array->connections[i].daddr, &tcp->daddr)) {
 983                         return &array->connections[i];
 984                 }
 985         }
 986         return NULL;
 987 }
 988
 989 /*
 990   called by a daemon to inform us of a TCP connection that one of its
 991   clients managing that should tickled with an ACK when IP takeover is
 992   done
 993  */
 994 int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata)
 995 {
 996         struct ctdb_control_tcp_vnn *p = (struct ctdb_control_tcp_vnn *)indata.dptr;
 997         struct ctdb_tcp_array *tcparray;
 998         struct ctdb_tcp_connection tcp;
 999         struct ctdb_vnn *vnn;
1000
1001         vnn = find_public_ip_vnn(ctdb, p->dest);
1002         if (vnn == NULL) {
1003                 DEBUG(0,(__location__ " got TCP_ADD control for an address which is not a public address '%s'\n",
1004                          inet_ntoa(p->dest.sin_addr)));
1005                 return -1;
1006         }
1007
1008
1009         tcparray = vnn->tcp_array;
1010
1011         /* If this is the first tickle */
1012         if (tcparray == NULL) {
1013                 tcparray = talloc_size(ctdb->nodes,
1014                         offsetof(struct ctdb_tcp_array, connections) +
1015                         sizeof(struct ctdb_tcp_connection) * 1);
1016                 CTDB_NO_MEMORY(ctdb, tcparray);
1017                 vnn->tcp_array = tcparray;
1018
1019                 tcparray->num = 0;
1020                 tcparray->connections = talloc_size(tcparray, sizeof(struct ctdb_tcp_connection));
1021                 CTDB_NO_MEMORY(ctdb, tcparray->connections);
1022
1023                 tcparray->connections[tcparray->num].saddr = p->src;
1024                 tcparray->connections[tcparray->num].daddr = p->dest;
1025                 tcparray->num++;
1026                 return 0;
1027         }
1028
1029
1030         /* Do we already have this tickle ?*/
1031         tcp.saddr = p->src;
1032         tcp.daddr = p->dest;
1033         if (ctdb_tcp_find(vnn->tcp_array, &tcp) != NULL) {
1034                 DEBUG(4,("Already had tickle info for %s:%u for vnn:%u\n",
1035                          inet_ntoa(tcp.daddr.sin_addr),
1036                          ntohs(tcp.daddr.sin_port),
1037                          vnn->pnn));
1038                 return 0;
1039         }
1040
1041         /* A new tickle, we must add it to the array */
1042         tcparray->connections = talloc_realloc(tcparray, tcparray->connections,
1043                                         struct ctdb_tcp_connection,
1044                                         tcparray->num+1);
1045         CTDB_NO_MEMORY(ctdb, tcparray->connections);
1046
1047         vnn->tcp_array = tcparray;
1048         tcparray->connections[tcparray->num].saddr = p->src;
1049         tcparray->connections[tcparray->num].daddr = p->dest;
1050         tcparray->num++;
1051
1052         DEBUG(2,("Added tickle info for %s:%u from vnn %u\n",
1053                  inet_ntoa(tcp.daddr.sin_addr),
1054                  ntohs(tcp.daddr.sin_port),
1055                  vnn->pnn));
1056
1057         return 0;
1058 }
1059
1060
1061 /*
1062   called by a daemon to inform us of a TCP connection that one of its
1063   clients managing that should tickled with an ACK when IP takeover is
1064   done
1065  */
1066 static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tcp_connection *conn)
1067 {
1068         struct ctdb_tcp_connection *tcpp;
1069         struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, conn->daddr);
1070
1071         if (vnn == NULL) {
1072                 DEBUG(0,(__location__ " unable to find public address %s\n", inet_ntoa(conn->daddr.sin_addr)));
1073                 return;
1074         }
1075
1076         /* if the array is empty we cant remove it
1077            and we dont need to do anything
1078          */
1079         if (vnn->tcp_array == NULL) {
1080                 DEBUG(2,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
1081                          inet_ntoa(conn->daddr.sin_addr),
1082                          ntohs(conn->daddr.sin_port)));
1083                 return;
1084         }
1085
1086
1087         /* See if we know this connection
1088            if we dont know this connection  then we dont need to do anything
1089          */
1090         tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
1091         if (tcpp == NULL) {
1092                 DEBUG(2,("Trying to remove tickle that doesnt exist %s:%u\n",
1093                          inet_ntoa(conn->daddr.sin_addr),
1094                          ntohs(conn->daddr.sin_port)));
1095                 return;
1096         }
1097
1098
1099         /* We need to remove this entry from the array.
1100            Instead of allocating a new array and copying data to it
1101            we cheat and just copy the last entry in the existing array
1102            to the entry that is to be removed and just shring the
1103            ->num field
1104          */
1105         *tcpp = vnn->tcp_array->connections[vnn->tcp_array->num - 1];
1106         vnn->tcp_array->num--;
1107
1108         /* If we deleted the last entry we also need to remove the entire array
1109          */
1110         if (vnn->tcp_array->num == 0) {
1111                 talloc_free(vnn->tcp_array);
1112                 vnn->tcp_array = NULL;
1113         }
1114
1115         vnn->tcp_update_needed = true;
1116
1117         DEBUG(2,("Removed tickle info for %s:%u\n",
1118                  inet_ntoa(conn->saddr.sin_addr),
1119                  ntohs(conn->saddr.sin_port)));
1120 }
1121
1122
1123 /*
1124   called when a daemon restarts - send all tickes for all public addresses
1125   we are serving immediately to the new node.
1126  */
1127 int32_t ctdb_control_startup(struct ctdb_context *ctdb, uint32_t vnn)
1128 {
1129 /*XXX here we should send all tickes we are serving to the new node */
1130         return 0;
1131 }
1132
1133
1134 /*
1135   called when a client structure goes away - hook to remove
1136   elements from the tcp_list in all daemons
1137  */
1138 void ctdb_takeover_client_destructor_hook(struct ctdb_client *client)
1139 {
1140         while (client->tcp_list) {
1141                 struct ctdb_tcp_list *tcp = client->tcp_list;
1142                 DLIST_REMOVE(client->tcp_list, tcp);
1143                 ctdb_remove_tcp_connection(client->ctdb, &tcp->connection);
1144         }
1145 }
1146
1147
1148 /*
1149   release all IPs on shutdown
1150  */
1151 void ctdb_release_all_ips(struct ctdb_context *ctdb)
1152 {
1153         struct ctdb_vnn *vnn;
1154
1155         for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
1156                 if (!ctdb_sys_have_ip(vnn->public_address)) {
1157                         continue;
1158                 }
1159                 ctdb_event_script(ctdb, "releaseip %s %s %u",
1160                                   vnn->iface,
1161                                   inet_ntoa(vnn->public_address.sin_addr),
1162                                   vnn->public_netmask_bits);
1163                 release_kill_clients(ctdb, vnn->public_address);
1164         }
1165 }
1166
1167
1168 /*
1169   get list of public IPs
1170  */
1171 int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
1172                                     struct ctdb_req_control *c, TDB_DATA *outdata)
1173 {
1174         int i, num, len;
1175         struct ctdb_all_public_ips *ips;
1176         struct ctdb_vnn *vnn;
1177
1178         /* count how many public ip structures we have */
1179         num = 0;
1180         for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
1181                 num++;
1182         }
1183
1184         len = offsetof(struct ctdb_all_public_ips, ips) +
1185                 num*sizeof(struct ctdb_public_ip);
1186         ips = talloc_zero_size(outdata, len);
1187         CTDB_NO_MEMORY(ctdb, ips);
1188
1189         outdata->dsize = len;
1190         outdata->dptr  = (uint8_t *)ips;
1191
1192         ips->num = num;
1193         i = 0;
1194         for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
1195                 ips->ips[i].pnn = vnn->pnn;
1196                 ips->ips[i].sin = vnn->public_address;
1197                 i++;
1198         }
1199
1200         return 0;
1201 }
1202
1203
1204
1205 /*
1206    structure containing the listening socket and the list of tcp connections
1207    that the ctdb daemon is to kill
1208 */
1209 struct ctdb_kill_tcp {
1210         struct ctdb_vnn *vnn;
1211         struct ctdb_context *ctdb;
1212         int capture_fd;
1213         int sending_fd;
1214         struct fd_event *fde;
1215         trbt_tree_t *connections;
1216         void *private_data;
1217 };
1218
1219 /*
1220   a tcp connection that is to be killed
1221  */
1222 struct ctdb_killtcp_con {
1223         struct sockaddr_in src;
1224         struct sockaddr_in dst;
1225         int count;
1226         struct ctdb_kill_tcp *killtcp;
1227 };
1228
1229 /* this function is used to create a key to represent this socketpair
1230    in the killtcp tree.
1231    this key is used to insert and lookup matching socketpairs that are
1232    to be tickled and RST
1233 */
1234 #define KILLTCP_KEYLEN  4
1235 static uint32_t *killtcp_key(struct sockaddr_in *src, struct sockaddr_in *dst)
1236 {
1237         static uint32_t key[KILLTCP_KEYLEN];
1238
1239         key[0]  = dst->sin_addr.s_addr;
1240         key[1]  = src->sin_addr.s_addr;
1241         key[2]  = dst->sin_port;
1242         key[3]  = src->sin_port;
1243
1244         return key;
1245 }
1246
1247 /*
1248   called when we get a read event on the raw socket
1249  */
1250 static void capture_tcp_handler(struct event_context *ev, struct fd_event *fde,
1251                                 uint16_t flags, void *private_data)
1252 {
1253         struct ctdb_kill_tcp *killtcp = talloc_get_type(private_data, struct ctdb_kill_tcp);
1254         struct ctdb_killtcp_con *con;
1255         struct sockaddr_in src, dst;
1256         uint32_t ack_seq, seq;
1257
1258         if (!(flags & EVENT_FD_READ)) {
1259                 return;
1260         }
1261
1262         if (ctdb_sys_read_tcp_packet(killtcp->capture_fd,
1263                                 killtcp->private_data,
1264                                 &src, &dst,
1265                                 &ack_seq, &seq) != 0) {
1266                 /* probably a non-tcp ACK packet */
1267                 return;
1268         }
1269
1270         /* check if we have this guy in our list of connections
1271            to kill
1272         */
1273         con = trbt_lookuparray32(killtcp->connections,
1274                         KILLTCP_KEYLEN, killtcp_key(&src, &dst));
1275         if (con == NULL) {
1276                 /* no this was some other packet we can just ignore */
1277                 return;
1278         }
1279
1280         /* This one has been tickled !
1281            now reset him and remove him from the list.
1282          */
1283         DEBUG(1, ("sending a tcp reset to kill connection :%d -> %s:%d\n", ntohs(con->dst.sin_port), inet_ntoa(con->src.sin_addr), ntohs(con->src.sin_port)));
1284
1285         ctdb_sys_send_tcp(killtcp->sending_fd, &con->dst,
1286                           &con->src, ack_seq, seq, 1);
1287         talloc_free(con);
1288 }
1289
1290
1291 /* when traversing the list of all tcp connections to send tickle acks to
1292    (so that we can capture the ack coming back and kill the connection
1293     by a RST)
1294    this callback is called for each connection we are currently trying to kill
1295 */
1296 static void tickle_connection_traverse(void *param, void *data)
1297 {
1298         struct ctdb_killtcp_con *con = talloc_get_type(data, struct ctdb_killtcp_con);
1299         struct ctdb_kill_tcp *killtcp = talloc_get_type(param, struct ctdb_kill_tcp);
1300
1301         /* have tried too many times, just give up */
1302         if (con->count >= 5) {
1303                 talloc_free(con);
1304                 return;
1305         }
1306
1307         /* othervise, try tickling it again */
1308         con->count++;
1309         ctdb_sys_send_tcp(killtcp->sending_fd, &con->dst, &con->src, 0, 0, 0);
1310 }
1311
1312
1313 /*
1314    called every second until all sentenced connections have been reset
1315  */
1316 static void ctdb_tickle_sentenced_connections(struct event_context *ev, struct timed_event *te,
1317                                               struct timeval t, void *private_data)
1318 {
1319         struct ctdb_kill_tcp *killtcp = talloc_get_type(private_data, struct ctdb_kill_tcp);
1320
1321
1322         /* loop over all connections sending tickle ACKs */
1323         trbt_traversearray32(killtcp->connections, KILLTCP_KEYLEN, tickle_connection_traverse, killtcp);
1324
1325
1326         /* If there are no more connections to kill we can remove the
1327            entire killtcp structure
1328          */
1329         if ( (killtcp->connections == NULL) ||
1330              (killtcp->connections->root == NULL) ) {
1331                 talloc_free(killtcp);
1332                 return;
1333         }
1334
1335         /* try tickling them again in a seconds time
1336          */
1337         event_add_timed(killtcp->ctdb->ev, killtcp, timeval_current_ofs(1, 0),
1338                         ctdb_tickle_sentenced_connections, killtcp);
1339 }
1340
1341 /*
1342   destroy the killtcp structure
1343  */
1344 static int ctdb_killtcp_destructor(struct ctdb_kill_tcp *killtcp)
1345 {
1346         if (killtcp->sending_fd != -1) {
1347                 close(killtcp->sending_fd);
1348                 killtcp->sending_fd = -1;
1349         }
1350         killtcp->vnn->killtcp = NULL;
1351         return 0;
1352 }
1353
1354
1355 /* nothing fancy here, just unconditionally replace any existing
1356    connection structure with the new one.
1357
1358    dont even free the old one if it did exist, that one is talloc_stolen
1359    by the same node in the tree anyway and will be deleted when the new data
1360    is deleted
1361 */
1362 static void *add_killtcp_callback(void *parm, void *data)
1363 {
1364         return parm;
1365 }
1366
1367 /*
1368   add a tcp socket to the list of connections we want to RST
1369  */
1370 static int ctdb_killtcp_add_connection(struct ctdb_context *ctdb,
1371                                        struct sockaddr_in *src, struct sockaddr_in *dst)
1372 {
1373         struct ctdb_kill_tcp *killtcp;
1374         struct ctdb_killtcp_con *con;
1375         struct ctdb_vnn *vnn;
1376
1377         vnn = find_public_ip_vnn(ctdb, *dst);
1378         if (vnn == NULL) {
1379                 vnn = find_public_ip_vnn(ctdb, *src);
1380         }
1381         if (vnn == NULL) {
1382                 /* if it is not a public ip   it could be our 'single ip' */
1383                 if (ctdb->single_ip_vnn) {
1384                         if (ctdb_same_ip(&ctdb->single_ip_vnn->public_address, dst)) {
1385                                 vnn = ctdb->single_ip_vnn;
1386                         }
1387                 }
1388         }
1389         if (vnn == NULL) {
1390                 DEBUG(0,(__location__ " Could not killtcp, not a public address\n"));
1391                 return -1;
1392         }
1393
1394         killtcp = vnn->killtcp;
1395
1396         /* If this is the first connection to kill we must allocate
1397            a new structure
1398          */
1399         if (killtcp == NULL) {
1400                 killtcp = talloc_zero(ctdb, struct ctdb_kill_tcp);
1401                 CTDB_NO_MEMORY(ctdb, killtcp);
1402
1403                 killtcp->vnn         = vnn;
1404                 killtcp->ctdb        = ctdb;
1405                 killtcp->capture_fd  = -1;
1406                 killtcp->sending_fd  = -1;
1407                 killtcp->connections = trbt_create(killtcp, 0);
1408
1409                 vnn->killtcp         = killtcp;
1410                 talloc_set_destructor(killtcp, ctdb_killtcp_destructor);
1411         }
1412
1413
1414
1415         /* create a structure that describes this connection we want to
1416            RST and store it in killtcp->connections
1417         */
1418         con = talloc(killtcp, struct ctdb_killtcp_con);
1419         CTDB_NO_MEMORY(ctdb, con);
1420         con->src     = *src;
1421         con->dst     = *dst;
1422         con->count   = 0;
1423         con->killtcp = killtcp;
1424
1425
1426         trbt_insertarray32_callback(killtcp->connections,
1427                         KILLTCP_KEYLEN, killtcp_key(&con->dst, &con->src),
1428                         add_killtcp_callback, con);
1429
1430         /*
1431            If we dont have a socket to send from yet we must create it
1432          */
1433         if (killtcp->sending_fd == -1) {
1434                 killtcp->sending_fd = ctdb_sys_open_sending_socket();
1435                 if (killtcp->sending_fd == -1) {
1436                         DEBUG(0,(__location__ " Failed to open sending socket for killtcp\n"));
1437                         goto failed;
1438                 }
1439         }
1440
1441         /*
1442            If we dont have a socket to listen on yet we must create it
1443          */
1444         if (killtcp->capture_fd == -1) {
1445                 killtcp->capture_fd = ctdb_sys_open_capture_socket(vnn->iface, &killtcp->private_data);
1446                 if (killtcp->capture_fd == -1) {
1447                         DEBUG(0,(__location__ " Failed to open capturing socket for killtcp\n"));
1448                         goto failed;
1449                 }
1450         }
1451
1452
1453         if (killtcp->fde == NULL) {
1454                 killtcp->fde = event_add_fd(ctdb->ev, killtcp, killtcp->capture_fd,
1455                                             EVENT_FD_READ | EVENT_FD_AUTOCLOSE,
1456                                             capture_tcp_handler, killtcp);
1457
1458                 /* We also need to set up some events to tickle all these connections
1459                    until they are all reset
1460                 */
1461                 event_add_timed(ctdb->ev, killtcp, timeval_current_ofs(1, 0),
1462                                 ctdb_tickle_sentenced_connections, killtcp);
1463         }
1464
1465         /* tickle him once now */
1466         ctdb_sys_send_tcp(killtcp->sending_fd, &con->dst, &con->src, 0, 0, 0);
1467
1468         return 0;
1469
1470 failed:
1471         talloc_free(vnn->killtcp);
1472         vnn->killtcp = NULL;
1473         return -1;
1474 }
1475
1476 /*
1477   kill a TCP connection.
1478  */
1479 int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata)
1480 {
1481         struct ctdb_control_killtcp *killtcp = (struct ctdb_control_killtcp *)indata.dptr;
1482
1483         return ctdb_killtcp_add_connection(ctdb, &killtcp->src, &killtcp->dst);
1484 }
1485
1486 /*
1487   called by a daemon to inform us of the entire list of TCP tickles for
1488   a particular public address.
1489   this control should only be sent by the node that is currently serving
1490   that public address.
1491  */
1492 int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata)
1493 {
1494         struct ctdb_control_tcp_tickle_list *list = (struct ctdb_control_tcp_tickle_list *)indata.dptr;
1495         struct ctdb_tcp_array *tcparray;
1496         struct ctdb_vnn *vnn;
1497
1498         /* We must at least have tickles.num or else we cant verify the size
1499            of the received data blob
1500          */
1501         if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list,
1502                                         tickles.connections)) {
1503                 DEBUG(0,("Bad indata in ctdb_control_set_tcp_tickle_list. Not enough data for the tickle.num field\n"));
1504                 return -1;
1505         }
1506
1507         /* verify that the size of data matches what we expect */
1508         if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list,
1509                                 tickles.connections)
1510                          + sizeof(struct ctdb_tcp_connection)
1511                                  * list->tickles.num) {
1512                 DEBUG(0,("Bad indata in ctdb_control_set_tcp_tickle_list\n"));
1513                 return -1;
1514         }
1515
1516         vnn = find_public_ip_vnn(ctdb, list->ip);
1517         if (vnn == NULL) {
1518                 DEBUG(0,(__location__ " Could not set tcp tickle list, '%s' is not a public address\n",
1519                          inet_ntoa(list->ip.sin_addr)));
1520                 return 1;
1521         }
1522
1523         /* remove any old ticklelist we might have */
1524         talloc_free(vnn->tcp_array);
1525         vnn->tcp_array = NULL;
1526
1527         tcparray = talloc(ctdb->nodes, struct ctdb_tcp_array);
1528         CTDB_NO_MEMORY(ctdb, tcparray);
1529
1530         tcparray->num = list->tickles.num;
1531
1532         tcparray->connections = talloc_array(tcparray, struct ctdb_tcp_connection, tcparray->num);
1533         CTDB_NO_MEMORY(ctdb, tcparray->connections);
1534
1535         memcpy(tcparray->connections, &list->tickles.connections[0],
1536                sizeof(struct ctdb_tcp_connection)*tcparray->num);
1537
1538         /* We now have a new fresh tickle list array for this vnn */
1539         vnn->tcp_array = talloc_steal(vnn, tcparray);
1540
1541         return 0;
1542 }
1543
1544 /*
1545   called to return the full list of tickles for the puclic address associated
1546   with the provided vnn
1547  */
1548 int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata)
1549 {
1550         struct sockaddr_in *ip = (struct sockaddr_in *)indata.dptr;
1551         struct ctdb_control_tcp_tickle_list *list;
1552         struct ctdb_tcp_array *tcparray;
1553         int num;
1554         struct ctdb_vnn *vnn;
1555
1556         vnn = find_public_ip_vnn(ctdb, *ip);
1557         if (vnn == NULL) {
1558                 DEBUG(0,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n",
1559                          inet_ntoa(ip->sin_addr)));
1560                 return 1;
1561         }
1562
1563         tcparray = vnn->tcp_array;
1564         if (tcparray) {
1565                 num = tcparray->num;
1566         } else {
1567                 num = 0;
1568         }
1569
1570         outdata->dsize = offsetof(struct ctdb_control_tcp_tickle_list,
1571                                 tickles.connections)
1572                         + sizeof(struct ctdb_tcp_connection) * num;
1573
1574         outdata->dptr  = talloc_size(outdata, outdata->dsize);
1575         CTDB_NO_MEMORY(ctdb, outdata->dptr);
1576         list = (struct ctdb_control_tcp_tickle_list *)outdata->dptr;
1577
1578         list->ip = *ip;
1579         list->tickles.num = num;
1580         if (num) {
1581                 memcpy(&list->tickles.connections[0], tcparray->connections,
1582                         sizeof(struct ctdb_tcp_connection) * num);
1583         }
1584
1585         return 0;
1586 }
1587
1588
1589 /*
1590   set the list of all tcp tickles for a public address
1591  */
1592 static int ctdb_ctrl_set_tcp_tickles(struct ctdb_context *ctdb,
1593                               struct timeval timeout, uint32_t destnode,
1594                               struct sockaddr_in *ip,
1595                               struct ctdb_tcp_array *tcparray)
1596 {
1597         int ret, num;
1598         TDB_DATA data;
1599         struct ctdb_control_tcp_tickle_list *list;
1600
1601         if (tcparray) {
1602                 num = tcparray->num;
1603         } else {
1604                 num = 0;
1605         }
1606
1607         data.dsize = offsetof(struct ctdb_control_tcp_tickle_list,
1608                                 tickles.connections) +
1609                         sizeof(struct ctdb_tcp_connection) * num;
1610         data.dptr = talloc_size(ctdb, data.dsize);
1611         CTDB_NO_MEMORY(ctdb, data.dptr);
1612
1613         list = (struct ctdb_control_tcp_tickle_list *)data.dptr;
1614         list->ip = *ip;
1615         list->tickles.num = num;
1616         if (tcparray) {
1617                 memcpy(&list->tickles.connections[0], tcparray->connections, sizeof(struct ctdb_tcp_connection) * num);
1618         }
1619
1620         ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_CONNECTED, 0,
1621                                        CTDB_CONTROL_SET_TCP_TICKLE_LIST,
1622                                        0, CTDB_CTRL_FLAG_NOREPLY, data, NULL, NULL);
1623         if (ret != 0) {
1624                 DEBUG(0,(__location__ " ctdb_control for set tcp tickles failed\n"));
1625                 return -1;
1626         }
1627
1628         talloc_free(data.dptr);
1629
1630         return ret;
1631 }
1632
1633
1634 /*
1635   perform tickle updates if required
1636  */
1637 static void ctdb_update_tcp_tickles(struct event_context *ev,
1638                                 struct timed_event *te,
1639                                 struct timeval t, void *private_data)
1640 {
1641         struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);
1642         int ret;
1643         struct ctdb_vnn *vnn;
1644
1645         for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
1646                 /* we only send out updates for public addresses that
1647                    we have taken over
1648                  */
1649                 if (ctdb->pnn != vnn->pnn) {
1650                         continue;
1651                 }
1652                 /* We only send out the updates if we need to */
1653                 if (!vnn->tcp_update_needed) {
1654                         continue;
1655                 }
1656                 ret = ctdb_ctrl_set_tcp_tickles(ctdb,
1657                                 TAKEOVER_TIMEOUT(),
1658                                 CTDB_BROADCAST_CONNECTED,
1659                                 &vnn->public_address,
1660                                 vnn->tcp_array);
1661                 if (ret != 0) {
1662                         DEBUG(0,("Failed to send the tickle update for public address %s\n",
1663                                  inet_ntoa(vnn->public_address.sin_addr)));
1664                 }
1665         }
1666
1667         event_add_timed(ctdb->ev, ctdb->tickle_update_context,
1668                              timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
1669                              ctdb_update_tcp_tickles, ctdb);
1670 }
1671
1672
1673 /*
1674   start periodic update of tcp tickles
1675  */
1676 void ctdb_start_tcp_tickle_update(struct ctdb_context *ctdb)
1677 {
1678         ctdb->tickle_update_context = talloc_new(ctdb);
1679
1680         event_add_timed(ctdb->ev, ctdb->tickle_update_context,
1681                              timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
1682                              ctdb_update_tcp_tickles, ctdb);
1683 }
1684
1685
1686
1687
1688 struct control_gratious_arp {
1689         struct ctdb_context *ctdb;
1690         struct sockaddr_in sin;
1691         const char *iface;
1692         int count;
1693 };
1694
1695 /*
1696   send a control_gratuitous arp
1697  */
1698 static void send_gratious_arp(struct event_context *ev, struct timed_event *te,
1699                                   struct timeval t, void *private_data)
1700 {
1701         int ret;
1702         struct control_gratious_arp *arp = talloc_get_type(private_data,
1703                                                         struct control_gratious_arp);
1704
1705         ret = ctdb_sys_send_arp(&arp->sin, arp->iface);
1706         if (ret != 0) {
1707                 DEBUG(0,(__location__ " sending of gratious arp failed (%s)\n", strerror(errno)));
1708         }
1709
1710
1711         arp->count++;
1712         if (arp->count == CTDB_ARP_REPEAT) {
1713                 talloc_free(arp);
1714                 return;
1715         }
1716
1717         event_add_timed(arp->ctdb->ev, arp,
1718                         timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
1719                         send_gratious_arp, arp);
1720 }
1721
1722
1723 /*
1724   send a gratious arp
1725  */
1726 int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb, TDB_DATA indata)
1727 {
1728         struct ctdb_control_gratious_arp *gratious_arp = (struct ctdb_control_gratious_arp *)indata.dptr;
1729         struct control_gratious_arp *arp;
1730
1731
1732         /* verify the size of indata */
1733         if (indata.dsize < offsetof(struct ctdb_control_gratious_arp, iface)) {
1734                 DEBUG(0,(__location__ " Too small indata to hold a ctdb_control_gratious_arp structure\n"));
1735                 return -1;
1736         }
1737         if (indata.dsize !=
1738                 ( offsetof(struct ctdb_control_gratious_arp, iface)
1739                 + gratious_arp->len ) ){
1740
1741                 DEBUG(0,(__location__ " Wrong size of indata. Was %d bytes "
1742                         "but should be %d bytes\n",
1743                         indata.dsize,
1744                         offsetof(struct ctdb_control_gratious_arp, iface)+gratious_arp->len));
1745                 return -1;
1746         }
1747
1748
1749         arp = talloc(ctdb, struct control_gratious_arp);
1750         CTDB_NO_MEMORY(ctdb, arp);
1751
1752         arp->ctdb  = ctdb;
1753         arp->sin   = gratious_arp->sin;
1754         arp->iface = talloc_strdup(arp, gratious_arp->iface);
1755         CTDB_NO_MEMORY(ctdb, arp->iface);
1756         arp->count = 0;
1757
1758         event_add_timed(arp->ctdb->ev, arp,
1759                         timeval_zero(), send_gratious_arp, arp);
1760
1761         return 0;
1762 }
1763