summaryrefslogtreecommitdiffstats
path: root/innbbsd/dbz.c
diff options
context:
space:
mode:
Diffstat (limited to 'innbbsd/dbz.c')
-rw-r--r--innbbsd/dbz.c2791
1 files changed, 1379 insertions, 1412 deletions
diff --git a/innbbsd/dbz.c b/innbbsd/dbz.c
index 6fd15df8..58616968 100644
--- a/innbbsd/dbz.c
+++ b/innbbsd/dbz.c
@@ -1,33 +1,32 @@
/*
-
-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.
-
-*/
+ * 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>
@@ -35,26 +34,24 @@ if the incore facility is used.
#include <ctype.h>
#include <errno.h>
#ifndef __STDC__
-extern int errno;
+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
+ *
+ * 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)
+ * 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
@@ -72,35 +69,35 @@ extern int errno;
#include <limits.h>
#endif
-static int dbzversion = 3; /* for validating .dir file format */
+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.
- *
+ * 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.
- *
+ * 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.)
+ * desirable to be a bit conservative because the overflow strategy tends to
+ * produce files with holes in them, which is a nuisance.)
*/
/*
@@ -112,41 +109,40 @@ static int dbzversion = 3; /* for validating .dir file format */
/*
* 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,
+ * 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.
+ * 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 */
+#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.
+ * 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 */
+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)
@@ -154,9 +150,9 @@ static of_t tagboth; /* tagbits|taghere */
#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.
+ * 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 */
@@ -183,42 +179,42 @@ static of_t tagboth; /* tagbits|taghere */
#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.
+ * 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 */
+ 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();
+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.
+ * 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>
@@ -232,51 +228,50 @@ static of_t bytemap();
#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.
+/*
+ * 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;
+static int incore = 1;
#else
-static int incore = 0;
+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.
+ * 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;
+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.
+ * 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 */
+static of_t pagbuf[NPAGBUF];/* only needed if !NOBUFFER && _IOFBF */
#endif
#endif
@@ -289,54 +284,53 @@ static of_t pagbuf[NPAGBUF]; /* only needed if !NOBUFFER && _IOFBF */
#define SHISTBUF 64
#endif
#ifdef _IOFBF
-static char basebuf[SHISTBUF]; /* only needed if _IOFBF exists */
+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? */
+ 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();
+static void start();
#define FRESH ((struct searcher *)NULL)
-static of_t search();
+static of_t search();
#define NOTFOUND ((of_t)-1)
-static int okayvalue();
-static int set();
+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.
+ * 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? */
+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.
+ * 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() */
+static int debug; /* controlled by dbzdebug() */
#define DEBUG(args) if (debug) { (void) printf args ; } else
#else
#define DEBUG(args) ;
@@ -344,1409 +338,1382 @@ static int debug; /* controlled by dbzdebug() */
/* 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();
+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();
+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();
+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();
+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();
+static int putcore();
#endif
-static int written; /* has a store() been done? */
+static int written; /* has a store() been done? */
/*
- - dbzfresh - set up a new database, no historical info
+ * - 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 */
+ 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));
+ 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?
+ * - dbzsize - what's a good table size to hold this many entries?
*/
long
dbzsize(contents)
-long contents; /* 0 means what's the default */
+ 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);
+ 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?
- *
+ * - isprime - is a number prime?
+ *
* This is not a terribly efficient approach.
*/
static int /* predicate */
isprime(x)
-register long 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);
+ 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
+ * - 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 */
+ 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));
+ 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.
+ * - 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 */
+int /* 0 success, -1 failure */
dbminit(name)
-char *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");
+ 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) {
- 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);
+ 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);
+ /*
+ * 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));
+ (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);
+ 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));
+ 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);
+ /* 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
+ * - enstring - concatenate two strings into a malloced area
*/
-static char * /* NULL if malloc fails */
+static char * /* NULL if malloc fails */
enstring(s1, s2)
-char *s1;
-char *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);
+ 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
+ * - 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)
+ 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;
- }
+ if (munmap((caddr_t) corepag, (int)conf.tsize * SOF) == -1) {
+ DEBUG(("dbmclose: munmap failed\n"));
+ ret = -1;
+ }
#else
- free((POINTER)corepag);
+ 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);
+ 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
+ * - dbzsync - push all in-core data out to disk
*/
int
dbzsync()
{
- register int ret = 0;
+ register int ret = 0;
- if (pagf == NULL) {
- DEBUG(("dbzsync: not opened!\n"));
- return(-1);
- }
- if (!written)
- return(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;
- }
+ 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;
+ if (!conf.olddbz)
+ if (putconf(dirf, &conf) < 0)
+ ret = -1;
- DEBUG(("dbzsync: %s\n", (ret == 0) ? "succeeded" : "failed"));
- return(ret);
+ 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.
+ * - 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);
+ if (pagf == NULL) {
+ DEBUG(("dbzcancel: not opened!\n"));
+ return (-1);
+ }
+ written = 0;
+ return (0);
}
/*
- - dbzfetch - fetch() with case mapping built in
+ * - dbzfetch - fetch() with case mapping built in
*/
datum
dbzfetch(key)
-datum 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));
+ 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.
+ * - 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;
+ 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 = %d\n",
- buffer, key.dptr, 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);
+ 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 = %d\n",
+ buffer, key.dptr, 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
+ * - latebase - try to open a base file that wasn't there at the start
*/
-static FILE *
+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;
+ 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));
+ (void)setvbuf(it, basebuf, _IOFBF, sizeof(basebuf));
#endif
- }
- if (it != NULL)
- CloseOnExec((int)fileno(it), 1);
- return(it);
+ }
+ if (it != NULL)
+ CloseOnExec((int)fileno(it), 1);
+ return (it);
}
/*
- - dbzstore - store() with case mapping built in
+ * - dbzstore - store() with case mapping built in
*/
int
dbzstore(key, data)
-datum key;
-datum 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));
+ 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
+ * - store - add an entry to the database
*/
int /* 0 success, -1 failure */
store(key, data)
-datum key;
-datum 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));
+ 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
+ * - dbzincore - control attempts to keep .pag file in core
*/
int /* old setting */
dbzincore(value)
-int value;
+ int value;
{
- register int old = incore;
+ register int old = incore;
#ifndef MMAP
- incore = value;
+ incore = value;
#endif
- return(old);
+ return (old);
}
/*
- - dbzwritethrough - write through the pag file in core
+ * - dbzwritethrough - write through the pag file in core
*/
int /* old setting */
dbzwritethrough(value)
-int value;
+ int value;
{
- register int old = writethrough;
+ register int old = writethrough;
- writethrough = value;
- return(old);
+ writethrough = value;
+ return (old);
}
/*
- - dbztagmask - calculate the correct tagmask for the given base file size
+ * - dbztagmask - calculate the correct tagmask for the given base file size
*/
long
dbztagmask(size)
-register long size;
+ register long size;
{
- register long m;
- register long tagmask;
- register int i;
+ register long m;
+ register long tagmask;
+ register int i;
- if (size <= 0)
- return(0L); /* silly size */
+ if (size <= 0)
+ return (0L); /* silly size */
- for (m = 1, i = 0; m < size; i++, m <<= 1)
- continue;
+ for (m = 1, i = 0; m < size; i++, m <<= 1)
+ continue;
- if (m < (1 << TAGSHIFT))
- return(0L); /* not worth tagging */
+ if (m < (1 << TAGSHIFT))
+ return (0L); /* not worth tagging */
- tagmask = (~(unsigned long)0) >> (i + 1);
- tagmask = tagmask << i;
- return(tagmask);
+ tagmask = (~(unsigned long)0) >> (i + 1);
+ tagmask = tagmask << i;
+ return (tagmask);
}
/*
- - getconf - get configuration from .dir file
+ * - 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 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;
+ 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"));
+ 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);
+ /* 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
+ * - getno - get a long
*/
static long
getno(f, ep)
-FILE *f;
-int *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));
+ 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
+ * - putconf - write configuration to .dir file
*/
static int /* 0 success, -1 failure */
putconf(f, cp)
-register FILE *f;
-register struct dbzconfig *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);
+ 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
+ * - getcore - try to set up an in-core copy of .pag file
*/
-static of_t * /* pointer to copy, or NULL */
+static of_t * /* pointer to copy, or NULL */
getcore(f)
-FILE *f;
+ FILE *f;
{
- register of_t *p;
- register size_t i;
- register size_t nread;
- register char *it;
+ register of_t *p;
+ register size_t i;
+ register size_t nread;
+ 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);
- }
+ 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);
+ /* not present in all versions of mmap() */
+ madvise(it, (size_t) conf.tsize * SOF, MADV_RANDOM);
#endif
#else
- 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;
+ 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);
+ /* NOSTRICT *//* Possible pointer alignment problem */
+ return ((of_t *) it);
}
#ifndef MMAP
/*
- - putcore - try to rewrite an in-core table
+ * - putcore - try to rewrite an in-core table
*/
static int /* 0 okay, -1 fail */
putcore(tab, f)
-of_t *tab;
-FILE *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);
+ 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
+ * - 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 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;
+ 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
+ * - search - conduct part of a search
*/
-static of_t /* NOTFOUND if we hit VACANT or error */
+static of_t /* NOTFOUND if we hit VACANT or error */
search(sp)
-register struct searcher *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);
- }
+ 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));
- /* 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)));
+ /* 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 */
+ }
+ /* NOTREACHED */
}
/*
- - okayvalue - check that a value can be stored
+ * - okayvalue - check that a value can be stored
*/
static int /* predicate */
okayvalue(value)
-of_t value;
+ of_t value;
{
- if (HASTAG(value))
- return(0);
+ if (HASTAG(value))
+ return (0);
#ifdef OVERFLOW
- if (value == LONG_MAX) /* BIAS() and UNBIAS() will overflow */
- return(0);
+ if (value == LONG_MAX) /* BIAS() and UNBIAS() will overflow */
+ return (0);
#endif
- return(1);
+ return (1);
}
/*
- - set - store a value into a location previously found by search
+ * - 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 struct searcher *sp;
+ of_t value;
{
- register of_t place = sp->place;
- register of_t v = value;
+ register of_t place = sp->place;
+ register of_t v = value;
- if (sp->aborted)
- return(-1);
+ if (sp->aborted)
+ return (-1);
- if (CANTAG(v) && !conf.olddbz) {
- v |= sp->tag | taghere;
- if (v != UNBIAS(VACANT)) /* BIAS(v) won't look VACANT */
+ 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 */
+ 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"));
+ 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);
+ return (0);
#else
- if (!writethrough)
- return(0);
+ 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);
+ }
+ /* 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.
+ * - 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] */
+ 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;
- }
+ 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
+ * - bytemap - transform an of_t from byte ordering map1 to map2
*/
-static of_t /* transformed result */
+static of_t /* transformed result */
bytemap(ino, map1, map2)
-of_t ino;
-int *map1;
-int *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);
+ 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
+ * 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];
+static long CrcTable[128];
/*
- - crcinit - initialize tables for hash function
+ * - 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"));
+ 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
+ * - hash - Honeyman's nice hashing function
*/
static long
hash(name, size)
-register char *name;
-register int size;
+ register char *name;
+ register int size;
{
- register long sum = 0L;
+ register long sum = 0L;
- while (size--) {
- sum = (sum >> 7) ^ CrcTable[(sum ^ (*name++)) & 0x7f];
- }
- DEBUG(("hash: returns (%ld)\n", sum));
- return(sum);
+ 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.
+ *
+ * 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 */
@@ -1760,159 +1727,159 @@ register int size;
(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? */
+static char cmap[MAPSIZE]; /* relies on init to '\0' */
+static int mprimed = 0; /* has cmap been set up? */
/*
- - mapprime - set up case-mapping stuff
+ * - 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;
+ 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
+ * - casencmp - case-independent strncmp
*/
static int /* < == > 0 */
casencmp(s1, s2, len)
-char *s1;
-char *s2;
-int 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));
+ 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
+ * - mapcase - do case-mapped copy
*/
-static char * /* returns src or dst */
+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;
+ 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 */
+ 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);
+ c = cipoint(src, siz);
+ if (c == NULL)
+ return (src);
- if (!mprimed)
- mapprime();
- s = src;
- e = s + siz;
- d = dst;
+ if (!mprimed)
+ mapprime();
+ s = src;
+ e = s + siz;
+ d = dst;
- while (s < c)
- *d++ = *s++;
- while (s < e)
- *d++ = TOLOW(*s++);
+ while (s < c)
+ *d++ = *s++;
+ while (s < e)
+ *d++ = TOLOW(*s++);
- return(dst);
+ return (dst);
}
/*
- - cipoint - where in this message-ID does it become case-insensitive?
- *
+ * - 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.)
+ * 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" */
+static char * /* pointer into s, or NULL for "nowhere" */
cipoint(s, siz)
-char *s;
-size_t 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 */
+ 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
+ * - dbzdebug - control dbz debugging at run time
*/
#ifdef DBZDEBUG
int /* old value */
dbzdebug(value)
-int value;
+ int value;
{
- register int old = debug;
+ register int old = debug;
- debug = value;
- return(old);
+ debug = value;
+ return (old);
}
#endif