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                                  uint32_t *loglevel)
 226 {
 227         if (reply->rdata.opcode != CTDB_CONTROL_GET_DEBUG) {
 228                 return EPROTO;
 229         }
 230
 231         if (reply->status == 0) {
 232                 *loglevel = 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                                 uint32_t 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 = 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, uint32_t tdb_flags)
 403 {
 404         request->opcode = CTDB_CONTROL_DB_ATTACH;
 405         request->pad = 0;
 406         request->srvid = tdb_flags;
 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                                            uint32_t tdb_flags)
1004 {
1005         request->opcode = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
1006         request->pad = 0;
1007         request->srvid = tdb_flags;
1008         request->client_id = 0;
1009         request->flags = 0;
1010
1011         request->rdata.opcode = CTDB_CONTROL_DB_ATTACH_PERSISTENT;
1012         request->rdata.data.db_name = db_name;
1013 }
1014
1015 int ctdb_reply_control_db_attach_persistent(struct ctdb_reply_control *reply,
1016                                             uint32_t *db_id)
1017 {
1018         if (reply->rdata.opcode != CTDB_CONTROL_DB_ATTACH_PERSISTENT) {
1019                 return EPROTO;
1020         }
1021
1022         if (reply->status == 0) {
1023                 *db_id = reply->rdata.data.db_id;
1024         }
1025         return reply->status;
1026 }
1027
1028 /* CTDB_CONTROL_UPDATE_RECORD */
1029
1030 void ctdb_req_control_update_record(struct ctdb_req_control *request,
1031                                     struct ctdb_rec_buffer *recbuf)
1032 {
1033         request->opcode = CTDB_CONTROL_UPDATE_RECORD;
1034         request->pad = 0;
1035         request->srvid = 0;
1036         request->client_id = 0;
1037         request->flags = 0;
1038
1039         request->rdata.opcode = CTDB_CONTROL_UPDATE_RECORD;
1040         request->rdata.data.recbuf = recbuf;
1041 }
1042
1043 int ctdb_reply_control_update_record(struct ctdb_reply_control *reply)
1044 {
1045         return ctdb_reply_control_generic(reply, CTDB_CONTROL_UPDATE_RECORD);
1046 }
1047
1048 /* CTDB_CONTROL_SEND_GRATUITOUS_ARP */
1049
1050 void ctdb_req_control_send_gratuitous_arp(struct ctdb_req_control *request,
1051                                           struct ctdb_addr_info *addr_info)
1052 {
1053         request->opcode = CTDB_CONTROL_SEND_GRATUITOUS_ARP;
1054         request->pad = 0;
1055         request->srvid = 0;
1056         request->client_id = 0;
1057         request->flags = 0;
1058
1059         request->rdata.opcode = CTDB_CONTROL_SEND_GRATUITOUS_ARP;
1060         request->rdata.data.addr_info = addr_info;
1061 }
1062
1063 int ctdb_reply_control_send_gratuitous_arp(struct ctdb_reply_control *reply)
1064 {
1065         return ctdb_reply_control_generic(reply,
1066                                           CTDB_CONTROL_SEND_GRATUITOUS_ARP);
1067 }
1068
1069 /* CTDB_CONTROL_TRANSACTION_START */
1070
1071 void ctdb_req_control_transaction_start(struct ctdb_req_control *request,
1072                                         uint32_t tid)
1073 {
1074         request->opcode = CTDB_CONTROL_TRANSACTION_START;
1075         request->pad = 0;
1076         request->srvid = 0;
1077         request->client_id = 0;
1078         request->flags = 0;
1079
1080         request->rdata.opcode = CTDB_CONTROL_TRANSACTION_START;
1081         request->rdata.data.tid = tid;
1082 }
1083
1084 int ctdb_reply_control_transaction_start(struct ctdb_reply_control *reply)
1085 {
1086         return ctdb_reply_control_generic(reply,
1087                                           CTDB_CONTROL_TRANSACTION_START);
1088 }
1089
1090 /* CTDB_CONTROL_TRANSACTION_COMMIT */
1091
1092 void ctdb_req_control_transaction_commit(struct ctdb_req_control *request,
1093                                          uint32_t tid)
1094 {
1095         request->opcode = CTDB_CONTROL_TRANSACTION_COMMIT;
1096         request->pad = 0;
1097         request->srvid = 0;
1098         request->client_id = 0;
1099         request->flags = 0;
1100
1101         request->rdata.opcode = CTDB_CONTROL_TRANSACTION_COMMIT;
1102         request->rdata.data.tid = tid;
1103 }
1104
1105 int ctdb_reply_control_transaction_commit(struct ctdb_reply_control *reply)
1106 {
1107         return ctdb_reply_control_generic(reply,
1108                                           CTDB_CONTROL_TRANSACTION_COMMIT);
1109 }
1110
1111 /* CTDB_CONTROL_WIPE_DATABASE */
1112
1113 void ctdb_req_control_wipe_database(struct ctdb_req_control *request,
1114                                     struct ctdb_transdb *transdb)
1115 {
1116         request->opcode = CTDB_CONTROL_WIPE_DATABASE;
1117         request->pad = 0;
1118         request->srvid = 0;
1119         request->client_id = 0;
1120         request->flags = 0;
1121
1122         request->rdata.opcode = CTDB_CONTROL_WIPE_DATABASE;
1123         request->rdata.data.transdb = transdb;
1124 }
1125
1126 int ctdb_reply_control_wipe_database(struct ctdb_reply_control *reply)
1127 {
1128         return ctdb_reply_control_generic(reply, CTDB_CONTROL_WIPE_DATABASE);
1129 }
1130
1131 /* CTDB_CONTROL_UPTIME */
1132
1133 void ctdb_req_control_uptime(struct ctdb_req_control *request)
1134 {
1135         request->opcode = CTDB_CONTROL_UPTIME;
1136         request->pad = 0;
1137         request->srvid = 0;
1138         request->client_id = 0;
1139         request->flags = 0;
1140
1141         request->rdata.opcode = CTDB_CONTROL_UPTIME;
1142 }
1143
1144 int ctdb_reply_control_uptime(struct ctdb_reply_control *reply,
1145                               TALLOC_CTX *mem_ctx, struct ctdb_uptime **uptime)
1146 {
1147         if (reply->rdata.opcode != CTDB_CONTROL_UPTIME) {
1148                 return EPROTO;
1149         }
1150
1151         if (reply->status == 0) {
1152                 *uptime = talloc_steal(mem_ctx, reply->rdata.data.uptime);
1153         }
1154         return reply->status;
1155 }
1156
1157 /* CTDB_CONTROL_START_RECOVERY */
1158
1159 void ctdb_req_control_start_recovery(struct ctdb_req_control *request)
1160 {
1161         request->opcode = CTDB_CONTROL_START_RECOVERY;
1162         request->pad = 0;
1163         request->srvid = 0;
1164         request->client_id = 0;
1165         request->flags = 0;
1166
1167         request->rdata.opcode = CTDB_CONTROL_START_RECOVERY;
1168 }
1169
1170 int ctdb_reply_control_start_recovery(struct ctdb_reply_control *reply)
1171 {
1172         return ctdb_reply_control_generic(reply, CTDB_CONTROL_START_RECOVERY);
1173 }
1174
1175 /* CTDB_CONTROL_END_RECOVERY */
1176
1177 void ctdb_req_control_end_recovery(struct ctdb_req_control *request)
1178 {
1179         request->opcode = CTDB_CONTROL_END_RECOVERY;
1180         request->pad = 0;
1181         request->srvid = 0;
1182         request->client_id = 0;
1183         request->flags = 0;
1184
1185         request->rdata.opcode = CTDB_CONTROL_END_RECOVERY;
1186 }
1187
1188 int ctdb_reply_control_end_recovery(struct ctdb_reply_control *reply)
1189 {
1190         return ctdb_reply_control_generic(reply, CTDB_CONTROL_END_RECOVERY);
1191 }
1192
1193 /* CTDB_CONTROL_RELOAD_NODES_FILE */
1194
1195 void ctdb_req_control_reload_nodes_file(struct ctdb_req_control *request)
1196 {
1197         request->opcode = CTDB_CONTROL_RELOAD_NODES_FILE;
1198         request->pad = 0;
1199         request->srvid = 0;
1200         request->client_id = 0;
1201         request->flags = 0;
1202
1203         request->rdata.opcode = CTDB_CONTROL_RELOAD_NODES_FILE;
1204 }
1205
1206 int ctdb_reply_control_reload_nodes_file(struct ctdb_reply_control *reply)
1207 {
1208         return ctdb_reply_control_generic(reply,
1209                                           CTDB_CONTROL_RELOAD_NODES_FILE);
1210 }
1211
1212 /* CTDB_CONTROL_TRY_DELETE_RECORDS */
1213
1214 void ctdb_req_control_try_delete_records(struct ctdb_req_control *request,
1215                                          struct ctdb_rec_buffer *recbuf)
1216 {
1217         request->opcode = CTDB_CONTROL_TRY_DELETE_RECORDS;
1218         request->pad = 0;
1219         request->srvid = 0;
1220         request->client_id = 0;
1221         request->flags = 0;
1222
1223         request->rdata.opcode = CTDB_CONTROL_TRY_DELETE_RECORDS;
1224         request->rdata.data.recbuf = recbuf;
1225 }
1226
1227 int ctdb_reply_control_try_delete_records(struct ctdb_reply_control *reply,
1228                                           TALLOC_CTX *mem_ctx,
1229                                           struct ctdb_rec_buffer **recbuf)
1230 {
1231         if (reply->rdata.opcode != CTDB_CONTROL_TRY_DELETE_RECORDS) {
1232                 return EPROTO;
1233         }
1234
1235         if (reply->status == 0) {
1236                 *recbuf = talloc_steal(mem_ctx, reply->rdata.data.recbuf);
1237         }
1238         return reply->status;
1239 }
1240
1241 /* CTDB_CONTROL_ENABLE_MONITOR */
1242
1243 void ctdb_req_control_enable_monitor(struct ctdb_req_control *request)
1244 {
1245         request->opcode = CTDB_CONTROL_ENABLE_MONITOR;
1246         request->pad = 0;
1247         request->srvid = 0;
1248         request->client_id = 0;
1249         request->flags = 0;
1250
1251         request->rdata.opcode = CTDB_CONTROL_ENABLE_MONITOR;
1252 }
1253
1254 int ctdb_reply_control_enable_monitor(struct ctdb_reply_control *reply)
1255 {
1256         return ctdb_reply_control_generic(reply, CTDB_CONTROL_ENABLE_MONITOR);
1257 }
1258
1259 /* CTDB_CONTROL_DISABLE_MONITOR */
1260
1261 void ctdb_req_control_disable_monitor(struct ctdb_req_control *request)
1262 {
1263         request->opcode = CTDB_CONTROL_DISABLE_MONITOR;
1264         request->pad = 0;
1265         request->srvid = 0;
1266         request->client_id = 0;
1267         request->flags = 0;
1268
1269         request->rdata.opcode = CTDB_CONTROL_DISABLE_MONITOR;
1270 }
1271
1272 int ctdb_reply_control_disable_monitor(struct ctdb_reply_control *reply)
1273 {
1274         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DISABLE_MONITOR);
1275 }
1276
1277 /* CTDB_CONTROL_ADD_PUBLIC_IP */
1278
1279 void ctdb_req_control_add_public_ip(struct ctdb_req_control *request,
1280                                     struct ctdb_addr_info *addr_info)
1281 {
1282         request->opcode = CTDB_CONTROL_ADD_PUBLIC_IP;
1283         request->pad = 0;
1284         request->srvid = 0;
1285         request->client_id = 0;
1286         request->flags = 0;
1287
1288         request->rdata.opcode = CTDB_CONTROL_ADD_PUBLIC_IP;
1289         request->rdata.data.addr_info = addr_info;
1290 }
1291
1292 int ctdb_reply_control_add_public_ip(struct ctdb_reply_control *reply)
1293 {
1294         return ctdb_reply_control_generic(reply, CTDB_CONTROL_ADD_PUBLIC_IP);
1295 }
1296
1297 /* CTDB_CONTROL_DEL_PUBLIC_IP */
1298
1299 void ctdb_req_control_del_public_ip(struct ctdb_req_control *request,
1300                                     struct ctdb_addr_info *addr_info)
1301 {
1302         request->opcode = CTDB_CONTROL_DEL_PUBLIC_IP;
1303         request->pad = 0;
1304         request->srvid = 0;
1305         request->client_id = 0;
1306         request->flags = 0;
1307
1308         request->rdata.opcode = CTDB_CONTROL_DEL_PUBLIC_IP;
1309         request->rdata.data.addr_info = addr_info;
1310 }
1311
1312 int ctdb_reply_control_del_public_ip(struct ctdb_reply_control *reply)
1313 {
1314         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DEL_PUBLIC_IP);
1315 }
1316
1317 /* CTDB_CONTROL_RUN_EVENTSCRIPTS */
1318
1319 void ctdb_req_control_run_eventscripts(struct ctdb_req_control *request,
1320                                        const char *event_str)
1321 {
1322         request->opcode = CTDB_CONTROL_RUN_EVENTSCRIPTS;
1323         request->pad = 0;
1324         request->srvid = 0;
1325         request->client_id = 0;
1326         request->flags = 0;
1327
1328         request->rdata.opcode = CTDB_CONTROL_RUN_EVENTSCRIPTS;
1329         request->rdata.data.event_str = event_str;
1330 }
1331
1332 int ctdb_reply_control_run_eventscripts(struct ctdb_reply_control *reply)
1333 {
1334         return ctdb_reply_control_generic(reply,
1335                                           CTDB_CONTROL_RUN_EVENTSCRIPTS);
1336 }
1337
1338 /* CTDB_CONTROL_GET_CAPABILITIES */
1339
1340 void ctdb_req_control_get_capabilities(struct ctdb_req_control *request)
1341 {
1342         request->opcode = CTDB_CONTROL_GET_CAPABILITIES;
1343         request->pad = 0;
1344         request->srvid = 0;
1345         request->client_id = 0;
1346         request->flags = 0;
1347
1348         request->rdata.opcode = CTDB_CONTROL_GET_CAPABILITIES;
1349 }
1350
1351 int ctdb_reply_control_get_capabilities(struct ctdb_reply_control *reply,
1352                                         uint32_t *caps)
1353 {
1354         if (reply->rdata.opcode != CTDB_CONTROL_GET_CAPABILITIES) {
1355                 return EPROTO;
1356         }
1357
1358         if (reply->status == 0) {
1359                 *caps = reply->rdata.data.caps;
1360         }
1361         return reply->status;
1362 }
1363
1364 /* CTDB_CONTROL_RECD_PING */
1365
1366 void ctdb_req_control_recd_ping(struct ctdb_req_control *request)
1367 {
1368         request->opcode = CTDB_CONTROL_RECD_PING;
1369         request->pad = 0;
1370         request->srvid = 0;
1371         request->client_id = 0;
1372         request->flags = 0;
1373
1374         request->rdata.opcode = CTDB_CONTROL_RECD_PING;
1375 }
1376
1377 int ctdb_reply_control_recd_ping(struct ctdb_reply_control *reply)
1378 {
1379         return ctdb_reply_control_generic(reply, CTDB_CONTROL_RECD_PING);
1380 }
1381
1382 /* CTDB_CONTROL_RELEASE_IP */
1383
1384 void ctdb_req_control_release_ip(struct ctdb_req_control *request,
1385                                  struct ctdb_public_ip *pubip)
1386 {
1387         request->opcode = CTDB_CONTROL_RELEASE_IP;
1388         request->pad = 0;
1389         request->srvid = 0;
1390         request->client_id = 0;
1391         request->flags = 0;
1392
1393         request->rdata.opcode = CTDB_CONTROL_RELEASE_IP;
1394         request->rdata.data.pubip = pubip;
1395 }
1396
1397 int ctdb_reply_control_release_ip(struct ctdb_reply_control *reply)
1398 {
1399         return ctdb_reply_control_generic(reply, CTDB_CONTROL_RELEASE_IP);
1400 }
1401
1402 /* CTDB_CONTROL_TAKEOVER_IP */
1403
1404 void ctdb_req_control_takeover_ip(struct ctdb_req_control *request,
1405                                   struct ctdb_public_ip *pubip)
1406 {
1407         request->opcode = CTDB_CONTROL_TAKEOVER_IP;
1408         request->pad = 0;
1409         request->srvid = 0;
1410         request->client_id = 0;
1411         request->flags = 0;
1412
1413         request->rdata.opcode = CTDB_CONTROL_TAKEOVER_IP;
1414         request->rdata.data.pubip = pubip;
1415 }
1416
1417 int ctdb_reply_control_takeover_ip(struct ctdb_reply_control *reply)
1418 {
1419         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TAKEOVER_IP);
1420 }
1421
1422 /* CTDB_CONTROL_GET_PUBLIC_IPS */
1423
1424 void ctdb_req_control_get_public_ips(struct ctdb_req_control *request)
1425 {
1426         request->opcode = CTDB_CONTROL_GET_PUBLIC_IPS;
1427         request->pad = 0;
1428         request->srvid = 0;
1429         request->client_id = 0;
1430         request->flags = 0;
1431
1432         request->rdata.opcode = CTDB_CONTROL_GET_PUBLIC_IPS;
1433 }
1434
1435 int ctdb_reply_control_get_public_ips(struct ctdb_reply_control *reply,
1436                                       TALLOC_CTX *mem_ctx,
1437                                       struct ctdb_public_ip_list **pubip_list)
1438 {
1439         if (reply->rdata.opcode != CTDB_CONTROL_GET_PUBLIC_IPS) {
1440                 return EPROTO;
1441         }
1442
1443         if (reply->status == 0) {
1444                 *pubip_list = talloc_steal(mem_ctx,
1445                                            reply->rdata.data.pubip_list);
1446         }
1447         return reply->status;
1448 }
1449
1450 /* CTDB_CONTROL_GET_NODEMAP */
1451
1452 void ctdb_req_control_get_nodemap(struct ctdb_req_control *request)
1453 {
1454         request->opcode = CTDB_CONTROL_GET_NODEMAP;
1455         request->pad = 0;
1456         request->srvid = 0;
1457         request->client_id = 0;
1458         request->flags = 0;
1459
1460         request->rdata.opcode = CTDB_CONTROL_GET_NODEMAP;
1461 }
1462
1463 int ctdb_reply_control_get_nodemap(struct ctdb_reply_control *reply,
1464                                    TALLOC_CTX *mem_ctx,
1465                                    struct ctdb_node_map **nodemap)
1466 {
1467         if (reply->rdata.opcode != CTDB_CONTROL_GET_NODEMAP) {
1468                 return EPROTO;
1469         }
1470
1471         if (reply->status == 0) {
1472                 *nodemap = talloc_steal(mem_ctx, reply->rdata.data.nodemap);
1473         }
1474         return reply->status;
1475 }
1476
1477 /* CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS */
1478
1479 void ctdb_req_control_get_event_script_status(struct ctdb_req_control *request,
1480                                               uint32_t event)
1481 {
1482         request->opcode = CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS;
1483         request->pad = 0;
1484         request->srvid = 0;
1485         request->client_id = 0;
1486         request->flags = 0;
1487
1488         request->rdata.opcode = CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS;
1489         request->rdata.data.event = event;
1490 }
1491
1492 int ctdb_reply_control_get_event_script_status(struct ctdb_reply_control *reply,
1493                                                TALLOC_CTX *mem_ctx,
1494                                                struct ctdb_script_list **slist)
1495 {
1496         if (reply->rdata.opcode != CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS) {
1497                 return EPROTO;
1498         }
1499
1500         if (reply->status == 0) {
1501                 *slist = talloc_steal(mem_ctx, reply->rdata.data.script_list);
1502         }
1503         return reply->status;
1504 }
1505
1506 /* CTDB_CONTROL_TRAVERSE_KILL */
1507
1508 void ctdb_req_control_traverse_kill(struct ctdb_req_control *request,
1509                                     struct ctdb_traverse_start *traverse)
1510 {
1511         request->opcode = CTDB_CONTROL_TRAVERSE_KILL;
1512         request->pad = 0;
1513         request->srvid = 0;
1514         request->client_id = 0;
1515         request->flags = 0;
1516
1517         request->rdata.opcode = CTDB_CONTROL_TRAVERSE_KILL;
1518         request->rdata.data.traverse_start = traverse;
1519 }
1520
1521 int ctdb_reply_control_traverse_kill(struct ctdb_reply_control *reply)
1522 {
1523         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRAVERSE_KILL);
1524 }
1525
1526 /* CTDB_CONTROL_RECD_RECLOCK_LATENCY */
1527
1528 void ctdb_req_control_recd_reclock_latency(struct ctdb_req_control *request,
1529                                            double reclock_latency)
1530 {
1531         request->opcode = CTDB_CONTROL_RECD_RECLOCK_LATENCY;
1532         request->pad = 0;
1533         request->srvid = 0;
1534         request->client_id = 0;
1535         request->flags = 0;
1536
1537         request->rdata.opcode = CTDB_CONTROL_RECD_RECLOCK_LATENCY;
1538         request->rdata.data.reclock_latency = reclock_latency;
1539 }
1540
1541 int ctdb_reply_control_recd_reclock_latency(struct ctdb_reply_control *reply)
1542 {
1543         return ctdb_reply_control_generic(reply,
1544                                           CTDB_CONTROL_RECD_RECLOCK_LATENCY);
1545 }
1546
1547 /* CTDB_CONTROL_GET_RECLOCK_FILE */
1548
1549 void ctdb_req_control_get_reclock_file(struct ctdb_req_control *request)
1550 {
1551         request->opcode = CTDB_CONTROL_GET_RECLOCK_FILE;
1552         request->pad = 0;
1553         request->srvid = 0;
1554         request->client_id = 0;
1555         request->flags = 0;
1556
1557         request->rdata.opcode = CTDB_CONTROL_GET_RECLOCK_FILE;
1558 }
1559
1560 int ctdb_reply_control_get_reclock_file(struct ctdb_reply_control *reply,
1561                                         TALLOC_CTX *mem_ctx,
1562                                         const char **reclock_file)
1563 {
1564         if (reply->rdata.opcode != CTDB_CONTROL_GET_RECLOCK_FILE) {
1565                 return EPROTO;
1566         }
1567
1568         if (reply->status == 0) {
1569                 *reclock_file = talloc_steal(mem_ctx,
1570                                              reply->rdata.data.reclock_file);
1571         }
1572         return reply->status;
1573 }
1574
1575 /* CTDB_CONTROL_STOP_NODE */
1576
1577 void ctdb_req_control_stop_node(struct ctdb_req_control *request)
1578 {
1579         request->opcode = CTDB_CONTROL_STOP_NODE;
1580         request->pad = 0;
1581         request->srvid = 0;
1582         request->client_id = 0;
1583         request->flags = 0;
1584
1585         request->rdata.opcode = CTDB_CONTROL_STOP_NODE;
1586 }
1587
1588 int ctdb_reply_control_stop_node(struct ctdb_reply_control *reply)
1589 {
1590         return ctdb_reply_control_generic(reply, CTDB_CONTROL_STOP_NODE);
1591 }
1592
1593 /* CTDB_CONTROL_CONTINUE_NODE */
1594
1595 void ctdb_req_control_continue_node(struct ctdb_req_control *request)
1596 {
1597         request->opcode = CTDB_CONTROL_CONTINUE_NODE;
1598         request->pad = 0;
1599         request->srvid = 0;
1600         request->client_id = 0;
1601         request->flags = 0;
1602
1603         request->rdata.opcode = CTDB_CONTROL_CONTINUE_NODE;
1604 }
1605
1606 int ctdb_reply_control_continue_node(struct ctdb_reply_control *reply)
1607 {
1608         return ctdb_reply_control_generic(reply, CTDB_CONTROL_CONTINUE_NODE);
1609 }
1610
1611 /* CTDB_CONTROL_SET_LMASTERROLE */
1612
1613 void ctdb_req_control_set_lmasterrole(struct ctdb_req_control *request,
1614                                       uint32_t lmaster_role)
1615 {
1616         request->opcode = CTDB_CONTROL_SET_LMASTERROLE;
1617         request->pad = 0;
1618         request->srvid = 0;
1619         request->client_id = 0;
1620         request->flags = 0;
1621
1622         request->rdata.opcode = CTDB_CONTROL_SET_LMASTERROLE;
1623         request->rdata.data.role = lmaster_role;
1624 }
1625
1626 int ctdb_reply_control_set_lmasterrole(struct ctdb_reply_control *reply)
1627 {
1628         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_LMASTERROLE);
1629 }
1630
1631 /* CTDB_CONTROL_SET_RECMASTERROLE */
1632
1633 void ctdb_req_control_set_recmasterrole(struct ctdb_req_control *request,
1634                                         uint32_t recmaster_role)
1635 {
1636         request->opcode = CTDB_CONTROL_SET_RECMASTERROLE;
1637         request->pad = 0;
1638         request->srvid = 0;
1639         request->client_id = 0;
1640         request->flags = 0;
1641
1642         request->rdata.opcode = CTDB_CONTROL_SET_RECMASTERROLE;
1643         request->rdata.data.role = recmaster_role;
1644 }
1645
1646 int ctdb_reply_control_set_recmasterrole(struct ctdb_reply_control *reply)
1647 {
1648         return ctdb_reply_control_generic(reply,
1649                                           CTDB_CONTROL_SET_RECMASTERROLE);
1650 }
1651
1652 /* CTDB_CONTROL_ENABLE_SCRIPT */
1653
1654 void ctdb_req_control_enable_script(struct ctdb_req_control *request,
1655                                     const char *script)
1656 {
1657         request->opcode = CTDB_CONTROL_ENABLE_SCRIPT;
1658         request->pad = 0;
1659         request->srvid = 0;
1660         request->client_id = 0;
1661         request->flags = 0;
1662
1663         request->rdata.opcode = CTDB_CONTROL_ENABLE_SCRIPT;
1664         request->rdata.data.script = script;
1665 }
1666
1667 int ctdb_reply_control_enable_script(struct ctdb_reply_control *reply)
1668 {
1669         return ctdb_reply_control_generic(reply, CTDB_CONTROL_ENABLE_SCRIPT);
1670 }
1671
1672 /* CTDB_CONTROL_DISABLE_SCRIPT */
1673
1674 void ctdb_req_control_disable_script(struct ctdb_req_control *request,
1675                                      const char *script)
1676 {
1677         request->opcode = CTDB_CONTROL_DISABLE_SCRIPT;
1678         request->pad = 0;
1679         request->srvid = 0;
1680         request->client_id = 0;
1681         request->flags = 0;
1682
1683         request->rdata.opcode = CTDB_CONTROL_DISABLE_SCRIPT;
1684         request->rdata.data.script = script;
1685 }
1686
1687 int ctdb_reply_control_disable_script(struct ctdb_reply_control *reply)
1688 {
1689         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DISABLE_SCRIPT);
1690 }
1691
1692 /* CTDB_CONTROL_SET_BAN_STATE */
1693
1694 void ctdb_req_control_set_ban_state(struct ctdb_req_control *request,
1695                                     struct ctdb_ban_state *ban_state)
1696 {
1697         request->opcode = CTDB_CONTROL_SET_BAN_STATE;
1698         request->pad = 0;
1699         request->srvid = 0;
1700         request->client_id = 0;
1701         request->flags = 0;
1702
1703         request->rdata.opcode = CTDB_CONTROL_SET_BAN_STATE;
1704         request->rdata.data.ban_state = ban_state;
1705 }
1706
1707 int ctdb_reply_control_set_ban_state(struct ctdb_reply_control *reply)
1708 {
1709         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_BAN_STATE);
1710 }
1711
1712 /* CTDB_CONTROL_GET_BAN_STATE */
1713
1714 void ctdb_req_control_get_ban_state(struct ctdb_req_control *request)
1715 {
1716         request->opcode = CTDB_CONTROL_GET_BAN_STATE;
1717         request->pad = 0;
1718         request->srvid = 0;
1719         request->client_id = 0;
1720         request->flags = 0;
1721
1722         request->rdata.opcode = CTDB_CONTROL_GET_BAN_STATE;
1723 }
1724
1725 int ctdb_reply_control_get_ban_state(struct ctdb_reply_control *reply,
1726                                      TALLOC_CTX *mem_ctx,
1727                                      struct ctdb_ban_state **ban_state)
1728 {
1729         if (reply->rdata.opcode != CTDB_CONTROL_GET_BAN_STATE) {
1730                 return EPROTO;
1731         }
1732
1733         if (reply->status == 0) {
1734                 *ban_state = talloc_steal(mem_ctx,
1735                                           reply->rdata.data.ban_state);
1736         }
1737         return reply->status;
1738 }
1739
1740 /* CTDB_CONTROL_TRANSACTION_CANCEL */
1741
1742 void ctdb_req_control_transaction_cancel(struct ctdb_req_control *request,
1743                                          uint32_t tid)
1744 {
1745         request->opcode = CTDB_CONTROL_TRANSACTION_CANCEL;
1746         request->pad = 0;
1747         request->srvid = 0;
1748         request->client_id = 0;
1749         request->flags = 0;
1750
1751         request->rdata.opcode = CTDB_CONTROL_TRANSACTION_CANCEL;
1752         request->rdata.data.tid = tid;
1753 }
1754
1755 int ctdb_reply_control_transaction_cancel(struct ctdb_reply_control *reply)
1756 {
1757         return ctdb_reply_control_generic(reply,
1758                                           CTDB_CONTROL_TRANSACTION_CANCEL);
1759 }
1760
1761 /* CTDB_CONTROL_REGISTER_NOTIFY */
1762
1763 void ctdb_req_control_register_notify(struct ctdb_req_control *request,
1764                                       struct ctdb_notify_data *notify)
1765 {
1766         request->opcode = CTDB_CONTROL_REGISTER_NOTIFY;
1767         request->pad = 0;
1768         request->srvid = 0;
1769         request->client_id = 0;
1770         request->flags = 0;
1771
1772         request->rdata.opcode = CTDB_CONTROL_REGISTER_NOTIFY;
1773         request->rdata.data.notify = notify;
1774 }
1775
1776 int ctdb_reply_control_register_notify(struct ctdb_reply_control *reply)
1777 {
1778         return ctdb_reply_control_generic(reply, CTDB_CONTROL_REGISTER_NOTIFY);
1779 }
1780
1781 /* CTDB_CONTROL_DEREGISTER_NOTIFY */
1782
1783 void ctdb_req_control_deregister_notify(struct ctdb_req_control *request,
1784                                         uint64_t srvid)
1785 {
1786         request->opcode = CTDB_CONTROL_DEREGISTER_NOTIFY;
1787         request->pad = 0;
1788         request->srvid = 0;
1789         request->client_id = 0;
1790         request->flags = 0;
1791
1792         request->rdata.opcode = CTDB_CONTROL_DEREGISTER_NOTIFY;
1793         request->rdata.data.srvid = srvid;
1794 }
1795
1796 int ctdb_reply_control_deregister_notify(struct ctdb_reply_control *reply)
1797 {
1798         return ctdb_reply_control_generic(reply,
1799                                           CTDB_CONTROL_DEREGISTER_NOTIFY);
1800 }
1801
1802 /* CTDB_CONTROL_TRANS3_COMMIT */
1803
1804 void ctdb_req_control_trans3_commit(struct ctdb_req_control *request,
1805                                     struct ctdb_rec_buffer *recbuf)
1806 {
1807         request->opcode = CTDB_CONTROL_TRANS3_COMMIT;
1808         request->pad = 0;
1809         request->srvid = 0;
1810         request->client_id = 0;
1811         request->flags = 0;
1812
1813         request->rdata.opcode = CTDB_CONTROL_TRANS3_COMMIT;
1814         request->rdata.data.recbuf = recbuf;
1815 }
1816
1817 int ctdb_reply_control_trans3_commit(struct ctdb_reply_control *reply)
1818 {
1819         return ctdb_reply_control_generic(reply, CTDB_CONTROL_TRANS3_COMMIT);
1820 }
1821
1822 /* CTDB_CONTROL_GET_DB_SEQNUM */
1823
1824 void ctdb_req_control_get_db_seqnum(struct ctdb_req_control *request,
1825                                     uint32_t db_id)
1826 {
1827         request->opcode = CTDB_CONTROL_GET_DB_SEQNUM;
1828         request->pad = 0;
1829         request->srvid = 0;
1830         request->client_id = 0;
1831         request->flags = 0;
1832
1833         request->rdata.opcode = CTDB_CONTROL_GET_DB_SEQNUM;
1834         request->rdata.data.db_id = db_id;
1835 }
1836
1837 int ctdb_reply_control_get_db_seqnum(struct ctdb_reply_control *reply,
1838                                      uint64_t *seqnum)
1839 {
1840         if (reply->rdata.opcode != CTDB_CONTROL_GET_DB_SEQNUM) {
1841                 return EPROTO;
1842         }
1843
1844         if (reply->status == 0) {
1845                 *seqnum = reply->rdata.data.seqnum;
1846         }
1847         return reply->status;
1848 }
1849
1850 /* CTDB_CONTROL_DB_SET_HEALTHY */
1851
1852 void ctdb_req_control_db_set_healthy(struct ctdb_req_control *request,
1853                                      uint32_t db_id)
1854 {
1855         request->opcode = CTDB_CONTROL_DB_SET_HEALTHY;
1856         request->pad = 0;
1857         request->srvid = 0;
1858         request->client_id = 0;
1859         request->flags = 0;
1860
1861         request->rdata.opcode = CTDB_CONTROL_DB_SET_HEALTHY;
1862         request->rdata.data.db_id = db_id;
1863 }
1864
1865 int ctdb_reply_control_db_set_healthy(struct ctdb_reply_control *reply)
1866 {
1867         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_SET_HEALTHY);
1868 }
1869
1870 /* CTDB_CONTROL_DB_GET_HEALTH */
1871
1872 void ctdb_req_control_db_get_health(struct ctdb_req_control *request,
1873                                     uint32_t db_id)
1874 {
1875         request->opcode = CTDB_CONTROL_DB_GET_HEALTH;
1876         request->pad = 0;
1877         request->srvid = 0;
1878         request->client_id = 0;
1879         request->flags = 0;
1880
1881         request->rdata.opcode = CTDB_CONTROL_DB_GET_HEALTH;
1882         request->rdata.data.db_id = db_id;
1883 }
1884
1885 int ctdb_reply_control_db_get_health(struct ctdb_reply_control *reply,
1886                                      TALLOC_CTX *mem_ctx, const char **reason)
1887 {
1888         if (reply->rdata.opcode != CTDB_CONTROL_DB_GET_HEALTH) {
1889                 return EPROTO;
1890         }
1891
1892         if (reply->status == 0) {
1893                 *reason = talloc_steal(mem_ctx, reply->rdata.data.reason);
1894         }
1895         return reply->status;
1896 }
1897
1898 /* CTDB_CONTROL_GET_PUBLIC_IP_INFO */
1899
1900 void ctdb_req_control_get_public_ip_info(struct ctdb_req_control *request,
1901                                          ctdb_sock_addr *addr)
1902 {
1903         request->opcode = CTDB_CONTROL_GET_PUBLIC_IP_INFO;
1904         request->pad = 0;
1905         request->srvid = 0;
1906         request->client_id = 0;
1907         request->flags = 0;
1908
1909         request->rdata.opcode = CTDB_CONTROL_GET_PUBLIC_IP_INFO;
1910         request->rdata.data.addr = addr;
1911 }
1912
1913 int ctdb_reply_control_get_public_ip_info(struct ctdb_reply_control *reply,
1914                                           TALLOC_CTX *mem_ctx,
1915                                           struct ctdb_public_ip_info **ipinfo)
1916 {
1917         if (reply->rdata.opcode != CTDB_CONTROL_GET_PUBLIC_IP_INFO) {
1918                 return EPROTO;
1919         }
1920
1921         if (reply->status == 0) {
1922                 *ipinfo = talloc_steal(mem_ctx, reply->rdata.data.ipinfo);
1923         }
1924         return reply->status;
1925 }
1926
1927 /* CTDB_CONTROL_GET_IFACES */
1928
1929 void ctdb_req_control_get_ifaces(struct ctdb_req_control *request)
1930 {
1931         request->opcode = CTDB_CONTROL_GET_IFACES;
1932         request->pad = 0;
1933         request->srvid = 0;
1934         request->client_id = 0;
1935         request->flags = 0;
1936
1937         request->rdata.opcode = CTDB_CONTROL_GET_IFACES;
1938 }
1939
1940 int ctdb_reply_control_get_ifaces(struct ctdb_reply_control *reply,
1941                                   TALLOC_CTX *mem_ctx,
1942                                   struct ctdb_iface_list **iface_list)
1943 {
1944         if (reply->rdata.opcode != CTDB_CONTROL_GET_IFACES) {
1945                 return EPROTO;
1946         }
1947
1948         if (reply->status == 0) {
1949                 *iface_list = talloc_steal(mem_ctx,
1950                                            reply->rdata.data.iface_list);
1951         }
1952         return reply->status;
1953 }
1954
1955 /* CTDB_CONTROL_SET_IFACE_LINK_STATE */
1956
1957 void ctdb_req_control_set_iface_link_state(struct ctdb_req_control *request,
1958                                            struct ctdb_iface *iface)
1959 {
1960         request->opcode = CTDB_CONTROL_SET_IFACE_LINK_STATE;
1961         request->pad = 0;
1962         request->srvid = 0;
1963         request->client_id = 0;
1964         request->flags = 0;
1965
1966         request->rdata.opcode = CTDB_CONTROL_SET_IFACE_LINK_STATE;
1967         request->rdata.data.iface = iface;
1968 }
1969
1970 int ctdb_reply_control_set_iface_link_state(struct ctdb_reply_control *reply)
1971 {
1972         return ctdb_reply_control_generic(reply,
1973                                           CTDB_CONTROL_SET_IFACE_LINK_STATE);
1974 }
1975
1976 /* CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE */
1977
1978 void ctdb_req_control_tcp_add_delayed_update(struct ctdb_req_control *request,
1979                                              struct ctdb_connection *conn)
1980 {
1981         request->opcode = CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE;
1982         request->pad = 0;
1983         request->srvid = 0;
1984         request->client_id = 0;
1985         request->flags = 0;
1986
1987         request->rdata.opcode = CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE;
1988         request->rdata.data.conn = conn;
1989 }
1990
1991 int ctdb_reply_control_tcp_add_delayed_update(struct ctdb_reply_control *reply)
1992 {
1993         return ctdb_reply_control_generic(reply,
1994                                           CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE);
1995 }
1996
1997 /* CTDB_CONTROL_GET_STAT_HISTORY */
1998
1999 void ctdb_req_control_get_stat_history(struct ctdb_req_control *request)
2000 {
2001         request->opcode = CTDB_CONTROL_GET_STAT_HISTORY;
2002         request->pad = 0;
2003         request->srvid = 0;
2004         request->client_id = 0;
2005         request->flags = 0;
2006
2007         request->rdata.opcode = CTDB_CONTROL_GET_STAT_HISTORY;
2008 }
2009
2010 int ctdb_reply_control_get_stat_history(struct ctdb_reply_control *reply,
2011                                         TALLOC_CTX *mem_ctx,
2012                                         struct ctdb_statistics_list **stats_list)
2013 {
2014         if (reply->rdata.opcode != CTDB_CONTROL_GET_STAT_HISTORY) {
2015                 return EPROTO;
2016         }
2017
2018         if (reply->status == 0) {
2019                 *stats_list = talloc_steal(mem_ctx,
2020                                            reply->rdata.data.stats_list);
2021         }
2022         return reply->status;
2023 }
2024
2025 /* CTDB_CONTROL_SCHEDULE_FOR_DELETION */
2026
2027 void ctdb_req_control_schedule_for_deletion(struct ctdb_req_control *request,
2028                                             struct ctdb_key_data *key)
2029 {
2030         request->opcode = CTDB_CONTROL_SCHEDULE_FOR_DELETION;
2031         request->pad = 0;
2032         request->srvid = 0;
2033         request->client_id = 0;
2034         request->flags = 0;
2035
2036         request->rdata.opcode = CTDB_CONTROL_SCHEDULE_FOR_DELETION;
2037         request->rdata.data.key = key;
2038 }
2039
2040 int ctdb_reply_control_schedule_for_deletion(struct ctdb_reply_control *reply)
2041 {
2042         return ctdb_reply_control_generic(reply,
2043                                           CTDB_CONTROL_SCHEDULE_FOR_DELETION);
2044 }
2045
2046 /* CTDB_CONTROL_SET_DB_READONLY */
2047
2048 void ctdb_req_control_set_db_readonly(struct ctdb_req_control *request,
2049                                       uint32_t db_id)
2050 {
2051         request->opcode = CTDB_CONTROL_SET_DB_READONLY;
2052         request->pad = 0;
2053         request->srvid = 0;
2054         request->client_id = 0;
2055         request->flags = 0;
2056
2057         request->rdata.opcode = CTDB_CONTROL_SET_DB_READONLY;
2058         request->rdata.data.db_id = db_id;
2059 }
2060
2061 int ctdb_reply_control_set_db_readonly(struct ctdb_reply_control *reply)
2062 {
2063         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DB_READONLY);
2064 }
2065
2066 /* CTDB_CONTROL_CHECK_SRVIDS */
2067
2068 void ctdb_req_control_check_srvids(struct ctdb_req_control *request,
2069                                    struct ctdb_uint64_array *u64_array)
2070 {
2071         request->opcode = CTDB_CONTROL_CHECK_SRVIDS;
2072         request->pad = 0;
2073         request->srvid = 0;
2074         request->client_id = 0;
2075         request->flags = 0;
2076
2077         request->rdata.opcode = CTDB_CONTROL_CHECK_SRVIDS;
2078         request->rdata.data.u64_array = u64_array;
2079 }
2080
2081 int ctdb_reply_control_check_srvids(struct ctdb_reply_control *reply,
2082                                     TALLOC_CTX *mem_ctx,
2083                                     struct ctdb_uint8_array **u8_array)
2084 {
2085         if (reply->rdata.opcode != CTDB_CONTROL_CHECK_SRVIDS) {
2086                 return EPROTO;
2087         }
2088
2089         if (reply->status == 0) {
2090                 *u8_array = talloc_steal(mem_ctx, reply->rdata.data.u8_array);
2091         }
2092         return reply->status;
2093 }
2094
2095 /* CTDB_CONTROL_TRAVERSE_START_EXT */
2096
2097 void ctdb_req_control_traverse_start_ext(struct ctdb_req_control *request,
2098                                          struct ctdb_traverse_start_ext *traverse)
2099 {
2100         request->opcode = CTDB_CONTROL_TRAVERSE_START_EXT;
2101         request->pad = 0;
2102         request->srvid = 0;
2103         request->client_id = 0;
2104         request->flags = 0;
2105
2106         request->rdata.opcode = CTDB_CONTROL_TRAVERSE_START_EXT;
2107         request->rdata.data.traverse_start_ext = traverse;
2108 }
2109
2110 int ctdb_reply_control_traverse_start_ext(struct ctdb_reply_control *reply)
2111 {
2112         return ctdb_reply_control_generic(reply,
2113                                           CTDB_CONTROL_TRAVERSE_START_EXT);
2114 }
2115
2116 /* CTDB_CONTROL_GET_DB_STATISTICS */
2117
2118 void ctdb_req_control_get_db_statistics(struct ctdb_req_control *request,
2119                                         uint32_t db_id)
2120 {
2121         request->opcode = CTDB_CONTROL_GET_DB_STATISTICS;
2122         request->pad = 0;
2123         request->srvid = 0;
2124         request->client_id = 0;
2125         request->flags = 0;
2126
2127         request->rdata.opcode = CTDB_CONTROL_GET_DB_STATISTICS;
2128         request->rdata.data.db_id = db_id;
2129 }
2130
2131 int ctdb_reply_control_get_db_statistics(struct ctdb_reply_control *reply,
2132                                          TALLOC_CTX *mem_ctx,
2133                                          struct ctdb_db_statistics **dbstats)
2134 {
2135         if (reply->rdata.opcode != CTDB_CONTROL_GET_DB_STATISTICS) {
2136                 return EPROTO;
2137         }
2138
2139         if (reply->status == 0) {
2140                 *dbstats = talloc_steal(mem_ctx, reply->rdata.data.dbstats);
2141         }
2142         return reply->status;
2143 }
2144
2145 /* CTDB_CONTROL_SET_DB_STICKY */
2146
2147 void ctdb_req_control_set_db_sticky(struct ctdb_req_control *request,
2148                                     uint32_t db_id)
2149 {
2150         request->opcode = CTDB_CONTROL_SET_DB_STICKY;
2151         request->pad = 0;
2152         request->srvid = 0;
2153         request->client_id = 0;
2154         request->flags = 0;
2155
2156         request->rdata.opcode = CTDB_CONTROL_SET_DB_STICKY;
2157         request->rdata.data.db_id = db_id;
2158 }
2159
2160 int ctdb_reply_control_set_db_sticky(struct ctdb_reply_control *reply)
2161 {
2162         return ctdb_reply_control_generic(reply, CTDB_CONTROL_SET_DB_STICKY);
2163 }
2164
2165 /* CTDB_CONTROL_RELOAD_PUBLIC_IPS */
2166
2167 void ctdb_req_control_reload_public_ips(struct ctdb_req_control *request)
2168 {
2169         request->opcode = CTDB_CONTROL_RELOAD_PUBLIC_IPS;
2170         request->pad = 0;
2171         request->srvid = 0;
2172         request->client_id = 0;
2173         request->flags = 0;
2174
2175         request->rdata.opcode = CTDB_CONTROL_RELOAD_PUBLIC_IPS;
2176 }
2177
2178 int ctdb_reply_control_reload_public_ips(struct ctdb_reply_control *reply)
2179 {
2180         return ctdb_reply_control_generic(reply,
2181                                           CTDB_CONTROL_RELOAD_PUBLIC_IPS);
2182 }
2183
2184 /* CTDB_CONTROL_TRAVERSE_ALL_EXT */
2185
2186 /* CTDB_CONTROL_RECEIVE_RECORDS */
2187
2188 void ctdb_req_control_receive_records(struct ctdb_req_control *request,
2189                                       struct ctdb_rec_buffer *recbuf)
2190 {
2191         request->opcode = CTDB_CONTROL_RECEIVE_RECORDS;
2192         request->pad = 0;
2193         request->srvid = 0;
2194         request->client_id = 0;
2195         request->flags = 0;
2196
2197         request->rdata.opcode = CTDB_CONTROL_RECEIVE_RECORDS;
2198         request->rdata.data.recbuf = recbuf;
2199 }
2200
2201 int ctdb_reply_control_receive_records(struct ctdb_reply_control *reply,
2202                                        TALLOC_CTX *mem_ctx,
2203                                        struct ctdb_rec_buffer **recbuf)
2204 {
2205         if (reply->rdata.opcode != CTDB_CONTROL_RECEIVE_RECORDS) {
2206                 return EPROTO;
2207         }
2208
2209         if (reply->status == 0) {
2210                 *recbuf = talloc_steal(mem_ctx, reply->rdata.data.recbuf);
2211         }
2212         return reply->status;
2213 }
2214
2215 /* CTDB_CONTROL_IPREALLOCATED */
2216
2217 void ctdb_req_control_ipreallocated(struct ctdb_req_control *request)
2218 {
2219         request->opcode = CTDB_CONTROL_IPREALLOCATED;
2220         request->pad = 0;
2221         request->srvid = 0;
2222         request->client_id = 0;
2223         request->flags = 0;
2224
2225         request->rdata.opcode = CTDB_CONTROL_IPREALLOCATED;
2226 }
2227
2228 int ctdb_reply_control_ipreallocated(struct ctdb_reply_control *reply)
2229 {
2230         return ctdb_reply_control_generic(reply, CTDB_CONTROL_IPREALLOCATED);
2231 }
2232
2233 /* CTDB_CONTROL_GET_RUNSTATE */
2234
2235 void ctdb_req_control_get_runstate(struct ctdb_req_control *request)
2236 {
2237         request->opcode = CTDB_CONTROL_GET_RUNSTATE;
2238         request->pad = 0;
2239         request->srvid = 0;
2240         request->client_id = 0;
2241         request->flags = 0;
2242
2243         request->rdata.opcode = CTDB_CONTROL_GET_RUNSTATE;
2244 }
2245
2246 int ctdb_reply_control_get_runstate(struct ctdb_reply_control *reply,
2247                                     enum ctdb_runstate *runstate)
2248 {
2249         if (reply->rdata.opcode != CTDB_CONTROL_GET_RUNSTATE) {
2250                 return EPROTO;
2251         }
2252
2253         if (reply->status == 0) {
2254                 *runstate = reply->rdata.data.runstate;
2255         }
2256         return reply->status;
2257 }
2258
2259 /* CTDB_CONTROL_DB_DETACH */
2260
2261 void ctdb_req_control_db_detach(struct ctdb_req_control *request,
2262                                 uint32_t db_id)
2263 {
2264         request->opcode = CTDB_CONTROL_DB_DETACH;
2265         request->pad = 0;
2266         request->srvid = 0;
2267         request->client_id = 0;
2268         request->flags = 0;
2269
2270         request->rdata.opcode = CTDB_CONTROL_DB_DETACH;
2271         request->rdata.data.db_id = db_id;
2272 }
2273
2274 int ctdb_reply_control_db_detach(struct ctdb_reply_control *reply)
2275 {
2276         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_DETACH);
2277 }
2278
2279 /* CTDB_CONTROL_GET_NODES_FILE */
2280
2281 void ctdb_req_control_get_nodes_file(struct ctdb_req_control *request)
2282 {
2283         request->opcode = CTDB_CONTROL_GET_NODES_FILE;
2284         request->pad = 0;
2285         request->srvid = 0;
2286         request->client_id = 0;
2287         request->flags = 0;
2288
2289         request->rdata.opcode = CTDB_CONTROL_GET_NODES_FILE;
2290 }
2291
2292 int ctdb_reply_control_get_nodes_file(struct ctdb_reply_control *reply,
2293                                       TALLOC_CTX *mem_ctx,
2294                                       struct ctdb_node_map **nodemap)
2295 {
2296         if (reply->rdata.opcode != CTDB_CONTROL_GET_NODES_FILE) {
2297                 return EPROTO;
2298         }
2299
2300         if (reply->status == 0) {
2301                 *nodemap = talloc_steal(mem_ctx, reply->rdata.data.nodemap);
2302         }
2303         return reply->status;
2304 }
2305
2306 /* CTDB_CONTROL_DB_FREEZE */
2307
2308 void ctdb_req_control_db_freeze(struct ctdb_req_control *request,
2309                                 uint32_t db_id)
2310 {
2311         request->opcode = CTDB_CONTROL_DB_FREEZE;
2312         request->pad = 0;
2313         request->srvid = 0;
2314         request->client_id = 0;
2315         request->flags = 0;
2316
2317         request->rdata.opcode = CTDB_CONTROL_DB_FREEZE;
2318         request->rdata.data.db_id = db_id;
2319 }
2320
2321 int ctdb_reply_control_db_freeze(struct ctdb_reply_control *reply)
2322 {
2323         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_FREEZE);
2324 }
2325
2326 /* CTDB_CONTROL_DB_THAW */
2327
2328 void ctdb_req_control_db_thaw(struct ctdb_req_control *request,
2329                               uint32_t db_id)
2330 {
2331         request->opcode = CTDB_CONTROL_DB_THAW;
2332         request->pad = 0;
2333         request->srvid = 0;
2334         request->client_id = 0;
2335         request->flags = 0;
2336
2337         request->rdata.opcode = CTDB_CONTROL_DB_THAW;
2338         request->rdata.data.db_id = db_id;
2339 }
2340
2341 int ctdb_reply_control_db_thaw(struct ctdb_reply_control *reply)
2342 {
2343         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_THAW);
2344 }
2345
2346 /* CTDB_CONTROL_DB_TRANSACTION_START */
2347
2348 void ctdb_req_control_db_transaction_start(struct ctdb_req_control *request,
2349                                            struct ctdb_transdb *transdb)
2350 {
2351         request->opcode = CTDB_CONTROL_DB_TRANSACTION_START;
2352         request->pad = 0;
2353         request->srvid = 0;
2354         request->client_id = 0;
2355         request->flags = 0;
2356
2357         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_START;
2358         request->rdata.data.transdb = transdb;
2359 }
2360
2361 int ctdb_reply_control_db_transaction_start(struct ctdb_reply_control *reply)
2362 {
2363         return ctdb_reply_control_generic(reply,
2364                                           CTDB_CONTROL_DB_TRANSACTION_START);
2365 }
2366
2367 /* CTDB_CONTROL_DB_TRANSACTION_COMMIT */
2368
2369 void ctdb_req_control_db_transaction_commit(struct ctdb_req_control *request,
2370                                             struct ctdb_transdb *transdb)
2371 {
2372         request->opcode = CTDB_CONTROL_DB_TRANSACTION_COMMIT;
2373         request->pad = 0;
2374         request->srvid = 0;
2375         request->client_id = 0;
2376         request->flags = 0;
2377
2378         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_COMMIT;
2379         request->rdata.data.transdb = transdb;
2380 }
2381
2382 int ctdb_reply_control_db_transaction_commit(struct ctdb_reply_control *reply)
2383 {
2384         return ctdb_reply_control_generic(reply,
2385                                           CTDB_CONTROL_DB_TRANSACTION_COMMIT);
2386 }
2387
2388 /* CTDB_CONTROL_DB_TRANSACTION_CANCEL */
2389
2390 void ctdb_req_control_db_transaction_cancel(struct ctdb_req_control *request,
2391                                             uint32_t db_id)
2392 {
2393         request->opcode = CTDB_CONTROL_DB_TRANSACTION_CANCEL;
2394         request->pad = 0;
2395         request->srvid = 0;
2396         request->client_id = 0;
2397         request->flags = 0;
2398
2399         request->rdata.opcode = CTDB_CONTROL_DB_TRANSACTION_CANCEL;
2400         request->rdata.data.db_id = db_id;
2401 }
2402
2403 int ctdb_reply_control_db_transaction_cancel(struct ctdb_reply_control *reply)
2404 {
2405         return ctdb_reply_control_generic(reply,
2406                                           CTDB_CONTROL_DB_TRANSACTION_CANCEL);
2407 }
2408
2409 /* CTDB_CONTROL_DB_PULL */
2410
2411 void ctdb_req_control_db_pull(struct ctdb_req_control *request,
2412                               struct ctdb_pulldb_ext *pulldb_ext)
2413 {
2414         request->opcode = CTDB_CONTROL_DB_PULL;
2415         request->pad = 0;
2416         request->srvid = 0;
2417         request->client_id = 0;
2418         request->flags = 0;
2419
2420         request->rdata.opcode = CTDB_CONTROL_DB_PULL;
2421         request->rdata.data.pulldb_ext = pulldb_ext;
2422 }
2423
2424 int ctdb_reply_control_db_pull(struct ctdb_reply_control *reply,
2425                                uint32_t *num_records)
2426 {
2427         if (reply->rdata.opcode != CTDB_CONTROL_DB_PULL) {
2428                 return EPROTO;
2429         }
2430
2431         if (reply->status == 0) {
2432                 *num_records = reply->rdata.data.num_records;
2433         }
2434         return reply->status;
2435 }
2436
2437 /* CTDB_CONTROL_DB_PUSH_START */
2438
2439 void ctdb_req_control_db_push_start(struct ctdb_req_control *request,
2440                                     struct ctdb_pulldb_ext *pulldb_ext)
2441 {
2442         request->opcode = CTDB_CONTROL_DB_PUSH_START;
2443         request->pad = 0;
2444         request->srvid = 0;
2445         request->client_id = 0;
2446         request->flags = 0;
2447
2448         request->rdata.opcode = CTDB_CONTROL_DB_PUSH_START;
2449         request->rdata.data.pulldb_ext = pulldb_ext;
2450 }
2451
2452 int ctdb_reply_control_db_push_start(struct ctdb_reply_control *reply)
2453 {
2454         return ctdb_reply_control_generic(reply, CTDB_CONTROL_DB_PUSH_START);
2455 }
2456
2457 /* CTDB_CONTROL_DB_PUSH_CONFIRM */
2458
2459 void ctdb_req_control_db_push_confirm(struct ctdb_req_control *request,
2460                                       uint32_t db_id)
2461 {
2462         request->opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
2463         request->pad = 0;
2464         request->srvid = 0;
2465         request->client_id = 0;
2466         request->flags = 0;
2467
2468         request->rdata.opcode = CTDB_CONTROL_DB_PUSH_CONFIRM;
2469         request->rdata.data.db_id = db_id;
2470 }
2471
2472 int ctdb_reply_control_db_push_confirm(struct ctdb_reply_control *reply,
2473                                        uint32_t *num_records)
2474 {
2475         if (reply->rdata.opcode != CTDB_CONTROL_DB_PUSH_CONFIRM) {
2476                 return EPROTO;
2477         }
2478
2479         if (reply->status == 0) {
2480                 *num_records = reply->rdata.data.num_records;
2481         }
2482         return reply->status;
2483 }