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