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

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 void open_tdb(void){  char *tok = get_token(1);  if (!tok) {    help();    return;  }  if (tdb) tdb_close(tdb);  tdb = tdb_open(tok, 0, 0, O_RDWR, 0600);  if (!tdb) {    printf("Could not open %s: %s/n", tok, strerror(errno));  }}

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, char *argv[]){	unsigned int i, j;	struct tdb_context *tdb;	int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,			TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,			TDB_NOMMAP|TDB_CONVERT };	TDB_DATA key = { (unsigned char *)&j, sizeof(j) };	TDB_DATA data = { (unsigned char *)&j, sizeof(j) };	char *summary;	plan_tests(sizeof(flags) / sizeof(flags[0]) * 14);	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {		tdb = tdb_open("run-summary.tdb1", flags[i]|TDB_VERSION1,			       O_RDWR|O_CREAT|O_TRUNC, 0600, NULL);		ok1(tdb);		if (!tdb)			continue;		/* Put some stuff in there. */		for (j = 0; j < 500; j++) {			/* Make sure padding varies to we get some graphs! */			data.dsize = j % (sizeof(j) + 1);			if (tdb_store(tdb, key, data, TDB_REPLACE)			    != TDB_SUCCESS) {				fail("Storing in tdb");			}		}		summary = tdb1_summary(tdb);		diag("%s", summary);		ok1(strstr(summary, "Size of file/data: "));		ok1(strstr(summary, "Number of records: 500/n"));		ok1(strstr(summary, "Smallest/average/largest keys: 4/4/4/n"));		ok1(strstr(summary, "Smallest/average/largest data: 0/2/4/n"));		ok1(strstr(summary, "Smallest/average/largest padding: "));		ok1(strstr(summary, "Number of dead records: 0/n"));		ok1(strstr(summary, "Number of free records: 1/n"));		ok1(strstr(summary, "Smallest/average/largest free records: "));		ok1(strstr(summary, "Number of hash chains: 131/n"));		ok1(strstr(summary, "Smallest/average/largest hash chains: "));		ok1(strstr(summary, "Number of uncoalesced records: 0/n"));		ok1(strstr(summary, "Smallest/average/largest uncoalesced runs: 0/0/0/n"));		ok1(strstr(summary, "Percentage keys/data/padding/free/dead/rechdrs&tailers/hashes: "));		free(summary);		tdb_close(tdb);	}	return exit_status();}

int main(int argc, char *argv[]){	unsigned int i;	struct tdb_context *tdb;	int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,			TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,			TDB_NOMMAP|TDB_CONVERT };	struct tdb_data key = tdb_mkdata("key", 3);	struct tdb_data data = tdb_mkdata("data", 4);	failtest_init(argc, argv);	failtest_hook = suppress_failure;	failtest_exit_check = exit_check_log;	failtest_suppress = true;	plan_tests(sizeof(flags) / sizeof(flags[0]) * 8 + 1);	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {		tdb = tdb_open("run-11-simple-fetch.tdb", flags[i],			       O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);		ok1(tdb);		if (tdb) {			struct tdb_data d = { NULL, 0 }; /* Bogus GCC warning */			/* fetch should fail. */			failtest_suppress = false;			if (!ok1(tdb_fetch(tdb, key, &d) == TDB_ERR_NOEXIST))				goto fail;			failtest_suppress = true;			ok1(tdb_check(tdb, NULL, NULL) == 0);			/* Insert should succeed. */			ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);			ok1(tdb_check(tdb, NULL, NULL) == 0);			/* Fetch should now work. */			failtest_suppress = false;			if (!ok1(tdb_fetch(tdb, key, &d) == TDB_SUCCESS))				goto fail;			failtest_suppress = true;			ok1(tdb_deq(d, data));			free(d.dptr);			ok1(tdb_check(tdb, NULL, NULL) == 0);			tdb_close(tdb);		}	}	ok1(tap_log_messages == 0);	return exit_status();fail:	failtest_suppress = true;	tdb_close(tdb);	failtest_exit(exit_status());}

