usr.sbin/makewhatis/makewhatis.c

   1 /*-
   2  * Copyright (c) 2002 John Rochester
   3  * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer,
  11  *    in this position and unchanged.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/usr.bin/makewhatis/makewhatis.c,v 1.9 2002/09/04 23:29:04 dwmalone Exp $
  30  */
  31
  32 #include <sys/tree.h>
  33 #include <sys/types.h>
  34 #include <sys/param.h>
  35 #include <sys/queue.h>
  36 #include <sys/stat.h>
  37
  38 #include <ctype.h>
  39 #include <dirent.h>
  40 #include <err.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <stringlist.h>
  45 #include <unistd.h>
  46 #include <zlib.h>
  47
  48 #define DEFAULT_MANPATH         "/usr/share/man"
  49 #define LINE_ALLOC              4096
  50
  51 static char blank[] =           "";
  52
  53 /*
  54  * Information collected about each man page alias.
  55  */
  56 struct page_alias {
  57         RB_ENTRY(page_alias) entry;
  58         char *filename;
  59         char *name;
  60         char *suffix;
  61         int gzipped;
  62 };
  63
  64 /*
  65  * Information collected about each unique man page.
  66  */
  67 struct page_info {
  68         RB_HEAD(page_alias_tree, page_alias) head;
  69         RB_ENTRY(page_info) entry;
  70         ino_t inode;
  71 };
  72
  73 static RB_HEAD(page_info_tree, page_info) page_head = RB_INITIALIZER(&page_head);
  74
  75 /*
  76  * Sorts page info by inode number.
  77  */
  78 static int
  79 infosort(const struct page_info *a, const struct page_info *b)
  80 {
  81         return (memcmp(&a->inode, &b->inode, sizeof(a->inode)));
  82 }
  83
  84 RB_PROTOTYPE(page_info_tree, page_info, entry, infosort);
  85 RB_GENERATE(page_info_tree, page_info, entry, infosort);
  86
  87 /*
  88  * Sorts page alias first by suffix, then name.
  89  */
  90 static int
  91 aliassort(const struct page_alias *a, const struct page_alias *b)
  92 {
  93         int ret = strcmp(a->suffix, b->suffix);
  94         if (ret) {
  95                 return (ret);
  96         }
  97
  98         return (strcmp(a->name, b->name));
  99 }
 100
 101 RB_PROTOTYPE(page_alias_tree, page_alias, entry, aliassort);
 102 RB_GENERATE(page_alias_tree, page_alias, entry, aliassort);
 103
 104 /*
 105  * An entry kept for each visited directory.
 106  */
 107 struct visited_dir {
 108         dev_t           device;
 109         ino_t           inode;
 110         SLIST_ENTRY(visited_dir)        next;
 111 };
 112
 113 /*
 114  * an expanding string
 115  */
 116 struct sbuf {
 117         char *  content;                /* the start of the buffer */
 118         char *  end;                    /* just past the end of the content */
 119         char *  last;                   /* the last allocated character */
 120 };
 121
 122 /*
 123  * Removes the last amount characters from the sbuf.
 124  */
 125 #define sbuf_retract(sbuf, amount)      \
 126         ((sbuf)->end -= (amount))
 127 /*
 128  * Returns the length of the sbuf content.
 129  */
 130 #define sbuf_length(sbuf)               \
 131         ((sbuf)->end - (sbuf)->content)
 132
 133 typedef char *edited_copy(char *from, char *to, int length);
 134
 135 static int append;                      /* -a flag: append to existing whatis */
 136 static int verbose;                     /* -v flag: be verbose with warnings */
 137 static int indent = 24;                 /* -i option: description indentation */
 138 static const char *whatis_name="whatis";/* -n option: the name */
 139 static char *common_output;             /* -o option: the single output file */
 140 static char *locale;                    /* user's locale if -L is used */
 141 static char *lang_locale;               /* short form of locale */
 142 static const char *machine;
 143
 144 static int exit_code;                   /* exit code to use when finished */
 145 static SLIST_HEAD(, visited_dir) visited_dirs =
 146     SLIST_HEAD_INITIALIZER(visited_dirs);
 147
 148 /*
 149  * While the whatis line is being formed, it is stored in whatis_proto.
 150  * When finished, it is reformatted into whatis_final and then appended
 151  * to whatis_lines.
 152  */
 153 static struct sbuf *whatis_proto;
 154 static struct sbuf *whatis_final;
 155 static StringList *whatis_lines;        /* collected output lines */
 156
 157 static char tmp_file[MAXPATHLEN];       /* path of temporary file, if any */
 158
 159 /* A set of possible names for the NAME man page section */
 160 static const char *name_section_titles[] = {
 161         "NAME", "Name", "NAMN", "BEZEICHNUNG", "\xcc\xbe\xbe\xce",
 162         "\xee\xe1\xfa\xf7\xe1\xee\xe9\xe5", NULL
 163 };
 164
 165 /* A subset of the mdoc(7) commands to ignore */
 166 static char mdoc_commands[] = "ArDvErEvFlLiNmPa";
 167
 168 /*
 169  * Frees a struct page_info and its content.
 170  */
 171 static void
 172 free_page_info(struct page_info *info)
 173 {
 174         struct page_alias *alias;
 175
 176         while ((alias = RB_ROOT(&info->head))) {
 177                 RB_REMOVE(page_alias_tree, &info->head, alias);
 178                 free(alias->filename);
 179                 free(alias->suffix);
 180                 free(alias->name);
 181                 free(alias);
 182         }
 183
 184         free(info);
 185 }
 186
 187 /*
 188  * Allocates and fills in a new struct page_alias given the
 189  * full file name of the man page and its dirent.
 190  * If the file is not a man page, nothing is added.
 191  */
 192 static void
 193 new_page_alias(struct page_info *info, char *filename, struct dirent *dirent)
 194 {
 195         int gzipped, basename_length;
 196         struct page_alias *alias;
 197         char *suffix;
 198
 199         basename_length = strlen(dirent->d_name);
 200         suffix = &dirent->d_name[basename_length];
 201
 202         gzipped = basename_length >= 4 &&
 203             strcmp(&dirent->d_name[basename_length - 3], ".gz") == 0;
 204         if (gzipped) {
 205                 suffix -= 3;
 206                 *suffix = '\0';
 207         }
 208
 209         for (;;) {
 210                 if (--suffix == dirent->d_name || !isalnum(*suffix)) {
 211                         if (*suffix == '.') {
 212                                 break;
 213                         }
 214                         if (verbose) {
 215                                 warnx("%s: invalid man page name", filename);
 216                         }
 217                         return;
 218                 }
 219         }
 220
 221         *suffix++ = '\0';
 222
 223         alias = malloc(sizeof(*alias));
 224         if (alias == NULL) {
 225                 err(1, "malloc");
 226         }
 227
 228         alias->name = strdup(dirent->d_name);   /* XXX unsafe */
 229         alias->filename = strdup(filename);     /* XXX unsafe */
 230         alias->suffix = strdup(suffix);         /* XXX unsafe */
 231         alias->gzipped = gzipped;
 232
 233         RB_INSERT(page_alias_tree, &info->head, alias);
 234 }
 235
 236 /*
 237  * Reset an sbuf's length to 0.
 238  */
 239 static void
 240 sbuf_clear(struct sbuf *sbuf)
 241 {
 242         sbuf->end = sbuf->content;
 243 }
 244
 245 /*
 246  * Allocate a new sbuf.
 247  */
 248 static struct sbuf *
 249 new_sbuf(void)
 250 {
 251         struct sbuf *sbuf = (struct sbuf *) malloc(sizeof(struct sbuf));
 252         sbuf->content = malloc(LINE_ALLOC);
 253         sbuf->last = sbuf->content + LINE_ALLOC - 1;
 254         sbuf_clear(sbuf);
 255         return(sbuf);
 256 }
 257
 258 /*
 259  * Ensure that there is enough room in the sbuf for nchars more characters.
 260  */
 261 static void
 262 sbuf_need(struct sbuf *sbuf, int nchars)
 263 {
 264         char *new_content;
 265         size_t size, cntsize;
 266
 267         /* double the size of the allocation until the buffer is big enough */
 268         while (sbuf->end + nchars > sbuf->last) {
 269                 size = sbuf->last + 1 - sbuf->content;
 270                 size *= 2;
 271                 cntsize = sbuf->end - sbuf->content;
 272
 273                 new_content = malloc(size);
 274                 memcpy(new_content, sbuf->content, cntsize);
 275                 free(sbuf->content);
 276                 sbuf->content = new_content;
 277                 sbuf->end = new_content + cntsize;
 278                 sbuf->last = new_content + size - 1;
 279         }
 280 }
 281
 282 /*
 283  * Appends a string of a given length to the sbuf.
 284  */
 285 static void
 286 sbuf_append(struct sbuf *sbuf, const char *text, int length)
 287 {
 288         if (length > 0) {
 289                 sbuf_need(sbuf, length);
 290                 memcpy(sbuf->end, text, length);
 291                 sbuf->end += length;
 292         }
 293 }
 294
 295 /*
 296  * Appends a null-terminated string to the sbuf.
 297  */
 298 static void
 299 sbuf_append_str(struct sbuf *sbuf, char *text)
 300 {
 301         sbuf_append(sbuf, text, strlen(text));
 302 }
 303
 304 /*
 305  * Appends an edited null-terminated string to the sbuf.
 306  */
 307 static void
 308 sbuf_append_edited(struct sbuf *sbuf, char *text, edited_copy copy)
 309 {
 310         int length = strlen(text);
 311         if (length > 0) {
 312                 sbuf_need(sbuf, length);
 313                 sbuf->end = copy(text, sbuf->end, length);
 314         }
 315 }
 316
 317 /*
 318  * Strips any of a set of chars from the end of the sbuf.
 319  */
 320 static void
 321 sbuf_strip(struct sbuf *sbuf, const char *set)
 322 {
 323         while (sbuf->end > sbuf->content && strchr(set, sbuf->end[-1]) != NULL)
 324                 sbuf->end--;
 325 }
 326
 327 /*
 328  * Returns the null-terminated string built by the sbuf.
 329  */
 330 static char *
 331 sbuf_content(struct sbuf *sbuf)
 332 {
 333         *sbuf->end = '\0';
 334         return(sbuf->content);
 335 }
 336
 337 static void
 338 trap_signal(int sig __unused)
 339 {
 340         if (tmp_file[0] != '\0')
 341                 unlink(tmp_file);
 342         exit(1);
 343 }
 344
 345 /*
 346  * Attempts to open an output file.  Returns NULL if unsuccessful.
 347  */
 348 static FILE *
 349 open_output(char *name)
 350 {
 351         FILE *output;
 352
 353         whatis_lines = sl_init();
 354         if (append) {
 355                 char line[LINE_ALLOC];
 356
 357                 output = fopen(name, "r");
 358                 if (output == NULL) {
 359                         warn("%s", name);
 360                         exit_code = 1;
 361                         return(NULL);
 362                 }
 363                 while (fgets(line, sizeof line, output) != NULL) {
 364                         line[strlen(line) - 1] = '\0';
 365                         sl_add(whatis_lines, strdup(line));
 366                 }
 367         }
 368         if (common_output == NULL) {
 369                 snprintf(tmp_file, sizeof tmp_file, "%s.tmp", name);
 370                 name = tmp_file;
 371         }
 372         output = fopen(name, "w");
 373         if (output == NULL) {
 374                 warn("%s", name);
 375                 exit_code = 1;
 376                 return(NULL);
 377         }
 378         return(output);
 379 }
 380
 381 static int
 382 linesort(const void *a, const void *b)
 383 {
 384         return(strcmp((*(const char * const *)a), (*(const char * const *)b)));
 385 }
 386
 387 /*
 388  * Writes the unique sorted lines to the output file.
 389  */
 390 static void
 391 finish_output(FILE *output, char *name)
 392 {
 393         size_t i;
 394         char *prev = NULL;
 395
 396         qsort(whatis_lines->sl_str, whatis_lines->sl_cur, sizeof(char *),
 397               linesort);
 398         for (i = 0; i < whatis_lines->sl_cur; i++) {
 399                 char *line = whatis_lines->sl_str[i];
 400                 if (i > 0 && strcmp(line, prev) == 0)
 401                         continue;
 402                 prev = line;
 403                 fputs(line, output);
 404                 putc('\n', output);
 405         }
 406         fclose(output);
 407         sl_free(whatis_lines, 1);
 408         if (common_output == NULL) {
 409                 rename(tmp_file, name);
 410                 unlink(tmp_file);
 411         }
 412 }
 413
 414 static FILE *
 415 open_whatis(char *mandir)
 416 {
 417         char filename[MAXPATHLEN];
 418
 419         snprintf(filename, sizeof filename, "%s/%s", mandir, whatis_name);
 420         return(open_output(filename));
 421 }
 422
 423 static void
 424 finish_whatis(FILE *output, char *mandir)
 425 {
 426         char filename[MAXPATHLEN];
 427
 428         snprintf(filename, sizeof filename, "%s/%s", mandir, whatis_name);
 429         finish_output(output, filename);
 430 }
 431
 432 /*
 433  * Tests to see if the given directory has already been visited.
 434  */
 435 static int
 436 already_visited(char *dir)
 437 {
 438         struct stat st;
 439         struct visited_dir *visit;
 440
 441         if (stat(dir, &st) < 0) {
 442                 warn("%s", dir);
 443                 exit_code = 1;
 444                 return(1);
 445         }
 446         SLIST_FOREACH(visit, &visited_dirs, next) {
 447                 if (visit->inode == st.st_ino &&
 448                     visit->device == st.st_dev) {
 449                         warnx("already visited %s", dir);
 450                         return(1);
 451                 }
 452         }
 453         visit = (struct visited_dir *) malloc(sizeof(struct visited_dir));
 454         visit->device = st.st_dev;
 455         visit->inode = st.st_ino;
 456         SLIST_INSERT_HEAD(&visited_dirs, visit, next);
 457         return(0);
 458 }
 459
 460 /*
 461  * Removes trailing spaces from a string, returning a pointer to just
 462  * beyond the new last character.
 463  */
 464 static char *
 465 trim_rhs(char *str)
 466 {
 467         char *rhs = &str[strlen(str)];
 468         while (--rhs > str && isspace(*rhs))
 469                 ;
 470         *++rhs = '\0';
 471         return(rhs);
 472 }
 473
 474 /*
 475  * Returns a pointer to the next non-space character in the string.
 476  */
 477 static char *
 478 skip_spaces(char *s)
 479 {
 480         while (*s != '\0' && isspace(*s))
 481                 s++;
 482         return(s);
 483 }
 484
 485 /*
 486  * Returns whether the string contains only digits.
 487  */
 488 static int
 489 only_digits(char *line)
 490 {
 491         if (!isdigit(*line++))
 492                 return(0);
 493         while (isdigit(*line))
 494                 line++;
 495         return(*line == '\0');
 496 }
 497
 498 /*
 499  * Returns whether the line is of one of the forms:
 500  *      .Sh NAME
 501  *      .Sh "NAME"
 502  *      etc.
 503  * assuming that section_start is ".Sh".
 504  */
 505 static int
 506 name_section_line(char *line, const char *section_start)
 507 {
 508         char *rhs;
 509         const char **title;
 510
 511         if (strncmp(line, section_start, 3) != 0)
 512                 return(0);
 513         line = skip_spaces(line + 3);
 514         rhs = trim_rhs(line);
 515         if (*line == '"') {
 516                 line++;
 517                 if (*--rhs == '"')
 518                         *rhs = '\0';
 519         }
 520         for (title = name_section_titles; *title != NULL; title++)
 521                 if (strcmp(*title, line) == 0)
 522                         return(1);
 523         return(0);
 524 }
 525
 526 /*
 527  * Copies characters while removing the most common nroff/troff
 528  * markup:
 529  *      \(em, \(mi, \s[+-N], \&
 530  *      \fF, \f(fo, \f[font]
 531  *      \*s, \*(st, \*[stringvar]
 532  */
 533 static char *
 534 de_nroff_copy(char *from, char *to, int fromlen)
 535 {
 536         char *from_end = &from[fromlen];
 537         while (from < from_end) {
 538                 switch (*from) {
 539                 case '\\':
 540                         switch (*++from) {
 541                         case '(':
 542                                 if (strncmp(&from[1], "em", 2) == 0 ||
 543                                     strncmp(&from[1], "mi", 2) == 0) {
 544                                         from += 3;
 545                                         continue;
 546                                 }
 547                                 break;
 548                         case 's':
 549                                 if (*++from == '-')
 550                                         from++;
 551                                 while (isdigit(*from))
 552                                         from++;
 553                                 continue;
 554                         case 'f':
 555                         case '*':
 556                                 if (*++from == '(')
 557                                         from += 3;
 558                                 else if (*from == '[') {
 559                                         while (*++from != ']' && from < from_end)
 560                                                 ;
 561                                         from++;
 562                                 } else
 563                                         from++;
 564                                 continue;
 565                         case '&':
 566                                 from++;
 567                                 continue;
 568                         }
 569                         break;
 570                 }
 571                 *to++ = *from++;
 572         }
 573         return(to);
 574 }
 575
 576 /*
 577  * Appends a string with the nroff formatting removed.
 578  */
 579 static void
 580 add_nroff(char *text)
 581 {
 582         sbuf_append_edited(whatis_proto, text, de_nroff_copy);
 583 }
 584
 585 /*
 586  * Appends "name(suffix), " to whatis_final.
 587  */
 588 static void
 589 add_whatis_name(char *name, char *suffix)
 590 {
 591         if (*name != '\0') {
 592                 sbuf_append_str(whatis_final, name);
 593                 sbuf_append(whatis_final, "(", 1);
 594                 sbuf_append_str(whatis_final, suffix);
 595                 sbuf_append(whatis_final, "), ", 3);
 596         }
 597 }
 598
 599 /*
 600  * Processes an old-style man(7) line.  This ignores commands with only
 601  * a single number argument.
 602  */
 603 static void
 604 process_man_line(char *line)
 605 {
 606         if (*line == '.') {
 607                 while (isalpha(*++line))
 608                         ;
 609                 line = skip_spaces(line);
 610                 if (only_digits(line))
 611                         return;
 612         } else
 613                 line = skip_spaces(line);
 614         if (*line != '\0') {
 615                 add_nroff(line);
 616                 sbuf_append(whatis_proto, " ", 1);
 617         }
 618 }
 619
 620 /*
 621  * Processes a new-style mdoc(7) line.
 622  */
 623 static void
 624 process_mdoc_line(char *line)
 625 {
 626         int xref;
 627         int arg = 0;
 628         char *line_end = &line[strlen(line)];
 629         int orig_length = sbuf_length(whatis_proto);
 630         char *next;
 631
 632         if (*line == '\0')
 633                 return;
 634         if (line[0] != '.' || !isupper(line[1]) || !islower(line[2])) {
 635                 add_nroff(skip_spaces(line));
 636                 sbuf_append(whatis_proto, " ", 1);
 637                 return;
 638         }
 639         xref = strncmp(line, ".Xr", 3) == 0;
 640         line += 3;
 641         while ((line = skip_spaces(line)) < line_end) {
 642                 if (*line == '"') {
 643                         next = ++line;
 644                         for (;;) {
 645                                 next = strchr(next, '"');
 646                                 if (next == NULL)
 647                                         break;
 648                                 memmove(next, next + 1, strlen(next));
 649                                 line_end--;
 650                                 if (*next != '"')
 651                                         break;
 652                                 next++;
 653                         }
 654                 } else
 655                         next = strpbrk(line, " \t");
 656                 if (next != NULL)
 657                         *next++ = '\0';
 658                 else
 659                         next = line_end;
 660                 if (isupper(*line) && islower(line[1]) && line[2] == '\0') {
 661                         if (strcmp(line, "Ns") == 0) {
 662                                 arg = 0;
 663                                 line = next;
 664                                 continue;
 665                         }
 666                         if (strstr(mdoc_commands, line) != NULL) {
 667                                 line = next;
 668                                 continue;
 669                         }
 670                 }
 671                 if (arg > 0 && strchr(",.:;?!)]", *line) == 0) {
 672                         if (xref) {
 673                                 sbuf_append(whatis_proto, "(", 1);
 674                                 add_nroff(line);
 675                                 sbuf_append(whatis_proto, ")", 1);
 676                                 xref = 0;
 677                                 line = blank;
 678                         } else
 679                                 sbuf_append(whatis_proto, " ", 1);
 680                 }
 681                 add_nroff(line);
 682                 arg++;
 683                 line = next;
 684         }
 685         if (sbuf_length(whatis_proto) > orig_length)
 686                 sbuf_append(whatis_proto, " ", 1);
 687 }
 688
 689 enum { STATE_UNKNOWN, STATE_MANSTYLE, STATE_MDOCNAME, STATE_MDOCDESC };
 690
 691 /*
 692  * Processes a man page source into a single whatis line and adds it
 693  * to whatis_lines.
 694  */
 695 static void
 696 process_page(struct page_info *info)
 697 {
 698         int state = STATE_UNKNOWN;
 699         struct page_alias *alias;
 700         char *line, *descr;
 701         char buffer[4096];
 702         gzFile in;
 703
 704         /*
 705          * Only read the page once for each inode.  It's
 706          * safe to assume that page->list is set.
 707          */
 708         alias = RB_MIN(page_alias_tree, &info->head);
 709
 710         if (verbose) {
 711                 fprintf(stderr, "\treading %s\n", alias->filename);
 712         }
 713
 714         sbuf_clear(whatis_proto);
 715         if ((in = gzopen(alias->filename, "r")) == NULL) {
 716                 warn("%s", alias->filename);
 717                 exit_code = 1;
 718                 return;
 719         }
 720         while (gzgets(in, buffer, sizeof(buffer)) != NULL) {
 721                 line = buffer;
 722                 if (strncmp(line, ".\\\"", 3) == 0)     /* ignore comments */
 723                         continue;
 724                 switch (state) {
 725                 /*
 726                  * haven't reached the NAME section yet.
 727                  */
 728                 case STATE_UNKNOWN:
 729                         if (name_section_line(line, ".SH"))
 730                                 state = STATE_MANSTYLE;
 731                         else if (name_section_line(line, ".Sh"))
 732                                 state = STATE_MDOCNAME;
 733                         continue;
 734                 /*
 735                  * Inside an old-style .SH NAME section.
 736                  */
 737                 case STATE_MANSTYLE:
 738                         if (strncmp(line, ".SH", 3) == 0)
 739                                 break;
 740                         if (strncmp(line, ".SS", 3) == 0)
 741                                 break;
 742                         trim_rhs(line);
 743                         if (strcmp(line, ".") == 0)
 744                                 continue;
 745                         if (strncmp(line, ".IX", 3) == 0) {
 746                                 line += 3;
 747                                 line = skip_spaces(line);
 748                         }
 749                         process_man_line(line);
 750                         continue;
 751                 /*
 752                  * Inside a new-style .Sh NAME section (the .Nm part).
 753                  */
 754                 case STATE_MDOCNAME:
 755                         trim_rhs(line);
 756                         if (strncmp(line, ".Nm", 3) == 0) {
 757                                 process_mdoc_line(line);
 758                                 continue;
 759                         } else {
 760                                 if (strcmp(line, ".") == 0)
 761                                         continue;
 762                                 sbuf_append(whatis_proto, "- ", 2);
 763                                 state = STATE_MDOCDESC;
 764                         }
 765                         /* fall through */
 766                 /*
 767                  * Inside a new-style .Sh NAME section (after the .Nm-s).
 768                  */
 769                 case STATE_MDOCDESC:
 770                         if (strncmp(line, ".Sh", 3) == 0)
 771                                 break;
 772                         trim_rhs(line);
 773                         if (strcmp(line, ".") == 0)
 774                                 continue;
 775                         process_mdoc_line(line);
 776                         continue;
 777                 }
 778                 break;
 779         }
 780         gzclose(in);
 781         sbuf_strip(whatis_proto, " \t.-");
 782         line = sbuf_content(whatis_proto);
 783         /*
 784          * line now contains the appropriate data, but without
 785          * the proper indentation or the section appended to each name.
 786          */
 787         descr = strstr(line, " - ");
 788         if (descr == NULL) {
 789                 descr = strchr(line, ' ');
 790                 if (descr == NULL) {
 791                         if (verbose)
 792                                 fprintf(stderr,
 793                                         "\tignoring junk description \"%s\"\n",
 794                                         line);
 795                         return;
 796                 }
 797                 *descr++ = '\0';
 798         } else {
 799                 *descr = '\0';
 800                 descr += 3;
 801         }
 802         sbuf_clear(whatis_final);
 803         RB_FOREACH(alias, page_alias_tree, &info->head) {
 804                 /*
 805                  * This won't append names stored in `line'.
 806                  * The reason for that is that we cannot be sure
 807                  * which section they belong to unless we have
 808                  * a real alias (via MLINKS) in this list.
 809                  */
 810                 add_whatis_name(alias->name, alias->suffix);
 811         }
 812         sbuf_retract(whatis_final, 2);          /* remove last ", " */
 813         while (sbuf_length(whatis_final) < indent)
 814                 sbuf_append(whatis_final, " ", 1);
 815         sbuf_append(whatis_final, " - ", 3);
 816         sbuf_append_str(whatis_final, skip_spaces(descr));
 817         sl_add(whatis_lines, strdup(sbuf_content(whatis_final)));
 818 }
 819
 820 /*
 821  * Processes a single man section.
 822  */
 823 static void
 824 process_section(char *section_dir)
 825 {
 826         struct dirent **entries;
 827         struct page_info *info;
 828         int nentries;
 829         int i;
 830
 831         if (verbose) {
 832                 fprintf(stderr, "  %s\n", section_dir);
 833         }
 834
 835         /*
 836          * scan the man section directory for pages
 837          */
 838         nentries = scandir(section_dir, &entries, NULL, alphasort);
 839         if (nentries < 0) {
 840                 warn("%s", section_dir);
 841                 exit_code = 1;
 842                 return;
 843         }
 844
 845         /*
 846          * collect information about man pages
 847          */
 848         for (i = 0; i < nentries; i++) {
 849                 struct page_info ref;
 850                 char *filename;
 851                 struct stat st;
 852
 853                 if (asprintf(&filename, "%s/%s", section_dir,
 854                     entries[i]->d_name) < 0) {
 855                         err(1, "malloc");
 856                 }
 857
 858                 if (stat(filename, &st) < 0) {
 859                         warn("%s", filename);
 860                         goto process_section_next;
 861                 }
 862
 863                 if (!S_ISREG(st.st_mode)) {
 864                         if (verbose && !S_ISDIR(st.st_mode))
 865                             warnx("%s: not a regular file", filename);
 866                         goto process_section_next;
 867                 }
 868
 869                 ref.inode = st.st_ino;
 870
 871                 info = RB_FIND(page_info_tree, &page_head, &ref);
 872                 if (info == NULL) {
 873                         info = malloc(sizeof(*info));
 874                         if (info == NULL) {
 875                                 err(1, "malloc");
 876                         }
 877
 878                         bzero(info, sizeof(*info));
 879                         info->inode = st.st_ino;
 880                         RB_INIT(&info->head);
 881
 882                         RB_INSERT(page_info_tree, &page_head, info);
 883                 }
 884
 885                 new_page_alias(info, filename, entries[i]);
 886
 887 process_section_next:
 888
 889                 free(entries[i]);
 890                 free(filename);
 891         }
 892         free(entries);
 893 }
 894
 895 /*
 896  * Returns whether the directory entry is a man page section.
 897  */
 898 static int
 899 select_sections(const struct dirent *entry)
 900 {
 901         const char *p = &entry->d_name[3];
 902
 903         if (strncmp(entry->d_name, "man", 3) != 0)
 904                 return(0);
 905         while (*p != '\0') {
 906                 if (!isalnum(*p++))
 907                         return(0);
 908         }
 909         return(1);
 910 }
 911
 912 /*
 913  * Processes a single top-level man directory by finding all the
 914  * sub-directories named man* and processing each one in turn.
 915  */
 916 static void
 917 process_mandir(char *dir_name)
 918 {
 919         struct dirent **entries;
 920         struct page_info *info;
 921         int nsections;
 922         FILE *fp = NULL;
 923         int i;
 924         struct stat st;
 925
 926         if (already_visited(dir_name))
 927                 return;
 928         if (verbose)
 929                 fprintf(stderr, "man directory %s\n", dir_name);
 930         nsections = scandir(dir_name, &entries, select_sections, alphasort);
 931         if (nsections < 0) {
 932                 warn("%s", dir_name);
 933                 exit_code = 1;
 934                 return;
 935         }
 936         if (common_output == NULL && (fp = open_whatis(dir_name)) == NULL)
 937                 return;
 938         for (i = 0; i < nsections; i++) {
 939                 char section_dir[MAXPATHLEN];
 940                 snprintf(section_dir, sizeof section_dir, "%s/%s", dir_name,
 941                          entries[i]->d_name);
 942                 process_section(section_dir);
 943                 snprintf(section_dir, sizeof section_dir, "%s/%s/%s", dir_name,
 944                          entries[i]->d_name, machine);
 945                 if (stat(section_dir, &st) == 0 && S_ISDIR(st.st_mode))
 946                         process_section(section_dir);
 947                 free(entries[i]);
 948         }
 949         free(entries);
 950
 951         /*
 952          * process and free all pages
 953          */
 954         while ((info = RB_ROOT(&page_head))) {
 955                 RB_REMOVE(page_info_tree, &page_head, info);
 956                 process_page(info);
 957                 free_page_info(info);
 958         }
 959
 960         if (common_output == NULL)
 961                 finish_whatis(fp, dir_name);
 962 }
 963
 964 /*
 965  * Processes one argument, which may be a colon-separated list of
 966  * directories.
 967  */
 968 static void
 969 process_argument(const char *arg)
 970 {
 971         char *dir;
 972         char *mandir;
 973         char *parg;
 974
 975         parg = strdup(arg);
 976         if (parg == NULL)
 977                 err(1, "out of memory");
 978         while ((dir = strsep(&parg, ":")) != NULL) {
 979                 if (locale != NULL) {
 980                         asprintf(&mandir, "%s/%s", dir, locale);
 981                         process_mandir(mandir);
 982                         free(mandir);
 983                         if (lang_locale != NULL) {
 984                                 asprintf(&mandir, "%s/%s", dir, lang_locale);
 985                                 process_mandir(mandir);
 986                                 free(mandir);
 987                         }
 988                 } else {
 989                         process_mandir(dir);
 990                 }
 991         }
 992         free(parg);
 993 }
 994
 995
 996 int
 997 main(int argc, char **argv)
 998 {
 999         int opt;
1000         FILE *fp = NULL;
1001
1002         while ((opt = getopt(argc, argv, "ai:n:o:vL")) != -1) {
1003                 switch (opt) {
1004                 case 'a':
1005                         append++;
1006                         break;
1007                 case 'i':
1008                         indent = atoi(optarg);
1009                         break;
1010                 case 'n':
1011                         whatis_name = optarg;
1012                         break;
1013                 case 'o':
1014                         common_output = optarg;
1015                         break;
1016                 case 'v':
1017                         verbose++;
1018                         break;
1019                 case 'L':
1020                         locale = getenv("LC_ALL");
1021                         if (locale == NULL)
1022                                 locale = getenv("LC_CTYPE");
1023                         if (locale == NULL)
1024                                 locale = getenv("LANG");
1025                         if (locale != NULL) {
1026                                 char *sep = strchr(locale, '_');
1027                                 if (sep != NULL && isupper(sep[1]) &&
1028                                     isupper(sep[2])) {
1029                                         asprintf(&lang_locale, "%.*s%s",
1030                                             (int)(sep - locale),
1031                                             locale, &sep[3]);
1032                                 }
1033                         }
1034                         break;
1035                 default:
1036                         fprintf(stderr, "usage: %s [-a] [-i indent] [-n name] [-o output_file] [-v] [-L] [directories...]\n", argv[0]);
1037                         exit(1);
1038                 }
1039         }
1040
1041         signal(SIGINT, trap_signal);
1042         signal(SIGHUP, trap_signal);
1043         signal(SIGQUIT, trap_signal);
1044         signal(SIGTERM, trap_signal);
1045         SLIST_INIT(&visited_dirs);
1046         whatis_proto = new_sbuf();
1047         whatis_final = new_sbuf();
1048
1049         if ((machine = getenv("MACHINE")) == NULL)
1050                 machine = MACHINE;
1051
1052         if (common_output != NULL && (fp = open_output(common_output)) == NULL)
1053                 err(1, "%s", common_output);
1054         if (optind == argc) {
1055                 const char *manpath = getenv("MANPATH");
1056                 if (manpath == NULL)
1057                         manpath = DEFAULT_MANPATH;
1058                 process_argument(manpath);
1059         } else {
1060                 while (optind < argc)
1061                         process_argument(argv[optind++]);
1062         }
1063         if (common_output != NULL)
1064                 finish_output(fp, common_output);
1065         exit(exit_code);
1066 }