?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb-server: Use ctdb_connection_same() to simplify
[samba4-gss.git] / ctdb / server / ctdb_takeover.c
blobdc4fcf395b7a32a3cf664e8620098ecca6268190
1 /*
2 ctdb ip takeover code
3
4 Copyright (C) Ronnie Sahlberg 2007
5 Copyright (C) Andrew Tridgell 2007
6 Copyright (C) Martin Schwenke 2011
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21 #include "replace.h"
22 #include "system/network.h"
23 #include "system/filesys.h"
24 #include "system/time.h"
25 #include "system/wait.h"
26
27 #include <talloc.h>
28 #include <tevent.h>
29
30 #include "lib/util/dlinklist.h"
31 #include "lib/util/debug.h"
32 #include "lib/util/samba_util.h"
33 #include "lib/util/util_file.h"
34 #include "lib/util/sys_rw.h"
35 #include "lib/util/util_process.h"
36
37 #include "protocol/protocol_util.h"
38
39 #include "ctdb_private.h"
40 #include "ctdb_client.h"
41
42 #include "common/reqid.h"
43 #include "common/system.h"
44 #include "common/system_socket.h"
45 #include "common/common.h"
46 #include "common/logging.h"
47 #include "common/path.h"
48
49 #include "conf/ctdb_config.h"
50
51 #include "server/ipalloc.h"
52
53 #define TAKEOVER_TIMEOUT() timeval_current_ofs(ctdb->tunable.takeover_timeout,0)
54
55 #define CTDB_ARP_INTERVAL 1
56 #define CTDB_ARP_REPEAT 3
57
58 struct ctdb_interface {
59 struct ctdb_interface *prev, *next;
60 const char *name;
61 bool link_up;
62 uint32_t references;
63 };
64
65 struct vnn_interface {
66 struct vnn_interface *prev, *next;
67 struct ctdb_interface *iface;
68 };
69
70 /* state associated with a public ip address */
71 struct ctdb_vnn {
72 struct ctdb_vnn *prev, *next;
73
74 struct ctdb_interface *iface;
75 struct vnn_interface *ifaces;
76 ctdb_sock_addr public_address;
77 uint8_t public_netmask_bits;
78 const char *name;
79
80 /*
81 * The node number that is serving this public address - set
82 * to CTDB_UNKNOWN_PNN if no node is serving it
83 */
84 uint32_t pnn;
85
86 /* List of clients to tickle for this public address */
87 struct ctdb_tcp_array *tcp_array;
88
89 /* whether we need to update the other nodes with changes to our list
90 of connected clients */
91 bool tcp_update_needed;
92
93 /* a context to hang sending gratious arp events off */
94 TALLOC_CTX *takeover_ctx;
95
96 /* Set to true any time an update to this VNN is in flight.
97 This helps to avoid races. */
98 bool update_in_flight;
99
100 /* If CTDB_CONTROL_DEL_PUBLIC_IP is received for this IP
101 * address then this flag is set. It will be deleted in the
102 * release IP callback. */
103 bool delete_pending;
104 };
105
106 static const char *iface_string(const struct ctdb_interface *iface)
107 {
108 return (iface != NULL ? iface->name : "__none__");
109 }
110
111 static const char *ctdb_vnn_iface_string(const struct ctdb_vnn *vnn)
112 {
113 return iface_string(vnn->iface);
114 }
115
116 static const char *ctdb_vnn_address_string(const struct ctdb_vnn *vnn)
117 {
118 return vnn->name;
119 }
120
121 static struct ctdb_interface *ctdb_find_iface(struct ctdb_context *ctdb,
122 const char *iface);
123
124 static struct ctdb_interface *
125 ctdb_add_local_iface(struct ctdb_context *ctdb, const char *iface)
126 {
127 struct ctdb_interface *i;
128
129 if (strlen(iface) > CTDB_IFACE_SIZE) {
130 DEBUG(DEBUG_ERR, ("Interface name too long \"%s\"\n", iface));
131 return NULL;
132 }
133
134 /* Verify that we don't have an entry for this ip yet */
135 i = ctdb_find_iface(ctdb, iface);
136 if (i != NULL) {
137 return i;
138 }
139
140 /* create a new structure for this interface */
141 i = talloc_zero(ctdb, struct ctdb_interface);
142 if (i == NULL) {
143 DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
144 return NULL;
145 }
146 i->name = talloc_strdup(i, iface);
147 if (i->name == NULL) {
148 DEBUG(DEBUG_ERR, (__location__ " out of memory\n"));
149 talloc_free(i);
150 return NULL;
151 }
152
153 i->link_up = true;
154
155 DLIST_ADD(ctdb->ifaces, i);
156
157 return i;
158 }
159
160 static bool vnn_has_interface(struct ctdb_vnn *vnn,
161 const struct ctdb_interface *iface)
162 {
163 struct vnn_interface *i;
164
165 for (i = vnn->ifaces; i != NULL; i = i->next) {
166 if (iface == i->iface) {
167 return true;
168 }
169 }
170
171 return false;
172 }
173
174 /* If any interfaces now have no possible IPs then delete them. This
175 * implementation is naive (i.e. simple) rather than clever
176 * (i.e. complex). Given that this is run on delip and that operation
177 * is rare, this doesn't need to be efficient - it needs to be
178 * foolproof. One alternative is reference counting, where the logic
179 * is distributed and can, therefore, be broken in multiple places.
180 * Another alternative is to build a red-black tree of interfaces that
181 * can have addresses (by walking ctdb->vnn once) and then walking
182 * ctdb->ifaces once and deleting those not in the tree. Let's go to
183 * one of those if the naive implementation causes problems... :-)
184 */
185 static void ctdb_remove_orphaned_ifaces(struct ctdb_context *ctdb,
186 struct ctdb_vnn *vnn)
187 {
188 struct ctdb_interface *i, *next;
189
190 /* For each interface, check if there's an IP using it. */
191 for (i = ctdb->ifaces; i != NULL; i = next) {
192 struct ctdb_vnn *tv;
193 bool found;
194 next = i->next;
195
196 /* Only consider interfaces named in the given VNN. */
197 if (!vnn_has_interface(vnn, i)) {
198 continue;
199 }
200
201 /* Search for a vnn with this interface. */
202 found = false;
203 for (tv=ctdb->vnn; tv; tv=tv->next) {
204 if (vnn_has_interface(tv, i)) {
205 found = true;
206 break;
207 }
208 }
209
210 if (!found) {
211 /* None of the VNNs are using this interface. */
212 DLIST_REMOVE(ctdb->ifaces, i);
213 talloc_free(i);
214 }
215 }
216 }
217
218
219 static struct ctdb_interface *ctdb_find_iface(struct ctdb_context *ctdb,
220 const char *iface)
221 {
222 struct ctdb_interface *i;
223
224 for (i=ctdb->ifaces;i;i=i->next) {
225 if (strcmp(i->name, iface) == 0) {
226 return i;
227 }
228 }
229
230 return NULL;
231 }
232
233 static struct ctdb_interface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
234 struct ctdb_vnn *vnn)
235 {
236 struct vnn_interface *i;
237 struct ctdb_interface *cur = NULL;
238 struct ctdb_interface *best = NULL;
239
240 for (i = vnn->ifaces; i != NULL; i = i->next) {
241
242 cur = i->iface;
243
244 if (!cur->link_up) {
245 continue;
246 }
247
248 if (best == NULL) {
249 best = cur;
250 continue;
251 }
252
253 if (cur->references < best->references) {
254 best = cur;
255 continue;
256 }
257 }
258
259 return best;
260 }
261
262 static int32_t ctdb_vnn_assign_iface(struct ctdb_context *ctdb,
263 struct ctdb_vnn *vnn)
264 {
265 struct ctdb_interface *best = NULL;
266
267 if (vnn->iface) {
268 DBG_INFO("public address '%s' still assigned to iface '%s'\n",
269 ctdb_vnn_address_string(vnn),
270 ctdb_vnn_iface_string(vnn));
271 return 0;
272 }
273
274 best = ctdb_vnn_best_iface(ctdb, vnn);
275 if (best == NULL) {
276 DBG_ERR("public address '%s' cannot assign to iface any iface\n",
277 ctdb_vnn_address_string(vnn));
278 return -1;
279 }
280
281 vnn->iface = best;
282 best->references++;
283 vnn->pnn = ctdb->pnn;
284
285 DBG_INFO("public address '%s' now assigned to iface '%s' refs[%d]\n",
286 ctdb_vnn_address_string(vnn),
287 ctdb_vnn_iface_string(vnn),
288 best->references);
289 return 0;
290 }
291
292 static void ctdb_vnn_unassign_iface(struct ctdb_context *ctdb,
293 struct ctdb_vnn *vnn)
294 {
295 DBG_INFO("public address '%s' "
296 "now unassigned (old iface '%s' refs[%d])\n",
297 ctdb_vnn_address_string(vnn),
298 ctdb_vnn_iface_string(vnn),
299 vnn->iface != NULL ? vnn->iface->references : 0);
300 if (vnn->iface) {
301 vnn->iface->references--;
302 }
303 vnn->iface = NULL;
304 if (vnn->pnn == ctdb->pnn) {
305 vnn->pnn = CTDB_UNKNOWN_PNN;
306 }
307 }
308
309 static bool ctdb_vnn_available(struct ctdb_context *ctdb,
310 struct ctdb_vnn *vnn)
311 {
312 uint32_t flags;
313 struct vnn_interface *i;
314
315 /* Nodes that are not RUNNING can not host IPs */
316 if (ctdb->runstate != CTDB_RUNSTATE_RUNNING) {
317 return false;
318 }
319
320 flags = ctdb->nodes[ctdb->pnn]->flags;
321 if ((flags & (NODE_FLAGS_INACTIVE|NODE_FLAGS_DISABLED)) != 0) {
322 return false;
323 }
324
325 if (vnn->delete_pending) {
326 return false;
327 }
328
329 if (vnn->iface && vnn->iface->link_up) {
330 return true;
331 }
332
333 for (i = vnn->ifaces; i != NULL; i = i->next) {
334 if (i->iface->link_up) {
335 return true;
336 }
337 }
338
339 return false;
340 }
341
342 struct ctdb_takeover_arp {
343 struct ctdb_context *ctdb;
344 uint32_t count;
345 ctdb_sock_addr addr;
346 struct ctdb_tcp_array *tcparray;
347 struct ctdb_vnn *vnn;
348 };
349
350
351 /*
352 lists of tcp endpoints
353 */
354 struct ctdb_tcp_list {
355 struct ctdb_tcp_list *prev, *next;
356 struct ctdb_client *client;
357 struct ctdb_connection connection;
358 };
359
360 /*
361 send a gratuitous arp
362 */
363 static void ctdb_control_send_arp(struct tevent_context *ev,
364 struct tevent_timer *te,
365 struct timeval t, void *private_data)
366 {
367 struct ctdb_takeover_arp *arp = talloc_get_type(private_data,
368 struct ctdb_takeover_arp);
369 int ret;
370 struct ctdb_tcp_array *tcparray;
371 const char *iface;
372
373 /* IP address might have been released between sends */
374 if (arp->vnn->iface == NULL) {
375 DBG_INFO("Cancelling ARP send for released IP %s\n",
376 ctdb_vnn_address_string(arp->vnn));
377 talloc_free(arp);
378 return;
379 }
380
381 iface = ctdb_vnn_iface_string(arp->vnn);
382 ret = ctdb_sys_send_arp(&arp->addr, iface);
383 if (ret != 0) {
384 DBG_ERR("Failed to send ARP on interface %s: %s\n",
385 iface, strerror(ret));
386 }
387
388 tcparray = arp->tcparray;
389 if (tcparray) {
390 unsigned int i;
391
392 for (i=0;i<tcparray->num;i++) {
393 struct ctdb_connection *tcon;
394 char buf[128];
395
396 tcon = &tcparray->connections[i];
397 ret = ctdb_connection_to_buf(buf,
398 sizeof(buf),
399 tcon,
400 false,
401 " -> ");
402 if (ret != 0) {
403 strlcpy(buf, "UNKNOWN", sizeof(buf));
404 }
405 D_INFO("Send TCP tickle ACK: %s\n", buf);
406 ret = ctdb_sys_send_tcp(
407 &tcon->src,
408 &tcon->dst,
409 0, 0, 0);
410 if (ret != 0) {
411 DBG_ERR("Failed to send TCP tickle ACK: %s\n",
412 buf);
413 }
414 }
415 }
416
417 arp->count++;
418
419 if (arp->count == CTDB_ARP_REPEAT) {
420 talloc_free(arp);
421 return;
422 }
423
424 tevent_add_timer(arp->ctdb->ev, arp->vnn->takeover_ctx,
425 timeval_current_ofs(CTDB_ARP_INTERVAL, 100000),
426 ctdb_control_send_arp, arp);
427 }
428
429 static int32_t ctdb_announce_vnn_iface(struct ctdb_context *ctdb,
430 struct ctdb_vnn *vnn)
431 {
432 struct ctdb_takeover_arp *arp;
433 struct ctdb_tcp_array *tcparray;
434
435 if (!vnn->takeover_ctx) {
436 vnn->takeover_ctx = talloc_new(vnn);
437 if (!vnn->takeover_ctx) {
438 return -1;
439 }
440 }
441
442 arp = talloc_zero(vnn->takeover_ctx, struct ctdb_takeover_arp);
443 if (!arp) {
444 return -1;
445 }
446
447 arp->ctdb = ctdb;
448 arp->addr = vnn->public_address;
449 arp->vnn = vnn;
450
451 tcparray = vnn->tcp_array;
452 if (tcparray) {
453 /* add all of the known tcp connections for this IP to the
454 list of tcp connections to send tickle acks for */
455 arp->tcparray = talloc_steal(arp, tcparray);
456
457 vnn->tcp_array = NULL;
458 vnn->tcp_update_needed = true;
459 }
460
461 tevent_add_timer(arp->ctdb->ev, vnn->takeover_ctx,
462 timeval_zero(), ctdb_control_send_arp, arp);
463
464 return 0;
465 }
466
467 struct ctdb_do_takeip_state {
468 struct ctdb_req_control_old *c;
469 struct ctdb_vnn *vnn;
470 };
471
472 /*
473 called when takeip event finishes
474 */
475 static void ctdb_do_takeip_callback(struct ctdb_context *ctdb, int status,
476 void *private_data)
477 {
478 struct ctdb_do_takeip_state *state =
479 talloc_get_type(private_data, struct ctdb_do_takeip_state);
480 int32_t ret;
481 TDB_DATA data;
482
483 if (status != 0) {
484 if (status == -ETIMEDOUT) {
485 ctdb_ban_self(ctdb);
486 }
487 DBG_ERR("Failed to takeover IP %s on interface %s\n",
488 ctdb_vnn_address_string(state->vnn),
489 ctdb_vnn_iface_string(state->vnn));
490 ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
491
492 talloc_free(state);
493 return;
494 }
495
496 if (ctdb->do_checkpublicip) {
497
498 ret = ctdb_announce_vnn_iface(ctdb, state->vnn);
499 if (ret != 0) {
500 ctdb_request_control_reply(ctdb, state->c, NULL, -1, NULL);
501 talloc_free(state);
502 return;
503 }
504
505 }
506
507 data.dptr = (uint8_t *)discard_const(
508 ctdb_vnn_address_string(state->vnn));
509 data.dsize = strlen((char *)data.dptr) + 1;
510 DEBUG(DEBUG_INFO,(__location__ " sending TAKE_IP for '%s'\n", data.dptr));
511
512 ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_TAKE_IP, data);
513
514
515 /* the control succeeded */
516 ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
517 talloc_free(state);
518 return;
519 }
520
521 static int ctdb_takeip_destructor(struct ctdb_do_takeip_state *state)
522 {
523 state->vnn->update_in_flight = false;
524 return 0;
525 }
526
527 /*
528 take over an ip address
529 */
530 static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
531 struct ctdb_req_control_old *c,
532 struct ctdb_vnn *vnn)
533 {
534 int ret;
535 struct ctdb_do_takeip_state *state;
536
537 if (vnn->update_in_flight) {
538 D_NOTICE("Takeover of IP %s/%u rejected "
539 "update for this IP already in flight\n",
540 ctdb_vnn_address_string(vnn),
541 vnn->public_netmask_bits);
542 return -1;
543 }
544
545 ret = ctdb_vnn_assign_iface(ctdb, vnn);
546 if (ret != 0) {
547 D_ERR("Takeover of IP %s/%u failed to "
548 "assign a usable interface\n",
549 ctdb_vnn_address_string(vnn),
550 vnn->public_netmask_bits);
551 return -1;
552 }
553
554 state = talloc(vnn, struct ctdb_do_takeip_state);
555 CTDB_NO_MEMORY(ctdb, state);
556
557 state->c = NULL;
558 state->vnn = vnn;
559
560 vnn->update_in_flight = true;
561 talloc_set_destructor(state, ctdb_takeip_destructor);
562
563 D_NOTICE("Takeover of IP %s/%u on interface %s\n",
564 ctdb_vnn_address_string(vnn),
565 vnn->public_netmask_bits,
566 ctdb_vnn_iface_string(vnn));
567
568 ret = ctdb_event_script_callback(ctdb,
569 state,
570 ctdb_do_takeip_callback,
571 state,
572 CTDB_EVENT_TAKE_IP,
573 "%s %s %u",
574 ctdb_vnn_iface_string(vnn),
575 ctdb_vnn_address_string(vnn),
576 vnn->public_netmask_bits);
577
578 if (ret != 0) {
579 DBG_ERR("Failed to takeover IP %s on interface %s\n",
580 ctdb_vnn_address_string(vnn),
581 ctdb_vnn_iface_string(vnn));
582 talloc_free(state);
583 return -1;
584 }
585
586 state->c = talloc_steal(ctdb, c);
587 return 0;
588 }
589
590 struct ctdb_do_updateip_state {
591 struct ctdb_req_control_old *c;
592 struct ctdb_interface *old;
593 struct ctdb_vnn *vnn;
594 };
595
596 /*
597 called when updateip event finishes
598 */
599 static void ctdb_do_updateip_callback(struct ctdb_context *ctdb, int status,
600 void *private_data)
601 {
602 struct ctdb_do_updateip_state *state =
603 talloc_get_type(private_data, struct ctdb_do_updateip_state);
604
605 if (status != 0) {
606 if (status == -ETIMEDOUT) {
607 ctdb_ban_self(ctdb);
608 }
609 D_ERR("Failed update of IP %s from interface %s to %s\n",
610 ctdb_vnn_address_string(state->vnn),
611 iface_string(state->old),
612 ctdb_vnn_iface_string(state->vnn));
613
614 /*
615 * All we can do is reset the old interface
616 * and let the next run fix it
617 */
618 ctdb_vnn_unassign_iface(ctdb, state->vnn);
619 state->vnn->iface = state->old;
620 state->vnn->iface->references++;
621
622 ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
623 talloc_free(state);
624 return;
625 }
626
627 /* the control succeeded */
628 ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
629 talloc_free(state);
630 return;
631 }
632
633 static int ctdb_updateip_destructor(struct ctdb_do_updateip_state *state)
634 {
635 state->vnn->update_in_flight = false;
636 return 0;
637 }
638
639 /*
640 update (move) an ip address
641 */
642 static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
643 struct ctdb_req_control_old *c,
644 struct ctdb_vnn *vnn)
645 {
646 int ret;
647 struct ctdb_do_updateip_state *state;
648 struct ctdb_interface *old = vnn->iface;
649 const char *old_name = iface_string(old);
650 const char *new_name;
651
652 if (vnn->update_in_flight) {
653 D_NOTICE("Update of IP %s/%u rejected "
654 "update for this IP already in flight\n",
655 ctdb_vnn_address_string(vnn),
656 vnn->public_netmask_bits);
657 return -1;
658 }
659
660 ctdb_vnn_unassign_iface(ctdb, vnn);
661 ret = ctdb_vnn_assign_iface(ctdb, vnn);
662 if (ret != 0) {
663 D_ERR("Update of IP %s/%u failed to "
664 "assign a usable interface (old iface '%s')\n",
665 ctdb_vnn_address_string(vnn),
666 vnn->public_netmask_bits,
667 old_name);
668 return -1;
669 }
670
671 if (old == vnn->iface) {
672 /* A benign update from one interface onto itself.
673 * no need to run the eventscripts in this case, just return
674 * success.
675 */
676 ctdb_request_control_reply(ctdb, c, NULL, 0, NULL);
677 return 0;
678 }
679
680 state = talloc(vnn, struct ctdb_do_updateip_state);
681 CTDB_NO_MEMORY(ctdb, state);
682
683 state->c = NULL;
684 state->old = old;
685 state->vnn = vnn;
686
687 vnn->update_in_flight = true;
688 talloc_set_destructor(state, ctdb_updateip_destructor);
689
690 new_name = ctdb_vnn_iface_string(vnn);
691 D_NOTICE("Update of IP %s/%u from "
692 "interface %s to %s\n",
693 ctdb_vnn_address_string(vnn),
694 vnn->public_netmask_bits,
695 old_name,
696 new_name);
697
698 ret = ctdb_event_script_callback(ctdb,
699 state,
700 ctdb_do_updateip_callback,
701 state,
702 CTDB_EVENT_UPDATE_IP,
703 "%s %s %s %u",
704 old_name,
705 new_name,
706 ctdb_vnn_address_string(vnn),
707 vnn->public_netmask_bits);
708 if (ret != 0) {
709 D_ERR("Failed update IP %s from interface %s to %s\n",
710 ctdb_vnn_address_string(vnn),
711 old_name,
712 new_name);
713 talloc_free(state);
714 return -1;
715 }
716
717 state->c = talloc_steal(ctdb, c);
718 return 0;
719 }
720
721 /*
722 * Find vnn that has public IP addr, return NULL if not found
723 */
724 static struct ctdb_vnn *find_public_ip_vnn(struct ctdb_context *ctdb,
725 ctdb_sock_addr *addr)
726 {
727 struct ctdb_vnn *vnn = NULL;
728
729 for (vnn = ctdb->vnn; vnn != NULL; vnn = vnn->next) {
730 if (ctdb_same_ip(&vnn->public_address, addr)) {
731 return vnn;
732 }
733 }
734
735 return NULL;
736 }
737
738 /*
739 take over an ip address
740 */
741 int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
742 struct ctdb_req_control_old *c,
743 TDB_DATA indata,
744 bool *async_reply)
745 {
746 int ret;
747 struct ctdb_public_ip *pip = (struct ctdb_public_ip *)indata.dptr;
748 struct ctdb_vnn *vnn;
749 bool have_ip = false;
750 bool do_updateip = false;
751 bool do_takeip = false;
752 struct ctdb_interface *best_iface = NULL;
753
754 if (pip->pnn != ctdb->pnn) {
755 DEBUG(DEBUG_ERR,(__location__" takeoverip called for an ip '%s' "
756 "with pnn %d, but we're node %d\n",
757 ctdb_addr_to_str(&pip->addr),
758 pip->pnn, ctdb->pnn));
759 return -1;
760 }
761
762 /* update out vnn list */
763 vnn = find_public_ip_vnn(ctdb, &pip->addr);
764 if (vnn == NULL) {
765 DEBUG(DEBUG_INFO,("takeoverip called for an ip '%s' that is not a public address\n",
766 ctdb_addr_to_str(&pip->addr)));
767 return 0;
768 }
769
770 if (ctdb_config.failover_disabled == 0 && ctdb->do_checkpublicip) {
771 have_ip = ctdb_sys_have_ip(&pip->addr);
772 }
773 best_iface = ctdb_vnn_best_iface(ctdb, vnn);
774 if (best_iface == NULL) {
775 D_ERR("takeoverip of IP %s/%u failed to find"
776 "a usable interface (old %s, have_ip %d)\n",
777 ctdb_vnn_address_string(vnn),
778 vnn->public_netmask_bits,
779 ctdb_vnn_iface_string(vnn),
780 have_ip);
781 return -1;
782 }
783
784 if (vnn->pnn != ctdb->pnn && have_ip && vnn->pnn != CTDB_UNKNOWN_PNN) {
785 DBG_ERR("takeoverip of IP %s is known to the kernel, "
786 "and we have it on iface[%s], "
787 "but it was assigned to node %d"
788 "and we are node %d, banning ourself\n",
789 ctdb_vnn_address_string(vnn),
790 ctdb_vnn_iface_string(vnn),
791 vnn->pnn,
792 ctdb->pnn);
793 ctdb_ban_self(ctdb);
794 return -1;
795 }
796
797 if (vnn->pnn == CTDB_UNKNOWN_PNN && have_ip) {
798 /* This will cause connections to be reset and
799 * reestablished. However, this is a very unusual
800 * situation and doing this will completely repair the
801 * inconsistency in the VNN.
802 */
803 DBG_WARNING(
804 "Doing updateip for IP %s already on an interface\n",
805 ctdb_vnn_address_string(vnn));
806 do_updateip = true;
807 }
808
809 if (vnn->iface) {
810 if (vnn->iface != best_iface) {
811 if (!vnn->iface->link_up) {
812 do_updateip = true;
813 } else if (vnn->iface->references > (best_iface->references + 1)) {
814 /* only move when the rebalance gains something */
815 do_updateip = true;
816 }
817 }
818 }
819
820 if (!have_ip) {
821 if (do_updateip) {
822 ctdb_vnn_unassign_iface(ctdb, vnn);
823 do_updateip = false;
824 }
825 do_takeip = true;
826 }
827
828 if (do_takeip) {
829 ret = ctdb_do_takeip(ctdb, c, vnn);
830 if (ret != 0) {
831 return -1;
832 }
833 } else if (do_updateip) {
834 ret = ctdb_do_updateip(ctdb, c, vnn);
835 if (ret != 0) {
836 return -1;
837 }
838 } else {
839 /*
840 * The interface is up and the kernel known the ip
841 * => do nothing
842 */
843 DEBUG(DEBUG_INFO,("Redundant takeover of IP %s/%u on interface %s (ip already held)\n",
844 ctdb_addr_to_str(&pip->addr),
845 vnn->public_netmask_bits,
846 ctdb_vnn_iface_string(vnn)));
847 return 0;
848 }
849
850 /* tell ctdb_control.c that we will be replying asynchronously */
851 *async_reply = true;
852
853 return 0;
854 }
855
856 static void do_delete_ip(struct ctdb_context *ctdb, struct ctdb_vnn *vnn)
857 {
858 DLIST_REMOVE(ctdb->vnn, vnn);
859 ctdb_vnn_unassign_iface(ctdb, vnn);
860 ctdb_remove_orphaned_ifaces(ctdb, vnn);
861 talloc_free(vnn);
862 }
863
864 static struct ctdb_vnn *release_ip_post(struct ctdb_context *ctdb,
865 struct ctdb_vnn *vnn,
866 ctdb_sock_addr *addr)
867 {
868 TDB_DATA data;
869
870 /* Send a message to all clients of this node telling them
871 * that the cluster has been reconfigured and they should
872 * close any connections on this IP address
873 */
874 data.dptr = (uint8_t *)ctdb_addr_to_str(addr);
875 data.dsize = strlen((char *)data.dptr)+1;
876 DEBUG(DEBUG_INFO, ("Sending RELEASE_IP message for %s\n", data.dptr));
877 ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_RELEASE_IP, data);
878
879 ctdb_vnn_unassign_iface(ctdb, vnn);
880
881 /* Process the IP if it has been marked for deletion */
882 if (vnn->delete_pending) {
883 do_delete_ip(ctdb, vnn);
884 return NULL;
885 }
886
887 return vnn;
888 }
889
890 struct release_ip_callback_state {
891 struct ctdb_req_control_old *c;
892 ctdb_sock_addr *addr;
893 struct ctdb_vnn *vnn;
894 uint32_t target_pnn;
895 };
896
897 /*
898 called when releaseip event finishes
899 */
900 static void release_ip_callback(struct ctdb_context *ctdb, int status,
901 void *private_data)
902 {
903 struct release_ip_callback_state *state =
904 talloc_get_type(private_data, struct release_ip_callback_state);
905
906 if (status == -ETIMEDOUT) {
907 ctdb_ban_self(ctdb);
908 }
909
910 if (ctdb_config.failover_disabled == 0 && ctdb->do_checkpublicip) {
911 if (ctdb_sys_have_ip(state->addr)) {
912 DEBUG(DEBUG_ERR,
913 ("IP %s still hosted during release IP callback, failing\n",
914 ctdb_addr_to_str(state->addr)));
915 ctdb_request_control_reply(ctdb, state->c,
916 NULL, -1, NULL);
917 talloc_free(state);
918 return;
919 }
920 }
921
922 state->vnn->pnn = state->target_pnn;
923 state->vnn = release_ip_post(ctdb, state->vnn, state->addr);
924
925 /* the control succeeded */
926 ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
927 talloc_free(state);
928 }
929
930 static int ctdb_releaseip_destructor(struct release_ip_callback_state *state)
931 {
932 if (state->vnn != NULL) {
933 state->vnn->update_in_flight = false;
934 }
935 return 0;
936 }
937
938 /*
939 release an ip address
940 */
941 int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
942 struct ctdb_req_control_old *c,
943 TDB_DATA indata,
944 bool *async_reply)
945 {
946 int ret;
947 struct release_ip_callback_state *state;
948 struct ctdb_public_ip *pip = (struct ctdb_public_ip *)indata.dptr;
949 struct ctdb_vnn *vnn;
950 const char *iface;
951
952 /* update our vnn list */
953 vnn = find_public_ip_vnn(ctdb, &pip->addr);
954 if (vnn == NULL) {
955 DEBUG(DEBUG_INFO,("releaseip called for an ip '%s' that is not a public address\n",
956 ctdb_addr_to_str(&pip->addr)));
957 return 0;
958 }
959
960 /* stop any previous arps */
961 talloc_free(vnn->takeover_ctx);
962 vnn->takeover_ctx = NULL;
963
964 /* RELEASE_IP controls are sent to all nodes that should not
965 * be hosting a particular IP. This serves 2 purposes. The
966 * first is to help resolve any inconsistencies. If a node
967 * does unexpectedly host an IP then it will be released. The
968 * 2nd is to use a "redundant release" to tell non-takeover
969 * nodes where an IP is moving to. This is how "ctdb ip" can
970 * report the (likely) location of an IP by only asking the
971 * local node. Redundant releases need to update the PNN but
972 * are otherwise ignored.
973 */
974 if (ctdb_config.failover_disabled == 0 && ctdb->do_checkpublicip) {
975 if (!ctdb_sys_have_ip(&pip->addr)) {
976 DEBUG(DEBUG_DEBUG,("Redundant release of IP %s/%u on interface %s (ip not held)\n",
977 ctdb_addr_to_str(&pip->addr),
978 vnn->public_netmask_bits,
979 ctdb_vnn_iface_string(vnn)));
980 vnn->pnn = pip->pnn;
981 ctdb_vnn_unassign_iface(ctdb, vnn);
982 return 0;
983 }
984 } else {
985 if (vnn->iface == NULL) {
986 DEBUG(DEBUG_DEBUG,("Redundant release of IP %s/%u (ip not held)\n",
987 ctdb_addr_to_str(&pip->addr),
988 vnn->public_netmask_bits));
989 vnn->pnn = pip->pnn;
990 return 0;
991 }
992 }
993
994 /* There is a potential race between take_ip and us because we
995 * update the VNN via a callback that run when the
996 * eventscripts have been run. Avoid the race by allowing one
997 * update to be in flight at a time.
998 */
999 if (vnn->update_in_flight) {
1000 D_NOTICE("Release of IP %s/%u rejected "
1001 "update for this IP already in flight\n",
1002 ctdb_vnn_address_string(vnn),
1003 vnn->public_netmask_bits);
1004 return -1;
1005 }
1006
1007 iface = ctdb_vnn_iface_string(vnn);
1008
1009 DEBUG(DEBUG_NOTICE,("Release of IP %s/%u on interface %s node:%d\n",
1010 ctdb_addr_to_str(&pip->addr),
1011 vnn->public_netmask_bits,
1012 iface,
1013 pip->pnn));
1014
1015 state = talloc(ctdb, struct release_ip_callback_state);
1016 if (state == NULL) {
1017 ctdb_set_error(ctdb, "Out of memory at %s:%d",
1018 __FILE__, __LINE__);
1019 return -1;
1020 }
1021
1022 state->c = NULL;
1023 state->addr = talloc(state, ctdb_sock_addr);
1024 if (state->addr == NULL) {
1025 ctdb_set_error(ctdb, "Out of memory at %s:%d",
1026 __FILE__, __LINE__);
1027 talloc_free(state);
1028 return -1;
1029 }
1030 *state->addr = pip->addr;
1031 state->target_pnn = pip->pnn;
1032 state->vnn = vnn;
1033
1034 vnn->update_in_flight = true;
1035 talloc_set_destructor(state, ctdb_releaseip_destructor);
1036
1037 ret = ctdb_event_script_callback(ctdb,
1038 state, release_ip_callback, state,
1039 CTDB_EVENT_RELEASE_IP,
1040 "%s %s %u",
1041 iface,
1042 ctdb_addr_to_str(&pip->addr),
1043 vnn->public_netmask_bits);
1044 if (ret != 0) {
1045 DEBUG(DEBUG_ERR,(__location__ " Failed to release IP %s on interface %s\n",
1046 ctdb_addr_to_str(&pip->addr),
1047 ctdb_vnn_iface_string(vnn)));
1048 talloc_free(state);
1049 return -1;
1050 }
1051
1052 /* tell the control that we will be reply asynchronously */
1053 *async_reply = true;
1054 state->c = talloc_steal(state, c);
1055 return 0;
1056 }
1057
1058 static int ctdb_add_public_address(struct ctdb_context *ctdb,
1059 ctdb_sock_addr *addr,
1060 unsigned mask, const char *ifaces)
1061 {
1062 struct ctdb_vnn *vnn;
1063 char *tmp;
1064 const char *iface;
1065
1066 /* Verify that we don't have an entry for this IP yet */
1067 for (vnn = ctdb->vnn; vnn != NULL; vnn = vnn->next) {
1068 if (ctdb_same_sockaddr(addr, &vnn->public_address)) {
1069 D_ERR("Duplicate public IP address '%s'\n",
1070 ctdb_addr_to_str(addr));
1071 return -1;
1072 }
1073 }
1074
1075 /* Create a new VNN structure for this IP address */
1076 vnn = talloc_zero(ctdb, struct ctdb_vnn);
1077 if (vnn == NULL) {
1078 DBG_ERR("Memory allocation error\n");
1079 return -1;
1080 }
1081
1082 vnn->name = ctdb_sock_addr_to_string(vnn, addr, false);
1083 if (vnn->name == NULL) {
1084 DBG_ERR("Memory allocation error\n");
1085 talloc_free(vnn);
1086 return -1;
1087 }
1088
1089 tmp = talloc_strdup(vnn, ifaces);
1090 if (tmp == NULL) {
1091 DBG_ERR("Memory allocation error\n");
1092 talloc_free(vnn);
1093 return -1;
1094 }
1095 for (iface = strtok(tmp, ","); iface; iface = strtok(NULL, ",")) {
1096 struct vnn_interface *vnn_iface;
1097 struct ctdb_interface *i;
1098
1099 if (!ctdb_sys_check_iface_exists(iface)) {
1100 D_ERR("Unknown interface %s for public address %s\n",
1101 iface,
1102 ctdb_vnn_address_string(vnn));
1103 talloc_free(vnn);
1104 return -1;
1105 }
1106
1107 i = ctdb_add_local_iface(ctdb, iface);
1108 if (i == NULL) {
1109 D_ERR("Failed to add interface '%s' "
1110 "for public address %s\n",
1111 iface,
1112 ctdb_vnn_address_string(vnn));
1113 talloc_free(vnn);
1114 return -1;
1115 }
1116
1117 vnn_iface = talloc_zero(vnn, struct vnn_interface);
1118 if (vnn_iface == NULL) {
1119 DBG_ERR("Memory allocation error\n");
1120 talloc_free(vnn);
1121 return -1;
1122 }
1123
1124 vnn_iface->iface = i;
1125 DLIST_ADD_END(vnn->ifaces, vnn_iface);
1126 }
1127 talloc_free(tmp);
1128 vnn->public_address = *addr;
1129 vnn->public_netmask_bits = mask;
1130 vnn->pnn = -1;
1131
1132 DLIST_ADD(ctdb->vnn, vnn);
1133
1134 return 0;
1135 }
1136
1137 /*
1138 setup the public address lists from a file
1139 */
1140 int ctdb_set_public_addresses(struct ctdb_context *ctdb)
1141 {
1142 bool ok;
1143 char **lines;
1144 int nlines;
1145 int i;
1146
1147 /* If no public addresses file given then try the default */
1148 if (ctdb->public_addresses_file == NULL) {
1149 ctdb->public_addresses_file = path_etcdir_append(
1150 ctdb, "public_addresses");
1151 if (ctdb->public_addresses_file == NULL) {
1152 DBG_ERR("Out of memory\n");
1153 return -1;
1154 }
1155 }
1156
1157 /* If the file doesn't exist then warn and do nothing */
1158 ok = file_exist(ctdb->public_addresses_file);
1159 if (!ok) {
1160 D_WARNING("Not loading public addresses, no file %s\n",
1161 ctdb->public_addresses_file);
1162 return 0;
1163 }
1164
1165 lines = file_lines_load(ctdb->public_addresses_file, &nlines, 0, ctdb);
1166 if (lines == NULL) {
1167 ctdb_set_error(ctdb, "Failed to load public address list '%s'\n", ctdb->public_addresses_file);
1168 return -1;
1169 }
1170 while (nlines > 0 && strcmp(lines[nlines-1], "") == 0) {
1171 nlines--;
1172 }
1173
1174 for (i=0;i<nlines;i++) {
1175 unsigned mask;
1176 ctdb_sock_addr addr;
1177 const char *addrstr;
1178 const char *ifaces;
1179 char *tok, *line;
1180 int ret;
1181
1182 line = lines[i];
1183 while ((*line == ' ') || (*line == '\t')) {
1184 line++;
1185 }
1186 if (*line == '#') {
1187 continue;
1188 }
1189 if (strcmp(line, "") == 0) {
1190 continue;
1191 }
1192 tok = strtok(line, " \t");
1193 addrstr = tok;
1194
1195 tok = strtok(NULL, " \t");
1196 if (tok == NULL) {
1197 D_ERR("No interface specified at line %u "
1198 "of public addresses file\n", i+1);
1199 talloc_free(lines);
1200 return -1;
1201 }
1202 ifaces = tok;
1203
1204 if (addrstr == NULL) {
1205 D_ERR("Badly formed line %u in public address list\n",
1206 i+1);
1207 talloc_free(lines);
1208 return -1;
1209 }
1210
1211 ret = ctdb_sock_addr_mask_from_string(addrstr, &addr, &mask);
1212 if (ret != 0) {
1213 D_ERR("Badly formed line %u in public address list\n",
1214 i+1);
1215 talloc_free(lines);
1216 return -1;
1217 }
1218
1219 if (ctdb_add_public_address(ctdb, &addr, mask, ifaces)) {
1220 DEBUG(DEBUG_CRIT,("Failed to add line %u to the public address list\n", i+1));
1221 talloc_free(lines);
1222 return -1;
1223 }
1224 }
1225
1226
1227 D_NOTICE("Loaded public addresses from %s\n",
1228 ctdb->public_addresses_file);
1229
1230 talloc_free(lines);
1231 return 0;
1232 }
1233
1234 /*
1235 destroy a ctdb_tcp_list structure
1236 */
1237 static int ctdb_tcp_list_destructor(struct ctdb_tcp_list *tcp)
1238 {
1239 struct ctdb_client *client = tcp->client;
1240 struct ctdb_connection *conn = &tcp->connection;
1241 char conn_str[132] = { 0, };
1242 int ret;
1243
1244 ret = ctdb_connection_to_buf(conn_str,
1245 sizeof(conn_str),
1246 conn,
1247 false,
1248 " -> ");
1249 if (ret != 0) {
1250 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1251 }
1252
1253 D_DEBUG("removing client TCP connection %s "
1254 "(client_id %u pid %d)\n",
1255 conn_str, client->client_id, client->pid);
1256
1257 DLIST_REMOVE(client->tcp_list, tcp);
1258
1259 /*
1260 * We don't call ctdb_remove_connection(vnn, conn) here
1261 * as we want the caller to decide if it's called
1262 * directly (local only) or indirectly via a
1263 * CTDB_CONTROL_TCP_REMOVE broadcast
1264 */
1265
1266 return 0;
1267 }
1268
1269 /*
1270 called by a client to inform us of a TCP connection that it is managing
1271 that should tickled with an ACK when IP takeover is done
1272 */
1273 int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
1274 TDB_DATA indata)
1275 {
1276 struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
1277 struct ctdb_connection *tcp_sock = NULL;
1278 struct ctdb_tcp_list *tcp;
1279 struct ctdb_connection t;
1280 int ret;
1281 TDB_DATA data;
1282 struct ctdb_vnn *vnn;
1283 char conn_str[132] = { 0, };
1284
1285 /* If we don't have public IPs, tickles are useless */
1286 if (ctdb->vnn == NULL) {
1287 return 0;
1288 }
1289
1290 tcp_sock = (struct ctdb_connection *)indata.dptr;
1291
1292 ctdb_canonicalize_ip_inplace(&tcp_sock->src);
1293 ctdb_canonicalize_ip_inplace(&tcp_sock->dst);
1294
1295 ret = ctdb_connection_to_buf(conn_str,
1296 sizeof(conn_str),
1297 tcp_sock,
1298 false,
1299 " -> ");
1300 if (ret != 0) {
1301 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1302 }
1303
1304 vnn = find_public_ip_vnn(ctdb, &tcp_sock->dst);
1305 if (vnn == NULL) {
1306 D_ERR("Could not register TCP connection %s - "
1307 "not a public address (client_id %u pid %u)\n",
1308 conn_str, client_id, client->pid);
1309 return 0;
1310 }
1311
1312 if (vnn->pnn != ctdb->pnn) {
1313 D_ERR("Attempt to register tcp client for IP %s we don't hold - "
1314 "failing (client_id %u pid %u)\n",
1315 ctdb_addr_to_str(&tcp_sock->dst),
1316 client_id, client->pid);
1317 /* failing this call will tell smbd to die */
1318 return -1;
1319 }
1320
1321 tcp = talloc(client, struct ctdb_tcp_list);
1322 CTDB_NO_MEMORY(ctdb, tcp);
1323 tcp->client = client;
1324
1325 tcp->connection.src = tcp_sock->src;
1326 tcp->connection.dst = tcp_sock->dst;
1327
1328 DLIST_ADD(client->tcp_list, tcp);
1329 talloc_set_destructor(tcp, ctdb_tcp_list_destructor);
1330
1331 t.src = tcp_sock->src;
1332 t.dst = tcp_sock->dst;
1333
1334 data.dptr = (uint8_t *)&t;
1335 data.dsize = sizeof(t);
1336
1337 D_INFO("Registered TCP connection %s (client_id %u pid %u)\n",
1338 conn_str, client_id, client->pid);
1339
1340 /* tell all nodes about this tcp connection */
1341 ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_CONNECTED, 0,
1342 CTDB_CONTROL_TCP_ADD,
1343 0, CTDB_CTRL_FLAG_NOREPLY, data, NULL, NULL);
1344 if (ret != 0) {
1345 DEBUG(DEBUG_ERR,(__location__ " Failed to send CTDB_CONTROL_TCP_ADD\n"));
1346 return -1;
1347 }
1348
1349 return 0;
1350 }
1351
1352 static bool ctdb_client_remove_tcp(struct ctdb_client *client,
1353 const struct ctdb_connection *conn)
1354 {
1355 struct ctdb_tcp_list *tcp = NULL;
1356 struct ctdb_tcp_list *tcp_next = NULL;
1357 bool found = false;
1358
1359 for (tcp = client->tcp_list; tcp != NULL; tcp = tcp_next) {
1360 bool same;
1361
1362 tcp_next = tcp->next;
1363
1364 same = ctdb_connection_same(conn, &tcp->connection);
1365 if (!same) {
1366 continue;
1367 }
1368
1369 TALLOC_FREE(tcp);
1370 found = true;
1371 }
1372
1373 return found;
1374 }
1375
1376 /*
1377 called by a client to inform us of a TCP connection that was disconnected
1378 */
1379 int32_t ctdb_control_tcp_client_disconnected(struct ctdb_context *ctdb,
1380 uint32_t client_id,
1381 TDB_DATA indata)
1382 {
1383 struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
1384 struct ctdb_connection *tcp_sock = NULL;
1385 int ret;
1386 TDB_DATA data;
1387 char conn_str[132] = { 0, };
1388 bool found = false;
1389
1390 tcp_sock = (struct ctdb_connection *)indata.dptr;
1391
1392 ctdb_canonicalize_ip_inplace(&tcp_sock->src);
1393 ctdb_canonicalize_ip_inplace(&tcp_sock->dst);
1394
1395 ret = ctdb_connection_to_buf(conn_str,
1396 sizeof(conn_str),
1397 tcp_sock,
1398 false,
1399 " -> ");
1400 if (ret != 0) {
1401 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1402 }
1403
1404 found = ctdb_client_remove_tcp(client, tcp_sock);
1405 if (!found) {
1406 DBG_DEBUG("TCP connection %s not found "
1407 "(client_id %u pid %u).\n",
1408 conn_str, client_id, client->pid);
1409 return 0;
1410 }
1411
1412 D_INFO("deregistered TCP connection %s "
1413 "(client_id %u pid %u)\n",
1414 conn_str, client_id, client->pid);
1415
1416 data.dptr = (uint8_t *)tcp_sock;
1417 data.dsize = sizeof(*tcp_sock);
1418
1419 /* tell all nodes about this tcp connection is gone */
1420 ret = ctdb_daemon_send_control(ctdb,
1421 CTDB_BROADCAST_CONNECTED,
1422 0,
1423 CTDB_CONTROL_TCP_REMOVE,
1424 0,
1425 CTDB_CTRL_FLAG_NOREPLY,
1426 data,
1427 NULL,
1428 NULL);
1429 if (ret != 0) {
1430 DBG_ERR("Failed to send CTDB_CONTROL_TCP_REMOVE: %s\n",
1431 conn_str);
1432 return -1;
1433 }
1434
1435 return 0;
1436 }
1437
1438 /*
1439 called by a client to inform us of a TCP connection was passed to a different
1440 "client" (typically with multichannel to another smbd process).
1441 */
1442 int32_t ctdb_control_tcp_client_passed(struct ctdb_context *ctdb,
1443 uint32_t client_id,
1444 TDB_DATA indata)
1445 {
1446 struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
1447 struct ctdb_connection *tcp_sock = NULL;
1448 int ret;
1449 char conn_str[132] = { 0, };
1450 bool found = false;
1451
1452 tcp_sock = (struct ctdb_connection *)indata.dptr;
1453
1454 ctdb_canonicalize_ip_inplace(&tcp_sock->src);
1455 ctdb_canonicalize_ip_inplace(&tcp_sock->dst);
1456
1457 ret = ctdb_connection_to_buf(conn_str,
1458 sizeof(conn_str),
1459 tcp_sock,
1460 false,
1461 " -> ");
1462 if (ret != 0) {
1463 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1464 }
1465
1466 found = ctdb_client_remove_tcp(client, tcp_sock);
1467 if (!found) {
1468 DBG_DEBUG("TCP connection from %s not found "
1469 "(client_id %u pid %u).\n",
1470 conn_str, client_id, client->pid);
1471 return 0;
1472 }
1473
1474 D_INFO("TCP connection from %s "
1475 "(client_id %u pid %u) passed to another client\n",
1476 conn_str, client_id, client->pid);
1477
1478 /*
1479 * We don't call CTDB_CONTROL_TCP_REMOVE
1480 * nor ctdb_remove_connection() as the connection
1481 * is still alive, but handled by another client
1482 */
1483
1484 return 0;
1485 }
1486
1487 /*
1488 find a tcp address on a list
1489 */
1490 static struct ctdb_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
1491 struct ctdb_connection *tcp)
1492 {
1493 unsigned int i;
1494
1495 if (array == NULL) {
1496 return NULL;
1497 }
1498
1499 for (i=0;i<array->num;i++) {
1500 if (ctdb_connection_same(&array->connections[i], tcp)) {
1501 return &array->connections[i];
1502 }
1503 }
1504 return NULL;
1505 }
1506
1507
1508
1509 /*
1510 called by a daemon to inform us of a TCP connection that one of its
1511 clients managing that should tickled with an ACK when IP takeover is
1512 done
1513 */
1514 int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb,
1515 TDB_DATA indata,
1516 bool tcp_update_needed)
1517 {
1518 struct ctdb_connection *p = (struct ctdb_connection *)indata.dptr;
1519 struct ctdb_connection *tmp = NULL;
1520 struct ctdb_tcp_array *tcparray;
1521 struct ctdb_vnn *vnn;
1522 char conn_str[132] = { 0, };
1523 int ret;
1524
1525 /* If we don't have public IPs, tickles are useless */
1526 if (ctdb->vnn == NULL) {
1527 return 0;
1528 }
1529
1530 ret = ctdb_connection_to_buf(conn_str,
1531 sizeof(conn_str),
1532 p,
1533 false,
1534 " -> ");
1535 if (ret != 0) {
1536 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1537 }
1538
1539 vnn = find_public_ip_vnn(ctdb, &p->dst);
1540 if (vnn == NULL) {
1541 DBG_INFO("Attempt to add connection %s "
1542 "but destination is not a public address\n",
1543 conn_str);
1544
1545 return -1;
1546 }
1547
1548 tcparray = vnn->tcp_array;
1549
1550 /* Do we already have this tickle ?*/
1551 if (ctdb_tcp_find(tcparray, p) != NULL) {
1552 DBG_DEBUG("Already had connection %s\n", conn_str);
1553 return 0;
1554 }
1555
1556 /* If this is the first tickle */
1557 if (tcparray == NULL) {
1558 tcparray = talloc_zero(vnn, struct ctdb_tcp_array);
1559 CTDB_NO_MEMORY(ctdb, tcparray);
1560 vnn->tcp_array = tcparray;
1561 }
1562
1563 /* A new tickle, we must add it to the array */
1564 tmp = talloc_realloc(tcparray,
1565 tcparray->connections,
1566 struct ctdb_connection,
1567 tcparray->num + 1);
1568 CTDB_NO_MEMORY(ctdb, tmp);
1569 tcparray->connections = tmp;
1570
1571 tcparray->connections[tcparray->num].src = p->src;
1572 tcparray->connections[tcparray->num].dst = p->dst;
1573 tcparray->num++;
1574
1575 D_INFO("Added connection %s\n", conn_str);
1576
1577 if (tcp_update_needed) {
1578 vnn->tcp_update_needed = true;
1579 }
1580
1581 return 0;
1582 }
1583
1584
1585 static void ctdb_remove_connection(struct ctdb_vnn *vnn,
1586 struct ctdb_connection *conn)
1587 {
1588 struct ctdb_connection *tcpp;
1589 char conn_str[132] = { 0, };
1590 int ret;
1591
1592 if (vnn == NULL) {
1593 return;
1594 }
1595
1596 ret = ctdb_connection_to_buf(conn_str,
1597 sizeof(conn_str),
1598 conn,
1599 false,
1600 " -> ");
1601 if (ret != 0) {
1602 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1603 }
1604
1605 /* If the array is empty there is nothing to remove */
1606 if (vnn->tcp_array == NULL) {
1607 D_INFO("Attempt to remove untracked connection %s (empty)\n",
1608 conn_str);
1609 return;
1610 }
1611
1612
1613 tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
1614 if (tcpp == NULL) {
1615 D_DEBUG("Attempt to remove untracked connection %s\n", conn_str);
1616 return;
1617 }
1618
1619
1620 /*
1621 * We need to remove this entry from the array. Instead of
1622 * allocating a new array and copying data to it, cheat and
1623 * just copy the last entry in the existing array to the entry
1624 * that is to be removed and just shrink the size.
1625 */
1626 *tcpp = vnn->tcp_array->connections[vnn->tcp_array->num - 1];
1627 vnn->tcp_array->num--;
1628
1629 /* Last entry deleted, so remove the entire array */
1630 if (vnn->tcp_array->num == 0) {
1631 talloc_free(vnn->tcp_array);
1632 vnn->tcp_array = NULL;
1633 }
1634
1635 vnn->tcp_update_needed = true;
1636
1637 D_INFO("Removed connection %s\n", conn_str);
1638 }
1639
1640
1641 /*
1642 called by a daemon to inform us of a TCP connection that one of its
1643 clients used are no longer needed in the tickle database
1644 */
1645 int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata)
1646 {
1647 struct ctdb_vnn *vnn;
1648 struct ctdb_connection *conn = (struct ctdb_connection *)indata.dptr;
1649
1650 /* If we don't have public IPs, tickles are useless */
1651 if (ctdb->vnn == NULL) {
1652 return 0;
1653 }
1654
1655 vnn = find_public_ip_vnn(ctdb, &conn->dst);
1656 if (vnn == NULL) {
1657 char conn_str[132] = { 0, };
1658 int ret;
1659
1660 ret = ctdb_connection_to_buf(conn_str,
1661 sizeof(conn_str),
1662 conn,
1663 false,
1664 " -> ");
1665 if (ret != 0) {
1666 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1667 }
1668
1669 DBG_ERR("Attempt to remove connection %s "
1670 "but destination is not a public address\n",
1671 conn_str);
1672 return 0;
1673 }
1674
1675 ctdb_remove_connection(vnn, conn);
1676
1677 return 0;
1678 }
1679
1680
1681 static void ctdb_send_set_tcp_tickles_for_all(struct ctdb_context *ctdb,
1682 bool force);
1683
1684 /*
1685 Called when another daemon starts - causes all tickles for all
1686 public addresses we are serving to be sent to the new node on the
1687 next check. This actually causes the tickles to be sent to the
1688 other node immediately. In case there is an error, the periodic
1689 timer will send the updates on timer event. This is simple and
1690 doesn't require careful error handling.
1691 */
1692 int32_t ctdb_control_startup(struct ctdb_context *ctdb, uint32_t pnn)
1693 {
1694 DEBUG(DEBUG_INFO, ("Received startup control from node %lu\n",
1695 (unsigned long) pnn));
1696
1697 ctdb_send_set_tcp_tickles_for_all(ctdb, true);
1698 return 0;
1699 }
1700
1701
1702 /*
1703 called when a client structure goes away - hook to remove
1704 elements from the tcp_list in all daemons
1705 */
1706 void ctdb_takeover_client_destructor_hook(struct ctdb_client *client)
1707 {
1708 while (client->tcp_list) {
1709 struct ctdb_vnn *vnn;
1710 struct ctdb_tcp_list *tcp = client->tcp_list;
1711 struct ctdb_connection *conn = &tcp->connection;
1712
1713 vnn = find_public_ip_vnn(client->ctdb,
1714 &conn->dst);
1715
1716 /* If the IP address is hosted on this node then
1717 * remove the connection. */
1718 if (vnn != NULL && vnn->pnn == client->ctdb->pnn) {
1719 ctdb_remove_connection(vnn, conn);
1720 }
1721
1722 /* Otherwise this function has been called because the
1723 * server IP address has been released to another node
1724 * and the client has exited. This means that we
1725 * should not delete the connection information. The
1726 * takeover node processes connections too. */
1727
1728 /*
1729 * The destructor removes from the list
1730 */
1731 TALLOC_FREE(tcp);
1732 }
1733 }
1734
1735
1736 void ctdb_release_all_ips(struct ctdb_context *ctdb)
1737 {
1738 struct ctdb_vnn *vnn, *next;
1739 int count = 0;
1740
1741 if (ctdb_config.failover_disabled == 1) {
1742 return;
1743 }
1744
1745 for (vnn = ctdb->vnn; vnn != NULL; vnn = next) {
1746 bool have_ip;
1747 int ret;
1748
1749 /* vnn can be freed below in release_ip_post() */
1750 next = vnn->next;
1751
1752 if (!ctdb_sys_have_ip(&vnn->public_address)) {
1753 ctdb_vnn_unassign_iface(ctdb, vnn);
1754 continue;
1755 }
1756
1757 /* Don't allow multiple releases at once. Some code,
1758 * particularly ctdb_tickle_sentenced_connections() is
1759 * not re-entrant */
1760 if (vnn->update_in_flight) {
1761 DBG_WARNING(
1762 "Not releasing IP %s/%u on interface %s, "
1763 "an update is already in progress\n",
1764 ctdb_vnn_address_string(vnn),
1765 vnn->public_netmask_bits,
1766 ctdb_vnn_iface_string(vnn));
1767 continue;
1768 }
1769 vnn->update_in_flight = true;
1770
1771 D_INFO("Release of IP %s/%u on interface %s node:-1\n",
1772 ctdb_vnn_address_string(vnn),
1773 vnn->public_netmask_bits,
1774 ctdb_vnn_iface_string(vnn));
1775
1776 /*
1777 * releaseip timeouts are converted to success, or IP
1778 * might be released but releaseip event failed (due
1779 * to failure of script after 10.interface), so try
1780 * hard to correctly report failures...
1781 */
1782 ret = ctdb_event_script_args(
1783 ctdb,
1784 CTDB_EVENT_RELEASE_IP,
1785 "%s %s %u",
1786 ctdb_vnn_iface_string(vnn),
1787 ctdb_vnn_address_string(vnn),
1788 vnn->public_netmask_bits);
1789 have_ip = ctdb_sys_have_ip(&vnn->public_address);
1790 if (have_ip) {
1791 if (ret != 0) {
1792 DBG_ERR("Error releasing IP %s\n",
1793 ctdb_vnn_address_string(vnn));
1794 } else {
1795 DBG_ERR("IP %s not released (timed out?)\n",
1796 ctdb_vnn_address_string(vnn));
1797 }
1798 vnn->update_in_flight = false;
1799 continue;
1800 }
1801 if (ret != 0) {
1802 DBG_ERR("Error releasing IP %s (but IP is gone!)\n",
1803 ctdb_vnn_address_string(vnn));
1804 vnn->update_in_flight = false;
1805 continue;
1806 }
1807
1808 vnn = release_ip_post(ctdb, vnn, &vnn->public_address);
1809 if (vnn != NULL) {
1810 vnn->update_in_flight = false;
1811 }
1812 count++;
1813 }
1814
1815 DEBUG(DEBUG_NOTICE,(__location__ " Released %d public IPs\n", count));
1816 }
1817
1818
1819 /*
1820 get list of public IPs
1821 */
1822 int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
1823 struct ctdb_req_control_old *c, TDB_DATA *outdata)
1824 {
1825 int i, num, len;
1826 struct ctdb_public_ip_list_old *ips;
1827 struct ctdb_vnn *vnn;
1828 bool only_available = false;
1829
1830 if (c->flags & CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE) {
1831 only_available = true;
1832 }
1833
1834 /* count how many public ip structures we have */
1835 num = 0;
1836 for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
1837 num++;
1838 }
1839
1840 len = offsetof(struct ctdb_public_ip_list_old, ips) +
1841 num*sizeof(struct ctdb_public_ip);
1842 ips = talloc_zero_size(outdata, len);
1843 CTDB_NO_MEMORY(ctdb, ips);
1844
1845 i = 0;
1846 for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
1847 if (only_available && !ctdb_vnn_available(ctdb, vnn)) {
1848 continue;
1849 }
1850 ips->ips[i].pnn = vnn->pnn;
1851 ips->ips[i].addr = vnn->public_address;
1852 i++;
1853 }
1854 ips->num = i;
1855 len = offsetof(struct ctdb_public_ip_list_old, ips) +
1856 i*sizeof(struct ctdb_public_ip);
1857
1858 outdata->dsize = len;
1859 outdata->dptr = (uint8_t *)ips;
1860
1861 return 0;
1862 }
1863
1864
1865 int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
1866 struct ctdb_req_control_old *c,
1867 TDB_DATA indata,
1868 TDB_DATA *outdata)
1869 {
1870 int i, num, len;
1871 ctdb_sock_addr *addr;
1872 struct ctdb_public_ip_info_old *info;
1873 struct ctdb_vnn *vnn;
1874 struct vnn_interface *iface;
1875
1876 addr = (ctdb_sock_addr *)indata.dptr;
1877
1878 vnn = find_public_ip_vnn(ctdb, addr);
1879 if (vnn == NULL) {
1880 DEBUG(DEBUG_ERR,(__location__ " Could not get public ip info, "
1881 "'%s'not a public address\n",
1882 ctdb_addr_to_str(addr)));
1883 return -1;
1884 }
1885
1886 /* count how many public ip structures we have */
1887 num = 0;
1888 for (iface = vnn->ifaces; iface != NULL; iface = iface->next) {
1889 num++;
1890 }
1891
1892 len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
1893 num*sizeof(struct ctdb_iface);
1894 info = talloc_zero_size(outdata, len);
1895 CTDB_NO_MEMORY(ctdb, info);
1896
1897 info->ip.addr = vnn->public_address;
1898 info->ip.pnn = vnn->pnn;
1899 info->active_idx = 0xFFFFFFFF;
1900
1901 i = 0;
1902 for (iface = vnn->ifaces; iface != NULL; iface = iface->next) {
1903 struct ctdb_interface *cur;
1904
1905 cur = iface->iface;
1906 if (vnn->iface == cur) {
1907 info->active_idx = i;
1908 }
1909 strncpy(info->ifaces[i].name, cur->name,
1910 sizeof(info->ifaces[i].name));
1911 info->ifaces[i].name[sizeof(info->ifaces[i].name)-1] = '\0';
1912 info->ifaces[i].link_state = cur->link_up;
1913 info->ifaces[i].references = cur->references;
1914
1915 i++;
1916 }
1917 info->num = i;
1918 len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
1919 i*sizeof(struct ctdb_iface);
1920
1921 outdata->dsize = len;
1922 outdata->dptr = (uint8_t *)info;
1923
1924 return 0;
1925 }
1926
1927 int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
1928 struct ctdb_req_control_old *c,
1929 TDB_DATA *outdata)
1930 {
1931 int i, num, len;
1932 struct ctdb_iface_list_old *ifaces;
1933 struct ctdb_interface *cur;
1934
1935 /* count how many public ip structures we have */
1936 num = 0;
1937 for (cur=ctdb->ifaces;cur;cur=cur->next) {
1938 num++;
1939 }
1940
1941 len = offsetof(struct ctdb_iface_list_old, ifaces) +
1942 num*sizeof(struct ctdb_iface);
1943 ifaces = talloc_zero_size(outdata, len);
1944 CTDB_NO_MEMORY(ctdb, ifaces);
1945
1946 i = 0;
1947 for (cur=ctdb->ifaces;cur;cur=cur->next) {
1948 strncpy(ifaces->ifaces[i].name, cur->name,
1949 sizeof(ifaces->ifaces[i].name));
1950 ifaces->ifaces[i].name[sizeof(ifaces->ifaces[i].name)-1] = '\0';
1951 ifaces->ifaces[i].link_state = cur->link_up;
1952 ifaces->ifaces[i].references = cur->references;
1953 i++;
1954 }
1955 ifaces->num = i;
1956 len = offsetof(struct ctdb_iface_list_old, ifaces) +
1957 i*sizeof(struct ctdb_iface);
1958
1959 outdata->dsize = len;
1960 outdata->dptr = (uint8_t *)ifaces;
1961
1962 return 0;
1963 }
1964
1965 int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
1966 struct ctdb_req_control_old *c,
1967 TDB_DATA indata)
1968 {
1969 struct ctdb_iface *info;
1970 struct ctdb_interface *iface;
1971 bool link_up = false;
1972
1973 info = (struct ctdb_iface *)indata.dptr;
1974
1975 if (info->name[CTDB_IFACE_SIZE] != '\0') {
1976 int len = strnlen(info->name, CTDB_IFACE_SIZE);
1977 DEBUG(DEBUG_ERR, (__location__ " name[%*.*s] not terminated\n",
1978 len, len, info->name));
1979 return -1;
1980 }
1981
1982 switch (info->link_state) {
1983 case 0:
1984 link_up = false;
1985 break;
1986 case 1:
1987 link_up = true;
1988 break;
1989 default:
1990 DEBUG(DEBUG_ERR, (__location__ " link_state[%u] invalid\n",
1991 (unsigned int)info->link_state));
1992 return -1;
1993 }
1994
1995 if (info->references != 0) {
1996 DEBUG(DEBUG_ERR, (__location__ " references[%u] should be 0\n",
1997 (unsigned int)info->references));
1998 return -1;
1999 }
2000
2001 iface = ctdb_find_iface(ctdb, info->name);
2002 if (iface == NULL) {
2003 return -1;
2004 }
2005
2006 if (link_up == iface->link_up) {
2007 return 0;
2008 }
2009
2010 DEBUG(DEBUG_ERR,
2011 ("iface[%s] has changed it's link status %s => %s\n",
2012 iface->name,
2013 iface->link_up?"up":"down",
2014 link_up?"up":"down"));
2015
2016 iface->link_up = link_up;
2017 return 0;
2018 }
2019
2020
2021 /*
2022 called by a daemon to inform us of the entire list of TCP tickles for
2023 a particular public address.
2024 this control should only be sent by the node that is currently serving
2025 that public address.
2026 */
2027 int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata)
2028 {
2029 struct ctdb_tickle_list_old *list = (struct ctdb_tickle_list_old *)indata.dptr;
2030 struct ctdb_tcp_array *tcparray;
2031 struct ctdb_vnn *vnn;
2032
2033 /* We must at least have tickles.num or else we can't verify the size
2034 of the received data blob
2035 */
2036 if (indata.dsize < offsetof(struct ctdb_tickle_list_old, connections)) {
2037 DEBUG(DEBUG_ERR,("Bad indata in ctdb_tickle_list. Not enough data for the tickle.num field\n"));
2038 return -1;
2039 }
2040
2041 /* verify that the size of data matches what we expect */
2042 if (indata.dsize < offsetof(struct ctdb_tickle_list_old, connections)
2043 + sizeof(struct ctdb_connection) * list->num) {
2044 DEBUG(DEBUG_ERR,("Bad indata in ctdb_tickle_list\n"));
2045 return -1;
2046 }
2047
2048 DEBUG(DEBUG_INFO, ("Received tickle update for public address %s\n",
2049 ctdb_addr_to_str(&list->addr)));
2050
2051 vnn = find_public_ip_vnn(ctdb, &list->addr);
2052 if (vnn == NULL) {
2053 DEBUG(DEBUG_INFO,(__location__ " Could not set tcp tickle list, '%s' is not a public address\n",
2054 ctdb_addr_to_str(&list->addr)));
2055
2056 return 1;
2057 }
2058
2059 if (vnn->pnn == ctdb->pnn) {
2060 DEBUG(DEBUG_INFO,
2061 ("Ignoring redundant set tcp tickle list, this node hosts '%s'\n",
2062 ctdb_addr_to_str(&list->addr)));
2063 return 0;
2064 }
2065
2066 /* remove any old ticklelist we might have */
2067 talloc_free(vnn->tcp_array);
2068 vnn->tcp_array = NULL;
2069
2070 tcparray = talloc(vnn, struct ctdb_tcp_array);
2071 CTDB_NO_MEMORY(ctdb, tcparray);
2072
2073 tcparray->num = list->num;
2074
2075 tcparray->connections = talloc_array(tcparray, struct ctdb_connection, tcparray->num);
2076 CTDB_NO_MEMORY(ctdb, tcparray->connections);
2077
2078 memcpy(tcparray->connections, &list->connections[0],
2079 sizeof(struct ctdb_connection)*tcparray->num);
2080
2081 /* We now have a new fresh tickle list array for this vnn */
2082 vnn->tcp_array = tcparray;
2083
2084 return 0;
2085 }
2086
2087 /*
2088 called to return the full list of tickles for the puclic address associated
2089 with the provided vnn
2090 */
2091 int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata)
2092 {
2093 ctdb_sock_addr *addr = (ctdb_sock_addr *)indata.dptr;
2094 struct ctdb_tickle_list_old *list;
2095 struct ctdb_tcp_array *tcparray;
2096 unsigned int num, i;
2097 struct ctdb_vnn *vnn;
2098 unsigned port;
2099
2100 vnn = find_public_ip_vnn(ctdb, addr);
2101 if (vnn == NULL) {
2102 DEBUG(DEBUG_ERR,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n",
2103 ctdb_addr_to_str(addr)));
2104
2105 return 1;
2106 }
2107
2108 port = ctdb_addr_to_port(addr);
2109
2110 tcparray = vnn->tcp_array;
2111 num = 0;
2112 if (tcparray != NULL) {
2113 if (port == 0) {
2114 /* All connections */
2115 num = tcparray->num;
2116 } else {
2117 /* Count connections for port */
2118 for (i = 0; i < tcparray->num; i++) {
2119 if (port == ctdb_addr_to_port(&tcparray->connections[i].dst)) {
2120 num++;
2121 }
2122 }
2123 }
2124 }
2125
2126 outdata->dsize = offsetof(struct ctdb_tickle_list_old, connections)
2127 + sizeof(struct ctdb_connection) * num;
2128
2129 outdata->dptr = talloc_size(outdata, outdata->dsize);
2130 CTDB_NO_MEMORY(ctdb, outdata->dptr);
2131 list = (struct ctdb_tickle_list_old *)outdata->dptr;
2132
2133 list->addr = *addr;
2134 list->num = num;
2135
2136 if (num == 0) {
2137 return 0;
2138 }
2139
2140 num = 0;
2141 for (i = 0; i < tcparray->num; i++) {
2142 if (port == 0 || \
2143 port == ctdb_addr_to_port(&tcparray->connections[i].dst)) {
2144 list->connections[num] = tcparray->connections[i];
2145 num++;
2146 }
2147 }
2148
2149 return 0;
2150 }
2151
2152
2153 /*
2154 set the list of all tcp tickles for a public address
2155 */
2156 static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
2157 ctdb_sock_addr *addr,
2158 struct ctdb_tcp_array *tcparray)
2159 {
2160 int ret, num;
2161 TDB_DATA data;
2162 struct ctdb_tickle_list_old *list;
2163
2164 if (tcparray) {
2165 num = tcparray->num;
2166 } else {
2167 num = 0;
2168 }
2169
2170 data.dsize = offsetof(struct ctdb_tickle_list_old, connections) +
2171 sizeof(struct ctdb_connection) * num;
2172 data.dptr = talloc_size(ctdb, data.dsize);
2173 CTDB_NO_MEMORY(ctdb, data.dptr);
2174
2175 list = (struct ctdb_tickle_list_old *)data.dptr;
2176 list->addr = *addr;
2177 list->num = num;
2178 if (tcparray) {
2179 memcpy(&list->connections[0], tcparray->connections, sizeof(struct ctdb_connection) * num);
2180 }
2181
2182 ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_ALL, 0,
2183 CTDB_CONTROL_SET_TCP_TICKLE_LIST,
2184 0, CTDB_CTRL_FLAG_NOREPLY, data, NULL, NULL);
2185 if (ret != 0) {
2186 DEBUG(DEBUG_ERR,(__location__ " ctdb_control for set tcp tickles failed\n"));
2187 return -1;
2188 }
2189
2190 talloc_free(data.dptr);
2191
2192 return ret;
2193 }
2194
2195 static void ctdb_send_set_tcp_tickles_for_all(struct ctdb_context *ctdb,
2196 bool force)
2197 {
2198 struct ctdb_vnn *vnn;
2199 int ret;
2200
2201 for (vnn = ctdb->vnn; vnn != NULL; vnn = vnn->next) {
2202 /* we only send out updates for public addresses that
2203 we have taken over
2204 */
2205 if (ctdb->pnn != vnn->pnn) {
2206 continue;
2207 }
2208
2209 /* We only send out the updates if we need to */
2210 if (!force && !vnn->tcp_update_needed) {
2211 continue;
2212 }
2213
2214 ret = ctdb_send_set_tcp_tickles_for_ip(ctdb,
2215 &vnn->public_address,
2216 vnn->tcp_array);
2217 if (ret != 0) {
2218 D_ERR("Failed to send the tickle update for ip %s\n",
2219 ctdb_vnn_address_string(vnn));
2220 vnn->tcp_update_needed = true;
2221 } else {
2222 D_INFO("Sent tickle update for ip %s\n",
2223 ctdb_vnn_address_string(vnn));
2224 vnn->tcp_update_needed = false;
2225 }
2226 }
2227
2228 }
2229
2230 /*
2231 perform tickle updates if required
2232 */
2233 static void ctdb_update_tcp_tickles(struct tevent_context *ev,
2234 struct tevent_timer *te,
2235 struct timeval t, void *private_data)
2236 {
2237 struct ctdb_context *ctdb = talloc_get_type(
2238 private_data, struct ctdb_context);
2239
2240 ctdb_send_set_tcp_tickles_for_all(ctdb, false);
2241
2242 tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
2243 timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
2244 ctdb_update_tcp_tickles, ctdb);
2245 }
2246
2247 /*
2248 start periodic update of tcp tickles
2249 */
2250 void ctdb_start_tcp_tickle_update(struct ctdb_context *ctdb)
2251 {
2252 ctdb->tickle_update_context = talloc_new(ctdb);
2253
2254 tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
2255 timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
2256 ctdb_update_tcp_tickles, ctdb);
2257 }
2258
2259
2260
2261
2262 struct control_gratious_arp {
2263 struct ctdb_context *ctdb;
2264 ctdb_sock_addr addr;
2265 const char *iface;
2266 int count;
2267 };
2268
2269 /*
2270 send a control_gratuitous arp
2271 */
2272 static void send_gratious_arp(struct tevent_context *ev,
2273 struct tevent_timer *te,
2274 struct timeval t, void *private_data)
2275 {
2276 int ret;
2277 struct control_gratious_arp *arp = talloc_get_type(private_data,
2278 struct control_gratious_arp);
2279
2280 ret = ctdb_sys_send_arp(&arp->addr, arp->iface);
2281 if (ret != 0) {
2282 DBG_ERR("Failed to send gratuitous ARP on iface %s: %s\n",
2283 arp->iface, strerror(ret));
2284 }
2285
2286
2287 arp->count++;
2288 if (arp->count == CTDB_ARP_REPEAT) {
2289 talloc_free(arp);
2290 return;
2291 }
2292
2293 tevent_add_timer(arp->ctdb->ev, arp,
2294 timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
2295 send_gratious_arp, arp);
2296 }
2297
2298
2299 /*
2300 send a gratious arp
2301 */
2302 int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb, TDB_DATA indata)
2303 {
2304 struct ctdb_addr_info_old *gratious_arp = (struct ctdb_addr_info_old *)indata.dptr;
2305 struct control_gratious_arp *arp;
2306
2307 /* verify the size of indata */
2308 if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
2309 DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_control_gratious_arp structure. Got %u require %u bytes\n",
2310 (unsigned)indata.dsize,
2311 (unsigned)offsetof(struct ctdb_addr_info_old, iface)));
2312 return -1;
2313 }
2314 if (indata.dsize !=
2315 ( offsetof(struct ctdb_addr_info_old, iface)
2316 + gratious_arp->len ) ){
2317
2318 DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
2319 "but should be %u bytes\n",
2320 (unsigned)indata.dsize,
2321 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+gratious_arp->len)));
2322 return -1;
2323 }
2324
2325
2326 arp = talloc(ctdb, struct control_gratious_arp);
2327 CTDB_NO_MEMORY(ctdb, arp);
2328
2329 arp->ctdb = ctdb;
2330 arp->addr = gratious_arp->addr;
2331 arp->iface = talloc_strdup(arp, gratious_arp->iface);
2332 CTDB_NO_MEMORY(ctdb, arp->iface);
2333 arp->count = 0;
2334
2335 tevent_add_timer(arp->ctdb->ev, arp,
2336 timeval_zero(), send_gratious_arp, arp);
2337
2338 return 0;
2339 }
2340
2341 int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
2342 {
2343 struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
2344 int ret;
2345
2346 /* verify the size of indata */
2347 if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
2348 DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_addr_info structure\n"));
2349 return -1;
2350 }
2351 if (indata.dsize !=
2352 ( offsetof(struct ctdb_addr_info_old, iface)
2353 + pub->len ) ){
2354
2355 DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
2356 "but should be %u bytes\n",
2357 (unsigned)indata.dsize,
2358 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+pub->len)));
2359 return -1;
2360 }
2361
2362 DEBUG(DEBUG_NOTICE,("Add IP %s\n", ctdb_addr_to_str(&pub->addr)));
2363
2364 ret = ctdb_add_public_address(ctdb, &pub->addr, pub->mask, &pub->iface[0]);
2365
2366 if (ret != 0) {
2367 DEBUG(DEBUG_ERR,(__location__ " Failed to add public address\n"));
2368 return -1;
2369 }
2370
2371 return 0;
2372 }
2373
2374 int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
2375 {
2376 struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
2377 struct ctdb_vnn *vnn;
2378
2379 /* verify the size of indata */
2380 if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
2381 DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_addr_info structure\n"));
2382 return -1;
2383 }
2384 if (indata.dsize !=
2385 ( offsetof(struct ctdb_addr_info_old, iface)
2386 + pub->len ) ){
2387
2388 DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
2389 "but should be %u bytes\n",
2390 (unsigned)indata.dsize,
2391 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+pub->len)));
2392 return -1;
2393 }
2394
2395 DEBUG(DEBUG_NOTICE,("Delete IP %s\n", ctdb_addr_to_str(&pub->addr)));
2396
2397 vnn = find_public_ip_vnn(ctdb, &pub->addr);
2398 if (vnn == NULL) {
2399 D_ERR("Delete IP of unknown public IP address %s\n",
2400 ctdb_addr_to_str(&pub->addr));
2401 return -1;
2402 }
2403
2404 if (vnn->pnn == ctdb->pnn) {
2405 /*
2406 * This IP is currently being hosted. Defer the
2407 * deletion until the next takeover run. "ctdb
2408 * reloadips" will always cause a takeover run. "ctdb
2409 * delip" will now need an explicit "ctdb
2410 * ipreallocated" afterwards.
2411 */
2412 vnn->delete_pending = true;
2413 } else {
2414 /*
2415 * This IP is not hosted on the current node so just
2416 * delete it now.
2417 */
2418 do_delete_ip(ctdb, vnn);
2419 }
2420
2421 return 0;
2422 }
2423
2424
2425 struct ipreallocated_callback_state {
2426 struct ctdb_req_control_old *c;
2427 };
2428
2429 static void ctdb_ipreallocated_callback(struct ctdb_context *ctdb,
2430 int status, void *p)
2431 {
2432 struct ipreallocated_callback_state *state =
2433 talloc_get_type(p, struct ipreallocated_callback_state);
2434 TDB_DATA data = { .dsize = 0, };
2435
2436 if (status != 0) {
2437 DEBUG(DEBUG_ERR,
2438 (" \"ipreallocated\" event script failed (status %d)\n",
2439 status));
2440 if (status == -ETIMEDOUT) {
2441 ctdb_ban_self(ctdb);
2442 }
2443 }
2444
2445 D_INFO("Sending IPREALLOCATED message\n");
2446 ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_IPREALLOCATED, data);
2447
2448 ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
2449 talloc_free(state);
2450 }
2451
2452 /* A control to run the ipreallocated event */
2453 int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
2454 struct ctdb_req_control_old *c,
2455 bool *async_reply)
2456 {
2457 int ret;
2458 struct ipreallocated_callback_state *state;
2459
2460 state = talloc(ctdb, struct ipreallocated_callback_state);
2461 CTDB_NO_MEMORY(ctdb, state);
2462
2463 DEBUG(DEBUG_INFO,(__location__ " Running \"ipreallocated\" event\n"));
2464
2465 ret = ctdb_event_script_callback(ctdb, state,
2466 ctdb_ipreallocated_callback, state,
2467 CTDB_EVENT_IPREALLOCATED,
2468 "%s", "");
2469
2470 if (ret != 0) {
2471 DEBUG(DEBUG_ERR,("Failed to run \"ipreallocated\" event \n"));
2472 talloc_free(state);
2473 return -1;
2474 }
2475
2476 /* tell the control that we will be reply asynchronously */
2477 state->c = talloc_steal(state, c);
2478 *async_reply = true;
2479
2480 return 0;
2481 }
2482
2483
2484 struct start_ipreallocate_callback_state {
2485 struct ctdb_req_control_old *c;
2486 };
2487
2488 static void ctdb_start_ipreallocate_callback(struct ctdb_context *ctdb,
2489 int status, void *p)
2490 {
2491 struct start_ipreallocate_callback_state *state = talloc_get_type_abort(
2492 p, struct start_ipreallocate_callback_state);
2493 TDB_DATA data = { .dsize = 0, };
2494
2495 if (status != 0) {
2496 D_ERR("\"startipreallocate\" event failed (status %d)\n",
2497 status);
2498 if (status == -ETIMEDOUT) {
2499 ctdb_ban_self(ctdb);
2500 }
2501 }
2502
2503 D_INFO("Sending START_IPREALLOCATE message\n");
2504 ctdb_daemon_send_message(ctdb,
2505 ctdb->pnn,
2506 CTDB_SRVID_START_IPREALLOCATE,
2507 data);
2508
2509 ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
2510 talloc_free(state);
2511 }
2512
2513 /* A control to run the startipreallocate event */
2514 int32_t ctdb_control_start_ipreallocate(struct ctdb_context *ctdb,
2515 struct ctdb_req_control_old *c,
2516 bool *async_reply)
2517 {
2518 int ret;
2519 struct start_ipreallocate_callback_state *state;
2520
2521 /* Nodes that are not RUNNING can not host IPs */
2522 if (ctdb->runstate != CTDB_RUNSTATE_RUNNING) {
2523 DBG_INFO("Skipping \"startipreallocate\" event, not RUNNING\n");
2524 return 0;
2525 }
2526
2527 state = talloc(ctdb, struct start_ipreallocate_callback_state);
2528 if (state == NULL) {
2529 DBG_ERR("Memory allocation error\n");
2530 return -1;
2531 }
2532
2533 DBG_INFO("Running \"startipreallocate\" event\n");
2534
2535 ret = ctdb_event_script_callback(ctdb,
2536 state,
2537 ctdb_start_ipreallocate_callback,
2538 state,
2539 CTDB_EVENT_START_IPREALLOCATE,
2540 "%s",
2541 "");
2542
2543 if (ret != 0) {
2544 D_ERR("Failed to run \"startipreallocate\" event \n");
2545 talloc_free(state);
2546 return -1;
2547 }
2548
2549 /* tell the control that we will be reply asynchronously */
2550 state->c = talloc_steal(state, c);
2551 *async_reply = true;
2552
2553 return 0;
2554 }
2555
2556
2557 struct ctdb_reloadips_handle {
2558 struct ctdb_context *ctdb;
2559 struct ctdb_req_control_old *c;
2560 int status;
2561 int fd[2];
2562 pid_t child;
2563 struct tevent_fd *fde;
2564 };
2565
2566 static int ctdb_reloadips_destructor(struct ctdb_reloadips_handle *h)
2567 {
2568 if (h == h->ctdb->reload_ips) {
2569 h->ctdb->reload_ips = NULL;
2570 }
2571 if (h->c != NULL) {
2572 ctdb_request_control_reply(h->ctdb, h->c, NULL, h->status, NULL);
2573 h->c = NULL;
2574 }
2575 ctdb_kill(h->ctdb, h->child, SIGKILL);
2576 return 0;
2577 }
2578
2579 static void ctdb_reloadips_timeout_event(struct tevent_context *ev,
2580 struct tevent_timer *te,
2581 struct timeval t, void *private_data)
2582 {
2583 struct ctdb_reloadips_handle *h = talloc_get_type(private_data, struct ctdb_reloadips_handle);
2584
2585 talloc_free(h);
2586 }
2587
2588 static void ctdb_reloadips_child_handler(struct tevent_context *ev,
2589 struct tevent_fd *fde,
2590 uint16_t flags, void *private_data)
2591 {
2592 struct ctdb_reloadips_handle *h = talloc_get_type(private_data, struct ctdb_reloadips_handle);
2593
2594 char res;
2595 int ret;
2596
2597 ret = sys_read(h->fd[0], &res, 1);
2598 if (ret < 1 || res != 0) {
2599 DEBUG(DEBUG_ERR, (__location__ " Reloadips child process returned error\n"));
2600 res = 1;
2601 }
2602 h->status = res;
2603
2604 talloc_free(h);
2605 }
2606
2607 static int ctdb_reloadips_child(struct ctdb_context *ctdb)
2608 {
2609 TALLOC_CTX *mem_ctx = talloc_new(NULL);
2610 struct ctdb_public_ip_list_old *ips;
2611 struct ctdb_vnn *vnn;
2612 struct client_async_data *async_data;
2613 struct timeval timeout;
2614 TDB_DATA data;
2615 struct ctdb_client_control_state *state;
2616 bool first_add;
2617 unsigned int i;
2618 int ret;
2619
2620 CTDB_NO_MEMORY(ctdb, mem_ctx);
2621
2622 /* Read IPs from local node */
2623 ret = ctdb_ctrl_get_public_ips(ctdb, TAKEOVER_TIMEOUT(),
2624 CTDB_CURRENT_NODE, mem_ctx, &ips);
2625 if (ret != 0) {
2626 DEBUG(DEBUG_ERR,
2627 ("Unable to fetch public IPs from local node\n"));
2628 talloc_free(mem_ctx);
2629 return -1;
2630 }
2631
2632 /* Read IPs file - this is safe since this is a child process */
2633 ctdb->vnn = NULL;
2634 if (ctdb_set_public_addresses(ctdb) != 0) {
2635 DEBUG(DEBUG_ERR,("Failed to re-read public addresses file\n"));
2636 talloc_free(mem_ctx);
2637 return -1;
2638 }
2639
2640 async_data = talloc_zero(mem_ctx, struct client_async_data);
2641 CTDB_NO_MEMORY(ctdb, async_data);
2642
2643 /* Compare IPs between node and file for IPs to be deleted */
2644 for (i = 0; i < ips->num; i++) {
2645 struct ctdb_addr_info_old *pub = NULL;
2646
2647 vnn = find_public_ip_vnn(ctdb, &ips->ips[i].addr);
2648 if (vnn != NULL) {
2649 /* IP is still in file */
2650 continue;
2651 }
2652
2653 /*
2654 * Delete IP ips->ips[i]
2655 */
2656
2657 D_NOTICE("IP %s no longer configured, deleting it\n",
2658 ctdb_addr_to_str(&ips->ips[i].addr));
2659
2660 pub = talloc_zero(mem_ctx, struct ctdb_addr_info_old);
2661 CTDB_NO_MEMORY(ctdb, pub);
2662
2663 pub->addr = ips->ips[i].addr;
2664 pub->mask = 0;
2665 pub->len = 0;
2666
2667 timeout = TAKEOVER_TIMEOUT();
2668
2669 data.dsize = offsetof(struct ctdb_addr_info_old,
2670 iface) + pub->len;
2671 data.dptr = (uint8_t *)pub;
2672
2673 state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, 0,
2674 CTDB_CONTROL_DEL_PUBLIC_IP,
2675 0, data, async_data,
2676 &timeout, NULL);
2677 if (state == NULL) {
2678 DBG_ERR("Failed sending CTDB_CONTROL_DEL_PUBLIC_IP\n");
2679 goto failed;
2680 }
2681
2682 ctdb_client_async_add(async_data, state);
2683 }
2684
2685 /* Compare IPs between node and file for IPs to be added */
2686 first_add = true;
2687 for (vnn = ctdb->vnn; vnn; vnn = vnn->next) {
2688 for (i = 0; i < ips->num; i++) {
2689 if (ctdb_same_ip(&vnn->public_address,
2690 &ips->ips[i].addr)) {
2691 /* IP already on node */
2692 break;
2693 }
2694 }
2695 if (i == ips->num) {
2696 /* Add IP ips->ips[i] */
2697 struct ctdb_addr_info_old *pub;
2698 const char *ifaces = NULL;
2699 uint32_t len;
2700 struct vnn_interface *iface = NULL;
2701
2702 D_NOTICE("New IP %s configured, adding it\n",
2703 ctdb_vnn_address_string(vnn));
2704 if (first_add) {
2705 uint32_t pnn = ctdb_get_pnn(ctdb);
2706
2707 data.dsize = sizeof(pnn);
2708 data.dptr = (uint8_t *)&pnn;
2709
2710 ret = ctdb_client_send_message(
2711 ctdb,
2712 CTDB_BROADCAST_CONNECTED,
2713 CTDB_SRVID_REBALANCE_NODE,
2714 data);
2715 if (ret != 0) {
2716 DEBUG(DEBUG_WARNING,
2717 ("Failed to send message to force node reallocation - IPs may be unbalanced\n"));
2718 }
2719
2720 first_add = false;
2721 }
2722
2723 ifaces = vnn->ifaces->iface->name;
2724 iface = vnn->ifaces->next;
2725 while (iface != NULL) {
2726 ifaces = talloc_asprintf(vnn, "%s,%s", ifaces,
2727 iface->iface->name);
2728 iface = iface->next;
2729 }
2730
2731 len = strlen(ifaces) + 1;
2732 pub = talloc_zero_size(mem_ctx,
2733 offsetof(struct ctdb_addr_info_old, iface) + len);
2734 CTDB_NO_MEMORY(ctdb, pub);
2735
2736 pub->addr = vnn->public_address;
2737 pub->mask = vnn->public_netmask_bits;
2738 pub->len = len;
2739 memcpy(&pub->iface[0], ifaces, pub->len);
2740
2741 timeout = TAKEOVER_TIMEOUT();
2742
2743 data.dsize = offsetof(struct ctdb_addr_info_old,
2744 iface) + pub->len;
2745 data.dptr = (uint8_t *)pub;
2746
2747 state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, 0,
2748 CTDB_CONTROL_ADD_PUBLIC_IP,
2749 0, data, async_data,
2750 &timeout, NULL);
2751 if (state == NULL) {
2752 DEBUG(DEBUG_ERR,
2753 (__location__
2754 " failed sending CTDB_CONTROL_ADD_PUBLIC_IP\n"));
2755 goto failed;
2756 }
2757
2758 ctdb_client_async_add(async_data, state);
2759 }
2760 }
2761
2762 if (ctdb_client_async_wait(ctdb, async_data) != 0) {
2763 DEBUG(DEBUG_ERR,(__location__ " Add/delete IPs failed\n"));
2764 goto failed;
2765 }
2766
2767 talloc_free(mem_ctx);
2768 return 0;
2769
2770 failed:
2771 talloc_free(mem_ctx);
2772 return -1;
2773 }
2774
2775 /* This control is sent to force the node to re-read the public addresses file
2776 and drop any addresses we should nnot longer host, and add new addresses
2777 that we are now able to host
2778 */
2779 int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control_old *c, bool *async_reply)
2780 {
2781 struct ctdb_reloadips_handle *h;
2782 pid_t parent = getpid();
2783
2784 if (ctdb->reload_ips != NULL) {
2785 talloc_free(ctdb->reload_ips);
2786 ctdb->reload_ips = NULL;
2787 }
2788
2789 h = talloc(ctdb, struct ctdb_reloadips_handle);
2790 CTDB_NO_MEMORY(ctdb, h);
2791 h->ctdb = ctdb;
2792 h->c = NULL;
2793 h->status = -1;
2794
2795 if (pipe(h->fd) == -1) {
2796 DEBUG(DEBUG_ERR,("Failed to create pipe for ctdb_freeze_lock\n"));
2797 talloc_free(h);
2798 return -1;
2799 }
2800
2801 h->child = ctdb_fork(ctdb);
2802 if (h->child == (pid_t)-1) {
2803 DEBUG(DEBUG_ERR, ("Failed to fork a child for reloadips\n"));
2804 close(h->fd[0]);
2805 close(h->fd[1]);
2806 talloc_free(h);
2807 return -1;
2808 }
2809
2810 /* child process */
2811 if (h->child == 0) {
2812 signed char res = 0;
2813
2814 close(h->fd[0]);
2815
2816 prctl_set_comment("ctdb_reloadips");
2817 if (switch_from_server_to_client(ctdb) != 0) {
2818 DEBUG(DEBUG_CRIT,("ERROR: Failed to switch reloadips child into client mode\n"));
2819 res = -1;
2820 } else {
2821 res = ctdb_reloadips_child(ctdb);
2822 if (res != 0) {
2823 DEBUG(DEBUG_ERR,("Failed to reload ips on local node\n"));
2824 }
2825 }
2826
2827 sys_write(h->fd[1], &res, 1);
2828 ctdb_wait_for_process_to_exit(parent);
2829 _exit(0);
2830 }
2831
2832 h->c = talloc_steal(h, c);
2833
2834 close(h->fd[1]);
2835 set_close_on_exec(h->fd[0]);
2836
2837 talloc_set_destructor(h, ctdb_reloadips_destructor);
2838
2839
2840 h->fde = tevent_add_fd(ctdb->ev, h, h->fd[0], TEVENT_FD_READ,
2841 ctdb_reloadips_child_handler, (void *)h);
2842 tevent_fd_set_auto_close(h->fde);
2843
2844 tevent_add_timer(ctdb->ev, h, timeval_current_ofs(120, 0),
2845 ctdb_reloadips_timeout_event, h);
2846
2847 /* we reply later */
2848 *async_reply = true;
2849 return 0;
2850 }
GSS-enabled samba4