static void move_rec(void){	char *k = get_token(1);	char *file = get_token(0);		TDB_DATA key, dbuf;	TDB_CONTEXT *dst_tdb;	if (!k) {		help();		return;	}		if ( !file ) {		terror("need destination tdb name");		return;	}	key.dptr = k;	key.dsize = strlen(k)+1;	dbuf = tdb_fetch(tdb, key);	if (!dbuf.dptr) {		/* maybe it is non-NULL terminated key? */		key.dsize = strlen(k); 		dbuf = tdb_fetch(tdb, key);				if ( !dbuf.dptr ) {			terror("fetch failed");			return;		}	}		print_rec(tdb, key, dbuf, NULL);		dst_tdb = tdb_open(file, 0, 0, O_RDWR, 0600);	if ( !dst_tdb ) {		terror("unable to open destination tdb");		return;	}		if ( tdb_store( dst_tdb, key, dbuf, TDB_REPLACE ) == -1 ) {		terror("failed to move record");	}	else		printf("record moved/n");		tdb_close( dst_tdb );		return;}

int main(int argc, char *argv[]){	unsigned int i, j;	struct tdb_context *tdb;	int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,			TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,			TDB_NOMMAP|TDB_CONVERT };	plan_tests(sizeof(flags) / sizeof(flags[0]) * 9 + 1);	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {		TDB_DATA k;		uint64_t size;		bool was_empty = false;		k.dptr = (void *)&j;		k.dsize = sizeof(j);		tdb = tdb_open("run-30-exhaust-before-expand.tdb", flags[i],			       O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);		ok1(tdb);		if (!tdb)			continue;		ok1(empty_freetable(tdb));		/* Need some hash lock for expand. */		ok1(tdb_lock_hashes(tdb, 0, 1, F_WRLCK, TDB_LOCK_WAIT) == 0);		/* Create some free space. */		ok1(tdb_expand(tdb, 1) == 0);		ok1(tdb_unlock_hashes(tdb, 0, 1, F_WRLCK) == 0);		ok1(tdb_check(tdb, NULL, NULL) == 0);		ok1(!empty_freetable(tdb));		size = tdb->map_size;		/* Insert minimal-length records until we expand. */		for (j = 0; tdb->map_size == size; j++) {			was_empty = empty_freetable(tdb);			if (tdb_store(tdb, k, k, TDB_INSERT) != 0)				err(1, "Failed to store record %i", j);		}		/* Would have been empty before expansion, but no longer. */		ok1(was_empty);		ok1(!empty_freetable(tdb));		tdb_close(tdb);	}	ok1(tap_log_messages == 0);	return exit_status();}

static void open_tdb(const char *tdbname){	union tdb_attribute log_attr;	log_attr.base.attr = TDB_ATTRIBUTE_LOG;	log_attr.base.next = NULL;	log_attr.log.fn = tdb_log;	if (tdb) tdb_close(tdb);	tdb = tdb_open(tdbname, disable_mmap?TDB_NOMMAP:0, O_RDWR, 0600,		       &log_attr);	if (!tdb) {		printf("Could not open %s: %s/n", tdbname, strerror(errno));	}}

static void create_tdb(void){  char *tok = get_token(1);  if (!tok) {    help();    return;  }  if (tdb) tdb_close(tdb);  tdb = tdb_open(tok, 0, TDB_CLEAR_IF_FIRST,           O_RDWR | O_CREAT | O_TRUNC, 0600);  if (!tdb) {    printf("Could not create %s: %s/n", tok, strerror(errno));  }}

int sss_ncache_init(TALLOC_CTX *memctx, struct sss_nc_ctx **_ctx){    struct sss_nc_ctx *ctx;    ctx = talloc_zero(memctx, struct sss_nc_ctx);    if (!ctx) return ENOMEM;    errno = 0;    /* open a memory only tdb with default hash size */    ctx->tdb = tdb_open("memcache", 0, TDB_INTERNAL, O_RDWR|O_CREAT, 0);    if (!ctx->tdb) return errno;    *_ctx = ctx;    return EOK;};

