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, &np);
 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, &np);
 487                 break;
 488
 489         case CTDB_CONTROL_TRAVERSE_ALL:
 490                 ctdb_traverse_all_push(cd->data.traverse_all, buf, &np);
 491                 break;
 492
 493         case CTDB_CONTROL_TRAVERSE_DATA:
 494                 ctdb_rec_data_push(cd->data.rec_data, buf, &np);
 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, &np);
 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, &np);
 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, &np);
 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, &np);
 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                                              &np);
 657                 break;
 658
 659         case CTDB_CONTROL_GET_DB_STATISTICS:
 660                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 661                 break;
 662
 663         case CTDB_CONTROL_SET_DB_STICKY:
 664                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 665                 break;
 666
 667         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 668                 ctdb_traverse_all_ext_push(cd->data.traverse_all_ext, buf);
 669                 break;
 670
 671         case CTDB_CONTROL_RECEIVE_RECORDS:
 672                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
 673                 break;
 674
 675         case CTDB_CONTROL_DB_DETACH:
 676                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 677                 break;
 678
 679         case CTDB_CONTROL_DB_FREEZE:
 680                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 681                 break;
 682
 683         case CTDB_CONTROL_DB_THAW:
 684                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 685                 break;
 686
 687         case CTDB_CONTROL_DB_TRANSACTION_START:
 688                 ctdb_transdb_push(cd->data.transdb, buf);
 689                 break;
 690
 691         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
 692                 ctdb_transdb_push(cd->data.transdb, buf);
 693                 break;
 694
 695         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
 696                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 697                 break;
 698
 699         case CTDB_CONTROL_DB_PULL:
 700                 ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf, &np);
 701                 break;
 702
 703         case CTDB_CONTROL_DB_PUSH_START:
 704                 ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf, &np);
 705                 break;
 706
 707         case CTDB_CONTROL_DB_PUSH_CONFIRM:
 708                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 709                 break;
 710
 711         case CTDB_CONTROL_DB_OPEN_FLAGS:
 712                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
 713                 break;
 714
 715         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
 716                 ctdb_string_push(&cd->data.db_name, buf, &np);
 717                 break;
 718         }
 719 }
 720
 721 static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
 722                                       uint32_t opcode,
 723                                       TALLOC_CTX *mem_ctx,
 724                                       struct ctdb_req_control_data *cd)
 725 {
 726         size_t np, offset;
 727         uint32_t u32;
 728         int ret = 0;
 729
 730         cd->opcode = opcode;
 731
 732         switch (opcode) {
 733         case CTDB_CONTROL_PROCESS_EXISTS:
 734                 ret = ctdb_pid_pull(buf, buflen, &cd->data.pid, &np);
 735                 break;
 736
 737         case CTDB_CONTROL_GETDBPATH:
 738                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 739                 break;
 740
 741         case CTDB_CONTROL_SETVNNMAP:
 742                 ret = ctdb_vnn_map_pull(buf, buflen, mem_ctx,
 743                                         &cd->data.vnnmap, &np);
 744                 break;
 745
 746         case CTDB_CONTROL_SET_DEBUG:
 747                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.loglevel, &np);
 748                 break;
 749
 750         case CTDB_CONTROL_PULL_DB:
 751                 ret = ctdb_pulldb_pull(buf, buflen, mem_ctx,
 752                                        &cd->data.pulldb, &np);
 753                 break;
 754
 755         case CTDB_CONTROL_PUSH_DB:
 756                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 757                                            &cd->data.recbuf, &np);
 758                 break;
 759
 760         case CTDB_CONTROL_SET_RECMODE:
 761                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.recmode, &np);
 762                 break;
 763
 764         case CTDB_CONTROL_DB_ATTACH:
 765                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
 766                                        &cd->data.db_name, &np);
 767                 break;
 768
 769         case CTDB_CONTROL_SET_CALL:
 770                 break;
 771
 772         case CTDB_CONTROL_TRAVERSE_START:
 773                 ret = ctdb_traverse_start_pull(buf, buflen, mem_ctx,
 774                                                &cd->data.traverse_start, &np);
 775                 break;
 776
 777         case CTDB_CONTROL_TRAVERSE_ALL:
 778                 ret = ctdb_traverse_all_pull(buf, buflen, mem_ctx,
 779                                              &cd->data.traverse_all, &np);
 780                 break;
 781
 782         case CTDB_CONTROL_TRAVERSE_DATA:
 783                 ret = ctdb_rec_data_pull(buf, buflen, mem_ctx,
 784                                          &cd->data.rec_data, &np);
 785                 break;
 786
 787         case CTDB_CONTROL_GET_DBNAME:
 788                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 789                 break;
 790
 791         case CTDB_CONTROL_ENABLE_SEQNUM:
 792                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 793                 break;
 794
 795         case CTDB_CONTROL_UPDATE_SEQNUM:
 796                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 797                 break;
 798
 799         case CTDB_CONTROL_SET_RECMASTER:
 800                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.recmaster, &np);
 801                 break;
 802
 803         case CTDB_CONTROL_TCP_CLIENT:
 804                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 805                                            &cd->data.conn);
 806                 break;
 807
 808         case CTDB_CONTROL_TCP_ADD:
 809                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 810                                            &cd->data.conn);
 811                 break;
 812
 813         case CTDB_CONTROL_TCP_REMOVE:
 814                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 815                                            &cd->data.conn);
 816                 break;
 817
 818         case CTDB_CONTROL_SET_TUNABLE:
 819                 ret = ctdb_tunable_pull(buf, buflen, mem_ctx,
 820                                         &cd->data.tunable);
 821                 break;
 822
 823         case CTDB_CONTROL_GET_TUNABLE:
 824                 ret = ctdb_stringn_pull(buf, buflen, mem_ctx,
 825                                         &cd->data.tun_var, &np);
 826                 break;
 827
 828         case CTDB_CONTROL_MODIFY_FLAGS:
 829                 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
 830                                                  &cd->data.flag_change);
 831                 break;
 832
 833         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
 834                 ret = ctdb_sock_addr_pull(buf, buflen, mem_ctx,
 835                                           &cd->data.addr);
 836                 break;
 837
 838         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
 839                 ret = ctdb_tickle_list_pull(buf, buflen, mem_ctx,
 840                                             &cd->data.tickles);
 841                 break;
 842
 843         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
 844                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
 845                                        &cd->data.db_name, &np);
 846                 break;
 847
 848         case CTDB_CONTROL_UPDATE_RECORD:
 849                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 850                                            &cd->data.recbuf, &np);
 851                 break;
 852
 853         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
 854                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 855                                           &cd->data.addr_info);
 856                 break;
 857
 858         case CTDB_CONTROL_WIPE_DATABASE:
 859                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
 860                                        &cd->data.transdb);
 861                 break;
 862
 863         case CTDB_CONTROL_TRY_DELETE_RECORDS:
 864                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 865                                            &cd->data.recbuf, &np);
 866                 break;
 867
 868         case CTDB_CONTROL_ADD_PUBLIC_IP:
 869                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 870                                           &cd->data.addr_info);
 871                 break;
 872
 873         case CTDB_CONTROL_DEL_PUBLIC_IP:
 874                 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
 875                                           &cd->data.addr_info);
 876                 break;
 877
 878         case CTDB_CONTROL_RELEASE_IP:
 879                 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
 880                                           &cd->data.pubip);
 881                 break;
 882
 883         case CTDB_CONTROL_TAKEOVER_IP:
 884                 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
 885                                           &cd->data.pubip);
 886                 break;
 887
 888         case CTDB_CONTROL_TRAVERSE_KILL:
 889                 ret = ctdb_traverse_start_pull(buf, buflen, mem_ctx,
 890                                                &cd->data.traverse_start, &np);
 891                 break;
 892
 893         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
 894                 ret = ctdb_double_pull(buf, buflen, &cd->data.reclock_latency,
 895                                        &np);
 896                 break;
 897
 898         case CTDB_CONTROL_SET_LMASTERROLE:
 899                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.role, &np);
 900                 break;
 901
 902         case CTDB_CONTROL_SET_RECMASTERROLE:
 903                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.role, &np);
 904                 break;
 905
 906         case CTDB_CONTROL_SET_BAN_STATE:
 907                 ret = ctdb_ban_state_pull(buf, buflen, mem_ctx,
 908                                           &cd->data.ban_state);
 909                 break;
 910
 911         case CTDB_CONTROL_REGISTER_NOTIFY:
 912                 ret = ctdb_notify_data_pull(buf, buflen, mem_ctx,
 913                                             &cd->data.notify);
 914                 break;
 915
 916         case CTDB_CONTROL_DEREGISTER_NOTIFY:
 917                 ctdb_uint64_pull(buf, buflen, &cd->data.srvid, &np);
 918                 break;
 919
 920         case CTDB_CONTROL_TRANS3_COMMIT:
 921                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 922                                            &cd->data.recbuf, &np);
 923                 break;
 924
 925         case CTDB_CONTROL_GET_DB_SEQNUM:
 926                 offset = 0;
 927                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 928                 if (ret != 0) {
 929                         break;
 930                 }
 931                 offset += np;
 932                 ret = ctdb_uint32_pull(buf+offset, buflen-offset, &u32, &np);
 933                 offset += np;
 934                 np = offset;
 935                 break;
 936
 937         case CTDB_CONTROL_DB_SET_HEALTHY:
 938                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 939                 break;
 940
 941         case CTDB_CONTROL_DB_GET_HEALTH:
 942                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 943                 break;
 944
 945         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
 946                 ret = ctdb_sock_addr_pull(buf, buflen, mem_ctx,
 947                                           &cd->data.addr);
 948                 break;
 949
 950         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
 951                 ret = ctdb_iface_pull(buf, buflen, mem_ctx,
 952                                       &cd->data.iface);
 953                 break;
 954
 955         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
 956                 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
 957                                            &cd->data.conn);
 958                 break;
 959
 960         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
 961                 ret = ctdb_key_data_pull(buf, buflen, mem_ctx,
 962                                          &cd->data.key);
 963                 break;
 964
 965         case CTDB_CONTROL_SET_DB_READONLY:
 966                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 967                 break;
 968
 969         case CTDB_CONTROL_CHECK_SRVIDS:
 970                 break;
 971
 972         case CTDB_CONTROL_TRAVERSE_START_EXT:
 973                 ret = ctdb_traverse_start_ext_pull(buf, buflen, mem_ctx,
 974                                                    &cd->data.traverse_start_ext,
 975                                                    &np);
 976                 break;
 977
 978         case CTDB_CONTROL_GET_DB_STATISTICS:
 979                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 980                 break;
 981
 982         case CTDB_CONTROL_SET_DB_STICKY:
 983                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 984                 break;
 985
 986         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
 987                 ret = ctdb_traverse_all_ext_pull(buf, buflen, mem_ctx,
 988                                                  &cd->data.traverse_all_ext);
 989                 break;
 990
 991         case CTDB_CONTROL_RECEIVE_RECORDS:
 992                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
 993                                            &cd->data.recbuf, &np);
 994                 break;
 995
 996         case CTDB_CONTROL_DB_DETACH:
 997                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
 998                 break;
 999
