ctdb/tests/src/protocol_client_test.c

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