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