自学教程：C++ tdb_traverse函数代码示例

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;}

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;}

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;}