games/fortune/fortune/fortune.c

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