ctdb/protocol/protocol_util.c

   1 /*
   2    CTDB protocol marshalling
   3
   4    Copyright (C) Amitay Isaacs  2015
   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
  23 #include <talloc.h>
  24
  25 #include "common/line.h"
  26
  27 #include "protocol.h"
  28 #include "protocol_util.h"
  29
  30 static struct {
  31         enum ctdb_runstate runstate;
  32         const char * label;
  33 } runstate_map[] = {
  34         { CTDB_RUNSTATE_UNKNOWN, "UNKNOWN" },
  35         { CTDB_RUNSTATE_INIT, "INIT" },
  36         { CTDB_RUNSTATE_SETUP, "SETUP" },
  37         { CTDB_RUNSTATE_FIRST_RECOVERY, "FIRST_RECOVERY" },
  38         { CTDB_RUNSTATE_STARTUP, "STARTUP" },
  39         { CTDB_RUNSTATE_RUNNING, "RUNNING" },
  40         { CTDB_RUNSTATE_SHUTDOWN, "SHUTDOWN" },
  41         { -1, NULL },
  42 };
  43
  44 const char *ctdb_runstate_to_string(enum ctdb_runstate runstate)
  45 {
  46         int i;
  47
  48         for (i=0; runstate_map[i].label != NULL; i++) {
  49                 if (runstate_map[i].runstate == runstate) {
  50                         return runstate_map[i].label;
  51                 }
  52         }
  53
  54         return runstate_map[0].label;
  55 }
  56
  57 enum ctdb_runstate ctdb_runstate_from_string(const char *runstate_str)
  58 {
  59         int i;
  60
  61         for (i=0; runstate_map[i].label != NULL; i++) {
  62                 if (strcasecmp(runstate_map[i].label,
  63                                runstate_str) == 0) {
  64                         return runstate_map[i].runstate;
  65                 }
  66         }
  67
  68         return CTDB_RUNSTATE_UNKNOWN;
  69 }
  70
  71 static struct {
  72         enum ctdb_event event;
  73         const char *label;
  74 } event_map[] = {
  75         { CTDB_EVENT_INIT, "init" },
  76         { CTDB_EVENT_SETUP, "setup" },
  77         { CTDB_EVENT_STARTUP, "startup" },
  78         { CTDB_EVENT_START_RECOVERY, "startrecovery" },
  79         { CTDB_EVENT_RECOVERED, "recovered" },
  80         { CTDB_EVENT_TAKE_IP, "takeip" },
  81         { CTDB_EVENT_RELEASE_IP, "releaseip" },
  82         { CTDB_EVENT_MONITOR, "monitor" },
  83         { CTDB_EVENT_SHUTDOWN, "shutdown" },
  84         { CTDB_EVENT_UPDATE_IP, "updateip" },
  85         { CTDB_EVENT_IPREALLOCATED, "ipreallocated" },
  86         { CTDB_EVENT_MAX, "all" },
  87         { -1, NULL },
  88 };
  89
  90 const char *ctdb_event_to_string(enum ctdb_event event)
  91 {
  92         int i;
  93
  94         for (i=0; event_map[i].label != NULL; i++) {
  95                 if (event_map[i].event == event) {
  96                         return event_map[i].label;
  97                 }
  98         }
  99
 100         return "unknown";
 101 }
 102
 103 enum ctdb_event ctdb_event_from_string(const char *event_str)
 104 {
 105         int i;
 106
 107         for (i=0; event_map[i].label != NULL; i++) {
 108                 if (strcmp(event_map[i].label, event_str) == 0) {
 109                         return event_map[i].event;
 110                 }
 111         }
 112
 113         return CTDB_EVENT_MAX;
 114 }
 115
 116 int ctdb_sock_addr_to_buf(char *buf, socklen_t buflen,
 117                           ctdb_sock_addr *addr, bool with_port)
 118 {
 119         const char *t;
 120
 121         switch (addr->sa.sa_family) {
 122         case AF_INET:
 123                 t = inet_ntop(addr->ip.sin_family, &addr->ip.sin_addr,
 124                               buf, buflen);
 125                 if (t == NULL) {
 126                         return errno;
 127                 }
 128                 break;
 129
 130         case AF_INET6:
 131                 t = inet_ntop(addr->ip6.sin6_family, &addr->ip6.sin6_addr,
 132                               buf, buflen);
 133                 if (t == NULL) {
 134                         return errno;
 135                 }
 136                 break;
 137
 138         default:
 139                 return EAFNOSUPPORT;
 140                 break;
 141         }
 142
 143         if (with_port) {
 144                 size_t len = strlen(buf);
 145                 int ret;
 146
 147                 ret = snprintf(buf+len, buflen-len,
 148                                ":%u", ctdb_sock_addr_port(addr));
 149                 if (ret >= buflen-len) {
 150                         return ENOSPC;
 151                 }
 152         }
 153
 154         return 0;
 155 }
 156
 157 const char *ctdb_sock_addr_to_string(TALLOC_CTX *mem_ctx,
 158                                      ctdb_sock_addr *addr, bool with_port)
 159 {
 160         size_t len = 64;
 161         char *cip;
 162         int ret;
 163
 164         cip = talloc_size(mem_ctx, len);
 165
 166         if (cip == NULL) {
 167                 return NULL;
 168         }
 169
 170         ret = ctdb_sock_addr_to_buf(cip, len, addr, with_port);
 171         if (ret != 0) {
 172                 talloc_free(cip);
 173                 return NULL;
 174         }
 175
 176         return cip;
 177 }
 178
 179 static int ipv4_from_string(const char *str, struct sockaddr_in *ip)
 180 {
 181         int ret;
 182
 183         *ip = (struct sockaddr_in) {
 184                 .sin_family = AF_INET,
 185         };
 186
 187         ret = inet_pton(AF_INET, str, &ip->sin_addr);
 188         if (ret != 1) {
 189                 return EINVAL;
 190         }
 191
 192 #ifdef HAVE_SOCK_SIN_LEN
 193         ip->sin_len = sizeof(*ip);
 194 #endif
 195         return 0;
 196 }
 197
 198 static int ipv6_from_string(const char *str, struct sockaddr_in6 *ip6)
 199 {
 200         int ret;
 201
 202         *ip6 = (struct sockaddr_in6) {
 203                 .sin6_family   = AF_INET6,
 204         };
 205
 206         ret = inet_pton(AF_INET6, str, &ip6->sin6_addr);
 207         if (ret != 1) {
 208                 return EINVAL;
 209         }
 210
 211 #ifdef HAVE_SOCK_SIN6_LEN
 212         ip6->sin6_len = sizeof(*ip6);
 213 #endif
 214         return 0;
 215 }
 216
 217 static int ip_from_string(const char *str, ctdb_sock_addr *addr)
 218 {
 219         char *p;
 220         int ret;
 221
 222         if (addr == NULL) {
 223                 return EINVAL;
 224         }
 225
 226         ZERO_STRUCTP(addr); /* valgrind :-) */
 227
 228         /* IPv4 or IPv6 address?
 229          *
 230          * Use rindex() because we need the right-most ':' below for
 231          * IPv4-mapped IPv6 addresses anyway...
 232          */
 233         p = rindex(str, ':');
 234         if (p == NULL) {
 235                 ret = ipv4_from_string(str, &addr->ip);
 236         } else {
 237                 uint8_t ipv4_mapped_prefix[12] = {
 238                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff
 239                 };
 240
 241                 ret = ipv6_from_string(str, &addr->ip6);
 242                 if (ret != 0) {
 243                         return ret;
 244                 }
 245
 246                 /*
 247                  * Check for IPv4-mapped IPv6 address
 248                  * (e.g. ::ffff:192.0.2.128) - reparse as IPv4 if
 249                  * necessary
 250                  */
 251                 if (memcmp(&addr->ip6.sin6_addr.s6_addr[0],
 252                            ipv4_mapped_prefix,
 253                            sizeof(ipv4_mapped_prefix)) == 0) {
 254                         /* Reparse as IPv4 */
 255                         ret = ipv4_from_string(p+1, &addr->ip);
 256                 }
 257         }
 258
 259         return ret;
 260 }
 261
 262 int ctdb_sock_addr_from_string(const char *str,
 263                                ctdb_sock_addr *addr, bool with_port)
 264 {
 265         char *p;
 266         char s[64]; /* Much longer than INET6_ADDRSTRLEN */
 267         unsigned port;
 268         char *endp = NULL;
 269         size_t len;
 270         int ret;
 271
 272         if (! with_port) {
 273                 ret = ip_from_string(str, addr);
 274                 return ret;
 275         }
 276
 277         /* Parse out port number and then IP address */
 278
 279         len = strlcpy(s, str, sizeof(s));
 280         if (len >= sizeof(s)) {
 281                 return EINVAL;
 282         }
 283
 284         p = rindex(s, ':');
 285         if (p == NULL) {
 286                 return EINVAL;
 287         }
 288
 289         port = strtoul(p+1, &endp, 10);
 290         if (endp == p+1 || *endp != '\0') {
 291                 /* Empty string or trailing garbage */
 292                 return EINVAL;
 293         }
 294
 295         *p = '\0';
 296         ret = ip_from_string(s, addr);
 297
 298         ctdb_sock_addr_set_port(addr, port);
 299
 300         return ret;
 301 }
 302
 303 int ctdb_sock_addr_mask_from_string(const char *str,
 304                                     ctdb_sock_addr *addr,
 305                                     unsigned int *mask)
 306 {
 307         char *p;
 308         char s[64]; /* Much longer than INET6_ADDRSTRLEN */
 309         unsigned int m;
 310         char *endp = NULL;
 311         ssize_t len;
 312         bool ret;
 313
 314         if (addr == NULL || mask == NULL) {
 315                 return EINVAL;
 316         }
 317
 318         len = strlcpy(s, str, sizeof(s));
 319         if (len >= sizeof(s)) {
 320                 return EINVAL;
 321         }
 322
 323         p = rindex(s, '/');
 324         if (p == NULL) {
 325                 return EINVAL;
 326         }
 327
 328         m = strtoul(p+1, &endp, 10);
 329         if (endp == p+1 || *endp != '\0') {
 330                 /* Empty string or trailing garbage */
 331                 return EINVAL;
 332         }
 333
 334         *p = '\0';
 335         ret = ip_from_string(s, addr);
 336
 337         if (ret == 0) {
 338                 *mask = m;
 339         }
 340
 341         return ret;
 342 }
 343
 344 unsigned int ctdb_sock_addr_port(ctdb_sock_addr *addr)
 345 {
 346         switch (addr->sa.sa_family) {
 347         case AF_INET:
 348                 return ntohs(addr->ip.sin_port);
 349                 break;
 350         case AF_INET6:
 351                 return ntohs(addr->ip6.sin6_port);
 352                 break;
 353         default:
 354                 return 0;
 355         }
 356 }
 357
 358 void ctdb_sock_addr_set_port(ctdb_sock_addr *addr, unsigned int port)
 359 {
 360         switch (addr->sa.sa_family) {
 361         case AF_INET:
 362                 addr->ip.sin_port = htons(port);
 363                 break;
 364         case AF_INET6:
 365                 addr->ip6.sin6_port = htons(port);
 366                 break;
 367         default:
 368                 break;
 369         }
 370 }
 371
 372 static int ctdb_sock_addr_cmp_family(const ctdb_sock_addr *addr1,
 373                                      const ctdb_sock_addr *addr2)
 374 {
 375         /* This is somewhat arbitrary.  However, when used for sorting
 376          * it just needs to be consistent.
 377          */
 378         if (addr1->sa.sa_family < addr2->sa.sa_family) {
 379                 return -1;
 380         }
 381         if (addr1->sa.sa_family > addr2->sa.sa_family) {
 382                 return 1;
 383         }
 384
 385         return 0;
 386 }
 387
 388 int ctdb_sock_addr_cmp_ip(const ctdb_sock_addr *addr1,
 389                           const ctdb_sock_addr *addr2)
 390 {
 391         int ret;
 392
 393         ret = ctdb_sock_addr_cmp_family(addr1, addr2);
 394         if (ret != 0) {
 395                 return ret;
 396         }
 397
 398         switch (addr1->sa.sa_family) {
 399         case AF_INET:
 400                 ret = memcmp(&addr1->ip.sin_addr.s_addr,
 401                              &addr2->ip.sin_addr.s_addr, 4);
 402                 break;
 403
 404         case AF_INET6:
 405                 ret = memcmp(addr1->ip6.sin6_addr.s6_addr,
 406                              addr2->ip6.sin6_addr.s6_addr, 16);
 407                 break;
 408
 409         default:
 410                 ret = -1;
 411         }
 412
 413         return ret;
 414 }
 415
 416 int ctdb_sock_addr_cmp(const ctdb_sock_addr *addr1,
 417                        const ctdb_sock_addr *addr2)
 418 {
 419         int ret = 0;
 420
 421         ret = ctdb_sock_addr_cmp_ip(addr1, addr2);
 422         if (ret != 0) {
 423                 return ret;
 424         }
 425
 426         switch (addr1->sa.sa_family) {
 427         case AF_INET:
 428                 if (addr1->ip.sin_port < addr2->ip.sin_port) {
 429                         ret = -1;
 430                 } else if (addr1->ip.sin_port > addr2->ip.sin_port) {
 431                         ret = 1;
 432                 }
 433                 break;
 434
 435         case AF_INET6:
 436                 if (addr1->ip6.sin6_port < addr2->ip6.sin6_port) {
 437                         ret = -1;
 438                 } else if (addr1->ip6.sin6_port > addr2->ip6.sin6_port) {
 439                         ret = 1;
 440                 }
 441                 break;
 442
 443         default:
 444                 ret = -1;
 445         }
 446
 447         return ret;
 448 }
 449
 450 bool ctdb_sock_addr_same_ip(const ctdb_sock_addr *addr1,
 451                             const ctdb_sock_addr *addr2)
 452 {
 453         return (ctdb_sock_addr_cmp_ip(addr1, addr2) == 0);
 454 }
 455
 456 bool ctdb_sock_addr_same(const ctdb_sock_addr *addr1,
 457                          const ctdb_sock_addr *addr2)
 458 {
 459         return (ctdb_sock_addr_cmp(addr1, addr2) == 0);
 460 }
 461
 462 int ctdb_connection_to_buf(char *buf, size_t buflen,
 463                            struct ctdb_connection *conn, bool client_first)
 464 {
 465         char server[64], client[64];
 466         int ret;
 467
 468         ret = ctdb_sock_addr_to_buf(server, sizeof(server),
 469                                     &conn->server, true);
 470         if (ret != 0) {
 471                 return ret;
 472         }
 473
 474         ret = ctdb_sock_addr_to_buf(client, sizeof(client),
 475                                     &conn->client, true);
 476         if (ret != 0) {
 477                 return ret;
 478         }
 479
 480         if (! client_first) {
 481                 ret = snprintf(buf, buflen, "%s %s", server, client);
 482         } else {
 483                 ret = snprintf(buf, buflen, "%s %s", client, server);
 484         }
 485         if (ret >= buflen) {
 486                 return ENOSPC;
 487         }
 488
 489         return 0;
 490 }
 491
 492 const char *ctdb_connection_to_string(TALLOC_CTX *mem_ctx,
 493                                       struct ctdb_connection *conn,
 494                                       bool client_first)
 495 {
 496         const size_t len = 128;
 497         char *out;
 498         int ret;
 499
 500         out = talloc_size(mem_ctx, len);
 501         if (out == NULL) {
 502                 return NULL;
 503         }
 504
 505         ret = ctdb_connection_to_buf(out, len, conn, client_first);
 506         if (ret != 0) {
 507                 talloc_free(out);
 508                 return NULL;
 509         }
 510
 511         return out;
 512 }
 513
 514 int ctdb_connection_from_string(const char *str, bool client_first,
 515                                 struct ctdb_connection *conn)
 516 {
 517         char s[128];
 518         char *t1 = NULL, *t2 = NULL;
 519         size_t len;
 520         ctdb_sock_addr *first = (client_first ? &conn->client : &conn->server);
 521         ctdb_sock_addr *second = (client_first ? &conn->server : &conn->client);
 522         int ret;
 523
 524         len = strlcpy(s, str, sizeof(s));
 525         if (len >= sizeof(s)) {
 526                 return EINVAL;
 527         }
 528
 529         t1 = strtok(s, " \t\n");
 530         if (t1 == NULL) {
 531                 return EINVAL;
 532         }
 533
 534         t2 = strtok(NULL, " \t\n\0");
 535         if (t2 == NULL) {
 536                 return EINVAL;
 537         }
 538
 539         ret = ctdb_sock_addr_from_string(t1, first, true);
 540         if (ret != 0) {
 541                 return ret;
 542         }
 543
 544         ret = ctdb_sock_addr_from_string(t2, second, true);
 545         if (ret != 0) {
 546                 return ret;
 547         }
 548
 549         ret = ctdb_sock_addr_cmp_family(first, second);
 550         if (ret != 0) {
 551                 return EINVAL;
 552         }
 553
 554         return 0;
 555 }
 556
 557 int ctdb_connection_list_add(struct ctdb_connection_list *conn_list,
 558                              struct ctdb_connection *conn)
 559 {
 560         uint32_t len;
 561
 562         if (conn_list == NULL) {
 563                 return EINVAL;
 564         }
 565
 566         /* Ensure array is big enough */
 567         len = talloc_array_length(conn_list->conn);
 568         if (conn_list->num == len) {
 569                 conn_list->conn = talloc_realloc(conn_list, conn_list->conn,
 570                                                  struct ctdb_connection,
 571                                                  len+128);
 572                 if (conn_list->conn == NULL) {
 573                         return ENOMEM;
 574                 }
 575         }
 576
 577         conn_list->conn[conn_list->num] = *conn;
 578         conn_list->num++;
 579
 580         return 0;
 581 }
 582
 583 static int connection_cmp(const void *a, const void *b)
 584 {
 585         const struct ctdb_connection *conn_a = a;
 586         const struct ctdb_connection *conn_b = b;
 587         int ret;
 588
 589         ret = ctdb_sock_addr_cmp(&conn_a->server, &conn_b->server);
 590         if (ret == 0) {
 591                 ret = ctdb_sock_addr_cmp(&conn_a->client, &conn_b->client);
 592         }
 593
 594         return ret;
 595 }
 596
 597 int ctdb_connection_list_sort(struct ctdb_connection_list *conn_list)
 598 {
 599         if (conn_list == NULL) {
 600                 return EINVAL;
 601         }
 602
 603         if (conn_list->num > 0) {
 604                 qsort(conn_list->conn, conn_list->num,
 605                       sizeof(struct ctdb_connection), connection_cmp);
 606         }
 607
 608         return 0;
 609 }
 610
 611 const char *ctdb_connection_list_to_string(
 612         TALLOC_CTX *mem_ctx,
 613         struct ctdb_connection_list *conn_list, bool client_first)
 614 {
 615         uint32_t i;
 616         char *out;
 617
 618         out = talloc_strdup(mem_ctx, "");
 619         if (out == NULL) {
 620                 return NULL;
 621         }
 622
 623         if (conn_list == NULL || conn_list->num == 0) {
 624                 return out;
 625         }
 626
 627         for (i = 0; i < conn_list->num; i++) {
 628                 char buf[128];
 629                 int ret;
 630
 631                 ret = ctdb_connection_to_buf(buf, sizeof(buf),
 632                                              &conn_list->conn[i], client_first);
 633                 if (ret != 0) {
 634                         talloc_free(out);
 635                         return NULL;
 636                 }
 637
 638                 out = talloc_asprintf_append(out, "%s\n", buf);
 639                 if (out == NULL) {
 640                         return NULL;
 641                 }
 642         }
 643
 644         return out;
 645 }
 646
 647 struct ctdb_connection_list_read_state {
 648         struct ctdb_connection_list *list;
 649         bool client_first;
 650 };
 651
 652 static int ctdb_connection_list_read_line(char *line, void *private_data)
 653 {
 654         struct ctdb_connection_list_read_state *state =
 655                 (struct ctdb_connection_list_read_state *)private_data;
 656         struct ctdb_connection conn;
 657         int ret;
 658
 659         /* Skip empty lines */
 660         if (line[0] == '\0') {
 661                 return 0;
 662         }
 663
 664         /* Comment */
 665         if (line[0] == '#') {
 666                 return 0;
 667         }
 668
 669         ret = ctdb_connection_from_string(line, state->client_first, &conn);
 670         if (ret != 0) {
 671                 return ret;
 672         }
 673
 674         ret = ctdb_connection_list_add(state->list, &conn);
 675         if (ret != 0) {
 676                 return ret;
 677         }
 678
 679         return 0;
 680 }
 681
 682 int ctdb_connection_list_read(TALLOC_CTX *mem_ctx,
 683                               int fd,
 684                               bool client_first,
 685                               struct ctdb_connection_list **conn_list)
 686 {
 687         struct ctdb_connection_list_read_state state;
 688         int ret;
 689
 690         if (conn_list == NULL) {
 691                 return EINVAL;
 692         }
 693
 694         state.list = talloc_zero(mem_ctx, struct ctdb_connection_list);
 695         if (state.list == NULL) {
 696                 return ENOMEM;
 697         }
 698
 699         state.client_first = client_first;
 700
 701         ret = line_read(fd,
 702                         128,
 703                         mem_ctx,
 704                         ctdb_connection_list_read_line,
 705                         &state,
 706                         NULL);
 707
 708         *conn_list = state.list;
 709
 710         return ret;
 711 }