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

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

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