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         case CTDB_CONTROL_START_IPREALLOCATE:
 423                 break;
 424         }
 425
 426         return len;
 427 }
 428
 429 static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
 430                                        uint8_t *buf, size_t *npush)
 431 {
 432         size_t np = 0, offset;
 433         uint32_t u32;
 434
 435         switch (cd->opcode) {
 436         case CTDB_CONTROL_PROCESS_EXISTS:
 437                 ctdb_pid_push(&cd->data.pid, buf, &np);
 438                 break;
 439
 440         case CTDB_CONTROL_GETDBPATH:
 441                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 442                 break;
 443
 444         case CTDB_CONTROL_SETVNNMAP:
 445                 ctdb_vnn_map_push(cd->data.vnnmap, buf, &np);
 446                 break;
 447
 448         case CTDB_CONTROL_SET_DEBUG:
 449                 ctdb_uint32_push(&cd->data.loglevel, buf, &np);
 450                 break;
 451
 452         case CTDB_CONTROL_SET_RECMODE:
 453                 ctdb_uint32_push(&cd->data.recmode, buf, &np);
 454                 break;
 455
 456         case CTDB_CONTROL_DB_ATTACH:
 457                 ctdb_string_push(&cd->data.db_name, buf, &np);
 458                 break;
 459
 460         case CTDB_CONTROL_TRAVERSE_START:
 461                 ctdb_traverse_start_push(cd->data.traverse_start, buf, &np);
 462                 break;
 463
 464         case CTDB_CONTROL_TRAVERSE_ALL:
 465                 ctdb_traverse_all_push(cd->data.traverse_all, buf, &np);
 466                 break;
 467
 468         case CTDB_CONTROL_TRAVERSE_DATA:
 469                 ctdb_rec_data_push(cd->data.rec_data, buf, &np);
 470                 break;
 471
 472         case CTDB_CONTROL_GET_DBNAME:
 473                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 474                 break;
 475
 476         case CTDB_CONTROL_ENABLE_SEQNUM:
 477                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 478                 break;
 479
 480         case CTDB_CONTROL_UPDATE_SEQNUM:
 481                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 482                 break;
 483
 484         case CTDB_CONTROL_TCP_CLIENT:
 485                 ctdb_connection_push(cd->data.conn, buf, &np);
 486                 break;
 487
 488         case CTDB_CONTROL_TCP_ADD:
 489                 ctdb_connection_push(cd->data.conn, buf, &np);
 490                 break;
 491
 492         case CTDB_CONTROL_TCP_REMOVE:
 493                 ctdb_connection_push(cd->data.conn, buf, &np);
 494                 break;
 495
 496         case CTDB_CONTROL_SET_TUNABLE:
 497                 ctdb_tunable_push(cd->data.tunable, buf, &np);
 498                 break;
 499
 500         case CTDB_CONTROL_GET_TUNABLE:
 501                 ctdb_stringn_push(&cd->data.tun_var, buf, &np);
 502                 break;
 503
 504         case CTDB_CONTROL_MODIFY_FLAGS:
 505                 ctdb_node_flag_change_push(cd->data.flag_change, buf, &np);
 506                 break;
 507
 508         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 509                 ctdb_sock_addr_push(cd->data.addr, buf, &np);
 510                 break;
 511
 512         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 513                 ctdb_tickle_list_push(cd->data.tickles, buf, &np);
 514                 break;
 515
 516         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 517                 ctdb_string_push(&cd->data.db_name, buf, &np);
 518                 break;
 519
 520         case CTDB_CONTROL_UPDATE_RECORD:
 521                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
 522                 break;
 523
 524         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 525                 ctdb_addr_info_push(cd->data.addr_info, buf, &np);
 526                 break;
 527
 528         case CTDB_CONTROL_WIPE_DATABASE:
 529                 ctdb_transdb_push(cd->data.transdb, buf, &np);
 530                 break;
 531
 532         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 533                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
 534                 break;
 535
 536         case CTDB_CONTROL_ADD_PUBLIC_IP:
 537                 ctdb_addr_info_push(cd->data.addr_info, buf, &np);
 538                 break;
 539
 540         case CTDB_CONTROL_DEL_PUBLIC_IP:
 541                 ctdb_addr_info_push(cd->data.addr_info, buf, &np);
 542                 break;
 543
 544         case CTDB_CONTROL_RELEASE_IP:
 545                 ctdb_public_ip_push(cd->data.pubip, buf, &np);
 546                 break;
 547
 548         case CTDB_CONTROL_TAKEOVER_IP:
 549                 ctdb_public_ip_push(cd->data.pubip, buf, &np);
 550                 break;
 551
 552         case CTDB_CONTROL_TRAVERSE_KILL:
 553                 ctdb_traverse_start_push(cd->data.traverse_start, buf, &np);
 554                 break;
 555
 556         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 557                 ctdb_double_push(&cd->data.reclock_latency, buf, &np);
 558                 break;
 559
 560         case CTDB_CONTROL_SET_LMASTERROLE:
 561                 ctdb_uint32_push(&cd->data.role, buf, &np);
 562                 break;
 563
 564         case CTDB_CONTROL_SET_RECMASTERROLE:
 565                 ctdb_uint32_push(&cd->data.role, buf, &np);
 566                 break;
 567
 568         case CTDB_CONTROL_SET_BAN_STATE:
 569                 ctdb_ban_state_push(cd->data.ban_state, buf, &np);
 570                 break;
 571
 572         case CTDB_CONTROL_REGISTER_NOTIFY:
 573                 ctdb_notify_data_push(cd->data.notify, buf, &np);
 574                 break;
 575
 576         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 577                 ctdb_uint64_push(&cd->data.srvid, buf, &np);
 578                 break;
 579
 580         case CTDB_CONTROL_TRANS3_COMMIT:
 581                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
 582                 break;
 583
 584         case CTDB_CONTROL_GET_DB_SEQNUM:
 585                 u32 = 0;
 586                 offset = 0;
 587                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 588                 offset += np;
 589                 ctdb_uint32_push(&u32, buf+offset, &np);
 590                 offset += np;
 591                 np = offset;
 592                 break;
 593
 594         case CTDB_CONTROL_DB_SET_HEALTHY:
 595                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 596                 break;
 597
 598         case CTDB_CONTROL_DB_GET_HEALTH:
 599                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 600                 break;
 601
 602         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 603                 ctdb_sock_addr_push(cd->data.addr, buf, &np);
 604                 break;
 605
 606         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 607                 ctdb_iface_push(cd->data.iface, buf, &np);
 608                 break;
 609
 610         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 611                 ctdb_connection_push(cd->data.conn, buf, &np);
 612                 break;
 613
 614         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 615                 ctdb_key_data_push(cd->data.key, buf, &np);
 616                 break;
 617
 618         case CTDB_CONTROL_SET_DB_READONLY:
 619                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 620                 break;
 621
 622         case CTDB_CONTROL_TRAVERSE_START_EXT:
 623                 ctdb_traverse_start_ext_push(cd->data.traverse_start_ext, buf,
 624                                              &np);
 625                 break;
 626
 627         case CTDB_CONTROL_GET_DB_STATISTICS:
 628                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 629                 break;
 630
 631         case CTDB_CONTROL_SET_DB_STICKY:
 632                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 633                 break;
 634
 635         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 636                 ctdb_traverse_all_ext_push(cd->data.traverse_all_ext, buf,
 637                                            &np);
 638                 break;
 639
 640         case CTDB_CONTROL_DB_DETACH:
 641                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 642                 break;
 643
 644         case CTDB_CONTROL_DB_FREEZE:
 645                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 646                 break;
 647
 648         case CTDB_CONTROL_DB_THAW:
 649                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 650                 break;
 651
 652         case CTDB_CONTROL_DB_TRANSACTION_START:
 653                 ctdb_transdb_push(cd->data.transdb, buf, &np);
 654                 break;
 655
 656         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
 657                 ctdb_transdb_push(cd->data.transdb, buf, &np);
 658                 break;
 659
 660         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
 661                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 662                 break;
 663
 664         case CTDB_CONTROL_DB_PULL:
 665                 ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf, &np);
 666                 break;
 667
 668         case CTDB_CONTROL_DB_PUSH_START:
 669                 ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf, &np);
 670                 break;
 671
 672         case CTDB_CONTROL_DB_PUSH_CONFIRM:
 673                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 674                 break;
 675
 676         case CTDB_CONTROL_DB_OPEN_FLAGS:
 677                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 678                 break;
 679
 680         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
 681                 ctdb_string_push(&cd->data.db_name, buf, &np);
 682                 break;
 683
 684         case CTDB_CONTROL_CHECK_PID_SRVID:
 685                 ctdb_pid_srvid_push(cd->data.pid_srvid, buf, &np);
 686                 break;
 687
 688         case CTDB_CONTROL_VACUUM_FETCH:
 689                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
 690                 break;
 691
 692         case CTDB_CONTROL_DB_VACUUM:
 693                 ctdb_db_vacuum_push(cd->data.db_vacuum, buf, &np);
 694                 break;
 695
 696         case CTDB_CONTROL_ECHO_DATA:
 697                 ctdb_echo_data_push(cd->data.echo_data, buf, &np);
 698                 break;
 699
 700         case CTDB_CONTROL_TCP_CLIENT_DISCONNECTED:
 701                 ctdb_connection_push(cd->data.conn, buf, &np);
 702                 break;
 703
 704         case CTDB_CONTROL_TCP_CLIENT_PASSED:
 705                 ctdb_connection_push(cd->data.conn, buf, &np);
 706                 break;
 707         }
 708
 709         *npush = np;
 710 }
 711
 712 static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
 713                                       uint32_t opcode,
 714                                       TALLOC_CTX *mem_ctx,
 715                                       struct ctdb_req_control_data *cd,
 716                                       size_t *npull)
 717 {
 718         size_t np = 0, offset;
 719         uint32_t u32;
 720         int ret = 0;
 721
 722         cd->opcode = opcode;
 723
 724         switch (opcode) {
 725         case CTDB_CONTROL_PROCESS_EXISTS:
 726                 ret = ctdb_pid_pull(buf, buflen, &cd->data.pid, &np);
 727                 break;
 728
 729         case CTDB_CONTROL_GETDBPATH:
 730                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 731                 break;
 732
 733         case CTDB_CONTROL_SETVNNMAP:
 734                 ret = ctdb_vnn_map_pull(buf, buflen, mem_ctx,
 735                                         &cd->data.vnnmap, &np);
 736                 break;
 737
 738         case CTDB_CONTROL_SET_DEBUG:
 739                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.loglevel, &np);
 740                 break;
 741
 742         case CTDB_CONTROL_SET_RECMODE:
 743                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.recmode, &np);
 744                 break;
 745
 746         case CTDB_CONTROL_DB_ATTACH:
 747                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
 748                                        &cd->data.db_name, &np);
 749                 break;
 750
 751         case CTDB_CONTROL_TRAVERSE_START:
 752                 ret = ctdb_traverse_start_pull(buf, buflen, mem_ctx,
 753                                                &cd->data.traverse_start, &np);
 754                 break;
 755
 756         case CTDB_CONTROL_TRAVERSE_ALL:
 757                 ret = ctdb_traverse_all_pull(buf, buflen, mem_ctx,
 758                                              &cd->data.traverse_all, &np);
 759                 break;
 760
 761         case CTDB_CONTROL_TRAVERSE_DATA:
 762                 ret = ctdb_rec_data_pull(buf, buflen, mem_ctx,
 763                                          &cd->data.rec_data, &np);
 764                 break;
 765
 766         case CTDB_CONTROL_GET_DBNAME:
 767                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 768                 break;
 769
 770         case CTDB_CONTROL_ENABLE_SEQNUM:
 771                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 772                 break;
 773
 774         case CTDB_CONTROL_UPDATE_SEQNUM:
 775                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 776                 break;
 777
 778         case CTDB_CONTROL_TCP_CLIENT:
 779                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 780                                            &cd->data.conn, &np);
 781                 break;
 782
 783         case CTDB_CONTROL_TCP_ADD:
 784                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 785                                            &cd->data.conn, &np);
 786                 break;
 787
 788         case CTDB_CONTROL_TCP_REMOVE:
 789                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 790                                            &cd->data.conn, &np);
 791                 break;
 792
 793         case CTDB_CONTROL_SET_TUNABLE:
 794                 ret = ctdb_tunable_pull(buf, buflen, mem_ctx,
 795                                         &cd->data.tunable, &np);
 796                 break;
 797
 798         case CTDB_CONTROL_GET_TUNABLE:
 799                 ret = ctdb_stringn_pull(buf, buflen, mem_ctx,
 800                                         &cd->data.tun_var, &np);
 801                 break;
 802
 803         case CTDB_CONTROL_MODIFY_FLAGS:
 804                 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
 805                                                  &cd->data.flag_change, &np);
 806                 break;
 807
 808         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 809                 ret = ctdb_sock_addr_pull(buf, buflen, mem_ctx,
 810                                           &cd->data.addr, &np);
 811                 break;
 812
 813         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 814                 ret = ctdb_tickle_list_pull(buf, buflen, mem_ctx,
 815                                             &cd->data.tickles, &np);
 816                 break;
 817
 818         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 819                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
 820                                        &cd->data.db_name, &np);
 821                 break;
 822
 823         case CTDB_CONTROL_UPDATE_RECORD:
 824                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 825                                            &cd->data.recbuf, &np);
 826                 break;
 827
 828         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 829                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 830                                           &cd->data.addr_info, &np);
 831                 break;
 832
 833         case CTDB_CONTROL_WIPE_DATABASE:
 834                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
 835                                        &cd->data.transdb, &np);
 836                 break;
 837
 838         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 839                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 840                                            &cd->data.recbuf, &np);
 841                 break;
 842
 843         case CTDB_CONTROL_ADD_PUBLIC_IP:
 844                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 845                                           &cd->data.addr_info, &np);
 846                 break;
 847
 848         case CTDB_CONTROL_DEL_PUBLIC_IP:
 849                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 850                                           &cd->data.addr_info, &np);
 851                 break;
 852
 853         case CTDB_CONTROL_RELEASE_IP:
 854                 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
 855                                           &cd->data.pubip, &np);
 856                 break;
 857
 858         case CTDB_CONTROL_TAKEOVER_IP:
 859                 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
 860                                           &cd->data.pubip, &np);
 861                 break;
 862
 863         case CTDB_CONTROL_TRAVERSE_KILL:
 864                 ret = ctdb_traverse_start_pull(buf, buflen, mem_ctx,
 865                                                &cd->data.traverse_start, &np);
 866                 break;
 867
 868         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 869                 ret = ctdb_double_pull(buf, buflen, &cd->data.reclock_latency,
 870                                        &np);
 871                 break;
 872
 873         case CTDB_CONTROL_SET_LMASTERROLE:
 874                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.role, &np);
 875                 break;
 876
 877         case CTDB_CONTROL_SET_RECMASTERROLE:
 878                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.role, &np);
 879                 break;
 880
 881         case CTDB_CONTROL_SET_BAN_STATE:
 882                 ret = ctdb_ban_state_pull(buf, buflen, mem_ctx,
 883                                           &cd->data.ban_state, &np);
 884                 break;
 885
 886         case CTDB_CONTROL_REGISTER_NOTIFY:
 887                 ret = ctdb_notify_data_pull(buf, buflen, mem_ctx,
 888                                             &cd->data.notify, &np);
 889                 break;
 890
 891         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 892                 ret = ctdb_uint64_pull(buf, buflen, &cd->data.srvid, &np);
 893                 break;
 894
 895         case CTDB_CONTROL_TRANS3_COMMIT:
 896                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 897                                            &cd->data.recbuf, &np);
 898                 break;
 899
 900         case CTDB_CONTROL_GET_DB_SEQNUM:
 901                 offset = 0;
 902                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 903                 if (ret != 0) {
 904                         break;
 905                 }
 906                 offset += np;
 907                 ret = ctdb_uint32_pull(buf+offset, buflen-offset, &u32, &np);
 908                 offset += np;
 909                 np = offset;
 910                 break;
 911
 912         case CTDB_CONTROL_DB_SET_HEALTHY:
 913                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 914                 break;
 915
 916         case CTDB_CONTROL_DB_GET_HEALTH:
 917                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 918                 break;
 919
 920         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 921                 ret = ctdb_sock_addr_pull(buf, buflen, mem_ctx,
 922                                           &cd->data.addr, &np);
 923                 break;
 924
 925         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 926                 ret = ctdb_iface_pull(buf, buflen, mem_ctx,
 927                                       &cd->data.iface, &np);
 928                 break;
 929
 930         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 931                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 932                                            &cd->data.conn, &np);
 933                 break;
 934
 935         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 936                 ret = ctdb_key_data_pull(buf, buflen, mem_ctx,
 937                                          &cd->data.key, &np);
 938                 break;
 939
 940         case CTDB_CONTROL_SET_DB_READONLY:
 941                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 942                 break;
 943
 944         case CTDB_CONTROL_TRAVERSE_START_EXT:
 945                 ret = ctdb_traverse_start_ext_pull(buf, buflen, mem_ctx,
 946                                                    &cd->data.traverse_start_ext,
 947                                                    &np);
 948                 break;
 949
 950         case CTDB_CONTROL_GET_DB_STATISTICS:
 951                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 952                 break;
 953
 954         case CTDB_CONTROL_SET_DB_STICKY:
 955                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 956                 break;
 957
 958         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 959                 ret = ctdb_traverse_all_ext_pull(buf, buflen, mem_ctx,
 960                                                  &cd->data.traverse_all_ext,
 961                                                  &np);
 962                 break;
 963
 964         case CTDB_CONTROL_DB_DETACH:
 965                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 966                 break;
 967
 968         case CTDB_CONTROL_DB_FREEZE:
 969                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 970                 break;
 971
 972         case CTDB_CONTROL_DB_THAW:
 973                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 974                 break;
 975
 976         case CTDB_CONTROL_DB_TRANSACTION_START:
 977                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
 978                                         &cd->data.transdb, &np);
 979                 break;
 980
 981         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
 982                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
 983                                         &cd->data.transdb, &np);
 984                 break;
 985
 986         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
 987                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 988                 break;
 989
 990         case CTDB_CONTROL_DB_PULL:
 991                 ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
 992                                            &cd->data.pulldb_ext, &np);
 993                 break;
 994
 995         case CTDB_CONTROL_DB_PUSH_START:
 996                 ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
 997                                            &cd->data.pulldb_ext, &np);
 998                 break;
 999
