/*
* call-seq:
* GDBM.new(filename, mode = 0666, flags = nil)
*
* Creates a new GDBM instance by opening a gdbm file named _filename_.
* If the file does not exist, a new file with file mode _mode_ will be
* created. _flags_ may be one of the following:
* * *READER* - open as a reader
* * *WRITER* - open as a writer
* * *WRCREAT* - open as a writer; if the database does not exist, create a new one
* * *NEWDB* - open as a writer; overwrite any existing databases
*
* The values *WRITER*, *WRCREAT* and *NEWDB* may be combined with the following
* values by bitwise or:
* * *SYNC* - cause all database operations to be synchronized to the disk
* * *NOLOCK* - do not lock the database file
*
* If no _flags_ are specified, the GDBM object will try to open the database
* file as a writer and will create it if it does not already exist
* (cf. flag <tt>WRCREAT</tt>). If this fails (for instance, if another process
* has already opened the database as a reader), it will try to open the
* database file as a reader (cf. flag <tt>READER</tt>).
*/
static VALUE
fgdbm_initialize(int argc, VALUE *argv, VALUE obj)
{
VALUE file, vmode, vflags;
GDBM_FILE 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 does not exist */
}
else {
mode = NUM2INT(vmode);
}
if (!NIL_P(vflags))
flags = NUM2INT(vflags);
SafeStringValue(file);
if (flags & RUBY_GDBM_RW_BIT) {
flags &= ~RUBY_GDBM_RW_BIT;
dbm = gdbm_open(RSTRING_PTR(file), MY_BLOCK_SIZE,
flags, mode, MY_FATAL_FUNC);
}
else {
dbm = 0;
if (mode >= 0)
dbm = gdbm_open(RSTRING_PTR(file), MY_BLOCK_SIZE,
GDBM_WRCREAT|flags, mode, MY_FATAL_FUNC);
if (!dbm)
dbm = gdbm_open(RSTRING_PTR(file), MY_BLOCK_SIZE,
GDBM_WRITER|flags, 0, MY_FATAL_FUNC);
if (!dbm)
dbm = gdbm_open(RSTRING_PTR(file), MY_BLOCK_SIZE,
GDBM_READER|flags, 0, MY_FATAL_FUNC);
}
if (!dbm) {
if (mode == -1) return Qnil;
if (gdbm_errno == GDBM_FILE_OPEN_ERROR ||
gdbm_errno == GDBM_CANT_BE_READER ||
gdbm_errno == GDBM_CANT_BE_WRITER)
rb_sys_fail(RSTRING_PTR(file));
else
rb_raise(rb_eGDBMError, "%s", gdbm_strerror(gdbm_errno));
}
dbmp = ALLOC(struct dbmdata);
free_dbm(DATA_PTR(obj));
DATA_PTR(obj) = dbmp;
dbmp->di_dbm = dbm;
dbmp->di_size = -1;
return obj;
}
/**
* open the gdbm database
*
* @param pe error buffer
* @param parameters db-specific parameter. In this case,
* the path to use
* @returns DB_E_SUCCESS on success, DB_E_* otherwise.
*/
int db_gdbm_open(char **pe, char *parameters) {
char db_path[PATH_MAX + 1];
int result = DB_E_SUCCESS;
snprintf(db_path,sizeof(db_path),"%s/%s",parameters,"songs.gdb");
// reload = reload ? GDBM_NEWDB : GDBM_WRCREAT;
_gdbm_lock();
_gdbm_songs = gdbm_open(db_path, 0, GDBM_WRCREAT | GDBM_SYNC | GDBM_NOLOCK,
0600,NULL);
if(!_gdbm_songs) {
/* let's try creating it! */
_gdbm_songs = gdbm_open(db_path,0,GDBM_NEWDB | GDBM_SYNC | GDBM_NOLOCK,
0600,NULL);
}
if(!_gdbm_songs) {
DPRINTF(E_FATAL,L_DB,"Could not open songs database (%s): %s\n",
db_path,strerror(errno));
db_get_error(pe,DB_E_DB_ERROR,gdbm_strerror(gdbm_errno));
result = DB_E_DB_ERROR;
}
_gdbm_unlock();
return result;
}
/**
* hcache_gdbm_open - Implements HcacheOps::open()
*/
static void *hcache_gdbm_open(const char *path)
{
int pagesize;
if ((mutt_str_atoi(C_HeaderCachePagesize, &pagesize) < 0) || (pagesize <= 0))
pagesize = 16384;
GDBM_FILE db = gdbm_open((char *) path, pagesize, GDBM_WRCREAT, 00600, NULL);
if (db)
return db;
/* if rw failed try ro */
return gdbm_open((char *) path, pagesize, GDBM_READER, 00600, NULL);
}
int
main(void)
{
GDBM_FILE dbf;
datum key = { "testkey", 8 }; /* key, length */
datum value = { "testvalue", 10 }; /* value, length */
dbf = gdbm_open("/home/suresh/codes/Git/C-codes/src/sys_kernel/testdb", 0, GDBM_NEWDB,0666, 0);
clock_t start, end;
double cpu_time_used;
start = clock();
int i=0;
while(i<1000000){
gdbm_store (dbf, key, value, GDBM_INSERT);
value = gdbm_fetch(dbf, key);
i=i+1;
}
end = clock();
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("%G\n",cpu_time_used );
printf ("%s\n", value.dptr);
free (value.dptr);
gdbm_close (dbf);
return 0;
}
static int
_gdbm_open (mu_dbm_file_t db, int flags, int mode)
{
int f;
struct gdbm_descr *gd;
GDBM_FILE file;
switch (flags)
{
case MU_STREAM_CREAT:
f = GDBM_NEWDB;
break;
case MU_STREAM_READ:
f = GDBM_READER;
break;
case MU_STREAM_RDWR:
f = GDBM_WRCREAT;
break;
default:
return EINVAL;
}
file = gdbm_open (db->db_name, 512, f, mode, NULL);
if (!file)
return MU_ERR_FAILURE;
gd = calloc (1, sizeof (*gd));
gd->file = file;
db->db_descr = gd;
return 0;
}
int system_dbmopen(M2_string filename, M2_bool Mutable) {
int gdbm_handle;
int flags = Mutable ? GDBM_WRCREAT : GDBM_READER;
int mode = 0666;
char *FileName = M2_tocharstar(filename);
GDBM_FILE f = gdbm_open(FileName, 0, flags, mode, NULL);
freemem(FileName);
if (f == NULL) return ERROR;
if (numfiles == 0) {
int i;
numfiles = 10;
gdbm_files = (GDBM_FILE *) getmem(numfiles * sizeof(GDBM_FILE));
for (i=0; i<numfiles; i++) gdbm_files[i] = NULL;
gdbm_handle = 0;
}
else {
for (gdbm_handle=0; TRUE ; gdbm_handle++) {
if (gdbm_handle==numfiles) {
GDBM_FILE *p;
int j;
numfiles *= 2;
p = (GDBM_FILE *) getmem(numfiles * sizeof(GDBM_FILE));
for (j=0; j<gdbm_handle; j++) p[j] = gdbm_files[j];
gdbm_files = p;
for (j=gdbm_handle; j<numfiles; j++) gdbm_files[j] = NULL;
break;
}
else if (gdbm_files[gdbm_handle] == NULL) break;
}
}
gdbm_files[gdbm_handle] = f;
return gdbm_handle;
}
/**
* Create and open a database file to store bookmarks.
*/
void db_init(char* dir) {
char* db_path = (char*) malloc(strlen(dir) + strlen(MANTRA_DB) + 1);
strcpy(db_path, dir);
strcpy(db_path + strlen(dir), MANTRA_DB);
db_path[strlen(dir) + strlen(MANTRA_DB)] = '\0';
db = gdbm_open(db_path, 0, GDBM_WRCREAT, 0644, NULL);
}
pa_database* pa_database_open(const char *fn, bool for_write) {
GDBM_FILE f;
int gdbm_cache_size;
char *path;
pa_assert(fn);
/* We include the host identifier in the file name because gdbm
* files are CPU dependent, and we don't want things to go wrong
* if we are on a multiarch system. */
path = pa_sprintf_malloc("%s."CANONICAL_HOST".gdbm", fn);
errno = 0;
/* We need to set the block size explicitly here, since otherwise
* gdbm takes the native block size of the underlying file system
* which might be incredibly large. */
f = gdbm_open((char*) path, 1024, GDBM_NOLOCK | (for_write ? GDBM_WRCREAT : GDBM_READER), 0644, NULL);
if (f)
pa_log_debug("Opened GDBM database '%s'", path);
pa_xfree(path);
if (!f) {
if (errno == 0)
errno = EIO;
return NULL;
}
/* By default the cache of gdbm is rather large, let's reduce it a bit to save memory */
gdbm_cache_size = 10;
gdbm_setopt(f, GDBM_CACHESIZE, &gdbm_cache_size, sizeof(gdbm_cache_size));
return (pa_database*) f;
}
int check_privileges(SSL *ssl)
{
SSL_SESSION* session;
const unsigned char *sess_id;
int sess_id_len;
GDBM_FILE database;
datum key, data;
int ret = 0;
session = SSL_get_session(ssl);
sess_id = SSL_SESSION_get_id(session, &sess_id_len);
/* check session id in database */
key.dptr = (char *)sess_id;
key.dsize = strlen(key.dptr);
database = gdbm_open(https_d.sess_db_name, 0, GDBM_READER | GDBM_NOMMAP, S_IRWXU, NULL);
data = gdbm_fetch(database, key);
if (data.dptr != NULL) {
if (!strcmp(data.dptr, "ADMIN")) {
ret = ADMIN_PRIV;
} else if (!strcmp(data.dptr, "GUEST")) {
ret = GUEST_PRIV;
}
}
gdbm_close(database);
printf("session id: %s", sess_id);
return ret;
}
void save_session(SSL *ssl, int privilege)
{
SSL_SESSION* session;
const unsigned char *sess_id;
int sess_id_len;
GDBM_FILE database;
datum key, data;
session = SSL_get_session(ssl);
sess_id = SSL_SESSION_get_id(session, &sess_id_len);
/* write session to dbm */
key.dptr = (char *)sess_id;
key.dsize = strlen(key.dptr);
database = gdbm_open(https_d.sess_db_name, 0, GDBM_WRITER | GDBM_NOMMAP , S_IRWXU, NULL);
switch (privilege) {
case ADMIN_PRIV:
data.dptr = "ADMIN";
data.dsize = strlen(data.dptr);
gdbm_store(database, key, data, GDBM_REPLACE);
break;
case GUEST_PRIV:
data.dptr = "GUEST";
data.dsize = strlen(data.dptr);
gdbm_store(database, key, data, GDBM_REPLACE);
break;
}
gdbm_close(database);
printf("session id: %s", sess_id);
}
/* 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 */
}
static void _hcache_validate_init(struct hcache *cache) {
char *vfname;
if (cache->validated) return;
vfname = mystrcat(cache->path,".validate");
cache->validated = gdbm_open(vfname,0, GDBM_NEWDB, 0666,NULL);
if (!cache->validated)
fatal(gdbm_errno,"gdbmopen(%s): %s", vfname, gdbm_strerror(gdbm_errno));
free(vfname);
}
static int
hcache_open_gdbm (struct header_cache* h, const char* path)
{
int pagesize;
if (mutt_atoi (HeaderCachePageSize, &pagesize) < 0 || pagesize <= 0)
pagesize = 16384;
h->db = gdbm_open((char *) path, pagesize, GDBM_WRCREAT, 00600, NULL);
if (h->db)
return 0;
/* if rw failed try ro */
h->db = gdbm_open((char *) path, pagesize, GDBM_READER, 00600, NULL);
if (h->db)
return 0;
return -1;
}
/** Maze z databaze informace o souboru.
*
* Presahne-li pocet smazanych polozek MAX_DELETED_ITEMS, reorganizuje
* databazi.
*
* Navratove hodnoty:
*
* - 1 vse OK.
* - -1 chyba pri vytvareni klice k souboru
* - -2 chyba pri zamykani/odemykani databaze
* - -3 chyba pri praci s databazi
*
*/
int DirectoryDatabase::DeleteFileInfo(string &name) {
string key;
datum keyd, datad;
int ret;
ret = File2Key(name.c_str(), key);
if (ret != 1) return -1;
keyd.dptr = (char *) key.c_str();
keyd.dsize = key.size();
// --- zacatek KRITICKE SEKCE ---
if (LockDatabase() != 1) return -2;
// otevreme databazi pro zapis
db_file = gdbm_open((char *)db_name.c_str(), GDBM_BLOCK_SIZE, GDBM_WRITER, S_IRUSR | S_IWUSR, 0);
if (db_file == 0) {
#ifdef DD_DEBUG
cout << getpid() << "DD::DFI open gdbm_errno = " << gdbm_errno << " ... " << gdbm_strerror(gdbm_errno) << endl;
#endif
UnlockDatabase();
return -3;
}
if (gdbm_delete(db_file, keyd) != 0) {
#ifdef DD_DEBUG
cout << getpid() << " - Informace o souboru " << name << " nelze z databaze odstranit." << endl;
#endif
gdbm_close(db_file);
UnlockDatabase();
return -3;
} else {
num_of_deleted_items++;
if (num_of_deleted_items >= MAX_DELETED_ITEMS) {
// gdbm samo nezmensi velikost souboru databaze, je potreba ho
// donutit pomoci gdbm_reorganize(), ktere by se nemelo volat moc
// casto
if (gdbm_reorganize(db_file) != 0) {
#ifdef DD_DEBUG
cout << getpid() << " - Nejspis se nepovedla reorganizace databaze ..." << endl;
#endif
}
}
}//else
gdbm_close(db_file);
if (UnlockDatabase() != 1) return -2;
// --- konec KRITICKE SEKCE ---
return 1;
}
void gdb_initial() /* opens gdbm file */
{
if((gdbmfile =
gdbm_open (getresource(resourcetype_filename, GDBMINDEX),
0,GDBM_READER, 0, 0))
== NULL)
{
fprintf(stderr,"Can't open dbm file!\n");
exit(1);
}
}
struct hcache *hcache_new(const char *base,int type,int len) {
struct hcache *cache = (struct hcache *)mymalloc(sizeof(struct hcache));
char *cachefile = mystrcat(base,".hcd");
memset(cache,0,sizeof(struct hcache));
cache->path = cachefile;
cache->dbf = gdbm_open(cachefile,0,GDBM_READER,0666,NULL);
cache->type = type;
cache->hlen = len;
return cache;
}
/**
cht_open:
@to: The message has sent to. It needed by filename.
Open the database.
Warning: Only #cht_add() can call it. You shouldn't call it.
*/
void
cht_open (const char *to)
{
GString *filename=g_string_new ("");
g_string_printf (filename, "%s/chat_with_%s", cht_dir->str, to);
if ((cht_file = gdbm_open(filename->str, -1, GDBM_WRCREAT, 0777, NULL)) == NULL)
{
g_warning (_("Cannot open database"));
success = FALSE;
}
g_string_free (filename, TRUE);
}
int
main(int argc, char *argv[])
{
int c;
GDBM_FILE dbf;
int flags = 0;
while ((c = getopt (argc, argv, "hlv")) != -1)
switch (c)
{
case 'h':
usage (argv[0]);
exit (0);
case 'l':
flags = GDBM_NOLOCK;
break;
case 'v':
version ();
exit (0);
default:
usage (argv[0]);
exit (1);
}
if (argc != 3)
{
usage (argv[0]);
exit (1);
}
dbf = gdbm_open (argv[1], 0, GDBM_READER | flags, 0600, NULL);
if (dbf == NULL)
{
fprintf (stderr, "%s: couldn't open database, %s\n", argv[0],
gdbm_strerror (gdbm_errno));
exit (1);
}
if (gdbm_export (dbf, argv[2], GDBM_WRCREAT | flags, 0600) == -1)
{
fprintf (stderr, "%s: export failed, %s\n",
argv[0], gdbm_strerror (gdbm_errno));
gdbm_close (dbf);
exit (1);
}
gdbm_close (dbf);
exit (0);
}
int main (int /* argc */, char * /* argv */[])
{
dbf = gdbm_open (const_cast<char*>("test.gdbm"), 0, GDBM_WRCREAT, 0666, 0);
if (!dbf)
{
fprintf (stderr, "File either doesn't exist or is not a gdbm file.\n");
return (2);
}
const char *datab[] = {
"key1", "value1",
"key2", "value2",
"key3", "value3",
"key4", "value4",
"key5", "value5",
"key6", "value6",
"key7", "value7",
"key8", "value8",
"key9", "value9",
"key10", "value10",
"key11", "value11",
NULL
};
datum key, data;
for (int i = 0; datab[i]; i += 2)
{
key.dsize = strlen(datab[i]) + 1;
key.dptr = const_cast<char*>(datab[i]);
data.dsize = strlen(datab[i + 1]) + 1;
data.dptr = const_cast<char*>(datab[i + 1]);
gdbm_store(dbf, key, data, GDBM_REPLACE);
}
for (int i = 0; datab[i]; i += 2)
{
key.dsize = strlen(datab[i]);
key.dptr = const_cast<char*>(datab[i]);
data = gdbm_fetch (dbf, key);
if (data.dsize > 0) {
printf ("%s\n", data.dptr);
free (data.dptr);
} else {
printf ("Key %s not found.\n", key.dptr);
}
}
gdbm_close (dbf);
return 0;
}
int main(void)
{
GDBM_FILE dbf;
datum key = { "testkey", 7 };
datum value = { "testvalue", 9 };
printf("Storing key-value pair ...");
dbf = gdbm_open( "test", 0, GDBM_NEWDB, 0644, 0 );
gdbm_store( dbf, key, value, GDBM_INSERT );
gdbm_close( dbf );
printf(" done.\n");
return foo(-3);
}
struct db *
db_open(char *name, const int read)
{
struct db *db = malloc (sizeof *db);
if (NULL == db)
return NULL;
db->dbf = gdbm_open(name, 0, read ? GDBM_NEWDB : GDBM_READER, 0666, NULL);
if (NULL == db->dbf)
{
free (db);
return NULL;
}
return db;
}
static void _hcache_validate_done(struct hcache *cache) {
char *vfname;
if (!cache->validated) return;
gdbm_close(cache->validated);
vfname = mystrcat(cache->path,".validate");
if (cache->dbf) {
gdbm_close(cache->dbf);
unlink(cache->path);
}
if (rename(vfname,cache->path) == -1)
errormsg("rename(%s->%s)",vfname, cache->path);
free(vfname);
cache->validated = NULL;
cache->dbf = gdbm_open(cache->path,0, GDBM_WRITER, 0666,NULL);
}
int
main(int argc, char **argv)
{
GDBM_FILE dbf;
datum key, next, value;
int i;
while ((i = getopt(argc, argv, "py")) != -1) {
switch (i) {
case 'p':
pflag = 1;
break;
case 'y':
yflag = 1;
break;
default:
fprintf(stderr, "Usage: %s [-p] [-y] file [...]\n",
strchr(argv[0], '/') ?
strrchr(argv[0], '/') + 1 : argv[0]);
return 1;
break;
}
}
for (i = optind; i < argc; i++) {
dbf = gdbm_open(argv[i], 0, GDBM_READER, 0600, NULL);
if (dbf == NULL) {
fprintf(stderr, "Error opening `%s': %s\n", argv[i],
gdbm_errno ? gdbm_strerror(gdbm_errno) :
strerror(errno));
return 1;
}
dump_start(argc - optind, argv[i]);
key = gdbm_firstkey(dbf);
while (key.dptr != NULL) {
value = gdbm_fetch(dbf, key);
if (value.dptr != NULL) {
dump_entry(key, value);
free(value.dptr);
}
next = gdbm_nextkey(dbf, key);
free(key.dptr);
key = next;
}
dump_end();
gdbm_close(dbf);
}
return 0;
}
int main(int argc, const char *argv[])
{
int i, seed=0;
int loops = 10000;
int num_entries;
char test_gdbm[] = "test.gdbm";
unlink("test.gdbm");
db = tdb_open("test.tdb", 0, TDB_CLEAR_IF_FIRST,
O_RDWR | O_CREAT | O_TRUNC, 0600);
gdbm = gdbm_open(test_gdbm, 512, GDBM_WRITER|GDBM_NEWDB|GDBM_FAST,
0600, NULL);
if (!db || !gdbm) {
fatal("db open failed");
}
#if 1
srand(seed);
_start_timer();
for (i=0;i<loops;i++) addrec_gdbm();
printf("gdbm got %.2f ops/sec\n", i/_end_timer());
#endif
merge_test();
srand(seed);
_start_timer();
for (i=0;i<loops;i++) addrec_db();
printf("tdb got %.2f ops/sec\n", i/_end_timer());
if (tdb_validate_freelist(db, &num_entries) == -1) {
printf("tdb freelist is corrupt\n");
} else {
printf("tdb freelist is good (%d entries)\n", num_entries);
}
compare_db();
printf("traversed %d records\n", tdb_traverse(db, traverse_fn, NULL));
printf("traversed %d records\n", tdb_traverse(db, traverse_fn, NULL));
tdb_close(db);
gdbm_close(gdbm);
return 0;
}
int main(void)
{
FILE *data_file;
char line[80];
char buffer[80];
GDBM_FILE dbf;
int ret;
datum data;
datum info;
char zip[6];
float lng;
float lat;
if( (data_file = fopen("zip_loc.txt", "r")) == NULL)
{
printf("Error Couldn't open zips data file\n");
exit(1);
}
if( (dbf = gdbm_open("zips_gdbm",1024,GDBM_NEWDB, 0755, 0)) == NULL)
{
fprintf(stderr, "Error: Couldn't open GDBM out file.");
exit(1);
}
while(!feof(data_file))
{
fgets(line,80,data_file);
sscanf(line,"%s %f %f", &zip, &lng, &lat);
data.dptr = zip;
data.dsize = 5;
sprintf(buffer,"%f %f", lng, lat);
info.dptr = buffer;
info.dsize = 80;
gdbm_store(dbf,data,info,GDBM_INSERT);
}
fclose(data_file);
gdbm_close(dbf);
printf("GDBM Database Created.\n");
exit(0);
}
/* perform read command */
int doread(char *name, int rnum){
GDBM_FILE dbf;
datum key, content;
int i, err, optval, len;
char buf[RECBUFSIZ];
if(showprgr) printf("<Reading Test>\n name=%s rnum=%d\n\n", name, rnum);
/* open a database */
if(!(dbf = gdbm_open(name, 0, GDBM_READER, 00644, NULL))){
fprintf(stderr, "gdbm_open failed\n");
return 1;
}
optval = CACHESIZE;
if(gdbm_setopt(dbf, GDBM_CACHESIZE, &optval, sizeof(int)) != 0){
fprintf(stderr, "gdbm_setopt failed\n");
gdbm_close(dbf);
return 1;
}
err = FALSE;
/* loop for each record */
for(i = 1; i <= rnum; i++){
/* retrieve a record */
len = sprintf(buf, "%08d", i);
key.dptr = buf;
key.dsize = len;
content = gdbm_fetch(dbf, key);
if(!content.dptr){
fprintf(stderr, "gdbm_fetch failed\n");
err = TRUE;
break;
}
free(content.dptr);
/* print progression */
if(showprgr && rnum > 250 && i % (rnum / 250) == 0){
putchar('.');
fflush(stdout);
if(i == rnum || i % (rnum / 10) == 0){
printf(" (%08d)\n", i);
fflush(stdout);
}
}
}
/* close the database */
gdbm_close(dbf);
if(showprgr && !err) printf("ok\n\n");
return err ? 1 : 0;
}
/*F ret = OpenDataBase(info)
**
** DESCRIPTION
** info: DataBaseInformation
** ret: SYSTEM_NORMAL_RETURN, SYSTEM_ERROR_RETURN
**
** This opens the database on disc with the name:
** - directory: info->Directory
** - rootname: info->RootName
** - suffix: ".dbf"
**
** REMARKS
**
** REFERENCES
**
** SEE ALSO
** gdbm_open
**
** HEADERFILE
**
*/
extern INT OpenDataBase(DataBaseInformation *info)
{
GDBM_FILE dbf;
CHAR *filename;
filename = ProduceFileName(info->Directory, info->FilenameRoot, "dbf");
dbf = gdbm_open(filename,0,GDBM_WRCREAT,0666,0);
info->File = (VOID) dbf;
Free(filename);
if(dbf == 0)
return(SYSTEM_ERROR_RETURN);
else
return(SYSTEM_NORMAL_RETURN);
}
static apr_status_t vt_gdbm_open(apr_dbm_t **pdb, const char *pathname,
apr_int32_t mode, apr_fileperms_t perm,
apr_pool_t *pool)
{
real_file_t file;
int dbmode;
*pdb = NULL;
switch (mode) {
case APR_DBM_READONLY:
dbmode = APR_DBM_DBMODE_RO;
break;
case APR_DBM_READWRITE:
dbmode = APR_DBM_DBMODE_RW;
break;
case APR_DBM_RWCREATE:
dbmode = APR_DBM_DBMODE_RWCREATE;
break;
case APR_DBM_RWTRUNC:
dbmode = APR_DBM_DBMODE_RWTRUNC;
break;
default:
return APR_EINVAL;
}
{
/* Note: stupid cast to get rid of "const" on the pathname */
file = gdbm_open((char *) pathname, 0, dbmode,
apr_posix_perms2mode(perm), NULL);
if (file == NULL)
return APR_EGENERAL; /* ### need a better error */
}
/* we have an open database... return it */
*pdb = apr_pcalloc(pool, sizeof(**pdb));
(*pdb)->pool = pool;
(*pdb)->type = &apr_dbm_type_gdbm;
SET_FILE(*pdb, file);
/* ### register a cleanup to close the DBM? */
return APR_SUCCESS;
}
int listusers(const char *path, listcb_t *cb)
{
GDBM_FILE indb;
datum dkey, nextkey, dvalue;
indb = gdbm_open((char *)path, 0, GDBM_READER, S_IRUSR | S_IWUSR, NULL);
if (!indb) {
fprintf(stderr, "can't open %s\n", path);
return 1;
}
memset(&dkey, 0, sizeof(datum));
dkey = gdbm_firstkey(indb);
while (dkey.dptr != NULL) {
char *authid = dkey.dptr;
char *realm = dkey.dptr+strlen(authid)+1;
char *tmp = realm + strlen(realm)+1;
char mech[1024];
int len = dkey.dsize - (tmp - ((char *)dkey.dptr));
if (len >= (int) sizeof mech) {
fprintf(stderr, "malformed database entry\n");
break;
}
memcpy(mech, tmp, len);
mech[dkey.dsize - (tmp - dkey.dptr)] = '\0';
dvalue = gdbm_fetch(indb, dkey);
if (*authid && dvalue.dptr) {
/* don't check return values */
cb(authid,realm,mech,dvalue.dptr,dvalue.dsize);
}
nextkey=gdbm_nextkey(indb, dkey);
dkey=nextkey;
}
gdbm_close(indb);
return 0;
}
static void
init_gdbm(pt_os_hnd_data_t *info)
{
if (!info->gdbm_filename) {
char *home = getenv("HOME");
if (!home)
return;
info->gdbm_filename = malloc(strlen(home)+strlen(GDBM_FILE)+2);
if (!info->gdbm_filename)
return;
strcpy(info->gdbm_filename, home);
strcat(info->gdbm_filename, "/");
strcat(info->gdbm_filename, GDBM_FILE);
}
info->gdbmf = gdbm_open(info->gdbm_filename, 512, GDBM_WRCREAT, 0600,
NULL);
/* gdbmf will be NULL on error, which is what reports an error. */
}
