home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume19 / cnews2 / pch16apr90 < prev    next >
Internet Message Format  |  1990-06-07  |  25KB
  1. From @BBN.COM,@uunet.uu.net.uucp:henry@zoo.toronto.edu Wed Apr 18 19:49:40 1990
  2. Received: from BBN.COM by pineapple.bbn.com id <AA15387@pineapple.bbn.com>; Wed, 18 Apr 90 19:49:28 -0400
  3. Received: from uunet.UU.NET by BBN.COM id aa26305; 18 Apr 90 19:22 EDT
  4. Received: from zoo.utoronto.ca by uunet.uu.net (5.61/1.14) with SMTP 
  5.     id AA15474; Wed, 18 Apr 90 16:50:21 -0400
  6. Message-Id: <9004182050.AA15474@uunet.uu.net>
  7. From: henry@zoo.toronto.edu
  8. Date: Wed, 18 Apr 90 14:17:51 EDT
  9. To: uunet!source-patches@uunet.uu.net
  10. Newsgroups: news.software.b,comp.sources.bugs
  11. Subject: C News patch of 16-Apr-1990
  12. Status: R
  13.  
  14. This is the third of three (!) patches mostly constituting the new dbz.
  15.  
  16. start of patch 16-Apr-1990
  17. (suggested archive name: `pch16Apr90.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. Prereq: 15-Apr-1990
  36. *** PATCHDATES.old    Sat Apr 14 20:24:28 1990
  37. --- PATCHDATES    Sat Apr 14 20:24:28 1990
  38. ***************
  39. *** 1,14 ****
  40. --- 1,15 ----
  41.   23-Jun-1989
  42.   7-Jul-1989
  43.   23-Jul-1989
  44.   22-Aug-1989
  45.   24-Aug-1989
  46.   14-Sep-1989
  47.   13-Nov-1989
  48.   10-Jan-1990
  49.   16-Jan-1990
  50.   17-Jan-1990
  51.   18-Jan-1990
  52.   12-Mar-1990
  53.   14-Apr-1990
  54.   15-Apr-1990
  55. + 16-Apr-1990
  56.  
  57. new dbz/dbz.h (patch can't create, so diff against null):
  58. Index: dbz/dbz.h
  59. *** cnpatch/old/dbz/dbz.h    Sat Apr 14 20:29:10 1990
  60. --- dbz/dbz.h    Wed Apr 11 17:14:10 1990
  61. ***************
  62. *** 0 ****
  63. --- 1,31 ----
  64. + /* for dbm and dbz */
  65. + typedef struct {
  66. +     char *dptr;
  67. +     int dsize;
  68. + } datum;
  69. + 
  70. + /* standard dbm functions */
  71. + extern int dbminit();
  72. + extern datum fetch();
  73. + extern int store();
  74. + extern int delete();        /* not in dbz */
  75. + extern datum firstkey();    /* not in dbz */
  76. + extern datum nextkey();        /* not in dbz */
  77. + extern int dbmclose();        /* in dbz, but not in old dbm */
  78. + 
  79. + /* new stuff for dbz */
  80. + extern int dbzfresh();
  81. + extern int dbzagain();
  82. + extern datum dbzfetch();
  83. + extern int dbzstore();
  84. + extern int dbzsync();
  85. + extern long dbzsize();
  86. + extern int dbzincore();
  87. + extern int dbzdebug();
  88. + 
  89. + /*
  90. +  * In principle we could handle unlimited-length keys by operating a chunk
  91. +  * at a time, but it's not worth it in practice.  Setting a nice large
  92. +  * bound on them simplifies the code and doesn't hurt anything.
  93. +  */
  94. + #define DBZMAXKEY    255
  95.  
  96. new dbz/dbzmain.c (patch can't create, so diff against null):
  97. Index: dbz/dbzmain.c
  98. *** cnpatch/old/dbz/dbzmain.c    Sat Apr 14 20:29:10 1990
  99. --- dbz/dbzmain.c    Thu Apr 12 16:52:59 1990
  100. ***************
  101. *** 0 ****
  102. --- 1,500 ----
  103. + /*
  104. +  * dbz - use and test dbz in various ways
  105. +  *
  106. +  * $Log$
  107. +  */
  108. + 
  109. + #include <stdio.h>
  110. + #include <sys/types.h>
  111. + #include <sys/stat.h>
  112. + #include <string.h>
  113. + #include <dbz.h>
  114. + 
  115. + #ifdef FUNNYSEEKS
  116. + #include <unistd.h>
  117. + #else
  118. + #define    SEEK_SET    0
  119. + #endif
  120. + 
  121. + #define    STREQ(a, b)    (*(a) == *(b) && strcmp((a), (b)) == 0)
  122. + 
  123. + #ifndef lint
  124. + static char RCSid[] = "$Header$";
  125. + #endif
  126. + 
  127. + char *progname;
  128. + 
  129. + char *inname = "(no file)";        /* filename for messages etc. */
  130. + long lineno;                /* line number for messages etc. */
  131. + 
  132. + char *basename;
  133. + char *pagname;
  134. + char *dirname;
  135. + char *str2dup();
  136. + FILE *base;
  137. + 
  138. + int op = 'b';            /* what to do, default build a new table */
  139. + int baseinput = 1;        /* is the base file also the input? */
  140. + 
  141. + char *from = NULL;        /* old table to use for dbzagain() */
  142. + int omitzero = 0;        /* omit lines tagged with 0 */
  143. + long every = 0;            /* report every n lines */
  144. + int syncs = 0;            /* dbzsync() on each report */
  145. + int quick = 0;            /* quick checking, not too thorough */
  146. + int sweep = 0;            /* sweep file checking all offsets */
  147. + int useincore = 1;        /* should we use incore facility? */
  148. + long xxx = 0;            /* debugging variable */
  149. + int printx = 0;            /* print xxx after all is done */
  150. + int unique = 1;            /* before store(), check with fetch() */
  151. + int usefresh = 0;        /* use dbzfresh? */
  152. + long siz = 0;            /* -p size */
  153. + char map = 'C';            /* -p map */
  154. + long tag = 0;            /* -p tag mask */
  155. + int exact = 0;            /* do not run dbzsize(siz) */
  156. + int dbzint = 1;            /* use new interface? */
  157. + char fs = '\t';            /* field separator, default tab */
  158. + int unopen = 0;            /* make base unopenable during dbminit? */
  159. + char *change = NULL;        /* chdir here before dbmclose */
  160. + 
  161. + #define    DEFBUF    1024        /* default line-buffer size */
  162. + int buflen = DEFBUF;        /* line length limit */
  163. + char lbuf[DEFBUF];
  164. + char *line = lbuf;
  165. + char cbuf[DEFBUF];
  166. + char *cmp = cbuf;
  167. + 
  168. + void fail();
  169. + void dofile();
  170. + void runs();
  171. + void dosweep();
  172. + void mkfiles();
  173. + void crfile();
  174. + void doline();
  175. + 
  176. + #ifdef HAVERFCIZE
  177. + extern char *rfc822ize();
  178. + #else
  179. + #define    rfc822ize(n)    (n)
  180. + #endif
  181. + 
  182. + /*
  183. +  - main - parse arguments and handle options
  184. +  */
  185. + main(argc, argv)
  186. + int argc;
  187. + char *argv[];
  188. + {
  189. +     int c;
  190. +     int errflg = 0;
  191. +     extern int optind;
  192. +     extern char *optarg;
  193. +     void process();
  194. +     int doruns = 0;
  195. +     extern long atol();
  196. +     extern char *malloc();
  197. + 
  198. +     progname = argv[0];
  199. + 
  200. +     while ((c = getopt(argc, argv, "axct:l:R0E:SqOiX:Yuf:p:eMUC:d")) != EOF)
  201. +         switch (c) {
  202. +         case 'a':    /* append to existing table */
  203. +             if (op != 'b')
  204. +                 fail("only one of -a -x -c can be given", "");
  205. +             op = 'a';
  206. +             baseinput = 0;
  207. +             break;
  208. +         case 'x':    /* extract from existing table */
  209. +             if (op != 'b')
  210. +                 fail("only one of -a -x -c can be given", "");
  211. +             op = 'x';
  212. +             baseinput = 0;
  213. +             break;
  214. +         case 'c':    /* check existing table */
  215. +             if (op != 'b')
  216. +                 fail("only one of -a -x -c can be given", "");
  217. +             op = 'c';
  218. +             break;
  219. +         case 't':    /* set field separator */
  220. +             if (strlen(optarg) > 1)
  221. +                 fail("only one field separator allowed", "");
  222. +             fs = *optarg;
  223. +             break;
  224. +         case 'l':    /* override line-length limit */
  225. +             buflen = atoi(optarg) + 1;
  226. +             if (buflen <= 2)
  227. +                 fail("bad -l value `%s'", optarg);
  228. +             line = malloc(buflen);
  229. +             cmp = malloc(buflen);
  230. +             if (line == NULL || cmp == NULL)
  231. +                 fail("cannot allocate %s-byte buffers", optarg);
  232. +             break;
  233. +         case 'R':    /* print run statistics */
  234. +             doruns = 1;
  235. +             break;
  236. +         case '0':    /* omit lines tagged (by fake -t) with 0 */
  237. +             omitzero = 1;
  238. +             break;
  239. +         case 'E':    /* report every n items */
  240. +             every = atol(optarg);
  241. +             break;
  242. +         case 'S':    /* dbzsync() on each -E report */
  243. +             syncs = 1;
  244. +             break;
  245. +         case 'q':    /* quick check, not too thorough */
  246. +             quick = 1;
  247. +             break;
  248. +         case 'O':    /* sweep file checking all offsets */
  249. +             sweep = 1;
  250. +             break;
  251. +         case 'i':    /* don't use incore */
  252. +             useincore = 0;
  253. +             break;
  254. +         case 'X':    /* set xxx */
  255. +             xxx = atoi(optarg);
  256. +             break;
  257. +         case 'Y':    /* print xxx afterward */
  258. +             printx = 1;
  259. +             break;
  260. +         case 'u':    /* don't check uniqueness */
  261. +             unique = 0;
  262. +             break;
  263. +         case 'f':    /* init from existing table's parameters */
  264. +             from = optarg;
  265. +             break;
  266. +         case 'p':    /* parameters for dbzfresh */
  267. +             if (sscanf(optarg, "%ld %1s %lx", &siz, &map, &tag) != 3) {
  268. +                 map = '?';
  269. +                 tag = 0;
  270. +                 if (sscanf(optarg, "%ld", &siz) != 1)
  271. +                     fail("bad -n value `%s'", optarg);
  272. +             }
  273. +             usefresh = 1;
  274. +             break;
  275. +         case 'e':    /* -p size is exact, don't dbzsize() it */
  276. +             exact = 1;
  277. +             break;
  278. +         case 'M':    /* use old dbm interface + rfc822ize */
  279. +             dbzint = 0;
  280. +             break;
  281. +         case 'U':    /* make base unopenable during init */
  282. +             unopen = 1;
  283. +             break;
  284. +         case 'C':    /* change directories before dbmclose */
  285. +             change = optarg;
  286. +             break;
  287. +         case 'd':    /* Debugging. */
  288. +             if (dbzdebug(1) < 0)
  289. +                 fail("dbz debugging not available", "");
  290. +             break;
  291. +         case '?':
  292. +         default:
  293. +             errflg++;
  294. +             break;
  295. +         }
  296. +     if (errflg || optind >= argc || (optind+1 < argc && baseinput)) {
  297. +         fprintf(stderr, "usage: %s ", progname);
  298. +         fprintf(stderr, "[-a] [-x] [-c] database [file] ...\n");
  299. +         exit(2);
  300. +     }
  301. + 
  302. +     (void) dbzincore(useincore);
  303. +     basename = argv[optind];
  304. +     pagname = str2dup(basename, ".pag");
  305. +     dirname = str2dup(basename, ".dir");
  306. +     mkfiles();
  307. +     optind++;
  308. + 
  309. +     if (baseinput)        /* implies no further arguments */
  310. +         process(base, basename);
  311. +     else if (optind >= argc)
  312. +         process(stdin, "stdin");
  313. +     else
  314. +         for (; optind < argc; optind++)
  315. +             dofile(argv[optind]);
  316. + 
  317. +     if (change != NULL)
  318. +         (void) chdir(change);
  319. +     if (dbmclose() < 0)
  320. +         fail("dbmclose failed", "");
  321. +     if (doruns)
  322. +         runs(pagname);
  323. +     if (sweep)
  324. +         dosweep(basename, pagname);
  325. +     if (printx)
  326. +         printf("%ld\n", xxx);
  327. +     exit(0);
  328. + }
  329. + 
  330. + /*
  331. +  - dofile - open a file and invoke process()
  332. +  */
  333. + void
  334. + dofile(name)
  335. + char *name;
  336. + {
  337. +     register FILE *in;
  338. + 
  339. +     if (STREQ(name, "-"))
  340. +         process(stdin, "-");
  341. +     else {
  342. +         in = fopen(name, "r");
  343. +         if (in == NULL)
  344. +             fail("cannot open `%s'", name);
  345. +         process(in, name);
  346. +         (void) fclose(in);
  347. +     }
  348. + }
  349. + 
  350. + /*
  351. +  - mkfiles - create empty files and open them up
  352. +  */
  353. + void
  354. + mkfiles()
  355. + {
  356. +     if (op == 'b' && !dbzint) {
  357. +         crfile(dirname);
  358. +         crfile(pagname);
  359. +     }
  360. + 
  361. +     base = fopen(basename, (op == 'a') ? "a" : "r");
  362. +     if (base == NULL)
  363. +         fail("cannot open `%s'", basename);
  364. +     if (unopen)
  365. +         (void) chmod(basename, 0);
  366. +     if (from != NULL) {
  367. +         if (dbzagain(basename, from) < 0)
  368. +             fail("dbzagain(`%s'...) failed", basename);
  369. +     } else if (op == 'b' && dbzint) {
  370. +         if (!exact)
  371. +             siz = dbzsize(siz);
  372. +         if (dbzfresh(basename, siz, (int)fs, map, tag) < 0)
  373. +             fail("dbzfresh(`%s'...) failed", basename);
  374. +     } else if (dbminit(basename) < 0)
  375. +         fail("dbminit(`%s') failed", basename);
  376. +     if (unopen)
  377. +         (void) chmod(basename, 0600);    /* hard to restore original */
  378. + }
  379. + 
  380. + /*
  381. +  - crfile - create a file
  382. +  */
  383. + void
  384. + crfile(name)
  385. + char *name;
  386. + {
  387. +     register int f;
  388. + 
  389. +     f = creat(name, 0666);
  390. +     if (f < 0)
  391. +         fail("cannot create `%s'", name);
  392. +     (void) close(f);
  393. + }
  394. + 
  395. + /*
  396. +  - process - process input file
  397. +  */
  398. + void
  399. + process(in, name)
  400. + FILE *in;
  401. + char *name;
  402. + {
  403. +     register off_t place;
  404. + 
  405. +     inname = name;
  406. +     lineno = 0;
  407. + 
  408. +     for (;;) {
  409. +         place = ftell(in);
  410. +         if (fgets(line, buflen, in) == NULL)
  411. +             return;
  412. +         lineno++;
  413. +         if (every > 0 && lineno%every == 0) {
  414. +             fprintf(stderr, "%ld\n", lineno);
  415. +             if (dbzsync() < 0)
  416. +                 fail("dbzsync failed", "");
  417. +         }
  418. +         doline(line, place);
  419. +     }
  420. +     /* NOTREACHED */
  421. + }
  422. + 
  423. + /*
  424. +  - doline - process input line
  425. +  */
  426. + void
  427. + doline(lp, inoffset)
  428. + char *lp;
  429. + off_t inoffset;
  430. + {
  431. +     register char *p;
  432. +     register char pc;
  433. +     datum key, value;
  434. +     off_t place = inoffset;
  435. +     register int shouldfind;
  436. +     register int llen;
  437. +     char keytext[DBZMAXKEY+1];
  438. + 
  439. +     p = NULL;
  440. +     if (fs != '\0')
  441. +         p = strchr(lp, fs);
  442. +     if (p == NULL)
  443. +         p = lp + strlen(lp);
  444. +     if (p > lp && *(p-1) == '\n')
  445. +         p--;
  446. +     if (p - lp > DBZMAXKEY)
  447. +         fail("key of `%.40s...' too long", lp);
  448. +     pc = *p;
  449. +     *p = '\0';
  450. +     (void) strcpy(keytext, lp);
  451. +     *p = pc;
  452. +     key.dptr = (dbzint) ? keytext : rfc822ize(keytext);
  453. +     key.dsize = strlen(keytext)+1;
  454. + 
  455. +     switch (op) {
  456. +     case 'a':
  457. +         place = ftell(base);
  458. +         llen = strlen(lp);
  459. +         if (fwrite(lp, 1, llen, base) != llen)
  460. +             fail("write error in `%s'", basename);
  461. +         /* FALLTHROUGH */
  462. +     case 'b':
  463. +         if (omitzero && p != NULL && *(p+1) == '0')
  464. +             return;
  465. +         if (unique) {
  466. +             value = (dbzint) ? dbzfetch(key) : fetch(key);
  467. +             if (value.dptr != NULL)
  468. +                 fail("`%.40s...' already present", lp);
  469. +         }
  470. +         value.dptr = (char *)&place;
  471. +         value.dsize = (int)sizeof(off_t);
  472. +         if (((dbzint) ? dbzstore(key, value) : store(key, value)) < 0)
  473. +             fail("store failed on `%.40s...'", lp);
  474. +         break;
  475. +     case 'c':
  476. +         value = (dbzint) ? dbzfetch(key) : fetch(key);
  477. +         shouldfind = (omitzero && p != NULL && *(p+1) == '0') ? 0 : 1;
  478. +         if (!shouldfind && (value.dptr != NULL || value.dsize != 0))
  479. +             fail("`%.40s...' found, shouldn't be", lp);
  480. +         if (shouldfind && (value.dptr == NULL ||
  481. +                     value.dsize != sizeof(off_t)))
  482. +             fail("can't find `%.40s...'", lp);
  483. +         if (shouldfind && !quick) {
  484. +             (void) memcpy((char *)&place, value.dptr, sizeof(off_t));
  485. +             if (place != inoffset)
  486. +                 fail("offset mismatch on `%.40s...'", lp);
  487. +             if (fseek(base, place, SEEK_SET) == -1)
  488. +                 fail("fseek failed on `%.40s...'", lp);
  489. +             if (fgets(cmp, buflen, base) == NULL)
  490. +                 fail("can't read line for `%.40s...'", lp);
  491. +             if (!STREQ(lp, cmp))
  492. +                 fail("compare failed on `%.40s...'", lp);
  493. +         }
  494. +         break;
  495. +     case 'x':
  496. +         value = (dbzint) ? dbzfetch(key) : fetch(key);
  497. +         if (value.dptr != NULL) {
  498. +             (void) memcpy((char *)&place, value.dptr, sizeof(off_t));
  499. +             if (fseek(base, place, SEEK_SET) == -1)
  500. +                 fail("fseek failed on `%.40s...'", lp);
  501. +             if (fgets(cmp, buflen, base) == NULL)
  502. +                 fail("can't read line for `%.40s...'", lp);
  503. +             fputs(cmp, stdout);
  504. +         }
  505. +         break;
  506. +     default:
  507. +         fail("unknown operator -- can't happen", "");
  508. +         break;
  509. +     }
  510. + }
  511. + 
  512. + /*
  513. +  - runs - print run statistics
  514. +  */
  515. + void
  516. + runs(file)
  517. + char *file;
  518. + {
  519. +     register FILE *fd;
  520. +     off_t it;
  521. +     register long run;
  522. + 
  523. +     fd = fopen(file, "r");
  524. +     if (fd == NULL)
  525. +         fail("cannot reopen `%s'", file);
  526. +     run = 0;
  527. +     while (fread((char *)&it, sizeof(off_t), 1, fd) == 1) {
  528. +         if (it != 0)
  529. +             run++;
  530. +         else if (run > 0) {
  531. +             printf("%ld\n", run);
  532. +             run = 0;
  533. +         }
  534. +     }
  535. +     (void) fclose(fd);
  536. + }
  537. + 
  538. + /*
  539. +  - dosweep - sweep pag file checking for valid offsets
  540. +  */
  541. + void
  542. + dosweep(fn, pn)
  543. + char *fn;
  544. + char *pn;
  545. + {
  546. +     register FILE *pf;
  547. +     off_t it;
  548. +     char nl;
  549. +     register FILE *hf;
  550. + 
  551. +     hf = fopen(fn, "r");
  552. +     if (hf == NULL)
  553. +         fail("cannot reopen `%s'", fn);
  554. +     pf = fopen(pn, "r");
  555. +     if (pf == NULL)
  556. +         fail("cannot reopen `%s'", pn);
  557. +     while (fread((char *)&it, sizeof(off_t), 1, pf) == 1) {
  558. +         it = (it & (0x80<<24)) ? (it&~(0xff<<24)) : it;
  559. +         if (it != 0 && it != 1) {    /* 0 empty, 1 known okay */
  560. +             it--;        /* get rid of bias */
  561. +             (void) fseek(hf, it-1, SEEK_SET);
  562. +             nl = getc(hf);
  563. +             if (nl != '\n')
  564. +                 fprintf(stderr, "offset 0%lo does not point to line\n",
  565. +                                 (long)it);
  566. +         }
  567. +     }
  568. +     (void) fclose(hf);
  569. +     (void) fclose(pf);
  570. + }
  571. + 
  572. + /*
  573. +  - fail - complain and die
  574. +  */
  575. + void
  576. + fail(s1, s2)
  577. + char *s1;
  578. + char *s2;
  579. + {
  580. +     fprintf(stderr, "%s: (file `%s', line %ld) ", progname, inname, lineno);
  581. +     fprintf(stderr, s1, s2);
  582. +     fprintf(stderr, "\n");
  583. +     exit(1);
  584. + }
  585. + 
  586. + /*
  587. +  - str2dup - concatenate strings and malloc result
  588. +  */
  589. + char *
  590. + str2dup(s1, s2)
  591. + char *s1;
  592. + char *s2;
  593. + {
  594. +     register char *p;
  595. + 
  596. +     p = malloc((size_t)strlen(s1) + strlen(s2) + 1);
  597. +     if (p == NULL)
  598. +         fail("can't allocate space for strings", "");
  599. +     (void) strcpy(p, s1);
  600. +     (void) strcat(p, s2);
  601. +     return(p);
  602. + }
  603.  
  604. new dbz/fake.c (patch can't create, so diff against null):
  605. Index: dbz/fake.c
  606. *** cnpatch/old/dbz/fake.c    Sat Apr 14 20:29:12 1990
  607. --- dbz/fake.c    Sat Mar 31 19:24:20 1990
  608. ***************
  609. *** 0 ****
  610. --- 1,142 ----
  611. + /*
  612. +  * fake - make up random lines resembling history-file entries, reproducibly
  613. +  *
  614. +  * $Log$
  615. +  */
  616. + 
  617. + #include <stdio.h>
  618. + #include <sys/types.h>
  619. + #include <sys/stat.h>
  620. + #include <string.h>
  621. + 
  622. + #define    MAXSTR    500        /* For sizing strings -- DON'T use BUFSIZ! */
  623. + #define    STREQ(a, b)    (*(a) == *(b) && strcmp((a), (b)) == 0)
  624. + 
  625. + #ifndef lint
  626. + static char RCSid[] = "$Header$";
  627. + #endif
  628. + 
  629. + int midonly = 0;        /* just message ids, rest not realistic */
  630. + int tag = 0;            /* tag lines with random digit for later use */
  631. + int expired = -1;        /* percentage of lines to be expired */
  632. + 
  633. + int debug = 0;
  634. + char *progname;
  635. + 
  636. + char *inname;                /* filename for messages etc. */
  637. + long lineno;                /* line number for messages etc. */
  638. + 
  639. + void fail();
  640. + void doline();
  641. + void addchars();
  642. + void seed();
  643. + 
  644. + /*
  645. +  - main - parse arguments and handle options
  646. +  */
  647. + main(argc, argv)
  648. + int argc;
  649. + char *argv[];
  650. + {
  651. +     int c;
  652. +     int errflg = 0;
  653. +     FILE *in;
  654. +     struct stat statbuf;
  655. +     extern int optind;
  656. +     extern char *optarg;
  657. +     extern FILE *efopen();
  658. +     void process();
  659. +     register long no;
  660. +     extern long atol();
  661. +     char line[MAXSTR];
  662. + 
  663. +     progname = argv[0];
  664. + 
  665. +     while ((c = getopt(argc, argv, "ms:te:d")) != EOF)
  666. +         switch (c) {
  667. +         case 'm':    /* message-ids only */
  668. +             midonly = 1;
  669. +             break;
  670. +         case 's':    /* seed */
  671. +             seed(atol(optarg));
  672. +             break;
  673. +         case 't':    /* tag lines with a random digit */
  674. +             tag = 1;
  675. +             break;
  676. +         case 'e':    /* percentage to be expired */
  677. +             expired = atoi(optarg);
  678. +             break;
  679. +         case 'd':    /* Debugging. */
  680. +             debug++;
  681. +             break;
  682. +         case '?':
  683. +         default:
  684. +             errflg++;
  685. +             break;
  686. +         }
  687. +     if (errflg || optind != argc - 1) {
  688. +         fprintf(stderr, "usage: %s ", progname);
  689. +         fprintf(stderr, "[-m] [-s seed] length\n");
  690. +         exit(2);
  691. +     }
  692. + 
  693. +     for (no = atol(argv[optind]); no > 0; no--) {
  694. +         doline(line);
  695. +         puts(line);
  696. +     }
  697. +     exit(0);
  698. + }
  699. + 
  700. + /*
  701. +  - doline - generate random history pseudo-line
  702. +  */
  703. + void
  704. + doline(buf)
  705. + char *buf;
  706. + {
  707. +     char tagch[2];
  708. + 
  709. +     (void) strcpy(buf, "<");
  710. +     addchars(buf, range(4, 20));
  711. +     (void) strcat(buf, "@");
  712. +     addchars(buf, range(8, 20));
  713. +     if (midonly)
  714. +         (void) strcat(buf, ">\tx");
  715. +     else {
  716. +         if (tag) {
  717. +             tagch[0] = "1234567890"[range(0,9)];
  718. +             tagch[1] = '\0';
  719. +             (void) strcat(buf, ">\t");
  720. +             (void) strcat(buf, tagch);
  721. +             (void) strcat(buf, "00000000~-");
  722. +         } else
  723. +             (void) strcat(buf, ">\t1234567890~-");
  724. +     }
  725. +     if (range(1, 100) > expired) {
  726. +         if (midonly)
  727. +             (void) strcat(buf, "\tx");
  728. +         else {
  729. +             (void) strcat(buf, "\t");
  730. +             addchars(buf, range(10, 30));
  731. +         }
  732. +     }
  733. + }
  734. + 
  735. + /*
  736. +  - addchars - generate n random characters suitable for history file
  737. +  */
  738. + void
  739. + addchars(buf, len)
  740. + char *buf;
  741. + int len;
  742. + {
  743. +     register int i;
  744. +     register char *p = buf + strlen(buf);
  745. +     static char vocab[] = "1234567890.abcde.fghij.klmno.pqrst.uvwxyz.\
  746. + 1234567890.ABCDE.FGHIJ.KLMNO.PQRST.UVWXYZ.1234567890.\
  747. + 1234567890.abcde.fghij.klmno.pqrst.uvwxyz.1234567890";
  748. + 
  749. +     for (i = len; i > 0; i--)
  750. +         *p++ = vocab[range(0, sizeof(vocab)-2)];
  751. +     *p++ = '\0';
  752. + }
  753.  
  754. new dbz/firstlast25 (patch can't create, so diff against null):
  755. Index: dbz/firstlast25
  756. *** cnpatch/old/dbz/firstlast25    Sat Apr 14 20:29:12 1990
  757. --- dbz/firstlast25    Sat Mar 31 19:24:20 1990
  758. ***************
  759. *** 0 ****
  760. --- 1,50 ----
  761. + <m....VO1.9q.@s95e1zKsIj7LrIwa1>    600000000~-    90fz0706yo.1Env21x8b
  762. + <H5.i.R6ZQ2@Vg6.5mqj8..z>    200000000~-
  763. + <1Hy.ufmjqe371x5.o@HEEl0tAp4>    700000000~-
  764. + <T6.c9.xM4i@943..7z.c..3h>    600000000~-
  765. + <Exus7LsME4fPL9v8@2.ouu97O25z9cdft>    700000000~-
  766. + <6kUzkf.v74@iC1iGj882RQ0zli>    400000000~-
  767. + <J.7YT7dV.Kkul8Bh0fc@Rar.EnMx2lm0.6Yeob>    600000000~-
  768. + <.wVJi1DX42@5.4i6.jaZ6qw9Ln1.>    500000000~-
  769. + <uUd9e18vxzevae7uY@33a480208l0.4p2q>    300000000~-
  770. + <43hQ.5shbE7@912400.ajES6x0sXl.M>    400000000~-
  771. + <g25r..2r.0WOZ6k3@tb3.U9xrR.uw61a2y0>    600000000~-
  772. + <923s5e67d5Oq085Y.1@6Pik68584>    900000000~-
  773. + <.5.n5cx5aD62i9q8@Ai60Sc.4x>    200000000~-
  774. + <9N9n@3.1ql87.yj2xFs.zLqI>    700000000~-    Q2.kni8kZps7kF5uiEv32B38y4z.p
  775. + <.X.fw.6LtoT.0@pp6bp.5s6yh74.>    400000000~-
  776. + <54c1w@7..u1.99m9T4j.BNGBiK>    600000000~-    .F3hb.OFh06V..p
  777. + <j12Mtn6q9@m2.m1X1s>    500000000~-
  778. + <o1WJV9G4H.zf0BX44w@W7.76xn33>    000000000~-
  779. + <0C605s6plaAgfM.ap40@e6d66n.uv01W.j.8ph.>    100000000~-    m.x7TY8.8DQ5
  780. + <.2.14xdn.@D0g.W.uZ.75gyyg.q1G>    100000000~-
  781. + <.A..03.@5v..64.5v3.3tbjUo.>    500000000~-
  782. + <72..c19ms65.WCf0G3.@83seEG9nnhM.O.j22>    900000000~-
  783. + <D..xX.kti9@u739li.xvy2>    000000000~-    NPLL42XVfM
  784. + <6HO.nFal1ufl3.8b@3.n0k7a.IDgNy>    700000000~-    Wv4j3Itccnh0Zp3
  785. + <x5RjUnIpd03xBBnuN@z0puc82Q26Ou.0T6>    400000000~-    k67.hvXwv6X745R4rh2ybuFN3n.
  786. + <62dIeg.fW92.ov375@x76mf5c6.37.v>    000000000~-
  787. + <chdpqs.0mgZOp.@Dxl9v..94e7ar2>    900000000~-
  788. + <.9Xr.7V91..oe5CG.hX@p5x3jos3s27R6O3yj1>    400000000~-
  789. + <Mm6dr.231dH35ua@SE1u0za3V1M43lRn9>    100000000~-
  790. + <JIhw2@.Qdf.8v28Tnf1M>    200000000~-
  791. + <z4FCa.q4MF..EE0.2@W9U63e33h9w3lcFFl>    400000000~-
  792. + <87.W3r6is4.@svVqQCBiNqz400A.qwj>    200000000~-
  793. + <0liI7Lu0Mx435m7M99@87Xw.8j63.9.>    500000000~-
  794. + <tRtht5M.6d0@06gj.qm3.s9>    200000000~-    e27S.BKVD70P.o
  795. + <Jpga8@m68yvw.b4b>    200000000~-
  796. + <.2.69hy3JT1@Aq3.r83o.9>    700000000~-
  797. + <.W7EurYppo4fhzs.I@8651m2W7v>    700000000~-
  798. + <3m02.@22074.a5ct2j3>    900000000~-
  799. + <.fy9Epa@.1.kNGCNokFwB8ezo1WM>    800000000~-
  800. + <c758d64.FS4yY7L5@43sw.kI6>    900000000~-
  801. + <vLd0.t@.kq70oHl96ixdnXd.GVv>    100000000~-    9A6Ejq5t55I4VJ6.q1
  802. + <d3.4@n17p4N.77N7W..7.8>    300000000~-
  803. + <f2lv064.8@4jokk3e07>    400000000~-
  804. + <rr7hoxA.U7.JXxnpvd@1rbMO437vHnakx>    000000000~-
  805. + <.0p3G7novlrYz9kjI@Sx.2w.yqzerZl12781.k>    700000000~-
  806. + <51ny.pQ7ay4@nfU2l1f0ixG09584.m>    000000000~-    38K5bhK7cr6.bg.5MlC2Fxq06Ziuw.
  807. + <2.cau.9s@.n4Pk0Jd9g>    300000000~-
  808. + <bEH1Bwa.662i@zm.3g.gx4.lp3>    300000000~-    c8.t4Q0.8t0.m50
  809. + <.t13789u5AqM4m3.z0T@P17e.ypf>    200000000~-    q17z.fZ3.FyD533WthqZs8q7
  810. + <M4r1I@Ovaev.dp>    100000000~-
  811.  
  812. new dbz/getmap (patch can't create, so diff against null):
  813. Index: dbz/getmap
  814. *** cnpatch/old/dbz/getmap    Sat Apr 14 20:29:13 1990
  815. --- dbz/getmap    Thu Apr 12 16:29:25 1990
  816. ***************
  817. *** 0 ****
  818. --- 1,5 ----
  819. + awk 'NR == 1 {
  820. +     for (i = 9; i <= NF; i++)
  821. +         printf "%s ", $i
  822. +     printf "\n"
  823. + }' $*
  824.  
  825. new dbz/random.c (patch can't create, so diff against null):
  826. Index: dbz/random.c
  827. *** cnpatch/old/dbz/random.c    Sat Apr 14 20:29:13 1990
  828. --- dbz/random.c    Sat Mar 31 19:24:21 1990
  829. ***************
  830. *** 0 ****
  831. --- 1,31 ----
  832. + /*
  833. +  * random-number generator for testing
  834. +  */
  835. + static unsigned long next = 1;
  836. + 
  837. + /*
  838. +  - range - generate a random number within an inclusive range
  839. +  *
  840. +  * Algorithm from ANSI C standard.  Limitation:  max-min <= 32767.
  841. +  */
  842. + int
  843. + range(min, max)
  844. + int min;
  845. + int max;
  846. + {
  847. +     register int temp;
  848. + 
  849. +     next = next * 1103515245 + 12345;
  850. +     temp = (int)((next/65536)%32768);
  851. +     return(temp%(max - min + 1) + min);
  852. + }
  853. + 
  854. + /*
  855. +  - seed - seed random number generator
  856. +  */
  857. + void
  858. + seed(n)
  859. + long n;
  860. + {
  861. +     next = (unsigned long)n;
  862. + }
  863.  
  864. new dbz/revbytes (patch can't create, so diff against null):
  865. Index: dbz/revbytes
  866. *** cnpatch/old/dbz/revbytes    Sat Apr 14 20:29:13 1990
  867. --- dbz/revbytes    Thu Apr 12 16:34:45 1990
  868. ***************
  869. *** 0 ****
  870. --- 1,7 ----
  871. + NR == 1 {
  872. +     printf "%s %s %s %s %s %s %s %s %s", $1, $2, $3, $4, $5, $6, $7, $8, $9
  873. +     for (i = NF; i > 9; i--)
  874. +         printf " %s", $i
  875. +     printf "\n"
  876. + }
  877. + NR > 1 { print }
  878.  
  879. new h/dbz.h (patch can't create, so diff against null):
  880. Index: h/dbz.h
  881. *** cnpatch/old/h/dbz.h    Sat Apr 14 20:29:14 1990
  882. --- h/dbz.h    Thu Apr 12 16:18:34 1990
  883. ***************
  884. *** 0 ****
  885. --- 1,31 ----
  886. + /* for dbm and dbz */
  887. + typedef struct {
  888. +     char *dptr;
  889. +     int dsize;
  890. + } datum;
  891. + 
  892. + /* standard dbm functions */
  893. + extern int dbminit();
  894. + extern datum fetch();
  895. + extern int store();
  896. + extern int delete();        /* not in dbz */
  897. + extern datum firstkey();    /* not in dbz */
  898. + extern datum nextkey();        /* not in dbz */
  899. + extern int dbmclose();        /* in dbz, but not in old dbm */
  900. + 
  901. + /* new stuff for dbz */
  902. + extern int dbzfresh();
  903. + extern int dbzagain();
  904. + extern datum dbzfetch();
  905. + extern int dbzstore();
  906. + extern int dbzsync();
  907. + extern long dbzsize();
  908. + extern int dbzincore();
  909. + extern int dbzdebug();
  910. + 
  911. + /*
  912. +  * In principle we could handle unlimited-length keys by operating a chunk
  913. +  * at a time, but it's not worth it in practice.  Setting a nice large
  914. +  * bound on them simplifies the code and doesn't hurt anything.
  915. +  */
  916. + #define DBZMAXKEY    255
  917.  
  918. new libfake/dbz.c (patch can't create, so diff against null):
  919. Index: libfake/dbz.c
  920. *** cnpatch/old/libfake/dbz.c    Sat Apr 14 20:29:15 1990
  921. --- libfake/dbz.c    Thu Apr 12 17:43:54 1990
  922. ***************
  923. *** 0 ****
  924. --- 1,82 ----
  925. + /*
  926. +  * fakes for using dbm (or old dbz) as if it were dbz
  927. +  */
  928. + #include <stdio.h>
  929. + #include <sys/types.h>
  930. + #include <dbz.h>
  931. + 
  932. + /* the simple stuff */
  933. + dbzfresh(a,b,c,d,e) char *a; long b; { return(dbzagain(a,a)); }
  934. + long dbzsize(a) long a; { return(a); }
  935. + dbzincore(n) int n; { return(0); }
  936. + dbzdebug(n) int n; { return(0); }
  937. + long dbztrim(a) long a; { return(a); }
  938. + int dbzsync() { return(0); }
  939. + 
  940. + /*
  941. +  - dbzagain - like dbminit but creates files
  942. +  */
  943. + int
  944. + dbzagain(a, b)
  945. + char *a;
  946. + char *b;
  947. + {
  948. +     char dirname[200];
  949. +     char pagname[200];
  950. +     FILE *p;
  951. +     FILE *d;
  952. + 
  953. +     sprintf(dirname, "%s.dir", a);
  954. +     sprintf(pagname, "%s.pag", a);
  955. +     p = fopen(dirname, "w");
  956. +     d = fopen(pagname, "w");
  957. +     if (p != NULL)
  958. +         (void) fclose(p);
  959. +     if (d != NULL)
  960. +         (void) fclose(d);
  961. +     if (p == NULL || d == NULL)
  962. +         return(-1);
  963. + 
  964. +     return(dbminit(a));
  965. + }
  966. + 
  967. + /*
  968. +  - dbzfetch - fetch() with case mapping built in
  969. +  *
  970. +  * Uses C News rfc822ize().  Assumes keys are strings.
  971. +  */
  972. + datum
  973. + dbzfetch(key)
  974. + datum key;
  975. + {
  976. +     char buffer[DBZMAXKEY + 1];
  977. +     datum mappedkey;
  978. + 
  979. +     (void) strcpy(buffer, key.dptr);
  980. +     (void) rfc822ize(buffer);
  981. +     mappedkey.dptr = buffer;
  982. +     mappedkey.dsize = key.dsize;
  983. + 
  984. +     return(fetch(mappedkey));
  985. + }
  986. + 
  987. + /*
  988. +  - dbzstore - store() with case mapping built in
  989. +  *
  990. +  * Uses C News rfc822ize().  Assumes keys are strings.
  991. +  */
  992. + int
  993. + dbzstore(key, data)
  994. + datum key;
  995. + datum data;
  996. + {
  997. +     char buffer[DBZMAXKEY + 1];
  998. +     datum mappedkey;
  999. + 
  1000. +     (void) strcpy(buffer, key.dptr);
  1001. +     (void) rfc822ize(buffer);
  1002. +     mappedkey.dptr = buffer;
  1003. +     mappedkey.dsize = key.dsize;
  1004. + 
  1005. +     return(store(mappedkey, data));
  1006. + }
  1007.  
  1008.  
  1009. end of patch 16-Apr-1990
  1010.  
  1011.