ctdb/protocol/protocol_client.c

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