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_types_test.c"
30 #define GENERATION 0xabcdef12
31 #define OPERATION CTDB_REQ_KEEPALIVE
32 #define REQID 0x34567890
37 * Functions to fill and verify protocol structures
40 static void verify_ctdb_req_header(struct ctdb_req_header *h,
41 struct ctdb_req_header *h2)
43 verify_buffer(h, h2, ctdb_req_header_len(h));
46 static void fill_ctdb_req_call(TALLOC_CTX *mem_ctx,
47 struct ctdb_req_call *c)
52 c->hopcount = rand32();
53 fill_tdb_data_nonnull(mem_ctx, &c->key);
54 fill_tdb_data(mem_ctx, &c->calldata);
57 static void verify_ctdb_req_call(struct ctdb_req_call *c,
58 struct ctdb_req_call *c2)
60 assert(c->flags == c2->flags);
61 assert(c->db_id == c2->db_id);
62 assert(c->callid == c2->callid);
63 assert(c->hopcount == c2->hopcount);
64 verify_tdb_data(&c->key, &c2->key);
65 verify_tdb_data(&c->calldata, &c2->calldata);
68 static void fill_ctdb_reply_call(TALLOC_CTX *mem_ctx,
69 struct ctdb_reply_call *c)
72 fill_tdb_data(mem_ctx, &c->data);
75 static void verify_ctdb_reply_call(struct ctdb_reply_call *c,
76 struct ctdb_reply_call *c2)
78 assert(c->status == c2->status);
79 verify_tdb_data(&c->data, &c2->data);
82 static void fill_ctdb_reply_error(TALLOC_CTX *mem_ctx,
83 struct ctdb_reply_error *c)
86 fill_tdb_data(mem_ctx, &c->msg);
89 static void verify_ctdb_reply_error(struct ctdb_reply_error *c,
90 struct ctdb_reply_error *c2)
92 assert(c->status == c2->status);
93 verify_tdb_data(&c->msg, &c2->msg);
96 static void fill_ctdb_req_dmaster(TALLOC_CTX *mem_ctx,
97 struct ctdb_req_dmaster *c)
101 c->dmaster = rand32();
102 fill_tdb_data_nonnull(mem_ctx, &c->key);
103 fill_tdb_data(mem_ctx, &c->data);
106 static void verify_ctdb_req_dmaster(struct ctdb_req_dmaster *c,
107 struct ctdb_req_dmaster *c2)
109 assert(c->db_id == c2->db_id);
110 assert(c->rsn == c2->rsn);
111 assert(c->dmaster == c2->dmaster);
112 verify_tdb_data(&c->key, &c2->key);
113 verify_tdb_data(&c->data, &c2->data);
116 static void fill_ctdb_reply_dmaster(TALLOC_CTX *mem_ctx,
117 struct ctdb_reply_dmaster *c)
121 fill_tdb_data_nonnull(mem_ctx, &c->key);
122 fill_tdb_data(mem_ctx, &c->data);
125 static void verify_ctdb_reply_dmaster(struct ctdb_reply_dmaster *c,
126 struct ctdb_reply_dmaster *c2)
128 assert(c->db_id == c2->db_id);
129 assert(c->rsn == c2->rsn);
130 verify_tdb_data(&c->key, &c2->key);
131 verify_tdb_data(&c->data, &c2->data);
134 static void fill_ctdb_req_control_data(TALLOC_CTX *mem_ctx,
135 struct ctdb_req_control_data *cd,
140 case CTDB_CONTROL_PROCESS_EXISTS:
141 cd->data.pid = rand32();
144 case CTDB_CONTROL_STATISTICS:
147 case CTDB_CONTROL_PING:
150 case CTDB_CONTROL_GETDBPATH:
151 cd->data.db_id = rand32();
154 case CTDB_CONTROL_GETVNNMAP:
157 case CTDB_CONTROL_SETVNNMAP:
158 cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
159 assert(cd->data.vnnmap != NULL);
160 fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
163 case CTDB_CONTROL_GET_DEBUG:
166 case CTDB_CONTROL_SET_DEBUG:
167 cd->data.loglevel = rand_int(5);
170 case CTDB_CONTROL_GET_DBMAP:
173 case CTDB_CONTROL_PULL_DB:
174 cd->data.pulldb = talloc(mem_ctx, struct ctdb_pulldb);
175 assert(cd->data.pulldb != NULL);
176 fill_ctdb_pulldb(mem_ctx, cd->data.pulldb);
179 case CTDB_CONTROL_PUSH_DB:
180 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
181 assert(cd->data.recbuf != NULL);
182 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
185 case CTDB_CONTROL_GET_RECMODE:
188 case CTDB_CONTROL_SET_RECMODE:
189 cd->data.recmode = rand_int(2);
192 case CTDB_CONTROL_STATISTICS_RESET:
195 case CTDB_CONTROL_DB_ATTACH:
196 fill_ctdb_string(mem_ctx, &cd->data.db_name);
197 assert(cd->data.db_name != NULL);
200 case CTDB_CONTROL_SET_CALL:
203 case CTDB_CONTROL_TRAVERSE_START:
204 cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
205 assert(cd->data.traverse_start != NULL);
206 fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
209 case CTDB_CONTROL_TRAVERSE_ALL:
210 cd->data.traverse_all = talloc(mem_ctx, struct ctdb_traverse_all);
211 assert(cd->data.traverse_all != NULL);
212 fill_ctdb_traverse_all(mem_ctx, cd->data.traverse_all);
215 case CTDB_CONTROL_TRAVERSE_DATA:
216 cd->data.rec_data = talloc(mem_ctx, struct ctdb_rec_data);
217 assert(cd->data.rec_data != NULL);
218 fill_ctdb_rec_data(mem_ctx, cd->data.rec_data);
221 case CTDB_CONTROL_REGISTER_SRVID:
224 case CTDB_CONTROL_DEREGISTER_SRVID:
227 case CTDB_CONTROL_GET_DBNAME:
228 cd->data.db_id = rand32();
231 case CTDB_CONTROL_ENABLE_SEQNUM:
232 cd->data.db_id = rand32();
235 case CTDB_CONTROL_UPDATE_SEQNUM:
236 cd->data.db_id = rand32();
239 case CTDB_CONTROL_DUMP_MEMORY:
242 case CTDB_CONTROL_GET_PID:
245 case CTDB_CONTROL_GET_RECMASTER:
248 case CTDB_CONTROL_SET_RECMASTER:
249 cd->data.recmaster = rand_int(32);
252 case CTDB_CONTROL_FREEZE:
255 case CTDB_CONTROL_GET_PNN:
258 case CTDB_CONTROL_SHUTDOWN:
261 case CTDB_CONTROL_GET_MONMODE:
264 case CTDB_CONTROL_TCP_CLIENT:
265 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
266 assert(cd->data.conn != NULL);
267 fill_ctdb_connection(mem_ctx, cd->data.conn);
270 case CTDB_CONTROL_TCP_ADD:
271 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
272 assert(cd->data.conn != NULL);
273 fill_ctdb_connection(mem_ctx, cd->data.conn);
276 case CTDB_CONTROL_TCP_REMOVE:
277 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
278 assert(cd->data.conn != NULL);
279 fill_ctdb_connection(mem_ctx, cd->data.conn);
282 case CTDB_CONTROL_STARTUP:
285 case CTDB_CONTROL_SET_TUNABLE:
286 cd->data.tunable = talloc(mem_ctx, struct ctdb_tunable);
287 assert(cd->data.tunable != NULL);
288 fill_ctdb_tunable(mem_ctx, cd->data.tunable);
291 case CTDB_CONTROL_GET_TUNABLE:
292 fill_ctdb_string(mem_ctx, &cd->data.tun_var);
293 assert(cd->data.tun_var != NULL);
296 case CTDB_CONTROL_LIST_TUNABLES:
299 case CTDB_CONTROL_MODIFY_FLAGS:
300 cd->data.flag_change = talloc(mem_ctx, struct ctdb_node_flag_change);
301 assert(cd->data.flag_change != NULL);
302 fill_ctdb_node_flag_change(mem_ctx, cd->data.flag_change);
305 case CTDB_CONTROL_GET_ALL_TUNABLES:
308 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
309 cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
310 assert(cd->data.addr != NULL);
311 fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
314 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
315 cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
316 assert(cd->data.tickles != NULL);
317 fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
320 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
321 fill_ctdb_string(mem_ctx, &cd->data.db_name);
322 assert(cd->data.db_name != NULL);
325 case CTDB_CONTROL_UPDATE_RECORD:
326 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
327 assert(cd->data.recbuf != NULL);
328 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
331 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
332 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
333 assert(cd->data.addr_info != NULL);
334 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
337 case CTDB_CONTROL_WIPE_DATABASE:
338 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
339 assert(cd->data.transdb != NULL);
340 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
343 case CTDB_CONTROL_UPTIME:
346 case CTDB_CONTROL_START_RECOVERY:
349 case CTDB_CONTROL_END_RECOVERY:
352 case CTDB_CONTROL_RELOAD_NODES_FILE:
355 case CTDB_CONTROL_TRY_DELETE_RECORDS:
356 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
357 assert(cd->data.recbuf != NULL);
358 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
361 case CTDB_CONTROL_ENABLE_MONITOR:
364 case CTDB_CONTROL_DISABLE_MONITOR:
367 case CTDB_CONTROL_ADD_PUBLIC_IP:
368 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
369 assert(cd->data.addr_info != NULL);
370 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
373 case CTDB_CONTROL_DEL_PUBLIC_IP:
374 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
375 assert(cd->data.addr_info != NULL);
376 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
379 case CTDB_CONTROL_GET_CAPABILITIES:
382 case CTDB_CONTROL_START_PERSISTENT_UPDATE:
385 case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
388 case CTDB_CONTROL_RECD_PING:
391 case CTDB_CONTROL_RELEASE_IP:
392 cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
393 assert(cd->data.pubip != NULL);
394 fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
397 case CTDB_CONTROL_TAKEOVER_IP:
398 cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
399 assert(cd->data.pubip != NULL);
400 fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
403 case CTDB_CONTROL_GET_PUBLIC_IPS:
406 case CTDB_CONTROL_GET_NODEMAP:
409 case CTDB_CONTROL_TRAVERSE_KILL:
410 cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
411 assert(cd->data.traverse_start != NULL);
412 fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
415 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
416 cd->data.reclock_latency = rand_double();
419 case CTDB_CONTROL_GET_RECLOCK_FILE:
422 case CTDB_CONTROL_STOP_NODE:
425 case CTDB_CONTROL_CONTINUE_NODE:
428 case CTDB_CONTROL_SET_LMASTERROLE:
429 cd->data.role = rand_int(2);
432 case CTDB_CONTROL_SET_RECMASTERROLE:
433 cd->data.role = rand_int(2);
436 case CTDB_CONTROL_SET_BAN_STATE:
437 cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
438 assert(cd->data.ban_state != NULL);
439 fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
442 case CTDB_CONTROL_GET_BAN_STATE:
445 case CTDB_CONTROL_REGISTER_NOTIFY:
446 cd->data.notify = talloc(mem_ctx, struct ctdb_notify_data);
447 assert(cd->data.notify != NULL);
448 fill_ctdb_notify_data(mem_ctx, cd->data.notify);
451 case CTDB_CONTROL_DEREGISTER_NOTIFY:
452 cd->data.srvid = rand64();
455 case CTDB_CONTROL_TRANS3_COMMIT:
456 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
457 assert(cd->data.recbuf != NULL);
458 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
461 case CTDB_CONTROL_GET_DB_SEQNUM:
462 cd->data.db_id = rand32();
465 case CTDB_CONTROL_DB_SET_HEALTHY:
466 cd->data.db_id = rand32();
469 case CTDB_CONTROL_DB_GET_HEALTH:
470 cd->data.db_id = rand32();
473 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
474 cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
475 assert(cd->data.addr != NULL);
476 fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
479 case CTDB_CONTROL_GET_IFACES:
482 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
483 cd->data.iface = talloc(mem_ctx, struct ctdb_iface);
484 assert(cd->data.iface != NULL);
485 fill_ctdb_iface(mem_ctx, cd->data.iface);
488 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
489 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
490 assert(cd->data.conn != NULL);
491 fill_ctdb_connection(mem_ctx, cd->data.conn);
494 case CTDB_CONTROL_GET_STAT_HISTORY:
497 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
498 cd->data.key = talloc(mem_ctx, struct ctdb_key_data);
499 assert(cd->data.key != NULL);
500 fill_ctdb_key_data(mem_ctx, cd->data.key);
503 case CTDB_CONTROL_SET_DB_READONLY:
504 cd->data.db_id = rand32();
507 case CTDB_CONTROL_CHECK_SRVIDS:
510 case CTDB_CONTROL_TRAVERSE_START_EXT:
511 cd->data.traverse_start_ext = talloc(mem_ctx, struct ctdb_traverse_start_ext);
512 assert(cd->data.traverse_start_ext != NULL);
513 fill_ctdb_traverse_start_ext(mem_ctx, cd->data.traverse_start_ext);
516 case CTDB_CONTROL_GET_DB_STATISTICS:
517 cd->data.db_id = rand32();
520 case CTDB_CONTROL_SET_DB_STICKY:
521 cd->data.db_id = rand32();
524 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
527 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
528 cd->data.traverse_all_ext = talloc(mem_ctx, struct ctdb_traverse_all_ext);
529 assert(cd->data.traverse_all_ext != NULL);
530 fill_ctdb_traverse_all_ext(mem_ctx, cd->data.traverse_all_ext);
533 case CTDB_CONTROL_RECEIVE_RECORDS:
534 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
535 assert(cd->data.recbuf != NULL);
536 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
539 case CTDB_CONTROL_IPREALLOCATED:
542 case CTDB_CONTROL_GET_RUNSTATE:
545 case CTDB_CONTROL_DB_DETACH:
546 cd->data.db_id = rand32();
549 case CTDB_CONTROL_GET_NODES_FILE:
552 case CTDB_CONTROL_DB_FREEZE:
553 cd->data.db_id = rand32();
556 case CTDB_CONTROL_DB_THAW:
557 cd->data.db_id = rand32();
560 case CTDB_CONTROL_DB_TRANSACTION_START:
561 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
562 assert(cd->data.transdb != NULL);
563 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
566 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
567 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
568 assert(cd->data.transdb != NULL);
569 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
572 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
573 cd->data.db_id = rand32();
576 case CTDB_CONTROL_DB_PULL:
577 cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
578 assert(cd->data.pulldb_ext != NULL);
579 fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
582 case CTDB_CONTROL_DB_PUSH_START:
583 cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
584 assert(cd->data.pulldb_ext != NULL);
585 fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
588 case CTDB_CONTROL_DB_PUSH_CONFIRM:
589 cd->data.db_id = rand32();
592 case CTDB_CONTROL_DB_OPEN_FLAGS:
593 cd->data.db_id = rand32();
596 case CTDB_CONTROL_DB_ATTACH_REPLICATED:
597 fill_ctdb_string(mem_ctx, &cd->data.db_name);
598 assert(cd->data.db_name != NULL);
603 static void verify_ctdb_req_control_data(struct ctdb_req_control_data *cd,
604 struct ctdb_req_control_data *cd2)
606 assert(cd->opcode == cd2->opcode);
608 switch (cd->opcode) {
609 case CTDB_CONTROL_PROCESS_EXISTS:
610 assert(cd->data.pid == cd2->data.pid);
613 case CTDB_CONTROL_STATISTICS:
616 case CTDB_CONTROL_PING:
619 case CTDB_CONTROL_GETDBPATH:
620 assert(cd->data.db_id == cd2->data.db_id);
623 case CTDB_CONTROL_GETVNNMAP:
626 case CTDB_CONTROL_SETVNNMAP:
627 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap);
630 case CTDB_CONTROL_GET_DEBUG:
633 case CTDB_CONTROL_SET_DEBUG:
634 assert(cd->data.loglevel == cd2->data.loglevel);
637 case CTDB_CONTROL_GET_DBMAP:
640 case CTDB_CONTROL_PULL_DB:
641 verify_ctdb_pulldb(cd->data.pulldb, cd2->data.pulldb);
644 case CTDB_CONTROL_PUSH_DB:
645 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
648 case CTDB_CONTROL_GET_RECMODE:
651 case CTDB_CONTROL_SET_RECMODE:
652 assert(cd->data.recmode == cd2->data.recmode);
655 case CTDB_CONTROL_STATISTICS_RESET:
658 case CTDB_CONTROL_DB_ATTACH:
659 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
662 case CTDB_CONTROL_SET_CALL:
665 case CTDB_CONTROL_TRAVERSE_START:
666 verify_ctdb_traverse_start(cd->data.traverse_start,
667 cd2->data.traverse_start);
670 case CTDB_CONTROL_TRAVERSE_ALL:
671 verify_ctdb_traverse_all(cd->data.traverse_all,
672 cd2->data.traverse_all);
675 case CTDB_CONTROL_TRAVERSE_DATA:
676 verify_ctdb_rec_data(cd->data.rec_data, cd2->data.rec_data);
679 case CTDB_CONTROL_REGISTER_SRVID:
682 case CTDB_CONTROL_DEREGISTER_SRVID:
685 case CTDB_CONTROL_GET_DBNAME:
686 assert(cd->data.db_id == cd2->data.db_id);
689 case CTDB_CONTROL_ENABLE_SEQNUM:
690 assert(cd->data.db_id == cd2->data.db_id);
693 case CTDB_CONTROL_UPDATE_SEQNUM:
694 assert(cd->data.db_id == cd2->data.db_id);
697 case CTDB_CONTROL_DUMP_MEMORY:
700 case CTDB_CONTROL_GET_PID:
703 case CTDB_CONTROL_GET_RECMASTER:
706 case CTDB_CONTROL_SET_RECMASTER:
707 assert(cd->data.recmaster == cd2->data.recmaster);
710 case CTDB_CONTROL_FREEZE:
713 case CTDB_CONTROL_GET_PNN:
716 case CTDB_CONTROL_SHUTDOWN:
719 case CTDB_CONTROL_GET_MONMODE:
722 case CTDB_CONTROL_TCP_CLIENT:
723 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
726 case CTDB_CONTROL_TCP_ADD:
727 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
730 case CTDB_CONTROL_TCP_REMOVE:
731 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
734 case CTDB_CONTROL_STARTUP:
737 case CTDB_CONTROL_SET_TUNABLE:
738 verify_ctdb_tunable(cd->data.tunable, cd2->data.tunable);
741 case CTDB_CONTROL_GET_TUNABLE:
742 verify_ctdb_string(cd->data.tun_var, cd2->data.tun_var);
745 case CTDB_CONTROL_LIST_TUNABLES:
748 case CTDB_CONTROL_MODIFY_FLAGS:
749 verify_ctdb_node_flag_change(cd->data.flag_change,
750 cd2->data.flag_change);
753 case CTDB_CONTROL_GET_ALL_TUNABLES:
756 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
757 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr);
760 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
761 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles);
764 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
765 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
768 case CTDB_CONTROL_UPDATE_RECORD:
769 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
772 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
773 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
776 case CTDB_CONTROL_WIPE_DATABASE:
777 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
780 case CTDB_CONTROL_UPTIME:
783 case CTDB_CONTROL_START_RECOVERY:
786 case CTDB_CONTROL_END_RECOVERY:
789 case CTDB_CONTROL_RELOAD_NODES_FILE:
792 case CTDB_CONTROL_TRY_DELETE_RECORDS:
793 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
796 case CTDB_CONTROL_ENABLE_MONITOR:
799 case CTDB_CONTROL_DISABLE_MONITOR:
802 case CTDB_CONTROL_ADD_PUBLIC_IP:
803 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
806 case CTDB_CONTROL_DEL_PUBLIC_IP:
807 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
810 case CTDB_CONTROL_GET_CAPABILITIES:
813 case CTDB_CONTROL_START_PERSISTENT_UPDATE:
816 case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
819 case CTDB_CONTROL_RECD_PING:
822 case CTDB_CONTROL_RELEASE_IP:
823 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip);
826 case CTDB_CONTROL_TAKEOVER_IP:
827 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip);
830 case CTDB_CONTROL_GET_PUBLIC_IPS:
833 case CTDB_CONTROL_GET_NODEMAP:
836 case CTDB_CONTROL_TRAVERSE_KILL:
837 verify_ctdb_traverse_start(cd->data.traverse_start,
838 cd2->data.traverse_start);
841 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
842 assert(cd->data.reclock_latency == cd2->data.reclock_latency);
845 case CTDB_CONTROL_GET_RECLOCK_FILE:
848 case CTDB_CONTROL_STOP_NODE:
851 case CTDB_CONTROL_CONTINUE_NODE:
854 case CTDB_CONTROL_SET_LMASTERROLE:
855 assert(cd->data.role == cd2->data.role);
858 case CTDB_CONTROL_SET_RECMASTERROLE:
859 assert(cd->data.role == cd2->data.role);
862 case CTDB_CONTROL_SET_BAN_STATE:
863 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state);
866 case CTDB_CONTROL_GET_BAN_STATE:
869 case CTDB_CONTROL_REGISTER_NOTIFY:
870 verify_ctdb_notify_data(cd->data.notify, cd2->data.notify);
873 case CTDB_CONTROL_DEREGISTER_NOTIFY:
874 assert(cd->data.srvid == cd2->data.srvid);
877 case CTDB_CONTROL_TRANS3_COMMIT:
878 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
881 case CTDB_CONTROL_GET_DB_SEQNUM:
882 assert(cd->data.db_id == cd2->data.db_id);
885 case CTDB_CONTROL_DB_SET_HEALTHY:
886 assert(cd->data.db_id == cd2->data.db_id);
889 case CTDB_CONTROL_DB_GET_HEALTH:
890 assert(cd->data.db_id == cd2->data.db_id);
893 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
894 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr);
897 case CTDB_CONTROL_GET_IFACES:
900 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
901 verify_ctdb_iface(cd->data.iface, cd2->data.iface);
904 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
905 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
908 case CTDB_CONTROL_GET_STAT_HISTORY:
911 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
912 verify_ctdb_key_data(cd->data.key, cd2->data.key);
915 case CTDB_CONTROL_SET_DB_READONLY:
916 assert(cd->data.db_id == cd2->data.db_id);
919 case CTDB_CONTROL_CHECK_SRVIDS:
922 case CTDB_CONTROL_TRAVERSE_START_EXT:
923 verify_ctdb_traverse_start_ext(cd->data.traverse_start_ext,
924 cd2->data.traverse_start_ext);
927 case CTDB_CONTROL_GET_DB_STATISTICS:
928 assert(cd->data.db_id == cd2->data.db_id);
931 case CTDB_CONTROL_SET_DB_STICKY:
932 assert(cd->data.db_id == cd2->data.db_id);
935 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
938 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
939 verify_ctdb_traverse_all_ext(cd->data.traverse_all_ext,
940 cd2->data.traverse_all_ext);
943 case CTDB_CONTROL_RECEIVE_RECORDS:
944 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
947 case CTDB_CONTROL_IPREALLOCATED:
950 case CTDB_CONTROL_GET_RUNSTATE:
953 case CTDB_CONTROL_DB_DETACH:
954 assert(cd->data.db_id == cd2->data.db_id);
957 case CTDB_CONTROL_GET_NODES_FILE:
960 case CTDB_CONTROL_DB_FREEZE:
961 assert(cd->data.db_id == cd2->data.db_id);
964 case CTDB_CONTROL_DB_THAW:
965 assert(cd->data.db_id == cd2->data.db_id);
968 case CTDB_CONTROL_DB_TRANSACTION_START:
969 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
972 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
973 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
976 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
977 assert(cd->data.db_id == cd2->data.db_id);
980 case CTDB_CONTROL_DB_PULL:
981 verify_ctdb_pulldb_ext(cd->data.pulldb_ext,
982 cd2->data.pulldb_ext);
985 case CTDB_CONTROL_DB_PUSH_START:
986 verify_ctdb_pulldb_ext(cd->data.pulldb_ext,
987 cd2->data.pulldb_ext);
990 case CTDB_CONTROL_DB_PUSH_CONFIRM:
991 assert(cd->data.db_id == cd2->data.db_id);
994 case CTDB_CONTROL_DB_OPEN_FLAGS:
995 assert(cd->data.db_id == cd2->data.db_id);
998 case CTDB_CONTROL_DB_ATTACH_REPLICATED:
999 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
1005 static void fill_ctdb_req_control(TALLOC_CTX *mem_ctx,
1006 struct ctdb_req_control *c,
1011 c->srvid = rand64();
1012 c->client_id = rand32();
1013 c->flags = rand32();
1015 fill_ctdb_req_control_data(mem_ctx, &c->rdata, opcode);
1018 static void verify_ctdb_req_control(struct ctdb_req_control *c,
1019 struct ctdb_req_control *c2)
1021 assert(c->opcode == c2->opcode);
1022 assert(c->pad == c2->pad);
1023 assert(c->srvid == c2->srvid);
1024 assert(c->client_id == c2->client_id);
1025 assert(c->flags == c2->flags);
1027 verify_ctdb_req_control_data(&c->rdata, &c2->rdata);
1030 static void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx,
1031 struct ctdb_reply_control_data *cd,
1034 cd->opcode = opcode;
1037 case CTDB_CONTROL_PROCESS_EXISTS:
1040 case CTDB_CONTROL_STATISTICS:
1041 cd->data.stats = talloc(mem_ctx, struct ctdb_statistics);
1042 assert(cd->data.stats != NULL);
1043 fill_ctdb_statistics(mem_ctx, cd->data.stats);
1046 case CTDB_CONTROL_PING:
1049 case CTDB_CONTROL_GETDBPATH:
1050 fill_ctdb_string(mem_ctx, &cd->data.db_path);
1051 assert(cd->data.db_path != NULL);
1054 case CTDB_CONTROL_GETVNNMAP:
1055 cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
1056 assert(cd->data.vnnmap != NULL);
1057 fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
1060 case CTDB_CONTROL_SETVNNMAP:
1063 case CTDB_CONTROL_GET_DEBUG:
1064 cd->data.loglevel = rand_int(5);
1067 case CTDB_CONTROL_SET_DEBUG:
1070 case CTDB_CONTROL_GET_DBMAP:
1071 cd->data.dbmap = talloc(mem_ctx, struct ctdb_dbid_map);
1072 assert(cd->data.dbmap != NULL);
1073 fill_ctdb_dbid_map(mem_ctx, cd->data.dbmap);
1076 case CTDB_CONTROL_PULL_DB:
1077 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1078 assert(cd->data.recbuf != NULL);
1079 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1082 case CTDB_CONTROL_PUSH_DB:
1085 case CTDB_CONTROL_GET_RECMODE:
1088 case CTDB_CONTROL_SET_RECMODE:
1091 case CTDB_CONTROL_STATISTICS_RESET:
1094 case CTDB_CONTROL_DB_ATTACH:
1095 cd->data.db_id = rand32();
1098 case CTDB_CONTROL_SET_CALL:
1101 case CTDB_CONTROL_TRAVERSE_START:
1104 case CTDB_CONTROL_TRAVERSE_ALL:
1107 case CTDB_CONTROL_TRAVERSE_DATA:
1110 case CTDB_CONTROL_REGISTER_SRVID:
1113 case CTDB_CONTROL_DEREGISTER_SRVID:
1116 case CTDB_CONTROL_GET_DBNAME:
1117 fill_ctdb_string(mem_ctx, &cd->data.db_name);
1118 assert(cd->data.db_name);
1121 case CTDB_CONTROL_ENABLE_SEQNUM:
1124 case CTDB_CONTROL_UPDATE_SEQNUM:
1127 case CTDB_CONTROL_DUMP_MEMORY:
1128 fill_ctdb_string(mem_ctx, &cd->data.mem_str);
1129 assert(cd->data.mem_str);
1132 case CTDB_CONTROL_GET_PID:
1135 case CTDB_CONTROL_GET_RECMASTER:
1138 case CTDB_CONTROL_SET_RECMASTER:
1141 case CTDB_CONTROL_FREEZE:
1144 case CTDB_CONTROL_GET_PNN:
1147 case CTDB_CONTROL_SHUTDOWN:
1150 case CTDB_CONTROL_GET_MONMODE:
1153 case CTDB_CONTROL_TCP_CLIENT:
1156 case CTDB_CONTROL_TCP_ADD:
1159 case CTDB_CONTROL_TCP_REMOVE:
1162 case CTDB_CONTROL_STARTUP:
1165 case CTDB_CONTROL_SET_TUNABLE:
1168 case CTDB_CONTROL_GET_TUNABLE:
1169 cd->data.tun_value = rand32();
1172 case CTDB_CONTROL_LIST_TUNABLES:
1173 cd->data.tun_var_list = talloc(mem_ctx, struct ctdb_var_list);
1174 assert(cd->data.tun_var_list != NULL);
1175 fill_ctdb_var_list(mem_ctx, cd->data.tun_var_list);
1178 case CTDB_CONTROL_MODIFY_FLAGS:
1181 case CTDB_CONTROL_GET_ALL_TUNABLES:
1182 cd->data.tun_list = talloc(mem_ctx, struct ctdb_tunable_list);
1183 assert(cd->data.tun_list != NULL);
1184 fill_ctdb_tunable_list(mem_ctx, cd->data.tun_list);
1187 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1188 cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
1189 assert(cd->data.tickles != NULL);
1190 fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
1193 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1196 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1197 cd->data.db_id = rand32();
1200 case CTDB_CONTROL_UPDATE_RECORD:
1203 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1206 case CTDB_CONTROL_WIPE_DATABASE:
1209 case CTDB_CONTROL_UPTIME:
1210 cd->data.uptime = talloc(mem_ctx, struct ctdb_uptime);
1211 assert(cd->data.uptime != NULL);
1212 fill_ctdb_uptime(mem_ctx, cd->data.uptime);
1215 case CTDB_CONTROL_START_RECOVERY:
1218 case CTDB_CONTROL_END_RECOVERY:
1221 case CTDB_CONTROL_RELOAD_NODES_FILE:
1224 case CTDB_CONTROL_TRY_DELETE_RECORDS:
1225 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1226 assert(cd->data.recbuf != NULL);
1227 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1230 case CTDB_CONTROL_ENABLE_MONITOR:
1233 case CTDB_CONTROL_DISABLE_MONITOR:
1236 case CTDB_CONTROL_ADD_PUBLIC_IP:
1239 case CTDB_CONTROL_DEL_PUBLIC_IP:
1242 case CTDB_CONTROL_GET_CAPABILITIES:
1243 cd->data.caps = rand32();
1246 case CTDB_CONTROL_START_PERSISTENT_UPDATE:
1249 case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
1252 case CTDB_CONTROL_RECD_PING:
1255 case CTDB_CONTROL_RELEASE_IP:
1258 case CTDB_CONTROL_TAKEOVER_IP:
1261 case CTDB_CONTROL_GET_PUBLIC_IPS:
1262 cd->data.pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list);
1263 assert(cd->data.pubip_list != NULL);
1264 fill_ctdb_public_ip_list(mem_ctx, cd->data.pubip_list);
1267 case CTDB_CONTROL_GET_NODEMAP:
1268 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
1269 assert(cd->data.nodemap != NULL);
1270 fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
1273 case CTDB_CONTROL_TRAVERSE_KILL:
1276 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1279 case CTDB_CONTROL_GET_RECLOCK_FILE:
1280 fill_ctdb_string(mem_ctx, &cd->data.reclock_file);
1281 assert(cd->data.reclock_file != NULL);
1284 case CTDB_CONTROL_STOP_NODE:
1287 case CTDB_CONTROL_CONTINUE_NODE:
1290 case CTDB_CONTROL_SET_LMASTERROLE:
1293 case CTDB_CONTROL_SET_RECMASTERROLE:
1296 case CTDB_CONTROL_SET_BAN_STATE:
1299 case CTDB_CONTROL_GET_BAN_STATE:
1300 cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
1301 assert(cd->data.ban_state != NULL);
1302 fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
1305 case CTDB_CONTROL_REGISTER_NOTIFY:
1308 case CTDB_CONTROL_DEREGISTER_NOTIFY:
1311 case CTDB_CONTROL_TRANS3_COMMIT:
1314 case CTDB_CONTROL_GET_DB_SEQNUM:
1315 cd->data.seqnum = rand64();
1318 case CTDB_CONTROL_DB_SET_HEALTHY:
1321 case CTDB_CONTROL_DB_GET_HEALTH:
1322 fill_ctdb_string(mem_ctx, &cd->data.reason);
1323 assert(cd->data.reason != NULL);
1326 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1327 cd->data.ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info);
1328 assert(cd->data.ipinfo != NULL);
1329 fill_ctdb_public_ip_info(mem_ctx, cd->data.ipinfo);
1332 case CTDB_CONTROL_GET_IFACES:
1333 cd->data.iface_list = talloc(mem_ctx, struct ctdb_iface_list);
1334 assert(cd->data.iface_list != NULL);
1335 fill_ctdb_iface_list(mem_ctx, cd->data.iface_list);
1338 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1341 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1344 case CTDB_CONTROL_GET_STAT_HISTORY:
1345 cd->data.stats_list = talloc(mem_ctx, struct ctdb_statistics_list);
1346 assert(cd->data.stats_list != NULL);
1347 fill_ctdb_statistics_list(mem_ctx, cd->data.stats_list);
1350 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1353 case CTDB_CONTROL_SET_DB_READONLY:
1356 case CTDB_CONTROL_CHECK_SRVIDS:
1359 case CTDB_CONTROL_TRAVERSE_START_EXT:
1362 case CTDB_CONTROL_GET_DB_STATISTICS:
1363 cd->data.dbstats = talloc(mem_ctx, struct ctdb_db_statistics);
1364 assert(cd->data.dbstats != NULL);
1365 fill_ctdb_db_statistics(mem_ctx, cd->data.dbstats);
1368 case CTDB_CONTROL_SET_DB_STICKY:
1371 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1374 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1377 case CTDB_CONTROL_RECEIVE_RECORDS:
1378 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1379 assert(cd->data.recbuf != NULL);
1380 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1383 case CTDB_CONTROL_IPREALLOCATED:
1386 case CTDB_CONTROL_GET_RUNSTATE:
1387 cd->data.runstate = rand32();
1390 case CTDB_CONTROL_DB_DETACH:
1393 case CTDB_CONTROL_GET_NODES_FILE:
1394 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
1395 assert(cd->data.nodemap != NULL);
1396 fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
1399 case CTDB_CONTROL_DB_PULL:
1400 cd->data.num_records = rand32();
1403 case CTDB_CONTROL_DB_PUSH_CONFIRM:
1404 cd->data.num_records = rand32();
1407 case CTDB_CONTROL_DB_OPEN_FLAGS:
1408 cd->data.tdb_flags = rand32();
1411 case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1412 cd->data.db_id = rand32();
1418 static void verify_ctdb_reply_control_data(struct ctdb_reply_control_data *cd,
1419 struct ctdb_reply_control_data *cd2)
1421 assert(cd->opcode == cd2->opcode);
1423 switch (cd->opcode) {
1424 case CTDB_CONTROL_PROCESS_EXISTS:
1427 case CTDB_CONTROL_STATISTICS:
1428 verify_ctdb_statistics(cd->data.stats, cd2->data.stats);
1431 case CTDB_CONTROL_PING:
1434 case CTDB_CONTROL_GETDBPATH:
1435 verify_ctdb_string(cd->data.db_path, cd2->data.db_path);
1438 case CTDB_CONTROL_GETVNNMAP:
1439 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap);
1442 case CTDB_CONTROL_SETVNNMAP:
1445 case CTDB_CONTROL_GET_DEBUG:
1446 assert(cd->data.loglevel == cd2->data.loglevel);
1449 case CTDB_CONTROL_SET_DEBUG:
1452 case CTDB_CONTROL_GET_DBMAP:
1453 verify_ctdb_dbid_map(cd->data.dbmap, cd2->data.dbmap);
1456 case CTDB_CONTROL_PULL_DB:
1457 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1460 case CTDB_CONTROL_PUSH_DB:
1463 case CTDB_CONTROL_GET_RECMODE:
1466 case CTDB_CONTROL_SET_RECMODE:
1469 case CTDB_CONTROL_STATISTICS_RESET:
1472 case CTDB_CONTROL_DB_ATTACH:
1473 assert(cd->data.db_id == cd2->data.db_id);
1476 case CTDB_CONTROL_SET_CALL:
1479 case CTDB_CONTROL_TRAVERSE_START:
1482 case CTDB_CONTROL_TRAVERSE_ALL:
1485 case CTDB_CONTROL_TRAVERSE_DATA:
1488 case CTDB_CONTROL_REGISTER_SRVID:
1491 case CTDB_CONTROL_DEREGISTER_SRVID:
1494 case CTDB_CONTROL_GET_DBNAME:
1495 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
1498 case CTDB_CONTROL_ENABLE_SEQNUM:
1501 case CTDB_CONTROL_UPDATE_SEQNUM:
1504 case CTDB_CONTROL_DUMP_MEMORY:
1505 verify_ctdb_string(cd->data.mem_str, cd2->data.mem_str);
1508 case CTDB_CONTROL_GET_PID:
1511 case CTDB_CONTROL_GET_RECMASTER:
1514 case CTDB_CONTROL_SET_RECMASTER:
1517 case CTDB_CONTROL_FREEZE:
1520 case CTDB_CONTROL_GET_PNN:
1523 case CTDB_CONTROL_SHUTDOWN:
1526 case CTDB_CONTROL_GET_MONMODE:
1529 case CTDB_CONTROL_TCP_CLIENT:
1532 case CTDB_CONTROL_TCP_ADD:
1535 case CTDB_CONTROL_TCP_REMOVE:
1538 case CTDB_CONTROL_STARTUP:
1541 case CTDB_CONTROL_SET_TUNABLE:
1544 case CTDB_CONTROL_GET_TUNABLE:
1545 assert(cd->data.tun_value == cd2->data.tun_value);
1548 case CTDB_CONTROL_LIST_TUNABLES:
1549 verify_ctdb_var_list(cd->data.tun_var_list,
1550 cd2->data.tun_var_list);
1553 case CTDB_CONTROL_MODIFY_FLAGS:
1556 case CTDB_CONTROL_GET_ALL_TUNABLES:
1557 verify_ctdb_tunable_list(cd->data.tun_list, cd2->data.tun_list);
1560 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1561 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles);
1564 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1567 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1568 assert(cd->data.db_id == cd2->data.db_id);
1571 case CTDB_CONTROL_UPDATE_RECORD:
1574 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1577 case CTDB_CONTROL_WIPE_DATABASE:
1580 case CTDB_CONTROL_UPTIME:
1581 verify_ctdb_uptime(cd->data.uptime, cd2->data.uptime);
1584 case CTDB_CONTROL_START_RECOVERY:
1587 case CTDB_CONTROL_END_RECOVERY:
1590 case CTDB_CONTROL_RELOAD_NODES_FILE:
1593 case CTDB_CONTROL_TRY_DELETE_RECORDS:
1594 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1597 case CTDB_CONTROL_ENABLE_MONITOR:
1600 case CTDB_CONTROL_DISABLE_MONITOR:
1603 case CTDB_CONTROL_ADD_PUBLIC_IP:
1606 case CTDB_CONTROL_DEL_PUBLIC_IP:
1609 case CTDB_CONTROL_GET_CAPABILITIES:
1610 assert(cd->data.caps == cd2->data.caps);
1613 case CTDB_CONTROL_RECD_PING:
1616 case CTDB_CONTROL_RELEASE_IP:
1619 case CTDB_CONTROL_TAKEOVER_IP:
1622 case CTDB_CONTROL_GET_PUBLIC_IPS:
1623 verify_ctdb_public_ip_list(cd->data.pubip_list,
1624 cd2->data.pubip_list);
1627 case CTDB_CONTROL_GET_NODEMAP:
1628 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap);
1631 case CTDB_CONTROL_TRAVERSE_KILL:
1634 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1637 case CTDB_CONTROL_GET_RECLOCK_FILE:
1638 verify_ctdb_string(cd->data.reclock_file,
1639 cd2->data.reclock_file);
1642 case CTDB_CONTROL_STOP_NODE:
1645 case CTDB_CONTROL_CONTINUE_NODE:
1648 case CTDB_CONTROL_SET_LMASTERROLE:
1651 case CTDB_CONTROL_SET_RECMASTERROLE:
1654 case CTDB_CONTROL_SET_BAN_STATE:
1657 case CTDB_CONTROL_GET_BAN_STATE:
1658 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state);
1661 case CTDB_CONTROL_REGISTER_NOTIFY:
1664 case CTDB_CONTROL_DEREGISTER_NOTIFY:
1667 case CTDB_CONTROL_TRANS3_COMMIT:
1670 case CTDB_CONTROL_GET_DB_SEQNUM:
1671 assert(cd->data.seqnum == cd2->data.seqnum);
1674 case CTDB_CONTROL_DB_SET_HEALTHY:
1677 case CTDB_CONTROL_DB_GET_HEALTH:
1678 verify_ctdb_string(cd->data.reason, cd2->data.reason);
1681 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1682 verify_ctdb_public_ip_info(cd->data.ipinfo, cd2->data.ipinfo);
1685 case CTDB_CONTROL_GET_IFACES:
1686 verify_ctdb_iface_list(cd->data.iface_list,
1687 cd2->data.iface_list);
1690 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1693 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1696 case CTDB_CONTROL_GET_STAT_HISTORY:
1697 verify_ctdb_statistics_list(cd->data.stats_list,
1698 cd2->data.stats_list);
1701 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1704 case CTDB_CONTROL_SET_DB_READONLY:
1707 case CTDB_CONTROL_CHECK_SRVIDS:
1710 case CTDB_CONTROL_TRAVERSE_START_EXT:
1713 case CTDB_CONTROL_GET_DB_STATISTICS:
1714 verify_ctdb_db_statistics(cd->data.dbstats, cd2->data.dbstats);
1717 case CTDB_CONTROL_SET_DB_STICKY:
1720 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1723 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1726 case CTDB_CONTROL_RECEIVE_RECORDS:
1727 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1730 case CTDB_CONTROL_IPREALLOCATED:
1733 case CTDB_CONTROL_GET_RUNSTATE:
1734 assert(cd->data.runstate == cd2->data.runstate);
1737 case CTDB_CONTROL_DB_DETACH:
1740 case CTDB_CONTROL_GET_NODES_FILE:
1741 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap);
1744 case CTDB_CONTROL_DB_PULL:
1745 assert(cd->data.num_records == cd2->data.num_records);
1748 case CTDB_CONTROL_DB_PUSH_CONFIRM:
1749 assert(cd->data.num_records == cd2->data.num_records);
1752 case CTDB_CONTROL_DB_OPEN_FLAGS:
1753 assert(cd->data.tdb_flags == cd2->data.tdb_flags);
1756 case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1757 assert(cd->data.db_id == cd2->data.db_id);
1763 static void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx,
1764 struct ctdb_reply_control *c,
1767 c->status = -rand_int(2);
1768 if (c->status == 0) {
1770 fill_ctdb_reply_control_data(mem_ctx, &c->rdata, opcode);
1772 fill_ctdb_string(mem_ctx, &c->errmsg);
1776 static void verify_ctdb_reply_control(struct ctdb_reply_control *c,
1777 struct ctdb_reply_control *c2)
1779 assert(c->status == c2->status);
1780 verify_ctdb_string(c->errmsg, c2->errmsg);
1781 if (c->status == 0) {
1782 verify_ctdb_reply_control_data(&c->rdata, &c2->rdata);
1786 static void fill_ctdb_req_message_data(TALLOC_CTX *mem_ctx,
1787 struct ctdb_req_message_data *c)
1789 c->srvid = rand64();
1790 fill_tdb_data(mem_ctx, &c->data);
1793 static void verify_ctdb_req_message_data(struct ctdb_req_message_data *c,
1794 struct ctdb_req_message_data *c2)
1796 assert(c->srvid == c2->srvid);
1797 verify_tdb_data(&c->data, &c2->data);
1801 * Functions to fill and verify eventd protocol structures
1804 static void fill_ctdb_event_request_data(TALLOC_CTX *mem_ctx,
1805 struct ctdb_event_request_data *r,
1808 r->command = command;
1811 case CTDB_EVENT_COMMAND_RUN:
1812 r->data.run = talloc(mem_ctx, struct ctdb_event_request_run);
1813 assert(r->data.run != NULL);
1815 fill_ctdb_event_request_run(mem_ctx, r->data.run);
1818 case CTDB_EVENT_COMMAND_STATUS:
1819 r->data.status = talloc(mem_ctx,
1820 struct ctdb_event_request_status);
1821 assert(r->data.status != NULL);
1823 fill_ctdb_event_request_status(mem_ctx, r->data.status);
1826 case CTDB_EVENT_COMMAND_SCRIPT_LIST:
1829 case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
1830 r->data.script_enable = talloc(mem_ctx,
1831 struct ctdb_event_request_script_enable);
1832 assert(r->data.script_enable != NULL);
1834 fill_ctdb_event_request_script_enable(mem_ctx,
1835 r->data.script_enable);
1838 case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
1839 r->data.script_disable = talloc(mem_ctx,
1840 struct ctdb_event_request_script_disable);
1841 assert(r->data.script_disable != NULL);
1843 fill_ctdb_event_request_script_disable(mem_ctx,
1844 r->data.script_disable);
1849 static void verify_ctdb_event_request_data(struct ctdb_event_request_data *r,
1850 struct ctdb_event_request_data *r2)
1852 assert(r->command == r2->command);
1854 switch (r->command) {
1855 case CTDB_EVENT_COMMAND_RUN:
1856 verify_ctdb_event_request_run(r->data.run, r2->data.run);
1859 case CTDB_EVENT_COMMAND_STATUS:
1860 verify_ctdb_event_request_status(r->data.status,
1864 case CTDB_EVENT_COMMAND_SCRIPT_LIST:
1867 case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
1868 verify_ctdb_event_request_script_enable(r->data.script_enable,
1869 r2->data.script_enable);
1872 case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
1873 verify_ctdb_event_request_script_disable(r->data.script_disable,
1874 r2->data.script_disable);
1879 static void fill_ctdb_event_reply_data(TALLOC_CTX *mem_ctx,
1880 struct ctdb_event_reply_data *r,
1883 r->command = command;
1884 r->result = rand32i();
1887 case CTDB_EVENT_COMMAND_STATUS:
1888 r->data.status = talloc(mem_ctx,
1889 struct ctdb_event_reply_status);
1890 assert(r->data.status != NULL);
1892 fill_ctdb_event_reply_status(mem_ctx, r->data.status);
1895 case CTDB_EVENT_COMMAND_SCRIPT_LIST:
1896 r->data.script_list = talloc(mem_ctx,
1897 struct ctdb_event_reply_script_list);
1898 assert(r->data.script_list != NULL);
1900 fill_ctdb_event_reply_script_list(mem_ctx,
1901 r->data.script_list);
1906 static void verify_ctdb_event_reply_data(struct ctdb_event_reply_data *r,
1907 struct ctdb_event_reply_data *r2)
1909 assert(r->command == r2->command);
1910 assert(r->result == r2->result);
1912 switch (r->command) {
1913 case CTDB_EVENT_COMMAND_RUN:
1916 case CTDB_EVENT_COMMAND_STATUS:
1917 verify_ctdb_event_reply_status(r->data.status,
1921 case CTDB_EVENT_COMMAND_SCRIPT_LIST:
1922 verify_ctdb_event_reply_script_list(r->data.script_list,
1923 r2->data.script_list);
1926 case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
1929 case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
1934 static void verify_ctdb_event_header(struct ctdb_event_header *h,
1935 struct ctdb_event_header *h2)
1937 verify_buffer(h, h2, ctdb_event_header_len(h));
1940 static void fill_ctdb_event_request(TALLOC_CTX *mem_ctx,
1941 struct ctdb_event_request *r,
1944 ctdb_event_header_fill(&r->header, rand());
1945 fill_ctdb_event_request_data(mem_ctx, &r->rdata, command);
1948 static void verify_ctdb_event_request(struct ctdb_event_request *r,
1949 struct ctdb_event_request *r2)
1951 verify_ctdb_event_header(&r->header, &r2->header);
1952 verify_ctdb_event_request_data(&r->rdata, &r2->rdata);
1955 static void fill_ctdb_event_reply(TALLOC_CTX *mem_ctx,
1956 struct ctdb_event_reply *r,
1959 ctdb_event_header_fill(&r->header, rand());
1960 fill_ctdb_event_reply_data(mem_ctx, &r->rdata, command);
1963 static void verify_ctdb_event_reply(struct ctdb_event_reply *r,
1964 struct ctdb_event_reply *r2)
1966 verify_ctdb_event_header(&r->header, &r2->header);
1967 verify_ctdb_event_reply_data(&r->rdata, &r2->rdata);
1971 * Functions to test marshalling
1974 static void test_ctdb_req_header(void)
1976 TALLOC_CTX *mem_ctx;
1979 struct ctdb_req_header h, h2;
1982 printf("ctdb_req_header\n");
1985 mem_ctx = talloc_new(NULL);
1986 assert(mem_ctx != NULL);
1988 ctdb_req_header_fill(&h, GENERATION, OPERATION, DESTNODE, SRCNODE,
1991 ret = ctdb_allocate_pkt(mem_ctx, ctdb_req_header_len(&h),
1994 assert(pkt != NULL);
1995 assert(pkt_len >= ctdb_req_header_len(&h));
1997 ctdb_req_header_push(&h, pkt);
1999 ret = ctdb_req_header_pull(pkt, pkt_len, &h2);
2002 verify_ctdb_req_header(&h, &h2);
2004 talloc_free(mem_ctx);
2007 static void test_ctdb_req_call(void)
2009 TALLOC_CTX *mem_ctx;
2011 size_t datalen, pkt_len, len;
2013 struct ctdb_req_header h, h2;
2014 struct ctdb_req_call c, c2;
2016 printf("ctdb_req_call\n");
2019 mem_ctx = talloc_new(NULL);
2020 assert(mem_ctx != NULL);
2022 ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CALL,
2023 DESTNODE, SRCNODE, REQID);
2025 fill_ctdb_req_call(mem_ctx, &c);
2026 datalen = ctdb_req_call_len(&h, &c);
2027 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2029 assert(pkt != NULL);
2030 assert(pkt_len >= datalen);
2032 ret = ctdb_req_call_push(&h, &c, pkt, &len);
2033 assert(ret == EMSGSIZE);
2034 assert(len == datalen);
2035 ret = ctdb_req_call_push(&h, &c, pkt, &pkt_len);
2037 ret = ctdb_req_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2039 verify_ctdb_req_header(&h, &h2);
2040 assert(h2.length == pkt_len);
2041 verify_ctdb_req_call(&c, &c2);
2043 talloc_free(mem_ctx);
2046 static void test_ctdb_reply_call(void)
2048 TALLOC_CTX *mem_ctx;
2050 size_t datalen, pkt_len, len;
2052 struct ctdb_req_header h, h2;
2053 struct ctdb_reply_call c, c2;
2055 printf("ctdb_reply_call\n");
2058 mem_ctx = talloc_new(NULL);
2059 assert(mem_ctx != NULL);
2061 ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CALL,
2062 DESTNODE, SRCNODE, REQID);
2064 fill_ctdb_reply_call(mem_ctx, &c);
2065 datalen = ctdb_reply_call_len(&h, &c);
2066 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2068 assert(pkt != NULL);
2069 assert(pkt_len >= datalen);
2071 ret = ctdb_reply_call_push(&h, &c, pkt, &len);
2072 assert(ret == EMSGSIZE);
2073 assert(len == datalen);
2074 ret = ctdb_reply_call_push(&h, &c, pkt, &pkt_len);
2076 ret = ctdb_reply_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2078 verify_ctdb_req_header(&h, &h2);
2079 assert(h2.length == pkt_len);
2080 verify_ctdb_reply_call(&c, &c2);
2082 talloc_free(mem_ctx);
2085 static void test_ctdb_reply_error(void)
2087 TALLOC_CTX *mem_ctx;
2089 size_t datalen, pkt_len, len;
2091 struct ctdb_req_header h, h2;
2092 struct ctdb_reply_error c, c2;
2094 printf("ctdb_reply_error\n");
2097 mem_ctx = talloc_new(NULL);
2098 assert(mem_ctx != NULL);
2100 ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_ERROR,
2101 DESTNODE, SRCNODE, REQID);
2103 fill_ctdb_reply_error(mem_ctx, &c);
2104 datalen = ctdb_reply_error_len(&h, &c);
2105 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2107 assert(pkt != NULL);
2108 assert(pkt_len >= datalen);
2110 ret = ctdb_reply_error_push(&h, &c, pkt, &len);
2111 assert(ret == EMSGSIZE);
2112 assert(len == datalen);
2113 ret = ctdb_reply_error_push(&h, &c, pkt, &pkt_len);
2115 ret = ctdb_reply_error_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2117 verify_ctdb_req_header(&h, &h2);
2118 assert(h2.length == pkt_len);
2119 verify_ctdb_reply_error(&c, &c2);
2121 talloc_free(mem_ctx);
2124 static void test_ctdb_req_dmaster(void)
2126 TALLOC_CTX *mem_ctx;
2128 size_t datalen, pkt_len, len;
2130 struct ctdb_req_header h, h2;
2131 struct ctdb_req_dmaster c, c2;
2133 printf("ctdb_req_dmaster\n");
2136 mem_ctx = talloc_new(NULL);
2137 assert(mem_ctx != NULL);
2139 ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_DMASTER,
2140 DESTNODE, SRCNODE, REQID);
2142 fill_ctdb_req_dmaster(mem_ctx, &c);
2143 datalen = ctdb_req_dmaster_len(&h, &c);
2144 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2146 assert(pkt != NULL);
2147 assert(pkt_len >= datalen);
2149 ret = ctdb_req_dmaster_push(&h, &c, pkt, &len);
2150 assert(ret == EMSGSIZE);
2151 assert(len == datalen);
2152 ret = ctdb_req_dmaster_push(&h, &c, pkt, &pkt_len);
2154 ret = ctdb_req_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2156 verify_ctdb_req_header(&h, &h2);
2157 assert(h2.length == pkt_len);
2158 verify_ctdb_req_dmaster(&c, &c2);
2160 talloc_free(mem_ctx);
2163 static void test_ctdb_reply_dmaster(void)
2165 TALLOC_CTX *mem_ctx;
2167 size_t datalen, pkt_len, len;
2169 struct ctdb_req_header h, h2;
2170 struct ctdb_reply_dmaster c, c2;
2172 printf("ctdb_reply_dmaster\n");
2175 mem_ctx = talloc_new(NULL);
2176 assert(mem_ctx != NULL);
2178 ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_DMASTER,
2179 DESTNODE, SRCNODE, REQID);
2181 fill_ctdb_reply_dmaster(mem_ctx, &c);
2182 datalen = ctdb_reply_dmaster_len(&h, &c);
2183 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2185 assert(pkt != NULL);
2186 assert(pkt_len >= datalen);
2188 ret = ctdb_reply_dmaster_push(&h, &c, pkt, &len);
2189 assert(ret == EMSGSIZE);
2190 assert(len == datalen);
2191 ret = ctdb_reply_dmaster_push(&h, &c, pkt, &pkt_len);
2193 ret = ctdb_reply_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2195 verify_ctdb_req_header(&h, &h2);
2196 assert(h2.length == pkt_len);
2197 verify_ctdb_reply_dmaster(&c, &c2);
2199 talloc_free(mem_ctx);
2202 #define NUM_CONTROLS 151
2204 static void test_ctdb_req_control_data(void)
2206 TALLOC_CTX *mem_ctx;
2209 struct ctdb_req_control_data cd, cd2;
2212 printf("ctdb_req_control_data\n");
2215 for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2216 mem_ctx = talloc_new(NULL);
2217 assert(mem_ctx != NULL);
2219 printf("%u.. ", opcode);
2221 fill_ctdb_req_control_data(mem_ctx, &cd, opcode);
2222 buflen = ctdb_req_control_data_len(&cd);
2223 ctdb_req_control_data_push(&cd, BUFFER);
2224 ret = ctdb_req_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
2226 verify_ctdb_req_control_data(&cd, &cd2);
2227 talloc_free(mem_ctx);
2234 static void test_ctdb_reply_control_data(void)
2236 TALLOC_CTX *mem_ctx;
2239 struct ctdb_reply_control_data cd, cd2;
2242 printf("ctdb_reply_control_data\n");
2245 for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2246 mem_ctx = talloc_new(NULL);
2247 assert(mem_ctx != NULL);
2249 printf("%u.. ", opcode);
2251 fill_ctdb_reply_control_data(mem_ctx, &cd, opcode);
2252 buflen = ctdb_reply_control_data_len(&cd);
2253 ctdb_reply_control_data_push(&cd, BUFFER);
2254 ret = ctdb_reply_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
2256 verify_ctdb_reply_control_data(&cd, &cd2);
2257 talloc_free(mem_ctx);
2264 static void test_ctdb_req_control(void)
2266 TALLOC_CTX *mem_ctx;
2268 size_t datalen, pkt_len, len;
2270 struct ctdb_req_header h, h2;
2271 struct ctdb_req_control c, c2;
2274 printf("ctdb_req_control\n");
2277 ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CONTROL,
2278 DESTNODE, SRCNODE, REQID);
2280 for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2281 mem_ctx = talloc_new(NULL);
2282 assert(mem_ctx != NULL);
2284 printf("%u.. ", opcode);
2286 fill_ctdb_req_control(mem_ctx, &c, opcode);
2287 datalen = ctdb_req_control_len(&h, &c);
2288 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2290 assert(pkt != NULL);
2291 assert(pkt_len >= datalen);
2293 ret = ctdb_req_control_push(&h, &c, pkt, &len);
2294 assert(ret == EMSGSIZE);
2295 assert(len == datalen);
2296 ret = ctdb_req_control_push(&h, &c, pkt, &pkt_len);
2298 ret = ctdb_req_control_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2300 verify_ctdb_req_header(&h, &h2);
2301 assert(h2.length == pkt_len);
2302 verify_ctdb_req_control(&c, &c2);
2304 talloc_free(mem_ctx);
2311 static void test_ctdb_reply_control(void)
2313 TALLOC_CTX *mem_ctx;
2315 size_t datalen, pkt_len, len;
2317 struct ctdb_req_header h, h2;
2318 struct ctdb_reply_control c, c2;
2321 printf("ctdb_reply_control\n");
2324 ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CONTROL,
2325 DESTNODE, SRCNODE, REQID);
2327 for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2328 mem_ctx = talloc_new(NULL);
2329 assert(mem_ctx != NULL);
2331 printf("%u.. ", opcode);
2333 fill_ctdb_reply_control(mem_ctx, &c, opcode);
2334 datalen = ctdb_reply_control_len(&h, &c);
2335 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2337 assert(pkt != NULL);
2338 assert(pkt_len >= datalen);
2340 ret = ctdb_reply_control_push(&h, &c, pkt, &len);
2341 assert(ret == EMSGSIZE);
2342 assert(len == datalen);
2343 ret = ctdb_reply_control_push(&h, &c, pkt, &pkt_len);
2345 ret = ctdb_reply_control_pull(pkt, pkt_len, opcode, &h2, mem_ctx, &c2);
2347 verify_ctdb_req_header(&h, &h2);
2348 assert(h2.length == pkt_len);
2349 verify_ctdb_reply_control(&c, &c2);
2351 talloc_free(mem_ctx);
2358 static void test_ctdb_req_message_data(void)
2360 TALLOC_CTX *mem_ctx;
2362 size_t datalen, pkt_len, len;
2364 struct ctdb_req_header h, h2;
2365 struct ctdb_req_message_data c, c2;
2367 printf("ctdb_req_message\n");
2370 mem_ctx = talloc_new(NULL);
2371 assert(mem_ctx != NULL);
2373 ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_MESSAGE,
2374 DESTNODE, SRCNODE, REQID);
2376 fill_ctdb_req_message_data(mem_ctx, &c);
2377 datalen = ctdb_req_message_data_len(&h, &c);
2378 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2380 assert(pkt != NULL);
2381 assert(pkt_len >= datalen);
2383 ret = ctdb_req_message_data_push(&h, &c, pkt, &len);
2384 assert(ret == EMSGSIZE);
2385 assert(len == datalen);
2386 ret = ctdb_req_message_data_push(&h, &c, pkt, &pkt_len);
2388 ret = ctdb_req_message_data_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2390 verify_ctdb_req_header(&h, &h2);
2391 assert(h2.length == pkt_len);
2392 verify_ctdb_req_message_data(&c, &c2);
2394 talloc_free(mem_ctx);
2398 * Functions to test eventd protocol marshalling
2401 static void test_ctdb_event_header(void)
2403 TALLOC_CTX *mem_ctx;
2405 struct ctdb_event_header h, h2;
2408 printf("ctdb_event_header\n");
2411 mem_ctx = talloc_new(NULL);
2412 assert(mem_ctx != NULL);
2414 ctdb_event_header_fill(&h, REQID);
2416 buflen = ctdb_event_header_len(&h);
2417 ctdb_event_header_push(&h, BUFFER);
2418 ret = ctdb_event_header_pull(BUFFER, buflen, mem_ctx, &h2);
2421 verify_ctdb_event_header(&h, &h2);
2423 talloc_free(mem_ctx);
2426 #define NUM_COMMANDS 5
2428 static void test_ctdb_event_request_data(void)
2430 TALLOC_CTX *mem_ctx;
2432 struct ctdb_event_request_data rd, rd2;
2436 printf("ctdb_event_request_data\n");
2439 for (command=1; command<=NUM_COMMANDS; command++) {
2440 mem_ctx = talloc_new(NULL);
2441 assert(mem_ctx != NULL);
2443 printf("%u.. ", command);
2445 fill_ctdb_event_request_data(mem_ctx, &rd, command);
2446 buflen = ctdb_event_request_data_len(&rd);
2447 ctdb_event_request_data_push(&rd, BUFFER);
2448 ret = ctdb_event_request_data_pull(BUFFER, buflen, mem_ctx, &rd2);
2450 verify_ctdb_event_request_data(&rd, &rd2);
2452 talloc_free(mem_ctx);
2459 static void test_ctdb_event_reply_data(void)
2461 TALLOC_CTX *mem_ctx;
2463 struct ctdb_event_reply_data rd, rd2;
2467 printf("ctdb_event_reply_data\n");
2470 for (command=1; command<=NUM_COMMANDS; command++) {
2471 mem_ctx = talloc_new(NULL);
2472 assert(mem_ctx != NULL);
2474 printf("%u.. ", command);
2476 fill_ctdb_event_reply_data(mem_ctx, &rd, command);
2477 buflen = ctdb_event_reply_data_len(&rd);
2478 ctdb_event_reply_data_push(&rd, BUFFER);
2479 ret = ctdb_event_reply_data_pull(BUFFER, buflen, mem_ctx, &rd2);
2481 verify_ctdb_event_reply_data(&rd, &rd2);
2483 talloc_free(mem_ctx);
2490 static void test_ctdb_event_request(void)
2492 TALLOC_CTX *mem_ctx;
2496 struct ctdb_event_request r, r2;
2499 printf("ctdb_event_request\n");
2502 for (command=1; command<=NUM_COMMANDS; command++) {
2503 mem_ctx = talloc_new(NULL);
2504 assert(mem_ctx != NULL);
2506 printf("%u.. ", command);
2508 fill_ctdb_event_request(mem_ctx, &r, command);
2509 buflen = ctdb_event_request_len(&r);
2510 buf = talloc_size(mem_ctx, buflen);
2511 assert(buf != NULL);
2513 ret = ctdb_event_request_push(&r, buf, &len);
2514 assert(ret == EMSGSIZE);
2515 assert(len == buflen);
2516 ret = ctdb_event_request_push(&r, buf, &buflen);
2518 ret = ctdb_event_request_pull(buf, buflen, mem_ctx, &r2);
2520 assert(r2.header.length == buflen);
2521 verify_ctdb_event_request(&r, &r2);
2523 talloc_free(mem_ctx);
2530 static void test_ctdb_event_reply(void)
2532 TALLOC_CTX *mem_ctx;
2536 struct ctdb_event_reply r, r2;
2539 printf("ctdb_event_reply\n");
2542 for (command=1; command<=NUM_COMMANDS; command++) {
2543 mem_ctx = talloc_new(NULL);
2544 assert(mem_ctx != NULL);
2546 printf("%u.. ", command);
2548 fill_ctdb_event_reply(mem_ctx, &r, command);
2549 buflen = ctdb_event_reply_len(&r);
2550 buf = talloc_size(mem_ctx, buflen);
2551 assert(buf != NULL);
2553 ret = ctdb_event_reply_push(&r, buf, &len);
2554 assert(ret == EMSGSIZE);
2555 assert(len == buflen);
2556 ret = ctdb_event_reply_push(&r, buf, &buflen);
2558 ret = ctdb_event_reply_pull(buf, buflen, mem_ctx, &r2);
2560 assert(r2.header.length == buflen);
2561 verify_ctdb_event_reply(&r, &r2);
2563 talloc_free(mem_ctx);
2570 int main(int argc, char *argv[])
2573 int seed = atoi(argv[1]);
2577 test_ctdb_req_header();
2579 test_ctdb_req_call();
2580 test_ctdb_reply_call();
2581 test_ctdb_reply_error();
2582 test_ctdb_req_dmaster();
2583 test_ctdb_reply_dmaster();
2585 test_ctdb_req_control_data();
2586 test_ctdb_reply_control_data();
2588 test_ctdb_req_control();
2589 test_ctdb_reply_control();
2591 test_ctdb_req_message_data();
2593 test_ctdb_event_header();
2595 test_ctdb_event_request_data();
2596 test_ctdb_event_reply_data();
2597 test_ctdb_event_request();
2598 test_ctdb_event_reply();