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