void
ypoldnext(SVCXPRT *transp)
{
bool dbmop_ok = TRUE;
struct yprequest req;
struct ypresponse resp;
char *fun = "ypoldnext";
DBM *fdb;
memset((void *) &req, 0, sizeof (req));
memset((void *) &resp, 0, sizeof (resp));
if (!svc_getargs(transp,
(xdrproc_t)_xdr_yprequest,
(caddr_t)&req)) {
svcerr_decode(transp);
return;
}
if (req.yp_reqtype != YPNEXT_REQTYPE) {
resp.ypnext_resp_status = (unsigned)YP_BADARGS;
dbmop_ok = FALSE;
}
if (dbmop_ok &&
((fdb = ypset_current_map(req.ypnext_req_map,
req.ypnext_req_domain,
&resp.ypnext_resp_status)) != NULL &&
yp_map_access(transp, &resp.ypnext_resp_status, fdb))) {
resp.ypnext_resp_keydat = dbm_nextkey(fdb);
if (resp.ypnext_resp_keyptr != NULL) {
resp.ypnext_resp_valdat =
dbm_fetch(fdb, resp.ypnext_resp_keydat);
if (resp.ypnext_resp_valptr != NULL) {
resp.ypnext_resp_status = YP_TRUE;
} else {
resp.ypnext_resp_status = (unsigned)YP_BADDB;
}
} else {
resp.ypnext_resp_status = (unsigned)YP_NOMORE;
}
}
resp.yp_resptype = YPNEXT_RESPTYPE;
if (!svc_sendreply(transp,
(xdrproc_t)_xdr_ypresponse,
(caddr_t)&resp)) {
RESPOND_ERR;
}
if (!svc_freeargs(transp,
(xdrproc_t)_xdr_yprequest,
(caddr_t)&req)) {
FREE_ERR;
}
}
int main(int argc, char *argv[]) {
int i;
DBM *db;
datum daKey, daVal;
/* Open the database (create) */
db = dbm_open("ndbmTest", O_RDWR, 0660);
if(db == NULL) {
printf("ERROR: Could not open the DB file. Error number: %d.\n", errno);
exit(1);
} else {
printf("DB handle created.\n");
printf("DB file opened.\n");
}
/* At this point you can add and remove things from the DB just as in mkNDBM. */
/* Traverse the entire DB and lookup each key. */
printf("All the records in the DB:\n");
for(i=1,daKey=dbm_firstkey(db); daKey.dptr!=NULL; daKey=dbm_nextkey(db),i++) {
daVal = dbm_fetch(db, daKey);
if(daVal.dptr == NULL) {
printf("ERROR: Could not look up %s\n", (char *)daKey.dptr);
} else {
printf(" Record(%d): '%s' ==> '%s'\n", i, (char *)daKey.dptr, (char *)daVal.dptr);
} /* end if/else */
} /* end for */
printf("Found %d records\n", i-1);
/* Close the DB (flush everything to the file) */
dbm_close(db);
printf("DB closed... Bye!\n");
return 0;
} /* end func main */
static char *get_dbm_pw(request_rec *r, char *user, char *auth_dbmpwfile)
{
DBM *f;
datum d, q;
char *pw = NULL;
q.dptr = user;
#ifndef NETSCAPE_DBM_COMPAT
q.dsize = strlen(q.dptr);
#else
q.dsize = strlen(q.dptr) + 1;
#endif
if (!(f = dbm_open(auth_dbmpwfile, O_RDONLY, 0664))) {
ap_log_error(APLOG_MARK, APLOG_ERR, r->server,
"could not open dbm auth file: %s", auth_dbmpwfile);
return NULL;
}
d = dbm_fetch(f, q);
if (d.dptr) {
pw = ap_palloc(r->pool, d.dsize + 1);
strncpy(pw, d.dptr, d.dsize);
pw[d.dsize] = '\0'; /* Terminate the string */
}
dbm_close(f);
return pw;
}
static VALUE
fdbm_fetch(VALUE obj, VALUE keystr, VALUE ifnone)
{
datum key, value;
struct dbmdata *dbmp;
DBM *dbm;
long len;
ExportStringValue(keystr);
len = RSTRING_LEN(keystr);
if (TOO_LONG(len)) goto not_found;
key.dptr = RSTRING_PTR(keystr);
key.dsize = (DSIZE_TYPE)len;
GetDBM2(obj, dbmp, dbm);
value = dbm_fetch(dbm, key);
if (value.dptr == 0) {
not_found:
if (NIL_P(ifnone) && rb_block_given_p()) {
keystr = rb_str_dup(keystr);
OBJ_TAINT(keystr);
return rb_yield(keystr);
}
return ifnone;
}
return rb_tainted_str_new(value.dptr, value.dsize);
}
/*
This function retrieves a single track entry, when passed a pointer
pointing to a catalog string and a track number. If the entry is not
found then the returned data has an empty catalog field. */
cdt_entry get_cdt_entry(const char *cd_catalog_ptr, const int track_no)
{
cdt_entry entry_to_return;
char entry_to_find[CAT_CAT_LEN + 10];
datum local_data_datum;
datum local_key_datum;
memset(&entry_to_return, '\0', sizeof(entry_to_return));
/* check database initialized and parameters valid */
if (!cdc_dbm_ptr || !cdt_dbm_ptr) return (entry_to_return);
if (!cd_catalog_ptr) return (entry_to_return);
if (strlen(cd_catalog_ptr) >= CAT_CAT_LEN) return (entry_to_return);
/* setup the search key, which is a composite key of catalog entry
and track number */
memset(&entry_to_find, '\0', sizeof(entry_to_find));
sprintf(entry_to_find, "%s %d", cd_catalog_ptr, track_no);
local_key_datum.dptr = (void *) entry_to_find;
local_key_datum.dsize = sizeof(entry_to_find);
memset(&local_data_datum, '\0', sizeof(local_data_datum));
local_data_datum = dbm_fetch(cdt_dbm_ptr, local_key_datum);
if (local_data_datum.dptr) {
memcpy(&entry_to_return, (char *) local_data_datum.dptr, local_data_datum.dsize);
}
return (entry_to_return);
} /* get_cdt_entry */
/*
* test_access_cookie
*
* returns -1: error
* 0: not valid
* 1: ok
*/
int cmp_access_cookie(char *accessdb, char *loginname, char *cookie,time_t timeout)
{
DBM *db;
datum key;
datum data;
time_t t;
struct access_data access;
db=dbm_open(accessdb, O_RDONLY, 0666);
if(!db) return -1;
key.dptr=(void *)loginname;
key.dsize=strlen(loginname);
data=dbm_fetch(db,key);
if(!data.dptr) { dbm_close(db); return(0); }
if(sizeof(access)!=data.dsize) { dbm_close(db); return(-1); }
memcpy(&access,data.dptr,data.dsize);
dbm_close(db);
if(strcmp(access.cookie,cookie)) {
return(0);
}
time(&t);
if(t-access.ti>timeout) {
return(0);
}
return(1);
}
/*
This function retrieves a single catalog entry, when passed a pointer
pointing to catalog text string. If the entry is not found then the
returned data has an empty catalog field. */
cdc_entry get_cdc_entry(const char *cd_catalog_ptr)
{
cdc_entry entry_to_return;
char entry_to_find[CAT_CAT_LEN + 1];
datum local_data_datum;
datum local_key_datum;
memset(&entry_to_return, '\0', sizeof(entry_to_return));
/* check database initialized and parameters valid */
if (!cdc_dbm_ptr || !cdt_dbm_ptr) return (entry_to_return);
if (!cd_catalog_ptr) return (entry_to_return);
if (strlen(cd_catalog_ptr) >= CAT_CAT_LEN) return (entry_to_return);
/* ensure the search key contains only the valid string and nulls */
memset(&entry_to_find, '\0', sizeof(entry_to_find));
strcpy(entry_to_find, cd_catalog_ptr);
local_key_datum.dptr = (void *) entry_to_find;
local_key_datum.dsize = sizeof(entry_to_find);
memset(&local_data_datum, '\0', sizeof(local_data_datum));
local_data_datum = dbm_fetch(cdc_dbm_ptr, local_key_datum);
if (local_data_datum.dptr) {
memcpy(&entry_to_return, (char *)local_data_datum.dptr, local_data_datum.dsize);
}
return (entry_to_return);
} /* get_cdc_entry */
static int
dbm_contains(PyObject *self, PyObject *arg)
{
dbmobject *dp = (dbmobject *)self;
datum key, val;
Py_ssize_t size;
if ((dp)->di_dbm == NULL) {
PyErr_SetString(DbmError,
"DBM object has already been closed");
return -1;
}
if (PyUnicode_Check(arg)) {
key.dptr = PyUnicode_AsUTF8AndSize(arg, &size);
key.dsize = size;
if (key.dptr == NULL)
return -1;
}
else if (!PyBytes_Check(arg)) {
PyErr_Format(PyExc_TypeError,
"dbm key must be bytes or string, not %.100s",
arg->ob_type->tp_name);
return -1;
}
else {
key.dptr = PyBytes_AS_STRING(arg);
key.dsize = PyBytes_GET_SIZE(arg);
}
val = dbm_fetch(dp->di_dbm, key);
return val.dptr != NULL;
}
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;
}
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 ;
}
Datum
ldbm_fetch( LDBM ldbm, Datum key )
{
Datum d;
LDBM_RLOCK;
d = ldbm_datum_dup( ldbm, dbm_fetch( ldbm, key ) );
LDBM_RUNLOCK;
return d;
}
static int vt_ndbm_exists(apr_dbm_t *dbm, apr_datum_t key)
{
datum kd, rd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
rd = dbm_fetch(dbm->file, kd);
return rd.dptr != NULL;
}
/* {{{ php_dbm_key_exists
*/
static int php_dbm_key_exists(DBM *dbf, datum key_datum) {
datum value_datum;
int ret;
value_datum = dbm_fetch(dbf, key_datum);
if (value_datum.dptr)
ret = 1;
else
ret = 0;
return ret;
}
char *database_fetch(DBM *db, s48_value key)
{
datum work_key, work_data;
char *work_string;
work_key.dptr = ADDRESS_AFTER_HEADER(key, char);
work_key.dsize = S48_STRING_LENGTH(key);
work_data = dbm_fetch(db, work_key);
if (work_data.dptr == NULL)
{
work_string = Malloc(char, 1);
work_string[0] = '\0';
}
void dbm_list_group(DBM *dbmgroup,char *group) {
datum key,resp;
key.dptr = group;
key.dsize = strlen(group);
resp = dbm_fetch(dbmgroup,key);
printf("Group: %s\n",key.dptr);
if (resp.dptr) {
printf(" Users: %s\n",resp.dptr);
} else {
printf(" Empty\n");
}
}
/* Dbm.fetch: t -> string -> string */
value caml_dbm_fetch(value vdb, value vkey) /* ML */
{
datum key,answer;
key.dptr = String_val(vkey);
key.dsize = string_length(vkey);
answer = dbm_fetch(extract_dbm(vdb), key);
if (answer.dptr) {
value res = alloc_string(answer.dsize);
memmove (String_val (res), answer.dptr, answer.dsize);
return res;
}
else raise_not_found();
}
static PyObject *
dbm_has_key(register dbmobject *dp, PyObject *args)
{
datum key, val;
int tmp_size;
if (!PyArg_ParseTuple(args, "s#:has_key", &key.dptr, &tmp_size))
return NULL;
key.dsize = tmp_size;
check_dbmobject_open(dp);
val = dbm_fetch(dp->di_dbm, key);
return PyInt_FromLong(val.dptr != NULL);
}
void dbm_list(DBM *dbmgroup) {
datum key,resp;
for (key = dbm_firstkey(dbmgroup); key.dptr != NULL; key = dbm_nextkey(dbmgroup)) {
resp = dbm_fetch(dbmgroup,key);
printf("Group: %s\n",key.dptr);
if (resp.dptr) {
printf(" Users: %s\n",resp.dptr);
} else {
printf(" Empty\n");
}
}
}
static int
search_ndbm(DBM *db, char *key, char **val)
{
datum k, v;
k.dptr = key;
k.dsize = strlen(key) + 1;
v = dbm_fetch(db, k);
if (v.dptr) {
*val = strdup(v.dptr);
return 0;
}
return ENOENT;
}
int main (int argc, char *argv[])
{
FILE *std_fp;
DBM *db;
datum dtKey, dtRec;
char rec[MAX_STRING_LEN];
char key[MAX_STRING_LEN];
char *pch1, *pch2;
int ndx;
if (argc != 3)
usage(argv[0]);
if (!(std_fp = fopen(argv[2], "w"))) {
fprintf(stderr,"%s: Could not open file %s for writing.\n",
argv[0],argv[2]);
perror("fopen");
exit(1);
}
if (!(db = dbm_open (argv[1], O_RDONLY, 0))) {
fprintf(stderr,"%s: Could not open database file %s.\n",
argv[0], argv[1]);
exit(1);
}
for (dtKey = dbm_firstkey(db); dtKey.dptr; dtKey = dbm_nextkey(db)) {
dtRec = dbm_fetch (db, dtKey);
pch1 = key;
for (ndx = 0; ndx < dtKey.dsize; ndx++)
*pch1++ = dtKey.dptr[ndx];
*pch1 = '\0';
pch2 = rec;
for (ndx = 0; ndx < dtRec.dsize; ndx++)
*pch2++ = dtRec.dptr[ndx];
*pch2 = '\0';
printf ("Storing data <%s> with key <%s>\n",
rec, key);
if (strchr (rec, ' '))
fprintf (std_fp,"%s: %s\n", key, rec);
else
fprintf (std_fp,"%s:%s\n", key, rec);
}
dbm_close(db);
exit(0);
}
void dbm_del_group(DBM *dbmgroup, char *group) {
datum key,resp;
key.dptr = group;
key.dsize = strlen(group);
resp = dbm_fetch(dbmgroup,key);
if (resp.dptr) {
printf("Deleting group %s.\n",group);
dbm_delete(dbmgroup,key);
} else {
fprintf(stderr,"Group %s does not exist.\n",group);
exit(1);
}
}
static int
_ndbm_fetch (mu_dbm_file_t db, struct mu_dbm_datum const *key,
struct mu_dbm_datum *ret)
{
datum keydat, content;
keydat.dptr = key->mu_dptr;
keydat.dsize = key->mu_dsize;
errno = 0;
content = dbm_fetch (db->db_descr, keydat);
mu_dbm_datum_free (ret);
if (content.dptr == NULL)
return MU_ERR_NOENT;
return _ndbm_conv_datum (db, ret, content);
}
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 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;
}
/*
* Given a key, this function retrieves the text from the database
* and checks the expire time on it. If it is still valid data, it
* returns the number of bytes in text, else 0 or -1 on error.
*/
int
cache_read(char *key, char **text)
{
#ifndef NOCACHE
datum dbkey;
datum dbstore;
#ifdef HAVE_GDBM_OPEN
GDBM_FILE dbf;
#else
DBM *dbf;
#endif
#endif
time_t time_c;
if (!cache)
return 0;
#ifndef NOCACHE
dbkey.dptr = key;
dbkey.dsize = strlen(key);
dbf = dbm_open(cfname, DBM_ROPTIONS, DBM_MODE);
if (!dbf)
return -1;
dbstore = dbm_fetch(dbf, dbkey);
if ((dbstore.dptr == NULL))
{
dbm_close(dbf);
return 0;
}
memcpy(&time_c,dbstore.dptr,sizeof(time_c)); /* ensure suitable alignment */
if ((time(NULL)-time_c)/(60*60) > cfexpire)
{
dbm_close(dbf);
return 0;
}
*text = malloc(dbstore.dsize);
if (!*text)
return -1;
memcpy(*text, (char *)(dbstore.dptr)+sizeof(time_t), dbstore.dsize-sizeof(time_t));
dbm_close(dbf);
return (dbstore.dsize-sizeof(time_t));
#else
return 0;
#endif /* !NOCACHE */
}
/* This function searches for a catalog entry, where the catalog
text contains the provided search text. If the search text points
to a null character then all entries are considered to match */
cdc_entry search_cdc_entry(const char *cd_catalog_ptr, int *first_call_ptr)
{
static int local_first_call = 1;
cdc_entry entry_to_return;
datum local_data_datum;
static datum local_key_datum; /* notice this must be static */
memset(&entry_to_return, '\0', sizeof(entry_to_return));
/* check database initialized and parameters valid */
if (!cdc_dbm_ptr || !cdt_dbm_ptr) return (entry_to_return);
if (!cd_catalog_ptr || !first_call_ptr) return (entry_to_return);
if (strlen(cd_catalog_ptr) >= CAT_CAT_LEN) return (entry_to_return);
/* protect against never passing *first_call_ptr true */
if (local_first_call) {
local_first_call = 0;
*first_call_ptr = 1;
}
if (*first_call_ptr) {
*first_call_ptr = 0;
local_key_datum = dbm_firstkey(cdc_dbm_ptr);
} else {
local_key_datum = dbm_nextkey(cdc_dbm_ptr);
}
do {
if (local_key_datum.dptr != NULL) {
/* an entry was found */
local_data_datum = dbm_fetch(cdc_dbm_ptr, local_key_datum);
if (local_data_datum.dptr) {
memcpy(&entry_to_return, (char *) local_data_datum.dptr, local_data_datum.dsize);
/* check if search string occures in the entry */
if (!strstr(entry_to_return.catalog, cd_catalog_ptr)) {
memset(&entry_to_return, '\0', sizeof(entry_to_return));
local_key_datum = dbm_nextkey(cdc_dbm_ptr);
}
}
}
} while (local_key_datum.dptr &&
local_data_datum.dptr &&
(entry_to_return.catalog[0] == '\0'));
/* Finished finding entries, either there are no more or one matched */
return (entry_to_return);
} /* search_cdc_entry */
static void
dumprgb (char *filename)
{
#ifdef NDBM
DBM *rgb_dbm;
#else
int rgb_dbm;
#endif
datum key;
rgb_dbm = dbm_open (filename, O_RDONLY, 0);
if (!rgb_dbm) {
fprintf (stderr, "%s: unable to open rgb database \"%s\"\n",
ProgramName, filename);
exit (1);
}
#ifndef NDBM
#define dbm_nextkey(db) (nextkey(key)) /* need variable called key */
#endif
for (key = dbm_firstkey(rgb_dbm); key.dptr != NULL;
key = dbm_nextkey(rgb_dbm)) {
datum value;
value = dbm_fetch(rgb_dbm, key);
if (value.dptr) {
RGB rgb;
unsigned short r, g, b;
memcpy( (char *)&rgb, value.dptr, sizeof rgb);
#define N(x) (((x) >> 8) & 0xff)
r = N(rgb.red);
g = N(rgb.green);
b = N(rgb.blue);
#undef N
printf ("%3u %3u %3u\t\t", r, g, b);
fwrite (key.dptr, 1, key.dsize, stdout);
putchar ('\n');
} else {
fprintf (stderr, "%s: no value found for key \"", ProgramName);
fwrite (key.dptr, 1, key.dsize, stderr);
fprintf (stderr, "\"\n");
}
}
dbm_close (rgb_dbm);
}
static apr_status_t vt_ndbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
apr_datum_t *pvalue)
{
datum kd, rd;
kd.dptr = key.dptr;
kd.dsize = key.dsize;
rd = dbm_fetch(dbm->file, kd);
pvalue->dptr = rd.dptr;
pvalue->dsize = rd.dsize;
/* store the error info into DBM, and return a status code. Also, note
that *pvalue should have been cleared on error. */
return set_error(dbm, APR_SUCCESS);
}
static PyObject *
_dbm_dbm_get_impl(dbmobject *self, const char *key,
Py_ssize_clean_t key_length, PyObject *default_value)
/*[clinic end generated code: output=b44f95eba8203d93 input=fee97bbe85e84822]*/
{
datum dbm_key, val;
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);
Py_INCREF(default_value);
return default_value;
}
static int
search_ndbm(mnt_map *m, DBM *db, char *key, char **val)
{
datum k, v;
k.dptr = key;
k.dsize = strlen(key) + 1;
v = dbm_fetch(db, k);
if (v.dptr) {
if (m->cfm && (m->cfm->cfm_flags & CFM_SUN_MAP_SYNTAX))
*val = sun_entry2amd(key, v.dptr);
else
*val = xstrdup(v.dptr);
return 0;
}
return ENOENT;
}
