ctdb/tests/src/protocol_common_ctdb.c

   1 /*
   2    protocol tests - ctdb protocol
   3
   4    Copyright (C) Amitay Isaacs  2017
   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 #include "tests/src/protocol_common.h"
  26 #include "tests/src/protocol_common_ctdb.h"
  27
  28 /*
  29  * Functions to fill and verify protocol structures
  30  */
  31
  32 void fill_ctdb_req_header(struct ctdb_req_header *h)
  33 {
  34         h->length = rand32();
  35         h->ctdb_magic = rand32();
  36         h->ctdb_version = rand32();
  37         h->generation = rand32();
  38         h->operation = rand32();
  39         h->destnode = rand32();
  40         h->srcnode = rand32();
  41         h->reqid = rand32();
  42 }
  43
  44 void verify_ctdb_req_header(struct ctdb_req_header *h,
  45                             struct ctdb_req_header *h2)
  46 {
  47         assert(h->length == h2->length);
  48         assert(h->ctdb_magic == h2->ctdb_magic);
  49         assert(h->ctdb_version == h2->ctdb_version);
  50         assert(h->generation == h2->generation);
  51         assert(h->operation == h2->operation);
  52         assert(h->destnode == h2->destnode);
  53         assert(h->srcnode == h2->srcnode);
  54         assert(h->reqid == h2->reqid);
  55 }
  56
  57 void fill_ctdb_req_call(TALLOC_CTX *mem_ctx, struct ctdb_req_call *c)
  58 {
  59         c->flags = rand32();
  60         c->db_id = rand32();
  61         c->callid = rand32();
  62         c->hopcount = rand32();
  63         fill_tdb_data_nonnull(mem_ctx, &c->key);
  64         fill_tdb_data(mem_ctx, &c->calldata);
  65 }
  66
  67 void verify_ctdb_req_call(struct ctdb_req_call *c, struct ctdb_req_call *c2)
  68 {
  69         assert(c->flags == c2->flags);
  70         assert(c->db_id == c2->db_id);
  71         assert(c->callid == c2->callid);
  72         assert(c->hopcount == c2->hopcount);
  73         verify_tdb_data(&c->key, &c2->key);
  74         verify_tdb_data(&c->calldata, &c2->calldata);
  75 }
  76
  77 void fill_ctdb_reply_call(TALLOC_CTX *mem_ctx, struct ctdb_reply_call *c)
  78 {
  79         c->status = rand32();
  80         fill_tdb_data(mem_ctx, &c->data);
  81 }
  82
  83 void verify_ctdb_reply_call(struct ctdb_reply_call *c,
  84                             struct ctdb_reply_call *c2)
  85 {
  86         assert(c->status == c2->status);
  87         verify_tdb_data(&c->data, &c2->data);
  88 }
  89
  90 void fill_ctdb_reply_error(TALLOC_CTX *mem_ctx, struct ctdb_reply_error *c)
  91 {
  92         c->status = rand32();
  93         fill_tdb_data(mem_ctx, &c->msg);
  94 }
  95
  96 void verify_ctdb_reply_error(struct ctdb_reply_error *c,
  97                              struct ctdb_reply_error *c2)
  98 {
  99         assert(c->status == c2->status);
 100         verify_tdb_data(&c->msg, &c2->msg);
 101 }
 102
 103 void fill_ctdb_req_dmaster(TALLOC_CTX *mem_ctx, struct ctdb_req_dmaster *c)
 104 {
 105         c->db_id = rand32();
 106         c->rsn = rand64();
 107         c->dmaster = rand32();
 108         fill_tdb_data_nonnull(mem_ctx, &c->key);
 109         fill_tdb_data(mem_ctx, &c->data);
 110 }
 111
 112 void verify_ctdb_req_dmaster(struct ctdb_req_dmaster *c,
 113                              struct ctdb_req_dmaster *c2)
 114 {
 115         assert(c->db_id == c2->db_id);
 116         assert(c->rsn == c2->rsn);
 117         assert(c->dmaster == c2->dmaster);
 118         verify_tdb_data(&c->key, &c2->key);
 119         verify_tdb_data(&c->data, &c2->data);
 120 }
 121
 122 void fill_ctdb_reply_dmaster(TALLOC_CTX *mem_ctx,
 123                              struct ctdb_reply_dmaster *c)
 124 {
 125         c->db_id = rand32();
 126         c->rsn = rand64();
 127         fill_tdb_data_nonnull(mem_ctx, &c->key);
 128         fill_tdb_data(mem_ctx, &c->data);
 129 }
 130
 131 void verify_ctdb_reply_dmaster(struct ctdb_reply_dmaster *c,
 132                                struct ctdb_reply_dmaster *c2)
 133 {
 134         assert(c->db_id == c2->db_id);
 135         assert(c->rsn == c2->rsn);
 136         verify_tdb_data(&c->key, &c2->key);
 137         verify_tdb_data(&c->data, &c2->data);
 138 }
 139
 140 void fill_ctdb_req_control_data(TALLOC_CTX *mem_ctx,
 141                                 struct ctdb_req_control_data *cd,
 142                                 uint32_t opcode)
 143 {
 144         cd->opcode = opcode;
 145         switch (opcode) {
 146         case CTDB_CONTROL_PROCESS_EXISTS:
 147                 cd->data.pid = rand32();
 148                 break;
 149
 150         case CTDB_CONTROL_STATISTICS:
 151                 break;
 152
 153         case CTDB_CONTROL_PING:
 154                 break;
 155
 156         case CTDB_CONTROL_GETDBPATH:
 157                 cd->data.db_id = rand32();
 158                 break;
 159
 160         case CTDB_CONTROL_GETVNNMAP:
 161                 break;
 162
 163         case CTDB_CONTROL_SETVNNMAP:
 164                 cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
 165                 assert(cd->data.vnnmap != NULL);
 166                 fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
 167                 break;
 168
 169         case CTDB_CONTROL_GET_DEBUG:
 170                 break;
 171
 172         case CTDB_CONTROL_SET_DEBUG:
 173                 cd->data.loglevel = rand_int(5);
 174                 break;
 175
 176         case CTDB_CONTROL_GET_DBMAP:
 177                 break;
 178
 179         case CTDB_CONTROL_GET_RECMODE:
 180                 break;
 181
 182         case CTDB_CONTROL_SET_RECMODE:
 183                 cd->data.recmode = rand_int(2);
 184                 break;
 185
 186         case CTDB_CONTROL_STATISTICS_RESET:
 187                 break;
 188
 189         case CTDB_CONTROL_DB_ATTACH:
 190                 fill_ctdb_string(mem_ctx, &cd->data.db_name);
 191                 assert(cd->data.db_name != NULL);
 192                 break;
 193
 194         case CTDB_CONTROL_TRAVERSE_START:
 195                 cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
 196                 assert(cd->data.traverse_start != NULL);
 197                 fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
 198                 break;
 199
 200         case CTDB_CONTROL_TRAVERSE_ALL:
 201                 cd->data.traverse_all = talloc(mem_ctx, struct ctdb_traverse_all);
 202                 assert(cd->data.traverse_all != NULL);
 203                 fill_ctdb_traverse_all(mem_ctx, cd->data.traverse_all);
 204                 break;
 205
 206         case CTDB_CONTROL_TRAVERSE_DATA:
 207                 cd->data.rec_data = talloc(mem_ctx, struct ctdb_rec_data);
 208                 assert(cd->data.rec_data != NULL);
 209                 fill_ctdb_rec_data(mem_ctx, cd->data.rec_data);
 210                 break;
 211
 212         case CTDB_CONTROL_REGISTER_SRVID:
 213                 break;
 214
 215         case CTDB_CONTROL_DEREGISTER_SRVID:
 216                 break;
 217
 218         case CTDB_CONTROL_GET_DBNAME:
 219                 cd->data.db_id = rand32();
 220                 break;
 221
 222         case CTDB_CONTROL_ENABLE_SEQNUM:
 223                 cd->data.db_id = rand32();
 224                 break;
 225
 226         case CTDB_CONTROL_UPDATE_SEQNUM:
 227                 cd->data.db_id = rand32();
 228                 break;
 229
 230         case CTDB_CONTROL_DUMP_MEMORY:
 231                 break;
 232
 233         case CTDB_CONTROL_GET_PID:
 234                 break;
 235
 236         case CTDB_CONTROL_FREEZE:
 237                 break;
 238
 239         case CTDB_CONTROL_GET_PNN:
 240                 break;
 241
 242         case CTDB_CONTROL_SHUTDOWN:
 243                 break;
 244
 245         case CTDB_CONTROL_TCP_CLIENT:
 246                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 247                 assert(cd->data.conn != NULL);
 248                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 249                 break;
 250
 251         case CTDB_CONTROL_TCP_ADD:
 252                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 253                 assert(cd->data.conn != NULL);
 254                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 255                 break;
 256
 257         case CTDB_CONTROL_TCP_REMOVE:
 258                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 259                 assert(cd->data.conn != NULL);
 260                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 261                 break;
 262
 263         case CTDB_CONTROL_STARTUP:
 264                 break;
 265
 266         case CTDB_CONTROL_SET_TUNABLE:
 267                 cd->data.tunable = talloc(mem_ctx, struct ctdb_tunable);
 268                 assert(cd->data.tunable != NULL);
 269                 fill_ctdb_tunable(mem_ctx, cd->data.tunable);
 270                 break;
 271
 272         case CTDB_CONTROL_GET_TUNABLE:
 273                 fill_ctdb_string(mem_ctx, &cd->data.tun_var);
 274                 assert(cd->data.tun_var != NULL);
 275                 break;
 276
 277         case CTDB_CONTROL_LIST_TUNABLES:
 278                 break;
 279
 280         case CTDB_CONTROL_MODIFY_FLAGS:
 281                 cd->data.flag_change = talloc(mem_ctx, struct ctdb_node_flag_change);
 282                 assert(cd->data.flag_change != NULL);
 283                 fill_ctdb_node_flag_change(mem_ctx, cd->data.flag_change);
 284                 break;
 285
 286         case CTDB_CONTROL_GET_ALL_TUNABLES:
 287                 break;
 288
 289         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 290                 cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
 291                 assert(cd->data.addr != NULL);
 292                 fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
 293                 break;
 294
 295         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 296                 cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
 297                 assert(cd->data.tickles != NULL);
 298                 fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
 299                 break;
 300
 301         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 302                 fill_ctdb_string(mem_ctx, &cd->data.db_name);
 303                 assert(cd->data.db_name != NULL);
 304                 break;
 305
 306         case CTDB_CONTROL_UPDATE_RECORD:
 307                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
 308                 assert(cd->data.recbuf != NULL);
 309                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
 310                 break;
 311
 312         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 313                 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
 314                 assert(cd->data.addr_info != NULL);
 315                 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
 316                 break;
 317
 318         case CTDB_CONTROL_WIPE_DATABASE:
 319                 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
 320                 assert(cd->data.transdb != NULL);
 321                 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
 322                 break;
 323
 324         case CTDB_CONTROL_UPTIME:
 325                 break;
 326
 327         case CTDB_CONTROL_START_RECOVERY:
 328                 break;
 329
 330         case CTDB_CONTROL_END_RECOVERY:
 331                 break;
 332
 333         case CTDB_CONTROL_RELOAD_NODES_FILE:
 334                 break;
 335
 336         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 337                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
 338                 assert(cd->data.recbuf != NULL);
 339                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
 340                 break;
 341
 342         case CTDB_CONTROL_ADD_PUBLIC_IP:
 343                 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
 344                 assert(cd->data.addr_info != NULL);
 345                 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
 346                 break;
 347
 348         case CTDB_CONTROL_DEL_PUBLIC_IP:
 349                 cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
 350                 assert(cd->data.addr_info != NULL);
 351                 fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
 352                 break;
 353
 354         case CTDB_CONTROL_GET_CAPABILITIES:
 355                 break;
 356
 357         case CTDB_CONTROL_RECD_PING:
 358                 break;
 359
 360         case CTDB_CONTROL_RELEASE_IP:
 361                 cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
 362                 assert(cd->data.pubip != NULL);
 363                 fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
 364                 break;
 365
 366         case CTDB_CONTROL_TAKEOVER_IP:
 367                 cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
 368                 assert(cd->data.pubip != NULL);
 369                 fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
 370                 break;
 371
 372         case CTDB_CONTROL_GET_PUBLIC_IPS:
 373                 break;
 374
 375         case CTDB_CONTROL_GET_NODEMAP:
 376                 break;
 377
 378         case CTDB_CONTROL_TRAVERSE_KILL:
 379                 cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
 380                 assert(cd->data.traverse_start != NULL);
 381                 fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
 382                 break;
 383
 384         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 385                 cd->data.reclock_latency = rand_double();
 386                 break;
 387
 388         case CTDB_CONTROL_GET_RECLOCK_FILE:
 389                 break;
 390
 391         case CTDB_CONTROL_STOP_NODE:
 392                 break;
 393
 394         case CTDB_CONTROL_CONTINUE_NODE:
 395                 break;
 396
 397         case CTDB_CONTROL_SET_LMASTERROLE:
 398                 cd->data.role = rand_int(2);
 399                 break;
 400
 401         case CTDB_CONTROL_SET_RECMASTERROLE:
 402                 cd->data.role = rand_int(2);
 403                 break;
 404
 405         case CTDB_CONTROL_SET_BAN_STATE:
 406                 cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
 407                 assert(cd->data.ban_state != NULL);
 408                 fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
 409                 break;
 410
 411         case CTDB_CONTROL_GET_BAN_STATE:
 412                 break;
 413
 414         case CTDB_CONTROL_REGISTER_NOTIFY:
 415                 cd->data.notify = talloc(mem_ctx, struct ctdb_notify_data);
 416                 assert(cd->data.notify != NULL);
 417                 fill_ctdb_notify_data(mem_ctx, cd->data.notify);
 418                 break;
 419
 420         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 421                 cd->data.srvid = rand64();
 422                 break;
 423
 424         case CTDB_CONTROL_TRANS3_COMMIT:
 425                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
 426                 assert(cd->data.recbuf != NULL);
 427                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
 428                 break;
 429
 430         case CTDB_CONTROL_GET_DB_SEQNUM:
 431                 cd->data.db_id = rand32();
 432                 break;
 433
 434         case CTDB_CONTROL_DB_SET_HEALTHY:
 435                 cd->data.db_id = rand32();
 436                 break;
 437
 438         case CTDB_CONTROL_DB_GET_HEALTH:
 439                 cd->data.db_id = rand32();
 440                 break;
 441
 442         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 443                 cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
 444                 assert(cd->data.addr != NULL);
 445                 fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
 446                 break;
 447
 448         case CTDB_CONTROL_GET_IFACES:
 449                 break;
 450
 451         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 452                 cd->data.iface = talloc(mem_ctx, struct ctdb_iface);
 453                 assert(cd->data.iface != NULL);
 454                 fill_ctdb_iface(mem_ctx, cd->data.iface);
 455                 break;
 456
 457         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 458                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 459                 assert(cd->data.conn != NULL);
 460                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 461                 break;
 462
 463         case CTDB_CONTROL_GET_STAT_HISTORY:
 464                 break;
 465
 466         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 467                 cd->data.key = talloc(mem_ctx, struct ctdb_key_data);
 468                 assert(cd->data.key != NULL);
 469                 fill_ctdb_key_data(mem_ctx, cd->data.key);
 470                 break;
 471
 472         case CTDB_CONTROL_SET_DB_READONLY:
 473                 cd->data.db_id = rand32();
 474                 break;
 475
 476         case CTDB_CONTROL_TRAVERSE_START_EXT:
 477                 cd->data.traverse_start_ext = talloc(mem_ctx, struct ctdb_traverse_start_ext);
 478                 assert(cd->data.traverse_start_ext != NULL);
 479                 fill_ctdb_traverse_start_ext(mem_ctx, cd->data.traverse_start_ext);
 480                 break;
 481
 482         case CTDB_CONTROL_GET_DB_STATISTICS:
 483                 cd->data.db_id = rand32();
 484                 break;
 485
 486         case CTDB_CONTROL_SET_DB_STICKY:
 487                 cd->data.db_id = rand32();
 488                 break;
 489
 490         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
 491                 break;
 492
 493         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 494                 cd->data.traverse_all_ext = talloc(mem_ctx, struct ctdb_traverse_all_ext);
 495                 assert(cd->data.traverse_all_ext != NULL);
 496                 fill_ctdb_traverse_all_ext(mem_ctx, cd->data.traverse_all_ext);
 497                 break;
 498
 499         case CTDB_CONTROL_IPREALLOCATED:
 500                 break;
 501
 502         case CTDB_CONTROL_GET_RUNSTATE:
 503                 break;
 504
 505         case CTDB_CONTROL_DB_DETACH:
 506                 cd->data.db_id = rand32();
 507                 break;
 508
 509         case CTDB_CONTROL_GET_NODES_FILE:
 510                 break;
 511
 512         case CTDB_CONTROL_DB_FREEZE:
 513                 cd->data.db_id = rand32();
 514                 break;
 515
 516         case CTDB_CONTROL_DB_THAW:
 517                 cd->data.db_id = rand32();
 518                 break;
 519
 520         case CTDB_CONTROL_DB_TRANSACTION_START:
 521                 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
 522                 assert(cd->data.transdb != NULL);
 523                 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
 524                 break;
 525
 526         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
 527                 cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
 528                 assert(cd->data.transdb != NULL);
 529                 fill_ctdb_transdb(mem_ctx, cd->data.transdb);
 530                 break;
 531
 532         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
 533                 cd->data.db_id = rand32();
 534                 break;
 535
 536         case CTDB_CONTROL_DB_PULL:
 537                 cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
 538                 assert(cd->data.pulldb_ext != NULL);
 539                 fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
 540                 break;
 541
 542         case CTDB_CONTROL_DB_PUSH_START:
 543                 cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
 544                 assert(cd->data.pulldb_ext != NULL);
 545                 fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
 546                 break;
 547
 548         case CTDB_CONTROL_DB_PUSH_CONFIRM:
 549                 cd->data.db_id = rand32();
 550                 break;
 551
 552         case CTDB_CONTROL_DB_OPEN_FLAGS:
 553                 cd->data.db_id = rand32();
 554                 break;
 555
 556         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
 557                 fill_ctdb_string(mem_ctx, &cd->data.db_name);
 558                 assert(cd->data.db_name != NULL);
 559                 break;
 560
 561         case CTDB_CONTROL_CHECK_PID_SRVID:
 562                 cd->data.pid_srvid = talloc(mem_ctx, struct ctdb_pid_srvid);
 563                 assert(cd->data.pid_srvid != NULL);
 564                 fill_ctdb_pid_srvid(mem_ctx, cd->data.pid_srvid);
 565                 break;
 566
 567         case CTDB_CONTROL_TUNNEL_REGISTER:
 568                 break;
 569
 570         case CTDB_CONTROL_TUNNEL_DEREGISTER:
 571                 break;
 572
 573         case CTDB_CONTROL_VACUUM_FETCH:
 574                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
 575                 assert(cd->data.recbuf != NULL);
 576                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
 577                 break;
 578
 579         case CTDB_CONTROL_DB_VACUUM:
 580                 cd->data.db_vacuum = talloc(mem_ctx, struct ctdb_db_vacuum);
 581                 assert(cd->data.db_vacuum != NULL);
 582                 fill_ctdb_db_vacuum(mem_ctx, cd->data.db_vacuum);
 583                 break;
 584
 585         case CTDB_CONTROL_ECHO_DATA:
 586                 cd->data.echo_data = talloc(mem_ctx, struct ctdb_echo_data);
 587                 assert(cd->data.echo_data != NULL);
 588                 fill_ctdb_echo_data(mem_ctx, cd->data.echo_data);
 589                 break;
 590
 591         case CTDB_CONTROL_DISABLE_NODE:
 592                 break;
 593
 594         case CTDB_CONTROL_ENABLE_NODE:
 595                 break;
 596
 597         case CTDB_CONTROL_TCP_CLIENT_DISCONNECTED:
 598                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 599                 assert(cd->data.conn != NULL);
 600                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 601                 break;
 602
 603         case CTDB_CONTROL_TCP_CLIENT_PASSED:
 604                 cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
 605                 assert(cd->data.conn != NULL);
 606                 fill_ctdb_connection(mem_ctx, cd->data.conn);
 607                 break;
 608
 609         }
 610 }
 611
 612 void verify_ctdb_req_control_data(struct ctdb_req_control_data *cd,
 613                                   struct ctdb_req_control_data *cd2)
 614 {
 615         assert(cd->opcode == cd2->opcode);
 616
 617         switch (cd->opcode) {
 618         case CTDB_CONTROL_PROCESS_EXISTS:
 619                 assert(cd->data.pid == cd2->data.pid);
 620                 break;
 621
 622         case CTDB_CONTROL_STATISTICS:
 623                 break;
 624
 625         case CTDB_CONTROL_PING:
 626                 break;
 627
 628         case CTDB_CONTROL_GETDBPATH:
 629                 assert(cd->data.db_id == cd2->data.db_id);
 630                 break;
 631
 632         case CTDB_CONTROL_GETVNNMAP:
 633                 break;
 634
 635         case CTDB_CONTROL_SETVNNMAP:
 636                 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap);
 637                 break;
 638
 639         case CTDB_CONTROL_GET_DEBUG:
 640                 break;
 641
 642         case CTDB_CONTROL_SET_DEBUG:
 643                 assert(cd->data.loglevel == cd2->data.loglevel);
 644                 break;
 645
 646         case CTDB_CONTROL_GET_DBMAP:
 647                 break;
 648
 649         case CTDB_CONTROL_GET_RECMODE:
 650                 break;
 651
 652         case CTDB_CONTROL_SET_RECMODE:
 653                 assert(cd->data.recmode == cd2->data.recmode);
 654                 break;
 655
 656         case CTDB_CONTROL_STATISTICS_RESET:
 657                 break;
 658
 659         case CTDB_CONTROL_DB_ATTACH:
 660                 verify_ctdb_string(&cd->data.db_name, &cd2->data.db_name);
 661                 break;
 662
 663         case CTDB_CONTROL_TRAVERSE_START:
 664                 verify_ctdb_traverse_start(cd->data.traverse_start,
 665                                            cd2->data.traverse_start);
 666                 break;
 667
 668         case CTDB_CONTROL_TRAVERSE_ALL:
 669                 verify_ctdb_traverse_all(cd->data.traverse_all,
 670                                          cd2->data.traverse_all);
 671                 break;
 672
 673         case CTDB_CONTROL_TRAVERSE_DATA:
 674                 verify_ctdb_rec_data(cd->data.rec_data, cd2->data.rec_data);
 675                 break;
 676
 677         case CTDB_CONTROL_REGISTER_SRVID:
 678                 break;
 679
 680         case CTDB_CONTROL_DEREGISTER_SRVID:
 681                 break;
 682
 683         case CTDB_CONTROL_GET_DBNAME:
 684                 assert(cd->data.db_id == cd2->data.db_id);
 685                 break;
 686
 687         case CTDB_CONTROL_ENABLE_SEQNUM:
 688                 assert(cd->data.db_id == cd2->data.db_id);
 689                 break;
 690
 691         case CTDB_CONTROL_UPDATE_SEQNUM:
 692                 assert(cd->data.db_id == cd2->data.db_id);
 693                 break;
 694
 695         case CTDB_CONTROL_DUMP_MEMORY:
 696                 break;
 697
 698         case CTDB_CONTROL_GET_PID:
 699                 break;
 700
 701         case CTDB_CONTROL_FREEZE:
 702                 break;
 703
 704         case CTDB_CONTROL_GET_PNN:
 705                 break;
 706
 707         case CTDB_CONTROL_SHUTDOWN:
 708                 break;
 709
 710         case CTDB_CONTROL_TCP_CLIENT:
 711                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
 712                 break;
 713
 714         case CTDB_CONTROL_TCP_ADD:
 715                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
 716                 break;
 717
 718         case CTDB_CONTROL_TCP_REMOVE:
 719                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
 720                 break;
 721
 722         case CTDB_CONTROL_STARTUP:
 723                 break;
 724
 725         case CTDB_CONTROL_SET_TUNABLE:
 726                 verify_ctdb_tunable(cd->data.tunable, cd2->data.tunable);
 727                 break;
 728
 729         case CTDB_CONTROL_GET_TUNABLE:
 730                 verify_ctdb_string(&cd->data.tun_var, &cd2->data.tun_var);
 731                 break;
 732
 733         case CTDB_CONTROL_LIST_TUNABLES:
 734                 break;
 735
 736         case CTDB_CONTROL_MODIFY_FLAGS:
 737                 verify_ctdb_node_flag_change(cd->data.flag_change,
 738                                              cd2->data.flag_change);
 739                 break;
 740
 741         case CTDB_CONTROL_GET_ALL_TUNABLES:
 742                 break;
 743
 744         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 745                 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr);
 746                 break;
 747
 748         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 749                 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles);
 750                 break;
 751
 752         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 753                 verify_ctdb_string(&cd->data.db_name, &cd2->data.db_name);
 754                 break;
 755
 756         case CTDB_CONTROL_UPDATE_RECORD:
 757                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
 758                 break;
 759
 760         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 761                 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
 762                 break;
 763
 764         case CTDB_CONTROL_WIPE_DATABASE:
 765                 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
 766                 break;
 767
 768         case CTDB_CONTROL_UPTIME:
 769                 break;
 770
 771         case CTDB_CONTROL_START_RECOVERY:
 772                 break;
 773
 774         case CTDB_CONTROL_END_RECOVERY:
 775                 break;
 776
 777         case CTDB_CONTROL_RELOAD_NODES_FILE:
 778                 break;
 779
 780         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 781                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
 782                 break;
 783
 784         case CTDB_CONTROL_ADD_PUBLIC_IP:
 785                 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
 786                 break;
 787
 788         case CTDB_CONTROL_DEL_PUBLIC_IP:
 789                 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info);
 790                 break;
 791
 792         case CTDB_CONTROL_GET_CAPABILITIES:
 793                 break;
 794
 795         case CTDB_CONTROL_RECD_PING:
 796                 break;
 797
 798         case CTDB_CONTROL_RELEASE_IP:
 799                 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip);
 800                 break;
 801
 802         case CTDB_CONTROL_TAKEOVER_IP:
 803                 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip);
 804                 break;
 805
 806         case CTDB_CONTROL_GET_PUBLIC_IPS:
 807                 break;
 808
 809         case CTDB_CONTROL_GET_NODEMAP:
 810                 break;
 811
 812         case CTDB_CONTROL_TRAVERSE_KILL:
 813                 verify_ctdb_traverse_start(cd->data.traverse_start,
 814                                            cd2->data.traverse_start);
 815                 break;
 816
 817         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 818                 assert(cd->data.reclock_latency == cd2->data.reclock_latency);
 819                 break;
 820
 821         case CTDB_CONTROL_GET_RECLOCK_FILE:
 822                 break;
 823
 824         case CTDB_CONTROL_STOP_NODE:
 825                 break;
 826
 827         case CTDB_CONTROL_CONTINUE_NODE:
 828                 break;
 829
 830         case CTDB_CONTROL_SET_LMASTERROLE:
 831                 assert(cd->data.role == cd2->data.role);
 832                 break;
 833
 834         case CTDB_CONTROL_SET_RECMASTERROLE:
 835                 assert(cd->data.role == cd2->data.role);
 836                 break;
 837
 838         case CTDB_CONTROL_SET_BAN_STATE:
 839                 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state);
 840                 break;
 841
 842         case CTDB_CONTROL_GET_BAN_STATE:
 843                 break;
 844
 845         case CTDB_CONTROL_REGISTER_NOTIFY:
 846                 verify_ctdb_notify_data(cd->data.notify, cd2->data.notify);
 847                 break;
 848
 849         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 850                 assert(cd->data.srvid == cd2->data.srvid);
 851                 break;
 852
 853         case CTDB_CONTROL_TRANS3_COMMIT:
 854                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
 855                 break;
 856
 857         case CTDB_CONTROL_GET_DB_SEQNUM:
 858                 assert(cd->data.db_id == cd2->data.db_id);
 859                 break;
 860
 861         case CTDB_CONTROL_DB_SET_HEALTHY:
 862                 assert(cd->data.db_id == cd2->data.db_id);
 863                 break;
 864
 865         case CTDB_CONTROL_DB_GET_HEALTH:
 866                 assert(cd->data.db_id == cd2->data.db_id);
 867                 break;
 868
 869         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 870                 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr);
 871                 break;
 872
 873         case CTDB_CONTROL_GET_IFACES:
 874                 break;
 875
 876         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 877                 verify_ctdb_iface(cd->data.iface, cd2->data.iface);
 878                 break;
 879
 880         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 881                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
 882                 break;
 883
 884         case CTDB_CONTROL_GET_STAT_HISTORY:
 885                 break;
 886
 887         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 888                 verify_ctdb_key_data(cd->data.key, cd2->data.key);
 889                 break;
 890
 891         case CTDB_CONTROL_SET_DB_READONLY:
 892                 assert(cd->data.db_id == cd2->data.db_id);
 893                 break;
 894
 895         case CTDB_CONTROL_TRAVERSE_START_EXT:
 896                 verify_ctdb_traverse_start_ext(cd->data.traverse_start_ext,
 897                                                cd2->data.traverse_start_ext);
 898                 break;
 899
 900         case CTDB_CONTROL_GET_DB_STATISTICS:
 901                 assert(cd->data.db_id == cd2->data.db_id);
 902                 break;
 903
 904         case CTDB_CONTROL_SET_DB_STICKY:
 905                 assert(cd->data.db_id == cd2->data.db_id);
 906                 break;
 907
 908         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
 909                 break;
 910
 911         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 912                 verify_ctdb_traverse_all_ext(cd->data.traverse_all_ext,
 913                                              cd2->data.traverse_all_ext);
 914                 break;
 915
 916         case CTDB_CONTROL_IPREALLOCATED:
 917                 break;
 918
 919         case CTDB_CONTROL_GET_RUNSTATE:
 920                 break;
 921
 922         case CTDB_CONTROL_DB_DETACH:
 923                 assert(cd->data.db_id == cd2->data.db_id);
 924                 break;
 925
 926         case CTDB_CONTROL_GET_NODES_FILE:
 927                 break;
 928
 929         case CTDB_CONTROL_DB_FREEZE:
 930                 assert(cd->data.db_id == cd2->data.db_id);
 931                 break;
 932
 933         case CTDB_CONTROL_DB_THAW:
 934                 assert(cd->data.db_id == cd2->data.db_id);
 935                 break;
 936
 937         case CTDB_CONTROL_DB_TRANSACTION_START:
 938                 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
 939                 break;
 940
 941         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
 942                 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb);
 943                 break;
 944
 945         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
 946                 assert(cd->data.db_id == cd2->data.db_id);
 947                 break;
 948
 949         case CTDB_CONTROL_DB_PULL:
 950                 verify_ctdb_pulldb_ext(cd->data.pulldb_ext,
 951                                        cd2->data.pulldb_ext);
 952                 break;
 953
 954         case CTDB_CONTROL_DB_PUSH_START:
 955                 verify_ctdb_pulldb_ext(cd->data.pulldb_ext,
 956                                        cd2->data.pulldb_ext);
 957                 break;
 958
 959         case CTDB_CONTROL_DB_PUSH_CONFIRM:
 960                 assert(cd->data.db_id == cd2->data.db_id);
 961                 break;
 962
 963         case CTDB_CONTROL_DB_OPEN_FLAGS:
 964                 assert(cd->data.db_id == cd2->data.db_id);
 965                 break;
 966
 967         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
 968                 verify_ctdb_string(&cd->data.db_name, &cd2->data.db_name);
 969                 break;
 970
 971         case CTDB_CONTROL_CHECK_PID_SRVID:
 972                 verify_ctdb_pid_srvid(cd->data.pid_srvid, cd2->data.pid_srvid);
 973                 break;
 974
 975         case CTDB_CONTROL_TUNNEL_REGISTER:
 976                 break;
 977
 978         case CTDB_CONTROL_TUNNEL_DEREGISTER:
 979                 break;
 980
 981         case CTDB_CONTROL_VACUUM_FETCH:
 982                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
 983                 break;
 984
 985         case CTDB_CONTROL_DB_VACUUM:
 986                 verify_ctdb_db_vacuum(cd->data.db_vacuum, cd2->data.db_vacuum);
 987                 break;
 988
 989         case CTDB_CONTROL_ECHO_DATA:
 990                 verify_ctdb_echo_data(cd->data.echo_data, cd2->data.echo_data);
 991                 break;
 992
 993         case CTDB_CONTROL_DISABLE_NODE:
 994                 break;
 995
 996         case CTDB_CONTROL_ENABLE_NODE:
 997                 break;
 998
 999         case CTDB_CONTROL_TCP_CLIENT_DISCONNECTED:
