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