home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume19 / cnews2 / pch15apr90 < prev    next >
Internet Message Format  |  1990-06-07  |  47KB
  1. From @uunet.uu.net:henry@zoo.toronto.edu Wed Apr 18 21:37:02 1990
  2. Received: from BBN.COM by pineapple.bbn.com id <AA15487@pineapple.bbn.com>; Wed, 18 Apr 90 21:36:45 -0400
  3. Received: from uunet.UU.NET by BBN.COM id aa01864; 18 Apr 90 21:33 EDT
  4. Received: from zoo.utoronto.ca by uunet.uu.net (5.61/1.14) with SMTP 
  5.     id AA17933; Wed, 18 Apr 90 16:58:38 -0400
  6. Message-Id: <9004182058.AA17933@uunet.uu.net>
  7. From: henry@zoo.toronto.edu
  8. Date: Wed, 18 Apr 90 16:54:48 EDT
  9. To: uunet!source-patches@uunet.uu.net
  10. Newsgroups: news.software.b,comp.sources.bugs
  11. Subject: C News patch of 15-Apr-1990
  12. Status: R
  13.  
  14. This is the second of three (!) patches mostly constituting the new dbz.
  15.  
  16. start of patch 15-Apr-1990
  17. (suggested archive name: `pch15Apr90.Z')
  18. this should be run with   patch -p0 <thisfile
  19.  
  20. The following is a complete list of patches to date.
  21.  
  22. Prereq: 23-Jun-1989
  23. Prereq: 7-Jul-1989
  24. Prereq: 23-Jul-1989
  25. Prereq: 22-Aug-1989
  26. Prereq: 24-Aug-1989
  27. Prereq: 14-Sep-1989
  28. Prereq: 13-Nov-1989
  29. Prereq: 10-Jan-1990
  30. Prereq: 16-Jan-1990
  31. Prereq: 17-Jan-1990
  32. Prereq: 18-Jan-1990
  33. Prereq: 12-Mar-1990
  34. Prereq: 14-Apr-1990
  35. *** PATCHDATES.old    Sat Apr 14 20:24:28 1990
  36. --- PATCHDATES    Sat Apr 14 20:24:28 1990
  37. ***************
  38. *** 1,13 ****
  39. --- 1,14 ----
  40.   23-Jun-1989
  41.   7-Jul-1989
  42.   23-Jul-1989
  43.   22-Aug-1989
  44.   24-Aug-1989
  45.   14-Sep-1989
  46.   13-Nov-1989
  47.   10-Jan-1990
  48.   16-Jan-1990
  49.   17-Jan-1990
  50.   18-Jan-1990
  51.   12-Mar-1990
  52.   14-Apr-1990
  53. + 15-Apr-1990
  54.  
  55. new dbz/dbz.c (patch can't create, so diff against null):
  56. Index: dbz/dbz.c
  57. *** cnpatch/old/dbz/dbz.c    Sat Apr 14 20:29:06 1990
  58. --- dbz/dbz.c    Thu Apr 12 16:52:15 1990
  59. ***************
  60. *** 0 ****
  61. --- 1,1708 ----
  62. + /*
  63. + 
  64. + dbz.c  V3.0
  65. + 
  66. + Copyright 1988 Jon Zeeff (zeeff@b-tech.ann-arbor.mi.us)
  67. + You can use this code in any manner, as long as you leave my name on it
  68. + and don't hold me responsible for any problems with it.
  69. + 
  70. + Hacked on by gdb@ninja.UUCP (David Butler); Sun Jun  5 00:27:08 CDT 1988
  71. + 
  72. + Various improvments + INCORE by moraes@ai.toronto.edu (Mark Moraes)
  73. + 
  74. + Major reworking by Henry Spencer as part of the C News project.
  75. + 
  76. + These routines replace dbm as used by the usenet news software
  77. + (it's not a full dbm replacement by any means).  It's fast and
  78. + simple.  It contains no AT&T code.
  79. + 
  80. + In general, dbz's files are 1/20 the size of dbm's.  Lookup performance
  81. + is somewhat better, while file creation is spectacularly faster, especially
  82. + if the incore facility is used.
  83. + 
  84. + */
  85. + 
  86. + #include <stdio.h>
  87. + #include <sys/types.h>
  88. + #include <string.h>
  89. + #include <ctype.h>
  90. + #include <dbz.h>
  91. + 
  92. + /*
  93. +  * #ifdef index.  "LIA" = "leave it alone unless you know what you're doing".
  94. +  *
  95. +  * FUNNYSEEKS    SEEK_SET is not 0, get it from <unistd.h>
  96. +  * INDEX_SIZE    backward compatibility with old dbz; avoid using this
  97. +  * NMEMORY    number of days of memory for use in sizing new table (LIA)
  98. +  * INCORE    backward compatibility with old dbz; use dbzincore() instead
  99. +  * DBZDEBUG    enable debugging
  100. +  * DEFSIZE    default table size (not as critical as in old dbz)
  101. +  * OLDBNEWS    default case mapping as in old B News
  102. +  * BNEWS    default case mapping as in current B News
  103. +  * DEFCASE    default case-map algorithm selector
  104. +  * NOTAGS    fseek offsets are strange, do not do tagging (see below)
  105. +  * NPAGBUF    size of .pag buffer, in longs (LIA)
  106. +  * SHISTBUF    size of ASCII-file buffer, in bytes (LIA)
  107. +  * MAXRUN    length of run which shifts to next table (see below) (LIA)
  108. +  * OVERFLOW    long-int arithmetic overflow must be avoided, will trap
  109. +  */
  110. + 
  111. + #ifdef FUNNYSEEKS
  112. + #include <unistd.h>
  113. + #else
  114. + #define    SEEK_SET    0
  115. + #endif
  116. + #ifdef OVERFLOW
  117. + #include <limits.h>
  118. + #endif
  119. + 
  120. + static int dbzversion = 3;    /* for validating .dir file format */
  121. + 
  122. + /*
  123. +  * The dbz database exploits the fact that when news stores a <key,value>
  124. +  * tuple, the `value' part is a seek offset into a text file, pointing to
  125. +  * a copy of the `key' part.  This avoids the need to store a copy of
  126. +  * the key in the dbz files.  However, the text file *must* exist and be
  127. +  * consistent with the dbz files, or things will fail.
  128. +  *
  129. +  * The basic format of the database is a simple hash table containing the
  130. +  * values.  A value is stored by indexing into the table using a hash value
  131. +  * computed from the key; collisions are resolved by linear probing (just
  132. +  * search forward for an empty slot, wrapping around to the beginning of
  133. +  * the table if necessary).  Linear probing is a performance disaster when
  134. +  * the table starts to get full, so a complication is introduced.  The
  135. +  * database is actually one *or more* tables, stored sequentially in the
  136. +  * .pag file, and the length of linear-probe sequences is limited.  The
  137. +  * search (for an existing item or an empty slot) always starts in the
  138. +  * first table, and whenever MAXRUN probes have been done in table N,
  139. +  * probing continues in table N+1.  This behaves reasonably well even in
  140. +  * cases of massive overflow.  There are some other small complications
  141. +  * added, see comments below.
  142. +  *
  143. +  * The table size is fixed for any particular database, but is determined
  144. +  * dynamically when a database is rebuilt.  The strategy is to try to pick
  145. +  * the size so the first table will be no more than 75% full, that being
  146. +  * about the point where performance starts to degrade.
  147. +  */
  148. + 
  149. + /*
  150. +  * The following is for backward compatibility.
  151. +  */
  152. + #ifdef INDEX_SIZE
  153. + #define    DEFSIZE    INDEX_SIZE
  154. + #endif
  155. + 
  156. + /*
  157. +  * ANSI C says an offset into a file is a long, not an off_t, for some
  158. +  * reason.  This actually does simplify life a bit, but it's still nice
  159. +  * to have a distinctive name for it.  Beware, this is just for readability,
  160. +  * don't try to change this.
  161. +  */
  162. + #define    of_t    long
  163. + #define    SOF    (sizeof(of_t))
  164. + 
  165. + /*
  166. +  * We assume that unused areas of a binary file are zeros, and that the
  167. +  * bit pattern of `(of_t)0' is all zeros.  The alternative is rather
  168. +  * painful file initialization.  Note that okayvalue(), if OVERFLOW is
  169. +  * defined, knows what value of an offset would cause overflow.
  170. +  */
  171. + #define    VACANT        ((of_t)0)
  172. + #define    BIAS(o)        ((o)+1)        /* make any valid of_t non-VACANT */
  173. + #define    UNBIAS(o)    ((o)-1)        /* reverse BIAS() effect */
  174. + 
  175. + /*
  176. +  * In a Unix implementation, or indeed any in which an of_t is a byte
  177. +  * count, there are a bunch of high bits free in an of_t.  There is a
  178. +  * use for them.  Checking a possible hit by looking it up in the base
  179. +  * file is relatively expensive, and the cost can be dramatically reduced
  180. +  * by using some of those high bits to tag the value with a few more bits
  181. +  * of the key's hash.  This detects most false hits without the overhead of
  182. +  * seek+read+strcmp.  We use the top bit to indicate whether the value is
  183. +  * tagged or not, and don't tag a value which is using the tag bits itself.
  184. +  * We're in trouble if the of_t representation wants to use the top bit.
  185. +  * The actual bitmasks and offset come from the configuration stuff,
  186. +  * which permits fiddling with them as necessary, and also suppressing
  187. +  * them completely (by defining the masks to 0).  We build pre-shifted
  188. +  * versions of the masks for efficiency.
  189. +  */
  190. + static of_t tagbits;        /* pre-shifted tag mask */
  191. + static of_t taghere;        /* pre-shifted tag-enable bit */
  192. + static of_t tagboth;        /* tagbits|taghere */
  193. + #define    HASTAG(o)    ((o)&taghere)
  194. + #define    TAG(o)        ((o)&tagbits)
  195. + #define    NOTAG(o)    ((o)&~tagboth)
  196. + #define    CANTAG(o)    (((o)&tagboth) == 0)
  197. + #define    MKTAG(v)    (((v)<<conf.tagshift)&tagbits)
  198. + 
  199. + /*
  200. +  * A new, from-scratch database, not built as a rebuild of an old one,
  201. +  * needs to know table size, casemap algorithm, and tagging.  Normally
  202. +  * the user supplies this info, but there have to be defaults.
  203. +  */
  204. + #ifndef DEFSIZE
  205. + #define    DEFSIZE    120011        /* 300007 might be better */
  206. + #endif
  207. + #ifdef OLDBNEWS
  208. + #define    DEFCASE    '0'        /* B2.10 -- no mapping */
  209. + #endif
  210. + #ifdef BNEWS
  211. + #define    DEFCASE    '='        /* B2.11 -- all mapped */
  212. + #endif
  213. + #ifndef DEFCASE            /* C News compatibility is the default */
  214. + #define    DEFCASE    'C'        /* C News -- RFC822 mapping */
  215. + #endif
  216. + #ifndef NOTAGS
  217. + #define    TAGENB    0x80        /* tag enable is top bit, tag is next 7 */
  218. + #define    TAGMASK    0x7f
  219. + #define    TAGSHIFT    24
  220. + #else
  221. + #define    TAGENB    0        /* no tags */
  222. + #define    TAGMASK    0
  223. + #define    TAGSHIFT    0
  224. + #endif
  225. + 
  226. + /*
  227. +  * We read configuration info from the .dir file into this structure,
  228. +  * so we can avoid wired-in assumptions for an existing database.
  229. +  *
  230. +  * Among the info is a record of recent peak usages, so that a new table
  231. +  * size can be chosen intelligently when rebuilding.  10 is a good
  232. +  * number of usages to keep, since news displays marked fluctuations
  233. +  * in volume on a 7-day cycle.
  234. +  */
  235. + struct dbzconfig {
  236. +     int olddbz;        /* .dir file empty but .pag not? */
  237. +     of_t tsize;        /* table size */
  238. + #    ifndef NMEMORY
  239. + #    define    NMEMORY    10    /* # days of use info to remember */
  240. + #    endif
  241. + #    define    NUSEDS    (1+NMEMORY)
  242. +     of_t used[NUSEDS];    /* entries used today, yesterday, ... */
  243. +     int valuesize;        /* size of table values, == SOF */
  244. +     int bytemap[SOF];    /* byte-order map */
  245. +     char casemap;        /* case-mapping algorithm (see cipoint()) */
  246. +     char fieldsep;        /* field separator in base file, if any */
  247. +     of_t tagenb;        /* unshifted tag-enable bit */
  248. +     of_t tagmask;        /* unshifted tag mask */
  249. +     int tagshift;        /* shift count for tagmask and tagenb */
  250. + };
  251. + static struct dbzconfig conf;
  252. + static int getconf();
  253. + static long getno();
  254. + static int putconf();
  255. + static void mybytemap();
  256. + static of_t bytemap();
  257. + 
  258. + /* 
  259. +  * For a program that makes many, many references to the database, it
  260. +  * is a large performance win to keep the table in core, if it will fit.
  261. +  * Note that this does hurt robustness in the event of crashes, and
  262. +  * dbmclose() *must* be called to flush the in-core database to disk.
  263. +  * The code is prepared to deal with the possibility that there isn't
  264. +  * enough memory.  There *is* an assumption that a size_t is big enough
  265. +  * to hold the size (in bytes) of one table, so dbminit() tries to figure
  266. +  * out whether this is possible first.
  267. +  *
  268. +  * The preferred way to ask for an in-core table is to do dbzincore(1)
  269. +  * before dbminit().  The default is not to do it, although -DINCORE
  270. +  * overrides this for backward compatibility with old dbz.
  271. +  *
  272. +  * We keep only the first table in core.  This greatly simplifies the
  273. +  * code, and bounds memory demand.  Furthermore, doing this is a large
  274. +  * performance win even in the event of massive overflow.
  275. +  */
  276. + #ifdef INCORE
  277. + static int incore = 1;
  278. + #else
  279. + static int incore = 0;
  280. + #endif
  281. + 
  282. + /*
  283. +  * Stdio buffer for .pag reads.  Buffering more than about 16 does not help
  284. +  * significantly at the densities we try to maintain, and the much larger
  285. +  * buffers that most stdios default to are much more expensive to fill.
  286. +  * With small buffers, stdio is performance-competitive with raw read(),
  287. +  * and it's much more portable.
  288. +  */
  289. + #ifndef NPAGBUF
  290. + #define    NPAGBUF    16
  291. + #endif
  292. + static of_t pagbuf[NPAGBUF];
  293. + 
  294. + /*
  295. +  * Stdio buffer for base-file reads.  Message-IDs (all news ever needs to
  296. +  * read) are essentially never longer than 64 bytes, and the typical stdio
  297. +  * buffer is so much larger that it is much more expensive to fill.
  298. +  */
  299. + #ifndef SHISTBUF
  300. + #define    SHISTBUF    64
  301. + #endif
  302. + static char basebuf[SHISTBUF];
  303. + 
  304. + /*
  305. +  * Data structure for recording info about searches.
  306. +  */
  307. + struct searcher {
  308. +     of_t place;        /* current location in file */
  309. +     int tabno;        /* which table we're in */
  310. +     int run;        /* how long we'll stay in this table */
  311. + #        ifndef MAXRUN
  312. + #        define    MAXRUN    100
  313. + #        endif
  314. +     long hash;        /* the key's hash code (for optimization) */
  315. +     of_t tag;        /* tag we are looking for */
  316. +     int seen;        /* have we examined current location? */
  317. +     int aborted;        /* has i/o error aborted search? */
  318. + };
  319. + static void start();
  320. + #define    FRESH    ((struct searcher *)NULL)
  321. + static of_t search();
  322. + #define    NOTFOUND    ((of_t)-1)
  323. + static int okayvalue();
  324. + static int set();
  325. + 
  326. + /*
  327. +  * Arguably the searcher struct for a given routine ought to be local to
  328. +  * it, but a fetch() is very often immediately followed by a store(), and
  329. +  * in some circumstances it is a useful performance win to remember where
  330. +  * the fetch() completed.  So we use a global struct and remember whether
  331. +  * it is current.
  332. +  */
  333. + static struct searcher srch;
  334. + static struct searcher *prevp;    /* &srch or FRESH */
  335. + 
  336. + /* byte-ordering stuff */
  337. + static int mybmap[SOF];            /* my byte order (see mybytemap()) */
  338. + static int bytesame;            /* is database order same as mine? */
  339. + #define    MAPIN(o)    ((bytesame) ? (o) : bytemap((o), conf.bytemap, mybmap))
  340. + #define    MAPOUT(o)    ((bytesame) ? (o) : bytemap((o), mybmap, conf.bytemap))
  341. + 
  342. + /*
  343. +  * The double parentheses needed to make this work are ugly, but the
  344. +  * alternative (under most compilers) is to pack around 2K of unused
  345. +  * strings -- there's just no way to get rid of them.
  346. +  */
  347. + static int debug;            /* controlled by dbzdebug() */
  348. + #ifdef DBZDEBUG
  349. + #define DEBUG(args) if (debug) { (void) printf args ; }
  350. + #else
  351. + #define    DEBUG(args)    ;
  352. + #endif
  353. + 
  354. + /* externals used */
  355. + extern char *malloc();
  356. + extern char *calloc();
  357. + extern void free();        /* ANSI C; some old implementations say int */
  358. + extern int atoi();
  359. + extern long atol();
  360. + extern char *memcpy();        /* in case string.h doesn't do mem fns */
  361. + extern char *memchr();
  362. + 
  363. + /* misc. forwards */
  364. + static long hash();
  365. + static void crcinit();
  366. + static char *cipoint();
  367. + static char *mapcase();
  368. + static int isprime();
  369. + static FILE *latebase();
  370. + 
  371. + /* file-naming stuff */
  372. + static char dir[] = ".dir";
  373. + static char pag[] = ".pag";
  374. + static char *enstring();
  375. + 
  376. + /* central data structures */
  377. + static FILE *basef;        /* descriptor for base file */
  378. + static char *basefname;        /* name for not-yet-opened base file */
  379. + static FILE *dirf;        /* descriptor for .dir file */
  380. + static int dirronly;        /* dirf open read-only? */
  381. + static FILE *pagf = NULL;    /* descriptor for .pag file */
  382. + static of_t pagpos;        /* posn in pagf; only search may set != -1 */
  383. + static int pagronly;        /* pagf open read-only? */
  384. + static of_t *corepag;        /* incore version of .pag file, if any */
  385. + static FILE *bufpagf;        /* well-buffered pagf, for incore rewrite */
  386. + static of_t *getcore();
  387. + static int putcore();
  388. + static int written;        /* has a store() been done? */
  389. + 
  390. + /*
  391. +  - dbzfresh - set up a new database, no historical info
  392. +  */
  393. + int                /* 0 success, -1 failure */
  394. + dbzfresh(name, size, fs, cmap, tagmask)
  395. + char *name;            /* base name; .dir and .pag must exist */
  396. + long size;            /* table size (0 means default) */
  397. + int fs;                /* field-separator character in base file */
  398. + int cmap;            /* case-map algorithm (0 means default) */
  399. + of_t tagmask;            /* 0 default, 1 no tags */
  400. + {
  401. +     register char *fn;
  402. +     struct dbzconfig c;
  403. +     register of_t m;
  404. +     register FILE *f;
  405. + 
  406. +     if (pagf != NULL) {
  407. +         DEBUG(("dbzfresh: database already open\n"));
  408. +         return(-1);
  409. +     }
  410. +     if (size != 0 && size < 2) {
  411. +         DEBUG(("dbzfresh: preposterous size (%ld)\n", size));
  412. +         return(-1);
  413. +     }
  414. + 
  415. +     /* get default configuration */
  416. +     if (getconf((FILE *)NULL, (FILE *)NULL, &c) < 0)
  417. +         return(-1);    /* "can't happen" */
  418. + 
  419. +     /* and mess with it as specified */
  420. +     if (size != 0)
  421. +         c.tsize = size;
  422. +     c.fieldsep = fs;
  423. +     switch (cmap) {
  424. +     case 0:
  425. +     case '0':
  426. +     case 'B':        /* 2.10 compat */
  427. +         c.casemap = '0';    /* '\0' nicer, but '0' printable! */
  428. +         break;
  429. +     case '=':
  430. +     case 'b':        /* 2.11 compat */
  431. +         c.casemap = '=';
  432. +         break;
  433. +     case 'C':
  434. +         c.casemap = 'C';
  435. +         break;
  436. +     case '?':
  437. +         c.casemap = DEFCASE;
  438. +         break;
  439. +     default:
  440. +         DEBUG(("dbzfresh case map `%c' unknown\n", cmap));
  441. +         return(-1);
  442. +         break;
  443. +     }
  444. +     switch (tagmask) {
  445. +     case 0:            /* default */
  446. +         break;
  447. +     case 1:            /* no tags */
  448. +         c.tagshift = 0;
  449. +         c.tagmask = 0;
  450. +         c.tagenb = 0;
  451. +         break;
  452. +     default:
  453. +         m = tagmask;
  454. +         c.tagshift = 0;
  455. +         while (!(m&01)) {
  456. +             m >>= 1;
  457. +             c.tagshift++;
  458. +         }
  459. +         c.tagmask = m;
  460. +         c.tagenb = (m << 1) & ~m;
  461. +         break;
  462. +     }
  463. + 
  464. +     /* write it out */
  465. +     fn = enstring(name, dir);
  466. +     if (fn == NULL)
  467. +         return(-1);
  468. +     f = fopen(fn, "w");
  469. +     free(fn);
  470. +     if (f == NULL) {
  471. +         DEBUG(("dbzfresh: unable to write config\n"));
  472. +         return(-1);
  473. +     }
  474. +     if (putconf(f, &c) < 0) {
  475. +         (void) fclose(f);
  476. +         return(-1);
  477. +     }
  478. +     if (fclose(f) == EOF) {
  479. +         DEBUG(("dbzfresh: fclose failure\n"));
  480. +         return(-1);
  481. +     }
  482. + 
  483. +     /* create/truncate .pag */
  484. +     fn = enstring(name, pag);
  485. +     if (fn == NULL)
  486. +         return(-1);
  487. +     f = fopen(fn, "w");
  488. +     free(fn);
  489. +     if (f == NULL) {
  490. +         DEBUG(("dbzfresh: unable to create/truncate .pag file\n"));
  491. +         return(-1);
  492. +     } else
  493. +         (void) fclose(f);
  494. + 
  495. +     /* and punt to dbminit for the hard work */
  496. +     return(dbminit(name));
  497. + }
  498. + 
  499. + /*
  500. +  - dbzsize - what's a good table size to hold this many entries?
  501. +  */
  502. + long
  503. + dbzsize(contents)
  504. + long contents;            /* 0 means what's the default */
  505. + {
  506. +     register long n;
  507. + 
  508. +     if (contents <= 0) {    /* foulup or default inquiry */
  509. +         DEBUG(("dbzsize: preposterous input (%ld)\n", contents));
  510. +         return(DEFSIZE);
  511. +     }
  512. +     n = (contents/3)*4;    /* try to keep table at most 75% full */
  513. +     if (!(n&01))        /* make it odd */
  514. +         n++;
  515. +     DEBUG(("dbzsize: tentative size %ld\n", n));
  516. +     while (!isprime(n))    /* and look for a prime */
  517. +         n += 2;
  518. +     DEBUG(("dbzsize: final size %ld\n", n));
  519. + 
  520. +     return(n);
  521. + }
  522. + 
  523. + /*
  524. +  - isprime - is a number prime?
  525. +  *
  526. +  * This is not a terribly efficient approach.
  527. +  */
  528. + static int            /* predicate */
  529. + isprime(x)
  530. + register long x;
  531. + {
  532. +     static int quick[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 0 };
  533. +     register int *ip;
  534. +     register long div;
  535. +     register long stop;
  536. + 
  537. +     /* hit the first few primes quickly to eliminate easy ones */
  538. +     /* this incidentally prevents ridiculously small tables */
  539. +     for (ip = quick; (div = *ip) != 0; ip++)
  540. +         if (x%div == 0) {
  541. +             DEBUG(("isprime: quick result on %ld\n", (long)x));
  542. +             return(0);
  543. +         }
  544. + 
  545. +     /* approximate square root of x */
  546. +     for (stop = x; x/stop < stop; stop >>= 1)
  547. +         continue;
  548. +     stop <<= 1;
  549. + 
  550. +     /* try odd numbers up to stop */
  551. +     for (div = *--ip; div < stop; div += 2)
  552. +         if (x%div == 0)
  553. +             return(0);
  554. + 
  555. +     return(1);
  556. + }
  557. + 
  558. + /*
  559. +  - dbzagain - set up a new database to be a rebuild of an old one
  560. +  */
  561. + int                /* 0 success, -1 failure */
  562. + dbzagain(name, oldname)
  563. + char *name;            /* base name; .dir and .pag must exist */
  564. + char *oldname;            /* base name; all must exist */
  565. + {
  566. +     register char *fn;
  567. +     struct dbzconfig c;
  568. +     register int i;
  569. +     register long top;
  570. +     register FILE *f;
  571. + 
  572. +     if (pagf != NULL) {
  573. +         DEBUG(("dbzagain: database already open\n"));
  574. +         return(-1);
  575. +     }
  576. + 
  577. +     /* pick up the old configuration */
  578. +     fn = enstring(oldname, dir);
  579. +     if (fn == NULL)
  580. +         return(-1);
  581. +     f = fopen(fn, "r");
  582. +     free(fn);
  583. +     if (f == NULL) {
  584. +         DEBUG(("dbzagain: cannot open old .dir file\n"));
  585. +         return(-1);
  586. +     }
  587. +     i = getconf(f, (FILE *)NULL, &c);
  588. +     (void) fclose(f);
  589. +     if (i < 0) {
  590. +         DEBUG(("dbzagain: getconf failed\n"));
  591. +         return(-1);
  592. +     }
  593. + 
  594. +     /* tinker with it */
  595. +     top = 0;
  596. +     for (i = 0; i < NUSEDS; i++)
  597. +         if (top < c.used[i])
  598. +             top = c.used[i];
  599. +     if (top == 0) {
  600. +         DEBUG(("dbzagain: old table has no contents!\n"));
  601. +         top = c.tsize/4*3;    /* and cross fingers */
  602. +     }
  603. +     for (i = NUSEDS-1; i > 0; i--)
  604. +         c.used[i] = c.used[i-1];
  605. +     c.used[0] = 0;
  606. +     c.tsize = dbzsize(top);
  607. + 
  608. +     /* write it out */
  609. +     fn = enstring(name, dir);
  610. +     if (fn == NULL)
  611. +         return(-1);
  612. +     f = fopen(fn, "w");
  613. +     free(fn);
  614. +     if (f == NULL) {
  615. +         DEBUG(("dbzagain: unable to write new .dir\n"));
  616. +         return(-1);
  617. +     }
  618. +     i = putconf(f, &c);
  619. +     (void) fclose(f);
  620. +     if (i < 0) {
  621. +         DEBUG(("dbzagain: putconf failed\n"));
  622. +         return(-1);
  623. +     }
  624. + 
  625. +     /* create/truncate .pag */
  626. +     fn = enstring(name, pag);
  627. +     if (fn == NULL)
  628. +         return(-1);
  629. +     f = fopen(fn, "w");
  630. +     free(fn);
  631. +     if (f == NULL) {
  632. +         DEBUG(("dbzagain: unable to create/truncate .pag file\n"));
  633. +         return(-1);
  634. +     } else
  635. +         (void) fclose(f);
  636. + 
  637. +     /* and let dbminit do the work */
  638. +     return(dbminit(name));
  639. + }
  640. + 
  641. + /*
  642. +  - dbminit - open a database, creating it (using defaults) if necessary
  643. +  */
  644. + int                 /* 0 success, -1 failure */
  645. + dbminit(name)
  646. + char *name;
  647. + {
  648. +     register int i;
  649. +     register size_t s;
  650. +     register char *dirfname;
  651. +     register char *pagfname;
  652. + 
  653. +     if (pagf != NULL) {
  654. +         DEBUG(("dbminit: dbminit already called once\n"));
  655. +         return(-1);
  656. +     }
  657. + 
  658. +     /* open the .dir file */
  659. +     dirfname = enstring(name, dir);
  660. +     if (dirfname == NULL)
  661. +         return(-1);
  662. +     dirf = fopen(dirfname, "r+");
  663. +     if (dirf == NULL) {
  664. +         dirf = fopen(dirfname, "r");
  665. +         dirronly = 1;
  666. +     } else
  667. +         dirronly = 0;
  668. +     free(dirfname);
  669. +     if (dirf == NULL) {
  670. +         DEBUG(("dbminit: can't open .dir file\n"));
  671. +         return(-1);
  672. +     }
  673. + 
  674. +     /* open the .pag file */
  675. +     pagfname = enstring(name, pag);
  676. +     if (pagfname == NULL) {
  677. +         (void) fclose(dirf);
  678. +         return(-1);
  679. +     }
  680. +     pagf = fopen(pagfname, "r+b");
  681. +     if (pagf == NULL) {
  682. +         pagf = fopen(pagfname, "rb");
  683. +         if (pagf == NULL) {
  684. +             DEBUG(("dbminit: .pag open failed\n"));
  685. +             (void) fclose(dirf);
  686. +             free(pagfname);
  687. +             return(-1);
  688. +         }
  689. +         pagronly = 1;
  690. +     } else if (dirronly)
  691. +         pagronly = 1;
  692. +     else
  693. +         pagronly = 0;
  694. + #ifdef _IOFBF
  695. +     (void) setvbuf(pagf, (char *)pagbuf, _IOFBF, sizeof(pagbuf));
  696. + #endif
  697. +     pagpos = -1;
  698. +     /* don't free pagfname, need it below */
  699. + 
  700. +     /* open the base file */
  701. +     basef = fopen(name, "r");
  702. +     if (basef == NULL) {
  703. +         DEBUG(("dbminit: basefile open failed\n"));
  704. +         basefname = enstring(name, "");
  705. +         if (basefname == NULL) {
  706. +             (void) fclose(pagf);
  707. +             (void) fclose(dirf);
  708. +             free(pagfname);
  709. +             return(-1);
  710. +         }
  711. +     } else
  712. +         basefname = NULL;
  713. + #ifdef _IOFBF
  714. +     if (basef != NULL)
  715. +         (void) setvbuf(basef, basebuf, _IOFBF, sizeof(basebuf));
  716. + #endif
  717. + 
  718. +     /* pick up configuration */
  719. +     if (getconf(dirf, pagf, &conf) < 0) {
  720. +         DEBUG(("dbminit: getconf failure\n"));
  721. +         (void) fclose(basef);
  722. +         (void) fclose(pagf);
  723. +         (void) fclose(dirf);
  724. +         free(pagfname);
  725. +         return(-1);
  726. +     }
  727. +     tagbits = conf.tagmask << conf.tagshift;
  728. +     taghere = conf.tagenb << conf.tagshift;
  729. +     tagboth = tagbits | taghere;
  730. +     mybytemap(mybmap);
  731. +     bytesame = 1;
  732. +     for (i = 0; i < SOF; i++)
  733. +         if (mybmap[i] != conf.bytemap[i])
  734. +             bytesame = 0;
  735. + 
  736. +     /* get first table into core, if it looks desirable and feasible */
  737. +     s = (size_t)conf.tsize * SOF;
  738. +     if (incore && (of_t)(s/SOF) == conf.tsize) {
  739. +         bufpagf = fopen(pagfname, (pagronly) ? "rb" : "r+b");
  740. +         if (bufpagf != NULL)
  741. +             corepag = getcore(bufpagf);
  742. +     } else {
  743. +         bufpagf = NULL;
  744. +         corepag = NULL;
  745. +     }
  746. +     free(pagfname);
  747. + 
  748. +     /* misc. setup */
  749. +     crcinit();
  750. +     written = 0;
  751. +     prevp = FRESH;
  752. +     DEBUG(("dbminit: succeeded\n"));
  753. +     return(0);
  754. + }
  755. + 
  756. + /*
  757. +  - enstring - concatenate two strings into a malloced area
  758. +  */
  759. + static char *            /* NULL if malloc fails */
  760. + enstring(s1, s2)
  761. + char *s1;
  762. + char *s2;
  763. + {
  764. +     register char *p;
  765. + 
  766. +     p = malloc((size_t)strlen(s1) + (size_t)strlen(s2) + 1);
  767. +     if (p != NULL) {
  768. +         (void) strcpy(p, s1);
  769. +         (void) strcat(p, s2);
  770. +     } else {
  771. +         DEBUG(("enstring(%s, %s) out of memory\n", s1, s2));
  772. +     }
  773. +     return(p);
  774. + }
  775. + 
  776. + /*
  777. +  - dbmclose - close a database
  778. +  */
  779. + int
  780. + dbmclose()
  781. + {
  782. +     register int ret = 0;
  783. + 
  784. +     if (pagf == NULL) {
  785. +         DEBUG(("dbmclose: not opened!\n"));
  786. +         return(-1);
  787. +     }
  788. + 
  789. +     if (fclose(pagf) == EOF) {
  790. +         DEBUG(("dbmclose: fclose(pagf) failed\n"));
  791. +         ret = -1;
  792. +     }
  793. +     if (dbzsync() < 0)
  794. +         ret = -1;
  795. +     if (bufpagf != NULL && fclose(bufpagf) == EOF) {
  796. +         DEBUG(("dbmclose: fclose(bufpagf) failed\n"));
  797. +         ret = -1;
  798. +     }
  799. +     if (corepag != NULL)
  800. +         free((char *)corepag);
  801. +     corepag = NULL;
  802. +     if (fclose(basef) == EOF) {
  803. +         DEBUG(("dbmclose: fclose(basef) failed\n"));
  804. +         ret = -1;
  805. +     }
  806. +     if (basefname != NULL)
  807. +         free(basefname);
  808. +     basef = NULL;
  809. +     pagf = NULL;
  810. +     if (fclose(dirf) == EOF) {
  811. +         DEBUG(("dbmclose: fclose(dirf) failed\n"));
  812. +         ret = -1;
  813. +     }
  814. + 
  815. +     DEBUG(("dbmclose: %s\n", (ret == 0) ? "succeeded" : "failed"));
  816. +     return(ret);
  817. + }
  818. + 
  819. + /*
  820. +  - dbzsync - push all in-core data out to disk
  821. +  */
  822. + int
  823. + dbzsync()
  824. + {
  825. +     register int ret = 0;
  826. + 
  827. +     if (pagf == NULL) {
  828. +         DEBUG(("dbzsync: not opened!\n"));
  829. +         return(-1);
  830. +     }
  831. +     if (!written)
  832. +         return(0);
  833. + 
  834. +     if (corepag != NULL) {
  835. +         if (putcore(corepag, bufpagf) < 0) {
  836. +             DEBUG(("dbzsync: putcore failed\n"));
  837. +             ret = -1;
  838. +         }
  839. +     }
  840. +     if (!conf.olddbz)
  841. +         if (putconf(dirf, &conf) < 0)
  842. +             ret = -1;
  843. + 
  844. +     DEBUG(("dbzsync: %s\n", (ret == 0) ? "succeeded" : "failed"));
  845. +     return(ret);
  846. + }
  847. + 
  848. + /*
  849. +  - dbzfetch - fetch() with case mapping built in
  850. +  */
  851. + datum
  852. + dbzfetch(key)
  853. + datum key;
  854. + {
  855. +     char buffer[DBZMAXKEY + 1];
  856. +     datum mappedkey;
  857. +     register size_t keysize;
  858. + 
  859. +     DEBUG(("dbzfetch: (%s)\n", key.dptr));
  860. + 
  861. +     /* Key is supposed to be less than DBZMAXKEY */
  862. +     keysize = key.dsize;
  863. +     if (keysize >= DBZMAXKEY) {
  864. +         keysize = DBZMAXKEY;
  865. +         DEBUG(("keysize is %d - truncated to %d\n", key.dsize, DBZMAXKEY));
  866. +     }
  867. + 
  868. +     mappedkey.dptr = mapcase(buffer, key.dptr, keysize);
  869. +     buffer[keysize] = '\0';    /* just a debug aid */
  870. +     mappedkey.dsize = keysize;
  871. + 
  872. +     return(fetch(mappedkey));
  873. + }
  874. + 
  875. + /*
  876. +  - fetch - get an entry from the database
  877. +  *
  878. +  * Disgusting fine point, in the name of backward compatibility:  if the
  879. +  * last character of "key" is a NUL, that character is (effectively) not
  880. +  * part of the comparison against the stored keys.
  881. +  */
  882. + datum                /* dptr NULL, dsize 0 means failure */
  883. + fetch(key)
  884. + datum key;
  885. + {
  886. +     char buffer[DBZMAXKEY + 1];
  887. +     static of_t key_ptr;        /* return value points here */
  888. +     datum output;
  889. +     register size_t keysize;
  890. +     register size_t cmplen;
  891. +     register char *sepp;
  892. + 
  893. +     DEBUG(("fetch: (%s)\n", key.dptr));
  894. +     output.dptr = NULL;
  895. +     output.dsize = 0;
  896. +     prevp = FRESH;
  897. + 
  898. +     /* Key is supposed to be less than DBZMAXKEY */
  899. +     keysize = key.dsize;
  900. +     if (keysize >= DBZMAXKEY) {
  901. +         keysize = DBZMAXKEY;
  902. +         DEBUG(("keysize is %d - truncated to %d\n", key.dsize, DBZMAXKEY));
  903. +     }
  904. + 
  905. +     if (pagf == NULL) {
  906. +         DEBUG(("fetch: database not open!\n"));
  907. +         return(output);
  908. +     } else if (basef == NULL) {    /* basef didn't exist yet */
  909. +         basef = latebase();
  910. +         if (basef == NULL)
  911. +             return(output);
  912. +     }
  913. + 
  914. +     cmplen = keysize;
  915. +     sepp = &conf.fieldsep;
  916. +     if (key.dptr[keysize-1] == '\0') {
  917. +         cmplen--;
  918. +         sepp = &buffer[keysize-1];
  919. +     }
  920. +     start(&srch, &key, FRESH);
  921. +     while ((key_ptr = search(&srch)) != NOTFOUND) {
  922. +         DEBUG(("got 0x%lx\n", key_ptr));
  923. + 
  924. +         /* fetch the key */
  925. +         if (fseek(basef, key_ptr, SEEK_SET) != 0) {
  926. +             DEBUG(("fetch: seek failed\n"));
  927. +             return(output);
  928. +         }
  929. +         if (fread(buffer, 1, keysize, basef) != keysize) {
  930. +             DEBUG(("fetch: read failed\n"));
  931. +             return(output);
  932. +         }
  933. + 
  934. +         /* try it */
  935. +         buffer[keysize] = '\0';        /* terminated for DEBUG */
  936. +         (void) mapcase(buffer, buffer, keysize);
  937. +         DEBUG(("fetch: buffer (%s) looking for (%s) size = %d\n", 
  938. +                         buffer, key.dptr, keysize));
  939. +         if (memcmp(key.dptr, buffer, cmplen) == 0 &&
  940. +                 (*sepp == conf.fieldsep || *sepp == '\0')) {
  941. +             /* we found it */
  942. +             output.dptr = (char *)&key_ptr;
  943. +             output.dsize = SOF;
  944. +             DEBUG(("fetch: successful\n"));
  945. +             return(output);
  946. +         }
  947. +     }
  948. + 
  949. +     /* we didn't find it */
  950. +     DEBUG(("fetch: failed\n"));
  951. +     prevp = &srch;            /* remember where we stopped */
  952. +     return(output);
  953. + }
  954. + 
  955. + /*
  956. +  - latebase - try to open a base file that wasn't there at the start
  957. +  */
  958. + static FILE *
  959. + latebase()
  960. + {
  961. +     register FILE *it;
  962. + 
  963. +     if (basefname == NULL) {
  964. +         DEBUG(("latebase: name foulup\n"));
  965. +         return(NULL);
  966. +     }
  967. +     it = fopen(basefname, "r");
  968. +     if (it == NULL) {
  969. +         DEBUG(("latebase: still can't open base\n"));
  970. +     } else {
  971. +         DEBUG(("latebase: late open succeeded\n"));
  972. +         free(basefname);
  973. +         basefname = NULL;
  974. + #ifdef _IOFBF
  975. +         (void) setvbuf(it, basebuf, _IOFBF, sizeof(basebuf));
  976. + #endif
  977. +     }
  978. +     return(it);
  979. + }
  980. + 
  981. + /*
  982. +  - dbzstore - store() with case mapping built in
  983. +  */
  984. + int
  985. + dbzstore(key, data)
  986. + datum key;
  987. + datum data;
  988. + {
  989. +     char buffer[DBZMAXKEY + 1];
  990. +     datum mappedkey;
  991. +     register size_t keysize;
  992. + 
  993. +     DEBUG(("dbzstore: (%s)\n", key.dptr));
  994. + 
  995. +     /* Key is supposed to be less than DBZMAXKEY */
  996. +     keysize = key.dsize;
  997. +     if (keysize >= DBZMAXKEY) {
  998. +         DEBUG(("dbzstore: key size too big (%d)\n", key.dsize));
  999. +         return(-1);
  1000. +     }
  1001. + 
  1002. +     mappedkey.dptr = mapcase(buffer, key.dptr, keysize);
  1003. +     buffer[keysize] = '\0';    /* just a debug aid */
  1004. +     mappedkey.dsize = keysize;
  1005. + 
  1006. +     return(store(mappedkey, data));
  1007. + }
  1008. + 
  1009. + /*
  1010. +  - store - add an entry to the database
  1011. +  */
  1012. + int                /* 0 success, -1 failure */
  1013. + store(key, data)
  1014. + datum key;
  1015. + datum data;
  1016. + {
  1017. +     of_t value;
  1018. + 
  1019. +     if (pagf == NULL) {
  1020. +         DEBUG(("store: database not open!\n"));
  1021. +         return(-1);
  1022. +     } else if (basef == NULL) {    /* basef didn't exist yet */
  1023. +         basef = latebase();
  1024. +         if (basef == NULL)
  1025. +             return(-1);
  1026. +     }
  1027. +     if (pagronly) {
  1028. +         DEBUG(("store: database open read-only\n"));
  1029. +         return(-1);
  1030. +     }
  1031. +     if (data.dsize != SOF) {
  1032. +         DEBUG(("store: value size wrong (%d)\n", data.dsize));
  1033. +         return(-1);
  1034. +     }
  1035. +     if (key.dsize >= DBZMAXKEY) {
  1036. +         DEBUG(("store: key size too big (%d)\n", key.dsize));
  1037. +         return(-1);
  1038. +     }
  1039. + 
  1040. +     /* copy the value in to ensure alignment */
  1041. +     (void) memcpy((char *)&value, data.dptr, SOF);
  1042. +     DEBUG(("store: (%s, %ld)\n", key.dptr, (long)value));
  1043. +     if (!okayvalue(value)) {
  1044. +         DEBUG(("store: reserved bit or overflow in 0x%lx\n", value));
  1045. +         return(-1);
  1046. +     }
  1047. + 
  1048. +     /* find the place, exploiting previous search if possible */
  1049. +     start(&srch, &key, prevp);
  1050. +     while (search(&srch) != NOTFOUND)
  1051. +         continue;
  1052. + 
  1053. +     prevp = FRESH;
  1054. +     conf.used[0]++;
  1055. +     DEBUG(("store: used count %ld\n", conf.used[0]));
  1056. +     written = 1;
  1057. +     return(set(&srch, value));
  1058. + }
  1059. + 
  1060. + /*
  1061. +  - dbzincore - control attempts to keep .pag file in core
  1062. +  */
  1063. + int                /* old setting */
  1064. + dbzincore(value)
  1065. + int value;
  1066. + {
  1067. +     register int old = incore;
  1068. + 
  1069. +     incore = value;
  1070. +     return(old);
  1071. + }
  1072. + 
  1073. + /*
  1074. +  - getconf - get configuration from .dir file
  1075. +  */
  1076. + static int            /* 0 success, -1 failure */
  1077. + getconf(df, pf, cp)
  1078. + register FILE *df;        /* NULL means just give me the default */
  1079. + register FILE *pf;        /* NULL means don't care about .pag */
  1080. + register struct dbzconfig *cp;
  1081. + {
  1082. +     register int c;
  1083. +     register int i;
  1084. +     int err = 0;
  1085. + 
  1086. +     c = (df != NULL) ? getc(df) : EOF;
  1087. +     if (c == EOF) {        /* empty file, no configuration known */
  1088. +         cp->olddbz = 0;
  1089. +         if (df != NULL && pf != NULL && getc(pf) != EOF)
  1090. +             cp->olddbz = 1;
  1091. +         cp->tsize = DEFSIZE;
  1092. +         cp->fieldsep = '\t';
  1093. +         for (i = 0; i < NUSEDS; i++)
  1094. +             cp->used[i] = 0;
  1095. +         cp->valuesize = SOF;
  1096. +         mybytemap(cp->bytemap);
  1097. +         cp->casemap = DEFCASE;
  1098. +         cp->tagenb = TAGENB;
  1099. +         cp->tagmask = TAGMASK;
  1100. +         cp->tagshift = TAGSHIFT;
  1101. +         DEBUG(("getconf: defaults (%ld, %c, (0x%lx/0x%lx<<%d))\n",
  1102. +             cp->tsize, cp->casemap, cp->tagenb, 
  1103. +             cp->tagmask, cp->tagshift));
  1104. +         return(0);
  1105. +     }
  1106. +     (void) ungetc(c, df);
  1107. + 
  1108. +     /* first line, the vital stuff */
  1109. +     if (getc(df) != 'd' || getc(df) != 'b' || getc(df) != 'z')
  1110. +         err = -1;
  1111. +     if (getno(df, &err) != dbzversion)
  1112. +         err = -1;
  1113. +     cp->tsize = getno(df, &err);
  1114. +     cp->fieldsep = getno(df, &err);
  1115. +     while ((c = getc(df)) == ' ')
  1116. +         continue;
  1117. +     cp->casemap = c;
  1118. +     cp->tagenb = getno(df, &err);
  1119. +     cp->tagmask = getno(df, &err);
  1120. +     cp->tagshift = getno(df, &err);
  1121. +     cp->valuesize = getno(df, &err);
  1122. +     if (cp->valuesize != SOF) {
  1123. +         DEBUG(("getconf: wrong of_t size (%d)\n", cp->valuesize));
  1124. +         err = -1;
  1125. +     }
  1126. +     for (i = 0; i < cp->valuesize; i++)
  1127. +         cp->bytemap[i] = getno(df, &err);
  1128. +     if (getc(df) != '\n')
  1129. +         err = -1;
  1130. +     DEBUG(("size %ld, sep %d, cmap %c, tags 0x%lx/0x%lx<<%d, ", cp->tsize,
  1131. +             cp->fieldsep, cp->casemap, cp->tagenb, cp->tagmask,
  1132. +             cp->tagshift));
  1133. +     DEBUG(("bytemap (%d)", cp->valuesize));
  1134. +     for (i = 0; i < cp->valuesize; i++) {
  1135. +         DEBUG((" %d", cp->bytemap[i]));
  1136. +     }
  1137. +     DEBUG(("\n"));
  1138. + 
  1139. +     /* second line, the usages */
  1140. +     for (i = 0; i < NUSEDS; i++)
  1141. +         cp->used[i] = getno(df, &err);
  1142. +     if (getc(df) != '\n')
  1143. +         err = -1;
  1144. +     DEBUG(("used %ld %ld %ld...\n", cp->used[0], cp->used[1], cp->used[2]));
  1145. + 
  1146. +     if (err < 0) {
  1147. +         DEBUG(("getconf error\n"));
  1148. +         return(-1);
  1149. +     }
  1150. +     return(0);
  1151. + }
  1152. + 
  1153. + /*
  1154. +  - getno - get a long
  1155. +  */
  1156. + static long
  1157. + getno(f, ep)
  1158. + FILE *f;
  1159. + int *ep;
  1160. + {
  1161. +     register char *p;
  1162. + #    define    MAXN    50
  1163. +     char getbuf[MAXN];
  1164. +     register int c;
  1165. + 
  1166. +     while ((c = getc(f)) == ' ')
  1167. +         continue;
  1168. +     if (c == EOF || c == '\n') {
  1169. +         DEBUG(("getno: missing number\n"));
  1170. +         *ep = -1;
  1171. +         return(0);
  1172. +     }
  1173. +     p = getbuf;
  1174. +     *p++ = c;
  1175. +     while ((c = getc(f)) != EOF && c != '\n' && c != ' ')
  1176. +         if (p < &getbuf[MAXN-1])
  1177. +             *p++ = c;
  1178. +     if (c == EOF) {
  1179. +         DEBUG(("getno: EOF\n"));
  1180. +         *ep = -1;
  1181. +     } else
  1182. +         (void) ungetc(c, f);
  1183. +     *p = '\0';
  1184. + 
  1185. +     if (strspn(getbuf, "-1234567890") != strlen(getbuf)) {
  1186. +         DEBUG(("getno: `%s' non-numeric\n", getbuf));
  1187. +         *ep = -1;
  1188. +     }
  1189. +     return(atol(getbuf));
  1190. + }
  1191. + 
  1192. + /*
  1193. +  - putconf - write configuration to .dir file
  1194. +  */
  1195. + static int            /* 0 success, -1 failure */
  1196. + putconf(f, cp)
  1197. + register FILE *f;
  1198. + register struct dbzconfig *cp;
  1199. + {
  1200. +     register int i;
  1201. +     register int ret = 0;
  1202. + 
  1203. +     if (fseek(f, (of_t)0, SEEK_SET) != 0) {
  1204. +         DEBUG(("fseek failure in putconf\n"));
  1205. +         ret = -1;
  1206. +     }
  1207. +     fprintf(f, "dbz %d %ld %d %c %ld %ld %d %d", dbzversion, cp->tsize,
  1208. +                 cp->fieldsep, cp->casemap, cp->tagenb,
  1209. +                 cp->tagmask, cp->tagshift, cp->valuesize);
  1210. +     for (i = 0; i < cp->valuesize; i++)
  1211. +         fprintf(f, " %d", cp->bytemap[i]);
  1212. +     fprintf(f, "\n");
  1213. +     for (i = 0; i < NUSEDS; i++)
  1214. +         fprintf(f, "%ld%c", cp->used[i], (i < NUSEDS-1) ? ' ' : '\n');
  1215. + 
  1216. +     (void) fflush(f);
  1217. +     if (ferror(f))
  1218. +         ret = -1;
  1219. + 
  1220. +     DEBUG(("putconf status %d\n", ret));
  1221. +     return(ret);
  1222. + }
  1223. + 
  1224. + /*
  1225. +  - getcore - try to set up an in-core copy of .pag file
  1226. +  */
  1227. + static of_t *            /* pointer to copy, or NULL */
  1228. + getcore(f)
  1229. + FILE *f;
  1230. + {
  1231. +     register of_t *p;
  1232. +     register size_t i;
  1233. +     register size_t nread;
  1234. +     register char *it;
  1235. + 
  1236. +     it = malloc((size_t)conf.tsize * SOF);
  1237. +     if (it == NULL) {
  1238. +         DEBUG(("getcore: malloc failed\n"));
  1239. +         return(NULL);
  1240. +     }
  1241. + 
  1242. +     nread = fread(it, SOF, (size_t)conf.tsize, f);
  1243. +     if (ferror(f)) {
  1244. +         DEBUG(("getcore: read failed\n"));
  1245. +         free(it);
  1246. +         return(NULL);
  1247. +     }
  1248. + 
  1249. +     p = (of_t *)it + nread;
  1250. +     i = (size_t)conf.tsize - nread;
  1251. +     while (i-- > 0)
  1252. +         *p++ = VACANT;
  1253. +     return((of_t *)it);
  1254. + }
  1255. + 
  1256. + /*
  1257. +  - putcore - try to rewrite an in-core table
  1258. +  */
  1259. + static int            /* 0 okay, -1 fail */
  1260. + putcore(tab, f)
  1261. + of_t *tab;
  1262. + FILE *f;
  1263. + {
  1264. +     if (fseek(f, (of_t)0, SEEK_SET) != 0) {
  1265. +         DEBUG(("fseek failure in putcore\n"));
  1266. +         return(-1);
  1267. +     }
  1268. +     (void) fwrite((char *)tab, SOF, (size_t)conf.tsize, f);
  1269. +     (void) fflush(f);
  1270. +     return((ferror(f)) ? -1 : 0);
  1271. + }
  1272. + 
  1273. + /*
  1274. +  - start - set up to start or restart a search
  1275. +  */
  1276. + static void
  1277. + start(sp, kp, osp)
  1278. + register struct searcher *sp;
  1279. + register datum *kp;
  1280. + register struct searcher *osp;        /* may be FRESH, i.e. NULL */
  1281. + {
  1282. +     register long h;
  1283. + 
  1284. +     h = hash(kp->dptr, kp->dsize);
  1285. +     if (osp != FRESH && osp->hash == h) {
  1286. +         if (sp != osp)
  1287. +             *sp = *osp;
  1288. +         DEBUG(("search restarted\n"));
  1289. +     } else {
  1290. +         sp->hash = h;
  1291. +         sp->tag = MKTAG(h / conf.tsize);
  1292. +         DEBUG(("tag 0x%lx\n", sp->tag));
  1293. +         sp->place = h % conf.tsize;
  1294. +         sp->tabno = 0;
  1295. +         sp->run = (conf.olddbz) ? conf.tsize : MAXRUN;
  1296. +         sp->aborted = 0;
  1297. +     }
  1298. +     sp->seen = 0;
  1299. + }
  1300. + 
  1301. + /*
  1302. +  - search - conduct part of a search
  1303. +  */
  1304. + static of_t            /* NOTFOUND if we hit VACANT or error */
  1305. + search(sp)
  1306. + register struct searcher *sp;
  1307. + {
  1308. +     register of_t dest;
  1309. +     register of_t value;
  1310. +     of_t val;        /* buffer for value (can't fread register) */
  1311. +     register of_t place;
  1312. + 
  1313. +     if (sp->aborted)
  1314. +         return(NOTFOUND);
  1315. + 
  1316. +     for (;;) {
  1317. +         /* determine location to be examined */
  1318. +         place = sp->place;
  1319. +         if (sp->seen) {
  1320. +             /* go to next location */
  1321. +             if (--sp->run <= 0) {
  1322. +                 sp->tabno++;
  1323. +                 sp->run = MAXRUN;
  1324. +             }
  1325. +             place = (place+1)%conf.tsize + sp->tabno*conf.tsize;
  1326. +             sp->place = place;
  1327. +         } else
  1328. +             sp->seen = 1;    /* now looking at current location */
  1329. +         DEBUG(("search @ %ld\n", place));
  1330. + 
  1331. +         /* get the tagged value */
  1332. +         if (corepag != NULL && place < conf.tsize) {
  1333. +             DEBUG(("search: in core\n"));
  1334. +             value = MAPIN(corepag[place]);
  1335. +         } else {
  1336. +             /* seek, if necessary */
  1337. +             dest = place * SOF;
  1338. +             if (pagpos != dest) {
  1339. +                 if (fseek(pagf, dest, SEEK_SET) != 0) {
  1340. +                     DEBUG(("search: seek failed\n"));
  1341. +                     pagpos = -1;
  1342. +                     sp->aborted = 1;
  1343. +                     return(NOTFOUND);
  1344. +                 }
  1345. +                 pagpos = dest;
  1346. +             }
  1347. + 
  1348. +             /* read it */
  1349. +             if (fread((char *)&val, sizeof(val), 1, pagf) == 1)
  1350. +                 value = MAPIN(val);
  1351. +             else if (ferror(pagf)) {
  1352. +                 DEBUG(("search: read failed\n"));
  1353. +                 pagpos = -1;
  1354. +                 sp->aborted = 1;
  1355. +                 return(NOTFOUND);
  1356. +             } else
  1357. +                 value = VACANT;
  1358. + 
  1359. +             /* and finish up */
  1360. +             pagpos += sizeof(val);
  1361. +         }
  1362. + 
  1363. +         /* vacant slot is always cause to return */
  1364. +         if (value == VACANT) {
  1365. +             DEBUG(("search: empty slot\n"));
  1366. +             return(NOTFOUND);
  1367. +         };
  1368. + 
  1369. +         /* check the tag */
  1370. +         value = UNBIAS(value);
  1371. +         DEBUG(("got 0x%lx\n", value));
  1372. +         if (!HASTAG(value)) {
  1373. +             DEBUG(("tagless\n"));
  1374. +             return(value);
  1375. +         } else if (TAG(value) == sp->tag) {
  1376. +             DEBUG(("match\n"));
  1377. +             return(NOTAG(value));
  1378. +         } else {
  1379. +             DEBUG(("mismatch 0x%lx\n", TAG(value)));
  1380. +         }
  1381. +     }
  1382. +     /* NOTREACHED */
  1383. + }
  1384. + 
  1385. + /*
  1386. +  - okayvalue - check that a value can be stored
  1387. +  */
  1388. + static int            /* predicate */
  1389. + okayvalue(value)
  1390. + of_t value;
  1391. + {
  1392. +     if (HASTAG(value))
  1393. +         return(0);
  1394. + #ifdef OVERFLOW
  1395. +     if (value == LONG_MAX)    /* BIAS() and UNBIAS() will overflow */
  1396. +         return(0);
  1397. + #endif
  1398. +     return(1);
  1399. + }
  1400. + 
  1401. + /*
  1402. +  - set - store a value into a location previously found by search
  1403. +  */
  1404. + static int            /* 0 success, -1 failure */
  1405. + set(sp, value)
  1406. + register struct searcher *sp;
  1407. + of_t value;
  1408. + {
  1409. +     register of_t place = sp->place;
  1410. +     register of_t v = value;
  1411. + 
  1412. +     if (sp->aborted)
  1413. +         return(-1);
  1414. + 
  1415. +     if (CANTAG(v) && !conf.olddbz) {
  1416. +         v |= sp->tag | taghere;
  1417. +         if (v != UNBIAS(VACANT))    /* BIAS(v) won't look VACANT */
  1418. + #ifdef OVERFLOW
  1419. +             if (v != LONG_MAX)    /* and it won't overflow */
  1420. + #endif
  1421. +             value = v;
  1422. +     }
  1423. +     DEBUG(("tagged value is 0x%lx\n", value));
  1424. +     value = BIAS(value);
  1425. +     value = MAPOUT(value);
  1426. + 
  1427. +     /* If we have the index file in memory, use it */
  1428. +     if (corepag != NULL && place < conf.tsize) {
  1429. +         corepag[place] = value;
  1430. +         DEBUG(("set: incore\n"));
  1431. +         return(0);
  1432. +     }
  1433. + 
  1434. +     /* seek to spot */
  1435. +     pagpos = -1;        /* invalidate position memory */
  1436. +     if (fseek(pagf, place * SOF, SEEK_SET) != 0) {
  1437. +         DEBUG(("set: seek failed\n"));
  1438. +         sp->aborted = 1;
  1439. +         return(-1);
  1440. +     }
  1441. + 
  1442. +     /* write in data */
  1443. +     if (fwrite((char *)&value, SOF, 1, pagf) != 1) {
  1444. +         DEBUG(("set: write failed\n"));
  1445. +         sp->aborted = 1;
  1446. +         return(-1);
  1447. +     }
  1448. +     /* fflush improves robustness, and buffer re-use is rare anyway */
  1449. +     if (fflush(pagf) == EOF) {
  1450. +         DEBUG(("set: fflush failed\n"));
  1451. +         sp->aborted = 1;
  1452. +         return(-1);
  1453. +     }
  1454. + 
  1455. +     DEBUG(("set: succeeded\n"));
  1456. +     return(0);
  1457. + }
  1458. + 
  1459. + /*
  1460. +  - mybytemap - determine this machine's byte map
  1461. +  *
  1462. +  * A byte map is an array of ints, sizeof(of_t) of them.  The 0th int
  1463. +  * is the byte number of the high-order byte in my of_t, and so forth.
  1464. +  */
  1465. + static void
  1466. + mybytemap(map)
  1467. + int map[];            /* -> int[SOF] */
  1468. + {
  1469. +     union {
  1470. +         of_t o;
  1471. +         char c[SOF];
  1472. +     } u;
  1473. +     register int *mp = &map[SOF];
  1474. +     register int ntodo;
  1475. +     register int i;
  1476. + 
  1477. +     u.o = 1;
  1478. +     for (ntodo = (int)SOF; ntodo > 0; ntodo--) {
  1479. +         for (i = 0; i < SOF; i++)
  1480. +             if (u.c[i] != 0)
  1481. +                 break;
  1482. +         if (i == SOF) {
  1483. +             /* trouble -- set it to *something* consistent */
  1484. +             DEBUG(("mybytemap: nonexistent byte %d!!!\n", ntodo));
  1485. +             for (i = 0; i < SOF; i++)
  1486. +                 map[i] = i;
  1487. +             return;
  1488. +         }
  1489. +         DEBUG(("mybytemap: byte %d\n", i));
  1490. +         *--mp = i;
  1491. +         while (u.c[i] != 0)
  1492. +             u.o <<= 1;
  1493. +     }
  1494. + }
  1495. + 
  1496. + /*
  1497. +  - bytemap - transform an of_t from byte ordering map1 to map2
  1498. +  */
  1499. + static of_t            /* transformed result */
  1500. + bytemap(ino, map1, map2)
  1501. + of_t ino;
  1502. + int *map1;
  1503. + int *map2;
  1504. + {
  1505. +     union oc {
  1506. +         of_t o;
  1507. +         char c[SOF];
  1508. +     };
  1509. +     union oc in;
  1510. +     union oc out;
  1511. +     register int i;
  1512. + 
  1513. +     in.o = ino;
  1514. +     for (i = 0; i < SOF; i++)
  1515. +         out.c[map2[i]] = in.c[map1[i]];
  1516. +     return(out.o);
  1517. + }
  1518. + 
  1519. + /*
  1520. +  * This is a simplified version of the pathalias hashing function.
  1521. +  * Thanks to Steve Belovin and Peter Honeyman
  1522. +  *
  1523. +  * hash a string into a long int.  31 bit crc (from andrew appel).
  1524. +  * the crc table is computed at run time by crcinit() -- we could
  1525. +  * precompute, but it takes 1 clock tick on a 750.
  1526. +  *
  1527. +  * This fast table calculation works only if POLY is a prime polynomial
  1528. +  * in the field of integers modulo 2.  Since the coefficients of a
  1529. +  * 32-bit polynomial won't fit in a 32-bit word, the high-order bit is
  1530. +  * implicit.  IT MUST ALSO BE THE CASE that the coefficients of orders
  1531. +  * 31 down to 25 are zero.  Happily, we have candidates, from
  1532. +  * E. J.  Watson, "Primitive Polynomials (Mod 2)", Math. Comp. 16 (1962):
  1533. +  *    x^32 + x^7 + x^5 + x^3 + x^2 + x^1 + x^0
  1534. +  *    x^31 + x^3 + x^0
  1535. +  *
  1536. +  * We reverse the bits to get:
  1537. +  *    111101010000000000000000000000001 but drop the last 1
  1538. +  *         f   5   0   0   0   0   0   0
  1539. +  *    010010000000000000000000000000001 ditto, for 31-bit crc
  1540. +  *       4   8   0   0   0   0   0   0
  1541. +  */
  1542. + 
  1543. + #define POLY 0x48000000L    /* 31-bit polynomial (avoids sign problems) */
  1544. + 
  1545. + static long CrcTable[128];
  1546. + 
  1547. + /*
  1548. +  - crcinit - initialize tables for hash function
  1549. +  */
  1550. + static void
  1551. + crcinit()
  1552. + {
  1553. +     register int i, j;
  1554. +     register long sum;
  1555. + 
  1556. +     for (i = 0; i < 128; ++i) {
  1557. +         sum = 0L;
  1558. +         for (j = 7 - 1; j >= 0; --j)
  1559. +             if (i & (1 << j))
  1560. +                 sum ^= POLY >> j;
  1561. +         CrcTable[i] = sum;
  1562. +     }
  1563. +     DEBUG(("crcinit: done\n"));
  1564. + }
  1565. + 
  1566. + /*
  1567. +  - hash - Honeyman's nice hashing function
  1568. +  */
  1569. + static long
  1570. + hash(name, size)
  1571. + register char *name;
  1572. + register int size;
  1573. + {
  1574. +     register long sum = 0L;
  1575. + 
  1576. +     while (size--) {
  1577. +         sum = (sum >> 7) ^ CrcTable[(sum ^ (*name++)) & 0x7f];
  1578. +     }
  1579. +     DEBUG(("hash: returns (%ld)\n", sum));
  1580. +     return(sum);
  1581. + }
  1582. + 
  1583. + /*
  1584. +  * case-mapping stuff
  1585. +  *
  1586. +  * Borrowed from C News, by permission of the authors.  Somewhat modified.
  1587. +  *
  1588. +  * We exploit the fact that we are dealing only with headers here, and
  1589. +  * headers are limited to the ASCII characters by RFC822.  It is barely
  1590. +  * possible that we might be dealing with a translation into another
  1591. +  * character set, but in particular it's very unlikely for a header
  1592. +  * character to be outside -128..255.
  1593. +  *
  1594. +  * Life would be a whole lot simpler if tolower() could safely and portably
  1595. +  * be applied to any char.
  1596. +  */
  1597. + 
  1598. + #define    OFFSET    128        /* avoid trouble with negative chars */
  1599. + 
  1600. + /* must call casencmp before invoking TOLOW... */
  1601. + #define    TOLOW(c)    (cmap[(c)+OFFSET])
  1602. + 
  1603. + /* ...but the use of it in CISTREQN is safe without the preliminary call (!) */
  1604. + /* CISTREQN is an optimised case-insensitive strncmp(a,b,n)==0; n > 0 */
  1605. + #define CISTREQN(a, b, n) \
  1606. +     (TOLOW((a)[0]) == TOLOW((b)[0]) && casencmp(a, b, n) == 0)
  1607. + 
  1608. + #define    MAPSIZE    (256+OFFSET)
  1609. + static char cmap[MAPSIZE];    /* relies on init to '\0' */
  1610. + static int mprimed = 0;        /* has cmap been set up? */
  1611. + 
  1612. + /*
  1613. +  - mapprime - set up case-mapping stuff
  1614. +  */
  1615. + static void
  1616. + mapprime()
  1617. + {
  1618. +     register char *lp;
  1619. +     register char *up;
  1620. +     register int c;
  1621. +     register int i;
  1622. +     static char lower[] = "abcdefghijklmnopqrstuvwxyz";
  1623. +     static char upper[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  1624. + 
  1625. +     for (lp = lower, up = upper; *lp != '\0'; lp++, up++) {
  1626. +         c = *lp;
  1627. +         cmap[c+OFFSET] = c;
  1628. +         cmap[*up+OFFSET] = c;
  1629. +     }
  1630. +     for (i = 0; i < MAPSIZE; i++)
  1631. +         if (cmap[i] == '\0')
  1632. +             cmap[i] = (char)(i-OFFSET);
  1633. +     mprimed = 1;
  1634. + }
  1635. + 
  1636. + /*
  1637. +  - casencmp - case-independent strncmp
  1638. +  */
  1639. + static int            /* < == > 0 */
  1640. + casencmp(s1, s2, len)
  1641. + char *s1;
  1642. + char *s2;
  1643. + int len;
  1644. + {
  1645. +     register char *p1;
  1646. +     register char *p2;
  1647. +     register int n;
  1648. + 
  1649. +     if (!mprimed)
  1650. +         mapprime();
  1651. + 
  1652. +     p1 = s1;
  1653. +     p2 = s2;
  1654. +     n = len;
  1655. +     while (--n >= 0 && *p1 != '\0' && TOLOW(*p1) == TOLOW(*p2)) {
  1656. +         p1++;
  1657. +         p2++;
  1658. +     }
  1659. +     if (n < 0)
  1660. +         return(0);
  1661. + 
  1662. +     /*
  1663. +      * The following case analysis is necessary so that characters
  1664. +      * which look negative collate low against normal characters but
  1665. +      * high against the end-of-string NUL.
  1666. +      */
  1667. +     if (*p1 == '\0' && *p2 == '\0')
  1668. +         return(0);
  1669. +     else if (*p1 == '\0')
  1670. +         return(-1);
  1671. +     else if (*p2 == '\0')
  1672. +         return(1);
  1673. +     else
  1674. +         return(TOLOW(*p1) - TOLOW(*p2));
  1675. + }
  1676. + 
  1677. + /*
  1678. +  - mapcase - do case-mapped copy
  1679. +  */
  1680. + static char *            /* returns src or dst */
  1681. + mapcase(dst, src, siz)
  1682. + char *dst;            /* destination, used only if mapping needed */
  1683. + char *src;            /* source; src == dst is legal */
  1684. + size_t siz;
  1685. + {
  1686. +     register char *s;
  1687. +     register char *d;
  1688. +     register char *c;    /* case break */
  1689. +     register char *e;    /* end of source */
  1690. + 
  1691. + 
  1692. +     c = cipoint(src, siz);
  1693. +     if (c == NULL)
  1694. +         return(src);
  1695. + 
  1696. +     if (!mprimed)
  1697. +         mapprime();
  1698. +     s = src;
  1699. +     e = s + siz;
  1700. +     d = dst;
  1701. + 
  1702. +     while (s < c)
  1703. +         *d++ = *s++;
  1704. +     while (s < e)
  1705. +         *d++ = TOLOW(*s++);
  1706. + 
  1707. +     return(dst);
  1708. + }
  1709. + 
  1710. + /*
  1711. +  - cipoint - where in this message-ID does it become case-insensitive?
  1712. +  *
  1713. +  * The RFC822 code is not quite complete.  Absolute, total, full RFC822
  1714. +  * compliance requires a horrible parsing job, because of the arcane
  1715. +  * quoting conventions -- abc"def"ghi is not equivalent to abc"DEF"ghi,
  1716. +  * for example.  There are three or four things that might occur in the
  1717. +  * domain part of a message-id that are case-sensitive.  They don't seem
  1718. +  * to ever occur in real news, thank Cthulhu.  (What?  You were expecting
  1719. +  * a merciful and forgiving deity to be invoked in connection with RFC822?
  1720. +  * Forget it; none of them would come near it.)
  1721. +  */
  1722. + static char *            /* pointer into s, or NULL for "nowhere" */
  1723. + cipoint(s, siz)
  1724. + char *s;
  1725. + size_t siz;
  1726. + {
  1727. +     register char *p;
  1728. +     static char post[] = "postmaster";
  1729. +     static int plen = sizeof(post)-1;
  1730. + 
  1731. +     switch (conf.casemap) {
  1732. +     case '0':        /* unmapped, sensible */
  1733. +         return(NULL);
  1734. +         break;
  1735. +     case 'C':        /* C News, RFC 822 conformant (approx.) */
  1736. +         p = memchr(s, '@', siz);
  1737. +         if (p == NULL)            /* no local/domain split */
  1738. +             return(NULL);        /* assume all local */
  1739. +         else if    (p - (s+1) == plen && CISTREQN(s+1, post, plen)) {
  1740. +             /* crazy -- "postmaster" is case-insensitive */
  1741. +             return(s);
  1742. +         } else
  1743. +             return(p);
  1744. +         break;
  1745. +     case '=':        /* 2.11, neither sensible nor conformant */
  1746. +         return(s);    /* all case-insensitive */
  1747. +         break;
  1748. +     }
  1749. + 
  1750. +     DEBUG(("cipoint: unknown case mapping `%c'\n", conf.casemap));
  1751. +     return(NULL);        /* just leave it alone */
  1752. + }
  1753. + 
  1754. + /*
  1755. +  - dbzdebug - control dbz debugging at run time
  1756. +  */
  1757. + int                /* old value */
  1758. + dbzdebug(value)
  1759. + int value;
  1760. + {
  1761. + #ifdef DBZDEBUG
  1762. +     register int old = debug;
  1763. + 
  1764. +     debug = value;
  1765. +     return(old);
  1766. + #else
  1767. +     return(-1);
  1768. + #endif
  1769. + }
  1770.  
  1771.  
  1772. end of patch 15-Apr-1990
  1773.  
  1774.