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