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