?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: libsmb: Plumb in additional_flags2 = FLAGS2_REPARSE_PATH to cli_list_trans_send().
[Samba.git] / ctdb / protocol / protocol_control.c
blobd5237ecc60913832169ca6287f474ad2251b7187
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 struct ctdb_req_control_wire {
31 struct ctdb_req_header hdr;
32 uint32_t opcode;
33 uint32_t pad;
34 uint64_t srvid;
35 uint32_t client_id;
36 uint32_t flags;
37 uint32_t datalen;
38 uint8_t data[1];
39 };
40
41 struct ctdb_reply_control_wire {
42 struct ctdb_req_header hdr;
43 int32_t status;
44 uint32_t datalen;
45 uint32_t errorlen;
46 uint8_t data[1];
47 };
48
49 static size_t ctdb_req_control_data_len(struct ctdb_req_control_data *cd)
50 {
51 size_t len = 0;
52 uint64_t u64;
53
54 if (cd == NULL) {
55 return 0;
56 }
57
58 switch (cd->opcode) {
59 case CTDB_CONTROL_PROCESS_EXISTS:
60 len = ctdb_pid_len(cd->data.pid);
61 break;
62
63 case CTDB_CONTROL_STATISTICS:
64 break;
65
66 case CTDB_CONTROL_PING:
67 break;
68
69 case CTDB_CONTROL_GETDBPATH:
70 len = ctdb_uint32_len(cd->data.db_id);
71 break;
72
73 case CTDB_CONTROL_GETVNNMAP:
74 break;
75
76 case CTDB_CONTROL_SETVNNMAP:
77 len = ctdb_vnn_map_len(cd->data.vnnmap);
78 break;
79
80 case CTDB_CONTROL_GET_DEBUG:
81 break;
82
83 case CTDB_CONTROL_SET_DEBUG:
84 len = ctdb_uint32_len(cd->data.loglevel);
85 break;
86
87 case CTDB_CONTROL_GET_DBMAP:
88 break;
89
90 case CTDB_CONTROL_PULL_DB:
91 len = ctdb_pulldb_len(cd->data.pulldb);
92 break;
93
94 case CTDB_CONTROL_PUSH_DB:
95 len = ctdb_rec_buffer_len(cd->data.recbuf);
96 break;
97
98 case CTDB_CONTROL_GET_RECMODE:
99 break;
100
101 case CTDB_CONTROL_SET_RECMODE:
102 len = ctdb_uint32_len(cd->data.recmode);
103 break;
104
105 case CTDB_CONTROL_STATISTICS_RESET:
106 break;
107
108 case CTDB_CONTROL_DB_ATTACH:
109 len = ctdb_string_len(cd->data.db_name);
110 break;
111
112 case CTDB_CONTROL_SET_CALL:
113 break;
114
115 case CTDB_CONTROL_TRAVERSE_START:
116 len = ctdb_traverse_start_len(cd->data.traverse_start);
117 break;
118
119 case CTDB_CONTROL_TRAVERSE_ALL:
120 len = ctdb_traverse_all_len(cd->data.traverse_all);
121 break;
122
123 case CTDB_CONTROL_TRAVERSE_DATA:
124 len = ctdb_rec_data_len(cd->data.rec_data);
125 break;
126
127 case CTDB_CONTROL_REGISTER_SRVID:
128 break;
129
130 case CTDB_CONTROL_DEREGISTER_SRVID:
131 break;
132
133 case CTDB_CONTROL_GET_DBNAME:
134 len = ctdb_uint32_len(cd->data.db_id);
135 break;
136
137 case CTDB_CONTROL_ENABLE_SEQNUM:
138 len = ctdb_uint32_len(cd->data.db_id);
139 break;
140
141 case CTDB_CONTROL_UPDATE_SEQNUM:
142 len = ctdb_uint32_len(cd->data.db_id);
143 break;
144
145 case CTDB_CONTROL_DUMP_MEMORY:
146 break;
147
148 case CTDB_CONTROL_GET_PID:
149 break;
150
151 case CTDB_CONTROL_GET_RECMASTER:
152 break;
153
154 case CTDB_CONTROL_SET_RECMASTER:
155 len = ctdb_uint32_len(cd->data.recmaster);
156 break;
157
158 case CTDB_CONTROL_FREEZE:
159 break;
160
161 case CTDB_CONTROL_GET_PNN:
162 break;
163
164 case CTDB_CONTROL_SHUTDOWN:
165 break;
166
167 case CTDB_CONTROL_GET_MONMODE:
168 break;
169
170 case CTDB_CONTROL_TCP_CLIENT:
171 len = ctdb_connection_len(cd->data.conn);
172 break;
173
174 case CTDB_CONTROL_TCP_ADD:
175 len = ctdb_connection_len(cd->data.conn);
176 break;
177
178 case CTDB_CONTROL_TCP_REMOVE:
179 len = ctdb_connection_len(cd->data.conn);
180 break;
181
182 case CTDB_CONTROL_STARTUP:
183 break;
184
185 case CTDB_CONTROL_SET_TUNABLE:
186 len = ctdb_tunable_len(cd->data.tunable);
187 break;
188
189 case CTDB_CONTROL_GET_TUNABLE:
190 len = ctdb_stringn_len(cd->data.tun_var);
191 break;
192
193 case CTDB_CONTROL_LIST_TUNABLES:
194 break;
195
196 case CTDB_CONTROL_MODIFY_FLAGS:
197 len = ctdb_node_flag_change_len(cd->data.flag_change);
198 break;
199
200 case CTDB_CONTROL_GET_ALL_TUNABLES:
201 break;
202
203 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
204 len = ctdb_sock_addr_len(cd->data.addr);
205 break;
206
207 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
208 len = ctdb_tickle_list_len(cd->data.tickles);
209 break;
210
211 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
212 len = ctdb_string_len(cd->data.db_name);
213 break;
214
215 case CTDB_CONTROL_UPDATE_RECORD:
216 len = ctdb_rec_buffer_len(cd->data.recbuf);
217 break;
218
219 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
220 len = ctdb_addr_info_len(cd->data.addr_info);
221 break;
222
223 case CTDB_CONTROL_WIPE_DATABASE:
224 len = ctdb_transdb_len(cd->data.transdb);
225 break;
226
227 case CTDB_CONTROL_UPTIME:
228 break;
229
230 case CTDB_CONTROL_START_RECOVERY:
231 break;
232
233 case CTDB_CONTROL_END_RECOVERY:
234 break;
235
236 case CTDB_CONTROL_RELOAD_NODES_FILE:
237 break;
238
239 case CTDB_CONTROL_TRY_DELETE_RECORDS:
240 len = ctdb_rec_buffer_len(cd->data.recbuf);
241 break;
242
243 case CTDB_CONTROL_ENABLE_MONITOR:
244 break;
245
246 case CTDB_CONTROL_DISABLE_MONITOR:
247 break;
248
249 case CTDB_CONTROL_ADD_PUBLIC_IP:
250 len = ctdb_addr_info_len(cd->data.addr_info);
251 break;
252
253 case CTDB_CONTROL_DEL_PUBLIC_IP:
254 len = ctdb_addr_info_len(cd->data.addr_info);
255 break;
256
257 case CTDB_CONTROL_RUN_EVENTSCRIPTS:
258 len = ctdb_string_len(cd->data.event_str);
259 break;
260
261 case CTDB_CONTROL_GET_CAPABILITIES:
262 break;
263
264 case CTDB_CONTROL_RECD_PING:
265 break;
266
267 case CTDB_CONTROL_RELEASE_IP:
268 len = ctdb_public_ip_len(cd->data.pubip);
269 break;
270
271 case CTDB_CONTROL_TAKEOVER_IP:
272 len = ctdb_public_ip_len(cd->data.pubip);
273 break;
274
275 case CTDB_CONTROL_GET_PUBLIC_IPS:
276 break;
277
278 case CTDB_CONTROL_GET_NODEMAP:
279 break;
280
281 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
282 len = ctdb_uint32_len(cd->data.event);
283 break;
284
285 case CTDB_CONTROL_TRAVERSE_KILL:
286 len = ctdb_traverse_start_len(cd->data.traverse_start);
287 break;
288
289 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
290 len = ctdb_double_len(cd->data.reclock_latency);
291 break;
292
293 case CTDB_CONTROL_GET_RECLOCK_FILE:
294 break;
295
296 case CTDB_CONTROL_STOP_NODE:
297 break;
298
299 case CTDB_CONTROL_CONTINUE_NODE:
300 break;
301
302 case CTDB_CONTROL_SET_LMASTERROLE:
303 len = ctdb_uint32_len(cd->data.role);
304 break;
305
306 case CTDB_CONTROL_SET_RECMASTERROLE:
307 len = ctdb_uint32_len(cd->data.role);
308 break;
309
310 case CTDB_CONTROL_ENABLE_SCRIPT:
311 len = ctdb_string_len(cd->data.script);
312 break;
313
314 case CTDB_CONTROL_DISABLE_SCRIPT:
315 len = ctdb_string_len(cd->data.script);
316 break;
317
318 case CTDB_CONTROL_SET_BAN_STATE:
319 len = ctdb_ban_state_len(cd->data.ban_state);
320 break;
321
322 case CTDB_CONTROL_GET_BAN_STATE:
323 break;
324
325 case CTDB_CONTROL_REGISTER_NOTIFY:
326 len = ctdb_notify_data_len(cd->data.notify);
327 break;
328
329 case CTDB_CONTROL_DEREGISTER_NOTIFY:
330 len = ctdb_uint64_len(cd->data.srvid);
331 break;
332
333 case CTDB_CONTROL_TRANS3_COMMIT:
334 len = ctdb_rec_buffer_len(cd->data.recbuf);
335 break;
336
337 case CTDB_CONTROL_GET_DB_SEQNUM:
338 u64 = cd->data.db_id;
339 len = ctdb_uint64_len(u64);
340 break;
341
342 case CTDB_CONTROL_DB_SET_HEALTHY:
343 len = ctdb_uint32_len(cd->data.db_id);
344 break;
345
346 case CTDB_CONTROL_DB_GET_HEALTH:
347 len = ctdb_uint32_len(cd->data.db_id);
348 break;
349
350 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
351 len = ctdb_sock_addr_len(cd->data.addr);
352 break;
353
354 case CTDB_CONTROL_GET_IFACES:
355 break;
356
357 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
358 len = ctdb_iface_len(cd->data.iface);
359 break;
360
361 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
362 len = ctdb_connection_len(cd->data.conn);
363 break;
364
365 case CTDB_CONTROL_GET_STAT_HISTORY:
366 break;
367
368 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
369 len = ctdb_key_data_len(cd->data.key);
370 break;
371
372 case CTDB_CONTROL_SET_DB_READONLY:
373 len = ctdb_uint32_len(cd->data.db_id);
374 break;
375
376 case CTDB_CONTROL_CHECK_SRVIDS:
377 len = ctdb_uint64_array_len(cd->data.u64_array);
378 break;
379
380 case CTDB_CONTROL_TRAVERSE_START_EXT:
381 len = ctdb_traverse_start_ext_len(cd->data.traverse_start_ext);
382 break;
383
384 case CTDB_CONTROL_GET_DB_STATISTICS:
385 len = ctdb_uint32_len(cd->data.db_id);
386 break;
387
388 case CTDB_CONTROL_SET_DB_STICKY:
389 len = ctdb_uint32_len(cd->data.db_id);
390 break;
391
392 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
393 break;
394
395 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
396 len = ctdb_traverse_all_ext_len(cd->data.traverse_all_ext);
397 break;
398
399 case CTDB_CONTROL_RECEIVE_RECORDS:
400 len = ctdb_rec_buffer_len(cd->data.recbuf);
401 break;
402
403 case CTDB_CONTROL_IPREALLOCATED:
404 break;
405
406 case CTDB_CONTROL_GET_RUNSTATE:
407 break;
408
409 case CTDB_CONTROL_DB_DETACH:
410 len = ctdb_uint32_len(cd->data.db_id);
411 break;
412
413 case CTDB_CONTROL_GET_NODES_FILE:
414 break;
415
416 case CTDB_CONTROL_DB_FREEZE:
417 len = ctdb_uint32_len(cd->data.db_id);
418 break;
419
420 case CTDB_CONTROL_DB_THAW:
421 len = ctdb_uint32_len(cd->data.db_id);
422 break;
423
424 case CTDB_CONTROL_DB_TRANSACTION_START:
425 len = ctdb_transdb_len(cd->data.transdb);
426 break;
427
428 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
429 len = ctdb_transdb_len(cd->data.transdb);
430 break;
431
432 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
433 len = ctdb_uint32_len(cd->data.db_id);
434 break;
435
436 case CTDB_CONTROL_DB_PULL:
437 len = ctdb_pulldb_ext_len(cd->data.pulldb_ext);
438 break;
439
440 case CTDB_CONTROL_DB_PUSH_START:
441 len = ctdb_pulldb_ext_len(cd->data.pulldb_ext);
442 break;
443
444 case CTDB_CONTROL_DB_PUSH_CONFIRM:
445 len = ctdb_uint32_len(cd->data.db_id);
446 break;
447 }
448
449 return len;
450 }
451
452 static void ctdb_req_control_data_push(struct ctdb_req_control_data *cd,
453 uint8_t *buf)
454 {
455 uint64_t u64;
456
457 switch (cd->opcode) {
458 case CTDB_CONTROL_PROCESS_EXISTS:
459 ctdb_pid_push(cd->data.pid, buf);
460 break;
461
462 case CTDB_CONTROL_GETDBPATH:
463 ctdb_uint32_push(cd->data.db_id, buf);
464 break;
465
466 case CTDB_CONTROL_SETVNNMAP:
467 ctdb_vnn_map_push(cd->data.vnnmap, buf);
468 break;
469
470 case CTDB_CONTROL_SET_DEBUG:
471 ctdb_uint32_push(cd->data.loglevel, buf);
472 break;
473
474 case CTDB_CONTROL_PULL_DB:
475 ctdb_pulldb_push(cd->data.pulldb, buf);
476 break;
477
478 case CTDB_CONTROL_PUSH_DB:
479 ctdb_rec_buffer_push(cd->data.recbuf, buf);
480 break;
481
482 case CTDB_CONTROL_SET_RECMODE:
483 ctdb_uint32_push(cd->data.recmode, buf);
484 break;
485
486 case CTDB_CONTROL_DB_ATTACH:
487 ctdb_string_push(cd->data.db_name, buf);
488 break;
489
490 case CTDB_CONTROL_SET_CALL:
491 break;
492
493 case CTDB_CONTROL_TRAVERSE_START:
494 ctdb_traverse_start_push(cd->data.traverse_start, buf);
495 break;
496
497 case CTDB_CONTROL_TRAVERSE_ALL:
498 ctdb_traverse_all_push(cd->data.traverse_all, buf);
499 break;
500
501 case CTDB_CONTROL_TRAVERSE_DATA:
502 ctdb_rec_data_push(cd->data.rec_data, buf);
503 break;
504
505 case CTDB_CONTROL_GET_DBNAME:
506 ctdb_uint32_push(cd->data.db_id, buf);
507 break;
508
509 case CTDB_CONTROL_ENABLE_SEQNUM:
510 ctdb_uint32_push(cd->data.db_id, buf);
511 break;
512
513 case CTDB_CONTROL_UPDATE_SEQNUM:
514 ctdb_uint32_push(cd->data.db_id, buf);
515 break;
516
517 case CTDB_CONTROL_SET_RECMASTER:
518 ctdb_uint32_push(cd->data.recmaster, buf);
519 break;
520
521 case CTDB_CONTROL_TCP_CLIENT:
522 ctdb_connection_push(cd->data.conn, buf);
523 break;
524
525 case CTDB_CONTROL_TCP_ADD:
526 ctdb_connection_push(cd->data.conn, buf);
527 break;
528
529 case CTDB_CONTROL_TCP_REMOVE:
530 ctdb_connection_push(cd->data.conn, buf);
531 break;
532
533 case CTDB_CONTROL_SET_TUNABLE:
534 ctdb_tunable_push(cd->data.tunable, buf);
535 break;
536
537 case CTDB_CONTROL_GET_TUNABLE:
538 ctdb_stringn_push(cd->data.tun_var, buf);
539 break;
540
541 case CTDB_CONTROL_MODIFY_FLAGS:
542 ctdb_node_flag_change_push(cd->data.flag_change, buf);
543 break;
544
545 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
546 ctdb_sock_addr_push(cd->data.addr, buf);
547 break;
548
549 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
550 ctdb_tickle_list_push(cd->data.tickles, buf);
551 break;
552
553 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
554 ctdb_string_push(cd->data.db_name, buf);
555 break;
556
557 case CTDB_CONTROL_UPDATE_RECORD:
558 ctdb_rec_buffer_push(cd->data.recbuf, buf);
559 break;
560
561 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
562 ctdb_addr_info_push(cd->data.addr_info, buf);
563 break;
564
565 case CTDB_CONTROL_WIPE_DATABASE:
566 ctdb_transdb_push(cd->data.transdb, buf);
567 break;
568
569 case CTDB_CONTROL_TRY_DELETE_RECORDS:
570 ctdb_rec_buffer_push(cd->data.recbuf, buf);
571 break;
572
573 case CTDB_CONTROL_ADD_PUBLIC_IP:
574 ctdb_addr_info_push(cd->data.addr_info, buf);
575 break;
576
577 case CTDB_CONTROL_DEL_PUBLIC_IP:
578 ctdb_addr_info_push(cd->data.addr_info, buf);
579 break;
580
581 case CTDB_CONTROL_RUN_EVENTSCRIPTS:
582 ctdb_string_push(cd->data.event_str, buf);
583 break;
584
585 case CTDB_CONTROL_RELEASE_IP:
586 ctdb_public_ip_push(cd->data.pubip, buf);
587 break;
588
589 case CTDB_CONTROL_TAKEOVER_IP:
590 ctdb_public_ip_push(cd->data.pubip, buf);
591 break;
592
593 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
594 ctdb_uint32_push(cd->data.event, buf);
595 break;
596
597 case CTDB_CONTROL_TRAVERSE_KILL:
598 ctdb_traverse_start_push(cd->data.traverse_start, buf);
599 break;
600
601 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
602 ctdb_double_push(cd->data.reclock_latency, buf);
603 break;
604
605 case CTDB_CONTROL_SET_LMASTERROLE:
606 ctdb_uint32_push(cd->data.role, buf);
607 break;
608
609 case CTDB_CONTROL_SET_RECMASTERROLE:
610 ctdb_uint32_push(cd->data.role, buf);
611 break;
612
613 case CTDB_CONTROL_ENABLE_SCRIPT:
614 ctdb_string_push(cd->data.script, buf);
615 break;
616
617 case CTDB_CONTROL_DISABLE_SCRIPT:
618 ctdb_string_push(cd->data.script, buf);
619 break;
620
621 case CTDB_CONTROL_SET_BAN_STATE:
622 ctdb_ban_state_push(cd->data.ban_state, buf);
623 break;
624
625 case CTDB_CONTROL_REGISTER_NOTIFY:
626 ctdb_notify_data_push(cd->data.notify, buf);
627 break;
628
629 case CTDB_CONTROL_DEREGISTER_NOTIFY:
630 ctdb_uint64_push(cd->data.srvid, buf);
631 break;
632
633 case CTDB_CONTROL_TRANS3_COMMIT:
634 ctdb_rec_buffer_push(cd->data.recbuf, buf);
635 break;
636
637 case CTDB_CONTROL_GET_DB_SEQNUM:
638 u64 = cd->data.db_id;
639 ctdb_uint64_push(u64, buf);
640 break;
641
642 case CTDB_CONTROL_DB_SET_HEALTHY:
643 ctdb_uint32_push(cd->data.db_id, buf);
644 break;
645
646 case CTDB_CONTROL_DB_GET_HEALTH:
647 ctdb_uint32_push(cd->data.db_id, buf);
648 break;
649
650 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
651 ctdb_sock_addr_push(cd->data.addr, buf);
652 break;
653
654 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
655 ctdb_iface_push(cd->data.iface, buf);
656 break;
657
658 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
659 ctdb_connection_push(cd->data.conn, buf);
660 break;
661
662 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
663 ctdb_key_data_push(cd->data.key, buf);
664 break;
665
666 case CTDB_CONTROL_SET_DB_READONLY:
667 ctdb_uint32_push(cd->data.db_id, buf);
668 break;
669
670 case CTDB_CONTROL_CHECK_SRVIDS:
671 ctdb_uint64_array_push(cd->data.u64_array, buf);
672 break;
673
674 case CTDB_CONTROL_TRAVERSE_START_EXT:
675 ctdb_traverse_start_ext_push(cd->data.traverse_start_ext, buf);
676 break;
677
678 case CTDB_CONTROL_GET_DB_STATISTICS:
679 ctdb_uint32_push(cd->data.db_id, buf);
680 break;
681
682 case CTDB_CONTROL_SET_DB_STICKY:
683 ctdb_uint32_push(cd->data.db_id, buf);
684 break;
685
686 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
687 ctdb_traverse_all_ext_push(cd->data.traverse_all_ext, buf);
688 break;
689
690 case CTDB_CONTROL_RECEIVE_RECORDS:
691 ctdb_rec_buffer_push(cd->data.recbuf, buf);
692 break;
693
694 case CTDB_CONTROL_DB_DETACH:
695 ctdb_uint32_push(cd->data.db_id, buf);
696 break;
697
698 case CTDB_CONTROL_DB_FREEZE:
699 ctdb_uint32_push(cd->data.db_id, buf);
700 break;
701
702 case CTDB_CONTROL_DB_THAW:
703 ctdb_uint32_push(cd->data.db_id, buf);
704 break;
705
706 case CTDB_CONTROL_DB_TRANSACTION_START:
707 ctdb_transdb_push(cd->data.transdb, buf);
708 break;
709
710 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
711 ctdb_transdb_push(cd->data.transdb, buf);
712 break;
713
714 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
715 ctdb_uint32_push(cd->data.db_id, buf);
716 break;
717
718 case CTDB_CONTROL_DB_PULL:
719 ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf);
720 break;
721
722 case CTDB_CONTROL_DB_PUSH_START:
723 ctdb_pulldb_ext_push(cd->data.pulldb_ext, buf);
724 break;
725
726 case CTDB_CONTROL_DB_PUSH_CONFIRM:
727 ctdb_uint32_push(cd->data.db_id, buf);
728 break;
729 }
730 }
731
732 static int ctdb_req_control_data_pull(uint8_t *buf, size_t buflen,
733 uint32_t opcode,
734 TALLOC_CTX *mem_ctx,
735 struct ctdb_req_control_data *cd)
736 {
737 int ret = 0;
738 uint64_t u64 = 0;
739
740 cd->opcode = opcode;
741
742 switch (opcode) {
743 case CTDB_CONTROL_PROCESS_EXISTS:
744 ret = ctdb_pid_pull(buf, buflen, mem_ctx,
745 &cd->data.pid);
746 break;
747
748 case CTDB_CONTROL_GETDBPATH:
749 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
750 &cd->data.db_id);
751 break;
752
753 case CTDB_CONTROL_SETVNNMAP:
754 ret = ctdb_vnn_map_pull(buf, buflen, mem_ctx,
755 &cd->data.vnnmap);
756 break;
757
758 case CTDB_CONTROL_SET_DEBUG:
759 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
760 &cd->data.loglevel);
761 break;
762
763 case CTDB_CONTROL_PULL_DB:
764 ret = ctdb_pulldb_pull(buf, buflen, mem_ctx,
765 &cd->data.pulldb);
766 break;
767
768 case CTDB_CONTROL_PUSH_DB:
769 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
770 &cd->data.recbuf);
771 break;
772
773 case CTDB_CONTROL_SET_RECMODE:
774 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
775 &cd->data.recmode);
776 break;
777
778 case CTDB_CONTROL_DB_ATTACH:
779 ret = ctdb_string_pull(buf, buflen, mem_ctx,
780 &cd->data.db_name);
781 break;
782
783 case CTDB_CONTROL_SET_CALL:
784 break;
785
786 case CTDB_CONTROL_TRAVERSE_START:
787 ret = ctdb_traverse_start_pull(buf, buflen, mem_ctx,
788 &cd->data.traverse_start);
789 break;
790
791 case CTDB_CONTROL_TRAVERSE_ALL:
792 ret = ctdb_traverse_all_pull(buf, buflen, mem_ctx,
793 &cd->data.traverse_all);
794 break;
795
796 case CTDB_CONTROL_TRAVERSE_DATA:
797 ret = ctdb_rec_data_pull(buf, buflen, mem_ctx,
798 &cd->data.rec_data);
799 break;
800
801 case CTDB_CONTROL_GET_DBNAME:
802 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
803 &cd->data.db_id);
804 break;
805
806 case CTDB_CONTROL_ENABLE_SEQNUM:
807 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
808 &cd->data.db_id);
809 break;
810
811 case CTDB_CONTROL_UPDATE_SEQNUM:
812 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
813 &cd->data.db_id);
814 break;
815
816 case CTDB_CONTROL_SET_RECMASTER:
817 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
818 &cd->data.recmaster);
819 break;
820
821 case CTDB_CONTROL_TCP_CLIENT:
822 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
823 &cd->data.conn);
824 break;
825
826 case CTDB_CONTROL_TCP_ADD:
827 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
828 &cd->data.conn);
829 break;
830
831 case CTDB_CONTROL_TCP_REMOVE:
832 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
833 &cd->data.conn);
834 break;
835
836 case CTDB_CONTROL_SET_TUNABLE:
837 ret = ctdb_tunable_pull(buf, buflen, mem_ctx,
838 &cd->data.tunable);
839 break;
840
841 case CTDB_CONTROL_GET_TUNABLE:
842 ret = ctdb_stringn_pull(buf, buflen, mem_ctx,
843 &cd->data.tun_var);
844 break;
845
846 case CTDB_CONTROL_MODIFY_FLAGS:
847 ret = ctdb_node_flag_change_pull(buf, buflen, mem_ctx,
848 &cd->data.flag_change);
849 break;
850
851 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
852 ret = ctdb_sock_addr_pull(buf, buflen, mem_ctx,
853 &cd->data.addr);
854 break;
855
856 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
857 ret = ctdb_tickle_list_pull(buf, buflen, mem_ctx,
858 &cd->data.tickles);
859 break;
860
861 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
862 ret = ctdb_string_pull(buf, buflen, mem_ctx,
863 &cd->data.db_name);
864 break;
865
866 case CTDB_CONTROL_UPDATE_RECORD:
867 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
868 &cd->data.recbuf);
869 break;
870
871 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
872 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
873 &cd->data.addr_info);
874 break;
875
876 case CTDB_CONTROL_WIPE_DATABASE:
877 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
878 &cd->data.transdb);
879 break;
880
881 case CTDB_CONTROL_TRY_DELETE_RECORDS:
882 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
883 &cd->data.recbuf);
884 break;
885
886 case CTDB_CONTROL_ADD_PUBLIC_IP:
887 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
888 &cd->data.addr_info);
889 break;
890
891 case CTDB_CONTROL_DEL_PUBLIC_IP:
892 ret = ctdb_addr_info_pull(buf, buflen, mem_ctx,
893 &cd->data.addr_info);
894 break;
895
896 case CTDB_CONTROL_RUN_EVENTSCRIPTS:
897 ret = ctdb_string_pull(buf, buflen, mem_ctx,
898 &cd->data.event_str);
899 break;
900
901 case CTDB_CONTROL_RELEASE_IP:
902 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
903 &cd->data.pubip);
904 break;
905
906 case CTDB_CONTROL_TAKEOVER_IP:
907 ret = ctdb_public_ip_pull(buf, buflen, mem_ctx,
908 &cd->data.pubip);
909 break;
910
911 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
912 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
913 &cd->data.event);
914 break;
915
916 case CTDB_CONTROL_TRAVERSE_KILL:
917 ret = ctdb_traverse_start_pull(buf, buflen, mem_ctx,
918 &cd->data.traverse_start);
919 break;
920
921 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
922 ret = ctdb_double_pull(buf, buflen, mem_ctx,
923 &cd->data.reclock_latency);
924 break;
925
926 case CTDB_CONTROL_SET_LMASTERROLE:
927 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
928 &cd->data.role);
929 break;
930
931 case CTDB_CONTROL_SET_RECMASTERROLE:
932 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
933 &cd->data.role);
934 break;
935
936 case CTDB_CONTROL_ENABLE_SCRIPT:
937 ret = ctdb_string_pull(buf, buflen, mem_ctx,
938 &cd->data.script);
939 break;
940
941 case CTDB_CONTROL_DISABLE_SCRIPT:
942 ret = ctdb_string_pull(buf, buflen, mem_ctx,
943 &cd->data.script);
944 break;
945
946 case CTDB_CONTROL_SET_BAN_STATE:
947 ret = ctdb_ban_state_pull(buf, buflen, mem_ctx,
948 &cd->data.ban_state);
949 break;
950
951 case CTDB_CONTROL_REGISTER_NOTIFY:
952 ret = ctdb_notify_data_pull(buf, buflen, mem_ctx,
953 &cd->data.notify);
954 break;
955
956 case CTDB_CONTROL_DEREGISTER_NOTIFY:
957 ctdb_uint64_pull(buf, buflen, mem_ctx,
958 &cd->data.srvid);
959 break;
960
961 case CTDB_CONTROL_TRANS3_COMMIT:
962 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
963 &cd->data.recbuf);
964 break;
965
966 case CTDB_CONTROL_GET_DB_SEQNUM:
967 ret = ctdb_uint64_pull(buf, buflen, mem_ctx, &u64);
968 cd->data.db_id = (uint32_t)u64;
969 break;
970
971 case CTDB_CONTROL_DB_SET_HEALTHY:
972 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
973 &cd->data.db_id);
974 break;
975
976 case CTDB_CONTROL_DB_GET_HEALTH:
977 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
978 &cd->data.db_id);
979 break;
980
981 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
982 ret = ctdb_sock_addr_pull(buf, buflen, mem_ctx,
983 &cd->data.addr);
984 break;
985
986 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
987 ret = ctdb_iface_pull(buf, buflen, mem_ctx,
988 &cd->data.iface);
989 break;
990
991 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
992 ret = ctdb_connection_pull(buf, buflen, mem_ctx,
993 &cd->data.conn);
994 break;
995
996 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
997 ret = ctdb_key_data_pull(buf, buflen, mem_ctx,
998 &cd->data.key);
999 break;
1000
1001 case CTDB_CONTROL_SET_DB_READONLY:
1002 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1003 &cd->data.db_id);
1004 break;
1005
1006 case CTDB_CONTROL_CHECK_SRVIDS:
1007 ret = ctdb_uint64_array_pull(buf, buflen, mem_ctx,
1008 &cd->data.u64_array);
1009 break;
1010
1011 case CTDB_CONTROL_TRAVERSE_START_EXT:
1012 ret = ctdb_traverse_start_ext_pull(buf, buflen, mem_ctx,
1013 &cd->data.traverse_start_ext);
1014 break;
1015
1016 case CTDB_CONTROL_GET_DB_STATISTICS:
1017 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1018 &cd->data.db_id);
1019 break;
1020
1021 case CTDB_CONTROL_SET_DB_STICKY:
1022 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1023 &cd->data.db_id);
1024 break;
1025
1026 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1027 ret = ctdb_traverse_all_ext_pull(buf, buflen, mem_ctx,
1028 &cd->data.traverse_all_ext);
1029 break;
1030
1031 case CTDB_CONTROL_RECEIVE_RECORDS:
1032 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1033 &cd->data.recbuf);
1034 break;
1035
1036 case CTDB_CONTROL_DB_DETACH:
1037 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1038 &cd->data.db_id);
1039 break;
1040
1041 case CTDB_CONTROL_DB_FREEZE:
1042 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1043 &cd->data.db_id);
1044 break;
1045
1046 case CTDB_CONTROL_DB_THAW:
1047 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1048 &cd->data.db_id);
1049 break;
1050
1051 case CTDB_CONTROL_DB_TRANSACTION_START:
1052 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
1053 &cd->data.transdb);
1054 break;
1055
1056 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
1057 ret = ctdb_transdb_pull(buf, buflen, mem_ctx,
1058 &cd->data.transdb);
1059 break;
1060
1061 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
1062 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1063 &cd->data.db_id);
1064 break;
1065
1066 case CTDB_CONTROL_DB_PULL:
1067 ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
1068 &cd->data.pulldb_ext);
1069 break;
1070
1071 case CTDB_CONTROL_DB_PUSH_START:
1072 ret = ctdb_pulldb_ext_pull(buf, buflen, mem_ctx,
1073 &cd->data.pulldb_ext);
1074 break;
1075
1076 case CTDB_CONTROL_DB_PUSH_CONFIRM:
1077 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1078 &cd->data.db_id);
1079 break;
1080 }
1081
1082 return ret;
1083 }
1084
1085 static size_t ctdb_reply_control_data_len(struct ctdb_reply_control_data *cd)
1086 {
1087 size_t len = 0;
1088
1089 if (cd == NULL) {
1090 return 0;
1091 }
1092
1093 switch (cd->opcode) {
1094 case CTDB_CONTROL_PROCESS_EXISTS:
1095 break;
1096
1097 case CTDB_CONTROL_STATISTICS:
1098 len = ctdb_statistics_len(cd->data.stats);
1099 break;
1100
1101 case CTDB_CONTROL_PING:
1102 break;
1103
1104 case CTDB_CONTROL_GETDBPATH:
1105 len = ctdb_string_len(cd->data.db_path);
1106 break;
1107
1108 case CTDB_CONTROL_GETVNNMAP:
1109 len = ctdb_vnn_map_len(cd->data.vnnmap);
1110 break;
1111
1112 case CTDB_CONTROL_SETVNNMAP:
1113 break;
1114
1115 case CTDB_CONTROL_GET_DEBUG:
1116 len = ctdb_uint32_len(cd->data.loglevel);
1117 break;
1118
1119 case CTDB_CONTROL_SET_DEBUG:
1120 break;
1121
1122 case CTDB_CONTROL_GET_DBMAP:
1123 len = ctdb_dbid_map_len(cd->data.dbmap);
1124 break;
1125
1126 case CTDB_CONTROL_PULL_DB:
1127 len = ctdb_rec_buffer_len(cd->data.recbuf);
1128 break;
1129
1130 case CTDB_CONTROL_PUSH_DB:
1131 break;
1132
1133 case CTDB_CONTROL_GET_RECMODE:
1134 break;
1135
1136 case CTDB_CONTROL_SET_RECMODE:
1137 break;
1138
1139 case CTDB_CONTROL_STATISTICS_RESET:
1140 break;
1141
1142 case CTDB_CONTROL_DB_ATTACH:
1143 len = ctdb_uint32_len(cd->data.db_id);
1144 break;
1145
1146 case CTDB_CONTROL_SET_CALL:
1147 break;
1148
1149 case CTDB_CONTROL_TRAVERSE_START:
1150 break;
1151
1152 case CTDB_CONTROL_TRAVERSE_ALL:
1153 break;
1154
1155 case CTDB_CONTROL_TRAVERSE_DATA:
1156 break;
1157
1158 case CTDB_CONTROL_REGISTER_SRVID:
1159 break;
1160
1161 case CTDB_CONTROL_DEREGISTER_SRVID:
1162 break;
1163
1164 case CTDB_CONTROL_GET_DBNAME:
1165 len = ctdb_string_len(cd->data.db_name);
1166 break;
1167
1168 case CTDB_CONTROL_ENABLE_SEQNUM:
1169 break;
1170
1171 case CTDB_CONTROL_UPDATE_SEQNUM:
1172 break;
1173
1174 case CTDB_CONTROL_DUMP_MEMORY:
1175 len = ctdb_string_len(cd->data.mem_str);
1176 break;
1177
1178 case CTDB_CONTROL_GET_PID:
1179 break;
1180
1181 case CTDB_CONTROL_GET_RECMASTER:
1182 break;
1183
1184 case CTDB_CONTROL_SET_RECMASTER:
1185 break;
1186
1187 case CTDB_CONTROL_FREEZE:
1188 break;
1189
1190 case CTDB_CONTROL_GET_PNN:
1191 break;
1192
1193 case CTDB_CONTROL_SHUTDOWN:
1194 break;
1195
1196 case CTDB_CONTROL_GET_MONMODE:
1197 break;
1198
1199 case CTDB_CONTROL_TCP_CLIENT:
1200 break;
1201
1202 case CTDB_CONTROL_TCP_ADD:
1203 break;
1204
1205 case CTDB_CONTROL_TCP_REMOVE:
1206 break;
1207
1208 case CTDB_CONTROL_STARTUP:
1209 break;
1210
1211 case CTDB_CONTROL_SET_TUNABLE:
1212 break;
1213
1214 case CTDB_CONTROL_GET_TUNABLE:
1215 len = ctdb_uint32_len(cd->data.tun_value);
1216 break;
1217
1218 case CTDB_CONTROL_LIST_TUNABLES:
1219 len = ctdb_var_list_len(cd->data.tun_var_list);
1220 break;
1221
1222 case CTDB_CONTROL_MODIFY_FLAGS:
1223 break;
1224
1225 case CTDB_CONTROL_GET_ALL_TUNABLES:
1226 len = ctdb_tunable_list_len(cd->data.tun_list);
1227 break;
1228
1229 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1230 len = ctdb_tickle_list_len(cd->data.tickles);
1231 break;
1232
1233 case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
1234 break;
1235
1236 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1237 len = ctdb_uint32_len(cd->data.db_id);
1238 break;
1239
1240 case CTDB_CONTROL_UPDATE_RECORD:
1241 break;
1242
1243 case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
1244 break;
1245
1246 case CTDB_CONTROL_WIPE_DATABASE:
1247 break;
1248
1249 case CTDB_CONTROL_UPTIME:
1250 len = ctdb_uptime_len(cd->data.uptime);
1251 break;
1252
1253 case CTDB_CONTROL_START_RECOVERY:
1254 break;
1255
1256 case CTDB_CONTROL_END_RECOVERY:
1257 break;
1258
1259 case CTDB_CONTROL_RELOAD_NODES_FILE:
1260 break;
1261
1262 case CTDB_CONTROL_TRY_DELETE_RECORDS:
1263 len = ctdb_rec_buffer_len(cd->data.recbuf);
1264 break;
1265
1266 case CTDB_CONTROL_ENABLE_MONITOR:
1267 break;
1268
1269 case CTDB_CONTROL_DISABLE_MONITOR:
1270 break;
1271
1272 case CTDB_CONTROL_ADD_PUBLIC_IP:
1273 break;
1274
1275 case CTDB_CONTROL_DEL_PUBLIC_IP:
1276 break;
1277
1278 case CTDB_CONTROL_RUN_EVENTSCRIPTS:
1279 break;
1280
1281 case CTDB_CONTROL_GET_CAPABILITIES:
1282 len = ctdb_uint32_len(cd->data.caps);
1283 break;
1284
1285 case CTDB_CONTROL_RECD_PING:
1286 break;
1287
1288 case CTDB_CONTROL_RELEASE_IP:
1289 break;
1290
1291 case CTDB_CONTROL_TAKEOVER_IP:
1292 break;
1293
1294 case CTDB_CONTROL_GET_PUBLIC_IPS:
1295 len = ctdb_public_ip_list_len(cd->data.pubip_list);
1296 break;
1297
1298 case CTDB_CONTROL_GET_NODEMAP:
1299 len = ctdb_node_map_len(cd->data.nodemap);
1300 break;
1301
1302 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
1303 len = ctdb_script_list_len(cd->data.script_list);
1304 break;
1305
1306 case CTDB_CONTROL_TRAVERSE_KILL:
1307 break;
1308
1309 case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
1310 break;
1311
1312 case CTDB_CONTROL_GET_RECLOCK_FILE:
1313 len = ctdb_string_len(cd->data.reclock_file);
1314 break;
1315
1316 case CTDB_CONTROL_STOP_NODE:
1317 break;
1318
1319 case CTDB_CONTROL_CONTINUE_NODE:
1320 break;
1321
1322 case CTDB_CONTROL_SET_LMASTERROLE:
1323 break;
1324
1325 case CTDB_CONTROL_SET_RECMASTERROLE:
1326 break;
1327
1328 case CTDB_CONTROL_ENABLE_SCRIPT:
1329 break;
1330
1331 case CTDB_CONTROL_DISABLE_SCRIPT:
1332 break;
1333
1334 case CTDB_CONTROL_SET_BAN_STATE:
1335 break;
1336
1337 case CTDB_CONTROL_GET_BAN_STATE:
1338 len = ctdb_ban_state_len(cd->data.ban_state);
1339 break;
1340
1341 case CTDB_CONTROL_SET_DB_PRIORITY:
1342 break;
1343
1344 case CTDB_CONTROL_GET_DB_PRIORITY:
1345 break;
1346
1347 case CTDB_CONTROL_REGISTER_NOTIFY:
1348 break;
1349
1350 case CTDB_CONTROL_DEREGISTER_NOTIFY:
1351 break;
1352
1353 case CTDB_CONTROL_TRANS3_COMMIT:
1354 break;
1355
1356 case CTDB_CONTROL_GET_DB_SEQNUM:
1357 len = ctdb_uint64_len(cd->data.seqnum);
1358 break;
1359
1360 case CTDB_CONTROL_DB_SET_HEALTHY:
1361 break;
1362
1363 case CTDB_CONTROL_DB_GET_HEALTH:
1364 len = ctdb_string_len(cd->data.reason);
1365 break;
1366
1367 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1368 len = ctdb_public_ip_info_len(cd->data.ipinfo);
1369 break;
1370
1371 case CTDB_CONTROL_GET_IFACES:
1372 len = ctdb_iface_list_len(cd->data.iface_list);
1373 break;
1374
1375 case CTDB_CONTROL_SET_IFACE_LINK_STATE:
1376 break;
1377
1378 case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
1379 break;
1380
1381 case CTDB_CONTROL_GET_STAT_HISTORY:
1382 len = ctdb_statistics_list_len(cd->data.stats_list);
1383 break;
1384
1385 case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
1386 break;
1387
1388 case CTDB_CONTROL_SET_DB_READONLY:
1389 break;
1390
1391 case CTDB_CONTROL_CHECK_SRVIDS:
1392 len = ctdb_uint8_array_len(cd->data.u8_array);
1393 break;
1394
1395 case CTDB_CONTROL_TRAVERSE_START_EXT:
1396 break;
1397
1398 case CTDB_CONTROL_GET_DB_STATISTICS:
1399 len = ctdb_db_statistics_len(cd->data.dbstats);
1400 break;
1401
1402 case CTDB_CONTROL_SET_DB_STICKY:
1403 break;
1404
1405 case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
1406 break;
1407
1408 case CTDB_CONTROL_TRAVERSE_ALL_EXT:
1409 break;
1410
1411 case CTDB_CONTROL_RECEIVE_RECORDS:
1412 len = ctdb_rec_buffer_len(cd->data.recbuf);
1413 break;
1414
1415 case CTDB_CONTROL_IPREALLOCATED:
1416 break;
1417
1418 case CTDB_CONTROL_GET_RUNSTATE:
1419 len = ctdb_uint32_len(cd->data.runstate);
1420 break;
1421
1422 case CTDB_CONTROL_DB_DETACH:
1423 break;
1424
1425 case CTDB_CONTROL_GET_NODES_FILE:
1426 len = ctdb_node_map_len(cd->data.nodemap);
1427 break;
1428
1429 case CTDB_CONTROL_DB_FREEZE:
1430 break;
1431
1432 case CTDB_CONTROL_DB_THAW:
1433 break;
1434
1435 case CTDB_CONTROL_DB_TRANSACTION_START:
1436 break;
1437
1438 case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
1439 break;
1440
1441 case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
1442 break;
1443
1444 case CTDB_CONTROL_DB_PULL:
1445 len = ctdb_uint32_len(cd->data.num_records);
1446 break;
1447
1448 case CTDB_CONTROL_DB_PUSH_START:
1449 break;
1450
1451 case CTDB_CONTROL_DB_PUSH_CONFIRM:
1452 len = ctdb_uint32_len(cd->data.num_records);
1453 break;
1454 }
1455
1456 return len;
1457 }
1458
1459 static void ctdb_reply_control_data_push(struct ctdb_reply_control_data *cd,
1460 uint8_t *buf)
1461 {
1462 switch (cd->opcode) {
1463 case CTDB_CONTROL_STATISTICS:
1464 ctdb_statistics_push(cd->data.stats, buf);
1465 break;
1466
1467 case CTDB_CONTROL_GETDBPATH:
1468 ctdb_string_push(cd->data.db_path, buf);
1469 break;
1470
1471 case CTDB_CONTROL_GETVNNMAP:
1472 ctdb_vnn_map_push(cd->data.vnnmap, buf);
1473 break;
1474
1475 case CTDB_CONTROL_GET_DEBUG:
1476 ctdb_uint32_push(cd->data.loglevel, buf);
1477 break;
1478
1479 case CTDB_CONTROL_GET_DBMAP:
1480 ctdb_dbid_map_push(cd->data.dbmap, buf);
1481 break;
1482
1483 case CTDB_CONTROL_PULL_DB:
1484 ctdb_rec_buffer_push(cd->data.recbuf, buf);
1485 break;
1486
1487 case CTDB_CONTROL_PUSH_DB:
1488 break;
1489
1490 case CTDB_CONTROL_DB_ATTACH:
1491 ctdb_uint32_push(cd->data.db_id, buf);
1492 break;
1493
1494 case CTDB_CONTROL_GET_DBNAME:
1495 ctdb_string_push(cd->data.db_name, buf);
1496 break;
1497
1498 case CTDB_CONTROL_DUMP_MEMORY:
1499 ctdb_string_push(cd->data.mem_str, buf);
1500 break;
1501
1502 case CTDB_CONTROL_GET_PID:
1503 break;
1504
1505 case CTDB_CONTROL_GET_RECMASTER:
1506 break;
1507
1508 case CTDB_CONTROL_GET_TUNABLE:
1509 ctdb_uint32_push(cd->data.tun_value, buf);
1510 break;
1511
1512 case CTDB_CONTROL_LIST_TUNABLES:
1513 ctdb_var_list_push(cd->data.tun_var_list, buf);
1514 break;
1515
1516 case CTDB_CONTROL_GET_ALL_TUNABLES:
1517 ctdb_tunable_list_push(cd->data.tun_list, buf);
1518 break;
1519
1520 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1521 ctdb_tickle_list_push(cd->data.tickles, buf);
1522 break;
1523
1524 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1525 ctdb_uint32_push(cd->data.db_id, buf);
1526 break;
1527
1528 case CTDB_CONTROL_UPTIME:
1529 ctdb_uptime_push(cd->data.uptime, buf);
1530 break;
1531
1532 case CTDB_CONTROL_TRY_DELETE_RECORDS:
1533 ctdb_rec_buffer_push(cd->data.recbuf, buf);
1534 break;
1535
1536 case CTDB_CONTROL_GET_CAPABILITIES:
1537 ctdb_uint32_push(cd->data.caps, buf);
1538 break;
1539
1540 case CTDB_CONTROL_GET_PUBLIC_IPS:
1541 ctdb_public_ip_list_push(cd->data.pubip_list, buf);
1542 break;
1543
1544 case CTDB_CONTROL_GET_NODEMAP:
1545 ctdb_node_map_push(cd->data.nodemap, buf);
1546 break;
1547
1548 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
1549 ctdb_script_list_push(cd->data.script_list, buf);
1550 break;
1551
1552 case CTDB_CONTROL_GET_RECLOCK_FILE:
1553 ctdb_string_push(cd->data.reclock_file, buf);
1554 break;
1555
1556 case CTDB_CONTROL_GET_BAN_STATE:
1557 ctdb_ban_state_push(cd->data.ban_state, buf);
1558 break;
1559
1560 case CTDB_CONTROL_GET_DB_PRIORITY:
1561 break;
1562
1563 case CTDB_CONTROL_GET_DB_SEQNUM:
1564 ctdb_uint64_push(cd->data.seqnum, buf);
1565 break;
1566
1567 case CTDB_CONTROL_DB_GET_HEALTH:
1568 ctdb_string_push(cd->data.reason, buf);
1569 break;
1570
1571 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1572 ctdb_public_ip_info_push(cd->data.ipinfo, buf);
1573 break;
1574
1575 case CTDB_CONTROL_GET_IFACES:
1576 ctdb_iface_list_push(cd->data.iface_list, buf);
1577 break;
1578
1579 case CTDB_CONTROL_GET_STAT_HISTORY:
1580 ctdb_statistics_list_push(cd->data.stats_list, buf);
1581 break;
1582
1583 case CTDB_CONTROL_CHECK_SRVIDS:
1584 ctdb_uint8_array_push(cd->data.u8_array, buf);
1585 break;
1586
1587 case CTDB_CONTROL_GET_DB_STATISTICS:
1588 ctdb_db_statistics_push(cd->data.dbstats, buf);
1589 break;
1590
1591 case CTDB_CONTROL_RECEIVE_RECORDS:
1592 ctdb_rec_buffer_push(cd->data.recbuf, buf);
1593 break;
1594
1595 case CTDB_CONTROL_GET_RUNSTATE:
1596 ctdb_uint32_push(cd->data.runstate, buf);
1597 break;
1598
1599 case CTDB_CONTROL_GET_NODES_FILE:
1600 ctdb_node_map_push(cd->data.nodemap, buf);
1601 break;
1602
1603 case CTDB_CONTROL_DB_PULL:
1604 ctdb_uint32_push(cd->data.num_records, buf);
1605 break;
1606
1607 case CTDB_CONTROL_DB_PUSH_CONFIRM:
1608 ctdb_uint32_push(cd->data.num_records, buf);
1609 break;
1610 }
1611 }
1612
1613 static int ctdb_reply_control_data_pull(uint8_t *buf, size_t buflen,
1614 uint32_t opcode, TALLOC_CTX *mem_ctx,
1615 struct ctdb_reply_control_data *cd)
1616 {
1617 int ret = 0;
1618 cd->opcode = opcode;
1619
1620 switch (opcode) {
1621 case CTDB_CONTROL_STATISTICS:
1622 ret = ctdb_statistics_pull(buf, buflen, mem_ctx,
1623 &cd->data.stats);
1624 break;
1625
1626 case CTDB_CONTROL_GETDBPATH:
1627 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1628 &cd->data.db_path);
1629 break;
1630
1631 case CTDB_CONTROL_GETVNNMAP:
1632 ret = ctdb_vnn_map_pull(buf, buflen, mem_ctx,
1633 &cd->data.vnnmap);
1634 break;
1635
1636 case CTDB_CONTROL_GET_DEBUG:
1637 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1638 &cd->data.loglevel);
1639 break;
1640
1641 case CTDB_CONTROL_GET_DBMAP:
1642 ret = ctdb_dbid_map_pull(buf, buflen, mem_ctx,
1643 &cd->data.dbmap);
1644 break;
1645
1646 case CTDB_CONTROL_PULL_DB:
1647 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1648 &cd->data.recbuf);
1649 break;
1650
1651 case CTDB_CONTROL_PUSH_DB:
1652 break;
1653
1654 case CTDB_CONTROL_DB_ATTACH:
1655 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1656 &cd->data.db_id);
1657 break;
1658
1659 case CTDB_CONTROL_GET_DBNAME:
1660 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1661 &cd->data.db_name);
1662 break;
1663
1664 case CTDB_CONTROL_DUMP_MEMORY:
1665 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1666 &cd->data.mem_str);
1667 break;
1668
1669 case CTDB_CONTROL_GET_PID:
1670 break;
1671
1672 case CTDB_CONTROL_GET_RECMASTER:
1673 break;
1674
1675 case CTDB_CONTROL_GET_TUNABLE:
1676 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1677 &cd->data.tun_value);
1678 break;
1679
1680 case CTDB_CONTROL_LIST_TUNABLES:
1681 ret = ctdb_var_list_pull(buf, buflen, mem_ctx,
1682 &cd->data.tun_var_list);
1683 break;
1684
1685 case CTDB_CONTROL_GET_ALL_TUNABLES:
1686 ret = ctdb_tunable_list_pull(buf, buflen, mem_ctx,
1687 &cd->data.tun_list);
1688 break;
1689
1690 case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
1691 ret = ctdb_tickle_list_pull(buf, buflen, mem_ctx,
1692 &cd->data.tickles);
1693 break;
1694
1695 case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
1696 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1697 &cd->data.db_id);
1698 break;
1699
1700 case CTDB_CONTROL_UPTIME:
1701 ret = ctdb_uptime_pull(buf, buflen, mem_ctx,
1702 &cd->data.uptime);
1703 break;
1704
1705 case CTDB_CONTROL_TRY_DELETE_RECORDS:
1706 ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1707 &cd->data.recbuf);
1708 break;
1709
1710 case CTDB_CONTROL_GET_CAPABILITIES:
1711 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1712 &cd->data.caps);
1713 break;
1714
1715 case CTDB_CONTROL_GET_PUBLIC_IPS:
1716 ret = ctdb_public_ip_list_pull(buf, buflen, mem_ctx,
1717 &cd->data.pubip_list);
1718 break;
1719
1720 case CTDB_CONTROL_GET_NODEMAP:
1721 ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
1722 &cd->data.nodemap);
1723 break;
1724
1725 case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
1726 ret = ctdb_script_list_pull(buf, buflen, mem_ctx,
1727 &cd->data.script_list);
1728 break;
1729
1730 case CTDB_CONTROL_GET_RECLOCK_FILE:
1731 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1732 &cd->data.reclock_file);
1733 break;
1734
1735 case CTDB_CONTROL_GET_BAN_STATE:
1736 ret = ctdb_ban_state_pull(buf, buflen, mem_ctx,
1737 &cd->data.ban_state);
1738 break;
1739
1740 case CTDB_CONTROL_GET_DB_PRIORITY:
1741 break;
1742
1743 case CTDB_CONTROL_GET_DB_SEQNUM:
1744 ret = ctdb_uint64_pull(buf, buflen, mem_ctx,
1745 &cd->data.seqnum);
1746 break;
1747
1748 case CTDB_CONTROL_DB_GET_HEALTH:
1749 ret = ctdb_string_pull(buf, buflen, mem_ctx,
1750 &cd->data.reason);
1751 break;
1752
1753 case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
1754 ret = ctdb_public_ip_info_pull(buf, buflen, mem_ctx,
1755 &cd->data.ipinfo);
1756 break;
1757
1758 case CTDB_CONTROL_GET_IFACES:
1759 ret = ctdb_iface_list_pull(buf, buflen, mem_ctx,
1760 &cd->data.iface_list);
1761 break;
1762
1763 case CTDB_CONTROL_GET_STAT_HISTORY:
1764 ret = ctdb_statistics_list_pull(buf, buflen, mem_ctx,
1765 &cd->data.stats_list);
1766 break;
1767
1768 case CTDB_CONTROL_CHECK_SRVIDS:
1769 ret = ctdb_uint8_array_pull(buf, buflen, mem_ctx,
1770 &cd->data.u8_array);
1771 break;
1772
1773 case CTDB_CONTROL_GET_DB_STATISTICS:
1774 ret = ctdb_db_statistics_pull(buf, buflen, mem_ctx,
1775 &cd->data.dbstats);
1776 break;
1777
1778 case CTDB_CONTROL_RECEIVE_RECORDS:
1779 ret = ctdb_rec_buffer_pull(buf, buflen, mem_ctx,
1780 &cd->data.recbuf);
1781 break;
1782
1783 case CTDB_CONTROL_GET_RUNSTATE:
1784 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1785 &cd->data.runstate);
1786 break;
1787
1788 case CTDB_CONTROL_GET_NODES_FILE:
1789 ret = ctdb_node_map_pull(buf, buflen, mem_ctx,
1790 &cd->data.nodemap);
1791 break;
1792
1793 case CTDB_CONTROL_DB_PULL:
1794 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1795 &cd->data.num_records);
1796 break;
1797
1798 case CTDB_CONTROL_DB_PUSH_CONFIRM:
1799 ret = ctdb_uint32_pull(buf, buflen, mem_ctx,
1800 &cd->data.num_records);
1801 break;
1802 }
1803
1804 return ret;
1805 }
1806
1807 size_t ctdb_req_control_len(struct ctdb_req_header *h,
1808 struct ctdb_req_control *c)
1809 {
1810 return offsetof(struct ctdb_req_control_wire, data) +
1811 ctdb_req_control_data_len(&c->rdata);
1812 }
1813
1814 int ctdb_req_control_push(struct ctdb_req_header *h,
1815 struct ctdb_req_control *request,
1816 uint8_t *buf, size_t *buflen)
1817 {
1818 struct ctdb_req_control_wire *wire =
1819 (struct ctdb_req_control_wire *)buf;
1820 size_t length;
1821
1822 length = ctdb_req_control_len(h, request);
1823 if (*buflen < length) {
1824 *buflen = length;
1825 return EMSGSIZE;
1826 }
1827
1828 h->length = *buflen;
1829 ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
1830
1831 wire->opcode = request->opcode;
1832 wire->pad = request->pad;
1833 wire->srvid = request->srvid;
1834 wire->client_id = request->client_id;
1835 wire->flags = request->flags;
1836
1837 wire->datalen = ctdb_req_control_data_len(&request->rdata);
1838 ctdb_req_control_data_push(&request->rdata, wire->data);
1839
1840 return 0;
1841 }
1842
1843 int ctdb_req_control_pull(uint8_t *buf, size_t buflen,
1844 struct ctdb_req_header *h,
1845 TALLOC_CTX *mem_ctx,
1846 struct ctdb_req_control *c)
1847 {
1848 struct ctdb_req_control_wire *wire =
1849 (struct ctdb_req_control_wire *)buf;
1850 size_t length;
1851 int ret;
1852
1853 length = offsetof(struct ctdb_req_control_wire, data);
1854 if (buflen < length) {
1855 return EMSGSIZE;
1856 }
1857 if (wire->datalen > buflen) {
1858 return EMSGSIZE;
1859 }
1860 if (length + wire->datalen < length) {
1861 return EMSGSIZE;
1862 }
1863 if (buflen < length + wire->datalen) {
1864 return EMSGSIZE;
1865 }
1866
1867 if (h != NULL) {
1868 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
1869 if (ret != 0) {
1870 return ret;
1871 }
1872 }
1873
1874 c->opcode = wire->opcode;
1875 c->pad = wire->pad;
1876 c->srvid = wire->srvid;
1877 c->client_id = wire->client_id;
1878 c->flags = wire->flags;
1879
1880 ret = ctdb_req_control_data_pull(wire->data, wire->datalen,
1881 c->opcode, mem_ctx, &c->rdata);
1882 if (ret != 0) {
1883 return ret;
1884 }
1885
1886 return 0;
1887 }
1888
1889 size_t ctdb_reply_control_len(struct ctdb_req_header *h,
1890 struct ctdb_reply_control *c)
1891 {
1892 return offsetof(struct ctdb_reply_control_wire, data) +
1893 (c->status == 0 ?
1894 ctdb_reply_control_data_len(&c->rdata) :
1895 ctdb_string_len(c->errmsg));
1896 }
1897
1898 int ctdb_reply_control_push(struct ctdb_req_header *h,
1899 struct ctdb_reply_control *reply,
1900 uint8_t *buf, size_t *buflen)
1901 {
1902 struct ctdb_reply_control_wire *wire =
1903 (struct ctdb_reply_control_wire *)buf;
1904 size_t length;
1905
1906 length = ctdb_reply_control_len(h, reply);
1907 if (*buflen < length) {
1908 *buflen = length;
1909 return EMSGSIZE;
1910 }
1911
1912 h->length = *buflen;
1913 ctdb_req_header_push(h, (uint8_t *)&wire->hdr);
1914
1915 wire->status = reply->status;
1916
1917 if (reply->status == 0) {
1918 wire->datalen = ctdb_reply_control_data_len(&reply->rdata);
1919 wire->errorlen = 0;
1920 ctdb_reply_control_data_push(&reply->rdata, wire->data);
1921 } else {
1922 wire->datalen = 0;
1923 wire->errorlen = ctdb_string_len(reply->errmsg);
1924 ctdb_string_push(reply->errmsg, wire->data + wire->datalen);
1925 }
1926
1927 return 0;
1928 }
1929
1930 int ctdb_reply_control_pull(uint8_t *buf, size_t buflen, uint32_t opcode,
1931 struct ctdb_req_header *h,
1932 TALLOC_CTX *mem_ctx,
1933 struct ctdb_reply_control *c)
1934 {
1935 struct ctdb_reply_control_wire *wire =
1936 (struct ctdb_reply_control_wire *)buf;
1937 size_t length;
1938 int ret;
1939
1940 length = offsetof(struct ctdb_reply_control_wire, data);
1941 if (buflen < length) {
1942 return EMSGSIZE;
1943 }
1944 if (wire->datalen > buflen || wire->errorlen > buflen) {
1945 return EMSGSIZE;
1946 }
1947 if (length + wire->datalen < length) {
1948 return EMSGSIZE;
1949 }
1950 if (length + wire->datalen + wire->errorlen < length) {
1951 return EMSGSIZE;
1952 }
1953 if (buflen < length + wire->datalen + wire->errorlen) {
1954 return EMSGSIZE;
1955 }
1956
1957 if (h != NULL) {
1958 ret = ctdb_req_header_pull((uint8_t *)&wire->hdr, buflen, h);
1959 if (ret != 0) {
1960 return ret;
1961 }
1962 }
1963
1964 c->status = wire->status;
1965
1966 if (c->status != -1) {
1967 ret = ctdb_reply_control_data_pull(wire->data, wire->datalen,
1968 opcode, mem_ctx,
1969 &c->rdata);
1970 if (ret != 0) {
1971 return ret;
1972 }
1973 }
1974
1975 ret = ctdb_string_pull(wire->data + wire->datalen, wire->errorlen,
1976 mem_ctx, &c->errmsg);
1977 if (ret != 0) {
1978 return ret;
1979 }
1980
1981 return 0;
1982 }
Samba GIT mirror