source: vendor/current/ctdb/protocol/protocol_client.c

Last change on this file was 989, checked in by Silvan Scherrer, 9 years ago

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