#include "tdb1_private.h"
-TDB1_DATA tdb1_null;
+TDB_DATA tdb1_null;
/*
non-blocking increment of the tdb sequence number if the tdb has been opened using
- the TDB1_SEQNUM flag
+ the TDB_SEQNUM flag
*/
void tdb1_increment_seqnum_nonblock(struct tdb1_context *tdb)
{
tdb1_off_t seqnum=0;
- if (!(tdb->flags & TDB1_SEQNUM)) {
+ if (!(tdb->flags & TDB_SEQNUM)) {
return;
}
/*
increment the tdb sequence number if the tdb has been opened using
- the TDB1_SEQNUM flag
+ the TDB_SEQNUM flag
*/
static void tdb1_increment_seqnum(struct tdb1_context *tdb)
{
- if (!(tdb->flags & TDB1_SEQNUM)) {
+ if (!(tdb->flags & TDB_SEQNUM)) {
return;
}
if (tdb1_nest_lock(tdb, TDB1_SEQNUM_OFS, F_WRLCK,
- TDB1_LOCK_WAIT|TDB1_LOCK_PROBE) != 0) {
+ TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
return;
}
tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK);
}
-static int tdb1_key_compare(TDB1_DATA key, TDB1_DATA data, void *private_data)
+static int tdb1_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
{
return memcmp(data.dptr, key.dptr, data.dsize);
}
/* Returns 0 on fail. On success, return offset of record, and fills
in rec */
-static tdb1_off_t tdb1_find(struct tdb1_context *tdb, TDB1_DATA key, uint32_t hash,
+static tdb1_off_t tdb1_find(struct tdb1_context *tdb, TDB_DATA key, uint32_t hash,
struct tdb1_record *r)
{
tdb1_off_t rec_ptr;
}
/* As tdb1_find, but if you succeed, keep the lock */
-tdb1_off_t tdb1_find_lock_hash(struct tdb1_context *tdb, TDB1_DATA key, uint32_t hash, int locktype,
+tdb1_off_t tdb1_find_lock_hash(struct tdb1_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
struct tdb1_record *rec)
{
uint32_t rec_ptr;
return rec_ptr;
}
-static TDB1_DATA _tdb1_fetch(struct tdb1_context *tdb, TDB1_DATA key);
+static TDB_DATA _tdb1_fetch(struct tdb1_context *tdb, TDB_DATA key);
/* update an entry in place - this only works if the new data size
is <= the old data size and the key exists.
on failure return -1.
*/
-static int tdb1_update_hash(struct tdb1_context *tdb, TDB1_DATA key, uint32_t hash, TDB1_DATA dbuf)
+static int tdb1_update_hash(struct tdb1_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
{
struct tdb1_record rec;
tdb1_off_t rec_ptr;
if (rec.key_len == key.dsize &&
rec.data_len == dbuf.dsize &&
rec.full_hash == hash) {
- TDB1_DATA data = _tdb1_fetch(tdb, key);
+ TDB_DATA data = _tdb1_fetch(tdb, key);
if (data.dsize == dbuf.dsize &&
memcmp(data.dptr, dbuf.dptr, data.dsize) == 0) {
if (data.dptr) {
/* find an entry in the database given a key */
/* If an entry doesn't exist tdb1_err will be set to
* TDB_ERR_NOEXIST. If a key has no data attached
- * then the TDB1_DATA will have zero length but
+ * then the TDB_DATA will have zero length but
* a non-zero pointer
*/
-static TDB1_DATA _tdb1_fetch(struct tdb1_context *tdb, TDB1_DATA key)
+static TDB_DATA _tdb1_fetch(struct tdb1_context *tdb, TDB_DATA key)
{
tdb1_off_t rec_ptr;
struct tdb1_record rec;
- TDB1_DATA ret;
+ TDB_DATA ret;
uint32_t hash;
/* find which hash bucket it is in */
return ret;
}
-TDB1_DATA tdb1_fetch(struct tdb1_context *tdb, TDB1_DATA key)
+TDB_DATA tdb1_fetch(struct tdb1_context *tdb, TDB_DATA key)
{
- TDB1_DATA ret = _tdb1_fetch(tdb, key);
+ TDB_DATA ret = _tdb1_fetch(tdb, key);
return ret;
}
* Return -1 if the record was not found.
*/
-int tdb1_parse_record(struct tdb1_context *tdb, TDB1_DATA key,
- int (*parser)(TDB1_DATA key, TDB1_DATA data,
+int tdb1_parse_record(struct tdb1_context *tdb, TDB_DATA key,
+ int (*parser)(TDB_DATA key, TDB_DATA data,
void *private_data),
void *private_data)
{
this doesn't match the conventions in the rest of this module, but is
compatible with gdbm
*/
-static int tdb1_exists_hash(struct tdb1_context *tdb, TDB1_DATA key, uint32_t hash)
+static int tdb1_exists_hash(struct tdb1_context *tdb, TDB_DATA key, uint32_t hash)
{
struct tdb1_record rec;
return 1;
}
-int tdb1_exists(struct tdb1_context *tdb, TDB1_DATA key)
+int tdb1_exists(struct tdb1_context *tdb, TDB_DATA key)
{
uint32_t hash = tdb->hash_fn(&key);
int ret;
}
/* delete an entry in the database given a key */
-static int tdb1_delete_hash(struct tdb1_context *tdb, TDB1_DATA key, uint32_t hash)
+static int tdb1_delete_hash(struct tdb1_context *tdb, TDB_DATA key, uint32_t hash)
{
tdb1_off_t rec_ptr;
struct tdb1_record rec;
return ret;
}
-int tdb1_delete(struct tdb1_context *tdb, TDB1_DATA key)
+int tdb1_delete(struct tdb1_context *tdb, TDB_DATA key)
{
uint32_t hash = tdb->hash_fn(&key);
int ret;
return 0;
}
-static int _tdb1_store(struct tdb1_context *tdb, TDB1_DATA key,
- TDB1_DATA dbuf, int flag, uint32_t hash)
+static int _tdb1_store(struct tdb1_context *tdb, TDB_DATA key,
+ TDB_DATA dbuf, int flag, uint32_t hash)
{
struct tdb1_record rec;
tdb1_off_t rec_ptr;
int ret = -1;
/* check for it existing, on insert. */
- if (flag == TDB1_INSERT) {
+ if (flag == TDB_INSERT) {
if (tdb1_exists_hash(tdb, key, hash)) {
tdb->last_error = TDB_ERR_EXISTS;
goto fail;
goto done;
}
if (tdb->last_error == TDB_ERR_NOEXIST &&
- flag == TDB1_MODIFY) {
+ flag == TDB_MODIFY) {
/* if the record doesn't exist and we are in TDB1_MODIFY mode then
we should fail the store */
goto fail;
/* delete any existing record - if it doesn't exist we don't
care. Doing this first reduces fragmentation, and avoids
coalescing with `allocated' block before it's updated. */
- if (flag != TDB1_INSERT)
+ if (flag != TDB_INSERT)
tdb1_delete_hash(tdb, key, hash);
/* Copy key+value *before* allocating free space in case malloc
return 0 on success, -1 on failure
*/
-int tdb1_store(struct tdb1_context *tdb, TDB1_DATA key, TDB1_DATA dbuf, int flag)
+int tdb1_store(struct tdb1_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
{
uint32_t hash;
int ret;
}
/* Append to an entry. Create if not exist. */
-int tdb1_append(struct tdb1_context *tdb, TDB1_DATA key, TDB1_DATA new_dbuf)
+int tdb1_append(struct tdb1_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
{
uint32_t hash;
- TDB1_DATA dbuf;
+ TDB_DATA dbuf;
int ret = -1;
/* find which hash bucket it is in */
/* the region is not worth adding */
return 0;
}
- if (length + offset > tdb->map_size) {
+ if (length + offset > tdb->file->map_size) {
tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
"tdb1_free_region: adding region beyond"
" end of file");
for the recovery area */
if (recovery_size == 0) {
/* the simple case - the whole file can be used as a freelist */
- data_len = (tdb->map_size - TDB1_DATA_START(tdb->header.hash_size));
+ data_len = (tdb->file->map_size - TDB1_DATA_START(tdb->header.hash_size));
if (tdb1_free_region(tdb, TDB1_DATA_START(tdb->header.hash_size), data_len) != 0) {
goto failed;
}
goto failed;
}
/* and the 2nd free list entry after the recovery area - if any */
- data_len = tdb->map_size - (recovery_head+recovery_size);
+ data_len = tdb->file->map_size - (recovery_head+recovery_size);
if (tdb1_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
goto failed;
}
/*
traverse function for repacking
*/
-static int repack_traverse(struct tdb1_context *tdb, TDB1_DATA key, TDB1_DATA data, void *private_data)
+static int repack_traverse(struct tdb1_context *tdb, TDB_DATA key, TDB_DATA data, void *private_data)
{
struct traverse_state *state = (struct traverse_state *)private_data;
- if (tdb1_store(state->dest_db, key, data, TDB1_INSERT) != 0) {
+ if (tdb1_store(state->dest_db, key, data, TDB_INSERT) != 0) {
state->error = state->dest_db->last_error;
return -1;
}
return -1;
}
- tmp_db = tdb1_open("tmpdb", tdb1_hash_size(tdb), TDB1_INTERNAL, O_RDWR|O_CREAT, 0);
+ tmp_db = tdb1_open("tmpdb", tdb1_hash_size(tdb), TDB_INTERNAL, O_RDWR|O_CREAT, 0);
if (tmp_db == NULL) {
tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
__location__ " Failed to create tmp_db");