1000         case CTDB_CONTROL_DB_FREEZE:
1001                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1002                 break;
1003
1004         case CTDB_CONTROL_DB_THAW:
1005                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1006                 break;
1007
1008         case CTDB_CONTROL_DB_TRANSACTION_START:
1009                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
1010                                         &cd->data.transdb);
1011                 break;
1012
1013         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
1014                 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
1015                                         &cd->data.transdb);
1016                 break;
1017
1018         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
1019                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1020                 break;
1021
1022         case CTDB_CONTROL_DB_PULL:
1023                 ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
1024                                            &cd->data.pulldb_ext, &np);
1025                 break;
1026
1027         case CTDB_CONTROL_DB_PUSH_START:
1028                 ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
1029                                            &cd->data.pulldb_ext, &np);
1030                 break;
1031
1032         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1033                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1034                 break;
1035
1036         case CTDB_CONTROL_DB_OPEN_FLAGS:
1037                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1038                 break;
1039
1040         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1041                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1042                                        &cd->data.db_name, &np);
1043                 break;
1044         }
1045
1046         return ret;
1047 }
1048
1049 static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
1050 {
1051         size_t len = 0;
1052
1053         if (cd == NULL) {
1054                 return 0;
1055         }
1056
1057         switch (cd->opcode) {
1058         case CTDB_CONTROL_PROCESS_EXISTS:
1059                 break;
1060
1061         case CTDB_CONTROL_STATISTICS:
1062                 len = ctdb_statistics_len(cd->data.stats);
1063                 break;
1064
1065         case CTDB_CONTROL_PING:
1066                 break;
1067
1068         case CTDB_CONTROL_GETDBPATH:
1069                 len = ctdb_string_len(&cd->data.db_path);
1070                 break;
1071
1072         case CTDB_CONTROL_GETVNNMAP:
1073                 len = ctdb_vnn_map_len(cd->data.vnnmap);
1074                 break;
1075
1076         case CTDB_CONTROL_SETVNNMAP:
1077                 break;
1078
1079         case CTDB_CONTROL_GET_DEBUG:
1080                 len = ctdb_uint32_len(&cd->data.loglevel);
1081                 break;
1082
1083         case CTDB_CONTROL_SET_DEBUG:
1084                 break;
1085
1086         case CTDB_CONTROL_GET_DBMAP:
1087                 len = ctdb_dbid_map_len(cd->data.dbmap);
1088                 break;
1089
1090         case CTDB_CONTROL_PULL_DB:
1091                 len = ctdb_rec_buffer_len(cd->data.recbuf);
1092                 break;
1093
1094         case CTDB_CONTROL_PUSH_DB:
1095                 break;
1096
1097         case CTDB_CONTROL_GET_RECMODE:
1098                 break;
1099
1100         case CTDB_CONTROL_SET_RECMODE:
1101                 break;
1102
1103         case CTDB_CONTROL_STATISTICS_RESET:
1104                 break;
1105
1106         case CTDB_CONTROL_DB_ATTACH:
1107                 len = ctdb_uint32_len(&cd->data.db_id);
1108                 break;
1109
1110         case CTDB_CONTROL_SET_CALL:
1111                 break;
1112
1113         case CTDB_CONTROL_TRAVERSE_START:
1114                 break;
1115
1116         case CTDB_CONTROL_TRAVERSE_ALL:
1117                 break;
1118
1119         case CTDB_CONTROL_TRAVERSE_DATA:
1120                 break;
1121
1122         case CTDB_CONTROL_REGISTER_SRVID:
1123                 break;
1124
1125         case CTDB_CONTROL_DEREGISTER_SRVID:
1126                 break;
1127
1128         case CTDB_CONTROL_GET_DBNAME:
1129                 len = ctdb_string_len(&cd->data.db_name);
1130                 break;
1131
1132         case CTDB_CONTROL_ENABLE_SEQNUM:
1133                 break;
1134
1135         case CTDB_CONTROL_UPDATE_SEQNUM:
1136                 break;
1137
1138         case CTDB_CONTROL_DUMP_MEMORY:
1139                 len = ctdb_string_len(&cd->data.mem_str);
1140                 break;
1141
1142         case CTDB_CONTROL_GET_PID:
1143                 break;
1144
1145         case CTDB_CONTROL_GET_RECMASTER:
1146                 break;
1147
1148         case CTDB_CONTROL_SET_RECMASTER:
1149                 break;
1150
1151         case CTDB_CONTROL_FREEZE:
1152                 break;
1153
1154         case CTDB_CONTROL_GET_PNN:
1155                 break;
1156
1157         case CTDB_CONTROL_SHUTDOWN:
1158                 break;
1159
1160         case CTDB_CONTROL_GET_MONMODE:
1161                 break;
1162
1163         case CTDB_CONTROL_TCP_CLIENT:
1164                 break;
1165
1166         case CTDB_CONTROL_TCP_ADD:
1167                 break;
1168
1169         case CTDB_CONTROL_TCP_REMOVE:
1170                 break;
1171
1172         case CTDB_CONTROL_STARTUP:
1173                 break;
1174
1175         case CTDB_CONTROL_SET_TUNABLE:
1176                 break;
1177
1178         case CTDB_CONTROL_GET_TUNABLE:
1179                 len = ctdb_uint32_len(&cd->data.tun_value);
1180                 break;
1181
1182         case CTDB_CONTROL_LIST_TUNABLES:
1183                 len = ctdb_var_list_len(cd->data.tun_var_list);
1184                 break;
1185
1186         case CTDB_CONTROL_MODIFY_FLAGS:
1187                 break;
1188
1189         case CTDB_CONTROL_GET_ALL_TUNABLES:
1190                 len = ctdb_tunable_list_len(cd->data.tun_list);
1191                 break;
1192
1193         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1194                 len = ctdb_tickle_list_len(cd->data.tickles);
1195                 break;
1196
1197         case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1198                 break;
1199
1200         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1201                 len = ctdb_uint32_len(&cd->data.db_id);
1202                 break;
1203
1204         case CTDB_CONTROL_UPDATE_RECORD:
1205                 break;
1206
1207         case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1208                 break;
1209
1210         case CTDB_CONTROL_WIPE_DATABASE:
1211                 break;
1212
1213         case CTDB_CONTROL_UPTIME:
1214                 len = ctdb_uptime_len(cd->data.uptime);
1215                 break;
1216
1217         case CTDB_CONTROL_START_RECOVERY:
1218                 break;
1219
1220         case CTDB_CONTROL_END_RECOVERY:
1221                 break;
1222
1223         case CTDB_CONTROL_RELOAD_NODES_FILE:
1224                 break;
1225
1226         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1227                 len = ctdb_rec_buffer_len(cd->data.recbuf);
1228                 break;
1229
1230         case CTDB_CONTROL_ENABLE_MONITOR:
1231                 break;
1232
1233         case CTDB_CONTROL_DISABLE_MONITOR:
1234                 break;
1235
1236         case CTDB_CONTROL_ADD_PUBLIC_IP:
1237                 break;
1238
1239         case CTDB_CONTROL_DEL_PUBLIC_IP:
1240                 break;
1241
1242         case CTDB_CONTROL_GET_CAPABILITIES:
1243                 len = ctdb_uint32_len(&cd->data.caps);
1244                 break;
1245
1246         case CTDB_CONTROL_RECD_PING:
1247                 break;
1248
1249         case CTDB_CONTROL_RELEASE_IP:
1250                 break;
1251
1252         case CTDB_CONTROL_TAKEOVER_IP:
1253                 break;
1254
1255         case CTDB_CONTROL_GET_PUBLIC_IPS:
1256                 len = ctdb_public_ip_list_len(cd->data.pubip_list);
1257                 break;
1258
1259         case CTDB_CONTROL_GET_NODEMAP:
1260                 len = ctdb_node_map_len(cd->data.nodemap);
1261                 break;
1262
1263         case CTDB_CONTROL_TRAVERSE_KILL:
1264                 break;
1265
1266         case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1267                 break;
1268
1269         case CTDB_CONTROL_GET_RECLOCK_FILE:
1270                 len = ctdb_string_len(&cd->data.reclock_file);
1271                 break;
1272
1273         case CTDB_CONTROL_STOP_NODE:
1274                 break;
1275
1276         case CTDB_CONTROL_CONTINUE_NODE:
1277                 break;
1278
1279         case CTDB_CONTROL_SET_LMASTERROLE:
1280                 break;
1281
1282         case CTDB_CONTROL_SET_RECMASTERROLE:
1283                 break;
1284
1285         case CTDB_CONTROL_SET_BAN_STATE:
1286                 break;
1287
1288         case CTDB_CONTROL_GET_BAN_STATE:
1289                 len = ctdb_ban_state_len(cd->data.ban_state);
1290                 break;
1291
1292         case CTDB_CONTROL_SET_DB_PRIORITY:
1293                 break;
1294
1295         case CTDB_CONTROL_GET_DB_PRIORITY:
1296                 break;
1297
1298         case CTDB_CONTROL_REGISTER_NOTIFY:
1299                 break;
1300
1301         case CTDB_CONTROL_DEREGISTER_NOTIFY:
1302                 break;
1303
1304         case CTDB_CONTROL_TRANS3_COMMIT:
1305                 break;
1306
1307         case CTDB_CONTROL_GET_DB_SEQNUM:
1308                 len = ctdb_uint64_len(&cd->data.seqnum);
1309                 break;
1310
1311         case CTDB_CONTROL_DB_SET_HEALTHY:
1312                 break;
1313
1314         case CTDB_CONTROL_DB_GET_HEALTH:
1315                 len = ctdb_string_len(&cd->data.reason);
1316                 break;
1317
1318         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1319                 len = ctdb_public_ip_info_len(cd->data.ipinfo);
1320                 break;
1321
1322         case CTDB_CONTROL_GET_IFACES:
1323                 len = ctdb_iface_list_len(cd->data.iface_list);
1324                 break;
1325
1326         case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1327                 break;
1328
1329         case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1330                 break;
1331
1332         case CTDB_CONTROL_GET_STAT_HISTORY:
1333                 len = ctdb_statistics_list_len(cd->data.stats_list);
1334                 break;
1335
1336         case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1337                 break;
1338
1339         case CTDB_CONTROL_SET_DB_READONLY:
1340                 break;
1341
1342         case CTDB_CONTROL_CHECK_SRVIDS:
1343                 break;
1344
1345         case CTDB_CONTROL_TRAVERSE_START_EXT:
1346                 break;
1347
1348         case CTDB_CONTROL_GET_DB_STATISTICS:
1349                 len = ctdb_db_statistics_len(cd->data.dbstats);
1350                 break;
1351
1352         case CTDB_CONTROL_SET_DB_STICKY:
1353                 break;
1354
1355         case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1356                 break;
1357
1358         case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1359                 break;
1360
1361         case CTDB_CONTROL_RECEIVE_RECORDS:
1362                 len = ctdb_rec_buffer_len(cd->data.recbuf);
1363                 break;
1364
1365         case CTDB_CONTROL_IPREALLOCATED:
1366                 break;
1367
1368         case CTDB_CONTROL_GET_RUNSTATE:
1369                 len = ctdb_uint32_len(&cd->data.runstate);
1370                 break;
1371
1372         case CTDB_CONTROL_DB_DETACH:
1373                 break;
1374
1375         case CTDB_CONTROL_GET_NODES_FILE:
1376                 len = ctdb_node_map_len(cd->data.nodemap);
1377                 break;
1378
1379         case CTDB_CONTROL_DB_FREEZE:
1380                 break;
1381
1382         case CTDB_CONTROL_DB_THAW:
1383                 break;
1384
1385         case CTDB_CONTROL_DB_TRANSACTION_START:
1386                 break;
1387
1388         case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
1389                 break;
1390
1391         case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
1392                 break;
1393
1394         case CTDB_CONTROL_DB_PULL:
1395                 len = ctdb_uint32_len(&cd->data.num_records);
1396                 break;
1397
1398         case CTDB_CONTROL_DB_PUSH_START:
1399                 break;
1400
1401         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1402                 len = ctdb_uint32_len(&cd->data.num_records);
1403                 break;
1404
1405         case CTDB_CONTROL_DB_OPEN_FLAGS:
1406                 len = ctdb_int32_len(&cd->data.tdb_flags);
1407                 break;
1408
1409         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1410                 len = ctdb_uint32_len(&cd->data.db_id);
1411                 break;
1412         }
1413
1414         return len;
1415 }
1416
1417 static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
1418                                          uint8_t *buf)
1419 {
1420         size_t np;
1421
1422         switch (cd->opcode) {
1423         case CTDB_CONTROL_STATISTICS:
1424                 ctdb_statistics_push(cd->data.stats, buf, &np);
1425                 break;
1426
1427         case CTDB_CONTROL_GETDBPATH:
1428                 ctdb_string_push(&cd->data.db_path, buf, &np);
1429                 break;
1430
1431         case CTDB_CONTROL_GETVNNMAP:
1432                 ctdb_vnn_map_push(cd->data.vnnmap, buf, &np);
1433                 break;
1434
1435         case CTDB_CONTROL_GET_DEBUG:
1436                 ctdb_uint32_push(&cd->data.loglevel, buf, &np);
1437                 break;
1438
1439         case CTDB_CONTROL_GET_DBMAP:
1440                 ctdb_dbid_map_push(cd->data.dbmap, buf, &np);
1441                 break;
1442
1443         case CTDB_CONTROL_PULL_DB:
1444                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
1445                 break;
1446
1447         case CTDB_CONTROL_PUSH_DB:
1448                 break;
1449
1450         case CTDB_CONTROL_DB_ATTACH:
1451                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
1452                 break;
1453
1454         case CTDB_CONTROL_GET_DBNAME:
1455                 ctdb_string_push(&cd->data.db_name, buf, &np);
1456                 break;
1457
1458         case CTDB_CONTROL_DUMP_MEMORY:
1459                 ctdb_string_push(&cd->data.mem_str, buf, &np);
1460                 break;
1461
1462         case CTDB_CONTROL_GET_PID:
1463                 break;
1464
1465         case CTDB_CONTROL_GET_RECMASTER:
1466                 break;
1467
1468         case CTDB_CONTROL_GET_TUNABLE:
1469                 ctdb_uint32_push(&cd->data.tun_value, buf, &np);
1470                 break;
1471
1472         case CTDB_CONTROL_LIST_TUNABLES:
1473                 ctdb_var_list_push(cd->data.tun_var_list, buf);
1474                 break;
1475
1476         case CTDB_CONTROL_GET_ALL_TUNABLES:
1477                 ctdb_tunable_list_push(cd->data.tun_list, buf);
1478                 break;
1479
1480         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1481                 ctdb_tickle_list_push(cd->data.tickles, buf);
1482                 break;
1483
1484         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1485                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
1486                 break;
1487
1488         case CTDB_CONTROL_UPTIME:
1489                 ctdb_uptime_push(cd->data.uptime, buf);
1490                 break;
1491
1492         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1493                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
1494                 break;
1495
1496         case CTDB_CONTROL_GET_CAPABILITIES:
1497                 ctdb_uint32_push(&cd->data.caps, buf, &np);
1498                 break;
1499
1500         case CTDB_CONTROL_GET_PUBLIC_IPS:
1501                 ctdb_public_ip_list_push(cd->data.pubip_list, buf);
1502                 break;
1503
1504         case CTDB_CONTROL_GET_NODEMAP:
1505                 ctdb_node_map_push(cd->data.nodemap, buf);
1506                 break;
1507
1508         case CTDB_CONTROL_GET_RECLOCK_FILE:
1509                 ctdb_string_push(&cd->data.reclock_file, buf, &np);
1510                 break;
1511
1512         case CTDB_CONTROL_GET_BAN_STATE:
1513                 ctdb_ban_state_push(cd->data.ban_state, buf);
1514                 break;
1515
1516         case CTDB_CONTROL_GET_DB_PRIORITY:
1517                 break;
1518
1519         case CTDB_CONTROL_GET_DB_SEQNUM:
1520                 ctdb_uint64_push(&cd->data.seqnum, buf, &np);
1521                 break;
1522
1523         case CTDB_CONTROL_DB_GET_HEALTH:
1524                 ctdb_string_push(&cd->data.reason, buf, &np);
1525                 break;
1526
1527         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1528                 ctdb_public_ip_info_push(cd->data.ipinfo, buf);
1529                 break;
1530
1531         case CTDB_CONTROL_GET_IFACES:
1532                 ctdb_iface_list_push(cd->data.iface_list, buf);
1533                 break;
1534
1535         case CTDB_CONTROL_GET_STAT_HISTORY:
1536                 ctdb_statistics_list_push(cd->data.stats_list, buf);
1537                 break;
1538
1539         case CTDB_CONTROL_CHECK_SRVIDS:
1540                 break;
1541
1542         case CTDB_CONTROL_GET_DB_STATISTICS:
1543                 ctdb_db_statistics_push(cd->data.dbstats, buf);
1544                 break;
1545
1546         case CTDB_CONTROL_RECEIVE_RECORDS:
1547                 ctdb_rec_buffer_push(cd->data.recbuf, buf, &np);
1548                 break;
1549
1550         case CTDB_CONTROL_GET_RUNSTATE:
1551                 ctdb_uint32_push(&cd->data.runstate, buf, &np);
1552                 break;
1553
1554         case CTDB_CONTROL_GET_NODES_FILE:
1555                 ctdb_node_map_push(cd->data.nodemap, buf);
1556                 break;
1557
1558         case CTDB_CONTROL_DB_PULL:
1559                 ctdb_uint32_push(&cd->data.num_records, buf, &np);
1560                 break;
1561
1562         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1563                 ctdb_uint32_push(&cd->data.num_records, buf, &np);
1564                 break;
1565
1566         case CTDB_CONTROL_DB_OPEN_FLAGS:
1567                 ctdb_int32_push(&cd->data.tdb_flags, buf, &np);
1568                 break;
1569
1570         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1571                 ctdb_uint32_push(&cd->data.db_id, buf, &np);
1572                 break;
1573         }
1574 }
1575
1576 static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
1577                                         uint32_t opcode, TALLOC_CTX *mem_ctx,
1578                                         struct ctdb_reply_control_data *cd)
1579 {
1580         size_t np;
1581         int ret = 0;
1582
1583         cd->opcode = opcode;
1584
1585         switch (opcode) {
1586         case CTDB_CONTROL_STATISTICS:
1587                 ret = ctdb_statistics_pull(buf, buflen, mem_ctx,
1588                                            &cd->data.stats, &np);
1589                 break;
1590
1591         case CTDB_CONTROL_GETDBPATH:
1592                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1593                                        &cd->data.db_path, &np);
1594                 break;
1595
1596         case CTDB_CONTROL_GETVNNMAP:
1597                 ret = ctdb_vnn_map_pull(buf, buflen, mem_ctx,
1598                                         &cd->data.vnnmap, &np);
1599                 break;
1600
1601         case CTDB_CONTROL_GET_DEBUG:
1602                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.loglevel, &np);
1603                 break;
1604
1605         case CTDB_CONTROL_GET_DBMAP:
1606                 ret = ctdb_dbid_map_pull(buf, buflen, mem_ctx,
1607                                          &cd->data.dbmap, &np);
1608                 break;
1609
1610         case CTDB_CONTROL_PULL_DB:
1611                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1612                                            &cd->data.recbuf, &np);
1613                 break;
1614
1615         case CTDB_CONTROL_PUSH_DB:
1616                 break;
1617
1618         case CTDB_CONTROL_DB_ATTACH:
1619                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1620                 break;
1621
1622         case CTDB_CONTROL_GET_DBNAME:
1623                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1624                                        &cd->data.db_name, &np);
1625                 break;
1626
1627         case CTDB_CONTROL_DUMP_MEMORY:
1628                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1629                                        &cd->data.mem_str, &np);
1630                 break;
1631
1632         case CTDB_CONTROL_GET_PID:
1633                 break;
1634
1635         case CTDB_CONTROL_GET_RECMASTER:
1636                 break;
1637
1638         case CTDB_CONTROL_GET_TUNABLE:
1639                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.tun_value,
1640                                        &np);
1641                 break;
1642
1643         case CTDB_CONTROL_LIST_TUNABLES:
1644                 ret = ctdb_var_list_pull(buf, buflen, mem_ctx,
1645                                          &cd->data.tun_var_list);
1646                 break;
1647
1648         case CTDB_CONTROL_GET_ALL_TUNABLES:
1649                 ret = ctdb_tunable_list_pull(buf, buflen, mem_ctx,
1650                                              &cd->data.tun_list);
1651                 break;
1652
1653         case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1654                 ret = ctdb_tickle_list_pull(buf, buflen, mem_ctx,
1655                                             &cd->data.tickles);
1656                 break;
1657
1658         case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1659                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1660                 break;
1661
1662         case CTDB_CONTROL_UPTIME:
1663                 ret = ctdb_uptime_pull(buf, buflen, mem_ctx,
1664                                        &cd->data.uptime);
1665                 break;
1666
1667         case CTDB_CONTROL_TRY_DELETE_RECORDS:
1668                 ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1669                                      &cd->data.recbuf, &np);
1670                 break;
1671
1672         case CTDB_CONTROL_GET_CAPABILITIES:
1673                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.caps, &np);
1674                 break;
1675
1676         case CTDB_CONTROL_GET_PUBLIC_IPS:
1677                 ret = ctdb_public_ip_list_pull(buf, buflen, mem_ctx,
1678                                                &cd->data.pubip_list);
1679                 break;
1680
1681         case CTDB_CONTROL_GET_NODEMAP:
1682                 ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
1683                                          &cd->data.nodemap);
1684                 break;
1685
1686         case CTDB_CONTROL_GET_RECLOCK_FILE:
1687                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1688                                        &cd->data.reclock_file, &np);
1689                 break;
1690
1691         case CTDB_CONTROL_GET_BAN_STATE:
1692                 ret = ctdb_ban_state_pull(buf, buflen, mem_ctx,
1693                                           &cd->data.ban_state);
1694                 break;
1695
1696         case CTDB_CONTROL_GET_DB_PRIORITY:
1697                 break;
1698
1699         case CTDB_CONTROL_GET_DB_SEQNUM:
1700                 ret = ctdb_uint64_pull(buf, buflen, &cd->data.seqnum, &np);
1701                 break;
1702
1703         case CTDB_CONTROL_DB_GET_HEALTH:
1704                 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1705                                        &cd->data.reason, &np);
1706                 break;
1707
1708         case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1709                 ret = ctdb_public_ip_info_pull(buf, buflen, mem_ctx,
1710                                                &cd->data.ipinfo);
1711                 break;
1712
1713         case CTDB_CONTROL_GET_IFACES:
1714                 ret = ctdb_iface_list_pull(buf, buflen, mem_ctx,
1715                                            &cd->data.iface_list);
1716                 break;
1717
1718         case CTDB_CONTROL_GET_STAT_HISTORY:
1719                 ret = ctdb_statistics_list_pull(buf, buflen, mem_ctx,
1720                                                 &cd->data.stats_list);
1721                 break;
1722
1723         case CTDB_CONTROL_CHECK_SRVIDS:
1724                 break;
1725
1726         case CTDB_CONTROL_GET_DB_STATISTICS:
1727                 ret = ctdb_db_statistics_pull(buf, buflen, mem_ctx,
1728                                               &cd->data.dbstats);
1729                 break;
1730
1731         case CTDB_CONTROL_RECEIVE_RECORDS:
1732                 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1733                                            &cd->data.recbuf, &np);
1734                 break;
1735
1736         case CTDB_CONTROL_GET_RUNSTATE:
1737                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.runstate, &np);
1738                 break;
1739
1740         case CTDB_CONTROL_GET_NODES_FILE:
1741                 ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
1742                                          &cd->data.nodemap);
1743                 break;
1744
1745         case CTDB_CONTROL_DB_PULL:
1746                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.num_records,
1747                                        &np);
1748                 break;
1749
1750         case CTDB_CONTROL_DB_PUSH_CONFIRM:
1751                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.num_records,
1752                                        &np);
1753                 break;
1754
1755         case CTDB_CONTROL_DB_OPEN_FLAGS:
1756                 ret = ctdb_int32_pull(buf, buflen, &cd->data.tdb_flags, &np);
1757                 break;
1758
1759         case CTDB_CONTROL_DB_ATTACH_REPLICATED:
1760                 ret = ctdb_uint32_pull(buf, buflen, &cd->data.db_id, &np);
1761                 break;
1762         }
1763
1764         return ret;
1765 }
1766
1767 size_t ctdb_req_control_len(struct ctdb_req_header *h,
1768                             struct ctdb_req_control *c)
1769 {
1770         return offsetof(struct ctdb_req_control_wire, data) +
1771                 ctdb_req_control_data_len(&c->rdata);
1772 }
1773
1774 int ctdb_req_control_push(struct ctdb_req_header *h,
1775                           struct ctdb_req_control *request,
1776                           uint8_t *buf, size_t *buflen)
1777 {
1778         struct ctdb_req_control_wire *wire =
1779                 (struct ctdb_req_control_wire *)buf;
1780         size_t length;
1781
1782         length = ctdb_req_control_len(h, request);
1783         if (*buflen < length) {
1784                 *buflen = length;
1785                 return EMSGSIZE;
1786         }
1787
1788         h->length = *buflen;
1789         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
1790
1791         wire->opcode = request->opcode;
1792         wire->pad = request->pad;
1793         wire->srvid = request->srvid;
1794         wire->client_id = request->client_id;
1795         wire->flags = request->flags;
1796
1797         wire->datalen = ctdb_req_control_data_len(&request->rdata);
1798         ctdb_req_control_data_push(&request->rdata, wire->data);
1799
1800         return 0;
1801 }
1802
1803 int ctdb_req_control_pull(uint8_t *buf, size_t buflen,
1804                           struct ctdb_req_header *h,
1805                           TALLOC_CTX *mem_ctx,
1806                           struct ctdb_req_control *c)
1807 {
1808         struct ctdb_req_control_wire *wire =
1809                 (struct ctdb_req_control_wire *)buf;
1810         size_t length;
1811         int ret;
1812
1813         length = offsetof(struct ctdb_req_control_wire, data);
1814         if (buflen < length) {
1815                 return EMSGSIZE;
1816         }
1817         if (wire->datalen > buflen) {
1818                 return EMSGSIZE;
1819         }
1820         if (length + wire->datalen < length) {
1821                 return EMSGSIZE;
1822         }
1823         if (buflen < length + wire->datalen) {
1824                 return EMSGSIZE;
1825         }
1826
1827         if (h != NULL) {
1828                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
1829                 if (ret != 0) {
1830                         return ret;
1831                 }
1832         }
1833
1834         c->opcode = wire->opcode;
1835         c->pad = wire->pad;
1836         c->srvid = wire->srvid;
1837         c->client_id = wire->client_id;
1838         c->flags = wire->flags;
1839
1840         ret = ctdb_req_control_data_pull(wire->data, wire->datalen,
1841                                          c->opcode, mem_ctx, &c->rdata);
1842         if (ret != 0) {
1843                 return ret;
1844         }
1845
1846         return 0;
1847 }
1848
1849 size_t ctdb_reply_control_len(struct ctdb_req_header *h,
1850                               struct ctdb_reply_control *c)
1851 {
1852         return offsetof(struct ctdb_reply_control_wire, data) +
1853                 (c->status == 0 ?
1854                         ctdb_reply_control_data_len(&c->rdata) :
1855                         ctdb_string_len(&c->errmsg));
1856 }
1857
1858 int ctdb_reply_control_push(struct ctdb_req_header *h,
1859                             struct ctdb_reply_control *reply,
1860                             uint8_t *buf, size_t *buflen)
1861 {
1862         struct ctdb_reply_control_wire *wire =
1863                 (struct ctdb_reply_control_wire *)buf;
1864         size_t length, np;
1865
1866         length = ctdb_reply_control_len(h, reply);
1867         if (*buflen < length) {
1868                 *buflen = length;
1869                 return EMSGSIZE;
1870         }
1871
1872         h->length = *buflen;
1873         ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
1874
1875         wire->status = reply->status;
1876
1877         if (reply->status == 0) {
1878                 wire->datalen = ctdb_reply_control_data_len(&reply->rdata);
1879                 wire->errorlen = 0;
1880                 ctdb_reply_control_data_push(&reply->rdata, wire->data);
1881         } else {
1882                 wire->datalen = 0;
1883                 wire->errorlen = ctdb_string_len(&reply->errmsg);
1884                 ctdb_string_push(&reply->errmsg, wire->data + wire->datalen,
1885                                  &np);
1886         }
1887
1888         return 0;
1889 }
1890
1891 int ctdb_reply_control_pull(uint8_t *buf, size_t buflen, uint32_t opcode,
1892                             struct ctdb_req_header *h,
1893                             TALLOC_CTX *mem_ctx,
1894                             struct ctdb_reply_control *c)
1895 {
1896         struct ctdb_reply_control_wire *wire =
1897                 (struct ctdb_reply_control_wire *)buf;
1898         size_t length, np;
1899         int ret;
1900
1901         length = offsetof(struct ctdb_reply_control_wire, data);
1902         if (buflen < length) {
1903                 return EMSGSIZE;
1904         }
1905         if (wire->datalen > buflen || wire->errorlen > buflen) {
1906                 return EMSGSIZE;
1907         }
1908         if (length + wire->datalen < length) {
1909                 return EMSGSIZE;
1910         }
1911         if (length + wire->datalen + wire->errorlen < length) {
1912                 return EMSGSIZE;
1913         }
1914         if (buflen < length + wire->datalen + wire->errorlen) {
1915                 return EMSGSIZE;
1916         }
1917
1918         if (h != NULL) {
1919                 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
1920                 if (ret != 0) {
1921                         return ret;
1922                 }
1923         }
1924
1925         c->status = wire->status;
1926
1927         if (c->status != -1) {
1928                 ret = ctdb_reply_control_data_pull(wire->data, wire->datalen,
1929                                                    opcode, mem_ctx,
1930                                                    &c->rdata);
1931                 if (ret != 0) {
1932                         return ret;
1933                 }
1934         }
1935
1936         ret = ctdb_string_pull(wire->data + wire->datalen, wire->errorlen,
1937                                mem_ctx, &c->errmsg, &np);
1938         if (ret != 0) {
1939                 return ret;
1940         }
1941
1942         return 0;
1943 }