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 struct ctdb_rec_data_wire {
505 size_t ctdb_rec_data_len(struct ctdb_rec_data *rec)
507 return offsetof(struct ctdb_rec_data_wire, data) +
508 rec->key.dsize + rec->data.dsize +
509 (rec->header == NULL ? 0 : sizeof(struct ctdb_ltdb_header));
512 void ctdb_rec_data_push(struct ctdb_rec_data *rec, uint8_t *buf)
514 struct ctdb_rec_data_wire *wire = (struct ctdb_rec_data_wire *)buf;
517 wire->length = ctdb_rec_data_len(rec);
518 wire->reqid = rec->reqid;
519 wire->keylen = rec->key.dsize;
520 wire->datalen = rec->data.dsize;
522 memcpy(wire->data, rec->key.dptr, rec->key.dsize);
523 offset = rec->key.dsize;
524 if (rec->header != NULL) {
525 memcpy(&wire->data[offset], rec->header,
526 sizeof(struct ctdb_ltdb_header));
527 offset += sizeof(struct ctdb_ltdb_header);
529 if (rec->data.dsize > 0) {
530 memcpy(&wire->data[offset], rec->data.dptr, rec->data.dsize);
534 static int ctdb_rec_data_pull_data(uint8_t *buf, size_t buflen,
536 struct ctdb_ltdb_header **header,
537 TDB_DATA *key, TDB_DATA *data,
540 struct ctdb_rec_data_wire *wire = (struct ctdb_rec_data_wire *)buf;
543 if (buflen < offsetof(struct ctdb_rec_data_wire, data)) {
546 n = offsetof(struct ctdb_rec_data_wire, data) +
547 wire->keylen + wire->datalen;
552 *reqid = wire->reqid;
554 key->dsize = wire->keylen;
555 key->dptr = wire->data;
556 offset = wire->keylen;
558 if (wire->length - n == sizeof(struct ctdb_ltdb_header)) {
559 *header = (struct ctdb_ltdb_header *)&wire->data[offset];
560 offset += sizeof(struct ctdb_ltdb_header);
565 data->dsize = wire->datalen;
566 data->dptr = &wire->data[offset];
573 static int ctdb_rec_data_pull_elems(uint8_t *buf, size_t buflen,
575 struct ctdb_rec_data *out)
578 struct ctdb_ltdb_header *header;
583 ret = ctdb_rec_data_pull_data(buf, buflen, &reqid, &header,
584 &key, &data, &reclen);
591 if (header != NULL) {
592 out->header = talloc_memdup(mem_ctx, header,
593 sizeof(struct ctdb_ltdb_header));
594 if (out->header == NULL) {
601 out->key.dsize = key.dsize;
603 out->key.dptr = talloc_memdup(mem_ctx, key.dptr, key.dsize);
604 if (out->key.dptr == NULL) {
609 out->data.dsize = data.dsize;
610 if (data.dsize > 0) {
611 out->data.dptr = talloc_memdup(mem_ctx, data.dptr, data.dsize);
612 if (out->data.dptr == NULL) {
620 int ctdb_rec_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
621 struct ctdb_rec_data **out)
623 struct ctdb_rec_data *rec;
626 rec = talloc(mem_ctx, struct ctdb_rec_data);
631 ret = ctdb_rec_data_pull_elems(buf, buflen, rec, rec);
640 struct ctdb_rec_buffer_wire {
646 size_t ctdb_rec_buffer_len(struct ctdb_rec_buffer *recbuf)
648 return offsetof(struct ctdb_rec_buffer_wire, data) + recbuf->buflen;
651 void ctdb_rec_buffer_push(struct ctdb_rec_buffer *recbuf, uint8_t *buf)
653 struct ctdb_rec_buffer_wire *wire = (struct ctdb_rec_buffer_wire *)buf;
655 wire->db_id = recbuf->db_id;
656 wire->count = recbuf->count;
657 if (recbuf->buflen > 0) {
658 memcpy(wire->data, recbuf->buf, recbuf->buflen);
662 int ctdb_rec_buffer_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
663 struct ctdb_rec_buffer **out)
665 struct ctdb_rec_buffer *recbuf;
666 struct ctdb_rec_buffer_wire *wire = (struct ctdb_rec_buffer_wire *)buf;
669 if (buflen < offsetof(struct ctdb_rec_buffer_wire, data)) {
673 recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
674 if (recbuf == NULL) {
678 recbuf->db_id = wire->db_id;
679 recbuf->count = wire->count;
681 offset = offsetof(struct ctdb_rec_buffer_wire, data);
682 recbuf->buflen = buflen - offset;
683 recbuf->buf = talloc_memdup(recbuf, wire->data, recbuf->buflen);
684 if (recbuf->buf == NULL) {
693 struct ctdb_rec_buffer *ctdb_rec_buffer_init(TALLOC_CTX *mem_ctx,
696 struct ctdb_rec_buffer *recbuf;
698 recbuf = talloc_zero(mem_ctx, struct ctdb_rec_buffer);
699 if (recbuf == NULL) {
703 recbuf->db_id = db_id;
708 int ctdb_rec_buffer_add(TALLOC_CTX *mem_ctx, struct ctdb_rec_buffer *recbuf,
709 uint32_t reqid, struct ctdb_ltdb_header *header,
710 TDB_DATA key, TDB_DATA data)
712 struct ctdb_rec_data recdata;
716 recdata.reqid = reqid;
717 recdata.header = header;
721 len = ctdb_rec_data_len(&recdata);
723 ptr = talloc_realloc(mem_ctx, recbuf->buf, uint8_t,
724 recbuf->buflen + len);
729 ctdb_rec_data_push(&recdata, &ptr[recbuf->buflen]);
733 recbuf->buflen += len;
737 int ctdb_rec_buffer_traverse(struct ctdb_rec_buffer *recbuf,
738 ctdb_rec_parser_func_t func,
741 struct ctdb_ltdb_header *header;
744 size_t offset, reclen;
748 for (i=0; i<recbuf->count; i++) {
749 ret = ctdb_rec_data_pull_data(&recbuf->buf[offset],
750 recbuf->buflen - offset,
752 &key, &data, &reclen);
757 ret = func(reqid, header, key, data, private_data);
768 size_t ctdb_traverse_start_len(struct ctdb_traverse_start *traverse)
770 return sizeof(struct ctdb_traverse_start);
773 void ctdb_traverse_start_push(struct ctdb_traverse_start *traverse,
776 memcpy(buf, traverse, sizeof(struct ctdb_traverse_start));
779 int ctdb_traverse_start_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
780 struct ctdb_traverse_start **out)
782 struct ctdb_traverse_start *traverse;
784 if (buflen < sizeof(struct ctdb_traverse_start)) {
788 traverse = talloc_memdup(mem_ctx, buf,
789 sizeof(struct ctdb_traverse_start));
790 if (traverse == NULL) {
798 size_t ctdb_traverse_all_len(struct ctdb_traverse_all *traverse)
800 return sizeof(struct ctdb_traverse_all);
803 void ctdb_traverse_all_push(struct ctdb_traverse_all *traverse, uint8_t *buf)
805 memcpy(buf, traverse, sizeof(struct ctdb_traverse_all));
808 int ctdb_traverse_all_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
809 struct ctdb_traverse_all **out)
811 struct ctdb_traverse_all *traverse;
813 if (buflen < sizeof(struct ctdb_traverse_all)) {
817 traverse = talloc_memdup(mem_ctx, buf,
818 sizeof(struct ctdb_traverse_all));
819 if (traverse == NULL) {
827 size_t ctdb_traverse_start_ext_len(struct ctdb_traverse_start_ext *traverse)
829 return sizeof(struct ctdb_traverse_start_ext);
832 void ctdb_traverse_start_ext_push(struct ctdb_traverse_start_ext *traverse,
835 memcpy(buf, traverse, sizeof(struct ctdb_traverse_start_ext));
838 int ctdb_traverse_start_ext_pull(uint8_t *buf, size_t buflen,
840 struct ctdb_traverse_start_ext **out)
842 struct ctdb_traverse_start_ext *traverse;
844 if (buflen < sizeof(struct ctdb_traverse_start_ext)) {
848 traverse = talloc_memdup(mem_ctx, buf,
849 sizeof(struct ctdb_traverse_start_ext));
850 if (traverse == NULL) {
858 size_t ctdb_traverse_all_ext_len(struct ctdb_traverse_all_ext *traverse)
860 return sizeof(struct ctdb_traverse_all_ext);
863 void ctdb_traverse_all_ext_push(struct ctdb_traverse_all_ext *traverse,
866 memcpy(buf, traverse, sizeof(struct ctdb_traverse_all_ext));
869 int ctdb_traverse_all_ext_pull(uint8_t *buf, size_t buflen,
871 struct ctdb_traverse_all_ext **out)
873 struct ctdb_traverse_all_ext *traverse;
875 if (buflen < sizeof(struct ctdb_traverse_all_ext)) {
879 traverse = talloc_memdup(mem_ctx, buf,
880 sizeof(struct ctdb_traverse_all_ext));
881 if (traverse == NULL) {
889 size_t ctdb_sock_addr_len(ctdb_sock_addr *addr)
891 return sizeof(ctdb_sock_addr);
894 void ctdb_sock_addr_push(ctdb_sock_addr *addr, uint8_t *buf)
896 memcpy(buf, addr, sizeof(ctdb_sock_addr));
899 static int ctdb_sock_addr_pull_elems(uint8_t *buf, size_t buflen,
900 TALLOC_CTX *mem_ctx, ctdb_sock_addr *out)
902 if (buflen < sizeof(ctdb_sock_addr)) {
906 memcpy(out, buf, sizeof(ctdb_sock_addr));
911 int ctdb_sock_addr_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
912 ctdb_sock_addr **out)
914 ctdb_sock_addr *addr;
917 addr = talloc(mem_ctx, ctdb_sock_addr);
922 ret = ctdb_sock_addr_pull_elems(buf, buflen, addr, addr);
931 size_t ctdb_connection_len(struct ctdb_connection *conn)
933 return sizeof(struct ctdb_connection);
936 void ctdb_connection_push(struct ctdb_connection *conn, uint8_t *buf)
938 memcpy(buf, conn, sizeof(struct ctdb_connection));
941 static int ctdb_connection_pull_elems(uint8_t *buf, size_t buflen,
943 struct ctdb_connection *out)
945 if (buflen < sizeof(struct ctdb_connection)) {
949 memcpy(out, buf, sizeof(struct ctdb_connection));
954 int ctdb_connection_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
955 struct ctdb_connection **out)
957 struct ctdb_connection *conn;
960 conn = talloc(mem_ctx, struct ctdb_connection);
965 ret = ctdb_connection_pull_elems(buf, buflen, conn, conn);
974 struct ctdb_tunable_wire {
980 size_t ctdb_tunable_len(struct ctdb_tunable *tunable)
982 return offsetof(struct ctdb_tunable_wire, name) +
983 strlen(tunable->name) + 1;
986 void ctdb_tunable_push(struct ctdb_tunable *tunable, uint8_t *buf)
988 struct ctdb_tunable_wire *wire = (struct ctdb_tunable_wire *)buf;
990 wire->value = tunable->value;
991 wire->length = strlen(tunable->name) + 1;
992 memcpy(wire->name, tunable->name, wire->length);
995 int ctdb_tunable_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
996 struct ctdb_tunable **out)
998 struct ctdb_tunable *tunable;
999 struct ctdb_tunable_wire *wire = (struct ctdb_tunable_wire *)buf;
1001 if (buflen < offsetof(struct ctdb_tunable_wire, name)) {
1004 if (buflen < offsetof(struct ctdb_tunable_wire, name) + wire->length) {
1008 tunable = talloc(mem_ctx, struct ctdb_tunable);
1009 if (tunable == NULL) {
1013 tunable->value = wire->value;
1014 tunable->name = talloc_memdup(tunable, wire->name, wire->length);
1015 if (tunable->name == NULL) {
1016 talloc_free(tunable);
1024 size_t ctdb_node_flag_change_len(struct ctdb_node_flag_change *flag_change)
1026 return sizeof(struct ctdb_node_flag_change);
1029 void ctdb_node_flag_change_push(struct ctdb_node_flag_change *flag_change,
1032 memcpy(buf, flag_change, sizeof(struct ctdb_node_flag_change));
1035 int ctdb_node_flag_change_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1036 struct ctdb_node_flag_change **out)
1038 struct ctdb_node_flag_change *flag_change;
1040 if (buflen < sizeof(struct ctdb_node_flag_change)) {
1044 flag_change = talloc_memdup(mem_ctx, buf,
1045 sizeof(struct ctdb_node_flag_change));
1046 if (flag_change == NULL) {
1054 struct ctdb_var_list_wire {
1059 size_t ctdb_var_list_len(struct ctdb_var_list *var_list)
1062 size_t len = sizeof(uint32_t);
1064 for (i=0; i<var_list->count; i++) {
1065 len += strlen(var_list->var[i]) + 1;
1070 void ctdb_var_list_push(struct ctdb_var_list *var_list, uint8_t *buf)
1072 struct ctdb_var_list_wire *wire = (struct ctdb_var_list_wire *)buf;
1076 if (var_list->count > 0) {
1077 n = sprintf(wire->list_str, "%s", var_list->var[0]);
1080 for (i=1; i<var_list->count; i++) {
1081 n = sprintf(&wire->list_str[offset], ":%s", var_list->var[i]);
1084 wire->length = offset + 1;
1087 int ctdb_var_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1088 struct ctdb_var_list **out)
1090 struct ctdb_var_list *var_list = NULL;
1091 struct ctdb_var_list_wire *wire = (struct ctdb_var_list_wire *)buf;
1092 char *str, *s, *tok, *ptr;
1095 if (buflen < sizeof(uint32_t)) {
1098 if (buflen < sizeof(uint32_t) + wire->length) {
1102 str = talloc_strndup(mem_ctx, (char *)wire->list_str, wire->length);
1107 var_list = talloc_zero(mem_ctx, struct ctdb_var_list);
1108 if (var_list == NULL) {
1113 while ((tok = strtok_r(s, ":", &ptr)) != NULL) {
1115 list = talloc_realloc(var_list, var_list->var, const char *,
1121 var_list->var = list;
1122 var_list->var[var_list->count] = talloc_strdup(var_list, tok);
1123 if (var_list->var[var_list->count] == NULL) {
1135 talloc_free(var_list);
1139 size_t ctdb_tunable_list_len(struct ctdb_tunable_list *tun_list)
1141 return sizeof(struct ctdb_tunable_list);
1144 void ctdb_tunable_list_push(struct ctdb_tunable_list *tun_list, uint8_t *buf)
1146 memcpy(buf, tun_list, sizeof(struct ctdb_tunable_list));
1149 int ctdb_tunable_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1150 struct ctdb_tunable_list **out)
1152 struct ctdb_tunable_list *tun_list;
1154 if (buflen < sizeof(struct ctdb_tunable_list)) {
1158 tun_list = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_tunable_list));
1159 if (tun_list == NULL) {
1167 struct ctdb_tickle_list_wire {
1168 ctdb_sock_addr addr;
1170 struct ctdb_connection conn[1];
1173 size_t ctdb_tickle_list_len(struct ctdb_tickle_list *tickles)
1175 return offsetof(struct ctdb_tickle_list, conn) +
1176 tickles->num * sizeof(struct ctdb_connection);
1179 void ctdb_tickle_list_push(struct ctdb_tickle_list *tickles, uint8_t *buf)
1181 struct ctdb_tickle_list_wire *wire =
1182 (struct ctdb_tickle_list_wire *)buf;
1186 memcpy(&wire->addr, &tickles->addr, sizeof(ctdb_sock_addr));
1187 wire->num = tickles->num;
1189 offset = offsetof(struct ctdb_tickle_list_wire, conn);
1190 for (i=0; i<tickles->num; i++) {
1191 ctdb_connection_push(&tickles->conn[i], &buf[offset]);
1192 offset += ctdb_connection_len(&tickles->conn[i]);
1196 int ctdb_tickle_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1197 struct ctdb_tickle_list **out)
1199 struct ctdb_tickle_list *tickles;
1200 struct ctdb_tickle_list_wire *wire =
1201 (struct ctdb_tickle_list_wire *)buf;
1205 if (buflen < offsetof(struct ctdb_tickle_list_wire, conn)) {
1208 if (buflen < offsetof(struct ctdb_tickle_list_wire, conn) +
1209 wire->num * sizeof(struct ctdb_connection)) {
1213 tickles = talloc(mem_ctx, struct ctdb_tickle_list);
1214 if (tickles == NULL) {
1218 offset = offsetof(struct ctdb_tickle_list, conn);
1219 memcpy(tickles, wire, offset);
1221 tickles->conn = talloc_array(tickles, struct ctdb_connection,
1223 if (tickles->conn == NULL) {
1224 talloc_free(tickles);
1228 for (i=0; i<wire->num; i++) {
1229 ret = ctdb_connection_pull_elems(&buf[offset], buflen-offset,
1233 talloc_free(tickles);
1236 offset += ctdb_connection_len(&tickles->conn[i]);
1243 size_t ctdb_client_id_len(struct ctdb_client_id *cid)
1245 return sizeof(struct ctdb_client_id);
1248 void ctdb_client_id_push(struct ctdb_client_id *cid, uint8_t *buf)
1250 memcpy(buf, cid, sizeof(struct ctdb_client_id));
1253 static int ctdb_client_id_pull_elems(uint8_t *buf, size_t buflen,
1254 TALLOC_CTX *mem_ctx,
1255 struct ctdb_client_id *out)
1257 if (buflen < sizeof(struct ctdb_client_id)) {
1261 memcpy(out, buf, sizeof(struct ctdb_client_id));
1266 int ctdb_client_id_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1267 struct ctdb_client_id **out)
1269 struct ctdb_client_id *cid;
1272 cid = talloc(mem_ctx, struct ctdb_client_id);
1277 ret = ctdb_client_id_pull_elems(buf, buflen, cid, cid);
1286 struct ctdb_client_id_list_wire {
1288 struct ctdb_client_id cid[1];
1291 size_t ctdb_client_id_list_len(struct ctdb_client_id_list *cid_list)
1293 return sizeof(uint32_t) +
1294 cid_list->num * sizeof(struct ctdb_client_id);
1297 void ctdb_client_id_list_push(struct ctdb_client_id_list *cid_list,
1300 struct ctdb_client_id_list_wire *wire =
1301 (struct ctdb_client_id_list_wire *)buf;
1305 wire->num = cid_list->num;
1307 offset = offsetof(struct ctdb_client_id_list_wire, cid);
1308 for (i=0; i<cid_list->num; i++) {
1309 ctdb_client_id_push(&cid_list->cid[i], &buf[offset]);
1310 offset += ctdb_client_id_len(&cid_list->cid[i]);
1314 static int ctdb_client_id_list_pull_elems(uint8_t *buf, size_t buflen,
1315 TALLOC_CTX *mem_ctx,
1316 struct ctdb_client_id_list *out)
1318 struct ctdb_client_id_list_wire *wire =
1319 (struct ctdb_client_id_list_wire *)buf;
1323 if (buflen < sizeof(uint32_t)) {
1326 if (buflen < sizeof(uint32_t) +
1327 wire->num * sizeof(struct ctdb_client_id)) {
1331 out->num = wire->num;
1332 out->cid = talloc_array(mem_ctx, struct ctdb_client_id,
1334 if (out->cid == NULL) {
1338 offset = offsetof(struct ctdb_client_id_list_wire, cid);
1339 for (i=0; i<wire->num; i++) {
1341 ret = ctdb_client_id_pull_elems(&buf[offset], buflen-offset,
1342 out->cid, &out->cid[i]);
1346 offset += ctdb_client_id_len(&out->cid[i]);
1352 int ctdb_client_id_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1353 struct ctdb_client_id_list **out)
1355 struct ctdb_client_id_list *cid_list;
1358 cid_list = talloc(mem_ctx, struct ctdb_client_id_list);
1359 if (cid_list == NULL) {
1363 ret = ctdb_client_id_list_pull_elems(buf, buflen, cid_list, cid_list);
1365 TALLOC_FREE(cid_list);
1372 struct ctdb_client_id_map_wire {
1374 struct ctdb_client_id_list list[1];
1377 size_t ctdb_client_id_map_len(struct ctdb_client_id_map *cid_map)
1383 for (i=0; i<cid_map->count; i++) {
1384 len += ctdb_client_id_list_len(&cid_map->list[i]);
1389 void ctdb_client_id_map_push(struct ctdb_client_id_map *cid_map, uint8_t *buf)
1391 struct ctdb_client_id_map_wire *wire =
1392 (struct ctdb_client_id_map_wire *)buf;
1396 wire->count = cid_map->count;
1398 offset = sizeof(int);
1399 for (i=0; i<cid_map->count; i++) {
1400 ctdb_client_id_list_push(&cid_map->list[i], &buf[offset]);
1401 offset += ctdb_client_id_list_len(&cid_map->list[i]);
1405 int ctdb_client_id_map_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1406 struct ctdb_client_id_map **out)
1408 struct ctdb_client_id_map *cid_map;
1409 struct ctdb_client_id_map_wire *wire =
1410 (struct ctdb_client_id_map_wire *)buf;
1415 if (buflen < sizeof(int)) {
1418 if (buflen < sizeof(int) +
1419 wire->count * sizeof(struct ctdb_client_id_list)) {
1423 cid_map = talloc(mem_ctx, struct ctdb_client_id_map);
1424 if (cid_map == NULL) {
1428 cid_map->count = wire->count;
1429 cid_map->list = talloc_array(cid_map, struct ctdb_client_id_list,
1431 if (cid_map->list == NULL) {
1435 offset = sizeof(int);
1436 for (i=0; i<wire->count; i++) {
1437 ret = ctdb_client_id_list_pull_elems(&buf[offset],
1442 talloc_free(cid_map);
1445 offset += ctdb_client_id_list_len(&cid_map->list[i]);
1452 struct ctdb_addr_info_wire {
1453 ctdb_sock_addr addr;
1459 size_t ctdb_addr_info_len(struct ctdb_addr_info *arp)
1461 return offsetof(struct ctdb_addr_info_wire, iface) +
1462 strlen(arp->iface)+1;
1465 void ctdb_addr_info_push(struct ctdb_addr_info *addr_info, uint8_t *buf)
1467 struct ctdb_addr_info_wire *wire = (struct ctdb_addr_info_wire *)buf;
1469 wire->addr = addr_info->addr;
1470 wire->mask = addr_info->mask;
1471 wire->len = strlen(addr_info->iface)+1;
1472 memcpy(wire->iface, addr_info->iface, wire->len);
1475 int ctdb_addr_info_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1476 struct ctdb_addr_info **out)
1478 struct ctdb_addr_info *addr_info;
1479 struct ctdb_addr_info_wire *wire = (struct ctdb_addr_info_wire *)buf;
1481 if (buflen < offsetof(struct ctdb_addr_info_wire, iface)) {
1484 if (buflen < offsetof(struct ctdb_addr_info_wire, iface) + wire->len) {
1488 addr_info = talloc(mem_ctx, struct ctdb_addr_info);
1489 if (addr_info == NULL) {
1493 addr_info->addr = wire->addr;
1494 addr_info->mask = wire->mask;
1496 addr_info->iface = talloc_strndup(addr_info, wire->iface, wire->len);
1497 if (addr_info->iface == NULL) {
1498 talloc_free(addr_info);
1506 size_t ctdb_transdb_len(struct ctdb_transdb *transdb)
1508 return sizeof(struct ctdb_transdb);
1511 void ctdb_transdb_push(struct ctdb_transdb *transdb, uint8_t *buf)
1513 memcpy(buf, transdb, sizeof(struct ctdb_transdb));
1516 int ctdb_transdb_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1517 struct ctdb_transdb **out)
1519 struct ctdb_transdb *transdb;
1521 if (buflen < sizeof(struct ctdb_transdb)) {
1525 transdb = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_transdb));
1526 if (transdb == NULL) {
1534 size_t ctdb_uptime_len(struct ctdb_uptime *uptime)
1536 return sizeof(struct ctdb_uptime);
1539 void ctdb_uptime_push(struct ctdb_uptime *uptime, uint8_t *buf)
1541 memcpy(buf, uptime, sizeof(struct ctdb_uptime));
1544 int ctdb_uptime_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1545 struct ctdb_uptime **out)
1547 struct ctdb_uptime *uptime;
1549 if (buflen < sizeof(struct ctdb_uptime)) {
1553 uptime = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_uptime));
1554 if (uptime == NULL) {
1562 size_t ctdb_public_ip_len(struct ctdb_public_ip *pubip)
1564 return sizeof(struct ctdb_public_ip);
1567 void ctdb_public_ip_push(struct ctdb_public_ip *pubip, uint8_t *buf)
1569 memcpy(buf, pubip, sizeof(struct ctdb_public_ip));
1572 static int ctdb_public_ip_pull_elems(uint8_t *buf, size_t buflen,
1573 TALLOC_CTX *mem_ctx,
1574 struct ctdb_public_ip *out)
1576 if (buflen < sizeof(struct ctdb_public_ip)) {
1580 memcpy(out, buf, sizeof(struct ctdb_public_ip));
1585 int ctdb_public_ip_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1586 struct ctdb_public_ip **out)
1588 struct ctdb_public_ip *pubip;
1591 pubip = talloc(mem_ctx, struct ctdb_public_ip);
1592 if (pubip == NULL) {
1596 ret = ctdb_public_ip_pull_elems(buf, buflen, pubip, pubip);
1605 struct ctdb_public_ip_list_wire {
1607 struct ctdb_public_ip ip[1];
1610 size_t ctdb_public_ip_list_len(struct ctdb_public_ip_list *pubip_list)
1615 len = sizeof(uint32_t);
1616 for (i=0; i<pubip_list->num; i++) {
1617 len += ctdb_public_ip_len(&pubip_list->ip[i]);
1622 void ctdb_public_ip_list_push(struct ctdb_public_ip_list *pubip_list,
1625 struct ctdb_public_ip_list_wire *wire =
1626 (struct ctdb_public_ip_list_wire *)buf;
1630 wire->num = pubip_list->num;
1632 offset = offsetof(struct ctdb_public_ip_list_wire, ip);
1633 for (i=0; i<pubip_list->num; i++) {
1634 ctdb_public_ip_push(&pubip_list->ip[i], &buf[offset]);
1635 offset += ctdb_public_ip_len(&pubip_list->ip[i]);
1639 int ctdb_public_ip_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1640 struct ctdb_public_ip_list **out)
1642 struct ctdb_public_ip_list *pubip_list;
1643 struct ctdb_public_ip_list_wire *wire =
1644 (struct ctdb_public_ip_list_wire *)buf;
1649 if (buflen < sizeof(uint32_t)) {
1652 if (buflen < sizeof(uint32_t) +
1653 wire->num * sizeof(struct ctdb_public_ip)) {
1657 pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list);
1658 if (pubip_list == NULL) {
1662 pubip_list->num = wire->num;
1663 pubip_list->ip = talloc_array(pubip_list, struct ctdb_public_ip,
1665 if (pubip_list->ip == NULL) {
1666 talloc_free(pubip_list);
1670 offset = offsetof(struct ctdb_public_ip_list_wire, ip);
1671 for (i=0; i<wire->num; i++) {
1672 ret = ctdb_public_ip_pull_elems(&buf[offset], buflen-offset,
1674 &pubip_list->ip[i]);
1676 talloc_free(pubip_list);
1679 offset += ctdb_public_ip_len(&pubip_list->ip[i]);
1686 size_t ctdb_node_and_flags_len(struct ctdb_node_and_flags *node)
1688 return sizeof(struct ctdb_node_and_flags);
1691 void ctdb_node_and_flags_push(struct ctdb_node_and_flags *node, uint8_t *buf)
1693 memcpy(buf, node, sizeof(struct ctdb_node_and_flags));
1696 static int ctdb_node_and_flags_pull_elems(TALLOC_CTX *mem_ctx,
1697 uint8_t *buf, size_t buflen,
1698 struct ctdb_node_and_flags *out)
1700 if (buflen < sizeof(struct ctdb_node_and_flags)) {
1704 memcpy(out, buf, sizeof(struct ctdb_node_and_flags));
1709 int ctdb_node_and_flags_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1710 struct ctdb_node_and_flags **out)
1712 struct ctdb_node_and_flags *node;
1715 node = talloc(mem_ctx, struct ctdb_node_and_flags);
1720 ret = ctdb_node_and_flags_pull_elems(node, buf, buflen, node);
1729 struct ctdb_node_map_wire {
1731 struct ctdb_node_and_flags node[1];
1734 size_t ctdb_node_map_len(struct ctdb_node_map *nodemap)
1736 return sizeof(uint32_t) +
1737 nodemap->num * sizeof(struct ctdb_node_and_flags);
1740 void ctdb_node_map_push(struct ctdb_node_map *nodemap, uint8_t *buf)
1742 struct ctdb_node_map_wire *wire = (struct ctdb_node_map_wire *)buf;
1746 wire->num = nodemap->num;
1748 offset = offsetof(struct ctdb_node_map_wire, node);
1749 for (i=0; i<nodemap->num; i++) {
1750 ctdb_node_and_flags_push(&nodemap->node[i], &buf[offset]);
1751 offset += ctdb_node_and_flags_len(&nodemap->node[i]);
1755 int ctdb_node_map_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1756 struct ctdb_node_map **out)
1758 struct ctdb_node_map *nodemap;
1759 struct ctdb_node_map_wire *wire = (struct ctdb_node_map_wire *)buf;
1764 nodemap = talloc(mem_ctx, struct ctdb_node_map);
1765 if (nodemap == NULL) {
1769 nodemap->num = wire->num;
1770 nodemap->node = talloc_array(nodemap, struct ctdb_node_and_flags,
1772 if (nodemap->node == NULL) {
1773 talloc_free(nodemap);
1777 offset = offsetof(struct ctdb_node_map_wire, node);
1778 for (i=0; i<wire->num; i++) {
1779 ret = ctdb_node_and_flags_pull_elems(nodemap->node,
1784 talloc_free(nodemap);
1787 offset += ctdb_node_and_flags_len(&nodemap->node[i]);
1794 size_t ctdb_script_len(struct ctdb_script *script)
1796 return sizeof(struct ctdb_script);
1799 void ctdb_script_push(struct ctdb_script *script, uint8_t *buf)
1801 memcpy(buf, script, sizeof(struct ctdb_script));
1804 static int ctdb_script_pull_elems(uint8_t *buf, size_t buflen,
1805 TALLOC_CTX *mem_ctx,
1806 struct ctdb_script *out)
1808 if (buflen < sizeof(struct ctdb_script)) {
1812 memcpy(out, buf, sizeof(struct ctdb_script));
1817 int ctdb_script_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1818 struct ctdb_script **out)
1820 struct ctdb_script *script;
1823 script = talloc(mem_ctx, struct ctdb_script);
1824 if (script == NULL) {
1828 ret = ctdb_script_pull_elems(buf, buflen, script, script);
1830 TALLOC_FREE(script);
1837 struct ctdb_script_list_wire {
1838 uint32_t num_scripts;
1839 struct ctdb_script script[1];
1842 size_t ctdb_script_list_len(struct ctdb_script_list *script_list)
1847 if (script_list == NULL) {
1851 len = offsetof(struct ctdb_script_list_wire, script);
1852 for (i=0; i<script_list->num_scripts; i++) {
1853 len += ctdb_script_len(&script_list->script[i]);
1858 void ctdb_script_list_push(struct ctdb_script_list *script_list, uint8_t *buf)
1860 struct ctdb_script_list_wire *wire =
1861 (struct ctdb_script_list_wire *)buf;
1865 if (script_list == NULL) {
1869 wire->num_scripts = script_list->num_scripts;
1871 offset = offsetof(struct ctdb_script_list_wire, script);
1872 for (i=0; i<script_list->num_scripts; i++) {
1873 ctdb_script_push(&script_list->script[i], &buf[offset]);
1874 offset += ctdb_script_len(&script_list->script[i]);
1878 int ctdb_script_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1879 struct ctdb_script_list **out)
1881 struct ctdb_script_list *script_list;
1882 struct ctdb_script_list_wire *wire =
1883 (struct ctdb_script_list_wire *)buf;
1888 /* If event scripts have never been run, the result will be NULL */
1894 offset = offsetof(struct ctdb_script_list_wire, script);
1896 if (buflen < offset) {
1899 if (buflen < offset + wire->num_scripts * sizeof(struct ctdb_script)) {
1903 script_list = talloc(mem_ctx, struct ctdb_script_list);
1904 if (script_list == NULL) {
1909 script_list->num_scripts = wire->num_scripts;
1910 script_list->script = talloc_array(script_list, struct ctdb_script,
1912 if (script_list->script == NULL) {
1913 talloc_free(script_list);
1917 for (i=0; i<wire->num_scripts; i++) {
1918 ret = ctdb_script_pull_elems(&buf[offset], buflen-offset,
1919 script_list->script,
1920 &script_list->script[i]);
1922 talloc_free(script_list);
1925 offset += ctdb_script_len(&script_list->script[i]);
1932 size_t ctdb_ban_state_len(struct ctdb_ban_state *ban_state)
1934 return sizeof(struct ctdb_ban_state);
1937 void ctdb_ban_state_push(struct ctdb_ban_state *ban_state, uint8_t *buf)
1939 memcpy(buf, ban_state, sizeof(struct ctdb_ban_state));
1942 int ctdb_ban_state_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1943 struct ctdb_ban_state **out)
1945 struct ctdb_ban_state *ban_state;
1947 if (buflen < sizeof(struct ctdb_ban_state)) {
1951 ban_state = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_ban_state));
1952 if (ban_state == NULL) {
1960 size_t ctdb_db_priority_len(struct ctdb_db_priority *db_prio)
1962 return sizeof(struct ctdb_db_priority);
1965 void ctdb_db_priority_push(struct ctdb_db_priority *db_prio, uint8_t *buf)
1967 memcpy(buf, db_prio, sizeof(struct ctdb_db_priority));
1970 int ctdb_db_priority_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1971 struct ctdb_db_priority **out)
1973 struct ctdb_db_priority *db_prio;
1975 if (buflen < sizeof(struct ctdb_db_priority)) {
1979 db_prio = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_db_priority));
1980 if (db_prio == NULL) {
1988 struct ctdb_notify_data_wire {
1994 size_t ctdb_notify_data_len(struct ctdb_notify_data *notify)
1996 return offsetof(struct ctdb_notify_data_wire, data) +
2000 void ctdb_notify_data_push(struct ctdb_notify_data *notify, uint8_t *buf)
2002 struct ctdb_notify_data_wire *wire =
2003 (struct ctdb_notify_data_wire *)buf;
2005 wire->srvid = notify->srvid;
2006 wire->len = notify->data.dsize;
2007 memcpy(wire->data, notify->data.dptr, notify->data.dsize);
2010 int ctdb_notify_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2011 struct ctdb_notify_data **out)
2013 struct ctdb_notify_data *notify;
2014 struct ctdb_notify_data_wire *wire =
2015 (struct ctdb_notify_data_wire *)buf;
2017 if (buflen < offsetof(struct ctdb_notify_data_wire, data)) {
2020 if (buflen < offsetof(struct ctdb_notify_data_wire, data) + wire->len) {
2024 notify = talloc(mem_ctx, struct ctdb_notify_data);
2025 if (notify == NULL) {
2029 notify->srvid = wire->srvid;
2030 notify->data.dsize = wire->len;
2031 notify->data.dptr = talloc_memdup(notify, wire->data, wire->len);
2032 if (notify->data.dptr == NULL) {
2033 talloc_free(notify);
2041 size_t ctdb_iface_len(struct ctdb_iface *iface)
2043 return sizeof(struct ctdb_iface);
2046 void ctdb_iface_push(struct ctdb_iface *iface, uint8_t *buf)
2048 memcpy(buf, iface, sizeof(struct ctdb_iface));
2051 static int ctdb_iface_pull_elems(uint8_t *buf, size_t buflen,
2052 TALLOC_CTX *mem_ctx,
2053 struct ctdb_iface *out)
2055 if (buflen < sizeof(struct ctdb_iface)) {
2059 memcpy(out, buf, sizeof(struct ctdb_iface));
2064 int ctdb_iface_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2065 struct ctdb_iface **out)
2067 struct ctdb_iface *iface;
2070 iface = talloc(mem_ctx, struct ctdb_iface);
2071 if (iface == NULL) {
2075 ret = ctdb_iface_pull_elems(buf, buflen, iface, iface);
2084 struct ctdb_iface_list_wire {
2086 struct ctdb_iface iface[1];
2089 size_t ctdb_iface_list_len(struct ctdb_iface_list *iface_list)
2091 return sizeof(uint32_t) +
2092 iface_list->num * sizeof(struct ctdb_iface);
2095 void ctdb_iface_list_push(struct ctdb_iface_list *iface_list, uint8_t *buf)
2097 struct ctdb_iface_list_wire *wire =
2098 (struct ctdb_iface_list_wire *)buf;
2100 wire->num = iface_list->num;
2101 memcpy(wire->iface, iface_list->iface,
2102 iface_list->num * sizeof(struct ctdb_iface));
2105 int ctdb_iface_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2106 struct ctdb_iface_list **out)
2108 struct ctdb_iface_list *iface_list;
2109 struct ctdb_iface_list_wire *wire =
2110 (struct ctdb_iface_list_wire *)buf;
2112 if (buflen < sizeof(uint32_t)) {
2115 if (buflen < sizeof(uint32_t) + wire->num * sizeof(struct ctdb_iface)) {
2119 iface_list = talloc(mem_ctx, struct ctdb_iface_list);
2120 if (iface_list == NULL) {
2124 iface_list->num = wire->num;
2125 iface_list->iface = talloc_array(iface_list, struct ctdb_iface,
2127 if (iface_list->iface == NULL) {
2128 talloc_free(iface_list);
2132 memcpy(iface_list->iface, wire->iface,
2133 wire->num * sizeof(struct ctdb_iface));
2139 struct ctdb_public_ip_info_wire {
2140 struct ctdb_public_ip ip;
2141 uint32_t active_idx;
2143 struct ctdb_iface ifaces[1];
2146 size_t ctdb_public_ip_info_len(struct ctdb_public_ip_info *ipinfo)
2148 return offsetof(struct ctdb_public_ip_info_wire, num) +
2149 ctdb_iface_list_len(ipinfo->ifaces);
2152 void ctdb_public_ip_info_push(struct ctdb_public_ip_info *ipinfo, uint8_t *buf)
2154 struct ctdb_public_ip_info_wire *wire =
2155 (struct ctdb_public_ip_info_wire *)buf;
2158 offset = offsetof(struct ctdb_public_ip_info_wire, num);
2159 memcpy(wire, ipinfo, offset);
2160 wire->num = ipinfo->ifaces->num;
2161 memcpy(wire->ifaces, ipinfo->ifaces->iface,
2162 ipinfo->ifaces->num * sizeof(struct ctdb_iface));
2165 int ctdb_public_ip_info_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2166 struct ctdb_public_ip_info **out)
2168 struct ctdb_public_ip_info *ipinfo;
2169 struct ctdb_public_ip_info_wire *wire =
2170 (struct ctdb_public_ip_info_wire *)buf;
2172 if (buflen < offsetof(struct ctdb_public_ip_info_wire, ifaces)) {
2176 ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info);
2177 if (ipinfo == NULL) {
2181 memcpy(ipinfo, wire, offsetof(struct ctdb_public_ip_info_wire, num));
2183 ipinfo->ifaces = talloc(ipinfo, struct ctdb_iface_list);
2184 if (ipinfo->ifaces == NULL) {
2185 talloc_free(ipinfo);
2189 ipinfo->ifaces->num = wire->num;
2190 ipinfo->ifaces->iface = talloc_array(ipinfo->ifaces, struct ctdb_iface,
2192 if (ipinfo->ifaces->iface == NULL) {
2193 talloc_free(ipinfo);
2197 memcpy(ipinfo->ifaces->iface, wire->ifaces,
2198 wire->num * sizeof(struct ctdb_iface));
2204 struct ctdb_key_data_wire {
2206 struct ctdb_ltdb_header header;
2211 size_t ctdb_key_data_len(struct ctdb_key_data *key)
2213 return offsetof(struct ctdb_key_data_wire, key) + key->key.dsize;
2216 void ctdb_key_data_push(struct ctdb_key_data *key, uint8_t *buf)
2218 struct ctdb_key_data_wire *wire = (struct ctdb_key_data_wire *)buf;
2220 memcpy(wire, key, offsetof(struct ctdb_key_data, key));
2221 wire->keylen = key->key.dsize;
2222 memcpy(wire->key, key->key.dptr, key->key.dsize);
2225 int ctdb_key_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2226 struct ctdb_key_data **out)
2228 struct ctdb_key_data *key_data;
2229 struct ctdb_key_data_wire *wire = (struct ctdb_key_data_wire *)buf;
2231 if (buflen < offsetof(struct ctdb_key_data_wire, key)) {
2234 if (buflen < offsetof(struct ctdb_key_data_wire, key) + wire->keylen) {
2238 key_data = talloc(mem_ctx, struct ctdb_key_data);
2239 if (key_data == NULL) {
2243 memcpy(key_data, wire, offsetof(struct ctdb_key_data, key));
2245 key_data->key.dsize = wire->keylen;
2246 key_data->key.dptr = talloc_memdup(key_data, wire->key, wire->keylen);
2247 if (key_data->key.dptr == NULL) {
2248 talloc_free(key_data);
2256 struct ctdb_db_statistics_wire {
2257 struct ctdb_db_statistics dbstats;
2258 char hot_keys_wire[1];
2261 size_t ctdb_db_statistics_len(struct ctdb_db_statistics *dbstats)
2266 len = sizeof(struct ctdb_db_statistics);
2267 for (i=0; i<MAX_HOT_KEYS; i++) {
2268 len += dbstats->hot_keys[i].key.dsize;
2273 void ctdb_db_statistics_push(struct ctdb_db_statistics *dbstats, void *buf)
2275 struct ctdb_db_statistics_wire *wire =
2276 (struct ctdb_db_statistics_wire *)buf;
2280 dbstats->num_hot_keys = MAX_HOT_KEYS;
2281 memcpy(wire, dbstats, sizeof(struct ctdb_db_statistics));
2284 for (i=0; i<MAX_HOT_KEYS; i++) {
2285 memcpy(&wire->hot_keys_wire[offset],
2286 dbstats->hot_keys[i].key.dptr,
2287 dbstats->hot_keys[i].key.dsize);
2288 offset += dbstats->hot_keys[i].key.dsize;
2292 int ctdb_db_statistics_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2293 struct ctdb_db_statistics **out)
2295 struct ctdb_db_statistics *dbstats;
2296 struct ctdb_db_statistics_wire *wire =
2297 (struct ctdb_db_statistics_wire *)buf;
2301 if (buflen < sizeof(struct ctdb_db_statistics)) {
2305 for (i=0; i<wire->dbstats.num_hot_keys; i++) {
2306 offset += wire->dbstats.hot_keys[i].key.dsize;
2308 if (buflen < sizeof(struct ctdb_db_statistics) + offset) {
2312 dbstats = talloc(mem_ctx, struct ctdb_db_statistics);
2313 if (dbstats == NULL) {
2317 memcpy(dbstats, wire, sizeof(struct ctdb_db_statistics));
2320 for (i=0; i<wire->dbstats.num_hot_keys; i++) {
2324 key_size = dbstats->hot_keys[i].key.dsize;
2325 ptr = talloc_memdup(mem_ctx, &wire->hot_keys_wire[offset],
2328 talloc_free(dbstats);
2331 dbstats->hot_keys[i].key.dptr = ptr;
2339 size_t ctdb_election_message_len(struct ctdb_election_message *election)
2341 return sizeof(struct ctdb_election_message);
2344 void ctdb_election_message_push(struct ctdb_election_message *election,
2347 memcpy(buf, election, sizeof(struct ctdb_election_message));
2350 int ctdb_election_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2351 struct ctdb_election_message **out)
2353 struct ctdb_election_message *election;
2355 if (buflen < sizeof(struct ctdb_election_message)) {
2359 election = talloc_memdup(mem_ctx, buf,
2360 sizeof(struct ctdb_election_message));
2361 if (election == NULL) {
2369 size_t ctdb_srvid_message_len(struct ctdb_srvid_message *msg)
2371 return sizeof(struct ctdb_srvid_message);
2374 void ctdb_srvid_message_push(struct ctdb_srvid_message *msg, uint8_t *buf)
2376 memcpy(buf, msg, sizeof(struct ctdb_srvid_message));
2379 int ctdb_srvid_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2380 struct ctdb_srvid_message **out)
2382 struct ctdb_srvid_message *msg;
2384 if (buflen < sizeof(struct ctdb_srvid_message)) {
2388 msg = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_srvid_message));
2397 size_t ctdb_disable_message_len(struct ctdb_disable_message *disable)
2399 return sizeof(struct ctdb_disable_message);
2402 void ctdb_disable_message_push(struct ctdb_disable_message *disable,
2405 memcpy(buf, disable, sizeof(struct ctdb_disable_message));
2408 int ctdb_disable_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2409 struct ctdb_disable_message **out)
2411 struct ctdb_disable_message *disable;
2413 if (buflen < sizeof(struct ctdb_disable_message)) {
2417 disable = talloc_memdup(mem_ctx, buf,
2418 sizeof(struct ctdb_disable_message));
2419 if (disable == NULL) {
2427 size_t ctdb_server_id_len(struct ctdb_server_id *sid)
2429 return sizeof(struct ctdb_server_id);
2432 void ctdb_server_id_push(struct ctdb_server_id *sid, uint8_t *buf)
2434 memcpy(buf, sid, sizeof(struct ctdb_server_id));
2437 int ctdb_server_id_pull(uint8_t *buf, size_t buflen,
2438 struct ctdb_server_id *sid)
2440 if (buflen < sizeof(struct ctdb_server_id)) {
2444 memcpy(sid, buf, sizeof(struct ctdb_server_id));
2448 size_t ctdb_g_lock_len(struct ctdb_g_lock *lock)
2450 return sizeof(struct ctdb_g_lock);
2453 void ctdb_g_lock_push(struct ctdb_g_lock *lock, uint8_t *buf)
2455 memcpy(buf, lock, sizeof(struct ctdb_g_lock));
2458 int ctdb_g_lock_pull(uint8_t *buf, size_t buflen, struct ctdb_g_lock *lock)
2460 if (buflen < sizeof(struct ctdb_g_lock)) {
2464 memcpy(lock, buf, sizeof(struct ctdb_g_lock));
2468 size_t ctdb_g_lock_list_len(struct ctdb_g_lock_list *lock_list)
2470 return lock_list->num * sizeof(struct ctdb_g_lock);
2473 void ctdb_g_lock_list_push(struct ctdb_g_lock_list *lock_list, uint8_t *buf)
2478 for (i=0; i<lock_list->num; i++) {
2479 ctdb_g_lock_push(&lock_list->lock[i], &buf[offset]);
2480 offset += sizeof(struct ctdb_g_lock);
2484 int ctdb_g_lock_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2485 struct ctdb_g_lock_list **out)
2487 struct ctdb_g_lock_list *lock_list;
2492 lock_list = talloc_zero(mem_ctx, struct ctdb_g_lock_list);
2493 if (lock_list == NULL) {
2497 count = buflen / sizeof(struct ctdb_g_lock);
2498 lock_list->lock = talloc_array(lock_list, struct ctdb_g_lock, count);
2499 if (lock_list->lock == NULL) {
2500 talloc_free(lock_list);
2505 for (i=0; i<count; i++) {
2506 ret = ctdb_g_lock_pull(&buf[offset], buflen-offset,
2507 &lock_list->lock[i]);
2509 talloc_free(lock_list);
2512 offset += sizeof(struct ctdb_g_lock);
2515 lock_list->num = count;