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 "lib/util/server_id.h"
23 #include "dbwrap/dbwrap.h"
24 #include "dbwrap/dbwrap_rbt.h"
27 #include "smbd/globals.h"
28 #include "smbd/smbXsrv_open.h"
30 #include "librpc/gen_ndr/ndr_open_files.h"
32 struct wipedbs_record_marker {
33 struct wipedbs_record_marker *prev, *next;
38 struct wipedbs_server_data {
39 struct server_id server_id;
40 const char *server_id_str;
42 struct wipedbs_record_marker *session_records;
43 struct wipedbs_record_marker *tcon_records;
44 struct wipedbs_record_marker *open_records;
47 struct wipedbs_state {
48 struct db_context *id2server_data;
60 } session, tcon, open;
63 struct server_id *server_ids;
66 struct db_context *session_db;
67 struct db_context *tcon_db;
68 struct db_context *open_db;
74 static struct wipedbs_server_data *get_server_data(struct wipedbs_state *state,
75 const struct server_id *id)
77 struct wipedbs_server_data *ret = NULL;
78 TDB_DATA key, val = tdb_null;
81 key = make_tdb_data((const void*)&id->unique_id, sizeof(id->unique_id));
82 status = dbwrap_fetch(state->id2server_data, talloc_tos(), key, &val);
83 if (NT_STATUS_IS_OK(status)) {
84 ret = *(struct wipedbs_server_data**) val.dptr;
85 TALLOC_FREE(val.dptr);
86 } else if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
87 struct server_id_buf idbuf;
89 server_id_str_buf(*id, &idbuf);
91 ret = talloc_zero(state->id2server_data,
92 struct wipedbs_server_data);
94 DEBUG(0, ("Failed to allocate server entry for %s\n",
99 ret->server_id_str = talloc_strdup(ret, idbuf.buf);
101 val = make_tdb_data((const void*)&ret, sizeof(ret));
102 status = dbwrap_store(state->id2server_data,
103 key, val, TDB_INSERT);
104 if (!NT_STATUS_IS_OK(status)) {
105 DEBUG(0, ("Failed to store server entry for %s: %s\n",
106 idbuf.buf, nt_errstr(status)));
110 struct server_id_buf idbuf;
111 DEBUG(0, ("Failed to fetch server entry for %s: %s\n",
112 server_id_str_buf(*id, &idbuf), nt_errstr(status)));
115 if (!server_id_equal(id, &ret->server_id)) {
116 struct server_id_buf idbuf1, idbuf2;
117 DEBUG(0, ("uniq id collision for %s and %s\n",
118 server_id_str_buf(*id, &idbuf1),
119 server_id_str_buf(ret->server_id, &idbuf2)));
120 smb_panic("server_id->unique_id not unique!");
126 static int wipedbs_traverse_sessions(struct smbXsrv_session_global0 *session,
129 struct wipedbs_state *state =
130 talloc_get_type_abort(wipedbs_state,
131 struct wipedbs_state);
132 struct wipedbs_server_data *sd;
133 struct wipedbs_record_marker *rec;
137 assert(session->num_channels == 1);
139 state->stat.session.total++;
141 sd = get_server_data(state, &session->channels[0].server_id);
146 if (server_id_is_disconnected(&sd->server_id)) {
147 state->stat.session.disconnected++;
150 rec = talloc_zero(sd, struct wipedbs_record_marker);
152 DEBUG(0, ("Out of memory!\n"));
156 tmp = dbwrap_record_get_key(session->db_rec);
157 rec->key = tdb_data_talloc_copy(rec, tmp);
158 tmp = dbwrap_record_get_value(session->db_rec);
159 rec->val = tdb_data_talloc_copy(rec, tmp);
161 rec->desc = talloc_asprintf(
162 rec, "session[global: %u wire: %llu]",
163 session->session_global_id,
164 (long long unsigned)session->session_wire_id);
166 if ((rec->key.dptr == NULL) || (rec->val.dptr == NULL) ||
169 DEBUG(0, ("Out of memory!\n"));
173 state->session_db = dbwrap_record_get_db(session->db_rec);
175 DLIST_ADD(sd->session_records, rec);
181 static int wipedbs_traverse_tcon(struct smbXsrv_tcon_global0 *tcon,
184 struct wipedbs_state *state =
185 talloc_get_type_abort(wipedbs_state,
186 struct wipedbs_state);
187 struct wipedbs_server_data *sd;
188 struct wipedbs_record_marker *rec;
192 state->stat.tcon.total++;
194 sd = get_server_data(state, &tcon->server_id);
199 if (server_id_is_disconnected(&sd->server_id)) {
200 state->stat.tcon.disconnected++;
203 rec = talloc_zero(sd, struct wipedbs_record_marker);
205 DEBUG(0, ("Out of memory!\n"));
209 tmp = dbwrap_record_get_key(tcon->db_rec);
210 rec->key = tdb_data_talloc_copy(rec, tmp);
211 tmp = dbwrap_record_get_value(tcon->db_rec);
212 rec->val = tdb_data_talloc_copy(rec, tmp);
214 rec->desc = talloc_asprintf(
215 rec, "tcon[global: %u wire: %u session: %u share: %s]",
216 tcon->tcon_global_id, tcon->tcon_wire_id,
217 tcon->session_global_id, tcon->share_name);
219 if ((rec->key.dptr == NULL) || (rec->val.dptr == NULL) ||
222 DEBUG(0, ("Out of memory!\n"));
226 state->tcon_db = dbwrap_record_get_db(tcon->db_rec);
228 DLIST_ADD(sd->tcon_records, rec);
235 static int wipedbs_traverse_open(struct db_record *db_rec,
236 struct smbXsrv_open_global0 *open,
239 struct wipedbs_state *state =
240 talloc_get_type_abort(wipedbs_state,
241 struct wipedbs_state);
242 struct wipedbs_server_data *sd;
243 struct wipedbs_record_marker *rec;
247 state->stat.open.total++;
249 sd = get_server_data(state, &open->server_id);
254 if (server_id_is_disconnected(&sd->server_id)) {
255 struct timeval disconnect_time;
259 state->stat.open.disconnected++;
261 nttime_to_timeval(&disconnect_time, open->disconnect_time);
262 tdiff = usec_time_diff(&state->now, &disconnect_time);
263 reached = (tdiff >= INT64_C(1000)*open->durable_timeout_msec);
265 if (state->verbose) {
266 TALLOC_CTX *mem_ctx = talloc_new(talloc_tos());
267 enum ndr_err_code ndr_err;
268 struct vfs_default_durable_cookie cookie;
270 ndr_err = ndr_pull_struct_blob(
271 &open->backend_cookie, mem_ctx, &cookie,
272 (ndr_pull_flags_fn_t)ndr_pull_vfs_default_durable_cookie);
273 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
274 d_printf("ndr_pull_struct_blob failed\n");
279 d_printf("open[%s/%s id: 0x%" PRIx32 "] disconnected at "
280 "[%s] %us ago with timeout of %us "
282 cookie.servicepath, cookie.base_name,
283 open->open_global_id,
284 nt_time_string(mem_ctx, open->disconnect_time),
285 (unsigned)(tdiff/1000000),
286 open->durable_timeout_msec / 1000,
287 reached ? "" : " not");
288 talloc_free(mem_ctx);
295 state->stat.open_timed_out++;
298 rec = talloc_zero(sd, struct wipedbs_record_marker);
300 DEBUG(0, ("Out of memory!\n"));
304 tmp = dbwrap_record_get_key(db_rec);
305 rec->key = tdb_data_talloc_copy(rec, tmp);
306 tmp = dbwrap_record_get_value(db_rec);
307 rec->val = tdb_data_talloc_copy(rec, tmp);
309 rec->desc = talloc_asprintf(
310 rec, "open[global: %u persistent: %llu volatile: %llu]",
311 open->open_global_id,
312 (long long unsigned)open->open_persistent_id,
313 (long long unsigned)open->open_volatile_id);
315 if ((rec->key.dptr == NULL) || (rec->val.dptr == NULL) ||
318 DEBUG(0, ("Out of memory!\n"));
322 state->open_db = dbwrap_record_get_db(db_rec);
324 DLIST_ADD(sd->open_records, rec);
331 static int wipedbs_traverse_nop(struct db_record *rec, void *private_data)
336 static int wipedbs_traverse_fill_ids(struct db_record *rec, void *wipedbs_state)
338 struct wipedbs_state *state = talloc_get_type_abort(
339 wipedbs_state, struct wipedbs_state);
341 TDB_DATA val = dbwrap_record_get_value(rec);
343 struct wipedbs_server_data *sd = talloc_get_type_abort(
344 *(void**)val.dptr, struct wipedbs_server_data);
346 state->server_ids[state->idx] = sd->server_id;
351 static int wipedbs_traverse_set_exists(struct db_record *rec,
354 struct wipedbs_state *state = talloc_get_type_abort(
355 wipedbs_state, struct wipedbs_state);
357 TDB_DATA val = dbwrap_record_get_value(rec);
359 struct wipedbs_server_data *sd = talloc_get_type_abort(
360 *(void**)val.dptr, struct wipedbs_server_data);
362 /* assume a stable traverse order for rbt */
363 SMB_ASSERT(server_id_equal(&state->server_ids[state->idx],
365 sd->exists = state->server_exists[state->idx];
368 state->stat.server.existing++;
370 if (server_id_is_disconnected(&sd->server_id)) {
371 state->stat.server.disconnected++;
378 static bool serverids_exist(const struct server_id *ids, int num_ids,
383 for (i=0; i<num_ids; i++) {
384 results[i] = serverid_exists(&ids[i]);
391 static NTSTATUS wipedbs_check_server_exists(struct wipedbs_state *state)
397 status = dbwrap_traverse_read(state->id2server_data,
398 wipedbs_traverse_nop, NULL, &num_servers);
399 if (!NT_STATUS_IS_OK(status)) {
400 DEBUG(0, ("Failed to traverse temporary database\n"));
403 state->stat.server.total = num_servers;
405 state->server_ids = talloc_array(state, struct server_id, num_servers);
406 state->server_exists = talloc_array(state, bool, num_servers);
407 if (state->server_ids == NULL || state->server_exists == NULL) {
408 DEBUG(0, ("Out of memory\n"));
413 status = dbwrap_traverse_read(state->id2server_data,
414 wipedbs_traverse_fill_ids,
416 if (!NT_STATUS_IS_OK(status)) {
417 DEBUG(0, ("Failed to traverse temporary database\n"));
421 ok = serverids_exist(state->server_ids, num_servers, state->server_exists);
423 DEBUG(0, ("Calling serverids_exist failed\n"));
424 status = NT_STATUS_UNSUCCESSFUL;
429 status = dbwrap_traverse_read(state->id2server_data,
430 wipedbs_traverse_set_exists, state, NULL);
431 if (!NT_STATUS_IS_OK(status)) {
432 DEBUG(0, ("Failed to traverse temporary database\n"));
436 TALLOC_FREE(state->server_ids);
437 TALLOC_FREE(state->server_exists);
441 struct wipedbs_delete_state {
442 struct wipedbs_record_marker *cur;
449 static void wipedbs_delete_fn(
450 struct db_record *rec, TDB_DATA value, void *private_data)
452 struct db_context *db = dbwrap_record_get_db(rec);
453 struct wipedbs_delete_state *state = private_data;
454 struct wipedbs_record_marker *cur = state->cur;
455 NTSTATUS status = NT_STATUS_OK;
459 if (!tdb_data_equal(value, cur->val)) {
460 DBG_ERR("Warning: record <%s> from %s changed,"
462 cur->desc, dbwrap_name(db));
466 if (state->verbose) {
467 d_printf("deleting %s\n", cur->desc);
470 if (!state->dry_run) {
471 status = dbwrap_record_delete(rec);
474 if (!NT_STATUS_IS_OK(status)) {
475 DBG_ERR("Failed to delete record <%s> from %s: %s\n",
485 static int wipedbs_delete_records(struct db_context *db,
486 struct wipedbs_record_marker *records,
487 bool dry_run, bool verbose, int *count)
489 struct wipedbs_delete_state state = {
490 .verbose = verbose, .dry_run = dry_run,
497 for (state.cur = records;
499 state.cur = state.cur->next) {
501 NTSTATUS status = dbwrap_do_locked(
502 db, state.cur->key, wipedbs_delete_fn, &state);
504 if (!NT_STATUS_IS_OK(status)) {
505 DBG_ERR("dbwrap_do_locked failed for record <%s> "
513 d_printf("Deleted %zu of %zu records from %s\n",
520 *count += state.total;
523 return state.total - state.num;
526 static int wipedbs_traverse_server_data(struct db_record *rec,
529 struct wipedbs_state *state = talloc_get_type_abort(
530 wipedbs_state, struct wipedbs_state);
531 bool dry_run = state->testmode;
532 TDB_DATA val = dbwrap_record_get_value(rec);
534 struct wipedbs_server_data *sd = talloc_get_type_abort(
535 *(void**)val.dptr, struct wipedbs_server_data);
537 if (state->verbose) {
538 d_printf("Server: '%s' %s\n", sd->server_id_str,
541 "does not exist, cleaning up...");
548 ret = wipedbs_delete_records(state->session_db, sd->session_records,
549 dry_run, state->verbose,
550 &state->stat.session.todelete);
551 state->stat.session.failure += ret;
553 ret = wipedbs_delete_records(state->tcon_db, sd->tcon_records,
554 dry_run, state->verbose,
555 &state->stat.tcon.todelete);
556 state->stat.tcon.failure += ret;
558 ret = wipedbs_delete_records(state->open_db, sd->open_records,
559 dry_run, state->verbose,
560 &state->stat.open.todelete);
561 state->stat.open.failure += ret;
566 static int net_serverid_wipedbs(struct net_context *c, int argc,
571 struct wipedbs_state *state = talloc_zero(talloc_tos(),
572 struct wipedbs_state);
574 if (c->display_usage) {
577 _("net serverid wipedbs [--test] [--verbose]\n"));
580 _("net serverid wipedbs -v\n"));
584 state->now = timeval_current();
585 state->testmode = c->opt_testmode;
586 state->verbose = c->opt_verbose;
588 state->id2server_data = db_open_rbt(state);
589 if (state->id2server_data == NULL) {
590 DEBUG(0, ("Failed to open temporary database\n"));
594 status = smbXsrv_session_global_traverse(wipedbs_traverse_sessions,
596 if (!NT_STATUS_IS_OK(status)) {
600 status = smbXsrv_tcon_global_traverse(wipedbs_traverse_tcon, state);
601 if (!NT_STATUS_IS_OK(status)) {
605 status = smbXsrv_open_global_traverse(wipedbs_traverse_open, state);
606 if (!NT_STATUS_IS_OK(status)) {
610 status = wipedbs_check_server_exists(state);
611 if (!NT_STATUS_IS_OK(status)) {
615 status = dbwrap_traverse_read(state->id2server_data,
616 wipedbs_traverse_server_data,
618 if (!NT_STATUS_IS_OK(status)) {
619 DEBUG(0, ("Failed to traverse db: %s\n", nt_errstr(status)));
623 d_printf("Found %d serverids, %d alive and %d disconnected\n",
624 state->stat.server.total,
625 state->stat.server.existing,
626 state->stat.server.disconnected);
627 d_printf("Found %d sessions, %d alive and %d disconnected"
628 ", cleaned up %d of %d entries\n",
629 state->stat.session.total,
630 state->stat.session.total - state->stat.session.todelete,
631 state->stat.session.disconnected,
632 state->stat.session.todelete - state->stat.session.failure,
633 state->stat.session.todelete);
634 d_printf("Found %d tcons, %d alive and %d disconnected"
635 ", cleaned up %d of %d entries\n",
636 state->stat.tcon.total,
637 state->stat.tcon.total - state->stat.tcon.todelete,
638 state->stat.tcon.disconnected,
639 state->stat.tcon.todelete - state->stat.tcon.failure,
640 state->stat.tcon.todelete);
641 d_printf("Found %d opens, %d alive, %d disconnected and %d timed out"
642 ", cleaned up %d of %d entries\n",
643 state->stat.open.total,
644 state->stat.open.total - state->stat.open.todelete
645 - (state->stat.open.disconnected - state->stat.open_timed_out),
646 state->stat.open.disconnected,
647 state->stat.open_timed_out,
648 state->stat.open.todelete - state->stat.open.failure,
649 state->stat.open.todelete);
657 static int net_serverid_exists(struct net_context *c, int argc,
660 struct server_id pid;
663 if ((argc != 1) || (c->display_usage)) {
665 "net serverid exists <serverid>\n");
669 pid = server_id_from_string(get_my_vnn(), argv[0]);
670 ok = serverid_exists(&pid);
673 d_printf("%s exists\n", argv[0]);
675 d_printf("%s does not exist\n", argv[0]);
681 int net_serverid(struct net_context *c, int argc, const char **argv)
683 struct functable func[] = {
686 net_serverid_wipedbs,
688 N_("Clean dead entries from temporary databases"),
689 N_("net serverid wipedbs\n"
690 " Clean dead entries from temporary databases")
696 N_("Show existence of a serverid"),
697 N_("net serverid exists <id>")
699 {NULL, NULL, 0, NULL, NULL}
702 return net_run_function(c, argc, argv, "net serverid", func);