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         case CTDB_CONTROL_DB_OPEN_FLAGS:
 431                 len = ctdb_uint32_len(cd->data.db_id);
 432                 break;
 433         }
 434
 435         return len;
 436 }
 437
 438 static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
 439                                        uint8_t *buf)
 440 {
 441         switch (cd->opcode) {
 442         case CTDB_CONTROL_PROCESS_EXISTS:
 443                 ctdb_pid_push(cd->data.pid, buf);
 444                 break;
 445
 446         case CTDB_CONTROL_GETDBPATH:
 447                 ctdb_uint32_push(cd->data.db_id, buf);
 448                 break;
 449
 450         case CTDB_CONTROL_SETVNNMAP:
 451                 ctdb_vnn_map_push(cd->data.vnnmap, buf);
 452                 break;
 453
 454         case CTDB_CONTROL_SET_DEBUG:
 455                 ctdb_uint32_push(cd->data.loglevel, buf);
 456                 break;
 457
 458         case CTDB_CONTROL_PULL_DB:
 459                 ctdb_pulldb_push(cd->data.pulldb, buf);
 460                 break;
 461
 462         case CTDB_CONTROL_PUSH_DB:
 463                 ctdb_rec_buffer_push(cd->data.recbuf, buf);
 464                 break;
 465
 466         case CTDB_CONTROL_SET_RECMODE:
 467                 ctdb_uint32_push(cd->data.recmode, buf);
 468                 break;
 469
 470         case CTDB_CONTROL_DB_ATTACH:
 471                 ctdb_string_push(cd->data.db_name, buf);
 472                 break;
 473
 474         case CTDB_CONTROL_SET_CALL:
 475                 break;
 476
 477         case CTDB_CONTROL_TRAVERSE_START:
 478                 ctdb_traverse_start_push(cd->data.traverse_start, buf);
 479                 break;
 480
 481         case CTDB_CONTROL_TRAVERSE_ALL:
 482                 ctdb_traverse_all_push(cd->data.traverse_all, buf);
 483                 break;
 484
 485         case CTDB_CONTROL_TRAVERSE_DATA:
 486                 ctdb_rec_data_push(cd->data.rec_data, buf);
 487                 break;
 488
 489         case CTDB_CONTROL_GET_DBNAME:
 490                 ctdb_uint32_push(cd->data.db_id, buf);
 491                 break;
 492
 493         case CTDB_CONTROL_ENABLE_SEQNUM:
 494                 ctdb_uint32_push(cd->data.db_id, buf);
 495                 break;
 496
 497         case CTDB_CONTROL_UPDATE_SEQNUM:
 498                 ctdb_uint32_push(cd->data.db_id, buf);
 499                 break;
 500
 501         case CTDB_CONTROL_SET_RECMASTER:
 502                 ctdb_uint32_push(cd->data.recmaster, buf);
 503                 break;
 504
 505         case CTDB_CONTROL_TCP_CLIENT:
 506                 ctdb_connection_push(cd->data.conn, buf);
 507                 break;
 508
 509         case CTDB_CONTROL_TCP_ADD:
 510                 ctdb_connection_push(cd->data.conn, buf);
 511                 break;
 512
 513         case CTDB_CONTROL_TCP_REMOVE:
 514                 ctdb_connection_push(cd->data.conn, buf);
 515                 break;
 516
 517         case CTDB_CONTROL_SET_TUNABLE:
 518                 ctdb_tunable_push(cd->data.tunable, buf);
 519                 break;
 520
 521         case CTDB_CONTROL_GET_TUNABLE:
 522                 ctdb_stringn_push(cd->data.tun_var, buf);
 523                 break;
 524
 525         case CTDB_CONTROL_MODIFY_FLAGS:
 526                 ctdb_node_flag_change_push(cd->data.flag_change, buf);
 527                 break;
 528
 529         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 530                 ctdb_sock_addr_push(cd->data.addr, buf);
 531                 break;
 532
 533         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 534                 ctdb_tickle_list_push(cd->data.tickles, buf);
 535                 break;
 536
 537         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 538                 ctdb_string_push(cd->data.db_name, buf);
 539                 break;
 540
 541         case CTDB_CONTROL_UPDATE_RECORD:
 542                 ctdb_rec_buffer_push(cd->data.recbuf, buf);
 543                 break;
 544
 545         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 546                 ctdb_addr_info_push(cd->data.addr_info, buf);
 547                 break;
 548
 549         case CTDB_CONTROL_WIPE_DATABASE:
 550                 ctdb_transdb_push(cd->data.transdb, buf);
 551                 break;
 552
 553         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 554                 ctdb_rec_buffer_push(cd->data.recbuf, buf);
 555                 break;
 556
 557         case CTDB_CONTROL_ADD_PUBLIC_IP:
 558                 ctdb_addr_info_push(cd->data.addr_info, buf);
 559                 break;
 560
 561         case CTDB_CONTROL_DEL_PUBLIC_IP:
 562                 ctdb_addr_info_push(cd->data.addr_info, buf);
 563                 break;
 564
 565         case CTDB_CONTROL_RELEASE_IP:
 566                 ctdb_public_ip_push(cd->data.pubip, buf);
 567                 break;
 568
 569         case CTDB_CONTROL_TAKEOVER_IP:
 570                 ctdb_public_ip_push(cd->data.pubip, buf);
 571                 break;
 572
 573         case CTDB_CONTROL_TRAVERSE_KILL:
 574                 ctdb_traverse_start_push(cd->data.traverse_start, buf);
 575                 break;
 576
 577         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 578                 ctdb_double_push(cd->data.reclock_latency, buf);
 579                 break;
 580
 581         case CTDB_CONTROL_SET_LMASTERROLE:
 582                 ctdb_uint32_push(cd->data.role, buf);
 583                 break;
 584
 585         case CTDB_CONTROL_SET_RECMASTERROLE:
 586                 ctdb_uint32_push(cd->data.role, buf);
 587                 break;
 588
 589         case CTDB_CONTROL_SET_BAN_STATE:
 590                 ctdb_ban_state_push(cd->data.ban_state, buf);
 591                 break;
 592
 593         case CTDB_CONTROL_REGISTER_NOTIFY:
 594                 ctdb_notify_data_push(cd->data.notify, buf);
 595                 break;
 596
 597         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 598                 ctdb_uint64_push(cd->data.srvid, buf);
 599                 break;
 600
 601         case CTDB_CONTROL_TRANS3_COMMIT:
 602                 ctdb_rec_buffer_push(cd->data.recbuf, buf);
 603                 break;
 604
 605         case CTDB_CONTROL_GET_DB_SEQNUM:
 606                 ctdb_uint32_push(cd->data.db_id, buf);
 607                 break;
 608
 609         case CTDB_CONTROL_DB_SET_HEALTHY:
 610                 ctdb_uint32_push(cd->data.db_id, buf);
 611                 break;
 612
 613         case CTDB_CONTROL_DB_GET_HEALTH:
 614                 ctdb_uint32_push(cd->data.db_id, buf);
 615                 break;
 616
 617         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 618                 ctdb_sock_addr_push(cd->data.addr, buf);
 619                 break;
 620
 621         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 622                 ctdb_iface_push(cd->data.iface, buf);
 623                 break;
 624
 625         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 626                 ctdb_connection_push(cd->data.conn, buf);
 627                 break;
 628
 629         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 630                 ctdb_key_data_push(cd->data.key, buf);
 631                 break;
 632
 633         case CTDB_CONTROL_SET_DB_READONLY:
 634                 ctdb_uint32_push(cd->data.db_id, buf);
 635                 break;
 636
 637         case CTDB_CONTROL_CHECK_SRVIDS:
 638                 ctdb_uint64_array_push(cd->data.u64_array, buf);
 639                 break;
 640
 641         case CTDB_CONTROL_TRAVERSE_START_EXT:
 642                 ctdb_traverse_start_ext_push(cd->data.traverse_start_ext, buf);
 643                 break;
 644
 645         case CTDB_CONTROL_GET_DB_STATISTICS:
 646                 ctdb_uint32_push(cd->data.db_id, buf);
 647                 break;
 648
 649         case CTDB_CONTROL_SET_DB_STICKY:
 650                 ctdb_uint32_push(cd->data.db_id, buf);
 651                 break;
 652
 653         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 654                 ctdb_traverse_all_ext_push(cd->data.traverse_all_ext, buf);
 655                 break;
 656
 657         case CTDB_CONTROL_RECEIVE_RECORDS:
 658                 ctdb_rec_buffer_push(cd->data.recbuf, buf);
 659                 break;
 660
 661         case CTDB_CONTROL_DB_DETACH:
 662                 ctdb_uint32_push(cd->data.db_id, buf);
 663                 break;
 664
 665         case CTDB_CONTROL_DB_FREEZE:
 666                 ctdb_uint32_push(cd->data.db_id, buf);
 667                 break;
 668
 669         case CTDB_CONTROL_DB_THAW:
 670                 ctdb_uint32_push(cd->data.db_id, buf);
 671                 break;
 672
 673         case CTDB_CONTROL_DB_TRANSACTION_START:
 674                 ctdb_transdb_push(cd->data.transdb, buf);
 675                 break;
 676
 677         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
 678                 ctdb_transdb_push(cd->data.transdb, buf);
 679                 break;
 680
 681         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
 682                 ctdb_uint32_push(cd->data.db_id, buf);
 683                 break;
 684
 685         case CTDB_CONTROL_DB_PULL:
 686                 ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf);
 687                 break;
 688
 689         case CTDB_CONTROL_DB_PUSH_START:
 690                 ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf);
 691                 break;
 692
 693         case CTDB_CONTROL_DB_PUSH_CONFIRM:
 694                 ctdb_uint32_push(cd->data.db_id, buf);
 695                 break;
 696
 697         case CTDB_CONTROL_DB_OPEN_FLAGS:
 698                 ctdb_uint32_push(cd->data.db_id, buf);
 699                 break;
 700         }
 701 }
 702
 703 static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
 704                                       uint32_t opcode,
 705                                       TALLOC_CTX *mem_ctx,
 706                                       struct ctdb_req_control_data *cd)
 707 {
 708         int ret = 0;
 709
 710         cd->opcode = opcode;
 711
 712         switch (opcode) {
 713         case CTDB_CONTROL_PROCESS_EXISTS:
 714                 ret = ctdb_pid_pull(buf, buflen, mem_ctx,
 715                                     &cd->data.pid);
 716                 break;
 717
 718         case CTDB_CONTROL_GETDBPATH:
 719                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 720                                      &cd->data.db_id);
 721                 break;
 722
 723         case CTDB_CONTROL_SETVNNMAP:
 724                 ret = ctdb_vnn_map_pull(buf, buflen, mem_ctx,
 725                                         &cd->data.vnnmap);
 726                 break;
 727
 728         case CTDB_CONTROL_SET_DEBUG:
 729                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 730                                      &cd->data.loglevel);
 731                 break;
 732
 733         case CTDB_CONTROL_PULL_DB:
 734                 ret = ctdb_pulldb_pull(buf, buflen, mem_ctx,
 735                                        &cd->data.pulldb);
 736                 break;
 737
 738         case CTDB_CONTROL_PUSH_DB:
 739                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 740                                            &cd->data.recbuf);
 741                 break;
 742
 743         case CTDB_CONTROL_SET_RECMODE:
 744                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 745                                      &cd->data.recmode);
 746                 break;
 747
 748         case CTDB_CONTROL_DB_ATTACH:
 749                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
 750                                        &cd->data.db_name);
 751                 break;
 752
 753         case CTDB_CONTROL_SET_CALL:
 754                 break;
 755
 756         case CTDB_CONTROL_TRAVERSE_START:
 757                 ret = ctdb_traverse_start_pull(buf, buflen, mem_ctx,
 758                                                &cd->data.traverse_start);
 759                 break;
 760
 761         case CTDB_CONTROL_TRAVERSE_ALL:
 762                 ret = ctdb_traverse_all_pull(buf, buflen, mem_ctx,
 763                                              &cd->data.traverse_all);
 764                 break;
 765
 766         case CTDB_CONTROL_TRAVERSE_DATA:
 767                 ret = ctdb_rec_data_pull(buf, buflen, mem_ctx,
 768                                          &cd->data.rec_data);
 769                 break;
 770
 771         case CTDB_CONTROL_GET_DBNAME:
 772                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 773                                      &cd->data.db_id);
 774                 break;
 775
 776         case CTDB_CONTROL_ENABLE_SEQNUM:
 777                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 778                                      &cd->data.db_id);
 779                 break;
 780
 781         case CTDB_CONTROL_UPDATE_SEQNUM:
 782                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 783                                      &cd->data.db_id);
 784                 break;
 785
 786         case CTDB_CONTROL_SET_RECMASTER:
 787                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 788                                      &cd->data.recmaster);
 789                 break;
 790
 791         case CTDB_CONTROL_TCP_CLIENT:
 792                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 793                                            &cd->data.conn);
 794                 break;
 795
 796         case CTDB_CONTROL_TCP_ADD:
 797                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 798                                            &cd->data.conn);
 799                 break;
 800
 801         case CTDB_CONTROL_TCP_REMOVE:
 802                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 803                                            &cd->data.conn);
 804                 break;
 805
 806         case CTDB_CONTROL_SET_TUNABLE:
 807                 ret = ctdb_tunable_pull(buf, buflen, mem_ctx,
 808                                         &cd->data.tunable);
 809                 break;
 810
 811         case CTDB_CONTROL_GET_TUNABLE:
 812                 ret = ctdb_stringn_pull(buf, buflen, mem_ctx,
 813                                         &cd->data.tun_var);
 814                 break;
 815
 816         case CTDB_CONTROL_MODIFY_FLAGS:
 817                 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
 818                                                  &cd->data.flag_change);
 819                 break;
 820
 821         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 822                 ret = ctdb_sock_addr_pull(buf, buflen, mem_ctx,
 823                                           &cd->data.addr);
 824                 break;
 825
 826         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 827                 ret = ctdb_tickle_list_pull(buf, buflen, mem_ctx,
 828                                             &cd->data.tickles);
 829                 break;
 830
 831         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 832                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
 833                                        &cd->data.db_name);
 834                 break;
 835
 836         case CTDB_CONTROL_UPDATE_RECORD:
 837                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 838                                            &cd->data.recbuf);
 839                 break;
 840
 841         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 842                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 843                                           &cd->data.addr_info);
 844                 break;
 845
 846         case CTDB_CONTROL_WIPE_DATABASE:
 847                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
 848                                        &cd->data.transdb);
 849                 break;
 850
 851         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 852                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 853                                            &cd->data.recbuf);
 854                 break;
 855
 856         case CTDB_CONTROL_ADD_PUBLIC_IP:
 857                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 858                                           &cd->data.addr_info);
 859                 break;
 860
 861         case CTDB_CONTROL_DEL_PUBLIC_IP:
 862                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 863                                           &cd->data.addr_info);
 864                 break;
 865
 866         case CTDB_CONTROL_RELEASE_IP:
 867                 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
 868                                           &cd->data.pubip);
 869                 break;
 870
 871         case CTDB_CONTROL_TAKEOVER_IP:
 872                 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
 873                                           &cd->data.pubip);
 874                 break;
 875
 876         case CTDB_CONTROL_TRAVERSE_KILL:
 877                 ret = ctdb_traverse_start_pull(buf, buflen, mem_ctx,
 878                                                &cd->data.traverse_start);
 879                 break;
 880
 881         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 882                 ret = ctdb_double_pull(buf, buflen, mem_ctx,
 883                                        &cd->data.reclock_latency);
 884                 break;
 885
 886         case CTDB_CONTROL_SET_LMASTERROLE:
 887                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 888                                      &cd->data.role);
 889                 break;
 890
 891         case CTDB_CONTROL_SET_RECMASTERROLE:
 892                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 893                                      &cd->data.role);
 894                 break;
 895
 896         case CTDB_CONTROL_SET_BAN_STATE:
 897                 ret = ctdb_ban_state_pull(buf, buflen, mem_ctx,
 898                                           &cd->data.ban_state);
 899                 break;
 900
 901         case CTDB_CONTROL_REGISTER_NOTIFY:
 902                 ret = ctdb_notify_data_pull(buf, buflen, mem_ctx,
 903                                             &cd->data.notify);
 904                 break;
 905
 906         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 907                 ctdb_uint64_pull(buf, buflen, mem_ctx,
 908                                  &cd->data.srvid);
 909                 break;
 910
 911         case CTDB_CONTROL_TRANS3_COMMIT:
 912                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 913                                            &cd->data.recbuf);
 914                 break;
 915
 916         case CTDB_CONTROL_GET_DB_SEQNUM:
 917                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 918                                        &cd->data.db_id);
 919                 break;
 920
 921         case CTDB_CONTROL_DB_SET_HEALTHY:
 922                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 923                                      &cd->data.db_id);
 924                 break;
 925
 926         case CTDB_CONTROL_DB_GET_HEALTH:
 927                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 928                                      &cd->data.db_id);
 929                 break;
 930
 931         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 932                 ret = ctdb_sock_addr_pull(buf, buflen, mem_ctx,
 933                                           &cd->data.addr);
 934                 break;
 935
 936         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 937                 ret = ctdb_iface_pull(buf, buflen, mem_ctx,
 938                                       &cd->data.iface);
 939                 break;
 940
 941         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 942                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 943                                            &cd->data.conn);
 944                 break;
 945
 946         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 947                 ret = ctdb_key_data_pull(buf, buflen, mem_ctx,
 948                                          &cd->data.key);
 949                 break;
 950
 951         case CTDB_CONTROL_SET_DB_READONLY:
 952                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 953                                      &cd->data.db_id);
 954                 break;
 955
 956         case CTDB_CONTROL_CHECK_SRVIDS:
 957                 ret = ctdb_uint64_array_pull(buf, buflen, mem_ctx,
 958                                              &cd->data.u64_array);
 959                 break;
 960
 961         case CTDB_CONTROL_TRAVERSE_START_EXT:
 962                 ret = ctdb_traverse_start_ext_pull(buf, buflen, mem_ctx,
 963                                                    &cd->data.traverse_start_ext);
 964                 break;
 965
 966         case CTDB_CONTROL_GET_DB_STATISTICS:
 967                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 968                                        &cd->data.db_id);
 969                 break;
 970
 971         case CTDB_CONTROL_SET_DB_STICKY:
 972                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 973                                        &cd->data.db_id);
 974                 break;
 975
 976         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 977                 ret = ctdb_traverse_all_ext_pull(buf, buflen, mem_ctx,
 978                                                  &cd->data.traverse_all_ext);
 979                 break;
 980
 981         case CTDB_CONTROL_RECEIVE_RECORDS:
 982                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 983                                            &cd->data.recbuf);
 984                 break;
 985
 986         case CTDB_CONTROL_DB_DETACH:
 987                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 988                                        &cd->data.db_id);
 989                 break;
 990
 991         case CTDB_CONTROL_DB_FREEZE:
 992                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 993                                        &cd->data.db_id);
 994                 break;
 995
 996         case CTDB_CONTROL_DB_THAW:
 997                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
 998                                        &cd->data.db_id);
 999                 break;
