ctdb/protocol/protocol_control.c

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