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