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