ctdb/protocol/protocol_control.c

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