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 void ctdb_req_control_get_monmode(struct ctdb_req_control *request)
 724 {
 725         request->opcode = CTDB_CONTROL_GET_MONMODE;
 726         request->pad = 0;
 727         request->srvid = 0;
 728         request->client_id = 0;
 729         request->flags = 0;
 730
 731         request->rdata.opcode = CTDB_CONTROL_GET_MONMODE;
 732 }
 733
 734 int ctdb_reply_control_get_monmode(struct ctdb_reply_control *reply,
 735                                    int *mon_mode)
 736 {
 737         if (reply->rdata.opcode != CTDB_CONTROL_GET_MONMODE) {
 738                 return EPROTO;
 739         }
 740
 741         if (reply->status >= 0) {
 742                 *mon_mode = reply->status;
 743                 reply->status = 0;
 744         }
 745         return reply->status;
 746 }
 747
 748 /* CTDB_CONTROL_TCP_CLIENT */
 749
 750 void ctdb_req_control_tcp_client(struct ctdb_req_control *request,
 751                                  struct ctdb_connection *conn)
 752 {
 753         request->opcode = CTDB_CONTROL_TCP_CLIENT;
 754         request->pad = 0;
 755         request->srvid = 0;
 756         request->client_id = 0;
 757         request->flags = 0;
 758
 759         request->rdata.opcode = CTDB_CONTROL_TCP_CLIENT;
 760         request->rdata.data.conn = conn;
 761 }
 762
 763 int ctdb_reply_control_tcp_client(struct ctdb_reply_control *reply)
 764 {
 765         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_CLIENT);
 766 }
 767
 768 /* CTDB_CONTROL_TCP_ADD */
 769
 770 void ctdb_req_control_tcp_add(struct ctdb_req_control *request,
 771                               struct ctdb_connection *conn)
 772 {
 773         request->opcode = CTDB_CONTROL_TCP_ADD;
 774         request->pad = 0;
 775         request->srvid = 0;
 776         request->client_id = 0;
 777         request->flags = 0;
 778
 779         request->rdata.opcode = CTDB_CONTROL_TCP_ADD;
 780         request->rdata.data.conn = conn;
 781 }
 782
 783 int ctdb_reply_control_tcp_add(struct ctdb_reply_control *reply)
 784 {
 785         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_ADD);
 786 }
 787
 788 /* CTDB_CONTROL_TCP_REMOVE */
 789
 790 void ctdb_req_control_tcp_remove(struct ctdb_req_control *request,
 791                                  struct ctdb_connection *conn)
 792 {
 793         request->opcode = CTDB_CONTROL_TCP_REMOVE;
 794         request->pad = 0;
 795         request->srvid = 0;
 796         request->client_id = 0;
 797         request->flags = 0;
 798
 799         request->rdata.opcode = CTDB_CONTROL_TCP_REMOVE;
 800         request->rdata.data.conn = conn;
 801 }
 802
 803 int ctdb_reply_control_tcp_remove(struct ctdb_reply_control *reply)
 804 {
 805         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TCP_REMOVE);
 806 }
 807
 808 /* CTDB_CONTROL_STARTUP */
 809
 810 void ctdb_req_control_startup(struct ctdb_req_control *request)
 811 {
 812         request->opcode = CTDB_CONTROL_STARTUP;
 813         request->pad = 0;
 814         request->srvid = 0;
 815         request->client_id = 0;
 816         request->flags = 0;
 817
 818         request->rdata.opcode = CTDB_CONTROL_STARTUP;
 819 }
 820
 821 int ctdb_reply_control_startup(struct ctdb_reply_control *reply)
 822 {
 823         return ctdb_reply_control_generic(reply, CTDB_CONTROL_STARTUP);
 824 }
 825
 826 /* CTDB_CONTROL_SET_TUNABLE */
 827
 828 void ctdb_req_control_set_tunable(struct ctdb_req_control *request,
 829                                   struct ctdb_tunable *tunable)
 830 {
 831         request->opcode = CTDB_CONTROL_SET_TUNABLE;
 832         request->pad = 0;
 833         request->srvid = 0;
 834         request->client_id = 0;
 835         request->flags = 0;
 836
 837         request->rdata.opcode = CTDB_CONTROL_SET_TUNABLE;
 838         request->rdata.data.tunable = tunable;
 839 }
 840
 841 int ctdb_reply_control_set_tunable(struct ctdb_reply_control *reply)
 842 {
 843         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_TUNABLE);
 844 }
 845
 846 /* CTDB_CONTROL_GET_TUNABLE */
 847
 848 void ctdb_req_control_get_tunable(struct ctdb_req_control *request,
 849                                   const char *name)
 850 {
 851         request->opcode = CTDB_CONTROL_GET_TUNABLE;
 852         request->pad = 0;
 853         request->srvid = 0;
 854         request->client_id = 0;
 855         request->flags = 0;
 856
 857         request->rdata.opcode = CTDB_CONTROL_GET_TUNABLE;
 858         request->rdata.data.tun_var = discard_const(name);
 859 }
 860
 861 int ctdb_reply_control_get_tunable(struct ctdb_reply_control *reply,
 862                                    uint32_t *value)
 863 {
 864         if (reply->rdata.opcode != CTDB_CONTROL_GET_TUNABLE) {
 865                 return EPROTO;
 866         }
 867
 868         if (reply->status == 0) {
 869                 *value = reply->rdata.data.tun_value;
 870         }
 871         return reply->status;
 872 }
 873
 874 /* CTDB_CONTROL_LIST_TUNABLES */
 875
 876 void ctdb_req_control_list_tunables(struct ctdb_req_control *request)
 877 {
 878         request->opcode = CTDB_CONTROL_LIST_TUNABLES;
 879         request->pad = 0;
 880         request->srvid = 0;
 881         request->client_id = 0;
 882         request->flags = 0;
 883
 884         request->rdata.opcode = CTDB_CONTROL_LIST_TUNABLES;
 885 }
 886
 887 int ctdb_reply_control_list_tunables(struct ctdb_reply_control *reply,
 888                                      TALLOC_CTX *mem_ctx,
 889                                      struct ctdb_var_list **tun_var_list)
 890 {
 891         if (reply->rdata.opcode != CTDB_CONTROL_LIST_TUNABLES) {
 892                 return EPROTO;
 893         }
 894
 895         if (reply->status == 0) {
 896                 *tun_var_list = talloc_steal(mem_ctx,
 897                                              reply->rdata.data.tun_var_list);
 898         }
 899         return reply->status;
 900 }
 901
 902 /* CTDB_CONTROL_MODIFY_FLAGS */
 903
 904 void ctdb_req_control_modify_flags(struct ctdb_req_control *request,
 905                                    struct ctdb_node_flag_change *flag_change)
 906 {
 907         request->opcode = CTDB_CONTROL_MODIFY_FLAGS;
 908         request->pad = 0;
 909         request->srvid = 0;
 910         request->client_id = 0;
 911         request->flags = 0;
 912
 913         request->rdata.opcode = CTDB_CONTROL_MODIFY_FLAGS;
 914         request->rdata.data.flag_change = flag_change;
 915 }
 916
 917 int ctdb_reply_control_modify_flags(struct ctdb_reply_control *reply)
 918 {
 919         return ctdb_reply_control_generic(reply, CTDB_CONTROL_MODIFY_FLAGS);
 920 }
 921
 922 /* CTDB_CONTROL_GET_ALL_TUNABLES */
 923
 924 void ctdb_req_control_get_all_tunables(struct ctdb_req_control *request)
 925 {
 926         request->opcode = CTDB_CONTROL_GET_ALL_TUNABLES;
 927         request->pad = 0;
 928         request->srvid = 0;
 929         request->client_id = 0;
 930         request->flags = 0;
 931
 932         request->rdata.opcode = CTDB_CONTROL_GET_ALL_TUNABLES;
 933 }
 934
 935 int ctdb_reply_control_get_all_tunables(struct ctdb_reply_control *reply,
 936                                         TALLOC_CTX *mem_ctx,
 937                                         struct ctdb_tunable_list **tun_list)
 938 {
 939         if (reply->rdata.opcode != CTDB_CONTROL_GET_ALL_TUNABLES) {
 940                 return EPROTO;
 941         }
 942
 943         if (reply->status == 0) {
 944                 *tun_list = talloc_steal(mem_ctx, reply->rdata.data.tun_list);
 945         }
 946         return reply->status;
 947 }
 948
 949 /* CTDB_CONTROL_GET_TCP_TICKLE_LIST */
 950
 951 void ctdb_req_control_get_tcp_tickle_list(struct ctdb_req_control *request,
 952                                           ctdb_sock_addr *addr)
 953 {
 954         request->opcode = CTDB_CONTROL_GET_TCP_TICKLE_LIST;
 955         request->pad = 0;
 956         request->srvid = 0;
 957         request->client_id = 0;
 958         request->flags = 0;
 959
 960         request->rdata.opcode = CTDB_CONTROL_GET_TCP_TICKLE_LIST;
 961         request->rdata.data.addr = addr;
 962 }
 963
 964 int ctdb_reply_control_get_tcp_tickle_list(struct ctdb_reply_control *reply,
 965                                            TALLOC_CTX *mem_ctx,
 966                                            struct ctdb_tickle_list **tickles)
 967 {
 968         if (reply->rdata.opcode != CTDB_CONTROL_GET_TCP_TICKLE_LIST) {
 969                 return EPROTO;
 970         }
 971
 972         if (reply->status == 0) {
 973                 *tickles = talloc_steal(mem_ctx, reply->rdata.data.tickles);
 974         }
 975         return reply->status;
 976 }
 977
 978 /* CTDB_CONTROL_SET_TCP_TICKLE_LIST */
 979
 980 void ctdb_req_control_set_tcp_tickle_list(struct ctdb_req_control *request,
 981                                           struct ctdb_tickle_list *tickles)
 982 {
 983         request->opcode = CTDB_CONTROL_SET_TCP_TICKLE_LIST;
 984         request->pad = 0;
 985         request->srvid = 0;
 986         request->client_id = 0;
 987         request->flags = 0;
 988
 989         request->rdata.opcode = CTDB_CONTROL_SET_TCP_TICKLE_LIST;
 990         request->rdata.data.tickles = tickles;
 991 }
 992
 993 int ctdb_reply_control_set_tcp_tickle_list(struct ctdb_reply_control *reply)
 994 {
 995         return ctdb_reply_control_generic(reply,
 996                                           CTDB_CONTROL_SET_TCP_TICKLE_LIST);
 997 }
 998
 999 /* CTDB_CONTROL_DB_ATTACH_PERSISTENT */
