static int run_child(int i, int seed, unsigned num_loops, unsigned start,
int tdb_flags)
{
struct sigaction act = { .sa_sigaction = segv_handler,
.sa_flags = SA_SIGINFO };
sigaction(11, &act, NULL);
db = tdb_open("torture.tdb", tdb_flags, O_RDWR | O_CREAT, 0600,
&log_attr);
if (!db) {
fatal(NULL, "db open failed");
}
#if 0
if (i == 0) {
printf("pid %i\n", getpid());
sleep(9);
} else
sleep(10);
#endif
srand(seed + i);
srandom(seed + i);
/* Set global, then we're ready to handle being killed. */
loopnum = start;
signal(SIGUSR1, send_count_and_suicide);
for (;loopnum<num_loops && error_count == 0;loopnum++) {
addrec_db();
}
if (error_count == 0) {
tdb_traverse(db, NULL, NULL);
#if TRANSACTION_PROB
if (always_transaction) {
while (in_transaction) {
tdb_transaction_cancel(db);
in_transaction--;
}
if (tdb_transaction_start(db) != 0)
fatal(db, "tdb_transaction_start failed");
}
#endif
tdb_traverse(db, traverse_fn, NULL);
tdb_traverse(db, traverse_fn, NULL);
#if TRANSACTION_PROB
if (always_transaction) {
if (tdb_transaction_commit(db) != 0)
fatal(db, "tdb_transaction_commit failed");
}
#endif
}
tdb_close(db);
return (error_count < 100 ? error_count : 100);
}
int main(int argc, char *argv[])
{
struct tdb_context *tdb;
TDB_DATA key, data;
union tdb_attribute hsize;
hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
hsize.base.next = &tap_log_attr;
hsize.tdb1_hashsize.hsize = 1024;
plan_tests(13);
agent = prepare_external_agent1();
if (!agent)
err(1, "preparing agent");
tdb = tdb_open("run-traverse-in-transaction.tdb1",
TDB_VERSION1, O_CREAT|O_TRUNC|O_RDWR,
0600, &hsize);
ok1(tdb);
key.dsize = strlen("hi");
key.dptr = (void *)"hi";
data.dptr = (void *)"world";
data.dsize = strlen("world");
ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
ok1(external_agent_operation1(agent, OPEN, tdb->name) == SUCCESS);
ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
== WOULD_HAVE_BLOCKED);
tdb_traverse(tdb, traverse, NULL);
/* That should *not* release the transaction lock! */
ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
== WOULD_HAVE_BLOCKED);
tdb_traverse(tdb, traverse, NULL);
/* That should *not* release the transaction lock! */
ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
== WOULD_HAVE_BLOCKED);
ok1(tdb_transaction_commit(tdb) == TDB_SUCCESS);
/* Now we should be fine. */
ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
== SUCCESS);
tdb_close(tdb);
return exit_status();
}
int main(int argc, const char *argv[])
{
int i, seed=0;
int loops = 10000;
int num_entries;
char test_gdbm[] = "test.gdbm";
unlink("test.gdbm");
db = tdb_open("test.tdb", 0, TDB_CLEAR_IF_FIRST,
O_RDWR | O_CREAT | O_TRUNC, 0600);
gdbm = gdbm_open(test_gdbm, 512, GDBM_WRITER|GDBM_NEWDB|GDBM_FAST,
0600, NULL);
if (!db || !gdbm) {
fatal("db open failed");
}
#if 1
srand(seed);
_start_timer();
for (i=0;i<loops;i++) addrec_gdbm();
printf("gdbm got %.2f ops/sec\n", i/_end_timer());
#endif
merge_test();
srand(seed);
_start_timer();
for (i=0;i<loops;i++) addrec_db();
printf("tdb got %.2f ops/sec\n", i/_end_timer());
if (tdb_validate_freelist(db, &num_entries) == -1) {
printf("tdb freelist is corrupt\n");
} else {
printf("tdb freelist is good (%d entries)\n", num_entries);
}
compare_db();
printf("traversed %d records\n", tdb_traverse(db, traverse_fn, NULL));
printf("traversed %d records\n", tdb_traverse(db, traverse_fn, NULL));
tdb_close(db);
gdbm_close(gdbm);
return 0;
}
int main(int argc, char *argv[])
{
unsigned int i;
bool found[NUM_TESTS];
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
TDB_VERSION1, TDB_VERSION1|TDB_NOMMAP,
TDB_VERSION1|TDB_CONVERT,
TDB_VERSION1|TDB_NOMMAP|TDB_CONVERT
};
plan_tests(sizeof(flags) / sizeof(flags[0]) * 6 + 1);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
tdb = tdb_open("run-93-repack.tdb", flags[i],
O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
ok1(tdb);
if (!tdb)
break;
ok1(store_all(tdb));
ok1(tdb_repack(tdb) == TDB_SUCCESS);
memset(found, 0, sizeof(found));
ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
ok1(tdb_traverse(tdb, mark_entry, found) == NUM_TESTS);
ok1(is_all_set(found, NUM_TESTS));
tdb_close(tdb);
}
ok1(tap_log_messages == 0);
return exit_status();
}
BOOL share_info_db_init(void)
{
const char *vstring = "INFO/version";
int32 vers_id;
if (share_tdb) {
return True;
}
share_tdb = tdb_open_log(lock_path("share_info.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
if (!share_tdb) {
DEBUG(0,("Failed to open share info database %s (%s)\n",
lock_path("share_info.tdb"), strerror(errno) ));
return False;
}
/* handle a Samba upgrade */
tdb_lock_bystring(share_tdb, vstring);
/* Cope with byte-reversed older versions of the db. */
vers_id = tdb_fetch_int32(share_tdb, vstring);
if ((vers_id == SHARE_DATABASE_VERSION_V1) || (IREV(vers_id) == SHARE_DATABASE_VERSION_V1)) {
/* Written on a bigendian machine with old fetch_int code. Save as le. */
tdb_store_int32(share_tdb, vstring, SHARE_DATABASE_VERSION_V2);
vers_id = SHARE_DATABASE_VERSION_V2;
}
if (vers_id != SHARE_DATABASE_VERSION_V2) {
tdb_traverse(share_tdb, tdb_traverse_delete_fn, NULL);
tdb_store_int32(share_tdb, vstring, SHARE_DATABASE_VERSION_V2);
}
tdb_unlock_bystring(share_tdb, vstring);
return True;
}
static NTSTATUS net_idmap_fixup_hwm(void)
{
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
TDB_CONTEXT *idmap_tdb;
char *tdbfile = NULL;
struct hwms hwms;
struct hwms highest;
if (!lp_idmap_uid(&hwms.user_hwm, &highest.user_hwm) ||
!lp_idmap_gid(&hwms.group_hwm, &highest.group_hwm)) {
d_fprintf(stderr, "idmap range missing\n");
return NT_STATUS_UNSUCCESSFUL;
}
tdbfile = SMB_STRDUP(lock_path("winbindd_idmap.tdb"));
if (!tdbfile) {
DEBUG(0, ("idmap_init: out of memory!\n"));
return NT_STATUS_NO_MEMORY;
}
idmap_tdb = tdb_open_log(tdbfile, 0, TDB_DEFAULT, O_RDWR, 0);
if (idmap_tdb == NULL) {
d_fprintf(stderr, "Could not open idmap: %s\n", tdbfile);
return NT_STATUS_NO_SUCH_FILE;
}
hwms.ok = True;
tdb_traverse(idmap_tdb, net_idmap_find_max_id, &hwms);
if (!hwms.ok) {
goto done;
}
d_printf("USER HWM: %d GROUP HWM: %d\n",
hwms.user_hwm, hwms.group_hwm);
if (hwms.user_hwm >= highest.user_hwm) {
d_fprintf(stderr, "Highest UID out of uid range\n");
goto done;
}
if (hwms.group_hwm >= highest.group_hwm) {
d_fprintf(stderr, "Highest GID out of gid range\n");
goto done;
}
if ((tdb_store_int32(idmap_tdb, "USER HWM", (int32)hwms.user_hwm) != 0) ||
(tdb_store_int32(idmap_tdb, "GROUP HWM", (int32)hwms.group_hwm) != 0)) {
d_fprintf(stderr, "Could not store HWMs\n");
goto done;
}
result = NT_STATUS_OK;
done:
tdb_close(idmap_tdb);
return result;
}
PyObject *py_tdb_hnd_traverse(PyObject *self, PyObject *args, PyObject *kw)
{
tdb_hnd_object *obj = (tdb_hnd_object *)self;
static char *kwlist[] = { "traverse_fn", "state", NULL };
PyObject *state = Py_None, *callback;
struct traverse_info info;
int result;
if (!PyArg_ParseTupleAndKeywords(
args, kw, "O|O", kwlist, &callback, &state))
return NULL;
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "parameter must be callable");
return NULL;
}
Py_INCREF(callback);
Py_INCREF(state);
info.callback = callback;
info.state = state;
result = tdb_traverse(obj->tdb, tdb_traverse_traverse, &info);
Py_DECREF(callback);
Py_DECREF(state);
return PyInt_FromLong(result);
}
/***********************************************************
Dump the current idmap
**********************************************************/
static int net_idmap_dump(struct net_context *c, int argc, const char **argv)
{
TDB_CONTEXT *idmap_tdb;
if ( argc != 1 || c->display_usage) {
d_printf(_("Usage:\n"
"net idmap dump <inputfile>\n"
" Dump current ID mapping.\n"
" inputfile\tTDB file to read mappings from.\n"));
return c->display_usage?0:-1;
}
idmap_tdb = tdb_open_log(argv[0], 0, TDB_DEFAULT, O_RDONLY, 0);
if (idmap_tdb == NULL) {
d_fprintf(stderr, _("Could not open idmap: %s\n"), argv[0]);
return -1;
}
tdb_traverse(idmap_tdb, net_idmap_dump_one_entry, NULL);
tdb_close(idmap_tdb);
return 0;
}
static int dump_tdb(const char *fname, const char *keyname, bool emergency)
{
TDB_CONTEXT *tdb;
TDB_DATA key, value;
struct tdb_logging_context logfn = { log_stderr };
tdb = tdb_open_ex(fname, 0, 0, O_RDONLY, 0, &logfn, NULL);
if (!tdb) {
printf("Failed to open %s\n", fname);
return 1;
}
if (emergency) {
return tdb_rescue(tdb, emergency_walk, keyname) == 0;
}
if (!keyname) {
return tdb_traverse(tdb, traverse_fn, NULL) == -1 ? 1 : 0;
} else {
key.dptr = discard_const_p(uint8_t, keyname);
key.dsize = strlen(keyname);
value = tdb_fetch(tdb, key);
if (!value.dptr) {
return 1;
} else {
print_data(value);
free(value.dptr);
}
}
return 0;
}
/**
* Send a message to all smbd processes.
*
* It isn't very efficient, but should be OK for the sorts of
* applications that use it. When we need efficient broadcast we can add
* it.
*
* @param n_sent Set to the number of messages sent. This should be
* equal to the number of processes, but be careful for races.
*
* @retval True for success.
**/
BOOL message_send_all(TDB_CONTEXT *conn_tdb, int msg_type,
const void *buf, size_t len,
BOOL duplicates_allowed,
int *n_sent)
{
struct msg_all msg_all;
msg_all.msg_type = msg_type;
if (msg_type < 1000)
msg_all.msg_flag = FLAG_MSG_GENERAL;
else if (msg_type > 1000 && msg_type < 2000)
msg_all.msg_flag = FLAG_MSG_NMBD;
else if (msg_type > 2000 && msg_type < 2100)
msg_all.msg_flag = FLAG_MSG_PRINT_NOTIFY;
else if (msg_type > 2100 && msg_type < 3000)
msg_all.msg_flag = FLAG_MSG_PRINT_GENERAL;
else if (msg_type > 3000 && msg_type < 4000)
msg_all.msg_flag = FLAG_MSG_SMBD;
else
return False;
msg_all.buf = buf;
msg_all.len = len;
msg_all.duplicates = duplicates_allowed;
msg_all.n_sent = 0;
tdb_traverse(conn_tdb, traverse_fn, &msg_all);
if (n_sent)
*n_sent = msg_all.n_sent;
return True;
}
int db_hash_traverse_update(struct db_hash_context *dh,
db_hash_record_parser_fn parser,
void *private_data, int *count)
{
struct db_hash_traverse_state state;
int ret;
if (dh == NULL || parser == NULL) {
return EINVAL;
}
state.parser = parser;
state.private_data = private_data;
ret = tdb_traverse(dh->db, db_hash_traverse_parser, &state);
if (ret == -1) {
ret = db_hash_map_tdb_error(dh);
} else {
if (count != NULL) {
*count = ret;
}
ret = 0;
}
return ret;
}
static int tdb_hnd_length(tdb_hnd_object *obj)
{
int result;
result = tdb_traverse(obj->tdb, tdb_traverse_count, NULL);
return result;
}
static void info_tdb(void)
{
int count;
total_bytes = 0;
if ((count = tdb_traverse(tdb, traverse_fn, NULL) == -1))
printf("Error = %s\n", tdb_errorstr(tdb));
else
printf("%d records totalling %d bytes\n", count, total_bytes);
}
int dump_tdb(DATABASE *db, tdb_traverse_func fn)
{
if (!db || !db->tdb) {
return ERR_DB_INVALID;
}
tdb_traverse(db->tdb, fn, NULL);
return ERR_OK;
}
static BOOL session_traverse(int (*fn)(TDB_CONTEXT *, TDB_DATA, TDB_DATA, void *), void *state)
{
if (!tdb) {
DEBUG(3, ("No tdb opened\n"));
return False;
}
tdb_traverse(tdb, fn, state);
return True;
}
int sss_ncache_reset_permament(struct sss_nc_ctx *ctx)
{
int ret;
ret = tdb_traverse(ctx->tdb, delete_permanent, NULL);
if (ret < 0)
return EIO;
return EOK;
}
enum TDB_ERROR tdb_repack(struct tdb_context *tdb)
{
struct tdb_context *tmp_db;
struct traverse_state state;
state.error = tdb_transaction_start(tdb);
if (state.error != TDB_SUCCESS) {
return state.error;
}
tmp_db = tdb_open("tmpdb", TDB_INTERNAL, O_RDWR|O_CREAT, 0, NULL);
if (tmp_db == NULL) {
state.error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
__location__
" Failed to create tmp_db");
tdb_transaction_cancel(tdb);
return tdb->last_error = state.error;
}
state.dest_db = tmp_db;
if (tdb_traverse(tdb, repack_traverse, &state) < 0) {
goto fail;
}
state.error = tdb_wipe_all(tdb);
if (state.error != TDB_SUCCESS) {
goto fail;
}
state.dest_db = tdb;
if (tdb_traverse(tmp_db, repack_traverse, &state) < 0) {
goto fail;
}
tdb_close(tmp_db);
return tdb_transaction_commit(tdb);
fail:
tdb_transaction_cancel(tdb);
tdb_close(tmp_db);
return state.error;
}
/****************************************************************************
delete all old unexpected packets
**************************************************************************/
void clear_unexpected(time_t t)
{
if (!tdbd) return;
if ((lastt != 0) && (t < lastt + NMBD_UNEXPECTED_TIMEOUT))
return;
lastt = t;
tdb_traverse(tdbd, traverse_fn, NULL);
}
static int run_child(const char *filename, int i, int seed, unsigned num_loops, unsigned start)
{
db = tdb_open_ex(filename, hash_size, TDB_DEFAULT,
O_RDWR | O_CREAT, 0600, &log_ctx, NULL);
if (!db) {
fatal("db open failed");
}
srand(seed + i);
srandom(seed + i);
/* Set global, then we're ready to handle being killed. */
loopnum = start;
signal(SIGUSR1, send_count_and_suicide);
for (;loopnum<num_loops && error_count == 0;loopnum++) {
addrec_db();
}
if (error_count == 0) {
tdb_traverse_read(db, NULL, NULL);
if (always_transaction) {
while (in_transaction) {
tdb_transaction_cancel(db);
in_transaction--;
}
if (tdb_transaction_start(db) != 0)
fatal("tdb_transaction_start failed");
}
tdb_traverse(db, traverse_fn, NULL);
tdb_traverse(db, traverse_fn, NULL);
if (always_transaction) {
if (tdb_transaction_commit(db) != 0)
fatal("tdb_transaction_commit failed");
}
}
tdb_close(db);
return (error_count < 100 ? error_count : 100);
}
/*
* internal validation function, executed by the child.
*/
static int tdb_validate_child(struct tdb_context *tdb,
tdb_validate_data_func validate_fn)
{
int ret = 1;
int num_entries = 0;
struct tdb_validation_status v_status;
v_status.tdb_error = False;
v_status.bad_freelist = False;
v_status.bad_entry = False;
v_status.unknown_key = False;
v_status.success = True;
if (!tdb) {
v_status.tdb_error = True;
v_status.success = False;
goto out;
}
/* Check if the tdb's freelist is good. */
if (tdb_validate_freelist(tdb, &num_entries) == -1) {
v_status.bad_freelist = True;
v_status.success = False;
goto out;
}
DEBUG(10,("tdb_validate_child: tdb %s freelist has %d entries\n",
tdb_name(tdb), num_entries));
/* Now traverse the tdb to validate it. */
num_entries = tdb_traverse(tdb, validate_fn, (void *)&v_status);
if (!v_status.success) {
goto out;
} else if (num_entries == -1) {
v_status.tdb_error = True;
v_status.success = False;
goto out;
}
DEBUG(10,("tdb_validate_child: tdb %s is good with %d entries\n",
tdb_name(tdb), num_entries));
ret = 0; /* Cache is good. */
out:
DEBUG(10, ("tdb_validate_child: summary of validation status:\n"));
DEBUGADD(10,(" * tdb error: %s\n", v_status.tdb_error ? "yes" : "no"));
DEBUGADD(10,(" * bad freelist: %s\n",v_status.bad_freelist?"yes":"no"));
DEBUGADD(10,(" * bad entry: %s\n", v_status.bad_entry ? "yes" : "no"));
DEBUGADD(10,(" * unknown key: %s\n", v_status.unknown_key?"yes":"no"));
DEBUGADD(10,(" => overall success: %s\n", v_status.success?"yes":"no"));
return ret;
}
/*
upgrade from a old style tdb
*/
static bool mapping_upgrade(const char *tdb_path)
{
static TDB_CONTEXT *tdb;
int ret, status=0;
tdb = tdb_open_log(tdb_path, 0, TDB_DEFAULT, O_RDWR, 0600);
if (tdb == NULL) goto failed;
/* we have to do the map records first, as alias records may
reference them */
ret = tdb_traverse(tdb, upgrade_map_record, &status);
if (ret == -1 || status == -1) goto failed;
ret = tdb_traverse(tdb, upgrade_alias_record, &status);
if (ret == -1 || status == -1) goto failed;
if (tdb) {
tdb_close(tdb);
tdb = NULL;
}
{
const char *old_path = tdb_path;
char *new_path = state_path("group_mapping.tdb.upgraded");
if (!new_path) {
goto failed;
}
if (rename(old_path, new_path) != 0) {
DEBUG(0,("Failed to rename old group mapping database\n"));
goto failed;
}
}
return True;
failed:
DEBUG(0,("Failed to upgrade group mapping database\n"));
if (tdb) tdb_close(tdb);
return False;
}
static int dump_tdb(const char *fname)
{
TDB_CONTEXT *tdb;
tdb = tdb_open(fname, 0, 0, O_RDONLY, 0);
if (!tdb) {
printf("Failed to open %s\n", fname);
return 1;
}
tdb_traverse(tdb, traverse_fn, NULL);
return 0;
}
static NTSTATUS tdbsam_setsampwent(struct pdb_methods *my_methods, BOOL update)
{
uint32 flags = update ? (O_RDWR|O_CREAT) : O_RDONLY;
struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
if ( !(tdb_state->passwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, flags )) )
return NT_STATUS_UNSUCCESSFUL;
tdb_traverse( tdb_state->passwd_tdb, tdbsam_traverse_setpwent, NULL );
return NT_STATUS_OK;
}
static int db_tdb_traverse(struct db_context *db,
int (*f)(struct db_record *rec, void *private_data),
void *private_data)
{
struct db_tdb_ctx *db_ctx =
talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
struct db_tdb_traverse_ctx ctx;
ctx.db = db;
ctx.f = f;
ctx.private_data = private_data;
return tdb_traverse(db_ctx->wtdb->tdb, db_tdb_traverse_func, &ctx);
}
void wcache_invalidate_cache(void)
{
struct winbindd_domain *domain;
for (domain = domain_list(); domain; domain = domain->next) {
struct winbind_cache *cache = get_cache(domain);
DEBUG(10, ("wcache_invalidate_cache: invalidating cache "
"entries for %s\n", domain->name));
if (cache)
tdb_traverse(cache->tdb, traverse_fn, NULL);
}
}
static int tdb_copy(struct tdb_context *src, struct tdb_context *dst)
{
struct tdb_copy_data data;
int count;
data.dst = dst;
data.success = True;
count = tdb_traverse(src, traverse_copy_fn, (void *)(&data));
if ((count < 0) || (data.success == False)) {
return -1;
}
return count;
}
static void check_db(TDB_CONTEXT *the_tdb)
{
int tdbcount=-1;
if (the_tdb) {
tdbcount = tdb_traverse(the_tdb, test_fn, NULL);
} else {
printf("Error: No database opened!\n");
}
if (tdbcount<0) {
printf("Integrity check for the opened database failed.\n");
} else {
printf("Database integrity is OK and has %d records.\n", tdbcount);
}
}
void namecache_flush(void)
{
int result;
if (!namecache_tdb)
return;
result = tdb_traverse(namecache_tdb, tdb_traverse_delete_fn, NULL);
if (result == -1)
DEBUG(5, ("namecache_flush: error deleting cache entries\n"));
else
DEBUG(5, ("namecache_flush: deleted %d cache entr%s\n",
result, result == 1 ? "y" : "ies"));
}
void brl_shutdown(int read_only)
{
if (!tdb)
return;
#if DONT_DO_THIS
/* doing this traversal could kill solaris machines under high load (tridge) */
/* delete any dead locks */
if (!read_only) {
BOOL check_self = True;
tdb_traverse(tdb, delete_fn, &check_self);
}
#endif
tdb_close(tdb);
}
static int dump_tdb(const char *fname, struct ldb_dn *dn, bool emergency)
{
TDB_CONTEXT *tdb;
struct tdb_logging_context logfn = { log_stderr };
tdb = tdb_open_ex(fname, 0, 0, O_RDONLY, 0, &logfn, NULL);
if (!tdb) {
fprintf(stderr, "Failed to open %s\n", fname);
return 1;
}
if (emergency) {
return tdb_rescue(tdb, emergency_walk, dn) == 0;
}
return tdb_traverse(tdb, traverse_fn, dn) == -1 ? 1 : 0;
}
