2 CTDB protocol marshalling
4 Copyright (C) Amitay Isaacs 2015
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"
25 #include "common/line.h"
28 #include "protocol_util.h"
29 #include "lib/util/util.h"
32 enum ctdb_runstate runstate;
35 { CTDB_RUNSTATE_UNKNOWN, "UNKNOWN" },
36 { CTDB_RUNSTATE_INIT, "INIT" },
37 { CTDB_RUNSTATE_SETUP, "SETUP" },
38 { CTDB_RUNSTATE_FIRST_RECOVERY, "FIRST_RECOVERY" },
39 { CTDB_RUNSTATE_STARTUP, "STARTUP" },
40 { CTDB_RUNSTATE_RUNNING, "RUNNING" },
41 { CTDB_RUNSTATE_SHUTDOWN, "SHUTDOWN" },
45 const char *ctdb_runstate_to_string(enum ctdb_runstate runstate)
49 for (i=0; runstate_map[i].label != NULL; i++) {
50 if (runstate_map[i].runstate == runstate) {
51 return runstate_map[i].label;
55 return runstate_map[0].label;
58 enum ctdb_runstate ctdb_runstate_from_string(const char *runstate_str)
62 for (i=0; runstate_map[i].label != NULL; i++) {
63 if (strcasecmp(runstate_map[i].label,
65 return runstate_map[i].runstate;
69 return CTDB_RUNSTATE_UNKNOWN;
73 enum ctdb_event event;
76 { CTDB_EVENT_INIT, "init" },
77 { CTDB_EVENT_SETUP, "setup" },
78 { CTDB_EVENT_STARTUP, "startup" },
79 { CTDB_EVENT_START_RECOVERY, "startrecovery" },
80 { CTDB_EVENT_RECOVERED, "recovered" },
81 { CTDB_EVENT_TAKE_IP, "takeip" },
82 { CTDB_EVENT_RELEASE_IP, "releaseip" },
83 { CTDB_EVENT_MONITOR, "monitor" },
84 { CTDB_EVENT_SHUTDOWN, "shutdown" },
85 { CTDB_EVENT_UPDATE_IP, "updateip" },
86 { CTDB_EVENT_IPREALLOCATED, "ipreallocated" },
87 { CTDB_EVENT_MAX, "all" },
91 const char *ctdb_event_to_string(enum ctdb_event event)
95 for (i=0; event_map[i].label != NULL; i++) {
96 if (event_map[i].event == event) {
97 return event_map[i].label;
104 enum ctdb_event ctdb_event_from_string(const char *event_str)
108 for (i=0; event_map[i].label != NULL; i++) {
109 if (strcmp(event_map[i].label, event_str) == 0) {
110 return event_map[i].event;
114 return CTDB_EVENT_MAX;
117 int ctdb_sock_addr_to_buf(char *buf, socklen_t buflen,
118 ctdb_sock_addr *addr, bool with_port)
122 switch (addr->sa.sa_family) {
124 t = inet_ntop(addr->ip.sin_family, &addr->ip.sin_addr,
132 t = inet_ntop(addr->ip6.sin6_family, &addr->ip6.sin6_addr,
145 size_t len = strlen(buf);
148 ret = snprintf(buf+len, buflen-len,
149 ":%u", ctdb_sock_addr_port(addr));
150 if (ret >= buflen-len) {
158 const char *ctdb_sock_addr_to_string(TALLOC_CTX *mem_ctx,
159 ctdb_sock_addr *addr, bool with_port)
165 cip = talloc_size(mem_ctx, len);
171 ret = ctdb_sock_addr_to_buf(cip, len, addr, with_port);
180 static int ipv4_from_string(const char *str, struct sockaddr_in *ip)
184 *ip = (struct sockaddr_in) {
185 .sin_family = AF_INET,
188 ret = inet_pton(AF_INET, str, &ip->sin_addr);
193 #ifdef HAVE_SOCK_SIN_LEN
194 ip->sin_len = sizeof(*ip);
199 static int ipv6_from_string(const char *str, struct sockaddr_in6 *ip6)
203 *ip6 = (struct sockaddr_in6) {
204 .sin6_family = AF_INET6,
207 ret = inet_pton(AF_INET6, str, &ip6->sin6_addr);
212 #ifdef HAVE_SOCK_SIN6_LEN
213 ip6->sin6_len = sizeof(*ip6);
218 static int ip_from_string(const char *str, ctdb_sock_addr *addr)
227 ZERO_STRUCTP(addr); /* valgrind :-) */
229 /* IPv4 or IPv6 address?
231 * Use rindex() because we need the right-most ':' below for
232 * IPv4-mapped IPv6 addresses anyway...
234 p = rindex(str, ':');
236 ret = ipv4_from_string(str, &addr->ip);
238 uint8_t ipv4_mapped_prefix[12] = {
239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff
242 ret = ipv6_from_string(str, &addr->ip6);
248 * Check for IPv4-mapped IPv6 address
249 * (e.g. ::ffff:192.0.2.128) - reparse as IPv4 if
252 if (memcmp(&addr->ip6.sin6_addr.s6_addr[0],
254 sizeof(ipv4_mapped_prefix)) == 0) {
255 /* Reparse as IPv4 */
256 ret = ipv4_from_string(p+1, &addr->ip);
263 int ctdb_sock_addr_from_string(const char *str,
264 ctdb_sock_addr *addr, bool with_port)
267 char s[64]; /* Much longer than INET6_ADDRSTRLEN */
274 ret = ip_from_string(str, addr);
278 /* Parse out port number and then IP address */
280 len = strlcpy(s, str, sizeof(s));
281 if (len >= sizeof(s)) {
290 port = strtoul_err(p+1, &endp, 10, &ret);
291 if (endp == p+1 || *endp != '\0' || ret != 0) {
292 /* Empty string or trailing garbage */
297 ret = ip_from_string(s, addr);
299 ctdb_sock_addr_set_port(addr, port);
304 int ctdb_sock_addr_mask_from_string(const char *str,
305 ctdb_sock_addr *addr,
309 char s[64]; /* Much longer than INET6_ADDRSTRLEN */
315 if (addr == NULL || mask == NULL) {
319 len = strlcpy(s, str, sizeof(s));
320 if (len >= sizeof(s)) {
329 m = strtoul_err(p+1, &endp, 10, &ret);
330 if (endp == p+1 || *endp != '\0' || ret != 0) {
331 /* Empty string or trailing garbage */
336 ret = ip_from_string(s, addr);
345 unsigned int ctdb_sock_addr_port(ctdb_sock_addr *addr)
347 switch (addr->sa.sa_family) {
349 return ntohs(addr->ip.sin_port);
352 return ntohs(addr->ip6.sin6_port);
359 void ctdb_sock_addr_set_port(ctdb_sock_addr *addr, unsigned int port)
361 switch (addr->sa.sa_family) {
363 addr->ip.sin_port = htons(port);
366 addr->ip6.sin6_port = htons(port);
373 static int ctdb_sock_addr_cmp_family(const ctdb_sock_addr *addr1,
374 const ctdb_sock_addr *addr2)
376 /* This is somewhat arbitrary. However, when used for sorting
377 * it just needs to be consistent.
379 if (addr1->sa.sa_family < addr2->sa.sa_family) {
382 if (addr1->sa.sa_family > addr2->sa.sa_family) {
389 int ctdb_sock_addr_cmp_ip(const ctdb_sock_addr *addr1,
390 const ctdb_sock_addr *addr2)
394 ret = ctdb_sock_addr_cmp_family(addr1, addr2);
399 switch (addr1->sa.sa_family) {
401 ret = memcmp(&addr1->ip.sin_addr.s_addr,
402 &addr2->ip.sin_addr.s_addr, 4);
406 ret = memcmp(addr1->ip6.sin6_addr.s6_addr,
407 addr2->ip6.sin6_addr.s6_addr, 16);
417 int ctdb_sock_addr_cmp(const ctdb_sock_addr *addr1,
418 const ctdb_sock_addr *addr2)
422 ret = ctdb_sock_addr_cmp_ip(addr1, addr2);
427 switch (addr1->sa.sa_family) {
429 if (addr1->ip.sin_port < addr2->ip.sin_port) {
431 } else if (addr1->ip.sin_port > addr2->ip.sin_port) {
437 if (addr1->ip6.sin6_port < addr2->ip6.sin6_port) {
439 } else if (addr1->ip6.sin6_port > addr2->ip6.sin6_port) {
451 bool ctdb_sock_addr_same_ip(const ctdb_sock_addr *addr1,
452 const ctdb_sock_addr *addr2)
454 return (ctdb_sock_addr_cmp_ip(addr1, addr2) == 0);
457 bool ctdb_sock_addr_same(const ctdb_sock_addr *addr1,
458 const ctdb_sock_addr *addr2)
460 return (ctdb_sock_addr_cmp(addr1, addr2) == 0);
463 int ctdb_connection_to_buf(char *buf, size_t buflen,
464 struct ctdb_connection *conn, bool client_first)
466 char server[64], client[64];
469 ret = ctdb_sock_addr_to_buf(server, sizeof(server),
470 &conn->server, true);
475 ret = ctdb_sock_addr_to_buf(client, sizeof(client),
476 &conn->client, true);
481 if (! client_first) {
482 ret = snprintf(buf, buflen, "%s %s", server, client);
484 ret = snprintf(buf, buflen, "%s %s", client, server);
493 const char *ctdb_connection_to_string(TALLOC_CTX *mem_ctx,
494 struct ctdb_connection *conn,
497 const size_t len = 128;
501 out = talloc_size(mem_ctx, len);
506 ret = ctdb_connection_to_buf(out, len, conn, client_first);
515 int ctdb_connection_from_string(const char *str, bool client_first,
516 struct ctdb_connection *conn)
519 char *t1 = NULL, *t2 = NULL;
521 ctdb_sock_addr *first = (client_first ? &conn->client : &conn->server);
522 ctdb_sock_addr *second = (client_first ? &conn->server : &conn->client);
525 len = strlcpy(s, str, sizeof(s));
526 if (len >= sizeof(s)) {
530 t1 = strtok(s, " \t\n");
535 t2 = strtok(NULL, " \t\n\0");
540 ret = ctdb_sock_addr_from_string(t1, first, true);
545 ret = ctdb_sock_addr_from_string(t2, second, true);
550 ret = ctdb_sock_addr_cmp_family(first, second);
558 int ctdb_connection_list_add(struct ctdb_connection_list *conn_list,
559 struct ctdb_connection *conn)
563 if (conn_list == NULL) {
567 /* Ensure array is big enough */
568 len = talloc_array_length(conn_list->conn);
569 if (conn_list->num == len) {
570 conn_list->conn = talloc_realloc(conn_list, conn_list->conn,
571 struct ctdb_connection,
573 if (conn_list->conn == NULL) {
578 conn_list->conn[conn_list->num] = *conn;
584 static int connection_cmp(const void *a, const void *b)
586 const struct ctdb_connection *conn_a = a;
587 const struct ctdb_connection *conn_b = b;
590 ret = ctdb_sock_addr_cmp(&conn_a->server, &conn_b->server);
592 ret = ctdb_sock_addr_cmp(&conn_a->client, &conn_b->client);
598 int ctdb_connection_list_sort(struct ctdb_connection_list *conn_list)
600 if (conn_list == NULL) {
604 if (conn_list->num > 0) {
605 qsort(conn_list->conn, conn_list->num,
606 sizeof(struct ctdb_connection), connection_cmp);
612 const char *ctdb_connection_list_to_string(
614 struct ctdb_connection_list *conn_list, bool client_first)
619 out = talloc_strdup(mem_ctx, "");
624 if (conn_list == NULL || conn_list->num == 0) {
628 for (i = 0; i < conn_list->num; i++) {
632 ret = ctdb_connection_to_buf(buf, sizeof(buf),
633 &conn_list->conn[i], client_first);
639 out = talloc_asprintf_append(out, "%s\n", buf);
648 struct ctdb_connection_list_read_state {
649 struct ctdb_connection_list *list;
653 static int ctdb_connection_list_read_line(char *line, void *private_data)
655 struct ctdb_connection_list_read_state *state =
656 (struct ctdb_connection_list_read_state *)private_data;
657 struct ctdb_connection conn;
660 /* Skip empty lines */
661 if (line[0] == '\0') {
666 if (line[0] == '#') {
670 ret = ctdb_connection_from_string(line, state->client_first, &conn);
675 ret = ctdb_connection_list_add(state->list, &conn);
683 int ctdb_connection_list_read(TALLOC_CTX *mem_ctx,
686 struct ctdb_connection_list **conn_list)
688 struct ctdb_connection_list_read_state state;
691 if (conn_list == NULL) {
695 state.list = talloc_zero(mem_ctx, struct ctdb_connection_list);
696 if (state.list == NULL) {
700 state.client_first = client_first;
705 ctdb_connection_list_read_line,
709 *conn_list = state.list;