2 Samba Unix/Linux SMB client library
4 Copyright (C) Volker Lendecke 2010
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.
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.
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/>.
21 #include "utils/net.h"
22 #include "dbwrap/dbwrap.h"
23 #include "dbwrap/dbwrap_rbt.h"
26 #include "lib/conn_tdb.h"
27 #include "smbd/globals.h"
30 static int net_serverid_list_fn(const struct server_id
*id
,
31 uint32_t msg_flags
, void *priv
)
33 char *str
= server_id_str(talloc_tos(), id
);
34 d_printf("%s %llu 0x%x\n", str
, (unsigned long long)id
->unique_id
,
35 (unsigned int)msg_flags
);
40 static int net_serverid_list(struct net_context
*c
, int argc
,
43 d_printf("pid unique_id msg_flags\n");
44 return serverid_traverse_read(net_serverid_list_fn
, NULL
) ? 0 : -1;
47 static int net_serverid_wipe_fn(struct db_record
*rec
,
48 const struct server_id
*id
,
49 uint32_t msg_flags
, void *private_data
)
53 if (id
->vnn
!= get_my_vnn()) {
56 status
= dbwrap_record_delete(rec
);
57 if (!NT_STATUS_IS_OK(status
)) {
58 char *str
= server_id_str(talloc_tos(), id
);
59 DEBUG(1, ("Could not delete serverid.tdb record %s: %s\n",
60 str
, nt_errstr(status
)));
66 static int net_serverid_wipe(struct net_context
*c
, int argc
,
69 return serverid_traverse(net_serverid_wipe_fn
, NULL
) ? 0 : -1;
73 struct wipedbs_record_marker
{
74 struct wipedbs_record_marker
*prev
, *next
;
79 struct wipedbs_server_data
{
80 struct server_id server_id
;
81 const char *server_id_str
;
83 struct wipedbs_record_marker
*session_records
;
84 struct wipedbs_record_marker
*tcon_records
;
85 struct wipedbs_record_marker
*open_records
;
88 struct wipedbs_state
{
89 struct db_context
*id2server_data
;
101 } session
, tcon
, open
;
104 struct server_id
*server_ids
;
107 struct db_context
*session_db
;
108 struct db_context
*tcon_db
;
109 struct db_context
*open_db
;
115 static struct wipedbs_server_data
*get_server_data(struct wipedbs_state
*state
,
116 const struct server_id
*id
)
118 struct wipedbs_server_data
*ret
= NULL
;
119 TDB_DATA key
, val
= tdb_null
;
122 key
= make_tdb_data((const void*)&id
->unique_id
, sizeof(id
->unique_id
));
123 status
= dbwrap_fetch(state
->id2server_data
, talloc_tos(), key
, &val
);
124 if (NT_STATUS_IS_OK(status
)) {
125 ret
= *(struct wipedbs_server_data
**) val
.dptr
;
126 TALLOC_FREE(val
.dptr
);
127 } else if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_FOUND
)) {
128 ret
= talloc_zero(state
->id2server_data
,
129 struct wipedbs_server_data
);
131 DEBUG(0, ("Failed to allocate server entry for %s\n",
132 server_id_str(talloc_tos(), id
)));
135 ret
->server_id
= *id
;
136 ret
->server_id_str
= server_id_str(ret
, id
);
138 val
= make_tdb_data((const void*)&ret
, sizeof(ret
));
139 status
= dbwrap_store(state
->id2server_data
,
140 key
, val
, TDB_INSERT
);
141 if (!NT_STATUS_IS_OK(status
)) {
142 DEBUG(0, ("Failed to store server entry for %s: %s\n",
143 server_id_str(talloc_tos(), id
),
148 DEBUG(0, ("Failed to fetch server entry for %s: %s\n",
149 server_id_str(talloc_tos(), id
), nt_errstr(status
)));
152 if (!server_id_equal(id
, &ret
->server_id
)) {
153 DEBUG(0, ("uniq id collision for %s and %s\n",
154 server_id_str(talloc_tos(), id
),
155 server_id_str(talloc_tos(), &ret
->server_id
)));
156 smb_panic("server_id->unique_id not unique!");
162 static int wipedbs_traverse_sessions(struct smbXsrv_session_global0
*session
,
165 struct wipedbs_state
*state
=
166 talloc_get_type_abort(wipedbs_state
,
167 struct wipedbs_state
);
168 struct wipedbs_server_data
*sd
;
169 struct wipedbs_record_marker
*rec
;
173 assert(session
->num_channels
== 1);
175 state
->stat
.session
.total
++;
177 sd
= get_server_data(state
, &session
->channels
[0].server_id
);
182 if (server_id_is_disconnected(&sd
->server_id
)) {
183 state
->stat
.session
.disconnected
++;
186 rec
= talloc_zero(sd
, struct wipedbs_record_marker
);
188 DEBUG(0, ("Out of memory!\n"));
192 tmp
= dbwrap_record_get_key(session
->db_rec
);
193 rec
->key
= tdb_data_talloc_copy(rec
, tmp
);
194 tmp
= dbwrap_record_get_value(session
->db_rec
);
195 rec
->val
= tdb_data_talloc_copy(rec
, tmp
);
197 rec
->desc
= talloc_asprintf(
198 rec
, "session[global: %u wire: %lu]",
199 session
->session_global_id
, session
->session_wire_id
);
201 if ((rec
->key
.dptr
== NULL
) || (rec
->val
.dptr
== NULL
) ||
204 DEBUG(0, ("Out of memory!\n"));
208 state
->session_db
= dbwrap_record_get_db(session
->db_rec
);
210 DLIST_ADD(sd
->session_records
, rec
);
216 static int wipedbs_traverse_tcon(struct smbXsrv_tcon_global0
*tcon
,
219 struct wipedbs_state
*state
=
220 talloc_get_type_abort(wipedbs_state
,
221 struct wipedbs_state
);
222 struct wipedbs_server_data
*sd
;
223 struct wipedbs_record_marker
*rec
;
227 state
->stat
.tcon
.total
++;
229 sd
= get_server_data(state
, &tcon
->server_id
);
234 if (server_id_is_disconnected(&sd
->server_id
)) {
235 state
->stat
.tcon
.disconnected
++;
238 rec
= talloc_zero(sd
, struct wipedbs_record_marker
);
240 DEBUG(0, ("Out of memory!\n"));
244 tmp
= dbwrap_record_get_key(tcon
->db_rec
);
245 rec
->key
= tdb_data_talloc_copy(rec
, tmp
);
246 tmp
= dbwrap_record_get_value(tcon
->db_rec
);
247 rec
->val
= tdb_data_talloc_copy(rec
, tmp
);
249 rec
->desc
= talloc_asprintf(
250 rec
, "tcon[global: %u wire: %u session: %u share: %s]",
251 tcon
->tcon_global_id
, tcon
->tcon_wire_id
,
252 tcon
->session_global_id
, tcon
->share_name
);
254 if ((rec
->key
.dptr
== NULL
) || (rec
->val
.dptr
== NULL
) ||
257 DEBUG(0, ("Out of memory!\n"));
261 state
->tcon_db
= dbwrap_record_get_db(tcon
->db_rec
);
263 DLIST_ADD(sd
->tcon_records
, rec
);
270 static int wipedbs_traverse_open(struct smbXsrv_open_global0
*open
,
273 struct wipedbs_state
*state
=
274 talloc_get_type_abort(wipedbs_state
,
275 struct wipedbs_state
);
276 struct wipedbs_server_data
*sd
;
277 struct wipedbs_record_marker
*rec
;
281 state
->stat
.open
.total
++;
283 sd
= get_server_data(state
, &open
->server_id
);
288 if (server_id_is_disconnected(&sd
->server_id
)) {
289 struct timeval disconnect_time
;
293 state
->stat
.open
.disconnected
++;
295 nttime_to_timeval(&disconnect_time
, open
->disconnect_time
);
296 tdiff
= usec_time_diff(&state
->now
, &disconnect_time
);
297 reached
= (tdiff
>= 1000*open
->durable_timeout_msec
);
299 if (state
->verbose
) {
300 TALLOC_CTX
*mem_ctx
= talloc_new(talloc_tos());
301 d_printf("open[global: %u] disconnected at "
302 "[%s] %us ago with timeout of %us "
304 open
->open_global_id
,
305 nt_time_string(mem_ctx
, open
->disconnect_time
),
306 (unsigned)(tdiff
/1000000),
307 open
->durable_timeout_msec
/ 1000,
308 reached
? "" : " not");
309 talloc_free(mem_ctx
);
316 state
->stat
.open_timed_out
++;
319 rec
= talloc_zero(sd
, struct wipedbs_record_marker
);
321 DEBUG(0, ("Out of memory!\n"));
325 tmp
= dbwrap_record_get_key(open
->db_rec
);
326 rec
->key
= tdb_data_talloc_copy(rec
, tmp
);
327 tmp
= dbwrap_record_get_value(open
->db_rec
);
328 rec
->val
= tdb_data_talloc_copy(rec
, tmp
);
330 rec
->desc
= talloc_asprintf(
331 rec
, "open[global: %u persistent: %lu volatile: %lu]",
332 open
->open_global_id
, open
->open_persistent_id
,
333 open
->open_volatile_id
);
335 if ((rec
->key
.dptr
== NULL
) || (rec
->val
.dptr
== NULL
) ||
338 DEBUG(0, ("Out of memory!\n"));
342 state
->open_db
= dbwrap_record_get_db(open
->db_rec
);
344 DLIST_ADD(sd
->open_records
, rec
);
351 static int wipedbs_traverse_nop(struct db_record
*rec
, void *private_data
)
356 static int wipedbs_traverse_fill_ids(struct db_record
*rec
, void *wipedbs_state
)
358 struct wipedbs_state
*state
= talloc_get_type_abort(
359 wipedbs_state
, struct wipedbs_state
);
361 TDB_DATA val
= dbwrap_record_get_value(rec
);
363 struct wipedbs_server_data
*sd
= talloc_get_type_abort(
364 *(void**)val
.dptr
, struct wipedbs_server_data
);
366 state
->server_ids
[state
->idx
] = sd
->server_id
;
371 static int wipedbs_traverse_set_exists(struct db_record
*rec
,
374 struct wipedbs_state
*state
= talloc_get_type_abort(
375 wipedbs_state
, struct wipedbs_state
);
377 TDB_DATA val
= dbwrap_record_get_value(rec
);
379 struct wipedbs_server_data
*sd
= talloc_get_type_abort(
380 *(void**)val
.dptr
, struct wipedbs_server_data
);
382 /* assume a stable traverse order for rbt */
383 SMB_ASSERT(server_id_equal(&state
->server_ids
[state
->idx
],
385 sd
->exists
= state
->server_exists
[state
->idx
];
388 state
->stat
.server
.existing
++;
390 if (server_id_is_disconnected(&sd
->server_id
)) {
391 state
->stat
.server
.disconnected
++;
398 static NTSTATUS
wipedbs_check_server_exists(struct wipedbs_state
*state
)
404 status
= dbwrap_traverse_read(state
->id2server_data
,
405 wipedbs_traverse_nop
, NULL
, &num_servers
);
406 if (!NT_STATUS_IS_OK(status
)) {
407 DEBUG(0, ("Failed to traverse temporary database\n"));
410 state
->stat
.server
.total
= num_servers
;
412 state
->server_ids
= talloc_array(state
, struct server_id
, num_servers
);
413 state
->server_exists
= talloc_array(state
, bool, num_servers
);
414 if (state
->server_ids
== NULL
|| state
->server_exists
== NULL
) {
415 DEBUG(0, ("Out of memory\n"));
420 status
= dbwrap_traverse_read(state
->id2server_data
,
421 wipedbs_traverse_fill_ids
,
423 if (!NT_STATUS_IS_OK(status
)) {
424 DEBUG(0, ("Failed to traverse temporary database\n"));
428 ok
= serverids_exist(state
->server_ids
, num_servers
, state
->server_exists
);
430 DEBUG(0, ("Calling serverids_exist failed\n"));
431 status
= NT_STATUS_UNSUCCESSFUL
;
436 status
= dbwrap_traverse_read(state
->id2server_data
,
437 wipedbs_traverse_set_exists
, state
, NULL
);
438 if (!NT_STATUS_IS_OK(status
)) {
439 DEBUG(0, ("Failed to traverse temporary database\n"));
443 TALLOC_FREE(state
->server_ids
);
444 TALLOC_FREE(state
->server_exists
);
448 static int wipedbs_delete_records(struct db_context
*db
,
449 struct wipedbs_record_marker
*records
,
450 bool dry_run
, bool verbose
, int *count
)
452 struct wipedbs_record_marker
*cur
;
453 struct db_record
*rec
;
456 unsigned num
=0, total
=0;
462 for (cur
= records
; cur
!= NULL
; cur
= cur
->next
) {
464 rec
= dbwrap_fetch_locked(db
, talloc_tos(), cur
->key
);
466 DEBUG(0, ("Failed to fetch record <%s> from %s",
467 cur
->desc
, dbwrap_name(db
)));
470 val
= dbwrap_record_get_value(rec
);
471 if (tdb_data_equal(val
, cur
->val
)) {
473 status
= NT_STATUS_OK
;
475 status
= dbwrap_record_delete(rec
);
477 if (NT_STATUS_IS_OK(status
)) {
480 DEBUG(0, ("Failed to delete record <%s> from %s"
481 ": %s\n", cur
->desc
, dbwrap_name(db
),
485 DEBUG(0, ("Warning: record <%s> from %s changed"
487 cur
->desc
, dbwrap_name(db
)));
490 d_printf("deleting %s\n", cur
->desc
);
496 d_printf("Deleted %u of %u records from %s\n",
497 num
, total
, dbwrap_name(db
));
507 static int wipedbs_traverse_server_data(struct db_record
*rec
,
510 struct wipedbs_state
*state
= talloc_get_type_abort(
511 wipedbs_state
, struct wipedbs_state
);
512 bool dry_run
= state
->testmode
;
513 TDB_DATA val
= dbwrap_record_get_value(rec
);
515 struct wipedbs_server_data
*sd
= talloc_get_type_abort(
516 *(void**)val
.dptr
, struct wipedbs_server_data
);
518 if (state
->verbose
) {
519 d_printf("Server: '%s' %s\n", sd
->server_id_str
,
522 "does not exist, cleaning up...");
529 ret
= wipedbs_delete_records(state
->session_db
, sd
->session_records
,
530 dry_run
, state
->verbose
,
531 &state
->stat
.session
.todelete
);
532 state
->stat
.session
.failure
+= ret
;
534 ret
= wipedbs_delete_records(state
->tcon_db
, sd
->tcon_records
,
535 dry_run
, state
->verbose
,
536 &state
->stat
.tcon
.todelete
);
537 state
->stat
.tcon
.failure
+= ret
;
539 ret
= wipedbs_delete_records(state
->open_db
, sd
->open_records
,
540 dry_run
, state
->verbose
,
541 &state
->stat
.open
.todelete
);
542 state
->stat
.open
.failure
+= ret
;
547 static int net_serverid_wipedbs(struct net_context
*c
, int argc
,
552 struct wipedbs_state
*state
= talloc_zero(talloc_tos(),
553 struct wipedbs_state
);
555 if (c
->display_usage
) {
558 _("net serverid wipedbs [--test] [--verbose]\n"));
561 _("net serverid wipedbs -v\n"));
565 state
->now
= timeval_current();
566 state
->testmode
= c
->opt_testmode
;
567 state
->verbose
= c
->opt_verbose
;
569 state
->id2server_data
= db_open_rbt(state
);
570 if (state
->id2server_data
== NULL
) {
571 DEBUG(0, ("Failed to open temporary database\n"));
575 status
= smbXsrv_session_global_traverse(wipedbs_traverse_sessions
,
577 if (!NT_STATUS_IS_OK(status
)) {
581 status
= smbXsrv_tcon_global_traverse(wipedbs_traverse_tcon
, state
);
582 if (!NT_STATUS_IS_OK(status
)) {
586 status
= smbXsrv_open_global_traverse(wipedbs_traverse_open
, state
);
587 if (!NT_STATUS_IS_OK(status
)) {
591 status
= wipedbs_check_server_exists(state
);
592 if (!NT_STATUS_IS_OK(status
)) {
596 status
= dbwrap_traverse_read(state
->id2server_data
,
597 wipedbs_traverse_server_data
,
599 if (!NT_STATUS_IS_OK(status
)) {
600 DEBUG(0, ("Failed to traverse db: %s\n", nt_errstr(status
)));
604 d_printf("Found %d serverids, %d alive and %d disconnected\n",
605 state
->stat
.server
.total
,
606 state
->stat
.server
.existing
,
607 state
->stat
.server
.disconnected
);
608 d_printf("Found %d sessions, %d alive and %d disconnected"
609 ", cleaned up %d of %d entries\n",
610 state
->stat
.session
.total
,
611 state
->stat
.session
.total
- state
->stat
.session
.todelete
,
612 state
->stat
.session
.disconnected
,
613 state
->stat
.session
.todelete
- state
->stat
.session
.failure
,
614 state
->stat
.session
.todelete
);
615 d_printf("Found %d tcons, %d alive and %d disconnected"
616 ", cleaned up %d of %d entries\n",
617 state
->stat
.tcon
.total
,
618 state
->stat
.tcon
.total
- state
->stat
.tcon
.todelete
,
619 state
->stat
.tcon
.disconnected
,
620 state
->stat
.tcon
.todelete
- state
->stat
.tcon
.failure
,
621 state
->stat
.tcon
.todelete
);
622 d_printf("Found %d opens, %d alive, %d disconnected and %d timed out"
623 ", cleaned up %d of %d entries\n",
624 state
->stat
.open
.total
,
625 state
->stat
.open
.total
- state
->stat
.open
.todelete
626 - (state
->stat
.open
.disconnected
- state
->stat
.open_timed_out
),
627 state
->stat
.open
.disconnected
,
628 state
->stat
.open_timed_out
,
629 state
->stat
.open
.todelete
- state
->stat
.open
.failure
,
630 state
->stat
.open
.todelete
);
638 int net_serverid(struct net_context
*c
, int argc
, const char **argv
)
640 struct functable func
[] = {
645 N_("List all entries from serverid.tdb"),
646 N_("net serverid list\n"
647 " List all entries from serverid.tdb")
653 N_("Wipe the serverid.tdb for the current node"),
654 N_("net serverid wipe\n"
655 " Wipe the serverid.tdb for the current node")
659 net_serverid_wipedbs
,
661 N_("Clean dead entries from temporary databases"),
662 N_("net serverid wipedbs\n"
663 " Clean dead entries from temporary databases")
665 {NULL
, NULL
, 0, NULL
, NULL
}
668 return net_run_function(c
, argc
, argv
, "net serverid", func
);