?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb-server: Handle pre-existing connection first
[samba4-gss.git] / ctdb / server / ctdb_takeover.c
blob50bd512d0ef1a5afd0c7f7257ae23cf1b67b19a6
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_same_sockaddr(&array->connections[i].src, &tcp->src) &&
1501 ctdb_same_sockaddr(&array->connections[i].dst, &tcp->dst)) {
1502 return &array->connections[i];
1503 }
1504 }
1505 return NULL;
1506 }
1507
1508
1509
1510 /*
1511 called by a daemon to inform us of a TCP connection that one of its
1512 clients managing that should tickled with an ACK when IP takeover is
1513 done
1514 */
1515 int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb,
1516 TDB_DATA indata,
1517 bool tcp_update_needed)
1518 {
1519 struct ctdb_connection *p = (struct ctdb_connection *)indata.dptr;
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(vnn, struct ctdb_tcp_array);
1559 CTDB_NO_MEMORY(ctdb, tcparray);
1560 vnn->tcp_array = tcparray;
1561
1562 tcparray->num = 0;
1563 tcparray->connections = talloc_size(tcparray,
1564 sizeof(struct ctdb_connection));
1565 CTDB_NO_MEMORY(ctdb, tcparray->connections);
1566
1567 tcparray->connections[tcparray->num].src = p->src;
1568 tcparray->connections[tcparray->num].dst = p->dst;
1569 tcparray->num++;
1570
1571 if (tcp_update_needed) {
1572 vnn->tcp_update_needed = true;
1573 }
1574 return 0;
1575 }
1576
1577 /* A new tickle, we must add it to the array */
1578 tcparray->connections = talloc_realloc(tcparray,
1579 tcparray->connections,
1580 struct ctdb_connection,
1581 tcparray->num + 1);
1582 CTDB_NO_MEMORY(ctdb, tcparray->connections);
1583
1584 tcparray->connections[tcparray->num].src = p->src;
1585 tcparray->connections[tcparray->num].dst = p->dst;
1586 tcparray->num++;
1587
1588 D_INFO("Added connection %s\n", conn_str);
1589
1590 if (tcp_update_needed) {
1591 vnn->tcp_update_needed = true;
1592 }
1593
1594 return 0;
1595 }
1596
1597
1598 static void ctdb_remove_connection(struct ctdb_vnn *vnn,
1599 struct ctdb_connection *conn)
1600 {
1601 struct ctdb_connection *tcpp;
1602 char conn_str[132] = { 0, };
1603 int ret;
1604
1605 if (vnn == NULL) {
1606 return;
1607 }
1608
1609 ret = ctdb_connection_to_buf(conn_str,
1610 sizeof(conn_str),
1611 conn,
1612 false,
1613 " -> ");
1614 if (ret != 0) {
1615 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1616 }
1617
1618 /* If the array is empty there is nothing to remove */
1619 if (vnn->tcp_array == NULL) {
1620 D_INFO("Attempt to remove untracked connection %s (empty)\n",
1621 conn_str);
1622 return;
1623 }
1624
1625
1626 tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
1627 if (tcpp == NULL) {
1628 D_DEBUG("Attempt to remove untracked connection %s\n", conn_str);
1629 return;
1630 }
1631
1632
1633 /*
1634 * We need to remove this entry from the array. Instead of
1635 * allocating a new array and copying data to it, cheat and
1636 * just copy the last entry in the existing array to the entry
1637 * that is to be removed and just shrink the size.
1638 */
1639 *tcpp = vnn->tcp_array->connections[vnn->tcp_array->num - 1];
1640 vnn->tcp_array->num--;
1641
1642 /* Last entry deleted, so remove the entire array */
1643 if (vnn->tcp_array->num == 0) {
1644 talloc_free(vnn->tcp_array);
1645 vnn->tcp_array = NULL;
1646 }
1647
1648 vnn->tcp_update_needed = true;
1649
1650 D_INFO("Removed connection %s\n", conn_str);
1651 }
1652
1653
1654 /*
1655 called by a daemon to inform us of a TCP connection that one of its
1656 clients used are no longer needed in the tickle database
1657 */
1658 int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata)
1659 {
1660 struct ctdb_vnn *vnn;
1661 struct ctdb_connection *conn = (struct ctdb_connection *)indata.dptr;
1662
1663 /* If we don't have public IPs, tickles are useless */
1664 if (ctdb->vnn == NULL) {
1665 return 0;
1666 }
1667
1668 vnn = find_public_ip_vnn(ctdb, &conn->dst);
1669 if (vnn == NULL) {
1670 char conn_str[132] = { 0, };
1671 int ret;
1672
1673 ret = ctdb_connection_to_buf(conn_str,
1674 sizeof(conn_str),
1675 conn,
1676 false,
1677 " -> ");
1678 if (ret != 0) {
1679 strlcpy(conn_str, "UNKNOWN", sizeof(conn_str));
1680 }
1681
1682 DBG_ERR("Attempt to remove connection %s "
1683 "but destination is not a public address\n",
1684 conn_str);
1685 return 0;
1686 }
1687
1688 ctdb_remove_connection(vnn, conn);
1689
1690 return 0;
1691 }
1692
1693
1694 static void ctdb_send_set_tcp_tickles_for_all(struct ctdb_context *ctdb,
1695 bool force);
1696
1697 /*
1698 Called when another daemon starts - causes all tickles for all
1699 public addresses we are serving to be sent to the new node on the
1700 next check. This actually causes the tickles to be sent to the
1701 other node immediately. In case there is an error, the periodic
1702 timer will send the updates on timer event. This is simple and
1703 doesn't require careful error handling.
1704 */
1705 int32_t ctdb_control_startup(struct ctdb_context *ctdb, uint32_t pnn)
1706 {
1707 DEBUG(DEBUG_INFO, ("Received startup control from node %lu\n",
1708 (unsigned long) pnn));
1709
1710 ctdb_send_set_tcp_tickles_for_all(ctdb, true);
1711 return 0;
1712 }
1713
1714
1715 /*
1716 called when a client structure goes away - hook to remove
1717 elements from the tcp_list in all daemons
1718 */
1719 void ctdb_takeover_client_destructor_hook(struct ctdb_client *client)
1720 {
1721 while (client->tcp_list) {
1722 struct ctdb_vnn *vnn;
1723 struct ctdb_tcp_list *tcp = client->tcp_list;
1724 struct ctdb_connection *conn = &tcp->connection;
1725
1726 vnn = find_public_ip_vnn(client->ctdb,
1727 &conn->dst);
1728
1729 /* If the IP address is hosted on this node then
1730 * remove the connection. */
1731 if (vnn != NULL && vnn->pnn == client->ctdb->pnn) {
1732 ctdb_remove_connection(vnn, conn);
1733 }
1734
1735 /* Otherwise this function has been called because the
1736 * server IP address has been released to another node
1737 * and the client has exited. This means that we
1738 * should not delete the connection information. The
1739 * takeover node processes connections too. */
1740
1741 /*
1742 * The destructor removes from the list
1743 */
1744 TALLOC_FREE(tcp);
1745 }
1746 }
1747
1748
1749 void ctdb_release_all_ips(struct ctdb_context *ctdb)
1750 {
1751 struct ctdb_vnn *vnn, *next;
1752 int count = 0;
1753
1754 if (ctdb_config.failover_disabled == 1) {
1755 return;
1756 }
1757
1758 for (vnn = ctdb->vnn; vnn != NULL; vnn = next) {
1759 bool have_ip;
1760 int ret;
1761
1762 /* vnn can be freed below in release_ip_post() */
1763 next = vnn->next;
1764
1765 if (!ctdb_sys_have_ip(&vnn->public_address)) {
1766 ctdb_vnn_unassign_iface(ctdb, vnn);
1767 continue;
1768 }
1769
1770 /* Don't allow multiple releases at once. Some code,
1771 * particularly ctdb_tickle_sentenced_connections() is
1772 * not re-entrant */
1773 if (vnn->update_in_flight) {
1774 DBG_WARNING(
1775 "Not releasing IP %s/%u on interface %s, "
1776 "an update is already in progress\n",
1777 ctdb_vnn_address_string(vnn),
1778 vnn->public_netmask_bits,
1779 ctdb_vnn_iface_string(vnn));
1780 continue;
1781 }
1782 vnn->update_in_flight = true;
1783
1784 D_INFO("Release of IP %s/%u on interface %s node:-1\n",
1785 ctdb_vnn_address_string(vnn),
1786 vnn->public_netmask_bits,
1787 ctdb_vnn_iface_string(vnn));
1788
1789 /*
1790 * releaseip timeouts are converted to success, or IP
1791 * might be released but releaseip event failed (due
1792 * to failure of script after 10.interface), so try
1793 * hard to correctly report failures...
1794 */
1795 ret = ctdb_event_script_args(
1796 ctdb,
1797 CTDB_EVENT_RELEASE_IP,
1798 "%s %s %u",
1799 ctdb_vnn_iface_string(vnn),
1800 ctdb_vnn_address_string(vnn),
1801 vnn->public_netmask_bits);
1802 have_ip = ctdb_sys_have_ip(&vnn->public_address);
1803 if (have_ip) {
1804 if (ret != 0) {
1805 DBG_ERR("Error releasing IP %s\n",
1806 ctdb_vnn_address_string(vnn));
1807 } else {
1808 DBG_ERR("IP %s not released (timed out?)\n",
1809 ctdb_vnn_address_string(vnn));
1810 }
1811 vnn->update_in_flight = false;
1812 continue;
1813 }
1814 if (ret != 0) {
1815 DBG_ERR("Error releasing IP %s (but IP is gone!)\n",
1816 ctdb_vnn_address_string(vnn));
1817 vnn->update_in_flight = false;
1818 continue;
1819 }
1820
1821 vnn = release_ip_post(ctdb, vnn, &vnn->public_address);
1822 if (vnn != NULL) {
1823 vnn->update_in_flight = false;
1824 }
1825 count++;
1826 }
1827
1828 DEBUG(DEBUG_NOTICE,(__location__ " Released %d public IPs\n", count));
1829 }
1830
1831
1832 /*
1833 get list of public IPs
1834 */
1835 int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
1836 struct ctdb_req_control_old *c, TDB_DATA *outdata)
1837 {
1838 int i, num, len;
1839 struct ctdb_public_ip_list_old *ips;
1840 struct ctdb_vnn *vnn;
1841 bool only_available = false;
1842
1843 if (c->flags & CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE) {
1844 only_available = true;
1845 }
1846
1847 /* count how many public ip structures we have */
1848 num = 0;
1849 for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
1850 num++;
1851 }
1852
1853 len = offsetof(struct ctdb_public_ip_list_old, ips) +
1854 num*sizeof(struct ctdb_public_ip);
1855 ips = talloc_zero_size(outdata, len);
1856 CTDB_NO_MEMORY(ctdb, ips);
1857
1858 i = 0;
1859 for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
1860 if (only_available && !ctdb_vnn_available(ctdb, vnn)) {
1861 continue;
1862 }
1863 ips->ips[i].pnn = vnn->pnn;
1864 ips->ips[i].addr = vnn->public_address;
1865 i++;
1866 }
1867 ips->num = i;
1868 len = offsetof(struct ctdb_public_ip_list_old, ips) +
1869 i*sizeof(struct ctdb_public_ip);
1870
1871 outdata->dsize = len;
1872 outdata->dptr = (uint8_t *)ips;
1873
1874 return 0;
1875 }
1876
1877
1878 int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
1879 struct ctdb_req_control_old *c,
1880 TDB_DATA indata,
1881 TDB_DATA *outdata)
1882 {
1883 int i, num, len;
1884 ctdb_sock_addr *addr;
1885 struct ctdb_public_ip_info_old *info;
1886 struct ctdb_vnn *vnn;
1887 struct vnn_interface *iface;
1888
1889 addr = (ctdb_sock_addr *)indata.dptr;
1890
1891 vnn = find_public_ip_vnn(ctdb, addr);
1892 if (vnn == NULL) {
1893 DEBUG(DEBUG_ERR,(__location__ " Could not get public ip info, "
1894 "'%s'not a public address\n",
1895 ctdb_addr_to_str(addr)));
1896 return -1;
1897 }
1898
1899 /* count how many public ip structures we have */
1900 num = 0;
1901 for (iface = vnn->ifaces; iface != NULL; iface = iface->next) {
1902 num++;
1903 }
1904
1905 len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
1906 num*sizeof(struct ctdb_iface);
1907 info = talloc_zero_size(outdata, len);
1908 CTDB_NO_MEMORY(ctdb, info);
1909
1910 info->ip.addr = vnn->public_address;
1911 info->ip.pnn = vnn->pnn;
1912 info->active_idx = 0xFFFFFFFF;
1913
1914 i = 0;
1915 for (iface = vnn->ifaces; iface != NULL; iface = iface->next) {
1916 struct ctdb_interface *cur;
1917
1918 cur = iface->iface;
1919 if (vnn->iface == cur) {
1920 info->active_idx = i;
1921 }
1922 strncpy(info->ifaces[i].name, cur->name,
1923 sizeof(info->ifaces[i].name));
1924 info->ifaces[i].name[sizeof(info->ifaces[i].name)-1] = '\0';
1925 info->ifaces[i].link_state = cur->link_up;
1926 info->ifaces[i].references = cur->references;
1927
1928 i++;
1929 }
1930 info->num = i;
1931 len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
1932 i*sizeof(struct ctdb_iface);
1933
1934 outdata->dsize = len;
1935 outdata->dptr = (uint8_t *)info;
1936
1937 return 0;
1938 }
1939
1940 int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
1941 struct ctdb_req_control_old *c,
1942 TDB_DATA *outdata)
1943 {
1944 int i, num, len;
1945 struct ctdb_iface_list_old *ifaces;
1946 struct ctdb_interface *cur;
1947
1948 /* count how many public ip structures we have */
1949 num = 0;
1950 for (cur=ctdb->ifaces;cur;cur=cur->next) {
1951 num++;
1952 }
1953
1954 len = offsetof(struct ctdb_iface_list_old, ifaces) +
1955 num*sizeof(struct ctdb_iface);
1956 ifaces = talloc_zero_size(outdata, len);
1957 CTDB_NO_MEMORY(ctdb, ifaces);
1958
1959 i = 0;
1960 for (cur=ctdb->ifaces;cur;cur=cur->next) {
1961 strncpy(ifaces->ifaces[i].name, cur->name,
1962 sizeof(ifaces->ifaces[i].name));
1963 ifaces->ifaces[i].name[sizeof(ifaces->ifaces[i].name)-1] = '\0';
1964 ifaces->ifaces[i].link_state = cur->link_up;
1965 ifaces->ifaces[i].references = cur->references;
1966 i++;
1967 }
1968 ifaces->num = i;
1969 len = offsetof(struct ctdb_iface_list_old, ifaces) +
1970 i*sizeof(struct ctdb_iface);
1971
1972 outdata->dsize = len;
1973 outdata->dptr = (uint8_t *)ifaces;
1974
1975 return 0;
1976 }
1977
1978 int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
1979 struct ctdb_req_control_old *c,
1980 TDB_DATA indata)
1981 {
1982 struct ctdb_iface *info;
1983 struct ctdb_interface *iface;
1984 bool link_up = false;
1985
1986 info = (struct ctdb_iface *)indata.dptr;
1987
1988 if (info->name[CTDB_IFACE_SIZE] != '\0') {
1989 int len = strnlen(info->name, CTDB_IFACE_SIZE);
1990 DEBUG(DEBUG_ERR, (__location__ " name[%*.*s] not terminated\n",
1991 len, len, info->name));
1992 return -1;
1993 }
1994
1995 switch (info->link_state) {
1996 case 0:
1997 link_up = false;
1998 break;
1999 case 1:
2000 link_up = true;
2001 break;
2002 default:
2003 DEBUG(DEBUG_ERR, (__location__ " link_state[%u] invalid\n",
2004 (unsigned int)info->link_state));
2005 return -1;
2006 }
2007
2008 if (info->references != 0) {
2009 DEBUG(DEBUG_ERR, (__location__ " references[%u] should be 0\n",
2010 (unsigned int)info->references));
2011 return -1;
2012 }
2013
2014 iface = ctdb_find_iface(ctdb, info->name);
2015 if (iface == NULL) {
2016 return -1;
2017 }
2018
2019 if (link_up == iface->link_up) {
2020 return 0;
2021 }
2022
2023 DEBUG(DEBUG_ERR,
2024 ("iface[%s] has changed it's link status %s => %s\n",
2025 iface->name,
2026 iface->link_up?"up":"down",
2027 link_up?"up":"down"));
2028
2029 iface->link_up = link_up;
2030 return 0;
2031 }
2032
2033
2034 /*
2035 called by a daemon to inform us of the entire list of TCP tickles for
2036 a particular public address.
2037 this control should only be sent by the node that is currently serving
2038 that public address.
2039 */
2040 int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata)
2041 {
2042 struct ctdb_tickle_list_old *list = (struct ctdb_tickle_list_old *)indata.dptr;
2043 struct ctdb_tcp_array *tcparray;
2044 struct ctdb_vnn *vnn;
2045
2046 /* We must at least have tickles.num or else we can't verify the size
2047 of the received data blob
2048 */
2049 if (indata.dsize < offsetof(struct ctdb_tickle_list_old, connections)) {
2050 DEBUG(DEBUG_ERR,("Bad indata in ctdb_tickle_list. Not enough data for the tickle.num field\n"));
2051 return -1;
2052 }
2053
2054 /* verify that the size of data matches what we expect */
2055 if (indata.dsize < offsetof(struct ctdb_tickle_list_old, connections)
2056 + sizeof(struct ctdb_connection) * list->num) {
2057 DEBUG(DEBUG_ERR,("Bad indata in ctdb_tickle_list\n"));
2058 return -1;
2059 }
2060
2061 DEBUG(DEBUG_INFO, ("Received tickle update for public address %s\n",
2062 ctdb_addr_to_str(&list->addr)));
2063
2064 vnn = find_public_ip_vnn(ctdb, &list->addr);
2065 if (vnn == NULL) {
2066 DEBUG(DEBUG_INFO,(__location__ " Could not set tcp tickle list, '%s' is not a public address\n",
2067 ctdb_addr_to_str(&list->addr)));
2068
2069 return 1;
2070 }
2071
2072 if (vnn->pnn == ctdb->pnn) {
2073 DEBUG(DEBUG_INFO,
2074 ("Ignoring redundant set tcp tickle list, this node hosts '%s'\n",
2075 ctdb_addr_to_str(&list->addr)));
2076 return 0;
2077 }
2078
2079 /* remove any old ticklelist we might have */
2080 talloc_free(vnn->tcp_array);
2081 vnn->tcp_array = NULL;
2082
2083 tcparray = talloc(vnn, struct ctdb_tcp_array);
2084 CTDB_NO_MEMORY(ctdb, tcparray);
2085
2086 tcparray->num = list->num;
2087
2088 tcparray->connections = talloc_array(tcparray, struct ctdb_connection, tcparray->num);
2089 CTDB_NO_MEMORY(ctdb, tcparray->connections);
2090
2091 memcpy(tcparray->connections, &list->connections[0],
2092 sizeof(struct ctdb_connection)*tcparray->num);
2093
2094 /* We now have a new fresh tickle list array for this vnn */
2095 vnn->tcp_array = tcparray;
2096
2097 return 0;
2098 }
2099
2100 /*
2101 called to return the full list of tickles for the puclic address associated
2102 with the provided vnn
2103 */
2104 int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata)
2105 {
2106 ctdb_sock_addr *addr = (ctdb_sock_addr *)indata.dptr;
2107 struct ctdb_tickle_list_old *list;
2108 struct ctdb_tcp_array *tcparray;
2109 unsigned int num, i;
2110 struct ctdb_vnn *vnn;
2111 unsigned port;
2112
2113 vnn = find_public_ip_vnn(ctdb, addr);
2114 if (vnn == NULL) {
2115 DEBUG(DEBUG_ERR,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n",
2116 ctdb_addr_to_str(addr)));
2117
2118 return 1;
2119 }
2120
2121 port = ctdb_addr_to_port(addr);
2122
2123 tcparray = vnn->tcp_array;
2124 num = 0;
2125 if (tcparray != NULL) {
2126 if (port == 0) {
2127 /* All connections */
2128 num = tcparray->num;
2129 } else {
2130 /* Count connections for port */
2131 for (i = 0; i < tcparray->num; i++) {
2132 if (port == ctdb_addr_to_port(&tcparray->connections[i].dst)) {
2133 num++;
2134 }
2135 }
2136 }
2137 }
2138
2139 outdata->dsize = offsetof(struct ctdb_tickle_list_old, connections)
2140 + sizeof(struct ctdb_connection) * num;
2141
2142 outdata->dptr = talloc_size(outdata, outdata->dsize);
2143 CTDB_NO_MEMORY(ctdb, outdata->dptr);
2144 list = (struct ctdb_tickle_list_old *)outdata->dptr;
2145
2146 list->addr = *addr;
2147 list->num = num;
2148
2149 if (num == 0) {
2150 return 0;
2151 }
2152
2153 num = 0;
2154 for (i = 0; i < tcparray->num; i++) {
2155 if (port == 0 || \
2156 port == ctdb_addr_to_port(&tcparray->connections[i].dst)) {
2157 list->connections[num] = tcparray->connections[i];
2158 num++;
2159 }
2160 }
2161
2162 return 0;
2163 }
2164
2165
2166 /*
2167 set the list of all tcp tickles for a public address
2168 */
2169 static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
2170 ctdb_sock_addr *addr,
2171 struct ctdb_tcp_array *tcparray)
2172 {
2173 int ret, num;
2174 TDB_DATA data;
2175 struct ctdb_tickle_list_old *list;
2176
2177 if (tcparray) {
2178 num = tcparray->num;
2179 } else {
2180 num = 0;
2181 }
2182
2183 data.dsize = offsetof(struct ctdb_tickle_list_old, connections) +
2184 sizeof(struct ctdb_connection) * num;
2185 data.dptr = talloc_size(ctdb, data.dsize);
2186 CTDB_NO_MEMORY(ctdb, data.dptr);
2187
2188 list = (struct ctdb_tickle_list_old *)data.dptr;
2189 list->addr = *addr;
2190 list->num = num;
2191 if (tcparray) {
2192 memcpy(&list->connections[0], tcparray->connections, sizeof(struct ctdb_connection) * num);
2193 }
2194
2195 ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_ALL, 0,
2196 CTDB_CONTROL_SET_TCP_TICKLE_LIST,
2197 0, CTDB_CTRL_FLAG_NOREPLY, data, NULL, NULL);
2198 if (ret != 0) {
2199 DEBUG(DEBUG_ERR,(__location__ " ctdb_control for set tcp tickles failed\n"));
2200 return -1;
2201 }
2202
2203 talloc_free(data.dptr);
2204
2205 return ret;
2206 }
2207
2208 static void ctdb_send_set_tcp_tickles_for_all(struct ctdb_context *ctdb,
2209 bool force)
2210 {
2211 struct ctdb_vnn *vnn;
2212 int ret;
2213
2214 for (vnn = ctdb->vnn; vnn != NULL; vnn = vnn->next) {
2215 /* we only send out updates for public addresses that
2216 we have taken over
2217 */
2218 if (ctdb->pnn != vnn->pnn) {
2219 continue;
2220 }
2221
2222 /* We only send out the updates if we need to */
2223 if (!force && !vnn->tcp_update_needed) {
2224 continue;
2225 }
2226
2227 ret = ctdb_send_set_tcp_tickles_for_ip(ctdb,
2228 &vnn->public_address,
2229 vnn->tcp_array);
2230 if (ret != 0) {
2231 D_ERR("Failed to send the tickle update for ip %s\n",
2232 ctdb_vnn_address_string(vnn));
2233 vnn->tcp_update_needed = true;
2234 } else {
2235 D_INFO("Sent tickle update for ip %s\n",
2236 ctdb_vnn_address_string(vnn));
2237 vnn->tcp_update_needed = false;
2238 }
2239 }
2240
2241 }
2242
2243 /*
2244 perform tickle updates if required
2245 */
2246 static void ctdb_update_tcp_tickles(struct tevent_context *ev,
2247 struct tevent_timer *te,
2248 struct timeval t, void *private_data)
2249 {
2250 struct ctdb_context *ctdb = talloc_get_type(
2251 private_data, struct ctdb_context);
2252
2253 ctdb_send_set_tcp_tickles_for_all(ctdb, false);
2254
2255 tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
2256 timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
2257 ctdb_update_tcp_tickles, ctdb);
2258 }
2259
2260 /*
2261 start periodic update of tcp tickles
2262 */
2263 void ctdb_start_tcp_tickle_update(struct ctdb_context *ctdb)
2264 {
2265 ctdb->tickle_update_context = talloc_new(ctdb);
2266
2267 tevent_add_timer(ctdb->ev, ctdb->tickle_update_context,
2268 timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
2269 ctdb_update_tcp_tickles, ctdb);
2270 }
2271
2272
2273
2274
2275 struct control_gratious_arp {
2276 struct ctdb_context *ctdb;
2277 ctdb_sock_addr addr;
2278 const char *iface;
2279 int count;
2280 };
2281
2282 /*
2283 send a control_gratuitous arp
2284 */
2285 static void send_gratious_arp(struct tevent_context *ev,
2286 struct tevent_timer *te,
2287 struct timeval t, void *private_data)
2288 {
2289 int ret;
2290 struct control_gratious_arp *arp = talloc_get_type(private_data,
2291 struct control_gratious_arp);
2292
2293 ret = ctdb_sys_send_arp(&arp->addr, arp->iface);
2294 if (ret != 0) {
2295 DBG_ERR("Failed to send gratuitous ARP on iface %s: %s\n",
2296 arp->iface, strerror(ret));
2297 }
2298
2299
2300 arp->count++;
2301 if (arp->count == CTDB_ARP_REPEAT) {
2302 talloc_free(arp);
2303 return;
2304 }
2305
2306 tevent_add_timer(arp->ctdb->ev, arp,
2307 timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
2308 send_gratious_arp, arp);
2309 }
2310
2311
2312 /*
2313 send a gratious arp
2314 */
2315 int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb, TDB_DATA indata)
2316 {
2317 struct ctdb_addr_info_old *gratious_arp = (struct ctdb_addr_info_old *)indata.dptr;
2318 struct control_gratious_arp *arp;
2319
2320 /* verify the size of indata */
2321 if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
2322 DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_control_gratious_arp structure. Got %u require %u bytes\n",
2323 (unsigned)indata.dsize,
2324 (unsigned)offsetof(struct ctdb_addr_info_old, iface)));
2325 return -1;
2326 }
2327 if (indata.dsize !=
2328 ( offsetof(struct ctdb_addr_info_old, iface)
2329 + gratious_arp->len ) ){
2330
2331 DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
2332 "but should be %u bytes\n",
2333 (unsigned)indata.dsize,
2334 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+gratious_arp->len)));
2335 return -1;
2336 }
2337
2338
2339 arp = talloc(ctdb, struct control_gratious_arp);
2340 CTDB_NO_MEMORY(ctdb, arp);
2341
2342 arp->ctdb = ctdb;
2343 arp->addr = gratious_arp->addr;
2344 arp->iface = talloc_strdup(arp, gratious_arp->iface);
2345 CTDB_NO_MEMORY(ctdb, arp->iface);
2346 arp->count = 0;
2347
2348 tevent_add_timer(arp->ctdb->ev, arp,
2349 timeval_zero(), send_gratious_arp, arp);
2350
2351 return 0;
2352 }
2353
2354 int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
2355 {
2356 struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
2357 int ret;
2358
2359 /* verify the size of indata */
2360 if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
2361 DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_addr_info structure\n"));
2362 return -1;
2363 }
2364 if (indata.dsize !=
2365 ( offsetof(struct ctdb_addr_info_old, iface)
2366 + pub->len ) ){
2367
2368 DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
2369 "but should be %u bytes\n",
2370 (unsigned)indata.dsize,
2371 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+pub->len)));
2372 return -1;
2373 }
2374
2375 DEBUG(DEBUG_NOTICE,("Add IP %s\n", ctdb_addr_to_str(&pub->addr)));
2376
2377 ret = ctdb_add_public_address(ctdb, &pub->addr, pub->mask, &pub->iface[0]);
2378
2379 if (ret != 0) {
2380 DEBUG(DEBUG_ERR,(__location__ " Failed to add public address\n"));
2381 return -1;
2382 }
2383
2384 return 0;
2385 }
2386
2387 int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
2388 {
2389 struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
2390 struct ctdb_vnn *vnn;
2391
2392 /* verify the size of indata */
2393 if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
2394 DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_addr_info structure\n"));
2395 return -1;
2396 }
2397 if (indata.dsize !=
2398 ( offsetof(struct ctdb_addr_info_old, iface)
2399 + pub->len ) ){
2400
2401 DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
2402 "but should be %u bytes\n",
2403 (unsigned)indata.dsize,
2404 (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+pub->len)));
2405 return -1;
2406 }
2407
2408 DEBUG(DEBUG_NOTICE,("Delete IP %s\n", ctdb_addr_to_str(&pub->addr)));
2409
2410 vnn = find_public_ip_vnn(ctdb, &pub->addr);
2411 if (vnn == NULL) {
2412 D_ERR("Delete IP of unknown public IP address %s\n",
2413 ctdb_addr_to_str(&pub->addr));
2414 return -1;
2415 }
2416
2417 if (vnn->pnn == ctdb->pnn) {
2418 /*
2419 * This IP is currently being hosted. Defer the
2420 * deletion until the next takeover run. "ctdb
2421 * reloadips" will always cause a takeover run. "ctdb
2422 * delip" will now need an explicit "ctdb
2423 * ipreallocated" afterwards.
2424 */
2425 vnn->delete_pending = true;
2426 } else {
2427 /*
2428 * This IP is not hosted on the current node so just
2429 * delete it now.
2430 */
2431 do_delete_ip(ctdb, vnn);
2432 }
2433
2434 return 0;
2435 }
2436
2437
2438 struct ipreallocated_callback_state {
2439 struct ctdb_req_control_old *c;
2440 };
2441
2442 static void ctdb_ipreallocated_callback(struct ctdb_context *ctdb,
2443 int status, void *p)
2444 {
2445 struct ipreallocated_callback_state *state =
2446 talloc_get_type(p, struct ipreallocated_callback_state);
2447 TDB_DATA data = { .dsize = 0, };
2448
2449 if (status != 0) {
2450 DEBUG(DEBUG_ERR,
2451 (" \"ipreallocated\" event script failed (status %d)\n",
2452 status));
2453 if (status == -ETIMEDOUT) {
2454 ctdb_ban_self(ctdb);
2455 }
2456 }
2457
2458 D_INFO("Sending IPREALLOCATED message\n");
2459 ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_IPREALLOCATED, data);
2460
2461 ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
2462 talloc_free(state);
2463 }
2464
2465 /* A control to run the ipreallocated event */
2466 int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
2467 struct ctdb_req_control_old *c,
2468 bool *async_reply)
2469 {
2470 int ret;
2471 struct ipreallocated_callback_state *state;
2472
2473 state = talloc(ctdb, struct ipreallocated_callback_state);
2474 CTDB_NO_MEMORY(ctdb, state);
2475
2476 DEBUG(DEBUG_INFO,(__location__ " Running \"ipreallocated\" event\n"));
2477
2478 ret = ctdb_event_script_callback(ctdb, state,
2479 ctdb_ipreallocated_callback, state,
2480 CTDB_EVENT_IPREALLOCATED,
2481 "%s", "");
2482
2483 if (ret != 0) {
2484 DEBUG(DEBUG_ERR,("Failed to run \"ipreallocated\" event \n"));
2485 talloc_free(state);
2486 return -1;
2487 }
2488
2489 /* tell the control that we will be reply asynchronously */
2490 state->c = talloc_steal(state, c);
2491 *async_reply = true;
2492
2493 return 0;
2494 }
2495
2496
2497 struct start_ipreallocate_callback_state {
2498 struct ctdb_req_control_old *c;
2499 };
2500
2501 static void ctdb_start_ipreallocate_callback(struct ctdb_context *ctdb,
2502 int status, void *p)
2503 {
2504 struct start_ipreallocate_callback_state *state = talloc_get_type_abort(
2505 p, struct start_ipreallocate_callback_state);
2506 TDB_DATA data = { .dsize = 0, };
2507
2508 if (status != 0) {
2509 D_ERR("\"startipreallocate\" event failed (status %d)\n",
2510 status);
2511 if (status == -ETIMEDOUT) {
2512 ctdb_ban_self(ctdb);
2513 }
2514 }
2515
2516 D_INFO("Sending START_IPREALLOCATE message\n");
2517 ctdb_daemon_send_message(ctdb,
2518 ctdb->pnn,
2519 CTDB_SRVID_START_IPREALLOCATE,
2520 data);
2521
2522 ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
2523 talloc_free(state);
2524 }
2525
2526 /* A control to run the startipreallocate event */
2527 int32_t ctdb_control_start_ipreallocate(struct ctdb_context *ctdb,
2528 struct ctdb_req_control_old *c,
2529 bool *async_reply)
2530 {
2531 int ret;
2532 struct start_ipreallocate_callback_state *state;
2533
2534 /* Nodes that are not RUNNING can not host IPs */
2535 if (ctdb->runstate != CTDB_RUNSTATE_RUNNING) {
2536 DBG_INFO("Skipping \"startipreallocate\" event, not RUNNING\n");
2537 return 0;
2538 }
2539
2540 state = talloc(ctdb, struct start_ipreallocate_callback_state);
2541 if (state == NULL) {
2542 DBG_ERR("Memory allocation error\n");
2543 return -1;
2544 }
2545
2546 DBG_INFO("Running \"startipreallocate\" event\n");
2547
2548 ret = ctdb_event_script_callback(ctdb,
2549 state,
2550 ctdb_start_ipreallocate_callback,
2551 state,
2552 CTDB_EVENT_START_IPREALLOCATE,
2553 "%s",
2554 "");
2555
2556 if (ret != 0) {
2557 D_ERR("Failed to run \"startipreallocate\" event \n");
2558 talloc_free(state);
2559 return -1;
2560 }
2561
2562 /* tell the control that we will be reply asynchronously */
2563 state->c = talloc_steal(state, c);
2564 *async_reply = true;
2565
2566 return 0;
2567 }
2568
2569
2570 struct ctdb_reloadips_handle {
2571 struct ctdb_context *ctdb;
2572 struct ctdb_req_control_old *c;
2573 int status;
2574 int fd[2];
2575 pid_t child;
2576 struct tevent_fd *fde;
2577 };
2578
2579 static int ctdb_reloadips_destructor(struct ctdb_reloadips_handle *h)
2580 {
2581 if (h == h->ctdb->reload_ips) {
2582 h->ctdb->reload_ips = NULL;
2583 }
2584 if (h->c != NULL) {
2585 ctdb_request_control_reply(h->ctdb, h->c, NULL, h->status, NULL);
2586 h->c = NULL;
2587 }
2588 ctdb_kill(h->ctdb, h->child, SIGKILL);
2589 return 0;
2590 }
2591
2592 static void ctdb_reloadips_timeout_event(struct tevent_context *ev,
2593 struct tevent_timer *te,
2594 struct timeval t, void *private_data)
2595 {
2596 struct ctdb_reloadips_handle *h = talloc_get_type(private_data, struct ctdb_reloadips_handle);
2597
2598 talloc_free(h);
2599 }
2600
2601 static void ctdb_reloadips_child_handler(struct tevent_context *ev,
2602 struct tevent_fd *fde,
2603 uint16_t flags, void *private_data)
2604 {
2605 struct ctdb_reloadips_handle *h = talloc_get_type(private_data, struct ctdb_reloadips_handle);
2606
2607 char res;
2608 int ret;
2609
2610 ret = sys_read(h->fd[0], &res, 1);
2611 if (ret < 1 || res != 0) {
2612 DEBUG(DEBUG_ERR, (__location__ " Reloadips child process returned error\n"));
2613 res = 1;
2614 }
2615 h->status = res;
2616
2617 talloc_free(h);
2618 }
2619
2620 static int ctdb_reloadips_child(struct ctdb_context *ctdb)
2621 {
2622 TALLOC_CTX *mem_ctx = talloc_new(NULL);
2623 struct ctdb_public_ip_list_old *ips;
2624 struct ctdb_vnn *vnn;
2625 struct client_async_data *async_data;
2626 struct timeval timeout;
2627 TDB_DATA data;
2628 struct ctdb_client_control_state *state;
2629 bool first_add;
2630 unsigned int i;
2631 int ret;
2632
2633 CTDB_NO_MEMORY(ctdb, mem_ctx);
2634
2635 /* Read IPs from local node */
2636 ret = ctdb_ctrl_get_public_ips(ctdb, TAKEOVER_TIMEOUT(),
2637 CTDB_CURRENT_NODE, mem_ctx, &ips);
2638 if (ret != 0) {
2639 DEBUG(DEBUG_ERR,
2640 ("Unable to fetch public IPs from local node\n"));
2641 talloc_free(mem_ctx);
2642 return -1;
2643 }
2644
2645 /* Read IPs file - this is safe since this is a child process */
2646 ctdb->vnn = NULL;
2647 if (ctdb_set_public_addresses(ctdb) != 0) {
2648 DEBUG(DEBUG_ERR,("Failed to re-read public addresses file\n"));
2649 talloc_free(mem_ctx);
2650 return -1;
2651 }
2652
2653 async_data = talloc_zero(mem_ctx, struct client_async_data);
2654 CTDB_NO_MEMORY(ctdb, async_data);
2655
2656 /* Compare IPs between node and file for IPs to be deleted */
2657 for (i = 0; i < ips->num; i++) {
2658 struct ctdb_addr_info_old *pub = NULL;
2659
2660 vnn = find_public_ip_vnn(ctdb, &ips->ips[i].addr);
2661 if (vnn != NULL) {
2662 /* IP is still in file */
2663 continue;
2664 }
2665
2666 /*
2667 * Delete IP ips->ips[i]
2668 */
2669
2670 D_NOTICE("IP %s no longer configured, deleting it\n",
2671 ctdb_addr_to_str(&ips->ips[i].addr));
2672
2673 pub = talloc_zero(mem_ctx, struct ctdb_addr_info_old);
2674 CTDB_NO_MEMORY(ctdb, pub);
2675
2676 pub->addr = ips->ips[i].addr;
2677 pub->mask = 0;
2678 pub->len = 0;
2679
2680 timeout = TAKEOVER_TIMEOUT();
2681
2682 data.dsize = offsetof(struct ctdb_addr_info_old,
2683 iface) + pub->len;
2684 data.dptr = (uint8_t *)pub;
2685
2686 state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, 0,
2687 CTDB_CONTROL_DEL_PUBLIC_IP,
2688 0, data, async_data,
2689 &timeout, NULL);
2690 if (state == NULL) {
2691 DBG_ERR("Failed sending CTDB_CONTROL_DEL_PUBLIC_IP\n");
2692 goto failed;
2693 }
2694
2695 ctdb_client_async_add(async_data, state);
2696 }
2697
2698 /* Compare IPs between node and file for IPs to be added */
2699 first_add = true;
2700 for (vnn = ctdb->vnn; vnn; vnn = vnn->next) {
2701 for (i = 0; i < ips->num; i++) {
2702 if (ctdb_same_ip(&vnn->public_address,
2703 &ips->ips[i].addr)) {
2704 /* IP already on node */
2705 break;
2706 }
2707 }
2708 if (i == ips->num) {
2709 /* Add IP ips->ips[i] */
2710 struct ctdb_addr_info_old *pub;
2711 const char *ifaces = NULL;
2712 uint32_t len;
2713 struct vnn_interface *iface = NULL;
2714
2715 D_NOTICE("New IP %s configured, adding it\n",
2716 ctdb_vnn_address_string(vnn));
2717 if (first_add) {
2718 uint32_t pnn = ctdb_get_pnn(ctdb);
2719
2720 data.dsize = sizeof(pnn);
2721 data.dptr = (uint8_t *)&pnn;
2722
2723 ret = ctdb_client_send_message(
2724 ctdb,
2725 CTDB_BROADCAST_CONNECTED,
2726 CTDB_SRVID_REBALANCE_NODE,
2727 data);
2728 if (ret != 0) {
2729 DEBUG(DEBUG_WARNING,
2730 ("Failed to send message to force node reallocation - IPs may be unbalanced\n"));
2731 }
2732
2733 first_add = false;
2734 }
2735
2736 ifaces = vnn->ifaces->iface->name;
2737 iface = vnn->ifaces->next;
2738 while (iface != NULL) {
2739 ifaces = talloc_asprintf(vnn, "%s,%s", ifaces,
2740 iface->iface->name);
2741 iface = iface->next;
2742 }
2743
2744 len = strlen(ifaces) + 1;
2745 pub = talloc_zero_size(mem_ctx,
2746 offsetof(struct ctdb_addr_info_old, iface) + len);
2747 CTDB_NO_MEMORY(ctdb, pub);
2748
2749 pub->addr = vnn->public_address;
2750 pub->mask = vnn->public_netmask_bits;
2751 pub->len = len;
2752 memcpy(&pub->iface[0], ifaces, pub->len);
2753
2754 timeout = TAKEOVER_TIMEOUT();
2755
2756 data.dsize = offsetof(struct ctdb_addr_info_old,
2757 iface) + pub->len;
2758 data.dptr = (uint8_t *)pub;
2759
2760 state = ctdb_control_send(ctdb, CTDB_CURRENT_NODE, 0,
2761 CTDB_CONTROL_ADD_PUBLIC_IP,
2762 0, data, async_data,
2763 &timeout, NULL);
2764 if (state == NULL) {
2765 DEBUG(DEBUG_ERR,
2766 (__location__
2767 " failed sending CTDB_CONTROL_ADD_PUBLIC_IP\n"));
2768 goto failed;
2769 }
2770
2771 ctdb_client_async_add(async_data, state);
2772 }
2773 }
2774
2775 if (ctdb_client_async_wait(ctdb, async_data) != 0) {
2776 DEBUG(DEBUG_ERR,(__location__ " Add/delete IPs failed\n"));
2777 goto failed;
2778 }
2779
2780 talloc_free(mem_ctx);
2781 return 0;
2782
2783 failed:
2784 talloc_free(mem_ctx);
2785 return -1;
2786 }
2787
2788 /* This control is sent to force the node to re-read the public addresses file
2789 and drop any addresses we should nnot longer host, and add new addresses
2790 that we are now able to host
2791 */
2792 int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control_old *c, bool *async_reply)
2793 {
2794 struct ctdb_reloadips_handle *h;
2795 pid_t parent = getpid();
2796
2797 if (ctdb->reload_ips != NULL) {
2798 talloc_free(ctdb->reload_ips);
2799 ctdb->reload_ips = NULL;
2800 }
2801
2802 h = talloc(ctdb, struct ctdb_reloadips_handle);
2803 CTDB_NO_MEMORY(ctdb, h);
2804 h->ctdb = ctdb;
2805 h->c = NULL;
2806 h->status = -1;
2807
2808 if (pipe(h->fd) == -1) {
2809 DEBUG(DEBUG_ERR,("Failed to create pipe for ctdb_freeze_lock\n"));
2810 talloc_free(h);
2811 return -1;
2812 }
2813
2814 h->child = ctdb_fork(ctdb);
2815 if (h->child == (pid_t)-1) {
2816 DEBUG(DEBUG_ERR, ("Failed to fork a child for reloadips\n"));
2817 close(h->fd[0]);
2818 close(h->fd[1]);
2819 talloc_free(h);
2820 return -1;
2821 }
2822
2823 /* child process */
2824 if (h->child == 0) {
2825 signed char res = 0;
2826
2827 close(h->fd[0]);
2828
2829 prctl_set_comment("ctdb_reloadips");
2830 if (switch_from_server_to_client(ctdb) != 0) {
2831 DEBUG(DEBUG_CRIT,("ERROR: Failed to switch reloadips child into client mode\n"));
2832 res = -1;
2833 } else {
2834 res = ctdb_reloadips_child(ctdb);
2835 if (res != 0) {
2836 DEBUG(DEBUG_ERR,("Failed to reload ips on local node\n"));
2837 }
2838 }
2839
2840 sys_write(h->fd[1], &res, 1);
2841 ctdb_wait_for_process_to_exit(parent);
2842 _exit(0);
2843 }
2844
2845 h->c = talloc_steal(h, c);
2846
2847 close(h->fd[1]);
2848 set_close_on_exec(h->fd[0]);
2849
2850 talloc_set_destructor(h, ctdb_reloadips_destructor);
2851
2852
2853 h->fde = tevent_add_fd(ctdb->ev, h, h->fd[0], TEVENT_FD_READ,
2854 ctdb_reloadips_child_handler, (void *)h);
2855 tevent_fd_set_auto_close(h->fde);
2856
2857 tevent_add_timer(ctdb->ev, h, timeval_current_ofs(120, 0),
2858 ctdb_reloadips_timeout_event, h);
2859
2860 /* we reply later */
2861 *async_reply = true;
2862 return 0;
2863 }
GSS-enabled samba4