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