1000
1001         case CTDB_CONTROL_DB_TRANSACTION_START:
1002                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
1003                                         &cd->data.transdb);
1004                 break;
1005
1006         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
1007                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
1008                                         &cd->data.transdb);
1009                 break;
1010
1011         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
1012                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1013                                         &cd->data.db_id);
1014                 break;
1015
1016         case CTDB_CONTROL_DB_PULL:
1017                 ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
1018                                            &cd->data.pulldb_ext);
1019                 break;
1020
1021         case CTDB_CONTROL_DB_PUSH_START:
1022                 ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
1023                                            &cd->data.pulldb_ext);
1024                 break;
1025
1026         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1027                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1028                                        &cd->data.db_id);
1029                 break;
1030
1031         case CTDB_CONTROL_DB_OPEN_FLAGS:
1032                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1033                                        &cd->data.db_id);
1034                 break;
1035         }
1036
1037         return ret;
1038 }
1039
1040 static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
1041 {
1042         size_t len = 0;
1043
1044         if (cd == NULL) {
1045                 return 0;
1046         }
1047
1048         switch (cd->opcode) {
1049         case CTDB_CONTROL_PROCESS_EXISTS:
1050                 break;
1051
1052         case CTDB_CONTROL_STATISTICS:
1053                 len = ctdb_statistics_len(cd->data.stats);
1054                 break;
1055
1056         case CTDB_CONTROL_PING:
1057                 break;
1058
1059         case CTDB_CONTROL_GETDBPATH:
1060                 len = ctdb_string_len(cd->data.db_path);
1061                 break;
1062
1063         case CTDB_CONTROL_GETVNNMAP:
1064                 len = ctdb_vnn_map_len(cd->data.vnnmap);
1065                 break;
1066
1067         case CTDB_CONTROL_SETVNNMAP:
1068                 break;
1069
1070         case CTDB_CONTROL_GET_DEBUG:
1071                 len = ctdb_uint32_len(cd->data.loglevel);
1072                 break;
1073
1074         case CTDB_CONTROL_SET_DEBUG:
1075                 break;
1076
1077         case CTDB_CONTROL_GET_DBMAP:
1078                 len = ctdb_dbid_map_len(cd->data.dbmap);
1079                 break;
1080
1081         case CTDB_CONTROL_PULL_DB:
1082                 len = ctdb_rec_buffer_len(cd->data.recbuf);
1083                 break;
1084
1085         case CTDB_CONTROL_PUSH_DB:
1086                 break;
1087
1088         case CTDB_CONTROL_GET_RECMODE:
1089                 break;
1090
1091         case CTDB_CONTROL_SET_RECMODE:
1092                 break;
1093
1094         case CTDB_CONTROL_STATISTICS_RESET:
1095                 break;
1096
1097         case CTDB_CONTROL_DB_ATTACH:
1098                 len = ctdb_uint32_len(cd->data.db_id);
1099                 break;
1100
1101         case CTDB_CONTROL_SET_CALL:
1102                 break;
1103
1104         case CTDB_CONTROL_TRAVERSE_START:
1105                 break;
1106
1107         case CTDB_CONTROL_TRAVERSE_ALL:
1108                 break;
1109
1110         case CTDB_CONTROL_TRAVERSE_DATA:
1111                 break;
1112
1113         case CTDB_CONTROL_REGISTER_SRVID:
1114                 break;
1115
1116         case CTDB_CONTROL_DEREGISTER_SRVID:
1117                 break;
1118
1119         case CTDB_CONTROL_GET_DBNAME:
1120                 len = ctdb_string_len(cd->data.db_name);
1121                 break;
1122
1123         case CTDB_CONTROL_ENABLE_SEQNUM:
1124                 break;
1125
1126         case CTDB_CONTROL_UPDATE_SEQNUM:
1127                 break;
1128
1129         case CTDB_CONTROL_DUMP_MEMORY:
1130                 len = ctdb_string_len(cd->data.mem_str);
1131                 break;
1132
1133         case CTDB_CONTROL_GET_PID:
1134                 break;
1135
1136         case CTDB_CONTROL_GET_RECMASTER:
1137                 break;
1138
1139         case CTDB_CONTROL_SET_RECMASTER:
1140                 break;
1141
1142         case CTDB_CONTROL_FREEZE:
1143                 break;
1144
1145         case CTDB_CONTROL_GET_PNN:
1146                 break;
1147
1148         case CTDB_CONTROL_SHUTDOWN:
1149                 break;
1150
1151         case CTDB_CONTROL_GET_MONMODE:
1152                 break;
1153
1154         case CTDB_CONTROL_TCP_CLIENT:
1155                 break;
1156
1157         case CTDB_CONTROL_TCP_ADD:
1158                 break;
1159
1160         case CTDB_CONTROL_TCP_REMOVE:
1161                 break;
1162
1163         case CTDB_CONTROL_STARTUP:
1164                 break;
1165
1166         case CTDB_CONTROL_SET_TUNABLE:
1167                 break;
1168
1169         case CTDB_CONTROL_GET_TUNABLE:
1170                 len = ctdb_uint32_len(cd->data.tun_value);
1171                 break;
1172
1173         case CTDB_CONTROL_LIST_TUNABLES:
1174                 len = ctdb_var_list_len(cd->data.tun_var_list);
1175                 break;
1176
1177         case CTDB_CONTROL_MODIFY_FLAGS:
1178                 break;
1179
1180         case CTDB_CONTROL_GET_ALL_TUNABLES:
1181                 len = ctdb_tunable_list_len(cd->data.tun_list);
1182                 break;
1183
1184         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1185                 len = ctdb_tickle_list_len(cd->data.tickles);
1186                 break;
1187
1188         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1189                 break;
1190
1191         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1192                 len = ctdb_uint32_len(cd->data.db_id);
1193                 break;
1194
1195         case CTDB_CONTROL_UPDATE_RECORD:
1196                 break;
1197
1198         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1199                 break;
1200
1201         case CTDB_CONTROL_WIPE_DATABASE:
1202                 break;
1203
1204         case CTDB_CONTROL_UPTIME:
1205                 len = ctdb_uptime_len(cd->data.uptime);
1206                 break;
1207
1208         case CTDB_CONTROL_START_RECOVERY:
1209                 break;
1210
1211         case CTDB_CONTROL_END_RECOVERY:
1212                 break;
1213
1214         case CTDB_CONTROL_RELOAD_NODES_FILE:
1215                 break;
1216
1217         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1218                 len = ctdb_rec_buffer_len(cd->data.recbuf);
1219                 break;
1220
1221         case CTDB_CONTROL_ENABLE_MONITOR:
1222                 break;
1223
1224         case CTDB_CONTROL_DISABLE_MONITOR:
1225                 break;
1226
1227         case CTDB_CONTROL_ADD_PUBLIC_IP:
1228                 break;
1229
1230         case CTDB_CONTROL_DEL_PUBLIC_IP:
1231                 break;
1232
1233         case CTDB_CONTROL_GET_CAPABILITIES:
1234                 len = ctdb_uint32_len(cd->data.caps);
1235                 break;
1236
1237         case CTDB_CONTROL_RECD_PING:
1238                 break;
1239
1240         case CTDB_CONTROL_RELEASE_IP:
1241                 break;
1242
1243         case CTDB_CONTROL_TAKEOVER_IP:
1244                 break;
1245
1246         case CTDB_CONTROL_GET_PUBLIC_IPS:
1247                 len = ctdb_public_ip_list_len(cd->data.pubip_list);
1248                 break;
1249
1250         case CTDB_CONTROL_GET_NODEMAP:
1251                 len = ctdb_node_map_len(cd->data.nodemap);
1252                 break;
1253
1254         case CTDB_CONTROL_TRAVERSE_KILL:
1255                 break;
1256
1257         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1258                 break;
1259
1260         case CTDB_CONTROL_GET_RECLOCK_FILE:
1261                 len = ctdb_string_len(cd->data.reclock_file);
1262                 break;
1263
1264         case CTDB_CONTROL_STOP_NODE:
1265                 break;
1266
1267         case CTDB_CONTROL_CONTINUE_NODE:
1268                 break;
1269
1270         case CTDB_CONTROL_SET_LMASTERROLE:
1271                 break;
1272
1273         case CTDB_CONTROL_SET_RECMASTERROLE:
1274                 break;
1275
1276         case CTDB_CONTROL_SET_BAN_STATE:
1277                 break;
1278
1279         case CTDB_CONTROL_GET_BAN_STATE:
1280                 len = ctdb_ban_state_len(cd->data.ban_state);
1281                 break;
1282
1283         case CTDB_CONTROL_SET_DB_PRIORITY:
1284                 break;
1285
1286         case CTDB_CONTROL_GET_DB_PRIORITY:
1287                 break;
1288
1289         case CTDB_CONTROL_REGISTER_NOTIFY:
1290                 break;
1291
1292         case CTDB_CONTROL_DEREGISTER_NOTIFY:
1293                 break;
1294
1295         case CTDB_CONTROL_TRANS3_COMMIT:
1296                 break;
1297
1298         case CTDB_CONTROL_GET_DB_SEQNUM:
1299                 len = ctdb_uint64_len(cd->data.seqnum);
1300                 break;
1301
1302         case CTDB_CONTROL_DB_SET_HEALTHY:
1303                 break;
1304
1305         case CTDB_CONTROL_DB_GET_HEALTH:
1306                 len = ctdb_string_len(cd->data.reason);
1307                 break;
1308
1309         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1310                 len = ctdb_public_ip_info_len(cd->data.ipinfo);
1311                 break;
1312
1313         case CTDB_CONTROL_GET_IFACES:
1314                 len = ctdb_iface_list_len(cd->data.iface_list);
1315                 break;
1316
1317         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1318                 break;
1319
1320         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1321                 break;
1322
1323         case CTDB_CONTROL_GET_STAT_HISTORY:
1324                 len = ctdb_statistics_list_len(cd->data.stats_list);
1325                 break;
1326
1327         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1328                 break;
1329
1330         case CTDB_CONTROL_SET_DB_READONLY:
1331                 break;
1332
1333         case CTDB_CONTROL_CHECK_SRVIDS:
1334                 len = ctdb_uint8_array_len(cd->data.u8_array);
1335                 break;
1336
1337         case CTDB_CONTROL_TRAVERSE_START_EXT:
1338                 break;
1339
1340         case CTDB_CONTROL_GET_DB_STATISTICS:
1341                 len = ctdb_db_statistics_len(cd->data.dbstats);
1342                 break;
1343
1344         case CTDB_CONTROL_SET_DB_STICKY:
1345                 break;
1346
1347         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1348                 break;
1349
1350         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1351                 break;
1352
1353         case CTDB_CONTROL_RECEIVE_RECORDS:
1354                 len = ctdb_rec_buffer_len(cd->data.recbuf);
1355                 break;
1356
1357         case CTDB_CONTROL_IPREALLOCATED:
1358                 break;
1359
1360         case CTDB_CONTROL_GET_RUNSTATE:
1361                 len = ctdb_uint32_len(cd->data.runstate);
1362                 break;
1363
1364         case CTDB_CONTROL_DB_DETACH:
1365                 break;
1366
1367         case CTDB_CONTROL_GET_NODES_FILE:
1368                 len = ctdb_node_map_len(cd->data.nodemap);
1369                 break;
1370
1371         case CTDB_CONTROL_DB_FREEZE:
1372                 break;
1373
1374         case CTDB_CONTROL_DB_THAW:
1375                 break;
1376
1377         case CTDB_CONTROL_DB_TRANSACTION_START:
1378                 break;
1379
1380         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
1381                 break;
1382
1383         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
1384                 break;
1385
1386         case CTDB_CONTROL_DB_PULL:
1387                 len = ctdb_uint32_len(cd->data.num_records);
1388                 break;
1389
1390         case CTDB_CONTROL_DB_PUSH_START:
1391                 break;
1392
1393         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1394                 len = ctdb_uint32_len(cd->data.num_records);
1395                 break;
1396
1397         case CTDB_CONTROL_DB_OPEN_FLAGS:
1398                 len = ctdb_int32_len(cd->data.tdb_flags);
1399                 break;
1400         }
1401
1402         return len;
1403 }
1404
1405 static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
1406                                          uint8_t *buf)
1407 {
1408         switch (cd->opcode) {
1409         case CTDB_CONTROL_STATISTICS:
1410                 ctdb_statistics_push(cd->data.stats, buf);
1411                 break;
1412
1413         case CTDB_CONTROL_GETDBPATH:
1414                 ctdb_string_push(cd->data.db_path, buf);
1415                 break;
1416
1417         case CTDB_CONTROL_GETVNNMAP:
1418                 ctdb_vnn_map_push(cd->data.vnnmap, buf);
1419                 break;
1420
1421         case CTDB_CONTROL_GET_DEBUG:
1422                 ctdb_uint32_push(cd->data.loglevel, buf);
1423                 break;
1424
1425         case CTDB_CONTROL_GET_DBMAP:
1426                 ctdb_dbid_map_push(cd->data.dbmap, buf);
1427                 break;
1428
1429         case CTDB_CONTROL_PULL_DB:
1430                 ctdb_rec_buffer_push(cd->data.recbuf, buf);
1431                 break;
1432
1433         case CTDB_CONTROL_PUSH_DB:
1434                 break;
1435
1436         case CTDB_CONTROL_DB_ATTACH:
1437                 ctdb_uint32_push(cd->data.db_id, buf);
1438                 break;
1439
1440         case CTDB_CONTROL_GET_DBNAME:
1441                 ctdb_string_push(cd->data.db_name, buf);
1442                 break;
1443
1444         case CTDB_CONTROL_DUMP_MEMORY:
1445                 ctdb_string_push(cd->data.mem_str, buf);
1446                 break;
1447
1448         case CTDB_CONTROL_GET_PID:
1449                 break;
1450
1451         case CTDB_CONTROL_GET_RECMASTER:
1452                 break;
1453
1454         case CTDB_CONTROL_GET_TUNABLE:
1455                 ctdb_uint32_push(cd->data.tun_value, buf);
1456                 break;
1457
1458         case CTDB_CONTROL_LIST_TUNABLES:
1459                 ctdb_var_list_push(cd->data.tun_var_list, buf);
1460                 break;
1461
1462         case CTDB_CONTROL_GET_ALL_TUNABLES:
1463                 ctdb_tunable_list_push(cd->data.tun_list, buf);
1464                 break;
1465
1466         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1467                 ctdb_tickle_list_push(cd->data.tickles, buf);
1468                 break;
1469
1470         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1471                 ctdb_uint32_push(cd->data.db_id, buf);
1472                 break;
1473
1474         case CTDB_CONTROL_UPTIME:
1475                 ctdb_uptime_push(cd->data.uptime, buf);
1476                 break;
1477
1478         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1479                 ctdb_rec_buffer_push(cd->data.recbuf, buf);
1480                 break;
1481
1482         case CTDB_CONTROL_GET_CAPABILITIES:
1483                 ctdb_uint32_push(cd->data.caps, buf);
1484                 break;
1485
1486         case CTDB_CONTROL_GET_PUBLIC_IPS:
1487                 ctdb_public_ip_list_push(cd->data.pubip_list, buf);
1488                 break;
1489
1490         case CTDB_CONTROL_GET_NODEMAP:
1491                 ctdb_node_map_push(cd->data.nodemap, buf);
1492                 break;
1493
1494         case CTDB_CONTROL_GET_RECLOCK_FILE:
1495                 ctdb_string_push(cd->data.reclock_file, buf);
1496                 break;
1497
1498         case CTDB_CONTROL_GET_BAN_STATE:
1499                 ctdb_ban_state_push(cd->data.ban_state, buf);
1500                 break;
1501
1502         case CTDB_CONTROL_GET_DB_PRIORITY:
1503                 break;
1504
1505         case CTDB_CONTROL_GET_DB_SEQNUM:
1506                 ctdb_uint64_push(cd->data.seqnum, buf);
1507                 break;
1508
1509         case CTDB_CONTROL_DB_GET_HEALTH:
1510                 ctdb_string_push(cd->data.reason, buf);
1511                 break;
1512
1513         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1514                 ctdb_public_ip_info_push(cd->data.ipinfo, buf);
1515                 break;
1516
1517         case CTDB_CONTROL_GET_IFACES:
1518                 ctdb_iface_list_push(cd->data.iface_list, buf);
1519                 break;
1520
1521         case CTDB_CONTROL_GET_STAT_HISTORY:
1522                 ctdb_statistics_list_push(cd->data.stats_list, buf);
1523                 break;
1524
1525         case CTDB_CONTROL_CHECK_SRVIDS:
1526                 ctdb_uint8_array_push(cd->data.u8_array, buf);
1527                 break;
1528
1529         case CTDB_CONTROL_GET_DB_STATISTICS:
1530                 ctdb_db_statistics_push(cd->data.dbstats, buf);
1531                 break;
1532
1533         case CTDB_CONTROL_RECEIVE_RECORDS:
1534                 ctdb_rec_buffer_push(cd->data.recbuf, buf);
1535                 break;
1536
1537         case CTDB_CONTROL_GET_RUNSTATE:
1538                 ctdb_uint32_push(cd->data.runstate, buf);
1539                 break;
1540
1541         case CTDB_CONTROL_GET_NODES_FILE:
1542                 ctdb_node_map_push(cd->data.nodemap, buf);
1543                 break;
1544
1545         case CTDB_CONTROL_DB_PULL:
1546                 ctdb_uint32_push(cd->data.num_records, buf);
1547                 break;
1548
1549         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1550                 ctdb_uint32_push(cd->data.num_records, buf);
1551                 break;
1552
1553         case CTDB_CONTROL_DB_OPEN_FLAGS:
1554                 ctdb_int32_push(cd->data.tdb_flags, buf);
1555                 break;
1556         }
1557 }
1558
1559 static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
1560                                         uint32_t opcode, TALLOC_CTX *mem_ctx,
1561                                         struct ctdb_reply_control_data *cd)
1562 {
1563         int ret = 0;
1564         cd->opcode = opcode;
1565
1566         switch (opcode) {
1567         case CTDB_CONTROL_STATISTICS:
1568                 ret = ctdb_statistics_pull(buf, buflen, mem_ctx,
1569                                            &cd->data.stats);
1570                 break;
1571
1572         case CTDB_CONTROL_GETDBPATH:
1573                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1574                                        &cd->data.db_path);
1575                 break;
1576
1577         case CTDB_CONTROL_GETVNNMAP:
1578                 ret = ctdb_vnn_map_pull(buf, buflen, mem_ctx,
1579                                         &cd->data.vnnmap);
1580                 break;
1581
1582         case CTDB_CONTROL_GET_DEBUG:
1583                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1584                                      &cd->data.loglevel);
1585                 break;
1586
1587         case CTDB_CONTROL_GET_DBMAP:
1588                 ret = ctdb_dbid_map_pull(buf, buflen, mem_ctx,
1589                                          &cd->data.dbmap);
1590                 break;
1591
1592         case CTDB_CONTROL_PULL_DB:
1593                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1594                                            &cd->data.recbuf);
1595                 break;
1596
1597         case CTDB_CONTROL_PUSH_DB:
1598                 break;
1599
1600         case CTDB_CONTROL_DB_ATTACH:
1601                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1602                                        &cd->data.db_id);
1603                 break;
1604
1605         case CTDB_CONTROL_GET_DBNAME:
1606                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1607                                        &cd->data.db_name);
1608                 break;
1609
1610         case CTDB_CONTROL_DUMP_MEMORY:
1611                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1612                                        &cd->data.mem_str);
1613                 break;
1614
1615         case CTDB_CONTROL_GET_PID:
1616                 break;
1617
1618         case CTDB_CONTROL_GET_RECMASTER:
1619                 break;
1620
1621         case CTDB_CONTROL_GET_TUNABLE:
1622                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1623                                      &cd->data.tun_value);
1624                 break;
1625
1626         case CTDB_CONTROL_LIST_TUNABLES:
1627                 ret = ctdb_var_list_pull(buf, buflen, mem_ctx,
1628                                          &cd->data.tun_var_list);
1629                 break;
1630
1631         case CTDB_CONTROL_GET_ALL_TUNABLES:
1632                 ret = ctdb_tunable_list_pull(buf, buflen, mem_ctx,
1633                                              &cd->data.tun_list);
1634                 break;
1635
1636         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1637                 ret = ctdb_tickle_list_pull(buf, buflen, mem_ctx,
1638                                             &cd->data.tickles);
1639                 break;
1640
1641         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1642                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1643                                        &cd->data.db_id);
1644                 break;
1645
1646         case CTDB_CONTROL_UPTIME:
1647                 ret = ctdb_uptime_pull(buf, buflen, mem_ctx,
1648                                        &cd->data.uptime);
1649                 break;
1650
1651         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1652                 ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1653                                      &cd->data.recbuf);
1654                 break;
1655
1656         case CTDB_CONTROL_GET_CAPABILITIES:
1657                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1658                                      &cd->data.caps);
1659                 break;
1660
1661         case CTDB_CONTROL_GET_PUBLIC_IPS:
1662                 ret = ctdb_public_ip_list_pull(buf, buflen, mem_ctx,
1663                                                &cd->data.pubip_list);
1664                 break;
1665
1666         case CTDB_CONTROL_GET_NODEMAP:
1667                 ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
1668                                          &cd->data.nodemap);
1669                 break;
1670
1671         case CTDB_CONTROL_GET_RECLOCK_FILE:
1672                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1673                                        &cd->data.reclock_file);
1674                 break;
1675
1676         case CTDB_CONTROL_GET_BAN_STATE:
1677                 ret = ctdb_ban_state_pull(buf, buflen, mem_ctx,
1678                                           &cd->data.ban_state);
1679                 break;
1680
1681         case CTDB_CONTROL_GET_DB_PRIORITY:
1682                 break;
1683
1684         case CTDB_CONTROL_GET_DB_SEQNUM:
1685                 ret = ctdb_uint64_pull(buf, buflen, mem_ctx,
1686                                        &cd->data.seqnum);
1687                 break;
1688
1689         case CTDB_CONTROL_DB_GET_HEALTH:
1690                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1691                                        &cd->data.reason);
1692                 break;
1693
1694         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1695                 ret = ctdb_public_ip_info_pull(buf, buflen, mem_ctx,
1696                                                &cd->data.ipinfo);
1697                 break;
1698
1699         case CTDB_CONTROL_GET_IFACES:
1700                 ret = ctdb_iface_list_pull(buf, buflen, mem_ctx,
1701                                            &cd->data.iface_list);
1702                 break;
1703
1704         case CTDB_CONTROL_GET_STAT_HISTORY:
1705                 ret = ctdb_statistics_list_pull(buf, buflen, mem_ctx,
1706                                                 &cd->data.stats_list);
1707                 break;
1708
1709         case CTDB_CONTROL_CHECK_SRVIDS:
1710                 ret = ctdb_uint8_array_pull(buf, buflen, mem_ctx,
1711                                             &cd->data.u8_array);
1712                 break;
1713
1714         case CTDB_CONTROL_GET_DB_STATISTICS:
1715                 ret = ctdb_db_statistics_pull(buf, buflen, mem_ctx,
1716                                               &cd->data.dbstats);
1717                 break;
1718
1719         case CTDB_CONTROL_RECEIVE_RECORDS:
1720                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1721                                            &cd->data.recbuf);
1722                 break;
1723
1724         case CTDB_CONTROL_GET_RUNSTATE:
1725                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1726                                        &cd->data.runstate);
1727                 break;
1728
1729         case CTDB_CONTROL_GET_NODES_FILE:
1730                 ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
1731                                          &cd->data.nodemap);
1732                 break;
1733
1734         case CTDB_CONTROL_DB_PULL:
1735                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1736                                        &cd->data.num_records);
1737                 break;
1738
1739         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1740                 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1741                                        &cd->data.num_records);
1742                 break;
1743
1744         case CTDB_CONTROL_DB_OPEN_FLAGS:
1745                 ret = ctdb_int32_pull(buf, buflen, mem_ctx,
1746                                       &cd->data.tdb_flags);
1747                 break;
1748         }
1749
1750         return ret;
1751 }
1752
1753 size_t ctdb_req_control_len(struct ctdb_req_header *h,
1754                             struct ctdb_req_control *c)
1755 {
1756         return offsetof(struct ctdb_req_control_wire, data) +
1757                 ctdb_req_control_data_len(&c->rdata);
1758 }
1759
1760 int ctdb_req_control_push(struct ctdb_req_header *h,
1761                           struct ctdb_req_control *request,
1762                           uint8_t *buf, size_t *buflen)
1763 {
1764         struct ctdb_req_control_wire *wire =
1765                 (struct ctdb_req_control_wire *)buf;
1766         size_t length;
1767
1768         length = ctdb_req_control_len(h, request);
1769         if (*buflen < length) {
1770                 *buflen = length;
1771                 return EMSGSIZE;
1772         }
1773
1774         h->length = *buflen;
1775         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
1776
1777         wire->opcode = request->opcode;
1778         wire->pad = request->pad;
1779         wire->srvid = request->srvid;
1780         wire->client_id = request->client_id;
1781         wire->flags = request->flags;
1782
1783         wire->datalen = ctdb_req_control_data_len(&request->rdata);
1784         ctdb_req_control_data_push(&request->rdata, wire->data);
1785
1786         return 0;
1787 }
1788
1789 int ctdb_req_control_pull(uint8_t *buf, size_t buflen,
1790                           struct ctdb_req_header *h,
1791                           TALLOC_CTX *mem_ctx,
1792                           struct ctdb_req_control *c)
1793 {
1794         struct ctdb_req_control_wire *wire =
1795                 (struct ctdb_req_control_wire *)buf;
1796         size_t length;
1797         int ret;
1798
1799         length = offsetof(struct ctdb_req_control_wire, data);
1800         if (buflen < length) {
1801                 return EMSGSIZE;
1802         }
1803         if (wire->datalen > buflen) {
1804                 return EMSGSIZE;
1805         }
1806         if (length + wire->datalen < length) {
1807                 return EMSGSIZE;
1808         }
1809         if (buflen < length + wire->datalen) {
1810                 return EMSGSIZE;
1811         }
1812
1813         if (h != NULL) {
1814                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
1815                 if (ret != 0) {
1816                         return ret;
1817                 }
1818         }
1819
1820         c->opcode = wire->opcode;
1821         c->pad = wire->pad;
1822         c->srvid = wire->srvid;
1823         c->client_id = wire->client_id;
1824         c->flags = wire->flags;
1825
1826         ret = ctdb_req_control_data_pull(wire->data, wire->datalen,
1827                                          c->opcode, mem_ctx, &c->rdata);
1828         if (ret != 0) {
1829                 return ret;
1830         }
1831
1832         return 0;
1833 }
1834
1835 size_t ctdb_reply_control_len(struct ctdb_req_header *h,
1836                               struct ctdb_reply_control *c)
1837 {
1838         return offsetof(struct ctdb_reply_control_wire, data) +
1839                 (c->status == 0 ?
1840                         ctdb_reply_control_data_len(&c->rdata) :
1841                         ctdb_string_len(c->errmsg));
1842 }
1843
1844 int ctdb_reply_control_push(struct ctdb_req_header *h,
1845                             struct ctdb_reply_control *reply,
1846                             uint8_t *buf, size_t *buflen)
1847 {
1848         struct ctdb_reply_control_wire *wire =
1849                 (struct ctdb_reply_control_wire *)buf;
1850         size_t length;
1851
1852         length = ctdb_reply_control_len(h, reply);
1853         if (*buflen < length) {
1854                 *buflen = length;
1855                 return EMSGSIZE;
1856         }
1857
1858         h->length = *buflen;
1859         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
1860
1861         wire->status = reply->status;
1862
1863         if (reply->status == 0) {
1864                 wire->datalen = ctdb_reply_control_data_len(&reply->rdata);
1865                 wire->errorlen = 0;
1866                 ctdb_reply_control_data_push(&reply->rdata, wire->data);
1867         } else {
1868                 wire->datalen = 0;
1869                 wire->errorlen = ctdb_string_len(reply->errmsg);
1870                 ctdb_string_push(reply->errmsg, wire->data + wire->datalen);
1871         }
1872
1873         return 0;
1874 }
1875
1876 int ctdb_reply_control_pull(uint8_t *buf, size_t buflen, uint32_t opcode,
1877                             struct ctdb_req_header *h,
1878                             TALLOC_CTX *mem_ctx,
1879                             struct ctdb_reply_control *c)
1880 {
1881         struct ctdb_reply_control_wire *wire =
1882                 (struct ctdb_reply_control_wire *)buf;
1883         size_t length;
1884         int ret;
1885
1886         length = offsetof(struct ctdb_reply_control_wire, data);
1887         if (buflen < length) {
1888                 return EMSGSIZE;
1889         }
1890         if (wire->datalen > buflen || wire->errorlen > buflen) {
1891                 return EMSGSIZE;
1892         }
1893         if (length + wire->datalen < length) {
1894                 return EMSGSIZE;
1895         }
1896         if (length + wire->datalen + wire->errorlen < length) {
1897                 return EMSGSIZE;
1898         }
1899         if (buflen < length + wire->datalen + wire->errorlen) {
1900                 return EMSGSIZE;
1901         }
1902
1903         if (h != NULL) {
1904                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
1905                 if (ret != 0) {
1906                         return ret;
1907                 }
1908         }
1909
1910         c->status = wire->status;
1911
1912         if (c->status != -1) {
1913                 ret = ctdb_reply_control_data_pull(wire->data, wire->datalen,
1914                                                    opcode, mem_ctx,
1915                                                    &c->rdata);
1916                 if (ret != 0) {
1917                         return ret;
1918                 }
1919         }
1920
1921         ret = ctdb_string_pull(wire->data + wire->datalen, wire->errorlen,
1922                                mem_ctx, &c->errmsg);
1923         if (ret != 0) {
1924                 return ret;
1925         }
1926
1927         return 0;
1928 }