4 Copyright (C) Andrew Tridgell 2006
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.
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.
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/>.
21 #include "system/network.h"
22 #include "system/filesys.h"
23 #include "system/wait.h"
24 #include "lib/util/util_file.h"
28 #include "lib/util/debug.h"
29 #include "lib/util/samba_util.h"
31 #include "ctdb_private.h"
33 #include "protocol/protocol_util.h"
35 #include "common/reqid.h"
36 #include "common/system.h"
37 #include "common/common.h"
38 #include "common/logging.h"
41 return error string for last error
43 const char *ctdb_errstr(struct ctdb_context *ctdb)
50 remember an error message
52 void ctdb_set_error(struct ctdb_context *ctdb, const char *fmt, ...)
55 talloc_free(ctdb->err_msg);
57 ctdb->err_msg = talloc_vasprintf(ctdb, fmt, ap);
58 DEBUG(DEBUG_ERR,("ctdb error: %s\n", ctdb->err_msg));
63 a fatal internal error occurred - no hope for recovery
65 void ctdb_fatal(struct ctdb_context *ctdb, const char *msg)
67 DEBUG(DEBUG_ALERT,("ctdb fatal error: %s\n", msg));
72 like ctdb_fatal() but a core/backtrace would not be useful
74 void ctdb_die(struct ctdb_context *ctdb, const char *msg)
76 DEBUG(DEBUG_ALERT,("ctdb exiting with error: %s\n", msg));
80 /* Set the path of a helper program from envvar, falling back to
81 * dir/file if envvar unset. type is a string to print in log
82 * messages. helper is assumed to point to a statically allocated
83 * array of size bytes, initialised to "". If file is NULL don't fall
84 * back if envvar is unset. If dir is NULL and envvar is unset (but
85 * file is not NULL) then this is an error. Returns true if helper is
86 * set, either previously or this time. */
87 bool ctdb_set_helper(const char *type, char *helper, size_t size,
89 const char *dir, const char *file)
94 if (helper[0] != '\0') {
101 if (strlen(t) >= size) {
103 ("Unable to set %s - path too long\n", type));
107 strncpy(helper, t, size);
108 } else if (file == NULL) {
110 } else if (dir == NULL) {
112 ("Unable to set %s - dir is NULL\n", type));
117 ret = snprintf(helper, size, "%s/%s", dir, file);
118 if (ret < 0 || (size_t)ret >= size) {
120 ("Unable to set %s - path too long\n", type));
125 if (stat(helper, &st) != 0) {
127 ("Unable to set %s \"%s\" - %s\n",
128 type, helper, strerror(errno)));
131 if (!(st.st_mode & S_IXUSR)) {
133 ("Unable to set %s \"%s\" - not executable\n",
139 ("Set %s to \"%s\"\n", type, helper));
146 int ctdb_parse_address(TALLOC_CTX *mem_ctx, const char *str,
147 ctdb_sock_addr *address)
154 se = getservbyname("ctdb", "tcp");
160 port = ntohs(se->s_port);
163 ret = ctdb_sock_addr_from_string(str, address, false);
167 ctdb_sock_addr_set_port(address, port);
174 check if two addresses are the same
176 bool ctdb_same_address(ctdb_sock_addr *a1, ctdb_sock_addr *a2)
178 return ctdb_same_ip(a1, a2) &&
179 ctdb_addr_to_port(a1) == ctdb_addr_to_port(a2);
184 hash function for mapping data to a VNN - taken from tdb
186 uint32_t ctdb_hash(const TDB_DATA *key)
188 return tdb_jenkins_hash(discard_const(key));
192 static uint32_t ctdb_marshall_record_size(TDB_DATA key,
193 struct ctdb_ltdb_header *header,
196 return offsetof(struct ctdb_rec_data_old, data) + key.dsize +
197 data.dsize + (header ? sizeof(*header) : 0);
200 static void ctdb_marshall_record_copy(struct ctdb_rec_data_old *rec,
203 struct ctdb_ltdb_header *header,
209 rec->length = length;
211 rec->keylen = key.dsize;
212 memcpy(&rec->data[0], key.dptr, key.dsize);
216 rec->datalen = data.dsize + sizeof(*header);
217 memcpy(&rec->data[offset], header, sizeof(*header));
218 offset += sizeof(*header);
220 rec->datalen = data.dsize;
222 memcpy(&rec->data[offset], data.dptr, data.dsize);
226 form a ctdb_rec_data record from a key/data pair
228 note that header may be NULL. If not NULL then it is included in the data portion
231 struct ctdb_rec_data_old *ctdb_marshall_record(TALLOC_CTX *mem_ctx,
234 struct ctdb_ltdb_header *header,
238 struct ctdb_rec_data_old *d;
240 length = ctdb_marshall_record_size(key, header, data);
242 d = (struct ctdb_rec_data_old *)talloc_size(mem_ctx, length);
247 ctdb_marshall_record_copy(d, reqid, key, header, data, length);
252 /* helper function for marshalling multiple records */
253 struct ctdb_marshall_buffer *ctdb_marshall_add(TALLOC_CTX *mem_ctx,
254 struct ctdb_marshall_buffer *m,
258 struct ctdb_ltdb_header *header,
261 struct ctdb_rec_data_old *r;
262 struct ctdb_marshall_buffer *m2;
263 uint32_t length, offset;
265 length = ctdb_marshall_record_size(key, header, data);
268 offset = offsetof(struct ctdb_marshall_buffer, data);
269 m2 = talloc_zero_size(mem_ctx, offset + length);
271 offset = talloc_get_size(m);
272 m2 = talloc_realloc_size(mem_ctx, m, offset + length);
283 r = (struct ctdb_rec_data_old *)((uint8_t *)m2 + offset);
284 ctdb_marshall_record_copy(r, reqid, key, header, data, length);
290 /* we've finished marshalling, return a data blob with the marshalled records */
291 TDB_DATA ctdb_marshall_finish(struct ctdb_marshall_buffer *m)
294 data.dptr = (uint8_t *)m;
295 data.dsize = talloc_get_size(m);
300 loop over a marshalling buffer
302 - pass r==NULL to start
303 - loop the number of times indicated by m->count
305 struct ctdb_rec_data_old *ctdb_marshall_loop_next(
306 struct ctdb_marshall_buffer *m,
307 struct ctdb_rec_data_old *r,
309 struct ctdb_ltdb_header *header,
310 TDB_DATA *key, TDB_DATA *data)
313 r = (struct ctdb_rec_data_old *)&m->data[0];
315 r = (struct ctdb_rec_data_old *)(r->length + (uint8_t *)r);
323 key->dptr = &r->data[0];
324 key->dsize = r->keylen;
327 data->dptr = &r->data[r->keylen];
328 data->dsize = r->datalen;
329 if (header != NULL) {
330 data->dptr += sizeof(*header);
331 data->dsize -= sizeof(*header);
335 if (header != NULL) {
336 if (r->datalen < sizeof(*header)) {
339 memcpy(header, &r->data[r->keylen], sizeof(*header));
346 This is used to canonicalize a ctdb_sock_addr structure.
348 void ctdb_canonicalize_ip(const ctdb_sock_addr *ip, ctdb_sock_addr *cip)
352 if (ip->sa.sa_family == AF_INET6) {
353 const char prefix[12] = { 0,0,0,0,0,0,0,0,0,0,0xff,0xff };
354 if (memcmp(&ip->ip6.sin6_addr, prefix, sizeof(prefix)) == 0) {
355 /* Copy IPv4-mapped IPv6 addresses as IPv4 */
356 cip->ip.sin_family = AF_INET;
357 #ifdef HAVE_SOCK_SIN_LEN
358 cip->ip.sin_len = sizeof(ctdb_sock_addr);
360 cip->ip.sin_port = ip->ip6.sin6_port;
361 memcpy(&cip->ip.sin_addr,
362 &ip->ip6.sin6_addr.s6_addr[12],
363 sizeof(cip->ip.sin_addr));
365 cip->ip6.sin6_family = AF_INET6;
366 #ifdef HAVE_SOCK_SIN6_LEN
367 cip->ip6.sin6_len = sizeof(ctdb_sock_addr);
369 cip->ip6.sin6_port = ip->ip6.sin6_port;
370 memcpy(&cip->ip6.sin6_addr,
372 sizeof(cip->ip6.sin6_addr));
378 if (ip->sa.sa_family == AF_INET) {
379 cip->ip.sin_family = AF_INET;
380 #ifdef HAVE_SOCK_SIN_LEN
381 cip->ip.sin_len = sizeof(ctdb_sock_addr);
383 cip->ip.sin_port = ip->ip.sin_port;
384 memcpy(&cip->ip.sin_addr,
386 sizeof(ip->ip.sin_addr));
392 void ctdb_canonicalize_ip_inplace(ctdb_sock_addr *ip)
395 ctdb_canonicalize_ip(ip, &tmp);
396 memcpy(ip, &tmp, sizeof(tmp));
399 bool ctdb_same_ip(const ctdb_sock_addr *tip1, const ctdb_sock_addr *tip2)
401 ctdb_sock_addr ip1, ip2;
403 ctdb_canonicalize_ip(tip1, &ip1);
404 ctdb_canonicalize_ip(tip2, &ip2);
406 if (ip1.sa.sa_family != ip2.sa.sa_family) {
410 switch (ip1.sa.sa_family) {
412 return ip1.ip.sin_addr.s_addr == ip2.ip.sin_addr.s_addr;
414 return !memcmp(&ip1.ip6.sin6_addr.s6_addr[0],
415 &ip2.ip6.sin6_addr.s6_addr[0],
418 DEBUG(DEBUG_ERR, (__location__ " CRITICAL Can not compare sockaddr structures of type %u\n", ip1.sa.sa_family));
426 compare two ctdb_sock_addr structures
428 bool ctdb_same_sockaddr(const ctdb_sock_addr *ip1, const ctdb_sock_addr *ip2)
430 return ctdb_same_ip(ip1, ip2) && ip1->ip.sin_port == ip2->ip.sin_port;
433 char *ctdb_addr_to_str(ctdb_sock_addr *addr)
435 static char cip[128] = "";
437 switch (addr->sa.sa_family) {
439 inet_ntop(addr->ip.sin_family, &addr->ip.sin_addr, cip, sizeof(cip));
442 inet_ntop(addr->ip6.sin6_family, &addr->ip6.sin6_addr, cip, sizeof(cip));
445 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family %u\n", addr->sa.sa_family));
451 unsigned ctdb_addr_to_port(ctdb_sock_addr *addr)
453 switch (addr->sa.sa_family) {
455 return ntohs(addr->ip.sin_port);
458 return ntohs(addr->ip6.sin6_port);
461 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family %u\n", addr->sa.sa_family));
467 /* Add a node to a node map with given address and flags */
468 static bool node_map_add(TALLOC_CTX *mem_ctx,
469 const char *nstr, uint32_t flags,
470 struct ctdb_node_map_old **node_map)
475 struct ctdb_node_and_flags *n;
477 /* Might as well do this before trying to allocate memory */
478 if (ctdb_parse_address(mem_ctx, nstr, &addr) == -1) {
482 num = (*node_map)->num + 1;
483 s = offsetof(struct ctdb_node_map_old, nodes) +
484 num * sizeof(struct ctdb_node_and_flags);
485 *node_map = talloc_realloc_size(mem_ctx, *node_map, s);
486 if (*node_map == NULL) {
487 DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
491 n = &(*node_map)->nodes[(*node_map)->num];
493 n->pnn = (*node_map)->num;
501 /* Read a nodes file into a node map */
502 struct ctdb_node_map_old *ctdb_read_nodes_file(TALLOC_CTX *mem_ctx,
508 struct ctdb_node_map_old *ret;
510 /* Allocate node map header */
511 ret = talloc_zero_size(mem_ctx, offsetof(struct ctdb_node_map_old, nodes));
513 DEBUG(DEBUG_ERR, (__location__ " Out of memory\n"));
517 lines = file_lines_load(nlist, &nlines, 0, mem_ctx);
519 DEBUG(DEBUG_ERR, ("Failed to read nodes file \"%s\"\n", nlist));
522 while (nlines > 0 && strcmp(lines[nlines-1], "") == 0) {
526 for (i=0; i < nlines; i++) {
532 /* strip leading spaces */
533 while((*node == ' ') || (*node == '\t')) {
540 ((node[len-1] == ' ') || (node[len-1] == '\t')))
550 /* A "deleted" node is a node that is
551 commented out in the nodes file. This is
552 used instead of removing a line, which
553 would cause subsequent nodes to change
555 flags = NODE_FLAGS_DELETED;
556 node = discard_const("0.0.0.0");
560 if (!node_map_add(mem_ctx, node, flags, &ret)) {
571 struct ctdb_node_map_old *
572 ctdb_node_list_to_map(struct ctdb_node **nodes, uint32_t num_nodes,
577 struct ctdb_node_map_old *node_map;
579 size = offsetof(struct ctdb_node_map_old, nodes) +
580 num_nodes * sizeof(struct ctdb_node_and_flags);
581 node_map = (struct ctdb_node_map_old *)talloc_zero_size(mem_ctx, size);
582 if (node_map == NULL) {
584 (__location__ " Failed to allocate nodemap array\n"));
588 node_map->num = num_nodes;
589 for (i=0; i<num_nodes; i++) {
590 node_map->nodes[i].addr = nodes[i]->address;
591 node_map->nodes[i].pnn = nodes[i]->pnn;
592 node_map->nodes[i].flags = nodes[i]->flags;
598 /* Runstate handling */
599 void ctdb_set_runstate(struct ctdb_context *ctdb, enum ctdb_runstate runstate)
601 DEBUG(DEBUG_NOTICE,("Set runstate to %s (%d)\n",
602 ctdb_runstate_to_string(runstate), runstate));
604 if (runstate <= ctdb->runstate) {
605 ctdb_fatal(ctdb, "runstate must always increase");
608 ctdb->runstate = runstate;
611 /* Convert arbitrary data to 4-byte boundary padded uint32 array */
612 uint32_t *ctdb_key_to_idkey(TALLOC_CTX *mem_ctx, TDB_DATA key)
614 uint32_t idkey_size, *k;
616 idkey_size = 1 + (key.dsize + sizeof(uint32_t)-1) / sizeof(uint32_t);
618 k = talloc_zero_array(mem_ctx, uint32_t, idkey_size);
624 memcpy(&k[1], key.dptr, key.dsize);