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