ctdb-protocol: Fix marshalling for ctdb_srvid_message
[vlendec/samba-autobuild/.git] / ctdb / protocol / protocol_api.h
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 #ifndef __CTDB_PROTOCOL_API_H__
21 #define __CTDB_PROTOCOL_API_H__
22
23 #include <talloc.h>
24
25 #include "protocol/protocol.h"
26
27 /* From protocol/protocol_types.c */
28
29 size_t ctdb_ltdb_header_len(struct ctdb_ltdb_header *in);
30 void ctdb_ltdb_header_push(struct ctdb_ltdb_header *in, uint8_t *buf,
31                            size_t *npush);
32 int ctdb_ltdb_header_pull(uint8_t *buf, size_t buflen,
33                           struct ctdb_ltdb_header *out, size_t *npull);
34
35 int ctdb_ltdb_header_extract(TDB_DATA *data, struct ctdb_ltdb_header *header);
36
37 size_t ctdb_rec_data_len(struct ctdb_rec_data *in);
38 void ctdb_rec_data_push(struct ctdb_rec_data *in, uint8_t *buf, size_t *npush);
39 int ctdb_rec_data_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
40                        struct ctdb_rec_data **out, size_t *npull);
41
42 size_t ctdb_rec_buffer_len(struct ctdb_rec_buffer *in);
43 void ctdb_rec_buffer_push(struct ctdb_rec_buffer *in, uint8_t *buf,
44                           size_t *npush);
45 int ctdb_rec_buffer_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
46                          struct ctdb_rec_buffer **out, size_t *npull);
47
48 struct ctdb_rec_buffer *ctdb_rec_buffer_init(TALLOC_CTX *mem_ctx,
49                                              uint32_t db_id);
50 int ctdb_rec_buffer_add(TALLOC_CTX *mem_ctx, struct ctdb_rec_buffer *recbuf,
51                         uint32_t reqid, struct ctdb_ltdb_header *header,
52                         TDB_DATA key, TDB_DATA data);
53 int ctdb_rec_buffer_traverse(struct ctdb_rec_buffer *recbuf,
54                              ctdb_rec_parser_func_t func,
55                              void *private_data);
56
57 int ctdb_rec_buffer_write(struct ctdb_rec_buffer *recbuf, int fd);
58 int ctdb_rec_buffer_read(int fd, TALLOC_CTX *mem_ctx,
59                          struct ctdb_rec_buffer **out);
60
61 size_t ctdb_server_id_len(struct ctdb_server_id *sid);
62 void ctdb_server_id_push(struct ctdb_server_id *sid, uint8_t *buf);
63 int ctdb_server_id_pull(uint8_t *buf, size_t buflen,
64                          struct ctdb_server_id *sid);
65
66 size_t ctdb_g_lock_len(struct ctdb_g_lock *lock);
67 void ctdb_g_lock_push(struct ctdb_g_lock *lock, uint8_t *buf);
68 int ctdb_g_lock_pull(uint8_t *buf, size_t buflen, struct ctdb_g_lock *lock);
69
70 size_t ctdb_g_lock_list_len(struct ctdb_g_lock_list *lock_list);
71 void ctdb_g_lock_list_push(struct ctdb_g_lock_list *lock_list, uint8_t *buf);
72 int ctdb_g_lock_list_pull(uint8_t *buf, size_t buflen, TALLOC_CTX *mem_ctx,
73                           struct ctdb_g_lock_list **out);
74
75 /* From protocol/protocol_header.c */
76
77 void ctdb_req_header_fill(struct ctdb_req_header *h, uint32_t generation,
78                           uint32_t operation, uint32_t destnode,
79                           uint32_t srcnode, uint32_t reqid);
80
81 size_t ctdb_req_header_len(struct ctdb_req_header *h);
82 void ctdb_req_header_push(struct ctdb_req_header *h, uint8_t *buf);
83 int ctdb_req_header_pull(uint8_t *buf, size_t buflen,
84                          struct ctdb_req_header *h);
85
86 int ctdb_req_header_verify(struct ctdb_req_header *h, uint32_t operation);
87
88 /* From protocol/protocol_call.c */
89
90 size_t ctdb_req_call_len(struct ctdb_req_header *h,
91                          struct ctdb_req_call *c);
92
93 int ctdb_req_call_push(struct ctdb_req_header *h,
94                        struct ctdb_req_call *c,
95                        uint8_t *buf, size_t *buflen);
96
97 int ctdb_req_call_pull(uint8_t *buf, size_t buflen,
98                        struct ctdb_req_header *h,
99                        TALLOC_CTX *mem_ctx,
100                        struct ctdb_req_call *c);
101
102 size_t ctdb_reply_call_len(struct ctdb_req_header *h,
103                            struct ctdb_reply_call *c);
104
105 int ctdb_reply_call_push(struct ctdb_req_header *h,
106                          struct ctdb_reply_call *c,
107                          uint8_t *buf, size_t *buflen);
108
109 int ctdb_reply_call_pull(uint8_t *buf, size_t buflen,
110                          struct ctdb_req_header *h,
111                          TALLOC_CTX *mem_ctx,
112                          struct ctdb_reply_call *c);
113
114 size_t ctdb_reply_error_len(struct ctdb_req_header *h,
115                             struct ctdb_reply_error *c);
116
117 int ctdb_reply_error_push(struct ctdb_req_header *h,
118                           struct ctdb_reply_error *c,
119                           uint8_t *buf, size_t *buflen);
120
121 int ctdb_reply_error_pull(uint8_t *buf, size_t buflen,
122                           struct ctdb_req_header *h,
123                           TALLOC_CTX *mem_ctx,
124                           struct ctdb_reply_error *c);
125
126 size_t ctdb_req_dmaster_len(struct ctdb_req_header *h,
127                             struct ctdb_req_dmaster *c);
128
129 int ctdb_req_dmaster_push(struct ctdb_req_header *h,
130                           struct ctdb_req_dmaster *c,
131                           uint8_t *buf, size_t *buflen);
132
133 int ctdb_req_dmaster_pull(uint8_t *buf, size_t buflen,
134                           struct ctdb_req_header *h,
135                           TALLOC_CTX *mem_ctx,
136                           struct ctdb_req_dmaster *c);
137
138 size_t ctdb_reply_dmaster_len(struct ctdb_req_header *h,
139                               struct ctdb_reply_dmaster *c);
140
141 int ctdb_reply_dmaster_push(struct ctdb_req_header *h,
142                             struct ctdb_reply_dmaster *c,
143                             uint8_t *buf, size_t *buflen);
144
145 int ctdb_reply_dmaster_pull(uint8_t *buf, size_t buflen,
146                             struct ctdb_req_header *h,
147                             TALLOC_CTX *mem_ctx,
148                             struct ctdb_reply_dmaster *c);
149
150 /* From protocol/protocol_control.c */
151
152 size_t ctdb_req_control_len(struct ctdb_req_header *h,
153                             struct ctdb_req_control *c);
154
155 int ctdb_req_control_push(struct ctdb_req_header *h,
156                           struct ctdb_req_control *c,
157                           uint8_t *buf, size_t *buflen);
158
159 int ctdb_req_control_pull(uint8_t *buf, size_t buflen,
160                           struct ctdb_req_header *h,
161                           TALLOC_CTX *mem_ctx,
162                           struct ctdb_req_control *c);
163
164 size_t ctdb_reply_control_len(struct ctdb_req_header *h,
165                               struct ctdb_reply_control *c);
166
167 int ctdb_reply_control_push(struct ctdb_req_header *h,
168                             struct ctdb_reply_control *c,
169                             uint8_t *buf, size_t *buflen);
170
171 int ctdb_reply_control_pull(uint8_t *buf, size_t buflen, uint32_t opcode,
172                             struct ctdb_req_header *h,
173                             TALLOC_CTX *mem_ctx,
174                             struct ctdb_reply_control *c);
175
176 /* From protocol/protocol_client.c */
177
178 void ctdb_req_control_process_exists(struct ctdb_req_control *request,
179                                      pid_t pid);
180 int ctdb_reply_control_process_exists(struct ctdb_reply_control *reply,
181                                       int *status);
182
183 void ctdb_req_control_statistics(struct ctdb_req_control *request);
184
185 int ctdb_reply_control_statistics(struct ctdb_reply_control *reply,
186                                   TALLOC_CTX *mem_ctx,
187                                   struct ctdb_statistics **stats);
188
189 void ctdb_req_control_ping(struct ctdb_req_control *request);
190 int ctdb_reply_control_ping(struct ctdb_reply_control *reply,
191                             int *num_clients);
192
193 void ctdb_req_control_getdbpath(struct ctdb_req_control *request,
194                                 uint32_t db_id);
195 int ctdb_reply_control_getdbpath(struct ctdb_reply_control *reply,
196                                  TALLOC_CTX *mem_ctx, const char **db_path);
197
198 void ctdb_req_control_getvnnmap(struct ctdb_req_control *request);
199 int ctdb_reply_control_getvnnmap(struct ctdb_reply_control *reply,
200                                  TALLOC_CTX *mem_ctx,
201                                  struct ctdb_vnn_map **vnnmap);
202
203 void ctdb_req_control_setvnnmap(struct ctdb_req_control *request,
204                                 struct ctdb_vnn_map *vnnmap);
205 int ctdb_reply_control_setvnnmap(struct ctdb_reply_control *reply);
206
207 void ctdb_req_control_get_debug(struct ctdb_req_control *request);
208 int ctdb_reply_control_get_debug(struct ctdb_reply_control *reply,
209                                  int *debug_level);
210
211 void ctdb_req_control_set_debug(struct ctdb_req_control *request,
212                                 int debug_level);
213 int ctdb_reply_control_set_debug(struct ctdb_reply_control *reply);
214
215 void ctdb_req_control_get_dbmap(struct ctdb_req_control *request);
216 int ctdb_reply_control_get_dbmap(struct ctdb_reply_control *reply,
217                                  TALLOC_CTX *mem_ctx,
218                                  struct ctdb_dbid_map **dbmap);
219
220 void ctdb_req_control_pull_db(struct ctdb_req_control *request,
221                               struct ctdb_pulldb *pulldb);
222 int ctdb_reply_control_pull_db(struct ctdb_reply_control *reply,
223                                TALLOC_CTX *mem_ctx,
224                                struct ctdb_rec_buffer **recbuf);
225
226 void ctdb_req_control_push_db(struct ctdb_req_control *request,
227                               struct ctdb_rec_buffer *recbuf);
228 int ctdb_reply_control_push_db(struct ctdb_reply_control *reply);
229
230 void ctdb_req_control_get_recmode(struct ctdb_req_control *request);
231 int ctdb_reply_control_get_recmode(struct ctdb_reply_control *reply,
232                                    int *recmode);
233
234 void ctdb_req_control_set_recmode(struct ctdb_req_control *request,
235                                   int recmode);
236 int ctdb_reply_control_set_recmode(struct ctdb_reply_control *reply);
237
238 void ctdb_req_control_statistics_reset(struct ctdb_req_control *request);
239 int ctdb_reply_control_statistics_reset(struct ctdb_reply_control *reply);
240
241 void ctdb_req_control_db_attach(struct ctdb_req_control *request,
242                                 const char *db_name);
243 int ctdb_reply_control_db_attach(struct ctdb_reply_control *reply,
244                                  uint32_t *db_id);
245
246 void ctdb_req_control_traverse_start(struct ctdb_req_control *request,
247                                      struct ctdb_traverse_start *traverse);
248 int ctdb_reply_control_traverse_start(struct ctdb_reply_control *reply);
249
250 void ctdb_req_control_register_srvid(struct ctdb_req_control *request,
251                                      uint64_t srvid);
252 int ctdb_reply_control_register_srvid(struct ctdb_reply_control *reply);
253
254 void ctdb_req_control_deregister_srvid(struct ctdb_req_control *request,
255                                        uint64_t srvid);
256 int ctdb_reply_control_deregister_srvid(struct ctdb_reply_control *reply);
257
258 void ctdb_req_control_get_dbname(struct ctdb_req_control *request,
259                                  uint32_t db_id);
260 int ctdb_reply_control_get_dbname(struct ctdb_reply_control *reply,
261                                   TALLOC_CTX *mem_ctx, const char **db_name);
262
263 void ctdb_req_control_enable_seqnum(struct ctdb_req_control *request,
264                                     uint32_t db_id);
265 int ctdb_reply_control_enable_seqnum(struct ctdb_reply_control *reply);
266
267 void ctdb_req_control_update_seqnum(struct ctdb_req_control *request,
268                                     uint32_t db_id);
269 int ctdb_reply_control_update_seqnum(struct ctdb_reply_control *reply);
270
271 void ctdb_req_control_dump_memory(struct ctdb_req_control *request);
272 int ctdb_reply_control_dump_memory(struct ctdb_reply_control *reply,
273                                    TALLOC_CTX *mem_ctx, const char **mem_str);
274
275 void ctdb_req_control_get_pid(struct ctdb_req_control *request);
276 int ctdb_reply_control_get_pid(struct ctdb_reply_control *reply,
277                                pid_t *pid);
278
279 void ctdb_req_control_get_recmaster(struct ctdb_req_control *request);
280 int ctdb_reply_control_get_recmaster(struct ctdb_reply_control *reply,
281                                      uint32_t *recmaster);
282
283 void ctdb_req_control_set_recmaster(struct ctdb_req_control *request,
284                                     int recmaster);
285 int ctdb_reply_control_set_recmaster(struct ctdb_reply_control *reply);
286
287 void ctdb_req_control_freeze(struct ctdb_req_control *request,
288                              uint32_t priority);
289 int ctdb_reply_control_freeze(struct ctdb_reply_control *reply);
290
291 void ctdb_req_control_get_pnn(struct ctdb_req_control *request);
292 int ctdb_reply_control_get_pnn(struct ctdb_reply_control *reply,
293                                uint32_t *pnn);
294
295 void ctdb_req_control_shutdown(struct ctdb_req_control *request);
296 int ctdb_reply_control_shutdown(struct ctdb_reply_control *reply);
297
298 void ctdb_req_control_get_monmode(struct ctdb_req_control *request);
299 int ctdb_reply_control_get_monmode(struct ctdb_reply_control *reply,
300                                    int *mon_mode);
301
302 void ctdb_req_control_tcp_client(struct ctdb_req_control *request,
303                                  struct ctdb_connection *conn);
304 int ctdb_reply_control_tcp_client(struct ctdb_reply_control *reply);
305
306 void ctdb_req_control_tcp_add(struct ctdb_req_control *request,
307                               struct ctdb_connection *conn);
308 int ctdb_reply_control_tcp_add(struct ctdb_reply_control *reply);
309
310 void ctdb_req_control_tcp_remove(struct ctdb_req_control *request,
311                                  struct ctdb_connection *conn);
312 int ctdb_reply_control_tcp_remove(struct ctdb_reply_control *reply);
313
314 void ctdb_req_control_startup(struct ctdb_req_control *request);
315 int ctdb_reply_control_startup(struct ctdb_reply_control *reply);
316
317 void ctdb_req_control_set_tunable(struct ctdb_req_control *request,
318                                   struct ctdb_tunable *tunable);
319 int ctdb_reply_control_set_tunable(struct ctdb_reply_control *reply);
320
321 void ctdb_req_control_get_tunable(struct ctdb_req_control *request,
322                                   const char *name);
323 int ctdb_reply_control_get_tunable(struct ctdb_reply_control *reply,
324                                    uint32_t *value);
325
326 void ctdb_req_control_list_tunables(struct ctdb_req_control *request);
327 int ctdb_reply_control_list_tunables(struct ctdb_reply_control *reply,
328                                      TALLOC_CTX *mem_ctx,
329                                      struct ctdb_var_list **tun_var_list);
330
331 void ctdb_req_control_modify_flags(struct ctdb_req_control *request,
332                                    struct ctdb_node_flag_change *flag_change);
333 int ctdb_reply_control_modify_flags(struct ctdb_reply_control *reply);
334
335 void ctdb_req_control_get_all_tunables(struct ctdb_req_control *request);
336 int ctdb_reply_control_get_all_tunables(struct ctdb_reply_control *reply,
337                                         TALLOC_CTX *mem_ctx,
338                                         struct ctdb_tunable_list **tun_list);
339
340 void ctdb_req_control_get_tcp_tickle_list(struct ctdb_req_control *request,
341                                           ctdb_sock_addr *addr);
342 int ctdb_reply_control_get_tcp_tickle_list(struct ctdb_reply_control *reply,
343                                            TALLOC_CTX *mem_ctx,
344                                            struct ctdb_tickle_list **tickles);
345
346 void ctdb_req_control_set_tcp_tickle_list(struct ctdb_req_control *request,
347                                           struct ctdb_tickle_list *tickles);
348 int ctdb_reply_control_set_tcp_tickle_list(struct ctdb_reply_control *reply);
349
350 void ctdb_req_control_db_attach_persistent(struct ctdb_req_control *request,
351                                            const char *name);
352 int ctdb_reply_control_db_attach_persistent(struct ctdb_reply_control *reply,
353                                             uint32_t *db_id);
354
355 void ctdb_req_control_update_record(struct ctdb_req_control *request,
356                                     struct ctdb_rec_buffer *recbuf);
357 int ctdb_reply_control_update_record(struct ctdb_reply_control *reply);
358
359 void ctdb_req_control_send_gratuitous_arp(struct ctdb_req_control *request,
360                                           struct ctdb_addr_info *addr_info);
361 int ctdb_reply_control_send_gratuitous_arp(struct ctdb_reply_control *reply);
362
363 void ctdb_req_control_wipe_database(struct ctdb_req_control *request,
364                                     struct ctdb_transdb *transdb);
365 int ctdb_reply_control_wipe_database(struct ctdb_reply_control *reply);
366
367 void ctdb_req_control_uptime(struct ctdb_req_control *request);
368 int ctdb_reply_control_uptime(struct ctdb_reply_control *reply,
369                               TALLOC_CTX *mem_ctx,
370                               struct ctdb_uptime **uptime);
371
372 void ctdb_req_control_start_recovery(struct ctdb_req_control *request);
373 int ctdb_reply_control_start_recovery(struct ctdb_reply_control *reply);
374
375 void ctdb_req_control_end_recovery(struct ctdb_req_control *request);
376 int ctdb_reply_control_end_recovery(struct ctdb_reply_control *reply);
377
378 void ctdb_req_control_reload_nodes_file(struct ctdb_req_control *request);
379 int ctdb_reply_control_reload_nodes_file(struct ctdb_reply_control *reply);
380
381 void ctdb_req_control_try_delete_records(struct ctdb_req_control *request,
382                                          struct ctdb_rec_buffer *recbuf);
383 int ctdb_reply_control_try_delete_records(struct ctdb_reply_control *reply,
384                                           TALLOC_CTX *mem_ctx,
385                                           struct ctdb_rec_buffer **recbuf);
386
387 void ctdb_req_control_enable_monitor(struct ctdb_req_control *request);
388 int ctdb_reply_control_enable_monitor(struct ctdb_reply_control *reply);
389
390 void ctdb_req_control_disable_monitor(struct ctdb_req_control *request);
391 int ctdb_reply_control_disable_monitor(struct ctdb_reply_control *reply);
392
393 void ctdb_req_control_add_public_ip(struct ctdb_req_control *request,
394                                     struct ctdb_addr_info *addr_info);
395 int ctdb_reply_control_add_public_ip(struct ctdb_reply_control *reply);
396
397 void ctdb_req_control_del_public_ip(struct ctdb_req_control *request,
398                                     struct ctdb_addr_info *addr_info);
399 int ctdb_reply_control_del_public_ip(struct ctdb_reply_control *reply);
400
401 void ctdb_req_control_get_capabilities(struct ctdb_req_control *request);
402 int ctdb_reply_control_get_capabilities(struct ctdb_reply_control *reply,
403                                         uint32_t *caps);
404
405 void ctdb_req_control_recd_ping(struct ctdb_req_control *request);
406 int ctdb_reply_control_recd_ping(struct ctdb_reply_control *reply);
407
408 void ctdb_req_control_release_ip(struct ctdb_req_control *request,
409                                  struct ctdb_public_ip *pubip);
410 int ctdb_reply_control_release_ip(struct ctdb_reply_control *reply);
411
412 void ctdb_req_control_takeover_ip(struct ctdb_req_control *request,
413                                   struct ctdb_public_ip *pubip);
414 int ctdb_reply_control_takeover_ip(struct ctdb_reply_control *reply);
415
416 void ctdb_req_control_get_public_ips(struct ctdb_req_control *request,
417                                      bool available_only);
418 int ctdb_reply_control_get_public_ips(struct ctdb_reply_control *reply,
419                                       TALLOC_CTX *mem_ctx,
420                                       struct ctdb_public_ip_list **pubip_list);
421
422 void ctdb_req_control_get_nodemap(struct ctdb_req_control *request);
423 int ctdb_reply_control_get_nodemap(struct ctdb_reply_control *reply,
424                                    TALLOC_CTX *mem_ctx,
425                                    struct ctdb_node_map **nodemap);
426
427 void ctdb_req_control_traverse_kill(struct ctdb_req_control *request,
428                                     struct ctdb_traverse_start *traverse);
429 int ctdb_reply_control_traverse_kill(struct ctdb_reply_control *reply);
430
431 void ctdb_req_control_recd_reclock_latency(struct ctdb_req_control *request,
432                                            double reclock_latency);
433 int ctdb_reply_control_recd_reclock_latency(struct ctdb_reply_control *reply);
434
435 void ctdb_req_control_get_reclock_file(struct ctdb_req_control *request);
436 int ctdb_reply_control_get_reclock_file(struct ctdb_reply_control *reply,
437                                         TALLOC_CTX *mem_ctx,
438                                         const char **reclock_file);
439
440 void ctdb_req_control_stop_node(struct ctdb_req_control *request);
441 int ctdb_reply_control_stop_node(struct ctdb_reply_control *reply);
442
443 void ctdb_req_control_continue_node(struct ctdb_req_control *request);
444 int ctdb_reply_control_continue_node(struct ctdb_reply_control *reply);
445
446 void ctdb_req_control_set_lmasterrole(struct ctdb_req_control *request,
447                                       uint32_t lmaster_role);
448 int ctdb_reply_control_set_lmasterrole(struct ctdb_reply_control *reply);
449
450 void ctdb_req_control_set_recmasterrole(struct ctdb_req_control *request,
451                                         uint32_t recmaster_role);
452 int ctdb_reply_control_set_recmasterrole(struct ctdb_reply_control *reply);
453
454 void ctdb_req_control_set_ban_state(struct ctdb_req_control *request,
455                                     struct ctdb_ban_state *ban_state);
456 int ctdb_reply_control_set_ban_state(struct ctdb_reply_control *reply);
457
458 void ctdb_req_control_get_ban_state(struct ctdb_req_control *request);
459 int ctdb_reply_control_get_ban_state(struct ctdb_reply_control *reply,
460                                      TALLOC_CTX *mem_ctx,
461                                      struct ctdb_ban_state **ban_state);
462
463 void ctdb_req_control_register_notify(struct ctdb_req_control *request,
464                                       struct ctdb_notify_data *notify);
465 int ctdb_reply_control_register_notify(struct ctdb_reply_control *reply);
466
467 void ctdb_req_control_deregister_notify(struct ctdb_req_control *request,
468                                         uint64_t srvid);
469 int ctdb_reply_control_deregister_notify(struct ctdb_reply_control *reply);
470
471 void ctdb_req_control_trans3_commit(struct ctdb_req_control *request,
472                                     struct ctdb_rec_buffer *recbuf);
473 int ctdb_reply_control_trans3_commit(struct ctdb_reply_control *reply);
474
475 void ctdb_req_control_get_db_seqnum(struct ctdb_req_control *request,
476                                     uint32_t db_id);
477 int ctdb_reply_control_get_db_seqnum(struct ctdb_reply_control *reply,
478                                      uint64_t *seqnum);
479
480 void ctdb_req_control_db_set_healthy(struct ctdb_req_control *request,
481                                      uint32_t db_id);
482 int ctdb_reply_control_db_set_healthy(struct ctdb_reply_control *reply);
483
484 void ctdb_req_control_db_get_health(struct ctdb_req_control *request,
485                                     uint32_t db_id);
486 int ctdb_reply_control_db_get_health(struct ctdb_reply_control *reply,
487                                      TALLOC_CTX *mem_ctx,
488                                      const char **reason);
489
490 void ctdb_req_control_get_public_ip_info(struct ctdb_req_control *request,
491                                          ctdb_sock_addr *addr);
492 int ctdb_reply_control_get_public_ip_info(struct ctdb_reply_control *reply,
493                                           TALLOC_CTX *mem_ctx,
494                                           struct ctdb_public_ip_info **ipinfo);
495
496 void ctdb_req_control_get_ifaces(struct ctdb_req_control *request);
497 int ctdb_reply_control_get_ifaces(struct ctdb_reply_control *reply,
498                                   TALLOC_CTX *mem_ctx,
499                                   struct ctdb_iface_list **iface_list);
500
501 void ctdb_req_control_set_iface_link_state(struct ctdb_req_control *request,
502                                            struct ctdb_iface *iface);
503 int ctdb_reply_control_set_iface_link_state(struct ctdb_reply_control *reply);
504
505 void ctdb_req_control_tcp_add_delayed_update(struct ctdb_req_control *request,
506                                              struct ctdb_connection *conn);
507 int ctdb_reply_control_tcp_add_delayed_update(struct ctdb_reply_control *reply);
508
509 void ctdb_req_control_get_stat_history(struct ctdb_req_control *request);
510 int ctdb_reply_control_get_stat_history(struct ctdb_reply_control *reply,
511                                         TALLOC_CTX *mem_ctx,
512                                         struct ctdb_statistics_list **stats_list);
513
514 void ctdb_req_control_schedule_for_deletion(struct ctdb_req_control *request,
515                                             struct ctdb_key_data *key);
516 int ctdb_reply_control_schedule_for_deletion(struct ctdb_reply_control *reply);
517
518 void ctdb_req_control_set_db_readonly(struct ctdb_req_control *request,
519                                       uint32_t db_id);
520 int ctdb_reply_control_set_db_readonly(struct ctdb_reply_control *reply);
521
522 void ctdb_req_control_traverse_start_ext(struct ctdb_req_control *request,
523                                          struct ctdb_traverse_start_ext *traverse);
524 int ctdb_reply_control_traverse_start_ext(struct ctdb_reply_control *reply);
525
526 void ctdb_req_control_get_db_statistics(struct ctdb_req_control *request,
527                                         uint32_t db_id);
528 int ctdb_reply_control_get_db_statistics(struct ctdb_reply_control *reply,
529                                          TALLOC_CTX *mem_ctx,
530                                          struct ctdb_db_statistics **dbstats);
531
532 void ctdb_req_control_set_db_sticky(struct ctdb_req_control *request,
533                                     uint32_t db_id);
534 int ctdb_reply_control_set_db_sticky(struct ctdb_reply_control *reply);
535
536 void ctdb_req_control_reload_public_ips(struct ctdb_req_control *request);
537 int ctdb_reply_control_reload_public_ips(struct ctdb_reply_control *reply);
538
539 void ctdb_req_control_receive_records(struct ctdb_req_control *request,
540                                       struct ctdb_rec_buffer *recbuf);
541 int ctdb_reply_control_receive_records(struct ctdb_reply_control *reply,
542                                        TALLOC_CTX *mem_ctx,
543                                        struct ctdb_rec_buffer **recbuf);
544
545 void ctdb_req_control_ipreallocated(struct ctdb_req_control *request);
546 int ctdb_reply_control_ipreallocated(struct ctdb_reply_control *reply);
547
548 void ctdb_req_control_get_runstate(struct ctdb_req_control *request);
549 int ctdb_reply_control_get_runstate(struct ctdb_reply_control *reply,
550                                     enum ctdb_runstate *runstate);
551
552 void ctdb_req_control_db_detach(struct ctdb_req_control *request,
553                                 uint32_t db_id);
554 int ctdb_reply_control_db_detach(struct ctdb_reply_control *reply);
555
556 void ctdb_req_control_get_nodes_file(struct ctdb_req_control *request);
557 int ctdb_reply_control_get_nodes_file(struct ctdb_reply_control *reply,
558                                       TALLOC_CTX *mem_ctx,
559                                       struct ctdb_node_map **nodemap);
560
561 void ctdb_req_control_db_freeze(struct ctdb_req_control *request,
562                                 uint32_t db_id);
563 int ctdb_reply_control_db_freeze(struct ctdb_reply_control *reply);
564
565 void ctdb_req_control_db_thaw(struct ctdb_req_control *request,
566                               uint32_t db_id);
567 int ctdb_reply_control_db_thaw(struct ctdb_reply_control *reply);
568
569 void ctdb_req_control_db_transaction_start(struct ctdb_req_control *request,
570                                            struct ctdb_transdb *transdb);
571 int ctdb_reply_control_db_transaction_start(struct ctdb_reply_control *reply);
572
573 void ctdb_req_control_db_transaction_commit(struct ctdb_req_control *request,
574                                             struct ctdb_transdb *transdb);
575 int ctdb_reply_control_db_transaction_commit(struct ctdb_reply_control *reply);
576
577 void ctdb_req_control_db_transaction_cancel(struct ctdb_req_control *request,
578                                             uint32_t db_id);
579 int ctdb_reply_control_db_transaction_cancel(struct ctdb_reply_control *reply);
580
581 void ctdb_req_control_db_pull(struct ctdb_req_control *request,
582                               struct ctdb_pulldb_ext *pulldb_ext);
583 int ctdb_reply_control_db_pull(struct ctdb_reply_control *reply,
584                                uint32_t *num_records);
585
586 void ctdb_req_control_db_push_start(struct ctdb_req_control *request,
587                                     struct ctdb_pulldb_ext *pulldb_ext);
588 int ctdb_reply_control_db_push_start(struct ctdb_reply_control *reply);
589
590 void ctdb_req_control_db_push_confirm(struct ctdb_req_control *request,
591                                       uint32_t db_id);
592 int ctdb_reply_control_db_push_confirm(struct ctdb_reply_control *reply,
593                                        uint32_t *num_records);
594
595 void ctdb_req_control_db_open_flags(struct ctdb_req_control *request,
596                                     uint32_t db_id);
597 int ctdb_reply_control_db_open_flags(struct ctdb_reply_control *reply,
598                                      int *tdb_flags);
599
600 void ctdb_req_control_db_attach_replicated(struct ctdb_req_control *request,
601                                            const char *db_name);
602 int ctdb_reply_control_db_attach_replicated(struct ctdb_reply_control *reply,
603                                             uint32_t *db_id);
604
605 /* From protocol/protocol_debug.c */
606
607 void ctdb_packet_print(uint8_t *buf, size_t buflen, FILE *fp);
608
609 /* From protocol/protocol_message.c */
610
611 size_t ctdb_req_message_len(struct ctdb_req_header *h,
612                             struct ctdb_req_message *c);
613
614 int ctdb_req_message_push(struct ctdb_req_header *h,
615                           struct ctdb_req_message *c,
616                           uint8_t *buf, size_t *buflen);
617
618 int ctdb_req_message_pull(uint8_t *buf, size_t buflen,
619                           struct ctdb_req_header *h,
620                           TALLOC_CTX *mem_ctx,
621                           struct ctdb_req_message *c);
622
623 size_t ctdb_req_message_data_len(struct ctdb_req_header *h,
624                                  struct ctdb_req_message_data *c);
625
626 int ctdb_req_message_data_push(struct ctdb_req_header *h,
627                                struct ctdb_req_message_data *c,
628                                uint8_t *buf, size_t *buflen);
629
630 int ctdb_req_message_data_pull(uint8_t *buf, size_t buflen,
631                                struct ctdb_req_header *h,
632                                TALLOC_CTX *mem_ctx,
633                                struct ctdb_req_message_data *c);
634
635 /* From protocol/protocol_event.c */
636
637 void ctdb_event_header_fill(struct ctdb_event_header *h, uint32_t reqid);
638
639 size_t ctdb_event_request_len(struct ctdb_event_request *in);
640
641 int ctdb_event_request_push(struct ctdb_event_request *in,
642                             uint8_t *buf, size_t *buflen);
643
644 int ctdb_event_request_pull(uint8_t *buf, size_t buflen,
645                             TALLOC_CTX *mem_ctx,
646                             struct ctdb_event_request *out);
647
648 size_t ctdb_event_reply_len(struct ctdb_event_reply *in);
649
650 int ctdb_event_reply_push(struct ctdb_event_reply *in,
651                           uint8_t *buf, size_t *buflen);
652
653 int ctdb_event_reply_pull(uint8_t *buf, size_t buflen,
654                           TALLOC_CTX *mem_ctx,
655                           struct ctdb_event_reply *out);
656
657 /* From protocol/protocol_packet.c */
658
659 int ctdb_allocate_pkt(TALLOC_CTX *mem_ctx, size_t datalen,
660                       uint8_t **buf, size_t *buflen);
661
662 /* From protocol/protocol_util.c */
663
664 const char *ctdb_runstate_to_string(enum ctdb_runstate runstate);
665 enum ctdb_runstate ctdb_runstate_from_string(const char *runstate_str);
666
667 const char *ctdb_event_to_string(enum ctdb_event event);
668 enum ctdb_event ctdb_event_from_string(const char *event_str);
669
670 const char *ctdb_sock_addr_to_string(TALLOC_CTX *mem_ctx, ctdb_sock_addr *addr);
671 int ctdb_sock_addr_cmp_ip(const ctdb_sock_addr *addr1,
672                           const ctdb_sock_addr *addr2);
673 int ctdb_sock_addr_cmp(const ctdb_sock_addr *addr1,
674                        const ctdb_sock_addr *addr2);
675 bool ctdb_sock_addr_same_ip(const ctdb_sock_addr *addr1,
676                             const ctdb_sock_addr *addr2);
677 bool ctdb_sock_addr_same(const ctdb_sock_addr *addr1,
678                          const ctdb_sock_addr *addr2);
679
680 #endif /* __CTDB_PROTOCOL_API_H__ */