int
ndbm_search(mnt_map *m, char *map, char *key, char **pval, time_t *tp)
{
  DBM *db;

  db = dbm_open(map, O_RDONLY, 0);
  if (db) {
    struct stat stb;
    int error;
#ifdef DBM_SUFFIX
    char dbfilename[256];

    strcpy(dbfilename, map);
    strcat(dbfilename, DBM_SUFFIX);
    error = stat(dbfilename, &stb);
#else /* not DBM_SUFFIX */
    error = fstat(dbm_pagfno(db), &stb);
#endif /* not DBM_SUFFIX */
    if (!error && *tp < stb.st_mtime) {
      *tp = stb.st_mtime;
      error = -1;
    } else {
      error = search_ndbm(db, key, pval);
    }
    (void) dbm_close(db);
    return error;
  }
  return errno;
}

int
ndbm_init(mnt_map *m, char *map, time_t *tp)
{
  DBM *db;

  db = dbm_open(map, O_RDONLY, 0);
  if (db) {
    struct stat stb;
    int error;
#ifdef DBM_SUFFIX
    char dbfilename[256];

    strcpy(dbfilename, map);
    strcat(dbfilename, DBM_SUFFIX);
    error = stat(dbfilename, &stb);
#else /* not DBM_SUFFIX */
    error = fstat(dbm_pagfno(db), &stb);
#endif /* not DBM_SUFFIX */
    if (error < 0)
      *tp = clocktime();
    else
      *tp = stb.st_mtime;
    dbm_close(db);
    return 0;
  }
  return errno;
}

static void
dbm_dealloc(register dbmobject *dp)
{
        if ( dp->di_dbm )
		dbm_close(dp->di_dbm);
	PyObject_Del(dp);
}

/*
 *  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 */
}

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

int
main()
{
	DBM*	dbm = 0;

	dbm_close(dbm);
	return 0;
}

static void
free_dbm(struct dbmdata *dbmp)
{
    if (dbmp) {
	if (dbmp->di_dbm) dbm_close(dbmp->di_dbm);
	xfree(dbmp);
    }
}

static PyObject *
_dbm_dbm_close_impl(dbmobject *self)
/*[clinic end generated code: output=c8dc5b6709600b86 input=046db72377d51be8]*/
{
    if (self->di_dbm)
        dbm_close(self->di_dbm);
    self->di_dbm = NULL;
    Py_RETURN_NONE;
}

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

static PyObject *
dbm__close(register dbmobject *dp, PyObject *unused)
{
        if (dp->di_dbm)
		dbm_close(dp->di_dbm);
	dp->di_dbm = NULL;
	Py_INCREF(Py_None);
	return Py_None;
}

static void
free_dbm(void *ptr)
{
    struct dbmdata *dbmp = ptr;
    if (dbmp) {
	if (dbmp->di_dbm) dbm_close(dbmp->di_dbm);
	xfree(dbmp);
    }
}

static krb5_error_code
NDBM_close(krb5_context context, HDB *db)
{
    struct ndbm_db *d = db->hdb_db;
    dbm_close(d->db);
    close(d->lock_fd);
    free(d);
    return 0;
}

static int
_ndbm_close (mu_dbm_file_t db)
{
  if (db->db_descr)
    {
      dbm_close ((DBM *) db->db_descr);
      db->db_descr = NULL;
    }
  return 0;
}

static PyObject *
_dbm_dbm_close_impl(dbmobject *self)
/*[clinic end generated code: output=c8dc5b6709600b86 input=046db72377d51be8]*/
{
    if (self->di_dbm)
        dbm_close(self->di_dbm);
    self->di_dbm = NULL;
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
dbm__close(register dbmobject *dp, PyObject *args)
{
	if (!PyArg_ParseTuple(args, ":close"))
		return NULL;
        if (dp->di_dbm)
		dbm_close(dp->di_dbm);
	dp->di_dbm = NULL;
	Py_INCREF(Py_None);
	return Py_None;
}

/*
 * call-seq:
 *   dbm.close
 *
 * Closes the database.
 */
static VALUE
fdbm_close(VALUE obj)
{
    struct dbmdata *dbmp;

    GetDBM(obj, dbmp);
    dbm_close(dbmp->di_dbm);
    dbmp->di_dbm = 0;

    return Qnil;
}

void pdbm_close(PDBM &pdbm, cindex_t dim)
{
    assert(dim);

    if (pdbm)
    {
        pdbm_prepare(pdbm, dim);
        dbm_close(pdbm_matrix(pdbm), dim);
    }

    assertx(pdbm_isValid(pdbm, dim));
}

endpwent()
{
	if (pwf != NULL) {
		fclose(pwf);
		pwf = NULL;
	}
	if (_pw_db != (DBM *)0) {
		dbm_close(_pw_db);
		_pw_db = (DBM *)0;
		_pw_stayopen = 0;
	}
}

static krb5_error_code
NDBM_open(krb5_context context, HDB *db, int flags, mode_t mode)
{
    krb5_error_code ret;
    struct ndbm_db *d = malloc(sizeof(*d));
    char *lock_file;

    if(d == NULL) {
	krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
	return ENOMEM;
    }
    asprintf(&lock_file, "%s.lock", (char*)db->hdb_name);
    if(lock_file == NULL) {
	free(d);
	krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
	return ENOMEM;
    }
    d->db = dbm_open((char*)db->hdb_name, flags, mode);
    if(d->db == NULL){
	ret = errno;
	free(d);
	free(lock_file);
	krb5_set_error_message(context, ret, "dbm_open(%s): %s", db->hdb_name,
			       strerror(ret));
	return ret;
    }
    d->lock_fd = open(lock_file, O_RDWR | O_CREAT, 0600);
    if(d->lock_fd < 0){
	ret = errno;
	dbm_close(d->db);
	free(d);
	krb5_set_error_message(context, ret, "open(%s): %s", lock_file,
			       strerror(ret));
	free(lock_file);
	return ret;
    }
    free(lock_file);
    db->hdb_db = d;
    if((flags & O_ACCMODE) == O_RDONLY)
	ret = hdb_check_db_format(context, db);
    else
	ret = hdb_init_db(context, db);
    if(ret == HDB_ERR_NOENTRY)
	return 0;
    if (ret) {
	NDBM_close(context, db);
	krb5_set_error_message(context, ret, "hdb_open: failed %s database %s",
			       (flags & O_ACCMODE) == O_RDONLY ?
			       "checking format of" : "initialize",
			       db->hdb_name);
    }
    return ret;
}

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