?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libads: abstract out SASL wrapping code
[Samba.git] / source3 / utils / net_serverid.c
blob942f7a4902411451b6a71c34ea756157c7e7a28d
1 /*
2 Samba Unix/Linux SMB client library
3 net serverid commands
4 Copyright (C) Volker Lendecke 2010
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 "includes.h"
21 #include "utils/net.h"
22 #include "lib/util/server_id.h"
23 #include "dbwrap/dbwrap.h"
24 #include "dbwrap/dbwrap_rbt.h"
25 #include "serverid.h"
26 #include "session.h"
27 #include "lib/conn_tdb.h"
28 #include "smbd/globals.h"
29 #include "util_tdb.h"
30 #include "librpc/gen_ndr/ndr_open_files.h"
31
32 static int net_serverid_list_fn(const struct server_id *id,
33 uint32_t msg_flags, void *priv)
34 {
35 struct server_id_buf idbuf;
36 d_printf("%s %llu 0x%x\n", server_id_str_buf(*id, &idbuf),
37 (unsigned long long)id->unique_id,
38 (unsigned int)msg_flags);
39 return 0;
40 }
41
42 static int net_serverid_list(struct net_context *c, int argc,
43 const char **argv)
44 {
45 d_printf("pid unique_id msg_flags\n");
46 return serverid_traverse_read(net_serverid_list_fn, NULL) ? 0 : -1;
47 }
48
49 static int net_serverid_wipe_fn(struct db_record *rec,
50 const struct server_id *id,
51 uint32_t msg_flags, void *private_data)
52 {
53 NTSTATUS status;
54
55 if (!procid_is_local(id)) {
56 return 0;
57 }
58 status = dbwrap_record_delete(rec);
59 if (!NT_STATUS_IS_OK(status)) {
60 struct server_id_buf idbuf;
61 DEBUG(1, ("Could not delete serverid.tdb record %s: %s\n",
62 server_id_str_buf(*id, &idbuf), nt_errstr(status)));
63 }
64 return 0;
65 }
66
67 static int net_serverid_wipe(struct net_context *c, int argc,
68 const char **argv)
69 {
70 return serverid_traverse(net_serverid_wipe_fn, NULL) ? 0 : -1;
71 }
72
73
74 struct wipedbs_record_marker {
75 struct wipedbs_record_marker *prev, *next;
76 TDB_DATA key, val;
77 const char *desc;
78 };
79
80 struct wipedbs_server_data {
81 struct server_id server_id;
82 const char *server_id_str;
83 bool exists;
84 struct wipedbs_record_marker *session_records;
85 struct wipedbs_record_marker *tcon_records;
86 struct wipedbs_record_marker *open_records;
87 };
88
89 struct wipedbs_state {
90 struct db_context *id2server_data;
91 struct {
92 struct {
93 int total;
94 int existing;
95 int disconnected;
96 } server;
97 struct {
98 int total;
99 int disconnected;
100 int todelete;
101 int failure;
102 } session, tcon, open;
103 int open_timed_out;
104 } stat;
105 struct server_id *server_ids;
106 bool *server_exists;
107 int idx;
108 struct db_context *session_db;
109 struct db_context *tcon_db;
110 struct db_context *open_db;
111 struct timeval now;
112 bool testmode;
113 bool verbose;
114 };
115
116 static struct wipedbs_server_data *get_server_data(struct wipedbs_state *state,
117 const struct server_id *id)
118 {
119 struct wipedbs_server_data *ret = NULL;
120 TDB_DATA key, val = tdb_null;
121 NTSTATUS status;
122
123 key = make_tdb_data((const void*)&id->unique_id, sizeof(id->unique_id));
124 status = dbwrap_fetch(state->id2server_data, talloc_tos(), key, &val);
125 if (NT_STATUS_IS_OK(status)) {
126 ret = *(struct wipedbs_server_data**) val.dptr;
127 TALLOC_FREE(val.dptr);
128 } else if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
129 struct server_id_buf idbuf;
130
131 server_id_str_buf(*id, &idbuf);
132
133 ret = talloc_zero(state->id2server_data,
134 struct wipedbs_server_data);
135 if (ret == NULL) {
136 DEBUG(0, ("Failed to allocate server entry for %s\n",
137 idbuf.buf));
138 goto done;
139 }
140 ret->server_id = *id;
141 ret->server_id_str = talloc_strdup(ret, idbuf.buf);
142 ret->exists = true;
143 val = make_tdb_data((const void*)&ret, sizeof(ret));
144 status = dbwrap_store(state->id2server_data,
145 key, val, TDB_INSERT);
146 if (!NT_STATUS_IS_OK(status)) {
147 DEBUG(0, ("Failed to store server entry for %s: %s\n",
148 idbuf.buf, nt_errstr(status)));
149 }
150 goto done;
151 } else {
152 struct server_id_buf idbuf;
153 DEBUG(0, ("Failed to fetch server entry for %s: %s\n",
154 server_id_str_buf(*id, &idbuf), nt_errstr(status)));
155 goto done;
156 }
157 if (!server_id_equal(id, &ret->server_id)) {
158 struct server_id_buf idbuf1, idbuf2;
159 DEBUG(0, ("uniq id collision for %s and %s\n",
160 server_id_str_buf(*id, &idbuf1),
161 server_id_str_buf(ret->server_id, &idbuf2)));
162 smb_panic("server_id->unique_id not unique!");
163 }
164 done:
165 return ret;
166 }
167
168 static int wipedbs_traverse_sessions(struct smbXsrv_session_global0 *session,
169 void *wipedbs_state)
170 {
171 struct wipedbs_state *state =
172 talloc_get_type_abort(wipedbs_state,
173 struct wipedbs_state);
174 struct wipedbs_server_data *sd;
175 struct wipedbs_record_marker *rec;
176 TDB_DATA tmp;
177 int ret = -1;
178
179 assert(session->num_channels == 1);
180
181 state->stat.session.total++;
182
183 sd = get_server_data(state, &session->channels[0].server_id);
184 if (sd == NULL) {
185 goto done;
186 }
187
188 if (server_id_is_disconnected(&sd->server_id)) {
189 state->stat.session.disconnected++;
190 }
191
192 rec = talloc_zero(sd, struct wipedbs_record_marker);
193 if (rec == NULL) {
194 DEBUG(0, ("Out of memory!\n"));
195 goto done;
196 }
197
198 tmp = dbwrap_record_get_key(session->db_rec);
199 rec->key = tdb_data_talloc_copy(rec, tmp);
200 tmp = dbwrap_record_get_value(session->db_rec);
201 rec->val = tdb_data_talloc_copy(rec, tmp);
202
203 rec->desc = talloc_asprintf(
204 rec, "session[global: %u wire: %llu]",
205 session->session_global_id,
206 (long long unsigned)session->session_wire_id);
207
208 if ((rec->key.dptr == NULL) || (rec->val.dptr == NULL) ||
209 (rec->desc == NULL))
210 {
211 DEBUG(0, ("Out of memory!\n"));
212 goto done;
213 }
214
215 state->session_db = dbwrap_record_get_db(session->db_rec);
216
217 DLIST_ADD(sd->session_records, rec);
218 ret = 0;
219 done:
220 return ret;
221 }
222
223 static int wipedbs_traverse_tcon(struct smbXsrv_tcon_global0 *tcon,
224 void *wipedbs_state)
225 {
226 struct wipedbs_state *state =
227 talloc_get_type_abort(wipedbs_state,
228 struct wipedbs_state);
229 struct wipedbs_server_data *sd;
230 struct wipedbs_record_marker *rec;
231 TDB_DATA tmp;
232 int ret = -1;
233
234 state->stat.tcon.total++;
235
236 sd = get_server_data(state, &tcon->server_id);
237 if (sd == NULL) {
238 goto done;
239 }
240
241 if (server_id_is_disconnected(&sd->server_id)) {
242 state->stat.tcon.disconnected++;
243 }
244
245 rec = talloc_zero(sd, struct wipedbs_record_marker);
246 if (rec == NULL) {
247 DEBUG(0, ("Out of memory!\n"));
248 goto done;
249 }
250
251 tmp = dbwrap_record_get_key(tcon->db_rec);
252 rec->key = tdb_data_talloc_copy(rec, tmp);
253 tmp = dbwrap_record_get_value(tcon->db_rec);
254 rec->val = tdb_data_talloc_copy(rec, tmp);
255
256 rec->desc = talloc_asprintf(
257 rec, "tcon[global: %u wire: %u session: %u share: %s]",
258 tcon->tcon_global_id, tcon->tcon_wire_id,
259 tcon->session_global_id, tcon->share_name);
260
261 if ((rec->key.dptr == NULL) || (rec->val.dptr == NULL) ||
262 (rec->desc == NULL))
263 {
264 DEBUG(0, ("Out of memory!\n"));
265 goto done;
266 }
267
268 state->tcon_db = dbwrap_record_get_db(tcon->db_rec);
269
270 DLIST_ADD(sd->tcon_records, rec);
271 ret = 0;
272
273 done:
274 return ret;
275 }
276
277 static int wipedbs_traverse_open(struct smbXsrv_open_global0 *open,
278 void *wipedbs_state)
279 {
280 struct wipedbs_state *state =
281 talloc_get_type_abort(wipedbs_state,
282 struct wipedbs_state);
283 struct wipedbs_server_data *sd;
284 struct wipedbs_record_marker *rec;
285 TDB_DATA tmp;
286 int ret = -1;
287
288 state->stat.open.total++;
289
290 sd = get_server_data(state, &open->server_id);
291 if (sd == NULL) {
292 goto done;
293 }
294
295 if (server_id_is_disconnected(&sd->server_id)) {
296 struct timeval disconnect_time;
297 int64_t tdiff;
298 bool reached;
299
300 state->stat.open.disconnected++;
301
302 nttime_to_timeval(&disconnect_time, open->disconnect_time);
303 tdiff = usec_time_diff(&state->now, &disconnect_time);
304 reached = (tdiff >= 1000*open->durable_timeout_msec);
305
306 if (state->verbose) {
307 TALLOC_CTX *mem_ctx = talloc_new(talloc_tos());
308 enum ndr_err_code ndr_err;
309 struct vfs_default_durable_cookie cookie;
310
311 ndr_err = ndr_pull_struct_blob(
312 &open->backend_cookie, mem_ctx, &cookie,
313 (ndr_pull_flags_fn_t)ndr_pull_vfs_default_durable_cookie);
314 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
315 d_printf("ndr_pull_struct_blob failed\n");
316 ret = -1;
317 goto done;
318 }
319
320 d_printf("open[%s/%s id: 0x%" PRIx32 "] disconnected at "
321 "[%s] %us ago with timeout of %us "
322 "-%s reached\n",
323 cookie.servicepath, cookie.base_name,
324 open->open_global_id,
325 nt_time_string(mem_ctx, open->disconnect_time),
326 (unsigned)(tdiff/1000000),
327 open->durable_timeout_msec / 1000,
328 reached ? "" : " not");
329 talloc_free(mem_ctx);
330 }
331
332 if (!reached) {
333 ret = 0;
334 goto done;
335 }
336 state->stat.open_timed_out++;
337 }
338
339 rec = talloc_zero(sd, struct wipedbs_record_marker);
340 if (rec == NULL) {
341 DEBUG(0, ("Out of memory!\n"));
342 goto done;
343 }
344
345 tmp = dbwrap_record_get_key(open->db_rec);
346 rec->key = tdb_data_talloc_copy(rec, tmp);
347 tmp = dbwrap_record_get_value(open->db_rec);
348 rec->val = tdb_data_talloc_copy(rec, tmp);
349
350 rec->desc = talloc_asprintf(
351 rec, "open[global: %u persistent: %llu volatile: %llu]",
352 open->open_global_id,
353 (long long unsigned)open->open_persistent_id,
354 (long long unsigned)open->open_volatile_id);
355
356 if ((rec->key.dptr == NULL) || (rec->val.dptr == NULL) ||
357 (rec->desc == NULL))
358 {
359 DEBUG(0, ("Out of memory!\n"));
360 goto done;
361 }
362
363 state->open_db = dbwrap_record_get_db(open->db_rec);
364
365 DLIST_ADD(sd->open_records, rec);
366 ret = 0;
367
368 done:
369 return ret;
370 }
371
372 static int wipedbs_traverse_nop(struct db_record *rec, void *private_data)
373 {
374 return 0;
375 }
376
377 static int wipedbs_traverse_fill_ids(struct db_record *rec, void *wipedbs_state)
378 {
379 struct wipedbs_state *state = talloc_get_type_abort(
380 wipedbs_state, struct wipedbs_state);
381
382 TDB_DATA val = dbwrap_record_get_value(rec);
383
384 struct wipedbs_server_data *sd = talloc_get_type_abort(
385 *(void**)val.dptr, struct wipedbs_server_data);
386
387 state->server_ids[state->idx] = sd->server_id;
388 state->idx++;
389 return 0;
390 }
391
392 static int wipedbs_traverse_set_exists(struct db_record *rec,
393 void *wipedbs_state)
394 {
395 struct wipedbs_state *state = talloc_get_type_abort(
396 wipedbs_state, struct wipedbs_state);
397
398 TDB_DATA val = dbwrap_record_get_value(rec);
399
400 struct wipedbs_server_data *sd = talloc_get_type_abort(
401 *(void**)val.dptr, struct wipedbs_server_data);
402
403 /* assume a stable traverse order for rbt */
404 SMB_ASSERT(server_id_equal(&state->server_ids[state->idx],
405 &sd->server_id));
406 sd->exists = state->server_exists[state->idx];
407
408 if (sd->exists) {
409 state->stat.server.existing++;
410 }
411 if (server_id_is_disconnected(&sd->server_id)) {
412 state->stat.server.disconnected++;
413 }
414
415 state->idx++;
416 return 0;
417 }
418
419 static bool serverids_exist(const struct server_id *ids, int num_ids,
420 bool *results)
421 {
422 int i;
423
424 for (i=0; i<num_ids; i++) {
425 results[i] = serverid_exists(&ids[i]);
426 }
427
428 return true;
429 }
430
431
432 static NTSTATUS wipedbs_check_server_exists(struct wipedbs_state *state)
433 {
434 NTSTATUS status;
435 bool ok;
436 int num_servers;
437
438 status = dbwrap_traverse_read(state->id2server_data,
439 wipedbs_traverse_nop, NULL, &num_servers);
440 if (!NT_STATUS_IS_OK(status)) {
441 DEBUG(0, ("Failed to traverse temporary database\n"));
442 goto done;
443 }
444 state->stat.server.total = num_servers;
445
446 state->server_ids = talloc_array(state, struct server_id, num_servers);
447 state->server_exists = talloc_array(state, bool, num_servers);
448 if (state->server_ids == NULL || state->server_exists == NULL) {
449 DEBUG(0, ("Out of memory\n"));
450 goto done;
451 }
452
453 state->idx = 0;
454 status = dbwrap_traverse_read(state->id2server_data,
455 wipedbs_traverse_fill_ids,
456 state, NULL);
457 if (!NT_STATUS_IS_OK(status)) {
458 DEBUG(0, ("Failed to traverse temporary database\n"));
459 goto done;
460 }
461
462 ok = serverids_exist(state->server_ids, num_servers, state->server_exists);
463 if (!ok) {
464 DEBUG(0, ("Calling serverids_exist failed\n"));
465 status = NT_STATUS_UNSUCCESSFUL;
466 goto done;
467 }
468
469 state->idx = 0;
470 status = dbwrap_traverse_read(state->id2server_data,
471 wipedbs_traverse_set_exists, state, NULL);
472 if (!NT_STATUS_IS_OK(status)) {
473 DEBUG(0, ("Failed to traverse temporary database\n"));
474 goto done;
475 }
476 done:
477 TALLOC_FREE(state->server_ids);
478 TALLOC_FREE(state->server_exists);
479 return status;
480 }
481
482 static int wipedbs_delete_records(struct db_context *db,
483 struct wipedbs_record_marker *records,
484 bool dry_run, bool verbose, int *count)
485 {
486 struct wipedbs_record_marker *cur;
487 struct db_record *rec;
488 TDB_DATA val;
489 NTSTATUS status;
490 unsigned num=0, total=0;
491
492 if (db == NULL) {
493 return 0;
494 }
495
496 for (cur = records; cur != NULL; cur = cur->next) {
497 total++;
498 rec = dbwrap_fetch_locked(db, talloc_tos(), cur->key);
499 if (rec == NULL) {
500 DEBUG(0, ("Failed to fetch record <%s> from %s",
501 cur->desc, dbwrap_name(db)));
502 continue;
503 }
504 val = dbwrap_record_get_value(rec);
505 if (tdb_data_equal(val, cur->val)) {
506 if (dry_run) {
507 status = NT_STATUS_OK;
508 } else {
509 status = dbwrap_record_delete(rec);
510 }
511 if (NT_STATUS_IS_OK(status)) {
512 num ++;
513 } else {
514 DEBUG(0, ("Failed to delete record <%s> from %s"
515 ": %s\n", cur->desc, dbwrap_name(db),
516 nt_errstr(status)));
517 }
518 } else {
519 DEBUG(0, ("Warning: record <%s> from %s changed"
520 ", skip record!\n",
521 cur->desc, dbwrap_name(db)));
522 }
523 if (verbose) {
524 d_printf("deleting %s\n", cur->desc);
525 }
526 TALLOC_FREE(rec);
527 }
528
529 if (verbose) {
530 d_printf("Deleted %u of %u records from %s\n",
531 num, total, dbwrap_name(db));
532 }
533
534 if (count) {
535 *count += total;
536 }
537
538 return total - num;
539 }
540
541 static int wipedbs_traverse_server_data(struct db_record *rec,
542 void *wipedbs_state)
543 {
544 struct wipedbs_state *state = talloc_get_type_abort(
545 wipedbs_state, struct wipedbs_state);
546 bool dry_run = state->testmode;
547 TDB_DATA val = dbwrap_record_get_value(rec);
548 int ret;
549 struct wipedbs_server_data *sd = talloc_get_type_abort(
550 *(void**)val.dptr, struct wipedbs_server_data);
551
552 if (state->verbose) {
553 d_printf("Server: '%s' %s\n", sd->server_id_str,
554 sd->exists ?
555 "exists" :
556 "does not exist, cleaning up...");
557 }
558
559 if (sd->exists) {
560 return 0;
561 }
562
563 ret = wipedbs_delete_records(state->session_db, sd->session_records,
564 dry_run, state->verbose,
565 &state->stat.session.todelete);
566 state->stat.session.failure += ret;
567
568 ret = wipedbs_delete_records(state->tcon_db, sd->tcon_records,
569 dry_run, state->verbose,
570 &state->stat.tcon.todelete);
571 state->stat.tcon.failure += ret;
572
573 ret = wipedbs_delete_records(state->open_db, sd->open_records,
574 dry_run, state->verbose,
575 &state->stat.open.todelete);
576 state->stat.open.failure += ret;
577
578 return 0;
579 }
580
581 static int net_serverid_wipedbs(struct net_context *c, int argc,
582 const char **argv)
583 {
584 int ret = -1;
585 NTSTATUS status;
586 struct wipedbs_state *state = talloc_zero(talloc_tos(),
587 struct wipedbs_state);
588
589 if (c->display_usage) {
590 d_printf("%s\n%s",
591 _("Usage:"),
592 _("net serverid wipedbs [--test] [--verbose]\n"));
593 d_printf("%s\n%s",
594 _("Example:"),
595 _("net serverid wipedbs -v\n"));
596 return -1;
597 }
598
599 state->now = timeval_current();
600 state->testmode = c->opt_testmode;
601 state->verbose = c->opt_verbose;
602
603 state->id2server_data = db_open_rbt(state);
604 if (state->id2server_data == NULL) {
605 DEBUG(0, ("Failed to open temporary database\n"));
606 goto done;
607 }
608
609 status = smbXsrv_session_global_traverse(wipedbs_traverse_sessions,
610 state);
611 if (!NT_STATUS_IS_OK(status)) {
612 goto done;
613 }
614
615 status = smbXsrv_tcon_global_traverse(wipedbs_traverse_tcon, state);
616 if (!NT_STATUS_IS_OK(status)) {
617 goto done;
618 }
619
620 status = smbXsrv_open_global_traverse(wipedbs_traverse_open, state);
621 if (!NT_STATUS_IS_OK(status)) {
622 goto done;
623 }
624
625 status = wipedbs_check_server_exists(state);
626 if (!NT_STATUS_IS_OK(status)) {
627 goto done;
628 }
629
630 status = dbwrap_traverse_read(state->id2server_data,
631 wipedbs_traverse_server_data,
632 state, NULL);
633 if (!NT_STATUS_IS_OK(status)) {
634 DEBUG(0, ("Failed to traverse db: %s\n", nt_errstr(status)));
635 goto done;
636 }
637
638 d_printf("Found %d serverids, %d alive and %d disconnected\n",
639 state->stat.server.total,
640 state->stat.server.existing,
641 state->stat.server.disconnected);
642 d_printf("Found %d sessions, %d alive and %d disconnected"
643 ", cleaned up %d of %d entries\n",
644 state->stat.session.total,
645 state->stat.session.total - state->stat.session.todelete,
646 state->stat.session.disconnected,
647 state->stat.session.todelete - state->stat.session.failure,
648 state->stat.session.todelete);
649 d_printf("Found %d tcons, %d alive and %d disconnected"
650 ", cleaned up %d of %d entries\n",
651 state->stat.tcon.total,
652 state->stat.tcon.total - state->stat.tcon.todelete,
653 state->stat.tcon.disconnected,
654 state->stat.tcon.todelete - state->stat.tcon.failure,
655 state->stat.tcon.todelete);
656 d_printf("Found %d opens, %d alive, %d disconnected and %d timed out"
657 ", cleaned up %d of %d entries\n",
658 state->stat.open.total,
659 state->stat.open.total - state->stat.open.todelete
660 - (state->stat.open.disconnected - state->stat.open_timed_out),
661 state->stat.open.disconnected,
662 state->stat.open_timed_out,
663 state->stat.open.todelete - state->stat.open.failure,
664 state->stat.open.todelete);
665
666 ret = 0;
667 done:
668 talloc_free(state);
669 return ret;
670 }
671
672 static int net_serverid_exists(struct net_context *c, int argc,
673 const char **argv)
674 {
675 struct server_id pid;
676 bool ok;
677
678 if ((argc != 1) || (c->display_usage)) {
679 d_printf("Usage:\n"
680 "net serverid exists <serverid>\n");
681 return -1;
682 }
683
684 pid = server_id_from_string(get_my_vnn(), argv[0]);
685 ok = serverid_exists(&pid);
686
687 if (ok) {
688 d_printf("%s exists\n", argv[0]);
689 } else {
690 d_printf("%s does not exist\n", argv[0]);
691 }
692
693 return 0;
694 }
695
696 int net_serverid(struct net_context *c, int argc, const char **argv)
697 {
698 struct functable func[] = {
699 {
700 "list",
701 net_serverid_list,
702 NET_TRANSPORT_LOCAL,
703 N_("List all entries from serverid.tdb"),
704 N_("net serverid list\n"
705 " List all entries from serverid.tdb")
706 },
707 {
708 "wipe",
709 net_serverid_wipe,
710 NET_TRANSPORT_LOCAL,
711 N_("Wipe the serverid.tdb for the current node"),
712 N_("net serverid wipe\n"
713 " Wipe the serverid.tdb for the current node")
714 },
715 {
716 "wipedbs",
717 net_serverid_wipedbs,
718 NET_TRANSPORT_LOCAL,
719 N_("Clean dead entries from temporary databases"),
720 N_("net serverid wipedbs\n"
721 " Clean dead entries from temporary databases")
722 },
723 {
724 "exists",
725 net_serverid_exists,
726 NET_TRANSPORT_LOCAL,
727 N_("Show existence of a serverid"),
728 N_("net serverid exists <id>")
729 },
730 {NULL, NULL, 0, NULL, NULL}
731 };
732
733 return net_run_function(c, argc, argv, "net serverid", func);
734 }
Samba GIT mirror