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