1000                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
1001                 break;
1002
1003         case CTDB_CONTROL_TCP_CLIENT_PASSED:
1004                 verify_ctdb_connection(cd->data.conn, cd2->data.conn);
1005                 break;
1006         }
1007 }
1008
1009 void fill_ctdb_req_control(TALLOC_CTX *mem_ctx, struct ctdb_req_control *c,
1010                            uint32_t opcode)
1011 {
1012         c->opcode = opcode;
1013         c->pad = rand32();
1014         c->srvid = rand64();
1015         c->client_id = rand32();
1016         c->flags = rand32();
1017
1018         fill_ctdb_req_control_data(mem_ctx, &c->rdata, opcode);
1019 }
1020
1021 void verify_ctdb_req_control(struct ctdb_req_control *c,
1022                              struct ctdb_req_control *c2)
1023 {
1024         assert(c->opcode == c2->opcode);
1025         assert(c->pad == c2->pad);
1026         assert(c->srvid == c2->srvid);
1027         assert(c->client_id == c2->client_id);
1028         assert(c->flags == c2->flags);
1029
1030         verify_ctdb_req_control_data(&c->rdata, &c2->rdata);
1031 }
1032
1033 void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx,
1034                                   struct ctdb_reply_control_data *cd,
1035                                   uint32_t opcode)
1036 {
1037         cd->opcode = opcode;
1038
1039         switch (opcode) {
1040         case CTDB_CONTROL_PROCESS_EXISTS:
1041                 break;
1042
1043         case CTDB_CONTROL_STATISTICS:
1044                 cd->data.stats = talloc(mem_ctx, struct ctdb_statistics);
1045                 assert(cd->data.stats != NULL);
1046                 fill_ctdb_statistics(mem_ctx, cd->data.stats);
1047                 break;
1048
1049         case CTDB_CONTROL_PING:
1050                 break;
1051
1052         case CTDB_CONTROL_GETDBPATH:
1053                 fill_ctdb_string(mem_ctx, &cd->data.db_path);
1054                 assert(cd->data.db_path != NULL);
1055                 break;
1056
1057         case CTDB_CONTROL_GETVNNMAP:
1058                 cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
1059                 assert(cd->data.vnnmap != NULL);
1060                 fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
1061                 break;
1062
1063         case CTDB_CONTROL_SETVNNMAP:
1064                 break;
1065
1066         case CTDB_CONTROL_GET_DEBUG:
1067                 cd->data.loglevel = rand_int(5);
1068                 break;
1069
1070         case CTDB_CONTROL_SET_DEBUG:
1071                 break;
1072
1073         case CTDB_CONTROL_GET_DBMAP:
1074                 cd->data.dbmap = talloc(mem_ctx, struct ctdb_dbid_map);
1075                 assert(cd->data.dbmap != NULL);
1076                 fill_ctdb_dbid_map(mem_ctx, cd->data.dbmap);
1077                 break;
1078
1079         case CTDB_CONTROL_GET_RECMODE:
1080                 break;
1081
1082         case CTDB_CONTROL_SET_RECMODE:
1083                 break;
1084
1085         case CTDB_CONTROL_STATISTICS_RESET:
1086                 break;
1087
1088         case CTDB_CONTROL_DB_ATTACH:
1089                 cd->data.db_id = rand32();
1090                 break;
1091
1092         case CTDB_CONTROL_TRAVERSE_START:
1093                 break;
1094
1095         case CTDB_CONTROL_TRAVERSE_ALL:
1096                 break;
1097
1098         case CTDB_CONTROL_TRAVERSE_DATA:
1099                 break;
1100
1101         case CTDB_CONTROL_REGISTER_SRVID:
1102                 break;
1103
1104         case CTDB_CONTROL_DEREGISTER_SRVID:
1105                 break;
1106
1107         case CTDB_CONTROL_GET_DBNAME:
1108                 fill_ctdb_string(mem_ctx, &cd->data.db_name);
1109                 assert(cd->data.db_name);
1110                 break;
1111
1112         case CTDB_CONTROL_ENABLE_SEQNUM:
1113                 break;
1114
1115         case CTDB_CONTROL_UPDATE_SEQNUM:
1116                 break;
1117
1118         case CTDB_CONTROL_DUMP_MEMORY:
1119                 fill_ctdb_string(mem_ctx, &cd->data.mem_str);
1120                 assert(cd->data.mem_str);
1121                 break;
1122
1123         case CTDB_CONTROL_GET_PID:
1124                 break;
1125
1126         case CTDB_CONTROL_FREEZE:
1127                 break;
1128
1129         case CTDB_CONTROL_GET_PNN:
1130                 break;
1131
1132         case CTDB_CONTROL_SHUTDOWN:
1133                 break;
1134
1135         case CTDB_CONTROL_TCP_CLIENT:
1136                 break;
1137
1138         case CTDB_CONTROL_TCP_ADD:
1139                 break;
1140
1141         case CTDB_CONTROL_TCP_REMOVE:
1142                 break;
1143
1144         case CTDB_CONTROL_STARTUP:
1145                 break;
1146
1147         case CTDB_CONTROL_SET_TUNABLE:
1148                 break;
1149
1150         case CTDB_CONTROL_GET_TUNABLE:
1151                 cd->data.tun_value = rand32();
1152                 break;
1153
1154         case CTDB_CONTROL_LIST_TUNABLES:
1155                 cd->data.tun_var_list = talloc(mem_ctx, struct ctdb_var_list);
1156                 assert(cd->data.tun_var_list != NULL);
1157                 fill_ctdb_var_list(mem_ctx, cd->data.tun_var_list);
1158                 break;
1159
1160         case CTDB_CONTROL_MODIFY_FLAGS:
1161                 break;
1162
1163         case CTDB_CONTROL_GET_ALL_TUNABLES:
1164                 cd->data.tun_list = talloc(mem_ctx, struct ctdb_tunable_list);
1165                 assert(cd->data.tun_list != NULL);
1166                 fill_ctdb_tunable_list(mem_ctx, cd->data.tun_list);
1167                 break;
1168
1169         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1170                 cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
1171                 assert(cd->data.tickles != NULL);
1172                 fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
1173                 break;
1174
1175         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1176                 break;
1177
1178         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1179                 cd->data.db_id = rand32();
1180                 break;
1181
1182         case CTDB_CONTROL_UPDATE_RECORD:
1183                 break;
1184
1185         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1186                 break;
1187
1188         case CTDB_CONTROL_WIPE_DATABASE:
1189                 break;
1190
1191         case CTDB_CONTROL_UPTIME:
1192                 cd->data.uptime = talloc(mem_ctx, struct ctdb_uptime);
1193                 assert(cd->data.uptime != NULL);
1194                 fill_ctdb_uptime(mem_ctx, cd->data.uptime);
1195                 break;
1196
1197         case CTDB_CONTROL_START_RECOVERY:
1198                 break;
1199
1200         case CTDB_CONTROL_END_RECOVERY:
1201                 break;
1202
1203         case CTDB_CONTROL_RELOAD_NODES_FILE:
1204                 break;
1205
1206         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1207                 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1208                 assert(cd->data.recbuf != NULL);
1209                 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
1210                 break;
1211
1212         case CTDB_CONTROL_ADD_PUBLIC_IP:
1213                 break;
1214
1215         case CTDB_CONTROL_DEL_PUBLIC_IP:
1216                 break;
1217
1218         case CTDB_CONTROL_GET_CAPABILITIES:
1219                 cd->data.caps = rand32();
1220                 break;
1221
1222         case CTDB_CONTROL_RECD_PING:
1223                 break;
1224
1225         case CTDB_CONTROL_RELEASE_IP:
1226                 break;
1227
1228         case CTDB_CONTROL_TAKEOVER_IP:
1229                 break;
1230
1231         case CTDB_CONTROL_GET_PUBLIC_IPS:
1232                 cd->data.pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list);
1233                 assert(cd->data.pubip_list != NULL);
1234                 fill_ctdb_public_ip_list(mem_ctx, cd->data.pubip_list);
1235                 break;
1236
1237         case CTDB_CONTROL_GET_NODEMAP:
1238                 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
1239                 assert(cd->data.nodemap != NULL);
1240                 fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
1241                 break;
1242
1243         case CTDB_CONTROL_TRAVERSE_KILL:
1244                 break;
1245
1246         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1247                 break;
1248
1249         case CTDB_CONTROL_GET_RECLOCK_FILE:
1250                 fill_ctdb_string(mem_ctx, &cd->data.reclock_file);
1251                 assert(cd->data.reclock_file != NULL);
1252                 break;
1253
1254         case CTDB_CONTROL_STOP_NODE:
1255                 break;
1256
1257         case CTDB_CONTROL_CONTINUE_NODE:
1258                 break;
1259
1260         case CTDB_CONTROL_SET_LMASTERROLE:
1261                 break;
1262
1263         case CTDB_CONTROL_SET_RECMASTERROLE:
1264                 break;
1265
1266         case CTDB_CONTROL_SET_BAN_STATE:
1267                 break;
1268
1269         case CTDB_CONTROL_GET_BAN_STATE:
1270                 cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
1271                 assert(cd->data.ban_state != NULL);
1272                 fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
1273                 break;
1274
1275         case CTDB_CONTROL_REGISTER_NOTIFY:
1276                 break;
1277
1278         case CTDB_CONTROL_DEREGISTER_NOTIFY:
1279                 break;
1280
1281         case CTDB_CONTROL_TRANS3_COMMIT:
1282                 break;
1283
1284         case CTDB_CONTROL_GET_DB_SEQNUM:
1285                 cd->data.seqnum = rand64();
1286                 break;
1287
1288         case CTDB_CONTROL_DB_SET_HEALTHY:
1289                 break;
1290
1291         case CTDB_CONTROL_DB_GET_HEALTH:
1292                 fill_ctdb_string(mem_ctx, &cd->data.reason);
1293                 assert(cd->data.reason != NULL);
1294                 break;
1295
1296         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1297                 cd->data.ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info);
1298                 assert(cd->data.ipinfo != NULL);
1299                 fill_ctdb_public_ip_info(mem_ctx, cd->data.ipinfo);
1300                 break;
1301
1302         case CTDB_CONTROL_GET_IFACES:
1303                 cd->data.iface_list = talloc(mem_ctx, struct ctdb_iface_list);
1304                 assert(cd->data.iface_list != NULL);
1305                 fill_ctdb_iface_list(mem_ctx, cd->data.iface_list);
1306                 break;
1307
1308         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1309                 break;
1310
1311         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1312                 break;
1313
1314         case CTDB_CONTROL_GET_STAT_HISTORY:
1315                 cd->data.stats_list = talloc(mem_ctx, struct ctdb_statistics_list);
1316                 assert(cd->data.stats_list != NULL);
1317                 fill_ctdb_statistics_list(mem_ctx, cd->data.stats_list);
1318                 break;
1319
1320         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1321                 break;
1322
1323         case CTDB_CONTROL_SET_DB_READONLY:
1324                 break;
1325
1326         case CTDB_CONTROL_TRAVERSE_START_EXT:
1327                 break;
1328
1329         case CTDB_CONTROL_GET_DB_STATISTICS:
1330                 cd->data.dbstats = talloc(mem_ctx, struct ctdb_db_statistics);
1331                 assert(cd->data.dbstats != NULL);
1332                 fill_ctdb_db_statistics(mem_ctx, cd->data.dbstats);
1333                 break;
1334
1335         case CTDB_CONTROL_SET_DB_STICKY:
1336                 break;
1337
1338         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1339                 break;
1340
1341         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1342                 break;
1343
1344         case CTDB_CONTROL_IPREALLOCATED:
1345                 break;
1346
1347         case CTDB_CONTROL_GET_RUNSTATE:
1348                 cd->data.runstate = rand32();
1349                 break;
1350
1351         case CTDB_CONTROL_DB_DETACH:
1352                 break;
1353
1354         case CTDB_CONTROL_GET_NODES_FILE:
1355                 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
1356                 assert(cd->data.nodemap != NULL);
1357                 fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
1358                 break;
1359
1360         case CTDB_CONTROL_DB_PULL:
1361                 cd->data.num_records = rand32();
1362                 break;
1363
1364         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1365                 cd->data.num_records = rand32();
1366                 break;
1367
1368         case CTDB_CONTROL_DB_OPEN_FLAGS:
1369                 cd->data.tdb_flags = rand32();
1370                 break;
1371
1372         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1373                 cd->data.db_id = rand32();
1374                 break;
1375
1376         case CTDB_CONTROL_CHECK_PID_SRVID:
1377                 break;
1378
1379         case CTDB_CONTROL_TUNNEL_REGISTER:
1380                 break;
1381
1382         case CTDB_CONTROL_TUNNEL_DEREGISTER:
1383                 break;
1384
1385         case CTDB_CONTROL_VACUUM_FETCH:
1386                 break;
1387
1388         case CTDB_CONTROL_DB_VACUUM:
1389                 break;
1390
1391         case CTDB_CONTROL_ECHO_DATA:
1392                 cd->data.echo_data = talloc(mem_ctx, struct ctdb_echo_data);
1393                 assert(cd->data.echo_data != NULL);
1394                 fill_ctdb_echo_data(mem_ctx, cd->data.echo_data);
1395                 break;
1396
1397         case CTDB_CONTROL_DISABLE_NODE:
1398                 break;
1399
1400         case CTDB_CONTROL_ENABLE_NODE:
1401                 break;
1402
1403         case CTDB_CONTROL_TCP_CLIENT_DISCONNECTED:
1404                 break;
1405
1406         case CTDB_CONTROL_TCP_CLIENT_PASSED:
1407                 break;
1408         }
1409 }
1410
1411 void verify_ctdb_reply_control_data(struct ctdb_reply_control_data *cd,
1412                                     struct ctdb_reply_control_data *cd2)
1413 {
1414         assert(cd->opcode == cd2->opcode);
1415
1416         switch (cd->opcode) {
1417         case CTDB_CONTROL_PROCESS_EXISTS:
1418                 break;
1419
1420         case CTDB_CONTROL_STATISTICS:
1421                 verify_ctdb_statistics(cd->data.stats, cd2->data.stats);
1422                 break;
1423
1424         case CTDB_CONTROL_PING:
1425                 break;
1426
1427         case CTDB_CONTROL_GETDBPATH:
1428                 verify_ctdb_string(&cd->data.db_path, &cd2->data.db_path);
1429                 break;
1430
1431         case CTDB_CONTROL_GETVNNMAP:
1432                 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap);
1433                 break;
1434
1435         case CTDB_CONTROL_SETVNNMAP:
1436                 break;
1437
1438         case CTDB_CONTROL_GET_DEBUG:
1439                 assert(cd->data.loglevel == cd2->data.loglevel);
1440                 break;
1441
1442         case CTDB_CONTROL_SET_DEBUG:
1443                 break;
1444
1445         case CTDB_CONTROL_GET_DBMAP:
1446                 verify_ctdb_dbid_map(cd->data.dbmap, cd2->data.dbmap);
1447                 break;
1448
1449         case CTDB_CONTROL_GET_RECMODE:
1450                 break;
1451
1452         case CTDB_CONTROL_SET_RECMODE:
1453                 break;
1454
1455         case CTDB_CONTROL_STATISTICS_RESET:
1456                 break;
1457
1458         case CTDB_CONTROL_DB_ATTACH:
1459                 assert(cd->data.db_id == cd2->data.db_id);
1460                 break;
1461
1462         case CTDB_CONTROL_TRAVERSE_START:
1463                 break;
1464
1465         case CTDB_CONTROL_TRAVERSE_ALL:
1466                 break;
1467
1468         case CTDB_CONTROL_TRAVERSE_DATA:
1469                 break;
1470
1471         case CTDB_CONTROL_REGISTER_SRVID:
1472                 break;
1473
1474         case CTDB_CONTROL_DEREGISTER_SRVID:
1475                 break;
1476
1477         case CTDB_CONTROL_GET_DBNAME:
1478                 verify_ctdb_string(&cd->data.db_name, &cd2->data.db_name);
1479                 break;
1480
1481         case CTDB_CONTROL_ENABLE_SEQNUM:
1482                 break;
1483
1484         case CTDB_CONTROL_UPDATE_SEQNUM:
1485                 break;
1486
1487         case CTDB_CONTROL_DUMP_MEMORY:
1488                 verify_ctdb_string(&cd->data.mem_str, &cd2->data.mem_str);
1489                 break;
1490
1491         case CTDB_CONTROL_GET_PID:
1492                 break;
1493
1494         case CTDB_CONTROL_FREEZE:
1495                 break;
1496
1497         case CTDB_CONTROL_GET_PNN:
1498                 break;
1499
1500         case CTDB_CONTROL_SHUTDOWN:
1501                 break;
1502
1503         case CTDB_CONTROL_TCP_CLIENT:
1504                 break;
1505
1506         case CTDB_CONTROL_TCP_ADD:
1507                 break;
1508
1509         case CTDB_CONTROL_TCP_REMOVE:
1510                 break;
1511
1512         case CTDB_CONTROL_STARTUP:
1513                 break;
1514
1515         case CTDB_CONTROL_SET_TUNABLE:
1516                 break;
1517
1518         case CTDB_CONTROL_GET_TUNABLE:
1519                 assert(cd->data.tun_value == cd2->data.tun_value);
1520                 break;
1521
1522         case CTDB_CONTROL_LIST_TUNABLES:
1523                 verify_ctdb_var_list(cd->data.tun_var_list,
1524                                      cd2->data.tun_var_list);
1525                 break;
1526
1527         case CTDB_CONTROL_MODIFY_FLAGS:
1528                 break;
1529
1530         case CTDB_CONTROL_GET_ALL_TUNABLES:
1531                 verify_ctdb_tunable_list(cd->data.tun_list, cd2->data.tun_list);
1532                 break;
1533
1534         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1535                 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles);
1536                 break;
1537
1538         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1539                 break;
1540
1541         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1542                 assert(cd->data.db_id == cd2->data.db_id);
1543                 break;
1544
1545         case CTDB_CONTROL_UPDATE_RECORD:
1546                 break;
1547
1548         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1549                 break;
1550
1551         case CTDB_CONTROL_WIPE_DATABASE:
1552                 break;
1553
1554         case CTDB_CONTROL_UPTIME:
1555                 verify_ctdb_uptime(cd->data.uptime, cd2->data.uptime);
1556                 break;
1557
1558         case CTDB_CONTROL_START_RECOVERY:
1559                 break;
1560
1561         case CTDB_CONTROL_END_RECOVERY:
1562                 break;
1563
1564         case CTDB_CONTROL_RELOAD_NODES_FILE:
1565                 break;
1566
1567         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1568                 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf);
1569                 break;
1570
1571         case CTDB_CONTROL_ADD_PUBLIC_IP:
1572                 break;
1573
1574         case CTDB_CONTROL_DEL_PUBLIC_IP:
1575                 break;
1576
1577         case CTDB_CONTROL_GET_CAPABILITIES:
1578                 assert(cd->data.caps == cd2->data.caps);
1579                 break;
1580
1581         case CTDB_CONTROL_RECD_PING:
1582                 break;
1583
1584         case CTDB_CONTROL_RELEASE_IP:
1585                 break;
1586
1587         case CTDB_CONTROL_TAKEOVER_IP:
1588                 break;
1589
1590         case CTDB_CONTROL_GET_PUBLIC_IPS:
1591                 verify_ctdb_public_ip_list(cd->data.pubip_list,
1592                                            cd2->data.pubip_list);
1593                 break;
1594
1595         case CTDB_CONTROL_GET_NODEMAP:
1596                 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap);
1597                 break;
1598
1599         case CTDB_CONTROL_TRAVERSE_KILL:
1600                 break;
1601
1602         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1603                 break;
1604
1605         case CTDB_CONTROL_GET_RECLOCK_FILE:
1606                 verify_ctdb_string(&cd->data.reclock_file,
1607                                    &cd2->data.reclock_file);
1608                 break;
1609
1610         case CTDB_CONTROL_STOP_NODE:
1611                 break;
1612
1613         case CTDB_CONTROL_CONTINUE_NODE:
1614                 break;
1615
1616         case CTDB_CONTROL_SET_LMASTERROLE:
1617                 break;
1618
1619         case CTDB_CONTROL_SET_RECMASTERROLE:
1620                 break;
1621
1622         case CTDB_CONTROL_SET_BAN_STATE:
1623                 break;
1624
1625         case CTDB_CONTROL_GET_BAN_STATE:
1626                 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state);
1627                 break;
1628
1629         case CTDB_CONTROL_REGISTER_NOTIFY:
1630                 break;
1631
1632         case CTDB_CONTROL_DEREGISTER_NOTIFY:
1633                 break;
1634
1635         case CTDB_CONTROL_TRANS3_COMMIT:
1636                 break;
1637
1638         case CTDB_CONTROL_GET_DB_SEQNUM:
1639                 assert(cd->data.seqnum == cd2->data.seqnum);
1640                 break;
1641
1642         case CTDB_CONTROL_DB_SET_HEALTHY:
1643                 break;
1644
1645         case CTDB_CONTROL_DB_GET_HEALTH:
1646                 verify_ctdb_string(&cd->data.reason, &cd2->data.reason);
1647                 break;
1648
1649         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1650                 verify_ctdb_public_ip_info(cd->data.ipinfo, cd2->data.ipinfo);
1651                 break;
1652
1653         case CTDB_CONTROL_GET_IFACES:
1654                 verify_ctdb_iface_list(cd->data.iface_list,
1655                                        cd2->data.iface_list);
1656                 break;
1657
1658         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1659                 break;
1660
1661         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1662                 break;
1663
1664         case CTDB_CONTROL_GET_STAT_HISTORY:
1665                 verify_ctdb_statistics_list(cd->data.stats_list,
1666                                             cd2->data.stats_list);
1667                 break;
1668
1669         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1670                 break;
1671
1672         case CTDB_CONTROL_SET_DB_READONLY:
1673                 break;
1674
1675         case CTDB_CONTROL_TRAVERSE_START_EXT:
1676                 break;
1677
1678         case CTDB_CONTROL_GET_DB_STATISTICS:
1679                 verify_ctdb_db_statistics(cd->data.dbstats, cd2->data.dbstats);
1680                 break;
1681
1682         case CTDB_CONTROL_SET_DB_STICKY:
1683                 break;
1684
1685         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1686                 break;
1687
1688         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1689                 break;
1690
1691         case CTDB_CONTROL_IPREALLOCATED:
1692                 break;
1693
1694         case CTDB_CONTROL_GET_RUNSTATE:
1695                 assert(cd->data.runstate == cd2->data.runstate);
1696                 break;
1697
1698         case CTDB_CONTROL_DB_DETACH:
1699                 break;
1700
1701         case CTDB_CONTROL_GET_NODES_FILE:
1702                 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap);
1703                 break;
1704
1705         case CTDB_CONTROL_DB_PULL:
1706                 assert(cd->data.num_records == cd2->data.num_records);
1707                 break;
1708
1709         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1710                 assert(cd->data.num_records == cd2->data.num_records);
1711                 break;
1712
1713         case CTDB_CONTROL_DB_OPEN_FLAGS:
1714                 assert(cd->data.tdb_flags == cd2->data.tdb_flags);
1715                 break;
1716
1717         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1718                 assert(cd->data.db_id == cd2->data.db_id);
1719                 break;
1720
1721         case CTDB_CONTROL_CHECK_PID_SRVID:
1722                 break;
1723
1724         case CTDB_CONTROL_TUNNEL_REGISTER:
1725                 break;
1726
1727         case CTDB_CONTROL_TUNNEL_DEREGISTER:
1728                 break;
1729
1730         case CTDB_CONTROL_VACUUM_FETCH:
1731                 break;
1732
1733         case CTDB_CONTROL_DB_VACUUM:
1734                 break;
1735
1736         case CTDB_CONTROL_ECHO_DATA:
1737                 verify_ctdb_echo_data(cd->data.echo_data, cd2->data.echo_data);
1738                 break;
1739
1740         case CTDB_CONTROL_DISABLE_NODE:
1741                 break;
1742
1743         case CTDB_CONTROL_ENABLE_NODE:
1744                 break;
1745
1746         case CTDB_CONTROL_TCP_CLIENT_DISCONNECTED:
1747                 break;
1748
1749         case CTDB_CONTROL_TCP_CLIENT_PASSED:
1750                 break;
1751         }
1752 }
1753
1754 void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx,
1755                              struct ctdb_reply_control *c, uint32_t opcode)
1756 {
1757         c->status = -rand_int(2);
1758         if (c->status == 0) {
1759                 c->errmsg = NULL;
1760                 fill_ctdb_reply_control_data(mem_ctx, &c->rdata, opcode);
1761         } else {
1762                 fill_ctdb_string(mem_ctx, &c->errmsg);
1763         }
1764 }
1765
1766 void verify_ctdb_reply_control(struct ctdb_reply_control *c,
1767                                struct ctdb_reply_control *c2)
1768 {
1769         assert(c->status == c2->status);
1770         verify_ctdb_string(&c->errmsg, &c2->errmsg);
1771         if (c->status == 0) {
1772                 verify_ctdb_reply_control_data(&c->rdata, &c2->rdata);
1773         }
1774 }
1775
1776 void fill_ctdb_message_data(TALLOC_CTX *mem_ctx, union ctdb_message_data *md,
1777                             uint64_t srvid)
1778 {
1779         switch (srvid) {
1780         case CTDB_SRVID_RECONFIGURE:
1781         case CTDB_SRVID_GETLOG:
1782         case CTDB_SRVID_CLEARLOG:
1783         case CTDB_SRVID_RELOAD_NODES:
1784                 break;
1785
1786         case CTDB_SRVID_ELECTION:
1787                 md->election = talloc(mem_ctx, struct ctdb_election_message);
1788                 assert(md->election != NULL);
1789                 fill_ctdb_election_message(md->election, md->election);
1790                 break;
1791
1792         case CTDB_SRVID_RELEASE_IP:
1793         case CTDB_SRVID_TAKE_IP:
1794                 fill_ctdb_string(mem_ctx, &md->ipaddr);
1795                 break;
1796
1797         case CTDB_SRVID_SET_NODE_FLAGS:
1798         case CTDB_SRVID_PUSH_NODE_FLAGS:
1799                 md->flag_change = talloc(mem_ctx,
1800                                          struct ctdb_node_flag_change);
1801                 assert(md->flag_change != NULL);
1802                 fill_ctdb_node_flag_change(md->flag_change, md->flag_change);
1803                 break;
1804
1805         case CTDB_SRVID_RECD_UPDATE_IP:
1806                 md->pubip = talloc(mem_ctx, struct ctdb_public_ip);
1807                 assert(md->pubip != NULL);
1808                 fill_ctdb_public_ip(md->pubip, md->pubip);
1809                 break;
1810
1811         case CTDB_SRVID_VACUUM_FETCH:
1812                 md->recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
1813                 assert(md->recbuf != NULL);
1814                 fill_ctdb_rec_buffer(md->recbuf, md->recbuf);
1815                 break;
1816
1817         case CTDB_SRVID_DETACH_DATABASE:
1818                 md->db_id = rand32();
1819                 break;
1820
1821         case CTDB_SRVID_MEM_DUMP:
1822         case CTDB_SRVID_TAKEOVER_RUN:
1823                 md->msg = talloc(mem_ctx, struct ctdb_srvid_message);
1824                 assert(md->msg != NULL);
1825                 fill_ctdb_srvid_message(md->msg, md->msg);
1826                 break;
1827
1828         case CTDB_SRVID_LEADER:
1829         case CTDB_SRVID_BANNING:
1830         case CTDB_SRVID_REBALANCE_NODE:
1831                 md->pnn = rand32();
1832                 break;
1833
1834         case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
1835         case CTDB_SRVID_DISABLE_RECOVERIES:
1836                 md->disable = talloc(mem_ctx, struct ctdb_disable_message);
1837                 assert(md->disable != NULL);
1838                 fill_ctdb_disable_message(md->disable, md->disable);
1839                 break;
1840
1841         case CTDB_SRVID_DISABLE_IP_CHECK:
1842                 md->timeout = rand32();
1843                 break;
1844
1845         default:
1846                 abort();
1847         }
1848 }
1849
1850 void verify_ctdb_message_data(union ctdb_message_data *md,
1851                               union ctdb_message_data *md2, uint64_t srvid)
1852 {
1853         switch (srvid) {
1854         case CTDB_SRVID_RECONFIGURE:
1855         case CTDB_SRVID_GETLOG:
1856         case CTDB_SRVID_CLEARLOG:
1857         case CTDB_SRVID_RELOAD_NODES:
1858                 break;
1859
1860         case CTDB_SRVID_ELECTION:
1861                 verify_ctdb_election_message(md->election, md2->election);
1862                 break;
1863
1864         case CTDB_SRVID_RELEASE_IP:
1865         case CTDB_SRVID_TAKE_IP:
1866                 verify_ctdb_string(&md->ipaddr, &md2->ipaddr);
1867                 break;
1868
1869         case CTDB_SRVID_SET_NODE_FLAGS:
1870         case CTDB_SRVID_PUSH_NODE_FLAGS:
1871                 verify_ctdb_node_flag_change(md->flag_change,
1872                                              md2->flag_change);
1873                 break;
1874
1875         case CTDB_SRVID_RECD_UPDATE_IP:
1876                 verify_ctdb_public_ip(md->pubip, md2->pubip);
1877                 break;
1878
1879         case CTDB_SRVID_VACUUM_FETCH:
1880                 verify_ctdb_rec_buffer(md->recbuf, md2->recbuf);
1881                 break;
1882
1883         case CTDB_SRVID_DETACH_DATABASE:
1884                 assert(md->db_id == md2->db_id);
1885                 break;
1886
1887         case CTDB_SRVID_MEM_DUMP:
1888         case CTDB_SRVID_TAKEOVER_RUN:
1889                 verify_ctdb_srvid_message(md->msg, md2->msg);
1890                 break;
1891
1892         case CTDB_SRVID_LEADER:
1893         case CTDB_SRVID_BANNING:
1894         case CTDB_SRVID_REBALANCE_NODE:
1895                 assert(md->pnn == md2->pnn);
1896                 break;
1897
1898         case CTDB_SRVID_DISABLE_TAKEOVER_RUNS:
1899         case CTDB_SRVID_DISABLE_RECOVERIES:
1900                 verify_ctdb_disable_message(md->disable, md2->disable);
1901                 break;
1902
1903         case CTDB_SRVID_DISABLE_IP_CHECK:
1904                 assert(md->timeout == md2->timeout);
1905                 break;
1906
1907         default:
1908                 abort();
1909         }
1910 }
1911
1912 void fill_ctdb_req_message(TALLOC_CTX *mem_ctx, struct ctdb_req_message *c,
1913                            uint64_t srvid)
1914 {
1915         c->srvid = srvid;
1916         fill_ctdb_message_data(mem_ctx, &c->data, srvid);
1917 }
1918
1919 void verify_ctdb_req_message(struct ctdb_req_message *c,
1920                              struct ctdb_req_message *c2)
1921 {
1922         assert(c->srvid == c2->srvid);
1923         verify_ctdb_message_data(&c->data, &c2->data, c->srvid);
1924 }
1925
1926 void fill_ctdb_req_message_data(TALLOC_CTX *mem_ctx,
1927                                 struct ctdb_req_message_data *c)
1928 {
1929         c->srvid = rand64();
1930         fill_tdb_data(mem_ctx, &c->data);
1931 }
1932
1933 void verify_ctdb_req_message_data(struct ctdb_req_message_data *c,
1934                                   struct ctdb_req_message_data *c2)
1935 {
1936         assert(c->srvid == c2->srvid);
1937         verify_tdb_data(&c->data, &c2->data);
1938 }
1939
1940 void fill_ctdb_req_keepalive(TALLOC_CTX *mem_ctx,
1941                                     struct ctdb_req_keepalive *c)
1942 {
1943         c->version = rand32();
1944         c->uptime = rand32();
1945 }
1946
1947 void verify_ctdb_req_keepalive(struct ctdb_req_keepalive *c,
1948                                       struct ctdb_req_keepalive *c2)
1949 {
1950         assert(c->version == c2->version);
1951         assert(c->uptime == c2->uptime);
1952 }
1953
1954 void fill_ctdb_req_tunnel(TALLOC_CTX *mem_ctx, struct ctdb_req_tunnel *c)
1955 {
1956         c->tunnel_id = rand64();
1957         c->flags = rand32();
1958         fill_tdb_data(mem_ctx, &c->data);
1959 }
1960
1961 void verify_ctdb_req_tunnel(struct ctdb_req_tunnel *c,
1962                             struct ctdb_req_tunnel *c2)
1963 {
1964         assert(c->tunnel_id == c2->tunnel_id);
1965         assert(c->flags == c2->flags);
1966         verify_tdb_data(&c->data, &c2->data);
1967 }