ctdb/protocol/protocol_control.c

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