ctdb/tests/src/protocol_client_test.c

   1 /*
   2    protocol tests
   3
   4    Copyright (C) Amitay Isaacs  2015
   5
   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.
  10
  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.
  15
  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/>.
  18 */
  19
  20 #include "replace.h"
  21 #include "system/network.h"
  22
  23 #include <assert.h>
  24
  25 #define PROTOCOL_TEST
  26
  27 #include "protocol_types_test.c"
  28
  29
  30 #define GENERATION      0xabcdef12
  31 #define OPERATION       CTDB_REQ_KEEPALIVE
  32 #define REQID           0x34567890
  33 #define SRCNODE         7
  34 #define DESTNODE        13
  35
  36 /*
  37  * Functions to fill and verify protocol structures
  38  */
  39
  40 static void verify_ctdb_req_header(struct ctdb_req_header *h,
  41                                    struct ctdb_req_header *h2)
  42 {
  43         verify_buffer(h, h2, ctdb_req_header_len(h));
  44 }
  45
  46 static void fill_ctdb_req_call(TALLOC_CTX *mem_ctx,
  47                                struct ctdb_req_call *c)
  48 {
  49         c->flags = rand32();
  50         c->db_id = rand32();
  51         c->callid = rand32();
  52         c->hopcount = rand32();
  53         fill_tdb_data(mem_ctx, &c->key);
  54         fill_tdb_data(mem_ctx, &c->calldata);
  55 }
  56
  57 static void verify_ctdb_req_call(struct ctdb_req_call *c,
  58                                  struct ctdb_req_call *c2)
  59 {
  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);
  66 }
  67
  68 static void fill_ctdb_reply_call(TALLOC_CTX *mem_ctx,
  69                                  struct ctdb_reply_call *c)
  70 {
  71         c->status = rand32();
  72         fill_tdb_data(mem_ctx, &c->data);
  73 }
  74
  75 static void verify_ctdb_reply_call(struct ctdb_reply_call *c,
  76                                    struct ctdb_reply_call *c2)
  77 {
  78         assert(c->status == c2->status);
  79         verify_tdb_data(&c->data, &c2->data);
  80 }
  81
  82 static void fill_ctdb_reply_error(TALLOC_CTX *mem_ctx,
  83                                   struct ctdb_reply_error *c)
  84 {
  85         c->status = rand32();
  86         fill_tdb_data(mem_ctx, &c->msg);
  87 }
  88
  89 static void verify_ctdb_reply_error(struct ctdb_reply_error *c,
  90                                     struct ctdb_reply_error *c2)
  91 {
  92         assert(c->status == c2->status);
  93         verify_tdb_data(&c->msg, &c2->msg);
  94 }
  95
  96 static void fill_ctdb_req_dmaster(TALLOC_CTX *mem_ctx,
  97                                   struct ctdb_req_dmaster *c)
  98 {
  99         c->db_id = rand32();
 100         c->rsn = rand64();
 101         c->dmaster = rand32();
 102         fill_tdb_data(mem_ctx, &c->key);
 103         fill_tdb_data(mem_ctx, &c->data);
 104 }
 105
 106 static void verify_ctdb_req_dmaster(struct ctdb_req_dmaster *c,
 107                                     struct ctdb_req_dmaster *c2)
 108 {
 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);
 114 }
 115
 116 static void fill_ctdb_reply_dmaster(TALLOC_CTX *mem_ctx,
 117                                     struct ctdb_reply_dmaster *c)
 118 {
 119         c->db_id = rand32();
 120         c->rsn = rand64();
 121         fill_tdb_data(mem_ctx, &c->key);
 122         fill_tdb_data(mem_ctx, &c->data);
 123 }
 124
 125 static void verify_ctdb_reply_dmaster(struct ctdb_reply_dmaster *c,
 126                                       struct ctdb_reply_dmaster *c2)
 127 {
 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);
 132 }
 133
 134 static void fill_ctdb_req_control_data(TALLOC_CTX *mem_ctx,
 135                                        struct ctdb_req_control_data *cd,
 136                                        uint32_t opcode)
 137 {
 138         cd->opcode = opcode;
 139         switch (opcode) {
 140         case CTDB_CONTROL_PROCESS_EXISTS:
 141                 cd->data.pid = rand32();
 142                 break;
 143
 144         case CTDB_CONTROL_STATISTICS:
 145                 break;
 146
 147         case CTDB_CONTROL_PING:
 148                 break;
 149
 150         case CTDB_CONTROL_GETDBPATH:
 151                 cd->data.db_id = rand32();
 152                 break;
 153
 154         case CTDB_CONTROL_GETVNNMAP:
 155                 break;
 156
 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);
 161                 break;
 162
 163         case CTDB_CONTROL_GET_DEBUG:
 164                 break;
 165
 166         case CTDB_CONTROL_SET_DEBUG:
 167                 cd->data.loglevel = rand_int(5);
 168                 break;
 169
 170         case CTDB_CONTROL_GET_DBMAP:
 171                 break;
 172
 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);
 177                 break;
 178
 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);
 183                 break;
 184
 185         case CTDB_CONTROL_GET_RECMODE:
 186                 break;
 187
 188         case CTDB_CONTROL_SET_RECMODE:
 189                 cd->data.recmode = rand_int(2);
 190                 break;
 191
 192         case CTDB_CONTROL_STATISTICS_RESET:
 193                 break;
 194
 195         case CTDB_CONTROL_DB_ATTACH:
 196                 fill_ctdb_string(mem_ctx, &cd->data.db_name);
 197                 assert(cd->data.db_name != NULL);
 198                 break;
 199
 200         case CTDB_CONTROL_SET_CALL:
 201                 break;
 202
 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);
 207                 break;
 208
 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);
 213                 break;
 214
 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);
 219                 break;
 220
 221         case CTDB_CONTROL_REGISTER_SRVID:
 222                 break;
 223
 224         case CTDB_CONTROL_DEREGISTER_SRVID:
 225                 break;
 226
 227         case CTDB_CONTROL_GET_DBNAME:
 228                 cd->data.db_id = rand32();
 229                 break;
 230
 231         case CTDB_CONTROL_ENABLE_SEQNUM:
 232                 cd->data.db_id = rand32();
 233                 break;
 234
 235         case CTDB_CONTROL_UPDATE_SEQNUM:
 236                 cd->data.db_id = rand32();
 237                 break;
 238
 239         case CTDB_CONTROL_DUMP_MEMORY:
 240                 break;
 241
 242         case CTDB_CONTROL_GET_PID:
 243                 break;
 244
 245         case CTDB_CONTROL_GET_RECMASTER:
 246                 break;
 247
 248         case CTDB_CONTROL_SET_RECMASTER:
 249                 cd->data.recmaster = rand_int(32);
 250                 break;
 251
 252         case CTDB_CONTROL_FREEZE:
 253                 break;
 254
 255         case CTDB_CONTROL_THAW:
 256                 break;
 257
 258         case CTDB_CONTROL_GET_PNN:
 259                 break;
 260
 261         case CTDB_CONTROL_SHUTDOWN:
 262                 break;
 263
 264         case CTDB_CONTROL_GET_MONMODE:
 265                 break;
 266
 267         case CTDB_CONTROL_TCP_CLIENT:
 268                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 269                 assert(cd->data.conn != NULL);
 270                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 271                 break;
 272
 273         case CTDB_CONTROL_TCP_ADD:
 274                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 275                 assert(cd->data.conn != NULL);
 276                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 277                 break;
 278
 279         case CTDB_CONTROL_TCP_REMOVE:
 280                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 281                 assert(cd->data.conn != NULL);
 282                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 283                 break;
 284
 285         case CTDB_CONTROL_STARTUP:
 286                 break;
 287
 288         case CTDB_CONTROL_SET_TUNABLE:
 289                 cd->data.tunable = talloc(mem_ctx, struct ctdb_tunable);
 290                 assert(cd->data.tunable != NULL);
 291                 fill_ctdb_tunable(mem_ctx, cd->data.tunable);
 292                 break;
 293
 294         case CTDB_CONTROL_GET_TUNABLE:
 295                 fill_ctdb_string(mem_ctx, &cd->data.tun_var);
 296                 assert(cd->data.tun_var != NULL);
 297                 break;
 298
 299         case CTDB_CONTROL_LIST_TUNABLES:
 300                 break;
 301
 302         case CTDB_CONTROL_MODIFY_FLAGS:
 303                 cd->data.flag_change = talloc(mem_ctx, struct ctdb_node_flag_change);
 304                 assert(cd->data.flag_change != NULL);
 305                 fill_ctdb_node_flag_change(mem_ctx, cd->data.flag_change);
 306                 break;
 307
 308         case CTDB_CONTROL_GET_ALL_TUNABLES:
 309                 break;
 310
 311         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 312                 cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
 313                 assert(cd->data.addr != NULL);
 314                 fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
 315                 break;
 316
 317         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 318                 cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
 319                 assert(cd->data.tickles != NULL);
 320                 fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
 321                 break;
 322
 323         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 324                 fill_ctdb_string(mem_ctx, &cd->data.db_name);
 325                 assert(cd->data.db_name != NULL);
 326                 break;
 327
 328         case CTDB_CONTROL_UPDATE_RECORD:
 329                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
 330                 assert(cd->data.recbuf != NULL);
 331                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
 332                 break;
 333
 334         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 335                 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
 336                 assert(cd->data.addr_info != NULL);
 337                 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
 338                 break;
 339
 340         case CTDB_CONTROL_TRANSACTION_START:
 341                 cd->data.tid = rand32();
 342                 break;
 343
 344         case CTDB_CONTROL_TRANSACTION_COMMIT:
 345                 cd->data.tid = rand32();
 346                 break;
 347
 348         case CTDB_CONTROL_WIPE_DATABASE:
 349                 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
 350                 assert(cd->data.transdb != NULL);
 351                 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
 352                 break;
 353
 354         case CTDB_CONTROL_UPTIME:
 355                 break;
 356
 357         case CTDB_CONTROL_START_RECOVERY:
 358                 break;
 359
 360         case CTDB_CONTROL_END_RECOVERY:
 361                 break;
 362
 363         case CTDB_CONTROL_RELOAD_NODES_FILE:
 364                 break;
 365
 366         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 367                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
 368                 assert(cd->data.recbuf != NULL);
 369                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
 370                 break;
 371
 372         case CTDB_CONTROL_ENABLE_MONITOR:
 373                 break;
 374
 375         case CTDB_CONTROL_DISABLE_MONITOR:
 376                 break;
 377
 378         case CTDB_CONTROL_ADD_PUBLIC_IP:
 379                 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
 380                 assert(cd->data.addr_info != NULL);
 381                 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
 382                 break;
 383
 384         case CTDB_CONTROL_DEL_PUBLIC_IP:
 385                 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
 386                 assert(cd->data.addr_info != NULL);
 387                 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
 388                 break;
 389
 390         case CTDB_CONTROL_RUN_EVENTSCRIPTS:
 391                 fill_ctdb_string(mem_ctx, &cd->data.event_str);
 392                 assert(cd->data.event_str != NULL);
 393                 break;
 394
 395         case CTDB_CONTROL_GET_CAPABILITIES:
 396                 break;
 397
 398         case CTDB_CONTROL_START_PERSISTENT_UPDATE:
 399                 break;
 400
 401         case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
 402                 break;
 403
 404         case CTDB_CONTROL_RECD_PING:
 405                 break;
 406
 407         case CTDB_CONTROL_RELEASE_IP:
 408                 cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
 409                 assert(cd->data.pubip != NULL);
 410                 fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
 411                 break;
 412
 413         case CTDB_CONTROL_TAKEOVER_IP:
 414                 cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
 415                 assert(cd->data.pubip != NULL);
 416                 fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
 417                 break;
 418
 419         case CTDB_CONTROL_GET_PUBLIC_IPS:
 420                 break;
 421
 422         case CTDB_CONTROL_GET_NODEMAP:
 423                 break;
 424
 425         case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
 426                 cd->data.event = rand_int(CTDB_EVENT_MAX);
 427                 break;
 428
 429         case CTDB_CONTROL_TRAVERSE_KILL:
 430                 cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
 431                 assert(cd->data.traverse_start != NULL);
 432                 fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
 433                 break;
 434
 435         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 436                 cd->data.reclock_latency = rand_double();
 437                 break;
 438
 439         case CTDB_CONTROL_GET_RECLOCK_FILE:
 440                 break;
 441
 442         case CTDB_CONTROL_STOP_NODE:
 443                 break;
 444
 445         case CTDB_CONTROL_CONTINUE_NODE:
 446                 break;
 447
 448         case CTDB_CONTROL_SET_LMASTERROLE:
 449                 cd->data.role = rand_int(2);
 450                 break;
 451
 452         case CTDB_CONTROL_SET_RECMASTERROLE:
 453                 cd->data.role = rand_int(2);
 454                 break;
 455
 456         case CTDB_CONTROL_ENABLE_SCRIPT:
 457                 fill_ctdb_string(mem_ctx, &cd->data.script);
 458                 assert(cd->data.script != NULL);
 459                 break;
 460
 461         case CTDB_CONTROL_DISABLE_SCRIPT:
 462                 fill_ctdb_string(mem_ctx, &cd->data.script);
 463                 assert(cd->data.script != NULL);
 464                 break;
 465
 466         case CTDB_CONTROL_SET_BAN_STATE:
 467                 cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
 468                 assert(cd->data.ban_state != NULL);
 469                 fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
 470                 break;
 471
 472         case CTDB_CONTROL_GET_BAN_STATE:
 473                 break;
 474
 475         case CTDB_CONTROL_SET_DB_PRIORITY:
 476                 cd->data.db_prio = talloc(mem_ctx, struct ctdb_db_priority);
 477                 assert(cd->data.db_prio != NULL);
 478                 fill_ctdb_db_priority(mem_ctx, cd->data.db_prio);
 479                 break;
 480
 481         case CTDB_CONTROL_GET_DB_PRIORITY:
 482                 cd->data.db_prio = talloc(mem_ctx, struct ctdb_db_priority);
 483                 assert(cd->data.db_prio != NULL);
 484                 fill_ctdb_db_priority(mem_ctx, cd->data.db_prio);
 485                 break;
 486
 487         case CTDB_CONTROL_TRANSACTION_CANCEL:
 488                 break;
 489
 490         case CTDB_CONTROL_REGISTER_NOTIFY:
 491                 cd->data.notify = talloc(mem_ctx, struct ctdb_notify_data);
 492                 assert(cd->data.notify != NULL);
 493                 fill_ctdb_notify_data(mem_ctx, cd->data.notify);
 494                 break;
 495
 496         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 497                 cd->data.srvid = rand64();
 498                 break;
 499
 500         case CTDB_CONTROL_TRANS3_COMMIT:
 501                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
 502                 assert(cd->data.recbuf != NULL);
 503                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
 504                 break;
 505
 506         case CTDB_CONTROL_GET_DB_SEQNUM:
 507                 cd->data.db_id = rand32();
 508                 break;
 509
 510         case CTDB_CONTROL_DB_SET_HEALTHY:
 511                 cd->data.db_id = rand32();
 512                 break;
 513
 514         case CTDB_CONTROL_DB_GET_HEALTH:
 515                 cd->data.db_id = rand32();
 516                 break;
 517
 518         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 519                 cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
 520                 assert(cd->data.addr != NULL);
 521                 fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
 522                 break;
 523
 524         case CTDB_CONTROL_GET_IFACES:
 525                 break;
 526
 527         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 528                 cd->data.iface = talloc(mem_ctx, struct ctdb_iface);
 529                 assert(cd->data.iface != NULL);
 530                 fill_ctdb_iface(mem_ctx, cd->data.iface);
 531                 break;
 532
 533         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 534                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 535                 assert(cd->data.conn != NULL);
 536                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 537                 break;
 538
 539         case CTDB_CONTROL_GET_STAT_HISTORY:
 540                 break;
 541
 542         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 543                 cd->data.key = talloc(mem_ctx, struct ctdb_key_data);
 544                 assert(cd->data.key != NULL);
 545                 fill_ctdb_key_data(mem_ctx, cd->data.key);
 546                 break;
 547
 548         case CTDB_CONTROL_SET_DB_READONLY:
 549                 cd->data.db_id = rand32();
 550                 break;
 551
 552         case CTDB_CONTROL_CHECK_SRVIDS:
 553                 cd->data.u64_array = talloc(mem_ctx, struct ctdb_uint64_array);
 554                 assert(cd->data.u64_array != NULL);
 555                 fill_ctdb_uint64_array(mem_ctx, cd->data.u64_array);
 556                 break;
 557
 558         case CTDB_CONTROL_TRAVERSE_START_EXT:
 559                 cd->data.traverse_start_ext = talloc(mem_ctx, struct ctdb_traverse_start_ext);
 560                 assert(cd->data.traverse_start_ext != NULL);
 561                 fill_ctdb_traverse_start_ext(mem_ctx, cd->data.traverse_start_ext);
 562                 break;
 563
 564         case CTDB_CONTROL_GET_DB_STATISTICS:
 565                 cd->data.db_id = rand32();
 566                 break;
 567
 568         case CTDB_CONTROL_SET_DB_STICKY:
 569                 cd->data.db_id = rand32();
 570                 break;
 571
 572         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
 573                 break;
 574
 575         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 576                 cd->data.traverse_all_ext = talloc(mem_ctx, struct ctdb_traverse_all_ext);
 577                 assert(cd->data.traverse_all_ext != NULL);
 578                 fill_ctdb_traverse_all_ext(mem_ctx, cd->data.traverse_all_ext);
 579                 break;
 580
 581         case CTDB_CONTROL_RECEIVE_RECORDS:
 582                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
 583                 assert(cd->data.recbuf != NULL);
 584                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
 585                 break;
 586
 587         case CTDB_CONTROL_IPREALLOCATED:
 588                 break;
 589
 590         case CTDB_CONTROL_GET_RUNSTATE:
 591                 break;
 592
 593         case CTDB_CONTROL_DB_DETACH:
 594                 cd->data.db_id = rand32();
 595                 break;
 596
 597         case CTDB_CONTROL_GET_NODES_FILE:
 598                 break;
 599
 600         case CTDB_CONTROL_DB_FREEZE:
 601                 cd->data.db_id = rand32();
 602                 break;
 603
 604         case CTDB_CONTROL_DB_THAW:
 605                 cd->data.db_id = rand32();
 606                 break;
 607
 608         case CTDB_CONTROL_DB_TRANSACTION_START:
 609                 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
 610                 assert(cd->data.transdb != NULL);
 611                 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
 612                 break;
 613
 614         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
 615                 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
 616                 assert(cd->data.transdb != NULL);
 617                 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
 618                 break;
 619
 620         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
 621                 cd->data.db_id = rand32();
 622                 break;
 623
 624         case CTDB_CONTROL_DB_PULL:
 625                 cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
 626                 assert(cd->data.pulldb_ext != NULL);
 627                 fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
 628                 break;
 629
 630         case CTDB_CONTROL_DB_PUSH_START:
 631                 cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
 632                 assert(cd->data.pulldb_ext != NULL);
 633                 fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
 634                 break;
 635
 636         case CTDB_CONTROL_DB_PUSH_CONFIRM:
 637                 cd->data.db_id = rand32();
 638                 break;
 639
 640         }
 641 }
 642
 643 static void verify_ctdb_req_control_data(struct ctdb_req_control_data *cd,
 644                                          struct ctdb_req_control_data *cd2)
 645 {
 646         assert(cd->opcode == cd2->opcode);
 647
 648         switch (cd->opcode) {
 649         case CTDB_CONTROL_PROCESS_EXISTS:
 650                 assert(cd->data.pid == cd2->data.pid);
 651                 break;
 652
 653         case CTDB_CONTROL_STATISTICS:
 654                 break;
 655
 656         case CTDB_CONTROL_PING:
 657                 break;
 658
 659         case CTDB_CONTROL_GETDBPATH:
 660                 assert(cd->data.db_id == cd2->data.db_id);
 661                 break;
 662
 663         case CTDB_CONTROL_GETVNNMAP:
 664                 break;
 665
 666         case CTDB_CONTROL_SETVNNMAP:
 667                 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap);
 668                 break;
 669
 670         case CTDB_CONTROL_GET_DEBUG:
 671                 break;
 672
 673         case CTDB_CONTROL_SET_DEBUG:
 674                 assert(cd->data.loglevel == cd2->data.loglevel);
 675                 break;
 676
 677         case CTDB_CONTROL_GET_DBMAP:
 678                 break;
 679
 680         case CTDB_CONTROL_PULL_DB:
 681                 verify_ctdb_pulldb(cd->data.pulldb, cd2->data.pulldb);
 682                 break;
 683
 684         case CTDB_CONTROL_PUSH_DB:
 685                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
 686                 break;
 687
 688         case CTDB_CONTROL_GET_RECMODE:
 689                 break;
 690
 691         case CTDB_CONTROL_SET_RECMODE:
 692                 assert(cd->data.recmode == cd2->data.recmode);
 693                 break;
 694
 695         case CTDB_CONTROL_STATISTICS_RESET:
 696                 break;
 697
 698         case CTDB_CONTROL_DB_ATTACH:
 699                 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
 700                 break;
 701
 702         case CTDB_CONTROL_SET_CALL:
 703                 break;
 704
 705         case CTDB_CONTROL_TRAVERSE_START:
 706                 verify_ctdb_traverse_start(cd->data.traverse_start,
 707                                            cd2->data.traverse_start);
 708                 break;
 709
 710         case CTDB_CONTROL_TRAVERSE_ALL:
 711                 verify_ctdb_traverse_all(cd->data.traverse_all,
 712                                          cd2->data.traverse_all);
 713                 break;
 714
 715         case CTDB_CONTROL_TRAVERSE_DATA:
 716                 verify_ctdb_rec_data(cd->data.rec_data, cd2->data.rec_data);
 717                 break;
 718
 719         case CTDB_CONTROL_REGISTER_SRVID:
 720                 break;
 721
 722         case CTDB_CONTROL_DEREGISTER_SRVID:
 723                 break;
 724
 725         case CTDB_CONTROL_GET_DBNAME:
 726                 assert(cd->data.db_id == cd2->data.db_id);
 727                 break;
 728
 729         case CTDB_CONTROL_ENABLE_SEQNUM:
 730                 assert(cd->data.db_id == cd2->data.db_id);
 731                 break;
 732
 733         case CTDB_CONTROL_UPDATE_SEQNUM:
 734                 assert(cd->data.db_id == cd2->data.db_id);
 735                 break;
 736
 737         case CTDB_CONTROL_DUMP_MEMORY:
 738                 break;
 739
 740         case CTDB_CONTROL_GET_PID:
 741                 break;
 742
 743         case CTDB_CONTROL_GET_RECMASTER:
 744                 break;
 745
 746         case CTDB_CONTROL_SET_RECMASTER:
 747                 assert(cd->data.recmaster == cd2->data.recmaster);
 748                 break;
 749
 750         case CTDB_CONTROL_FREEZE:
 751                 break;
 752
 753         case CTDB_CONTROL_THAW:
 754                 break;
 755
 756         case CTDB_CONTROL_GET_PNN:
 757                 break;
 758
 759         case CTDB_CONTROL_SHUTDOWN:
 760                 break;
 761
 762         case CTDB_CONTROL_GET_MONMODE:
 763                 break;
 764
 765         case CTDB_CONTROL_TCP_CLIENT:
 766                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
 767                 break;
 768
 769         case CTDB_CONTROL_TCP_ADD:
 770                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
 771                 break;
 772
 773         case CTDB_CONTROL_TCP_REMOVE:
 774                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
 775                 break;
 776
 777         case CTDB_CONTROL_STARTUP:
 778                 break;
 779
 780         case CTDB_CONTROL_SET_TUNABLE:
 781                 verify_ctdb_tunable(cd->data.tunable, cd2->data.tunable);
 782                 break;
 783
 784         case CTDB_CONTROL_GET_TUNABLE:
 785                 verify_ctdb_string(cd->data.tun_var, cd2->data.tun_var);
 786                 break;
 787
 788         case CTDB_CONTROL_LIST_TUNABLES:
 789                 break;
 790
 791         case CTDB_CONTROL_MODIFY_FLAGS:
 792                 verify_ctdb_node_flag_change(cd->data.flag_change,
 793                                              cd2->data.flag_change);
 794                 break;
 795
 796         case CTDB_CONTROL_GET_ALL_TUNABLES:
 797                 break;
 798
 799         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 800                 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr);
 801                 break;
 802
 803         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 804                 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles);
 805                 break;
 806
 807         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 808                 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
 809                 break;
 810
 811         case CTDB_CONTROL_UPDATE_RECORD:
 812                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
 813                 break;
 814
 815         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 816                 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
 817                 break;
 818
 819         case CTDB_CONTROL_TRANSACTION_START:
 820                 assert(cd->data.tid == cd2->data.tid);
 821                 break;
 822
 823         case CTDB_CONTROL_TRANSACTION_COMMIT:
 824                 assert(cd->data.tid == cd2->data.tid);
 825                 break;
 826
 827         case CTDB_CONTROL_WIPE_DATABASE:
 828                 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
 829                 break;
 830
 831         case CTDB_CONTROL_UPTIME:
 832                 break;
 833
 834         case CTDB_CONTROL_START_RECOVERY:
 835                 break;
 836
 837         case CTDB_CONTROL_END_RECOVERY:
 838                 break;
 839
 840         case CTDB_CONTROL_RELOAD_NODES_FILE:
 841                 break;
 842
 843         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 844                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
 845                 break;
 846
 847         case CTDB_CONTROL_ENABLE_MONITOR:
 848                 break;
 849
 850         case CTDB_CONTROL_DISABLE_MONITOR:
 851                 break;
 852
 853         case CTDB_CONTROL_ADD_PUBLIC_IP:
 854                 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
 855                 break;
 856
 857         case CTDB_CONTROL_DEL_PUBLIC_IP:
 858                 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
 859                 break;
 860
 861         case CTDB_CONTROL_RUN_EVENTSCRIPTS:
 862                 verify_ctdb_string(cd->data.event_str, cd2->data.event_str);
 863                 break;
 864
 865         case CTDB_CONTROL_GET_CAPABILITIES:
 866                 break;
 867
 868         case CTDB_CONTROL_START_PERSISTENT_UPDATE:
 869                 break;
 870
 871         case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
 872                 break;
 873
 874         case CTDB_CONTROL_RECD_PING:
 875                 break;
 876
 877         case CTDB_CONTROL_RELEASE_IP:
 878                 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip);
 879                 break;
 880
 881         case CTDB_CONTROL_TAKEOVER_IP:
 882                 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip);
 883                 break;
 884
 885         case CTDB_CONTROL_GET_PUBLIC_IPS:
 886                 break;
 887
 888         case CTDB_CONTROL_GET_NODEMAP:
 889                 break;
 890
 891         case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
 892                 assert(cd->data.event == cd2->data.event);
 893                 break;
 894
 895         case CTDB_CONTROL_TRAVERSE_KILL:
 896                 verify_ctdb_traverse_start(cd->data.traverse_start,
 897                                            cd2->data.traverse_start);
 898                 break;
 899
 900         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 901                 assert(cd->data.reclock_latency == cd2->data.reclock_latency);
 902                 break;
 903
 904         case CTDB_CONTROL_GET_RECLOCK_FILE:
 905                 break;
 906
 907         case CTDB_CONTROL_STOP_NODE:
 908                 break;
 909
 910         case CTDB_CONTROL_CONTINUE_NODE:
 911                 break;
 912
 913         case CTDB_CONTROL_SET_LMASTERROLE:
 914                 assert(cd->data.role == cd2->data.role);
 915                 break;
 916
 917         case CTDB_CONTROL_SET_RECMASTERROLE:
 918                 assert(cd->data.role == cd2->data.role);
 919                 break;
 920
 921         case CTDB_CONTROL_ENABLE_SCRIPT:
 922                 verify_ctdb_string(cd->data.script, cd2->data.script);
 923                 break;
 924
 925         case CTDB_CONTROL_DISABLE_SCRIPT:
 926                 verify_ctdb_string(cd->data.script, cd2->data.script);
 927                 break;
 928
 929         case CTDB_CONTROL_SET_BAN_STATE:
 930                 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state);
 931                 break;
 932
 933         case CTDB_CONTROL_GET_BAN_STATE:
 934                 break;
 935
 936         case CTDB_CONTROL_SET_DB_PRIORITY:
 937                 verify_ctdb_db_priority(cd->data.db_prio, cd2->data.db_prio);
 938                 break;
 939
 940         case CTDB_CONTROL_GET_DB_PRIORITY:
 941                 assert(cd->data.db_id == cd2->data.db_id);
 942                 break;
 943
 944         case CTDB_CONTROL_TRANSACTION_CANCEL:
 945                 break;
 946
 947         case CTDB_CONTROL_REGISTER_NOTIFY:
 948                 verify_ctdb_notify_data(cd->data.notify, cd2->data.notify);
 949                 break;
 950
 951         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 952                 assert(cd->data.srvid == cd2->data.srvid);
 953                 break;
 954
 955         case CTDB_CONTROL_TRANS3_COMMIT:
 956                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
 957                 break;
 958
 959         case CTDB_CONTROL_GET_DB_SEQNUM:
 960                 assert(cd->data.db_id == cd2->data.db_id);
 961                 break;
 962
 963         case CTDB_CONTROL_DB_SET_HEALTHY:
 964                 assert(cd->data.db_id == cd2->data.db_id);
 965                 break;
 966
 967         case CTDB_CONTROL_DB_GET_HEALTH:
 968                 assert(cd->data.db_id == cd2->data.db_id);
 969                 break;
 970
 971         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 972                 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr);
 973                 break;
 974
 975         case CTDB_CONTROL_GET_IFACES:
 976                 break;
 977
 978         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 979                 verify_ctdb_iface(cd->data.iface, cd2->data.iface);
 980                 break;
 981
 982         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 983                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
 984                 break;
 985
 986         case CTDB_CONTROL_GET_STAT_HISTORY:
 987                 break;
 988
 989         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 990                 verify_ctdb_key_data(cd->data.key, cd2->data.key);
 991                 break;
 992
 993         case CTDB_CONTROL_SET_DB_READONLY:
 994                 assert(cd->data.db_id == cd2->data.db_id);
 995                 break;
 996
 997         case CTDB_CONTROL_CHECK_SRVIDS:
 998                 verify_ctdb_uint64_array(cd->data.u64_array,
 999                                          cd2->data.u64_array);
