static int db_ntdb_transaction_cancel(struct db_context *db)
{
struct db_ntdb_ctx *db_ctx =
talloc_get_type_abort(db->private_data, struct db_ntdb_ctx);
ntdb_transaction_cancel(db_ctx->ntdb);
return 0;
}
_PUBLIC_ enum NTDB_ERROR ntdb_repack(struct ntdb_context *ntdb)
{
struct ntdb_context *tmp_db;
struct traverse_state state;
state.error = ntdb_transaction_start(ntdb);
if (state.error != NTDB_SUCCESS) {
return state.error;
}
tmp_db = ntdb_open("tmpdb", NTDB_INTERNAL, O_RDWR|O_CREAT, 0, NULL);
if (tmp_db == NULL) {
state.error = ntdb_logerr(ntdb, NTDB_ERR_OOM, NTDB_LOG_ERROR,
__location__
" Failed to create tmp_db");
ntdb_transaction_cancel(ntdb);
return state.error;
}
state.dest_db = tmp_db;
if (ntdb_traverse(ntdb, repack_traverse, &state) < 0) {
goto fail;
}
state.error = ntdb_wipe_all(ntdb);
if (state.error != NTDB_SUCCESS) {
goto fail;
}
state.dest_db = ntdb;
if (ntdb_traverse(tmp_db, repack_traverse, &state) < 0) {
goto fail;
}
ntdb_close(tmp_db);
return ntdb_transaction_commit(ntdb);
fail:
ntdb_transaction_cancel(ntdb);
ntdb_close(tmp_db);
return state.error;
}
int main(int argc, char *argv[])
{
unsigned int i;
struct ntdb_context *ntdb;
int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP,
NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT };
NTDB_DATA key = ntdb_mkdata("key", 3);
NTDB_DATA data = ntdb_mkdata("data", 4);
plan_tests(sizeof(flags) / sizeof(flags[0]) * 14);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
int status;
tap_log_messages = 0;
ntdb = ntdb_open("run-fork-test.ntdb",
flags[i]|MAYBE_NOSYNC,
O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
if (!ok1(ntdb))
continue;
/* Put a record in here. */
ok1(ntdb_store(ntdb, key, data, NTDB_REPLACE) == NTDB_SUCCESS);
ok1(ntdb_chainlock(ntdb, key) == NTDB_SUCCESS);
if (fork() == 0) {
/* We expect this to fail. */
if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != NTDB_ERR_LOCK)
return 1;
if (ntdb_fetch(ntdb, key, &data) != NTDB_ERR_LOCK)
return 1;
if (tap_log_messages != 2)
return 2;
/* Child can do this without any complaints. */
ntdb_chainunlock(ntdb, key);
if (tap_log_messages != 2)
return 3;
ntdb_close(ntdb);
if (tap_log_messages != 2)
return 4;
return 0;
}
wait(&status);
ok1(WIFEXITED(status) && WEXITSTATUS(status) == 0);
ntdb_chainunlock(ntdb, key);
ok1(ntdb_lockall(ntdb) == NTDB_SUCCESS);
if (fork() == 0) {
/* We expect this to fail. */
if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != NTDB_ERR_LOCK)
return 1;
if (ntdb_fetch(ntdb, key, &data) != NTDB_ERR_LOCK)
return 1;
if (tap_log_messages != 2)
return 2;
/* Child can do this without any complaints. */
ntdb_unlockall(ntdb);
if (tap_log_messages != 2)
return 3;
ntdb_close(ntdb);
if (tap_log_messages != 2)
return 4;
return 0;
}
wait(&status);
ok1(WIFEXITED(status) && WEXITSTATUS(status) == 0);
ntdb_unlockall(ntdb);
ok1(ntdb_lockall_read(ntdb) == NTDB_SUCCESS);
if (fork() == 0) {
/* We expect this to fail. */
/* This would always fail anyway... */
if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != NTDB_ERR_LOCK)
return 1;
if (ntdb_fetch(ntdb, key, &data) != NTDB_ERR_LOCK)
return 1;
if (tap_log_messages != 2)
return 2;
/* Child can do this without any complaints. */
ntdb_unlockall_read(ntdb);
if (tap_log_messages != 2)
return 3;
ntdb_close(ntdb);
if (tap_log_messages != 2)
return 4;
return 0;
}
wait(&status);
ok1(WIFEXITED(status) && WEXITSTATUS(status) == 0);
ntdb_unlockall_read(ntdb);
ok1(ntdb_transaction_start(ntdb) == NTDB_SUCCESS);
/* If transactions is empty, noop "commit" succeeds. */
ok1(ntdb_delete(ntdb, key) == NTDB_SUCCESS);
if (fork() == 0) {
int last_log_messages;
/* We expect this to fail. */
if (ntdb_store(ntdb, key, data, NTDB_REPLACE) != NTDB_ERR_LOCK)
return 1;
if (ntdb_fetch(ntdb, key, &data) != NTDB_ERR_LOCK)
return 1;
if (tap_log_messages != 2)
return 2;
if (ntdb_transaction_prepare_commit(ntdb)
!= NTDB_ERR_LOCK)
return 3;
if (tap_log_messages == 2)
return 4;
last_log_messages = tap_log_messages;
/* Child can do this without any complaints. */
ntdb_transaction_cancel(ntdb);
if (tap_log_messages != last_log_messages)
return 4;
ntdb_close(ntdb);
if (tap_log_messages != last_log_messages)
return 4;
return 0;
}
wait(&status);
ok1(WIFEXITED(status) && WEXITSTATUS(status) == 0);
ntdb_transaction_cancel(ntdb);
ok1(ntdb_parse_record(ntdb, key, fork_in_parse, ntdb)
== NTDB_SUCCESS);
ntdb_close(ntdb);
if (am_child) {
/* Child can return from parse without complaints. */
if (tap_log_messages != 2)
exit(3);
exit(0);
}
ok1(tap_log_messages == 0);
}
return exit_status();
}
static int do_command(void)
{
COMMAND_TABLE *ctp = cmd_table;
enum commands mycmd = CMD_HELP;
int cmd_len;
if (cmdname && strlen(cmdname) == 0) {
mycmd = CMD_NEXT;
} else {
while (ctp->name) {
cmd_len = strlen(ctp->name);
if (strncmp(ctp->name,cmdname,cmd_len) == 0) {
mycmd = ctp->cmd;
break;
}
ctp++;
}
}
switch (mycmd) {
case CMD_CREATE_NTDB:
bIterate = 0;
create_ntdb(arg1);
return 0;
case CMD_OPEN_NTDB:
bIterate = 0;
open_ntdb(arg1);
return 0;
case CMD_SYSTEM:
/* Shell command */
if (system(arg1) == -1) {
terror(NTDB_SUCCESS, "system() call failed\n");
}
return 0;
case CMD_QUIT:
return 1;
default:
/* all the rest require a open database */
if (!ntdb) {
bIterate = 0;
terror(NTDB_SUCCESS, "database not open");
help();
return 0;
}
switch (mycmd) {
case CMD_TRANSACTION_START:
bIterate = 0;
ntdb_transaction_start(ntdb);
return 0;
case CMD_TRANSACTION_COMMIT:
bIterate = 0;
ntdb_transaction_commit(ntdb);
return 0;
case CMD_TRANSACTION_CANCEL:
bIterate = 0;
ntdb_transaction_cancel(ntdb);
return 0;
case CMD_ERASE:
bIterate = 0;
ntdb_traverse(ntdb, do_delete_fn, NULL);
return 0;
case CMD_DUMP:
bIterate = 0;
ntdb_traverse(ntdb, print_rec, NULL);
return 0;
case CMD_INSERT:
bIterate = 0;
insert_ntdb(arg1, arg1len,arg2,arg2len);
return 0;
case CMD_MOVE:
bIterate = 0;
move_rec(arg1,arg1len,arg2);
return 0;
case CMD_STORE:
bIterate = 0;
store_ntdb(arg1,arg1len,arg2,arg2len);
return 0;
case CMD_SHOW:
bIterate = 0;
show_ntdb(arg1, arg1len);
return 0;
case CMD_KEYS:
ntdb_traverse(ntdb, print_key, NULL);
return 0;
case CMD_HEXKEYS:
ntdb_traverse(ntdb, print_hexkey, NULL);
return 0;
case CMD_DELETE:
bIterate = 0;
delete_ntdb(arg1,arg1len);
return 0;
#if 0
case CMD_LIST_HASH_FREE:
ntdb_dump_all(ntdb);
return 0;
case CMD_LIST_FREE:
ntdb_printfreelist(ntdb);
return 0;
#endif
case CMD_INFO:
info_ntdb();
return 0;
case CMD_SPEED:
speed_ntdb(arg1);
return 0;
case CMD_MMAP:
toggle_mmap();
return 0;
case CMD_FIRST:
bIterate = 1;
first_record(ntdb, &iterate_kbuf);
return 0;
case CMD_NEXT:
if (bIterate)
next_record(ntdb, &iterate_kbuf);
return 0;
case CMD_CHECK:
check_db(ntdb);
return 0;
case CMD_HELP:
help();
return 0;
case CMD_CREATE_NTDB:
case CMD_OPEN_NTDB:
case CMD_SYSTEM:
case CMD_QUIT:
/*
* unhandled commands. cases included here to avoid compiler
* warnings.
*/
return 0;
}
}
return 0;
}
int main(int argc, char *argv[])
{
unsigned int i;
struct ntdb_context *ntdb;
unsigned char *buffer;
int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP,
NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT };
NTDB_DATA key = ntdb_mkdata("key", 3);
NTDB_DATA data;
buffer = malloc(1000);
for (i = 0; i < 1000; i++)
buffer[i] = i;
plan_tests(sizeof(flags) / sizeof(flags[0]) * 20 + 1);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
ntdb = ntdb_open("run-55-transaction.ntdb",
flags[i]|MAYBE_NOSYNC,
O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
ok1(ntdb);
if (!ntdb)
continue;
ok1(ntdb_transaction_start(ntdb) == 0);
data.dptr = buffer;
data.dsize = 1000;
ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0);
ok1(ntdb_fetch(ntdb, key, &data) == NTDB_SUCCESS);
ok1(data.dsize == 1000);
ok1(memcmp(data.dptr, buffer, data.dsize) == 0);
free(data.dptr);
/* Cancelling a transaction means no store */
ntdb_transaction_cancel(ntdb);
ok1(ntdb->file->allrecord_lock.count == 0
&& ntdb->file->num_lockrecs == 0);
ok1(ntdb_check(ntdb, NULL, NULL) == 0);
ok1(ntdb_fetch(ntdb, key, &data) == NTDB_ERR_NOEXIST);
/* Commit the transaction. */
ok1(ntdb_transaction_start(ntdb) == 0);
data.dptr = buffer;
data.dsize = 1000;
ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0);
ok1(ntdb_fetch(ntdb, key, &data) == NTDB_SUCCESS);
ok1(data.dsize == 1000);
ok1(memcmp(data.dptr, buffer, data.dsize) == 0);
free(data.dptr);
ok1(ntdb_transaction_commit(ntdb) == 0);
ok1(ntdb->file->allrecord_lock.count == 0
&& ntdb->file->num_lockrecs == 0);
ok1(ntdb_check(ntdb, NULL, NULL) == 0);
ok1(ntdb_fetch(ntdb, key, &data) == NTDB_SUCCESS);
ok1(data.dsize == 1000);
ok1(memcmp(data.dptr, buffer, data.dsize) == 0);
free(data.dptr);
ntdb_close(ntdb);
}
ok1(tap_log_messages == 0);
free(buffer);
return exit_status();
}
int main(int argc, char *argv[])
{
unsigned int i, seq;
struct ntdb_context *ntdb;
NTDB_DATA d = { NULL, 0 }; /* Bogus GCC warning */
NTDB_DATA key = ntdb_mkdata("key", 3);
NTDB_DATA data = ntdb_mkdata("data", 4);
int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP,
NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT,
NTDB_NOMMAP|NTDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 15 + 4 * 13);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
ntdb = ntdb_open("api-81-seqnum.ntdb",
flags[i]|NTDB_SEQNUM|MAYBE_NOSYNC,
O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
if (!ok1(ntdb))
continue;
seq = 0;
ok1(ntdb_get_seqnum(ntdb) == seq);
ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0);
ok1(ntdb_get_seqnum(ntdb) == ++seq);
/* Fetch doesn't change seqnum */
if (ok1(ntdb_fetch(ntdb, key, &d) == NTDB_SUCCESS))
free(d.dptr);
ok1(ntdb_get_seqnum(ntdb) == seq);
ok1(ntdb_append(ntdb, key, data) == NTDB_SUCCESS);
ok1(ntdb_get_seqnum(ntdb) == ++seq);
ok1(ntdb_delete(ntdb, key) == NTDB_SUCCESS);
ok1(ntdb_get_seqnum(ntdb) == ++seq);
/* Empty append works */
ok1(ntdb_append(ntdb, key, data) == NTDB_SUCCESS);
ok1(ntdb_get_seqnum(ntdb) == ++seq);
ok1(ntdb_wipe_all(ntdb) == NTDB_SUCCESS);
ok1(ntdb_get_seqnum(ntdb) == ++seq);
if (!(flags[i] & NTDB_INTERNAL)) {
ok1(ntdb_transaction_start(ntdb) == NTDB_SUCCESS);
ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0);
ok1(ntdb_get_seqnum(ntdb) == ++seq);
ok1(ntdb_append(ntdb, key, data) == NTDB_SUCCESS);
ok1(ntdb_get_seqnum(ntdb) == ++seq);
ok1(ntdb_delete(ntdb, key) == NTDB_SUCCESS);
ok1(ntdb_get_seqnum(ntdb) == ++seq);
ok1(ntdb_transaction_commit(ntdb) == NTDB_SUCCESS);
ok1(ntdb_get_seqnum(ntdb) == seq);
ok1(ntdb_transaction_start(ntdb) == NTDB_SUCCESS);
ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == 0);
ok1(ntdb_get_seqnum(ntdb) == seq + 1);
ntdb_transaction_cancel(ntdb);
ok1(ntdb_get_seqnum(ntdb) == seq);
}
ntdb_close(ntdb);
ok1(tap_log_messages == 0);
}
return exit_status();
}