static int storecontent (const char * username) {
datum d,k;
int res;
if ( pdb == NULL || concntr < 2 ) return 1;
DOUT2("store:\n%s\ncontent:\n%s",username,content);
d.dptr = content;
d.dsize = concntr + 1;
k.dptr = username;
k.dsize = strlen(username) + 1;
res = dbm_store(pdb, k, d, DBM_INSERT);
if ( res == 1 ) dbm_store(pdb, k, d, DBM_REPLACE);
if ( res < 0 ) {
perror("Couldn't insert record");
st_errors++;
st_skiped++;
} else st_loaded++;
concntr = 0;
*content = '\0';
return 0;
}
int
pw_dbm_update(const struct passwd *pw)
{
datum key;
datum content;
char data[BUFSIZ];
int len;
static int once;
if (! once) {
if (! pw_dbm)
setpwent ();
once++;
}
if (! pw_dbm)
return 0;
len = pw_pack (pw, data);
content.dsize = len;
content.dptr = data;
key.dsize = strlen (pw->pw_name);
key.dptr = pw->pw_name;
if (dbm_store(pw_dbm, key, content, DBM_REPLACE))
return 0;
/*
* XXX - on systems with 16-bit UIDs (such as Linux/x86)
* name "aa" and UID 24929 will give the same key. This
* happens only rarely, but code which only "works most
* of the time" is not good enough...
*
* This needs to be fixed in several places (pwdbm.c,
* grdbm.c, pwent.c, grent.c). Fixing it will cause
* incompatibility with existing dbm files.
*
* Summary: don't use this stuff for now. --marekm
*/
key.dsize = sizeof pw->pw_uid;
key.dptr = (char *) &pw->pw_uid;
if (dbm_store(pw_dbm, key, content, DBM_REPLACE))
return 0;
return 1;
}
void dbm_del_user(DBM *dbmgroup, char *group, char *user) {
datum key, resp;
char *userlist;
char *tmp;
key.dptr = group;
key.dsize = strlen(group);
resp = dbm_fetch(dbmgroup,key);
if (resp.dptr) {
if (resp.dptr[0] != '\0') {
if (!strcmp(resp.dptr,user)) {
resp.dptr[0] = '\0';
resp.dsize = 1;
dbm_store(dbmgroup,key,resp,DBM_REPLACE);
} else {
tmp = resp.dptr;
while ((tmp = strstr(tmp,user))) {
if ((tmp[strlen(user)] == '\0') || (tmp[strlen(user)] == ' ') ||
(tmp[strlen(user)] == ',')) {
break;
} else tmp++;
}
if (!tmp) {
fprintf(stderr,"The user %s is not in group %s.\n",user,group);
exit(1);
}
printf("Deleting user %s from group %s.\n",user,group);
userlist = (char *)malloc(strlen(resp.dptr) - strlen(user)+1);
if (tmp != resp.dptr) {
strncpy(userlist,resp.dptr,tmp-resp.dptr-1);
strcat(userlist,(tmp+strlen(user)));
} else {
strcpy(userlist,(tmp+strlen(user)));
}
resp.dptr = userlist;
resp.dsize = strlen(userlist);
dbm_store(dbmgroup,key,resp,DBM_REPLACE);
}
} else {
fprintf(stderr,"The group %s is emptry.\n",group);
exit(1);
}
} else {
fprintf(stderr,"There is no group %s.\n",group);
exit(1);
}
}
static krb5_error_code
NDBM__put(krb5_context context, HDB *db, int replace,
krb5_data key, krb5_data value)
{
#ifdef WRITE_SUPPORT
struct ndbm_db *d = (struct ndbm_db *)db->hdb_db;
datum k, v;
int code;
k.dptr = key.data;
k.dsize = key.length;
v.dptr = value.data;
v.dsize = value.length;
code = db->hdb_lock(context, db, HDB_WLOCK);
if(code)
return code;
code = dbm_store(d->db, k, v, replace ? DBM_REPLACE : DBM_INSERT);
db->hdb_unlock(context, db);
if(code == 1)
return HDB_ERR_EXISTS;
if (code < 0)
return code;
return 0;
#else
return HDB_ERR_NO_WRITE_SUPPORT;
#endif
}
static int
_ndbm_store (mu_dbm_file_t db,
struct mu_dbm_datum const *key,
struct mu_dbm_datum const *contents,
int replace)
{
DBM *dbm = db->db_descr;
datum keydat, condat;
keydat.dptr = key->mu_dptr;
keydat.dsize = key->mu_dsize;
condat.dptr = contents->mu_dptr;
condat.dsize = contents->mu_dsize;
errno = 0;
switch (dbm_store (dbm, keydat, condat,
replace ? DBM_REPLACE : DBM_INSERT))
{
case 0:
break;
case 1:
return MU_ERR_EXISTS;
case -1:
db->db_errno.n = errno;
return MU_ERR_FAILURE;
}
return 0;
}
static PyObject *
dbm_setdefault(register dbmobject *dp, PyObject *args)
{
datum key, val;
PyObject *defvalue = NULL;
int tmp_size;
if (!PyArg_ParseTuple(args, "s#|S:setdefault",
&key.dptr, &tmp_size, &defvalue))
return NULL;
key.dsize = tmp_size;
check_dbmobject_open(dp);
val = dbm_fetch(dp->di_dbm, key);
if (val.dptr != NULL)
return PyString_FromStringAndSize(val.dptr, val.dsize);
if (defvalue == NULL) {
defvalue = PyString_FromStringAndSize(NULL, 0);
if (defvalue == NULL)
return NULL;
}
else
Py_INCREF(defvalue);
val.dptr = PyString_AS_STRING(defvalue);
val.dsize = PyString_GET_SIZE(defvalue);
if (dbm_store(dp->di_dbm, key, val, DBM_INSERT) < 0) {
dbm_clearerr(dp->di_dbm);
PyErr_SetString(DbmError, "cannot add item to database");
return NULL;
}
return defvalue;
}
/* This function adds a new catalog entry. The access key is the
catalog string and track number acting as a composite key */
int add_cdt_entry(const cdt_entry entry_to_add)
{
char key_to_add[CAT_CAT_LEN + 10];
datum local_data_datum;
datum local_key_datum;
int result;
/* check database initialized and parameters valid */
if (!cdc_dbm_ptr || !cdt_dbm_ptr) return (0);
if (strlen(entry_to_add.catalog) >= CAT_CAT_LEN) return (0);
/* ensure the search key contains only the valid string and nulls */
memset(&key_to_add, '\0', sizeof(key_to_add));
sprintf(key_to_add, "%s %d", entry_to_add.catalog, entry_to_add.track_no);
local_key_datum.dptr = (void *) key_to_add;
local_key_datum.dsize = sizeof(key_to_add);
local_data_datum.dptr = (void *) &entry_to_add;
local_data_datum.dsize = sizeof(entry_to_add);
result = dbm_store(cdt_dbm_ptr, local_key_datum, local_data_datum, DBM_REPLACE);
/* dbm_store() uses 0 for success and -ve numbers for errors */
if (result == 0)
return (1);
return (0);
} /* add_cdt_entry */
int main()
{
const char *database_name = "/tmp/ndbm" ;
//create a dbm
DBM *dbmptr = 0 ;
TFUNVR(0, dbmptr, dbm_open(database_name, O_RDWR | O_CREAT, 0666))
//append some item to dbm from user
const int DATA_MAX_LEN = 101 ;
datum key_datum, data_datum ;
int key, result ;
char data[DATA_MAX_LEN] ;
printf("Enter a database item, form is 'key data', when key is -1 to end.\n") ;
scanf("%d", &key) ;
while(-1 != key) {
key_datum.dptr = (void *)&key ;
key_datum.dsize = sizeof(key) ;
fgets(data, DATA_MAX_LEN , stdin) ;
data_datum.dptr = data ;
data_datum.dsize = strlen(data) ;
do{
if(1 == (result = dbm_store(dbmptr, key_datum, data_datum, DBM_INSERT))) {
fprintf(stderr, "dbm_store has been a same key\n") ;
break ;
} else if(0 > result) {
fprintf(stderr, "dbm_store failed\n") ;
exit(1) ;
}
}while(0) ; //use for break can scanf
scanf("%d", &key) ;
}
//read data frm dbm
printf("Now you can search itme, enter a key, when key is -1 to end\n") ;
scanf("%d", &key) ;
while(-1 != key)
{
key_datum.dptr = (void *)&key ;
key_datum.dsize = sizeof(key) ;
data_datum = dbm_fetch(dbmptr, key_datum) ;
if(NULL == data_datum.dptr) {
printf("No has this key item, try again:") ;
} else {
printf("key:%-4d:%s\n", key, (char *)data_datum.dptr) ;
}
scanf("%d", &key) ;
}
//close dbm
dbm_close(dbmptr) ;
return 0 ;
}
int
otp_put (void *v, OtpContext *ctx)
{
DBM *dbm = (DBM *)v;
datum dat, key;
char buf[1024], *p;
time_t zero = 0;
size_t len, rem;
key.dsize = strlen(ctx->user);
key.dptr = ctx->user;
p = buf;
rem = sizeof(buf);
if (rem < sizeof(zero))
return -1;
memcpy (p, &zero, sizeof(zero));
p += sizeof(zero);
rem -= sizeof(zero);
len = strlen(ctx->alg->name) + 1;
if (rem < len)
return -1;
strlcpy (p, ctx->alg->name, rem);
p += len;
rem -= len;
if (rem < 4)
return -1;
{
unsigned char *up = (unsigned char *)p;
*up++ = (ctx->n >> 24) & 0xFF;
*up++ = (ctx->n >> 16) & 0xFF;
*up++ = (ctx->n >> 8) & 0xFF;
*up++ = (ctx->n >> 0) & 0xFF;
}
p += 4;
rem -= 4;
if (rem < OTPKEYSIZE)
return -1;
memcpy (p, ctx->key, OTPKEYSIZE);
p += OTPKEYSIZE;
rem -= OTPKEYSIZE;
len = strlen(ctx->seed) + 1;
if (rem < len)
return -1;
strlcpy (p, ctx->seed, rem);
p += len;
rem -= len;
dat.dptr = buf;
dat.dsize = p - buf;
return dbm_store (dbm, key, dat, DBM_REPLACE);
}
int
ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
{
int rc;
LDBM_WLOCK;
rc = dbm_store( ldbm, key, data, flags );
LDBM_WUNLOCK;
return rc;
}
static int
store_data(voidp db, char *k, char *v)
{
datum key, val;
key.dptr = k;
val.dptr = v;
key.dsize = strlen(k) + 1;
val.dsize = strlen(v) + 1;
return dbm_store((DBM *) db, key, val, DBM_INSERT);
}
void dbm_add_user(DBM *dbmgroup, char *group, char *user) {
datum key,resp;
char *newusers;
char *tmp;
key.dptr = group;
key.dsize = strlen(group);
resp = dbm_fetch(dbmgroup,key);
if (resp.dptr) {
printf("Adding %s to group %s.\n",user,group);
if (resp.dptr[0]) {
if (!(newusers = (char *)malloc(resp.dsize + strlen(user) + 2))) {
fprintf(stderr,"Not enough memory to complete operation.\n");
perror("malloc");
exit(1);
}
tmp = resp.dptr;
while ((tmp = strstr(tmp,user))) {
if ((tmp[strlen(user)] == '\0') || (tmp[strlen(user)] == ' ') ||
(tmp[strlen(user)] == ',')) {
printf("User %s is already in group %s.\n",user,group);
exit(0);
} else tmp++;
}
strcpy(newusers,resp.dptr);
sprintf(newusers,"%s %s",newusers,user);
resp.dptr = newusers;
resp.dsize = strlen(newusers);
dbm_store(dbmgroup,key,resp,DBM_REPLACE);
} else {
resp.dptr = user;
resp.dsize = strlen(user);
dbm_store(dbmgroup,key,resp,DBM_INSERT);
}
} else {
printf("Creating group %s and adding user %s.\n",group,user);
resp.dptr = user;
resp.dsize = strlen(user);
dbm_store(dbmgroup,key,resp,DBM_INSERT);
}
}
static int
otp_get_internal (void *v, OtpContext *ctx, int lockp)
{
DBM *dbm = (DBM *)v;
datum dat, key;
char *p;
time_t now, then;
key.dsize = strlen(ctx->user);
key.dptr = ctx->user;
dat = dbm_fetch (dbm, key);
if (dat.dptr == NULL) {
ctx->err = "Entry not found";
return -1;
}
p = dat.dptr;
memcpy (&then, p, sizeof(then));
ctx->lock_time = then;
if (lockp) {
time(&now);
if (then && now - then < OTP_USER_TIMEOUT) {
ctx->err = "Entry locked";
return -1;
}
memcpy (p, &now, sizeof(now));
}
p += sizeof(now);
ctx->alg = otp_find_alg (p);
if (ctx->alg == NULL) {
ctx->err = "Bad algorithm";
return -1;
}
p += strlen(p) + 1;
{
unsigned char *up = (unsigned char *)p;
ctx->n = (up[0] << 24) | (up[1] << 16) | (up[2] << 8) | up[3];
}
p += 4;
memcpy (ctx->key, p, OTPKEYSIZE);
p += OTPKEYSIZE;
strlcpy (ctx->seed, p, sizeof(ctx->seed));
if (lockp)
return dbm_store (dbm, key, dat, DBM_REPLACE);
else
return 0;
}
value caml_dbm_replace(value vdb, value vkey, value vcontent) /* ML */
{
datum key, content;
key.dptr = String_val(vkey);
key.dsize = string_length(vkey);
content.dptr = String_val(vcontent);
content.dsize = string_length(vcontent);
switch(dbm_store(extract_dbm(vdb), key, content, DBM_REPLACE)) {
case 0:
return Val_unit;
default:
raise_dbm("dbm_store failed");
}
}
/*
* save the user status in *accessdb
*
* return 0 -> ok
* -1 -> failed to update accessdb
*/
int save_access_status (char *accessdb, char *loginname, int status, int delay,char *cookie) {
char txt_nul[]="0";
DBM *db;
datum key;
datum data;
time_t t;
struct access_data access;
if (cookie==NULL) {
cookie=txt_nul;
}
db=dbm_open(accessdb, O_RDWR | O_CREAT, 0600);
if (!db) return(-1); /* failed to create db */
key.dptr=(void *)loginname;
key.dsize=strlen(loginname);
time(&t);
access.status=1;
if (status)
{
data=dbm_fetch(db,key);
if (data.dptr)
{
if(sizeof(access)!=data.dsize) { dbm_close(db); return(-1); }
memcpy(&access,data.dptr,data.dsize);
if (access.status && (t-access.ti>delay))
{
access.status=0;
}
++access.status;
}
}
else access.status=0;
access.ti=t;
memset(access.cookie,'\0',sizeof(access.cookie));
strncpy(access.cookie,cookie,59);
data.dptr=(void *)&access;
data.dsize=sizeof(access);
if (dbm_store(db,key,data,DBM_REPLACE)!=0)
{
dbm_close(db);
return(-1); /* failed to store user data */
}
dbm_close(db);
return(0);
}
static apr_status_t vt_ndbm_store(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t value)
{
int rc;
datum kd, vd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
vd.dptr = value.dptr;
vd.dsize = value.dsize;
rc = dbm_store(dbm->file, kd, vd, DBM_REPLACE);
/* store any error info into DBM, and return a status code. */
return set_error(dbm, ndbm2s(rc));
}
static int
dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
{
datum krec, drec;
int tmp_size;
if ( !PyArg_Parse(v, "s#", &krec.dptr, &tmp_size) ) {
PyErr_SetString(PyExc_TypeError,
"dbm mappings have string indices only");
return -1;
}
krec.dsize = tmp_size;
if (dp->di_dbm == NULL) {
PyErr_SetString(DbmError, "DBM object has already been closed");
return -1;
}
dp->di_size = -1;
if (w == NULL) {
if ( dbm_delete(dp->di_dbm, krec) < 0 ) {
dbm_clearerr(dp->di_dbm);
PyErr_SetString(PyExc_KeyError,
PyString_AS_STRING((PyStringObject *)v));
return -1;
}
} else {
if ( !PyArg_Parse(w, "s#", &drec.dptr, &tmp_size) ) {
PyErr_SetString(PyExc_TypeError,
"dbm mappings have string elements only");
return -1;
}
drec.dsize = tmp_size;
if ( dbm_store(dp->di_dbm, krec, drec, DBM_REPLACE) < 0 ) {
dbm_clearerr(dp->di_dbm);
PyErr_SetString(DbmError,
"cannot add item to database");
return -1;
}
}
if ( dbm_error(dp->di_dbm) ) {
dbm_clearerr(dp->di_dbm);
PyErr_SetString(DbmError, "");
return -1;
}
return 0;
}
/*
* This stores the passed text in the database with the key `key'.
* Returns 0 on success and -1 on failure.
*/
int
cache_store(char *key, const char *text)
{
#ifndef NOCACHE
datum dbkey;
datum dbstore;
int ret;
#ifdef HAVE_GDBM_OPEN
GDBM_FILE dbf;
#else
DBM *dbf;
#endif
time_t *timeptr;
char *ptr;
if (cache)
{
dbkey.dptr = key;
dbkey.dsize = strlen(key);
ptr = malloc(strlen(text)+sizeof(time_t)+1);
if (!ptr)
return -1;
memcpy(ptr+sizeof(time_t), text, strlen(text)+1);
timeptr = (time_t *)ptr;
*timeptr = time(NULL);
dbstore.dptr = ptr;
dbstore.dsize = strlen(text)+sizeof(time_t)+1;
dbf = dbm_open(cfname, DBM_WOPTIONS, DBM_MODE);
if (!dbf)
return -1;
else
{
ret = dbm_store(dbf, dbkey, dbstore, DBM_IOPTIONS);
if (ret < 0)
return -1;
dbm_close(dbf);
}
}
#endif
return 0;
}
void dbm_add_group(DBM *dbmgroup, char *group) {
datum key,resp;
char tmp[5];
key.dptr = group;
key.dsize = strlen(group);
resp = dbm_fetch(dbmgroup,key);
if (resp.dptr) {
fprintf(stderr,"Group %s already exists.\n",group);
exit(1);
} else {
printf("Adding group %s.\n",group);
resp.dptr = tmp;
tmp[0] = '\0';
resp.dsize = 1;
dbm_store(dbmgroup,key,resp,DBM_INSERT);
}
}
value caml_dbm_insert(value vdb, value vkey, value vcontent) /* ML */
{
datum key, content;
key.dptr = String_val(vkey);
key.dsize = string_length(vkey);
content.dptr = String_val(vcontent);
content.dsize = string_length(vcontent);
switch(dbm_store(extract_dbm(vdb), key, content, DBM_INSERT)) {
case 0:
return Val_unit;
case 1: /* DBM_INSERT and already existing */
raise_dbm("Entry already exists");
default:
raise_dbm("dbm_store failed");
}
}
static PyObject *
dbm_setdefault(dbmobject *dp, PyObject *args)
{
datum key, val;
PyObject *defvalue = NULL;
char *tmp_ptr;
Py_ssize_t tmp_size;
if (!PyArg_ParseTuple(args, "s#|O:setdefault",
&tmp_ptr, &tmp_size, &defvalue))
return NULL;
key.dptr = tmp_ptr;
key.dsize = tmp_size;
check_dbmobject_open(dp);
val = dbm_fetch(dp->di_dbm, key);
if (val.dptr != NULL)
return PyBytes_FromStringAndSize(val.dptr, val.dsize);
if (defvalue == NULL) {
defvalue = PyBytes_FromStringAndSize(NULL, 0);
if (defvalue == NULL)
return NULL;
val.dptr = NULL;
val.dsize = 0;
}
else {
if ( !PyArg_Parse(defvalue, "s#", &val.dptr, &tmp_size) ) {
PyErr_SetString(PyExc_TypeError,
"dbm mappings have byte string elements only");
return NULL;
}
val.dsize = tmp_size;
Py_INCREF(defvalue);
}
if (dbm_store(dp->di_dbm, key, val, DBM_INSERT) < 0) {
dbm_clearerr(dp->di_dbm);
PyErr_SetString(DbmError, "cannot add item to database");
Py_DECREF(defvalue);
return NULL;
}
return defvalue;
}
static PyObject *
_dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
Py_ssize_clean_t key_length,
PyObject *default_value)
/*[clinic end generated code: output=52545886cf272161 input=6a3b99ae91f20203]*/
{
datum dbm_key, val;
Py_ssize_t tmp_size;
dbm_key.dptr = (char *)key;
dbm_key.dsize = key_length;
check_dbmobject_open(self);
val = dbm_fetch(self->di_dbm, dbm_key);
if (val.dptr != NULL)
return PyBytes_FromStringAndSize(val.dptr, val.dsize);
if (default_value == NULL) {
default_value = PyBytes_FromStringAndSize(NULL, 0);
if (default_value == NULL)
return NULL;
val.dptr = NULL;
val.dsize = 0;
}
else {
if ( !PyArg_Parse(default_value, "s#", &val.dptr, &tmp_size) ) {
PyErr_SetString(PyExc_TypeError,
"dbm mappings have byte string elements only");
return NULL;
}
val.dsize = tmp_size;
Py_INCREF(default_value);
}
if (dbm_store(self->di_dbm, dbm_key, val, DBM_INSERT) < 0) {
dbm_clearerr(self->di_dbm);
PyErr_SetString(DbmError, "cannot add item to database");
Py_DECREF(default_value);
return NULL;
}
return default_value;
}
void store(char *what, int value)
{
datum name, val;
char blah[15];
int old;
name.dptr=what;
name.dsize=strlen(what);
val=dbm_fetch(db, name);
if(val.dptr == NULL)
old=0;
else
old=atoi(val.dptr);
sprintf(blah, "%d", value+old);
val.dptr=blah;
val.dsize=strlen(blah);
dbm_store(db, name, val, DBM_REPLACE);
}
int main(int argc, char *argv[])
{
#ifdef FBSD_DATABASE
DBT inKey, inVal;
DB * db;
#else
DBM * db;
datum Key;
datum Val;
#endif
FILE *ifd;
char line[256];
char *iptr;
char *optr;
extern char *optarg;
extern int optind;
char c;
int i;
/* read in file name */
if(argc==1) {
(void)fprintf(stderr, "Usage: %s",argv[0]);
(void)fprintf(stderr,"\t-o output_file_without_extention -i input_file\n");
exit(2);
}
while((c = getopt(argc,argv,"i:o:")) != -1) {
switch(c) {
case 'i':
iptr = optarg;
break;
case 'o':
optr = optarg;
break;
default:
(void)fprintf(stderr, "Usage: %s",argv[0]);
(void)fprintf(stderr,"\t-o output_file_without_extention -i input_file\n");
exit(2);
}
}
if(!strcmp(iptr,"-")) {
ifd = stdin;
} else if ((ifd=fopen(iptr,"r")) == NULL) {
(void)fprintf(stderr,"Can't open file %s\n",iptr);
exit(1);
}
#ifdef FBSD_DATABASE
db = dbopen(optr,O_RDWR|O_CREAT, 0000644, DB_HASH, &openinfo);
while(fgets(line,256,ifd)) {
inKey.data = strtok(line," ");
inKey.size = strlen(inKey.data)+1;
inVal.data = strtok(NULL,"\n");
inVal.size = strlen(inVal.data)+1;
(db->put)(db,&inKey,&inVal,R_NOOVERWRITE);
i++;
fprintf(stderr,"%d\r",i);
}
(void)(db->close)(db);
#else
db = dbm_open(optr,O_RDWR|O_CREAT, 0000644);
while(fgets(line,256,ifd)) {
Key.dptr = strtok(line," ");
Key.dsize = strlen(Key.dptr)+1;
Val.dptr = strtok(NULL,"\n");
Val.dsize = strlen(Val.dptr)+1;
dbm_store(db,Key,Val,DBM_INSERT);
i++;
fprintf(stderr,"%d\r",i);
}
dbm_close(db);
#endif
return(0);
}
int main() {
struct test_data items_to_store[ITEMS_USED];
struct test_data item_retrieved;
char key_to_use[20];
int i, result;
// a datum is dbm's wrapper around binary data. It consists of a void*
// to our data and a size_t giving the data size
datum key_datum;
datum data_datum;
// a DBM struct is a wrapper around two files, one used to track indices
// and another used to store the binary data.
DBM *dbm_p;
dbm_p = dbm_open(TEST_DB_FILE, O_RDWR | O_CREAT, 0666);
if (!dbm_p) {
fprintf(stderr, "Failed to open database\n");
exit(EXIT_FAILURE);
}
// set all data to zero first, then set some data
// note that we *need* all zeros in some cases, e.g. if we use
// char arrays as keys. If they are only used for values it's less
// important.
memset(items_to_store, '\0', sizeof(items_to_store));
// Ff47
strcpy(items_to_store[0].misc_chars, "First!");
items_to_store[0].any_integer = 47;
strcpy(items_to_store[0].more_chars, "foo");
// bu13
strcpy(items_to_store[1].misc_chars, "bar");
items_to_store[1].any_integer = 13;
strcpy(items_to_store[1].more_chars, "unlucky?");
// Tb3
strcpy(items_to_store[2].misc_chars, "Third");
items_to_store[2].any_integer = 3;
strcpy(items_to_store[2].more_chars, "baz");
for (i = 0; i < ITEMS_USED; i++) {
// make the key string
sprintf(key_to_use, "%c%c%d",
items_to_store[i].misc_chars[0],
items_to_store[i].more_chars[0],
items_to_store[i].any_integer);
// make the key. Check that you understand why we *must* use
// strlen() here and not sizeof()
key_datum.dptr = (void *) key_to_use;
key_datum.dsize = strlen(key_to_use);
// make the data
data_datum.dptr = (void *) &items_to_store[i];
data_datum.dsize = sizeof(struct test_data);
// write the data. Note that we have a choice of what to do
// if we see a known key; here it doesn't matter.
result = dbm_store(dbm_p, key_datum, data_datum, DBM_REPLACE);
if (result != 0) {
fprintf(stderr, "Failed to write to database\n");
exit(2);
}
}
// now try retrieving the second entry
sprintf(key_to_use, "bu%d", 13);
key_datum.dptr = (void *) key_to_use;
key_datum.dsize = strlen(key_to_use);
data_datum = dbm_fetch(dbm_p, key_datum);
// if we don't find a key, we get a datum with NULL dptr
if (data_datum.dptr) {
printf("Data retrieved\n");
memcpy(&item_retrieved, data_datum.dptr, data_datum.dsize);
printf("Retrieved item - %s %d %s\n",
item_retrieved.misc_chars,
item_retrieved.any_integer,
item_retrieved.more_chars);
} else {
printf("No data found for key %s\n", key_to_use);
}
printf("\n\nNow we'll try deleting and then cycling\n\n");
// delete the entry we just looked at
if (dbm_delete(dbm_p, key_datum) == 0) {
printf("Data with key %s deleted\n", key_to_use);
} else {
printf("Nothing deleted for key %s\n", key_to_use);
}
// now use dbm_firstkey and dbm_nextkey to iterate over keys.
// ... the order in which they appear is not defined
for (key_datum = dbm_firstkey(dbm_p);
key_datum.dptr; // the end condition is a NULL dptr
key_datum = dbm_nextkey(dbm_p)) {
// get the data. The data_datum shouldn't be null in this situation,
// but it could happen due to race conditions and such, so we should
// still guard against it.
data_datum = dbm_fetch(dbm_p, key_datum);
if (data_datum.dptr) {
printf("Data retrieved for key %s\n", (char *)key_datum.dptr);
memcpy(&item_retrieved, data_datum.dptr, data_datum.dsize);
printf("Retrieved item - %s %d %s\n",
item_retrieved.misc_chars,
item_retrieved.any_integer,
item_retrieved.more_chars);
} else {
// the authors oopsed here, don't use `key_to_use`
printf("No data found for key %s\n", (char *) key_datum.dptr);
}
}
// don't forget to close the database!
dbm_close(dbm_p);
exit(EXIT_SUCCESS);
}
int main(void)
{
struct test_data items_to_store[ITEMS_USED];
struct test_data items_retrieved;
char key_to_use[20];
int i, result;
datum key_datum;
datum data_datum;
DBM *dbm_ptr;
dbm_ptr = dbm_open(TEST_DB_FILE, O_RDWR | O_CREAT, 0666);
if(!dbm_ptr) {
fprintf(stderr, "Failed to open database\n");
exit(EXIT_FAILURE);
}
memset(items_to_store, '\0', sizeof(items_to_store));
strcpy(items_to_store[0].misc_chars, "First!");
items_to_store[0].any_integer = 47;
strcpy(items_to_store[0].more_chars, "foo");
strcpy(items_to_store[1].misc_chars, "bar");
items_to_store[1].any_integer = 13;
strcpy(items_to_store[1].more_chars, "unlucky?");
strcpy(items_to_store[2].misc_chars, "Third");
items_to_store[2].any_integer = 3;
strcpy(items_to_store[2].more_chars, "baz");
for(i = 0; i < ITEMS_USED; i++) {
sprintf(key_to_use, "%c%c%d", items_to_store[i].misc_chars[0],
items_to_store[i].more_chars[0], items_to_store[i].any_integer);
key_datum.dptr = (void *)key_to_use;
key_datum.dsize = strlen(key_to_use);
data_datum.dptr = (void *)&items_to_store[i];
data_datum.dsize = sizeof(struct test_data);
result = dbm_store(dbm_ptr, key_datum, data_datum, DBM_REPLACE);
if(result != 0) {
fprintf(stderr, "dbm_store failed on key %s\n", key_to_use);
exit(2);
}
}
/* let's delete some data */
sprintf(key_to_use, "bu%d", 13);
key_datum.dptr = key_to_use;
key_datum.dsize = strlen(key_to_use);
if(dbm_delete(dbm_ptr, key_datum) == 0)
printf("Data with key %s deleted\n", key_to_use);
else
printf("nothing deleted for key %s", key_to_use);
for(key_datum =dbm_firstkey(dbm_ptr); key_datum.dptr;
key_datum = dbm_nextkey(dbm_ptr)) {
data_datum = dbm_fetch(dbm_ptr, key_datum);
if(data_datum.dptr) {
printf("Data retrieved\n");
memcpy(&items_retrieved, data_datum.dptr, data_datum.dsize);
printf("Retrieved items - %s %d %s\n", items_retrieved.misc_chars,
items_retrieved.any_integer, items_retrieved.more_chars);
}
else
printf("No data found for key %s\n", key_to_use);
}
dbm_close(dbm_ptr);
exit(EXIT_SUCCESS);
}
int main() {
struct test_data items_to_store[ITEMS_USED];
struct test_data item_retrieved;
char key_to_use[20];
int i, result;
datum key_datum;
datum data_datum;
DBM *dbm_ptr;
dbm_ptr = dbm_open(TEST_DB_FILE, O_RDWR | O_CREAT, 0666);
if (!dbm_ptr) {
fprintf(stderr, "Failed to open database\n");
exit(EXIT_FAILURE);
}
/* put some data in the structures */
memset(items_to_store, '\0', sizeof(items_to_store));
strcpy(items_to_store[0].misc_chars, "First!");
items_to_store[0].any_integer = 47;
strcpy(items_to_store[0].more_chars, "foo");
strcpy(items_to_store[1].misc_chars, "bar");
items_to_store[1].any_integer = 13;
strcpy(items_to_store[1].more_chars, "unlucky?");
strcpy(items_to_store[2].misc_chars, "Third");
items_to_store[2].any_integer = 3;
strcpy(items_to_store[2].more_chars, "baz");
for (i = 0; i < ITEMS_USED; i++) {
/* build a key to use */
sprintf(key_to_use, "%c%c%d",
items_to_store[i].misc_chars[0],
items_to_store[i].more_chars[0],
items_to_store[i].any_integer);
/* build the key datum strcture */
key_datum.dptr = (void *)key_to_use;
key_datum.dsize = strlen(key_to_use);
data_datum.dptr = (void *)&items_to_store[i];
data_datum.dsize = sizeof(struct test_data);
result = dbm_store(dbm_ptr, key_datum, data_datum, DBM_REPLACE);
if (result != 0) {
fprintf(stderr, "dbm_store failed on key %s\n", key_to_use);
exit(2);
}
} /* for */
/* now try and retrieve some data */
sprintf(key_to_use, "bu%d", 13); /* this is the key for the second item */
key_datum.dptr = key_to_use;
key_datum.dsize = strlen(key_to_use);
data_datum = dbm_fetch(dbm_ptr, key_datum);
if (data_datum.dptr) {
printf("Data retrieved\n");
memcpy(&item_retrieved, data_datum.dptr, data_datum.dsize);
printf("Retrieved item - %s %d %s\n",
item_retrieved.misc_chars,
item_retrieved.any_integer,
item_retrieved.more_chars);
}
else {
printf("No data found for key %s\n", key_to_use);
}
dbm_close(dbm_ptr);
exit(EXIT_SUCCESS);
}
int
main(int argc, char **argv)
{
typedef enum {
YOW, FETCH, STORE, DELETE, SCAN, REGEXP
} commands;
char opt;
int flags;
int giveusage = 0;
int verbose = 0;
commands what = YOW;
char *comarg[3];
int st_flag = DBM_INSERT;
int argn;
DBM *db;
datum key;
datum content;
flags = O_RDWR;
argn = 0;
while ((opt = getopt(argc, argv, "acdfFm:rstvx")) != ':') {
switch (opt) {
case 'a':
what = SCAN;
break;
case 'c':
flags |= O_CREAT;
break;
case 'd':
what = DELETE;
break;
case 'f':
what = FETCH;
break;
case 'F':
what = REGEXP;
break;
case 'm':
flags &= ~(000007);
if (strcmp(optarg, "r") == 0)
flags |= O_RDONLY;
else if (strcmp(optarg, "w") == 0)
flags |= O_WRONLY;
else if (strcmp(optarg, "rw") == 0)
flags |= O_RDWR;
else {
fprintf(stderr, "Invalid mode: \"%s\"\n", optarg);
giveusage = 1;
}
break;
case 'r':
st_flag = DBM_REPLACE;
break;
case 's':
what = STORE;
break;
case 't':
flags |= O_TRUNC;
break;
case 'v':
verbose = 1;
break;
case 'x':
flags |= O_EXCL;
break;
case '!':
giveusage = 1;
break;
case '?':
if (argn < 3)
comarg[argn++] = optarg;
else {
fprintf(stderr, "Too many arguments.\n");
giveusage = 1;
}
break;
}
}
if (giveusage || what == YOW || argn < 1) {
fprintf(stderr, "Usage: %s database [-m r|w|rw] [-crtx] -a|-d|-f|-F|-s [key [content]]\n", argv[0]);
exit(-1);
}
if ((db = dbm_open(comarg[0], flags, 0777)) == NULL) {
fprintf(stderr, "Error opening database \"%s\"\n", comarg[0]);
exit(-1);
}
if (argn > 1)
key = read_datum(comarg[1]);
if (argn > 2)
content = read_datum(comarg[2]);
switch (what) {
case SCAN:
key = dbm_firstkey(db);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching first key\n");
goto db_exit;
}
while (key.dptr != NULL) {
content = dbm_fetch(db, key);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching ");
print_datum(key);
printf("\n");
goto db_exit;
}
print_datum(key);
printf(": ");
print_datum(content);
printf("\n");
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching next key\n");
goto db_exit;
}
key = dbm_nextkey(db);
}
break;
case REGEXP:
if (argn < 2) {
fprintf(stderr, "Missing regular expression.\n");
goto db_exit;
}
if (re_comp(comarg[1])) {
fprintf(stderr, "Invalid regular expression\n");
goto db_exit;
}
key = dbm_firstkey(db);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching first key\n");
goto db_exit;
}
while (key.dptr != NULL) {
if (re_exec(key2s(key))) {
content = dbm_fetch(db, key);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching ");
print_datum(key);
printf("\n");
goto db_exit;
}
print_datum(key);
printf(": ");
print_datum(content);
printf("\n");
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching next key\n");
goto db_exit;
}
}
key = dbm_nextkey(db);
}
break;
case FETCH:
if (argn < 2) {
fprintf(stderr, "Missing fetch key.\n");
goto db_exit;
}
content = dbm_fetch(db, key);
if (dbm_error(db)) {
fprintf(stderr, "Error when fetching ");
print_datum(key);
printf("\n");
goto db_exit;
}
if (content.dptr == NULL) {
fprintf(stderr, "Cannot find ");
print_datum(key);
printf("\n");
goto db_exit;
}
print_datum(key);
printf(": ");
print_datum(content);
printf("\n");
break;
case DELETE:
if (argn < 2) {
fprintf(stderr, "Missing delete key.\n");
goto db_exit;
}
if (dbm_delete(db, key) || dbm_error(db)) {
fprintf(stderr, "Error when deleting ");
print_datum(key);
printf("\n");
goto db_exit;
}
if (verbose) {
print_datum(key);
printf(": DELETED\n");
}
break;
case STORE:
if (argn < 3) {
fprintf(stderr, "Missing key and/or content.\n");
goto db_exit;
}
if (dbm_store(db, key, content, st_flag) || dbm_error(db)) {
fprintf(stderr, "Error when storing ");
print_datum(key);
printf("\n");
goto db_exit;
}
if (verbose) {
print_datum(key);
printf(": ");
print_datum(content);
printf(" STORED\n");
}
break;
}
db_exit:
dbm_clearerr(db);
dbm_close(db);
if (dbm_error(db)) {
fprintf(stderr, "Error closing database \"%s\"\n", comarg[0]);
exit(-1);
}
}
/*
* This function initialises the cache database and possibly converts it
* to a newer format if such exists. Returns -1 on error. 0 on success.
*/
int
cache_init()
{
int iret;
char *ret, *ret2;
struct jconfig *j;
#ifndef NOCACHE
datum dbkey = {"#jwhois#cacheversion#1", 22};
datum dbstore = {"1", 1};
#ifdef HAVE_GDBM_OPEN
GDBM_FILE dbf;
#else
DBM *dbf;
#endif
if (!cache) return 0;
jconfig_set();
j = jconfig_getone("jwhois", "cachefile");
if (!j)
cfname = LOCALSTATEDIR "/jwhois.db";
else
cfname = j->value;
if (verbose) printf("[Debug: cfname = \"%s\"]\n",cfname);
jconfig_set();
j = jconfig_getone("jwhois", "cacheexpire");
if (!j)
ret = CACHEEXPIRE;
else
ret = j->value;
#ifdef HAVE_STRTOL
cfexpire = strtol(ret, &ret2, 10);
if (*ret2 != '\0')
{
if (verbose)
{
printf("[%s (%s) -- %s]\n", _("invalid expire time"),
ret, _("using defaults"));
cfexpire = 168;
}
}
#else
cfexpire = atoi(ret2);
#endif /* HAVE_STRTOL */
if (verbose) printf("[Debug: cfexpire = %d]\n", cfexpire);
umask(0);
dbf = dbm_open(cfname, DBM_COPTIONS, DBM_MODE);
if (!dbf)
{
if (verbose) printf("[Debug: %s %s -- %s\n", _("unable to open"),
cfname, _("disabling cache"));
cache = 0;
return -1;
}
iret = dbm_store(dbf, dbkey, dbstore, DBM_IOPTIONS);
if (iret < 0)
{
if (verbose) printf("[Debug: %s -- %s]\n",
_("unable to store data in database"),
_("disabling cache"));
cache = 0;
}
dbm_close(dbf);
#endif
}
int RawStoreFile::store(datum key, datum content, int mode) {
return dbm_store(_dbm, key, content, mode);
}