1000
1001 void ctdb_req_control_db_attach_persistent(struct ctdb_req_control *request,
1002                                            const char *db_name)
1003 {
1004         request->opcode = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
1005         request->pad = 0;
1006         request->srvid = 0;
1007         request->client_id = 0;
1008         request->flags = 0;
1009
1010         request->rdata.opcode = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
1011         request->rdata.data.db_name = db_name;
1012 }
1013
1014 int ctdb_reply_control_db_attach_persistent(struct ctdb_reply_control *reply,
1015                                             uint32_t *db_id)
1016 {
1017         if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH_PERSISTENT) {
1018                 return EPROTO;
1019         }
1020
1021         if (reply->status == 0) {
1022                 *db_id = reply->rdata.data.db_id;
1023         }
1024         return reply->status;
1025 }
1026
1027 /* CTDB_CONTROL_UPDATE_RECORD */
1028
1029 void ctdb_req_control_update_record(struct ctdb_req_control *request,
1030                                     struct ctdb_rec_buffer *recbuf)
1031 {
1032         request->opcode = CTDB_CONTROL_UPDATE_RECORD;
1033         request->pad = 0;
1034         request->srvid = 0;
1035         request->client_id = 0;
1036         request->flags = 0;
1037
1038         request->rdata.opcode = CTDB_CONTROL_UPDATE_RECORD;
1039         request->rdata.data.recbuf = recbuf;
1040 }
1041
1042 int ctdb_reply_control_update_record(struct ctdb_reply_control *reply)
1043 {
1044         return ctdb_reply_control_generic(reply, CTDB_CONTROL_UPDATE_RECORD);
1045 }
1046
1047 /* CTDB_CONTROL_SEND_GRATUITOUS_ARP */
1048
1049 void ctdb_req_control_send_gratuitous_arp(struct ctdb_req_control *request,
1050                                           struct ctdb_addr_info *addr_info)
1051 {
1052         request->opcode = CTDB_CONTROL_SEND_GRATUITOUS_ARP;
1053         request->pad = 0;
1054         request->srvid = 0;
1055         request->client_id = 0;
1056         request->flags = 0;
1057
1058         request->rdata.opcode = CTDB_CONTROL_SEND_GRATUITOUS_ARP;
1059         request->rdata.data.addr_info = addr_info;
1060 }
1061
1062 int ctdb_reply_control_send_gratuitous_arp(struct ctdb_reply_control *reply)
1063 {
1064         return ctdb_reply_control_generic(reply,
1065                                           CTDB_CONTROL_SEND_GRATUITOUS_ARP);
1066 }
1067
1068 /* CTDB_CONTROL_WIPE_DATABASE */
1069
1070 void ctdb_req_control_wipe_database(struct ctdb_req_control *request,
1071                                     struct ctdb_transdb *transdb)
1072 {
1073         request->opcode = CTDB_CONTROL_WIPE_DATABASE;
1074         request->pad = 0;
1075         request->srvid = 0;
1076         request->client_id = 0;
1077         request->flags = 0;
1078
1079         request->rdata.opcode = CTDB_CONTROL_WIPE_DATABASE;
1080         request->rdata.data.transdb = transdb;
1081 }
1082
1083 int ctdb_reply_control_wipe_database(struct ctdb_reply_control *reply)
1084 {
1085         return ctdb_reply_control_generic(reply, CTDB_CONTROL_WIPE_DATABASE);
1086 }
1087
1088 /* CTDB_CONTROL_UPTIME */
1089
1090 void ctdb_req_control_uptime(struct ctdb_req_control *request)
1091 {
1092         request->opcode = CTDB_CONTROL_UPTIME;
1093         request->pad = 0;
1094         request->srvid = 0;
1095         request->client_id = 0;
1096         request->flags = 0;
1097
1098         request->rdata.opcode = CTDB_CONTROL_UPTIME;
1099 }
1100
1101 int ctdb_reply_control_uptime(struct ctdb_reply_control *reply,
1102                               TALLOC_CTX *mem_ctx, struct ctdb_uptime **uptime)
1103 {
1104         if (reply->rdata.opcode != CTDB_CONTROL_UPTIME) {
1105                 return EPROTO;
1106         }
1107
1108         if (reply->status == 0) {
1109                 *uptime = talloc_steal(mem_ctx, reply->rdata.data.uptime);
1110         }
1111         return reply->status;
1112 }
1113
1114 /* CTDB_CONTROL_START_RECOVERY */
1115
1116 void ctdb_req_control_start_recovery(struct ctdb_req_control *request)
1117 {
1118         request->opcode = CTDB_CONTROL_START_RECOVERY;
1119         request->pad = 0;
1120         request->srvid = 0;
1121         request->client_id = 0;
1122         request->flags = 0;
1123
1124         request->rdata.opcode = CTDB_CONTROL_START_RECOVERY;
1125 }
1126
1127 int ctdb_reply_control_start_recovery(struct ctdb_reply_control *reply)
1128 {
1129         return ctdb_reply_control_generic(reply, CTDB_CONTROL_START_RECOVERY);
1130 }
1131
1132 /* CTDB_CONTROL_END_RECOVERY */
1133
1134 void ctdb_req_control_end_recovery(struct ctdb_req_control *request)
1135 {
1136         request->opcode = CTDB_CONTROL_END_RECOVERY;
1137         request->pad = 0;
1138         request->srvid = 0;
1139         request->client_id = 0;
1140         request->flags = 0;
1141
1142         request->rdata.opcode = CTDB_CONTROL_END_RECOVERY;
1143 }
1144
1145 int ctdb_reply_control_end_recovery(struct ctdb_reply_control *reply)
1146 {
1147         return ctdb_reply_control_generic(reply, CTDB_CONTROL_END_RECOVERY);
1148 }
1149
1150 /* CTDB_CONTROL_RELOAD_NODES_FILE */
1151
1152 void ctdb_req_control_reload_nodes_file(struct ctdb_req_control *request)
1153 {
1154         request->opcode = CTDB_CONTROL_RELOAD_NODES_FILE;
1155         request->pad = 0;
1156         request->srvid = 0;
1157         request->client_id = 0;
1158         request->flags = 0;
1159
1160         request->rdata.opcode = CTDB_CONTROL_RELOAD_NODES_FILE;
1161 }
1162
1163 int ctdb_reply_control_reload_nodes_file(struct ctdb_reply_control *reply)
1164 {
1165         return ctdb_reply_control_generic(reply,
1166                                           CTDB_CONTROL_RELOAD_NODES_FILE);
1167 }
1168
1169 /* CTDB_CONTROL_TRY_DELETE_RECORDS */
1170
1171 void ctdb_req_control_try_delete_records(struct ctdb_req_control *request,
1172                                          struct ctdb_rec_buffer *recbuf)
1173 {
1174         request->opcode = CTDB_CONTROL_TRY_DELETE_RECORDS;
1175         request->pad = 0;
1176         request->srvid = 0;
1177         request->client_id = 0;
1178         request->flags = 0;
1179
1180         request->rdata.opcode = CTDB_CONTROL_TRY_DELETE_RECORDS;
1181         request->rdata.data.recbuf = recbuf;
1182 }
1183
1184 int ctdb_reply_control_try_delete_records(struct ctdb_reply_control *reply,
1185                                           TALLOC_CTX *mem_ctx,
1186                                           struct ctdb_rec_buffer **recbuf)
1187 {
1188         if (reply->rdata.opcode != CTDB_CONTROL_TRY_DELETE_RECORDS) {
1189                 return EPROTO;
1190         }
1191
1192         if (reply->status == 0) {
1193                 *recbuf = talloc_steal(mem_ctx, reply->rdata.data.recbuf);
1194         }
1195         return reply->status;
1196 }
1197
1198 /* CTDB_CONTROL_ENABLE_MONITOR */
1199
1200 void ctdb_req_control_enable_monitor(struct ctdb_req_control *request)
1201 {
1202         request->opcode = CTDB_CONTROL_ENABLE_MONITOR;
1203         request->pad = 0;
1204         request->srvid = 0;
1205         request->client_id = 0;
1206         request->flags = 0;
1207
1208         request->rdata.opcode = CTDB_CONTROL_ENABLE_MONITOR;
1209 }
1210
1211 int ctdb_reply_control_enable_monitor(struct ctdb_reply_control *reply)
1212 {
1213         return ctdb_reply_control_generic(reply, CTDB_CONTROL_ENABLE_MONITOR);
1214 }
1215
1216 /* CTDB_CONTROL_DISABLE_MONITOR */
1217
1218 void ctdb_req_control_disable_monitor(struct ctdb_req_control *request)
1219 {
1220         request->opcode = CTDB_CONTROL_DISABLE_MONITOR;
1221         request->pad = 0;
1222         request->srvid = 0;
1223         request->client_id = 0;
1224         request->flags = 0;
1225
1226         request->rdata.opcode = CTDB_CONTROL_DISABLE_MONITOR;
1227 }
1228
1229 int ctdb_reply_control_disable_monitor(struct ctdb_reply_control *reply)
1230 {
1231         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DISABLE_MONITOR);
1232 }
1233
1234 /* CTDB_CONTROL_ADD_PUBLIC_IP */
1235
1236 void ctdb_req_control_add_public_ip(struct ctdb_req_control *request,
1237                                     struct ctdb_addr_info *addr_info)
1238 {
1239         request->opcode = CTDB_CONTROL_ADD_PUBLIC_IP;
1240         request->pad = 0;
1241         request->srvid = 0;
1242         request->client_id = 0;
1243         request->flags = 0;
1244
1245         request->rdata.opcode = CTDB_CONTROL_ADD_PUBLIC_IP;
1246         request->rdata.data.addr_info = addr_info;
1247 }
1248
1249 int ctdb_reply_control_add_public_ip(struct ctdb_reply_control *reply)
1250 {
1251         return ctdb_reply_control_generic(reply, CTDB_CONTROL_ADD_PUBLIC_IP);
1252 }
1253
1254 /* CTDB_CONTROL_DEL_PUBLIC_IP */
1255
1256 void ctdb_req_control_del_public_ip(struct ctdb_req_control *request,
1257                                     struct ctdb_addr_info *addr_info)
1258 {
1259         request->opcode = CTDB_CONTROL_DEL_PUBLIC_IP;
1260         request->pad = 0;
1261         request->srvid = 0;
1262         request->client_id = 0;
1263         request->flags = 0;
1264
1265         request->rdata.opcode = CTDB_CONTROL_DEL_PUBLIC_IP;
1266         request->rdata.data.addr_info = addr_info;
1267 }
1268
1269 int ctdb_reply_control_del_public_ip(struct ctdb_reply_control *reply)
1270 {
1271         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DEL_PUBLIC_IP);
1272 }
1273
1274 /* CTDB_CONTROL_GET_CAPABILITIES */
1275
1276 void ctdb_req_control_get_capabilities(struct ctdb_req_control *request)
1277 {
1278         request->opcode = CTDB_CONTROL_GET_CAPABILITIES;
1279         request->pad = 0;
1280         request->srvid = 0;
1281         request->client_id = 0;
1282         request->flags = 0;
1283
1284         request->rdata.opcode = CTDB_CONTROL_GET_CAPABILITIES;
1285 }
1286
1287 int ctdb_reply_control_get_capabilities(struct ctdb_reply_control *reply,
1288                                         uint32_t *caps)
1289 {
1290         if (reply->rdata.opcode != CTDB_CONTROL_GET_CAPABILITIES) {
1291                 return EPROTO;
1292         }
1293
1294         if (reply->status == 0) {
1295                 *caps = reply->rdata.data.caps;
1296         }
1297         return reply->status;
1298 }
1299
1300 /* CTDB_CONTROL_RECD_PING */
1301
1302 void ctdb_req_control_recd_ping(struct ctdb_req_control *request)
1303 {
1304         request->opcode = CTDB_CONTROL_RECD_PING;
1305         request->pad = 0;
1306         request->srvid = 0;
1307         request->client_id = 0;
1308         request->flags = 0;
1309
1310         request->rdata.opcode = CTDB_CONTROL_RECD_PING;
1311 }
1312
1313 int ctdb_reply_control_recd_ping(struct ctdb_reply_control *reply)
1314 {
1315         return ctdb_reply_control_generic(reply, CTDB_CONTROL_RECD_PING);
1316 }
1317
1318 /* CTDB_CONTROL_RELEASE_IP */
1319
1320 void ctdb_req_control_release_ip(struct ctdb_req_control *request,
1321                                  struct ctdb_public_ip *pubip)
1322 {
1323         request->opcode = CTDB_CONTROL_RELEASE_IP;
1324         request->pad = 0;
1325         request->srvid = 0;
1326         request->client_id = 0;
1327         request->flags = 0;
1328
1329         request->rdata.opcode = CTDB_CONTROL_RELEASE_IP;
1330         request->rdata.data.pubip = pubip;
1331 }
1332
1333 int ctdb_reply_control_release_ip(struct ctdb_reply_control *reply)
1334 {
1335         return ctdb_reply_control_generic(reply, CTDB_CONTROL_RELEASE_IP);
1336 }
1337
1338 /* CTDB_CONTROL_TAKEOVER_IP */
1339
1340 void ctdb_req_control_takeover_ip(struct ctdb_req_control *request,
1341                                   struct ctdb_public_ip *pubip)
1342 {
1343         request->opcode = CTDB_CONTROL_TAKEOVER_IP;
1344         request->pad = 0;
1345         request->srvid = 0;
1346         request->client_id = 0;
1347         request->flags = 0;
1348
1349         request->rdata.opcode = CTDB_CONTROL_TAKEOVER_IP;
1350         request->rdata.data.pubip = pubip;
1351 }
1352
1353 int ctdb_reply_control_takeover_ip(struct ctdb_reply_control *reply)
1354 {
1355         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TAKEOVER_IP);
1356 }
1357
1358 /* CTDB_CONTROL_GET_PUBLIC_IPS */
1359
1360 void ctdb_req_control_get_public_ips(struct ctdb_req_control *request,
1361                                      bool available_only)
1362 {
1363         request->opcode = CTDB_CONTROL_GET_PUBLIC_IPS;
1364         request->pad = 0;
1365         request->srvid = 0;
1366         request->client_id = 0;
1367         request->flags = 0;
1368
1369         request->rdata.opcode = CTDB_CONTROL_GET_PUBLIC_IPS;
1370         if (available_only) {
1371                 request->flags = CTDB_PUBLIC_IP_FLAGS_ONLY_AVAILABLE;
1372         }
1373 }
1374
1375 int ctdb_reply_control_get_public_ips(struct ctdb_reply_control *reply,
1376                                       TALLOC_CTX *mem_ctx,
1377                                       struct ctdb_public_ip_list **pubip_list)
1378 {
1379         if (reply->rdata.opcode != CTDB_CONTROL_GET_PUBLIC_IPS) {
1380                 return EPROTO;
1381         }
1382
1383         if (reply->status == 0) {
1384                 *pubip_list = talloc_steal(mem_ctx,
1385                                            reply->rdata.data.pubip_list);
1386         }
1387         return reply->status;
1388 }
1389
1390 /* CTDB_CONTROL_GET_NODEMAP */
1391
1392 void ctdb_req_control_get_nodemap(struct ctdb_req_control *request)
1393 {
1394         request->opcode = CTDB_CONTROL_GET_NODEMAP;
1395         request->pad = 0;
1396         request->srvid = 0;
1397         request->client_id = 0;
1398         request->flags = 0;
1399
1400         request->rdata.opcode = CTDB_CONTROL_GET_NODEMAP;
1401 }
1402
1403 int ctdb_reply_control_get_nodemap(struct ctdb_reply_control *reply,
1404                                    TALLOC_CTX *mem_ctx,
1405                                    struct ctdb_node_map **nodemap)
1406 {
1407         if (reply->rdata.opcode != CTDB_CONTROL_GET_NODEMAP) {
1408                 return EPROTO;
1409         }
1410
1411         if (reply->status == 0) {
1412                 *nodemap = talloc_steal(mem_ctx, reply->rdata.data.nodemap);
1413         }
1414         return reply->status;
1415 }
1416
1417 /* CTDB_CONTROL_TRAVERSE_KILL */
1418
1419 void ctdb_req_control_traverse_kill(struct ctdb_req_control *request,
1420                                     struct ctdb_traverse_start *traverse)
1421 {
1422         request->opcode = CTDB_CONTROL_TRAVERSE_KILL;
1423         request->pad = 0;
1424         request->srvid = 0;
1425         request->client_id = 0;
1426         request->flags = 0;
1427
1428         request->rdata.opcode = CTDB_CONTROL_TRAVERSE_KILL;
1429         request->rdata.data.traverse_start = traverse;
1430 }
1431
1432 int ctdb_reply_control_traverse_kill(struct ctdb_reply_control *reply)
1433 {
1434         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRAVERSE_KILL);
1435 }
1436
1437 /* CTDB_CONTROL_RECD_RECLOCK_LATENCY */
1438
1439 void ctdb_req_control_recd_reclock_latency(struct ctdb_req_control *request,
1440                                            double reclock_latency)
1441 {
1442         request->opcode = CTDB_CONTROL_RECD_RECLOCK_LATENCY;
1443         request->pad = 0;
1444         request->srvid = 0;
1445         request->client_id = 0;
1446         request->flags = 0;
1447
1448         request->rdata.opcode = CTDB_CONTROL_RECD_RECLOCK_LATENCY;
1449         request->rdata.data.reclock_latency = reclock_latency;
1450 }
1451
1452 int ctdb_reply_control_recd_reclock_latency(struct ctdb_reply_control *reply)
1453 {
1454         return ctdb_reply_control_generic(reply,
1455                                           CTDB_CONTROL_RECD_RECLOCK_LATENCY);
1456 }
1457
1458 /* CTDB_CONTROL_GET_RECLOCK_FILE */
1459
1460 void ctdb_req_control_get_reclock_file(struct ctdb_req_control *request)
1461 {
1462         request->opcode = CTDB_CONTROL_GET_RECLOCK_FILE;
1463         request->pad = 0;
1464         request->srvid = 0;
1465         request->client_id = 0;
1466         request->flags = 0;
1467
1468         request->rdata.opcode = CTDB_CONTROL_GET_RECLOCK_FILE;
1469 }
1470
1471 int ctdb_reply_control_get_reclock_file(struct ctdb_reply_control *reply,
1472                                         TALLOC_CTX *mem_ctx,
1473                                         const char **reclock_file)
1474 {
1475         if (reply->rdata.opcode != CTDB_CONTROL_GET_RECLOCK_FILE) {
1476                 return EPROTO;
1477         }
1478
1479         if (reply->status == 0) {
1480                 *reclock_file = talloc_steal(mem_ctx,
1481                                              reply->rdata.data.reclock_file);
1482         }
1483         return reply->status;
1484 }
1485
1486 /* CTDB_CONTROL_STOP_NODE */
1487
1488 void ctdb_req_control_stop_node(struct ctdb_req_control *request)
1489 {
1490         request->opcode = CTDB_CONTROL_STOP_NODE;
1491         request->pad = 0;
1492         request->srvid = 0;
1493         request->client_id = 0;
1494         request->flags = 0;
1495
1496         request->rdata.opcode = CTDB_CONTROL_STOP_NODE;
1497 }
1498
1499 int ctdb_reply_control_stop_node(struct ctdb_reply_control *reply)
1500 {
1501         return ctdb_reply_control_generic(reply, CTDB_CONTROL_STOP_NODE);
1502 }
1503
1504 /* CTDB_CONTROL_CONTINUE_NODE */
1505
1506 void ctdb_req_control_continue_node(struct ctdb_req_control *request)
1507 {
1508         request->opcode = CTDB_CONTROL_CONTINUE_NODE;
1509         request->pad = 0;
1510         request->srvid = 0;
1511         request->client_id = 0;
1512         request->flags = 0;
1513
1514         request->rdata.opcode = CTDB_CONTROL_CONTINUE_NODE;
1515 }
1516
1517 int ctdb_reply_control_continue_node(struct ctdb_reply_control *reply)
1518 {
1519         return ctdb_reply_control_generic(reply, CTDB_CONTROL_CONTINUE_NODE);
1520 }
1521
1522 /* CTDB_CONTROL_SET_LMASTERROLE */
1523
1524 void ctdb_req_control_set_lmasterrole(struct ctdb_req_control *request,
1525                                       uint32_t lmaster_role)
1526 {
1527         request->opcode = CTDB_CONTROL_SET_LMASTERROLE;
1528         request->pad = 0;
1529         request->srvid = 0;
1530         request->client_id = 0;
1531         request->flags = 0;
1532
1533         request->rdata.opcode = CTDB_CONTROL_SET_LMASTERROLE;
1534         request->rdata.data.role = lmaster_role;
1535 }
1536
1537 int ctdb_reply_control_set_lmasterrole(struct ctdb_reply_control *reply)
1538 {
1539         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_LMASTERROLE);
1540 }
1541
1542 /* CTDB_CONTROL_SET_RECMASTERROLE */
1543
1544 void ctdb_req_control_set_recmasterrole(struct ctdb_req_control *request,
1545                                         uint32_t recmaster_role)
1546 {
1547         request->opcode = CTDB_CONTROL_SET_RECMASTERROLE;
1548         request->pad = 0;
1549         request->srvid = 0;
1550         request->client_id = 0;
1551         request->flags = 0;
1552
1553         request->rdata.opcode = CTDB_CONTROL_SET_RECMASTERROLE;
1554         request->rdata.data.role = recmaster_role;
1555 }
1556
1557 int ctdb_reply_control_set_recmasterrole(struct ctdb_reply_control *reply)
1558 {
1559         return ctdb_reply_control_generic(reply,
1560                                           CTDB_CONTROL_SET_RECMASTERROLE);
1561 }
1562
1563 /* CTDB_CONTROL_SET_BAN_STATE */
1564
1565 void ctdb_req_control_set_ban_state(struct ctdb_req_control *request,
1566                                     struct ctdb_ban_state *ban_state)
1567 {
1568         request->opcode = CTDB_CONTROL_SET_BAN_STATE;
1569         request->pad = 0;
1570         request->srvid = 0;
1571         request->client_id = 0;
1572         request->flags = 0;
1573
1574         request->rdata.opcode = CTDB_CONTROL_SET_BAN_STATE;
1575         request->rdata.data.ban_state = ban_state;
1576 }
1577
1578 int ctdb_reply_control_set_ban_state(struct ctdb_reply_control *reply)
1579 {
1580         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_BAN_STATE);
1581 }
1582
1583 /* CTDB_CONTROL_GET_BAN_STATE */
1584
1585 void ctdb_req_control_get_ban_state(struct ctdb_req_control *request)
1586 {
1587         request->opcode = CTDB_CONTROL_GET_BAN_STATE;
1588         request->pad = 0;
1589         request->srvid = 0;
1590         request->client_id = 0;
1591         request->flags = 0;
1592
1593         request->rdata.opcode = CTDB_CONTROL_GET_BAN_STATE;
1594 }
1595
1596 int ctdb_reply_control_get_ban_state(struct ctdb_reply_control *reply,
1597                                      TALLOC_CTX *mem_ctx,
1598                                      struct ctdb_ban_state **ban_state)
1599 {
1600         if (reply->rdata.opcode != CTDB_CONTROL_GET_BAN_STATE) {
1601                 return EPROTO;
1602         }
1603
1604         if (reply->status == 0) {
1605                 *ban_state = talloc_steal(mem_ctx,
1606                                           reply->rdata.data.ban_state);
1607         }
1608         return reply->status;
1609 }
1610
1611 /* CTDB_CONTROL_REGISTER_NOTIFY */
1612
1613 void ctdb_req_control_register_notify(struct ctdb_req_control *request,
1614                                       struct ctdb_notify_data *notify)
1615 {
1616         request->opcode = CTDB_CONTROL_REGISTER_NOTIFY;
1617         request->pad = 0;
1618         request->srvid = 0;
1619         request->client_id = 0;
1620         request->flags = 0;
1621
1622         request->rdata.opcode = CTDB_CONTROL_REGISTER_NOTIFY;
1623         request->rdata.data.notify = notify;
1624 }
1625
1626 int ctdb_reply_control_register_notify(struct ctdb_reply_control *reply)
1627 {
1628         return ctdb_reply_control_generic(reply, CTDB_CONTROL_REGISTER_NOTIFY);
1629 }
1630
1631 /* CTDB_CONTROL_DEREGISTER_NOTIFY */
1632
1633 void ctdb_req_control_deregister_notify(struct ctdb_req_control *request,
1634                                         uint64_t srvid)
1635 {
1636         request->opcode = CTDB_CONTROL_DEREGISTER_NOTIFY;
1637         request->pad = 0;
1638         request->srvid = 0;
1639         request->client_id = 0;
1640         request->flags = 0;
1641
1642         request->rdata.opcode = CTDB_CONTROL_DEREGISTER_NOTIFY;
1643         request->rdata.data.srvid = srvid;
1644 }
1645
1646 int ctdb_reply_control_deregister_notify(struct ctdb_reply_control *reply)
1647 {
1648         return ctdb_reply_control_generic(reply,
1649                                           CTDB_CONTROL_DEREGISTER_NOTIFY);
1650 }
1651
1652 /* CTDB_CONTROL_TRANS3_COMMIT */
1653
1654 void ctdb_req_control_trans3_commit(struct ctdb_req_control *request,
1655                                     struct ctdb_rec_buffer *recbuf)
1656 {
1657         request->opcode = CTDB_CONTROL_TRANS3_COMMIT;
1658         request->pad = 0;
1659         request->srvid = 0;
1660         request->client_id = 0;
1661         request->flags = 0;
1662
1663         request->rdata.opcode = CTDB_CONTROL_TRANS3_COMMIT;
1664         request->rdata.data.recbuf = recbuf;
1665 }
1666
1667 int ctdb_reply_control_trans3_commit(struct ctdb_reply_control *reply)
1668 {
1669         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRANS3_COMMIT);
1670 }
1671
1672 /* CTDB_CONTROL_GET_DB_SEQNUM */
1673
1674 void ctdb_req_control_get_db_seqnum(struct ctdb_req_control *request,
1675                                     uint32_t db_id)
1676 {
1677         request->opcode = CTDB_CONTROL_GET_DB_SEQNUM;
1678         request->pad = 0;
1679         request->srvid = 0;
1680         request->client_id = 0;
1681         request->flags = 0;
1682
1683         request->rdata.opcode = CTDB_CONTROL_GET_DB_SEQNUM;
1684         request->rdata.data.db_id = db_id;
1685 }
1686
1687 int ctdb_reply_control_get_db_seqnum(struct ctdb_reply_control *reply,
1688                                      uint64_t *seqnum)
1689 {
1690         if (reply->rdata.opcode != CTDB_CONTROL_GET_DB_SEQNUM) {
1691                 return EPROTO;
1692         }
1693
1694         if (reply->status == 0) {
1695                 *seqnum = reply->rdata.data.seqnum;
1696         }
1697         return reply->status;
1698 }
1699
1700 /* CTDB_CONTROL_DB_SET_HEALTHY */
1701
1702 void ctdb_req_control_db_set_healthy(struct ctdb_req_control *request,
1703                                      uint32_t db_id)
1704 {
1705         request->opcode = CTDB_CONTROL_DB_SET_HEALTHY;
1706         request->pad = 0;
1707         request->srvid = 0;
1708         request->client_id = 0;
1709         request->flags = 0;
1710
1711         request->rdata.opcode = CTDB_CONTROL_DB_SET_HEALTHY;
1712         request->rdata.data.db_id = db_id;
1713 }
1714
1715 int ctdb_reply_control_db_set_healthy(struct ctdb_reply_control *reply)
1716 {
1717         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_SET_HEALTHY);
1718 }
1719
1720 /* CTDB_CONTROL_DB_GET_HEALTH */
1721
1722 void ctdb_req_control_db_get_health(struct ctdb_req_control *request,
1723                                     uint32_t db_id)
1724 {
1725         request->opcode = CTDB_CONTROL_DB_GET_HEALTH;
1726         request->pad = 0;
1727         request->srvid = 0;
1728         request->client_id = 0;
1729         request->flags = 0;
1730
1731         request->rdata.opcode = CTDB_CONTROL_DB_GET_HEALTH;
1732         request->rdata.data.db_id = db_id;
1733 }
1734
1735 int ctdb_reply_control_db_get_health(struct ctdb_reply_control *reply,
1736                                      TALLOC_CTX *mem_ctx, const char **reason)
1737 {
1738         if (reply->rdata.opcode != CTDB_CONTROL_DB_GET_HEALTH) {
1739                 return EPROTO;
1740         }
1741
1742         if (reply->status == 0) {
1743                 *reason = talloc_steal(mem_ctx, reply->rdata.data.reason);
1744         }
1745         return reply->status;
1746 }
1747
1748 /* CTDB_CONTROL_GET_PUBLIC_IP_INFO */
1749
1750 void ctdb_req_control_get_public_ip_info(struct ctdb_req_control *request,
1751                                          ctdb_sock_addr *addr)
1752 {
1753         request->opcode = CTDB_CONTROL_GET_PUBLIC_IP_INFO;
1754         request->pad = 0;
1755         request->srvid = 0;
1756         request->client_id = 0;
1757         request->flags = 0;
1758
1759         request->rdata.opcode = CTDB_CONTROL_GET_PUBLIC_IP_INFO;
1760         request->rdata.data.addr = addr;
1761 }
1762
1763 int ctdb_reply_control_get_public_ip_info(struct ctdb_reply_control *reply,
1764                                           TALLOC_CTX *mem_ctx,
1765                                           struct ctdb_public_ip_info **ipinfo)
1766 {
1767         if (reply->rdata.opcode != CTDB_CONTROL_GET_PUBLIC_IP_INFO) {
1768                 return EPROTO;
1769         }
1770
1771         if (reply->status == 0) {
1772                 *ipinfo = talloc_steal(mem_ctx, reply->rdata.data.ipinfo);
1773         }
1774         return reply->status;
1775 }
1776
1777 /* CTDB_CONTROL_GET_IFACES */
1778
1779 void ctdb_req_control_get_ifaces(struct ctdb_req_control *request)
1780 {
1781         request->opcode = CTDB_CONTROL_GET_IFACES;
1782         request->pad = 0;
1783         request->srvid = 0;
1784         request->client_id = 0;
1785         request->flags = 0;
1786
1787         request->rdata.opcode = CTDB_CONTROL_GET_IFACES;
1788 }
1789
1790 int ctdb_reply_control_get_ifaces(struct ctdb_reply_control *reply,
1791                                   TALLOC_CTX *mem_ctx,
1792                                   struct ctdb_iface_list **iface_list)
1793 {
1794         if (reply->rdata.opcode != CTDB_CONTROL_GET_IFACES) {
1795                 return EPROTO;
1796         }
1797
1798         if (reply->status == 0) {
1799                 *iface_list = talloc_steal(mem_ctx,
1800                                            reply->rdata.data.iface_list);
1801         }
1802         return reply->status;
1803 }
1804
1805 /* CTDB_CONTROL_SET_IFACE_LINK_STATE */
1806
1807 void ctdb_req_control_set_iface_link_state(struct ctdb_req_control *request,
1808                                            struct ctdb_iface *iface)
1809 {
1810         request->opcode = CTDB_CONTROL_SET_IFACE_LINK_STATE;
1811         request->pad = 0;
1812         request->srvid = 0;
1813         request->client_id = 0;
1814         request->flags = 0;
1815
1816         request->rdata.opcode = CTDB_CONTROL_SET_IFACE_LINK_STATE;
1817         request->rdata.data.iface = iface;
1818 }
1819
1820 int ctdb_reply_control_set_iface_link_state(struct ctdb_reply_control *reply)
1821 {
1822         return ctdb_reply_control_generic(reply,
1823                                           CTDB_CONTROL_SET_IFACE_LINK_STATE);
1824 }
1825
1826 /* CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE */
1827
1828 void ctdb_req_control_tcp_add_delayed_update(struct ctdb_req_control *request,
1829                                              struct ctdb_connection *conn)
1830 {
1831         request->opcode = CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE;
1832         request->pad = 0;
1833         request->srvid = 0;
1834         request->client_id = 0;
1835         request->flags = 0;
1836
1837         request->rdata.opcode = CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE;
1838         request->rdata.data.conn = conn;
1839 }
1840
1841 int ctdb_reply_control_tcp_add_delayed_update(struct ctdb_reply_control *reply)
1842 {
1843         return ctdb_reply_control_generic(reply,
1844                                           CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE);
1845 }
1846
1847 /* CTDB_CONTROL_GET_STAT_HISTORY */
1848
1849 void ctdb_req_control_get_stat_history(struct ctdb_req_control *request)
1850 {
1851         request->opcode = CTDB_CONTROL_GET_STAT_HISTORY;
1852         request->pad = 0;
1853         request->srvid = 0;
1854         request->client_id = 0;
1855         request->flags = 0;
1856
1857         request->rdata.opcode = CTDB_CONTROL_GET_STAT_HISTORY;
1858 }
1859
1860 int ctdb_reply_control_get_stat_history(struct ctdb_reply_control *reply,
1861                                         TALLOC_CTX *mem_ctx,
1862                                         struct ctdb_statistics_list **stats_list)
1863 {
1864         if (reply->rdata.opcode != CTDB_CONTROL_GET_STAT_HISTORY) {
1865                 return EPROTO;
1866         }
1867
1868         if (reply->status == 0) {
1869                 *stats_list = talloc_steal(mem_ctx,
1870                                            reply->rdata.data.stats_list);
1871         }
1872         return reply->status;
1873 }
1874
1875 /* CTDB_CONTROL_SCHEDULE_FOR_DELETION */
1876
1877 void ctdb_req_control_schedule_for_deletion(struct ctdb_req_control *request,
1878                                             struct ctdb_key_data *key)
1879 {
1880         request->opcode = CTDB_CONTROL_SCHEDULE_FOR_DELETION;
1881         request->pad = 0;
1882         request->srvid = 0;
1883         request->client_id = 0;
1884         request->flags = 0;
1885
1886         request->rdata.opcode = CTDB_CONTROL_SCHEDULE_FOR_DELETION;
1887         request->rdata.data.key = key;
1888 }
1889
1890 int ctdb_reply_control_schedule_for_deletion(struct ctdb_reply_control *reply)
1891 {
1892         return ctdb_reply_control_generic(reply,
1893                                           CTDB_CONTROL_SCHEDULE_FOR_DELETION);
1894 }
1895
1896 /* CTDB_CONTROL_SET_DB_READONLY */
1897
1898 void ctdb_req_control_set_db_readonly(struct ctdb_req_control *request,
1899                                       uint32_t db_id)
1900 {
1901         request->opcode = CTDB_CONTROL_SET_DB_READONLY;
1902         request->pad = 0;
1903         request->srvid = 0;
1904         request->client_id = 0;
1905         request->flags = 0;
1906
1907         request->rdata.opcode = CTDB_CONTROL_SET_DB_READONLY;
1908         request->rdata.data.db_id = db_id;
1909 }
1910
1911 int ctdb_reply_control_set_db_readonly(struct ctdb_reply_control *reply)
1912 {
1913         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DB_READONLY);
1914 }
1915
1916 /* CTDB_CONTROL_CHECK_SRVIDS */
1917
1918 /* CTDB_CONTROL_TRAVERSE_START_EXT */
1919
1920 void ctdb_req_control_traverse_start_ext(struct ctdb_req_control *request,
1921                                          struct ctdb_traverse_start_ext *traverse)
1922 {
1923         request->opcode = CTDB_CONTROL_TRAVERSE_START_EXT;
1924         request->pad = 0;
1925         request->srvid = 0;
1926         request->client_id = 0;
1927         request->flags = 0;
1928
1929         request->rdata.opcode = CTDB_CONTROL_TRAVERSE_START_EXT;
1930         request->rdata.data.traverse_start_ext = traverse;
1931 }
1932
1933 int ctdb_reply_control_traverse_start_ext(struct ctdb_reply_control *reply)
1934 {
1935         return ctdb_reply_control_generic(reply,
1936                                           CTDB_CONTROL_TRAVERSE_START_EXT);
1937 }
1938
1939 /* CTDB_CONTROL_GET_DB_STATISTICS */
1940
1941 void ctdb_req_control_get_db_statistics(struct ctdb_req_control *request,
1942                                         uint32_t db_id)
1943 {
1944         request->opcode = CTDB_CONTROL_GET_DB_STATISTICS;
1945         request->pad = 0;
1946         request->srvid = 0;
1947         request->client_id = 0;
1948         request->flags = 0;
1949
1950         request->rdata.opcode = CTDB_CONTROL_GET_DB_STATISTICS;
1951         request->rdata.data.db_id = db_id;
1952 }
1953
1954 int ctdb_reply_control_get_db_statistics(struct ctdb_reply_control *reply,
1955                                          TALLOC_CTX *mem_ctx,
1956                                          struct ctdb_db_statistics **dbstats)
1957 {
1958         if (reply->rdata.opcode != CTDB_CONTROL_GET_DB_STATISTICS) {
1959                 return EPROTO;
1960         }
1961
1962         if (reply->status == 0) {
1963                 *dbstats = talloc_steal(mem_ctx, reply->rdata.data.dbstats);
1964         }
1965         return reply->status;
1966 }
1967
1968 /* CTDB_CONTROL_SET_DB_STICKY */
1969
1970 void ctdb_req_control_set_db_sticky(struct ctdb_req_control *request,
1971                                     uint32_t db_id)
1972 {
1973         request->opcode = CTDB_CONTROL_SET_DB_STICKY;
1974         request->pad = 0;
1975         request->srvid = 0;
1976         request->client_id = 0;
1977         request->flags = 0;
1978
1979         request->rdata.opcode = CTDB_CONTROL_SET_DB_STICKY;
1980         request->rdata.data.db_id = db_id;
1981 }
1982
1983 int ctdb_reply_control_set_db_sticky(struct ctdb_reply_control *reply)
1984 {
1985         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DB_STICKY);
1986 }
1987
1988 /* CTDB_CONTROL_RELOAD_PUBLIC_IPS */
1989
1990 void ctdb_req_control_reload_public_ips(struct ctdb_req_control *request)
1991 {
1992         request->opcode = CTDB_CONTROL_RELOAD_PUBLIC_IPS;
1993         request->pad = 0;
1994         request->srvid = 0;
1995         request->client_id = 0;
1996         request->flags = 0;
1997
1998         request->rdata.opcode = CTDB_CONTROL_RELOAD_PUBLIC_IPS;
1999 }
2000
2001 int ctdb_reply_control_reload_public_ips(struct ctdb_reply_control *reply)
2002 {
2003         return ctdb_reply_control_generic(reply,
2004                                           CTDB_CONTROL_RELOAD_PUBLIC_IPS);
2005 }
2006
2007 /* CTDB_CONTROL_TRAVERSE_ALL_EXT */
2008
2009 /* CTDB_CONTROL_RECEIVE_RECORDS */
2010
2011 void ctdb_req_control_receive_records(struct ctdb_req_control *request,
2012                                       struct ctdb_rec_buffer *recbuf)
2013 {
2014         request->opcode = CTDB_CONTROL_RECEIVE_RECORDS;
2015         request->pad = 0;
2016         request->srvid = 0;
2017         request->client_id = 0;
2018         request->flags = 0;
2019
2020         request->rdata.opcode = CTDB_CONTROL_RECEIVE_RECORDS;
2021         request->rdata.data.recbuf = recbuf;
2022 }
2023
2024 int ctdb_reply_control_receive_records(struct ctdb_reply_control *reply,
2025                                        TALLOC_CTX *mem_ctx,
2026                                        struct ctdb_rec_buffer **recbuf)
2027 {
2028         if (reply->rdata.opcode != CTDB_CONTROL_RECEIVE_RECORDS) {
2029                 return EPROTO;
2030         }
2031
2032         if (reply->status == 0) {
2033                 *recbuf = talloc_steal(mem_ctx, reply->rdata.data.recbuf);
2034         }
2035         return reply->status;
2036 }
2037
2038 /* CTDB_CONTROL_IPREALLOCATED */
2039
2040 void ctdb_req_control_ipreallocated(struct ctdb_req_control *request)
2041 {
2042         request->opcode = CTDB_CONTROL_IPREALLOCATED;
2043         request->pad = 0;
2044         request->srvid = 0;
2045         request->client_id = 0;
2046         request->flags = 0;
2047
2048         request->rdata.opcode = CTDB_CONTROL_IPREALLOCATED;
2049 }
2050
2051 int ctdb_reply_control_ipreallocated(struct ctdb_reply_control *reply)
2052 {
2053         return ctdb_reply_control_generic(reply, CTDB_CONTROL_IPREALLOCATED);
2054 }
2055
2056 /* CTDB_CONTROL_GET_RUNSTATE */
2057
2058 void ctdb_req_control_get_runstate(struct ctdb_req_control *request)
2059 {
2060         request->opcode = CTDB_CONTROL_GET_RUNSTATE;
2061         request->pad = 0;
2062         request->srvid = 0;
2063         request->client_id = 0;
2064         request->flags = 0;
2065
2066         request->rdata.opcode = CTDB_CONTROL_GET_RUNSTATE;
2067 }
2068
2069 int ctdb_reply_control_get_runstate(struct ctdb_reply_control *reply,
2070                                     enum ctdb_runstate *runstate)
2071 {
2072         if (reply->rdata.opcode != CTDB_CONTROL_GET_RUNSTATE) {
2073                 return EPROTO;
2074         }
2075
2076         if (reply->status == 0) {
2077                 *runstate = reply->rdata.data.runstate;
2078         }
2079         return reply->status;
2080 }
2081
2082 /* CTDB_CONTROL_DB_DETACH */
2083
2084 void ctdb_req_control_db_detach(struct ctdb_req_control *request,
2085                                 uint32_t db_id)
2086 {
2087         request->opcode = CTDB_CONTROL_DB_DETACH;
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_DETACH;
2094         request->rdata.data.db_id = db_id;
2095 }
2096
2097 int ctdb_reply_control_db_detach(struct ctdb_reply_control *reply)
2098 {
2099         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_DETACH);
2100 }
2101
2102 /* CTDB_CONTROL_GET_NODES_FILE */
2103
2104 void ctdb_req_control_get_nodes_file(struct ctdb_req_control *request)
2105 {
2106         request->opcode = CTDB_CONTROL_GET_NODES_FILE;
2107         request->pad = 0;
2108         request->srvid = 0;
2109         request->client_id = 0;
2110         request->flags = 0;
2111
2112         request->rdata.opcode = CTDB_CONTROL_GET_NODES_FILE;
2113 }
2114
2115 int ctdb_reply_control_get_nodes_file(struct ctdb_reply_control *reply,
2116                                       TALLOC_CTX *mem_ctx,
2117                                       struct ctdb_node_map **nodemap)
2118 {
2119         if (reply->rdata.opcode != CTDB_CONTROL_GET_NODES_FILE) {
2120                 return EPROTO;
2121         }
2122
2123         if (reply->status == 0) {
2124                 *nodemap = talloc_steal(mem_ctx, reply->rdata.data.nodemap);
2125         }
2126         return reply->status;
2127 }
2128
2129 /* CTDB_CONTROL_DB_FREEZE */
2130
2131 void ctdb_req_control_db_freeze(struct ctdb_req_control *request,
2132                                 uint32_t db_id)
2133 {
2134         request->opcode = CTDB_CONTROL_DB_FREEZE;
2135         request->pad = 0;
2136         request->srvid = 0;
2137         request->client_id = 0;
2138         request->flags = 0;
2139
2140         request->rdata.opcode = CTDB_CONTROL_DB_FREEZE;
2141         request->rdata.data.db_id = db_id;
2142 }
2143
2144 int ctdb_reply_control_db_freeze(struct ctdb_reply_control *reply)
2145 {
2146         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_FREEZE);
2147 }
2148
2149 /* CTDB_CONTROL_DB_THAW */
2150
2151 void ctdb_req_control_db_thaw(struct ctdb_req_control *request,
2152                               uint32_t db_id)
2153 {
2154         request->opcode = CTDB_CONTROL_DB_THAW;
2155         request->pad = 0;
2156         request->srvid = 0;
2157         request->client_id = 0;
2158         request->flags = 0;
2159
2160         request->rdata.opcode = CTDB_CONTROL_DB_THAW;
2161         request->rdata.data.db_id = db_id;
2162 }
2163
2164 int ctdb_reply_control_db_thaw(struct ctdb_reply_control *reply)
2165 {
2166         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_THAW);
2167 }
2168
2169 /* CTDB_CONTROL_DB_TRANSACTION_START */
2170
2171 void ctdb_req_control_db_transaction_start(struct ctdb_req_control *request,
2172                                            struct ctdb_transdb *transdb)
2173 {
2174         request->opcode = CTDB_CONTROL_DB_TRANSACTION_START;
2175         request->pad = 0;
2176         request->srvid = 0;
2177         request->client_id = 0;
2178         request->flags = 0;
2179
2180         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_START;
2181         request->rdata.data.transdb = transdb;
2182 }
2183
2184 int ctdb_reply_control_db_transaction_start(struct ctdb_reply_control *reply)
2185 {
2186         return ctdb_reply_control_generic(reply,
2187                                           CTDB_CONTROL_DB_TRANSACTION_START);
2188 }
2189
2190 /* CTDB_CONTROL_DB_TRANSACTION_COMMIT */
2191
2192 void ctdb_req_control_db_transaction_commit(struct ctdb_req_control *request,
2193                                             struct ctdb_transdb *transdb)
2194 {
2195         request->opcode = CTDB_CONTROL_DB_TRANSACTION_COMMIT;
2196         request->pad = 0;
2197         request->srvid = 0;
2198         request->client_id = 0;
2199         request->flags = 0;
2200
2201         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_COMMIT;
2202         request->rdata.data.transdb = transdb;
2203 }
2204
2205 int ctdb_reply_control_db_transaction_commit(struct ctdb_reply_control *reply)
2206 {
2207         return ctdb_reply_control_generic(reply,
2208                                           CTDB_CONTROL_DB_TRANSACTION_COMMIT);
2209 }
2210
2211 /* CTDB_CONTROL_DB_TRANSACTION_CANCEL */
2212
2213 void ctdb_req_control_db_transaction_cancel(struct ctdb_req_control *request,
2214                                             uint32_t db_id)
2215 {
2216         request->opcode = CTDB_CONTROL_DB_TRANSACTION_CANCEL;
2217         request->pad = 0;
2218         request->srvid = 0;
2219         request->client_id = 0;
2220         request->flags = 0;
2221
2222         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_CANCEL;
2223         request->rdata.data.db_id = db_id;
2224 }
2225
2226 int ctdb_reply_control_db_transaction_cancel(struct ctdb_reply_control *reply)
2227 {
2228         return ctdb_reply_control_generic(reply,
2229                                           CTDB_CONTROL_DB_TRANSACTION_CANCEL);
2230 }
2231
2232 /* CTDB_CONTROL_DB_PULL */
2233
2234 void ctdb_req_control_db_pull(struct ctdb_req_control *request,
2235                               struct ctdb_pulldb_ext *pulldb_ext)
2236 {
2237         request->opcode = CTDB_CONTROL_DB_PULL;
2238         request->pad = 0;
2239         request->srvid = 0;
2240         request->client_id = 0;
2241         request->flags = 0;
2242
2243         request->rdata.opcode = CTDB_CONTROL_DB_PULL;
2244         request->rdata.data.pulldb_ext = pulldb_ext;
2245 }
2246
2247 int ctdb_reply_control_db_pull(struct ctdb_reply_control *reply,
2248                                uint32_t *num_records)
2249 {
2250         if (reply->rdata.opcode != CTDB_CONTROL_DB_PULL) {
2251                 return EPROTO;
2252         }
2253
2254         if (reply->status == 0) {
2255                 *num_records = reply->rdata.data.num_records;
2256         }
2257         return reply->status;
2258 }
2259
2260 /* CTDB_CONTROL_DB_PUSH_START */
2261
2262 void ctdb_req_control_db_push_start(struct ctdb_req_control *request,
2263                                     struct ctdb_pulldb_ext *pulldb_ext)
2264 {
2265         request->opcode = CTDB_CONTROL_DB_PUSH_START;
2266         request->pad = 0;
2267         request->srvid = 0;
2268         request->client_id = 0;
2269         request->flags = 0;
2270
2271         request->rdata.opcode = CTDB_CONTROL_DB_PUSH_START;
2272         request->rdata.data.pulldb_ext = pulldb_ext;
2273 }
2274
2275 int ctdb_reply_control_db_push_start(struct ctdb_reply_control *reply)
2276 {
2277         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_PUSH_START);
2278 }
2279
2280 /* CTDB_CONTROL_DB_PUSH_CONFIRM */
2281
2282 void ctdb_req_control_db_push_confirm(struct ctdb_req_control *request,
2283                                       uint32_t db_id)
2284 {
2285         request->opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
2286         request->pad = 0;
2287         request->srvid = 0;
2288         request->client_id = 0;
2289         request->flags = 0;
2290
2291         request->rdata.opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
2292         request->rdata.data.db_id = db_id;
2293 }
2294
2295 int ctdb_reply_control_db_push_confirm(struct ctdb_reply_control *reply,
2296                                        uint32_t *num_records)
2297 {
2298         if (reply->rdata.opcode != CTDB_CONTROL_DB_PUSH_CONFIRM) {
2299                 return EPROTO;
2300         }
2301
2302         if (reply->status == 0) {
2303                 *num_records = reply->rdata.data.num_records;
2304         }
2305         return reply->status;
2306 }
2307
2308 /* CTDB_CONTROL_DB_OPEN_FLAGS */
2309
2310 void ctdb_req_control_db_open_flags(struct ctdb_req_control *request,
2311                                     uint32_t db_id)
2312 {
2313         request->opcode = CTDB_CONTROL_DB_OPEN_FLAGS;
2314         request->pad = 0;
2315         request->srvid = 0;
2316         request->client_id = 0;
2317         request->flags = 0;
2318
2319         request->rdata.opcode = CTDB_CONTROL_DB_OPEN_FLAGS;
2320         request->rdata.data.db_id = db_id;
2321 }
2322
2323 int ctdb_reply_control_db_open_flags(struct ctdb_reply_control *reply,
2324                                      int *tdb_flags)
2325 {
2326         if (reply->rdata.opcode != CTDB_CONTROL_DB_OPEN_FLAGS) {
2327                 return EPROTO;
2328         }
2329
2330         if (reply->status == 0) {
2331                 *tdb_flags = reply->rdata.data.tdb_flags;
2332         }
2333         return reply->status;
2334 }
2335
2336 /* CTDB_CONTROL_DB_ATTACH_REPLICATED */
2337
2338 void ctdb_req_control_db_attach_replicated(struct ctdb_req_control *request,
2339                                            const char *db_name)
2340 {
2341         request->opcode = CTDB_CONTROL_DB_ATTACH_REPLICATED;
2342         request->pad = 0;
2343         request->srvid = 0;
2344         request->client_id = 0;
2345         request->flags = 0;
2346
2347         request->rdata.opcode = CTDB_CONTROL_DB_ATTACH_REPLICATED;
2348         request->rdata.data.db_name = db_name;
2349 }
2350
2351 int ctdb_reply_control_db_attach_replicated(struct ctdb_reply_control *reply,
2352                                             uint32_t *db_id)
2353 {
2354         if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH_REPLICATED) {
2355                 return EPROTO;
2356         }
2357         if (reply->status == 0) {
2358                 *db_id = reply->rdata.data.db_id;
2359         }
2360         return reply->status;
2361 }