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:
508 cd->data.u64_array = talloc(mem_ctx, struct ctdb_uint64_array);
509 assert(cd->data.u64_array != NULL);
510 fill_ctdb_uint64_array(mem_ctx, cd->data.u64_array);
513 case CTDB_CONTROL_TRAVERSE_START_EXT:
514 cd->data.traverse_start_ext = talloc(mem_ctx, struct ctdb_traverse_start_ext);
515 assert(cd->data.traverse_start_ext != NULL);
516 fill_ctdb_traverse_start_ext(mem_ctx, cd->data.traverse_start_ext);
519 case CTDB_CONTROL_GET_DB_STATISTICS:
520 cd->data.db_id = rand32();
523 case CTDB_CONTROL_SET_DB_STICKY:
524 cd->data.db_id = rand32();
527 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
530 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
531 cd->data.traverse_all_ext = talloc(mem_ctx, struct ctdb_traverse_all_ext);
532 assert(cd->data.traverse_all_ext != NULL);
533 fill_ctdb_traverse_all_ext(mem_ctx, cd->data.traverse_all_ext);
536 case CTDB_CONTROL_RECEIVE_RECORDS:
537 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
538 assert(cd->data.recbuf != NULL);
539 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
542 case CTDB_CONTROL_IPREALLOCATED:
545 case CTDB_CONTROL_GET_RUNSTATE:
548 case CTDB_CONTROL_DB_DETACH:
549 cd->data.db_id = rand32();
552 case CTDB_CONTROL_GET_NODES_FILE:
555 case CTDB_CONTROL_DB_FREEZE:
556 cd->data.db_id = rand32();
559 case CTDB_CONTROL_DB_THAW:
560 cd->data.db_id = rand32();
563 case CTDB_CONTROL_DB_TRANSACTION_START:
564 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
565 assert(cd->data.transdb != NULL);
566 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
569 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
570 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
571 assert(cd->data.transdb != NULL);
572 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
575 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
576 cd->data.db_id = rand32();
579 case CTDB_CONTROL_DB_PULL:
580 cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
581 assert(cd->data.pulldb_ext != NULL);
582 fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
585 case CTDB_CONTROL_DB_PUSH_START:
586 cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
587 assert(cd->data.pulldb_ext != NULL);
588 fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
591 case CTDB_CONTROL_DB_PUSH_CONFIRM:
592 cd->data.db_id = rand32();
595 case CTDB_CONTROL_DB_OPEN_FLAGS:
596 cd->data.db_id = rand32();
602 static void verify_ctdb_req_control_data(struct ctdb_req_control_data *cd,
603 struct ctdb_req_control_data *cd2)
605 assert(cd->opcode == cd2->opcode);
607 switch (cd->opcode) {
608 case CTDB_CONTROL_PROCESS_EXISTS:
609 assert(cd->data.pid == cd2->data.pid);
612 case CTDB_CONTROL_STATISTICS:
615 case CTDB_CONTROL_PING:
618 case CTDB_CONTROL_GETDBPATH:
619 assert(cd->data.db_id == cd2->data.db_id);
622 case CTDB_CONTROL_GETVNNMAP:
625 case CTDB_CONTROL_SETVNNMAP:
626 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap);
629 case CTDB_CONTROL_GET_DEBUG:
632 case CTDB_CONTROL_SET_DEBUG:
633 assert(cd->data.loglevel == cd2->data.loglevel);
636 case CTDB_CONTROL_GET_DBMAP:
639 case CTDB_CONTROL_PULL_DB:
640 verify_ctdb_pulldb(cd->data.pulldb, cd2->data.pulldb);
643 case CTDB_CONTROL_PUSH_DB:
644 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
647 case CTDB_CONTROL_GET_RECMODE:
650 case CTDB_CONTROL_SET_RECMODE:
651 assert(cd->data.recmode == cd2->data.recmode);
654 case CTDB_CONTROL_STATISTICS_RESET:
657 case CTDB_CONTROL_DB_ATTACH:
658 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
661 case CTDB_CONTROL_SET_CALL:
664 case CTDB_CONTROL_TRAVERSE_START:
665 verify_ctdb_traverse_start(cd->data.traverse_start,
666 cd2->data.traverse_start);
669 case CTDB_CONTROL_TRAVERSE_ALL:
670 verify_ctdb_traverse_all(cd->data.traverse_all,
671 cd2->data.traverse_all);
674 case CTDB_CONTROL_TRAVERSE_DATA:
675 verify_ctdb_rec_data(cd->data.rec_data, cd2->data.rec_data);
678 case CTDB_CONTROL_REGISTER_SRVID:
681 case CTDB_CONTROL_DEREGISTER_SRVID:
684 case CTDB_CONTROL_GET_DBNAME:
685 assert(cd->data.db_id == cd2->data.db_id);
688 case CTDB_CONTROL_ENABLE_SEQNUM:
689 assert(cd->data.db_id == cd2->data.db_id);
692 case CTDB_CONTROL_UPDATE_SEQNUM:
693 assert(cd->data.db_id == cd2->data.db_id);
696 case CTDB_CONTROL_DUMP_MEMORY:
699 case CTDB_CONTROL_GET_PID:
702 case CTDB_CONTROL_GET_RECMASTER:
705 case CTDB_CONTROL_SET_RECMASTER:
706 assert(cd->data.recmaster == cd2->data.recmaster);
709 case CTDB_CONTROL_FREEZE:
712 case CTDB_CONTROL_GET_PNN:
715 case CTDB_CONTROL_SHUTDOWN:
718 case CTDB_CONTROL_GET_MONMODE:
721 case CTDB_CONTROL_TCP_CLIENT:
722 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
725 case CTDB_CONTROL_TCP_ADD:
726 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
729 case CTDB_CONTROL_TCP_REMOVE:
730 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
733 case CTDB_CONTROL_STARTUP:
736 case CTDB_CONTROL_SET_TUNABLE:
737 verify_ctdb_tunable(cd->data.tunable, cd2->data.tunable);
740 case CTDB_CONTROL_GET_TUNABLE:
741 verify_ctdb_string(cd->data.tun_var, cd2->data.tun_var);
744 case CTDB_CONTROL_LIST_TUNABLES:
747 case CTDB_CONTROL_MODIFY_FLAGS:
748 verify_ctdb_node_flag_change(cd->data.flag_change,
749 cd2->data.flag_change);
752 case CTDB_CONTROL_GET_ALL_TUNABLES:
755 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
756 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr);
759 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
760 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles);
763 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
764 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
767 case CTDB_CONTROL_UPDATE_RECORD:
768 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
771 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
772 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
775 case CTDB_CONTROL_WIPE_DATABASE:
776 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
779 case CTDB_CONTROL_UPTIME:
782 case CTDB_CONTROL_START_RECOVERY:
785 case CTDB_CONTROL_END_RECOVERY:
788 case CTDB_CONTROL_RELOAD_NODES_FILE:
791 case CTDB_CONTROL_TRY_DELETE_RECORDS:
792 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
795 case CTDB_CONTROL_ENABLE_MONITOR:
798 case CTDB_CONTROL_DISABLE_MONITOR:
801 case CTDB_CONTROL_ADD_PUBLIC_IP:
802 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
805 case CTDB_CONTROL_DEL_PUBLIC_IP:
806 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
809 case CTDB_CONTROL_GET_CAPABILITIES:
812 case CTDB_CONTROL_START_PERSISTENT_UPDATE:
815 case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
818 case CTDB_CONTROL_RECD_PING:
821 case CTDB_CONTROL_RELEASE_IP:
822 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip);
825 case CTDB_CONTROL_TAKEOVER_IP:
826 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip);
829 case CTDB_CONTROL_GET_PUBLIC_IPS:
832 case CTDB_CONTROL_GET_NODEMAP:
835 case CTDB_CONTROL_TRAVERSE_KILL:
836 verify_ctdb_traverse_start(cd->data.traverse_start,
837 cd2->data.traverse_start);
840 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
841 assert(cd->data.reclock_latency == cd2->data.reclock_latency);
844 case CTDB_CONTROL_GET_RECLOCK_FILE:
847 case CTDB_CONTROL_STOP_NODE:
850 case CTDB_CONTROL_CONTINUE_NODE:
853 case CTDB_CONTROL_SET_LMASTERROLE:
854 assert(cd->data.role == cd2->data.role);
857 case CTDB_CONTROL_SET_RECMASTERROLE:
858 assert(cd->data.role == cd2->data.role);
861 case CTDB_CONTROL_SET_BAN_STATE:
862 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state);
865 case CTDB_CONTROL_GET_BAN_STATE:
868 case CTDB_CONTROL_REGISTER_NOTIFY:
869 verify_ctdb_notify_data(cd->data.notify, cd2->data.notify);
872 case CTDB_CONTROL_DEREGISTER_NOTIFY:
873 assert(cd->data.srvid == cd2->data.srvid);
876 case CTDB_CONTROL_TRANS3_COMMIT:
877 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
880 case CTDB_CONTROL_GET_DB_SEQNUM:
881 assert(cd->data.db_id == cd2->data.db_id);
884 case CTDB_CONTROL_DB_SET_HEALTHY:
885 assert(cd->data.db_id == cd2->data.db_id);
888 case CTDB_CONTROL_DB_GET_HEALTH:
889 assert(cd->data.db_id == cd2->data.db_id);
892 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
893 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr);
896 case CTDB_CONTROL_GET_IFACES:
899 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
900 verify_ctdb_iface(cd->data.iface, cd2->data.iface);
903 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
904 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
907 case CTDB_CONTROL_GET_STAT_HISTORY:
910 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
911 verify_ctdb_key_data(cd->data.key, cd2->data.key);
914 case CTDB_CONTROL_SET_DB_READONLY:
915 assert(cd->data.db_id == cd2->data.db_id);
918 case CTDB_CONTROL_CHECK_SRVIDS:
919 verify_ctdb_uint64_array(cd->data.u64_array,
920 cd2->data.u64_array);
923 case CTDB_CONTROL_TRAVERSE_START_EXT:
924 verify_ctdb_traverse_start_ext(cd->data.traverse_start_ext,
925 cd2->data.traverse_start_ext);
928 case CTDB_CONTROL_GET_DB_STATISTICS:
929 assert(cd->data.db_id == cd2->data.db_id);
932 case CTDB_CONTROL_SET_DB_STICKY:
933 assert(cd->data.db_id == cd2->data.db_id);
936 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
939 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
940 verify_ctdb_traverse_all_ext(cd->data.traverse_all_ext,
941 cd2->data.traverse_all_ext);
944 case CTDB_CONTROL_RECEIVE_RECORDS:
945 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
948 case CTDB_CONTROL_IPREALLOCATED:
951 case CTDB_CONTROL_GET_RUNSTATE:
954 case CTDB_CONTROL_DB_DETACH:
955 assert(cd->data.db_id == cd2->data.db_id);
958 case CTDB_CONTROL_GET_NODES_FILE:
961 case CTDB_CONTROL_DB_FREEZE:
962 assert(cd->data.db_id == cd2->data.db_id);
965 case CTDB_CONTROL_DB_THAW:
966 assert(cd->data.db_id == cd2->data.db_id);
969 case CTDB_CONTROL_DB_TRANSACTION_START:
970 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
973 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
974 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
977 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
978 assert(cd->data.db_id == cd2->data.db_id);
981 case CTDB_CONTROL_DB_PULL:
982 verify_ctdb_pulldb_ext(cd->data.pulldb_ext,
983 cd2->data.pulldb_ext);
986 case CTDB_CONTROL_DB_PUSH_START:
987 verify_ctdb_pulldb_ext(cd->data.pulldb_ext,
988 cd2->data.pulldb_ext);
991 case CTDB_CONTROL_DB_PUSH_CONFIRM:
992 assert(cd->data.db_id == cd2->data.db_id);
995 case CTDB_CONTROL_DB_OPEN_FLAGS:
996 assert(cd->data.db_id == cd2->data.db_id);
1002 static void fill_ctdb_req_control(TALLOC_CTX *mem_ctx,
1003 struct ctdb_req_control *c,
1008 c->srvid = rand64();
1009 c->client_id = rand32();
1010 c->flags = rand32();
1012 fill_ctdb_req_control_data(mem_ctx, &c->rdata, opcode);
1015 static void verify_ctdb_req_control(struct ctdb_req_control *c,
1016 struct ctdb_req_control *c2)
1018 assert(c->opcode == c2->opcode);
1019 assert(c->pad == c2->pad);
1020 assert(c->srvid == c2->srvid);
1021 assert(c->client_id == c2->client_id);
1022 assert(c->flags == c2->flags);
1024 verify_ctdb_req_control_data(&c->rdata, &c2->rdata);
1027 static void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx,
1028 struct ctdb_reply_control_data *cd,
1031 cd->opcode = opcode;
1034 case CTDB_CONTROL_PROCESS_EXISTS:
1037 case CTDB_CONTROL_STATISTICS:
1038 cd->data.stats = talloc(mem_ctx, struct ctdb_statistics);
1039 assert(cd->data.stats != NULL);
1040 fill_ctdb_statistics(mem_ctx, cd->data.stats);
1043 case CTDB_CONTROL_PING:
1046 case CTDB_CONTROL_GETDBPATH:
1047 fill_ctdb_string(mem_ctx, &cd->data.db_path);
1048 assert(cd->data.db_path != NULL);
1051 case CTDB_CONTROL_GETVNNMAP:
1052 cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
1053 assert(cd->data.vnnmap != NULL);
1054 fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
1057 case CTDB_CONTROL_SETVNNMAP:
1060 case CTDB_CONTROL_GET_DEBUG:
1061 cd->data.loglevel = rand_int(5);
1064 case CTDB_CONTROL_SET_DEBUG:
1067 case CTDB_CONTROL_GET_DBMAP:
1068 cd->data.dbmap = talloc(mem_ctx, struct ctdb_dbid_map);
1069 assert(cd->data.dbmap != NULL);
1070 fill_ctdb_dbid_map(mem_ctx, cd->data.dbmap);
1073 case CTDB_CONTROL_PULL_DB:
1074 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1075 assert(cd->data.recbuf != NULL);
1076 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1079 case CTDB_CONTROL_PUSH_DB:
1082 case CTDB_CONTROL_GET_RECMODE:
1085 case CTDB_CONTROL_SET_RECMODE:
1088 case CTDB_CONTROL_STATISTICS_RESET:
1091 case CTDB_CONTROL_DB_ATTACH:
1092 cd->data.db_id = rand32();
1095 case CTDB_CONTROL_SET_CALL:
1098 case CTDB_CONTROL_TRAVERSE_START:
1101 case CTDB_CONTROL_TRAVERSE_ALL:
1104 case CTDB_CONTROL_TRAVERSE_DATA:
1107 case CTDB_CONTROL_REGISTER_SRVID:
1110 case CTDB_CONTROL_DEREGISTER_SRVID:
1113 case CTDB_CONTROL_GET_DBNAME:
1114 fill_ctdb_string(mem_ctx, &cd->data.db_name);
1115 assert(cd->data.db_name);
1118 case CTDB_CONTROL_ENABLE_SEQNUM:
1121 case CTDB_CONTROL_UPDATE_SEQNUM:
1124 case CTDB_CONTROL_DUMP_MEMORY:
1125 fill_ctdb_string(mem_ctx, &cd->data.mem_str);
1126 assert(cd->data.mem_str);
1129 case CTDB_CONTROL_GET_PID:
1132 case CTDB_CONTROL_GET_RECMASTER:
1135 case CTDB_CONTROL_SET_RECMASTER:
1138 case CTDB_CONTROL_FREEZE:
1141 case CTDB_CONTROL_GET_PNN:
1144 case CTDB_CONTROL_SHUTDOWN:
1147 case CTDB_CONTROL_GET_MONMODE:
1150 case CTDB_CONTROL_TCP_CLIENT:
1153 case CTDB_CONTROL_TCP_ADD:
1156 case CTDB_CONTROL_TCP_REMOVE:
1159 case CTDB_CONTROL_STARTUP:
1162 case CTDB_CONTROL_SET_TUNABLE:
1165 case CTDB_CONTROL_GET_TUNABLE:
1166 cd->data.tun_value = rand32();
1169 case CTDB_CONTROL_LIST_TUNABLES:
1170 cd->data.tun_var_list = talloc(mem_ctx, struct ctdb_var_list);
1171 assert(cd->data.tun_var_list != NULL);
1172 fill_ctdb_var_list(mem_ctx, cd->data.tun_var_list);
1175 case CTDB_CONTROL_MODIFY_FLAGS:
1178 case CTDB_CONTROL_GET_ALL_TUNABLES:
1179 cd->data.tun_list = talloc(mem_ctx, struct ctdb_tunable_list);
1180 assert(cd->data.tun_list != NULL);
1181 fill_ctdb_tunable_list(mem_ctx, cd->data.tun_list);
1184 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1185 cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
1186 assert(cd->data.tickles != NULL);
1187 fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
1190 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1193 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1196 case CTDB_CONTROL_UPDATE_RECORD:
1199 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1202 case CTDB_CONTROL_WIPE_DATABASE:
1205 case CTDB_CONTROL_UPTIME:
1206 cd->data.uptime = talloc(mem_ctx, struct ctdb_uptime);
1207 assert(cd->data.uptime != NULL);
1208 fill_ctdb_uptime(mem_ctx, cd->data.uptime);
1211 case CTDB_CONTROL_START_RECOVERY:
1214 case CTDB_CONTROL_END_RECOVERY:
1217 case CTDB_CONTROL_RELOAD_NODES_FILE:
1220 case CTDB_CONTROL_TRY_DELETE_RECORDS:
1221 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1222 assert(cd->data.recbuf != NULL);
1223 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1226 case CTDB_CONTROL_ENABLE_MONITOR:
1229 case CTDB_CONTROL_DISABLE_MONITOR:
1232 case CTDB_CONTROL_ADD_PUBLIC_IP:
1235 case CTDB_CONTROL_DEL_PUBLIC_IP:
1238 case CTDB_CONTROL_GET_CAPABILITIES:
1239 cd->data.caps = rand32();
1242 case CTDB_CONTROL_START_PERSISTENT_UPDATE:
1245 case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
1248 case CTDB_CONTROL_RECD_PING:
1251 case CTDB_CONTROL_RELEASE_IP:
1254 case CTDB_CONTROL_TAKEOVER_IP:
1257 case CTDB_CONTROL_GET_PUBLIC_IPS:
1258 cd->data.pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list);
1259 assert(cd->data.pubip_list != NULL);
1260 fill_ctdb_public_ip_list(mem_ctx, cd->data.pubip_list);
1263 case CTDB_CONTROL_GET_NODEMAP:
1264 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
1265 assert(cd->data.nodemap != NULL);
1266 fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
1269 case CTDB_CONTROL_TRAVERSE_KILL:
1272 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1275 case CTDB_CONTROL_GET_RECLOCK_FILE:
1276 fill_ctdb_string(mem_ctx, &cd->data.reclock_file);
1277 assert(cd->data.reclock_file != NULL);
1280 case CTDB_CONTROL_STOP_NODE:
1283 case CTDB_CONTROL_CONTINUE_NODE:
1286 case CTDB_CONTROL_SET_LMASTERROLE:
1289 case CTDB_CONTROL_SET_RECMASTERROLE:
1292 case CTDB_CONTROL_SET_BAN_STATE:
1295 case CTDB_CONTROL_GET_BAN_STATE:
1296 cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
1297 assert(cd->data.ban_state != NULL);
1298 fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
1301 case CTDB_CONTROL_REGISTER_NOTIFY:
1304 case CTDB_CONTROL_DEREGISTER_NOTIFY:
1307 case CTDB_CONTROL_TRANS3_COMMIT:
1310 case CTDB_CONTROL_GET_DB_SEQNUM:
1311 cd->data.seqnum = rand64();
1314 case CTDB_CONTROL_DB_SET_HEALTHY:
1317 case CTDB_CONTROL_DB_GET_HEALTH:
1318 fill_ctdb_string(mem_ctx, &cd->data.reason);
1319 assert(cd->data.reason != NULL);
1322 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1323 cd->data.ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info);
1324 assert(cd->data.ipinfo != NULL);
1325 fill_ctdb_public_ip_info(mem_ctx, cd->data.ipinfo);
1328 case CTDB_CONTROL_GET_IFACES:
1329 cd->data.iface_list = talloc(mem_ctx, struct ctdb_iface_list);
1330 assert(cd->data.iface_list != NULL);
1331 fill_ctdb_iface_list(mem_ctx, cd->data.iface_list);
1334 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1337 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1340 case CTDB_CONTROL_GET_STAT_HISTORY:
1341 cd->data.stats_list = talloc(mem_ctx, struct ctdb_statistics_list);
1342 assert(cd->data.stats_list != NULL);
1343 fill_ctdb_statistics_list(mem_ctx, cd->data.stats_list);
1346 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1349 case CTDB_CONTROL_SET_DB_READONLY:
1352 case CTDB_CONTROL_CHECK_SRVIDS:
1353 cd->data.u8_array = talloc(mem_ctx, struct ctdb_uint8_array);
1354 assert(cd->data.u8_array != NULL);
1355 fill_ctdb_uint8_array(mem_ctx, cd->data.u8_array);
1358 case CTDB_CONTROL_TRAVERSE_START_EXT:
1361 case CTDB_CONTROL_GET_DB_STATISTICS:
1362 cd->data.dbstats = talloc(mem_ctx, struct ctdb_db_statistics);
1363 assert(cd->data.dbstats != NULL);
1364 fill_ctdb_db_statistics(mem_ctx, cd->data.dbstats);
1367 case CTDB_CONTROL_SET_DB_STICKY:
1370 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1373 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1376 case CTDB_CONTROL_RECEIVE_RECORDS:
1377 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1378 assert(cd->data.recbuf != NULL);
1379 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1382 case CTDB_CONTROL_IPREALLOCATED:
1385 case CTDB_CONTROL_GET_RUNSTATE:
1386 cd->data.runstate = rand32();
1389 case CTDB_CONTROL_DB_DETACH:
1392 case CTDB_CONTROL_GET_NODES_FILE:
1393 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
1394 assert(cd->data.nodemap != NULL);
1395 fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
1398 case CTDB_CONTROL_DB_PULL:
1399 cd->data.num_records = rand32();
1402 case CTDB_CONTROL_DB_PUSH_CONFIRM:
1403 cd->data.num_records = rand32();
1406 case CTDB_CONTROL_DB_OPEN_FLAGS:
1407 cd->data.tdb_flags = rand32();
1413 static void verify_ctdb_reply_control_data(struct ctdb_reply_control_data *cd,
1414 struct ctdb_reply_control_data *cd2)
1416 assert(cd->opcode == cd2->opcode);
1418 switch (cd->opcode) {
1419 case CTDB_CONTROL_PROCESS_EXISTS:
1422 case CTDB_CONTROL_STATISTICS:
1423 verify_ctdb_statistics(cd->data.stats, cd2->data.stats);
1426 case CTDB_CONTROL_PING:
1429 case CTDB_CONTROL_GETDBPATH:
1430 verify_ctdb_string(cd->data.db_path, cd2->data.db_path);
1433 case CTDB_CONTROL_GETVNNMAP:
1434 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap);
1437 case CTDB_CONTROL_SETVNNMAP:
1440 case CTDB_CONTROL_GET_DEBUG:
1441 assert(cd->data.loglevel == cd2->data.loglevel);
1444 case CTDB_CONTROL_SET_DEBUG:
1447 case CTDB_CONTROL_GET_DBMAP:
1448 verify_ctdb_dbid_map(cd->data.dbmap, cd2->data.dbmap);
1451 case CTDB_CONTROL_PULL_DB:
1452 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1455 case CTDB_CONTROL_PUSH_DB:
1458 case CTDB_CONTROL_GET_RECMODE:
1461 case CTDB_CONTROL_SET_RECMODE:
1464 case CTDB_CONTROL_STATISTICS_RESET:
1467 case CTDB_CONTROL_DB_ATTACH:
1468 assert(cd->data.db_id == cd2->data.db_id);
1471 case CTDB_CONTROL_SET_CALL:
1474 case CTDB_CONTROL_TRAVERSE_START:
1477 case CTDB_CONTROL_TRAVERSE_ALL:
1480 case CTDB_CONTROL_TRAVERSE_DATA:
1483 case CTDB_CONTROL_REGISTER_SRVID:
1486 case CTDB_CONTROL_DEREGISTER_SRVID:
1489 case CTDB_CONTROL_GET_DBNAME:
1490 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
1493 case CTDB_CONTROL_ENABLE_SEQNUM:
1496 case CTDB_CONTROL_UPDATE_SEQNUM:
1499 case CTDB_CONTROL_DUMP_MEMORY:
1500 verify_ctdb_string(cd->data.mem_str, cd2->data.mem_str);
1503 case CTDB_CONTROL_GET_PID:
1506 case CTDB_CONTROL_GET_RECMASTER:
1509 case CTDB_CONTROL_SET_RECMASTER:
1512 case CTDB_CONTROL_FREEZE:
1515 case CTDB_CONTROL_GET_PNN:
1518 case CTDB_CONTROL_SHUTDOWN:
1521 case CTDB_CONTROL_GET_MONMODE:
1524 case CTDB_CONTROL_TCP_CLIENT:
1527 case CTDB_CONTROL_TCP_ADD:
1530 case CTDB_CONTROL_TCP_REMOVE:
1533 case CTDB_CONTROL_STARTUP:
1536 case CTDB_CONTROL_SET_TUNABLE:
1539 case CTDB_CONTROL_GET_TUNABLE:
1540 assert(cd->data.tun_value == cd2->data.tun_value);
1543 case CTDB_CONTROL_LIST_TUNABLES:
1544 verify_ctdb_var_list(cd->data.tun_var_list,
1545 cd2->data.tun_var_list);
1548 case CTDB_CONTROL_MODIFY_FLAGS:
1551 case CTDB_CONTROL_GET_ALL_TUNABLES:
1552 verify_ctdb_tunable_list(cd->data.tun_list, cd2->data.tun_list);
1555 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1556 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles);
1559 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1562 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1565 case CTDB_CONTROL_UPDATE_RECORD:
1568 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1571 case CTDB_CONTROL_WIPE_DATABASE:
1574 case CTDB_CONTROL_UPTIME:
1575 verify_ctdb_uptime(cd->data.uptime, cd2->data.uptime);
1578 case CTDB_CONTROL_START_RECOVERY:
1581 case CTDB_CONTROL_END_RECOVERY:
1584 case CTDB_CONTROL_RELOAD_NODES_FILE:
1587 case CTDB_CONTROL_TRY_DELETE_RECORDS:
1588 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1591 case CTDB_CONTROL_ENABLE_MONITOR:
1594 case CTDB_CONTROL_DISABLE_MONITOR:
1597 case CTDB_CONTROL_ADD_PUBLIC_IP:
1600 case CTDB_CONTROL_DEL_PUBLIC_IP:
1603 case CTDB_CONTROL_GET_CAPABILITIES:
1604 assert(cd->data.caps == cd2->data.caps);
1607 case CTDB_CONTROL_RECD_PING:
1610 case CTDB_CONTROL_RELEASE_IP:
1613 case CTDB_CONTROL_TAKEOVER_IP:
1616 case CTDB_CONTROL_GET_PUBLIC_IPS:
1617 verify_ctdb_public_ip_list(cd->data.pubip_list,
1618 cd2->data.pubip_list);
1621 case CTDB_CONTROL_GET_NODEMAP:
1622 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap);
1625 case CTDB_CONTROL_TRAVERSE_KILL:
1628 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1631 case CTDB_CONTROL_GET_RECLOCK_FILE:
1632 verify_ctdb_string(cd->data.reclock_file,
1633 cd2->data.reclock_file);
1636 case CTDB_CONTROL_STOP_NODE:
1639 case CTDB_CONTROL_CONTINUE_NODE:
1642 case CTDB_CONTROL_SET_LMASTERROLE:
1645 case CTDB_CONTROL_SET_RECMASTERROLE:
1648 case CTDB_CONTROL_SET_BAN_STATE:
1651 case CTDB_CONTROL_GET_BAN_STATE:
1652 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state);
1655 case CTDB_CONTROL_REGISTER_NOTIFY:
1658 case CTDB_CONTROL_DEREGISTER_NOTIFY:
1661 case CTDB_CONTROL_TRANS3_COMMIT:
1664 case CTDB_CONTROL_GET_DB_SEQNUM:
1665 assert(cd->data.seqnum == cd2->data.seqnum);
1668 case CTDB_CONTROL_DB_SET_HEALTHY:
1671 case CTDB_CONTROL_DB_GET_HEALTH:
1672 verify_ctdb_string(cd->data.reason, cd2->data.reason);
1675 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1676 verify_ctdb_public_ip_info(cd->data.ipinfo, cd2->data.ipinfo);
1679 case CTDB_CONTROL_GET_IFACES:
1680 verify_ctdb_iface_list(cd->data.iface_list,
1681 cd2->data.iface_list);
1684 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1687 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1690 case CTDB_CONTROL_GET_STAT_HISTORY:
1691 verify_ctdb_statistics_list(cd->data.stats_list,
1692 cd2->data.stats_list);
1695 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1698 case CTDB_CONTROL_SET_DB_READONLY:
1701 case CTDB_CONTROL_CHECK_SRVIDS:
1702 verify_ctdb_uint8_array(cd->data.u8_array, cd2->data.u8_array);
1705 case CTDB_CONTROL_TRAVERSE_START_EXT:
1708 case CTDB_CONTROL_GET_DB_STATISTICS:
1709 verify_ctdb_db_statistics(cd->data.dbstats, cd2->data.dbstats);
1712 case CTDB_CONTROL_SET_DB_STICKY:
1715 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1718 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1721 case CTDB_CONTROL_RECEIVE_RECORDS:
1722 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1725 case CTDB_CONTROL_IPREALLOCATED:
1728 case CTDB_CONTROL_GET_RUNSTATE:
1729 assert(cd->data.runstate == cd2->data.runstate);
1732 case CTDB_CONTROL_DB_DETACH:
1735 case CTDB_CONTROL_GET_NODES_FILE:
1736 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap);
1739 case CTDB_CONTROL_DB_PULL:
1740 assert(cd->data.num_records == cd2->data.num_records);
1743 case CTDB_CONTROL_DB_PUSH_CONFIRM:
1744 assert(cd->data.num_records == cd2->data.num_records);
1747 case CTDB_CONTROL_DB_OPEN_FLAGS:
1748 assert(cd->data.tdb_flags == cd2->data.tdb_flags);
1754 static void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx,
1755 struct ctdb_reply_control *c,
1758 c->status = -rand_int(2);
1759 if (c->status == 0) {
1761 fill_ctdb_reply_control_data(mem_ctx, &c->rdata, opcode);
1763 fill_ctdb_string(mem_ctx, &c->errmsg);
1767 static void verify_ctdb_reply_control(struct ctdb_reply_control *c,
1768 struct ctdb_reply_control *c2)
1770 assert(c->status == c2->status);
1771 verify_ctdb_string(c->errmsg, c2->errmsg);
1772 if (c->status == 0) {
1773 verify_ctdb_reply_control_data(&c->rdata, &c2->rdata);
1777 static void fill_ctdb_req_message_data(TALLOC_CTX *mem_ctx,
1778 struct ctdb_req_message_data *c)
1780 c->srvid = rand64();
1781 fill_tdb_data(mem_ctx, &c->data);
1784 static void verify_ctdb_req_message_data(struct ctdb_req_message_data *c,
1785 struct ctdb_req_message_data *c2)
1787 assert(c->srvid == c2->srvid);
1788 verify_tdb_data(&c->data, &c2->data);
1792 * Functions to fill and verify eventd protocol structures
1795 static void fill_ctdb_event_request_data(TALLOC_CTX *mem_ctx,
1796 struct ctdb_event_request_data *r,
1799 r->command = command;
1802 case CTDB_EVENT_COMMAND_RUN:
1803 r->data.run = talloc(mem_ctx, struct ctdb_event_request_run);
1804 assert(r->data.run != NULL);
1806 fill_ctdb_event_request_run(mem_ctx, r->data.run);
1809 case CTDB_EVENT_COMMAND_STATUS:
1810 r->data.status = talloc(mem_ctx,
1811 struct ctdb_event_request_status);
1812 assert(r->data.status != NULL);
1814 fill_ctdb_event_request_status(mem_ctx, r->data.status);
1817 case CTDB_EVENT_COMMAND_SCRIPT_LIST:
1820 case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
1821 r->data.script_enable = talloc(mem_ctx,
1822 struct ctdb_event_request_script_enable);
1823 assert(r->data.script_enable != NULL);
1825 fill_ctdb_event_request_script_enable(mem_ctx,
1826 r->data.script_enable);
1829 case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
1830 r->data.script_disable = talloc(mem_ctx,
1831 struct ctdb_event_request_script_disable);
1832 assert(r->data.script_disable != NULL);
1834 fill_ctdb_event_request_script_disable(mem_ctx,
1835 r->data.script_disable);
1840 static void verify_ctdb_event_request_data(struct ctdb_event_request_data *r,
1841 struct ctdb_event_request_data *r2)
1843 assert(r->command == r2->command);
1845 switch (r->command) {
1846 case CTDB_EVENT_COMMAND_RUN:
1847 verify_ctdb_event_request_run(r->data.run, r2->data.run);
1850 case CTDB_EVENT_COMMAND_STATUS:
1851 verify_ctdb_event_request_status(r->data.status,
1855 case CTDB_EVENT_COMMAND_SCRIPT_LIST:
1858 case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
1859 verify_ctdb_event_request_script_enable(r->data.script_enable,
1860 r2->data.script_enable);
1863 case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
1864 verify_ctdb_event_request_script_disable(r->data.script_disable,
1865 r2->data.script_disable);
1870 static void fill_ctdb_event_reply_data(TALLOC_CTX *mem_ctx,
1871 struct ctdb_event_reply_data *r,
1874 r->command = command;
1875 r->result = rand32i();
1878 case CTDB_EVENT_COMMAND_STATUS:
1879 r->data.status = talloc(mem_ctx,
1880 struct ctdb_event_reply_status);
1881 assert(r->data.status != NULL);
1883 fill_ctdb_event_reply_status(mem_ctx, r->data.status);
1886 case CTDB_EVENT_COMMAND_SCRIPT_LIST:
1887 r->data.script_list = talloc(mem_ctx,
1888 struct ctdb_event_reply_script_list);
1889 assert(r->data.script_list != NULL);
1891 fill_ctdb_event_reply_script_list(mem_ctx,
1892 r->data.script_list);
1897 static void verify_ctdb_event_reply_data(struct ctdb_event_reply_data *r,
1898 struct ctdb_event_reply_data *r2)
1900 assert(r->command == r2->command);
1901 assert(r->result == r2->result);
1903 switch (r->command) {
1904 case CTDB_EVENT_COMMAND_RUN:
1907 case CTDB_EVENT_COMMAND_STATUS:
1908 verify_ctdb_event_reply_status(r->data.status,
1912 case CTDB_EVENT_COMMAND_SCRIPT_LIST:
1913 verify_ctdb_event_reply_script_list(r->data.script_list,
1914 r2->data.script_list);
1917 case CTDB_EVENT_COMMAND_SCRIPT_ENABLE:
1920 case CTDB_EVENT_COMMAND_SCRIPT_DISABLE:
1925 static void verify_ctdb_event_header(struct ctdb_event_header *h,
1926 struct ctdb_event_header *h2)
1928 verify_buffer(h, h2, ctdb_event_header_len(h));
1931 static void fill_ctdb_event_request(TALLOC_CTX *mem_ctx,
1932 struct ctdb_event_request *r,
1935 ctdb_event_header_fill(&r->header, rand());
1936 fill_ctdb_event_request_data(mem_ctx, &r->rdata, command);
1939 static void verify_ctdb_event_request(struct ctdb_event_request *r,
1940 struct ctdb_event_request *r2)
1942 verify_ctdb_event_header(&r->header, &r2->header);
1943 verify_ctdb_event_request_data(&r->rdata, &r2->rdata);
1946 static void fill_ctdb_event_reply(TALLOC_CTX *mem_ctx,
1947 struct ctdb_event_reply *r,
1950 ctdb_event_header_fill(&r->header, rand());
1951 fill_ctdb_event_reply_data(mem_ctx, &r->rdata, command);
1954 static void verify_ctdb_event_reply(struct ctdb_event_reply *r,
1955 struct ctdb_event_reply *r2)
1957 verify_ctdb_event_header(&r->header, &r2->header);
1958 verify_ctdb_event_reply_data(&r->rdata, &r2->rdata);
1962 * Functions to test marshalling
1965 static void test_ctdb_req_header(void)
1967 TALLOC_CTX *mem_ctx;
1970 struct ctdb_req_header h, h2;
1973 printf("ctdb_req_header\n");
1976 mem_ctx = talloc_new(NULL);
1977 assert(mem_ctx != NULL);
1979 ctdb_req_header_fill(&h, GENERATION, OPERATION, DESTNODE, SRCNODE,
1982 ret = ctdb_allocate_pkt(mem_ctx, ctdb_req_header_len(&h),
1985 assert(pkt != NULL);
1986 assert(pkt_len >= ctdb_req_header_len(&h));
1988 ctdb_req_header_push(&h, pkt);
1990 ret = ctdb_req_header_pull(pkt, pkt_len, &h2);
1993 verify_ctdb_req_header(&h, &h2);
1995 talloc_free(mem_ctx);
1998 static void test_ctdb_req_call(void)
2000 TALLOC_CTX *mem_ctx;
2002 size_t datalen, pkt_len, len;
2004 struct ctdb_req_header h, h2;
2005 struct ctdb_req_call c, c2;
2007 printf("ctdb_req_call\n");
2010 mem_ctx = talloc_new(NULL);
2011 assert(mem_ctx != NULL);
2013 ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CALL,
2014 DESTNODE, SRCNODE, REQID);
2016 fill_ctdb_req_call(mem_ctx, &c);
2017 datalen = ctdb_req_call_len(&h, &c);
2018 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2020 assert(pkt != NULL);
2021 assert(pkt_len >= datalen);
2023 ret = ctdb_req_call_push(&h, &c, pkt, &len);
2024 assert(ret == EMSGSIZE);
2025 assert(len == datalen);
2026 ret = ctdb_req_call_push(&h, &c, pkt, &pkt_len);
2028 ret = ctdb_req_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2030 verify_ctdb_req_header(&h, &h2);
2031 assert(h2.length == pkt_len);
2032 verify_ctdb_req_call(&c, &c2);
2034 talloc_free(mem_ctx);
2037 static void test_ctdb_reply_call(void)
2039 TALLOC_CTX *mem_ctx;
2041 size_t datalen, pkt_len, len;
2043 struct ctdb_req_header h, h2;
2044 struct ctdb_reply_call c, c2;
2046 printf("ctdb_reply_call\n");
2049 mem_ctx = talloc_new(NULL);
2050 assert(mem_ctx != NULL);
2052 ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CALL,
2053 DESTNODE, SRCNODE, REQID);
2055 fill_ctdb_reply_call(mem_ctx, &c);
2056 datalen = ctdb_reply_call_len(&h, &c);
2057 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2059 assert(pkt != NULL);
2060 assert(pkt_len >= datalen);
2062 ret = ctdb_reply_call_push(&h, &c, pkt, &len);
2063 assert(ret == EMSGSIZE);
2064 assert(len == datalen);
2065 ret = ctdb_reply_call_push(&h, &c, pkt, &pkt_len);
2067 ret = ctdb_reply_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2069 verify_ctdb_req_header(&h, &h2);
2070 assert(h2.length == pkt_len);
2071 verify_ctdb_reply_call(&c, &c2);
2073 talloc_free(mem_ctx);
2076 static void test_ctdb_reply_error(void)
2078 TALLOC_CTX *mem_ctx;
2080 size_t datalen, pkt_len, len;
2082 struct ctdb_req_header h, h2;
2083 struct ctdb_reply_error c, c2;
2085 printf("ctdb_reply_error\n");
2088 mem_ctx = talloc_new(NULL);
2089 assert(mem_ctx != NULL);
2091 ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_ERROR,
2092 DESTNODE, SRCNODE, REQID);
2094 fill_ctdb_reply_error(mem_ctx, &c);
2095 datalen = ctdb_reply_error_len(&h, &c);
2096 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2098 assert(pkt != NULL);
2099 assert(pkt_len >= datalen);
2101 ret = ctdb_reply_error_push(&h, &c, pkt, &len);
2102 assert(ret == EMSGSIZE);
2103 assert(len == datalen);
2104 ret = ctdb_reply_error_push(&h, &c, pkt, &pkt_len);
2106 ret = ctdb_reply_error_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2108 verify_ctdb_req_header(&h, &h2);
2109 assert(h2.length == pkt_len);
2110 verify_ctdb_reply_error(&c, &c2);
2112 talloc_free(mem_ctx);
2115 static void test_ctdb_req_dmaster(void)
2117 TALLOC_CTX *mem_ctx;
2119 size_t datalen, pkt_len, len;
2121 struct ctdb_req_header h, h2;
2122 struct ctdb_req_dmaster c, c2;
2124 printf("ctdb_req_dmaster\n");
2127 mem_ctx = talloc_new(NULL);
2128 assert(mem_ctx != NULL);
2130 ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_DMASTER,
2131 DESTNODE, SRCNODE, REQID);
2133 fill_ctdb_req_dmaster(mem_ctx, &c);
2134 datalen = ctdb_req_dmaster_len(&h, &c);
2135 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2137 assert(pkt != NULL);
2138 assert(pkt_len >= datalen);
2140 ret = ctdb_req_dmaster_push(&h, &c, pkt, &len);
2141 assert(ret == EMSGSIZE);
2142 assert(len == datalen);
2143 ret = ctdb_req_dmaster_push(&h, &c, pkt, &pkt_len);
2145 ret = ctdb_req_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2147 verify_ctdb_req_header(&h, &h2);
2148 assert(h2.length == pkt_len);
2149 verify_ctdb_req_dmaster(&c, &c2);
2151 talloc_free(mem_ctx);
2154 static void test_ctdb_reply_dmaster(void)
2156 TALLOC_CTX *mem_ctx;
2158 size_t datalen, pkt_len, len;
2160 struct ctdb_req_header h, h2;
2161 struct ctdb_reply_dmaster c, c2;
2163 printf("ctdb_reply_dmaster\n");
2166 mem_ctx = talloc_new(NULL);
2167 assert(mem_ctx != NULL);
2169 ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_DMASTER,
2170 DESTNODE, SRCNODE, REQID);
2172 fill_ctdb_reply_dmaster(mem_ctx, &c);
2173 datalen = ctdb_reply_dmaster_len(&h, &c);
2174 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2176 assert(pkt != NULL);
2177 assert(pkt_len >= datalen);
2179 ret = ctdb_reply_dmaster_push(&h, &c, pkt, &len);
2180 assert(ret == EMSGSIZE);
2181 assert(len == datalen);
2182 ret = ctdb_reply_dmaster_push(&h, &c, pkt, &pkt_len);
2184 ret = ctdb_reply_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2186 verify_ctdb_req_header(&h, &h2);
2187 assert(h2.length == pkt_len);
2188 verify_ctdb_reply_dmaster(&c, &c2);
2190 talloc_free(mem_ctx);
2193 #define NUM_CONTROLS 150
2195 static void test_ctdb_req_control_data(void)
2197 TALLOC_CTX *mem_ctx;
2200 struct ctdb_req_control_data cd, cd2;
2203 printf("ctdb_req_control_data\n");
2206 for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2207 mem_ctx = talloc_new(NULL);
2208 assert(mem_ctx != NULL);
2210 printf("%u.. ", opcode);
2212 fill_ctdb_req_control_data(mem_ctx, &cd, opcode);
2213 buflen = ctdb_req_control_data_len(&cd);
2214 ctdb_req_control_data_push(&cd, BUFFER);
2215 ret = ctdb_req_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
2217 verify_ctdb_req_control_data(&cd, &cd2);
2218 talloc_free(mem_ctx);
2225 static void test_ctdb_reply_control_data(void)
2227 TALLOC_CTX *mem_ctx;
2230 struct ctdb_reply_control_data cd, cd2;
2233 printf("ctdb_reply_control_data\n");
2236 for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2237 mem_ctx = talloc_new(NULL);
2238 assert(mem_ctx != NULL);
2240 printf("%u.. ", opcode);
2242 fill_ctdb_reply_control_data(mem_ctx, &cd, opcode);
2243 buflen = ctdb_reply_control_data_len(&cd);
2244 ctdb_reply_control_data_push(&cd, BUFFER);
2245 ret = ctdb_reply_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
2247 verify_ctdb_reply_control_data(&cd, &cd2);
2248 talloc_free(mem_ctx);
2255 static void test_ctdb_req_control(void)
2257 TALLOC_CTX *mem_ctx;
2259 size_t datalen, pkt_len, len;
2261 struct ctdb_req_header h, h2;
2262 struct ctdb_req_control c, c2;
2265 printf("ctdb_req_control\n");
2268 ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CONTROL,
2269 DESTNODE, SRCNODE, REQID);
2271 for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2272 mem_ctx = talloc_new(NULL);
2273 assert(mem_ctx != NULL);
2275 printf("%u.. ", opcode);
2277 fill_ctdb_req_control(mem_ctx, &c, opcode);
2278 datalen = ctdb_req_control_len(&h, &c);
2279 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2281 assert(pkt != NULL);
2282 assert(pkt_len >= datalen);
2284 ret = ctdb_req_control_push(&h, &c, pkt, &len);
2285 assert(ret == EMSGSIZE);
2286 assert(len == datalen);
2287 ret = ctdb_req_control_push(&h, &c, pkt, &pkt_len);
2289 ret = ctdb_req_control_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2291 verify_ctdb_req_header(&h, &h2);
2292 assert(h2.length == pkt_len);
2293 verify_ctdb_req_control(&c, &c2);
2295 talloc_free(mem_ctx);
2302 static void test_ctdb_reply_control(void)
2304 TALLOC_CTX *mem_ctx;
2306 size_t datalen, pkt_len, len;
2308 struct ctdb_req_header h, h2;
2309 struct ctdb_reply_control c, c2;
2312 printf("ctdb_reply_control\n");
2315 ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CONTROL,
2316 DESTNODE, SRCNODE, REQID);
2318 for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2319 mem_ctx = talloc_new(NULL);
2320 assert(mem_ctx != NULL);
2322 printf("%u.. ", opcode);
2324 fill_ctdb_reply_control(mem_ctx, &c, opcode);
2325 datalen = ctdb_reply_control_len(&h, &c);
2326 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2328 assert(pkt != NULL);
2329 assert(pkt_len >= datalen);
2331 ret = ctdb_reply_control_push(&h, &c, pkt, &len);
2332 assert(ret == EMSGSIZE);
2333 assert(len == datalen);
2334 ret = ctdb_reply_control_push(&h, &c, pkt, &pkt_len);
2336 ret = ctdb_reply_control_pull(pkt, pkt_len, opcode, &h2, mem_ctx, &c2);
2338 verify_ctdb_req_header(&h, &h2);
2339 assert(h2.length == pkt_len);
2340 verify_ctdb_reply_control(&c, &c2);
2342 talloc_free(mem_ctx);
2349 static void test_ctdb_req_message_data(void)
2351 TALLOC_CTX *mem_ctx;
2353 size_t datalen, pkt_len, len;
2355 struct ctdb_req_header h, h2;
2356 struct ctdb_req_message_data c, c2;
2358 printf("ctdb_req_message\n");
2361 mem_ctx = talloc_new(NULL);
2362 assert(mem_ctx != NULL);
2364 ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_MESSAGE,
2365 DESTNODE, SRCNODE, REQID);
2367 fill_ctdb_req_message_data(mem_ctx, &c);
2368 datalen = ctdb_req_message_data_len(&h, &c);
2369 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2371 assert(pkt != NULL);
2372 assert(pkt_len >= datalen);
2374 ret = ctdb_req_message_data_push(&h, &c, pkt, &len);
2375 assert(ret == EMSGSIZE);
2376 assert(len == datalen);
2377 ret = ctdb_req_message_data_push(&h, &c, pkt, &pkt_len);
2379 ret = ctdb_req_message_data_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2381 verify_ctdb_req_header(&h, &h2);
2382 assert(h2.length == pkt_len);
2383 verify_ctdb_req_message_data(&c, &c2);
2385 talloc_free(mem_ctx);
2389 * Functions to test eventd protocol marshalling
2392 static void test_ctdb_event_header(void)
2394 TALLOC_CTX *mem_ctx;
2396 struct ctdb_event_header h, h2;
2399 printf("ctdb_event_header\n");
2402 mem_ctx = talloc_new(NULL);
2403 assert(mem_ctx != NULL);
2405 ctdb_event_header_fill(&h, REQID);
2407 buflen = ctdb_event_header_len(&h);
2408 ctdb_event_header_push(&h, BUFFER);
2409 ret = ctdb_event_header_pull(BUFFER, buflen, mem_ctx, &h2);
2412 verify_ctdb_event_header(&h, &h2);
2414 talloc_free(mem_ctx);
2417 #define NUM_COMMANDS 5
2419 static void test_ctdb_event_request_data(void)
2421 TALLOC_CTX *mem_ctx;
2423 struct ctdb_event_request_data rd, rd2;
2427 printf("ctdb_event_request_data\n");
2430 for (command=1; command<=NUM_COMMANDS; command++) {
2431 mem_ctx = talloc_new(NULL);
2432 assert(mem_ctx != NULL);
2434 printf("%u.. ", command);
2436 fill_ctdb_event_request_data(mem_ctx, &rd, command);
2437 buflen = ctdb_event_request_data_len(&rd);
2438 ctdb_event_request_data_push(&rd, BUFFER);
2439 ret = ctdb_event_request_data_pull(BUFFER, buflen, mem_ctx, &rd2);
2441 verify_ctdb_event_request_data(&rd, &rd2);
2443 talloc_free(mem_ctx);
2450 static void test_ctdb_event_reply_data(void)
2452 TALLOC_CTX *mem_ctx;
2454 struct ctdb_event_reply_data rd, rd2;
2458 printf("ctdb_event_reply_data\n");
2461 for (command=1; command<=NUM_COMMANDS; command++) {
2462 mem_ctx = talloc_new(NULL);
2463 assert(mem_ctx != NULL);
2465 printf("%u.. ", command);
2467 fill_ctdb_event_reply_data(mem_ctx, &rd, command);
2468 buflen = ctdb_event_reply_data_len(&rd);
2469 ctdb_event_reply_data_push(&rd, BUFFER);
2470 ret = ctdb_event_reply_data_pull(BUFFER, buflen, mem_ctx, &rd2);
2472 verify_ctdb_event_reply_data(&rd, &rd2);
2474 talloc_free(mem_ctx);
2481 static void test_ctdb_event_request(void)
2483 TALLOC_CTX *mem_ctx;
2487 struct ctdb_event_request r, r2;
2490 printf("ctdb_event_request\n");
2493 for (command=1; command<=NUM_COMMANDS; command++) {
2494 mem_ctx = talloc_new(NULL);
2495 assert(mem_ctx != NULL);
2497 printf("%u.. ", command);
2499 fill_ctdb_event_request(mem_ctx, &r, command);
2500 buflen = ctdb_event_request_len(&r);
2501 buf = talloc_size(mem_ctx, buflen);
2502 assert(buf != NULL);
2504 ret = ctdb_event_request_push(&r, buf, &len);
2505 assert(ret == EMSGSIZE);
2506 assert(len == buflen);
2507 ret = ctdb_event_request_push(&r, buf, &buflen);
2509 ret = ctdb_event_request_pull(buf, buflen, mem_ctx, &r2);
2511 assert(r2.header.length == buflen);
2512 verify_ctdb_event_request(&r, &r2);
2514 talloc_free(mem_ctx);
2521 static void test_ctdb_event_reply(void)
2523 TALLOC_CTX *mem_ctx;
2527 struct ctdb_event_reply r, r2;
2530 printf("ctdb_event_reply\n");
2533 for (command=1; command<=NUM_COMMANDS; command++) {
2534 mem_ctx = talloc_new(NULL);
2535 assert(mem_ctx != NULL);
2537 printf("%u.. ", command);
2539 fill_ctdb_event_reply(mem_ctx, &r, command);
2540 buflen = ctdb_event_reply_len(&r);
2541 buf = talloc_size(mem_ctx, buflen);
2542 assert(buf != NULL);
2544 ret = ctdb_event_reply_push(&r, buf, &len);
2545 assert(ret == EMSGSIZE);
2546 assert(len == buflen);
2547 ret = ctdb_event_reply_push(&r, buf, &buflen);
2549 ret = ctdb_event_reply_pull(buf, buflen, mem_ctx, &r2);
2551 assert(r2.header.length == buflen);
2552 verify_ctdb_event_reply(&r, &r2);
2554 talloc_free(mem_ctx);
2561 int main(int argc, char *argv[])
2564 int seed = atoi(argv[1]);
2568 test_ctdb_req_header();
2570 test_ctdb_req_call();
2571 test_ctdb_reply_call();
2572 test_ctdb_reply_error();
2573 test_ctdb_req_dmaster();
2574 test_ctdb_reply_dmaster();
2576 test_ctdb_req_control_data();
2577 test_ctdb_reply_control_data();
2579 test_ctdb_req_control();
2580 test_ctdb_reply_control();
2582 test_ctdb_req_message_data();
2584 test_ctdb_event_header();
2586 test_ctdb_event_request_data();
2587 test_ctdb_event_reply_data();
2588 test_ctdb_event_request();
2589 test_ctdb_event_reply();