git » nmdb » master » tree

[master] / nmdb / be-bdb.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
#if BE_ENABLE_BDB

#include <string.h>	/* memset() */
#include <stddef.h>	/* NULL */
#include <stdlib.h>	/* malloc() and friends */

/* typedefs to work around db.h include bug */
typedef unsigned int u_int;
typedef unsigned long u_long;
#include <db.h>

#include "be.h"


int bdb_set(struct db_conn *db, const unsigned char *key, size_t ksize,
		unsigned char *val, size_t vsize);
int bdb_get(struct db_conn *db, const unsigned char *key, size_t ksize,
		unsigned char *val, size_t *vsize);
int bdb_del(struct db_conn *db, const unsigned char *key, size_t ksize);
int bdb_close(struct db_conn *db);


struct db_conn *bdb_open(const char *name, int flags)
{
	int rv;
	struct db_conn *db;
	DB *bdb_db;

	rv = db_create(&bdb_db, NULL, 0);
	if (rv != 0)
		return NULL;

	rv = bdb_db->open(bdb_db, NULL, name, NULL, DB_HASH, DB_CREATE, 0);
	if (rv != 0) {
		bdb_db->close(bdb_db, 0);
		return NULL;
	}

	db = malloc(sizeof(struct db_conn));
	if (db == NULL) {
		bdb_db->close(bdb_db, 0);
		return NULL;
	}

	db->conn = bdb_db;
	db->set = bdb_set;
	db->get = bdb_get;
	db->del = bdb_del;
	db->firstkey = NULL;
	db->nextkey = NULL;
	db->close = bdb_close;

	return db;
}


int bdb_close(struct db_conn *db)
{
	int rv;
	DB *bdb_db = (DB *) db->conn;

	rv = bdb_db->close(bdb_db, 0);
	if (rv != 0)
		return 0;

	free(db);
	return 1;
}


int bdb_set(struct db_conn *db, const unsigned char *key, size_t ksize,
		unsigned char *val, size_t vsize)
{
	int rv;
	DBT k, v;
	DB *bdb_db = (DB *) db->conn;

	memset(&k, 0, sizeof(DBT));
	memset(&v, 0, sizeof(DBT));

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

	rv = bdb_db->put(bdb_db, NULL, &k, &v, 0);
	if (rv != 0)
		return 0;
	return 1;
}


int bdb_get(struct db_conn *db, const unsigned char *key, size_t ksize,
		unsigned char *val, size_t *vsize)
{
	int rv;
	DBT k, v;
	DB *bdb_db = (DB *) db->conn;

	memset(&k, 0, sizeof(DBT));
	memset(&v, 0, sizeof(DBT));

	k.data = (unsigned char *) key;
	k.size = ksize;
	v.data = val;
	v.ulen = *vsize;
	v.flags = DB_DBT_USERMEM;	/* we supplied the memory */

	rv = bdb_db->get(bdb_db, NULL, &k, &v, 0);
	if (rv != 0) {
		return 0;
	} else {
		*vsize = v.size;
		return 1;
	}
}

int bdb_del(struct db_conn *db, const unsigned char *key, size_t ksize)
{
	int rv;
	DBT k, v;
	DB *bdb_db = (DB *) db->conn;

	memset(&k, 0, sizeof(DBT));
	memset(&v, 0, sizeof(DBT));

	k.data = (unsigned char *) key;
	k.size = ksize;

	rv = bdb_db->del(bdb_db, NULL, &k, 0);
	if (rv != 0)
		return 0;
	return 1;
}

#else

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

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

#endif