int
cdb_make_put(struct cdb_make *cdbmp,
const void *key, unsigned klen,
const void *val, unsigned vlen,
enum cdb_put_mode mode)
{
unsigned hval = cdb_hash(key, klen);
int r;
switch(mode) {
case CDB_PUT_REPLACE:
case CDB_PUT_INSERT:
case CDB_PUT_WARN:
case CDB_PUT_REPLACE0:
r = findrec(cdbmp, key, klen, hval, mode);
if (r < 0)
return -1;
if (r && mode == CDB_PUT_INSERT)
return errno = EEXIST, 1;
break;
case CDB_PUT_ADD:
r = 0;
break;
default:
return errno = EINVAL, -1;
}
if (_cdb_make_add(cdbmp, hval, key, klen, val, vlen) < 0)
return -1;
return r;
}
int
cdb_make_find(struct cdb_make *cdbmp,
const void *key, unsigned klen,
enum cdb_put_mode mode)
{
return findrec(cdbmp, key, klen, cdb_hash(key, klen), mode);
}
int
cdb_find(struct cdb *C, const uchar_t *key, uint32_t klen)
{
uint32_t fp;
uchar_t nbuf[8];
uint32_t hash, tslots, target;
/* search initialization: */
C->key = (uchar_t *)key;
C->klen = klen;
C->h = hash = cdb_hash(key, klen);
/* lookup subtable for this hash value: */
fp = cdb_NTAB(hash) * 8;
if(cdb_read(C, nbuf, 8, fp) == -1){
return -1;
}
/* subtable offet: */
C->tbase = upak32_unpack(nbuf);
/* slots in subtable: */
C->tslots = tslots = upak32_unpack(nbuf + 4);
if(tslots == 0){
/* no slots in this table; key not found: */
return 0;
}
/* target slot for this key: */
target = cdb_SLOT(hash, tslots);
C->s0 = target;
/* probe: */
return cdb_hash_probe(C, target);
}
/*
static int check_default(const char *s, int len)
{
char tst[64];
register char *x = s;
if (len!=7) return 0;
//snprintf(tst,len+1,"%s",s);
getprint(s,len,tst);
dbger("checkd(): %s",tst);
if (*x != 'n') return 0; len--; if(len < 0) return 0; x++;
if (*x != 'o') return 0; len--; if(len < 0) return 0; x++;
if (*x != 'm') return 0; len--; if(len < 0) return 0; x++;
if (*x != 'a') return 0; len--; if(len < 0) return 0; x++;
if (*x != 't') return 0; len--; if(len < 0) return 0; x++;
if (*x != 'c') return 0; len--; if(len < 0) return 0; x++;
if (*x != 'h') return 0; len--; if(len < 0) return 0; x++;
dbger("match_default_entry");
return 1;
}
*/
static uint32 gethash(const char *s, uint32 slen)
{
if (slen == 0) return 0U;
#ifdef SHASTRID
return sha_hash(s,slen);
#else
return cdb_hash(s,slen);
#endif
}
/* ---------------- exported functions ------------------ */
static PyObject *
_wrap_cdb_hash(PyObject *ignore, PyObject *args) {
char *s;
int sz;
if (! PyArg_ParseTuple(args, "s#:hash", &s, &sz))
return NULL;
return Py_BuildValue("l", cdb_hash(s, (unsigned int) sz));
}
int cdb_findnext(struct cdb *c,char *key,unsigned int len)
{
char buf[8];
uint32 pos;
uint32 u;
U_INTERNAL_TRACE("cdb_findnext(%p,%.*s,%u)",c,len,key,len)
if (!c->loop) {
u = cdb_hash(key,len);
if (cdb_read(c,buf,8,(u % CDB_NUM_HASH_TABLE_POINTER) * 8) == -1) return -1;
uint32_unpack(buf + 4,&c->hslots);
if (!c->hslots) return 0;
uint32_unpack(buf,&c->hpos);
c->khash = u;
u /= CDB_NUM_HASH_TABLE_POINTER;
u %= c->hslots;
u <<= 3;
c->kpos = c->hpos + u;
}
while (c->loop < c->hslots) {
if (cdb_read(c,buf,8,c->kpos) == -1) return -1;
uint32_unpack(buf + 4,&pos);
if (!pos) return 0;
c->loop += 1;
c->kpos += 8;
if (c->kpos == c->hpos + (c->hslots << 3)) c->kpos = c->hpos;
uint32_unpack(buf,&u);
if (u == c->khash) {
if (cdb_read(c,buf,8,pos) == -1) return -1;
uint32_unpack(buf,&u);
if (u == len)
switch(match(c,key,len,pos + 8)) {
case -1:
return -1;
case 1:
uint32_unpack(buf + 4,&c->dlen);
c->dpos = pos + 8 + len;
return 1;
}
}
}
U_INTERNAL_TRACE("not found",0)
return 0;
}
int cdb_findnext(struct cdb *c,char *key,unsigned int len)
{
char buf[8];
uint32 pos;
uint32 u;
if (!c->loop) {
u = cdb_hash(key,len);
if (cdb_read(c,buf,8,(u << 3) & 2047) == -1) return -1;
uint32_unpack(buf + 4,&c->hslots);
if (!c->hslots) return 0;
uint32_unpack(buf,&c->hpos);
c->khash = u;
u >>= 8;
u %= c->hslots;
u <<= 3;
c->kpos = c->hpos + u;
}
int cdb_findnext(struct cdb *c,char *key,off_t len)
{
char buf[entry_size];
ref_t pos;
ref_t u;
if (!c->loop) {
u = cdb_hash(key,len);
if (cdb_read(c,buf,entry_size,(u * entry_size) & (256*entry_size - 1)) == -1) return -1;
ref_unpack(buf + ref_size,&c->hslots);
if (!c->hslots) return 0;
ref_unpack(buf,&c->hpos);
c->khash = u;
u /= ref_size;
u %= c->hslots;
u *= entry_size;
c->kpos = c->hpos + u;
}
while (c->loop < c->hslots) {
if (cdb_read(c,buf,entry_size,c->kpos) == -1) return -1;
ref_unpack(buf + ref_size,&pos);
if (!pos) return 0;
c->loop += 1;
c->kpos += 8;
if (c->kpos == c->hpos + (c->hslots * entry_size)) c->kpos = c->hpos;
ref_unpack(buf,&u);
if (u == c->khash) {
if (cdb_read(c,buf,entry_size,pos) == -1) return -1;
ref_unpack(buf,&u);
if (u == len)
switch(match(c,key,len,pos + entry_size)) {
case -1:
return -1;
case 1:
ref_unpack(buf + ref_size,&c->dlen);
c->dpos = pos + entry_size + len;
return 1;
}
}
}
return 0;
}
int
cdb_make_put(struct cdb_make *cdbmp,
const void *key, unsigned klen,
const void *val, unsigned vlen,
int flags)
{
unsigned char rlen[8];
unsigned hval = cdb_hash(key, klen);
struct cdb_rl *rl;
int c, r;
switch(flags) {
case CDB_PUT_REPLACE:
case CDB_PUT_INSERT:
case CDB_PUT_WARN:
c = _cdb_make_find(cdbmp, key, klen, hval, &rl);
if (c < 0)
return -1;
if (c) {
if (flags == CDB_PUT_INSERT)
return errno = EEXIST, 1;
else if (flags == CDB_PUT_REPLACE) {
--c;
r = 1;
break;
}
else
r = 1;
}
/* fall */
case CDB_PUT_ADD:
rl = cdbmp->cdb_rec[hval&255];
if (!rl || rl->cnt >= sizeof(rl->rec)/sizeof(rl->rec[0])) {
rl = (struct cdb_rl*)xmalloc(sizeof(struct cdb_rl));
if (!rl)
return errno = ENOMEM, -1;
rl->cnt = 0;
rl->next = cdbmp->cdb_rec[hval&255];
cdbmp->cdb_rec[hval&255] = rl;
}
c = rl->cnt;
r = 0;
break;
default:
return errno = EINVAL, -1;
}
if (klen > 0xffffffff - (cdbmp->cdb_dpos + 8) ||
vlen > 0xffffffff - (cdbmp->cdb_dpos + klen + 8))
return errno = ENOMEM, -1;
rl->rec[c].hval = hval;
rl->rec[c].rpos = cdbmp->cdb_dpos;
if ((unsigned)c == rl->cnt) {
++rl->cnt;
++cdbmp->cdb_rcnt;
}
cdb_pack(klen, rlen);
cdb_pack(vlen, rlen + 4);
if (_cdb_make_write(cdbmp, (const char *)rlen, 8) < 0 ||
_cdb_make_write(cdbmp, (const char *)key, klen) < 0 ||
_cdb_make_write(cdbmp, (const char *)val, vlen) < 0)
return -1;
return r;
}
int
cdb_make_exists(struct cdb_make *cdbmp,
const void *key, unsigned klen)
{
return _cdb_make_find(cdbmp, key, klen, cdb_hash(key, klen), NULL);
}