/* return the methods for this mangling implementation */const struct mangle_fns *mangle_hash_init(void){	mangle_reset();	/* Create the in-memory tdb using our custom hash function. */#ifndef BUILD_TDB2	tdb_mangled_cache = tdb_open_ex("mangled_cache", 1031, TDB_INTERNAL,				(O_RDWR|O_CREAT), 0644, NULL, fast_string_hash);#else	/* FIXME: We should *never* open a tdb without logging! */	tdb_mangled_cache = tdb_open("mangled_cache", TDB_INTERNAL, 0, 0, NULL);#endif	return &mangle_hash_fns;}

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

errcode_t ext2fs_create_icount_tdb(ext2_filsys fs, char *tdb_dir,				   int flags, ext2_icount_t *ret){	ext2_icount_t	icount;	errcode_t	retval;	char 		*fn, uuid[40];	ext2_ino_t	num_inodes;	int		fd;	retval = alloc_icount(fs, flags,  &icount);	if (retval)		return retval;	retval = ext2fs_get_mem(strlen(tdb_dir) + 64, &fn);	if (retval)		goto errout;	uuid_unparse(fs->super->s_uuid, uuid);	sprintf(fn, "%s/%s-icount-XXXXXX", tdb_dir, uuid);	fd = mkstemp(fn);	if (fd < 0)		return fd;	/*	 * This is an overestimate of the size that we will need; the	 * ideal value is the number of used inodes with a count	 * greater than 1.  OTOH the times when we really need this is	 * with the backup programs that use lots of hard links, in	 * which case the number of inodes in use approaches the ideal	 * value.	 */	num_inodes = fs->super->s_inodes_count - fs->super->s_free_inodes_count;	icount->tdb_fn = fn;	icount->tdb = tdb_open(fn, num_inodes, TDB_NOLOCK | TDB_NOSYNC,			       O_RDWR | O_CREAT | O_TRUNC, 0600);	if (icount->tdb) {		close(fd);		*ret = icount;		return 0;	}	retval = errno;	close(fd);errout:	ext2fs_free_icount(icount);	return(retval);}

void TdbDatabase::truncate() {    if (m_tdbFile) {        tdb_close(m_tdbFile);    }    m_tdbFile = tdb_open(m_databaseName.c_str(), 512, 0, O_RDWR | O_CREAT | O_TRUNC, S_IRWXU | S_IRGRP | S_IROTH);    if (m_tdbFile == NULL) {        string message;        message += "Error opening tdb database: ";        message += m_databaseName;        throw DatabaseException(CONNECT_ERROR, message.c_str());    }}

int main (int argc, char** argv){  struct MHD_Daemon *daemon;  TDB_CONTEXT *db;  db = tdb_open ("linksdb", 0, NULL, O_CREAT | O_RDWR, 0666);  daemon = MHD_start_daemon (MHD_USE_SELECT_INTERNALLY, PORT, NULL, NULL,			     &answer_to_connection, db, MHD_OPTION_END);  if (daemon == NULL)    return 1;  getchar();  MHD_stop_daemon (daemon);  return 0;}

int main(int argc, char *argv[]){	TDB_DATA key;	TDB_CONTEXT *tdb;	if (argc != 2)		barf("Usage: xs_tdb_dump <tdbfile>");	tdb = tdb_open(talloc_strdup(NULL, argv[1]), 0, 0, O_RDONLY, 0);	if (!tdb)		barf_perror("Could not open %s", argv[1]);	key = tdb_firstkey(tdb);	while (key.dptr) {		TDB_DATA data;		struct record_hdr *hdr;		data = tdb_fetch(tdb, key);		hdr = (void *)data.dptr;		if (data.dsize < sizeof(*hdr))			fprintf(stderr, "%.*s: BAD truncated/n",				(int)key.dsize, key.dptr);		else if (data.dsize != total_size(hdr))			fprintf(stderr, "%.*s: BAD length %i for %i/%i/%i (%i)/n",				(int)key.dsize, key.dptr, (int)data.dsize,				hdr->num_perms, hdr->datalen,				hdr->childlen, total_size(hdr));		else {			unsigned int i;			char *p;			printf("%.*s: ", (int)key.dsize, key.dptr);			for (i = 0; i < hdr->num_perms; i++)				printf("%s%c%i",				       i == 0 ? "" : ",",				       perm_to_char(hdr->perms[i].perms),				       hdr->perms[i].id);			p = (void *)&hdr->perms[hdr->num_perms];			printf(" %.*s/n", hdr->datalen, p);			p += hdr->datalen;			for (i = 0; i < hdr->childlen; i += strlen(p+i)+1)				printf("/t-> %s/n", p+i);		}		key = tdb_nextkey(tdb, key);	}	return 0;}

DATABASE* open_db( const char *DBName ){        if( NULL == DBName )        return NULL;    struct tdb_context *tdb = tdb_open(DBName, 0, 0, O_RDWR | O_CREAT, 0666);    if( NULL == tdb )        return NULL;    DATABASE *db = (DATABASE*)malloc(sizeof(DATABASE));    db->tdb = tdb;    sem_init( &db->sem, 0, 1 );    db->stamp = time(NULL);   // printf("time is %u/n", db->stamp );        return db;}

static int pytdb_init(PyTDB *self, PyObject *args, PyObject *kwds) {  static char *kwlist[] = {"filename", "hashsize", NULL};  if(!PyArg_ParseTupleAndKeywords(args, kwds, "s|L", kwlist, 				  &self->filename, &self->hashsize))    return -1;   self->context = tdb_open(self->filename, self->hashsize,			   0,			   O_RDWR | O_CREAT, 0644);  if(!self->context) {    PyErr_Format(PyExc_IOError, "Unable to open tdb file: %s", self->filename);    return -1;  };  return 0;};

BOOL torture_mangle(struct torture_context *torture, 					struct smbcli_state *cli){	extern int torture_numops;	int i;	/* we will use an internal tdb to store the names we have used */	tdb = tdb_open(NULL, 100000, TDB_INTERNAL, 0, 0);	if (!tdb) {		printf("ERROR: Failed to open tdb/n");		return False;	}	if (!torture_setup_dir(cli, "//mangle_test")) {		return False;	}	for (i=0;i<torture_numops;i++) {		fstring name;		ZERO_STRUCT(name);		gen_name(name);		if (!test_one(cli, name)) {			break;		}		if (total && total % 100 == 0) {			printf("collisions %u/%u  - %.2f%%   (%u failures)/r",			       collisions, total, (100.0*collisions) / total, failures);		}	}	smbcli_unlink(cli->tree, "//mangle_test//*");	if (NT_STATUS_IS_ERR(smbcli_rmdir(cli->tree, "//mangle_test"))) {		printf("ERROR: Failed to remove directory/n");		return False;	}	printf("/nTotal collisions %u/%u  - %.2f%%   (%u failures)/n",	       collisions, total, (100.0*collisions) / total, failures);	return (failures == 0);}

/** * copies a subset of data from one DB into another one. The subset is * given by field names */static int cmd_recode(const char* output_path, const char* input,		      const char** field_names, int names_length){	assert(names_length > 0);	tdb* const db = tdb_init(); assert(db);	int err = tdb_open(db, input);	if(err) {		REPORT_ERROR("Failed to open TDB. error=%i/n", err);		return 1;	}	tdb_field* field_ids;	err = resolve_fieldids(&field_ids, db, field_names, names_length);	if(err < 0) {		goto free_tdb;	}	tdb_cons* const cons = tdb_cons_init();	assert(cons);	err = tdb_cons_open(cons, output_path, field_names, (unsigned)names_length);	if(err) {		REPORT_ERROR("Failed to create TDB cons. error=%i/n", err);		goto free_ids;	}	TIMED("recode", err, do_recode(cons, db, field_ids, names_length));	if(err)		goto close_cons;	err = tdb_cons_finalize(cons);	if(err) {		REPORT_ERROR("Failed to finalize output DB. error=%i/n", err);	}close_cons:	tdb_cons_close(cons);free_ids:	free(field_ids);free_tdb:	tdb_close(db);	return err;}

/**   /details Initialize MAPI handles context   /param mem_ctx pointer to the memory context   /return Allocated MAPI handles context on success, otherwise NULL */_PUBLIC_ struct mapi_handles_context *mapi_handles_init(TALLOC_CTX *mem_ctx){	struct mapi_handles_context	*handles_ctx;	/* Step 1. Initialize the context */	handles_ctx = talloc_zero(mem_ctx, struct mapi_handles_context);	if (!handles_ctx) return NULL;	/* Step 2. Initialize the TDB context */	handles_ctx->tdb_ctx = tdb_open(NULL, 0, TDB_INTERNAL, O_RDWR|O_CREAT, 0600);	/* Step 3. Initialize the handles list */	handles_ctx->handles = NULL;	/* Step 4. Set last_handle to the first valid value */	handles_ctx->last_handle = 1;	return handles_ctx;}

int main(int argc, char *argv[]){	const int flags[] = { TDB_DEFAULT,			      TDB_NOMMAP,			      TDB_CONVERT,			      TDB_CONVERT | TDB_NOMMAP };	int i;	struct tdb_context *tdb;	TDB_DATA key, data;	plan_tests(20);	agent = prepare_external_agent();	if (!agent)		err(1, "preparing agent");	unlock_callback = after_unlock;	for (i = 0; i < sizeof(flags)/sizeof(flags[0]); i++) {		diag("Test with %s and %s/n",		     (flags[i] & TDB_CONVERT) ? "CONVERT" : "DEFAULT",		     (flags[i] & TDB_NOMMAP) ? "no mmap" : "mmap");		unlink(TEST_DBNAME);		tdb = tdb_open(TEST_DBNAME, flags[i],			       O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);		ok1(tdb);		opened = true;		ok1(tdb_transaction_start(tdb) == 0);		key.dsize = strlen("hi");		key.dptr = (void *)"hi";		data.dptr = (void *)"world";		data.dsize = strlen("world");		ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);		ok1(tdb_transaction_commit(tdb) == 0);		ok(!errors, "We had %u open errors", errors);		opened = false;		tdb_close(tdb);	}	return exit_status();}

static void move_rec(char *keyname, size_t keylen, char* tdbname){	TDB_DATA key, dbuf;	TDB_CONTEXT *dst_tdb;	if ((keyname == NULL) || (keylen == 0)) {		terror("need key");		return;	}	if ( !tdbname ) {		terror("need destination tdb name");		return;	}	key.dptr = (unsigned char *)keyname;	key.dsize = keylen;	dbuf = tdb_fetch(tdb, key);	if (!dbuf.dptr) {		terror("fetch failed");		return;	}	print_rec(tdb, key, dbuf, NULL);	dst_tdb = tdb_open(tdbname, 0, 0, O_RDWR, 0600);	if ( !dst_tdb ) {		terror("unable to open destination tdb");		return;	}	if (tdb_store( dst_tdb, key, dbuf, TDB_REPLACE ) != 0) {		terror("failed to move record");	}	else		printf("record moved/n");	tdb_close( dst_tdb );	return;}

int main(int argc, char *argv[]){	unsigned int i;	struct tdb_context *tdb;	int flags[] = { TDB_INTERNAL,			TDB_INTERNAL|TDB_CONVERT,			TDB_CONVERT,			TDB_INTERNAL|TDB_VERSION1,			TDB_VERSION1,			TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,			TDB_CONVERT|TDB_VERSION1 };	struct tdb_data key = tdb_mkdata("key", 3);	struct tdb_data data = tdb_mkdata("data", 4);	failtest_init(argc, argv);	failtest_hook = block_repeat_failures;	failtest_exit_check = exit_check_log;	failtest_suppress = true;	plan_tests(sizeof(flags) / sizeof(flags[0]) * 3 + 1);	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {		tdb = tdb_open("run-12-check.tdb", flags[i],			       O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);		ok1(tdb);		ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);		/* This is what we really want to test: tdb_check(). */		failtest_suppress = false;		if (!ok1(tdb_check(tdb, NULL, NULL) == 0))			goto fail;		failtest_suppress = true;		tdb_close(tdb);	}	ok1(tap_log_messages == 0);	failtest_exit(exit_status());fail:	failtest_suppress = true;	tdb_close(tdb);	failtest_exit(exit_status());}

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