1000                 break;
1001
1002         case CTDB_CONTROL_TRAVERSE_START_EXT:
1003                 verify_ctdb_traverse_start_ext(cd->data.traverse_start_ext,
1004                                                cd2->data.traverse_start_ext);
1005                 break;
1006
1007         case CTDB_CONTROL_GET_DB_STATISTICS:
1008                 assert(cd->data.db_id == cd2->data.db_id);
1009                 break;
1010
1011         case CTDB_CONTROL_SET_DB_STICKY:
1012                 assert(cd->data.db_id == cd2->data.db_id);
1013                 break;
1014
1015         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1016                 break;
1017
1018         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1019                 verify_ctdb_traverse_all_ext(cd->data.traverse_all_ext,
1020                                              cd2->data.traverse_all_ext);
1021                 break;
1022
1023         case CTDB_CONTROL_RECEIVE_RECORDS:
1024                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1025                 break;
1026
1027         case CTDB_CONTROL_IPREALLOCATED:
1028                 break;
1029
1030         case CTDB_CONTROL_GET_RUNSTATE:
1031                 break;
1032
1033         case CTDB_CONTROL_DB_DETACH:
1034                 assert(cd->data.db_id == cd2->data.db_id);
1035                 break;
1036
1037         case CTDB_CONTROL_GET_NODES_FILE:
1038                 break;
1039
1040         case CTDB_CONTROL_DB_FREEZE:
1041                 assert(cd->data.db_id == cd2->data.db_id);
1042                 break;
1043
1044         case CTDB_CONTROL_DB_THAW:
1045                 assert(cd->data.db_id == cd2->data.db_id);
1046                 break;
1047
1048         case CTDB_CONTROL_DB_TRANSACTION_START:
1049                 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
1050                 break;
1051
1052         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
1053                 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
1054                 break;
1055
1056         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
1057                 assert(cd->data.db_id == cd2->data.db_id);
1058                 break;
1059
1060         case CTDB_CONTROL_DB_PULL:
1061                 verify_ctdb_pulldb_ext(cd->data.pulldb_ext,
1062                                        cd2->data.pulldb_ext);
1063                 break;
1064
1065         case CTDB_CONTROL_DB_PUSH_START:
1066                 verify_ctdb_pulldb_ext(cd->data.pulldb_ext,
1067                                        cd2->data.pulldb_ext);
1068                 break;
1069
1070         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1071                 assert(cd->data.db_id == cd2->data.db_id);
1072                 break;
1073
1074         }
1075 }
1076
1077 static void fill_ctdb_req_control(TALLOC_CTX *mem_ctx,
1078                                   struct ctdb_req_control *c,
1079                                   uint32_t opcode)
1080 {
1081         c->opcode = opcode;
1082         c->pad = rand32();
1083         c->srvid = rand64();
1084         c->client_id = rand32();
1085         c->flags = rand32();
1086
1087         fill_ctdb_req_control_data(mem_ctx, &c->rdata, opcode);
1088 }
1089
1090 static void verify_ctdb_req_control(struct ctdb_req_control *c,
1091                                     struct ctdb_req_control *c2)
1092 {
1093         assert(c->opcode == c2->opcode);
1094         assert(c->pad == c2->pad);
1095         assert(c->srvid == c2->srvid);
1096         assert(c->client_id == c2->client_id);
1097         assert(c->flags == c2->flags);
1098
1099         verify_ctdb_req_control_data(&c->rdata, &c2->rdata);
1100 }
1101
1102 static void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx,
1103                                          struct ctdb_reply_control_data *cd,
1104                                          uint32_t opcode)
1105 {
1106         cd->opcode = opcode;
1107
1108         switch (opcode) {
1109         case CTDB_CONTROL_PROCESS_EXISTS:
1110                 break;
1111
1112         case CTDB_CONTROL_STATISTICS:
1113                 cd->data.stats = talloc(mem_ctx, struct ctdb_statistics);
1114                 assert(cd->data.stats != NULL);
1115                 fill_ctdb_statistics(mem_ctx, cd->data.stats);
1116                 break;
1117
1118         case CTDB_CONTROL_PING:
1119                 break;
1120
1121         case CTDB_CONTROL_GETDBPATH:
1122                 fill_ctdb_string(mem_ctx, &cd->data.db_path);
1123                 assert(cd->data.db_path != NULL);
1124                 break;
1125
1126         case CTDB_CONTROL_GETVNNMAP:
1127                 cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
1128                 assert(cd->data.vnnmap != NULL);
1129                 fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
1130                 break;
1131
1132         case CTDB_CONTROL_SETVNNMAP:
1133                 break;
1134
1135         case CTDB_CONTROL_GET_DEBUG:
1136                 cd->data.loglevel = rand_int(5);
1137                 break;
1138
1139         case CTDB_CONTROL_SET_DEBUG:
1140                 break;
1141
1142         case CTDB_CONTROL_GET_DBMAP:
1143                 cd->data.dbmap = talloc(mem_ctx, struct ctdb_dbid_map);
1144                 assert(cd->data.dbmap != NULL);
1145                 fill_ctdb_dbid_map(mem_ctx, cd->data.dbmap);
1146                 break;
1147
1148         case CTDB_CONTROL_PULL_DB:
1149                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1150                 assert(cd->data.recbuf != NULL);
1151                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1152                 break;
1153
1154         case CTDB_CONTROL_PUSH_DB:
1155                 break;
1156
1157         case CTDB_CONTROL_GET_RECMODE:
1158                 break;
1159
1160         case CTDB_CONTROL_SET_RECMODE:
1161                 break;
1162
1163         case CTDB_CONTROL_STATISTICS_RESET:
1164                 break;
1165
1166         case CTDB_CONTROL_DB_ATTACH:
1167                 cd->data.db_id = rand32();
1168                 break;
1169
1170         case CTDB_CONTROL_SET_CALL:
1171                 break;
1172
1173         case CTDB_CONTROL_TRAVERSE_START:
1174                 break;
1175
1176         case CTDB_CONTROL_TRAVERSE_ALL:
1177                 break;
1178
1179         case CTDB_CONTROL_TRAVERSE_DATA:
1180                 break;
1181
1182         case CTDB_CONTROL_REGISTER_SRVID:
1183                 break;
1184
1185         case CTDB_CONTROL_DEREGISTER_SRVID:
1186                 break;
1187
1188         case CTDB_CONTROL_GET_DBNAME:
1189                 fill_ctdb_string(mem_ctx, &cd->data.db_name);
1190                 assert(cd->data.db_name);
1191                 break;
1192
1193         case CTDB_CONTROL_ENABLE_SEQNUM:
1194                 break;
1195
1196         case CTDB_CONTROL_UPDATE_SEQNUM:
1197                 break;
1198
1199         case CTDB_CONTROL_DUMP_MEMORY:
1200                 fill_ctdb_string(mem_ctx, &cd->data.mem_str);
1201                 assert(cd->data.mem_str);
1202                 break;
1203
1204         case CTDB_CONTROL_GET_PID:
1205                 break;
1206
1207         case CTDB_CONTROL_GET_RECMASTER:
1208                 break;
1209
1210         case CTDB_CONTROL_SET_RECMASTER:
1211                 break;
1212
1213         case CTDB_CONTROL_FREEZE:
1214                 break;
1215
1216         case CTDB_CONTROL_THAW:
1217                 break;
1218
1219         case CTDB_CONTROL_GET_PNN:
1220                 break;
1221
1222         case CTDB_CONTROL_SHUTDOWN:
1223                 break;
1224
1225         case CTDB_CONTROL_GET_MONMODE:
1226                 break;
1227
1228         case CTDB_CONTROL_TCP_CLIENT:
1229                 break;
1230
1231         case CTDB_CONTROL_TCP_ADD:
1232                 break;
1233
1234         case CTDB_CONTROL_TCP_REMOVE:
1235                 break;
1236
1237         case CTDB_CONTROL_STARTUP:
1238                 break;
1239
1240         case CTDB_CONTROL_SET_TUNABLE:
1241                 break;
1242
1243         case CTDB_CONTROL_GET_TUNABLE:
1244                 cd->data.tun_value = rand32();
1245                 break;
1246
1247         case CTDB_CONTROL_LIST_TUNABLES:
1248                 cd->data.tun_var_list = talloc(mem_ctx, struct ctdb_var_list);
1249                 assert(cd->data.tun_var_list != NULL);
1250                 fill_ctdb_var_list(mem_ctx, cd->data.tun_var_list);
1251                 break;
1252
1253         case CTDB_CONTROL_MODIFY_FLAGS:
1254                 break;
1255
1256         case CTDB_CONTROL_GET_ALL_TUNABLES:
1257                 cd->data.tun_list = talloc(mem_ctx, struct ctdb_tunable_list);
1258                 assert(cd->data.tun_list != NULL);
1259                 fill_ctdb_tunable_list(mem_ctx, cd->data.tun_list);
1260                 break;
1261
1262         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1263                 cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
1264                 assert(cd->data.tickles != NULL);
1265                 fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
1266                 break;
1267
1268         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1269                 break;
1270
1271         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1272                 break;
1273
1274         case CTDB_CONTROL_UPDATE_RECORD:
1275                 break;
1276
1277         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1278                 break;
1279
1280         case CTDB_CONTROL_TRANSACTION_START:
1281                 break;
1282
1283         case CTDB_CONTROL_TRANSACTION_COMMIT:
1284                 break;
1285
1286         case CTDB_CONTROL_WIPE_DATABASE:
1287                 break;
1288
1289         case CTDB_CONTROL_UPTIME:
1290                 cd->data.uptime = talloc(mem_ctx, struct ctdb_uptime);
1291                 assert(cd->data.uptime != NULL);
1292                 fill_ctdb_uptime(mem_ctx, cd->data.uptime);
1293                 break;
1294
1295         case CTDB_CONTROL_START_RECOVERY:
1296                 break;
1297
1298         case CTDB_CONTROL_END_RECOVERY:
1299                 break;
1300
1301         case CTDB_CONTROL_RELOAD_NODES_FILE:
1302                 break;
1303
1304         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1305                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1306                 assert(cd->data.recbuf != NULL);
1307                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1308                 break;
1309
1310         case CTDB_CONTROL_ENABLE_MONITOR:
1311                 break;
1312
1313         case CTDB_CONTROL_DISABLE_MONITOR:
1314                 break;
1315
1316         case CTDB_CONTROL_ADD_PUBLIC_IP:
1317                 break;
1318
1319         case CTDB_CONTROL_DEL_PUBLIC_IP:
1320                 break;
1321
1322         case CTDB_CONTROL_RUN_EVENTSCRIPTS:
1323                 break;
1324
1325         case CTDB_CONTROL_GET_CAPABILITIES:
1326                 cd->data.caps = rand32();
1327                 break;
1328
1329         case CTDB_CONTROL_START_PERSISTENT_UPDATE:
1330                 break;
1331
1332         case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
1333                 break;
1334
1335         case CTDB_CONTROL_RECD_PING:
1336                 break;
1337
1338         case CTDB_CONTROL_RELEASE_IP:
1339                 break;
1340
1341         case CTDB_CONTROL_TAKEOVER_IP:
1342                 break;
1343
1344         case CTDB_CONTROL_GET_PUBLIC_IPS:
1345                 cd->data.pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list);
1346                 assert(cd->data.pubip_list != NULL);
1347                 fill_ctdb_public_ip_list(mem_ctx, cd->data.pubip_list);
1348                 break;
1349
1350         case CTDB_CONTROL_GET_NODEMAP:
1351                 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
1352                 assert(cd->data.nodemap != NULL);
1353                 fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
1354                 break;
1355
1356         case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
1357                 cd->data.script_list = talloc(mem_ctx, struct ctdb_script_list);
1358                 assert(cd->data.script_list != NULL);
1359                 fill_ctdb_script_list(mem_ctx, cd->data.script_list);
1360                 break;
1361
1362         case CTDB_CONTROL_TRAVERSE_KILL:
1363                 break;
1364
1365         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1366                 break;
1367
1368         case CTDB_CONTROL_GET_RECLOCK_FILE:
1369                 fill_ctdb_string(mem_ctx, &cd->data.reclock_file);
1370                 assert(cd->data.reclock_file != NULL);
1371                 break;
1372
1373         case CTDB_CONTROL_STOP_NODE:
1374                 break;
1375
1376         case CTDB_CONTROL_CONTINUE_NODE:
1377                 break;
1378
1379         case CTDB_CONTROL_SET_LMASTERROLE:
1380                 break;
1381
1382         case CTDB_CONTROL_SET_RECMASTERROLE:
1383                 break;
1384
1385         case CTDB_CONTROL_ENABLE_SCRIPT:
1386                 break;
1387
1388         case CTDB_CONTROL_DISABLE_SCRIPT:
1389                 break;
1390
1391         case CTDB_CONTROL_SET_BAN_STATE:
1392                 break;
1393
1394         case CTDB_CONTROL_GET_BAN_STATE:
1395                 cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
1396                 assert(cd->data.ban_state != NULL);
1397                 fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
1398                 break;
1399
1400         case CTDB_CONTROL_SET_DB_PRIORITY:
1401                 break;
1402
1403         case CTDB_CONTROL_GET_DB_PRIORITY:
1404                 break;
1405
1406         case CTDB_CONTROL_TRANSACTION_CANCEL:
1407                 break;
1408
1409         case CTDB_CONTROL_REGISTER_NOTIFY:
1410                 break;
1411
1412         case CTDB_CONTROL_DEREGISTER_NOTIFY:
1413                 break;
1414
1415         case CTDB_CONTROL_TRANS3_COMMIT:
1416                 break;
1417
1418         case CTDB_CONTROL_GET_DB_SEQNUM:
1419                 cd->data.seqnum = rand64();
1420                 break;
1421
1422         case CTDB_CONTROL_DB_SET_HEALTHY:
1423                 break;
1424
1425         case CTDB_CONTROL_DB_GET_HEALTH:
1426                 fill_ctdb_string(mem_ctx, &cd->data.reason);
1427                 assert(cd->data.reason != NULL);
1428                 break;
1429
1430         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1431                 cd->data.ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info);
1432                 assert(cd->data.ipinfo != NULL);
1433                 fill_ctdb_public_ip_info(mem_ctx, cd->data.ipinfo);
1434                 break;
1435
1436         case CTDB_CONTROL_GET_IFACES:
1437                 cd->data.iface_list = talloc(mem_ctx, struct ctdb_iface_list);
1438                 assert(cd->data.iface_list != NULL);
1439                 fill_ctdb_iface_list(mem_ctx, cd->data.iface_list);
1440                 break;
1441
1442         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1443                 break;
1444
1445         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1446                 break;
1447
1448         case CTDB_CONTROL_GET_STAT_HISTORY:
1449                 cd->data.stats_list = talloc(mem_ctx, struct ctdb_statistics_list);
1450                 assert(cd->data.stats_list != NULL);
1451                 fill_ctdb_statistics_list(mem_ctx, cd->data.stats_list);
1452                 break;
1453
1454         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1455                 break;
1456
1457         case CTDB_CONTROL_SET_DB_READONLY:
1458                 break;
1459
1460         case CTDB_CONTROL_CHECK_SRVIDS:
1461                 cd->data.u8_array = talloc(mem_ctx, struct ctdb_uint8_array);
1462                 assert(cd->data.u8_array != NULL);
1463                 fill_ctdb_uint8_array(mem_ctx, cd->data.u8_array);
1464                 break;
1465
1466         case CTDB_CONTROL_TRAVERSE_START_EXT:
1467                 break;
1468
1469         case CTDB_CONTROL_GET_DB_STATISTICS:
1470                 cd->data.dbstats = talloc(mem_ctx, struct ctdb_db_statistics);
1471                 assert(cd->data.dbstats != NULL);
1472                 fill_ctdb_db_statistics(mem_ctx, cd->data.dbstats);
1473                 break;
1474
1475         case CTDB_CONTROL_SET_DB_STICKY:
1476                 break;
1477
1478         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1479                 break;
1480
1481         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1482                 break;
1483
1484         case CTDB_CONTROL_RECEIVE_RECORDS:
1485                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1486                 assert(cd->data.recbuf != NULL);
1487                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1488                 break;
1489
1490         case CTDB_CONTROL_IPREALLOCATED:
1491                 break;
1492
1493         case CTDB_CONTROL_GET_RUNSTATE:
1494                 cd->data.runstate = rand32();
1495                 break;
1496
1497         case CTDB_CONTROL_DB_DETACH:
1498                 break;
1499
1500         case CTDB_CONTROL_GET_NODES_FILE:
1501                 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
1502                 assert(cd->data.nodemap != NULL);
1503                 fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
1504                 break;
1505
1506         case CTDB_CONTROL_DB_PULL:
1507                 cd->data.num_records = rand32();
1508                 break;
1509
1510         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1511                 cd->data.num_records = rand32();
1512                 break;
1513
1514         }
1515 }
1516
1517 static void verify_ctdb_reply_control_data(struct ctdb_reply_control_data *cd,
1518                                            struct ctdb_reply_control_data *cd2)
1519 {
1520         assert(cd->opcode == cd2->opcode);
1521
1522         switch (cd->opcode) {
1523         case CTDB_CONTROL_PROCESS_EXISTS:
1524                 break;
1525
1526         case CTDB_CONTROL_STATISTICS:
1527                 verify_ctdb_statistics(cd->data.stats, cd2->data.stats);
1528                 break;
1529
1530         case CTDB_CONTROL_PING:
1531                 break;
1532
1533         case CTDB_CONTROL_GETDBPATH:
1534                 verify_ctdb_string(cd->data.db_path, cd2->data.db_path);
1535                 break;
1536
1537         case CTDB_CONTROL_GETVNNMAP:
1538                 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap);
1539                 break;
1540
1541         case CTDB_CONTROL_SETVNNMAP:
1542                 break;
1543
1544         case CTDB_CONTROL_GET_DEBUG:
1545                 assert(cd->data.loglevel == cd2->data.loglevel);
1546                 break;
1547
1548         case CTDB_CONTROL_SET_DEBUG:
1549                 break;
1550
1551         case CTDB_CONTROL_GET_DBMAP:
1552                 verify_ctdb_dbid_map(cd->data.dbmap, cd2->data.dbmap);
1553                 break;
1554
1555         case CTDB_CONTROL_PULL_DB:
1556                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1557                 break;
1558
1559         case CTDB_CONTROL_PUSH_DB:
1560                 break;
1561
1562         case CTDB_CONTROL_GET_RECMODE:
1563                 break;
1564
1565         case CTDB_CONTROL_SET_RECMODE:
1566                 break;
1567
1568         case CTDB_CONTROL_STATISTICS_RESET:
1569                 break;
1570
1571         case CTDB_CONTROL_DB_ATTACH:
1572                 assert(cd->data.db_id == cd2->data.db_id);
1573                 break;
1574
1575         case CTDB_CONTROL_SET_CALL:
1576                 break;
1577
1578         case CTDB_CONTROL_TRAVERSE_START:
1579                 break;
1580
1581         case CTDB_CONTROL_TRAVERSE_ALL:
1582                 break;
1583
1584         case CTDB_CONTROL_TRAVERSE_DATA:
1585                 break;
1586
1587         case CTDB_CONTROL_REGISTER_SRVID:
1588                 break;
1589
1590         case CTDB_CONTROL_DEREGISTER_SRVID:
1591                 break;
1592
1593         case CTDB_CONTROL_GET_DBNAME:
1594                 verify_ctdb_string(cd->data.db_name, cd2->data.db_name);
1595                 break;
1596
1597         case CTDB_CONTROL_ENABLE_SEQNUM:
1598                 break;
1599
1600         case CTDB_CONTROL_UPDATE_SEQNUM:
1601                 break;
1602
1603         case CTDB_CONTROL_DUMP_MEMORY:
1604                 verify_ctdb_string(cd->data.mem_str, cd2->data.mem_str);
1605                 break;
1606
1607         case CTDB_CONTROL_GET_PID:
1608                 break;
1609
1610         case CTDB_CONTROL_GET_RECMASTER:
1611                 break;
1612
1613         case CTDB_CONTROL_SET_RECMASTER:
1614                 break;
1615
1616         case CTDB_CONTROL_FREEZE:
1617                 break;
1618
1619         case CTDB_CONTROL_THAW:
1620                 break;
1621
1622         case CTDB_CONTROL_GET_PNN:
1623                 break;
1624
1625         case CTDB_CONTROL_SHUTDOWN:
1626                 break;
1627
1628         case CTDB_CONTROL_GET_MONMODE:
1629                 break;
1630
1631         case CTDB_CONTROL_TCP_CLIENT:
1632                 break;
1633
1634         case CTDB_CONTROL_TCP_ADD:
1635                 break;
1636
1637         case CTDB_CONTROL_TCP_REMOVE:
1638                 break;
1639
1640         case CTDB_CONTROL_STARTUP:
1641                 break;
1642
1643         case CTDB_CONTROL_SET_TUNABLE:
1644                 break;
1645
1646         case CTDB_CONTROL_GET_TUNABLE:
1647                 assert(cd->data.tun_value == cd2->data.tun_value);
1648                 break;
1649
1650         case CTDB_CONTROL_LIST_TUNABLES:
1651                 verify_ctdb_var_list(cd->data.tun_var_list,
1652                                      cd2->data.tun_var_list);
1653                 break;
1654
1655         case CTDB_CONTROL_MODIFY_FLAGS:
1656                 break;
1657
1658         case CTDB_CONTROL_GET_ALL_TUNABLES:
1659                 verify_ctdb_tunable_list(cd->data.tun_list, cd2->data.tun_list);
1660                 break;
1661
1662         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1663                 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles);
1664                 break;
1665
1666         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1667                 break;
1668
1669         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1670                 break;
1671
1672         case CTDB_CONTROL_UPDATE_RECORD:
1673                 break;
1674
1675         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1676                 break;
1677
1678         case CTDB_CONTROL_TRANSACTION_START:
1679                 break;
1680
1681         case CTDB_CONTROL_TRANSACTION_COMMIT:
1682                 break;
1683
1684         case CTDB_CONTROL_WIPE_DATABASE:
1685                 break;
1686
1687         case CTDB_CONTROL_UPTIME:
1688                 verify_ctdb_uptime(cd->data.uptime, cd2->data.uptime);
1689                 break;
1690
1691         case CTDB_CONTROL_START_RECOVERY:
1692                 break;
1693
1694         case CTDB_CONTROL_END_RECOVERY:
1695                 break;
1696
1697         case CTDB_CONTROL_RELOAD_NODES_FILE:
1698                 break;
1699
1700         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1701                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1702                 break;
1703
1704         case CTDB_CONTROL_ENABLE_MONITOR:
1705                 break;
1706
1707         case CTDB_CONTROL_DISABLE_MONITOR:
1708                 break;
1709
1710         case CTDB_CONTROL_ADD_PUBLIC_IP:
1711                 break;
1712
1713         case CTDB_CONTROL_DEL_PUBLIC_IP:
1714                 break;
1715
1716         case CTDB_CONTROL_RUN_EVENTSCRIPTS:
1717                 break;
1718
1719         case CTDB_CONTROL_GET_CAPABILITIES:
1720                 assert(cd->data.caps == cd2->data.caps);
1721                 break;
1722
1723         case CTDB_CONTROL_RECD_PING:
1724                 break;
1725
1726         case CTDB_CONTROL_RELEASE_IP:
1727                 break;
1728
1729         case CTDB_CONTROL_TAKEOVER_IP:
1730                 break;
1731
1732         case CTDB_CONTROL_GET_PUBLIC_IPS:
1733                 verify_ctdb_public_ip_list(cd->data.pubip_list,
1734                                            cd2->data.pubip_list);
1735                 break;
1736
1737         case CTDB_CONTROL_GET_NODEMAP:
1738                 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap);
1739                 break;
1740
1741         case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
1742                 verify_ctdb_script_list(cd->data.script_list,
1743                                         cd2->data.script_list);
1744                 break;
1745
1746         case CTDB_CONTROL_TRAVERSE_KILL:
1747                 break;
1748
1749         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1750                 break;
1751
1752         case CTDB_CONTROL_GET_RECLOCK_FILE:
1753                 verify_ctdb_string(cd->data.reclock_file,
1754                                    cd2->data.reclock_file);
1755                 break;
1756
1757         case CTDB_CONTROL_STOP_NODE:
1758                 break;
1759
1760         case CTDB_CONTROL_CONTINUE_NODE:
1761                 break;
1762
1763         case CTDB_CONTROL_SET_LMASTERROLE:
1764                 break;
1765
1766         case CTDB_CONTROL_SET_RECMASTERROLE:
1767                 break;
1768
1769         case CTDB_CONTROL_ENABLE_SCRIPT:
1770                 break;
1771
1772         case CTDB_CONTROL_DISABLE_SCRIPT:
1773                 break;
1774
1775         case CTDB_CONTROL_SET_BAN_STATE:
1776                 break;
1777
1778         case CTDB_CONTROL_GET_BAN_STATE:
1779                 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state);
1780                 break;
1781
1782         case CTDB_CONTROL_SET_DB_PRIORITY:
1783                 break;
1784
1785         case CTDB_CONTROL_GET_DB_PRIORITY:
1786                 break;
1787
1788         case CTDB_CONTROL_TRANSACTION_CANCEL:
1789                 break;
1790
1791         case CTDB_CONTROL_REGISTER_NOTIFY:
1792                 break;
1793
1794         case CTDB_CONTROL_DEREGISTER_NOTIFY:
1795                 break;
1796
1797         case CTDB_CONTROL_TRANS3_COMMIT:
1798                 break;
1799
1800         case CTDB_CONTROL_GET_DB_SEQNUM:
1801                 assert(cd->data.seqnum == cd2->data.seqnum);
1802                 break;
1803
1804         case CTDB_CONTROL_DB_SET_HEALTHY:
1805                 break;
1806
1807         case CTDB_CONTROL_DB_GET_HEALTH:
1808                 verify_ctdb_string(cd->data.reason, cd2->data.reason);
1809                 break;
1810
1811         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1812                 verify_ctdb_public_ip_info(cd->data.ipinfo, cd2->data.ipinfo);
1813                 break;
1814
1815         case CTDB_CONTROL_GET_IFACES:
1816                 verify_ctdb_iface_list(cd->data.iface_list,
1817                                        cd2->data.iface_list);
1818                 break;
1819
1820         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1821                 break;
1822
1823         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1824                 break;
1825
1826         case CTDB_CONTROL_GET_STAT_HISTORY:
1827                 verify_ctdb_statistics_list(cd->data.stats_list,
1828                                             cd2->data.stats_list);
1829                 break;
1830
1831         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1832                 break;
1833
1834         case CTDB_CONTROL_SET_DB_READONLY:
1835                 break;
1836
1837         case CTDB_CONTROL_CHECK_SRVIDS:
1838                 verify_ctdb_uint8_array(cd->data.u8_array, cd2->data.u8_array);
1839                 break;
1840
1841         case CTDB_CONTROL_TRAVERSE_START_EXT:
1842                 break;
1843
1844         case CTDB_CONTROL_GET_DB_STATISTICS:
1845                 verify_ctdb_db_statistics(cd->data.dbstats, cd2->data.dbstats);
1846                 break;
1847
1848         case CTDB_CONTROL_SET_DB_STICKY:
1849                 break;
1850
1851         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1852                 break;
1853
1854         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1855                 break;
1856
1857         case CTDB_CONTROL_RECEIVE_RECORDS:
1858                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1859                 break;
1860
1861         case CTDB_CONTROL_IPREALLOCATED:
1862                 break;
1863
1864         case CTDB_CONTROL_GET_RUNSTATE:
1865                 assert(cd->data.runstate == cd2->data.runstate);
1866                 break;
1867
1868         case CTDB_CONTROL_DB_DETACH:
1869                 break;
1870
1871         case CTDB_CONTROL_GET_NODES_FILE:
1872                 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap);
1873                 break;
1874
1875         case CTDB_CONTROL_DB_PULL:
1876                 assert(cd->data.num_records == cd2->data.num_records);
1877                 break;
1878
1879         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1880                 assert(cd->data.num_records == cd2->data.num_records);
1881                 break;
1882
1883         }
1884 }
1885
1886 static void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx,
1887                                     struct ctdb_reply_control *c,
1888                                     uint32_t opcode)
1889 {
1890         c->status = -rand_int(2);
1891         if (c->status == 0) {
1892                 c->errmsg = NULL;
1893                 fill_ctdb_reply_control_data(mem_ctx, &c->rdata, opcode);
1894         } else {
1895                 fill_ctdb_string(mem_ctx, &c->errmsg);
1896         }
1897 }
1898
1899 static void verify_ctdb_reply_control(struct ctdb_reply_control *c,
1900                                       struct ctdb_reply_control *c2)
1901 {
1902         assert(c->status == c2->status);
1903         verify_ctdb_string(c->errmsg, c2->errmsg);
1904         if (c->status == 0) {
1905                 verify_ctdb_reply_control_data(&c->rdata, &c2->rdata);
1906         }
1907 }
1908
1909 static void fill_ctdb_req_message_data(TALLOC_CTX *mem_ctx,
1910                                        struct ctdb_req_message_data *c)
1911 {
1912         c->srvid = rand64();
1913         fill_tdb_data(mem_ctx, &c->data);
1914 }
1915
1916 static void verify_ctdb_req_message_data(struct ctdb_req_message_data *c,
1917                                          struct ctdb_req_message_data *c2)
1918 {
1919         assert(c->srvid == c2->srvid);
1920         verify_tdb_data(&c->data, &c2->data);
1921 }
1922
1923 /*
1924  * Functions to test marshalling
1925  */
1926
1927 static void test_ctdb_req_header(void)
1928 {
1929         TALLOC_CTX *mem_ctx;
1930         uint8_t *pkt;
1931         size_t pkt_len;
1932         struct ctdb_req_header h, h2;
1933         int ret;
1934
1935         printf("ctdb_req_header\n");
1936         fflush(stdout);
1937
1938         mem_ctx = talloc_new(NULL);
1939         assert(mem_ctx != NULL);
1940
1941         ctdb_req_header_fill(&h, GENERATION, OPERATION, DESTNODE, SRCNODE,
1942                              REQID);
1943
1944         ret = ctdb_allocate_pkt(mem_ctx, ctdb_req_header_len(&h),
1945                                 &pkt, &pkt_len);
1946         assert(ret == 0);
1947         assert(pkt != NULL);
1948         assert(pkt_len >= ctdb_req_header_len(&h));
1949
1950         ctdb_req_header_push(&h, pkt);
1951
1952         ret = ctdb_req_header_pull(pkt, pkt_len, &h2);
1953         assert(ret == 0);
1954
1955         verify_ctdb_req_header(&h, &h2);
1956
1957         talloc_free(mem_ctx);
1958 }
1959
1960 static void test_req_call_test(void)
1961 {
1962         TALLOC_CTX *mem_ctx;
1963         uint8_t *pkt;
1964         size_t datalen, pkt_len, len;
1965         int ret;
1966         struct ctdb_req_header h, h2;
1967         struct ctdb_req_call c, c2;
1968
1969         printf("ctdb_req_call\n");
1970         fflush(stdout);
1971
1972         mem_ctx = talloc_new(NULL);
1973         assert(mem_ctx != NULL);
1974
1975         ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CALL,
1976                              DESTNODE, SRCNODE, REQID);
1977
1978         fill_ctdb_req_call(mem_ctx, &c);
1979         datalen = ctdb_req_call_len(&h, &c);
1980         ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
1981         assert(ret == 0);
1982         assert(pkt != NULL);
1983         assert(pkt_len >= datalen);
1984         len = 0;
1985         ret = ctdb_req_call_push(&h, &c, pkt, &len);
1986         assert(ret == EMSGSIZE);
1987         assert(len == datalen);
1988         ret = ctdb_req_call_push(&h, &c, pkt, &pkt_len);
1989         assert(ret == 0);
1990         ret = ctdb_req_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
1991         assert(ret == 0);
1992         verify_ctdb_req_header(&h, &h2);
1993         assert(h2.length == pkt_len);
1994         verify_ctdb_req_call(&c, &c2);
1995
1996         talloc_free(mem_ctx);
1997 }
1998
1999 static void test_reply_call_test(void)
2000 {
2001         TALLOC_CTX *mem_ctx;
2002         uint8_t *pkt;
2003         size_t datalen, pkt_len, len;
2004         int ret;
2005         struct ctdb_req_header h, h2;
2006         struct ctdb_reply_call c, c2;
2007
2008         printf("ctdb_reply_call\n");
2009         fflush(stdout);
2010
2011         mem_ctx = talloc_new(NULL);
2012         assert(mem_ctx != NULL);
2013
2014         ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CALL,
2015                              DESTNODE, SRCNODE, REQID);
2016
2017         fill_ctdb_reply_call(mem_ctx, &c);
2018         datalen = ctdb_reply_call_len(&h, &c);
2019         ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2020         assert(ret == 0);
2021         assert(pkt != NULL);
2022         assert(pkt_len >= datalen);
2023         len = 0;
2024         ret = ctdb_reply_call_push(&h, &c, pkt, &len);
2025         assert(ret == EMSGSIZE);
2026         assert(len == datalen);
2027         ret = ctdb_reply_call_push(&h, &c, pkt, &pkt_len);
2028         assert(ret == 0);
2029         ret = ctdb_reply_call_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2030         assert(ret == 0);
2031         verify_ctdb_req_header(&h, &h2);
2032         assert(h2.length == pkt_len);
2033         verify_ctdb_reply_call(&c, &c2);
2034
2035         talloc_free(mem_ctx);
2036 }
2037
2038 static void test_reply_error_test(void)
2039 {
2040         TALLOC_CTX *mem_ctx;
2041         uint8_t *pkt;
2042         size_t datalen, pkt_len, len;
2043         int ret;
2044         struct ctdb_req_header h, h2;
2045         struct ctdb_reply_error c, c2;
2046
2047         printf("ctdb_reply_error\n");
2048         fflush(stdout);
2049
2050         mem_ctx = talloc_new(NULL);
2051         assert(mem_ctx != NULL);
2052
2053         ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_ERROR,
2054                              DESTNODE, SRCNODE, REQID);
2055
2056         fill_ctdb_reply_error(mem_ctx, &c);
2057         datalen = ctdb_reply_error_len(&h, &c);
2058         ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2059         assert(ret == 0);
2060         assert(pkt != NULL);
2061         assert(pkt_len >= datalen);
2062         len = 0;
2063         ret = ctdb_reply_error_push(&h, &c, pkt, &len);
2064         assert(ret == EMSGSIZE);
2065         assert(len == datalen);
2066         ret = ctdb_reply_error_push(&h, &c, pkt, &pkt_len);
2067         assert(ret == 0);
2068         ret = ctdb_reply_error_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2069         assert(ret == 0);
2070         verify_ctdb_req_header(&h, &h2);
2071         assert(h2.length == pkt_len);
2072         verify_ctdb_reply_error(&c, &c2);
2073
2074         talloc_free(mem_ctx);
2075 }
2076
2077 static void test_req_dmaster_test(void)
2078 {
2079         TALLOC_CTX *mem_ctx;
2080         uint8_t *pkt;
2081         size_t datalen, pkt_len, len;
2082         int ret;
2083         struct ctdb_req_header h, h2;
2084         struct ctdb_req_dmaster c, c2;
2085
2086         printf("ctdb_req_dmaster\n");
2087         fflush(stdout);
2088
2089         mem_ctx = talloc_new(NULL);
2090         assert(mem_ctx != NULL);
2091
2092         ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_DMASTER,
2093                              DESTNODE, SRCNODE, REQID);
2094
2095         fill_ctdb_req_dmaster(mem_ctx, &c);
2096         datalen = ctdb_req_dmaster_len(&h, &c);
2097         ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2098         assert(ret == 0);
2099         assert(pkt != NULL);
2100         assert(pkt_len >= datalen);
2101         len = 0;
2102         ret = ctdb_req_dmaster_push(&h, &c, pkt, &len);
2103         assert(ret == EMSGSIZE);
2104         assert(len == datalen);
2105         ret = ctdb_req_dmaster_push(&h, &c, pkt, &pkt_len);
2106         assert(ret == 0);
2107         ret = ctdb_req_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2108         assert(ret == 0);
2109         verify_ctdb_req_header(&h, &h2);
2110         assert(h2.length == pkt_len);
2111         verify_ctdb_req_dmaster(&c, &c2);
2112
2113         talloc_free(mem_ctx);
2114 }
2115
2116 static void test_reply_dmaster_test(void)
2117 {
2118         TALLOC_CTX *mem_ctx;
2119         uint8_t *pkt;
2120         size_t datalen, pkt_len, len;
2121         int ret;
2122         struct ctdb_req_header h, h2;
2123         struct ctdb_reply_dmaster c, c2;
2124
2125         printf("ctdb_reply_dmaster\n");
2126         fflush(stdout);
2127
2128         mem_ctx = talloc_new(NULL);
2129         assert(mem_ctx != NULL);
2130
2131         ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_DMASTER,
2132                              DESTNODE, SRCNODE, REQID);
2133
2134         fill_ctdb_reply_dmaster(mem_ctx, &c);
2135         datalen = ctdb_reply_dmaster_len(&h, &c);
2136         ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2137         assert(ret == 0);
2138         assert(pkt != NULL);
2139         assert(pkt_len >= datalen);
2140         len = 0;
2141         ret = ctdb_reply_dmaster_push(&h, &c, pkt, &len);
2142         assert(ret == EMSGSIZE);
2143         assert(len == datalen);
2144         ret = ctdb_reply_dmaster_push(&h, &c, pkt, &pkt_len);
2145         assert(ret == 0);
2146         ret = ctdb_reply_dmaster_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2147         assert(ret == 0);
2148         verify_ctdb_req_header(&h, &h2);
2149         assert(h2.length == pkt_len);
2150         verify_ctdb_reply_dmaster(&c, &c2);
2151
2152         talloc_free(mem_ctx);
2153 }
2154
2155 #define NUM_CONTROLS    149
2156
2157 static void test_req_control_data_test(void)
2158 {
2159         TALLOC_CTX *mem_ctx;
2160         size_t buflen;
2161         int ret;
2162         struct ctdb_req_control_data cd, cd2;
2163         uint32_t opcode;
2164
2165         printf("ctdb_req_control_data\n");
2166         fflush(stdout);
2167
2168         for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2169                 mem_ctx = talloc_new(NULL);
2170                 assert(mem_ctx != NULL);
2171
2172                 printf("%u.. ", opcode);
2173                 fflush(stdout);
2174                 fill_ctdb_req_control_data(mem_ctx, &cd, opcode);
2175                 buflen = ctdb_req_control_data_len(&cd);
2176                 ctdb_req_control_data_push(&cd, BUFFER);
2177                 ret = ctdb_req_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
2178                 assert(ret == 0);
2179                 verify_ctdb_req_control_data(&cd, &cd2);
2180                 talloc_free(mem_ctx);
2181         }
2182
2183         printf("\n");
2184         fflush(stdout);
2185 }
2186
2187 static void test_reply_control_data_test(void)
2188 {
2189         TALLOC_CTX *mem_ctx;
2190         size_t buflen;
2191         int ret;
2192         struct ctdb_reply_control_data cd, cd2;
2193         uint32_t opcode;
2194
2195         printf("ctdb_reply_control_data\n");
2196         fflush(stdout);
2197
2198         for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2199                 mem_ctx = talloc_new(NULL);
2200                 assert(mem_ctx != NULL);
2201
2202                 printf("%u.. ", opcode);
2203                 fflush(stdout);
2204                 fill_ctdb_reply_control_data(mem_ctx, &cd, opcode);
2205                 buflen = ctdb_reply_control_data_len(&cd);
2206                 ctdb_reply_control_data_push(&cd, BUFFER);
2207                 ret = ctdb_reply_control_data_pull(BUFFER, buflen, opcode, mem_ctx, &cd2);
2208                 assert(ret == 0);
2209                 verify_ctdb_reply_control_data(&cd, &cd2);
2210                 talloc_free(mem_ctx);
2211         }
2212
2213         printf("\n");
2214         fflush(stdout);
2215 }
2216
2217 static void test_req_control_test(void)
2218 {
2219         TALLOC_CTX *mem_ctx;
2220         uint8_t *pkt;
2221         size_t datalen, pkt_len, len;
2222         int ret;
2223         struct ctdb_req_header h, h2;
2224         struct ctdb_req_control c, c2;
2225         uint32_t opcode;
2226
2227         printf("ctdb_req_control\n");
2228         fflush(stdout);
2229
2230         ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_CONTROL,
2231                              DESTNODE, SRCNODE, REQID);
2232
2233         for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2234                 mem_ctx = talloc_new(NULL);
2235                 assert(mem_ctx != NULL);
2236
2237                 printf("%u.. ", opcode);
2238                 fflush(stdout);
2239                 fill_ctdb_req_control(mem_ctx, &c, opcode);
2240                 datalen = ctdb_req_control_len(&h, &c);
2241                 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2242                 assert(ret == 0);
2243                 assert(pkt != NULL);
2244                 assert(pkt_len >= datalen);
2245                 len = 0;
2246                 ret = ctdb_req_control_push(&h, &c, pkt, &len);
2247                 assert(ret == EMSGSIZE);
2248                 assert(len == datalen);
2249                 ret = ctdb_req_control_push(&h, &c, pkt, &pkt_len);
2250                 assert(ret == 0);
2251                 ret = ctdb_req_control_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2252                 assert(ret == 0);
2253                 verify_ctdb_req_header(&h, &h2);
2254                 assert(h2.length == pkt_len);
2255                 verify_ctdb_req_control(&c, &c2);
2256
2257                 talloc_free(mem_ctx);
2258         }
2259
2260         printf("\n");
2261         fflush(stdout);
2262 }
2263
2264 static void test_reply_control_test(void)
2265 {
2266         TALLOC_CTX *mem_ctx;
2267         uint8_t *pkt;
2268         size_t datalen, pkt_len, len;
2269         int ret;
2270         struct ctdb_req_header h, h2;
2271         struct ctdb_reply_control c, c2;
2272         uint32_t opcode;
2273
2274         printf("ctdb_reply_control\n");
2275         fflush(stdout);
2276
2277         ctdb_req_header_fill(&h, GENERATION, CTDB_REPLY_CONTROL,
2278                              DESTNODE, SRCNODE, REQID);
2279
2280         for (opcode=0; opcode<NUM_CONTROLS; opcode++) {
2281                 mem_ctx = talloc_new(NULL);
2282                 assert(mem_ctx != NULL);
2283
2284                 printf("%u.. ", opcode);
2285                 fflush(stdout);
2286                 fill_ctdb_reply_control(mem_ctx, &c, opcode);
2287                 datalen = ctdb_reply_control_len(&h, &c);
2288                 ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2289                 assert(ret == 0);
2290                 assert(pkt != NULL);
2291                 assert(pkt_len >= datalen);
2292                 len = 0;
2293                 ret = ctdb_reply_control_push(&h, &c, pkt, &len);
2294                 assert(ret == EMSGSIZE);
2295                 assert(len == datalen);
2296                 ret = ctdb_reply_control_push(&h, &c, pkt, &pkt_len);
2297                 assert(ret == 0);
2298                 ret = ctdb_reply_control_pull(pkt, pkt_len, opcode, &h2, mem_ctx, &c2);
2299                 assert(ret == 0);
2300                 verify_ctdb_req_header(&h, &h2);
2301                 assert(h2.length == pkt_len);
2302                 verify_ctdb_reply_control(&c, &c2);
2303
2304                 talloc_free(mem_ctx);
2305         }
2306
2307         printf("\n");
2308         fflush(stdout);
2309 }
2310
2311 static void test_req_message_test(void)
2312 {
2313         TALLOC_CTX *mem_ctx;
2314         uint8_t *pkt;
2315         size_t datalen, pkt_len, len;
2316         int ret;
2317         struct ctdb_req_header h, h2;
2318         struct ctdb_req_message_data c, c2;
2319
2320         printf("ctdb_req_message\n");
2321         fflush(stdout);
2322
2323         mem_ctx = talloc_new(NULL);
2324         assert(mem_ctx != NULL);
2325
2326         ctdb_req_header_fill(&h, GENERATION, CTDB_REQ_MESSAGE,
2327                              DESTNODE, SRCNODE, REQID);
2328
2329         fill_ctdb_req_message_data(mem_ctx, &c);
2330         datalen = ctdb_req_message_data_len(&h, &c);
2331         ret = ctdb_allocate_pkt(mem_ctx, datalen, &pkt, &pkt_len);
2332         assert(ret == 0);
2333         assert(pkt != NULL);
2334         assert(pkt_len >= datalen);
2335         len = 0;
2336         ret = ctdb_req_message_data_push(&h, &c, pkt, &len);
2337         assert(ret == EMSGSIZE);
2338         assert(len == datalen);
2339         ret = ctdb_req_message_data_push(&h, &c, pkt, &pkt_len);
2340         assert(ret == 0);
2341         ret = ctdb_req_message_data_pull(pkt, pkt_len, &h2, mem_ctx, &c2);
2342         assert(ret == 0);
2343         verify_ctdb_req_header(&h, &h2);
2344         assert(h2.length == pkt_len);
2345         verify_ctdb_req_message_data(&c, &c2);
2346
2347         talloc_free(mem_ctx);
2348 }
2349
2350 int main(int argc, char *argv[])
2351 {
2352         if (argc == 2) {
2353                 int seed = atoi(argv[1]);
2354                 srandom(seed);
2355         }
2356
2357         test_ctdb_req_header();
2358
2359         test_req_call_test();
2360         test_reply_call_test();
2361         test_reply_error_test();
2362         test_req_dmaster_test();
2363         test_reply_dmaster_test();
2364
2365         test_req_control_data_test();
2366         test_reply_control_data_test();
2367
2368         test_req_control_test();
2369         test_reply_control_test();
2370
2371         test_req_message_test();
2372
2373         return 0;
2374 }