1000         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1001                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1002                 break;
1003
1004         case CTDB_CONTROL_DB_OPEN_FLAGS:
1005                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1006                 break;
1007
1008         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1009                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1010                                        &cd->data.db_name, &np);
1011                 break;
1012
1013         case CTDB_CONTROL_CHECK_PID_SRVID:
1014                 ret = ctdb_pid_srvid_pull(buf, buflen, mem_ctx,
1015                                           &cd->data.pid_srvid, &np);
1016                 break;
1017
1018         case CTDB_CONTROL_VACUUM_FETCH:
1019                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1020                                            &cd->data.recbuf, &np);
1021                 break;
1022
1023         case CTDB_CONTROL_DB_VACUUM:
1024                 ret = ctdb_db_vacuum_pull(buf,
1025                                           buflen,
1026                                           mem_ctx,
1027                                           &cd->data.db_vacuum,
1028                                           &np);
1029                 break;
1030
1031         case CTDB_CONTROL_ECHO_DATA:
1032                 ret = ctdb_echo_data_pull(buf,
1033                                           buflen,
1034                                           mem_ctx,
1035                                           &cd->data.echo_data,
1036                                           &np);
1037                 break;
1038
1039         case CTDB_CONTROL_TCP_CLIENT_DISCONNECTED:
1040                 ret = ctdb_connection_pull(buf,
1041                                            buflen,
1042                                            mem_ctx,
1043                                            &cd->data.conn,
1044                                            &np);
1045                 break;
1046
1047         case CTDB_CONTROL_TCP_CLIENT_PASSED:
1048                 ret = ctdb_connection_pull(buf,
1049                                            buflen,
1050                                            mem_ctx,
1051                                            &cd->data.conn,
1052                                            &np);
1053                 break;
1054         }
1055
1056         if (ret != 0) {
1057                 return ret;
1058         }
1059
1060         *npull = np;
1061         return 0;
1062 }
1063
1064 static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
1065 {
1066         size_t len = 0;
1067
1068         if (cd == NULL) {
1069                 return 0;
1070         }
1071
1072         switch (cd->opcode) {
1073         case CTDB_CONTROL_PROCESS_EXISTS:
1074                 break;
1075
1076         case CTDB_CONTROL_STATISTICS:
1077                 len = ctdb_statistics_len(cd->data.stats);
1078                 break;
1079
1080         case CTDB_CONTROL_PING:
1081                 break;
1082
1083         case CTDB_CONTROL_GETDBPATH:
1084                 len = ctdb_string_len(&cd->data.db_path);
1085                 break;
1086
1087         case CTDB_CONTROL_GETVNNMAP:
1088                 len = ctdb_vnn_map_len(cd->data.vnnmap);
1089                 break;
1090
1091         case CTDB_CONTROL_SETVNNMAP:
1092                 break;
1093
1094         case CTDB_CONTROL_GET_DEBUG:
1095                 len = ctdb_uint32_len(&cd->data.loglevel);
1096                 break;
1097
1098         case CTDB_CONTROL_SET_DEBUG:
1099                 break;
1100
1101         case CTDB_CONTROL_GET_DBMAP:
1102                 len = ctdb_dbid_map_len(cd->data.dbmap);
1103                 break;
1104
1105         case CTDB_CONTROL_GET_RECMODE:
1106                 break;
1107
1108         case CTDB_CONTROL_SET_RECMODE:
1109                 break;
1110
1111         case CTDB_CONTROL_STATISTICS_RESET:
1112                 break;
1113
1114         case CTDB_CONTROL_DB_ATTACH:
1115                 len = ctdb_uint32_len(&cd->data.db_id);
1116                 break;
1117
1118         case CTDB_CONTROL_TRAVERSE_START:
1119                 break;
1120
1121         case CTDB_CONTROL_TRAVERSE_ALL:
1122                 break;
1123
1124         case CTDB_CONTROL_TRAVERSE_DATA:
1125                 break;
1126
1127         case CTDB_CONTROL_REGISTER_SRVID:
1128                 break;
1129
1130         case CTDB_CONTROL_DEREGISTER_SRVID:
1131                 break;
1132
1133         case CTDB_CONTROL_GET_DBNAME:
1134                 len = ctdb_string_len(&cd->data.db_name);
1135                 break;
1136
1137         case CTDB_CONTROL_ENABLE_SEQNUM:
1138                 break;
1139
1140         case CTDB_CONTROL_UPDATE_SEQNUM:
1141                 break;
1142
1143         case CTDB_CONTROL_DUMP_MEMORY:
1144                 len = ctdb_string_len(&cd->data.mem_str);
1145                 break;
1146
1147         case CTDB_CONTROL_GET_PID:
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_TCP_CLIENT:
1160                 break;
1161
1162         case CTDB_CONTROL_TCP_ADD:
1163                 break;
1164
1165         case CTDB_CONTROL_TCP_REMOVE:
1166                 break;
1167
1168         case CTDB_CONTROL_STARTUP:
1169                 break;
1170
1171         case CTDB_CONTROL_SET_TUNABLE:
1172                 break;
1173
1174         case CTDB_CONTROL_GET_TUNABLE:
1175                 len = ctdb_uint32_len(&cd->data.tun_value);
1176                 break;
1177
1178         case CTDB_CONTROL_LIST_TUNABLES:
1179                 len = ctdb_var_list_len(cd->data.tun_var_list);
1180                 break;
1181
1182         case CTDB_CONTROL_MODIFY_FLAGS:
1183                 break;
1184
1185         case CTDB_CONTROL_GET_ALL_TUNABLES:
1186                 len = ctdb_tunable_list_len(cd->data.tun_list);
1187                 break;
1188
1189         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1190                 len = ctdb_tickle_list_len(cd->data.tickles);
1191                 break;
1192
1193         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1194                 break;
1195
1196         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1197                 len = ctdb_uint32_len(&cd->data.db_id);
1198                 break;
1199
1200         case CTDB_CONTROL_UPDATE_RECORD:
1201                 break;
1202
1203         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1204                 break;
1205
1206         case CTDB_CONTROL_WIPE_DATABASE:
1207                 break;
1208
1209         case CTDB_CONTROL_UPTIME:
1210                 len = ctdb_uptime_len(cd->data.uptime);
1211                 break;
1212
1213         case CTDB_CONTROL_START_RECOVERY:
1214                 break;
1215
1216         case CTDB_CONTROL_END_RECOVERY:
1217                 break;
1218
1219         case CTDB_CONTROL_RELOAD_NODES_FILE:
1220                 break;
1221
1222         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1223                 len = ctdb_rec_buffer_len(cd->data.recbuf);
1224                 break;
1225
1226         case CTDB_CONTROL_ADD_PUBLIC_IP:
1227                 break;
1228
1229         case CTDB_CONTROL_DEL_PUBLIC_IP:
1230                 break;
1231
1232         case CTDB_CONTROL_GET_CAPABILITIES:
1233                 len = ctdb_uint32_len(&cd->data.caps);
1234                 break;
1235
1236         case CTDB_CONTROL_RECD_PING:
1237                 break;
1238
1239         case CTDB_CONTROL_RELEASE_IP:
1240                 break;
1241
1242         case CTDB_CONTROL_TAKEOVER_IP:
1243                 break;
1244
1245         case CTDB_CONTROL_GET_PUBLIC_IPS:
1246                 len = ctdb_public_ip_list_len(cd->data.pubip_list);
1247                 break;
1248
1249         case CTDB_CONTROL_GET_NODEMAP:
1250                 len = ctdb_node_map_len(cd->data.nodemap);
1251                 break;
1252
1253         case CTDB_CONTROL_TRAVERSE_KILL:
1254                 break;
1255
1256         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1257                 break;
1258
1259         case CTDB_CONTROL_GET_RECLOCK_FILE:
1260                 len = ctdb_string_len(&cd->data.reclock_file);
1261                 break;
1262
1263         case CTDB_CONTROL_STOP_NODE:
1264                 break;
1265
1266         case CTDB_CONTROL_CONTINUE_NODE:
1267                 break;
1268
1269         case CTDB_CONTROL_SET_LMASTERROLE:
1270                 break;
1271
1272         case CTDB_CONTROL_SET_RECMASTERROLE:
1273                 break;
1274
1275         case CTDB_CONTROL_SET_BAN_STATE:
1276                 break;
1277
1278         case CTDB_CONTROL_GET_BAN_STATE:
1279                 len = ctdb_ban_state_len(cd->data.ban_state);
1280                 break;
1281
1282         case CTDB_CONTROL_REGISTER_NOTIFY:
1283                 break;
1284
1285         case CTDB_CONTROL_DEREGISTER_NOTIFY:
1286                 break;
1287
1288         case CTDB_CONTROL_TRANS3_COMMIT:
1289                 break;
1290
1291         case CTDB_CONTROL_GET_DB_SEQNUM:
1292                 len = ctdb_uint64_len(&cd->data.seqnum);
1293                 break;
1294
1295         case CTDB_CONTROL_DB_SET_HEALTHY:
1296                 break;
1297
1298         case CTDB_CONTROL_DB_GET_HEALTH:
1299                 len = ctdb_string_len(&cd->data.reason);
1300                 break;
1301
1302         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1303                 len = ctdb_public_ip_info_len(cd->data.ipinfo);
1304                 break;
1305
1306         case CTDB_CONTROL_GET_IFACES:
1307                 len = ctdb_iface_list_len(cd->data.iface_list);
1308                 break;
1309
1310         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1311                 break;
1312
1313         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1314                 break;
1315
1316         case CTDB_CONTROL_GET_STAT_HISTORY:
1317                 len = ctdb_statistics_list_len(cd->data.stats_list);
1318                 break;
1319
1320         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1321                 break;
1322
1323         case CTDB_CONTROL_SET_DB_READONLY:
1324                 break;
1325
1326         case CTDB_CONTROL_TRAVERSE_START_EXT:
1327                 break;
1328
1329         case CTDB_CONTROL_GET_DB_STATISTICS:
1330                 len = ctdb_db_statistics_len(cd->data.dbstats);
1331                 break;
1332
1333         case CTDB_CONTROL_SET_DB_STICKY:
1334                 break;
1335
1336         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1337                 break;
1338
1339         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1340                 break;
1341
1342         case CTDB_CONTROL_IPREALLOCATED:
1343                 break;
1344
1345         case CTDB_CONTROL_GET_RUNSTATE:
1346                 len = ctdb_uint32_len(&cd->data.runstate);
1347                 break;
1348
1349         case CTDB_CONTROL_DB_DETACH:
1350                 break;
1351
1352         case CTDB_CONTROL_GET_NODES_FILE:
1353                 len = ctdb_node_map_len(cd->data.nodemap);
1354                 break;
1355
1356         case CTDB_CONTROL_DB_FREEZE:
1357                 break;
1358
1359         case CTDB_CONTROL_DB_THAW:
1360                 break;
1361
1362         case CTDB_CONTROL_DB_TRANSACTION_START:
1363                 break;
1364
1365         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
1366                 break;
1367
1368         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
1369                 break;
1370
1371         case CTDB_CONTROL_DB_PULL:
1372                 len = ctdb_uint32_len(&cd->data.num_records);
1373                 break;
1374
1375         case CTDB_CONTROL_DB_PUSH_START:
1376                 break;
1377
1378         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1379                 len = ctdb_uint32_len(&cd->data.num_records);
1380                 break;
1381
1382         case CTDB_CONTROL_DB_OPEN_FLAGS:
1383                 len = ctdb_int32_len(&cd->data.tdb_flags);
1384                 break;
1385
1386         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1387                 len = ctdb_uint32_len(&cd->data.db_id);
1388                 break;
1389
1390         case CTDB_CONTROL_CHECK_PID_SRVID:
1391                 break;
1392
1393         case CTDB_CONTROL_TUNNEL_REGISTER:
1394                 break;
1395
1396         case CTDB_CONTROL_TUNNEL_DEREGISTER:
1397                 break;
1398
1399         case CTDB_CONTROL_VACUUM_FETCH:
1400                 break;
1401
1402         case CTDB_CONTROL_DB_VACUUM:
1403                 break;
1404
1405         case CTDB_CONTROL_ECHO_DATA:
1406                 len = ctdb_echo_data_len(cd->data.echo_data);
1407                 break;
1408
1409         case CTDB_CONTROL_DISABLE_NODE:
1410                 break;
1411
1412         case CTDB_CONTROL_ENABLE_NODE:
1413                 break;
1414
1415         case CTDB_CONTROL_TCP_CLIENT_DISCONNECTED:
1416                 break;
1417
1418         case CTDB_CONTROL_TCP_CLIENT_PASSED:
1419                 break;
1420
1421         case CTDB_CONTROL_START_IPREALLOCATE:
1422             break;
1423         }
1424
1425         return len;
1426 }
1427
1428 static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
1429                                          uint8_t *buf, size_t *npush)
1430 {
1431         size_t np = 0;
1432
1433         switch (cd->opcode) {
1434         case CTDB_CONTROL_STATISTICS:
1435                 ctdb_statistics_push(cd->data.stats, buf, &np);
1436                 break;
1437
1438         case CTDB_CONTROL_GETDBPATH:
1439                 ctdb_string_push(&cd->data.db_path, buf, &np);
1440                 break;
1441
1442         case CTDB_CONTROL_GETVNNMAP:
1443                 ctdb_vnn_map_push(cd->data.vnnmap, buf, &np);
1444                 break;
1445
1446         case CTDB_CONTROL_GET_DEBUG:
1447                 ctdb_uint32_push(&cd->data.loglevel, buf, &np);
1448                 break;
1449
1450         case CTDB_CONTROL_GET_DBMAP:
1451                 ctdb_dbid_map_push(cd->data.dbmap, buf, &np);
1452                 break;
1453
1454         case CTDB_CONTROL_DB_ATTACH:
1455                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
1456                 break;
1457
1458         case CTDB_CONTROL_GET_DBNAME:
1459                 ctdb_string_push(&cd->data.db_name, buf, &np);
1460                 break;
1461
1462         case CTDB_CONTROL_DUMP_MEMORY:
1463                 ctdb_string_push(&cd->data.mem_str, buf, &np);
1464                 break;
1465
1466         case CTDB_CONTROL_GET_PID:
1467                 break;
1468
1469         case CTDB_CONTROL_GET_TUNABLE:
1470                 ctdb_uint32_push(&cd->data.tun_value, buf, &np);
1471                 break;
1472
1473         case CTDB_CONTROL_LIST_TUNABLES:
1474                 ctdb_var_list_push(cd->data.tun_var_list, buf, &np);
1475                 break;
1476
1477         case CTDB_CONTROL_GET_ALL_TUNABLES:
1478                 ctdb_tunable_list_push(cd->data.tun_list, buf, &np);
1479                 break;
1480
1481         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1482                 ctdb_tickle_list_push(cd->data.tickles, buf, &np);
1483                 break;
1484
1485         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1486                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
1487                 break;
1488
1489         case CTDB_CONTROL_UPTIME:
1490                 ctdb_uptime_push(cd->data.uptime, buf, &np);
1491                 break;
1492
1493         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1494                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
1495                 break;
1496
1497         case CTDB_CONTROL_GET_CAPABILITIES:
1498                 ctdb_uint32_push(&cd->data.caps, buf, &np);
1499                 break;
1500
1501         case CTDB_CONTROL_GET_PUBLIC_IPS:
1502                 ctdb_public_ip_list_push(cd->data.pubip_list, buf, &np);
1503                 break;
1504
1505         case CTDB_CONTROL_GET_NODEMAP:
1506                 ctdb_node_map_push(cd->data.nodemap, buf, &np);
1507                 break;
1508
1509         case CTDB_CONTROL_GET_RECLOCK_FILE:
1510                 ctdb_string_push(&cd->data.reclock_file, buf, &np);
1511                 break;
1512
1513         case CTDB_CONTROL_GET_BAN_STATE:
1514                 ctdb_ban_state_push(cd->data.ban_state, buf, &np);
1515                 break;
1516
1517         case CTDB_CONTROL_GET_DB_SEQNUM:
1518                 ctdb_uint64_push(&cd->data.seqnum, buf, &np);
1519                 break;
1520
1521         case CTDB_CONTROL_DB_GET_HEALTH:
1522                 ctdb_string_push(&cd->data.reason, buf, &np);
1523                 break;
1524
1525         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1526                 ctdb_public_ip_info_push(cd->data.ipinfo, buf, &np);
1527                 break;
1528
1529         case CTDB_CONTROL_GET_IFACES:
1530                 ctdb_iface_list_push(cd->data.iface_list, buf, &np);
1531                 break;
1532
1533         case CTDB_CONTROL_GET_STAT_HISTORY:
1534                 ctdb_statistics_list_push(cd->data.stats_list, buf, &np);
1535                 break;
1536
1537         case CTDB_CONTROL_GET_DB_STATISTICS:
1538                 ctdb_db_statistics_push(cd->data.dbstats, buf, &np);
1539                 break;
1540
1541         case CTDB_CONTROL_GET_RUNSTATE:
1542                 ctdb_uint32_push(&cd->data.runstate, buf, &np);
1543                 break;
1544
1545         case CTDB_CONTROL_GET_NODES_FILE:
1546                 ctdb_node_map_push(cd->data.nodemap, buf, &np);
1547                 break;
1548
1549         case CTDB_CONTROL_DB_PULL:
1550                 ctdb_uint32_push(&cd->data.num_records, buf, &np);
1551                 break;
1552
1553         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1554                 ctdb_uint32_push(&cd->data.num_records, buf, &np);
1555                 break;
1556
1557         case CTDB_CONTROL_DB_OPEN_FLAGS:
1558                 ctdb_int32_push(&cd->data.tdb_flags, buf, &np);
1559                 break;
1560
1561         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1562                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
1563                 break;
1564
1565         case CTDB_CONTROL_CHECK_PID_SRVID:
1566                 break;
1567
1568         case CTDB_CONTROL_VACUUM_FETCH:
1569                 break;
1570
1571         case CTDB_CONTROL_DB_VACUUM:
1572                 break;
1573
1574         case CTDB_CONTROL_ECHO_DATA:
1575                 ctdb_echo_data_push(cd->data.echo_data, buf, &np);
1576                 break;
1577         }
1578
1579         *npush = np;
1580 }
1581
1582 static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
1583                                         uint32_t opcode, TALLOC_CTX *mem_ctx,
1584                                         struct ctdb_reply_control_data *cd,
1585                                         size_t *npull)
1586 {
1587         size_t np = 0;
1588         int ret = 0;
1589
1590         cd->opcode = opcode;
1591
1592         switch (opcode) {
1593         case CTDB_CONTROL_STATISTICS:
1594                 ret = ctdb_statistics_pull(buf, buflen, mem_ctx,
1595                                            &cd->data.stats, &np);
1596                 break;
1597
1598         case CTDB_CONTROL_GETDBPATH:
1599                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1600                                        &cd->data.db_path, &np);
1601                 break;
1602
1603         case CTDB_CONTROL_GETVNNMAP:
1604                 ret = ctdb_vnn_map_pull(buf, buflen, mem_ctx,
1605                                         &cd->data.vnnmap, &np);
1606                 break;
1607
1608         case CTDB_CONTROL_GET_DEBUG:
1609                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.loglevel, &np);
1610                 break;
1611
1612         case CTDB_CONTROL_GET_DBMAP:
1613                 ret = ctdb_dbid_map_pull(buf, buflen, mem_ctx,
1614                                          &cd->data.dbmap, &np);
1615                 break;
1616
1617         case CTDB_CONTROL_DB_ATTACH:
1618                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1619                 break;
1620
1621         case CTDB_CONTROL_GET_DBNAME:
1622                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1623                                        &cd->data.db_name, &np);
1624                 break;
1625
1626         case CTDB_CONTROL_DUMP_MEMORY:
1627                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1628                                        &cd->data.mem_str, &np);
1629                 break;
1630
1631         case CTDB_CONTROL_GET_PID:
1632                 break;
1633
1634         case CTDB_CONTROL_GET_TUNABLE:
1635                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.tun_value,
1636                                        &np);
1637                 break;
1638
1639         case CTDB_CONTROL_LIST_TUNABLES:
1640                 ret = ctdb_var_list_pull(buf, buflen, mem_ctx,
1641                                          &cd->data.tun_var_list, &np);
1642                 break;
1643
1644         case CTDB_CONTROL_GET_ALL_TUNABLES:
1645                 ret = ctdb_tunable_list_pull(buf, buflen, mem_ctx,
1646                                              &cd->data.tun_list, &np);
1647                 break;
1648
1649         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1650                 ret = ctdb_tickle_list_pull(buf, buflen, mem_ctx,
1651                                             &cd->data.tickles, &np);
1652                 break;
1653
1654         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1655                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1656                 break;
1657
1658         case CTDB_CONTROL_UPTIME:
1659                 ret = ctdb_uptime_pull(buf, buflen, mem_ctx,
1660                                        &cd->data.uptime, &np);
1661                 break;
1662
1663         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1664                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1665                                            &cd->data.recbuf, &np);
1666                 break;
1667
1668         case CTDB_CONTROL_GET_CAPABILITIES:
1669                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.caps, &np);
1670                 break;
1671
1672         case CTDB_CONTROL_GET_PUBLIC_IPS:
1673                 ret = ctdb_public_ip_list_pull(buf, buflen, mem_ctx,
1674                                                &cd->data.pubip_list, &np);
1675                 break;
1676
1677         case CTDB_CONTROL_GET_NODEMAP:
1678                 ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
1679                                          &cd->data.nodemap, &np);
1680                 break;
1681
1682         case CTDB_CONTROL_GET_RECLOCK_FILE:
1683                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1684                                        &cd->data.reclock_file, &np);
1685                 break;
1686
1687         case CTDB_CONTROL_GET_BAN_STATE:
1688                 ret = ctdb_ban_state_pull(buf, buflen, mem_ctx,
1689                                           &cd->data.ban_state, &np);
1690                 break;
1691
1692         case CTDB_CONTROL_GET_DB_SEQNUM:
1693                 ret = ctdb_uint64_pull(buf, buflen, &cd->data.seqnum, &np);
1694                 break;
1695
1696         case CTDB_CONTROL_DB_GET_HEALTH:
1697                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1698                                        &cd->data.reason, &np);
1699                 break;
1700
1701         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1702                 ret = ctdb_public_ip_info_pull(buf, buflen, mem_ctx,
1703                                                &cd->data.ipinfo, &np);
1704                 break;
1705
1706         case CTDB_CONTROL_GET_IFACES:
1707                 ret = ctdb_iface_list_pull(buf, buflen, mem_ctx,
1708                                            &cd->data.iface_list, &np);
1709                 break;
1710
1711         case CTDB_CONTROL_GET_STAT_HISTORY:
1712                 ret = ctdb_statistics_list_pull(buf, buflen, mem_ctx,
1713                                                 &cd->data.stats_list, &np);
1714                 break;
1715
1716         case CTDB_CONTROL_GET_DB_STATISTICS:
1717                 ret = ctdb_db_statistics_pull(buf, buflen, mem_ctx,
1718                                               &cd->data.dbstats, &np);
1719                 break;
1720
1721         case CTDB_CONTROL_GET_RUNSTATE:
1722                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.runstate, &np);
1723                 break;
1724
1725         case CTDB_CONTROL_GET_NODES_FILE:
1726                 ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
1727                                          &cd->data.nodemap, &np);
1728                 break;
1729
1730         case CTDB_CONTROL_DB_PULL:
1731                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.num_records,
1732                                        &np);
1733                 break;
1734
1735         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1736                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.num_records,
1737                                        &np);
1738                 break;
1739
1740         case CTDB_CONTROL_DB_OPEN_FLAGS:
1741                 ret = ctdb_int32_pull(buf, buflen, &cd->data.tdb_flags, &np);
1742                 break;
1743
1744         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1745                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1746                 break;
1747
1748         case CTDB_CONTROL_CHECK_PID_SRVID:
1749                 break;
1750
1751         case CTDB_CONTROL_VACUUM_FETCH:
1752                 break;
1753
1754         case CTDB_CONTROL_DB_VACUUM:
1755                 break;
1756
1757         case CTDB_CONTROL_ECHO_DATA:
1758                 ret = ctdb_echo_data_pull(buf,
1759                                           buflen,
1760                                           mem_ctx,
1761                                           &cd->data.echo_data,
1762                                           &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         uint32_t dsize, esize;
1914
1915         if (c->status == 0) {
1916                 dsize = ctdb_reply_control_data_len(&c->rdata);
1917                 esize = 0;
1918         } else {
1919                 dsize = 0;
1920                 esize = ctdb_string_len(&c->errmsg);
1921         }
1922
1923         return ctdb_req_header_len(h) +
1924                 ctdb_int32_len(&c->status) +
1925                 ctdb_uint32_len(&dsize) +
1926                 ctdb_uint32_len(&esize) +
1927                 dsize + esize;
1928 }
1929
1930 int ctdb_reply_control_push(struct ctdb_req_header *h,
1931                             struct ctdb_reply_control *c,
1932                             uint8_t *buf, size_t *buflen)
1933 {
1934         size_t offset = 0, np;
1935         size_t length;
1936         uint32_t dsize, esize;
1937
1938         length = ctdb_reply_control_len(h, c);
1939         if (*buflen < length) {
1940                 *buflen = length;
1941                 return EMSGSIZE;
1942         }
1943
1944         h->length = *buflen;
1945         ctdb_req_header_push(h, buf+offset, &np);
1946         offset += np;
1947
1948         ctdb_int32_push(&c->status, buf+offset, &np);
1949         offset += np;
1950
1951         if (c->status == 0) {
1952                 dsize = ctdb_reply_control_data_len(&c->rdata);
1953                 esize = 0;
1954         } else {
1955                 dsize = 0;
1956                 esize = ctdb_string_len(&c->errmsg);
1957         }
1958
1959         ctdb_uint32_push(&dsize, buf+offset, &np);
1960         offset += np;
1961
1962         ctdb_uint32_push(&esize, buf+offset, &np);
1963         offset += np;
1964
1965         if (c->status == 0) {
1966                 ctdb_reply_control_data_push(&c->rdata, buf+offset, &np);
1967         } else {
1968                 ctdb_string_push(&c->errmsg, buf+offset, &np);
1969         }
1970         offset += np;
1971
1972         return 0;
1973 }
1974
1975 int ctdb_reply_control_pull(uint8_t *buf, size_t buflen, uint32_t opcode,
1976                             struct ctdb_req_header *h,
1977                             TALLOC_CTX *mem_ctx,
1978                             struct ctdb_reply_control *c)
1979 {
1980         struct ctdb_req_header header;
1981         size_t offset = 0, np;
1982         uint32_t dsize, esize;
1983         int ret;
1984
1985         ret = ctdb_req_header_pull(buf+offset, buflen-offset, &header, &np);
1986         if (ret != 0) {
1987                 return ret;
1988         }
1989         offset += np;
1990
1991         if (h != NULL) {
1992                 *h = header;
1993         }
1994
1995         ret = ctdb_int32_pull(buf+offset, buflen-offset, &c->status, &np);
1996         if (ret != 0) {
1997                 return ret;
1998         }
1999         offset += np;
2000
2001         ret = ctdb_uint32_pull(buf+offset, buflen-offset, &dsize, &np);
2002         if (ret != 0) {
2003                 return ret;
2004         }
2005         offset += np;
2006
2007         ret = ctdb_uint32_pull(buf+offset, buflen-offset, &esize, &np);
2008         if (ret != 0) {
2009                 return ret;
2010         }
2011         offset += np;
2012
2013         c->errmsg = NULL;
2014
2015         if (c->status == 0) {
2016                 if (buflen-offset < dsize) {
2017                         return EMSGSIZE;
2018                 }
2019
2020                 ret = ctdb_reply_control_data_pull(buf+offset, dsize,
2021                                                    opcode, mem_ctx, &c->rdata,
2022                                                    &np);
2023                 if (ret != 0) {
2024                         return ret;
2025                 }
2026                 offset += np;
2027
2028         } else {
2029                 if (buflen-offset < esize) {
2030                         return EMSGSIZE;
2031                 }
2032
2033                 ret = ctdb_string_pull(buf+offset, esize, mem_ctx, &c->errmsg,
2034                                        &np);
2035                 if (ret != 0) {
2036                         return ret;
2037                 }
2038                 offset += np;
2039         }
2040
2041         return 0;
2042 }