Geo-LatLon2Place/cdb-embedded.c

/* embeddable/static cdb version by schmorp */

/* cdb.h: public cdb include file
 *
 * This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
 * Public domain.
 */

#ifndef TINYCDB_VERSION
#define TINYCDB_VERSION 0.78

#ifdef __cplusplus
extern "C" {
#endif

typedef unsigned int cdbi_t; /* compatibility */

/* common routines */
static unsigned cdb_hash(const void *buf, unsigned len);
static unsigned cdb_unpack(const unsigned char buf[4]);
static void cdb_pack(unsigned num, unsigned char buf[4]);

struct cdb {
  int cdb_fd;                   /* file descriptor */
  /* private members */
  unsigned cdb_fsize;           /* datafile size */
  unsigned cdb_dend;            /* end of data ptr */
  const unsigned char *cdb_mem; /* mmap'ed file memory */
  unsigned cdb_vpos, cdb_vlen;  /* found data */
  unsigned cdb_kpos, cdb_klen;  /* found key */
};

#define CDB_STATIC_INIT {0,0,0,0,0,0,0,0}

#define cdb_datapos(c) ((c)->cdb_vpos)
#define cdb_datalen(c) ((c)->cdb_vlen)
#define cdb_keypos(c) ((c)->cdb_kpos)
#define cdb_keylen(c) ((c)->cdb_klen)
#define cdb_fileno(c) ((c)->cdb_fd)

static int cdb_init(struct cdb *cdbp, int fd);
static void cdb_free(struct cdb *cdbp);

static int cdb_read(const struct cdb *cdbp,
             void *buf, unsigned len, unsigned pos);
#define cdb_readdata(cdbp, buf) \
        cdb_read((cdbp), (buf), cdb_datalen(cdbp), cdb_datapos(cdbp))
#define cdb_readkey(cdbp, buf) \
        cdb_read((cdbp), (buf), cdb_keylen(cdbp), cdb_keypos(cdbp))

static const void *cdb_get(const struct cdb *cdbp, unsigned len, unsigned pos);
#define cdb_getdata(cdbp) \
        cdb_get((cdbp), cdb_datalen(cdbp), cdb_datapos(cdbp))
#define cdb_getkey(cdbp) \
        cdb_get((cdbp), cdb_keylen(cdbp), cdb_keypos(cdbp))

static int cdb_find(struct cdb *cdbp, const void *key, unsigned klen);

struct cdb_find {
  struct cdb *cdb_cdbp;
  unsigned cdb_hval;
  const unsigned char *cdb_htp, *cdb_htab, *cdb_htend;
  unsigned cdb_httodo;
  const void *cdb_key;
  unsigned cdb_klen;
};

static int cdb_findinit(struct cdb_find *cdbfp, struct cdb *cdbp,
                 const void *key, unsigned klen);
static int cdb_findnext(struct cdb_find *cdbfp);

#define cdb_seqinit(cptr, cdbp) ((*(cptr))=2048)
static int cdb_seqnext(unsigned *cptr, struct cdb *cdbp);

/* old simple interface */
/* open file using standard routine, then: */
static int cdb_seek(int fd, const void *key, unsigned klen, unsigned *dlenp);
static int cdb_bread(int fd, void *buf, int len);

/* cdb_make */

struct cdb_make {
  int cdb_fd;                   /* file descriptor */
  /* private */
  unsigned cdb_dpos;            /* data position so far */
  unsigned cdb_rcnt;            /* record count so far */
  unsigned char cdb_buf[4096];  /* write buffer */
  unsigned char *cdb_bpos;      /* current buf position */
  struct cdb_rl *cdb_rec[256];  /* list of arrays of record infos */
};

enum cdb_put_mode {
  CDB_PUT_ADD = 0,      /* add unconditionnaly, like cdb_make_add() */
#define CDB_PUT_ADD     CDB_PUT_ADD
  CDB_FIND = CDB_PUT_ADD,
  CDB_PUT_REPLACE,      /* replace: do not place to index OLD record */
#define CDB_PUT_REPLACE CDB_PUT_REPLACE
  CDB_FIND_REMOVE = CDB_PUT_REPLACE,
  CDB_PUT_INSERT,       /* add only if not already exists */
#define CDB_PUT_INSERT  CDB_PUT_INSERT
  CDB_PUT_WARN,         /* add unconditionally but ret. 1 if exists */
#define CDB_PUT_WARN    CDB_PUT_WARN
  CDB_PUT_REPLACE0,     /* if a record exists, fill old one with zeros */
#define CDB_PUT_REPLACE0 CDB_PUT_REPLACE0
  CDB_FIND_FILL0 = CDB_PUT_REPLACE0
};

static int cdb_make_start(struct cdb_make *cdbmp, int fd);
static int cdb_make_add(struct cdb_make *cdbmp,
                 const void *key, unsigned klen,
                 const void *val, unsigned vlen);
static int cdb_make_exists(struct cdb_make *cdbmp,
                    const void *key, unsigned klen);
static int cdb_make_find(struct cdb_make *cdbmp,
                  const void *key, unsigned klen,
                  enum cdb_put_mode mode);
static int cdb_make_put(struct cdb_make *cdbmp,
                 const void *key, unsigned klen,
                 const void *val, unsigned vlen,
                 enum cdb_put_mode mode);
static int cdb_make_finish(struct cdb_make *cdbmp);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif /* include guard */

/* cdb_int.h: internal cdb library declarations
 *
 * This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
 * Public domain.
 */

#include <errno.h>
#include <string.h>

#ifndef EPROTO
# define EPROTO EINVAL
#endif

#define internal_function static

struct cdb_rec {
  unsigned hval;
  unsigned rpos;
};

struct cdb_rl {
  struct cdb_rl *next;
  unsigned cnt;
  struct cdb_rec rec[254];
};

static int _cdb_make_write(struct cdb_make *cdbmp,
                    const void *ptr, unsigned len);
static int _cdb_make_fullwrite(int fd, const unsigned char *buf, unsigned len);
static int _cdb_make_flush(struct cdb_make *cdbmp);
static int _cdb_make_add(struct cdb_make *cdbmp, unsigned hval,
                  const void *key, unsigned klen,
                  const void *val, unsigned vlen);

/* cdb_find.c: cdb_find routine
 *
 * This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
 * Public domain.
 */

static int
cdb_find(struct cdb *cdbp, const void *key, unsigned klen)
{
  const unsigned char *htp;     /* hash table pointer */
  const unsigned char *htab;    /* hash table */
  const unsigned char *htend;   /* end of hash table */
  unsigned httodo;              /* ht bytes left to look */
  unsigned pos, n;

  unsigned hval;

  if (klen >= cdbp->cdb_dend)   /* if key size is too large */
    return 0;

  hval = cdb_hash(key, klen);

  /* find (pos,n) hash table to use */
  /* first 2048 bytes (toc) are always available */
  /* (hval % 256) * 8 */
  htp = cdbp->cdb_mem + ((hval << 3) & 2047); /* index in toc (256x8) */
  n = cdb_unpack(htp + 4);      /* table size */
  if (!n)                       /* empty table */
    return 0;                   /* not found */
  httodo = n << 3;              /* bytes of htab to lookup */
  pos = cdb_unpack(htp);        /* htab position */
  if (n > (cdbp->cdb_fsize >> 3) /* overflow of httodo ? */
      || pos < cdbp->cdb_dend /* is htab inside data section ? */
      || pos > cdbp->cdb_fsize /* htab start within file ? */
      || httodo > cdbp->cdb_fsize - pos) /* entrie htab within file ? */
    return errno = EPROTO, -1;

  htab = cdbp->cdb_mem + pos;   /* htab pointer */
  htend = htab + httodo;        /* after end of htab */
  /* htab starting position: rest of hval modulo htsize, 8bytes per elt */
  htp = htab + (((hval >> 8) % n) << 3);

  for(;;) {
    pos = cdb_unpack(htp + 4);  /* record position */
    if (!pos)
      return 0;
    if (cdb_unpack(htp) == hval) {
      if (pos > cdbp->cdb_dend - 8) /* key+val lengths */
        return errno = EPROTO, -1;
      if (cdb_unpack(cdbp->cdb_mem + pos) == klen) {
        if (cdbp->cdb_dend - klen < pos + 8)
          return errno = EPROTO, -1;
        if (memcmp(key, cdbp->cdb_mem + pos + 8, klen) == 0) {
          n = cdb_unpack(cdbp->cdb_mem + pos + 4);
          pos += 8;
          if (cdbp->cdb_dend < n || cdbp->cdb_dend - n < pos + klen)
            return errno = EPROTO, -1;
          cdbp->cdb_kpos = pos;
          cdbp->cdb_klen = klen;
          cdbp->cdb_vpos = pos + klen;
          cdbp->cdb_vlen = n;
          return 1;
        }
      }
    }
    httodo -= 8;
    if (!httodo)
      return 0;
    if ((htp += 8) >= htend)
      htp = htab;
  }

}

/* cdb_hash.c: cdb hashing routine
 *
 * This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
 * Public domain.
 */

static unsigned
cdb_hash(const void *buf, unsigned len)
{
  register const unsigned char *p = (const unsigned char *)buf;
  register const unsigned char *end = p + len;
  register unsigned hash = 5381;        /* start value */
  while (p < end)
    hash = (hash + (hash << 5)) ^ *p++;
  return hash;
}

/* cdb_init.c: cdb_init, cdb_free and cdb_read routines
 *
 * This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
 * Public domain.
 */

#include <sys/types.h>
#ifdef _WIN32
# include <windows.h>
#else
# include <sys/mman.h>
# ifndef MAP_FAILED
#  define MAP_FAILED ((void*)-1)
# endif
#endif
#include <sys/stat.h>

static int
cdb_init(struct cdb *cdbp, int fd)
{
  struct stat st;
  unsigned char *mem;
  unsigned fsize, dend;
#ifdef _WIN32
  HANDLE hFile, hMapping;
#endif

  /* get file size */
  if (fstat(fd, &st) < 0)
    return -1;
  /* trivial sanity check: at least toc should be here */
  if (st.st_size < 2048)
    return errno = EPROTO, -1;
  fsize = st.st_size < 0xffffffffu ? st.st_size : 0xffffffffu;
  /* memory-map file */
#ifdef _WIN32
  hFile = (HANDLE) _get_osfhandle(fd);
  if (hFile == (HANDLE) -1)
    return -1;
  hMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
  if (!hMapping)
    return -1;
  mem = (unsigned char *)MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
  CloseHandle(hMapping);
  if (!mem)
    return -1;
#else
  mem = (unsigned char*)mmap(NULL, fsize, PROT_READ, MAP_SHARED, fd, 0);
  if (mem == MAP_FAILED)
    return -1;
#endif /* _WIN32 */

  cdbp->cdb_fd = fd;
  cdbp->cdb_fsize = fsize;
  cdbp->cdb_mem = mem;

#if 0
  /* XXX don't know well about madvise syscall -- is it legal
     to set different options for parts of one mmap() region?
     There is also posix_madvise() exist, with POSIX_MADV_RANDOM etc...
  */
#ifdef MADV_RANDOM
  /* set madvise() parameters. Ignore errors for now if system
     doesn't support it */
  madvise(mem, 2048, MADV_WILLNEED);
  madvise(mem + 2048, cdbp->cdb_fsize - 2048, MADV_RANDOM);
#endif
#endif

  cdbp->cdb_vpos = cdbp->cdb_vlen = 0;
  cdbp->cdb_kpos = cdbp->cdb_klen = 0;
  dend = cdb_unpack(mem);
  if (dend < 2048) dend = 2048;
  else if (dend >= fsize) dend = fsize;
  cdbp->cdb_dend = dend;

  return 0;
}

static void
cdb_free(struct cdb *cdbp)
{
  if (cdbp->cdb_mem) {
#ifdef _WIN32
    UnmapViewOfFile((void*) cdbp->cdb_mem);
#else
    munmap((void*)cdbp->cdb_mem, cdbp->cdb_fsize);
#endif /* _WIN32 */
    cdbp->cdb_mem = NULL;
  }
  cdbp->cdb_fsize = 0;
}

static const void *
cdb_get(const struct cdb *cdbp, unsigned len, unsigned pos)
{
  if (pos > cdbp->cdb_fsize || cdbp->cdb_fsize - pos < len) {
    errno = EPROTO;
    return NULL;
  }
  return cdbp->cdb_mem + pos;
}

static int
cdb_read(const struct cdb *cdbp, void *buf, unsigned len, unsigned pos)
{
  const void *data = cdb_get(cdbp, len, pos);
  if (!data) return -1;
  memcpy(buf, data, len);
  return 0;
}

/* cdb_make_add.c: basic cdb_make_add routine
 *
 * This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
 * Public domain.
 */

#include <stdlib.h> /* for malloc */

int internal_function
_cdb_make_add(struct cdb_make *cdbmp, unsigned hval,
              const void *key, unsigned klen,
              const void *val, unsigned vlen)
{
  unsigned char rlen[8];
  struct cdb_rl *rl;
  unsigned i;
  if (klen > 0xffffffff - (cdbmp->cdb_dpos + 8) ||
      vlen > 0xffffffff - (cdbmp->cdb_dpos + klen + 8))
    return errno = ENOMEM, -1;
  i = hval & 255;
  rl = cdbmp->cdb_rec[i];
  if (!rl || rl->cnt >= sizeof(rl->rec)/sizeof(rl->rec[0])) {
    rl = (struct cdb_rl*)malloc(sizeof(struct cdb_rl));
    if (!rl)
      return errno = ENOMEM, -1;
    rl->cnt = 0;
    rl->next = cdbmp->cdb_rec[i];
    cdbmp->cdb_rec[i] = rl;
  }
  i = rl->cnt++;
  rl->rec[i].hval = hval;
  rl->rec[i].rpos = cdbmp->cdb_dpos;
  ++cdbmp->cdb_rcnt;
  cdb_pack(klen, rlen);
  cdb_pack(vlen, rlen + 4);
  if (_cdb_make_write(cdbmp, rlen, 8) < 0 ||
      _cdb_make_write(cdbmp, key, klen) < 0 ||
      _cdb_make_write(cdbmp, val, vlen) < 0)
    return -1;
  return 0;
}

static int
cdb_make_add(struct cdb_make *cdbmp,
             const void *key, unsigned klen,
             const void *val, unsigned vlen) {
  return _cdb_make_add(cdbmp, cdb_hash(key, klen), key, klen, val, vlen);
}

/* cdb_unpack.c: unpack 32bit integer
 *
 * This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
 * Public domain.
 */

static inline unsigned
cdb_unpack(const unsigned char buf[4])
{
  unsigned n = buf[3];
  n <<= 8; n |= buf[2];
  n <<= 8; n |= buf[1];
  n <<= 8; n |= buf[0];
  return n;
}

/* cdb_make.c: basic cdb creation routines
 *
 * This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
 * Public domain.
 */

#include <unistd.h>
#include <stdlib.h>
#include <string.h>

static inline void
cdb_pack(unsigned num, unsigned char buf[4])
{
  buf[0] = num & 255; num >>= 8;
  buf[1] = num & 255; num >>= 8;
  buf[2] = num & 255;
  buf[3] = num >> 8;
}

static int
cdb_make_start(struct cdb_make *cdbmp, int fd)
{
  memset(cdbmp, 0, sizeof(*cdbmp));
  cdbmp->cdb_fd = fd;
  cdbmp->cdb_dpos = 2048;
  cdbmp->cdb_bpos = cdbmp->cdb_buf + 2048;
  return 0;
}

int internal_function
_cdb_make_fullwrite(int fd, const unsigned char *buf, unsigned len)
{
  while(len) {
    int l = write(fd, buf, len);
    if (l > 0) {
      len -= l;
      buf += l;
    }
    else if (l < 0 && errno != EINTR)
      return -1;
  }
  return 0;
}

int internal_function
_cdb_make_flush(struct cdb_make *cdbmp) {
  unsigned len = cdbmp->cdb_bpos - cdbmp->cdb_buf;
  if (len) {
    if (_cdb_make_fullwrite(cdbmp->cdb_fd, cdbmp->cdb_buf, len) < 0)
      return -1;
    cdbmp->cdb_bpos = cdbmp->cdb_buf;
  }
  return 0;
}

int internal_function
_cdb_make_write(struct cdb_make *cdbmp, const void *ptr_, unsigned len)
{
  const unsigned char *ptr = (const unsigned char *)ptr_;
  unsigned l = sizeof(cdbmp->cdb_buf) - (cdbmp->cdb_bpos - cdbmp->cdb_buf);
  cdbmp->cdb_dpos += len;
  if (len > l) {
    memcpy(cdbmp->cdb_bpos, ptr, l);
    cdbmp->cdb_bpos += l;
    if (_cdb_make_flush(cdbmp) < 0)
      return -1;
    ptr += l; len -= l;
    l = len / sizeof(cdbmp->cdb_buf);
    if (l) {
      l *= sizeof(cdbmp->cdb_buf);
      if (_cdb_make_fullwrite(cdbmp->cdb_fd, ptr, l) < 0)
        return -1;
      ptr += l; len -= l;
    }
  }
  if (len) {
    memcpy(cdbmp->cdb_bpos, ptr, len);
    cdbmp->cdb_bpos += len;
  }
  return 0;
}

static int
cdb_make_finish_internal(struct cdb_make *cdbmp)
{
  unsigned hcnt[256];           /* hash table counts */
  unsigned hpos[256];           /* hash table positions */
  struct cdb_rec *htab;
  unsigned char *p;
  struct cdb_rl *rl;
  unsigned hsize;
  unsigned t, i;

  if (((0xffffffff - cdbmp->cdb_dpos) >> 3) < cdbmp->cdb_rcnt)
    return errno = ENOMEM, -1;

  /* count htab sizes and reorder reclists */
  hsize = 0;
  for (t = 0; t < 256; ++t) {
    struct cdb_rl *rlt = NULL;
    i = 0;
    rl = cdbmp->cdb_rec[t];
    while(rl) {
      struct cdb_rl *rln = rl->next;
      rl->next = rlt;
      rlt = rl;
      i += rl->cnt;
      rl = rln;
    }
    cdbmp->cdb_rec[t] = rlt;
    if (hsize < (hcnt[t] = i << 1))
      hsize = hcnt[t];
  }

  /* allocate memory to hold max htable */
  htab = (struct cdb_rec*)malloc((hsize + 2) * sizeof(struct cdb_rec));
  if (!htab)
    return errno = ENOENT, -1;
  p = (unsigned char *)htab;
  htab += 2;

  /* build hash tables */
  for (t = 0; t < 256; ++t) {
    unsigned len, hi;
    hpos[t] = cdbmp->cdb_dpos;
    if ((len = hcnt[t]) == 0)
      continue;
    for (i = 0; i < len; ++i)
      htab[i].hval = htab[i].rpos = 0;
    for (rl = cdbmp->cdb_rec[t]; rl; rl = rl->next)
      for (i = 0; i < rl->cnt; ++i) {
       hi = (rl->rec[i].hval >> 8) % len;
        while(htab[hi].rpos)
          if (++hi == len)
            hi = 0;
        htab[hi] = rl->rec[i];
      }
    for (i = 0; i < len; ++i) {
      cdb_pack(htab[i].hval, p + (i << 3));
      cdb_pack(htab[i].rpos, p + (i << 3) + 4);
    }
    if (_cdb_make_write(cdbmp, p, len << 3) < 0) {
      free(p);
      return -1;
    }
  }
  free(p);
  if (_cdb_make_flush(cdbmp) < 0)
    return -1;
  p = cdbmp->cdb_buf;
  for (t = 0; t < 256; ++t) {
    cdb_pack(hpos[t], p + (t << 3));
    cdb_pack(hcnt[t], p + (t << 3) + 4);
  }
  if (lseek(cdbmp->cdb_fd, 0, 0) != 0 ||
      _cdb_make_fullwrite(cdbmp->cdb_fd, p, 2048) != 0)
    return -1;

  return 0;
}

static void
cdb_make_free(struct cdb_make *cdbmp)
{
  unsigned t;
  for(t = 0; t < 256; ++t) {
    struct cdb_rl *rl = cdbmp->cdb_rec[t];
    while(rl) {
      struct cdb_rl *tm = rl;
      rl = rl->next;
      free(tm);
    }
  }
}

static int
cdb_make_finish(struct cdb_make *cdbmp)
{
  int r = cdb_make_finish_internal(cdbmp);
  cdb_make_free(cdbmp);
  return r;
}

Revision:	1.3
Committed:	Thu Mar 17 22:55:34 2022 UTC (2 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-1_0, HEAD
Changes since 1.2:	+3 -2 lines
Log Message:	convert to c++
#	User	Rev	Content
1	root	1.1	/* embeddable/static cdb version by schmorp */
2
3			/* cdb.h: public cdb include file
4			*
5			* This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
6			* Public domain.
7			*/
8
9			#ifndef TINYCDB_VERSION
10			#define TINYCDB_VERSION 0.78
11
12			#ifdef __cplusplus
13			extern "C" {
14			#endif
15
16			typedef unsigned int cdbi_t; /* compatibility */
17
18			/* common routines */
19			static unsigned cdb_hash(const void *buf, unsigned len);
20			static unsigned cdb_unpack(const unsigned char buf[4]);
21			static void cdb_pack(unsigned num, unsigned char buf[4]);
22
23			struct cdb {
24			int cdb_fd; /* file descriptor */
25			/* private members */
26			unsigned cdb_fsize; /* datafile size */
27			unsigned cdb_dend; /* end of data ptr */
28			const unsigned char cdb_mem; / mmap'ed file memory */
29			unsigned cdb_vpos, cdb_vlen; /* found data */
30			unsigned cdb_kpos, cdb_klen; /* found key */
31			};
32
33			#define CDB_STATIC_INIT {0,0,0,0,0,0,0,0}
34
35			#define cdb_datapos(c) ((c)->cdb_vpos)
36			#define cdb_datalen(c) ((c)->cdb_vlen)
37			#define cdb_keypos(c) ((c)->cdb_kpos)
38			#define cdb_keylen(c) ((c)->cdb_klen)
39			#define cdb_fileno(c) ((c)->cdb_fd)
40
41			static int cdb_init(struct cdb *cdbp, int fd);
42			static void cdb_free(struct cdb *cdbp);
43
44			static int cdb_read(const struct cdb *cdbp,
45			void *buf, unsigned len, unsigned pos);
46			#define cdb_readdata(cdbp, buf) \
47			cdb_read((cdbp), (buf), cdb_datalen(cdbp), cdb_datapos(cdbp))
48			#define cdb_readkey(cdbp, buf) \
49			cdb_read((cdbp), (buf), cdb_keylen(cdbp), cdb_keypos(cdbp))
50
51			static const void cdb_get(const struct cdb cdbp, unsigned len, unsigned pos);
52			#define cdb_getdata(cdbp) \
53			cdb_get((cdbp), cdb_datalen(cdbp), cdb_datapos(cdbp))
54			#define cdb_getkey(cdbp) \
55			cdb_get((cdbp), cdb_keylen(cdbp), cdb_keypos(cdbp))
56
57			static int cdb_find(struct cdb cdbp, const void key, unsigned klen);
58
59			struct cdb_find {
60			struct cdb *cdb_cdbp;
61			unsigned cdb_hval;
62			const unsigned char cdb_htp, cdb_htab, *cdb_htend;
63			unsigned cdb_httodo;
64			const void *cdb_key;
65			unsigned cdb_klen;
66			};
67
68			static int cdb_findinit(struct cdb_find cdbfp, struct cdb cdbp,
69			const void *key, unsigned klen);
70			static int cdb_findnext(struct cdb_find *cdbfp);
71
72			#define cdb_seqinit(cptr, cdbp) ((*(cptr))=2048)
73			static int cdb_seqnext(unsigned cptr, struct cdb cdbp);
74
75			/* old simple interface */
76			/* open file using standard routine, then: */
77			static int cdb_seek(int fd, const void key, unsigned klen, unsigned dlenp);
78			static int cdb_bread(int fd, void *buf, int len);
79
80			/* cdb_make */
81
82			struct cdb_make {
83			int cdb_fd; /* file descriptor */
84			/* private */
85			unsigned cdb_dpos; /* data position so far */
86			unsigned cdb_rcnt; /* record count so far */
87			unsigned char cdb_buf[4096]; /* write buffer */
88			unsigned char cdb_bpos; / current buf position */
89			struct cdb_rl cdb_rec[256]; / list of arrays of record infos */
90			};
91
92			enum cdb_put_mode {
93			CDB_PUT_ADD = 0, /* add unconditionnaly, like cdb_make_add() */
94			#define CDB_PUT_ADD CDB_PUT_ADD
95			CDB_FIND = CDB_PUT_ADD,
96			CDB_PUT_REPLACE, /* replace: do not place to index OLD record */
97			#define CDB_PUT_REPLACE CDB_PUT_REPLACE
98			CDB_FIND_REMOVE = CDB_PUT_REPLACE,
99			CDB_PUT_INSERT, /* add only if not already exists */
100			#define CDB_PUT_INSERT CDB_PUT_INSERT
101			CDB_PUT_WARN, /* add unconditionally but ret. 1 if exists */
102			#define CDB_PUT_WARN CDB_PUT_WARN
103			CDB_PUT_REPLACE0, /* if a record exists, fill old one with zeros */
104			#define CDB_PUT_REPLACE0 CDB_PUT_REPLACE0
105			CDB_FIND_FILL0 = CDB_PUT_REPLACE0
106			};
107
108			static int cdb_make_start(struct cdb_make *cdbmp, int fd);
109			static int cdb_make_add(struct cdb_make *cdbmp,
110			const void *key, unsigned klen,
111			const void *val, unsigned vlen);
112			static int cdb_make_exists(struct cdb_make *cdbmp,
113			const void *key, unsigned klen);
114			static int cdb_make_find(struct cdb_make *cdbmp,
115			const void *key, unsigned klen,
116			enum cdb_put_mode mode);
117			static int cdb_make_put(struct cdb_make *cdbmp,
118			const void *key, unsigned klen,
119			const void *val, unsigned vlen,
120			enum cdb_put_mode mode);
121			static int cdb_make_finish(struct cdb_make *cdbmp);
122
123			#ifdef __cplusplus
124			} /* extern "C" */
125			#endif
126
127			#endif /* include guard */
128
129			/* cdb_int.h: internal cdb library declarations
130			*
131			* This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
132			* Public domain.
133			*/
134
135			#include <errno.h>
136			#include <string.h>
137
138			#ifndef EPROTO
139			# define EPROTO EINVAL
140			#endif
141
142			#define internal_function static
143
144			struct cdb_rec {
145			unsigned hval;
146			unsigned rpos;
147			};
148
149			struct cdb_rl {
150			struct cdb_rl *next;
151			unsigned cnt;
152			struct cdb_rec rec[254];
153			};
154
155			static int _cdb_make_write(struct cdb_make *cdbmp,
156	root	1.3	const void *ptr, unsigned len);
157	root	1.1	static int _cdb_make_fullwrite(int fd, const unsigned char *buf, unsigned len);
158			static int _cdb_make_flush(struct cdb_make *cdbmp);
159			static int _cdb_make_add(struct cdb_make *cdbmp, unsigned hval,
160			const void *key, unsigned klen,
161			const void *val, unsigned vlen);
162	root	1.2
163	root	1.1	/* cdb_find.c: cdb_find routine
164			*
165			* This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
166			* Public domain.
167			*/
168
169			static int
170			cdb_find(struct cdb cdbp, const void key, unsigned klen)
171			{
172			const unsigned char htp; / hash table pointer */
173			const unsigned char htab; / hash table */
174			const unsigned char htend; / end of hash table */
175			unsigned httodo; /* ht bytes left to look */
176			unsigned pos, n;
177
178			unsigned hval;
179
180			if (klen >= cdbp->cdb_dend) /* if key size is too large */
181			return 0;
182
183			hval = cdb_hash(key, klen);
184
185			/* find (pos,n) hash table to use */
186			/* first 2048 bytes (toc) are always available */
187			/* (hval % 256) * 8 */
188			htp = cdbp->cdb_mem + ((hval << 3) & 2047); /* index in toc (256x8) */
189			n = cdb_unpack(htp + 4); /* table size */
190			if (!n) /* empty table */
191			return 0; /* not found */
192			httodo = n << 3; /* bytes of htab to lookup */
193			pos = cdb_unpack(htp); /* htab position */
194			if (n > (cdbp->cdb_fsize >> 3) /* overflow of httodo ? */
195			\|\| pos < cdbp->cdb_dend /* is htab inside data section ? */
196			\|\| pos > cdbp->cdb_fsize /* htab start within file ? */
197			\|\| httodo > cdbp->cdb_fsize - pos) /* entrie htab within file ? */
198			return errno = EPROTO, -1;
199
200			htab = cdbp->cdb_mem + pos; /* htab pointer */
201			htend = htab + httodo; /* after end of htab */
202			/* htab starting position: rest of hval modulo htsize, 8bytes per elt */
203			htp = htab + (((hval >> 8) % n) << 3);
204
205			for(;;) {
206			pos = cdb_unpack(htp + 4); /* record position */
207			if (!pos)
208			return 0;
209			if (cdb_unpack(htp) == hval) {
210			if (pos > cdbp->cdb_dend - 8) /* key+val lengths */
211			return errno = EPROTO, -1;
212			if (cdb_unpack(cdbp->cdb_mem + pos) == klen) {
213			if (cdbp->cdb_dend - klen < pos + 8)
214			return errno = EPROTO, -1;
215			if (memcmp(key, cdbp->cdb_mem + pos + 8, klen) == 0) {
216			n = cdb_unpack(cdbp->cdb_mem + pos + 4);
217			pos += 8;
218			if (cdbp->cdb_dend < n \|\| cdbp->cdb_dend - n < pos + klen)
219			return errno = EPROTO, -1;
220			cdbp->cdb_kpos = pos;
221			cdbp->cdb_klen = klen;
222			cdbp->cdb_vpos = pos + klen;
223			cdbp->cdb_vlen = n;
224			return 1;
225			}
226			}
227			}
228			httodo -= 8;
229			if (!httodo)
230			return 0;
231			if ((htp += 8) >= htend)
232			htp = htab;
233			}
234
235			}
236
237			/* cdb_hash.c: cdb hashing routine
238			*
239			* This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
240			* Public domain.
241			*/
242
243			static unsigned
244			cdb_hash(const void *buf, unsigned len)
245			{
246			register const unsigned char p = (const unsigned char )buf;
247			register const unsigned char *end = p + len;
248			register unsigned hash = 5381; /* start value */
249			while (p < end)
250			hash = (hash + (hash << 5)) ^ *p++;
251			return hash;
252			}
253
254			/* cdb_init.c: cdb_init, cdb_free and cdb_read routines
255			*
256			* This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
257			* Public domain.
258			*/
259
260			#include <sys/types.h>
261			#ifdef _WIN32
262			# include <windows.h>
263			#else
264			# include <sys/mman.h>
265			# ifndef MAP_FAILED
266			# define MAP_FAILED ((void*)-1)
267			# endif
268			#endif
269			#include <sys/stat.h>
270
271			static int
272			cdb_init(struct cdb *cdbp, int fd)
273			{
274			struct stat st;
275			unsigned char *mem;
276			unsigned fsize, dend;
277			#ifdef _WIN32
278			HANDLE hFile, hMapping;
279			#endif
280
281			/* get file size */
282			if (fstat(fd, &st) < 0)
283			return -1;
284			/* trivial sanity check: at least toc should be here */
285			if (st.st_size < 2048)
286			return errno = EPROTO, -1;
287			fsize = st.st_size < 0xffffffffu ? st.st_size : 0xffffffffu;
288			/* memory-map file */
289			#ifdef _WIN32
290			hFile = (HANDLE) _get_osfhandle(fd);
291			if (hFile == (HANDLE) -1)
292			return -1;
293			hMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
294			if (!hMapping)
295			return -1;
296			mem = (unsigned char *)MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
297			CloseHandle(hMapping);
298			if (!mem)
299			return -1;
300			#else
301			mem = (unsigned char*)mmap(NULL, fsize, PROT_READ, MAP_SHARED, fd, 0);
302			if (mem == MAP_FAILED)
303			return -1;
304			#endif /* _WIN32 */
305
306			cdbp->cdb_fd = fd;
307			cdbp->cdb_fsize = fsize;
308			cdbp->cdb_mem = mem;
309
310			#if 0
311			/* XXX don't know well about madvise syscall -- is it legal
312			to set different options for parts of one mmap() region?
313			There is also posix_madvise() exist, with POSIX_MADV_RANDOM etc...
314			*/
315			#ifdef MADV_RANDOM
316			/* set madvise() parameters. Ignore errors for now if system
317			doesn't support it */
318			madvise(mem, 2048, MADV_WILLNEED);
319			madvise(mem + 2048, cdbp->cdb_fsize - 2048, MADV_RANDOM);
320			#endif
321			#endif
322
323			cdbp->cdb_vpos = cdbp->cdb_vlen = 0;
324			cdbp->cdb_kpos = cdbp->cdb_klen = 0;
325			dend = cdb_unpack(mem);
326			if (dend < 2048) dend = 2048;
327			else if (dend >= fsize) dend = fsize;
328			cdbp->cdb_dend = dend;
329
330			return 0;
331			}
332
333			static void
334			cdb_free(struct cdb *cdbp)
335			{
336			if (cdbp->cdb_mem) {
337			#ifdef _WIN32
338			UnmapViewOfFile((void*) cdbp->cdb_mem);
339			#else
340			munmap((void*)cdbp->cdb_mem, cdbp->cdb_fsize);
341			#endif /* _WIN32 */
342			cdbp->cdb_mem = NULL;
343			}
344			cdbp->cdb_fsize = 0;
345			}
346
347			static const void *
348			cdb_get(const struct cdb *cdbp, unsigned len, unsigned pos)
349			{
350			if (pos > cdbp->cdb_fsize \|\| cdbp->cdb_fsize - pos < len) {
351			errno = EPROTO;
352			return NULL;
353			}
354			return cdbp->cdb_mem + pos;
355			}
356
357			static int
358			cdb_read(const struct cdb cdbp, void buf, unsigned len, unsigned pos)
359			{
360			const void *data = cdb_get(cdbp, len, pos);
361			if (!data) return -1;
362			memcpy(buf, data, len);
363			return 0;
364			}
365
366			/* cdb_make_add.c: basic cdb_make_add routine
367			*
368			* This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
369			* Public domain.
370			*/
371
372			#include <stdlib.h> /* for malloc */
373
374			int internal_function
375			_cdb_make_add(struct cdb_make *cdbmp, unsigned hval,
376			const void *key, unsigned klen,
377			const void *val, unsigned vlen)
378			{
379			unsigned char rlen[8];
380			struct cdb_rl *rl;
381			unsigned i;
382			if (klen > 0xffffffff - (cdbmp->cdb_dpos + 8) \|\|
383			vlen > 0xffffffff - (cdbmp->cdb_dpos + klen + 8))
384			return errno = ENOMEM, -1;
385			i = hval & 255;
386			rl = cdbmp->cdb_rec[i];
387			if (!rl \|\| rl->cnt >= sizeof(rl->rec)/sizeof(rl->rec[0])) {
388			rl = (struct cdb_rl*)malloc(sizeof(struct cdb_rl));
389			if (!rl)
390			return errno = ENOMEM, -1;
391			rl->cnt = 0;
392			rl->next = cdbmp->cdb_rec[i];
393			cdbmp->cdb_rec[i] = rl;
394			}
395			i = rl->cnt++;
396			rl->rec[i].hval = hval;
397			rl->rec[i].rpos = cdbmp->cdb_dpos;
398			++cdbmp->cdb_rcnt;
399			cdb_pack(klen, rlen);
400			cdb_pack(vlen, rlen + 4);
401			if (_cdb_make_write(cdbmp, rlen, 8) < 0 \|\|
402			_cdb_make_write(cdbmp, key, klen) < 0 \|\|
403			_cdb_make_write(cdbmp, val, vlen) < 0)
404			return -1;
405			return 0;
406			}
407
408			static int
409			cdb_make_add(struct cdb_make *cdbmp,
410			const void *key, unsigned klen,
411			const void *val, unsigned vlen) {
412			return _cdb_make_add(cdbmp, cdb_hash(key, klen), key, klen, val, vlen);
413			}
414
415			/* cdb_unpack.c: unpack 32bit integer
416			*
417			* This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
418			* Public domain.
419			*/
420
421			static inline unsigned
422			cdb_unpack(const unsigned char buf[4])
423			{
424			unsigned n = buf[3];
425			n <<= 8; n \|= buf[2];
426			n <<= 8; n \|= buf[1];
427			n <<= 8; n \|= buf[0];
428			return n;
429			}
430
431			/* cdb_make.c: basic cdb creation routines
432			*
433			* This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.
434			* Public domain.
435			*/
436
437			#include <unistd.h>
438			#include <stdlib.h>
439			#include <string.h>
440
441			static inline void
442			cdb_pack(unsigned num, unsigned char buf[4])
443			{
444			buf[0] = num & 255; num >>= 8;
445			buf[1] = num & 255; num >>= 8;
446			buf[2] = num & 255;
447			buf[3] = num >> 8;
448			}
449
450			static int
451			cdb_make_start(struct cdb_make *cdbmp, int fd)
452			{
453			memset(cdbmp, 0, sizeof(*cdbmp));
454			cdbmp->cdb_fd = fd;
455			cdbmp->cdb_dpos = 2048;
456			cdbmp->cdb_bpos = cdbmp->cdb_buf + 2048;
457			return 0;
458			}
459
460			int internal_function
461			_cdb_make_fullwrite(int fd, const unsigned char *buf, unsigned len)
462			{
463			while(len) {
464			int l = write(fd, buf, len);
465			if (l > 0) {
466			len -= l;
467			buf += l;
468			}
469			else if (l < 0 && errno != EINTR)
470			return -1;
471			}
472			return 0;
473			}
474
475			int internal_function
476			_cdb_make_flush(struct cdb_make *cdbmp) {
477			unsigned len = cdbmp->cdb_bpos - cdbmp->cdb_buf;
478			if (len) {
479			if (_cdb_make_fullwrite(cdbmp->cdb_fd, cdbmp->cdb_buf, len) < 0)
480			return -1;
481			cdbmp->cdb_bpos = cdbmp->cdb_buf;
482			}
483			return 0;
484			}
485
486			int internal_function
487	root	1.3	_cdb_make_write(struct cdb_make cdbmp, const void ptr_, unsigned len)
488	root	1.1	{
489	root	1.3	const unsigned char ptr = (const unsigned char )ptr_;
490	root	1.1	unsigned l = sizeof(cdbmp->cdb_buf) - (cdbmp->cdb_bpos - cdbmp->cdb_buf);
491			cdbmp->cdb_dpos += len;
492			if (len > l) {
493			memcpy(cdbmp->cdb_bpos, ptr, l);
494			cdbmp->cdb_bpos += l;
495			if (_cdb_make_flush(cdbmp) < 0)
496			return -1;
497			ptr += l; len -= l;
498			l = len / sizeof(cdbmp->cdb_buf);
499			if (l) {
500			l *= sizeof(cdbmp->cdb_buf);
501			if (_cdb_make_fullwrite(cdbmp->cdb_fd, ptr, l) < 0)
502			return -1;
503			ptr += l; len -= l;
504			}
505			}
506			if (len) {
507			memcpy(cdbmp->cdb_bpos, ptr, len);
508			cdbmp->cdb_bpos += len;
509			}
510			return 0;
511			}
512
513			static int
514			cdb_make_finish_internal(struct cdb_make *cdbmp)
515			{
516			unsigned hcnt[256]; /* hash table counts */
517			unsigned hpos[256]; /* hash table positions */
518			struct cdb_rec *htab;
519			unsigned char *p;
520			struct cdb_rl *rl;
521			unsigned hsize;
522			unsigned t, i;
523
524			if (((0xffffffff - cdbmp->cdb_dpos) >> 3) < cdbmp->cdb_rcnt)
525			return errno = ENOMEM, -1;
526
527			/* count htab sizes and reorder reclists */
528			hsize = 0;
529			for (t = 0; t < 256; ++t) {
530			struct cdb_rl *rlt = NULL;
531			i = 0;
532			rl = cdbmp->cdb_rec[t];
533			while(rl) {
534			struct cdb_rl *rln = rl->next;
535			rl->next = rlt;
536			rlt = rl;
537			i += rl->cnt;
538			rl = rln;
539			}
540			cdbmp->cdb_rec[t] = rlt;
541			if (hsize < (hcnt[t] = i << 1))
542			hsize = hcnt[t];
543			}
544
545			/* allocate memory to hold max htable */
546			htab = (struct cdb_rec)malloc((hsize + 2) sizeof(struct cdb_rec));
547			if (!htab)
548			return errno = ENOENT, -1;
549			p = (unsigned char *)htab;
550			htab += 2;
551
552			/* build hash tables */
553			for (t = 0; t < 256; ++t) {
554			unsigned len, hi;
555			hpos[t] = cdbmp->cdb_dpos;
556			if ((len = hcnt[t]) == 0)
557			continue;
558			for (i = 0; i < len; ++i)
559			htab[i].hval = htab[i].rpos = 0;
560			for (rl = cdbmp->cdb_rec[t]; rl; rl = rl->next)
561			for (i = 0; i < rl->cnt; ++i) {
562			hi = (rl->rec[i].hval >> 8) % len;
563			while(htab[hi].rpos)
564			if (++hi == len)
565			hi = 0;
566			htab[hi] = rl->rec[i];
567			}
568			for (i = 0; i < len; ++i) {
569			cdb_pack(htab[i].hval, p + (i << 3));
570			cdb_pack(htab[i].rpos, p + (i << 3) + 4);
571			}
572			if (_cdb_make_write(cdbmp, p, len << 3) < 0) {
573			free(p);
574			return -1;
575			}
576			}
577			free(p);
578			if (_cdb_make_flush(cdbmp) < 0)
579			return -1;
580			p = cdbmp->cdb_buf;
581			for (t = 0; t < 256; ++t) {
582			cdb_pack(hpos[t], p + (t << 3));
583			cdb_pack(hcnt[t], p + (t << 3) + 4);
584			}
585			if (lseek(cdbmp->cdb_fd, 0, 0) != 0 \|\|
586			_cdb_make_fullwrite(cdbmp->cdb_fd, p, 2048) != 0)
587			return -1;
588
589			return 0;
590			}
591
592			static void
593			cdb_make_free(struct cdb_make *cdbmp)
594			{
595			unsigned t;
596			for(t = 0; t < 256; ++t) {
597			struct cdb_rl *rl = cdbmp->cdb_rec[t];
598			while(rl) {
599			struct cdb_rl *tm = rl;
600			rl = rl->next;
601			free(tm);
602			}
603			}
604			}
605
606			static int
607			cdb_make_finish(struct cdb_make *cdbmp)
608			{
609			int r = cdb_make_finish_internal(cdbmp);
610			cdb_make_free(cdbmp);
611			return r;
612			}
613