int main(int argc, char *argv[]){	unsigned int i;	struct tdb_context *tdb;	int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,			TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,			TDB_NOMMAP|TDB_CONVERT };	plan_tests(sizeof(flags) / sizeof(flags[0]) * 2 + 1);	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {		tdb = tdb_open("run-14-exists.tdb", flags[i],			       O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);		if (ok1(tdb))			ok1(test_records(tdb));		tdb_close(tdb);	}	ok1(tap_log_messages == 0);	return exit_status();}

static void move_rec(char *keyname, size_t keylen, char* tdbname){	TDB_DATA key, dbuf;	struct tdb_context *dst_tdb;	enum TDB_ERROR ecode;	if ((keyname == NULL) || (keylen == 0)) {		terror(TDB_SUCCESS, "need key");		return;	}	if ( !tdbname ) {		terror(TDB_SUCCESS, "need destination tdb name");		return;	}	key.dptr = (unsigned char *)keyname;	key.dsize = keylen;	ecode = tdb_fetch(tdb, key, &dbuf);	if (ecode) {		terror(ecode, "fetch failed");		return;	}		print_rec(tdb, key, dbuf, NULL);		dst_tdb = tdb_open(tdbname, 0, O_RDWR, 0600, NULL);	if ( !dst_tdb ) {		terror(TDB_SUCCESS, "unable to open destination tdb");		return;	}		ecode = tdb_store( dst_tdb, key, dbuf, TDB_REPLACE);	if (ecode)		terror(ecode, "failed to move record");	else		printf("record moved/n");		tdb_close( dst_tdb );}

