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