1 /*
2 ctdb utility code
3
4 Copyright (C) Andrew Tridgell 2006
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "replace.h"
21 #include "system/network.h"
22 #include "system/filesys.h"
23 #include "system/wait.h"
24
25 #include <tdb.h>
26
27 #include "lib/util/debug.h"
28 #include "lib/util/samba_util.h"
29
30 #include "ctdb_private.h"
31
32 #include "protocol/protocol_util.h"
33
34 #include "common/reqid.h"
35 #include "common/system.h"
36 #include "common/common.h"
37 #include "common/logging.h"
38
39 /*
40 return error string for last error
41 */
ctdb_errstr(struct ctdb_context * ctdb)42 const char *ctdb_errstr(struct ctdb_context *ctdb)
43 {
44 return ctdb->err_msg;
45 }
46
47
48 /*
49 remember an error message
50 */
ctdb_set_error(struct ctdb_context * ctdb,const char * fmt,...)51 void ctdb_set_error(struct ctdb_context *ctdb, const char *fmt, ...)
52 {
53 va_list ap;
54 talloc_free(ctdb->err_msg);
55 va_start(ap, fmt);
56 ctdb->err_msg = talloc_vasprintf(ctdb, fmt, ap);
57 DEBUG(DEBUG_ERR,("ctdb error: %s\n", ctdb->err_msg));
58 va_end(ap);
59 }
60
61 /*
62 a fatal internal error occurred - no hope for recovery
63 */
ctdb_fatal(struct ctdb_context * ctdb,const char * msg)64 void ctdb_fatal(struct ctdb_context *ctdb, const char *msg)
65 {
66 DEBUG(DEBUG_ALERT,("ctdb fatal error: %s\n", msg));
67 abort();
68 }
69
70 /*
71 like ctdb_fatal() but a core/backtrace would not be useful
72 */
ctdb_die(struct ctdb_context * ctdb,const char * msg)73 void ctdb_die(struct ctdb_context *ctdb, const char *msg)
74 {
75 DEBUG(DEBUG_ALERT,("ctdb exiting with error: %s\n", msg));
76 exit(1);
77 }
78
79 /* Set the path of a helper program from envvar, falling back to
80 * dir/file if envvar unset. type is a string to print in log
81 * messages. helper is assumed to point to a statically allocated
82 * array of size bytes, initialised to "". If file is NULL don't fall
83 * back if envvar is unset. If dir is NULL and envvar is unset (but
84 * file is not NULL) then this is an error. Returns true if helper is
85 * set, either previously or this time. */
ctdb_set_helper(const char * type,char * helper,size_t size,const char * envvar,const char * dir,const char * file)86 bool ctdb_set_helper(const char *type, char *helper, size_t size,
87 const char *envvar,
88 const char *dir, const char *file)
89 {
90 const char *t;
91 struct stat st;
92
93 if (helper[0] != '\0') {
94 /* Already set */
95 return true;
96 }
97
98 t = getenv(envvar);
99 if (t != NULL) {
100 if (strlen(t) >= size) {
101 DEBUG(DEBUG_ERR,
102 ("Unable to set %s - path too long\n", type));
103 return false;
104 }
105
106 strncpy(helper, t, size);
107 } else if (file == NULL) {
108 return false;
109 } else if (dir == NULL) {
110 DEBUG(DEBUG_ERR,
111 ("Unable to set %s - dir is NULL\n", type));
112 return false;
113 } else {
114 int ret;
115
116 ret = snprintf(helper, size, "%s/%s", dir, file);
117 if (ret < 0 || (size_t)ret >= size) {
118 DEBUG(DEBUG_ERR,
119 ("Unable to set %s - path too long\n", type));
120 return false;
121 }
122 }
123
124 if (stat(helper, &st) != 0) {
125 DEBUG(DEBUG_ERR,
126 ("Unable to set %s \"%s\" - %s\n",
127 type, helper, strerror(errno)));
128 return false;
129 }
130 if (!(st.st_mode & S_IXUSR)) {
131 DEBUG(DEBUG_ERR,
132 ("Unable to set %s \"%s\" - not executable\n",
133 type, helper));
134 return false;
135 }
136
137 DEBUG(DEBUG_NOTICE,
138 ("Set %s to \"%s\"\n", type, helper));
139 return true;
140 }
141
142 /*
143 parse a IP:port pair
144 */
ctdb_parse_address(TALLOC_CTX * mem_ctx,const char * str,ctdb_sock_addr * address)145 int ctdb_parse_address(TALLOC_CTX *mem_ctx, const char *str,
146 ctdb_sock_addr *address)
147 {
148 struct servent *se;
149 int port;
150 int ret;
151
152 setservent(0);
153 se = getservbyname("ctdb", "tcp");
154 endservent();
155
156 if (se == NULL) {
157 port = CTDB_PORT;
158 } else {
159 port = ntohs(se->s_port);
160 }
161
162 ret = ctdb_sock_addr_from_string(str, address, false);
163 if (ret != 0) {
164 return -1;
165 }
166 ctdb_sock_addr_set_port(address, port);
167
168 return 0;
169 }
170
171
172 /*
173 check if two addresses are the same
174 */
ctdb_same_address(ctdb_sock_addr * a1,ctdb_sock_addr * a2)175 bool ctdb_same_address(ctdb_sock_addr *a1, ctdb_sock_addr *a2)
176 {
177 return ctdb_same_ip(a1, a2) &&
178 ctdb_addr_to_port(a1) == ctdb_addr_to_port(a2);
179 }
180
181
182 /*
183 hash function for mapping data to a VNN - taken from tdb
184 */
ctdb_hash(const TDB_DATA * key)185 uint32_t ctdb_hash(const TDB_DATA *key)
186 {
187 return tdb_jenkins_hash(discard_const(key));
188 }
189
190
ctdb_marshall_record_size(TDB_DATA key,struct ctdb_ltdb_header * header,TDB_DATA data)191 static uint32_t ctdb_marshall_record_size(TDB_DATA key,
192 struct ctdb_ltdb_header *header,
193 TDB_DATA data)
194 {
195 return offsetof(struct ctdb_rec_data_old, data) + key.dsize +
196 data.dsize + (header ? sizeof(*header) : 0);
197 }
198
ctdb_marshall_record_copy(struct ctdb_rec_data_old * rec,uint32_t reqid,TDB_DATA key,struct ctdb_ltdb_header * header,TDB_DATA data,uint32_t length)199 static void ctdb_marshall_record_copy(struct ctdb_rec_data_old *rec,
200 uint32_t reqid,
201 TDB_DATA key,
202 struct ctdb_ltdb_header *header,
203 TDB_DATA data,
204 uint32_t length)
205 {
206 uint32_t offset;
207
208 rec->length = length;
209 rec->reqid = reqid;
210 rec->keylen = key.dsize;
211 memcpy(&rec->data[0], key.dptr, key.dsize);
212 offset = key.dsize;
213
214 if (header) {
215 rec->datalen = data.dsize + sizeof(*header);
216 memcpy(&rec->data[offset], header, sizeof(*header));
217 offset += sizeof(*header);
218 } else {
219 rec->datalen = data.dsize;
220 }
221 memcpy(&rec->data[offset], data.dptr, data.dsize);
222 }
223
224 /*
225 form a ctdb_rec_data record from a key/data pair
226
227 note that header may be NULL. If not NULL then it is included in the data portion
228 of the record
229 */
ctdb_marshall_record(TALLOC_CTX * mem_ctx,uint32_t reqid,TDB_DATA key,struct ctdb_ltdb_header * header,TDB_DATA data)230 struct ctdb_rec_data_old *ctdb_marshall_record(TALLOC_CTX *mem_ctx,
231 uint32_t reqid,
232 TDB_DATA key,
233 struct ctdb_ltdb_header *header,
234 TDB_DATA data)
235 {
236 size_t length;
237 struct ctdb_rec_data_old *d;
238
239 length = ctdb_marshall_record_size(key, header, data);
240
241 d = (struct ctdb_rec_data_old *)talloc_size(mem_ctx, length);
242 if (d == NULL) {
243 return NULL;
244 }
245
246 ctdb_marshall_record_copy(d, reqid, key, header, data, length);
247 return d;
248 }
249
250
251 /* helper function for marshalling multiple records */
ctdb_marshall_add(TALLOC_CTX * mem_ctx,struct ctdb_marshall_buffer * m,uint32_t db_id,uint32_t reqid,TDB_DATA key,struct ctdb_ltdb_header * header,TDB_DATA data)252 struct ctdb_marshall_buffer *ctdb_marshall_add(TALLOC_CTX *mem_ctx,
253 struct ctdb_marshall_buffer *m,
254 uint32_t db_id,
255 uint32_t reqid,
256 TDB_DATA key,
257 struct ctdb_ltdb_header *header,
258 TDB_DATA data)
259 {
260 struct ctdb_rec_data_old *r;
261 struct ctdb_marshall_buffer *m2;
262 uint32_t length, offset;
263
264 length = ctdb_marshall_record_size(key, header, data);
265
266 if (m == NULL) {
267 offset = offsetof(struct ctdb_marshall_buffer, data);
268 m2 = talloc_zero_size(mem_ctx, offset + length);
269 } else {
270 offset = talloc_get_size(m);
271 m2 = talloc_realloc_size(mem_ctx, m, offset + length);
272 }
273 if (m2 == NULL) {
274 TALLOC_FREE(m);
275 return NULL;
276 }
277
278 if (m == NULL) {
279 m2->db_id = db_id;
280 }
281
282 r = (struct ctdb_rec_data_old *)((uint8_t *)m2 + offset);
283 ctdb_marshall_record_copy(r, reqid, key, header, data, length);
284 m2->count++;
285
286 return m2;
287 }
288
289 /* we've finished marshalling, return a data blob with the marshalled records */
ctdb_marshall_finish(struct ctdb_marshall_buffer * m)290 TDB_DATA ctdb_marshall_finish(struct ctdb_marshall_buffer *m)
291 {
292 TDB_DATA data;
293 data.dptr = (uint8_t *)m;
294 data.dsize = talloc_get_size(m);
295 return data;
296 }
297
298 /*
299 loop over a marshalling buffer
300
301 - pass r==NULL to start
302 - loop the number of times indicated by m->count
303 */
ctdb_marshall_loop_next(struct ctdb_marshall_buffer * m,struct ctdb_rec_data_old * r,uint32_t * reqid,struct ctdb_ltdb_header * header,TDB_DATA * key,TDB_DATA * data)304 struct ctdb_rec_data_old *ctdb_marshall_loop_next(
305 struct ctdb_marshall_buffer *m,
306 struct ctdb_rec_data_old *r,
307 uint32_t *reqid,
308 struct ctdb_ltdb_header *header,
309 TDB_DATA *key, TDB_DATA *data)
310 {
311 if (r == NULL) {
312 r = (struct ctdb_rec_data_old *)&m->data[0];
313 } else {
314 r = (struct ctdb_rec_data_old *)(r->length + (uint8_t *)r);
315 }
316
317 if (reqid != NULL) {
318 *reqid = r->reqid;
319 }
320
321 if (key != NULL) {
322 key->dptr = &r->data[0];
323 key->dsize = r->keylen;
324 }
325 if (data != NULL) {
326 data->dptr = &r->data[r->keylen];
327 data->dsize = r->datalen;
328 if (header != NULL) {
329 data->dptr += sizeof(*header);
330 data->dsize -= sizeof(*header);
331 }
332 }
333
334 if (header != NULL) {
335 if (r->datalen < sizeof(*header)) {
336 return NULL;
337 }
338 memcpy(header, &r->data[r->keylen], sizeof(*header));
339 }
340
341 return r;
342 }
343
344 /*
345 This is used to canonicalize a ctdb_sock_addr structure.
346 */
ctdb_canonicalize_ip(const ctdb_sock_addr * ip,ctdb_sock_addr * cip)347 void ctdb_canonicalize_ip(const ctdb_sock_addr *ip, ctdb_sock_addr *cip)
348 {
349 ZERO_STRUCTP(cip);
350
351 if (ip->sa.sa_family == AF_INET6) {
352 const char prefix[12] = { 0,0,0,0,0,0,0,0,0,0,0xff,0xff };
353 if (memcmp(&ip->ip6.sin6_addr, prefix, sizeof(prefix)) == 0) {
354 /* Copy IPv4-mapped IPv6 addresses as IPv4 */
355 cip->ip.sin_family = AF_INET;
356 #ifdef HAVE_SOCK_SIN_LEN
357 cip->ip.sin_len = sizeof(ctdb_sock_addr);
358 #endif
359 cip->ip.sin_port = ip->ip6.sin6_port;
360 memcpy(&cip->ip.sin_addr,
361 &ip->ip6.sin6_addr.s6_addr[12],
362 sizeof(cip->ip.sin_addr));
363 } else {
364 cip->ip6.sin6_family = AF_INET6;
365 #ifdef HAVE_SOCK_SIN6_LEN
366 cip->ip6.sin6_len = sizeof(ctdb_sock_addr);
367 #endif
368 cip->ip6.sin6_port = ip->ip6.sin6_port;
369 memcpy(&cip->ip6.sin6_addr,
370 &ip->ip6.sin6_addr,
371 sizeof(cip->ip6.sin6_addr));
372 }
373
374 return;
375 }
376
377 if (ip->sa.sa_family == AF_INET) {
378 cip->ip.sin_family = AF_INET;
379 #ifdef HAVE_SOCK_SIN_LEN
380 cip->ip.sin_len = sizeof(ctdb_sock_addr);
381 #endif
382 cip->ip.sin_port = ip->ip.sin_port;
383 memcpy(&cip->ip.sin_addr,
384 &ip->ip.sin_addr,
385 sizeof(ip->ip.sin_addr));
386
387 return;
388 }
389 }
390
ctdb_same_ip(const ctdb_sock_addr * tip1,const ctdb_sock_addr * tip2)391 bool ctdb_same_ip(const ctdb_sock_addr *tip1, const ctdb_sock_addr *tip2)
392 {
393 ctdb_sock_addr ip1, ip2;
394
395 ctdb_canonicalize_ip(tip1, &ip1);
396 ctdb_canonicalize_ip(tip2, &ip2);
397
398 if (ip1.sa.sa_family != ip2.sa.sa_family) {
399 return false;
400 }
401
402 switch (ip1.sa.sa_family) {
403 case AF_INET:
404 return ip1.ip.sin_addr.s_addr == ip2.ip.sin_addr.s_addr;
405 case AF_INET6:
406 return !memcmp(&ip1.ip6.sin6_addr.s6_addr[0],
407 &ip2.ip6.sin6_addr.s6_addr[0],
408 16);
409 default:
410 DEBUG(DEBUG_ERR, (__location__ " CRITICAL Can not compare sockaddr structures of type %u\n", ip1.sa.sa_family));
411 return false;
412 }
413
414 return true;
415 }
416
417 /*
418 compare two ctdb_sock_addr structures
419 */
ctdb_same_sockaddr(const ctdb_sock_addr * ip1,const ctdb_sock_addr * ip2)420 bool ctdb_same_sockaddr(const ctdb_sock_addr *ip1, const ctdb_sock_addr *ip2)
421 {
422 return ctdb_same_ip(ip1, ip2) && ip1->ip.sin_port == ip2->ip.sin_port;
423 }
424
ctdb_addr_to_str(ctdb_sock_addr * addr)425 char *ctdb_addr_to_str(ctdb_sock_addr *addr)
426 {
427 static char cip[128] = "";
428
429 switch (addr->sa.sa_family) {
430 case AF_INET:
431 inet_ntop(addr->ip.sin_family, &addr->ip.sin_addr, cip, sizeof(cip));
432 break;
433 case AF_INET6:
434 inet_ntop(addr->ip6.sin6_family, &addr->ip6.sin6_addr, cip, sizeof(cip));
435 break;
436 default:
437 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family %u\n", addr->sa.sa_family));
438 }
439
440 return cip;
441 }
442
ctdb_addr_to_port(ctdb_sock_addr * addr)443 unsigned ctdb_addr_to_port(ctdb_sock_addr *addr)
444 {
445 switch (addr->sa.sa_family) {
446 case AF_INET:
447 return ntohs(addr->ip.sin_port);
448 break;
449 case AF_INET6:
450 return ntohs(addr->ip6.sin6_port);
451 break;
452 default:
453 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family %u\n", addr->sa.sa_family));
454 }
455
456 return 0;
457 }
458
459 /* Add a node to a node map with given address and flags */
node_map_add(TALLOC_CTX * mem_ctx,const char * nstr,uint32_t flags,struct ctdb_node_map_old ** node_map)460 static bool node_map_add(TALLOC_CTX *mem_ctx,
461 const char *nstr, uint32_t flags,
462 struct ctdb_node_map_old **node_map)
463 {
464 ctdb_sock_addr addr;
465 uint32_t num;
466 size_t s;
467 struct ctdb_node_and_flags *n;
468
469 /* Might as well do this before trying to allocate memory */
470 if (ctdb_parse_address(mem_ctx, nstr, &addr) == -1) {
471 return false;
472 }
473
474 num = (*node_map)->num + 1;
475 s = offsetof(struct ctdb_node_map_old, nodes) +
476 num * sizeof(struct ctdb_node_and_flags);
477 *node_map = talloc_realloc_size(mem_ctx, *node_map, s);
478 if (*node_map == NULL) {
479 DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
480 return false;
481 }
482
483 n = &(*node_map)->nodes[(*node_map)->num];
484 n->addr = addr;
485 n->pnn = (*node_map)->num;
486 n->flags = flags;
487
488 (*node_map)->num++;
489
490 return true;
491 }
492
493 /* Read a nodes file into a node map */
ctdb_read_nodes_file(TALLOC_CTX * mem_ctx,const char * nlist)494 struct ctdb_node_map_old *ctdb_read_nodes_file(TALLOC_CTX *mem_ctx,
495 const char *nlist)
496 {
497 char **lines;
498 int nlines;
499 int i;
500 struct ctdb_node_map_old *ret;
501
502 /* Allocate node map header */
503 ret = talloc_zero_size(mem_ctx, offsetof(struct ctdb_node_map_old, nodes));
504 if (ret == NULL) {
505 DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
506 return false;
507 }
508
509 lines = file_lines_load(nlist, &nlines, 0, mem_ctx);
510 if (lines == NULL) {
511 DEBUG(DEBUG_ERR, ("Failed to read nodes file \"%s\"\n", nlist));
512 return false;
513 }
514 while (nlines > 0 && strcmp(lines[nlines-1], "") == 0) {
515 nlines--;
516 }
517
518 for (i=0; i < nlines; i++) {
519 char *node;
520 uint32_t flags;
521 size_t len;
522
523 node = lines[i];
524 /* strip leading spaces */
525 while((*node == ' ') || (*node == '\t')) {
526 node++;
527 }
528
529 len = strlen(node);
530
531 while ((len > 1) &&
532 ((node[len-1] == ' ') || (node[len-1] == '\t')))
533 {
534 node[len-1] = '\0';
535 len--;
536 }
537
538 if (len == 0) {
539 continue;
540 }
541 if (*node == '#') {
542 /* A "deleted" node is a node that is
543 commented out in the nodes file. This is
544 used instead of removing a line, which
545 would cause subsequent nodes to change
546 their PNN. */
547 flags = NODE_FLAGS_DELETED;
548 node = discard_const("0.0.0.0");
549 } else {
550 flags = 0;
551 }
552 if (!node_map_add(mem_ctx, node, flags, &ret)) {
553 talloc_free(lines);
554 TALLOC_FREE(ret);
555 return NULL;
556 }
557 }
558
559 talloc_free(lines);
560 return ret;
561 }
562
563 struct ctdb_node_map_old *
ctdb_node_list_to_map(struct ctdb_node ** nodes,uint32_t num_nodes,TALLOC_CTX * mem_ctx)564 ctdb_node_list_to_map(struct ctdb_node **nodes, uint32_t num_nodes,
565 TALLOC_CTX *mem_ctx)
566 {
567 uint32_t i;
568 size_t size;
569 struct ctdb_node_map_old *node_map;
570
571 size = offsetof(struct ctdb_node_map_old, nodes) +
572 num_nodes * sizeof(struct ctdb_node_and_flags);
573 node_map = (struct ctdb_node_map_old *)talloc_zero_size(mem_ctx, size);
574 if (node_map == NULL) {
575 DEBUG(DEBUG_ERR,
576 (__location__ " Failed to allocate nodemap array\n"));
577 return NULL;
578 }
579
580 node_map->num = num_nodes;
581 for (i=0; i<num_nodes; i++) {
582 node_map->nodes[i].addr = nodes[i]->address;
583 node_map->nodes[i].pnn = nodes[i]->pnn;
584 node_map->nodes[i].flags = nodes[i]->flags;
585 }
586
587 return node_map;
588 }
589
590 const char *ctdb_eventscript_call_names[] = {
591 "init",
592 "setup",
593 "startup",
594 "startrecovery",
595 "recovered",
596 "takeip",
597 "releaseip",
598 "stopped",
599 "monitor",
600 "status",
601 "shutdown",
602 "reload",
603 "updateip",
604 "ipreallocated"
605 };
606
607 /* Runstate handling */
608 static struct {
609 enum ctdb_runstate runstate;
610 const char * label;
611 } runstate_map[] = {
612 { CTDB_RUNSTATE_UNKNOWN, "UNKNOWN" },
613 { CTDB_RUNSTATE_INIT, "INIT" },
614 { CTDB_RUNSTATE_SETUP, "SETUP" },
615 { CTDB_RUNSTATE_FIRST_RECOVERY, "FIRST_RECOVERY" },
616 { CTDB_RUNSTATE_STARTUP, "STARTUP" },
617 { CTDB_RUNSTATE_RUNNING, "RUNNING" },
618 { CTDB_RUNSTATE_SHUTDOWN, "SHUTDOWN" },
619 { -1, NULL },
620 };
621
runstate_to_string(enum ctdb_runstate runstate)622 const char *runstate_to_string(enum ctdb_runstate runstate)
623 {
624 int i;
625 for (i=0; runstate_map[i].label != NULL ; i++) {
626 if (runstate_map[i].runstate == runstate) {
627 return runstate_map[i].label;
628 }
629 }
630
631 return runstate_map[0].label;
632 }
633
runstate_from_string(const char * label)634 enum ctdb_runstate runstate_from_string(const char *label)
635 {
636 int i;
637 for (i=0; runstate_map[i].label != NULL; i++) {
638 if (strcasecmp(runstate_map[i].label, label) == 0) {
639 return runstate_map[i].runstate;
640 }
641 }
642
643 return CTDB_RUNSTATE_UNKNOWN;
644 }
645
ctdb_set_runstate(struct ctdb_context * ctdb,enum ctdb_runstate runstate)646 void ctdb_set_runstate(struct ctdb_context *ctdb, enum ctdb_runstate runstate)
647 {
648 DEBUG(DEBUG_NOTICE,("Set runstate to %s (%d)\n",
649 runstate_to_string(runstate), runstate));
650
651 if (runstate <= ctdb->runstate) {
652 ctdb_fatal(ctdb, "runstate must always increase");
653 }
654
655 ctdb->runstate = runstate;
656 }
657
658 /* Convert arbitrary data to 4-byte boundary padded uint32 array */
ctdb_key_to_idkey(TALLOC_CTX * mem_ctx,TDB_DATA key)659 uint32_t *ctdb_key_to_idkey(TALLOC_CTX *mem_ctx, TDB_DATA key)
660 {
661 uint32_t idkey_size, *k;
662
663 idkey_size = 1 + (key.dsize + sizeof(uint32_t)-1) / sizeof(uint32_t);
664
665 k = talloc_zero_array(mem_ctx, uint32_t, idkey_size);
666 if (k == NULL) {
667 return NULL;
668 }
669
670 k[0] = idkey_size;
671 memcpy(&k[1], key.dptr, key.dsize);
672
673 return k;
674 }
675