ctdb/protocol/protocol_control.c

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