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);
}
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;
}
/**
* Create a bookmark entry in the DB.
*/
int add_bookmark(Page* page, char* line, bool update) {
datum key;
datum val;
char* sectpage = (char*) malloc(strlen(page->name) + 3);
sectpage[0] = '0' + page->sect;
sectpage[1] = ':';
strcpy(sectpage + 2, page->name);
sectpage[strlen(page->name) + 3] = '\0';
_datum(&key, sectpage);
_datum(&val, line);
if (gdbm_store(db, key, val, GDBM_INSERT)) {
/* If we couldn't add a record, this may be
* because the key exists. If update requested,
* remove the record and try again.
*/
if (update) {
if (gdbm_store(db, key, val, GDBM_REPLACE))
return -1;
update_bookmark_for_page(page, line);
}
return -1;
}
insert_bookmark(page, line);
return 0;
}
bool
db_insert(struct db *db, uint32_t key, uint32_t value)
{
GDBM_FILE dbf = db->dbf;
datum k = {&key, sizeof key};
int result;
datum data = gdbm_fetch(dbf, k);
if(data.dptr!=NULL){
int size=data.dsize;
if (NULL == (data.dptr = realloc (data.dptr, data.dsize + sizeof value)))
perror("Failed creating inserting key/value pair");
data.dsize += sizeof value;
memcpy (data.dptr+size, &value, sizeof value);
}
else{
data.dptr = &value;
data.dsize = sizeof value;
}
result= gdbm_store(dbf, k, data, GDBM_REPLACE);
if(result==-1)
perror("You tried inserting a key as a reader");
return result == 0;
}
static int
database_store(os_handler_t *handler,
char *key,
unsigned char *data,
unsigned int data_len)
{
pt_os_hnd_data_t *info = handler->internal_data;
datum gkey, gdata;
int rv;
pthread_mutex_lock(&info->gdbm_lock);
if (!info->gdbmf) {
init_gdbm(info);
if (!info->gdbmf) {
pthread_mutex_unlock(&info->gdbm_lock);
return EINVAL;
}
}
gkey.dptr = key;
gkey.dsize = strlen(key);
gdata.dptr = (char *) data;
gdata.dsize = data_len;
rv = gdbm_store(info->gdbmf, gkey, gdata, GDBM_REPLACE);
pthread_mutex_unlock(&info->gdbm_lock);
if (rv)
return EINVAL;
return 0;
}
static void addrec_gdbm(void)
{
int klen, dlen;
char *k, *d;
datum key, data;
klen = 1 + (rand() % 4);
dlen = 1 + (rand() % 100);
k = randbuf(klen);
d = randbuf(dlen);
key.dptr = k;
key.dsize = klen+1;
data.dptr = d;
data.dsize = dlen+1;
if (rand() % DELETE_PROB == 0) {
gdbm_delete(gdbm, key);
} else if (rand() % STORE_PROB == 0) {
if (gdbm_store(gdbm, key, data, GDBM_REPLACE) != 0) {
fatal("gdbm_store failed");
}
} else {
data = gdbm_fetch(gdbm, key);
if (data.dptr) free(data.dptr);
}
free(k);
free(d);
}
int
dbm_store (DBM *dbm, datum key, datum content, int flags)
{
int rc = gdbm_store (dbm->file, key, content, flags);
__gdbm_error_to_ndbm (dbm);
return rc;
}
static int
database_store(os_handler_t *handler,
char *key,
unsigned char *data,
unsigned int data_len)
{
iposix_info_t *info = handler->internal_data;
datum gkey, gdata;
int rv;
if (!info->gdbmf) {
init_gdbm(info);
if (!info->gdbmf)
return EINVAL;
}
gkey.dptr = key;
gkey.dsize = strlen(key);
gdata.dptr = (char *) data;
gdata.dsize = data_len;
rv = gdbm_store(info->gdbmf, gkey, gdata, GDBM_REPLACE);
if (rv)
return EINVAL;
return 0;
}
static int
_gdbm_store (mu_dbm_file_t db,
struct mu_dbm_datum const *key,
struct mu_dbm_datum const *contents,
int replace)
{
struct gdbm_descr *gd = db->db_descr;
datum keydat, condat;
keydat.dptr = key->mu_dptr;
keydat.dsize = key->mu_dsize;
condat.dptr = contents->mu_dptr;
condat.dsize = contents->mu_dsize;
switch (gdbm_store (gd->file, keydat, condat, replace))
{
case 0:
break;
case 1:
return MU_ERR_EXISTS;
case -1:
db->db_errno.n = gdbm_errno;
return MU_ERR_FAILURE;
}
return 0;
}
/**
add_callback_handler:
@s_data: a dbdb pointer.
WARNING!! You should not call this by yourself.
*/
static gpointer /* NULL: successful */
add_callback_handler (void *s_data)
{
struct dbdb *data = (struct dbdb *)s_data;
g_mutex_lock (mutex); /* LOCK!! If this mutex has been lock, wait for unlock */
/* write */
cht_open (data->to);
if (!success)
{
dbg_print("DBG: failed to open chatlog file.");
return (gpointer) !NULL;
}
/* if this key already exist, replace it */
if (gdbm_store (cht_file, data->key, data->context, GDBM_REPLACE))
{
dbg_print ("DBG: failed to save message.");
return (gpointer)!NULL;
}
cht_close (FALSE); /* just kill current action. */
g_mutex_unlock (mutex);
/* free memory, but not useful. */
/*g_mutex_free (mutex);
mutex = NULL;*/
return 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 ClRcT
cdbGDBMRecordReplace(ClDBHandleT dbHandle, /* Handle to the database */
ClDBKeyT dbKey, /* Handle to the key being added */
ClUint32T keySize, /* Size of the key being added */
ClDBRecordT dbRec, /* Handle to the record being added */
ClUint32T recSize) /* Size of the record being added */
{
ClRcT errorCode = CL_OK;
GDBMHandle_t* pGDBMHandle = (GDBMHandle_t*)dbHandle;
ClUint32T returnCode = 0;
datum key = {NULL, 0};
datum data = {NULL, 0};
CL_FUNC_ENTER();
key.dsize = keySize;
key.dptr = (ClCharT *)dbKey;
data.dsize = recSize;
data.dptr = (ClCharT *)dbRec;
/* Replace the record in the database */
returnCode = gdbm_store(pGDBMHandle->gdbmInstance, key, data, GDBM_REPLACE);
if(0 != returnCode) {
/* Some GDBM error occured. return DB error */
errorCode = CL_DBAL_RC(CL_DBAL_ERR_DB_ERROR);
CL_DEBUG_PRINT ( CL_DEBUG_TRACE,("\nGDBM replace failed"));
CL_FUNC_EXIT();
return(errorCode);
}
CL_FUNC_EXIT();
return(CL_OK);
}
/*F ret = StoreGenericElement(link,key,dinfo)
**
** DESCRIPTION
** key: The key
** dinfo: The linked list structure
** link: the link
**
** Writes a generic element to the specified database and returns the
** linked list structure (DbaseLinkedList).
**
** REMARKS
**
** REFERENCES
**
** SEE ALSO
**
** HEADERFILE
**
*/
extern INT WriteGenericElement(DbaseLinkedList *link,
DbaseKeyword *keyword,
INT flag,
DataBaseInformation *info)
{
datum *key, *datset;
INT ret;
key = AllocateDatum;
key->dsize = keyword->Size;
key->dptr = keyword->KeyWord;
datset = MakeDatumElement(link);
ret = gdbm_store((GDBM_FILE) info->File,
*key,
*datset,
(int) flag);
Free(datset->dptr);
Free(datset);
Free(key);
return(ret);
}
int pa_database_set(pa_database *db, const pa_datum *key, const pa_datum* data, bool overwrite) {
datum gdbm_key, gdbm_data;
pa_assert(db);
pa_assert(key);
pa_assert(data);
return gdbm_store(MAKE_GDBM_FILE(db),
*datum_to_gdbm(&gdbm_key, key),
*datum_to_gdbm(&gdbm_data, data),
overwrite ? GDBM_REPLACE : GDBM_INSERT) != 0 ? -1 : 0;
}
int
mutt_hcache_store_raw (header_cache_t* h, const char* filename, void* data,
size_t dlen, size_t(*keylen) (const char* fn))
{
#ifndef HAVE_DB4
char path[_POSIX_PATH_MAX];
int ksize;
#endif
#if HAVE_GDBM
datum key;
datum databuf;
#elif HAVE_DB4
DBT key;
DBT databuf;
#endif
if (!h)
return -1;
#if HAVE_DB4
if (filename[0] == '/')
filename++;
mutt_hcache_dbt_init(&key, (void *) filename, keylen(filename));
mutt_hcache_dbt_empty_init(&databuf);
databuf.flags = DB_DBT_USERMEM;
databuf.data = data;
databuf.size = dlen;
databuf.ulen = dlen;
return h->db->put(h->db, NULL, &key, &databuf, 0);
#else
strncpy(path, h->folder, sizeof (path));
safe_strcat(path, sizeof (path), filename);
ksize = strlen(h->folder) + keylen(path + strlen(h->folder));
#endif
#if HAVE_QDBM
return vlput(h->db, path, ksize, data, dlen, VL_DOVER);
#elif HAVE_TC
return tcbdbput(h->db, path, ksize, data, dlen);
#elif HAVE_GDBM
key.dptr = path;
key.dsize = ksize;
databuf.dsize = dlen;
databuf.dptr = data;
return gdbm_store(h->db, key, databuf, GDBM_REPLACE);
#endif
}
int
ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
{
int rc;
LDBM_WLOCK;
rc = gdbm_store( ldbm, key, data, flags & ~LDBM_SYNC );
if ( flags & LDBM_SYNC )
gdbm_sync( ldbm );
LDBM_WUNLOCK;
return( rc );
}
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;
}
static void
gdbmhashsetfn(Param pm, HashTable ht)
{
int i;
HashNode hn;
GDBM_FILE dbf;
datum key, content;
if (!pm->u.hash || pm->u.hash == ht)
return;
if (!(dbf = (GDBM_FILE)(pm->u.hash->tmpdata)))
return;
key = gdbm_firstkey(dbf);
while (key.dptr) {
queue_signals();
(void)gdbm_delete(dbf, key);
free(key.dptr);
unqueue_signals();
key = gdbm_firstkey(dbf);
}
/* just deleted everything, clean up */
(void)gdbm_reorganize(dbf);
if (!ht)
return;
for (i = 0; i < ht->hsize; i++)
for (hn = ht->nodes[i]; hn; hn = hn->next) {
struct value v;
v.isarr = v.flags = v.start = 0;
v.end = -1;
v.arr = NULL;
v.pm = (Param) hn;
key.dptr = v.pm->node.nam;
key.dsize = strlen(key.dptr) + 1;
queue_signals();
content.dptr = getstrvalue(&v);
content.dsize = strlen(content.dptr) + 1;
(void)gdbm_store(dbf, key, content, GDBM_REPLACE);
unqueue_signals();
}
}
static void
gdbmsetfn(Param pm, char *val)
{
datum key, content;
GDBM_FILE dbf;
key.dptr = pm->node.nam;
key.dsize = strlen(key.dptr) + 1;
content.dptr = val;
content.dsize = strlen(content.dptr) + 1;
dbf = (GDBM_FILE)(pm->u.hash->tmpdata);
(void)gdbm_store(dbf, key, content, GDBM_REPLACE);
}
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);
}
int main(int argc, char** argv) {
GDBM_FILE dbf;
srand(time(NULL));
char value[STR_SIZE];
datum key_datum;
datum value_datum = {value, STR_SIZE};
//dbf = gdbm_open(DATABASE_FILE, 0, GDBM_WRCREAT | GDBM_NOMMAP | GDBM_SYNC, 0666, NULL);
//dbf = gdbm_open(DATABASE_FILE, 0, GDBM_WRCREAT | GDBM_NOMMAP, 0666, NULL);
//dbf = gdbm_open(DATABASE_FILE, 0, GDBM_WRCREAT, 0666, NULL);
//dbf = gdbm_open(DATABASE_FILE, 0, GDBM_WRCREAT | GDBM_SYNC, 0666, NULL);
if (dbf == NULL) {
printf("Error: failed to open the data base\n");
return 1;
}
int i = 0;
int* key;
double start = getTime();
for (i = 0; i < NUM_OF_KEYS; i++) {
key = (int*) malloc(KEY_SIZE * sizeof (int));
memset(key, 0, KEY_SIZE * sizeof (int));
key[3] = i;
key_datum.dptr = (char*) key;
key_datum.dsize = KEY_SIZE * sizeof (int);
gdbm_store(dbf, key_datum, value_datum, GDBM_REPLACE);
}
double end = getTime();
printf("Write:\t%f\t", NUM_OF_KEYS / (end - start));
key = (int*) malloc(KEY_SIZE * sizeof (int));
memset(key, 0, KEY_SIZE * sizeof (int));
key_datum.dsize = KEY_SIZE * sizeof (int);
start = getTime();
for (i = 0; i < NUM_OF_KEYS; i++) {
key[3] = rand() % NUM_OF_KEYS;
key_datum.dptr = (char*) key;
value_datum = gdbm_fetch(dbf, key_datum);
}
end = getTime();
printf("Read:\t%f\n", NUM_OF_KEYS / (end - start));
gdbm_close(dbf);
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);
}
void index_file(char *path, void* db_)
{
GDBM_FILE db = db_;
datum key = {path, strlen(path)+1};
int skip;
#pragma omp critical
skip = gdbm_exists(db, key);
if(skip) {
free(path);
return;
}
struct feature *features;
int num_features;
struct kd_node *kd_tree;
char *data;
size_t data_size;
if(verbose)
tprintf("%s\n", path);
if(!sift(path, &features, &num_features)) {
free(path);
return;
}
if(verbose)
tprintf(" %d features detected\n", num_features);
kd_tree = kdtree_build(features, num_features);
pack(features, num_features, kd_tree, &data, &data_size);
free(features);
kdtree_release(kd_tree);
datum value = {data, data_size};
#pragma omp critical
gdbm_store(db, key, value, GDBM_REPLACE);
free(data);
free(path);
}
/* perform write command */
int dowrite(char *name, int rnum){
GDBM_FILE dbf;
datum key, content;
int i, err, optval, len;
char buf[RECBUFSIZ];
if(showprgr) printf("<Writing Test>\n name=%s rnum=%d\n\n", name, rnum);
/* open a database */
if(!(dbf = gdbm_open(name, 0, GDBM_NEWDB, 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++){
len = sprintf(buf, "%08d", i);
key.dptr = buf;
key.dsize = len;
content.dptr = buf;
content.dsize = len;
/* store a record */
if(gdbm_store(dbf, key, content, GDBM_REPLACE) != 0){
fprintf(stderr, "gdbm_store failed\n");
err = TRUE;
break;
}
/* 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;
}
/**
* hcache_gdbm_store - Implements HcacheOps::store()
*/
static int hcache_gdbm_store(void *ctx, const char *key, size_t keylen, void *data, size_t dlen)
{
datum dkey;
datum databuf;
if (!ctx)
return -1;
GDBM_FILE db = ctx;
dkey.dptr = (char *) key;
dkey.dsize = keylen;
databuf.dsize = dlen;
databuf.dptr = data;
return gdbm_store(db, dkey, databuf, GDBM_REPLACE);
}
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();
}
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);
}
void inserare( char *cv, char *ex){
datum key, content;
if(( key.dptr = malloc(strlen(cv)+1)) == NULL){
smsg("Not enough memory\n");
exit(1);
}
strcpy(key.dptr, cv);
key.dsize = strlen(key.dptr)+1+count_cuv(key.dptr); //sax
if((content.dptr = malloc(strlen(ex)+1)) == NULL){
smsg("\n Not enough memory");
exit(1);
}
strcpy(content.dptr, ex);
content.dsize = strlen(content.dptr)+1;
gdbm_store(bz, key, content, GDBM_INSERT);
free(key.dptr);
free(content.dptr);
}
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;
}
static ClRcT
cdbGDBMRecordAdd(ClDBHandleT dbHandle, /* Handle to the database */
ClDBKeyT dbKey, /* Handle to the key being added */
ClUint32T keySize, /* Size of the key being added */
ClDBRecordT dbRec, /* Handle to the record being added */
ClUint32T recSize) /* Size of the record being added */
{
ClRcT errorCode = CL_OK;
GDBMHandle_t* pGDBMHandle = (GDBMHandle_t*)dbHandle;
int returnCode = 0;
datum key = {NULL, 0};
datum data = {NULL, 0};
CL_FUNC_ENTER();
key.dsize = keySize;
key.dptr = (ClCharT *)dbKey;
data.dsize = recSize;
data.dptr = (ClCharT *)dbRec;
/* Store the key and record into the database */
returnCode = gdbm_store(pGDBMHandle->gdbmInstance, key, data, GDBM_INSERT);
if(1 == returnCode) {
/* GDBM returned duplicate error, so return CL_ERR_DUPLICATE */
errorCode = CL_DBAL_RC(CL_ERR_DUPLICATE);
CL_DEBUG_PRINT ( CL_DEBUG_TRACE,("\nDuplicate key"));
CL_FUNC_EXIT();
return(errorCode);
}
if(0 != returnCode) {
/* If not, some other GDBM error occured. return DB error */
errorCode = CL_DBAL_RC(CL_DBAL_ERR_DB_ERROR);
CL_DEBUG_PRINT ( CL_DEBUG_TRACE,("\nGDBM ERROR"));
CL_FUNC_EXIT();
return(errorCode);
}
CL_FUNC_EXIT();
return(CL_OK);
}
