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"
27 #include "protocol_private.h"
28 #include "protocol_api.h"
30 size_t ctdb_uint32_len(uint32_t val)
32 return sizeof(uint32_t);
35 void ctdb_uint32_push(uint32_t val, uint8_t *buf)
37 memcpy(buf, &val, sizeof(uint32_t));
40 int ctdb_uint32_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
43 if (buflen < sizeof(uint32_t)) {
47 *out = *(uint32_t *)buf;
51 size_t ctdb_uint64_len(uint64_t val)
53 return sizeof(uint64_t);
56 void ctdb_uint64_push(uint64_t val, uint8_t *buf)
58 memcpy(buf, &val, sizeof(uint64_t));
61 int ctdb_uint64_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
64 if (buflen < sizeof(uint64_t)) {
68 *out = *(uint64_t *)buf;
72 size_t ctdb_double_len(double val)
74 return sizeof(double);
77 void ctdb_double_push(double val, uint8_t *buf)
79 memcpy(buf, &val, sizeof(double));
82 int ctdb_double_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
85 if (buflen < sizeof(double)) {
89 *out = *(double *)buf;
93 size_t ctdb_uint8_array_len(struct ctdb_uint8_array *array)
95 return array->num * sizeof(uint8_t);
98 void ctdb_uint8_array_push(struct ctdb_uint8_array *array, uint8_t *buf)
100 memcpy(buf, array->val, array->num * sizeof(uint8_t));
103 int ctdb_uint8_array_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
104 struct ctdb_uint8_array **out)
106 struct ctdb_uint8_array *array;
108 array = talloc(mem_ctx, struct ctdb_uint8_array);
113 array->num = buflen / sizeof(uint8_t);
115 array->val = talloc_array(array, uint8_t, array->num);
116 if (array->val == NULL) {
120 memcpy(array->val, buf, buflen);
126 size_t ctdb_uint64_array_len(struct ctdb_uint64_array *array)
128 return array->num * sizeof(uint64_t);
131 void ctdb_uint64_array_push(struct ctdb_uint64_array *array, uint8_t *buf)
133 memcpy(buf, array->val, array->num * sizeof(uint64_t));
136 int ctdb_uint64_array_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
137 struct ctdb_uint64_array **out)
139 struct ctdb_uint64_array *array;
141 array = talloc(mem_ctx, struct ctdb_uint64_array);
146 array->num = buflen / sizeof(uint64_t);
148 array->val = talloc_array(array, uint64_t, array->num);
149 if (array->val == NULL) {
153 memcpy(array->val, buf, buflen);
159 size_t ctdb_pid_len(pid_t pid)
161 return sizeof(pid_t);
164 void ctdb_pid_push(pid_t pid, uint8_t *buf)
166 memcpy(buf, &pid, sizeof(pid_t));
169 int ctdb_pid_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
172 if (buflen < sizeof(pid_t)) {
176 *out = *(pid_t *)buf;
180 size_t ctdb_string_len(const char *str)
185 return strlen(str) + 1;
188 void ctdb_string_push(const char *str, uint8_t *buf)
193 memcpy(buf, str, strlen(str)+1);
196 int ctdb_string_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
205 str = talloc_strndup(mem_ctx, (char *)buf, buflen);
214 struct stringn_wire {
219 size_t ctdb_stringn_len(const char *str)
221 return sizeof(uint32_t) + strlen(str) + 1;
224 void ctdb_stringn_push(const char *str, uint8_t *buf)
226 struct stringn_wire *wire = (struct stringn_wire *)buf;
231 wire->length = strlen(str) + 1;
232 memcpy(wire->str, str, wire->length);
236 int ctdb_stringn_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
240 struct stringn_wire *wire = (struct stringn_wire *)buf;
242 if (buflen < sizeof(uint32_t)) {
246 if (buflen < sizeof(uint32_t) + wire->length) {
250 str = talloc_strndup(mem_ctx, (char *)wire->str, wire->length);
259 size_t ctdb_statistics_len(struct ctdb_statistics *stats)
261 return sizeof(struct ctdb_statistics);
264 void ctdb_statistics_push(struct ctdb_statistics *stats, uint8_t *buf)
266 memcpy(buf, stats, sizeof(struct ctdb_statistics));
269 int ctdb_statistics_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
270 struct ctdb_statistics **out)
272 struct ctdb_statistics *stats;
273 struct ctdb_statistics *wire = (struct ctdb_statistics *)buf;
275 if (buflen < sizeof(struct ctdb_statistics)) {
279 stats = talloc(mem_ctx, struct ctdb_statistics);
283 memcpy(stats, wire, sizeof(struct ctdb_statistics));
289 struct ctdb_statistics_list_wire {
291 struct ctdb_statistics stats[1];
294 size_t ctdb_statistics_list_len(struct ctdb_statistics_list *stats_list)
296 return offsetof(struct ctdb_statistics_list_wire, stats) +
297 stats_list->num * sizeof(struct ctdb_statistics);
300 void ctdb_statistics_list_push(struct ctdb_statistics_list *stats_list,
303 struct ctdb_statistics_list_wire *wire =
304 (struct ctdb_statistics_list_wire *)buf;
306 wire->num = stats_list->num;
307 memcpy(wire->stats, stats_list->stats,
308 stats_list->num * sizeof(struct ctdb_statistics));
311 int ctdb_statistics_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
312 struct ctdb_statistics_list **out)
314 struct ctdb_statistics_list *stats_list;
315 struct ctdb_statistics_list_wire *wire =
316 (struct ctdb_statistics_list_wire *)buf;
318 if (buflen < offsetof(struct ctdb_statistics_list_wire, stats)) {
321 if (buflen < offsetof(struct ctdb_statistics_list_wire, stats) +
322 wire->num * sizeof(struct ctdb_statistics)) {
326 stats_list = talloc(mem_ctx, struct ctdb_statistics_list);
327 if (stats_list == NULL) {
331 stats_list->num = wire->num;
333 stats_list->stats = talloc_array(stats_list, struct ctdb_statistics,
335 if (stats_list->stats == NULL) {
336 talloc_free(stats_list);
340 memcpy(stats_list->stats, wire->stats,
341 wire->num * sizeof(struct ctdb_statistics));
347 struct ctdb_vnn_map_wire {
353 size_t ctdb_vnn_map_len(struct ctdb_vnn_map *vnnmap)
355 return offsetof(struct ctdb_vnn_map, map) +
356 vnnmap->size * sizeof(uint32_t);
359 void ctdb_vnn_map_push(struct ctdb_vnn_map *vnnmap, uint8_t *buf)
361 struct ctdb_vnn_map_wire *wire = (struct ctdb_vnn_map_wire *)buf;
363 memcpy(wire, vnnmap, offsetof(struct ctdb_vnn_map, map));
364 memcpy(wire->map, vnnmap->map, vnnmap->size * sizeof(uint32_t));
367 int ctdb_vnn_map_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
368 struct ctdb_vnn_map **out)
370 struct ctdb_vnn_map *vnnmap;
371 struct ctdb_vnn_map_wire *wire = (struct ctdb_vnn_map_wire *)buf;
373 if (buflen < offsetof(struct ctdb_vnn_map_wire, map)) {
376 if (buflen < offsetof(struct ctdb_vnn_map_wire, map) +
377 wire->size * sizeof(uint32_t)) {
381 vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
382 if (vnnmap == NULL) {
386 memcpy(vnnmap, wire, offsetof(struct ctdb_vnn_map, map));
388 vnnmap->map = talloc_memdup(vnnmap, wire->map,
389 wire->size * sizeof(uint32_t));
390 if (vnnmap->map == NULL) {
399 struct ctdb_dbid_map_wire {
401 struct ctdb_dbid dbs[1];
404 size_t ctdb_dbid_map_len(struct ctdb_dbid_map *dbmap)
406 return sizeof(uint32_t) + dbmap->num * sizeof(struct ctdb_dbid);
409 void ctdb_dbid_map_push(struct ctdb_dbid_map *dbmap, uint8_t *buf)
411 struct ctdb_dbid_map_wire *wire = (struct ctdb_dbid_map_wire *)buf;
413 wire->num = dbmap->num;
414 memcpy(wire->dbs, dbmap->dbs, dbmap->num * sizeof(struct ctdb_dbid));
417 int ctdb_dbid_map_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
418 struct ctdb_dbid_map **out)
420 struct ctdb_dbid_map *dbmap;
421 struct ctdb_dbid_map_wire *wire = (struct ctdb_dbid_map_wire *)buf;
423 if (buflen < sizeof(uint32_t)) {
426 if (buflen < sizeof(uint32_t) + wire->num * sizeof(struct ctdb_dbid)) {
430 dbmap = talloc(mem_ctx, struct ctdb_dbid_map);
435 dbmap->num = wire->num;
437 dbmap->dbs = talloc_memdup(dbmap, wire->dbs,
438 wire->num * sizeof(struct ctdb_dbid));
439 if (dbmap->dbs == NULL) {
448 size_t ctdb_pulldb_len(struct ctdb_pulldb *pulldb)
450 return sizeof(struct ctdb_pulldb);
453 void ctdb_pulldb_push(struct ctdb_pulldb *pulldb, uint8_t *buf)
455 memcpy(buf, pulldb, sizeof(struct ctdb_pulldb));
458 int ctdb_pulldb_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
459 struct ctdb_pulldb **out)
461 struct ctdb_pulldb *pulldb;
463 if (buflen < sizeof(struct ctdb_pulldb)) {
467 pulldb = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_pulldb));
468 if (pulldb == NULL) {
476 size_t ctdb_ltdb_header_len(struct ctdb_ltdb_header *header)
478 return sizeof(struct ctdb_ltdb_header);
481 void ctdb_ltdb_header_push(struct ctdb_ltdb_header *header, uint8_t *buf)
483 memcpy(buf, header, sizeof(struct ctdb_ltdb_header));
486 int ctdb_ltdb_header_pull(uint8_t *buf, size_t buflen,
487 struct ctdb_ltdb_header *header)
489 if (buflen < sizeof(struct ctdb_ltdb_header)) {
493 memcpy(header, buf, sizeof(struct ctdb_ltdb_header));
497 int ctdb_ltdb_header_extract(TDB_DATA *data, struct ctdb_ltdb_header *header)
501 ret = ctdb_ltdb_header_pull(data->dptr, data->dsize, header);
506 data->dptr += sizeof(struct ctdb_ltdb_header);
507 data->dsize -= sizeof(struct ctdb_ltdb_header);
512 struct ctdb_rec_data_wire {
520 size_t ctdb_rec_data_len(struct ctdb_rec_data *rec)
522 return offsetof(struct ctdb_rec_data_wire, data) +
523 rec->key.dsize + rec->data.dsize +
524 (rec->header == NULL ? 0 : sizeof(struct ctdb_ltdb_header));
527 void ctdb_rec_data_push(struct ctdb_rec_data *rec, uint8_t *buf)
529 struct ctdb_rec_data_wire *wire = (struct ctdb_rec_data_wire *)buf;
532 wire->length = ctdb_rec_data_len(rec);
533 wire->reqid = rec->reqid;
534 wire->keylen = rec->key.dsize;
535 wire->datalen = rec->data.dsize;
536 if (rec->header != NULL) {
537 wire->datalen += sizeof(struct ctdb_ltdb_header);
540 memcpy(wire->data, rec->key.dptr, rec->key.dsize);
541 offset = rec->key.dsize;
542 if (rec->header != NULL) {
543 memcpy(&wire->data[offset], rec->header,
544 sizeof(struct ctdb_ltdb_header));
545 offset += sizeof(struct ctdb_ltdb_header);
547 if (rec->data.dsize > 0) {
548 memcpy(&wire->data[offset], rec->data.dptr, rec->data.dsize);
552 static int ctdb_rec_data_pull_data(uint8_t *buf, size_t buflen,
554 struct ctdb_ltdb_header **header,
555 TDB_DATA *key, TDB_DATA *data,
558 struct ctdb_rec_data_wire *wire = (struct ctdb_rec_data_wire *)buf;
561 if (buflen < offsetof(struct ctdb_rec_data_wire, data)) {
564 n = offsetof(struct ctdb_rec_data_wire, data) +
565 wire->keylen + wire->datalen;
570 *reqid = wire->reqid;
572 key->dsize = wire->keylen;
573 key->dptr = wire->data;
574 offset = wire->keylen;
576 /* Always set header to NULL. If it is required, exact it using
577 * ctdb_rec_data_extract_header()
581 data->dsize = wire->datalen;
582 data->dptr = &wire->data[offset];
589 static int ctdb_rec_data_pull_elems(uint8_t *buf, size_t buflen,
591 struct ctdb_rec_data *out)
594 struct ctdb_ltdb_header *header;
599 ret = ctdb_rec_data_pull_data(buf, buflen, &reqid, &header,
600 &key, &data, &reclen);
608 out->key.dsize = key.dsize;
610 out->key.dptr = talloc_memdup(mem_ctx, key.dptr, key.dsize);
611 if (out->key.dptr == NULL) {
616 out->data.dsize = data.dsize;
617 if (data.dsize > 0) {
618 out->data.dptr = talloc_memdup(mem_ctx, data.dptr, data.dsize);
619 if (out->data.dptr == NULL) {
627 int ctdb_rec_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
628 struct ctdb_rec_data **out)
630 struct ctdb_rec_data *rec;
633 rec = talloc(mem_ctx, struct ctdb_rec_data);
638 ret = ctdb_rec_data_pull_elems(buf, buflen, rec, rec);
647 struct ctdb_rec_buffer_wire {
653 size_t ctdb_rec_buffer_len(struct ctdb_rec_buffer *recbuf)
655 return offsetof(struct ctdb_rec_buffer_wire, data) + recbuf->buflen;
658 void ctdb_rec_buffer_push(struct ctdb_rec_buffer *recbuf, uint8_t *buf)
660 struct ctdb_rec_buffer_wire *wire = (struct ctdb_rec_buffer_wire *)buf;
662 wire->db_id = recbuf->db_id;
663 wire->count = recbuf->count;
664 if (recbuf->buflen > 0) {
665 memcpy(wire->data, recbuf->buf, recbuf->buflen);
669 int ctdb_rec_buffer_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
670 struct ctdb_rec_buffer **out)
672 struct ctdb_rec_buffer *recbuf;
673 struct ctdb_rec_buffer_wire *wire = (struct ctdb_rec_buffer_wire *)buf;
676 if (buflen < offsetof(struct ctdb_rec_buffer_wire, data)) {
680 recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
681 if (recbuf == NULL) {
685 recbuf->db_id = wire->db_id;
686 recbuf->count = wire->count;
688 offset = offsetof(struct ctdb_rec_buffer_wire, data);
689 recbuf->buflen = buflen - offset;
690 recbuf->buf = talloc_memdup(recbuf, wire->data, recbuf->buflen);
691 if (recbuf->buf == NULL) {
700 struct ctdb_rec_buffer *ctdb_rec_buffer_init(TALLOC_CTX *mem_ctx,
703 struct ctdb_rec_buffer *recbuf;
705 recbuf = talloc_zero(mem_ctx, struct ctdb_rec_buffer);
706 if (recbuf == NULL) {
710 recbuf->db_id = db_id;
715 int ctdb_rec_buffer_add(TALLOC_CTX *mem_ctx, struct ctdb_rec_buffer *recbuf,
716 uint32_t reqid, struct ctdb_ltdb_header *header,
717 TDB_DATA key, TDB_DATA data)
719 struct ctdb_rec_data recdata;
723 recdata.reqid = reqid;
724 recdata.header = header;
728 len = ctdb_rec_data_len(&recdata);
730 ptr = talloc_realloc(mem_ctx, recbuf->buf, uint8_t,
731 recbuf->buflen + len);
736 ctdb_rec_data_push(&recdata, &ptr[recbuf->buflen]);
740 recbuf->buflen += len;
744 int ctdb_rec_buffer_traverse(struct ctdb_rec_buffer *recbuf,
745 ctdb_rec_parser_func_t func,
748 struct ctdb_ltdb_header *header;
751 size_t offset, reclen;
755 for (i=0; i<recbuf->count; i++) {
756 ret = ctdb_rec_data_pull_data(&recbuf->buf[offset],
757 recbuf->buflen - offset,
759 &key, &data, &reclen);
764 ret = func(reqid, header, key, data, private_data);
775 size_t ctdb_traverse_start_len(struct ctdb_traverse_start *traverse)
777 return sizeof(struct ctdb_traverse_start);
780 void ctdb_traverse_start_push(struct ctdb_traverse_start *traverse,
783 memcpy(buf, traverse, sizeof(struct ctdb_traverse_start));
786 int ctdb_traverse_start_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
787 struct ctdb_traverse_start **out)
789 struct ctdb_traverse_start *traverse;
791 if (buflen < sizeof(struct ctdb_traverse_start)) {
795 traverse = talloc_memdup(mem_ctx, buf,
796 sizeof(struct ctdb_traverse_start));
797 if (traverse == NULL) {
805 size_t ctdb_traverse_all_len(struct ctdb_traverse_all *traverse)
807 return sizeof(struct ctdb_traverse_all);
810 void ctdb_traverse_all_push(struct ctdb_traverse_all *traverse, uint8_t *buf)
812 memcpy(buf, traverse, sizeof(struct ctdb_traverse_all));
815 int ctdb_traverse_all_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
816 struct ctdb_traverse_all **out)
818 struct ctdb_traverse_all *traverse;
820 if (buflen < sizeof(struct ctdb_traverse_all)) {
824 traverse = talloc_memdup(mem_ctx, buf,
825 sizeof(struct ctdb_traverse_all));
826 if (traverse == NULL) {
834 size_t ctdb_traverse_start_ext_len(struct ctdb_traverse_start_ext *traverse)
836 return sizeof(struct ctdb_traverse_start_ext);
839 void ctdb_traverse_start_ext_push(struct ctdb_traverse_start_ext *traverse,
842 memcpy(buf, traverse, sizeof(struct ctdb_traverse_start_ext));
845 int ctdb_traverse_start_ext_pull(uint8_t *buf, size_t buflen,
847 struct ctdb_traverse_start_ext **out)
849 struct ctdb_traverse_start_ext *traverse;
851 if (buflen < sizeof(struct ctdb_traverse_start_ext)) {
855 traverse = talloc_memdup(mem_ctx, buf,
856 sizeof(struct ctdb_traverse_start_ext));
857 if (traverse == NULL) {
865 size_t ctdb_traverse_all_ext_len(struct ctdb_traverse_all_ext *traverse)
867 return sizeof(struct ctdb_traverse_all_ext);
870 void ctdb_traverse_all_ext_push(struct ctdb_traverse_all_ext *traverse,
873 memcpy(buf, traverse, sizeof(struct ctdb_traverse_all_ext));
876 int ctdb_traverse_all_ext_pull(uint8_t *buf, size_t buflen,
878 struct ctdb_traverse_all_ext **out)
880 struct ctdb_traverse_all_ext *traverse;
882 if (buflen < sizeof(struct ctdb_traverse_all_ext)) {
886 traverse = talloc_memdup(mem_ctx, buf,
887 sizeof(struct ctdb_traverse_all_ext));
888 if (traverse == NULL) {
896 size_t ctdb_sock_addr_len(ctdb_sock_addr *addr)
898 return sizeof(ctdb_sock_addr);
901 void ctdb_sock_addr_push(ctdb_sock_addr *addr, uint8_t *buf)
903 memcpy(buf, addr, sizeof(ctdb_sock_addr));
906 static int ctdb_sock_addr_pull_elems(uint8_t *buf, size_t buflen,
907 TALLOC_CTX *mem_ctx, ctdb_sock_addr *out)
909 if (buflen < sizeof(ctdb_sock_addr)) {
913 memcpy(out, buf, sizeof(ctdb_sock_addr));
918 int ctdb_sock_addr_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
919 ctdb_sock_addr **out)
921 ctdb_sock_addr *addr;
924 addr = talloc(mem_ctx, ctdb_sock_addr);
929 ret = ctdb_sock_addr_pull_elems(buf, buflen, addr, addr);
938 size_t ctdb_connection_len(struct ctdb_connection *conn)
940 return sizeof(struct ctdb_connection);
943 void ctdb_connection_push(struct ctdb_connection *conn, uint8_t *buf)
945 memcpy(buf, conn, sizeof(struct ctdb_connection));
948 static int ctdb_connection_pull_elems(uint8_t *buf, size_t buflen,
950 struct ctdb_connection *out)
952 if (buflen < sizeof(struct ctdb_connection)) {
956 memcpy(out, buf, sizeof(struct ctdb_connection));
961 int ctdb_connection_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
962 struct ctdb_connection **out)
964 struct ctdb_connection *conn;
967 conn = talloc(mem_ctx, struct ctdb_connection);
972 ret = ctdb_connection_pull_elems(buf, buflen, conn, conn);
981 struct ctdb_tunable_wire {
987 size_t ctdb_tunable_len(struct ctdb_tunable *tunable)
989 return offsetof(struct ctdb_tunable_wire, name) +
990 strlen(tunable->name) + 1;
993 void ctdb_tunable_push(struct ctdb_tunable *tunable, uint8_t *buf)
995 struct ctdb_tunable_wire *wire = (struct ctdb_tunable_wire *)buf;
997 wire->value = tunable->value;
998 wire->length = strlen(tunable->name) + 1;
999 memcpy(wire->name, tunable->name, wire->length);
1002 int ctdb_tunable_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1003 struct ctdb_tunable **out)
1005 struct ctdb_tunable *tunable;
1006 struct ctdb_tunable_wire *wire = (struct ctdb_tunable_wire *)buf;
1008 if (buflen < offsetof(struct ctdb_tunable_wire, name)) {
1011 if (buflen < offsetof(struct ctdb_tunable_wire, name) + wire->length) {
1015 tunable = talloc(mem_ctx, struct ctdb_tunable);
1016 if (tunable == NULL) {
1020 tunable->value = wire->value;
1021 tunable->name = talloc_memdup(tunable, wire->name, wire->length);
1022 if (tunable->name == NULL) {
1023 talloc_free(tunable);
1031 size_t ctdb_node_flag_change_len(struct ctdb_node_flag_change *flag_change)
1033 return sizeof(struct ctdb_node_flag_change);
1036 void ctdb_node_flag_change_push(struct ctdb_node_flag_change *flag_change,
1039 memcpy(buf, flag_change, sizeof(struct ctdb_node_flag_change));
1042 int ctdb_node_flag_change_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1043 struct ctdb_node_flag_change **out)
1045 struct ctdb_node_flag_change *flag_change;
1047 if (buflen < sizeof(struct ctdb_node_flag_change)) {
1051 flag_change = talloc_memdup(mem_ctx, buf,
1052 sizeof(struct ctdb_node_flag_change));
1053 if (flag_change == NULL) {
1061 struct ctdb_var_list_wire {
1066 size_t ctdb_var_list_len(struct ctdb_var_list *var_list)
1069 size_t len = sizeof(uint32_t);
1071 for (i=0; i<var_list->count; i++) {
1072 len += strlen(var_list->var[i]) + 1;
1077 void ctdb_var_list_push(struct ctdb_var_list *var_list, uint8_t *buf)
1079 struct ctdb_var_list_wire *wire = (struct ctdb_var_list_wire *)buf;
1083 if (var_list->count > 0) {
1084 n = sprintf(wire->list_str, "%s", var_list->var[0]);
1087 for (i=1; i<var_list->count; i++) {
1088 n = sprintf(&wire->list_str[offset], ":%s", var_list->var[i]);
1091 wire->length = offset + 1;
1094 int ctdb_var_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1095 struct ctdb_var_list **out)
1097 struct ctdb_var_list *var_list = NULL;
1098 struct ctdb_var_list_wire *wire = (struct ctdb_var_list_wire *)buf;
1099 char *str, *s, *tok, *ptr;
1102 if (buflen < sizeof(uint32_t)) {
1105 if (buflen < sizeof(uint32_t) + wire->length) {
1109 str = talloc_strndup(mem_ctx, (char *)wire->list_str, wire->length);
1114 var_list = talloc_zero(mem_ctx, struct ctdb_var_list);
1115 if (var_list == NULL) {
1120 while ((tok = strtok_r(s, ":", &ptr)) != NULL) {
1122 list = talloc_realloc(var_list, var_list->var, const char *,
1128 var_list->var = list;
1129 var_list->var[var_list->count] = talloc_strdup(var_list, tok);
1130 if (var_list->var[var_list->count] == NULL) {
1142 talloc_free(var_list);
1146 size_t ctdb_tunable_list_len(struct ctdb_tunable_list *tun_list)
1148 return sizeof(struct ctdb_tunable_list);
1151 void ctdb_tunable_list_push(struct ctdb_tunable_list *tun_list, uint8_t *buf)
1153 memcpy(buf, tun_list, sizeof(struct ctdb_tunable_list));
1156 int ctdb_tunable_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1157 struct ctdb_tunable_list **out)
1159 struct ctdb_tunable_list *tun_list;
1161 if (buflen < sizeof(struct ctdb_tunable_list)) {
1165 tun_list = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_tunable_list));
1166 if (tun_list == NULL) {
1174 struct ctdb_tickle_list_wire {
1175 ctdb_sock_addr addr;
1177 struct ctdb_connection conn[1];
1180 size_t ctdb_tickle_list_len(struct ctdb_tickle_list *tickles)
1182 return offsetof(struct ctdb_tickle_list, conn) +
1183 tickles->num * sizeof(struct ctdb_connection);
1186 void ctdb_tickle_list_push(struct ctdb_tickle_list *tickles, uint8_t *buf)
1188 struct ctdb_tickle_list_wire *wire =
1189 (struct ctdb_tickle_list_wire *)buf;
1193 memcpy(&wire->addr, &tickles->addr, sizeof(ctdb_sock_addr));
1194 wire->num = tickles->num;
1196 offset = offsetof(struct ctdb_tickle_list_wire, conn);
1197 for (i=0; i<tickles->num; i++) {
1198 ctdb_connection_push(&tickles->conn[i], &buf[offset]);
1199 offset += ctdb_connection_len(&tickles->conn[i]);
1203 int ctdb_tickle_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1204 struct ctdb_tickle_list **out)
1206 struct ctdb_tickle_list *tickles;
1207 struct ctdb_tickle_list_wire *wire =
1208 (struct ctdb_tickle_list_wire *)buf;
1212 if (buflen < offsetof(struct ctdb_tickle_list_wire, conn)) {
1215 if (buflen < offsetof(struct ctdb_tickle_list_wire, conn) +
1216 wire->num * sizeof(struct ctdb_connection)) {
1220 tickles = talloc(mem_ctx, struct ctdb_tickle_list);
1221 if (tickles == NULL) {
1225 offset = offsetof(struct ctdb_tickle_list, conn);
1226 memcpy(tickles, wire, offset);
1228 tickles->conn = talloc_array(tickles, struct ctdb_connection,
1230 if (tickles->conn == NULL) {
1231 talloc_free(tickles);
1235 for (i=0; i<wire->num; i++) {
1236 ret = ctdb_connection_pull_elems(&buf[offset], buflen-offset,
1240 talloc_free(tickles);
1243 offset += ctdb_connection_len(&tickles->conn[i]);
1250 size_t ctdb_client_id_len(struct ctdb_client_id *cid)
1252 return sizeof(struct ctdb_client_id);
1255 void ctdb_client_id_push(struct ctdb_client_id *cid, uint8_t *buf)
1257 memcpy(buf, cid, sizeof(struct ctdb_client_id));
1260 static int ctdb_client_id_pull_elems(uint8_t *buf, size_t buflen,
1261 TALLOC_CTX *mem_ctx,
1262 struct ctdb_client_id *out)
1264 if (buflen < sizeof(struct ctdb_client_id)) {
1268 memcpy(out, buf, sizeof(struct ctdb_client_id));
1273 int ctdb_client_id_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1274 struct ctdb_client_id **out)
1276 struct ctdb_client_id *cid;
1279 cid = talloc(mem_ctx, struct ctdb_client_id);
1284 ret = ctdb_client_id_pull_elems(buf, buflen, cid, cid);
1293 struct ctdb_client_id_list_wire {
1295 struct ctdb_client_id cid[1];
1298 size_t ctdb_client_id_list_len(struct ctdb_client_id_list *cid_list)
1300 return sizeof(uint32_t) +
1301 cid_list->num * sizeof(struct ctdb_client_id);
1304 void ctdb_client_id_list_push(struct ctdb_client_id_list *cid_list,
1307 struct ctdb_client_id_list_wire *wire =
1308 (struct ctdb_client_id_list_wire *)buf;
1312 wire->num = cid_list->num;
1314 offset = offsetof(struct ctdb_client_id_list_wire, cid);
1315 for (i=0; i<cid_list->num; i++) {
1316 ctdb_client_id_push(&cid_list->cid[i], &buf[offset]);
1317 offset += ctdb_client_id_len(&cid_list->cid[i]);
1321 static int ctdb_client_id_list_pull_elems(uint8_t *buf, size_t buflen,
1322 TALLOC_CTX *mem_ctx,
1323 struct ctdb_client_id_list *out)
1325 struct ctdb_client_id_list_wire *wire =
1326 (struct ctdb_client_id_list_wire *)buf;
1330 if (buflen < sizeof(uint32_t)) {
1333 if (buflen < sizeof(uint32_t) +
1334 wire->num * sizeof(struct ctdb_client_id)) {
1338 out->num = wire->num;
1339 out->cid = talloc_array(mem_ctx, struct ctdb_client_id,
1341 if (out->cid == NULL) {
1345 offset = offsetof(struct ctdb_client_id_list_wire, cid);
1346 for (i=0; i<wire->num; i++) {
1348 ret = ctdb_client_id_pull_elems(&buf[offset], buflen-offset,
1349 out->cid, &out->cid[i]);
1353 offset += ctdb_client_id_len(&out->cid[i]);
1359 int ctdb_client_id_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1360 struct ctdb_client_id_list **out)
1362 struct ctdb_client_id_list *cid_list;
1365 cid_list = talloc(mem_ctx, struct ctdb_client_id_list);
1366 if (cid_list == NULL) {
1370 ret = ctdb_client_id_list_pull_elems(buf, buflen, cid_list, cid_list);
1372 TALLOC_FREE(cid_list);
1379 struct ctdb_client_id_map_wire {
1381 struct ctdb_client_id_list list[1];
1384 size_t ctdb_client_id_map_len(struct ctdb_client_id_map *cid_map)
1390 for (i=0; i<cid_map->count; i++) {
1391 len += ctdb_client_id_list_len(&cid_map->list[i]);
1396 void ctdb_client_id_map_push(struct ctdb_client_id_map *cid_map, uint8_t *buf)
1398 struct ctdb_client_id_map_wire *wire =
1399 (struct ctdb_client_id_map_wire *)buf;
1403 wire->count = cid_map->count;
1405 offset = sizeof(int);
1406 for (i=0; i<cid_map->count; i++) {
1407 ctdb_client_id_list_push(&cid_map->list[i], &buf[offset]);
1408 offset += ctdb_client_id_list_len(&cid_map->list[i]);
1412 int ctdb_client_id_map_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1413 struct ctdb_client_id_map **out)
1415 struct ctdb_client_id_map *cid_map;
1416 struct ctdb_client_id_map_wire *wire =
1417 (struct ctdb_client_id_map_wire *)buf;
1422 if (buflen < sizeof(int)) {
1425 if (buflen < sizeof(int) +
1426 wire->count * sizeof(struct ctdb_client_id_list)) {
1430 cid_map = talloc(mem_ctx, struct ctdb_client_id_map);
1431 if (cid_map == NULL) {
1435 cid_map->count = wire->count;
1436 cid_map->list = talloc_array(cid_map, struct ctdb_client_id_list,
1438 if (cid_map->list == NULL) {
1442 offset = sizeof(int);
1443 for (i=0; i<wire->count; i++) {
1444 ret = ctdb_client_id_list_pull_elems(&buf[offset],
1449 talloc_free(cid_map);
1452 offset += ctdb_client_id_list_len(&cid_map->list[i]);
1459 struct ctdb_addr_info_wire {
1460 ctdb_sock_addr addr;
1466 size_t ctdb_addr_info_len(struct ctdb_addr_info *arp)
1470 len = offsetof(struct ctdb_addr_info_wire, iface);
1471 if (arp->iface != NULL) {
1472 len += strlen(arp->iface)+1;
1478 void ctdb_addr_info_push(struct ctdb_addr_info *addr_info, uint8_t *buf)
1480 struct ctdb_addr_info_wire *wire = (struct ctdb_addr_info_wire *)buf;
1482 wire->addr = addr_info->addr;
1483 wire->mask = addr_info->mask;
1484 if (addr_info->iface == NULL) {
1487 wire->len = strlen(addr_info->iface)+1;
1488 memcpy(wire->iface, addr_info->iface, wire->len);
1492 int ctdb_addr_info_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1493 struct ctdb_addr_info **out)
1495 struct ctdb_addr_info *addr_info;
1496 struct ctdb_addr_info_wire *wire = (struct ctdb_addr_info_wire *)buf;
1498 if (buflen < offsetof(struct ctdb_addr_info_wire, iface)) {
1501 if (buflen < offsetof(struct ctdb_addr_info_wire, iface) + wire->len) {
1505 addr_info = talloc(mem_ctx, struct ctdb_addr_info);
1506 if (addr_info == NULL) {
1510 addr_info->addr = wire->addr;
1511 addr_info->mask = wire->mask;
1513 if (wire->len == 0) {
1514 addr_info->iface = NULL;
1516 addr_info->iface = talloc_strndup(addr_info, wire->iface,
1518 if (addr_info->iface == NULL) {
1519 talloc_free(addr_info);
1528 size_t ctdb_transdb_len(struct ctdb_transdb *transdb)
1530 return sizeof(struct ctdb_transdb);
1533 void ctdb_transdb_push(struct ctdb_transdb *transdb, uint8_t *buf)
1535 memcpy(buf, transdb, sizeof(struct ctdb_transdb));
1538 int ctdb_transdb_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1539 struct ctdb_transdb **out)
1541 struct ctdb_transdb *transdb;
1543 if (buflen < sizeof(struct ctdb_transdb)) {
1547 transdb = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_transdb));
1548 if (transdb == NULL) {
1556 size_t ctdb_uptime_len(struct ctdb_uptime *uptime)
1558 return sizeof(struct ctdb_uptime);
1561 void ctdb_uptime_push(struct ctdb_uptime *uptime, uint8_t *buf)
1563 memcpy(buf, uptime, sizeof(struct ctdb_uptime));
1566 int ctdb_uptime_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1567 struct ctdb_uptime **out)
1569 struct ctdb_uptime *uptime;
1571 if (buflen < sizeof(struct ctdb_uptime)) {
1575 uptime = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_uptime));
1576 if (uptime == NULL) {
1584 size_t ctdb_public_ip_len(struct ctdb_public_ip *pubip)
1586 return sizeof(struct ctdb_public_ip);
1589 void ctdb_public_ip_push(struct ctdb_public_ip *pubip, uint8_t *buf)
1591 memcpy(buf, pubip, sizeof(struct ctdb_public_ip));
1594 static int ctdb_public_ip_pull_elems(uint8_t *buf, size_t buflen,
1595 TALLOC_CTX *mem_ctx,
1596 struct ctdb_public_ip *out)
1598 if (buflen < sizeof(struct ctdb_public_ip)) {
1602 memcpy(out, buf, sizeof(struct ctdb_public_ip));
1607 int ctdb_public_ip_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1608 struct ctdb_public_ip **out)
1610 struct ctdb_public_ip *pubip;
1613 pubip = talloc(mem_ctx, struct ctdb_public_ip);
1614 if (pubip == NULL) {
1618 ret = ctdb_public_ip_pull_elems(buf, buflen, pubip, pubip);
1627 struct ctdb_public_ip_list_wire {
1629 struct ctdb_public_ip ip[1];
1632 size_t ctdb_public_ip_list_len(struct ctdb_public_ip_list *pubip_list)
1637 len = sizeof(uint32_t);
1638 for (i=0; i<pubip_list->num; i++) {
1639 len += ctdb_public_ip_len(&pubip_list->ip[i]);
1644 void ctdb_public_ip_list_push(struct ctdb_public_ip_list *pubip_list,
1647 struct ctdb_public_ip_list_wire *wire =
1648 (struct ctdb_public_ip_list_wire *)buf;
1652 wire->num = pubip_list->num;
1654 offset = offsetof(struct ctdb_public_ip_list_wire, ip);
1655 for (i=0; i<pubip_list->num; i++) {
1656 ctdb_public_ip_push(&pubip_list->ip[i], &buf[offset]);
1657 offset += ctdb_public_ip_len(&pubip_list->ip[i]);
1661 int ctdb_public_ip_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1662 struct ctdb_public_ip_list **out)
1664 struct ctdb_public_ip_list *pubip_list;
1665 struct ctdb_public_ip_list_wire *wire =
1666 (struct ctdb_public_ip_list_wire *)buf;
1671 if (buflen < sizeof(uint32_t)) {
1674 if (buflen < sizeof(uint32_t) +
1675 wire->num * sizeof(struct ctdb_public_ip)) {
1679 pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list);
1680 if (pubip_list == NULL) {
1684 pubip_list->num = wire->num;
1685 if (wire->num == 0) {
1686 pubip_list->ip = NULL;
1690 pubip_list->ip = talloc_array(pubip_list, struct ctdb_public_ip,
1692 if (pubip_list->ip == NULL) {
1693 talloc_free(pubip_list);
1697 offset = offsetof(struct ctdb_public_ip_list_wire, ip);
1698 for (i=0; i<wire->num; i++) {
1699 ret = ctdb_public_ip_pull_elems(&buf[offset], buflen-offset,
1701 &pubip_list->ip[i]);
1703 talloc_free(pubip_list);
1706 offset += ctdb_public_ip_len(&pubip_list->ip[i]);
1713 size_t ctdb_node_and_flags_len(struct ctdb_node_and_flags *node)
1715 return sizeof(struct ctdb_node_and_flags);
1718 void ctdb_node_and_flags_push(struct ctdb_node_and_flags *node, uint8_t *buf)
1720 memcpy(buf, node, sizeof(struct ctdb_node_and_flags));
1723 static int ctdb_node_and_flags_pull_elems(TALLOC_CTX *mem_ctx,
1724 uint8_t *buf, size_t buflen,
1725 struct ctdb_node_and_flags *out)
1727 if (buflen < sizeof(struct ctdb_node_and_flags)) {
1731 memcpy(out, buf, sizeof(struct ctdb_node_and_flags));
1736 int ctdb_node_and_flags_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1737 struct ctdb_node_and_flags **out)
1739 struct ctdb_node_and_flags *node;
1742 node = talloc(mem_ctx, struct ctdb_node_and_flags);
1747 ret = ctdb_node_and_flags_pull_elems(node, buf, buflen, node);
1756 struct ctdb_node_map_wire {
1758 struct ctdb_node_and_flags node[1];
1761 size_t ctdb_node_map_len(struct ctdb_node_map *nodemap)
1763 return sizeof(uint32_t) +
1764 nodemap->num * sizeof(struct ctdb_node_and_flags);
1767 void ctdb_node_map_push(struct ctdb_node_map *nodemap, uint8_t *buf)
1769 struct ctdb_node_map_wire *wire = (struct ctdb_node_map_wire *)buf;
1773 wire->num = nodemap->num;
1775 offset = offsetof(struct ctdb_node_map_wire, node);
1776 for (i=0; i<nodemap->num; i++) {
1777 ctdb_node_and_flags_push(&nodemap->node[i], &buf[offset]);
1778 offset += ctdb_node_and_flags_len(&nodemap->node[i]);
1782 int ctdb_node_map_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1783 struct ctdb_node_map **out)
1785 struct ctdb_node_map *nodemap;
1786 struct ctdb_node_map_wire *wire = (struct ctdb_node_map_wire *)buf;
1791 nodemap = talloc(mem_ctx, struct ctdb_node_map);
1792 if (nodemap == NULL) {
1796 nodemap->num = wire->num;
1797 nodemap->node = talloc_array(nodemap, struct ctdb_node_and_flags,
1799 if (nodemap->node == NULL) {
1800 talloc_free(nodemap);
1804 offset = offsetof(struct ctdb_node_map_wire, node);
1805 for (i=0; i<wire->num; i++) {
1806 ret = ctdb_node_and_flags_pull_elems(nodemap->node,
1811 talloc_free(nodemap);
1814 offset += ctdb_node_and_flags_len(&nodemap->node[i]);
1821 size_t ctdb_script_len(struct ctdb_script *script)
1823 return sizeof(struct ctdb_script);
1826 void ctdb_script_push(struct ctdb_script *script, uint8_t *buf)
1828 memcpy(buf, script, sizeof(struct ctdb_script));
1831 static int ctdb_script_pull_elems(uint8_t *buf, size_t buflen,
1832 TALLOC_CTX *mem_ctx,
1833 struct ctdb_script *out)
1835 if (buflen < sizeof(struct ctdb_script)) {
1839 memcpy(out, buf, sizeof(struct ctdb_script));
1844 int ctdb_script_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1845 struct ctdb_script **out)
1847 struct ctdb_script *script;
1850 script = talloc(mem_ctx, struct ctdb_script);
1851 if (script == NULL) {
1855 ret = ctdb_script_pull_elems(buf, buflen, script, script);
1857 TALLOC_FREE(script);
1864 struct ctdb_script_list_wire {
1865 uint32_t num_scripts;
1866 struct ctdb_script script[1];
1869 size_t ctdb_script_list_len(struct ctdb_script_list *script_list)
1874 if (script_list == NULL) {
1878 len = offsetof(struct ctdb_script_list_wire, script);
1879 for (i=0; i<script_list->num_scripts; i++) {
1880 len += ctdb_script_len(&script_list->script[i]);
1885 void ctdb_script_list_push(struct ctdb_script_list *script_list, uint8_t *buf)
1887 struct ctdb_script_list_wire *wire =
1888 (struct ctdb_script_list_wire *)buf;
1892 if (script_list == NULL) {
1896 wire->num_scripts = script_list->num_scripts;
1898 offset = offsetof(struct ctdb_script_list_wire, script);
1899 for (i=0; i<script_list->num_scripts; i++) {
1900 ctdb_script_push(&script_list->script[i], &buf[offset]);
1901 offset += ctdb_script_len(&script_list->script[i]);
1905 int ctdb_script_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1906 struct ctdb_script_list **out)
1908 struct ctdb_script_list *script_list;
1909 struct ctdb_script_list_wire *wire =
1910 (struct ctdb_script_list_wire *)buf;
1915 /* If event scripts have never been run, the result will be NULL */
1921 offset = offsetof(struct ctdb_script_list_wire, script);
1923 if (buflen < offset) {
1926 if (buflen < offset + wire->num_scripts * sizeof(struct ctdb_script)) {
1930 script_list = talloc(mem_ctx, struct ctdb_script_list);
1931 if (script_list == NULL) {
1936 script_list->num_scripts = wire->num_scripts;
1937 script_list->script = talloc_array(script_list, struct ctdb_script,
1939 if (script_list->script == NULL) {
1940 talloc_free(script_list);
1944 for (i=0; i<wire->num_scripts; i++) {
1945 ret = ctdb_script_pull_elems(&buf[offset], buflen-offset,
1946 script_list->script,
1947 &script_list->script[i]);
1949 talloc_free(script_list);
1952 offset += ctdb_script_len(&script_list->script[i]);
1959 size_t ctdb_ban_state_len(struct ctdb_ban_state *ban_state)
1961 return sizeof(struct ctdb_ban_state);
1964 void ctdb_ban_state_push(struct ctdb_ban_state *ban_state, uint8_t *buf)
1966 memcpy(buf, ban_state, sizeof(struct ctdb_ban_state));
1969 int ctdb_ban_state_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1970 struct ctdb_ban_state **out)
1972 struct ctdb_ban_state *ban_state;
1974 if (buflen < sizeof(struct ctdb_ban_state)) {
1978 ban_state = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_ban_state));
1979 if (ban_state == NULL) {
1987 size_t ctdb_db_priority_len(struct ctdb_db_priority *db_prio)
1989 return sizeof(struct ctdb_db_priority);
1992 void ctdb_db_priority_push(struct ctdb_db_priority *db_prio, uint8_t *buf)
1994 memcpy(buf, db_prio, sizeof(struct ctdb_db_priority));
1997 int ctdb_db_priority_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1998 struct ctdb_db_priority **out)
2000 struct ctdb_db_priority *db_prio;
2002 if (buflen < sizeof(struct ctdb_db_priority)) {
2006 db_prio = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_db_priority));
2007 if (db_prio == NULL) {
2015 struct ctdb_notify_data_wire {
2021 size_t ctdb_notify_data_len(struct ctdb_notify_data *notify)
2023 return offsetof(struct ctdb_notify_data_wire, data) +
2027 void ctdb_notify_data_push(struct ctdb_notify_data *notify, uint8_t *buf)
2029 struct ctdb_notify_data_wire *wire =
2030 (struct ctdb_notify_data_wire *)buf;
2032 wire->srvid = notify->srvid;
2033 wire->len = notify->data.dsize;
2034 memcpy(wire->data, notify->data.dptr, notify->data.dsize);
2037 int ctdb_notify_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2038 struct ctdb_notify_data **out)
2040 struct ctdb_notify_data *notify;
2041 struct ctdb_notify_data_wire *wire =
2042 (struct ctdb_notify_data_wire *)buf;
2044 if (buflen < offsetof(struct ctdb_notify_data_wire, data)) {
2047 if (buflen < offsetof(struct ctdb_notify_data_wire, data) + wire->len) {
2051 notify = talloc(mem_ctx, struct ctdb_notify_data);
2052 if (notify == NULL) {
2056 notify->srvid = wire->srvid;
2057 notify->data.dsize = wire->len;
2058 notify->data.dptr = talloc_memdup(notify, wire->data, wire->len);
2059 if (notify->data.dptr == NULL) {
2060 talloc_free(notify);
2068 size_t ctdb_iface_len(struct ctdb_iface *iface)
2070 return sizeof(struct ctdb_iface);
2073 void ctdb_iface_push(struct ctdb_iface *iface, uint8_t *buf)
2075 memcpy(buf, iface, sizeof(struct ctdb_iface));
2078 static int ctdb_iface_pull_elems(uint8_t *buf, size_t buflen,
2079 TALLOC_CTX *mem_ctx,
2080 struct ctdb_iface *out)
2082 if (buflen < sizeof(struct ctdb_iface)) {
2086 memcpy(out, buf, sizeof(struct ctdb_iface));
2091 int ctdb_iface_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2092 struct ctdb_iface **out)
2094 struct ctdb_iface *iface;
2097 iface = talloc(mem_ctx, struct ctdb_iface);
2098 if (iface == NULL) {
2102 ret = ctdb_iface_pull_elems(buf, buflen, iface, iface);
2111 struct ctdb_iface_list_wire {
2113 struct ctdb_iface iface[1];
2116 size_t ctdb_iface_list_len(struct ctdb_iface_list *iface_list)
2118 return sizeof(uint32_t) +
2119 iface_list->num * sizeof(struct ctdb_iface);
2122 void ctdb_iface_list_push(struct ctdb_iface_list *iface_list, uint8_t *buf)
2124 struct ctdb_iface_list_wire *wire =
2125 (struct ctdb_iface_list_wire *)buf;
2127 wire->num = iface_list->num;
2128 memcpy(wire->iface, iface_list->iface,
2129 iface_list->num * sizeof(struct ctdb_iface));
2132 int ctdb_iface_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2133 struct ctdb_iface_list **out)
2135 struct ctdb_iface_list *iface_list;
2136 struct ctdb_iface_list_wire *wire =
2137 (struct ctdb_iface_list_wire *)buf;
2139 if (buflen < sizeof(uint32_t)) {
2142 if (buflen < sizeof(uint32_t) + wire->num * sizeof(struct ctdb_iface)) {
2146 iface_list = talloc(mem_ctx, struct ctdb_iface_list);
2147 if (iface_list == NULL) {
2151 iface_list->num = wire->num;
2152 iface_list->iface = talloc_array(iface_list, struct ctdb_iface,
2154 if (iface_list->iface == NULL) {
2155 talloc_free(iface_list);
2159 memcpy(iface_list->iface, wire->iface,
2160 wire->num * sizeof(struct ctdb_iface));
2166 struct ctdb_public_ip_info_wire {
2167 struct ctdb_public_ip ip;
2168 uint32_t active_idx;
2170 struct ctdb_iface ifaces[1];
2173 size_t ctdb_public_ip_info_len(struct ctdb_public_ip_info *ipinfo)
2175 return offsetof(struct ctdb_public_ip_info_wire, num) +
2176 ctdb_iface_list_len(ipinfo->ifaces);
2179 void ctdb_public_ip_info_push(struct ctdb_public_ip_info *ipinfo, uint8_t *buf)
2181 struct ctdb_public_ip_info_wire *wire =
2182 (struct ctdb_public_ip_info_wire *)buf;
2185 offset = offsetof(struct ctdb_public_ip_info_wire, num);
2186 memcpy(wire, ipinfo, offset);
2187 wire->num = ipinfo->ifaces->num;
2188 memcpy(wire->ifaces, ipinfo->ifaces->iface,
2189 ipinfo->ifaces->num * sizeof(struct ctdb_iface));
2192 int ctdb_public_ip_info_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2193 struct ctdb_public_ip_info **out)
2195 struct ctdb_public_ip_info *ipinfo;
2196 struct ctdb_public_ip_info_wire *wire =
2197 (struct ctdb_public_ip_info_wire *)buf;
2199 if (buflen < offsetof(struct ctdb_public_ip_info_wire, ifaces)) {
2203 ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info);
2204 if (ipinfo == NULL) {
2208 memcpy(ipinfo, wire, offsetof(struct ctdb_public_ip_info_wire, num));
2210 ipinfo->ifaces = talloc(ipinfo, struct ctdb_iface_list);
2211 if (ipinfo->ifaces == NULL) {
2212 talloc_free(ipinfo);
2216 ipinfo->ifaces->num = wire->num;
2217 ipinfo->ifaces->iface = talloc_array(ipinfo->ifaces, struct ctdb_iface,
2219 if (ipinfo->ifaces->iface == NULL) {
2220 talloc_free(ipinfo);
2224 memcpy(ipinfo->ifaces->iface, wire->ifaces,
2225 wire->num * sizeof(struct ctdb_iface));
2231 struct ctdb_key_data_wire {
2233 struct ctdb_ltdb_header header;
2238 size_t ctdb_key_data_len(struct ctdb_key_data *key)
2240 return offsetof(struct ctdb_key_data_wire, key) + key->key.dsize;
2243 void ctdb_key_data_push(struct ctdb_key_data *key, uint8_t *buf)
2245 struct ctdb_key_data_wire *wire = (struct ctdb_key_data_wire *)buf;
2247 memcpy(wire, key, offsetof(struct ctdb_key_data, key));
2248 wire->keylen = key->key.dsize;
2249 memcpy(wire->key, key->key.dptr, key->key.dsize);
2252 int ctdb_key_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2253 struct ctdb_key_data **out)
2255 struct ctdb_key_data *key_data;
2256 struct ctdb_key_data_wire *wire = (struct ctdb_key_data_wire *)buf;
2258 if (buflen < offsetof(struct ctdb_key_data_wire, key)) {
2261 if (buflen < offsetof(struct ctdb_key_data_wire, key) + wire->keylen) {
2265 key_data = talloc(mem_ctx, struct ctdb_key_data);
2266 if (key_data == NULL) {
2270 memcpy(key_data, wire, offsetof(struct ctdb_key_data, key));
2272 key_data->key.dsize = wire->keylen;
2273 key_data->key.dptr = talloc_memdup(key_data, wire->key, wire->keylen);
2274 if (key_data->key.dptr == NULL) {
2275 talloc_free(key_data);
2283 struct ctdb_db_statistics_wire {
2284 struct ctdb_db_statistics dbstats;
2285 char hot_keys_wire[1];
2288 size_t ctdb_db_statistics_len(struct ctdb_db_statistics *dbstats)
2293 len = sizeof(struct ctdb_db_statistics);
2294 for (i=0; i<MAX_HOT_KEYS; i++) {
2295 len += dbstats->hot_keys[i].key.dsize;
2300 void ctdb_db_statistics_push(struct ctdb_db_statistics *dbstats, void *buf)
2302 struct ctdb_db_statistics_wire *wire =
2303 (struct ctdb_db_statistics_wire *)buf;
2307 dbstats->num_hot_keys = MAX_HOT_KEYS;
2308 memcpy(wire, dbstats, sizeof(struct ctdb_db_statistics));
2311 for (i=0; i<MAX_HOT_KEYS; i++) {
2312 memcpy(&wire->hot_keys_wire[offset],
2313 dbstats->hot_keys[i].key.dptr,
2314 dbstats->hot_keys[i].key.dsize);
2315 offset += dbstats->hot_keys[i].key.dsize;
2319 int ctdb_db_statistics_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2320 struct ctdb_db_statistics **out)
2322 struct ctdb_db_statistics *dbstats;
2323 struct ctdb_db_statistics_wire *wire =
2324 (struct ctdb_db_statistics_wire *)buf;
2328 if (buflen < sizeof(struct ctdb_db_statistics)) {
2332 for (i=0; i<wire->dbstats.num_hot_keys; i++) {
2333 offset += wire->dbstats.hot_keys[i].key.dsize;
2335 if (buflen < sizeof(struct ctdb_db_statistics) + offset) {
2339 dbstats = talloc(mem_ctx, struct ctdb_db_statistics);
2340 if (dbstats == NULL) {
2344 memcpy(dbstats, wire, sizeof(struct ctdb_db_statistics));
2347 for (i=0; i<wire->dbstats.num_hot_keys; i++) {
2351 key_size = dbstats->hot_keys[i].key.dsize;
2352 ptr = talloc_memdup(mem_ctx, &wire->hot_keys_wire[offset],
2355 talloc_free(dbstats);
2358 dbstats->hot_keys[i].key.dptr = ptr;
2366 size_t ctdb_election_message_len(struct ctdb_election_message *election)
2368 return sizeof(struct ctdb_election_message);
2371 void ctdb_election_message_push(struct ctdb_election_message *election,
2374 memcpy(buf, election, sizeof(struct ctdb_election_message));
2377 int ctdb_election_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2378 struct ctdb_election_message **out)
2380 struct ctdb_election_message *election;
2382 if (buflen < sizeof(struct ctdb_election_message)) {
2386 election = talloc_memdup(mem_ctx, buf,
2387 sizeof(struct ctdb_election_message));
2388 if (election == NULL) {
2396 size_t ctdb_srvid_message_len(struct ctdb_srvid_message *msg)
2398 return sizeof(struct ctdb_srvid_message);
2401 void ctdb_srvid_message_push(struct ctdb_srvid_message *msg, uint8_t *buf)
2403 memcpy(buf, msg, sizeof(struct ctdb_srvid_message));
2406 int ctdb_srvid_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2407 struct ctdb_srvid_message **out)
2409 struct ctdb_srvid_message *msg;
2411 if (buflen < sizeof(struct ctdb_srvid_message)) {
2415 msg = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_srvid_message));
2424 size_t ctdb_disable_message_len(struct ctdb_disable_message *disable)
2426 return sizeof(struct ctdb_disable_message);
2429 void ctdb_disable_message_push(struct ctdb_disable_message *disable,
2432 memcpy(buf, disable, sizeof(struct ctdb_disable_message));
2435 int ctdb_disable_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2436 struct ctdb_disable_message **out)
2438 struct ctdb_disable_message *disable;
2440 if (buflen < sizeof(struct ctdb_disable_message)) {
2444 disable = talloc_memdup(mem_ctx, buf,
2445 sizeof(struct ctdb_disable_message));
2446 if (disable == NULL) {
2454 size_t ctdb_tdb_data_len(TDB_DATA data)
2459 void ctdb_tdb_data_push(TDB_DATA data, uint8_t *buf)
2461 memcpy(buf, data.dptr, data.dsize);
2464 int ctdb_tdb_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2469 data.dsize = buflen;
2470 if (data.dsize > 0) {
2471 data.dptr = talloc_memdup(mem_ctx, buf, buflen);
2472 if (data.dptr == NULL) {
2483 size_t ctdb_server_id_len(struct ctdb_server_id *sid)
2485 return sizeof(struct ctdb_server_id);
2488 void ctdb_server_id_push(struct ctdb_server_id *sid, uint8_t *buf)
2490 memcpy(buf, sid, sizeof(struct ctdb_server_id));
2493 int ctdb_server_id_pull(uint8_t *buf, size_t buflen,
2494 struct ctdb_server_id *sid)
2496 if (buflen < sizeof(struct ctdb_server_id)) {
2500 memcpy(sid, buf, sizeof(struct ctdb_server_id));
2504 size_t ctdb_g_lock_len(struct ctdb_g_lock *lock)
2506 return sizeof(struct ctdb_g_lock);
2509 void ctdb_g_lock_push(struct ctdb_g_lock *lock, uint8_t *buf)
2511 memcpy(buf, lock, sizeof(struct ctdb_g_lock));
2514 int ctdb_g_lock_pull(uint8_t *buf, size_t buflen, struct ctdb_g_lock *lock)
2516 if (buflen < sizeof(struct ctdb_g_lock)) {
2520 memcpy(lock, buf, sizeof(struct ctdb_g_lock));
2524 size_t ctdb_g_lock_list_len(struct ctdb_g_lock_list *lock_list)
2526 return lock_list->num * sizeof(struct ctdb_g_lock);
2529 void ctdb_g_lock_list_push(struct ctdb_g_lock_list *lock_list, uint8_t *buf)
2534 for (i=0; i<lock_list->num; i++) {
2535 ctdb_g_lock_push(&lock_list->lock[i], &buf[offset]);
2536 offset += sizeof(struct ctdb_g_lock);
2540 int ctdb_g_lock_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2541 struct ctdb_g_lock_list **out)
2543 struct ctdb_g_lock_list *lock_list;
2548 lock_list = talloc_zero(mem_ctx, struct ctdb_g_lock_list);
2549 if (lock_list == NULL) {
2553 count = buflen / sizeof(struct ctdb_g_lock);
2554 lock_list->lock = talloc_array(lock_list, struct ctdb_g_lock, count);
2555 if (lock_list->lock == NULL) {
2556 talloc_free(lock_list);
2561 for (i=0; i<count; i++) {
2562 ret = ctdb_g_lock_pull(&buf[offset], buflen-offset,
2563 &lock_list->lock[i]);
2565 talloc_free(lock_list);
2568 offset += sizeof(struct ctdb_g_lock);
2571 lock_list->num = count;