![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fortune.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / fortune|
Return to fortune.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / fortune |
1.1 root 1: /*
2: * Copyright (c) 1986 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Ken Arnold.
7: *
8: * Redistribution and use in source and binary forms are permitted
9: * provided that the above copyright notice and this paragraph are
10: * duplicated in all such forms and that any documentation,
11: * advertising materials, and other materials related to such
12: * distribution and use acknowledge that the software was developed
13: * by the University of California, Berkeley. The name of the
14: * University may not be used to endorse or promote products derived
15: * from this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: */
20:
21: #ifndef lint
22: char copyright[] =
23: "@(#) Copyright (c) 1986 The Regents of the University of California.\n\
24: All rights reserved.\n";
25: #endif /* not lint */
26:
27: #ifndef lint
28: static char sccsid[] = "@(#)fortune.c 5.12 (Berkeley) 12/15/89";
29: #endif /* not lint */
30:
31: # include <machine/endian.h>
32: # include <sys/param.h>
33: # include <sys/stat.h>
34: # include <sys/dir.h>
35: # include <stdio.h>
36: # include <assert.h>
37: # include "strfile.h"
38: # include "pathnames.h"
39:
40: #ifdef SYSV
41: # include <dirent.h>
42:
43: # define NO_LOCK
44: # define REGCMP
45: # ifdef NO_REGEX
46: # undef NO_REGEX
47: # endif /* NO_REGEX */
48: # define index strchr
49: # define rindex strrchr
50: #endif /* SYSV */
51:
52: #ifndef NO_REGEX
53: # include <ctype.h>
54: #endif /* NO_REGEX */
55:
56: # ifndef NO_LOCK
57: # include <sys/file.h>
58: # endif /* NO_LOCK */
59:
60: # ifndef F_OK
61: /* codes for access() */
62: # define F_OK 0 /* does file exist */
63: # define X_OK 1 /* is it executable by caller */
64: # define W_OK 2 /* writable by caller */
65: # define R_OK 4 /* readable by caller */
66: # endif /* F_OK */
67:
68: # define TRUE 1
69: # define FALSE 0
70: # define bool short
71:
72: # define MINW 6 /* minimum wait if desired */
73: # define CPERS 20 /* # of chars for each sec */
74: # define SLEN 160 /* # of chars in short fortune */
75:
76: # define POS_UNKNOWN ((unsigned long) -1) /* pos for file unknown */
77: # define NO_PROB (-1) /* no prob specified for file */
78:
79: # ifdef DEBUG
80: # define DPRINTF(l,x) if (Debug >= l) fprintf x; else
81: # undef NDEBUG
82: # else /* DEBUG */
83: # define DPRINTF(l,x)
84: # define NDEBUG 1
85: # endif /* DEBUG */
86:
87: typedef struct fd {
88: int percent;
89: int fd, datfd;
90: unsigned long pos;
91: FILE *inf;
92: char *name;
93: char *path;
94: char *datfile, *posfile;
95: bool read_tbl;
96: bool was_pos_file;
97: STRFILE tbl;
98: int num_children;
99: struct fd *child, *parent;
100: struct fd *next, *prev;
101: } FILEDESC;
102:
103: bool Found_one; /* did we find a match? */
104: bool Find_files = FALSE; /* just find a list of proper fortune files */
105: bool Wait = FALSE; /* wait desired after fortune */
106: bool Short_only = FALSE; /* short fortune desired */
107: bool Long_only = FALSE; /* long fortune desired */
108: bool Offend = FALSE; /* offensive fortunes only */
109: bool All_forts = FALSE; /* any fortune allowed */
110: bool Equal_probs = FALSE; /* scatter un-allocted prob equally */
111: #ifndef NO_REGEX
112: bool Match = FALSE; /* dump fortunes matching a pattern */
113: #endif
114: #ifdef DEBUG
115: bool Debug = FALSE; /* print debug messages */
116: #endif
117:
118: char *Fortbuf = NULL; /* fortune buffer for -m */
119:
120: int Fort_len = 0;
121:
122: off_t Seekpts[2]; /* seek pointers to fortunes */
123:
124: FILEDESC *File_list = NULL, /* Head of file list */
125: *File_tail = NULL; /* Tail of file list */
126: FILEDESC *Fortfile; /* Fortune file to use */
127:
128: STRFILE Noprob_tbl; /* sum of data for all no prob files */
129:
130: char *do_malloc(), *copy(), *off_name();
131:
132: FILEDESC *pick_child(), *new_fp();
133:
134: extern char *malloc(), *index(), *rindex(), *strcpy(), *strcat();
135:
136: extern time_t time();
137:
138: #ifndef NO_REGEX
139: char *conv_pat();
140: #endif
141:
142: #ifndef NO_REGEX
143: #ifdef REGCMP
144: # define RE_COMP(p) (Re_pat = regcmp(p, NULL))
145: # define BAD_COMP(f) ((f) == NULL)
146: # define RE_EXEC(p) regex(Re_pat, (p))
147:
148: char *Re_pat;
149:
150: char *regcmp(), *regex();
151: #else
152: # define RE_COMP(p) (p = re_comp(p))
153: # define BAD_COMP(f) ((f) != NULL)
154: # define RE_EXEC(p) re_exec(p)
155:
156: char *re_comp();
157: #ifdef SYSV
158: char *re_exec();
159: #else
160: int re_exec();
161: #endif
162: #endif
163: #endif
164:
165: main(ac, av)
166: int ac;
167: char *av[];
168: {
169: #ifdef OK_TO_WRITE_DISK
170: int fd;
171: #endif /* OK_TO_WRITE_DISK */
172:
173: getargs(ac, av);
174:
175: #ifndef NO_REGEX
176: if (Match)
177: exit(find_matches() != 0);
178: #endif
179:
180: init_prob();
181: srandom((int)(time((time_t *) NULL) + getpid()));
182: do {
183: get_fort();
184: } while ((Short_only && fortlen() > SLEN) ||
185: (Long_only && fortlen() <= SLEN));
186:
187: display(Fortfile);
188:
189: #ifdef OK_TO_WRITE_DISK
190: if ((fd = creat(Fortfile->posfile, 0666)) < 0) {
191: perror(Fortfile->posfile);
192: exit(1);
193: }
194: #ifdef LOCK_EX
195: /*
196: * if we can, we exclusive lock, but since it isn't very
197: * important, we just punt if we don't have easy locking
198: * available.
199: */
200: (void) flock(fd, LOCK_EX);
201: #endif /* LOCK_EX */
202: write(fd, (char *) &Fortfile->pos, sizeof Fortfile->pos);
203: if (!Fortfile->was_pos_file)
204: (void) chmod(Fortfile->path, 0666);
205: #ifdef LOCK_EX
206: (void) flock(fd, LOCK_UN);
207: #endif /* LOCK_EX */
208: #endif /* OK_TO_WRITE_DISK */
209: if (Wait) {
210: if (Fort_len == 0)
211: (void) fortlen();
212: sleep((unsigned int) max(Fort_len / CPERS, MINW));
213: }
214: exit(0);
215: /* NOTREACHED */
216: }
217:
218: display(fp)
219: FILEDESC *fp;
220: {
221: register char *p, ch;
222: char line[BUFSIZ];
223:
224: open_fp(fp);
225: (void) fseek(fp->inf, Seekpts[0], 0);
226: for (Fort_len = 0; fgets(line, sizeof line, fp->inf) != NULL &&
227: !STR_ENDSTRING(line, fp->tbl); Fort_len++) {
228: if (fp->tbl.str_flags & STR_ROTATED)
229: for (p = line; ch = *p; ++p)
230: if (isupper(ch))
231: *p = 'A' + (ch - 'A' + 13) % 26;
232: else if (islower(ch))
233: *p = 'a' + (ch - 'a' + 13) % 26;
234: fputs(line, stdout);
235: }
236: (void) fflush(stdout);
237: }
238:
239: /*
240: * fortlen:
241: * Return the length of the fortune.
242: */
243: fortlen()
244: {
245: register int nchar;
246: char line[BUFSIZ];
247:
248: if (!(Fortfile->tbl.str_flags & (STR_RANDOM | STR_ORDERED)))
249: nchar = (Seekpts[1] - Seekpts[0] <= SLEN);
250: else {
251: open_fp(Fortfile);
252: (void) fseek(Fortfile->inf, Seekpts[0], 0);
253: nchar = 0;
254: while (fgets(line, sizeof line, Fortfile->inf) != NULL &&
255: !STR_ENDSTRING(line, Fortfile->tbl))
256: nchar += strlen(line);
257: }
258: Fort_len = nchar;
259: return nchar;
260: }
261:
262: /*
263: * This routine evaluates the arguments on the command line
264: */
265: getargs(argc, argv)
266: register int argc;
267: register char **argv;
268: {
269: register int ignore_case;
270: # ifndef NO_REGEX
271: register char *pat;
272: # endif /* NO_REGEX */
273: extern char *optarg;
274: extern int optind;
275: int ch;
276:
277: ignore_case = FALSE;
278: pat = NULL;
279:
280: # ifdef DEBUG
281: while ((ch = getopt(argc, argv, "aDefilm:osw")) != EOF)
282: #else
283: while ((ch = getopt(argc, argv, "aefilm:osw")) != EOF)
284: #endif /* DEBUG */
285: switch(ch) {
286: case 'a': /* any fortune */
287: All_forts++;
288: break;
289: # ifdef DEBUG
290: case 'D':
291: Debug++;
292: break;
293: # endif /* DEBUG */
294: case 'e':
295: Equal_probs++; /* scatter un-allocted prob equally */
296: break;
297: case 'f': /* find fortune files */
298: Find_files++;
299: break;
300: case 'l': /* long ones only */
301: Long_only++;
302: Short_only = FALSE;
303: break;
304: case 'o': /* offensive ones only */
305: Offend++;
306: break;
307: case 's': /* short ones only */
308: Short_only++;
309: Long_only = FALSE;
310: break;
311: case 'w': /* give time to read */
312: Wait++;
313: break;
314: # ifdef NO_REGEX
315: case 'i': /* case-insensitive match */
316: case 'm': /* dump out the fortunes */
317: (void) fprintf(stderr,
318: "fortune: can't match fortunes on this system (Sorry)\n");
319: exit(0);
320: # else /* NO_REGEX */
321: case 'm': /* dump out the fortunes */
322: Match++;
323: pat = optarg;
324: break;
325: case 'i': /* case-insensitive match */
326: ignore_case++;
327: break;
328: # endif /* NO_REGEX */
329: case '?':
330: default:
331: usage();
332: }
333: argc -= optind;
334: argv += optind;
335:
336: if (!form_file_list(argv, argc))
337: exit(1); /* errors printed through form_file_list() */
338: #ifdef DEBUG
339: if (Debug >= 1)
340: print_file_list();
341: #endif /* DEBUG */
342: if (Find_files) {
343: print_file_list();
344: exit(0);
345: }
346:
347: # ifndef NO_REGEX
348: if (pat != NULL) {
349: if (ignore_case)
350: pat = conv_pat(pat);
351: if (BAD_COMP(RE_COMP(pat))) {
352: #ifndef REGCMP
353: fprintf(stderr, "%s\n", pat);
354: #else /* REGCMP */
355: fprintf(stderr, "bad pattern: %s\n", pat);
356: #endif /* REGCMP */
357: }
358: }
359: # endif /* NO_REGEX */
360: }
361:
362: /*
363: * form_file_list:
364: * Form the file list from the file specifications.
365: */
366: form_file_list(files, file_cnt)
367: register char **files;
368: register int file_cnt;
369: {
370: register int i, percent;
371: register char *sp;
372:
373: if (file_cnt == 0)
374: if (Find_files)
375: return add_file(NO_PROB, FORTDIR, NULL, &File_list,
376: &File_tail, NULL);
377: else
378: return add_file(NO_PROB, "fortunes", FORTDIR,
379: &File_list, &File_tail, NULL);
380: for (i = 0; i < file_cnt; i++) {
381: percent = NO_PROB;
382: if (!isdigit(files[i][0]))
383: sp = files[i];
384: else {
385: percent = 0;
386: for (sp = files[i]; isdigit(*sp); sp++)
387: percent = percent * 10 + *sp - '0';
388: if (percent > 100) {
389: fprintf(stderr, "percentages must be <= 100\n");
390: return FALSE;
391: }
392: if (*sp == '.') {
393: fprintf(stderr, "percentages must be integers\n");
394: return FALSE;
395: }
396: /*
397: * If the number isn't followed by a '%', then
398: * it was not a percentage, just the first part
399: * of a file name which starts with digits.
400: */
401: if (*sp != '%') {
402: percent = NO_PROB;
403: sp = files[i];
404: }
405: else if (*++sp == '\0') {
406: if (++i >= file_cnt) {
407: fprintf(stderr, "percentages must precede files\n");
408: return FALSE;
409: }
410: sp = files[i];
411: }
412: }
413: if (strcmp(sp, "all") == 0)
414: sp = FORTDIR;
415: if (!add_file(percent, sp, NULL, &File_list, &File_tail, NULL))
416: return FALSE;
417: }
418: return TRUE;
419: }
420:
421: /*
422: * add_file:
423: * Add a file to the file list.
424: */
425: add_file(percent, file, dir, head, tail, parent)
426: int percent;
427: register char *file;
428: char *dir;
429: FILEDESC **head, **tail;
430: FILEDESC *parent;
431: {
432: register FILEDESC *fp;
433: register int fd;
434: register char *path, *offensive;
435: register bool was_malloc;
436: register bool isdir;
437:
438: if (dir == NULL) {
439: path = file;
440: was_malloc = FALSE;
441: }
442: else {
443: path = do_malloc((unsigned int) (strlen(dir) + strlen(file) + 2));
444: (void) strcat(strcat(strcpy(path, dir), "/"), file);
445: was_malloc = TRUE;
446: }
447: if ((isdir = is_dir(path)) && parent != NULL) {
448: if (was_malloc)
449: free(path);
450: return FALSE; /* don't recurse */
451: }
452: offensive = NULL;
453: if (!isdir && parent == NULL && (All_forts || Offend) &&
454: !is_off_name(path)) {
455: offensive = off_name(path);
456: was_malloc = TRUE;
457: if (Offend) {
458: if (was_malloc)
459: free(path);
460: path = offensive;
461: file = off_name(file);
462: }
463: }
464:
465: DPRINTF(1, (stderr, "adding file \"%s\"\n", path));
466: over:
467: if ((fd = open(path, 0)) < 0) {
468: /*
469: * This is a sneak. If the user said -a, and if the
470: * file we're given isn't a file, we check to see if
471: * there is a -o version. If there is, we treat it as
472: * if *that* were the file given. We only do this for
473: * individual files -- if we're scanning a directory,
474: * we'll pick up the -o file anyway.
475: */
476: if (All_forts && offensive != NULL) {
477: path = offensive;
478: if (was_malloc)
479: free(path);
480: offensive = NULL;
481: was_malloc = TRUE;
482: DPRINTF(1, (stderr, "\ttrying \"%s\"\n", path));
483: file = off_name(file);
484: goto over;
485: }
486: if (dir == NULL && file[0] != '/')
487: return add_file(percent, file, FORTDIR, head, tail,
488: parent);
489: if (parent == NULL)
490: perror(path);
491: if (was_malloc)
492: free(path);
493: return FALSE;
494: }
495:
496: DPRINTF(2, (stderr, "path = \"%s\"\n", path));
497:
498: fp = new_fp();
499: fp->fd = fd;
500: fp->percent = percent;
501: fp->name = file;
502: fp->path = path;
503: fp->parent = parent;
504:
505: if ((isdir && !add_dir(fp)) ||
506: (!isdir &&
507: !is_fortfile(path, &fp->datfile, &fp->posfile, (parent != NULL))))
508: {
509: if (parent == NULL)
510: fprintf(stderr,
511: "fortune:%s not a fortune file or directory\n",
512: path);
513: free((char *) fp);
514: if (was_malloc)
515: free(path);
516: do_free(fp->datfile);
517: do_free(fp->posfile);
518: do_free(offensive);
519: return FALSE;
520: }
521: /*
522: * If the user said -a, we need to make this node a pointer to
523: * both files, if there are two. We don't need to do this if
524: * we are scanning a directory, since the scan will pick up the
525: * -o file anyway.
526: */
527: if (All_forts && parent == NULL && !is_off_name(path))
528: all_forts(fp, offensive);
529: if (*head == NULL)
530: *head = *tail = fp;
531: else if (fp->percent == NO_PROB) {
532: (*tail)->next = fp;
533: fp->prev = *tail;
534: *tail = fp;
535: }
536: else {
537: (*head)->prev = fp;
538: fp->next = *head;
539: *head = fp;
540: }
541: #ifdef OK_TO_WRITE_DISK
542: fp->was_pos_file = (access(fp->posfile, W_OK) >= 0);
543: #endif /* OK_TO_WRITE_DISK */
544:
545: return TRUE;
546: }
547:
548: /*
549: * new_fp:
550: * Return a pointer to an initialized new FILEDESC.
551: */
552: FILEDESC *
553: new_fp()
554: {
555: register FILEDESC *fp;
556:
557: fp = (FILEDESC *) do_malloc(sizeof *fp);
558: fp->datfd = -1;
559: fp->pos = POS_UNKNOWN;
560: fp->inf = NULL;
561: fp->fd = -1;
562: fp->percent = NO_PROB;
563: fp->read_tbl = FALSE;
564: fp->next = NULL;
565: fp->prev = NULL;
566: fp->child = NULL;
567: fp->parent = NULL;
568: fp->datfile = NULL;
569: fp->posfile = NULL;
570: return fp;
571: }
572:
573: /*
574: * off_name:
575: * Return a pointer to the offensive version of a file of this name.
576: */
577: char *
578: off_name(file)
579: char *file;
580: {
581: char *new;
582:
583: new = copy(file, (unsigned int) (strlen(file) + 2));
584: return strcat(new, "-o");
585: }
586:
587: /*
588: * is_off_name:
589: * Is the file an offensive-style name?
590: */
591: is_off_name(file)
592: char *file;
593: {
594: int len;
595:
596: len = strlen(file);
597: return (len >= 3 && file[len - 2] == '-' && file[len - 1] == 'o');
598: }
599:
600: /*
601: * all_forts:
602: * Modify a FILEDESC element to be the parent of two children if
603: * there are two children to be a parent of.
604: */
605: all_forts(fp, offensive)
606: register FILEDESC *fp;
607: char *offensive;
608: {
609: register char *sp;
610: register FILEDESC *scene, *obscene;
611: register int fd;
612: auto char *datfile, *posfile;
613:
614: if (fp->child != NULL) /* this is a directory, not a file */
615: return;
616: if (!is_fortfile(offensive, &datfile, &posfile, FALSE))
617: return;
618: if ((fd = open(offensive, 0)) < 0)
619: return;
620: DPRINTF(1, (stderr, "adding \"%s\" because of -a\n", offensive));
621: scene = new_fp();
622: obscene = new_fp();
623: *scene = *fp;
624:
625: fp->num_children = 2;
626: fp->child = scene;
627: scene->next = obscene;
628: obscene->next = NULL;
629: scene->child = obscene->child = NULL;
630: scene->parent = obscene->parent = fp;
631:
632: fp->fd = -1;
633: scene->percent = obscene->percent = NO_PROB;
634:
635: obscene->fd = fd;
636: obscene->inf = NULL;
637: obscene->path = offensive;
638: if ((sp = rindex(offensive, '/')) == NULL)
639: obscene->name = offensive;
640: else
641: obscene->name = ++sp;
642: obscene->datfile = datfile;
643: obscene->posfile = posfile;
644: obscene->read_tbl = FALSE;
645: #ifdef OK_TO_WRITE_DISK
646: obscene->was_pos_file = (access(obscene->posfile, W_OK) >= 0);
647: #endif /* OK_TO_WRITE_DISK */
648: }
649:
650: /*
651: * add_dir:
652: * Add the contents of an entire directory.
653: */
654: add_dir(fp)
655: register FILEDESC *fp;
656: {
657: register DIR *dir;
658: #ifdef SYSV
659: register struct dirent *dirent; /* NIH, of course! */
660: #else
661: register struct direct *dirent;
662: #endif
663: auto FILEDESC *tailp;
664: auto char *name;
665:
666: (void) close(fp->fd);
667: fp->fd = -1;
668: if ((dir = opendir(fp->path)) == NULL) {
669: perror(fp->path);
670: return FALSE;
671: }
672: tailp = NULL;
673: DPRINTF(1, (stderr, "adding dir \"%s\"\n", fp->path));
674: fp->num_children = 0;
675: while ((dirent = readdir(dir)) != NULL) {
676: if (dirent->d_namlen == 0)
677: continue;
678: name = copy(dirent->d_name, dirent->d_namlen);
679: if (add_file(NO_PROB, name, fp->path, &fp->child, &tailp, fp))
680: fp->num_children++;
681: else
682: free(name);
683: }
684: if (fp->num_children == 0) {
685: (void) fprintf(stderr,
686: "fortune: %s: No fortune files in directory.\n", fp->path);
687: return FALSE;
688: }
689: return TRUE;
690: }
691:
692: /*
693: * is_dir:
694: * Return TRUE if the file is a directory, FALSE otherwise.
695: */
696: is_dir(file)
697: char *file;
698: {
699: auto struct stat sbuf;
700:
701: if (stat(file, &sbuf) < 0)
702: return FALSE;
703: return (sbuf.st_mode & S_IFDIR);
704: }
705:
706: /*
707: * is_fortfile:
708: * Return TRUE if the file is a fortune database file. We try and
709: * exclude files without reading them if possible to avoid
710: * overhead. Files which start with ".", or which have "illegal"
711: * suffixes, as contained in suflist[], are ruled out.
712: */
713: /* ARGSUSED */
714: is_fortfile(file, datp, posp, check_for_offend)
715: char *file;
716: char **datp, **posp;
717: int check_for_offend;
718: {
719: register int i;
720: register char *sp;
721: register char *datfile;
722: static char *suflist[] = { /* list of "illegal" suffixes" */
723: "dat", "pos", "c", "h", "p", "i", "f",
724: "pas", "ftn", "ins.c", "ins,pas",
725: "ins.ftn", "sml",
726: NULL
727: };
728:
729: DPRINTF(2, (stderr, "is_fortfile(%s) returns ", file));
730:
731: /*
732: * Preclude any -o files for offendable people, and any non -o
733: * files for completely offensive people.
734: */
735: if (check_for_offend && !All_forts) {
736: i = strlen(file);
737: if (Offend ^ (file[i - 2] == '-' && file[i - 1] == 'o'))
738: return FALSE;
739: }
740:
741: if ((sp = rindex(file, '/')) == NULL)
742: sp = file;
743: else
744: sp++;
745: if (*sp == '.') {
746: DPRINTF(2, (stderr, "FALSE (file starts with '.')\n"));
747: return FALSE;
748: }
749: if ((sp = rindex(sp, '.')) != NULL) {
750: sp++;
751: for (i = 0; suflist[i] != NULL; i++)
752: if (strcmp(sp, suflist[i]) == 0) {
753: DPRINTF(2, (stderr, "FALSE (file has suffix \".%s\")\n", sp));
754: return FALSE;
755: }
756: }
757:
758: datfile = copy(file, (unsigned int) (strlen(file) + 4)); /* +4 for ".dat" */
759: strcat(datfile, ".dat");
760: if (access(datfile, R_OK) < 0) {
761: free(datfile);
762: DPRINTF(2, (stderr, "FALSE (no \".dat\" file)\n"));
763: return FALSE;
764: }
765: if (datp != NULL)
766: *datp = datfile;
767: else
768: free(datfile);
769: #ifdef OK_TO_WRITE_DISK
770: if (posp != NULL) {
771: *posp = copy(file, (unsigned int) (strlen(file) + 4)); /* +4 for ".dat" */
772: (void) strcat(*posp, ".pos");
773: }
774: #endif /* OK_TO_WRITE_DISK */
775: DPRINTF(2, (stderr, "TRUE\n"));
776: return TRUE;
777: }
778:
779: /*
780: * copy:
781: * Return a malloc()'ed copy of the string
782: */
783: char *
784: copy(str, len)
785: char *str;
786: unsigned int len;
787: {
788: char *new, *sp;
789:
790: new = do_malloc(len + 1);
791: sp = new;
792: do {
793: *sp++ = *str;
794: } while (*str++);
795: return new;
796: }
797:
798: /*
799: * do_malloc:
800: * Do a malloc, checking for NULL return.
801: */
802: char *
803: do_malloc(size)
804: unsigned int size;
805: {
806: char *new;
807:
808: if ((new = malloc(size)) == NULL) {
809: (void) fprintf(stderr, "fortune: out of memory.\n");
810: exit(1);
811: }
812: return new;
813: }
814:
815: /*
816: * do_free:
817: * Free malloc'ed space, if any.
818: */
819: do_free(ptr)
820: char *ptr;
821: {
822: if (ptr != NULL)
823: free(ptr);
824: }
825:
826: /*
827: * init_prob:
828: * Initialize the fortune probabilities.
829: */
830: init_prob()
831: {
832: register FILEDESC *fp, *last;
833: register int percent, num_noprob, frac;
834:
835: /*
836: * Distribute the residual probability (if any) across all
837: * files with unspecified probability (i.e., probability of 0)
838: * (if any).
839: */
840:
841: percent = 0;
842: num_noprob = 0;
843: for (fp = File_tail; fp != NULL; fp = fp->prev)
844: if (fp->percent == NO_PROB) {
845: num_noprob++;
846: if (Equal_probs)
847: last = fp;
848: }
849: else
850: percent += fp->percent;
851: DPRINTF(1, (stderr, "summing probabilities:%d%% with %d NO_PROB's",
852: percent, num_noprob));
853: if (percent > 100) {
854: (void) fprintf(stderr,
855: "fortune: probabilities sum to %d%%!\n", percent);
856: exit(1);
857: }
858: else if (percent < 100 && num_noprob == 0) {
859: (void) fprintf(stderr,
860: "fortune: no place to put residual probability (%d%%)\n",
861: percent);
862: exit(1);
863: }
864: else if (percent == 100 && num_noprob != 0) {
865: (void) fprintf(stderr,
866: "fortune: no probability left to put in residual files\n");
867: exit(1);
868: }
869: percent = 100 - percent;
870: if (Equal_probs)
871: if (num_noprob != 0) {
872: if (num_noprob > 1) {
873: frac = percent / num_noprob;
874: DPRINTF(1, (stderr, ", frac = %d%%", frac));
875: for (fp = File_list; fp != last; fp = fp->next)
876: if (fp->percent == NO_PROB) {
877: fp->percent = frac;
878: percent -= frac;
879: }
880: }
881: last->percent = percent;
882: DPRINTF(1, (stderr, ", residual = %d%%", percent));
883: }
884: else {
885: DPRINTF(1, (stderr,
886: ", %d%% distributed over remaining fortunes\n",
887: percent));
888: }
889: DPRINTF(1, (stderr, "\n"));
890:
891: #ifdef DEBUG
892: if (Debug >= 1)
893: print_file_list();
894: #endif
895: }
896:
897: /*
898: * get_fort:
899: * Get the fortune data file's seek pointer for the next fortune.
900: */
901: get_fort()
902: {
903: register FILEDESC *fp;
904: register int choice;
905: long random();
906:
907: if (File_list->next == NULL || File_list->percent == NO_PROB)
908: fp = File_list;
909: else {
910: choice = random() % 100;
911: DPRINTF(1, (stderr, "choice = %d\n", choice));
912: for (fp = File_list; fp->percent != NO_PROB; fp = fp->next)
913: if (choice < fp->percent)
914: break;
915: else {
916: choice -= fp->percent;
917: DPRINTF(1, (stderr,
918: " skip \"%s\", %d%% (choice = %d)\n",
919: fp->name, fp->percent, choice));
920: }
921: DPRINTF(1, (stderr,
922: "using \"%s\", %d%% (choice = %d)\n",
923: fp->name, fp->percent, choice));
924: }
925: if (fp->percent != NO_PROB)
926: get_tbl(fp);
927: else {
928: if (fp->next != NULL) {
929: sum_noprobs(fp);
930: choice = random() % Noprob_tbl.str_numstr;
931: DPRINTF(1, (stderr, "choice = %d (of %d) \n", choice,
932: Noprob_tbl.str_numstr));
933: while (choice >= fp->tbl.str_numstr) {
934: choice -= fp->tbl.str_numstr;
935: fp = fp->next;
936: DPRINTF(1, (stderr,
937: " skip \"%s\", %d (choice = %d)\n",
938: fp->name, fp->tbl.str_numstr,
939: choice));
940: }
941: DPRINTF(1, (stderr, "using \"%s\", %d\n", fp->name,
942: fp->tbl.str_numstr));
943: }
944: get_tbl(fp);
945: }
946: if (fp->child != NULL) {
947: DPRINTF(1, (stderr, "picking child\n"));
948: fp = pick_child(fp);
949: }
950: Fortfile = fp;
951: get_pos(fp);
952: open_dat(fp);
953: (void) lseek(fp->datfd,
954: (off_t) (sizeof fp->tbl + fp->pos * sizeof Seekpts[0]), 0);
955: read(fp->datfd, Seekpts, sizeof Seekpts);
956: Seekpts[0] = ntohl(Seekpts[0]);
957: Seekpts[1] = ntohl(Seekpts[1]);
958: }
959:
960: /*
961: * pick_child
962: * Pick a child from a chosen parent.
963: */
964: FILEDESC *
965: pick_child(parent)
966: FILEDESC *parent;
967: {
968: register FILEDESC *fp;
969: register int choice;
970:
971: if (Equal_probs) {
972: choice = random() % parent->num_children;
973: DPRINTF(1, (stderr, " choice = %d (of %d)\n",
974: choice, parent->num_children));
975: for (fp = parent->child; choice--; fp = fp->next)
976: continue;
977: DPRINTF(1, (stderr, " using %s\n", fp->name));
978: return fp;
979: }
980: else {
981: get_tbl(parent);
982: choice = random() % parent->tbl.str_numstr;
983: DPRINTF(1, (stderr, " choice = %d (of %d)\n",
984: choice, parent->tbl.str_numstr));
985: for (fp = parent->child; choice >= fp->tbl.str_numstr;
986: fp = fp->next) {
987: choice -= fp->tbl.str_numstr;
988: DPRINTF(1, (stderr, "\tskip %s, %d (choice = %d)\n",
989: fp->name, fp->tbl.str_numstr, choice));
990: }
991: DPRINTF(1, (stderr, " using %s, %d\n", fp->name,
992: fp->tbl.str_numstr));
993: return fp;
994: }
995: }
996:
997: /*
998: * sum_noprobs:
999: * Sum up all the noprob probabilities, starting with fp.
1000: */
1001: sum_noprobs(fp)
1002: register FILEDESC *fp;
1003: {
1004: static bool did_noprobs = FALSE;
1005:
1006: if (did_noprobs)
1007: return;
1008: zero_tbl(&Noprob_tbl);
1009: while (fp != NULL) {
1010: get_tbl(fp);
1011: sum_tbl(&Noprob_tbl, &fp->tbl);
1012: fp = fp->next;
1013: }
1014: did_noprobs = TRUE;
1015: }
1016:
1017: max(i, j)
1018: register int i, j;
1019: {
1020: return (i >= j ? i : j);
1021: }
1022:
1023: /*
1024: * open_fp:
1025: * Assocatiate a FILE * with the given FILEDESC.
1026: */
1027: open_fp(fp)
1028: FILEDESC *fp;
1029: {
1030: if (fp->inf == NULL && (fp->inf = fdopen(fp->fd, "r")) == NULL) {
1031: perror(fp->path);
1032: exit(1);
1033: }
1034: }
1035:
1036: /*
1037: * open_dat:
1038: * Open up the dat file if we need to.
1039: */
1040: open_dat(fp)
1041: FILEDESC *fp;
1042: {
1043: if (fp->datfd < 0 && (fp->datfd = open(fp->datfile, 0)) < 0) {
1044: perror(fp->datfile);
1045: exit(1);
1046: }
1047: }
1048:
1049: /*
1050: * get_pos:
1051: * Get the position from the pos file, if there is one. If not,
1052: * return a random number.
1053: */
1054: get_pos(fp)
1055: FILEDESC *fp;
1056: {
1057: #ifdef OK_TO_WRITE_DISK
1058: int fd;
1059: #endif /* OK_TO_WRITE_DISK */
1060:
1061: assert(fp->read_tbl);
1062: if (fp->pos == POS_UNKNOWN) {
1063: #ifdef OK_TO_WRITE_DISK
1064: if ((fd = open(fp->posfile, 0)) < 0 ||
1065: read(fd, &fp->pos, sizeof fp->pos) != sizeof fp->pos)
1066: fp->pos = random() % fp->tbl.str_numstr;
1067: else if (fp->pos >= fp->tbl.str_numstr)
1068: fp->pos %= fp->tbl.str_numstr;
1069: if (fd >= 0)
1070: (void) close(fd);
1071: #else
1072: fp->pos = random() % fp->tbl.str_numstr;
1073: #endif /* OK_TO_WRITE_DISK */
1074: }
1075: if (++(fp->pos) >= fp->tbl.str_numstr)
1076: fp->pos -= fp->tbl.str_numstr;
1077: DPRINTF(1, (stderr, "pos for %s is %d\n", fp->name, fp->pos));
1078: }
1079:
1080: /*
1081: * get_tbl:
1082: * Get the tbl data file the datfile.
1083: */
1084: get_tbl(fp)
1085: FILEDESC *fp;
1086: {
1087: auto int fd;
1088: register FILEDESC *child;
1089:
1090: if (fp->read_tbl)
1091: return;
1092: if (fp->child == NULL) {
1093: if ((fd = open(fp->datfile, 0)) < 0) {
1094: perror(fp->datfile);
1095: exit(1);
1096: }
1097: if (read(fd, (char *) &fp->tbl, sizeof fp->tbl) != sizeof fp->tbl) {
1098: (void)fprintf(stderr,
1099: "fortune: %s corrupted\n", fp->path);
1100: exit(1);
1101: }
1102: /* fp->tbl.str_version = ntohl(fp->tbl.str_version); */
1103: fp->tbl.str_numstr = ntohl(fp->tbl.str_numstr);
1104: fp->tbl.str_longlen = ntohl(fp->tbl.str_longlen);
1105: fp->tbl.str_shortlen = ntohl(fp->tbl.str_shortlen);
1106: fp->tbl.str_flags = ntohl(fp->tbl.str_flags);
1107: (void) close(fd);
1108: }
1109: else {
1110: zero_tbl(&fp->tbl);
1111: for (child = fp->child; child != NULL; child = child->next) {
1112: get_tbl(child);
1113: sum_tbl(&fp->tbl, &child->tbl);
1114: }
1115: }
1116: fp->read_tbl = TRUE;
1117: }
1118:
1119: /*
1120: * zero_tbl:
1121: * Zero out the fields we care about in a tbl structure.
1122: */
1123: zero_tbl(tp)
1124: register STRFILE *tp;
1125: {
1126: tp->str_numstr = 0;
1127: tp->str_longlen = 0;
1128: tp->str_shortlen = -1;
1129: }
1130:
1131: /*
1132: * sum_tbl:
1133: * Merge the tbl data of t2 into t1.
1134: */
1135: sum_tbl(t1, t2)
1136: register STRFILE *t1, *t2;
1137: {
1138: t1->str_numstr += t2->str_numstr;
1139: if (t1->str_longlen < t2->str_longlen)
1140: t1->str_longlen = t2->str_longlen;
1141: if (t1->str_shortlen > t2->str_shortlen)
1142: t1->str_shortlen = t2->str_shortlen;
1143: }
1144:
1145: #define STR(str) ((str) == NULL ? "NULL" : (str))
1146:
1147: /*
1148: * print_file_list:
1149: * Print out the file list
1150: */
1151: print_file_list()
1152: {
1153: print_list(File_list, 0);
1154: }
1155:
1156: /*
1157: * print_list:
1158: * Print out the actual list, recursively.
1159: */
1160: print_list(list, lev)
1161: register FILEDESC *list;
1162: int lev;
1163: {
1164: while (list != NULL) {
1165: fprintf(stderr, "%*s", lev * 4, "");
1166: if (list->percent == NO_PROB)
1167: fprintf(stderr, "___%%");
1168: else
1169: fprintf(stderr, "%3d%%", list->percent);
1170: fprintf(stderr, " %s", STR(list->name));
1171: DPRINTF(1, (stderr, " (%s, %s, %s)\n", STR(list->path),
1172: STR(list->datfile), STR(list->posfile)));
1173: putc('\n', stderr);
1174: if (list->child != NULL)
1175: print_list(list->child, lev + 1);
1176: list = list->next;
1177: }
1178: }
1179:
1180: #ifndef NO_REGEX
1181: /*
1182: * conv_pat:
1183: * Convert the pattern to an ignore-case equivalent.
1184: */
1185: char *
1186: conv_pat(orig)
1187: register char *orig;
1188: {
1189: register char *sp;
1190: register unsigned int cnt;
1191: register char *new;
1192:
1193: cnt = 1; /* allow for '\0' */
1194: for (sp = orig; *sp != '\0'; sp++)
1195: if (isalpha(*sp))
1196: cnt += 4;
1197: else
1198: cnt++;
1199: if ((new = malloc(cnt)) == NULL) {
1200: fprintf(stderr, "pattern too long for ignoring case\n");
1201: exit(1);
1202: }
1203:
1204: for (sp = new; *orig != '\0'; orig++) {
1205: if (islower(*orig)) {
1206: *sp++ = '[';
1207: *sp++ = *orig;
1208: *sp++ = toupper(*orig);
1209: *sp++ = ']';
1210: }
1211: else if (isupper(*orig)) {
1212: *sp++ = '[';
1213: *sp++ = *orig;
1214: *sp++ = tolower(*orig);
1215: *sp++ = ']';
1216: }
1217: else
1218: *sp++ = *orig;
1219: }
1220: *sp = '\0';
1221: return new;
1222: }
1223:
1224: /*
1225: * find_matches:
1226: * Find all the fortunes which match the pattern we've been given.
1227: */
1228: find_matches()
1229: {
1230: Fort_len = maxlen_in_list(File_list);
1231: DPRINTF(2, (stderr, "Maximum length is %d\n", Fort_len));
1232: /* extra length, "%\n" is appended */
1233: Fortbuf = do_malloc((unsigned int) Fort_len + 10);
1234:
1235: Found_one = FALSE;
1236: matches_in_list(File_list);
1237: return Found_one;
1238: /* NOTREACHED */
1239: }
1240:
1241: /*
1242: * maxlen_in_list
1243: * Return the maximum fortune len in the file list.
1244: */
1245: maxlen_in_list(list)
1246: FILEDESC *list;
1247: {
1248: register FILEDESC *fp;
1249: register int len, maxlen;
1250:
1251: maxlen = 0;
1252: for (fp = list; fp != NULL; fp = fp->next) {
1253: if (fp->child != NULL) {
1254: if ((len = maxlen_in_list(fp->child)) > maxlen)
1255: maxlen = len;
1256: }
1257: else {
1258: get_tbl(fp);
1259: if (fp->tbl.str_longlen > maxlen)
1260: maxlen = fp->tbl.str_longlen;
1261: }
1262: }
1263: return maxlen;
1264: }
1265:
1266: /*
1267: * matches_in_list
1268: * Print out the matches from the files in the list.
1269: */
1270: matches_in_list(list)
1271: FILEDESC *list;
1272: {
1273: register char *sp;
1274: register FILEDESC *fp;
1275: int in_file;
1276:
1277: for (fp = list; fp != NULL; fp = fp->next) {
1278: if (fp->child != NULL) {
1279: matches_in_list(fp->child);
1280: continue;
1281: }
1282: DPRINTF(1, (stderr, "searching in %s\n", fp->path));
1283: open_fp(fp);
1284: sp = Fortbuf;
1285: in_file = FALSE;
1286: while (fgets(sp, Fort_len, fp->inf) != NULL)
1287: if (!STR_ENDSTRING(sp, fp->tbl))
1288: sp += strlen(sp);
1289: else {
1290: *sp = '\0';
1291: if (RE_EXEC(Fortbuf)) {
1292: printf("%c%c", fp->tbl.str_delim,
1293: fp->tbl.str_delim);
1294: if (!in_file) {
1295: printf(" (%s)", fp->name);
1296: Found_one = TRUE;
1297: in_file = TRUE;
1298: }
1299: putchar('\n');
1300: (void) fwrite(Fortbuf, 1, (sp - Fortbuf), stdout);
1301: }
1302: sp = Fortbuf;
1303: }
1304: }
1305: }
1306: # endif /* NO_REGEX */
1307:
1308: usage()
1309: {
1310: (void) fprintf(stderr, "fortune [-a");
1311: #ifdef DEBUG
1312: (void) fprintf(stderr, "D");
1313: #endif /* DEBUG */
1314: (void) fprintf(stderr, "f");
1315: #ifndef NO_REGEX
1316: (void) fprintf(stderr, "i");
1317: #endif /* NO_REGEX */
1318: (void) fprintf(stderr, "losw]");
1319: #ifndef NO_REGEX
1320: (void) fprintf(stderr, " [-m pattern]");
1321: #endif /* NO_REGEX */
1322: (void) fprintf(stderr, "[ [#%%] file/directory/all]\n");
1323: exit(1);
1324: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.