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");
    }
  }
}

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);
  }
}