ctdb/protocol/protocol_client.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 /*
  31 void ctdb_req_call_fill(struct ctdb_req_call *c,
  32                         uint32_t db_id, uint32_t flags,
  33                         uint32_t call_id, TDB_DATA key)
  34 {
  35         request->flags = flags;
  36         c->db_id = db_id;
  37         c->call_id = call_id;
  38         c->key = key;
  39         c->calldata = tdb_null;
  40 }
  41 */
  42
  43 static int ctdb_reply_control_generic(struct ctdb_reply_control *reply,
  44                                       uint32_t opcode)
  45 {
  46         if (reply->rdata.opcode != opcode) {
  47                 return EPROTO;
  48         }
  49
  50         return reply->status;
  51 }
  52
  53 /* CTDB_CONTROL_PROCESS_EXISTS */
  54
  55 void ctdb_req_control_process_exists(struct ctdb_req_control *request,
  56                                      pid_t pid)
  57 {
  58         request->opcode = CTDB_CONTROL_PROCESS_EXISTS;
  59         request->pad = 0;
  60         request->srvid = 0;
  61         request->client_id = 0;
  62         request->flags = 0;
  63
  64         request->rdata.opcode = CTDB_CONTROL_PROCESS_EXISTS;
  65         request->rdata.data.pid = pid;
  66
  67 }
  68
  69 int ctdb_reply_control_process_exists(struct ctdb_reply_control *reply,
  70                                       int *status)
  71 {
  72         if (reply->rdata.opcode != CTDB_CONTROL_PROCESS_EXISTS) {
  73                 return EPROTO;
  74         }
  75
  76         *status = reply->status;
  77         reply->status = 0;
  78
  79         return reply->status;
  80 }
  81
  82 /* CTDB_CONTROL_STATISTICS */
  83
  84 void ctdb_req_control_statistics(struct ctdb_req_control *request)
  85 {
  86         request->opcode = CTDB_CONTROL_STATISTICS;
  87         request->pad = 0;
  88         request->srvid = 0;
  89         request->client_id = 0;
  90         request->flags = 0;
  91
  92         request->rdata.opcode = CTDB_CONTROL_STATISTICS;
  93 }
  94
  95 int ctdb_reply_control_statistics(struct ctdb_reply_control *reply,
  96                                   TALLOC_CTX *mem_ctx,
  97                                   struct ctdb_statistics **stats)
  98 {
  99         if (reply->rdata.opcode != CTDB_CONTROL_STATISTICS) {
 100                 return EPROTO;
 101         }
 102
 103         if (reply->status == 0) {
 104                 *stats = talloc_steal(mem_ctx, reply->rdata.data.stats);
 105         }
 106         return reply->status;
 107 }
 108
 109 /* CTDB_CONTROL_PING */
 110
 111 void ctdb_req_control_ping(struct ctdb_req_control *request)
 112 {
 113         request->opcode = CTDB_CONTROL_PING;
 114         request->pad = 0;
 115         request->srvid = 0;
 116         request->client_id = 0;
 117         request->flags = 0;
 118
 119         request->rdata.opcode = CTDB_CONTROL_PING;
 120 }
 121
 122 int ctdb_reply_control_ping(struct ctdb_reply_control *reply,
 123                             int *num_clients)
 124 {
 125         if (reply->rdata.opcode != CTDB_CONTROL_PING) {
 126                 return EPROTO;
 127         }
 128
 129         if (reply->status >= 0) {
 130                 *num_clients = reply->status;
 131                 reply->status = 0;
 132         }
 133         return reply->status;
 134 }
 135
 136 /* CTDB_CONTROL_GETDBPATH */
 137
 138 void ctdb_req_control_getdbpath(struct ctdb_req_control *request,
 139                                 uint32_t db_id)
 140 {
 141         request->opcode = CTDB_CONTROL_GETDBPATH;
 142         request->pad = 0;
 143         request->srvid = 0;
 144         request->client_id = 0;
 145         request->flags = 0;
 146
 147         request->rdata.opcode = CTDB_CONTROL_GETDBPATH;
 148         request->rdata.data.db_id = db_id;
 149 }
 150
 151 int ctdb_reply_control_getdbpath(struct ctdb_reply_control *reply,
 152                                  TALLOC_CTX *mem_ctx, const char **db_path)
 153 {
 154         if (reply->rdata.opcode != CTDB_CONTROL_GETDBPATH) {
 155                 return EPROTO;
 156         }
 157
 158         if (reply->status == 0) {
 159                 *db_path = talloc_steal(mem_ctx, reply->rdata.data.db_path);
 160         }
 161         return reply->status;
 162 }
 163
 164 /* CTDB_CONTROL_GETVNNMAP */
 165
 166 void ctdb_req_control_getvnnmap(struct ctdb_req_control *request)
 167 {
 168         request->opcode = CTDB_CONTROL_GETVNNMAP;
 169         request->pad = 0;
 170         request->srvid = 0;
 171         request->client_id = 0;
 172         request->flags = 0;
 173
 174         request->rdata.opcode = CTDB_CONTROL_GETVNNMAP;
 175 }
 176
 177 int ctdb_reply_control_getvnnmap(struct ctdb_reply_control *reply,
 178                                  TALLOC_CTX *mem_ctx,
 179                                  struct ctdb_vnn_map **vnnmap)
 180 {
 181         if (reply->rdata.opcode != CTDB_CONTROL_GETVNNMAP) {
 182                 return EPROTO;
 183         }
 184
 185         if (reply->status == 0) {
 186                 *vnnmap = talloc_steal(mem_ctx, reply->rdata.data.vnnmap);
 187         }
 188         return reply->status;
 189 }
 190
 191 /* CTDB_CONTROL_SETVNNMAP */
 192
 193 void ctdb_req_control_setvnnmap(struct ctdb_req_control *request,
 194                                 struct ctdb_vnn_map *vnnmap)
 195 {
 196         request->opcode = CTDB_CONTROL_SETVNNMAP;
 197         request->pad = 0;
 198         request->srvid = 0;
 199         request->client_id = 0;
 200         request->flags = 0;
 201
 202         request->rdata.opcode = CTDB_CONTROL_SETVNNMAP;
 203         request->rdata.data.vnnmap = vnnmap;
 204 }
 205
 206 int ctdb_reply_control_setvnnmap(struct ctdb_reply_control *reply)
 207 {
 208         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SETVNNMAP);
 209 }
 210
 211 /* CTDB_CONTROL_GET_DEBUG */
 212
 213 void ctdb_req_control_get_debug(struct ctdb_req_control *request)
 214 {
 215         request->opcode = CTDB_CONTROL_GET_DEBUG;
 216         request->pad = 0;
 217         request->srvid = 0;
 218         request->client_id = 0;
 219         request->flags = 0;
 220
 221         request->rdata.opcode = CTDB_CONTROL_GET_DEBUG;
 222 }
 223
 224 int ctdb_reply_control_get_debug(struct ctdb_reply_control *reply,
 225                                  int *loglevel)
 226 {
 227         if (reply->rdata.opcode != CTDB_CONTROL_GET_DEBUG) {
 228                 return EPROTO;
 229         }
 230
 231         if (reply->status == 0) {
 232                 *loglevel = (int)reply->rdata.data.loglevel;
 233         }
 234         return reply->status;
 235 }
 236
 237 /* CTDB_CONTROL_SET_DEBUG */
 238
 239 void ctdb_req_control_set_debug(struct ctdb_req_control *request,
 240                                 int loglevel)
 241 {
 242         request->opcode = CTDB_CONTROL_SET_DEBUG;
 243         request->pad = 0;
 244         request->srvid = 0;
 245         request->client_id = 0;
 246         request->flags = 0;
 247
 248         request->rdata.opcode = CTDB_CONTROL_SET_DEBUG;
 249         request->rdata.data.loglevel = (uint32_t)loglevel;
 250 }
 251
 252 int ctdb_reply_control_set_debug(struct ctdb_reply_control *reply)
 253 {
 254         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DEBUG);
 255 }
 256
 257 /* CTDB_CONTROL_GET_DBMAP */
 258
 259 void ctdb_req_control_get_dbmap(struct ctdb_req_control *request)
 260 {
 261         request->opcode = CTDB_CONTROL_GET_DBMAP;
 262         request->pad = 0;
 263         request->srvid = 0;
 264         request->client_id = 0;
 265         request->flags = 0;
 266
 267         request->rdata.opcode = CTDB_CONTROL_GET_DBMAP;
 268 }
 269
 270 int ctdb_reply_control_get_dbmap(struct ctdb_reply_control *reply,
 271                                  TALLOC_CTX *mem_ctx,
 272                                  struct ctdb_dbid_map **dbmap)
 273 {
 274         if (reply->rdata.opcode != CTDB_CONTROL_GET_DBMAP) {
 275                 return EPROTO;
 276         }
 277
 278         if (reply->status == 0) {
 279                 *dbmap = talloc_steal(mem_ctx, reply->rdata.data.dbmap);
 280         }
 281         return reply->status;
 282 }
 283
 284 /* CTDB_CONTROL_PULL_DB */
 285
 286 void ctdb_req_control_pull_db(struct ctdb_req_control *request,
 287                               struct ctdb_pulldb *pulldb)
 288 {
 289         request->opcode = CTDB_CONTROL_PULL_DB;
 290         request->pad = 0;
 291         request->srvid = 0;
 292         request->client_id = 0;
 293         request->flags = 0;
 294
 295         request->rdata.opcode = CTDB_CONTROL_PULL_DB;
 296         request->rdata.data.pulldb = pulldb;
 297 }
 298
 299 int ctdb_reply_control_pull_db(struct ctdb_reply_control *reply,
 300                                TALLOC_CTX *mem_ctx,
 301                                struct ctdb_rec_buffer **recbuf)
 302 {
 303         if (reply->rdata.opcode != CTDB_CONTROL_PULL_DB) {
 304                 return EPROTO;
 305         }
 306
 307         if (reply->status == 0) {
 308                 *recbuf = talloc_steal(mem_ctx, reply->rdata.data.recbuf);
 309         }
 310         return reply->status;
 311 }
 312
 313 /* CTDB_CONTROL_PUSH_DB */
 314
 315 void ctdb_req_control_push_db(struct ctdb_req_control *request,
 316                               struct ctdb_rec_buffer *recbuf)
 317 {
 318         request->opcode = CTDB_CONTROL_PUSH_DB;
 319         request->pad = 0;
 320         request->srvid = 0;
 321         request->client_id = 0;
 322         request->flags = 0;
 323
 324         request->rdata.opcode = CTDB_CONTROL_PUSH_DB;
 325         request->rdata.data.recbuf = recbuf;
 326 }
 327
 328 int ctdb_reply_control_push_db(struct ctdb_reply_control *reply)
 329 {
 330         return ctdb_reply_control_generic(reply, CTDB_CONTROL_PUSH_DB);
 331 }
 332
 333 /* CTDB_CONTROL_GET_RECMODE */
 334
 335 void ctdb_req_control_get_recmode(struct ctdb_req_control *request)
 336 {
 337         request->opcode = CTDB_CONTROL_GET_RECMODE;
 338         request->pad = 0;
 339         request->srvid = 0;
 340         request->client_id = 0;
 341         request->flags = 0;
 342
 343         request->rdata.opcode = CTDB_CONTROL_GET_RECMODE;
 344 }
 345
 346 int ctdb_reply_control_get_recmode(struct ctdb_reply_control *reply,
 347                                    int *recmode)
 348 {
 349         if (reply->rdata.opcode != CTDB_CONTROL_GET_RECMODE) {
 350                 return EPROTO;
 351         }
 352
 353         if (reply->status >= 0) {
 354                 *recmode = reply->status;
 355                 reply->status = 0;
 356         }
 357         return reply->status;
 358 }
 359
 360 /* CTDB_CONTROL_SET_RECMODE */
 361
 362 void ctdb_req_control_set_recmode(struct ctdb_req_control *request,
 363                                   int recmode)
 364 {
 365         request->opcode = CTDB_CONTROL_SET_RECMODE;
 366         request->pad = 0;
 367         request->srvid = 0;
 368         request->client_id = 0;
 369         request->flags = 0;
 370
 371         request->rdata.opcode = CTDB_CONTROL_SET_RECMODE;
 372         request->rdata.data.recmode = recmode;
 373 }
 374
 375 int ctdb_reply_control_set_recmode(struct ctdb_reply_control *reply)
 376 {
 377         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_RECMODE);
 378 }
 379
 380 /* CTDB_CONTROL_STATISTICS_RESET */
 381
 382 void ctdb_req_control_statistics_reset(struct ctdb_req_control *request)
 383 {
 384         request->opcode = CTDB_CONTROL_STATISTICS_RESET;
 385         request->pad = 0;
 386         request->srvid = 0;
 387         request->client_id = 0;
 388         request->flags = 0;
 389
 390         request->rdata.opcode = CTDB_CONTROL_STATISTICS_RESET;
 391 }
 392
 393 int ctdb_reply_control_statistics_reset(struct ctdb_reply_control *reply)
 394 {
 395         return ctdb_reply_control_generic(reply,
 396                                           CTDB_CONTROL_STATISTICS_RESET);
 397 }
 398
 399 /* CTDB_CONTROL_DB_ATTACH */
 400
 401 void ctdb_req_control_db_attach(struct ctdb_req_control *request,
 402                                 const char *db_name)
 403 {
 404         request->opcode = CTDB_CONTROL_DB_ATTACH;
 405         request->pad = 0;
 406         request->srvid = 0;
 407         request->client_id = 0;
 408         request->flags = 0;
 409
 410         request->rdata.opcode = CTDB_CONTROL_DB_ATTACH;
 411         request->rdata.data.db_name = db_name;
 412 }
 413
 414 int ctdb_reply_control_db_attach(struct ctdb_reply_control *reply,
 415                                  uint32_t *db_id)
 416 {
 417         if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH) {
 418                 return EPROTO;
 419         }
 420
 421         if (reply->status == 0) {
 422                 *db_id = reply->rdata.data.db_id;
 423         }
 424         return reply->status;
 425 }
 426
 427 /* CTDB_CONTROL_SET_CALL */
 428
 429 /* CTDB_CONTROL_TRAVERSE_START */
 430
 431 void ctdb_req_control_traverse_start(struct ctdb_req_control *request,
 432                                      struct ctdb_traverse_start *traverse)
 433 {
 434         request->opcode = CTDB_CONTROL_TRAVERSE_START;
 435         request->pad = 0;
 436         request->srvid = 0;
 437         request->client_id = 0;
 438         request->flags = 0;
 439
 440         request->rdata.opcode = CTDB_CONTROL_TRAVERSE_START;
 441         request->rdata.data.traverse_start = traverse;
 442 }
 443
 444 int ctdb_reply_control_traverse_start(struct ctdb_reply_control *reply)
 445 {
 446         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRAVERSE_START);
 447 }
 448
 449 /* CTDB_CONTROL_TRAVERSE_ALL */
 450 /* CTDB_CONTROL_TRAVERSE_DATA */
 451
 452 /* CTDB_CONTROL_REGISTER_SRVID */
 453
 454 void ctdb_req_control_register_srvid(struct ctdb_req_control *request,
 455                                      uint64_t srvid)
 456 {
 457         request->opcode = CTDB_CONTROL_REGISTER_SRVID;
 458         request->pad = 0;
 459         request->srvid = srvid;
 460         request->client_id = 0;
 461         request->flags = 0;
 462
 463         request->rdata.opcode = CTDB_CONTROL_REGISTER_SRVID;
 464 }
 465
 466 int ctdb_reply_control_register_srvid(struct ctdb_reply_control *reply)
 467 {
 468         return ctdb_reply_control_generic(reply, CTDB_CONTROL_REGISTER_SRVID);
 469 }
 470
 471 /* CTDB_CONTROL_DEREGISTER_SRVID */
 472
 473 void ctdb_req_control_deregister_srvid(struct ctdb_req_control *request,
 474                                        uint64_t srvid)
 475 {
 476         request->opcode = CTDB_CONTROL_DEREGISTER_SRVID;
 477         request->pad = 0;
 478         request->srvid = srvid;
 479         request->client_id = 0;
 480         request->flags = 0;
 481
 482         request->rdata.opcode = CTDB_CONTROL_DEREGISTER_SRVID;
 483 }
 484
 485 int ctdb_reply_control_deregister_srvid(struct ctdb_reply_control *reply)
 486 {
 487         return ctdb_reply_control_generic(reply,
 488                                           CTDB_CONTROL_DEREGISTER_SRVID);
 489 }
 490
 491 /* CTDB_CONTROL_GET_DBNAME */
 492
 493 void ctdb_req_control_get_dbname(struct ctdb_req_control *request,
 494                                  uint32_t db_id)
 495 {
 496         request->opcode = CTDB_CONTROL_GET_DBNAME;
 497         request->pad = 0;
 498         request->srvid = 0;
 499         request->client_id = 0;
 500         request->flags = 0;
 501
 502         request->rdata.opcode = CTDB_CONTROL_GET_DBNAME;
 503         request->rdata.data.db_id = db_id;
 504 }
 505
 506 int ctdb_reply_control_get_dbname(struct ctdb_reply_control *reply,
 507                                   TALLOC_CTX *mem_ctx, const char **db_name)
 508 {
 509         if (reply->rdata.opcode != CTDB_CONTROL_GET_DBNAME) {
 510                 return EPROTO;
 511         }
 512
 513         if (reply->status == 0) {
 514                 *db_name = talloc_steal(mem_ctx, reply->rdata.data.db_name);
 515         }
 516         return reply->status;
 517 }
 518
 519 /* CTDB_CONTROL_ENABLE_SEQNUM */
 520
 521 void ctdb_req_control_enable_seqnum(struct ctdb_req_control *request,
 522                                     uint32_t db_id)
 523 {
 524         request->opcode = CTDB_CONTROL_ENABLE_SEQNUM;
 525         request->pad = 0;
 526         request->srvid = 0;
 527         request->client_id = 0;
 528         request->flags = 0;
 529
 530         request->rdata.opcode = CTDB_CONTROL_ENABLE_SEQNUM;
 531         request->rdata.data.db_id = db_id;
 532 }
 533
 534 int ctdb_reply_control_enable_seqnum(struct ctdb_reply_control *reply)
 535 {
 536         return ctdb_reply_control_generic(reply, CTDB_CONTROL_ENABLE_SEQNUM);
 537 }
 538
 539 /* CTDB_CONTROL_UPDATE_SEQNUM */
 540
 541 void ctdb_req_control_update_seqnum(struct ctdb_req_control *request,
 542                                     uint32_t db_id)
 543 {
 544         request->opcode = CTDB_CONTROL_UPDATE_SEQNUM;
 545         request->pad = 0;
 546         request->srvid = 0;
 547         request->client_id = 0;
 548         request->flags = 0;
 549
 550         request->rdata.opcode = CTDB_CONTROL_UPDATE_SEQNUM;
 551         request->rdata.data.db_id = db_id;
 552 }
 553
 554 int ctdb_reply_control_update_seqnum(struct ctdb_reply_control *reply)
 555 {
 556         return ctdb_reply_control_generic(reply, CTDB_CONTROL_UPDATE_SEQNUM);
 557 }
 558
 559 /* CTDB_CONTROL_DUMP_MEMORY */
 560
 561 void ctdb_req_control_dump_memory(struct ctdb_req_control *request)
 562 {
 563         request->opcode = CTDB_CONTROL_DUMP_MEMORY;
 564         request->pad = 0;
 565         request->srvid = 0;
 566         request->client_id = 0;
 567         request->flags = 0;
 568
 569         request->rdata.opcode = CTDB_CONTROL_DUMP_MEMORY;
 570 }
 571
 572 int ctdb_reply_control_dump_memory(struct ctdb_reply_control *reply,
 573                                    TALLOC_CTX *mem_ctx, const char **mem_str)
 574 {
 575         if (reply->rdata.opcode != CTDB_CONTROL_DUMP_MEMORY) {
 576                 return EPROTO;
 577         }
 578
 579         if (reply->status == 0) {
 580                 *mem_str = talloc_steal(mem_ctx, reply->rdata.data.mem_str);
 581         }
 582         return reply->status;
 583 }
 584
 585 /* CTDB_CONTROL_GET_PID */
 586
 587 void ctdb_req_control_get_pid(struct ctdb_req_control *request)
 588 {
 589         request->opcode = CTDB_CONTROL_GET_PID;
 590         request->pad = 0;
 591         request->srvid = 0;
 592         request->client_id = 0;
 593         request->flags = 0;
 594
 595         request->rdata.opcode = CTDB_CONTROL_GET_PID;
 596 }
 597
 598 int ctdb_reply_control_get_pid(struct ctdb_reply_control *reply,
 599                                pid_t *pid)
 600 {
 601         if (reply->rdata.opcode != CTDB_CONTROL_GET_PID) {
 602                 return EPROTO;
 603         }
 604
 605         *pid = reply->status;
 606         reply->status = 0;
 607
 608         return reply->status;
 609 }
 610
 611 /* CTDB_CONTROL_GET_RECMASTER */
 612
 613 void ctdb_req_control_get_recmaster(struct ctdb_req_control *request)
 614 {
 615         request->opcode = CTDB_CONTROL_GET_RECMASTER;
 616         request->pad = 0;
 617         request->srvid = 0;
 618         request->client_id = 0;
 619         request->flags = 0;
 620
 621         request->rdata.opcode = CTDB_CONTROL_GET_RECMASTER;
 622 }
 623
 624 int ctdb_reply_control_get_recmaster(struct ctdb_reply_control *reply,
 625                                      uint32_t *recmaster)
 626 {
 627         if (reply->rdata.opcode != CTDB_CONTROL_GET_RECMASTER) {
 628                 return EPROTO;
 629         }
 630
 631         *recmaster = reply->status;
 632         reply->status = 0;
 633
 634         return reply->status;
 635 }
 636
 637 /* CTDB_CONTROL_SET_RECMASTER */
 638
 639 void ctdb_req_control_set_recmaster(struct ctdb_req_control *request,
 640                                     int recmaster)
 641 {
 642         request->opcode = CTDB_CONTROL_SET_RECMASTER;
 643         request->pad = 0;
 644         request->srvid = 0;
 645         request->client_id = 0;
 646         request->flags = 0;
 647
 648         request->rdata.opcode = CTDB_CONTROL_SET_RECMASTER;
 649         request->rdata.data.recmaster = recmaster;
 650 }
 651
 652 int ctdb_reply_control_set_recmaster(struct ctdb_reply_control *reply)
 653 {
 654         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_RECMASTER);
 655 }
 656
 657 /* CTDB_CONTROL_FREEZE */
 658
 659 void ctdb_req_control_freeze(struct ctdb_req_control *request,
 660                              uint32_t priority)
 661 {
 662         request->opcode = CTDB_CONTROL_FREEZE;
 663         request->pad = 0;
 664         request->srvid = priority;
 665         request->client_id = 0;
 666         request->flags = 0;
 667
 668         request->rdata.opcode = CTDB_CONTROL_FREEZE;
 669 }
 670
 671 int ctdb_reply_control_freeze(struct ctdb_reply_control *reply)
 672 {
 673         return ctdb_reply_control_generic(reply, CTDB_CONTROL_FREEZE);
 674 }
 675
 676 /* CTDB_CONTROL_GET_PNN */
 677
 678 void ctdb_req_control_get_pnn(struct ctdb_req_control *request)
 679 {
 680         request->opcode = CTDB_CONTROL_GET_PNN;
 681         request->pad = 0;
 682         request->srvid = 0;
 683         request->client_id = 0;
 684         request->flags = 0;
 685
 686         request->rdata.opcode = CTDB_CONTROL_GET_PNN;
 687 }
 688
 689 int ctdb_reply_control_get_pnn(struct ctdb_reply_control *reply,
 690                                uint32_t *pnn)
 691 {
 692         if (reply->rdata.opcode != CTDB_CONTROL_GET_PNN) {
 693                 return EPROTO;
 694         }
 695
 696         if (reply->status >= 0) {
 697                 *pnn = reply->status;
 698                 reply->status = 0;
 699         }
 700         return reply->status;
 701 }
 702
 703 /* CTDB_CONTROL_SHUTDOWN */
 704
 705 void ctdb_req_control_shutdown(struct ctdb_req_control *request)
 706 {
 707         request->opcode = CTDB_CONTROL_SHUTDOWN;
 708         request->pad = 0;
 709         request->srvid = 0;
 710         request->client_id = 0;
 711         request->flags = CTDB_CTRL_FLAG_NOREPLY;
 712
 713         request->rdata.opcode = CTDB_CONTROL_SHUTDOWN;
 714 }
 715
 716 int ctdb_reply_control_shutdown(struct ctdb_reply_control *reply)
 717 {
 718         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SHUTDOWN);
 719 }
 720
 721 /* CTDB_CONTROL_GET_MONMODE */
 722
 723 /* CTDB_CONTROL_TCP_CLIENT */
 724
 725 void ctdb_req_control_tcp_client(struct ctdb_req_control *request,
 726                                  struct ctdb_connection *conn)
 727 {
 728         request->opcode = CTDB_CONTROL_TCP_CLIENT;
 729         request->pad = 0;
 730         request->srvid = 0;
 731         request->client_id = 0;
 732         request->flags = 0;
 733
 734         request->rdata.opcode = CTDB_CONTROL_TCP_CLIENT;
 735         request->rdata.data.conn = conn;
 736 }
 737
 738 int ctdb_reply_control_tcp_client(struct ctdb_reply_control *reply)
 739 {
 740         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_CLIENT);
 741 }
 742
 743 /* CTDB_CONTROL_TCP_ADD */
 744
 745 void ctdb_req_control_tcp_add(struct ctdb_req_control *request,
 746                               struct ctdb_connection *conn)
 747 {
 748         request->opcode = CTDB_CONTROL_TCP_ADD;
 749         request->pad = 0;
 750         request->srvid = 0;
 751         request->client_id = 0;
 752         request->flags = 0;
 753
 754         request->rdata.opcode = CTDB_CONTROL_TCP_ADD;
 755         request->rdata.data.conn = conn;
 756 }
 757
 758 int ctdb_reply_control_tcp_add(struct ctdb_reply_control *reply)
 759 {
 760         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_ADD);
 761 }
 762
 763 /* CTDB_CONTROL_TCP_REMOVE */
 764
 765 void ctdb_req_control_tcp_remove(struct ctdb_req_control *request,
 766                                  struct ctdb_connection *conn)
 767 {
 768         request->opcode = CTDB_CONTROL_TCP_REMOVE;
 769         request->pad = 0;
 770         request->srvid = 0;
 771         request->client_id = 0;
 772         request->flags = 0;
 773
 774         request->rdata.opcode = CTDB_CONTROL_TCP_REMOVE;
 775         request->rdata.data.conn = conn;
 776 }
 777
 778 int ctdb_reply_control_tcp_remove(struct ctdb_reply_control *reply)
 779 {
 780         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_REMOVE);
 781 }
 782
 783 /* CTDB_CONTROL_STARTUP */
 784
 785 void ctdb_req_control_startup(struct ctdb_req_control *request)
 786 {
 787         request->opcode = CTDB_CONTROL_STARTUP;
 788         request->pad = 0;
 789         request->srvid = 0;
 790         request->client_id = 0;
 791         request->flags = 0;
 792
 793         request->rdata.opcode = CTDB_CONTROL_STARTUP;
 794 }
 795
 796 int ctdb_reply_control_startup(struct ctdb_reply_control *reply)
 797 {
 798         return ctdb_reply_control_generic(reply, CTDB_CONTROL_STARTUP);
 799 }
 800
 801 /* CTDB_CONTROL_SET_TUNABLE */
 802
 803 void ctdb_req_control_set_tunable(struct ctdb_req_control *request,
 804                                   struct ctdb_tunable *tunable)
 805 {
 806         request->opcode = CTDB_CONTROL_SET_TUNABLE;
 807         request->pad = 0;
 808         request->srvid = 0;
 809         request->client_id = 0;
 810         request->flags = 0;
 811
 812         request->rdata.opcode = CTDB_CONTROL_SET_TUNABLE;
 813         request->rdata.data.tunable = tunable;
 814 }
 815
 816 int ctdb_reply_control_set_tunable(struct ctdb_reply_control *reply)
 817 {
 818         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_TUNABLE);
 819 }
 820
 821 /* CTDB_CONTROL_GET_TUNABLE */
 822
 823 void ctdb_req_control_get_tunable(struct ctdb_req_control *request,
 824                                   const char *name)
 825 {
 826         request->opcode = CTDB_CONTROL_GET_TUNABLE;
 827         request->pad = 0;
 828         request->srvid = 0;
 829         request->client_id = 0;
 830         request->flags = 0;
 831
 832         request->rdata.opcode = CTDB_CONTROL_GET_TUNABLE;
 833         request->rdata.data.tun_var = discard_const(name);
 834 }
 835
 836 int ctdb_reply_control_get_tunable(struct ctdb_reply_control *reply,
 837                                    uint32_t *value)
 838 {
 839         if (reply->rdata.opcode != CTDB_CONTROL_GET_TUNABLE) {
 840                 return EPROTO;
 841         }
 842
 843         if (reply->status == 0) {
 844                 *value = reply->rdata.data.tun_value;
 845         }
 846         return reply->status;
 847 }
 848
 849 /* CTDB_CONTROL_LIST_TUNABLES */
 850
 851 void ctdb_req_control_list_tunables(struct ctdb_req_control *request)
 852 {
 853         request->opcode = CTDB_CONTROL_LIST_TUNABLES;
 854         request->pad = 0;
 855         request->srvid = 0;
 856         request->client_id = 0;
 857         request->flags = 0;
 858
 859         request->rdata.opcode = CTDB_CONTROL_LIST_TUNABLES;
 860 }
 861
 862 int ctdb_reply_control_list_tunables(struct ctdb_reply_control *reply,
 863                                      TALLOC_CTX *mem_ctx,
 864                                      struct ctdb_var_list **tun_var_list)
 865 {
 866         if (reply->rdata.opcode != CTDB_CONTROL_LIST_TUNABLES) {
 867                 return EPROTO;
 868         }
 869
 870         if (reply->status == 0) {
 871                 *tun_var_list = talloc_steal(mem_ctx,
 872                                              reply->rdata.data.tun_var_list);
 873         }
 874         return reply->status;
 875 }
 876
 877 /* CTDB_CONTROL_MODIFY_FLAGS */
 878
 879 void ctdb_req_control_modify_flags(struct ctdb_req_control *request,
 880                                    struct ctdb_node_flag_change *flag_change)
 881 {
 882         request->opcode = CTDB_CONTROL_MODIFY_FLAGS;
 883         request->pad = 0;
 884         request->srvid = 0;
 885         request->client_id = 0;
 886         request->flags = 0;
 887
 888         request->rdata.opcode = CTDB_CONTROL_MODIFY_FLAGS;
 889         request->rdata.data.flag_change = flag_change;
 890 }
 891
 892 int ctdb_reply_control_modify_flags(struct ctdb_reply_control *reply)
 893 {
 894         return ctdb_reply_control_generic(reply, CTDB_CONTROL_MODIFY_FLAGS);
 895 }
 896
 897 /* CTDB_CONTROL_GET_ALL_TUNABLES */
 898
 899 void ctdb_req_control_get_all_tunables(struct ctdb_req_control *request)
 900 {
 901         request->opcode = CTDB_CONTROL_GET_ALL_TUNABLES;
 902         request->pad = 0;
 903         request->srvid = 0;
 904         request->client_id = 0;
 905         request->flags = 0;
 906
 907         request->rdata.opcode = CTDB_CONTROL_GET_ALL_TUNABLES;
 908 }
 909
 910 int ctdb_reply_control_get_all_tunables(struct ctdb_reply_control *reply,
 911                                         TALLOC_CTX *mem_ctx,
 912                                         struct ctdb_tunable_list **tun_list)
 913 {
 914         if (reply->rdata.opcode != CTDB_CONTROL_GET_ALL_TUNABLES) {
 915                 return EPROTO;
 916         }
 917
 918         if (reply->status == 0) {
 919                 *tun_list = talloc_steal(mem_ctx, reply->rdata.data.tun_list);
 920         }
 921         return reply->status;
 922 }
 923
 924 /* CTDB_CONTROL_GET_TCP_TICKLE_LIST */
 925
 926 void ctdb_req_control_get_tcp_tickle_list(struct ctdb_req_control *request,
 927                                           ctdb_sock_addr *addr)
 928 {
 929         request->opcode = CTDB_CONTROL_GET_TCP_TICKLE_LIST;
 930         request->pad = 0;
 931         request->srvid = 0;
 932         request->client_id = 0;
 933         request->flags = 0;
 934
 935         request->rdata.opcode = CTDB_CONTROL_GET_TCP_TICKLE_LIST;
 936         request->rdata.data.addr = addr;
 937 }
 938
 939 int ctdb_reply_control_get_tcp_tickle_list(struct ctdb_reply_control *reply,
 940                                            TALLOC_CTX *mem_ctx,
 941                                            struct ctdb_tickle_list **tickles)
 942 {
 943         if (reply->rdata.opcode != CTDB_CONTROL_GET_TCP_TICKLE_LIST) {
 944                 return EPROTO;
 945         }
 946
 947         if (reply->status == 0) {
 948                 *tickles = talloc_steal(mem_ctx, reply->rdata.data.tickles);
 949         }
 950         return reply->status;
 951 }
 952
 953 /* CTDB_CONTROL_SET_TCP_TICKLE_LIST */
 954
 955 void ctdb_req_control_set_tcp_tickle_list(struct ctdb_req_control *request,
 956                                           struct ctdb_tickle_list *tickles)
 957 {
 958         request->opcode = CTDB_CONTROL_SET_TCP_TICKLE_LIST;
 959         request->pad = 0;
 960         request->srvid = 0;
 961         request->client_id = 0;
 962         request->flags = 0;
 963
 964         request->rdata.opcode = CTDB_CONTROL_SET_TCP_TICKLE_LIST;
 965         request->rdata.data.tickles = tickles;
 966 }
 967
 968 int ctdb_reply_control_set_tcp_tickle_list(struct ctdb_reply_control *reply)
 969 {
 970         return ctdb_reply_control_generic(reply,
 971                                           CTDB_CONTROL_SET_TCP_TICKLE_LIST);
 972 }
 973
 974 /* CTDB_CONTROL_DB_ATTACH_PERSISTENT */
 975
 976 void ctdb_req_control_db_attach_persistent(struct ctdb_req_control *request,
 977                                            const char *db_name)
 978 {
 979         request->opcode = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
 980         request->pad = 0;
 981         request->srvid = 0;
 982         request->client_id = 0;
 983         request->flags = 0;
 984
 985         request->rdata.opcode = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
 986         request->rdata.data.db_name = db_name;
 987 }
 988
 989 int ctdb_reply_control_db_attach_persistent(struct ctdb_reply_control *reply,
 990                                             uint32_t *db_id)
 991 {
 992         if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH_PERSISTENT) {
 993                 return EPROTO;
 994         }
 995
 996         if (reply->status == 0) {
 997                 *db_id = reply->rdata.data.db_id;
 998         }
 999         return reply->status;
