/*
* gdbm.c
*
* Created by: Benny Holmgren
* Description: LPC interface to GNU dbm.
*/
#ifdef LATTICE
#include "/lpc_incl.h"
#include "/eoperators.h"
#include "/regexp.h"
#include "/debug.h"
#else
#include "../lpc_incl.h"
#include "../eoperators.h"
#include "../regexp.h"
#include "../debug.h"
#endif
#include "gdbm.h"
#ifdef F_DB_EXISTS
void
f_db_exists PROT((void))
{
int res = db_exists( (sp-1)->u.string, sp->u.string );
pop_n_elems(2);
push_number(res);
}
#endif
#ifdef F_DB_QUERY
void
f_db_query PROT((void))
{
svalue_t res;
if (db_query(&res, (sp-1)->u.string, sp->u.string);
pop_n_elems( 2 );
*sp++ = ret;
if( res ) {
switch(res->type) {
case T_STRING:
switch (respush_string(res->u.string, res->subtype);
break;
case T_ARRAY:
push_array(res->u.arr);
break;
case T_NUMBER:
push_number(res->u.number);
break;
case T_REAL:
push_real(res->u.real);
break;
case T_MAPPING:
push_mapping(res->u.map);
break;
default:
/* Huh? */
fatal("Bogus svalue in db_query(), type %d\n", res->type);
}
free_svalue(res, "f_db_query");
FREE(res);
} else
push_undefined();
}
#endif
#ifdef F_DB_STORE
void
f_db_store PROT((void))
{
int res;
if(!(sp->type & (T_STRING|T_ARRAY|T_NUMBER|T_REAL|T_MAPPING)))
bad_argument(sp, T_STRING|T_ARRAY|T_NUMBER|T_REAL|T_MAPPING, 3, F_DB_STORE);
res = db_store( (sp-2)->u.string, (sp-1)->u.string, sp );
pop_n_elems( 3 );
push_number( res );
}
#endif
#ifdef F_DB_DELETE
void
f_db_delete PROT((void))
{
int res;
res = db_delete((sp-1)->u.string, sp->u.string);
pop_n_elems(2);
push_number(res);
}
#endif
#ifdef F_DB_KEYS
void
f_db_keys PROT((void))
{
array_t *res;
res = db_keys((sp-st_num_arg+1)->u.string,
(st_num_arg == 1 ? (char *)NULL : sp->u.string));
pop_n_elems(st_num_arg);
if(res) {
push_array(res);
res->ref--; /* Ref count back to 1 */
} else
push_null();
}
#endif
/*
* Support functions.
*/
#ifdef PACKAGE_GDBM
#include <gdbm.h>
int
db_exists( db, keystr )
char *db;
char *keystr;
{
int res;
GDBM_FILE dbf;
datum key;
if(!check_valid_path(db, current_object, "db_exists", 0))
error("Denied read permission for database.\n");
dbf = gdbm_open( db, 0, GDBM_READER, 0640, NULL );
if( !dbf ) {
if( gdbm_errno != GDBM_FILE_OPEN_ERROR )
debug(512,("dbm file open error: %s\n",gdbm_strerror(gdbm_errno)));
return(0);
}
key.dptr = keystr;
key.dsize = strlen(keystr)+1;
res = gdbm_exists( dbf, key );
gdbm_close( dbf );
return( (int)res );
}
svalue_t *
db_query P3( svalue_t *, ret, char *, db, char *, keystr )
{
int res;
GDBM_FILE dbf;
datum key, content;
extern svalue_t const0u;
if(!check_valid_path(db, current_object, "db_query", 0))
error("Denied read permission for database.\n");
dbf = gdbm_open( db, 0, GDBM_READER, 0640, NULL );
if( !dbf ) {
if( gdbm_errno != GDBM_FILE_OPEN_ERROR )
debug(512,("dbm file open error: %s\n",gdbm_strerror(gdbm_errno)));
return( (svalue_t *)NULL );
}
key.dptr = keystr;
key.dsize = strlen(keystr)+1;
content = gdbm_fetch( dbf, key );
gdbm_close( dbf );
if( !content.dptr )
return( (svalue_t *)NULL );
res = restore_svalue( content.dptr, ret);
FREE(content.dptr);
switch (res)
{
case -1:
free_svalue(ret, "db_query");
error("db_query(): Illegal array format.\n");
case -2:
free_svalue(ret, "db_query");
error("db_query(): Illegal mapping format.\n");
}
return( val );
}
int
db_store( db, keystr, val )
char *db, *keystr;
svalue_t *val;
{
GDBM_FILE dbf;
int savesize, res;
datum key, content;
extern int save_svalue_depth;
char *savestring, *tmp;
if(!check_valid_path(db, current_object, "db_store", 1))
error("Denied write permission for database.\n");
dbf = gdbm_open( db, 0, GDBM_WRCREAT, 0640, NULL );
if( !dbf ) {
if( gdbm_errno != GDBM_FILE_OPEN_ERROR )
debug(512,("dbm file open error: %s\n",gdbm_strerror(gdbm_errno)));
return( 0 );
}
save_svalue_depth = 0;
savesize = svalue_save_size(val);
if (save_svalue_depth > MAX_SAVE_SVALUE_DEPTH) {
error("Mappings and/or arrays nested too deep (%d) for db_store\n",
MAX_SAVE_SVALUE_DEPTH);
}
savestring = (char *)XALLOC(savesize);
*savestring = '\0';
tmp = savestring;
save_svalue(val, &tmp);
key.dptr = keystr;
key.dsize = strlen( keystr ) +1;
content.dptr = savestring;
content.dsize = strlen( savestring ) +1;
res = gdbm_store( dbf, key, content, GDBM_REPLACE );
gdbm_close( dbf );
FREE(savestring);
if( res ) {
debug(512, ("db_store() failed: %s\n", gdbm_strerror(gdbm_errno)));
return( 0 );
}
return( 1 );
}
int
db_delete(db, keystr)
char *db, *keystr;
{
int res;
datum key;
GDBM_FILE dbf;
if(!check_valid_path(db, current_object, "db_delete", 1))
error("Denied write permission for database.\n");
dbf = gdbm_open( db, 0, GDBM_WRITER, 0640, NULL );
if( !dbf ) {
if( gdbm_errno != GDBM_FILE_OPEN_ERROR )
debug(512,("dbm file open error: %s\n",gdbm_strerror(gdbm_errno)));
return(0);
}
key.dptr = keystr;
key.dsize = strlen( keystr ) +1;
res = gdbm_delete( dbf, key );
gdbm_close( dbf );
if( res != 0 ) /* Not found. */
return(0);
return(1);
}
array_t *
db_keys( db, pattern )
char *db;
char *pattern;
{
datum key, nextkey;
GDBM_FILE dbf;
int keycnt, i;
char *keys[MAX_ARRAY_SIZE];
struct regexp *rexp = (struct regexp *)NULL;
array_t *ret;
extern int eval_cost;
if(!check_valid_path(db, current_object, "db_keys", 0))
error("Denied read permission for database.\n");
if(pattern) {
rexp = regcomp(pattern, 0);
if (!rexp)
return((array_t *)NULL);
}
dbf = gdbm_open( db, 0, GDBM_READER, 0640, NULL );
if( !dbf ) {
if( gdbm_errno != GDBM_FILE_OPEN_ERROR )
debug(512,("dbm file open error: %s\n",gdbm_strerror(gdbm_errno)));
return((array_t *)NULL);
}
keycnt = 0;
key = gdbm_firstkey(dbf);
while(key.dptr) {
nextkey = gdbm_nextkey(dbf, key);
if(pattern && !regexec(rexp, key.dptr))
free(key.dptr);
else
keys[keycnt++] = key.dptr;
key = nextkey;
}
gdbm_close(dbf);
if(rexp)
FREE((char *)rexp);
ret = allocate_array(keycnt);
for(i=0; i < keycnt; i++) {
ret->item[i].type = T_STRING;
ret->item[i].subtype = STRING_MALLOC; /* Should we make it shared? */
ret->item[i].u.string = keys[i]; /* string_copy() for debugging? */
}
return(ret);
}
#endif /* PACKAGE_DBM */
