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)
1463 len = offsetof(struct ctdb_addr_info_wire, iface);
1464 if (arp->iface != NULL) {
1465 len += strlen(arp->iface)+1;
1471 void ctdb_addr_info_push(struct ctdb_addr_info *addr_info, uint8_t *buf)
1473 struct ctdb_addr_info_wire *wire = (struct ctdb_addr_info_wire *)buf;
1475 wire->addr = addr_info->addr;
1476 wire->mask = addr_info->mask;
1477 if (addr_info->iface == NULL) {
1480 wire->len = strlen(addr_info->iface)+1;
1481 memcpy(wire->iface, addr_info->iface, wire->len);
1485 int ctdb_addr_info_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1486 struct ctdb_addr_info **out)
1488 struct ctdb_addr_info *addr_info;
1489 struct ctdb_addr_info_wire *wire = (struct ctdb_addr_info_wire *)buf;
1491 if (buflen < offsetof(struct ctdb_addr_info_wire, iface)) {
1494 if (buflen < offsetof(struct ctdb_addr_info_wire, iface) + wire->len) {
1498 addr_info = talloc(mem_ctx, struct ctdb_addr_info);
1499 if (addr_info == NULL) {
1503 addr_info->addr = wire->addr;
1504 addr_info->mask = wire->mask;
1506 if (wire->len == 0) {
1507 addr_info->iface = NULL;
1509 addr_info->iface = talloc_strndup(addr_info, wire->iface,
1511 if (addr_info->iface == NULL) {
1512 talloc_free(addr_info);
1521 size_t ctdb_transdb_len(struct ctdb_transdb *transdb)
1523 return sizeof(struct ctdb_transdb);
1526 void ctdb_transdb_push(struct ctdb_transdb *transdb, uint8_t *buf)
1528 memcpy(buf, transdb, sizeof(struct ctdb_transdb));
1531 int ctdb_transdb_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1532 struct ctdb_transdb **out)
1534 struct ctdb_transdb *transdb;
1536 if (buflen < sizeof(struct ctdb_transdb)) {
1540 transdb = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_transdb));
1541 if (transdb == NULL) {
1549 size_t ctdb_uptime_len(struct ctdb_uptime *uptime)
1551 return sizeof(struct ctdb_uptime);
1554 void ctdb_uptime_push(struct ctdb_uptime *uptime, uint8_t *buf)
1556 memcpy(buf, uptime, sizeof(struct ctdb_uptime));
1559 int ctdb_uptime_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1560 struct ctdb_uptime **out)
1562 struct ctdb_uptime *uptime;
1564 if (buflen < sizeof(struct ctdb_uptime)) {
1568 uptime = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_uptime));
1569 if (uptime == NULL) {
1577 size_t ctdb_public_ip_len(struct ctdb_public_ip *pubip)
1579 return sizeof(struct ctdb_public_ip);
1582 void ctdb_public_ip_push(struct ctdb_public_ip *pubip, uint8_t *buf)
1584 memcpy(buf, pubip, sizeof(struct ctdb_public_ip));
1587 static int ctdb_public_ip_pull_elems(uint8_t *buf, size_t buflen,
1588 TALLOC_CTX *mem_ctx,
1589 struct ctdb_public_ip *out)
1591 if (buflen < sizeof(struct ctdb_public_ip)) {
1595 memcpy(out, buf, sizeof(struct ctdb_public_ip));
1600 int ctdb_public_ip_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1601 struct ctdb_public_ip **out)
1603 struct ctdb_public_ip *pubip;
1606 pubip = talloc(mem_ctx, struct ctdb_public_ip);
1607 if (pubip == NULL) {
1611 ret = ctdb_public_ip_pull_elems(buf, buflen, pubip, pubip);
1620 struct ctdb_public_ip_list_wire {
1622 struct ctdb_public_ip ip[1];
1625 size_t ctdb_public_ip_list_len(struct ctdb_public_ip_list *pubip_list)
1630 len = sizeof(uint32_t);
1631 for (i=0; i<pubip_list->num; i++) {
1632 len += ctdb_public_ip_len(&pubip_list->ip[i]);
1637 void ctdb_public_ip_list_push(struct ctdb_public_ip_list *pubip_list,
1640 struct ctdb_public_ip_list_wire *wire =
1641 (struct ctdb_public_ip_list_wire *)buf;
1645 wire->num = pubip_list->num;
1647 offset = offsetof(struct ctdb_public_ip_list_wire, ip);
1648 for (i=0; i<pubip_list->num; i++) {
1649 ctdb_public_ip_push(&pubip_list->ip[i], &buf[offset]);
1650 offset += ctdb_public_ip_len(&pubip_list->ip[i]);
1654 int ctdb_public_ip_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1655 struct ctdb_public_ip_list **out)
1657 struct ctdb_public_ip_list *pubip_list;
1658 struct ctdb_public_ip_list_wire *wire =
1659 (struct ctdb_public_ip_list_wire *)buf;
1664 if (buflen < sizeof(uint32_t)) {
1667 if (buflen < sizeof(uint32_t) +
1668 wire->num * sizeof(struct ctdb_public_ip)) {
1672 pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list);
1673 if (pubip_list == NULL) {
1677 pubip_list->num = wire->num;
1678 pubip_list->ip = talloc_array(pubip_list, struct ctdb_public_ip,
1680 if (pubip_list->ip == NULL) {
1681 talloc_free(pubip_list);
1685 offset = offsetof(struct ctdb_public_ip_list_wire, ip);
1686 for (i=0; i<wire->num; i++) {
1687 ret = ctdb_public_ip_pull_elems(&buf[offset], buflen-offset,
1689 &pubip_list->ip[i]);
1691 talloc_free(pubip_list);
1694 offset += ctdb_public_ip_len(&pubip_list->ip[i]);
1701 size_t ctdb_node_and_flags_len(struct ctdb_node_and_flags *node)
1703 return sizeof(struct ctdb_node_and_flags);
1706 void ctdb_node_and_flags_push(struct ctdb_node_and_flags *node, uint8_t *buf)
1708 memcpy(buf, node, sizeof(struct ctdb_node_and_flags));
1711 static int ctdb_node_and_flags_pull_elems(TALLOC_CTX *mem_ctx,
1712 uint8_t *buf, size_t buflen,
1713 struct ctdb_node_and_flags *out)
1715 if (buflen < sizeof(struct ctdb_node_and_flags)) {
1719 memcpy(out, buf, sizeof(struct ctdb_node_and_flags));
1724 int ctdb_node_and_flags_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1725 struct ctdb_node_and_flags **out)
1727 struct ctdb_node_and_flags *node;
1730 node = talloc(mem_ctx, struct ctdb_node_and_flags);
1735 ret = ctdb_node_and_flags_pull_elems(node, buf, buflen, node);
1744 struct ctdb_node_map_wire {
1746 struct ctdb_node_and_flags node[1];
1749 size_t ctdb_node_map_len(struct ctdb_node_map *nodemap)
1751 return sizeof(uint32_t) +
1752 nodemap->num * sizeof(struct ctdb_node_and_flags);
1755 void ctdb_node_map_push(struct ctdb_node_map *nodemap, uint8_t *buf)
1757 struct ctdb_node_map_wire *wire = (struct ctdb_node_map_wire *)buf;
1761 wire->num = nodemap->num;
1763 offset = offsetof(struct ctdb_node_map_wire, node);
1764 for (i=0; i<nodemap->num; i++) {
1765 ctdb_node_and_flags_push(&nodemap->node[i], &buf[offset]);
1766 offset += ctdb_node_and_flags_len(&nodemap->node[i]);
1770 int ctdb_node_map_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1771 struct ctdb_node_map **out)
1773 struct ctdb_node_map *nodemap;
1774 struct ctdb_node_map_wire *wire = (struct ctdb_node_map_wire *)buf;
1779 nodemap = talloc(mem_ctx, struct ctdb_node_map);
1780 if (nodemap == NULL) {
1784 nodemap->num = wire->num;
1785 nodemap->node = talloc_array(nodemap, struct ctdb_node_and_flags,
1787 if (nodemap->node == NULL) {
1788 talloc_free(nodemap);
1792 offset = offsetof(struct ctdb_node_map_wire, node);
1793 for (i=0; i<wire->num; i++) {
1794 ret = ctdb_node_and_flags_pull_elems(nodemap->node,
1799 talloc_free(nodemap);
1802 offset += ctdb_node_and_flags_len(&nodemap->node[i]);
1809 size_t ctdb_script_len(struct ctdb_script *script)
1811 return sizeof(struct ctdb_script);
1814 void ctdb_script_push(struct ctdb_script *script, uint8_t *buf)
1816 memcpy(buf, script, sizeof(struct ctdb_script));
1819 static int ctdb_script_pull_elems(uint8_t *buf, size_t buflen,
1820 TALLOC_CTX *mem_ctx,
1821 struct ctdb_script *out)
1823 if (buflen < sizeof(struct ctdb_script)) {
1827 memcpy(out, buf, sizeof(struct ctdb_script));
1832 int ctdb_script_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1833 struct ctdb_script **out)
1835 struct ctdb_script *script;
1838 script = talloc(mem_ctx, struct ctdb_script);
1839 if (script == NULL) {
1843 ret = ctdb_script_pull_elems(buf, buflen, script, script);
1845 TALLOC_FREE(script);
1852 struct ctdb_script_list_wire {
1853 uint32_t num_scripts;
1854 struct ctdb_script script[1];
1857 size_t ctdb_script_list_len(struct ctdb_script_list *script_list)
1862 if (script_list == NULL) {
1866 len = offsetof(struct ctdb_script_list_wire, script);
1867 for (i=0; i<script_list->num_scripts; i++) {
1868 len += ctdb_script_len(&script_list->script[i]);
1873 void ctdb_script_list_push(struct ctdb_script_list *script_list, uint8_t *buf)
1875 struct ctdb_script_list_wire *wire =
1876 (struct ctdb_script_list_wire *)buf;
1880 if (script_list == NULL) {
1884 wire->num_scripts = script_list->num_scripts;
1886 offset = offsetof(struct ctdb_script_list_wire, script);
1887 for (i=0; i<script_list->num_scripts; i++) {
1888 ctdb_script_push(&script_list->script[i], &buf[offset]);
1889 offset += ctdb_script_len(&script_list->script[i]);
1893 int ctdb_script_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1894 struct ctdb_script_list **out)
1896 struct ctdb_script_list *script_list;
1897 struct ctdb_script_list_wire *wire =
1898 (struct ctdb_script_list_wire *)buf;
1903 /* If event scripts have never been run, the result will be NULL */
1909 offset = offsetof(struct ctdb_script_list_wire, script);
1911 if (buflen < offset) {
1914 if (buflen < offset + wire->num_scripts * sizeof(struct ctdb_script)) {
1918 script_list = talloc(mem_ctx, struct ctdb_script_list);
1919 if (script_list == NULL) {
1924 script_list->num_scripts = wire->num_scripts;
1925 script_list->script = talloc_array(script_list, struct ctdb_script,
1927 if (script_list->script == NULL) {
1928 talloc_free(script_list);
1932 for (i=0; i<wire->num_scripts; i++) {
1933 ret = ctdb_script_pull_elems(&buf[offset], buflen-offset,
1934 script_list->script,
1935 &script_list->script[i]);
1937 talloc_free(script_list);
1940 offset += ctdb_script_len(&script_list->script[i]);
1947 size_t ctdb_ban_state_len(struct ctdb_ban_state *ban_state)
1949 return sizeof(struct ctdb_ban_state);
1952 void ctdb_ban_state_push(struct ctdb_ban_state *ban_state, uint8_t *buf)
1954 memcpy(buf, ban_state, sizeof(struct ctdb_ban_state));
1957 int ctdb_ban_state_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1958 struct ctdb_ban_state **out)
1960 struct ctdb_ban_state *ban_state;
1962 if (buflen < sizeof(struct ctdb_ban_state)) {
1966 ban_state = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_ban_state));
1967 if (ban_state == NULL) {
1975 size_t ctdb_db_priority_len(struct ctdb_db_priority *db_prio)
1977 return sizeof(struct ctdb_db_priority);
1980 void ctdb_db_priority_push(struct ctdb_db_priority *db_prio, uint8_t *buf)
1982 memcpy(buf, db_prio, sizeof(struct ctdb_db_priority));
1985 int ctdb_db_priority_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
1986 struct ctdb_db_priority **out)
1988 struct ctdb_db_priority *db_prio;
1990 if (buflen < sizeof(struct ctdb_db_priority)) {
1994 db_prio = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_db_priority));
1995 if (db_prio == NULL) {
2003 struct ctdb_notify_data_wire {
2009 size_t ctdb_notify_data_len(struct ctdb_notify_data *notify)
2011 return offsetof(struct ctdb_notify_data_wire, data) +
2015 void ctdb_notify_data_push(struct ctdb_notify_data *notify, uint8_t *buf)
2017 struct ctdb_notify_data_wire *wire =
2018 (struct ctdb_notify_data_wire *)buf;
2020 wire->srvid = notify->srvid;
2021 wire->len = notify->data.dsize;
2022 memcpy(wire->data, notify->data.dptr, notify->data.dsize);
2025 int ctdb_notify_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2026 struct ctdb_notify_data **out)
2028 struct ctdb_notify_data *notify;
2029 struct ctdb_notify_data_wire *wire =
2030 (struct ctdb_notify_data_wire *)buf;
2032 if (buflen < offsetof(struct ctdb_notify_data_wire, data)) {
2035 if (buflen < offsetof(struct ctdb_notify_data_wire, data) + wire->len) {
2039 notify = talloc(mem_ctx, struct ctdb_notify_data);
2040 if (notify == NULL) {
2044 notify->srvid = wire->srvid;
2045 notify->data.dsize = wire->len;
2046 notify->data.dptr = talloc_memdup(notify, wire->data, wire->len);
2047 if (notify->data.dptr == NULL) {
2048 talloc_free(notify);
2056 size_t ctdb_iface_len(struct ctdb_iface *iface)
2058 return sizeof(struct ctdb_iface);
2061 void ctdb_iface_push(struct ctdb_iface *iface, uint8_t *buf)
2063 memcpy(buf, iface, sizeof(struct ctdb_iface));
2066 static int ctdb_iface_pull_elems(uint8_t *buf, size_t buflen,
2067 TALLOC_CTX *mem_ctx,
2068 struct ctdb_iface *out)
2070 if (buflen < sizeof(struct ctdb_iface)) {
2074 memcpy(out, buf, sizeof(struct ctdb_iface));
2079 int ctdb_iface_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2080 struct ctdb_iface **out)
2082 struct ctdb_iface *iface;
2085 iface = talloc(mem_ctx, struct ctdb_iface);
2086 if (iface == NULL) {
2090 ret = ctdb_iface_pull_elems(buf, buflen, iface, iface);
2099 struct ctdb_iface_list_wire {
2101 struct ctdb_iface iface[1];
2104 size_t ctdb_iface_list_len(struct ctdb_iface_list *iface_list)
2106 return sizeof(uint32_t) +
2107 iface_list->num * sizeof(struct ctdb_iface);
2110 void ctdb_iface_list_push(struct ctdb_iface_list *iface_list, uint8_t *buf)
2112 struct ctdb_iface_list_wire *wire =
2113 (struct ctdb_iface_list_wire *)buf;
2115 wire->num = iface_list->num;
2116 memcpy(wire->iface, iface_list->iface,
2117 iface_list->num * sizeof(struct ctdb_iface));
2120 int ctdb_iface_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2121 struct ctdb_iface_list **out)
2123 struct ctdb_iface_list *iface_list;
2124 struct ctdb_iface_list_wire *wire =
2125 (struct ctdb_iface_list_wire *)buf;
2127 if (buflen < sizeof(uint32_t)) {
2130 if (buflen < sizeof(uint32_t) + wire->num * sizeof(struct ctdb_iface)) {
2134 iface_list = talloc(mem_ctx, struct ctdb_iface_list);
2135 if (iface_list == NULL) {
2139 iface_list->num = wire->num;
2140 iface_list->iface = talloc_array(iface_list, struct ctdb_iface,
2142 if (iface_list->iface == NULL) {
2143 talloc_free(iface_list);
2147 memcpy(iface_list->iface, wire->iface,
2148 wire->num * sizeof(struct ctdb_iface));
2154 struct ctdb_public_ip_info_wire {
2155 struct ctdb_public_ip ip;
2156 uint32_t active_idx;
2158 struct ctdb_iface ifaces[1];
2161 size_t ctdb_public_ip_info_len(struct ctdb_public_ip_info *ipinfo)
2163 return offsetof(struct ctdb_public_ip_info_wire, num) +
2164 ctdb_iface_list_len(ipinfo->ifaces);
2167 void ctdb_public_ip_info_push(struct ctdb_public_ip_info *ipinfo, uint8_t *buf)
2169 struct ctdb_public_ip_info_wire *wire =
2170 (struct ctdb_public_ip_info_wire *)buf;
2173 offset = offsetof(struct ctdb_public_ip_info_wire, num);
2174 memcpy(wire, ipinfo, offset);
2175 wire->num = ipinfo->ifaces->num;
2176 memcpy(wire->ifaces, ipinfo->ifaces->iface,
2177 ipinfo->ifaces->num * sizeof(struct ctdb_iface));
2180 int ctdb_public_ip_info_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2181 struct ctdb_public_ip_info **out)
2183 struct ctdb_public_ip_info *ipinfo;
2184 struct ctdb_public_ip_info_wire *wire =
2185 (struct ctdb_public_ip_info_wire *)buf;
2187 if (buflen < offsetof(struct ctdb_public_ip_info_wire, ifaces)) {
2191 ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info);
2192 if (ipinfo == NULL) {
2196 memcpy(ipinfo, wire, offsetof(struct ctdb_public_ip_info_wire, num));
2198 ipinfo->ifaces = talloc(ipinfo, struct ctdb_iface_list);
2199 if (ipinfo->ifaces == NULL) {
2200 talloc_free(ipinfo);
2204 ipinfo->ifaces->num = wire->num;
2205 ipinfo->ifaces->iface = talloc_array(ipinfo->ifaces, struct ctdb_iface,
2207 if (ipinfo->ifaces->iface == NULL) {
2208 talloc_free(ipinfo);
2212 memcpy(ipinfo->ifaces->iface, wire->ifaces,
2213 wire->num * sizeof(struct ctdb_iface));
2219 struct ctdb_key_data_wire {
2221 struct ctdb_ltdb_header header;
2226 size_t ctdb_key_data_len(struct ctdb_key_data *key)
2228 return offsetof(struct ctdb_key_data_wire, key) + key->key.dsize;
2231 void ctdb_key_data_push(struct ctdb_key_data *key, uint8_t *buf)
2233 struct ctdb_key_data_wire *wire = (struct ctdb_key_data_wire *)buf;
2235 memcpy(wire, key, offsetof(struct ctdb_key_data, key));
2236 wire->keylen = key->key.dsize;
2237 memcpy(wire->key, key->key.dptr, key->key.dsize);
2240 int ctdb_key_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2241 struct ctdb_key_data **out)
2243 struct ctdb_key_data *key_data;
2244 struct ctdb_key_data_wire *wire = (struct ctdb_key_data_wire *)buf;
2246 if (buflen < offsetof(struct ctdb_key_data_wire, key)) {
2249 if (buflen < offsetof(struct ctdb_key_data_wire, key) + wire->keylen) {
2253 key_data = talloc(mem_ctx, struct ctdb_key_data);
2254 if (key_data == NULL) {
2258 memcpy(key_data, wire, offsetof(struct ctdb_key_data, key));
2260 key_data->key.dsize = wire->keylen;
2261 key_data->key.dptr = talloc_memdup(key_data, wire->key, wire->keylen);
2262 if (key_data->key.dptr == NULL) {
2263 talloc_free(key_data);
2271 struct ctdb_db_statistics_wire {
2272 struct ctdb_db_statistics dbstats;
2273 char hot_keys_wire[1];
2276 size_t ctdb_db_statistics_len(struct ctdb_db_statistics *dbstats)
2281 len = sizeof(struct ctdb_db_statistics);
2282 for (i=0; i<MAX_HOT_KEYS; i++) {
2283 len += dbstats->hot_keys[i].key.dsize;
2288 void ctdb_db_statistics_push(struct ctdb_db_statistics *dbstats, void *buf)
2290 struct ctdb_db_statistics_wire *wire =
2291 (struct ctdb_db_statistics_wire *)buf;
2295 dbstats->num_hot_keys = MAX_HOT_KEYS;
2296 memcpy(wire, dbstats, sizeof(struct ctdb_db_statistics));
2299 for (i=0; i<MAX_HOT_KEYS; i++) {
2300 memcpy(&wire->hot_keys_wire[offset],
2301 dbstats->hot_keys[i].key.dptr,
2302 dbstats->hot_keys[i].key.dsize);
2303 offset += dbstats->hot_keys[i].key.dsize;
2307 int ctdb_db_statistics_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2308 struct ctdb_db_statistics **out)
2310 struct ctdb_db_statistics *dbstats;
2311 struct ctdb_db_statistics_wire *wire =
2312 (struct ctdb_db_statistics_wire *)buf;
2316 if (buflen < sizeof(struct ctdb_db_statistics)) {
2320 for (i=0; i<wire->dbstats.num_hot_keys; i++) {
2321 offset += wire->dbstats.hot_keys[i].key.dsize;
2323 if (buflen < sizeof(struct ctdb_db_statistics) + offset) {
2327 dbstats = talloc(mem_ctx, struct ctdb_db_statistics);
2328 if (dbstats == NULL) {
2332 memcpy(dbstats, wire, sizeof(struct ctdb_db_statistics));
2335 for (i=0; i<wire->dbstats.num_hot_keys; i++) {
2339 key_size = dbstats->hot_keys[i].key.dsize;
2340 ptr = talloc_memdup(mem_ctx, &wire->hot_keys_wire[offset],
2343 talloc_free(dbstats);
2346 dbstats->hot_keys[i].key.dptr = ptr;
2354 size_t ctdb_election_message_len(struct ctdb_election_message *election)
2356 return sizeof(struct ctdb_election_message);
2359 void ctdb_election_message_push(struct ctdb_election_message *election,
2362 memcpy(buf, election, sizeof(struct ctdb_election_message));
2365 int ctdb_election_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2366 struct ctdb_election_message **out)
2368 struct ctdb_election_message *election;
2370 if (buflen < sizeof(struct ctdb_election_message)) {
2374 election = talloc_memdup(mem_ctx, buf,
2375 sizeof(struct ctdb_election_message));
2376 if (election == NULL) {
2384 size_t ctdb_srvid_message_len(struct ctdb_srvid_message *msg)
2386 return sizeof(struct ctdb_srvid_message);
2389 void ctdb_srvid_message_push(struct ctdb_srvid_message *msg, uint8_t *buf)
2391 memcpy(buf, msg, sizeof(struct ctdb_srvid_message));
2394 int ctdb_srvid_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2395 struct ctdb_srvid_message **out)
2397 struct ctdb_srvid_message *msg;
2399 if (buflen < sizeof(struct ctdb_srvid_message)) {
2403 msg = talloc_memdup(mem_ctx, buf, sizeof(struct ctdb_srvid_message));
2412 size_t ctdb_disable_message_len(struct ctdb_disable_message *disable)
2414 return sizeof(struct ctdb_disable_message);
2417 void ctdb_disable_message_push(struct ctdb_disable_message *disable,
2420 memcpy(buf, disable, sizeof(struct ctdb_disable_message));
2423 int ctdb_disable_message_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2424 struct ctdb_disable_message **out)
2426 struct ctdb_disable_message *disable;
2428 if (buflen < sizeof(struct ctdb_disable_message)) {
2432 disable = talloc_memdup(mem_ctx, buf,
2433 sizeof(struct ctdb_disable_message));
2434 if (disable == NULL) {
2442 size_t ctdb_tdb_data_len(TDB_DATA data)
2447 void ctdb_tdb_data_push(TDB_DATA data, uint8_t *buf)
2449 memcpy(buf, data.dptr, data.dsize);
2452 int ctdb_tdb_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2457 data.dsize = buflen;
2458 if (data.dsize > 0) {
2459 data.dptr = talloc_memdup(mem_ctx, buf, buflen);
2460 if (data.dptr == NULL) {
2471 size_t ctdb_server_id_len(struct ctdb_server_id *sid)
2473 return sizeof(struct ctdb_server_id);
2476 void ctdb_server_id_push(struct ctdb_server_id *sid, uint8_t *buf)
2478 memcpy(buf, sid, sizeof(struct ctdb_server_id));
2481 int ctdb_server_id_pull(uint8_t *buf, size_t buflen,
2482 struct ctdb_server_id *sid)
2484 if (buflen < sizeof(struct ctdb_server_id)) {
2488 memcpy(sid, buf, sizeof(struct ctdb_server_id));
2492 size_t ctdb_g_lock_len(struct ctdb_g_lock *lock)
2494 return sizeof(struct ctdb_g_lock);
2497 void ctdb_g_lock_push(struct ctdb_g_lock *lock, uint8_t *buf)
2499 memcpy(buf, lock, sizeof(struct ctdb_g_lock));
2502 int ctdb_g_lock_pull(uint8_t *buf, size_t buflen, struct ctdb_g_lock *lock)
2504 if (buflen < sizeof(struct ctdb_g_lock)) {
2508 memcpy(lock, buf, sizeof(struct ctdb_g_lock));
2512 size_t ctdb_g_lock_list_len(struct ctdb_g_lock_list *lock_list)
2514 return lock_list->num * sizeof(struct ctdb_g_lock);
2517 void ctdb_g_lock_list_push(struct ctdb_g_lock_list *lock_list, uint8_t *buf)
2522 for (i=0; i<lock_list->num; i++) {
2523 ctdb_g_lock_push(&lock_list->lock[i], &buf[offset]);
2524 offset += sizeof(struct ctdb_g_lock);
2528 int ctdb_g_lock_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
2529 struct ctdb_g_lock_list **out)
2531 struct ctdb_g_lock_list *lock_list;
2536 lock_list = talloc_zero(mem_ctx, struct ctdb_g_lock_list);
2537 if (lock_list == NULL) {
2541 count = buflen / sizeof(struct ctdb_g_lock);
2542 lock_list->lock = talloc_array(lock_list, struct ctdb_g_lock, count);
2543 if (lock_list->lock == NULL) {
2544 talloc_free(lock_list);
2549 for (i=0; i<count; i++) {
2550 ret = ctdb_g_lock_pull(&buf[offset], buflen-offset,
2551 &lock_list->lock[i]);
2553 talloc_free(lock_list);
2556 offset += sizeof(struct ctdb_g_lock);
2559 lock_list->num = count;