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 case CTDB_CONTROL_DB_VACUUM: 599 cd->data.db_vacuum = talloc(mem_ctx, struct ctdb_db_vacuum); 600 assert(cd->data.db_vacuum != NULL); 601 fill_ctdb_db_vacuum(mem_ctx, cd->data.db_vacuum); 602 break; 603 } 604 } 605 606 void verify_ctdb_req_control_data(struct ctdb_req_control_data *cd, 607 struct ctdb_req_control_data *cd2) 608 { 609 assert(cd->opcode == cd2->opcode); 610 611 switch (cd->opcode) { 612 case CTDB_CONTROL_PROCESS_EXISTS: 613 assert(cd->data.pid == cd2->data.pid); 614 break; 615 616 case CTDB_CONTROL_STATISTICS: 617 break; 618 619 case CTDB_CONTROL_PING: 620 break; 621 622 case CTDB_CONTROL_GETDBPATH: 623 assert(cd->data.db_id == cd2->data.db_id); 624 break; 625 626 case CTDB_CONTROL_GETVNNMAP: 627 break; 628 629 case CTDB_CONTROL_SETVNNMAP: 630 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap); 631 break; 632 633 case CTDB_CONTROL_GET_DEBUG: 634 break; 635 636 case CTDB_CONTROL_SET_DEBUG: 637 assert(cd->data.loglevel == cd2->data.loglevel); 638 break; 639 640 case CTDB_CONTROL_GET_DBMAP: 641 break; 642 643 case CTDB_CONTROL_PULL_DB: 644 verify_ctdb_pulldb(cd->data.pulldb, cd2->data.pulldb); 645 break; 646 647 case CTDB_CONTROL_PUSH_DB: 648 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf); 649 break; 650 651 case CTDB_CONTROL_GET_RECMODE: 652 break; 653 654 case CTDB_CONTROL_SET_RECMODE: 655 assert(cd->data.recmode == cd2->data.recmode); 656 break; 657 658 case CTDB_CONTROL_STATISTICS_RESET: 659 break; 660 661 case CTDB_CONTROL_DB_ATTACH: 662 verify_ctdb_string(&cd->data.db_name, &cd2->data.db_name); 663 break; 664 665 case CTDB_CONTROL_TRAVERSE_START: 666 verify_ctdb_traverse_start(cd->data.traverse_start, 667 cd2->data.traverse_start); 668 break; 669 670 case CTDB_CONTROL_TRAVERSE_ALL: 671 verify_ctdb_traverse_all(cd->data.traverse_all, 672 cd2->data.traverse_all); 673 break; 674 675 case CTDB_CONTROL_TRAVERSE_DATA: 676 verify_ctdb_rec_data(cd->data.rec_data, cd2->data.rec_data); 677 break; 678 679 case CTDB_CONTROL_REGISTER_SRVID: 680 break; 681 682 case CTDB_CONTROL_DEREGISTER_SRVID: 683 break; 684 685 case CTDB_CONTROL_GET_DBNAME: 686 assert(cd->data.db_id == cd2->data.db_id); 687 break; 688 689 case CTDB_CONTROL_ENABLE_SEQNUM: 690 assert(cd->data.db_id == cd2->data.db_id); 691 break; 692 693 case CTDB_CONTROL_UPDATE_SEQNUM: 694 assert(cd->data.db_id == cd2->data.db_id); 695 break; 696 697 case CTDB_CONTROL_DUMP_MEMORY: 698 break; 699 700 case CTDB_CONTROL_GET_PID: 701 break; 702 703 case CTDB_CONTROL_GET_RECMASTER: 704 break; 705 706 case CTDB_CONTROL_SET_RECMASTER: 707 assert(cd->data.recmaster == cd2->data.recmaster); 708 break; 709 710 case CTDB_CONTROL_FREEZE: 711 break; 712 713 case CTDB_CONTROL_GET_PNN: 714 break; 715 716 case CTDB_CONTROL_SHUTDOWN: 717 break; 718 719 case CTDB_CONTROL_TCP_CLIENT: 720 verify_ctdb_connection(cd->data.conn, cd2->data.conn); 721 break; 722 723 case CTDB_CONTROL_TCP_ADD: 724 verify_ctdb_connection(cd->data.conn, cd2->data.conn); 725 break; 726 727 case CTDB_CONTROL_TCP_REMOVE: 728 verify_ctdb_connection(cd->data.conn, cd2->data.conn); 729 break; 730 731 case CTDB_CONTROL_STARTUP: 732 break; 733 734 case CTDB_CONTROL_SET_TUNABLE: 735 verify_ctdb_tunable(cd->data.tunable, cd2->data.tunable); 736 break; 737 738 case CTDB_CONTROL_GET_TUNABLE: 739 verify_ctdb_string(&cd->data.tun_var, &cd2->data.tun_var); 740 break; 741 742 case CTDB_CONTROL_LIST_TUNABLES: 743 break; 744 745 case CTDB_CONTROL_MODIFY_FLAGS: 746 verify_ctdb_node_flag_change(cd->data.flag_change, 747 cd2->data.flag_change); 748 break; 749 750 case CTDB_CONTROL_GET_ALL_TUNABLES: 751 break; 752 753 case CTDB_CONTROL_GET_TCP_TICKLE_LIST: 754 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr); 755 break; 756 757 case CTDB_CONTROL_SET_TCP_TICKLE_LIST: 758 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles); 759 break; 760 761 case CTDB_CONTROL_DB_ATTACH_PERSISTENT: 762 verify_ctdb_string(&cd->data.db_name, &cd2->data.db_name); 763 break; 764 765 case CTDB_CONTROL_UPDATE_RECORD: 766 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf); 767 break; 768 769 case CTDB_CONTROL_SEND_GRATUITOUS_ARP: 770 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info); 771 break; 772 773 case CTDB_CONTROL_WIPE_DATABASE: 774 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb); 775 break; 776 777 case CTDB_CONTROL_UPTIME: 778 break; 779 780 case CTDB_CONTROL_START_RECOVERY: 781 break; 782 783 case CTDB_CONTROL_END_RECOVERY: 784 break; 785 786 case CTDB_CONTROL_RELOAD_NODES_FILE: 787 break; 788 789 case CTDB_CONTROL_TRY_DELETE_RECORDS: 790 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf); 791 break; 792 793 case CTDB_CONTROL_ADD_PUBLIC_IP: 794 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info); 795 break; 796 797 case CTDB_CONTROL_DEL_PUBLIC_IP: 798 verify_ctdb_addr_info(cd->data.addr_info, cd2->data.addr_info); 799 break; 800 801 case CTDB_CONTROL_GET_CAPABILITIES: 802 break; 803 804 case CTDB_CONTROL_RECD_PING: 805 break; 806 807 case CTDB_CONTROL_RELEASE_IP: 808 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip); 809 break; 810 811 case CTDB_CONTROL_TAKEOVER_IP: 812 verify_ctdb_public_ip(cd->data.pubip, cd2->data.pubip); 813 break; 814 815 case CTDB_CONTROL_GET_PUBLIC_IPS: 816 break; 817 818 case CTDB_CONTROL_GET_NODEMAP: 819 break; 820 821 case CTDB_CONTROL_TRAVERSE_KILL: 822 verify_ctdb_traverse_start(cd->data.traverse_start, 823 cd2->data.traverse_start); 824 break; 825 826 case CTDB_CONTROL_RECD_RECLOCK_LATENCY: 827 assert(cd->data.reclock_latency == cd2->data.reclock_latency); 828 break; 829 830 case CTDB_CONTROL_GET_RECLOCK_FILE: 831 break; 832 833 case CTDB_CONTROL_STOP_NODE: 834 break; 835 836 case CTDB_CONTROL_CONTINUE_NODE: 837 break; 838 839 case CTDB_CONTROL_SET_LMASTERROLE: 840 assert(cd->data.role == cd2->data.role); 841 break; 842 843 case CTDB_CONTROL_SET_RECMASTERROLE: 844 assert(cd->data.role == cd2->data.role); 845 break; 846 847 case CTDB_CONTROL_SET_BAN_STATE: 848 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state); 849 break; 850 851 case CTDB_CONTROL_GET_BAN_STATE: 852 break; 853 854 case CTDB_CONTROL_REGISTER_NOTIFY: 855 verify_ctdb_notify_data(cd->data.notify, cd2->data.notify); 856 break; 857 858 case CTDB_CONTROL_DEREGISTER_NOTIFY: 859 assert(cd->data.srvid == cd2->data.srvid); 860 break; 861 862 case CTDB_CONTROL_TRANS3_COMMIT: 863 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf); 864 break; 865 866 case CTDB_CONTROL_GET_DB_SEQNUM: 867 assert(cd->data.db_id == cd2->data.db_id); 868 break; 869 870 case CTDB_CONTROL_DB_SET_HEALTHY: 871 assert(cd->data.db_id == cd2->data.db_id); 872 break; 873 874 case CTDB_CONTROL_DB_GET_HEALTH: 875 assert(cd->data.db_id == cd2->data.db_id); 876 break; 877 878 case CTDB_CONTROL_GET_PUBLIC_IP_INFO: 879 verify_ctdb_sock_addr(cd->data.addr, cd2->data.addr); 880 break; 881 882 case CTDB_CONTROL_GET_IFACES: 883 break; 884 885 case CTDB_CONTROL_SET_IFACE_LINK_STATE: 886 verify_ctdb_iface(cd->data.iface, cd2->data.iface); 887 break; 888 889 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE: 890 verify_ctdb_connection(cd->data.conn, cd2->data.conn); 891 break; 892 893 case CTDB_CONTROL_GET_STAT_HISTORY: 894 break; 895 896 case CTDB_CONTROL_SCHEDULE_FOR_DELETION: 897 verify_ctdb_key_data(cd->data.key, cd2->data.key); 898 break; 899 900 case CTDB_CONTROL_SET_DB_READONLY: 901 assert(cd->data.db_id == cd2->data.db_id); 902 break; 903 904 case CTDB_CONTROL_TRAVERSE_START_EXT: 905 verify_ctdb_traverse_start_ext(cd->data.traverse_start_ext, 906 cd2->data.traverse_start_ext); 907 break; 908 909 case CTDB_CONTROL_GET_DB_STATISTICS: 910 assert(cd->data.db_id == cd2->data.db_id); 911 break; 912 913 case CTDB_CONTROL_SET_DB_STICKY: 914 assert(cd->data.db_id == cd2->data.db_id); 915 break; 916 917 case CTDB_CONTROL_RELOAD_PUBLIC_IPS: 918 break; 919 920 case CTDB_CONTROL_TRAVERSE_ALL_EXT: 921 verify_ctdb_traverse_all_ext(cd->data.traverse_all_ext, 922 cd2->data.traverse_all_ext); 923 break; 924 925 case CTDB_CONTROL_IPREALLOCATED: 926 break; 927 928 case CTDB_CONTROL_GET_RUNSTATE: 929 break; 930 931 case CTDB_CONTROL_DB_DETACH: 932 assert(cd->data.db_id == cd2->data.db_id); 933 break; 934 935 case CTDB_CONTROL_GET_NODES_FILE: 936 break; 937 938 case CTDB_CONTROL_DB_FREEZE: 939 assert(cd->data.db_id == cd2->data.db_id); 940 break; 941 942 case CTDB_CONTROL_DB_THAW: 943 assert(cd->data.db_id == cd2->data.db_id); 944 break; 945 946 case CTDB_CONTROL_DB_TRANSACTION_START: 947 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb); 948 break; 949 950 case CTDB_CONTROL_DB_TRANSACTION_COMMIT: 951 verify_ctdb_transdb(cd->data.transdb, cd2->data.transdb); 952 break; 953 954 case CTDB_CONTROL_DB_TRANSACTION_CANCEL: 955 assert(cd->data.db_id == cd2->data.db_id); 956 break; 957 958 case CTDB_CONTROL_DB_PULL: 959 verify_ctdb_pulldb_ext(cd->data.pulldb_ext, 960 cd2->data.pulldb_ext); 961 break; 962 963 case CTDB_CONTROL_DB_PUSH_START: 964 verify_ctdb_pulldb_ext(cd->data.pulldb_ext, 965 cd2->data.pulldb_ext); 966 break; 967 968 case CTDB_CONTROL_DB_PUSH_CONFIRM: 969 assert(cd->data.db_id == cd2->data.db_id); 970 break; 971 972 case CTDB_CONTROL_DB_OPEN_FLAGS: 973 assert(cd->data.db_id == cd2->data.db_id); 974 break; 975 976 case CTDB_CONTROL_DB_ATTACH_REPLICATED: 977 verify_ctdb_string(&cd->data.db_name, &cd2->data.db_name); 978 break; 979 980 case CTDB_CONTROL_CHECK_PID_SRVID: 981 verify_ctdb_pid_srvid(cd->data.pid_srvid, cd2->data.pid_srvid); 982 break; 983 984 case CTDB_CONTROL_TUNNEL_REGISTER: 985 break; 986 987 case CTDB_CONTROL_TUNNEL_DEREGISTER: 988 break; 989 990 case CTDB_CONTROL_VACUUM_FETCH: 991 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf); 992 break; 993 994 case CTDB_CONTROL_DB_VACUUM: 995 verify_ctdb_db_vacuum(cd->data.db_vacuum, cd2->data.db_vacuum); 996 break; 997 } 998 } 999 1000 void fill_ctdb_req_control(TALLOC_CTX *mem_ctx, struct ctdb_req_control *c, 1001 uint32_t opcode) 1002 { 1003 c->opcode = opcode; 1004 c->pad = rand32(); 1005 c->srvid = rand64(); 1006 c->client_id = rand32(); 1007 c->flags = rand32(); 1008 1009 fill_ctdb_req_control_data(mem_ctx, &c->rdata, opcode); 1010 } 1011 1012 void verify_ctdb_req_control(struct ctdb_req_control *c, 1013 struct ctdb_req_control *c2) 1014 { 1015 assert(c->opcode == c2->opcode); 1016 assert(c->pad == c2->pad); 1017 assert(c->srvid == c2->srvid); 1018 assert(c->client_id == c2->client_id); 1019 assert(c->flags == c2->flags); 1020 1021 verify_ctdb_req_control_data(&c->rdata, &c2->rdata); 1022 } 1023 1024 void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx, 1025 struct ctdb_reply_control_data *cd, 1026 uint32_t opcode) 1027 { 1028 cd->opcode = opcode; 1029 1030 switch (opcode) { 1031 case CTDB_CONTROL_PROCESS_EXISTS: 1032 break; 1033 1034 case CTDB_CONTROL_STATISTICS: 1035 cd->data.stats = talloc(mem_ctx, struct ctdb_statistics); 1036 assert(cd->data.stats != NULL); 1037 fill_ctdb_statistics(mem_ctx, cd->data.stats); 1038 break; 1039 1040 case CTDB_CONTROL_PING: 1041 break; 1042 1043 case CTDB_CONTROL_GETDBPATH: 1044 fill_ctdb_string(mem_ctx, &cd->data.db_path); 1045 assert(cd->data.db_path != NULL); 1046 break; 1047 1048 case CTDB_CONTROL_GETVNNMAP: 1049 cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map); 1050 assert(cd->data.vnnmap != NULL); 1051 fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap); 1052 break; 1053 1054 case CTDB_CONTROL_SETVNNMAP: 1055 break; 1056 1057 case CTDB_CONTROL_GET_DEBUG: 1058 cd->data.loglevel = rand_int(5); 1059 break; 1060 1061 case CTDB_CONTROL_SET_DEBUG: 1062 break; 1063 1064 case CTDB_CONTROL_GET_DBMAP: 1065 cd->data.dbmap = talloc(mem_ctx, struct ctdb_dbid_map); 1066 assert(cd->data.dbmap != NULL); 1067 fill_ctdb_dbid_map(mem_ctx, cd->data.dbmap); 1068 break; 1069 1070 case CTDB_CONTROL_PULL_DB: 1071 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer); 1072 assert(cd->data.recbuf != NULL); 1073 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf); 1074 break; 1075 1076 case CTDB_CONTROL_PUSH_DB: 1077 break; 1078 1079 case CTDB_CONTROL_GET_RECMODE: 1080 break; 1081 1082 case CTDB_CONTROL_SET_RECMODE: 1083 break; 1084 1085 case CTDB_CONTROL_STATISTICS_RESET: 1086 break; 1087 1088 case CTDB_CONTROL_DB_ATTACH: 1089 cd->data.db_id = rand32(); 1090 break; 1091 1092 case CTDB_CONTROL_TRAVERSE_START: 1093 break; 1094 1095 case CTDB_CONTROL_TRAVERSE_ALL: 1096 break; 1097 1098 case CTDB_CONTROL_TRAVERSE_DATA: 1099 break; 1100 1101 case CTDB_CONTROL_REGISTER_SRVID: 1102 break; 1103 1104 case CTDB_CONTROL_DEREGISTER_SRVID: 1105 break; 1106 1107 case CTDB_CONTROL_GET_DBNAME: 1108 fill_ctdb_string(mem_ctx, &cd->data.db_name); 1109 assert(cd->data.db_name); 1110 break; 1111 1112 case CTDB_CONTROL_ENABLE_SEQNUM: 1113 break; 1114 1115 case CTDB_CONTROL_UPDATE_SEQNUM: 1116 break; 1117 1118 case CTDB_CONTROL_DUMP_MEMORY: 1119 fill_ctdb_string(mem_ctx, &cd->data.mem_str); 1120 assert(cd->data.mem_str); 1121 break; 1122 1123 case CTDB_CONTROL_GET_PID: 1124 break; 1125 1126 case CTDB_CONTROL_GET_RECMASTER: 1127 break; 1128 1129 case CTDB_CONTROL_SET_RECMASTER: 1130 break; 1131 1132 case CTDB_CONTROL_FREEZE: 1133 break; 1134 1135 case CTDB_CONTROL_GET_PNN: 1136 break; 1137 1138 case CTDB_CONTROL_SHUTDOWN: 1139 break; 1140 1141 case CTDB_CONTROL_TCP_CLIENT: 1142 break; 1143 1144 case CTDB_CONTROL_TCP_ADD: 1145 break; 1146 1147 case CTDB_CONTROL_TCP_REMOVE: 1148 break; 1149 1150 case CTDB_CONTROL_STARTUP: 1151 break; 1152 1153 case CTDB_CONTROL_SET_TUNABLE: 1154 break; 1155 1156 case CTDB_CONTROL_GET_TUNABLE: 1157 cd->data.tun_value = rand32(); 1158 break; 1159 1160 case CTDB_CONTROL_LIST_TUNABLES: 1161 cd->data.tun_var_list = talloc(mem_ctx, struct ctdb_var_list); 1162 assert(cd->data.tun_var_list != NULL); 1163 fill_ctdb_var_list(mem_ctx, cd->data.tun_var_list); 1164 break; 1165 1166 case CTDB_CONTROL_MODIFY_FLAGS: 1167 break; 1168 1169 case CTDB_CONTROL_GET_ALL_TUNABLES: 1170 cd->data.tun_list = talloc(mem_ctx, struct ctdb_tunable_list); 1171 assert(cd->data.tun_list != NULL); 1172 fill_ctdb_tunable_list(mem_ctx, cd->data.tun_list); 1173 break; 1174 1175 case CTDB_CONTROL_GET_TCP_TICKLE_LIST: 1176 cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list); 1177 assert(cd->data.tickles != NULL); 1178 fill_ctdb_tickle_list(mem_ctx, cd->data.tickles); 1179 break; 1180 1181 case CTDB_CONTROL_SET_TCP_TICKLE_LIST: 1182 break; 1183 1184 case CTDB_CONTROL_DB_ATTACH_PERSISTENT: 1185 cd->data.db_id = rand32(); 1186 break; 1187 1188 case CTDB_CONTROL_UPDATE_RECORD: 1189 break; 1190 1191 case CTDB_CONTROL_SEND_GRATUITOUS_ARP: 1192 break; 1193 1194 case CTDB_CONTROL_WIPE_DATABASE: 1195 break; 1196 1197 case CTDB_CONTROL_UPTIME: 1198 cd->data.uptime = talloc(mem_ctx, struct ctdb_uptime); 1199 assert(cd->data.uptime != NULL); 1200 fill_ctdb_uptime(mem_ctx, cd->data.uptime); 1201 break; 1202 1203 case CTDB_CONTROL_START_RECOVERY: 1204 break; 1205 1206 case CTDB_CONTROL_END_RECOVERY: 1207 break; 1208 1209 case CTDB_CONTROL_RELOAD_NODES_FILE: 1210 break; 1211 1212 case CTDB_CONTROL_TRY_DELETE_RECORDS: 1213 cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer); 1214 assert(cd->data.recbuf != NULL); 1215 fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf); 1216 break; 1217 1218 case CTDB_CONTROL_ADD_PUBLIC_IP: 1219 break; 1220 1221 case CTDB_CONTROL_DEL_PUBLIC_IP: 1222 break; 1223 1224 case CTDB_CONTROL_GET_CAPABILITIES: 1225 cd->data.caps = rand32(); 1226 break; 1227 1228 case CTDB_CONTROL_RECD_PING: 1229 break; 1230 1231 case CTDB_CONTROL_RELEASE_IP: 1232 break; 1233 1234 case CTDB_CONTROL_TAKEOVER_IP: 1235 break; 1236 1237 case CTDB_CONTROL_GET_PUBLIC_IPS: 1238 cd->data.pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list); 1239 assert(cd->data.pubip_list != NULL); 1240 fill_ctdb_public_ip_list(mem_ctx, cd->data.pubip_list); 1241 break; 1242 1243 case CTDB_CONTROL_GET_NODEMAP: 1244 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map); 1245 assert(cd->data.nodemap != NULL); 1246 fill_ctdb_node_map(mem_ctx, cd->data.nodemap); 1247 break; 1248 1249 case CTDB_CONTROL_TRAVERSE_KILL: 1250 break; 1251 1252 case CTDB_CONTROL_RECD_RECLOCK_LATENCY: 1253 break; 1254 1255 case CTDB_CONTROL_GET_RECLOCK_FILE: 1256 fill_ctdb_string(mem_ctx, &cd->data.reclock_file); 1257 assert(cd->data.reclock_file != NULL); 1258 break; 1259 1260 case CTDB_CONTROL_STOP_NODE: 1261 break; 1262 1263 case CTDB_CONTROL_CONTINUE_NODE: 1264 break; 1265 1266 case CTDB_CONTROL_SET_LMASTERROLE: 1267 break; 1268 1269 case CTDB_CONTROL_SET_RECMASTERROLE: 1270 break; 1271 1272 case CTDB_CONTROL_SET_BAN_STATE: 1273 break; 1274 1275 case CTDB_CONTROL_GET_BAN_STATE: 1276 cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state); 1277 assert(cd->data.ban_state != NULL); 1278 fill_ctdb_ban_state(mem_ctx, cd->data.ban_state); 1279 break; 1280 1281 case CTDB_CONTROL_REGISTER_NOTIFY: 1282 break; 1283 1284 case CTDB_CONTROL_DEREGISTER_NOTIFY: 1285 break; 1286 1287 case CTDB_CONTROL_TRANS3_COMMIT: 1288 break; 1289 1290 case CTDB_CONTROL_GET_DB_SEQNUM: 1291 cd->data.seqnum = rand64(); 1292 break; 1293 1294 case CTDB_CONTROL_DB_SET_HEALTHY: 1295 break; 1296 1297 case CTDB_CONTROL_DB_GET_HEALTH: 1298 fill_ctdb_string(mem_ctx, &cd->data.reason); 1299 assert(cd->data.reason != NULL); 1300 break; 1301 1302 case CTDB_CONTROL_GET_PUBLIC_IP_INFO: 1303 cd->data.ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info); 1304 assert(cd->data.ipinfo != NULL); 1305 fill_ctdb_public_ip_info(mem_ctx, cd->data.ipinfo); 1306 break; 1307 1308 case CTDB_CONTROL_GET_IFACES: 1309 cd->data.iface_list = talloc(mem_ctx, struct ctdb_iface_list); 1310 assert(cd->data.iface_list != NULL); 1311 fill_ctdb_iface_list(mem_ctx, cd->data.iface_list); 1312 break; 1313 1314 case CTDB_CONTROL_SET_IFACE_LINK_STATE: 1315 break; 1316 1317 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE: 1318 break; 1319 1320 case CTDB_CONTROL_GET_STAT_HISTORY: 1321 cd->data.stats_list = talloc(mem_ctx, struct ctdb_statistics_list); 1322 assert(cd->data.stats_list != NULL); 1323 fill_ctdb_statistics_list(mem_ctx, cd->data.stats_list); 1324 break; 1325 1326 case CTDB_CONTROL_SCHEDULE_FOR_DELETION: 1327 break; 1328 1329 case CTDB_CONTROL_SET_DB_READONLY: 1330 break; 1331 1332 case CTDB_CONTROL_TRAVERSE_START_EXT: 1333 break; 1334 1335 case CTDB_CONTROL_GET_DB_STATISTICS: 1336 cd->data.dbstats = talloc(mem_ctx, struct ctdb_db_statistics); 1337 assert(cd->data.dbstats != NULL); 1338 fill_ctdb_db_statistics(mem_ctx, cd->data.dbstats); 1339 break; 1340 1341 case CTDB_CONTROL_SET_DB_STICKY: 1342 break; 1343 1344 case CTDB_CONTROL_RELOAD_PUBLIC_IPS: 1345 break; 1346 1347 case CTDB_CONTROL_TRAVERSE_ALL_EXT: 1348 break; 1349 1350 case CTDB_CONTROL_IPREALLOCATED: 1351 break; 1352 1353 case CTDB_CONTROL_GET_RUNSTATE: 1354 cd->data.runstate = rand32(); 1355 break; 1356 1357 case CTDB_CONTROL_DB_DETACH: 1358 break; 1359 1360 case CTDB_CONTROL_GET_NODES_FILE: 1361 cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map); 1362 assert(cd->data.nodemap != NULL); 1363 fill_ctdb_node_map(mem_ctx, cd->data.nodemap); 1364 break; 1365 1366 case CTDB_CONTROL_DB_PULL: 1367 cd->data.num_records = rand32(); 1368 break; 1369 1370 case CTDB_CONTROL_DB_PUSH_CONFIRM: 1371 cd->data.num_records = rand32(); 1372 break; 1373 1374 case CTDB_CONTROL_DB_OPEN_FLAGS: 1375 cd->data.tdb_flags = rand32(); 1376 break; 1377 1378 case CTDB_CONTROL_DB_ATTACH_REPLICATED: 1379 cd->data.db_id = rand32(); 1380 break; 1381 1382 case CTDB_CONTROL_CHECK_PID_SRVID: 1383 break; 1384 1385 case CTDB_CONTROL_TUNNEL_REGISTER: 1386 break; 1387 1388 case CTDB_CONTROL_TUNNEL_DEREGISTER: 1389 break; 1390 1391 case CTDB_CONTROL_VACUUM_FETCH: 1392 break; 1393 1394 case CTDB_CONTROL_DB_VACUUM: 1395 break; 1396 } 1397 } 1398 1399 void verify_ctdb_reply_control_data(struct ctdb_reply_control_data *cd, 1400 struct ctdb_reply_control_data *cd2) 1401 { 1402 assert(cd->opcode == cd2->opcode); 1403 1404 switch (cd->opcode) { 1405 case CTDB_CONTROL_PROCESS_EXISTS: 1406 break; 1407 1408 case CTDB_CONTROL_STATISTICS: 1409 verify_ctdb_statistics(cd->data.stats, cd2->data.stats); 1410 break; 1411 1412 case CTDB_CONTROL_PING: 1413 break; 1414 1415 case CTDB_CONTROL_GETDBPATH: 1416 verify_ctdb_string(&cd->data.db_path, &cd2->data.db_path); 1417 break; 1418 1419 case CTDB_CONTROL_GETVNNMAP: 1420 verify_ctdb_vnn_map(cd->data.vnnmap, cd2->data.vnnmap); 1421 break; 1422 1423 case CTDB_CONTROL_SETVNNMAP: 1424 break; 1425 1426 case CTDB_CONTROL_GET_DEBUG: 1427 assert(cd->data.loglevel == cd2->data.loglevel); 1428 break; 1429 1430 case CTDB_CONTROL_SET_DEBUG: 1431 break; 1432 1433 case CTDB_CONTROL_GET_DBMAP: 1434 verify_ctdb_dbid_map(cd->data.dbmap, cd2->data.dbmap); 1435 break; 1436 1437 case CTDB_CONTROL_PULL_DB: 1438 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf); 1439 break; 1440 1441 case CTDB_CONTROL_PUSH_DB: 1442 break; 1443 1444 case CTDB_CONTROL_GET_RECMODE: 1445 break; 1446 1447 case CTDB_CONTROL_SET_RECMODE: 1448 break; 1449 1450 case CTDB_CONTROL_STATISTICS_RESET: 1451 break; 1452 1453 case CTDB_CONTROL_DB_ATTACH: 1454 assert(cd->data.db_id == cd2->data.db_id); 1455 break; 1456 1457 case CTDB_CONTROL_TRAVERSE_START: 1458 break; 1459 1460 case CTDB_CONTROL_TRAVERSE_ALL: 1461 break; 1462 1463 case CTDB_CONTROL_TRAVERSE_DATA: 1464 break; 1465 1466 case CTDB_CONTROL_REGISTER_SRVID: 1467 break; 1468 1469 case CTDB_CONTROL_DEREGISTER_SRVID: 1470 break; 1471 1472 case CTDB_CONTROL_GET_DBNAME: 1473 verify_ctdb_string(&cd->data.db_name, &cd2->data.db_name); 1474 break; 1475 1476 case CTDB_CONTROL_ENABLE_SEQNUM: 1477 break; 1478 1479 case CTDB_CONTROL_UPDATE_SEQNUM: 1480 break; 1481 1482 case CTDB_CONTROL_DUMP_MEMORY: 1483 verify_ctdb_string(&cd->data.mem_str, &cd2->data.mem_str); 1484 break; 1485 1486 case CTDB_CONTROL_GET_PID: 1487 break; 1488 1489 case CTDB_CONTROL_GET_RECMASTER: 1490 break; 1491 1492 case CTDB_CONTROL_SET_RECMASTER: 1493 break; 1494 1495 case CTDB_CONTROL_FREEZE: 1496 break; 1497 1498 case CTDB_CONTROL_GET_PNN: 1499 break; 1500 1501 case CTDB_CONTROL_SHUTDOWN: 1502 break; 1503 1504 case CTDB_CONTROL_TCP_CLIENT: 1505 break; 1506 1507 case CTDB_CONTROL_TCP_ADD: 1508 break; 1509 1510 case CTDB_CONTROL_TCP_REMOVE: 1511 break; 1512 1513 case CTDB_CONTROL_STARTUP: 1514 break; 1515 1516 case CTDB_CONTROL_SET_TUNABLE: 1517 break; 1518 1519 case CTDB_CONTROL_GET_TUNABLE: 1520 assert(cd->data.tun_value == cd2->data.tun_value); 1521 break; 1522 1523 case CTDB_CONTROL_LIST_TUNABLES: 1524 verify_ctdb_var_list(cd->data.tun_var_list, 1525 cd2->data.tun_var_list); 1526 break; 1527 1528 case CTDB_CONTROL_MODIFY_FLAGS: 1529 break; 1530 1531 case CTDB_CONTROL_GET_ALL_TUNABLES: 1532 verify_ctdb_tunable_list(cd->data.tun_list, cd2->data.tun_list); 1533 break; 1534 1535 case CTDB_CONTROL_GET_TCP_TICKLE_LIST: 1536 verify_ctdb_tickle_list(cd->data.tickles, cd2->data.tickles); 1537 break; 1538 1539 case CTDB_CONTROL_SET_TCP_TICKLE_LIST: 1540 break; 1541 1542 case CTDB_CONTROL_DB_ATTACH_PERSISTENT: 1543 assert(cd->data.db_id == cd2->data.db_id); 1544 break; 1545 1546 case CTDB_CONTROL_UPDATE_RECORD: 1547 break; 1548 1549 case CTDB_CONTROL_SEND_GRATUITOUS_ARP: 1550 break; 1551 1552 case CTDB_CONTROL_WIPE_DATABASE: 1553 break; 1554 1555 case CTDB_CONTROL_UPTIME: 1556 verify_ctdb_uptime(cd->data.uptime, cd2->data.uptime); 1557 break; 1558 1559 case CTDB_CONTROL_START_RECOVERY: 1560 break; 1561 1562 case CTDB_CONTROL_END_RECOVERY: 1563 break; 1564 1565 case CTDB_CONTROL_RELOAD_NODES_FILE: 1566 break; 1567 1568 case CTDB_CONTROL_TRY_DELETE_RECORDS: 1569 verify_ctdb_rec_buffer(cd->data.recbuf, cd2->data.recbuf); 1570 break; 1571 1572 case CTDB_CONTROL_ADD_PUBLIC_IP: 1573 break; 1574 1575 case CTDB_CONTROL_DEL_PUBLIC_IP: 1576 break; 1577 1578 case CTDB_CONTROL_GET_CAPABILITIES: 1579 assert(cd->data.caps == cd2->data.caps); 1580 break; 1581 1582 case CTDB_CONTROL_RECD_PING: 1583 break; 1584 1585 case CTDB_CONTROL_RELEASE_IP: 1586 break; 1587 1588 case CTDB_CONTROL_TAKEOVER_IP: 1589 break; 1590 1591 case CTDB_CONTROL_GET_PUBLIC_IPS: 1592 verify_ctdb_public_ip_list(cd->data.pubip_list, 1593 cd2->data.pubip_list); 1594 break; 1595 1596 case CTDB_CONTROL_GET_NODEMAP: 1597 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap); 1598 break; 1599 1600 case CTDB_CONTROL_TRAVERSE_KILL: 1601 break; 1602 1603 case CTDB_CONTROL_RECD_RECLOCK_LATENCY: 1604 break; 1605 1606 case CTDB_CONTROL_GET_RECLOCK_FILE: 1607 verify_ctdb_string(&cd->data.reclock_file, 1608 &cd2->data.reclock_file); 1609 break; 1610 1611 case CTDB_CONTROL_STOP_NODE: 1612 break; 1613 1614 case CTDB_CONTROL_CONTINUE_NODE: 1615 break; 1616 1617 case CTDB_CONTROL_SET_LMASTERROLE: 1618 break; 1619 1620 case CTDB_CONTROL_SET_RECMASTERROLE: 1621 break; 1622 1623 case CTDB_CONTROL_SET_BAN_STATE: 1624 break; 1625 1626 case CTDB_CONTROL_GET_BAN_STATE: 1627 verify_ctdb_ban_state(cd->data.ban_state, cd2->data.ban_state); 1628 break; 1629 1630 case CTDB_CONTROL_REGISTER_NOTIFY: 1631 break; 1632 1633 case CTDB_CONTROL_DEREGISTER_NOTIFY: 1634 break; 1635 1636 case CTDB_CONTROL_TRANS3_COMMIT: 1637 break; 1638 1639 case CTDB_CONTROL_GET_DB_SEQNUM: 1640 assert(cd->data.seqnum == cd2->data.seqnum); 1641 break; 1642 1643 case CTDB_CONTROL_DB_SET_HEALTHY: 1644 break; 1645 1646 case CTDB_CONTROL_DB_GET_HEALTH: 1647 verify_ctdb_string(&cd->data.reason, &cd2->data.reason); 1648 break; 1649 1650 case CTDB_CONTROL_GET_PUBLIC_IP_INFO: 1651 verify_ctdb_public_ip_info(cd->data.ipinfo, cd2->data.ipinfo); 1652 break; 1653 1654 case CTDB_CONTROL_GET_IFACES: 1655 verify_ctdb_iface_list(cd->data.iface_list, 1656 cd2->data.iface_list); 1657 break; 1658 1659 case CTDB_CONTROL_SET_IFACE_LINK_STATE: 1660 break; 1661 1662 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE: 1663 break; 1664 1665 case CTDB_CONTROL_GET_STAT_HISTORY: 1666 verify_ctdb_statistics_list(cd->data.stats_list, 1667 cd2->data.stats_list); 1668 break; 1669 1670 case CTDB_CONTROL_SCHEDULE_FOR_DELETION: 1671 break; 1672 1673 case CTDB_CONTROL_SET_DB_READONLY: 1674 break; 1675 1676 case CTDB_CONTROL_TRAVERSE_START_EXT: 1677 break; 1678 1679 case CTDB_CONTROL_GET_DB_STATISTICS: 1680 verify_ctdb_db_statistics(cd->data.dbstats, cd2->data.dbstats); 1681 break; 1682 1683 case CTDB_CONTROL_SET_DB_STICKY: 1684 break; 1685 1686 case CTDB_CONTROL_RELOAD_PUBLIC_IPS: 1687 break; 1688 1689 case CTDB_CONTROL_TRAVERSE_ALL_EXT: 1690 break; 1691 1692 case CTDB_CONTROL_IPREALLOCATED: 1693 break; 1694 1695 case CTDB_CONTROL_GET_RUNSTATE: 1696 assert(cd->data.runstate == cd2->data.runstate); 1697 break; 1698 1699 case CTDB_CONTROL_DB_DETACH: 1700 break; 1701 1702 case CTDB_CONTROL_GET_NODES_FILE: 1703 verify_ctdb_node_map(cd->data.nodemap, cd2->data.nodemap); 1704 break; 1705 1706 case CTDB_CONTROL_DB_PULL: 1707 assert(cd->data.num_records == cd2->data.num_records); 1708 break; 1709 1710 case CTDB_CONTROL_DB_PUSH_CONFIRM: 1711 assert(cd->data.num_records == cd2->data.num_records); 1712 break; 1713 1714 case CTDB_CONTROL_DB_OPEN_FLAGS: 1715 assert(cd->data.tdb_flags == cd2->data.tdb_flags); 1716 break; 1717 1718 case CTDB_CONTROL_DB_ATTACH_REPLICATED: 1719 assert(cd->data.db_id == cd2->data.db_id); 1720 break; 1721 1722 case CTDB_CONTROL_CHECK_PID_SRVID: 1723 break; 1724 1725 case CTDB_CONTROL_TUNNEL_REGISTER: 1726 break; 1727 1728 case CTDB_CONTROL_TUNNEL_DEREGISTER: 1729 break; 1730 1731 case CTDB_CONTROL_VACUUM_FETCH: 1732 break; 1733 1734 case CTDB_CONTROL_DB_VACUUM: 1735 break; 1736 } 1737 } 1738 1739 void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx, 1740 struct ctdb_reply_control *c, uint32_t opcode) 1741 { 1742 c->status = -rand_int(2); 1743 if (c->status == 0) { 1744 c->errmsg = NULL; 1745 fill_ctdb_reply_control_data(mem_ctx, &c->rdata, opcode); 1746 } else { 1747 fill_ctdb_string(mem_ctx, &c->errmsg); 1748 } 1749 } 1750 1751 void verify_ctdb_reply_control(struct ctdb_reply_control *c, 1752 struct ctdb_reply_control *c2) 1753 { 1754 assert(c->status == c2->status); 1755 verify_ctdb_string(&c->errmsg, &c2->errmsg); 1756 if (c->status == 0) { 1757 verify_ctdb_reply_control_data(&c->rdata, &c2->rdata); 1758 } 1759 } 1760 1761 void fill_ctdb_message_data(TALLOC_CTX *mem_ctx, union ctdb_message_data *md, 1762 uint64_t srvid) 1763 { 1764 switch (srvid) { 1765 case CTDB_SRVID_RECONFIGURE: 1766 case CTDB_SRVID_GETLOG: 1767 case CTDB_SRVID_CLEARLOG: 1768 case CTDB_SRVID_RELOAD_NODES: 1769 break; 1770 1771 case CTDB_SRVID_ELECTION: 1772 md->election = talloc(mem_ctx, struct ctdb_election_message); 1773 assert(md->election != NULL); 1774 fill_ctdb_election_message(md->election, md->election); 1775 break; 1776 1777 case CTDB_SRVID_RELEASE_IP: 1778 case CTDB_SRVID_TAKE_IP: 1779 fill_ctdb_string(mem_ctx, &md->ipaddr); 1780 break; 1781 1782 case CTDB_SRVID_SET_NODE_FLAGS: 1783 case CTDB_SRVID_PUSH_NODE_FLAGS: 1784 md->flag_change = talloc(mem_ctx, 1785 struct ctdb_node_flag_change); 1786 assert(md->flag_change != NULL); 1787 fill_ctdb_node_flag_change(md->flag_change, md->flag_change); 1788 break; 1789 1790 case CTDB_SRVID_RECD_UPDATE_IP: 1791 md->pubip = talloc(mem_ctx, struct ctdb_public_ip); 1792 assert(md->pubip != NULL); 1793 fill_ctdb_public_ip(md->pubip, md->pubip); 1794 break; 1795 1796 case CTDB_SRVID_VACUUM_FETCH: 1797 md->recbuf = talloc(mem_ctx, struct ctdb_rec_buffer); 1798 assert(md->recbuf != NULL); 1799 fill_ctdb_rec_buffer(md->recbuf, md->recbuf); 1800 break; 1801 1802 case CTDB_SRVID_DETACH_DATABASE: 1803 md->db_id = rand32(); 1804 break; 1805 1806 case CTDB_SRVID_MEM_DUMP: 1807 case CTDB_SRVID_TAKEOVER_RUN: 1808 md->msg = talloc(mem_ctx, struct ctdb_srvid_message); 1809 assert(md->msg != NULL); 1810 fill_ctdb_srvid_message(md->msg, md->msg); 1811 break; 1812 1813 case CTDB_SRVID_BANNING: 1814 case CTDB_SRVID_REBALANCE_NODE: 1815 md->pnn = rand32(); 1816 break; 1817 1818 case CTDB_SRVID_DISABLE_TAKEOVER_RUNS: 1819 case CTDB_SRVID_DISABLE_RECOVERIES: 1820 md->disable = talloc(mem_ctx, struct ctdb_disable_message); 1821 assert(md->disable != NULL); 1822 fill_ctdb_disable_message(md->disable, md->disable); 1823 break; 1824 1825 case CTDB_SRVID_DISABLE_IP_CHECK: 1826 md->timeout = rand32(); 1827 break; 1828 1829 default: 1830 abort(); 1831 } 1832 } 1833 1834 void verify_ctdb_message_data(union ctdb_message_data *md, 1835 union ctdb_message_data *md2, uint64_t srvid) 1836 { 1837 switch (srvid) { 1838 case CTDB_SRVID_RECONFIGURE: 1839 case CTDB_SRVID_GETLOG: 1840 case CTDB_SRVID_CLEARLOG: 1841 case CTDB_SRVID_RELOAD_NODES: 1842 break; 1843 1844 case CTDB_SRVID_ELECTION: 1845 verify_ctdb_election_message(md->election, md2->election); 1846 break; 1847 1848 case CTDB_SRVID_RELEASE_IP: 1849 case CTDB_SRVID_TAKE_IP: 1850 verify_ctdb_string(&md->ipaddr, &md2->ipaddr); 1851 break; 1852 1853 case CTDB_SRVID_SET_NODE_FLAGS: 1854 case CTDB_SRVID_PUSH_NODE_FLAGS: 1855 verify_ctdb_node_flag_change(md->flag_change, 1856 md2->flag_change); 1857 break; 1858 1859 case CTDB_SRVID_RECD_UPDATE_IP: 1860 verify_ctdb_public_ip(md->pubip, md2->pubip); 1861 break; 1862 1863 case CTDB_SRVID_VACUUM_FETCH: 1864 verify_ctdb_rec_buffer(md->recbuf, md2->recbuf); 1865 break; 1866 1867 case CTDB_SRVID_DETACH_DATABASE: 1868 assert(md->db_id == md2->db_id); 1869 break; 1870 1871 case CTDB_SRVID_MEM_DUMP: 1872 case CTDB_SRVID_TAKEOVER_RUN: 1873 verify_ctdb_srvid_message(md->msg, md2->msg); 1874 break; 1875 1876 case CTDB_SRVID_BANNING: 1877 case CTDB_SRVID_REBALANCE_NODE: 1878 assert(md->pnn == md2->pnn); 1879 break; 1880 1881 case CTDB_SRVID_DISABLE_TAKEOVER_RUNS: 1882 case CTDB_SRVID_DISABLE_RECOVERIES: 1883 verify_ctdb_disable_message(md->disable, md2->disable); 1884 break; 1885 1886 case CTDB_SRVID_DISABLE_IP_CHECK: 1887 assert(md->timeout == md2->timeout); 1888 break; 1889 1890 default: 1891 abort(); 1892 } 1893 } 1894 1895 void fill_ctdb_req_message(TALLOC_CTX *mem_ctx, struct ctdb_req_message *c, 1896 uint64_t srvid) 1897 { 1898 c->srvid = srvid; 1899 fill_ctdb_message_data(mem_ctx, &c->data, srvid); 1900 } 1901 1902 void verify_ctdb_req_message(struct ctdb_req_message *c, 1903 struct ctdb_req_message *c2) 1904 { 1905 assert(c->srvid == c2->srvid); 1906 verify_ctdb_message_data(&c->data, &c2->data, c->srvid); 1907 } 1908 1909 void fill_ctdb_req_message_data(TALLOC_CTX *mem_ctx, 1910 struct ctdb_req_message_data *c) 1911 { 1912 c->srvid = rand64(); 1913 fill_tdb_data(mem_ctx, &c->data); 1914 } 1915 1916 void verify_ctdb_req_message_data(struct ctdb_req_message_data *c, 1917 struct ctdb_req_message_data *c2) 1918 { 1919 assert(c->srvid == c2->srvid); 1920 verify_tdb_data(&c->data, &c2->data); 1921 } 1922 1923 void fill_ctdb_req_keepalive(TALLOC_CTX *mem_ctx, 1924 struct ctdb_req_keepalive *c) 1925 { 1926 c->version = rand32(); 1927 c->uptime = rand32(); 1928 } 1929 1930 void verify_ctdb_req_keepalive(struct ctdb_req_keepalive *c, 1931 struct ctdb_req_keepalive *c2) 1932 { 1933 assert(c->version == c2->version); 1934 assert(c->uptime == c2->uptime); 1935 } 1936 1937 void fill_ctdb_req_tunnel(TALLOC_CTX *mem_ctx, struct ctdb_req_tunnel *c) 1938 { 1939 c->tunnel_id = rand64(); 1940 c->flags = rand32(); 1941 fill_tdb_data(mem_ctx, &c->data); 1942 } 1943 1944 void verify_ctdb_req_tunnel(struct ctdb_req_tunnel *c, 1945 struct ctdb_req_tunnel *c2) 1946 { 1947 assert(c->tunnel_id == c2->tunnel_id); 1948 assert(c->flags == c2->flags); 1949 verify_tdb_data(&c->data, &c2->data); 1950 } 1951