ctdb/common/ctdb_util.c

   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 #include "lib/util/util_file.h"
  25
  26 #include <tdb.h>
  27
  28 #include "lib/util/debug.h"
  29 #include "lib/util/samba_util.h"
  30
  31 #include "ctdb_private.h"
  32
  33 #include "protocol/protocol_util.h"
  34
  35 #include "common/reqid.h"
  36 #include "common/system.h"
  37 #include "common/common.h"
  38 #include "common/logging.h"
  39
  40 /*
  41   return error string for last error
  42 */
  43 const char *ctdb_errstr(struct ctdb_context *ctdb)
  44 {
  45         return ctdb->err_msg;
  46 }
  47
  48
  49 /*
  50   remember an error message
  51 */
  52 void ctdb_set_error(struct ctdb_context *ctdb, const char *fmt, ...)
  53 {
  54         va_list ap;
  55         talloc_free(ctdb->err_msg);
  56         va_start(ap, fmt);
  57         ctdb->err_msg = talloc_vasprintf(ctdb, fmt, ap);
  58         DEBUG(DEBUG_ERR,("ctdb error: %s\n", ctdb->err_msg));
  59         va_end(ap);
  60 }
  61
  62 /*
  63   a fatal internal error occurred - no hope for recovery
  64 */
  65 void ctdb_fatal(struct ctdb_context *ctdb, const char *msg)
  66 {
  67         DEBUG(DEBUG_ALERT,("ctdb fatal error: %s\n", msg));
  68         abort();
  69 }
  70
  71 /*
  72   like ctdb_fatal() but a core/backtrace would not be useful
  73 */
  74 void ctdb_die(struct ctdb_context *ctdb, const char *msg)
  75 {
  76         DEBUG(DEBUG_ALERT,("ctdb exiting with error: %s\n", msg));
  77         exit(1);
  78 }
  79
  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,
  88                      const char *envvar,
  89                      const char *dir, const char *file)
  90 {
  91         const char *t;
  92         struct stat st;
  93
  94         if (helper[0] != '\0') {
  95                 /* Already set */
  96                 return true;
  97         }
  98
  99         t = getenv(envvar);
 100         if (t != NULL) {
 101                 if (strlen(t) >= size) {
 102                         DEBUG(DEBUG_ERR,
 103                               ("Unable to set %s - path too long\n", type));
 104                         return false;
 105                 }
 106
 107                 strncpy(helper, t, size);
 108         } else if (file == NULL) {
 109                 return false;
 110         } else if (dir == NULL) {
 111                         DEBUG(DEBUG_ERR,
 112                               ("Unable to set %s - dir is NULL\n", type));
 113                 return false;
 114         } else {
 115                 int ret;
 116
 117                 ret = snprintf(helper, size, "%s/%s", dir, file);
 118                 if (ret < 0 || (size_t)ret >= size) {
 119                         DEBUG(DEBUG_ERR,
 120                               ("Unable to set %s - path too long\n", type));
 121                         return false;
 122                 }
 123         }
 124
 125         if (stat(helper, &st) != 0) {
 126                 DEBUG(DEBUG_ERR,
 127                       ("Unable to set %s \"%s\" - %s\n",
 128                        type, helper, strerror(errno)));
 129                 return false;
 130         }
 131         if (!(st.st_mode & S_IXUSR)) {
 132                 DEBUG(DEBUG_ERR,
 133                       ("Unable to set %s \"%s\" - not executable\n",
 134                        type, helper));
 135                 return false;
 136         }
 137
 138         DEBUG(DEBUG_NOTICE,
 139               ("Set %s to \"%s\"\n", type, helper));
 140         return true;
 141 }
 142
 143 /*
 144   check if two addresses are the same
 145 */
 146 bool ctdb_same_address(ctdb_sock_addr *a1, ctdb_sock_addr *a2)
 147 {
 148         return ctdb_same_ip(a1, a2) &&
 149                 ctdb_addr_to_port(a1) == ctdb_addr_to_port(a2);
 150 }
 151
 152
 153 /*
 154   hash function for mapping data to a VNN - taken from tdb
 155 */
 156 uint32_t ctdb_hash(const TDB_DATA *key)
 157 {
 158         return tdb_jenkins_hash(discard_const(key));
 159 }
 160
 161
 162 static uint32_t ctdb_marshall_record_size(TDB_DATA key,
 163                                           struct ctdb_ltdb_header *header,
 164                                           TDB_DATA data)
 165 {
 166         return offsetof(struct ctdb_rec_data_old, data) + key.dsize +
 167                data.dsize + (header ? sizeof(*header) : 0);
 168 }
 169
 170 static void ctdb_marshall_record_copy(struct ctdb_rec_data_old *rec,
 171                                       uint32_t reqid,
 172                                       TDB_DATA key,
 173                                       struct ctdb_ltdb_header *header,
 174                                       TDB_DATA data,
 175                                       uint32_t length)
 176 {
 177         uint32_t offset;
 178
 179         rec->length = length;
 180         rec->reqid = reqid;
 181         rec->keylen = key.dsize;
 182         memcpy(&rec->data[0], key.dptr, key.dsize);
 183         offset = key.dsize;
 184
 185         if (header) {
 186                 rec->datalen = data.dsize + sizeof(*header);
 187                 memcpy(&rec->data[offset], header, sizeof(*header));
 188                 offset += sizeof(*header);
 189         } else {
 190                 rec->datalen = data.dsize;
 191         }
 192         memcpy(&rec->data[offset], data.dptr, data.dsize);
 193 }
 194
 195 /*
 196   form a ctdb_rec_data record from a key/data pair
 197
 198   note that header may be NULL. If not NULL then it is included in the data portion
 199   of the record
 200  */
 201 struct ctdb_rec_data_old *ctdb_marshall_record(TALLOC_CTX *mem_ctx,
 202                                                uint32_t reqid,
 203                                                TDB_DATA key,
 204                                                struct ctdb_ltdb_header *header,
 205                                                TDB_DATA data)
 206 {
 207         size_t length;
 208         struct ctdb_rec_data_old *d;
 209
 210         length = ctdb_marshall_record_size(key, header, data);
 211
 212         d = (struct ctdb_rec_data_old *)talloc_size(mem_ctx, length);
 213         if (d == NULL) {
 214                 return NULL;
 215         }
 216
 217         ctdb_marshall_record_copy(d, reqid, key, header, data, length);
 218         return d;
 219 }
 220
 221
 222 /* helper function for marshalling multiple records */
 223 struct ctdb_marshall_buffer *ctdb_marshall_add(TALLOC_CTX *mem_ctx,
 224                                                struct ctdb_marshall_buffer *m,
 225                                                uint32_t db_id,
 226                                                uint32_t reqid,
 227                                                TDB_DATA key,
 228                                                struct ctdb_ltdb_header *header,
 229                                                TDB_DATA data)
 230 {
 231         struct ctdb_rec_data_old *r;
 232         struct ctdb_marshall_buffer *m2;
 233         uint32_t length, offset;
 234
 235         length = ctdb_marshall_record_size(key, header, data);
 236
 237         if (m == NULL) {
 238                 offset = offsetof(struct ctdb_marshall_buffer, data);
 239                 m2 = talloc_zero_size(mem_ctx, offset + length);
 240         } else {
 241                 offset = talloc_get_size(m);
 242                 m2 = talloc_realloc_size(mem_ctx, m, offset + length);
 243         }
 244         if (m2 == NULL) {
 245                 TALLOC_FREE(m);
 246                 return NULL;
 247         }
 248
 249         if (m == NULL) {
 250                 m2->db_id = db_id;
 251         }
 252
 253         r = (struct ctdb_rec_data_old *)((uint8_t *)m2 + offset);
 254         ctdb_marshall_record_copy(r, reqid, key, header, data, length);
 255         m2->count++;
 256
 257         return m2;
 258 }
 259
 260 /* we've finished marshalling, return a data blob with the marshalled records */
 261 TDB_DATA ctdb_marshall_finish(struct ctdb_marshall_buffer *m)
 262 {
 263         TDB_DATA data;
 264         data.dptr = (uint8_t *)m;
 265         data.dsize = talloc_get_size(m);
 266         return data;
 267 }
 268
 269 /*
 270    loop over a marshalling buffer
 271
 272      - pass r==NULL to start
 273      - loop the number of times indicated by m->count
 274 */
 275 struct ctdb_rec_data_old *ctdb_marshall_loop_next(
 276                                 struct ctdb_marshall_buffer *m,
 277                                 struct ctdb_rec_data_old *r,
 278                                 uint32_t *reqid,
 279                                 struct ctdb_ltdb_header *header,
 280                                 TDB_DATA *key, TDB_DATA *data)
 281 {
 282         if (r == NULL) {
 283                 r = (struct ctdb_rec_data_old *)&m->data[0];
 284         } else {
 285                 r = (struct ctdb_rec_data_old *)(r->length + (uint8_t *)r);
 286         }
 287
 288         if (reqid != NULL) {
 289                 *reqid = r->reqid;
 290         }
 291
 292         if (key != NULL) {
 293                 key->dptr   = &r->data[0];
 294                 key->dsize  = r->keylen;
 295         }
 296         if (data != NULL) {
 297                 data->dptr  = &r->data[r->keylen];
 298                 data->dsize = r->datalen;
 299                 if (header != NULL) {
 300                         data->dptr += sizeof(*header);
 301                         data->dsize -= sizeof(*header);
 302                 }
 303         }
 304
 305         if (header != NULL) {
 306                 if (r->datalen < sizeof(*header)) {
 307                         return NULL;
 308                 }
 309                 memcpy(header, &r->data[r->keylen], sizeof(*header));
 310         }
 311
 312         return r;
 313 }
 314
 315 /*
 316    This is used to canonicalize a ctdb_sock_addr structure.
 317 */
 318 void ctdb_canonicalize_ip(const ctdb_sock_addr *ip, ctdb_sock_addr *cip)
 319 {
 320         ZERO_STRUCTP(cip);
 321
 322         if (ip->sa.sa_family == AF_INET6) {
 323                 const char prefix[12] = { 0,0,0,0,0,0,0,0,0,0,0xff,0xff };
 324                 if (memcmp(&ip->ip6.sin6_addr, prefix, sizeof(prefix)) == 0) {
 325                         /* Copy IPv4-mapped IPv6 addresses as IPv4 */
 326                         cip->ip.sin_family = AF_INET;
 327 #ifdef HAVE_SOCK_SIN_LEN
 328                         cip->ip.sin_len = sizeof(ctdb_sock_addr);
 329 #endif
 330                         cip->ip.sin_port   = ip->ip6.sin6_port;
 331                         memcpy(&cip->ip.sin_addr,
 332                                &ip->ip6.sin6_addr.s6_addr[12],
 333                                sizeof(cip->ip.sin_addr));
 334                 } else {
 335                         cip->ip6.sin6_family = AF_INET6;
 336 #ifdef HAVE_SOCK_SIN6_LEN
 337                         cip->ip6.sin6_len = sizeof(ctdb_sock_addr);
 338 #endif
 339                         cip->ip6.sin6_port   = ip->ip6.sin6_port;
 340                         memcpy(&cip->ip6.sin6_addr,
 341                                &ip->ip6.sin6_addr,
 342                                sizeof(cip->ip6.sin6_addr));
 343                 }
 344
 345                 return;
 346         }
 347
 348         if (ip->sa.sa_family == AF_INET) {
 349                 cip->ip.sin_family = AF_INET;
 350 #ifdef HAVE_SOCK_SIN_LEN
 351                 cip->ip.sin_len = sizeof(ctdb_sock_addr);
 352 #endif
 353                 cip->ip.sin_port = ip->ip.sin_port;
 354                 memcpy(&cip->ip.sin_addr,
 355                        &ip->ip.sin_addr,
 356                        sizeof(ip->ip.sin_addr));
 357
 358                 return;
 359         }
 360 }
 361
 362 void ctdb_canonicalize_ip_inplace(ctdb_sock_addr *ip)
 363 {
 364         ctdb_sock_addr tmp;
 365         ctdb_canonicalize_ip(ip, &tmp);
 366         memcpy(ip, &tmp, sizeof(tmp));
 367 }
 368
 369 bool ctdb_same_ip(const ctdb_sock_addr *tip1, const ctdb_sock_addr *tip2)
 370 {
 371         ctdb_sock_addr ip1, ip2;
 372
 373         ctdb_canonicalize_ip(tip1, &ip1);
 374         ctdb_canonicalize_ip(tip2, &ip2);
 375
 376         if (ip1.sa.sa_family != ip2.sa.sa_family) {
 377                 return false;
 378         }
 379
 380         switch (ip1.sa.sa_family) {
 381         case AF_INET:
 382                 return ip1.ip.sin_addr.s_addr == ip2.ip.sin_addr.s_addr;
 383         case AF_INET6:
 384                 return !memcmp(&ip1.ip6.sin6_addr.s6_addr[0],
 385                                 &ip2.ip6.sin6_addr.s6_addr[0],
 386                                 16);
 387         default:
 388                 DEBUG(DEBUG_ERR, (__location__ " CRITICAL Can not compare sockaddr structures of type %u\n", ip1.sa.sa_family));
 389                 return false;
 390         }
 391
 392         return true;
 393 }
 394
 395 /*
 396   compare two ctdb_sock_addr structures
 397  */
 398 bool ctdb_same_sockaddr(const ctdb_sock_addr *ip1, const ctdb_sock_addr *ip2)
 399 {
 400         return ctdb_same_ip(ip1, ip2) && ip1->ip.sin_port == ip2->ip.sin_port;
 401 }
 402
 403 char *ctdb_addr_to_str(ctdb_sock_addr *addr)
 404 {
 405         static char cip[128] = "";
 406
 407         switch (addr->sa.sa_family) {
 408         case AF_INET:
 409                 inet_ntop(addr->ip.sin_family, &addr->ip.sin_addr, cip, sizeof(cip));
 410                 break;
 411         case AF_INET6:
 412                 inet_ntop(addr->ip6.sin6_family, &addr->ip6.sin6_addr, cip, sizeof(cip));
 413                 break;
 414         default:
 415                 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family %u\n", addr->sa.sa_family));
 416         }
 417
 418         return cip;
 419 }
 420
 421 unsigned ctdb_addr_to_port(ctdb_sock_addr *addr)
 422 {
 423         switch (addr->sa.sa_family) {
 424         case AF_INET:
 425                 return ntohs(addr->ip.sin_port);
 426                 break;
 427         case AF_INET6:
 428                 return ntohs(addr->ip6.sin6_port);
 429                 break;
 430         default:
 431                 DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family %u\n", addr->sa.sa_family));
 432         }
 433
 434         return 0;
 435 }
 436
 437 struct ctdb_node_map_old *
 438 ctdb_node_list_to_map(struct ctdb_node **nodes, uint32_t num_nodes,
 439                       TALLOC_CTX *mem_ctx)
 440 {
 441         uint32_t i;
 442         size_t size;
 443         struct ctdb_node_map_old *node_map;
 444
 445         size = offsetof(struct ctdb_node_map_old, nodes) +
 446                 num_nodes * sizeof(struct ctdb_node_and_flags);
 447         node_map  = (struct ctdb_node_map_old *)talloc_zero_size(mem_ctx, size);
 448         if (node_map == NULL) {
 449                 DEBUG(DEBUG_ERR,
 450                       (__location__ " Failed to allocate nodemap array\n"));
 451                 return NULL;
 452         }
 453
 454         node_map->num = num_nodes;
 455         for (i=0; i<num_nodes; i++) {
 456                 node_map->nodes[i].addr  = nodes[i]->address;
 457                 node_map->nodes[i].pnn   = nodes[i]->pnn;
 458                 node_map->nodes[i].flags = nodes[i]->flags;
 459         }
 460
 461         return node_map;
 462 }
 463
 464 /* Runstate handling */
 465 void ctdb_set_runstate(struct ctdb_context *ctdb, enum ctdb_runstate runstate)
 466 {
 467         DEBUG(DEBUG_NOTICE,("Set runstate to %s (%d)\n",
 468                             ctdb_runstate_to_string(runstate), runstate));
 469
 470         if (runstate <= ctdb->runstate) {
 471                 ctdb_fatal(ctdb, "runstate must always increase");
 472         }
 473
 474         ctdb->runstate = runstate;
 475 }
 476
 477 /* Convert arbitrary data to 4-byte boundary padded uint32 array */
 478 uint32_t *ctdb_key_to_idkey(TALLOC_CTX *mem_ctx, TDB_DATA key)
 479 {
 480         uint32_t idkey_size, *k;
 481
 482         idkey_size = 1 + (key.dsize + sizeof(uint32_t)-1) / sizeof(uint32_t);
 483
 484         k = talloc_zero_array(mem_ctx, uint32_t, idkey_size);
 485         if (k == NULL) {
 486                 return NULL;
 487         }
 488
 489         k[0] = idkey_size;
 490         memcpy(&k[1], key.dptr, key.dsize);
 491
 492         return k;
 493 }