1000 }
1001
1002 /* CTDB_CONTROL_UPDATE_RECORD */
1003
1004 void ctdb_req_control_update_record(struct ctdb_req_control *request,
1005                                     struct ctdb_rec_buffer *recbuf)
1006 {
1007         request->opcode = CTDB_CONTROL_UPDATE_RECORD;
1008         request->pad = 0;
1009         request->srvid = 0;
1010         request->client_id = 0;
1011         request->flags = 0;
1012
1013         request->rdata.opcode = CTDB_CONTROL_UPDATE_RECORD;
1014         request->rdata.data.recbuf = recbuf;
1015 }
1016
1017 int ctdb_reply_control_update_record(struct ctdb_reply_control *reply)
1018 {
1019         return ctdb_reply_control_generic(reply, CTDB_CONTROL_UPDATE_RECORD);
1020 }
1021
1022 /* CTDB_CONTROL_SEND_GRATUITOUS_ARP */
1023
1024 void ctdb_req_control_send_gratuitous_arp(struct ctdb_req_control *request,
1025                                           struct ctdb_addr_info *addr_info)
1026 {
1027         request->opcode = CTDB_CONTROL_SEND_GRATUITOUS_ARP;
1028         request->pad = 0;
1029         request->srvid = 0;
1030         request->client_id = 0;
1031         request->flags = 0;
1032
1033         request->rdata.opcode = CTDB_CONTROL_SEND_GRATUITOUS_ARP;
1034         request->rdata.data.addr_info = addr_info;
1035 }
1036
1037 int ctdb_reply_control_send_gratuitous_arp(struct ctdb_reply_control *reply)
1038 {
1039         return ctdb_reply_control_generic(reply,
1040                                           CTDB_CONTROL_SEND_GRATUITOUS_ARP);
1041 }
1042
1043 /* CTDB_CONTROL_WIPE_DATABASE */
1044
1045 void ctdb_req_control_wipe_database(struct ctdb_req_control *request,
1046                                     struct ctdb_transdb *transdb)
1047 {
1048         request->opcode = CTDB_CONTROL_WIPE_DATABASE;
1049         request->pad = 0;
1050         request->srvid = 0;
1051         request->client_id = 0;
1052         request->flags = 0;
1053
1054         request->rdata.opcode = CTDB_CONTROL_WIPE_DATABASE;
1055         request->rdata.data.transdb = transdb;
1056 }
1057
1058 int ctdb_reply_control_wipe_database(struct ctdb_reply_control *reply)
1059 {
1060         return ctdb_reply_control_generic(reply, CTDB_CONTROL_WIPE_DATABASE);
1061 }
1062
1063 /* CTDB_CONTROL_UPTIME */
1064
1065 void ctdb_req_control_uptime(struct ctdb_req_control *request)
1066 {
1067         request->opcode = CTDB_CONTROL_UPTIME;
1068         request->pad = 0;
1069         request->srvid = 0;
1070         request->client_id = 0;
1071         request->flags = 0;
1072
1073         request->rdata.opcode = CTDB_CONTROL_UPTIME;
1074 }
1075
1076 int ctdb_reply_control_uptime(struct ctdb_reply_control *reply,
1077                               TALLOC_CTX *mem_ctx, struct ctdb_uptime **uptime)
1078 {
1079         if (reply->rdata.opcode != CTDB_CONTROL_UPTIME) {
1080                 return EPROTO;
1081         }
1082
1083         if (reply->status == 0) {
1084                 *uptime = talloc_steal(mem_ctx, reply->rdata.data.uptime);
1085         }
1086         return reply->status;
1087 }
1088
1089 /* CTDB_CONTROL_START_RECOVERY */
1090
1091 void ctdb_req_control_start_recovery(struct ctdb_req_control *request)
1092 {
1093         request->opcode = CTDB_CONTROL_START_RECOVERY;
1094         request->pad = 0;
1095         request->srvid = 0;
1096         request->client_id = 0;
1097         request->flags = 0;
1098
1099         request->rdata.opcode = CTDB_CONTROL_START_RECOVERY;
1100 }
1101
1102 int ctdb_reply_control_start_recovery(struct ctdb_reply_control *reply)
1103 {
1104         return ctdb_reply_control_generic(reply, CTDB_CONTROL_START_RECOVERY);
1105 }
1106
1107 /* CTDB_CONTROL_END_RECOVERY */
1108
1109 void ctdb_req_control_end_recovery(struct ctdb_req_control *request)
1110 {
1111         request->opcode = CTDB_CONTROL_END_RECOVERY;
1112         request->pad = 0;
1113         request->srvid = 0;
1114         request->client_id = 0;
1115         request->flags = 0;
1116
1117         request->rdata.opcode = CTDB_CONTROL_END_RECOVERY;
1118 }
1119
1120 int ctdb_reply_control_end_recovery(struct ctdb_reply_control *reply)
1121 {
1122         return ctdb_reply_control_generic(reply, CTDB_CONTROL_END_RECOVERY);
1123 }
1124
1125 /* CTDB_CONTROL_RELOAD_NODES_FILE */
1126
1127 void ctdb_req_control_reload_nodes_file(struct ctdb_req_control *request)
1128 {
1129         request->opcode = CTDB_CONTROL_RELOAD_NODES_FILE;
1130         request->pad = 0;
1131         request->srvid = 0;
1132         request->client_id = 0;
1133         request->flags = 0;
1134
1135         request->rdata.opcode = CTDB_CONTROL_RELOAD_NODES_FILE;
1136 }
1137
1138 int ctdb_reply_control_reload_nodes_file(struct ctdb_reply_control *reply)
1139 {
1140         return ctdb_reply_control_generic(reply,
1141                                           CTDB_CONTROL_RELOAD_NODES_FILE);
1142 }
1143
1144 /* CTDB_CONTROL_TRY_DELETE_RECORDS */
1145
1146 void ctdb_req_control_try_delete_records(struct ctdb_req_control *request,
1147                                          struct ctdb_rec_buffer *recbuf)
1148 {
1149         request->opcode = CTDB_CONTROL_TRY_DELETE_RECORDS;
1150         request->pad = 0;
1151         request->srvid = 0;
1152         request->client_id = 0;
1153         request->flags = 0;
1154
1155         request->rdata.opcode = CTDB_CONTROL_TRY_DELETE_RECORDS;
1156         request->rdata.data.recbuf = recbuf;
1157 }
1158
1159 int ctdb_reply_control_try_delete_records(struct ctdb_reply_control *reply,
1160                                           TALLOC_CTX *mem_ctx,
1161                                           struct ctdb_rec_buffer **recbuf)
1162 {
1163         if (reply->rdata.opcode != CTDB_CONTROL_TRY_DELETE_RECORDS) {
1164                 return EPROTO;
1165         }
1166
1167         if (reply->status == 0) {
1168                 *recbuf = talloc_steal(mem_ctx, reply->rdata.data.recbuf);
1169         }
1170         return reply->status;
1171 }
1172
1173 /* CTDB_CONTROL_ENABLE_MONITOR */
1174 /* CTDB_CONTROL_DISABLE_MONITOR */
1175
1176 /* CTDB_CONTROL_ADD_PUBLIC_IP */
1177
1178 void ctdb_req_control_add_public_ip(struct ctdb_req_control *request,
1179                                     struct ctdb_addr_info *addr_info)
1180 {
1181         request->opcode = CTDB_CONTROL_ADD_PUBLIC_IP;
1182         request->pad = 0;
1183         request->srvid = 0;
1184         request->client_id = 0;
1185         request->flags = 0;
1186
1187         request->rdata.opcode = CTDB_CONTROL_ADD_PUBLIC_IP;
1188         request->rdata.data.addr_info = addr_info;
1189 }
1190
1191 int ctdb_reply_control_add_public_ip(struct ctdb_reply_control *reply)
1192 {
1193         return ctdb_reply_control_generic(reply, CTDB_CONTROL_ADD_PUBLIC_IP);
1194 }
1195
1196 /* CTDB_CONTROL_DEL_PUBLIC_IP */
1197
1198 void ctdb_req_control_del_public_ip(struct ctdb_req_control *request,
1199                                     struct ctdb_addr_info *addr_info)
1200 {
1201         request->opcode = CTDB_CONTROL_DEL_PUBLIC_IP;
1202         request->pad = 0;
1203         request->srvid = 0;
1204         request->client_id = 0;
1205         request->flags = 0;
1206
1207         request->rdata.opcode = CTDB_CONTROL_DEL_PUBLIC_IP;
1208         request->rdata.data.addr_info = addr_info;
1209 }
1210
1211 int ctdb_reply_control_del_public_ip(struct ctdb_reply_control *reply)
1212 {
1213         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DEL_PUBLIC_IP);
1214 }
1215
1216 /* CTDB_CONTROL_GET_CAPABILITIES */
1217
1218 void ctdb_req_control_get_capabilities(struct ctdb_req_control *request)
1219 {
1220         request->opcode = CTDB_CONTROL_GET_CAPABILITIES;
1221         request->pad = 0;
1222         request->srvid = 0;
1223         request->client_id = 0;
1224         request->flags = 0;
1225
1226         request->rdata.opcode = CTDB_CONTROL_GET_CAPABILITIES;
1227 }
1228
1229 int ctdb_reply_control_get_capabilities(struct ctdb_reply_control *reply,
1230                                         uint32_t *caps)
1231 {
1232         if (reply->rdata.opcode != CTDB_CONTROL_GET_CAPABILITIES) {
1233                 return EPROTO;
1234         }
1235
1236         if (reply->status == 0) {
1237                 *caps = reply->rdata.data.caps;
1238         }
1239         return reply->status;
1240 }
1241
1242 /* CTDB_CONTROL_RECD_PING */
1243
1244 void ctdb_req_control_recd_ping(struct ctdb_req_control *request)
1245 {
1246         request->opcode = CTDB_CONTROL_RECD_PING;
1247         request->pad = 0;
1248         request->srvid = 0;
1249         request->client_id = 0;
1250         request->flags = 0;
1251
1252         request->rdata.opcode = CTDB_CONTROL_RECD_PING;
1253 }
1254
1255 int ctdb_reply_control_recd_ping(struct ctdb_reply_control *reply)
1256 {
1257         return ctdb_reply_control_generic(reply, CTDB_CONTROL_RECD_PING);
1258 }
1259
1260 /* CTDB_CONTROL_RELEASE_IP */
1261
1262 void ctdb_req_control_release_ip(struct ctdb_req_control *request,
1263                                  struct ctdb_public_ip *pubip)
1264 {
1265         request->opcode = CTDB_CONTROL_RELEASE_IP;
1266         request->pad = 0;
1267         request->srvid = 0;
1268         request->client_id = 0;
1269         request->flags = 0;
1270
1271         request->rdata.opcode = CTDB_CONTROL_RELEASE_IP;
1272         request->rdata.data.pubip = pubip;
1273 }
1274
1275 int ctdb_reply_control_release_ip(struct ctdb_reply_control *reply)
1276 {
1277         return ctdb_reply_control_generic(reply, CTDB_CONTROL_RELEASE_IP);
1278 }
1279
1280 /* CTDB_CONTROL_TAKEOVER_IP */
1281
1282 void ctdb_req_control_takeover_ip(struct ctdb_req_control *request,
1283                                   struct ctdb_public_ip *pubip)
1284 {
1285         request->opcode = CTDB_CONTROL_TAKEOVER_IP;
1286         request->pad = 0;
1287         request->srvid = 0;
1288         request->client_id = 0;
1289         request->flags = 0;
1290
1291         request->rdata.opcode = CTDB_CONTROL_TAKEOVER_IP;
1292         request->rdata.data.pubip = pubip;
1293 }
1294
1295 int ctdb_reply_control_takeover_ip(struct ctdb_reply_control *reply)
1296 {
1297         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TAKEOVER_IP);
1298 }
1299
1300 /* CTDB_CONTROL_GET_PUBLIC_IPS */
1301
1302 void ctdb_req_control_get_public_ips(struct ctdb_req_control *request,
1303                                      bool available_only)
1304 {
1305         request->opcode = CTDB_CONTROL_GET_PUBLIC_IPS;
1306         request->pad = 0;
1307         request->srvid = 0;
1308         request->client_id = 0;
1309         request->flags = 0;
1310
1311         request->rdata.opcode = CTDB_CONTROL_GET_PUBLIC_IPS;
1312         if (available_only) {
1313                 request->flags = CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE;
1314         }
1315 }
1316
1317 int ctdb_reply_control_get_public_ips(struct ctdb_reply_control *reply,
1318                                       TALLOC_CTX *mem_ctx,
1319                                       struct ctdb_public_ip_list **pubip_list)
1320 {
1321         if (reply->rdata.opcode != CTDB_CONTROL_GET_PUBLIC_IPS) {
1322                 return EPROTO;
1323         }
1324
1325         if (reply->status == 0) {
1326                 *pubip_list = talloc_steal(mem_ctx,
1327                                            reply->rdata.data.pubip_list);
1328         }
1329         return reply->status;
1330 }
1331
1332 /* CTDB_CONTROL_GET_NODEMAP */
1333
1334 void ctdb_req_control_get_nodemap(struct ctdb_req_control *request)
1335 {
1336         request->opcode = CTDB_CONTROL_GET_NODEMAP;
1337         request->pad = 0;
1338         request->srvid = 0;
1339         request->client_id = 0;
1340         request->flags = 0;
1341
1342         request->rdata.opcode = CTDB_CONTROL_GET_NODEMAP;
1343 }
1344
1345 int ctdb_reply_control_get_nodemap(struct ctdb_reply_control *reply,
1346                                    TALLOC_CTX *mem_ctx,
1347                                    struct ctdb_node_map **nodemap)
1348 {
1349         if (reply->rdata.opcode != CTDB_CONTROL_GET_NODEMAP) {
1350                 return EPROTO;
1351         }
1352
1353         if (reply->status == 0) {
1354                 *nodemap = talloc_steal(mem_ctx, reply->rdata.data.nodemap);
1355         }
1356         return reply->status;
1357 }
1358
1359 /* CTDB_CONTROL_TRAVERSE_KILL */
1360
1361 void ctdb_req_control_traverse_kill(struct ctdb_req_control *request,
1362                                     struct ctdb_traverse_start *traverse)
1363 {
1364         request->opcode = CTDB_CONTROL_TRAVERSE_KILL;
1365         request->pad = 0;
1366         request->srvid = 0;
1367         request->client_id = 0;
1368         request->flags = 0;
1369
1370         request->rdata.opcode = CTDB_CONTROL_TRAVERSE_KILL;
1371         request->rdata.data.traverse_start = traverse;
1372 }
1373
1374 int ctdb_reply_control_traverse_kill(struct ctdb_reply_control *reply)
1375 {
1376         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRAVERSE_KILL);
1377 }
1378
1379 /* CTDB_CONTROL_RECD_RECLOCK_LATENCY */
1380
1381 void ctdb_req_control_recd_reclock_latency(struct ctdb_req_control *request,
1382                                            double reclock_latency)
1383 {
1384         request->opcode = CTDB_CONTROL_RECD_RECLOCK_LATENCY;
1385         request->pad = 0;
1386         request->srvid = 0;
1387         request->client_id = 0;
1388         request->flags = 0;
1389
1390         request->rdata.opcode = CTDB_CONTROL_RECD_RECLOCK_LATENCY;
1391         request->rdata.data.reclock_latency = reclock_latency;
1392 }
1393
1394 int ctdb_reply_control_recd_reclock_latency(struct ctdb_reply_control *reply)
1395 {
1396         return ctdb_reply_control_generic(reply,
1397                                           CTDB_CONTROL_RECD_RECLOCK_LATENCY);
1398 }
1399
1400 /* CTDB_CONTROL_GET_RECLOCK_FILE */
1401
1402 void ctdb_req_control_get_reclock_file(struct ctdb_req_control *request)
1403 {
1404         request->opcode = CTDB_CONTROL_GET_RECLOCK_FILE;
1405         request->pad = 0;
1406         request->srvid = 0;
1407         request->client_id = 0;
1408         request->flags = 0;
1409
1410         request->rdata.opcode = CTDB_CONTROL_GET_RECLOCK_FILE;
1411 }
1412
1413 int ctdb_reply_control_get_reclock_file(struct ctdb_reply_control *reply,
1414                                         TALLOC_CTX *mem_ctx,
1415                                         const char **reclock_file)
1416 {
1417         if (reply->rdata.opcode != CTDB_CONTROL_GET_RECLOCK_FILE) {
1418                 return EPROTO;
1419         }
1420
1421         if (reply->status == 0) {
1422                 *reclock_file = talloc_steal(mem_ctx,
1423                                              reply->rdata.data.reclock_file);
1424         }
1425         return reply->status;
1426 }
1427
1428 /* CTDB_CONTROL_STOP_NODE */
1429
1430 void ctdb_req_control_stop_node(struct ctdb_req_control *request)
1431 {
1432         request->opcode = CTDB_CONTROL_STOP_NODE;
1433         request->pad = 0;
1434         request->srvid = 0;
1435         request->client_id = 0;
1436         request->flags = 0;
1437
1438         request->rdata.opcode = CTDB_CONTROL_STOP_NODE;
1439 }
1440
1441 int ctdb_reply_control_stop_node(struct ctdb_reply_control *reply)
1442 {
1443         return ctdb_reply_control_generic(reply, CTDB_CONTROL_STOP_NODE);
1444 }
1445
1446 /* CTDB_CONTROL_CONTINUE_NODE */
1447
1448 void ctdb_req_control_continue_node(struct ctdb_req_control *request)
1449 {
1450         request->opcode = CTDB_CONTROL_CONTINUE_NODE;
1451         request->pad = 0;
1452         request->srvid = 0;
1453         request->client_id = 0;
1454         request->flags = 0;
1455
1456         request->rdata.opcode = CTDB_CONTROL_CONTINUE_NODE;
1457 }
1458
1459 int ctdb_reply_control_continue_node(struct ctdb_reply_control *reply)
1460 {
1461         return ctdb_reply_control_generic(reply, CTDB_CONTROL_CONTINUE_NODE);
1462 }
1463
1464 /* CTDB_CONTROL_SET_LMASTERROLE */
1465
1466 void ctdb_req_control_set_lmasterrole(struct ctdb_req_control *request,
1467                                       uint32_t lmaster_role)
1468 {
1469         request->opcode = CTDB_CONTROL_SET_LMASTERROLE;
1470         request->pad = 0;
1471         request->srvid = 0;
1472         request->client_id = 0;
1473         request->flags = 0;
1474
1475         request->rdata.opcode = CTDB_CONTROL_SET_LMASTERROLE;
1476         request->rdata.data.role = lmaster_role;
1477 }
1478
1479 int ctdb_reply_control_set_lmasterrole(struct ctdb_reply_control *reply)
1480 {
1481         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_LMASTERROLE);
1482 }
1483
1484 /* CTDB_CONTROL_SET_RECMASTERROLE */
1485
1486 void ctdb_req_control_set_recmasterrole(struct ctdb_req_control *request,
1487                                         uint32_t recmaster_role)
1488 {
1489         request->opcode = CTDB_CONTROL_SET_RECMASTERROLE;
1490         request->pad = 0;
1491         request->srvid = 0;
1492         request->client_id = 0;
1493         request->flags = 0;
1494
1495         request->rdata.opcode = CTDB_CONTROL_SET_RECMASTERROLE;
1496         request->rdata.data.role = recmaster_role;
1497 }
1498
1499 int ctdb_reply_control_set_recmasterrole(struct ctdb_reply_control *reply)
1500 {
1501         return ctdb_reply_control_generic(reply,
1502                                           CTDB_CONTROL_SET_RECMASTERROLE);
1503 }
1504
1505 /* CTDB_CONTROL_SET_BAN_STATE */
1506
1507 void ctdb_req_control_set_ban_state(struct ctdb_req_control *request,
1508                                     struct ctdb_ban_state *ban_state)
1509 {
1510         request->opcode = CTDB_CONTROL_SET_BAN_STATE;
1511         request->pad = 0;
1512         request->srvid = 0;
1513         request->client_id = 0;
1514         request->flags = 0;
1515
1516         request->rdata.opcode = CTDB_CONTROL_SET_BAN_STATE;
1517         request->rdata.data.ban_state = ban_state;
1518 }
1519
1520 int ctdb_reply_control_set_ban_state(struct ctdb_reply_control *reply)
1521 {
1522         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_BAN_STATE);
1523 }
1524
1525 /* CTDB_CONTROL_GET_BAN_STATE */
1526
1527 void ctdb_req_control_get_ban_state(struct ctdb_req_control *request)
1528 {
1529         request->opcode = CTDB_CONTROL_GET_BAN_STATE;
1530         request->pad = 0;
1531         request->srvid = 0;
1532         request->client_id = 0;
1533         request->flags = 0;
1534
1535         request->rdata.opcode = CTDB_CONTROL_GET_BAN_STATE;
1536 }
1537
1538 int ctdb_reply_control_get_ban_state(struct ctdb_reply_control *reply,
1539                                      TALLOC_CTX *mem_ctx,
1540                                      struct ctdb_ban_state **ban_state)
1541 {
1542         if (reply->rdata.opcode != CTDB_CONTROL_GET_BAN_STATE) {
1543                 return EPROTO;
1544         }
1545
1546         if (reply->status == 0) {
1547                 *ban_state = talloc_steal(mem_ctx,
1548                                           reply->rdata.data.ban_state);
1549         }
1550         return reply->status;
1551 }
1552
1553 /* CTDB_CONTROL_REGISTER_NOTIFY */
1554
1555 void ctdb_req_control_register_notify(struct ctdb_req_control *request,
1556                                       struct ctdb_notify_data *notify)
1557 {
1558         request->opcode = CTDB_CONTROL_REGISTER_NOTIFY;
1559         request->pad = 0;
1560         request->srvid = 0;
1561         request->client_id = 0;
1562         request->flags = 0;
1563
1564         request->rdata.opcode = CTDB_CONTROL_REGISTER_NOTIFY;
1565         request->rdata.data.notify = notify;
1566 }
1567
1568 int ctdb_reply_control_register_notify(struct ctdb_reply_control *reply)
1569 {
1570         return ctdb_reply_control_generic(reply, CTDB_CONTROL_REGISTER_NOTIFY);
1571 }
1572
1573 /* CTDB_CONTROL_DEREGISTER_NOTIFY */
1574
1575 void ctdb_req_control_deregister_notify(struct ctdb_req_control *request,
1576                                         uint64_t srvid)
1577 {
1578         request->opcode = CTDB_CONTROL_DEREGISTER_NOTIFY;
1579         request->pad = 0;
1580         request->srvid = 0;
1581         request->client_id = 0;
1582         request->flags = 0;
1583
1584         request->rdata.opcode = CTDB_CONTROL_DEREGISTER_NOTIFY;
1585         request->rdata.data.srvid = srvid;
1586 }
1587
1588 int ctdb_reply_control_deregister_notify(struct ctdb_reply_control *reply)
1589 {
1590         return ctdb_reply_control_generic(reply,
1591                                           CTDB_CONTROL_DEREGISTER_NOTIFY);
1592 }
1593
1594 /* CTDB_CONTROL_TRANS3_COMMIT */
1595
1596 void ctdb_req_control_trans3_commit(struct ctdb_req_control *request,
1597                                     struct ctdb_rec_buffer *recbuf)
1598 {
1599         request->opcode = CTDB_CONTROL_TRANS3_COMMIT;
1600         request->pad = 0;
1601         request->srvid = 0;
1602         request->client_id = 0;
1603         request->flags = 0;
1604
1605         request->rdata.opcode = CTDB_CONTROL_TRANS3_COMMIT;
1606         request->rdata.data.recbuf = recbuf;
1607 }
1608
1609 int ctdb_reply_control_trans3_commit(struct ctdb_reply_control *reply)
1610 {
1611         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRANS3_COMMIT);
1612 }
1613
1614 /* CTDB_CONTROL_GET_DB_SEQNUM */
1615
1616 void ctdb_req_control_get_db_seqnum(struct ctdb_req_control *request,
1617                                     uint32_t db_id)
1618 {
1619         request->opcode = CTDB_CONTROL_GET_DB_SEQNUM;
1620         request->pad = 0;
1621         request->srvid = 0;
1622         request->client_id = 0;
1623         request->flags = 0;
1624
1625         request->rdata.opcode = CTDB_CONTROL_GET_DB_SEQNUM;
1626         request->rdata.data.db_id = db_id;
1627 }
1628
1629 int ctdb_reply_control_get_db_seqnum(struct ctdb_reply_control *reply,
1630                                      uint64_t *seqnum)
1631 {
1632         if (reply->rdata.opcode != CTDB_CONTROL_GET_DB_SEQNUM) {
1633                 return EPROTO;
1634         }
1635
1636         if (reply->status == 0) {
1637                 *seqnum = reply->rdata.data.seqnum;
1638         }
1639         return reply->status;
1640 }
1641
1642 /* CTDB_CONTROL_DB_SET_HEALTHY */
1643
1644 void ctdb_req_control_db_set_healthy(struct ctdb_req_control *request,
1645                                      uint32_t db_id)
1646 {
1647         request->opcode = CTDB_CONTROL_DB_SET_HEALTHY;
1648         request->pad = 0;
1649         request->srvid = 0;
1650         request->client_id = 0;
1651         request->flags = 0;
1652
1653         request->rdata.opcode = CTDB_CONTROL_DB_SET_HEALTHY;
1654         request->rdata.data.db_id = db_id;
1655 }
1656
1657 int ctdb_reply_control_db_set_healthy(struct ctdb_reply_control *reply)
1658 {
1659         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_SET_HEALTHY);
1660 }
1661
1662 /* CTDB_CONTROL_DB_GET_HEALTH */
1663
1664 void ctdb_req_control_db_get_health(struct ctdb_req_control *request,
1665                                     uint32_t db_id)
1666 {
1667         request->opcode = CTDB_CONTROL_DB_GET_HEALTH;
1668         request->pad = 0;
1669         request->srvid = 0;
1670         request->client_id = 0;
1671         request->flags = 0;
1672
1673         request->rdata.opcode = CTDB_CONTROL_DB_GET_HEALTH;
1674         request->rdata.data.db_id = db_id;
1675 }
1676
1677 int ctdb_reply_control_db_get_health(struct ctdb_reply_control *reply,
1678                                      TALLOC_CTX *mem_ctx, const char **reason)
1679 {
1680         if (reply->rdata.opcode != CTDB_CONTROL_DB_GET_HEALTH) {
1681                 return EPROTO;
1682         }
1683
1684         if (reply->status == 0) {
1685                 *reason = talloc_steal(mem_ctx, reply->rdata.data.reason);
1686         }
1687         return reply->status;
1688 }
1689
1690 /* CTDB_CONTROL_GET_PUBLIC_IP_INFO */
1691
1692 void ctdb_req_control_get_public_ip_info(struct ctdb_req_control *request,
1693                                          ctdb_sock_addr *addr)
1694 {
1695         request->opcode = CTDB_CONTROL_GET_PUBLIC_IP_INFO;
1696         request->pad = 0;
1697         request->srvid = 0;
1698         request->client_id = 0;
1699         request->flags = 0;
1700
1701         request->rdata.opcode = CTDB_CONTROL_GET_PUBLIC_IP_INFO;
1702         request->rdata.data.addr = addr;
1703 }
1704
1705 int ctdb_reply_control_get_public_ip_info(struct ctdb_reply_control *reply,
1706                                           TALLOC_CTX *mem_ctx,
1707                                           struct ctdb_public_ip_info **ipinfo)
1708 {
1709         if (reply->rdata.opcode != CTDB_CONTROL_GET_PUBLIC_IP_INFO) {
1710                 return EPROTO;
1711         }
1712
1713         if (reply->status == 0) {
1714                 *ipinfo = talloc_steal(mem_ctx, reply->rdata.data.ipinfo);
1715         }
1716         return reply->status;
1717 }
1718
1719 /* CTDB_CONTROL_GET_IFACES */
1720
1721 void ctdb_req_control_get_ifaces(struct ctdb_req_control *request)
1722 {
1723         request->opcode = CTDB_CONTROL_GET_IFACES;
1724         request->pad = 0;
1725         request->srvid = 0;
1726         request->client_id = 0;
1727         request->flags = 0;
1728
1729         request->rdata.opcode = CTDB_CONTROL_GET_IFACES;
1730 }
1731
1732 int ctdb_reply_control_get_ifaces(struct ctdb_reply_control *reply,
1733                                   TALLOC_CTX *mem_ctx,
1734                                   struct ctdb_iface_list **iface_list)
1735 {
1736         if (reply->rdata.opcode != CTDB_CONTROL_GET_IFACES) {
1737                 return EPROTO;
1738         }
1739
1740         if (reply->status == 0) {
1741                 *iface_list = talloc_steal(mem_ctx,
1742                                            reply->rdata.data.iface_list);
1743         }
1744         return reply->status;
1745 }
1746
1747 /* CTDB_CONTROL_SET_IFACE_LINK_STATE */
1748
1749 void ctdb_req_control_set_iface_link_state(struct ctdb_req_control *request,
1750                                            struct ctdb_iface *iface)
1751 {
1752         request->opcode = CTDB_CONTROL_SET_IFACE_LINK_STATE;
1753         request->pad = 0;
1754         request->srvid = 0;
1755         request->client_id = 0;
1756         request->flags = 0;
1757
1758         request->rdata.opcode = CTDB_CONTROL_SET_IFACE_LINK_STATE;
1759         request->rdata.data.iface = iface;
1760 }
1761
1762 int ctdb_reply_control_set_iface_link_state(struct ctdb_reply_control *reply)
1763 {
1764         return ctdb_reply_control_generic(reply,
1765                                           CTDB_CONTROL_SET_IFACE_LINK_STATE);
1766 }
1767
1768 /* CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE */
1769
1770 void ctdb_req_control_tcp_add_delayed_update(struct ctdb_req_control *request,
1771                                              struct ctdb_connection *conn)
1772 {
1773         request->opcode = CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE;
1774         request->pad = 0;
1775         request->srvid = 0;
1776         request->client_id = 0;
1777         request->flags = 0;
1778
1779         request->rdata.opcode = CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE;
1780         request->rdata.data.conn = conn;
1781 }
1782
1783 int ctdb_reply_control_tcp_add_delayed_update(struct ctdb_reply_control *reply)
1784 {
1785         return ctdb_reply_control_generic(reply,
1786                                           CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE);
1787 }
1788
1789 /* CTDB_CONTROL_GET_STAT_HISTORY */
1790
1791 void ctdb_req_control_get_stat_history(struct ctdb_req_control *request)
1792 {
1793         request->opcode = CTDB_CONTROL_GET_STAT_HISTORY;
1794         request->pad = 0;
1795         request->srvid = 0;
1796         request->client_id = 0;
1797         request->flags = 0;
1798
1799         request->rdata.opcode = CTDB_CONTROL_GET_STAT_HISTORY;
1800 }
1801
1802 int ctdb_reply_control_get_stat_history(struct ctdb_reply_control *reply,
1803                                         TALLOC_CTX *mem_ctx,
1804                                         struct ctdb_statistics_list **stats_list)
1805 {
1806         if (reply->rdata.opcode != CTDB_CONTROL_GET_STAT_HISTORY) {
1807                 return EPROTO;
1808         }
1809
1810         if (reply->status == 0) {
1811                 *stats_list = talloc_steal(mem_ctx,
1812                                            reply->rdata.data.stats_list);
1813         }
1814         return reply->status;
1815 }
1816
1817 /* CTDB_CONTROL_SCHEDULE_FOR_DELETION */
1818
1819 void ctdb_req_control_schedule_for_deletion(struct ctdb_req_control *request,
1820                                             struct ctdb_key_data *key)
1821 {
1822         request->opcode = CTDB_CONTROL_SCHEDULE_FOR_DELETION;
1823         request->pad = 0;
1824         request->srvid = 0;
1825         request->client_id = 0;
1826         request->flags = 0;
1827
1828         request->rdata.opcode = CTDB_CONTROL_SCHEDULE_FOR_DELETION;
1829         request->rdata.data.key = key;
1830 }
1831
1832 int ctdb_reply_control_schedule_for_deletion(struct ctdb_reply_control *reply)
1833 {
1834         return ctdb_reply_control_generic(reply,
1835                                           CTDB_CONTROL_SCHEDULE_FOR_DELETION);
1836 }
1837
1838 /* CTDB_CONTROL_SET_DB_READONLY */
1839
1840 void ctdb_req_control_set_db_readonly(struct ctdb_req_control *request,
1841                                       uint32_t db_id)
1842 {
1843         request->opcode = CTDB_CONTROL_SET_DB_READONLY;
1844         request->pad = 0;
1845         request->srvid = 0;
1846         request->client_id = 0;
1847         request->flags = 0;
1848
1849         request->rdata.opcode = CTDB_CONTROL_SET_DB_READONLY;
1850         request->rdata.data.db_id = db_id;
1851 }
1852
1853 int ctdb_reply_control_set_db_readonly(struct ctdb_reply_control *reply)
1854 {
1855         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DB_READONLY);
1856 }
1857
1858 /* CTDB_CONTROL_CHECK_SRVIDS */
1859
1860 /* CTDB_CONTROL_TRAVERSE_START_EXT */
1861
1862 void ctdb_req_control_traverse_start_ext(struct ctdb_req_control *request,
1863                                          struct ctdb_traverse_start_ext *traverse)
1864 {
1865         request->opcode = CTDB_CONTROL_TRAVERSE_START_EXT;
1866         request->pad = 0;
1867         request->srvid = 0;
1868         request->client_id = 0;
1869         request->flags = 0;
1870
1871         request->rdata.opcode = CTDB_CONTROL_TRAVERSE_START_EXT;
1872         request->rdata.data.traverse_start_ext = traverse;
1873 }
1874
1875 int ctdb_reply_control_traverse_start_ext(struct ctdb_reply_control *reply)
1876 {
1877         return ctdb_reply_control_generic(reply,
1878                                           CTDB_CONTROL_TRAVERSE_START_EXT);
1879 }
1880
1881 /* CTDB_CONTROL_GET_DB_STATISTICS */
1882
1883 void ctdb_req_control_get_db_statistics(struct ctdb_req_control *request,
1884                                         uint32_t db_id)
1885 {
1886         request->opcode = CTDB_CONTROL_GET_DB_STATISTICS;
1887         request->pad = 0;
1888         request->srvid = 0;
1889         request->client_id = 0;
1890         request->flags = 0;
1891
1892         request->rdata.opcode = CTDB_CONTROL_GET_DB_STATISTICS;
1893         request->rdata.data.db_id = db_id;
1894 }
1895
1896 int ctdb_reply_control_get_db_statistics(struct ctdb_reply_control *reply,
1897                                          TALLOC_CTX *mem_ctx,
1898                                          struct ctdb_db_statistics **dbstats)
1899 {
1900         if (reply->rdata.opcode != CTDB_CONTROL_GET_DB_STATISTICS) {
1901                 return EPROTO;
1902         }
1903
1904         if (reply->status == 0) {
1905                 *dbstats = talloc_steal(mem_ctx, reply->rdata.data.dbstats);
1906         }
1907         return reply->status;
1908 }
1909
1910 /* CTDB_CONTROL_SET_DB_STICKY */
1911
1912 void ctdb_req_control_set_db_sticky(struct ctdb_req_control *request,
1913                                     uint32_t db_id)
1914 {
1915         request->opcode = CTDB_CONTROL_SET_DB_STICKY;
1916         request->pad = 0;
1917         request->srvid = 0;
1918         request->client_id = 0;
1919         request->flags = 0;
1920
1921         request->rdata.opcode = CTDB_CONTROL_SET_DB_STICKY;
1922         request->rdata.data.db_id = db_id;
1923 }
1924
1925 int ctdb_reply_control_set_db_sticky(struct ctdb_reply_control *reply)
1926 {
1927         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DB_STICKY);
1928 }
1929
1930 /* CTDB_CONTROL_RELOAD_PUBLIC_IPS */
1931
1932 void ctdb_req_control_reload_public_ips(struct ctdb_req_control *request)
1933 {
1934         request->opcode = CTDB_CONTROL_RELOAD_PUBLIC_IPS;
1935         request->pad = 0;
1936         request->srvid = 0;
1937         request->client_id = 0;
1938         request->flags = 0;
1939
1940         request->rdata.opcode = CTDB_CONTROL_RELOAD_PUBLIC_IPS;
1941 }
1942
1943 int ctdb_reply_control_reload_public_ips(struct ctdb_reply_control *reply)
1944 {
1945         return ctdb_reply_control_generic(reply,
1946                                           CTDB_CONTROL_RELOAD_PUBLIC_IPS);
1947 }
1948
1949 /* CTDB_CONTROL_TRAVERSE_ALL_EXT */
1950
1951 /* CTDB_CONTROL_IPREALLOCATED */
1952
1953 void ctdb_req_control_ipreallocated(struct ctdb_req_control *request)
1954 {
1955         request->opcode = CTDB_CONTROL_IPREALLOCATED;
1956         request->pad = 0;
1957         request->srvid = 0;
1958         request->client_id = 0;
1959         request->flags = 0;
1960
1961         request->rdata.opcode = CTDB_CONTROL_IPREALLOCATED;
1962 }
1963
1964 int ctdb_reply_control_ipreallocated(struct ctdb_reply_control *reply)
1965 {
1966         return ctdb_reply_control_generic(reply, CTDB_CONTROL_IPREALLOCATED);
1967 }
1968
1969 /* CTDB_CONTROL_GET_RUNSTATE */
1970
1971 void ctdb_req_control_get_runstate(struct ctdb_req_control *request)
1972 {
1973         request->opcode = CTDB_CONTROL_GET_RUNSTATE;
1974         request->pad = 0;
1975         request->srvid = 0;
1976         request->client_id = 0;
1977         request->flags = 0;
1978
1979         request->rdata.opcode = CTDB_CONTROL_GET_RUNSTATE;
1980 }
1981
1982 int ctdb_reply_control_get_runstate(struct ctdb_reply_control *reply,
1983                                     enum ctdb_runstate *runstate)
1984 {
1985         if (reply->rdata.opcode != CTDB_CONTROL_GET_RUNSTATE) {
1986                 return EPROTO;
1987         }
1988
1989         if (reply->status == 0) {
1990                 *runstate = reply->rdata.data.runstate;
1991         }
1992         return reply->status;
1993 }
1994
1995 /* CTDB_CONTROL_DB_DETACH */
1996
1997 void ctdb_req_control_db_detach(struct ctdb_req_control *request,
1998                                 uint32_t db_id)
1999 {
2000         request->opcode = CTDB_CONTROL_DB_DETACH;
2001         request->pad = 0;
2002         request->srvid = 0;
2003         request->client_id = 0;
2004         request->flags = 0;
2005
2006         request->rdata.opcode = CTDB_CONTROL_DB_DETACH;
2007         request->rdata.data.db_id = db_id;
2008 }
2009
2010 int ctdb_reply_control_db_detach(struct ctdb_reply_control *reply)
2011 {
2012         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_DETACH);
2013 }
2014
2015 /* CTDB_CONTROL_GET_NODES_FILE */
2016
2017 void ctdb_req_control_get_nodes_file(struct ctdb_req_control *request)
2018 {
2019         request->opcode = CTDB_CONTROL_GET_NODES_FILE;
2020         request->pad = 0;
2021         request->srvid = 0;
2022         request->client_id = 0;
2023         request->flags = 0;
2024
2025         request->rdata.opcode = CTDB_CONTROL_GET_NODES_FILE;
2026 }
2027
2028 int ctdb_reply_control_get_nodes_file(struct ctdb_reply_control *reply,
2029                                       TALLOC_CTX *mem_ctx,
2030                                       struct ctdb_node_map **nodemap)
2031 {
2032         if (reply->rdata.opcode != CTDB_CONTROL_GET_NODES_FILE) {
2033                 return EPROTO;
2034         }
2035
2036         if (reply->status == 0) {
2037                 *nodemap = talloc_steal(mem_ctx, reply->rdata.data.nodemap);
2038         }
2039         return reply->status;
2040 }
2041
2042 /* CTDB_CONTROL_DB_FREEZE */
2043
2044 void ctdb_req_control_db_freeze(struct ctdb_req_control *request,
2045                                 uint32_t db_id)
2046 {
2047         request->opcode = CTDB_CONTROL_DB_FREEZE;
2048         request->pad = 0;
2049         request->srvid = 0;
2050         request->client_id = 0;
2051         request->flags = 0;
2052
2053         request->rdata.opcode = CTDB_CONTROL_DB_FREEZE;
2054         request->rdata.data.db_id = db_id;
2055 }
2056
2057 int ctdb_reply_control_db_freeze(struct ctdb_reply_control *reply)
2058 {
2059         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_FREEZE);
2060 }
2061
2062 /* CTDB_CONTROL_DB_THAW */
2063
2064 void ctdb_req_control_db_thaw(struct ctdb_req_control *request,
2065                               uint32_t db_id)
2066 {
2067         request->opcode = CTDB_CONTROL_DB_THAW;
2068         request->pad = 0;
2069         request->srvid = 0;
2070         request->client_id = 0;
2071         request->flags = 0;
2072
2073         request->rdata.opcode = CTDB_CONTROL_DB_THAW;
2074         request->rdata.data.db_id = db_id;
2075 }
2076
2077 int ctdb_reply_control_db_thaw(struct ctdb_reply_control *reply)
2078 {
2079         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_THAW);
2080 }
2081
2082 /* CTDB_CONTROL_DB_TRANSACTION_START */
2083
2084 void ctdb_req_control_db_transaction_start(struct ctdb_req_control *request,
2085                                            struct ctdb_transdb *transdb)
2086 {
2087         request->opcode = CTDB_CONTROL_DB_TRANSACTION_START;
2088         request->pad = 0;
2089         request->srvid = 0;
2090         request->client_id = 0;
2091         request->flags = 0;
2092
2093         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_START;
2094         request->rdata.data.transdb = transdb;
2095 }
2096
2097 int ctdb_reply_control_db_transaction_start(struct ctdb_reply_control *reply)
2098 {
2099         return ctdb_reply_control_generic(reply,
2100                                           CTDB_CONTROL_DB_TRANSACTION_START);
2101 }
2102
2103 /* CTDB_CONTROL_DB_TRANSACTION_COMMIT */
2104
2105 void ctdb_req_control_db_transaction_commit(struct ctdb_req_control *request,
2106                                             struct ctdb_transdb *transdb)
2107 {
2108         request->opcode = CTDB_CONTROL_DB_TRANSACTION_COMMIT;
2109         request->pad = 0;
2110         request->srvid = 0;
2111         request->client_id = 0;
2112         request->flags = 0;
2113
2114         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_COMMIT;
2115         request->rdata.data.transdb = transdb;
2116 }
2117
2118 int ctdb_reply_control_db_transaction_commit(struct ctdb_reply_control *reply)
2119 {
2120         return ctdb_reply_control_generic(reply,
2121                                           CTDB_CONTROL_DB_TRANSACTION_COMMIT);
2122 }
2123
2124 /* CTDB_CONTROL_DB_TRANSACTION_CANCEL */
2125
2126 void ctdb_req_control_db_transaction_cancel(struct ctdb_req_control *request,
2127                                             uint32_t db_id)
2128 {
2129         request->opcode = CTDB_CONTROL_DB_TRANSACTION_CANCEL;
2130         request->pad = 0;
2131         request->srvid = 0;
2132         request->client_id = 0;
2133         request->flags = 0;
2134
2135         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_CANCEL;
2136         request->rdata.data.db_id = db_id;
2137 }
2138
2139 int ctdb_reply_control_db_transaction_cancel(struct ctdb_reply_control *reply)
2140 {
2141         return ctdb_reply_control_generic(reply,
2142                                           CTDB_CONTROL_DB_TRANSACTION_CANCEL);
2143 }
2144
2145 /* CTDB_CONTROL_DB_PULL */
2146
2147 void ctdb_req_control_db_pull(struct ctdb_req_control *request,
2148                               struct ctdb_pulldb_ext *pulldb_ext)
2149 {
2150         request->opcode = CTDB_CONTROL_DB_PULL;
2151         request->pad = 0;
2152         request->srvid = 0;
2153         request->client_id = 0;
2154         request->flags = 0;
2155
2156         request->rdata.opcode = CTDB_CONTROL_DB_PULL;
2157         request->rdata.data.pulldb_ext = pulldb_ext;
2158 }
2159
2160 int ctdb_reply_control_db_pull(struct ctdb_reply_control *reply,
2161                                uint32_t *num_records)
2162 {
2163         if (reply->rdata.opcode != CTDB_CONTROL_DB_PULL) {
2164                 return EPROTO;
2165         }
2166
2167         if (reply->status == 0) {
2168                 *num_records = reply->rdata.data.num_records;
2169         }
2170         return reply->status;
2171 }
2172
2173 /* CTDB_CONTROL_DB_PUSH_START */
2174
2175 void ctdb_req_control_db_push_start(struct ctdb_req_control *request,
2176                                     struct ctdb_pulldb_ext *pulldb_ext)
2177 {
2178         request->opcode = CTDB_CONTROL_DB_PUSH_START;
2179         request->pad = 0;
2180         request->srvid = 0;
2181         request->client_id = 0;
2182         request->flags = 0;
2183
2184         request->rdata.opcode = CTDB_CONTROL_DB_PUSH_START;
2185         request->rdata.data.pulldb_ext = pulldb_ext;
2186 }
2187
2188 int ctdb_reply_control_db_push_start(struct ctdb_reply_control *reply)
2189 {
2190         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_PUSH_START);
2191 }
2192
2193 /* CTDB_CONTROL_DB_PUSH_CONFIRM */
2194
2195 void ctdb_req_control_db_push_confirm(struct ctdb_req_control *request,
2196                                       uint32_t db_id)
2197 {
2198         request->opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
2199         request->pad = 0;
2200         request->srvid = 0;
2201         request->client_id = 0;
2202         request->flags = 0;
2203
2204         request->rdata.opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
2205         request->rdata.data.db_id = db_id;
2206 }
2207
2208 int ctdb_reply_control_db_push_confirm(struct ctdb_reply_control *reply,
2209                                        uint32_t *num_records)
2210 {
2211         if (reply->rdata.opcode != CTDB_CONTROL_DB_PUSH_CONFIRM) {
2212                 return EPROTO;
2213         }
2214
2215         if (reply->status == 0) {
2216                 *num_records = reply->rdata.data.num_records;
2217         }
2218         return reply->status;
2219 }
2220
2221 /* CTDB_CONTROL_DB_OPEN_FLAGS */
2222
2223 void ctdb_req_control_db_open_flags(struct ctdb_req_control *request,
2224                                     uint32_t db_id)
2225 {
2226         request->opcode = CTDB_CONTROL_DB_OPEN_FLAGS;
2227         request->pad = 0;
2228         request->srvid = 0;
2229         request->client_id = 0;
2230         request->flags = 0;
2231
2232         request->rdata.opcode = CTDB_CONTROL_DB_OPEN_FLAGS;
2233         request->rdata.data.db_id = db_id;
2234 }
2235
2236 int ctdb_reply_control_db_open_flags(struct ctdb_reply_control *reply,
2237                                      int *tdb_flags)
2238 {
2239         if (reply->rdata.opcode != CTDB_CONTROL_DB_OPEN_FLAGS) {
2240                 return EPROTO;
2241         }
2242
2243         if (reply->status == 0) {
2244                 *tdb_flags = reply->rdata.data.tdb_flags;
2245         }
2246         return reply->status;
2247 }
2248
2249 /* CTDB_CONTROL_DB_ATTACH_REPLICATED */
2250
2251 void ctdb_req_control_db_attach_replicated(struct ctdb_req_control *request,
2252                                            const char *db_name)
2253 {
2254         request->opcode = CTDB_CONTROL_DB_ATTACH_REPLICATED;
2255         request->pad = 0;
2256         request->srvid = 0;
2257         request->client_id = 0;
2258         request->flags = 0;
2259
2260         request->rdata.opcode = CTDB_CONTROL_DB_ATTACH_REPLICATED;
2261         request->rdata.data.db_name = db_name;
2262 }
2263
2264 int ctdb_reply_control_db_attach_replicated(struct ctdb_reply_control *reply,
2265                                             uint32_t *db_id)
2266 {
2267         if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH_REPLICATED) {
2268                 return EPROTO;
2269         }
2270         if (reply->status == 0) {
2271                 *db_id = reply->rdata.data.db_id;
2272         }
2273         return reply->status;
2274 }
2275
2276 /* CTDB_CONTROL_CHECK_PID_SRVID */
2277
2278 void ctdb_req_control_check_pid_srvid(struct ctdb_req_control *request,
2279                                       struct ctdb_pid_srvid *pid_srvid)
2280 {
2281         request->opcode = CTDB_CONTROL_CHECK_PID_SRVID;
2282         request->pad = 0;
2283         request->srvid = 0;
2284         request->client_id = 0;
2285         request->flags = 0;
2286
2287         request->rdata.opcode = CTDB_CONTROL_CHECK_PID_SRVID;
2288         request->rdata.data.pid_srvid = pid_srvid;
2289 }
2290
2291 int ctdb_reply_control_check_pid_srvid(struct ctdb_reply_control *reply,
2292                                        int *status)
2293 {
2294         if (reply->rdata.opcode != CTDB_CONTROL_CHECK_PID_SRVID) {
2295                 return EPROTO;
2296         }
2297
2298         *status = reply->status;
2299         reply->status = 0;
2300
2301         return reply->status;
2302 }
2303
2304 /* CTDB_CONTROL_TUNNEL_REGISTER */
2305
2306 void ctdb_req_control_tunnel_register(struct ctdb_req_control *request,
2307                                       uint64_t tunnel_id)
2308 {
2309         request->opcode = CTDB_CONTROL_TUNNEL_REGISTER;
2310         request->pad = 0;
2311         request->srvid = tunnel_id;
2312         request->client_id = 0;
2313         request->flags = 0;
2314 }
2315
2316 int ctdb_reply_control_tunnel_register(struct ctdb_reply_control *reply)
2317 {
2318         if (reply->rdata.opcode != CTDB_CONTROL_TUNNEL_REGISTER) {
2319                 return EPROTO;
2320         }
2321
2322         return reply->status;
2323 }
2324
2325 /* CTDB_CONTROL_TUNNEL_DEREGISTER */
2326
2327 void ctdb_req_control_tunnel_deregister(struct ctdb_req_control *request,
2328                                         uint64_t tunnel_id)
2329 {
2330         request->opcode = CTDB_CONTROL_TUNNEL_DEREGISTER;
2331         request->pad = 0;
2332         request->srvid = tunnel_id;
2333         request->client_id = 0;
2334         request->flags = 0;
2335 }
2336
2337 int ctdb_reply_control_tunnel_deregister(struct ctdb_reply_control *reply)
2338 {
2339         if (reply->rdata.opcode != CTDB_CONTROL_TUNNEL_DEREGISTER) {
2340                 return EPROTO;
2341         }
2342
2343         return reply->status;
2344 }