int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb, *ntdb2; struct agent *agent; union ntdb_attribute cif; NTDB_DATA key = ntdb_mkdata(KEY_STR, strlen(KEY_STR)); int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; cif.openhook.base.attr = NTDB_ATTRIBUTE_OPENHOOK; cif.openhook.base.next = &tap_log_attr; cif.openhook.fn = clear_if_first; cif.openhook.data = clear_if_first; agent = prepare_external_agent(); plan_tests(sizeof(flags) / sizeof(flags[0]) * 16); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { /* Create it */ ntdb = ntdb_open("run-83-openhook.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, NULL); ok1(ntdb); ok1(ntdb_store(ntdb, key, key, NTDB_REPLACE) == 0); ntdb_close(ntdb); /* Now, open with CIF, should clear it. */ ntdb = ntdb_open("run-83-openhook.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR, 0, &cif); ok1(ntdb); ok1(!ntdb_exists(ntdb, key)); ok1(ntdb_store(ntdb, key, key, NTDB_REPLACE) == 0); /* Agent should not clear it, since it's still open. */ ok1(external_agent_operation(agent, OPEN_WITH_HOOK, "run-83-openhook.ntdb") == SUCCESS); ok1(external_agent_operation(agent, FETCH, KEY_STR "=" KEY_STR) == SUCCESS); ok1(external_agent_operation(agent, CLOSE, "") == SUCCESS); /* Still exists for us too. */ ok1(ntdb_exists(ntdb, key)); /* Nested open should not erase db. */ ntdb2 = ntdb_open("run-83-openhook.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR, 0, &cif); ok1(ntdb_exists(ntdb2, key)); ok1(ntdb_exists(ntdb, key)); ntdb_close(ntdb2); ok1(ntdb_exists(ntdb, key)); /* Close it, now agent should clear it. */ ntdb_close(ntdb); ok1(external_agent_operation(agent, OPEN_WITH_HOOK, "run-83-openhook.ntdb") == SUCCESS); ok1(external_agent_operation(agent, FETCH, KEY_STR "=" KEY_STR) == FAILED); ok1(external_agent_operation(agent, CLOSE, "") == SUCCESS); ok1(tap_log_messages == 0); } free_external_agent(agent); return exit_status(); }
int main(int argc, char *argv[]) { unsigned int i; struct ntdb_context *ntdb; NTDB_DATA key = ntdb_mkdata("key", 3); NTDB_DATA data = ntdb_mkdata("data", 4); int flags[] = { NTDB_DEFAULT, NTDB_NOMMAP, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; plan_tests(sizeof(flags) / sizeof(flags[0]) * 48); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { /* RW -> R0 */ ntdb = ntdb_open("run-92-get-set-readonly.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr); ok1(ntdb); ok1(!(ntdb_get_flags(ntdb) & NTDB_RDONLY)); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == NTDB_SUCCESS); ntdb_add_flag(ntdb, NTDB_RDONLY); ok1(ntdb_get_flags(ntdb) & NTDB_RDONLY); /* Can't store, append, delete. */ ok1(ntdb_store(ntdb, key, data, NTDB_MODIFY) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 1); ok1(ntdb_append(ntdb, key, data) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 2); ok1(ntdb_delete(ntdb, key) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 3); /* Can't start a transaction, or any write lock. */ ok1(ntdb_transaction_start(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 4); ok1(ntdb_chainlock(ntdb, key) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 5); ok1(ntdb_lockall(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 6); ok1(ntdb_wipe_all(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 7); /* Back to RW. */ ntdb_remove_flag(ntdb, NTDB_RDONLY); ok1(!(ntdb_get_flags(ntdb) & NTDB_RDONLY)); ok1(ntdb_store(ntdb, key, data, NTDB_MODIFY) == NTDB_SUCCESS); ok1(ntdb_append(ntdb, key, data) == NTDB_SUCCESS); ok1(ntdb_delete(ntdb, key) == NTDB_SUCCESS); ok1(ntdb_transaction_start(ntdb) == NTDB_SUCCESS); ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == NTDB_SUCCESS); ok1(ntdb_transaction_commit(ntdb) == NTDB_SUCCESS); ok1(ntdb_chainlock(ntdb, key) == NTDB_SUCCESS); ntdb_chainunlock(ntdb, key); ok1(ntdb_lockall(ntdb) == NTDB_SUCCESS); ntdb_unlockall(ntdb); ok1(ntdb_wipe_all(ntdb) == NTDB_SUCCESS); ok1(tap_log_messages == 7); ntdb_close(ntdb); /* R0 -> RW */ ntdb = ntdb_open("run-92-get-set-readonly.ntdb", flags[i]|MAYBE_NOSYNC, O_RDONLY, 0600, &tap_log_attr); ok1(ntdb); ok1(ntdb_get_flags(ntdb) & NTDB_RDONLY); /* Can't store, append, delete. */ ok1(ntdb_store(ntdb, key, data, NTDB_INSERT) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 8); ok1(ntdb_append(ntdb, key, data) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 9); ok1(ntdb_delete(ntdb, key) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 10); /* Can't start a transaction, or any write lock. */ ok1(ntdb_transaction_start(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 11); ok1(ntdb_chainlock(ntdb, key) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 12); ok1(ntdb_lockall(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 13); ok1(ntdb_wipe_all(ntdb) == NTDB_ERR_RDONLY); ok1(tap_log_messages == 14); /* Can't remove NTDB_RDONLY since we opened with O_RDONLY */ ntdb_remove_flag(ntdb, NTDB_RDONLY); ok1(tap_log_messages == 15); ok1(ntdb_get_flags(ntdb) & NTDB_RDONLY); ntdb_close(ntdb); ok1(tap_log_messages == 15); tap_log_messages = 0; } return exit_status(); }
static enum agent_return do_operation(enum operation op, const char *name) { NTDB_DATA k, d; enum agent_return ret; NTDB_DATA data; enum NTDB_ERROR ecode; union ntdb_attribute cif; const char *eq; if (op != OPEN && op != OPEN_WITH_HOOK && !ntdb) { diag("external: No ntdb open!"); return OTHER_FAILURE; } diag("external: %s", operation_name(op)); eq = strchr(name, '='); if (eq) { k = ntdb_mkdata(name, eq - name); d = ntdb_mkdata(eq + 1, strlen(eq+1)); } else { k = ntdb_mkdata(name, strlen(name)); d.dsize = 0; d.dptr = NULL; } locking_would_block = 0; switch (op) { case OPEN: if (ntdb) { diag("Already have ntdb %s open", ntdb_name(ntdb)); return OTHER_FAILURE; } ntdb = ntdb_open(name, MAYBE_NOSYNC, O_RDWR, 0, &tap_log_attr); if (!ntdb) { if (!locking_would_block) diag("Opening ntdb gave %s", strerror(errno)); forget_locking(); ret = OTHER_FAILURE; } else ret = SUCCESS; break; case OPEN_WITH_HOOK: if (ntdb) { diag("Already have ntdb %s open", ntdb_name(ntdb)); return OTHER_FAILURE; } cif.openhook.base.attr = NTDB_ATTRIBUTE_OPENHOOK; cif.openhook.base.next = &tap_log_attr; cif.openhook.fn = clear_if_first; ntdb = ntdb_open(name, MAYBE_NOSYNC, O_RDWR, 0, &cif); if (!ntdb) { if (!locking_would_block) diag("Opening ntdb gave %s", strerror(errno)); forget_locking(); ret = OTHER_FAILURE; } else ret = SUCCESS; break; case FETCH: ecode = ntdb_fetch(ntdb, k, &data); if (ecode == NTDB_ERR_NOEXIST) { ret = FAILED; } else if (ecode < 0) { ret = OTHER_FAILURE; } else if (!ntdb_deq(data, d)) { ret = OTHER_FAILURE; external_agent_free(data.dptr); } else { ret = SUCCESS; external_agent_free(data.dptr); } break; case STORE: ret = ntdb_store(ntdb, k, d, 0) == 0 ? SUCCESS : OTHER_FAILURE; break; case TRANSACTION_START: ret = ntdb_transaction_start(ntdb) == 0 ? SUCCESS : OTHER_FAILURE; break; case TRANSACTION_COMMIT: ret = ntdb_transaction_commit(ntdb)==0 ? SUCCESS : OTHER_FAILURE; break; case NEEDS_RECOVERY: ret = external_agent_needs_rec(ntdb); break; case CHECK: ret = ntdb_check(ntdb, NULL, NULL) == 0 ? SUCCESS : OTHER_FAILURE; break; case CLOSE: ret = ntdb_close(ntdb) == 0 ? SUCCESS : OTHER_FAILURE; ntdb = NULL; break; case SEND_SIGNAL: /* We do this async */ ret = SUCCESS; break; default: ret = OTHER_FAILURE; } if (locking_would_block) ret = WOULD_HAVE_BLOCKED; return ret; }
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(); }
int main(int argc, char *argv[]) { unsigned int i, j; int num; struct trav_data td; NTDB_DATA k; struct ntdb_context *ntdb; union ntdb_attribute seed_attr; enum NTDB_ERROR ecode; int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP, NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT, NTDB_NOMMAP|NTDB_CONVERT }; seed_attr.base.attr = NTDB_ATTRIBUTE_SEED; seed_attr.base.next = &tap_log_attr; seed_attr.seed.seed = 6334326220117065685ULL; plan_tests(sizeof(flags) / sizeof(flags[0]) * (NUM_RECORDS*6 + (NUM_RECORDS-1)*3 + 22) + 1); for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) { ntdb = ntdb_open("api-firstkey-nextkey.ntdb", flags[i]|MAYBE_NOSYNC, O_RDWR|O_CREAT|O_TRUNC, 0600, &seed_attr); ok1(ntdb); if (!ntdb) continue; ok1(ntdb_firstkey(ntdb, &k) == NTDB_ERR_NOEXIST); /* One entry... */ k.dptr = (unsigned char *)# k.dsize = sizeof(num); num = 0; ok1(ntdb_store(ntdb, k, k, NTDB_INSERT) == 0); ok1(ntdb_firstkey(ntdb, &k) == NTDB_SUCCESS); ok1(k.dsize == sizeof(num)); ok1(memcmp(k.dptr, &num, sizeof(num)) == 0); ok1(ntdb_nextkey(ntdb, &k) == NTDB_ERR_NOEXIST); /* Two entries. */ k.dptr = (unsigned char *)# k.dsize = sizeof(num); num = 1; ok1(ntdb_store(ntdb, k, k, NTDB_INSERT) == 0); ok1(ntdb_firstkey(ntdb, &k) == NTDB_SUCCESS); ok1(k.dsize == sizeof(num)); memcpy(&num, k.dptr, sizeof(num)); ok1(num == 0 || num == 1); ok1(ntdb_nextkey(ntdb, &k) == NTDB_SUCCESS); ok1(k.dsize == sizeof(j)); memcpy(&j, k.dptr, sizeof(j)); ok1(j == 0 || j == 1); ok1(j != num); ok1(ntdb_nextkey(ntdb, &k) == NTDB_ERR_NOEXIST); /* Clean up. */ k.dptr = (unsigned char *)# k.dsize = sizeof(num); num = 0; ok1(ntdb_delete(ntdb, k) == 0); num = 1; ok1(ntdb_delete(ntdb, k) == 0); /* Now lots of records. */ ok1(store_records(ntdb)); td.calls = 0; num = ntdb_traverse(ntdb, trav, &td); ok1(num == NUM_RECORDS); ok1(td.calls == NUM_RECORDS); /* Simple loop should match ntdb_traverse */ for (j = 0, ecode = ntdb_firstkey(ntdb, &k); j < td.calls; j++) { int val; ok1(ecode == NTDB_SUCCESS); ok1(k.dsize == sizeof(val)); memcpy(&val, k.dptr, k.dsize); ok1(td.records[j] == val); ecode = ntdb_nextkey(ntdb, &k); } /* But arbitrary orderings should work too. */ for (j = td.calls-1; j > 0; j--) { k.dptr = (unsigned char *)&td.records[j-1]; k.dsize = sizeof(td.records[j-1]); k = dup_key(k); ok1(ntdb_nextkey(ntdb, &k) == NTDB_SUCCESS); ok1(k.dsize == sizeof(td.records[j])); ok1(memcmp(k.dptr, &td.records[j], k.dsize) == 0); free(k.dptr); } /* Even delete should work. */ for (j = 0, ecode = ntdb_firstkey(ntdb, &k); ecode != NTDB_ERR_NOEXIST; j++) { ok1(ecode == NTDB_SUCCESS); ok1(k.dsize == 4); ok1(ntdb_delete(ntdb, k) == 0); ecode = ntdb_nextkey(ntdb, &k); } diag("delete using first/nextkey gave %u of %u records", j, NUM_RECORDS); ok1(j == NUM_RECORDS); ntdb_close(ntdb); } ok1(tap_log_messages == 0); return exit_status(); }