static void setup_tdb(e2fsck_t ctx, ext2_ino_t num_dirs){    struct dir_info_db	*db = ctx->dir_info;    unsigned int		threshold;    errcode_t		retval;    mode_t			save_umask;    char			*tdb_dir, uuid[40];    int			fd, enable;    profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0,                       &tdb_dir);    profile_get_uint(ctx->profile, "scratch_files",                     "numdirs_threshold", 0, 0, &threshold);    profile_get_boolean(ctx->profile, "scratch_files",                        "dirinfo", 0, 1, &enable);    if (!enable || !tdb_dir || access(tdb_dir, W_OK) ||            (threshold && num_dirs <= threshold))        return;    retval = ext2fs_get_mem(strlen(tdb_dir) + 64, &db->tdb_fn);    if (retval)        return;    uuid_unparse(ctx->fs->super->s_uuid, uuid);    sprintf(db->tdb_fn, "%s/%s-dirinfo-XXXXXX", tdb_dir, uuid);    save_umask = umask(077);    fd = mkstemp(db->tdb_fn);    umask(save_umask);    if (fd < 0) {        db->tdb = NULL;        return;    }    if (num_dirs < 99991)        num_dirs = 99991; /* largest 5 digit prime */    db->tdb = tdb_open(db->tdb_fn, num_dirs, TDB_NOLOCK | TDB_NOSYNC,                       O_RDWR | O_CREAT | O_TRUNC, 0600);    close(fd);}

/**************************************************************************** Initialise the locking functions.****************************************************************************/BOOL locking_init(int read_only){	brl_init(read_only);	if (tdb)		return True;	tdb = tdb_open(lock_path("locking.tdb"),		       0, TDB_CLEAR_IF_FIRST,		       read_only ? O_RDONLY : O_RDWR | O_CREAT, 0644);	if (!tdb)	{		DEBUG(0, ("ERROR: Failed to initialise share modes/n"));		return False;	}	if (!posix_locking_init(read_only))		return False;	return True;}

static int lock_db(const char *dbpath, const char *dbflags){	struct tdb_context *tdb;	int tdb_flags;	/* No error checking since CTDB always passes sane values */	tdb_flags = strtol(dbflags, NULL, 0);	tdb = tdb_open(dbpath, 0, tdb_flags, O_RDWR, 0600);	if (tdb == NULL) {		fprintf(stderr, "%s: Error opening database %s/n", progname, dbpath);		return 1;	}	if (tdb_lockall(tdb) < 0) {		fprintf(stderr, "%s: Error getting db lock (%s)/n",			progname, tdb_errorstr(tdb));		return 1;	}	return 0;}