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