/*
* dbz.c V3.2
*
* Copyright 1988 Jon Zeeff (zeeff@b-tech.ann-arbor.mi.us) You can use this code
* in any manner, as long as you leave my name on it and don't hold me
* responsible for any problems with it.
*
* Hacked on by gdb@ninja.UUCP (David Butler); Sun Jun 5 00:27:08 CDT 1988
*
* Various improvments + INCORE by moraes@ai.toronto.edu (Mark Moraes)
*
* Major reworking by Henry Spencer as part of the C News project.
*
* Minor lint and CodeCenter (Saber) fluff removal by Rich $alz (March, 1991).
* Non-portable CloseOnExec() calls added by Rich $alz (September, 1991).
* Added "writethrough" and tagmask calculation code from
* <rob@violet.berkeley.edu> and <leres@ee.lbl.gov> by Rich $alz (December,
* 1992). Merged in MMAP code by David Robinson, formerly
* <david@elroy.jpl.nasa.gov> now <david.robinson@sun.com> (January, 1993).
*
* These routines replace dbm as used by the usenet news software (it's not a
* full dbm replacement by any means). It's fast and simple. It contains no
* AT&T code.
*
* In general, dbz's files are 1/20 the size of dbm's. Lookup performance is
* somewhat better, while file creation is spectacularly faster, especially
* if the incore facility is used.
*
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <errno.h>
#ifndef __STDC__
extern int errno;
#endif
#include <dbz.h>
#include "clibrary.h"
/*
* #ifdef index. "LIA" = "leave it alone unless you know what you're doing".
*
* FUNNYSEEKS SEEK_SET is not 0, get it from <unistd.h> INDEX_SIZE
* backward compatibility with old dbz; avoid using this NMEMORY
* number of days of memory for use in sizing new table (LIA) INCORE
* backward compatibility with old dbz; use dbzincore() instead DBZDEBUG
* enable debugging DEFSIZE default table size (not as critical as in old
* dbz) OLDBNEWS default case mapping as in old B News; set NOBUFFER
* BNEWS default case mapping as in current B News; set NOBUFFER
* DEFCASE default case-map algorithm selector NOTAGS fseek offsets
* are strange, do not do tagging (see below) NPAGBUF size of .pag buffer,
* in longs (LIA) SHISTBUF size of ASCII-file buffer, in bytes (LIA)
* MAXRUN length of run which shifts to next table (see below) (LIA)
* OVERFLOW long-int arithmetic overflow must be avoided, will trap
* NOBUFFER do not buffer hash-table i/o, B News locking is defective
* MMAP Use SunOS style mmap() for efficient incore
*/
/* SUPPRESS 530 *//* Empty body for statement */
/* SUPPRESS 701 on free *//* Conflicting declaration */
#ifdef FUNNYSEEKS
#include <unistd.h>
#else
#define SEEK_SET 0
#endif
#ifdef OVERFLOW
#include <limits.h>
#endif
static int dbzversion = 3; /* for validating .dir file format */
/*
* The dbz database exploits the fact that when news stores a <key,value>
* tuple, the `value' part is a seek offset into a text file, pointing to a
* copy of the `key' part. This avoids the need to store a copy of the key
* in the dbz files. However, the text file *must* exist and be consistent
* with the dbz files, or things will fail.
*
* The basic format of the database is a simple hash table containing the
* values. A value is stored by indexing into the table using a hash value
* computed from the key; collisions are resolved by linear probing (just
* search forward for an empty slot, wrapping around to the beginning of the
* table if necessary). Linear probing is a performance disaster when the
* table starts to get full, so a complication is introduced. The database
* is actually one *or more* tables, stored sequentially in the .pag file,
* and the length of linear-probe sequences is limited. The search (for an
* existing item or an empty slot) always starts in the first table, and
* whenever MAXRUN probes have been done in table N, probing continues in
* table N+1. This behaves reasonably well even in cases of massive
* overflow. There are some other small complications added, see comments
* below.
*
* The table size is fixed for any particular database, but is determined
* dynamically when a database is rebuilt. The strategy is to try to pick
* the size so the first table will be no more than 2/3 full, that being
* slightly before the point where performance starts to degrade. (It is
* desirable to be a bit conservative because the overflow strategy tends to
* produce files with holes in them, which is a nuisance.)
*/
/*
* The following is for backward compatibility.
*/
#ifdef INDEX_SIZE
#define DEFSIZE INDEX_SIZE
#endif
/*
* ANSI C says an offset into a file is a long, not an off_t, for some
* reason. This actually does simplify life a bit, but it's still nice to
* have a distinctive name for it. Beware, this is just for readability,
* don't try to change this.
*/
#define of_t long
#define SOF (sizeof(of_t))
/*
* We assume that unused areas of a binary file are zeros, and that the bit
* pattern of `(of_t)0' is all zeros. The alternative is rather painful file
* initialization. Note that okayvalue(), if OVERFLOW is defined, knows what
* value of an offset would cause overflow.
*/
#define VACANT ((of_t)0)
#define BIAS(o) ((o)+1) /* make any valid of_t non-VACANT */
#define UNBIAS(o) ((o)-1) /* reverse BIAS() effect */
/*
* In a Unix implementation, or indeed any in which an of_t is a byte count,
* there are a bunch of high bits free in an of_t. There is a use for them.
* Checking a possible hit by looking it up in the base file is relatively
* expensive, and the cost can be dramatically reduced by using some of those
* high bits to tag the value with a few more bits of the key's hash. This
* detects most false hits without the overhead of seek+read+strcmp. We use
* the top bit to indicate whether the value is tagged or not, and don't tag
* a value which is using the tag bits itself. We're in trouble if the of_t
* representation wants to use the top bit. The actual bitmasks and offset
* come from the configuration stuff, which permits fiddling with them as
* necessary, and also suppressing them completely (by defining the masks to
* 0). We build pre-shifted versions of the masks for efficiency.
*/
static of_t tagbits; /* pre-shifted tag mask */
static of_t taghere; /* pre-shifted tag-enable bit */
static of_t tagboth; /* tagbits|taghere */
#define HASTAG(o) ((o)&taghere)
#define TAG(o) ((o)&tagbits)
#define NOTAG(o) ((o)&~tagboth)
#define CANTAG(o) (((o)&tagboth) == 0)
#define MKTAG(v) (((v)<<conf.tagshift)&tagbits)
/*
* A new, from-scratch database, not built as a rebuild of an old one, needs
* to know table size, casemap algorithm, and tagging. Normally the user
* supplies this info, but there have to be defaults.
*/
#ifndef DEFSIZE
#define DEFSIZE 120011 /* 300007 might be better */
#endif
#ifdef OLDBNEWS
#define DEFCASE '0' /* B2.10 -- no mapping */
#define NOBUFFER /* B News locking is defective */
#endif
#ifdef BNEWS
#define DEFCASE '=' /* B2.11 -- all mapped */
#define NOBUFFER /* B News locking is defective */
#endif
#ifndef DEFCASE /* C News compatibility is the default */
#define DEFCASE 'C' /* C News -- RFC822 mapping */
#endif
#ifndef NOTAGS
#define TAGENB 0x80 /* tag enable is top bit, tag is next 7 */
#define TAGMASK 0x7f
#define TAGSHIFT 24
#else
#define TAGENB 0 /* no tags */
#define TAGMASK 0
#define TAGSHIFT 0
#endif
/*
* We read configuration info from the .dir file into this structure, so we
* can avoid wired-in assumptions for an existing database.
*
* Among the info is a record of recent peak usages, so that a new table size
* can be chosen intelligently when rebuilding. 10 is a good number of
* usages to keep, since news displays marked fluctuations in volume on a
* 7-day cycle.
*/
struct dbzconfig {
int olddbz; /* .dir file empty but .pag not? */
of_t tsize; /* table size */
#ifndef NMEMORY
#define NMEMORY 10 /* # days of use info to remember */
#endif
#define NUSEDS (1+NMEMORY)
of_t used[NUSEDS]; /* entries used today, yesterday, ... */
int valuesize; /* size of table values, == SOF */
int bytemap[SOF]; /* byte-order map */
char casemap; /* case-mapping algorithm (see cipoint()) */
char fieldsep; /* field separator in base file, if any */
of_t tagenb; /* unshifted tag-enable bit */
of_t tagmask; /* unshifted tag mask */
int tagshift; /* shift count for tagmask and tagenb */
};
static struct dbzconfig conf;
static int getconf();
static long getno();
static int putconf();
static void mybytemap();
static of_t bytemap();
/*
* Using mmap() is a more efficent way of keeping the .pag file incore. On
* average, it cuts the number of system calls and buffer copies in half. It
* also allows one copy to be shared among many processes without consuming
* any extra resources.
*/
#ifdef MMAP
#include <sys/mman.h>
#ifdef MAP_FILE
#define MAP__ARG (MAP_FILE | MAP_SHARED)
#else
#define MAP__ARG (MAP_SHARED)
#endif
#ifndef INCORE
#define INCORE
#endif
#endif
/*
* For a program that makes many, many references to the database, it is a
* large performance win to keep the table in core, if it will fit. Note that
* this does hurt robustness in the event of crashes, and dbmclose() *must*
* be called to flush the in-core database to disk. The code is prepared to
* deal with the possibility that there isn't enough memory. There *is* an
* assumption that a size_t is big enough to hold the size (in bytes) of one
* table, so dbminit() tries to figure out whether this is possible first.
*
* The preferred way to ask for an in-core table is to do dbzincore(1) before
* dbminit(). The default is not to do it, although -DINCORE overrides this
* for backward compatibility with old dbz.
*
* We keep only the first table in core. This greatly simplifies the code, and
* bounds memory demand. Furthermore, doing this is a large performance win
* even in the event of massive overflow.
*/
#ifdef INCORE
static int incore = 1;
#else
static int incore = 0;
#endif
/*
* Write to filesystem even if incore? This replaces a single multi-
* megabyte write when doing a dbzsync with a multi-byte write each time an
* article is added. On most systems, this will give an overall performance
* boost.
*/
static int writethrough = 0;
/*
* Stdio buffer for .pag reads. Buffering more than about 16 does not help
* significantly at the densities we try to maintain, and the much larger
* buffers that most stdios default to are much more expensive to fill. With
* small buffers, stdio is performance-competitive with raw read(), and it's
* much more portable.
*/
#ifndef NPAGBUF
#define NPAGBUF 16
#endif
#ifndef NOBUFFER
#ifdef _IOFBF
static of_t pagbuf[NPAGBUF];/* only needed if !NOBUFFER && _IOFBF */
#endif
#endif
/*
* Stdio buffer for base-file reads. Message-IDs (all news ever needs to
* read) are essentially never longer than 64 bytes, and the typical stdio
* buffer is so much larger that it is much more expensive to fill.
*/
#ifndef SHISTBUF
#define SHISTBUF 64
#endif
#ifdef _IOFBF
static char basebuf[SHISTBUF]; /* only needed if _IOFBF exists */
#endif
/*
* Data structure for recording info about searches.
*/
struct searcher {
of_t place; /* current location in file */
int tabno; /* which table we're in */
int run; /* how long we'll stay in this table */
#ifndef MAXRUN
#define MAXRUN 100
#endif
long hash; /* the key's hash code (for optimization) */
of_t tag; /* tag we are looking for */
int seen; /* have we examined current location? */
int aborted; /* has i/o error aborted search? */
};
static void start();
#define FRESH ((struct searcher *)NULL)
static of_t search();
#define NOTFOUND ((of_t)-1)
static int okayvalue();
static int set();
/*
* Arguably the searcher struct for a given routine ought to be local to it,
* but a fetch() is very often immediately followed by a store(), and in some
* circumstances it is a useful performance win to remember where the fetch()
* completed. So we use a global struct and remember whether it is current.
*/
static struct searcher srch;
static struct searcher *prevp; /* &srch or FRESH */
/* byte-ordering stuff */
static int mybmap[SOF]; /* my byte order (see mybytemap()) */
static int bytesame; /* is database order same as mine? */
#define MAPIN(o) ((bytesame) ? (o) : bytemap((o), conf.bytemap, mybmap))
#define MAPOUT(o) ((bytesame) ? (o) : bytemap((o), mybmap, conf.bytemap))
/*
* The double parentheses needed to make this work are ugly, but the
* alternative (under most compilers) is to pack around 2K of unused strings
* -- there's just no way to get rid of them.
*/
#ifdef DBZDEBUG
static int debug; /* controlled by dbzdebug() */
#define DEBUG(args) if (debug) { (void) printf args ; } else
#else
#define DEBUG(args) ;
#endif
/* externals used */
#if 0
extern char *memcpy();
extern char *memchr();
extern char *malloc();
extern char *calloc();
extern void free(); /* ANSI C; some old implementations say int */
#endif /* 0 */
extern int atoi();
extern long atol();
extern void CloseOnExec();
/* misc. forwards */
static long hash();
static void crcinit();
static char *cipoint();
static char *mapcase();
static int isprime();
static FILE *latebase();
/* file-naming stuff */
static char dir[] = ".dir";
static char pag[] = ".pag";
static char *enstring();
/* central data structures */
static FILE *basef; /* descriptor for base file */
static char *basefname; /* name for not-yet-opened base file */
static FILE *dirf; /* descriptor for .dir file */
static int dirronly; /* dirf open read-only? */
static FILE *pagf = NULL; /* descriptor for .pag file */
static of_t pagpos; /* posn in pagf; only search may set != -1 */
static int pagronly; /* pagf open read-only? */
static of_t *corepag; /* incore version of .pag file, if any */
static FILE *bufpagf; /* well-buffered pagf, for incore rewrite */
static of_t *getcore();
#ifndef MMAP
static int putcore();
#endif
static int written; /* has a store() been done? */
/*
* - dbzfresh - set up a new database, no historical info
*/
int /* 0 success, -1 failure */
dbzfresh(name, size, fs, cmap, tagmask)
char *name; /* base name; .dir and .pag must exist */
long size; /* table size (0 means default) */
int fs; /* field-separator character in base file */
int cmap; /* case-map algorithm (0 means default) */
of_t tagmask; /* 0 default, 1 no tags */
{
register char *fn;
struct dbzconfig c;
register of_t m;
register FILE *f;
if (pagf != NULL) {
DEBUG(("dbzfresh: database already open\n"));
return (-1);
}
if (size != 0 && size < 2) {
DEBUG(("dbzfresh: preposterous size (%ld)\n", size));
return (-1);
}
/* get default configuration */
if (getconf((FILE *) NULL, (FILE *) NULL, &c) < 0)
return (-1); /* "can't happen" */
/* and mess with it as specified */
if (size != 0)
c.tsize = size;
c.fieldsep = fs;
switch (cmap) {
case 0:
case '0':
case 'B': /* 2.10 compat */
c.casemap = '0'; /* '\0' nicer, but '0' printable! */
break;
case '=':
case 'b': /* 2.11 compat */
c.casemap = '=';
break;
case 'C':
c.casemap = 'C';
break;
case '?':
c.casemap = DEFCASE;
break;
default:
DEBUG(("dbzfresh case map `%c' unknown\n", cmap));
return (-1);
}
switch ((int)tagmask) {
case 0: /* default */
break;
case 1: /* no tags */
c.tagshift = 0;
c.tagmask = 0;
c.tagenb = 0;
break;
default:
m = tagmask;
c.tagshift = 0;
while (!(m & 01)) {
m >>= 1;
c.tagshift++;
}
c.tagmask = m;
c.tagenb = (m << 1) & ~m;
break;
}
/* write it out */
fn = enstring(name, dir);
if (fn == NULL)
return (-1);
f = fopen(fn, "w");
free((POINTER) fn);
if (f == NULL) {
DEBUG(("dbzfresh: unable to write config\n"));
return (-1);
}
if (putconf(f, &c) < 0) {
(void)fclose(f);
return (-1);
}
if (fclose(f) == EOF) {
DEBUG(("dbzfresh: fclose failure\n"));
return (-1);
}
/* create/truncate .pag */
fn = enstring(name, pag);
if (fn == NULL)
return (-1);
f = fopen(fn, "w");
free((POINTER) fn);
if (f == NULL) {
DEBUG(("dbzfresh: unable to create/truncate .pag file\n"));
return (-1);
} else
(void)fclose(f);
/* and punt to dbminit for the hard work */
return (dbminit(name));
}
/*
* - dbzsize - what's a good table size to hold this many entries?
*/
long
dbzsize(contents)
long contents; /* 0 means what's the default */
{
register long n;
if (contents <= 0) { /* foulup or default inquiry */
DEBUG(("dbzsize: preposterous input (%ld)\n", contents));
return (DEFSIZE);
}
n = (contents / 2) * 3; /* try to keep table at most 2/3 full */
if (!(n & 01)) /* make it odd */
n++;
DEBUG(("dbzsize: tentative size %ld\n", n));
while (!isprime(n)) /* and look for a prime */
n += 2;
DEBUG(("dbzsize: final size %ld\n", n));
return (n);
}
/*
* - isprime - is a number prime?
*
* This is not a terribly efficient approach.
*/
static int /* predicate */
isprime(x)
register long x;
{
static int quick[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 0};
register int *ip;
register long div;
register long stop;
/* hit the first few primes quickly to eliminate easy ones */
/* this incidentally prevents ridiculously small tables */
for (ip = quick; (div = *ip) != 0; ip++)
if (x % div == 0) {
DEBUG(("isprime: quick result on %ld\n", (long)x));
return (0);
}
/* approximate square root of x */
for (stop = x; x / stop < stop; stop >>= 1)
continue;
stop <<= 1;
/* try odd numbers up to stop */
for (div = *--ip; div < stop; div += 2)
if (x % div == 0)
return (0);
return (1);
}
/*
* - dbzagain - set up a new database to be a rebuild of an old one
*/
int /* 0 success, -1 failure */
dbzagain(name, oldname)
char *name; /* base name; .dir and .pag must exist */
char *oldname; /* base name; all must exist */
{
register char *fn;
struct dbzconfig c;
register int i;
register long top;
register FILE *f;
register int newtable;
register of_t newsize;
struct stat sb;
register of_t m;
if (pagf != NULL) {
DEBUG(("dbzagain: database already open\n"));
return (-1);
}
/* pick up the old configuration */
fn = enstring(oldname, dir);
if (fn == NULL)
return (-1);
f = fopen(fn, "r");
free((POINTER) fn);
if (f == NULL) {
DEBUG(("dbzagain: cannot open old .dir file\n"));
return (-1);
}
i = getconf(f, (FILE *) NULL, &c);
(void)fclose(f);
if (i < 0) {
DEBUG(("dbzagain: getconf failed\n"));
return (-1);
}
/* calculate tagging from old file */
if (stat(oldname, &sb) != -1) {
for (m = 1, i = 0; m < sb.st_size; i++, m <<= 1)
continue;
/* if we had more tags than the default, use the new data */
if ((c.tagmask | c.tagenb) && m > (1 << TAGSHIFT)) {
c.tagshift = i;
c.tagmask = (~(unsigned long)0) >> (i + 1);
c.tagenb = (c.tagmask << 1) & ~c.tagmask;
}
}
/* tinker with it */
top = 0;
newtable = 0;
for (i = 0; i < NUSEDS; i++) {
if (top < c.used[i])
top = c.used[i];
if (c.used[i] == 0)
newtable = 1; /* hasn't got full usage history yet */
}
if (top == 0) {
DEBUG(("dbzagain: old table has no contents!\n"));
newtable = 1;
}
for (i = NUSEDS - 1; i > 0; i--)
c.used[i] = c.used[i - 1];
c.used[0] = 0;
newsize = dbzsize(top);
if (!newtable || newsize > c.tsize) /* don't shrink new table */
c.tsize = newsize;
/* write it out */
fn = enstring(name, dir);
if (fn == NULL)
return (-1);
f = fopen(fn, "w");
free((POINTER) fn);
if (f == NULL) {
DEBUG(("dbzagain: unable to write new .dir\n"));
return (-1);
}
i = putconf(f, &c);
(void)fclose(f);
if (i < 0) {
DEBUG(("dbzagain: putconf failed\n"));
return (-1);
}
/* create/truncate .pag */
fn = enstring(name, pag);
if (fn == NULL)
return (-1);
f = fopen(fn, "w");
free((POINTER) fn);
if (f == NULL) {
DEBUG(("dbzagain: unable to create/truncate .pag file\n"));
return (-1);
} else
(void)fclose(f);
/* and let dbminit do the work */
return (dbminit(name));
}
/*
* - dbminit - open a database, creating it (using defaults) if necessary
*
* We try to leave errno set plausibly, to the extent that underlying functions
* permit this, since many people consult it if dbminit() fails.
*/
int /* 0 success, -1 failure */
dbminit(name)
char *name;
{
register int i;
register size_t s;
register char *dirfname;
register char *pagfname;
if (pagf != NULL) {
DEBUG(("dbminit: dbminit already called once\n"));
errno = 0;
return (-1);
}
/* open the .dir file */
dirfname = enstring(name, dir);
if (dirfname == NULL)
return (-1);
dirf = fopen(dirfname, "r+");
if (dirf == NULL) {
dirf = fopen(dirfname, "r");
dirronly = 1;
} else
dirronly = 0;
free((POINTER) dirfname);
if (dirf == NULL) {
DEBUG(("dbminit: can't open .dir file\n"));
return (-1);
}
CloseOnExec((int)fileno(dirf), 1);
/* open the .pag file */
pagfname = enstring(name, pag);
if (pagfname == NULL) {
(void)fclose(dirf);
return (-1);
}
pagf = fopen(pagfname, "r+b");
if (pagf == NULL) {
pagf = fopen(pagfname, "rb");
if (pagf == NULL) {
DEBUG(("dbminit: .pag open failed\n"));
(void)fclose(dirf);
free((POINTER) pagfname);
return (-1);
}
pagronly = 1;
} else if (dirronly)
pagronly = 1;
else
pagronly = 0;
if (pagf != NULL)
CloseOnExec((int)fileno(pagf), 1);
#ifdef NOBUFFER
/*
* B News does not do adequate locking on its database accesses. Why it
* doesn't get into trouble using dbm is a mystery. In any case, doing
* unbuffered i/o does not cure the problem, but does enormously reduce
* its incidence.
*/
(void)setbuf(pagf, (char *)NULL);
#else
#ifdef _IOFBF
(void)setvbuf(pagf, (char *)pagbuf, _IOFBF, sizeof(pagbuf));
#endif
#endif
pagpos = -1;
/* don't free pagfname, need it below */
/* open the base file */
basef = fopen(name, "r");
if (basef == NULL) {
DEBUG(("dbminit: basefile open failed\n"));
basefname = enstring(name, "");
if (basefname == NULL) {
(void)fclose(pagf);
(void)fclose(dirf);
free((POINTER) pagfname);
pagf = NULL;
return (-1);
}
} else
basefname = NULL;
if (basef != NULL)
CloseOnExec((int)fileno(basef), 1);
#ifdef _IOFBF
if (basef != NULL)
(void)setvbuf(basef, basebuf, _IOFBF, sizeof(basebuf));
#endif
/* pick up configuration */
if (getconf(dirf, pagf, &conf) < 0) {
DEBUG(("dbminit: getconf failure\n"));
(void)fclose(basef);
(void)fclose(pagf);
(void)fclose(dirf);
free((POINTER) pagfname);
pagf = NULL;
errno = EDOM; /* kind of a kludge, but very portable */
return (-1);
}
tagbits = conf.tagmask << conf.tagshift;
taghere = conf.tagenb << conf.tagshift;
tagboth = tagbits | taghere;
mybytemap(mybmap);
bytesame = 1;
for (i = 0; i < SOF; i++)
if (mybmap[i] != conf.bytemap[i])
bytesame = 0;
/* get first table into core, if it looks desirable and feasible */
s = (size_t) conf.tsize * SOF;
if (incore && (of_t) (s / SOF) == conf.tsize) {
bufpagf = fopen(pagfname, (pagronly) ? "rb" : "r+b");
if (bufpagf != NULL) {
corepag = getcore(bufpagf);
CloseOnExec((int)fileno(bufpagf), 1);
}
} else {
bufpagf = NULL;
corepag = NULL;
}
free((POINTER) pagfname);
/* misc. setup */
crcinit();
written = 0;
prevp = FRESH;
DEBUG(("dbminit: succeeded\n"));
return (0);
}
/*
* - enstring - concatenate two strings into a malloced area
*/
static char * /* NULL if malloc fails */
enstring(s1, s2)
char *s1;
char *s2;
{
register char *p;
p = malloc((size_t) strlen(s1) + (size_t) strlen(s2) + 1);
if (p != NULL) {
(void)strcpy(p, s1);
(void)strcat(p, s2);
} else {
DEBUG(("enstring(%s, %s) out of memory\n", s1, s2));
}
return (p);
}
/*
* - dbmclose - close a database
*/
int
dbmclose()
{
register int ret = 0;
if (pagf == NULL) {
DEBUG(("dbmclose: not opened!\n"));
return (-1);
}
if (fclose(pagf) == EOF) {
DEBUG(("dbmclose: fclose(pagf) failed\n"));
ret = -1;
}
pagf = basef; /* ensure valid pointer; dbzsync checks it */
if (dbzsync() < 0)
ret = -1;
if (bufpagf != NULL && fclose(bufpagf) == EOF) {
DEBUG(("dbmclose: fclose(bufpagf) failed\n"));
ret = -1;
}
if (corepag != NULL)
#ifdef MMAP
if (munmap((caddr_t) corepag, (int)conf.tsize * SOF) == -1) {
DEBUG(("dbmclose: munmap failed\n"));
ret = -1;
}
#else
free((POINTER) corepag);
#endif
corepag = NULL;
if (basef) {
if (fclose(basef) == EOF) {
DEBUG(("dbmclose: fclose(basef) failed\n"));
ret = -1;
}
}
if (basefname != NULL)
free((POINTER) basefname);
basef = NULL;
pagf = NULL;
if (fclose(dirf) == EOF) {
DEBUG(("dbmclose: fclose(dirf) failed\n"));
ret = -1;
}
DEBUG(("dbmclose: %s\n", (ret == 0) ? "succeeded" : "failed"));
return (ret);
}
/*
* - dbzsync - push all in-core data out to disk
*/
int
dbzsync()
{
register int ret = 0;
if (pagf == NULL) {
DEBUG(("dbzsync: not opened!\n"));
return (-1);
}
if (!written)
return (0);
#ifndef MMAP
if (corepag != NULL && !writethrough) {
if (putcore(corepag, bufpagf) < 0) {
DEBUG(("dbzsync: putcore failed\n"));
ret = -1;
}
}
#endif
if (!conf.olddbz)
if (putconf(dirf, &conf) < 0)
ret = -1;
DEBUG(("dbzsync: %s\n", (ret == 0) ? "succeeded" : "failed"));
return (ret);
}
/*
* - dbzcancel - cancel writing of in-core data Mostly for use from child
* processes. Note that we don't need to futz around with stdio buffers,
* because we always fflush them immediately anyway and so they never have
* stale data.
*/
int
dbzcancel()
{
if (pagf == NULL) {
DEBUG(("dbzcancel: not opened!\n"));
return (-1);
}
written = 0;
return (0);
}
/*
* - dbzfetch - fetch() with case mapping built in
*/
datum
dbzfetch(key)
datum key;
{
char buffer[DBZMAXKEY + 1];
datum mappedkey;
register size_t keysize;
DEBUG(("dbzfetch: (%s)\n", key.dptr));
/* Key is supposed to be less than DBZMAXKEY */
keysize = key.dsize;
if (keysize >= DBZMAXKEY) {
keysize = DBZMAXKEY;
DEBUG(("keysize is %d - truncated to %d\n", key.dsize, DBZMAXKEY));
}
mappedkey.dptr = mapcase(buffer, key.dptr, keysize);
buffer[keysize] = '\0'; /* just a debug aid */
mappedkey.dsize = keysize;
return (fetch(mappedkey));
}
/*
* - fetch - get an entry from the database
*
* Disgusting fine point, in the name of backward compatibility: if the last
* character of "key" is a NUL, that character is (effectively) not part of
* the comparison against the stored keys.
*/
datum /* dptr NULL, dsize 0 means failure */
fetch(key)
datum key;
{
char buffer[DBZMAXKEY + 1];
static of_t key_ptr; /* return value points here */
datum output;
register size_t keysize;
register size_t cmplen;
register char *sepp;
DEBUG(("fetch: (%s)\n", key.dptr));
output.dptr = NULL;
output.dsize = 0;
prevp = FRESH;
/* Key is supposed to be less than DBZMAXKEY */
keysize = key.dsize;
if (keysize >= DBZMAXKEY) {
keysize = DBZMAXKEY;
DEBUG(("keysize is %d - truncated to %d\n", key.dsize, DBZMAXKEY));
}
if (pagf == NULL) {
DEBUG(("fetch: database not open!\n"));
return (output);
} else if (basef == NULL) { /* basef didn't exist yet */
basef = latebase();
if (basef == NULL)
return (output);
}
cmplen = keysize;
sepp = &conf.fieldsep;
if (key.dptr[keysize - 1] == '\0') {
cmplen--;
sepp = &buffer[keysize - 1];
}
start(&srch, &key, FRESH);
while ((key_ptr = search(&srch)) != NOTFOUND) {
DEBUG(("got 0x%lx\n", key_ptr));
/* fetch the key */
if (fseek(basef, key_ptr, SEEK_SET) != 0) {
DEBUG(("fetch: seek failed\n"));
return (output);
}
if (fread((POINTER) buffer, 1, keysize, basef) != keysize) {
DEBUG(("fetch: read failed\n"));
return (output);
}
/* try it */
buffer[keysize] = '\0'; /* terminated for DEBUG */
(void)mapcase(buffer, buffer, keysize);
DEBUG(("fetch: buffer (%s) looking for (%s) size = %ld\n",
buffer, key.dptr, (long)keysize));
if (memcmp((POINTER) key.dptr, (POINTER) buffer, cmplen) == 0 &&
(*sepp == conf.fieldsep || *sepp == '\0')) {
/* we found it */
output.dptr = (char *)&key_ptr;
output.dsize = SOF;
DEBUG(("fetch: successful\n"));
return (output);
}
}
/* we didn't find it */
DEBUG(("fetch: failed\n"));
prevp = &srch; /* remember where we stopped */
return (output);
}
/*
* - latebase - try to open a base file that wasn't there at the start
*/
static FILE *
latebase()
{
register FILE *it;
if (basefname == NULL) {
DEBUG(("latebase: name foulup\n"));
return (NULL);
}
it = fopen(basefname, "r");
if (it == NULL) {
DEBUG(("latebase: still can't open base\n"));
} else {
DEBUG(("latebase: late open succeeded\n"));
free((POINTER) basefname);
basefname = NULL;
#ifdef _IOFBF
(void)setvbuf(it, basebuf, _IOFBF, sizeof(basebuf));
#endif
}
if (it != NULL)
CloseOnExec((int)fileno(it), 1);
return (it);
}
/*
* - dbzstore - store() with case mapping built in
*/
int
dbzstore(key, data)
datum key;
datum data;
{
char buffer[DBZMAXKEY + 1];
datum mappedkey;
register size_t keysize;
DEBUG(("dbzstore: (%s)\n", key.dptr));
/* Key is supposed to be less than DBZMAXKEY */
keysize = key.dsize;
if (keysize >= DBZMAXKEY) {
DEBUG(("dbzstore: key size too big (%d)\n", key.dsize));
return (-1);
}
mappedkey.dptr = mapcase(buffer, key.dptr, keysize);
buffer[keysize] = '\0'; /* just a debug aid */
mappedkey.dsize = keysize;
return (store(mappedkey, data));
}
/*
* - store - add an entry to the database
*/
int /* 0 success, -1 failure */
store(key, data)
datum key;
datum data;
{
of_t value;
if (pagf == NULL) {
DEBUG(("store: database not open!\n"));
return (-1);
} else if (basef == NULL) { /* basef didn't exist yet */
basef = latebase();
if (basef == NULL)
return (-1);
}
if (pagronly) {
DEBUG(("store: database open read-only\n"));
return (-1);
}
if (data.dsize != SOF) {
DEBUG(("store: value size wrong (%d)\n", data.dsize));
return (-1);
}
if (key.dsize >= DBZMAXKEY) {
DEBUG(("store: key size too big (%d)\n", key.dsize));
return (-1);
}
/* copy the value in to ensure alignment */
(void)memcpy((POINTER) & value, (POINTER) data.dptr, SOF);
DEBUG(("store: (%s, %ld)\n", key.dptr, (long)value));
if (!okayvalue(value)) {
DEBUG(("store: reserved bit or overflow in 0x%lx\n", value));
return (-1);
}
/* find the place, exploiting previous search if possible */
start(&srch, &key, prevp);
while (search(&srch) != NOTFOUND)
continue;
prevp = FRESH;
conf.used[0]++;
DEBUG(("store: used count %ld\n", conf.used[0]));
written = 1;
return (set(&srch, value));
}
/*
* - dbzincore - control attempts to keep .pag file in core
*/
int /* old setting */
dbzincore(value)
int value;
{
register int old = incore;
#ifndef MMAP
incore = value;
#endif
return (old);
}
/*
* - dbzwritethrough - write through the pag file in core
*/
int /* old setting */
dbzwritethrough(value)
int value;
{
register int old = writethrough;
writethrough = value;
return (old);
}
/*
* - dbztagmask - calculate the correct tagmask for the given base file size
*/
long
dbztagmask(size)
register long size;
{
register long m;
register long tagmask;
register int i;
if (size <= 0)
return (0L); /* silly size */
for (m = 1, i = 0; m < size; i++, m <<= 1)
continue;
if (m < (1 << TAGSHIFT))
return (0L); /* not worth tagging */
tagmask = (~(unsigned long)0) >> (i + 1);
tagmask = tagmask << i;
return (tagmask);
}
/*
* - getconf - get configuration from .dir file
*/
static int /* 0 success, -1 failure */
getconf(df, pf, cp)
register FILE *df; /* NULL means just give me the default */
register FILE *pf; /* NULL means don't care about .pag */
register struct dbzconfig *cp;
{
register int c;
register int i;
int err = 0;
c = (df != NULL) ? getc(df) : EOF;
if (c == EOF) { /* empty file, no configuration known */
cp->olddbz = 0;
if (df != NULL && pf != NULL && getc(pf) != EOF)
cp->olddbz = 1;
cp->tsize = DEFSIZE;
cp->fieldsep = '\t';
for (i = 0; i < NUSEDS; i++)
cp->used[i] = 0;
cp->valuesize = SOF;
mybytemap(cp->bytemap);
cp->casemap = DEFCASE;
cp->tagenb = TAGENB;
cp->tagmask = TAGMASK;
cp->tagshift = TAGSHIFT;
DEBUG(("getconf: defaults (%ld, %c, (0x%lx/0x%lx<<%d))\n",
cp->tsize, cp->casemap, cp->tagenb,
cp->tagmask, cp->tagshift));
return (0);
}
(void)ungetc(c, df);
/* first line, the vital stuff */
if (getc(df) != 'd' || getc(df) != 'b' || getc(df) != 'z')
err = -1;
if (getno(df, &err) != dbzversion)
err = -1;
cp->tsize = getno(df, &err);
cp->fieldsep = (int)getno(df, &err);
while ((c = getc(df)) == ' ')
continue;
cp->casemap = c;
cp->tagenb = getno(df, &err);
cp->tagmask = getno(df, &err);
cp->tagshift = getno(df, &err);
cp->valuesize = getno(df, &err);
if (cp->valuesize != SOF) {
DEBUG(("getconf: wrong of_t size (%d)\n", cp->valuesize));
err = -1;
cp->valuesize = SOF; /* to protect the loops below */
}
for (i = 0; i < cp->valuesize; i++)
cp->bytemap[i] = getno(df, &err);
if (getc(df) != '\n')
err = -1;
#ifdef DBZDEBUG
DEBUG(("size %ld, sep %d, cmap %c, tags 0x%lx/0x%lx<<%d, ", cp->tsize,
cp->fieldsep, cp->casemap, cp->tagenb, cp->tagmask,
cp->tagshift));
DEBUG(("bytemap (%d)", cp->valuesize));
for (i = 0; i < cp->valuesize; i++) {
DEBUG((" %d", cp->bytemap[i]));
}
DEBUG(("\n"));
#endif
/* second line, the usages */
for (i = 0; i < NUSEDS; i++)
cp->used[i] = getno(df, &err);
if (getc(df) != '\n')
err = -1;
DEBUG(("used %ld %ld %ld...\n", cp->used[0], cp->used[1], cp->used[2]));
if (err < 0) {
DEBUG(("getconf error\n"));
return (-1);
}
return (0);
}
/*
* - getno - get a long
*/
static long
getno(f, ep)
FILE *f;
int *ep;
{
register char *p;
#define MAXN 50
char getbuf[MAXN];
register int c;
while ((c = getc(f)) == ' ')
continue;
if (c == EOF || c == '\n') {
DEBUG(("getno: missing number\n"));
*ep = -1;
return (0);
}
p = getbuf;
*p++ = c;
while ((c = getc(f)) != EOF && c != '\n' && c != ' ')
if (p < &getbuf[MAXN - 1])
*p++ = c;
if (c == EOF) {
DEBUG(("getno: EOF\n"));
*ep = -1;
} else
(void)ungetc(c, f);
*p = '\0';
if (strspn(getbuf, "-1234567890") != strlen(getbuf)) {
DEBUG(("getno: `%s' non-numeric\n", getbuf));
*ep = -1;
}
return (atol(getbuf));
}
/*
* - putconf - write configuration to .dir file
*/
static int /* 0 success, -1 failure */
putconf(f, cp)
register FILE *f;
register struct dbzconfig *cp;
{
register int i;
register int ret = 0;
if (fseek(f, (of_t) 0, SEEK_SET) != 0) {
DEBUG(("fseek failure in putconf\n"));
ret = -1;
}
(void)fprintf(f, "dbz %d %ld %d %c %ld %ld %d %d", dbzversion, cp->tsize,
cp->fieldsep, cp->casemap, cp->tagenb,
cp->tagmask, cp->tagshift, cp->valuesize);
for (i = 0; i < cp->valuesize; i++)
(void)fprintf(f, " %d", cp->bytemap[i]);
(void)fprintf(f, "\n");
for (i = 0; i < NUSEDS; i++)
(void)fprintf(f, "%ld%c", cp->used[i], (i < NUSEDS - 1) ? ' ' : '\n');
(void)fflush(f);
if (ferror(f))
ret = -1;
DEBUG(("putconf status %d\n", ret));
return (ret);
}
/*
* - getcore - try to set up an in-core copy of .pag file
*/
static of_t * /* pointer to copy, or NULL */
getcore(f)
FILE *f;
{
register char *it;
#ifdef MMAP
struct stat st;
if (fstat(fileno(f), &st) == -1) {
DEBUG(("getcore: fstat failed\n"));
return (NULL);
}
if (((size_t) conf.tsize * SOF) > st.st_size) {
/* file too small; extend it */
if (ftruncate((int)fileno(f), conf.tsize * SOF) == -1) {
DEBUG(("getcore: ftruncate failed\n"));
return (NULL);
}
}
it = mmap((caddr_t) 0, (size_t) conf.tsize * SOF,
pagronly ? PROT_READ : PROT_WRITE | PROT_READ, MAP__ARG,
(int)fileno(f), (off_t) 0);
if (it == (char *)-1) {
DEBUG(("getcore: mmap failed\n"));
return (NULL);
}
#ifdef MC_ADVISE
/* not present in all versions of mmap() */
madvise(it, (size_t) conf.tsize * SOF, MADV_RANDOM);
#endif
#else
register of_t *p;
register size_t i;
register size_t nread;
it = malloc((size_t) conf.tsize * SOF);
if (it == NULL) {
DEBUG(("getcore: malloc failed\n"));
return (NULL);
}
nread = fread((POINTER) it, SOF, (size_t) conf.tsize, f);
if (ferror(f)) {
DEBUG(("getcore: read failed\n"));
free((POINTER) it);
return (NULL);
}
/* NOSTRICT *//* Possible pointer alignment problem */
p = (of_t *) it + nread;
i = (size_t) conf.tsize - nread;
while (i-- > 0)
*p++ = VACANT;
#endif
/* NOSTRICT *//* Possible pointer alignment problem */
return ((of_t *) it);
}
#ifndef MMAP
/*
* - putcore - try to rewrite an in-core table
*/
static int /* 0 okay, -1 fail */
putcore(tab, f)
of_t *tab;
FILE *f;
{
if (fseek(f, (of_t) 0, SEEK_SET) != 0) {
DEBUG(("fseek failure in putcore\n"));
return (-1);
}
(void)fwrite((POINTER) tab, SOF, (size_t) conf.tsize, f);
(void)fflush(f);
return ((ferror(f)) ? -1 : 0);
}
#endif
/*
* - start - set up to start or restart a search
*/
static void
start(sp, kp, osp)
register struct searcher *sp;
register datum *kp;
register struct searcher *osp; /* may be FRESH, i.e. NULL */
{
register long h;
h = hash(kp->dptr, kp->dsize);
if (osp != FRESH && osp->hash == h) {
if (sp != osp)
*sp = *osp;
DEBUG(("search restarted\n"));
} else {
sp->hash = h;
sp->tag = MKTAG(h / conf.tsize);
DEBUG(("tag 0x%lx\n", sp->tag));
sp->place = h % conf.tsize;
sp->tabno = 0;
sp->run = (conf.olddbz) ? conf.tsize : MAXRUN;
sp->aborted = 0;
}
sp->seen = 0;
}
/*
* - search - conduct part of a search
*/
static of_t /* NOTFOUND if we hit VACANT or error */
search(sp)
register struct searcher *sp;
{
register of_t dest;
register of_t value;
of_t val; /* buffer for value (can't fread register) */
register of_t place;
if (sp->aborted)
return (NOTFOUND);
for (;;) {
/* determine location to be examined */
place = sp->place;
if (sp->seen) {
/* go to next location */
if (--sp->run <= 0) {
sp->tabno++;
sp->run = MAXRUN;
}
place = (place + 1) % conf.tsize + sp->tabno * conf.tsize;
sp->place = place;
} else
sp->seen = 1; /* now looking at current location */
DEBUG(("search @ %ld\n", place));
/* get the tagged value */
if (corepag != NULL && place < conf.tsize) {
DEBUG(("search: in core\n"));
value = MAPIN(corepag[place]);
} else {
/* seek, if necessary */
dest = place * SOF;
if (pagpos != dest) {
if (fseek(pagf, dest, SEEK_SET) != 0) {
DEBUG(("search: seek failed\n"));
pagpos = -1;
sp->aborted = 1;
return (NOTFOUND);
}
pagpos = dest;
}
/* read it */
if (fread((POINTER) & val, sizeof(val), 1, pagf) == 1)
value = MAPIN(val);
else if (ferror(pagf)) {
DEBUG(("search: read failed\n"));
pagpos = -1;
sp->aborted = 1;
return (NOTFOUND);
} else
value = VACANT;
/* and finish up */
pagpos += sizeof(val);
}
/* vacant slot is always cause to return */
if (value == VACANT) {
DEBUG(("search: empty slot\n"));
return (NOTFOUND);
};
/* check the tag */
value = UNBIAS(value);
DEBUG(("got 0x%lx\n", value));
if (!HASTAG(value)) {
DEBUG(("tagless\n"));
return (value);
} else if (TAG(value) == sp->tag) {
DEBUG(("match\n"));
return (NOTAG(value));
} else {
DEBUG(("mismatch 0x%lx\n", TAG(value)));
}
}
/* NOTREACHED */
}
/*
* - okayvalue - check that a value can be stored
*/
static int /* predicate */
okayvalue(value)
of_t value;
{
if (HASTAG(value))
return (0);
#ifdef OVERFLOW
if (value == LONG_MAX) /* BIAS() and UNBIAS() will overflow */
return (0);
#endif
return (1);
}
/*
* - set - store a value into a location previously found by search
*/
static int /* 0 success, -1 failure */
set(sp, value)
register struct searcher *sp;
of_t value;
{
register of_t place = sp->place;
register of_t v = value;
if (sp->aborted)
return (-1);
if (CANTAG(v) && !conf.olddbz) {
v |= sp->tag | taghere;
if (v != UNBIAS(VACANT))/* BIAS(v) won't look VACANT */
#ifdef OVERFLOW
if (v != LONG_MAX) /* and it won't overflow */
#endif
value = v;
}
DEBUG(("tagged value is 0x%lx\n", value));
value = BIAS(value);
value = MAPOUT(value);
/* If we have the index file in memory, use it */
if (corepag != NULL && place < conf.tsize) {
corepag[place] = value;
DEBUG(("set: incore\n"));
#ifdef MMAP
return (0);
#else
if (!writethrough)
return (0);
#endif
}
/* seek to spot */
pagpos = -1; /* invalidate position memory */
if (fseek(pagf, (of_t) (place * SOF), SEEK_SET) != 0) {
DEBUG(("set: seek failed\n"));
sp->aborted = 1;
return (-1);
}
/* write in data */
if (fwrite((POINTER) & value, SOF, 1, pagf) != 1) {
DEBUG(("set: write failed\n"));
sp->aborted = 1;
return (-1);
}
/* fflush improves robustness, and buffer re-use is rare anyway */
if (fflush(pagf) == EOF) {
DEBUG(("set: fflush failed\n"));
sp->aborted = 1;
return (-1);
}
DEBUG(("set: succeeded\n"));
return (0);
}
/*
* - mybytemap - determine this machine's byte map
*
* A byte map is an array of ints, sizeof(of_t) of them. The 0th int is the
* byte number of the high-order byte in my of_t, and so forth.
*/
static void
mybytemap(map)
int map[]; /* -> int[SOF] */
{
union {
of_t o;
char c[SOF];
} u;
register int *mp = &map[SOF];
register int ntodo;
register int i;
u.o = 1;
for (ntodo = (int)SOF; ntodo > 0; ntodo--) {
for (i = 0; i < SOF; i++)
/* SUPPRESS 112 *//* Retrieving char where long is stored */
if (u.c[i] != 0)
break;
if (i == SOF) {
/* trouble -- set it to *something* consistent */
DEBUG(("mybytemap: nonexistent byte %d!!!\n", ntodo));
for (i = 0; i < SOF; i++)
map[i] = i;
return;
}
DEBUG(("mybytemap: byte %d\n", i));
*--mp = i;
/* SUPPRESS 112 *//* Retrieving char where long is stored */
while (u.c[i] != 0)
u.o <<= 1;
}
}
/*
* - bytemap - transform an of_t from byte ordering map1 to map2
*/
static of_t /* transformed result */
bytemap(ino, map1, map2)
of_t ino;
int *map1;
int *map2;
{
union oc {
of_t o;
char c[SOF];
};
union oc in;
union oc out;
register int i;
in.o = ino;
for (i = 0; i < SOF; i++)
out.c[map2[i]] = in.c[map1[i]];
return (out.o);
}
/*
* This is a simplified version of the pathalias hashing function. Thanks to
* Steve Belovin and Peter Honeyman
*
* hash a string into a long int. 31 bit crc (from andrew appel). the crc table
* is computed at run time by crcinit() -- we could precompute, but it takes
* 1 clock tick on a 750.
*
* This fast table calculation works only if POLY is a prime polynomial in the
* field of integers modulo 2. Since the coefficients of a 32-bit polynomial
* won't fit in a 32-bit word, the high-order bit is implicit. IT MUST ALSO
* BE THE CASE that the coefficients of orders 31 down to 25 are zero.
* Happily, we have candidates, from E. J. Watson, "Primitive Polynomials
* (Mod 2)", Math. Comp. 16 (1962): x^32 + x^7 + x^5 + x^3 + x^2 + x^1 + x^0
* x^31 + x^3 + x^0
*
* We reverse the bits to get: 111101010000000000000000000000001 but drop the
* last 1 f 5 0 0 0 0 0 0 010010000000000000000000000000001
* ditto, for 31-bit crc 4 8 0 0 0 0 0 0
*/
#define POLY 0x48000000L /* 31-bit polynomial (avoids sign problems) */
static long CrcTable[128];
/*
* - crcinit - initialize tables for hash function
*/
static void
crcinit()
{
register int i, j;
register long sum;
for (i = 0; i < 128; ++i) {
sum = 0L;
for (j = 7 - 1; j >= 0; --j)
if (i & (1 << j))
sum ^= POLY >> j;
CrcTable[i] = sum;
}
DEBUG(("crcinit: done\n"));
}
/*
* - hash - Honeyman's nice hashing function
*/
static long
hash(name, size)
register char *name;
register int size;
{
register long sum = 0L;
while (size--) {
sum = (sum >> 7) ^ CrcTable[(sum ^ (*name++)) & 0x7f];
}
DEBUG(("hash: returns (%ld)\n", sum));
return (sum);
}
/*
* case-mapping stuff
*
* Borrowed from C News, by permission of the authors. Somewhat modified.
*
* We exploit the fact that we are dealing only with headers here, and headers
* are limited to the ASCII characters by RFC822. It is barely possible that
* we might be dealing with a translation into another character set, but in
* particular it's very unlikely for a header character to be outside
* -128..255.
*
* Life would be a whole lot simpler if tolower() could safely and portably be
* applied to any char.
*/
#define OFFSET 128 /* avoid trouble with negative chars */
/* must call casencmp before invoking TOLOW... */
#define TOLOW(c) (cmap[(c)+OFFSET])
/* ...but the use of it in CISTREQN is safe without the preliminary call (!) */
/* CISTREQN is an optimised case-insensitive strncmp(a,b,n)==0; n > 0 */
#define CISTREQN(a, b, n) \
(TOLOW((a)[0]) == TOLOW((b)[0]) && casencmp(a, b, n) == 0)
#define MAPSIZE (256+OFFSET)
static char cmap[MAPSIZE]; /* relies on init to '\0' */
static int mprimed = 0; /* has cmap been set up? */
/*
* - mapprime - set up case-mapping stuff
*/
static void
mapprime()
{
register char *lp;
register char *up;
register int c;
register int i;
static char lower[] = "abcdefghijklmnopqrstuvwxyz";
static char upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (lp = lower, up = upper; *lp != '\0'; lp++, up++) {
c = *lp;
cmap[c + OFFSET] = c;
cmap[*up + OFFSET] = c;
}
for (i = 0; i < MAPSIZE; i++)
if (cmap[i] == '\0')
cmap[i] = (char)(i - OFFSET);
mprimed = 1;
}
/*
* - casencmp - case-independent strncmp
*/
static int /* < == > 0 */
casencmp(s1, s2, len)
char *s1;
char *s2;
int len;
{
register char *p1;
register char *p2;
register int n;
if (!mprimed)
mapprime();
p1 = s1;
p2 = s2;
n = len;
while (--n >= 0 && *p1 != '\0' && TOLOW(*p1) == TOLOW(*p2)) {
p1++;
p2++;
}
if (n < 0)
return (0);
/*
* The following case analysis is necessary so that characters which look
* negative collate low against normal characters but high against the
* end-of-string NUL.
*/
if (*p1 == '\0' && *p2 == '\0')
return (0);
else if (*p1 == '\0')
return (-1);
else if (*p2 == '\0')
return (1);
else
return (TOLOW(*p1) - TOLOW(*p2));
}
/*
* - mapcase - do case-mapped copy
*/
static char * /* returns src or dst */
mapcase(dst, src, siz)
char *dst; /* destination, used only if mapping needed */
char *src; /* source; src == dst is legal */
size_t siz;
{
register char *s;
register char *d;
register char *c; /* case break */
register char *e; /* end of source */
c = cipoint(src, siz);
if (c == NULL)
return (src);
if (!mprimed)
mapprime();
s = src;
e = s + siz;
d = dst;
while (s < c)
*d++ = *s++;
while (s < e)
*d++ = TOLOW(*s++);
return (dst);
}
/*
* - cipoint - where in this message-ID does it become case-insensitive?
*
* The RFC822 code is not quite complete. Absolute, total, full RFC822
* compliance requires a horrible parsing job, because of the arcane quoting
* conventions -- abc"def"ghi is not equivalent to abc"DEF"ghi, for example.
* There are three or four things that might occur in the domain part of a
* message-id that are case-sensitive. They don't seem to ever occur in real
* news, thank Cthulhu. (What? You were expecting a merciful and forgiving
* deity to be invoked in connection with RFC822? Forget it; none of them
* would come near it.)
*/
static char * /* pointer into s, or NULL for "nowhere" */
cipoint(s, siz)
char *s;
size_t siz;
{
register char *p;
static char post[] = "postmaster";
static int plen = sizeof(post) - 1;
switch (conf.casemap) {
case '0': /* unmapped, sensible */
return (NULL);
case 'C': /* C News, RFC 822 conformant (approx.) */
p = memchr((POINTER) s, '@', siz);
if (p == NULL) /* no local/domain split */
return (NULL); /* assume all local */
if (p - (s + 1) == plen && CISTREQN(s + 1, post, plen)) {
/* crazy -- "postmaster" is case-insensitive */
return (s);
}
return (p);
case '=': /* 2.11, neither sensible nor conformant */
return (s); /* all case-insensitive */
}
DEBUG(("cipoint: unknown case mapping `%c'\n", conf.casemap));
return (NULL); /* just leave it alone */
}
/*
* - dbzdebug - control dbz debugging at run time
*/
#ifdef DBZDEBUG
int /* old value */
dbzdebug(value)
int value;
{
register int old = debug;
debug = value;
return (old);
}
#endif
