/* This function initializes access to the database. If the parameter
   new_database is true, then a new database is started.
 */
int database_initialize(const int new_database)
{
    int open_mode = O_RDWR;

    /* If any existing database is open then close it */
    if (cdc_dbm_ptr) dbm_close(cdc_dbm_ptr);
    if (cdt_dbm_ptr) dbm_close(cdt_dbm_ptr);

    if (new_database) {
	/* delete the old files */
	(void) unlink(CDC_FILE_PAG);
	(void) unlink(CDC_FILE_DIR);
	(void) unlink(CDT_FILE_PAG);
	(void) unlink(CDT_FILE_DIR);

	open_mode = O_CREAT | O_RDWR;
    }
    /* Open some new files, creating them if required */
    cdc_dbm_ptr = dbm_open(CDC_FILE_BASE, open_mode, 0644);
    cdt_dbm_ptr = dbm_open(CDT_FILE_BASE, open_mode, 0644);
    if (!cdc_dbm_ptr || !cdt_dbm_ptr) {
	fprintf(stderr, "Unable to create database\n");
	cdc_dbm_ptr = cdt_dbm_ptr = NULL;
	return (0);
    }
    return (1);

} /* database_initialize */

/*
 * FUNCTION :	open_yptol_files()
 *
 * DESCRIPTION:	Opens both yptol files for a map. This is called both when a
 *		map is opened and when it is reopened as a result of an update
 *		operation. Must be called with map locked.
 *
 * GIVEN :	Initialized map_ctrl
 *
 * RETURNS :	SUCCESS = Maps opened
 *		FAILURE = Maps not opened (and mess tidied up)
 */
suc_code
open_yptol_files(map_ctrl *map)
{

	/* Open entries map */
	map->entries = dbm_open(map->map_path, map->open_flags, map->open_mode);

	if (NULL == map->entries) {
		/* Maybe we were asked to open a non-existent map. No problem */
		return (FAILURE);
	}

	if (yptol_mode) {
		/* Open TTLs map. Must always be writable */
		map->ttl = dbm_open(map->ttl_path, O_RDWR | O_CREAT, 0644);
		if (NULL == map->ttl) {
			logmsg(MSG_NOTIMECHECK, LOG_ERR,
				"Cannot open TTL file %s", map->ttl_path);
			dbm_close(map->entries);
			map->entries = NULL;
			return (FAILURE);
		}
	}

	return (SUCCESS);
}

/*
 * call-seq:
 *   DBM.new(filename[, mode[, flags]]) -> dbm
 *
 * Open a dbm database with the specified name, which can include a directory
 * path. Any file extensions needed will be supplied automatically by the dbm
 * library. For example, Berkeley DB appends '.db', and GNU gdbm uses two
 * physical files with extensions '.dir' and '.pag'.
 *
 * The mode should be an integer, as for Unix chmod.
 *
 * Flags should be one of READER, WRITER, WRCREAT or NEWDB.
 */
static VALUE
fdbm_initialize(int argc, VALUE *argv, VALUE obj)
{
    volatile VALUE file;
    VALUE vmode, vflags;
    DBM *dbm;
    struct dbmdata *dbmp;
    int mode, flags = 0;

    if (rb_scan_args(argc, argv, "12", &file, &vmode, &vflags) == 1) {
	mode = 0666;		/* default value */
    }
    else if (NIL_P(vmode)) {
	mode = -1;		/* return nil if DB not exist */
    }
    else {
	mode = NUM2INT(vmode);
    }

    if (!NIL_P(vflags))
        flags = NUM2INT(vflags);

    FilePathValue(file);

    if (flags & RUBY_DBM_RW_BIT) {
        flags &= ~RUBY_DBM_RW_BIT;
        dbm = dbm_open(RSTRING_PTR(file), flags, mode);
    }
    else {
        dbm = 0;
        if (mode >= 0) {
            dbm = dbm_open(RSTRING_PTR(file), O_RDWR|O_CREAT, mode);
        }
        if (!dbm) {
            dbm = dbm_open(RSTRING_PTR(file), O_RDWR, 0);
        }
        if (!dbm) {
            dbm = dbm_open(RSTRING_PTR(file), O_RDONLY, 0);
        }
    }

    if (!dbm) {
	if (mode == -1) return Qnil;
	rb_sys_fail(RSTRING_PTR(file));
    }

    dbmp = ALLOC(struct dbmdata);
    DATA_PTR(obj) = dbmp;
    dbmp->di_dbm = dbm;
    dbmp->di_size = -1;

    return obj;
}

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

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

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

void *
otp_db_open (void)
{
  int lock;
  int i;
  void *ret;

  for(i = 0; i < RETRIES; ++i) {
    struct stat statbuf;

    lock = open (OTP_DB_LOCK, O_WRONLY | O_CREAT | O_EXCL, 0666);
    if (lock >= 0) {
      close(lock);
      break;
    }
    if (stat (OTP_DB_LOCK, &statbuf) == 0) {
      if (time(NULL) - statbuf.st_mtime > OTP_DB_TIMEOUT)
	unlink (OTP_DB_LOCK);
      else
	sleep (1);
    }
  }
  if (i == RETRIES)
    return NULL;
  ret = dbm_open (OTP_DB, O_RDWR | O_CREAT, 0600);
  if (ret == NULL)
    unlink (OTP_DB_LOCK);
  return ret;
}

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

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

    xstrlcpy(dbfilename, map, sizeof(dbfilename));
    xstrlcat(dbfilename, DBM_SUFFIX, sizeof(dbfilename));
    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(m, db, key, pval);
    }
    (void) dbm_close(db);
    return error;
  }
  return errno;
}

