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