git » nmdb » master » tree

[master] / nmdb / be-tdb.c 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#if BE_ENABLE_TDB

#include <string.h>	/* memcpy() */
#include <stdlib.h>	/* malloc() and friends */

/* tdb.h needs mode_t defined externally, and it is defined in one of these
(which are the ones required for open() */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <tdb.h>

#include "be.h"

/* Local operations names are prepended with an 'x' so they don't collide with
 * tdb real functions */

int xtdb_set(struct db_conn *db, const unsigned char *key, size_t ksize,
		unsigned char *val, size_t vsize);
int xtdb_get(struct db_conn *db, const unsigned char *key, size_t ksize,
		unsigned char *val, size_t *vsize);
int xtdb_del(struct db_conn *db, const unsigned char *key, size_t ksize);
int xtdb_firstkey(struct db_conn *db, unsigned char *key, size_t *ksize);
int xtdb_nextkey(struct db_conn *db,
		const unsigned char *key, size_t ksize,
		unsigned char *nextkey, size_t *nksize);
int xtdb_close(struct db_conn *db);


struct db_conn *xtdb_open(const char *name, int flags)
{
	struct db_conn *db;
	TDB_CONTEXT *tdb_db;

	tdb_db = tdb_open(name, 0, 0, O_CREAT | O_RDWR, 0640);
	if (tdb_db == NULL)
		return NULL;

	db = malloc(sizeof(struct db_conn));
	if (db == NULL) {
		tdb_close(tdb_db);
		return NULL;
	}

	db->conn = tdb_db;
	db->set = xtdb_set;
	db->get = xtdb_get;
	db->del = xtdb_del;
	db->firstkey = xtdb_firstkey;
	db->nextkey = xtdb_nextkey;
	db->close = xtdb_close;

	return db;
}

int xtdb_close(struct db_conn *db)
{
	int rv;

	rv = tdb_close(db->conn);
	free(db);
	return rv == 0;
}

int xtdb_set(struct db_conn *db, const unsigned char *key, size_t ksize,
		unsigned char *val, size_t vsize)
{
	TDB_DATA k, v;

	/* we can't maintain "const"ness here because tdb's prototypes; the
	 * same applies to get and del, so we just cast */
	k.dptr = (unsigned char *) key;
	k.dsize = ksize;
	v.dptr = (unsigned char *) val;
	v.dsize = vsize;

	return tdb_store(db->conn, k, v, TDB_REPLACE) == 0;
}

int xtdb_get(struct db_conn *db, const unsigned char *key, size_t ksize,
		unsigned char *val, size_t *vsize)
{
	TDB_DATA k, v;

	k.dptr = (unsigned char *) key;
	k.dsize = ksize;

	v = tdb_fetch(db->conn, k);
	if (v.dptr == NULL)
		return 0;

	if (v.dsize > *vsize)
		return 0;

	*vsize = v.dsize;
	memcpy(val, v.dptr, v.dsize);
	free(v.dptr);
	return 1;
}

int xtdb_del(struct db_conn *db, const unsigned char *key, size_t ksize)
{
	TDB_DATA k;

	k.dptr = (unsigned char *) key;
	k.dsize = ksize;

	return tdb_delete(db->conn, k) == 0;
}

int xtdb_firstkey(struct db_conn *db, unsigned char *key, size_t *ksize)
{
	TDB_DATA k;

	k = tdb_firstkey(db->conn);
	if (k.dptr == NULL)
		return 0;

	*ksize = k.dsize;
	memcpy(key, k.dptr, k.dsize);
	free(k.dptr);
	return 1;
}

int xtdb_nextkey(struct db_conn *db,
		const unsigned char *key, size_t ksize,
		unsigned char *nextkey, size_t *nksize)
{
	TDB_DATA pk, nk;

	pk.dptr = (unsigned char *) key;
	pk.dsize = ksize;

	nk = tdb_nextkey(db->conn, pk);
	if (nk.dptr == NULL)
		return 0;

	*nksize = nk.dsize;
	memcpy(nextkey, nk.dptr, nk.dsize);
	free(nk.dptr);
	return 1;
}

#else

#include <stddef.h>	/* NULL */

struct db_conn *xtdb_open(const char *name, int flags)
{
	return NULL;
}

#endif