static int
_ndbm_open (mu_dbm_file_t db, int flags, int mode)
{
  int f;
  DBM *dbm;
  
  switch (flags)
    {
    case MU_STREAM_CREAT:
      f = O_CREAT|O_TRUNC|O_RDWR;
      break;
      
    case MU_STREAM_READ:
      f = O_RDONLY;
      break;
      
    case MU_STREAM_RDWR:
      f = O_CREAT|O_RDWR;
      break;
      
    default:
      errno = EINVAL;
      return -1;
    }
  dbm = dbm_open (db->db_name, f, mode);
  if (!dbm)
    return MU_ERR_FAILURE;
  db->db_descr = dbm;
  return 0;
}

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 int open_storage(const char * fname) {

  if ( (pdb = dbm_open(fname, oflags, 0600 )) == NULL ) {
	perror("Couldn't open database");
	return 1;
  }
  return 0;
}

/* Check for the existence of the replay dbm file, and create it if it does
 * not exist.  Returns the number of db entries or -1 on error.
*/
static int
replay_db_cache_init(fko_srv_options_t *opts)
{
#ifdef NO_DIGEST_CACHE
    return(-1);
#else

#ifdef HAVE_LIBGDBM
    GDBM_FILE   rpdb;
#elif HAVE_LIBNDBM
    DBM        *rpdb;
    datum       db_ent;
#endif

    datum       db_key, db_next_key;
    int         db_count = 0;

#ifdef HAVE_LIBGDBM
    rpdb = gdbm_open(
        opts->config[CONF_DIGEST_DB_FILE], 512, GDBM_WRCREAT, S_IRUSR|S_IWUSR, 0
    );
#elif HAVE_LIBNDBM
    rpdb = dbm_open(
        opts->config[CONF_DIGEST_DB_FILE], O_RDWR|O_CREAT, S_IRUSR|S_IWUSR
    );
#endif

    if(!rpdb)
    {
        log_msg(LOG_ERR,
            "Unable to open digest cache file: '%s': %s",
            opts->config[CONF_DIGEST_DB_FILE],
            MY_DBM_STRERROR(errno)
        );

        return(-1);
    }

#ifdef HAVE_LIBGDBM
    db_key = gdbm_firstkey(rpdb);

    while (db_key.dptr != NULL)
    {
        db_count++;
        db_next_key = gdbm_nextkey(rpdb, db_key);
        free(db_key.dptr);
        db_key = db_next_key;
    }
#elif HAVE_LIBNDBM
    for (db_key = dbm_firstkey(rpdb); db_ent.dptr != NULL; db_key = dbm_nextkey(rpdb))
        db_count++;
#endif

    MY_DBM_CLOSE(rpdb);

    return(db_count);
#endif /* NO_DIGEST_CACHE */
}

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

void
kalog_Init(void)
{
    OpenLog(AFSDIR_SERVER_KALOGDB_FILEPATH);	/* set up logging */
    SetupLogSignals();
    kalog_db =
	dbm_open(AFSDIR_SERVER_KALOG_FILEPATH, O_WRONLY | O_CREAT,
		 KALOG_DB_MODE);
    if (!kalog_db)
	ViceLog(0, ("Cannot open dbm database - no DB logging possible\n"));
}

	void RawStoreFile::open() {
		if (_dbm != NULL) {
			throw std::runtime_error("Fichier DBM deja ouvert");
		}
		
		const char* filenameStartPt = _filenameStart.c_str();
		_dbm = dbm_open(filenameStartPt, _flags, _mode);
		if (_dbm == NULL) {
			throw std::runtime_error("Erreur a l'ouverture de la base DBM");
		}
	}

/* ARGSUSED */
LDBM
ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
{
	LDBM ldbm;

	LDBM_WLOCK;
	ldbm = dbm_open( name, rw, mode );
	LDBM_WUNLOCK;

	return( ldbm );
}

/* Dbm.open : string -> Sys.open_flag list -> int -> t */
value caml_dbm_open(value vfile, value vflags, value vmode) /* ML */
{
  char *file = String_val(vfile);
  int flags = convert_flag_list(vflags, dbm_open_flags);
  int mode = Int_val(vmode);
  DBM *db = dbm_open(file,flags,mode);

  if (db == NULL) 
    raise_dbm("Can't open file");
  else
    return (alloc_dbm(db));
}

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()
{
	test_data_t items_to_store[ITEMS_USED];
	test_data_t item_retrieved;

	char key_datum;
	
	DBM *dbm_ptr;
	dbm_ptr = dbm_open(TEST_DB_FILE,O_RDWR | O_CREAT,0666);
	menset(items_to_store,'\0',sizeof(items_to_store));


}

/*
 * Create a new dbmgroupfile.  If it exists, truncate it.
 */
DBM* create_dbm_file(char *filename) {
  DBM *db;
  mode_t mode;
  mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
  
  db = dbm_open(filename, O_RDWR | O_CREAT | O_TRUNC, mode);
  if (!db) {
    fprintf(stderr,"Can't create the database %s.\n", filename);
    perror("dbm_open");
    exit(1);
  }
  else fprintf(stderr,"Created the database %s.\n", filename);
  return db;
}