Beispiel #1
0
/*
 * 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;
}
Beispiel #3
0
/**
 * 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);
}
Beispiel #4
0
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;
}
Beispiel #5
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;
}
Beispiel #6
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;
     }
Beispiel #7
0
/**
 * 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);
}
Beispiel #8
0
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;
}
Beispiel #9
0
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;
}
Beispiel #10
0
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);
}
Beispiel #11
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 */
}
Beispiel #12
0
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);
}
Beispiel #13
0
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;
}
Beispiel #14
0
/** 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;
}
Beispiel #15
0
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);
            }
      }
Beispiel #16
0
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;
}
Beispiel #17
0
/**
   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);
}
Beispiel #18
0
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);
}
Beispiel #19
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;
}
Beispiel #20
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);
}
Beispiel #21
0
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;
}
Beispiel #22
0
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);
}
Beispiel #23
0
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;
}
Beispiel #24
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;
}
Beispiel #25
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);
}
Beispiel #26
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;
}
Beispiel #27
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);
     }
Beispiel #28
0
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;
}
Beispiel #29
0
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. */
}