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