static rlm_rcode_t add_defaults(rlm_counter_t *inst) { datum key_datum; datum time_datum; static char const *default1 = "DEFAULT1"; static char const *default2 = "DEFAULT2"; DEBUG2("rlm_counter: add_defaults: Start"); memcpy(&key_datum.dptr, &default1, sizeof(key_datum.dptr)); key_datum.dsize = strlen(key_datum.dptr); time_datum.dptr = (char *) &inst->reset_time; time_datum.dsize = sizeof(time_t); if (gdbm_store(inst->gdbm, key_datum, time_datum, GDBM_REPLACE) < 0) { ERROR("rlm_counter: Failed storing data to %s: %s", inst->filename, gdbm_strerror(gdbm_errno)); return RLM_MODULE_FAIL; } DEBUG2("rlm_counter: DEFAULT1 set to %u", (unsigned int) inst->reset_time); memcpy(&key_datum.dptr, &default2, sizeof(key_datum.dptr)); key_datum.dsize = strlen(key_datum.dptr); key_datum.dsize = strlen(default2); time_datum.dptr = (char *) &inst->last_reset; time_datum.dsize = sizeof(time_t); if (gdbm_store(inst->gdbm, key_datum, time_datum, GDBM_REPLACE) < 0) { ERROR("rlm_counter: Failed storing data to %s: %s", inst->filename, gdbm_strerror(gdbm_errno)); return RLM_MODULE_FAIL; } DEBUG2("rlm_counter: DEFAULT2 set to %u", (unsigned int) inst->last_reset); DEBUG2("rlm_counter: add_defaults: End"); return RLM_MODULE_OK; }
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); }
/** Pomocna funkce, vytiskne obsah databaze na stdout. * */ void DirectoryDatabase::PrintContent() { datum keyd; datum nextkeyd; datum datad; FileInfoGdbmRecord record; keyd = gdbm_firstkey(db_file); while (keyd.dptr) { datad = gdbm_fetch(db_file, keyd); if (datad.dptr == 0) { #ifdef DD_DEBUG cout << getpid() << " - soubor nebyl v databazi nalezen. "; cout << "gdbm_errno = " << gdbm_errno << " ... " << gdbm_strerror(gdbm_errno) << endl; #endif } nextkeyd = gdbm_nextkey(db_file, keyd); memcpy(&record, datad.dptr, datad.dsize); free(datad.dptr); // nutne uvolnit misto na ktere ukazuje datad.dptr --> gdbm to samo neudela!!! #ifdef DD_DEBUG cout << record.name << " user = "******" user_rights = " << record.user_rights << endl; #endif free(keyd.dptr); keyd = nextkeyd; } }
/* * 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; }
void gdbm_perror (const char *fmt, ...) { va_list ap; va_start (ap, fmt); prerror (fmt, ap, gdbm_strerror (gdbm_errno)); va_end (ap); }
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); }
/** 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; }
int main(int argc, char *argv[]) { GDBM_FILE gdbm_file; datum key_data, data_data; if(argc != 4) { usage(argv[0]); } if((strlen(argv[1]) != 17) || (argv[1][2] != ':') || (argv[1][5] != ':') || (argv[1][8] != ':') || (argv[1][11] != ':') || (argv[1][14] != ':')) { printf("Wrong MAC Address format. Example: 08:00:09:B4:AA:81\n"); exit(-1); } gdbm_file = gdbm_open (argv[3], 0, GDBM_WRCREAT, 00664, NULL); if(gdbm_file == NULL) { printf("Database open failed: %s\n", gdbm_strerror(gdbm_errno)); exit(-1); } key_data.dptr = argv[1]; key_data.dsize = strlen(key_data.dptr)+1; data_data.dptr = argv[2]; data_data.dsize = strlen(data_data.dptr)+1; if(gdbm_store(gdbm_file, key_data, data_data, GDBM_REPLACE) != 0) printf("Error while adding data: %s\n", gdbm_strerror(gdbm_errno)); gdbm_close(gdbm_file); return(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; }
static PyObject * _gdbm_gdbm_reorganize_impl(dbmobject *self) /*[clinic end generated code: output=38d9624df92e961d input=f6bea85bcfd40dd2]*/ { check_dbmobject_open(self); errno = 0; if (gdbm_reorganize(self->di_dbm) < 0) { if (errno != 0) PyErr_SetFromErrno(DbmError); else PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno)); return NULL; } Py_INCREF(Py_None); return Py_None; }
void hcache_put(struct hcache *cache, struct stat *st,char *hash) { datum key, datum; //ckpt(); _hcache_validate_done(cache); key = _hcache_genkey(cache,st); //ckptm(">>"); //printhex(stderr,key.dptr,key.dsize,0); //ckptm("\n"); datum.dptr = hash; datum.dsize = cache->hlen; //ckpt(); //ckptm("hash=%s, len=%d\n",hash,cache->hlen); if (gdbm_store(cache->dbf,key,datum,GDBM_REPLACE) == -1) fatal(gdbm_errno,"gdbm_store %s", gdbm_strerror(gdbm_errno)); //ckpt(); free(key.dptr); //ckpt(); }
static apr_status_t set_error(apr_dbm_t *dbm, apr_status_t dbm_said) { apr_status_t rv = APR_SUCCESS; /* ### ignore whatever the DBM said (dbm_said); ask it explicitly */ if ((dbm->errcode = gdbm_errno) == GDBM_NO_ERROR) { dbm->errmsg = NULL; } else { dbm->errmsg = gdbm_strerror(gdbm_errno); rv = APR_EGENERAL; /* ### need something better */ } /* captured it. clear it now. */ gdbm_errno = GDBM_NO_ERROR; return rv; }
void hcache_validate(struct hcache *cache, struct stat *st) { datum key, datum; //ckpt(0); _hcache_validate_init(cache); if (!cache->dbf) return; //ckpt(0); key = _hcache_genkey(cache,st); //ckpt(0); datum = gdbm_fetch(cache->dbf, key); //ckpt(0); if (datum.dptr == NULL) { free(key.dptr); return; } if (gdbm_store(cache->validated, key, datum, GDBM_INSERT) == -1) fatal(gdbm_errno,"gdbm_store %s", gdbm_strerror(gdbm_errno)); //ckpt(0); free(datum.dptr); free(key.dptr); }
static PyObject * newdbmobject(char *file, int flags, int mode) { dbmobject *dp; dp = PyObject_New(dbmobject, &Dbmtype); if (dp == NULL) return NULL; dp->di_size = -1; errno = 0; if ((dp->di_dbm = gdbm_open(file, 0, flags, mode, NULL)) == 0) { if (errno != 0) PyErr_SetFromErrno(DbmError); else PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno)); Py_DECREF(dp); return NULL; } return (PyObject *)dp; }
static int dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w) { datum krec, drec; if (!PyArg_Parse(v, "s#", &krec.dptr, &krec.dsize) ) { PyErr_SetString(PyExc_TypeError, "gdbm mappings have string indices only"); return -1; } if (dp->di_dbm == NULL) { PyErr_SetString(DbmError, "GDBM object has already been closed"); return -1; } dp->di_size = -1; if (w == NULL) { if (gdbm_delete(dp->di_dbm, krec) < 0) { PyErr_SetString(PyExc_KeyError, PyString_AS_STRING((PyStringObject *)v)); return -1; } } else { if (!PyArg_Parse(w, "s#", &drec.dptr, &drec.dsize)) { PyErr_SetString(PyExc_TypeError, "gdbm mappings have string elements only"); return -1; } errno = 0; if (gdbm_store(dp->di_dbm, krec, drec, GDBM_REPLACE) < 0) { if (errno != 0) PyErr_SetFromErrno(DbmError); else PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno)); return -1; } } return 0; }
/* * Write accounting information to this modules database. */ static rlm_rcode_t CC_HINT(nonnull) mod_accounting(void *instance, REQUEST *request) { rlm_counter_t *inst = instance; datum key_datum; datum count_datum; VALUE_PAIR *key_vp, *count_vp, *proto_vp, *uniqueid_vp; rad_counter counter; rlm_rcode_t rcode; int ret; int acctstatustype = 0; time_t diff; if ((key_vp = pairfind(request->packet->vps, PW_ACCT_STATUS_TYPE, 0, TAG_ANY)) != NULL) acctstatustype = key_vp->vp_integer; else { DEBUG("rlm_counter: Could not find account status type in packet"); return RLM_MODULE_NOOP; } if (acctstatustype != PW_STATUS_STOP) { DEBUG("rlm_counter: We only run on Accounting-Stop packets"); return RLM_MODULE_NOOP; } uniqueid_vp = pairfind(request->packet->vps, PW_ACCT_UNIQUE_SESSION_ID, 0, TAG_ANY); if (uniqueid_vp != NULL) DEBUG("rlm_counter: Packet Unique ID = '%s'",uniqueid_vp->vp_strvalue); /* * Before doing anything else, see if we have to reset * the counters. */ if (inst->reset_time && (inst->reset_time <= request->timestamp)) { DEBUG("rlm_counter: Time to reset the database"); inst->last_reset = inst->reset_time; find_next_reset(inst,request->timestamp); pthread_mutex_lock(&inst->mutex); rcode = reset_db(inst); pthread_mutex_unlock(&inst->mutex); if (rcode != RLM_MODULE_OK) return rcode; } /* * Check if we need to watch out for a specific service-type. If yes then check it */ if (inst->service_type != NULL) { if ((proto_vp = pairfind(request->packet->vps, PW_SERVICE_TYPE, 0, TAG_ANY)) == NULL) { DEBUG("rlm_counter: Could not find Service-Type attribute in the request. Returning NOOP"); return RLM_MODULE_NOOP; } if ((unsigned)proto_vp->vp_integer != inst->service_val) { DEBUG("rlm_counter: This Service-Type is not allowed. Returning NOOP"); return RLM_MODULE_NOOP; } } /* * Check if request->timestamp - {Acct-Delay-Time} < last_reset * If yes reject the packet since it is very old */ key_vp = pairfind(request->packet->vps, PW_ACCT_DELAY_TIME, 0, TAG_ANY); if (key_vp != NULL) { if ((key_vp->vp_integer != 0) && (request->timestamp - (time_t) key_vp->vp_integer) < inst->last_reset) { DEBUG("rlm_counter: This packet is too old. Returning NOOP"); return RLM_MODULE_NOOP; } } /* * Look for the key. User-Name is special. It means * The REAL username, after stripping. */ key_vp = (inst->key_attr->attr == PW_USER_NAME) ? request->username : pair_find_by_da(request->packet->vps, inst->key_attr, TAG_ANY); if (!key_vp) { DEBUG("rlm_counter: Could not find the key-attribute in the request. Returning NOOP"); return RLM_MODULE_NOOP; } /* * Look for the attribute to use as a counter. */ count_vp = pair_find_by_da(request->packet->vps, inst->count_attr, TAG_ANY); if (!count_vp) { DEBUG("rlm_counter: Could not find the count_attribute in the request"); return RLM_MODULE_NOOP; } ASSIGN(key_datum.dptr, key_vp->vp_strvalue); key_datum.dsize = key_vp->length; DEBUG("rlm_counter: Searching the database for key '%s'",key_vp->vp_strvalue); pthread_mutex_lock(&inst->mutex); count_datum = gdbm_fetch(inst->gdbm, key_datum); if (!count_datum.dptr) { DEBUG("rlm_counter: Could not find the requested key in the database"); counter.user_counter = 0; if (uniqueid_vp != NULL) strlcpy(counter.uniqueid,uniqueid_vp->vp_strvalue, sizeof(counter.uniqueid)); else memset((char *)counter.uniqueid,0,UNIQUEID_MAX_LEN); } else { DEBUG("rlm_counter: Key found"); memcpy(&counter, count_datum.dptr, sizeof(rad_counter)); free(count_datum.dptr); DEBUG("rlm_counter: Counter Unique ID = '%s'",counter.uniqueid); if (uniqueid_vp != NULL) { if (strncmp(uniqueid_vp->vp_strvalue,counter.uniqueid, UNIQUEID_MAX_LEN - 1) == 0) { DEBUG("rlm_counter: Unique IDs for user match. Droping the request"); pthread_mutex_unlock(&inst->mutex); return RLM_MODULE_NOOP; } strlcpy(counter.uniqueid,uniqueid_vp->vp_strvalue, sizeof(counter.uniqueid)); } DEBUG("rlm_counter: User=%s, Counter=%d.",request->username->vp_strvalue,counter.user_counter); } if (inst->count_attr->attr == PW_ACCT_SESSION_TIME) { /* * If session time < diff then the user got in after the * last reset. So add his session time, otherwise add the * diff. * * That way if he logged in at 23:00 and we reset the * daily counter at 24:00 and he logged out at 01:00 * then we will only count one hour (the one in the new * day). That is the right thing */ diff = request->timestamp - inst->last_reset; counter.user_counter += ((time_t) count_vp->vp_integer < diff) ? count_vp->vp_integer : diff; } else if (count_vp->da->type == PW_TYPE_INTEGER) { /* * Integers get counted, without worrying about * reset dates. */ counter.user_counter += count_vp->vp_integer; } else { /* * The attribute is NOT an integer, just count once * more that we've seen it. */ counter.user_counter++; } DEBUG("rlm_counter: User=%s, New Counter=%d.",request->username->vp_strvalue,counter.user_counter); count_datum.dptr = (char *) &counter; count_datum.dsize = sizeof(rad_counter); DEBUG("rlm_counter: Storing new value in database"); ret = gdbm_store(inst->gdbm, key_datum, count_datum, GDBM_REPLACE); pthread_mutex_unlock(&inst->mutex); if (ret < 0) { ERROR("rlm_counter: Failed storing data to %s: %s", inst->filename, gdbm_strerror(gdbm_errno)); return RLM_MODULE_FAIL; } DEBUG("rlm_counter: New value stored successfully"); return RLM_MODULE_OK; }
/** Uklada do databaze informace o souboru. * * K vytvoreni klice pouziva File2Key. * * 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::PutFileInfo(FileInfo &file) { string key; datum keyd, datad; FileInfoGdbmRecord file_record; //data, ktera budou ulozena do databaze int store_err; int open_err; int ret; ret = File2Key(file.name.c_str(), key); if (ret != 1) return -1; keyd.dptr = (char *)key.c_str(); keyd.dsize = key.size(); file_record = (FileInfoGdbmRecord) file; //pretypujeme FileInfo na nas zaznam datad.dptr = (char *)&file_record; datad.dsize = sizeof(struct FileInfoGdbmRecord); #ifdef DD_DEBUG cout << getpid() << " - DD::PutFileInfo ... storing " << file_record.name << " juzra: " << file_record.user_name << " with i-node# " << key << " user_rights = " << file_record.user_rights << " in da dejtabejz" << endl; #endif // --- 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) { //nastala chyba #ifdef DD_DEBUG cout << getpid() << "DD::PFI open gdbm_errno = " << gdbm_errno << " ... " << gdbm_strerror(gdbm_errno) << endl; #endif UnlockDatabase(); return -3; } //ulozime data int err = gdbm_store(db_file, keyd, datad, GDBM_REPLACE); if (err != 0) { #ifdef DD_DEBUG cout << getpid() << "DD::PFI store gdbm_errno = " << gdbm_errno << " ... " << gdbm_strerror(gdbm_errno) << endl; #endif gdbm_close(db_file); //musime, viz komentar niz UnlockDatabase(); return -3; } //databazi zase musime zavrit!!! aby ostatni procesy mohly cist a //zapisovat !!! gdbm_close(db_file); ret = UnlockDatabase(); if (ret != 1){ return -2; } // --- konec KRITICKE SEKCE --- #ifdef DD_DEBUG cout << getpid() << " - DD::PutFileInfo ... stored" << endl; #endif return 1; }
int main(int argc, char **argv) { GDBM_FILE db; char *dbfile = "sift.db"; int dbflags = 0; char *index_dir = 0; char *exec = 0; int dump = 0; struct option long_options[] = { {"index",required_argument, 0, 'i'}, {"clean",no_argument, &dbflags, GDBM_NEWDB}, {"db", required_argument, 0, 'b'}, {"exec", required_argument, 0, 'e'}, {"dump", no_argument, &dump, 1}, {"help", no_argument, 0, 'h'}, {"verbose",no_argument, &verbose, 1}, {0, 0, 0, 0} }; while(1) { int option_index = 0; int c = getopt_long(argc, argv, "", long_options, &option_index); if(c == -1) break; switch (c) { case 'i': index_dir = optarg; break; case 'b': dbfile = optarg; break; case 'e': exec = optarg; break; case 'h': print_usage(stderr); return 0; case 0: // Flags break; default: return 1; } } if(index_dir) { db = gdbm_open(dbfile, 1024, GDBM_WRCREAT|dbflags, 0644, 0); if(!db) { fprintf(stderr, "Can't open '%s': %s\n", dbfile, gdbm_strerror(gdbm_errno)); return 1; } fprintf(stderr, "Indexing '%s'\n", index_dir); update_index(index_dir, db); gdbm_close(db); } // Subsequent operations require no write access db = gdbm_open(dbfile, 1024, GDBM_READER, 0, 0); if(!db) { fprintf(stderr, "Can't open '%s': %s\n", dbfile, gdbm_strerror(gdbm_errno)); return 1; } if(dump) { // This functionality doesn't seem to be available easily // using gdbmtool or similar thus I added it here datum key = gdbm_firstkey(db); while(key.dptr) { datum nextkey = gdbm_nextkey(db, key); puts(key.dptr); free(key.dptr); key = nextkey; } gdbm_close(db); return 0; } // At least space for argv[0] and terminating NUL char **exec_files = malloc(2*sizeof(char*)); int num_exec_files = 1; exec_files[0] = exec; for(int i = optind; i < argc; i++) { struct match *matches; int num_matches = 0; fprintf(stderr, "Matching '%s'...\n", argv[i]); match_file(argv[i], db, &matches, &num_matches); num_exec_files += num_matches; exec_files = realloc(exec_files, (num_exec_files+1)*sizeof(char*)); match_sort(matches, num_matches); for(int j = 0; j < num_matches; j++) { exec_files[num_exec_files - num_matches + j] = matches[j].file; if(!isatty(STDOUT_FILENO)) puts(matches[j].file); } free(matches); } if(exec) { if(verbose) { for(int i = 0; i < num_exec_files; i++) fprintf(stderr, "%s ", exec_files[i]); putc('\n', stderr); } gdbm_close(db); // terminate array with NUL exec_files[num_exec_files] = 0; execvp(exec, exec_files); } for(int i = 0; i < num_exec_files; i++) free(exec_files[i]); free(exec_files); gdbm_close(db); return 0; }
/* * execute the 'index' function */ int sblib_func_exec(int index, int param_count, slib_par_t *params, var_t *retval) { int success = 0; switch ( index ) { case 0: // handle <- GDBM_OPEN(file[, block_size, flags, mode]) { char *file; int bsize, flags, mode; success = mod_parstr_ptr(0, params, param_count, &file); success = mod_opt_parint(1, params, param_count, &bsize, 0); success = mod_opt_parint(2, params, param_count, &flags, GDBM_WRCREAT); success = mod_opt_parint(3, params, param_count, &mode, 0666); if ( success ) { int handle; handle = get_free_handle(); if ( handle >= 0 ) { table[handle].dbf = gdbm_open(file, bsize, flags, mode, NULL); success = (table[handle].dbf != NULL); if ( success ) v_setint(retval, handle); else v_setstr(retval, gdbm_strerror(gdbm_errno)); } else { success = 0; v_setstr(retval, "GDBM_OPEN: NO FREE HANDLES"); } } else v_setstr(retval, "GDBM_OPEN: argument error"); } break; case 1: // handle <- GDBM_STORE(handle, key, data [, flags]) { int handle, flags; char *key, *data; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); success = mod_parstr_ptr(2, params, param_count, &data); success = mod_opt_parint(3, params, param_count, &flags, GDBM_REPLACE); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key, dt_data; int r; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; dt_data.dptr = data; dt_data.dsize = strlen(data) + 1; r = gdbm_store(table[handle].dbf, dt_key, dt_data, flags); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_STORE: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_STORE: argument error"); } break; case 2: // data <- GDBM_FETCH(handle, key) { int handle; char *key; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key, dt_data; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; dt_data = gdbm_fetch(table[handle].dbf, dt_key); v_setstr(retval, (char *) dt_data.dptr); success = 1; } else { success = 0; v_setstr(retval, "GDBM_FETCH: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_FETCH: argument error"); } break; case 3: // status <- GDBM_DELETE(handle, key) { int handle; char *key; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key; int r; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; r = gdbm_delete(table[handle].dbf, dt_key); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_DELETE: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_DELETE: argument error"); } break; case 4: // key <- GDBM_FIRSTKEY(handle) { int handle; success = mod_parint (0, params, param_count, &handle); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key; dt_key = gdbm_firstkey(table[handle].dbf); v_setstr(retval, (char *) dt_key.dptr); success = 1; } else { success = 0; v_setstr(retval, "GDBM_FIRSTKEY: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_FIRSTKEY: argument error"); } break; case 5: // key <- GDBM_NEXTKEY(handle, key) { int handle; char *key; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; dt_key = gdbm_nextkey(table[handle].dbf, dt_key); v_setstr(retval, (char *) dt_key.dptr); success = 1; } else { success = 0; v_setstr(retval, "GDBM_NEXTKEY: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_NEXTKEY: argument error"); } break; case 6: // status <- GDBM_REORGANIZE(handle) { int handle; success = mod_parint (0, params, param_count, &handle); if ( success ) { if ( is_valid_handle(handle) ) { int r; r = gdbm_reorganize(table[handle].dbf); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_REORGANIZE: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_REORGANIZE: argument error"); } break; case 7: // status <- GDBM_EXISTS(handle, key) { int handle; char *key; success = mod_parint (0, params, param_count, &handle); success = mod_parstr_ptr(1, params, param_count, &key); if ( success ) { if ( is_valid_handle(handle) ) { datum dt_key; int r; dt_key.dptr = key; dt_key.dsize = strlen(key) + 1; r = gdbm_exists(table[handle].dbf, dt_key); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_EXISTS: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_EXISTS: argument error"); } break; case 8: // str <- GDBM_STRERROR() v_setstr(retval, gdbm_strerror(gdbm_errno)); break; case 9: // status <- GDBM_SETOPT(handle, option, value, size) { int handle, option, value, size; success = mod_parint (0, params, param_count, &handle); success = mod_parint (1, params, param_count, &option); success = mod_parint (2, params, param_count, &value); success = mod_parint (3, params, param_count, &size); if ( success ) { if ( is_valid_handle(handle) ) { int r; r = gdbm_setopt(table[handle].dbf, option, &value, size); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_SETOPT: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_SETOPT: argument error"); } break; case 10: // status <- GDBM_FDESC(handle) { int handle; success = mod_parint (0, params, param_count, &handle); if ( success ) { if ( is_valid_handle(handle) ) { int r; r = gdbm_fdesc(table[handle].dbf); v_setint(retval, r); success = 1; } else { success = 0; v_setstr(retval, "GDBM_FDESC: INVALID HANDLE"); } } else v_setstr(retval, "GDBM_FDESC: argument error"); } break; default: v_setstr(retval, "GDBM: function does not exist!"); } return success; }
int gdbm_store (GDBM_FILE dbf, datum key, datum content, int flags) { int new_hash_val; /* The new hash value. */ int elem_loc; /* The location in hash bucket. */ off_t file_adr; /* The address of new space in the file. */ off_t file_pos; /* The position after a lseek. */ off_t free_adr; /* For keeping track of a freed section. */ int free_size; int new_size; /* Used in allocating space. */ char *temp; /* Used in _gdbm_findkey call. */ int rc; /* First check to make sure this guy is a writer. */ if (dbf->read_write == GDBM_READER) { gdbm_errno = GDBM_READER_CANT_STORE; return -1; } /* Check for illegal data values. A NULL dptr field is illegal because NULL dptr returned by a lookup procedure indicates an error. */ if ((key.dptr == NULL) || (content.dptr == NULL)) { gdbm_errno = GDBM_ILLEGAL_DATA; return -1; } /* Initialize the gdbm_errno variable. */ gdbm_errno = GDBM_NO_ERROR; /* Look for the key in the file. A side effect loads the correct bucket and calculates the hash value. */ elem_loc = _gdbm_findkey (dbf, key, &temp, &new_hash_val); /* Initialize these. */ file_adr = 0; new_size = key.dsize + content.dsize; /* Did we find the item? */ if (elem_loc != -1) { if (flags == GDBM_REPLACE) { /* Just replace the data. */ free_adr = dbf->bucket->h_table[elem_loc].data_pointer; free_size = dbf->bucket->h_table[elem_loc].key_size + dbf->bucket->h_table[elem_loc].data_size; if (free_size != new_size) { _gdbm_free (dbf, free_adr, free_size); } else { /* Just reuse the same address! */ file_adr = free_adr; } } else { gdbm_errno = GDBM_CANNOT_REPLACE; return 1; } } /* Get the file address for the new space. (Current bucket's free space is first place to look.) */ if (file_adr == 0) file_adr = _gdbm_alloc (dbf, new_size); /* If this is a new entry in the bucket, we need to do special things. */ if (elem_loc == -1) { if (dbf->bucket->count == dbf->header->bucket_elems) { /* Split the current bucket. */ _gdbm_split_bucket (dbf, new_hash_val); } /* Find space to insert into bucket and set elem_loc to that place. */ elem_loc = new_hash_val % dbf->header->bucket_elems; while (dbf->bucket->h_table[elem_loc].hash_value != -1) elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; /* We now have another element in the bucket. Add the new information.*/ dbf->bucket->count++; dbf->bucket->h_table[elem_loc].hash_value = new_hash_val; memcpy (dbf->bucket->h_table[elem_loc].key_start, key.dptr, (SMALL < key.dsize ? SMALL : key.dsize)); } /* Update current bucket data pointer and sizes. */ dbf->bucket->h_table[elem_loc].data_pointer = file_adr; dbf->bucket->h_table[elem_loc].key_size = key.dsize; dbf->bucket->h_table[elem_loc].data_size = content.dsize; /* Write the data to the file. */ file_pos = __lseek (dbf, file_adr, SEEK_SET); if (file_pos != file_adr) _gdbm_fatal (dbf, _("lseek error")); rc = _gdbm_full_write (dbf, key.dptr, key.dsize); if (rc) _gdbm_fatal (dbf, gdbm_strerror (rc)); rc = _gdbm_full_write (dbf, content.dptr, content.dsize); if (rc) _gdbm_fatal (dbf, gdbm_strerror (rc)); /* Current bucket has changed. */ dbf->cache_entry->ca_changed = TRUE; dbf->bucket_changed = TRUE; /* Write everything that is needed to the disk. */ _gdbm_end_update (dbf); return 0; }
/* * Cache the reply items and the Auth-Type */ static int caching_postauth(void *instance, REQUEST *request) { rlm_caching_t *data = (rlm_caching_t *)instance; char key[MAX_STRING_LEN]; datum key_datum; datum data_datum; VALUE_PAIR *reply_vp; VALUE_PAIR *auth_type; rlm_caching_data cache_data; int count = 0; int ret = 0; int size = 0; int rcode = 0; if (pairfind(request->packet->vps, PW_CACHE_NO_CACHING, 0) != NULL){ DEBUG("rlm_caching: Cache-No-Caching is set. Returning NOOP"); return RLM_MODULE_NOOP; } if ((auth_type = pairfind(request->config_items, PW_AUTH_TYPE, 0)) != NULL){ DEBUG("rlm_caching: Found Auth-Type, value: '%s'",auth_type->vp_strvalue); if (strcmp(auth_type->vp_strvalue,"Reject") == 0 && data->cache_rejects == 0){ DEBUG("rlm_caching: No caching of Rejects. Returning NOOP"); return RLM_MODULE_NOOP; } if (strlen(auth_type->vp_strvalue) > MAX_AUTH_TYPE - 1){ DEBUG("rlm_caching: Auth-Type value too large"); return RLM_MODULE_NOOP; } } else{ DEBUG("rlm_caching: No Auth-Type found. Returning NOOP"); return RLM_MODULE_NOOP; } reply_vp = request->reply->vps; if (reply_vp == NULL) { DEBUG("rlm_caching: The Request does not contain any reply attributes"); return RLM_MODULE_NOOP; } if (!radius_xlat(key,sizeof(key), data->key, request, NULL)){ radlog(L_ERR, "rlm_caching: xlat on key '%s' failed.",data->key); return RLM_MODULE_FAIL; } memset(&cache_data,0,sizeof(rlm_caching_data)); cache_data.creation = time(NULL); strcpy(cache_data.auth_type,auth_type->vp_strvalue); size = MAX_RECORD_LEN; while(reply_vp) { if (size <= 1){ DEBUG("rlm_caching: Not enough space."); return RLM_MODULE_NOOP; } ret = vp_prints(cache_data.data + count,size,reply_vp); if (ret == 0) { DEBUG("rlm_caching: Record is too large, will not store it."); return RLM_MODULE_NOOP; } count += (ret + 1); size -= (ret + 1); DEBUG("rlm_caching: VP=%s,VALUE=%s,length=%d,cache record length=%d, space left=%d", reply_vp->name,reply_vp->vp_strvalue,ret,count,size); reply_vp = reply_vp->next; } cache_data.len = count; DEBUG("rlm_caching: Storing cache for Key='%s'",key); data_datum.dptr = (rlm_caching_data *) &cache_data; data_datum.dsize = sizeof(rlm_caching_data); key_datum.dptr = (char *) key; key_datum.dsize = strlen(key); pthread_mutex_lock(&data->mutex); rcode = gdbm_store(data->gdbm, key_datum, data_datum, GDBM_REPLACE); pthread_mutex_unlock(&data->mutex); if (rcode < 0) { radlog(L_ERR, "rlm_caching: Failed storing data to %s: %s", data->filename, gdbm_strerror(gdbm_errno)); return RLM_MODULE_FAIL; } DEBUG("rlm_caching: New value stored successfully."); return RLM_MODULE_OK; }
int main (int argc, char **argv) { const char *progname = canonical_progname (argv[0]); const char *dbname; int line = 0; char buf[1024]; datum key; datum data; int replace = 0; int flags = 0; int mode = GDBM_WRCREAT; int block_size = 0; GDBM_FILE dbf; int delim = '\t'; int data_z = 0; size_t mapped_size_max = 0; while (--argc) { char *arg = *++argv; if (strcmp (arg, "-h") == 0) { printf ("usage: %s [-replace] [-clear] [-blocksize=N] [-null] [-nolock] [-nommap] [-maxmap=N] [-sync] [-delim=CHR] DBFILE\n", progname); exit (0); } else if (strcmp (arg, "-replace") == 0) replace |= GDBM_REPLACE; else if (strcmp (arg, "-clear") == 0) mode = GDBM_NEWDB; else if (strcmp (arg, "-null") == 0) data_z = 1; else if (strcmp (arg, "-nolock") == 0) flags |= GDBM_NOLOCK; else if (strcmp (arg, "-nommap") == 0) flags |= GDBM_NOMMAP; else if (strcmp (arg, "-sync") == 0) flags |= GDBM_SYNC; else if (strncmp (arg, "-blocksize=", 11) == 0) block_size = atoi (arg + 11); else if (strncmp (arg, "-maxmap=", 8) == 0) { char *p; errno = 0; mapped_size_max = strtoul (arg + 8, &p, 10); if (errno) { fprintf (stderr, "%s: ", progname); perror ("maxmap"); exit (1); } if (*p) { fprintf (stderr, "%s: bad maxmap\n", progname); exit (1); } } else if (strncmp (arg, "-delim=", 7) == 0) delim = arg[7]; else if (strcmp (arg, "--") == 0) { --argc; ++argv; break; } else if (arg[0] == '-') { fprintf (stderr, "%s: unknown option %s\n", progname, arg); exit (1); } else break; } if (argc != 1) { fprintf (stderr, "%s: wrong arguments\n", progname); exit (1); } dbname = *argv; dbf = gdbm_open (dbname, block_size, mode|flags, 00664, NULL); if (!dbf) { fprintf (stderr, "gdbm_open failed: %s\n", gdbm_strerror (gdbm_errno)); exit (1); } if (mapped_size_max) { if (gdbm_setopt (dbf, GDBM_SETMAXMAPSIZE, &mapped_size_max, sizeof (mapped_size_max))) { fprintf (stderr, "gdbm_setopt failed: %s\n", gdbm_strerror (gdbm_errno)); exit (1); } } while (fgets (buf, sizeof buf, stdin)) { size_t i, j; size_t len = strlen (buf); if (buf[len - 1] != '\n') { fprintf (stderr, "%s: %d: line too long\n", progname, line); continue; } buf[--len] = 0; line++; for (i = j = 0; i < len; i++) { if (buf[i] == '\\') i++; else if (buf[i] == delim) break; else buf[j++] = buf[i]; } if (buf[i] != delim) { fprintf (stderr, "%s: %d: malformed line\n", progname, line); continue; } key.dptr = buf; key.dsize = j + data_z; data.dptr = buf + j + 1; data.dsize = strlen (buf + j + 1) + data_z; if (gdbm_store (dbf, key, data, replace) != 0) { fprintf (stderr, "%s: %d: item not inserted\n", progname, line); exit (1); } } gdbm_close (dbf); exit (0); }
static char const * _gdbm_strerror (mu_dbm_file_t db) { return gdbm_strerror (db->db_errno.n); }
/** Ziska z databaze informace o zadanem souboru. * * Navratove hodnoty: * * - 1 vse OK. * - -1 chyba pri vytvareni klice k souboru * - -3 chyba pri praci s databazi * */ int DirectoryDatabase::GetFileInfo(string name, FileInfo &info) { 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 cteni db_file = gdbm_open((char *)db_name.c_str(), GDBM_BLOCK_SIZE, GDBM_READER, S_IRUSR | S_IWUSR, 0); if (db_file == 0) { //nastala chyba #ifdef DD_DEBUG cout << getpid() << "DD::GFI open gdbm_errno = " << gdbm_errno << " ... " << gdbm_strerror(gdbm_errno) << endl; #endif UnlockDatabase(); return -3; } datad = gdbm_fetch(db_file, keyd); if (datad.dptr == 0) { #ifdef DD_DEBUG cout << getpid() << " - soubor " << name << " nebyl v databazi nalezen. "; cout << "gdbm_errno = " << gdbm_errno << " ... " << gdbm_strerror(gdbm_errno) << endl; #endif gdbm_close(db_file); UnlockDatabase(); return -3; } //databazi zase musime zavrit!!! aby ostatni procesy mohly cist a //zapisovat !!! gdbm_close(db_file); ret = UnlockDatabase(); if (ret != 1){ return -2; } // --- konec KRITICKE SEKCE --- FileInfoGdbmRecord record; memcpy(&record, datad.dptr, datad.dsize); //cout << "get file info: free(datad.dptr)" << endl; free(datad.dptr); // nutne uvolnit misto na ktere ukazuje datad.dptr --> gdbm to samo neudela!!! #ifdef DD_DEBUG cout << getpid() << " - GetFileInfo: ke klici " << key << "jsme dostali informace o " << record.name << endl; #endif FileInfo result; result = record; info = result; return 1; }
M2_string system_dbmstrerror(void) { return M2_tostring(gdbm_strerror(gdbm_errno)); }
int main (int argc, char **argv) { GDBM_FILE dbf = NULL; int rc, opt; char *dbname, *filename; FILE *fp; unsigned long err_line, n; char *end; int oflags = GDBM_NEWDB|GDBM_NOMMAP; int cache_size = 0; int block_size = 0; #ifdef HAVE_SETLOCALE setlocale (LC_ALL, ""); #endif bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); set_progname (argv[0]); for (opt = parseopt_first (argc, argv, optab); opt != EOF; opt = parseopt_next ()) { switch (opt) { case 'b': block_size = get_int (optarg); break; case 'c': cache_size = get_int (optarg); break; case 'm': { errno = 0; n = strtoul (optarg, &end, 8); if (*end == 0 && errno == 0) { mode = n & 0777; meta_mask |= GDBM_META_MASK_MODE; } else { error ("%s", _("invalid octal number")); exit (EXIT_USAGE); } } break; case 'u': { size_t len; struct passwd *pw; len = strcspn (optarg, ".:"); if (optarg[len]) optarg[len++] = 0; pw = getpwnam (optarg); if (pw) owner_uid = pw->pw_uid; else { errno = 0; n = strtoul (optarg, &end, 10); if (*end == 0 && errno == 0) owner_uid = n; else { error (_("invalid user name: %s"), optarg); exit (EXIT_USAGE); } } if (optarg[len]) { char *grname = optarg + len; struct group *gr = getgrnam (grname); if (gr) owner_gid = gr->gr_gid; else { errno = 0; n = strtoul (grname, &end, 10); if (*end == 0 && errno == 0) owner_gid = n; else { error (_("invalid group name: %s"), grname); exit (EXIT_USAGE); } } } else { if (!pw) { pw = getpwuid (owner_uid); if (!pw) { error (_("no such UID: %lu"), (unsigned long)owner_uid); exit (EXIT_USAGE); } } owner_gid = pw->pw_gid; } meta_mask |= GDBM_META_MASK_OWNER; } break; case 'r': replace = 1; break; case 'n': no_meta_option = 1; break; case 'M': oflags &= ~GDBM_NOMMAP; break; default: error (_("unknown option")); exit (EXIT_USAGE); } } argc -= optind; argv += optind; if (argc == 0) { parseopt_print_help (); exit (EXIT_OK); } if (argc > 2) { error (_("too many arguments; try `%s -h' for more info"), progname); exit (EXIT_USAGE); } filename = argv[0]; if (argc == 2) dbname = argv[1]; else dbname = NULL; if (strcmp (filename, "-") == 0) { filename = "<stdin>"; fp = stdin; } else { fp = fopen (filename, "r"); if (!fp) { sys_perror (errno, _("cannot open %s"), filename); exit (EXIT_FATAL); } } if (dbname) { dbf = gdbm_open (dbname, block_size, oflags, 0600, NULL); if (!dbf) { gdbm_perror (_("gdbm_open failed")); exit (EXIT_FATAL); } if (cache_size && gdbm_setopt (dbf, GDBM_SETCACHESIZE, &cache_size, sizeof (int)) == -1) error (_("gdbm_setopt failed: %s"), gdbm_strerror (gdbm_errno)); } rc = gdbm_load_from_file (&dbf, fp, replace, no_meta_option ? (GDBM_META_MASK_MODE | GDBM_META_MASK_OWNER) : meta_mask, &err_line); if (rc) { switch (gdbm_errno) { case GDBM_ERR_FILE_OWNER: case GDBM_ERR_FILE_MODE: error (_("error restoring metadata: %s (%s)"), gdbm_strerror (gdbm_errno), strerror (errno)); rc = EXIT_MILD; break; default: if (err_line) gdbm_perror ("%s:%lu", filename, err_line); else gdbm_perror (_("cannot load from %s"), filename); rc = EXIT_FATAL; } } if (dbf) { if (!no_meta_option && set_meta_info (dbf)) { error (_("error restoring metadata: %s (%s)"), gdbm_strerror (gdbm_errno), strerror (errno)); rc = EXIT_MILD; } if (!dbname) { if (gdbm_setopt (dbf, GDBM_GETDBNAME, &dbname, sizeof (dbname))) gdbm_perror (_("gdbm_setopt failed")); else { printf ("%s: created %s\n", progname, dbname); free (dbname); } } gdbm_close (dbf); } exit (rc); }