cmd/man/man.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2012, Josef 'Jeff' Sipek <jeffpc@31bits.net>. All rights reserved.
 * Copyright 2014 Garrett D'Amore <garrett@damore.org>
 * Copyright 2016 Nexenta Systems, Inc.
 */

/*  Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989  AT&T.   */
/*      All rights reserved.                    */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*
 * Find and display reference manual pages. This version includes makewhatis
 * functionality as well.
 */

#include <sys/param.h>
#include <sys/stat.h>
#include <sys/termios.h>
#include <sys/types.h>

#include <ctype.h>
#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <fnmatch.h>
#include <limits.h>
#include <locale.h>
#include <malloc.h>
#include <memory.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "man.h"


/* Mapping of old directories to new directories */
static const struct map_entry {
    char    *old_name;
    char    *new_name;
} map[] = {
    { "3b",     "3ucb"      },
    { "3e",     "3elf"      },
    { "3g",     "3gen"      },
    { "3k",     "3kstat"    },
    { "3n",     "3socket"   },
    { "3r",     "3rt"       },
    { "3s",     "3c"        },
    { "3t",     "3thr"      },
    { "3x",     "3curses"   },
    { "3xc",    "3xcurses"  },
    { "3xn",    "3xnet"     },
    { NULL,     NULL        }
};

struct suffix {
    char *ds;
    char *fs;
};

/*
 * Flags that control behavior of build_manpath()
 *
 *   BMP_ISPATH         pathv is a vector constructed from PATH.
 *                      Perform appropriate path translations for
 *              manpath.
 *   BMP_APPEND_DEFMANDIR   Add DEFMANDIR to the end if it hasn't
 *              already appeared earlier.
 *   BMP_FALLBACK_DEFMANDIR Append /usr/share/man only if no other
 *              manpath (including derived from PATH)
 *              elements are valid.
 */
#define BMP_ISPATH      1
#define BMP_APPEND_DEFMANDIR    2
#define BMP_FALLBACK_DEFMANDIR  4

/*
 * When doing equality comparisons of directories, device and inode
 * comparisons are done.  The secnode and dupnode structures are used
 * to form a list of lists for this processing.
 */
struct secnode {
    char        *secp;
    struct secnode  *next;
};
struct dupnode {
    dev_t       dev;    /* from struct stat st_dev */
    ino_t       ino;    /* from struct stat st_ino */
    struct secnode  *secl;  /* sections already considered */
    struct dupnode  *next;
};

/*
 * Map directories that may appear in PATH to the corresponding
 * man directory.
 */
static struct pathmap {
    char    *bindir;
    char    *mandir;
    dev_t   dev;
    ino_t   ino;
} bintoman[] = {
    { "/sbin",      "/usr/share/man,1m",        0, 0 },
    { "/usr/sbin",      "/usr/share/man,1m",        0, 0 },
    { "/usr/ucb",       "/usr/share/man,1b",        0, 0 },
    { "/usr/bin",       "/usr/share/man,1,1m,1s,1t,1c", 0, 0 },
    { "/usr/xpg4/bin",  "/usr/share/man,1",     0, 0 },
    { "/usr/xpg6/bin",  "/usr/share/man,1",     0, 0 },
    { NULL,         NULL,               0, 0 }
};

struct man_node {
    char        *path;      /* mandir path */
    char        **secv;     /* submandir suffices */
    int     defsrch;    /* hint for man -p */
    int     frompath;   /* hint for man -d */
    struct man_node *next;
};

static int  all = 0;
static int  apropos = 0;
static int  debug = 0;
static int  found = 0;
static int  list = 0;
static int  makewhatis = 0;
static int  printmp = 0;
static int  sargs = 0;
static int  psoutput = 0;
static int  lintout = 0;
static int  whatis = 0;
static int  makewhatishere = 0;

static char *mansec;
static char *pager = NULL;

static char *addlocale(char *);
static struct man_node *build_manpath(char **, int);
static void do_makewhatis(struct man_node *);
static char *check_config(char *);
static int  cmp(const void *, const void *);
static int  dupcheck(struct man_node *, struct dupnode **);
static int  format(char *, char *, char *, char *);
static void free_dupnode(struct dupnode *);
static void free_manp(struct man_node *manp);
static void freev(char **);
static void fullpaths(struct man_node **);
static void get_all_sect(struct man_node *);
static int  getdirs(char *, char ***, int);
static void getpath(struct man_node *, char **);
static void getsect(struct man_node *, char **);
static void init_bintoman(void);
static void lower(char *);
static void mandir(char **, char *, char *, int);
static int  manual(struct man_node *, char *);
static char *map_section(char *, char *);
static char *path_to_manpath(char *);
static void print_manpath(struct man_node *);
static void search_whatis(char *, char *);
static int  searchdir(char *, char *, char *);
static void sortdir(DIR *, char ***);
static char **split(char *, char);
static void usage_man(void);
static void usage_whatapro(void);
static void usage_catman(void);
static void usage_makewhatis(void);
static void whatapro(struct man_node *, char *);

static char language[MAXPATHLEN];   /* LC_MESSAGES */
static char localedir[MAXPATHLEN];  /* locale specific path component */

static char *newsection = NULL;

static int  manwidth = 0;

extern const char   *__progname;

int
main(int argc, char **argv)
{
    int     c, i;
    char        **pathv;
    char        *manpath = NULL;
    static struct man_node *mandirs = NULL;
    int     bmp_flags = 0;
    int     ret = 0;
    char        *opts;
    char        *mwstr;
    int     catman = 0;

    (void) setlocale(LC_ALL, "");
    (void) strcpy(language, setlocale(LC_MESSAGES, (char *)NULL));
    if (strcmp("C", language) != 0)
        (void) strlcpy(localedir, language, MAXPATHLEN);

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
    (void) textdomain(TEXT_DOMAIN);

    if (strcmp(__progname, "apropos") == 0) {
        apropos++;
        opts = "M:ds:";
    } else if (strcmp(__progname, "whatis") == 0) {
        apropos++;
        whatis++;
        opts = "M:ds:";
    } else if (strcmp(__progname, "catman") == 0) {
        catman++;
        makewhatis++;
        opts = "P:M:w";
    } else if (strcmp(__progname, "makewhatis") == 0) {
        makewhatis++;
        makewhatishere++;
        manpath = ".";
        opts = "";
    } else {
        opts = "FM:P:T:adfklprs:tw";
        if (argc > 1 && strcmp(argv[1], "-") == 0) {
            pager = "cat";
            optind++;
        }
    }

    opterr = 0;
    while ((c = getopt(argc, argv, opts)) != -1) {
        switch (c) {
        case 'M':   /* Respecify path for man pages */
            manpath = optarg;
            break;
        case 'a':
            all++;
            break;
        case 'd':
            debug++;
            break;
        case 'f':
            whatis++;
            /*FALLTHROUGH*/
        case 'k':
            apropos++;
            break;
        case 'l':
            list++;
            all++;
            break;
        case 'p':
            printmp++;
            break;
        case 's':
            mansec = optarg;
            sargs++;
            break;
        case 'r':
            lintout++;
            break;
        case 't':
            psoutput++;
            break;
        case 'T':
        case 'P':
        case 'F':
            /* legacy options, compatibility only and ignored */
            break;
        case 'w':
            makewhatis++;
            break;
        case '?':
        default:
            if (apropos)
                usage_whatapro();
            else if (catman)
                usage_catman();
            else if (makewhatishere)
                usage_makewhatis();
            else
                usage_man();
        }
    }
    argc -= optind;
    argv += optind;

    if (argc == 0) {
        if (apropos) {
            (void) fprintf(stderr, gettext("%s what?\n"),
                __progname);
            exit(1);
        } else if (!printmp && !makewhatis) {
            (void) fprintf(stderr,
                gettext("What manual page do you want?\n"));
            exit(1);
        }
    }

    init_bintoman();
    if (manpath == NULL && (manpath = getenv("MANPATH")) == NULL) {
        if ((manpath = getenv("PATH")) != NULL)
            bmp_flags = BMP_ISPATH | BMP_APPEND_DEFMANDIR;
        else
            manpath = DEFMANDIR;
    }
    pathv = split(manpath, ':');
    mandirs = build_manpath(pathv, bmp_flags);
    freev(pathv);
    fullpaths(&mandirs);

    if (makewhatis) {
        do_makewhatis(mandirs);
        exit(0);
    }

    if (printmp) {
        print_manpath(mandirs);
        exit(0);
    }

    /* Collect environment information */
    if (isatty(STDOUT_FILENO) && (mwstr = getenv("MANWIDTH")) != NULL &&
        *mwstr != '\0') {
        if (strcasecmp(mwstr, "tty") == 0) {
            struct winsize  ws;

            if (ioctl(0, TIOCGWINSZ, &ws) != 0)
                warn("TIOCGWINSZ");
            else
                manwidth = ws.ws_col;
        } else {
            manwidth = (int)strtol(mwstr, (char **)NULL, 10);
            if (manwidth < 0)
                manwidth = 0;
        }
    }
    if (manwidth != 0) {
        DPRINTF("-- Using non-standard page width: %d\n", manwidth);
    }

    if (pager == NULL) {
        if ((pager = getenv("PAGER")) == NULL || *pager == '\0')
            pager = PAGER;
    }
    DPRINTF("-- Using pager: %s\n", pager);

    for (i = 0; i < argc; i++) {
        char        *cmd;
        static struct man_node *mp;
        char        *pv[2];

        /*
         * If full path to command specified, customize
         * the manpath accordingly.
         */
        if ((cmd = strrchr(argv[i], '/')) != NULL) {
            *cmd = '\0';
            if ((pv[0] = strdup(argv[i])) == NULL)
                err(1, "strdup");
            pv[1] = NULL;
            *cmd = '/';
            mp = build_manpath(pv,
                BMP_ISPATH | BMP_FALLBACK_DEFMANDIR);
        } else {
            mp = mandirs;
        }

        if (apropos)
            whatapro(mp, argv[i]);
        else
            ret += manual(mp, argv[i]);

        if (mp != NULL && mp != mandirs) {
            free(pv[0]);
            free_manp(mp);
        }
    }

    return (ret == 0 ? 0 : 1);
}

/*
 * This routine builds the manpage structure from MANPATH or PATH,
 * depending on flags.  See BMP_* definitions above for valid
 * flags.
 */
static struct man_node *
build_manpath(char **pathv, int flags)
{
    struct man_node *manpage = NULL;
    struct man_node *currp = NULL;
    struct man_node *lastp = NULL;
    char        **p;
    char        **q;
    char        *mand = NULL;
    char        *mandir = DEFMANDIR;
    int     s;
    struct dupnode  *didup = NULL;
    struct stat sb;

    s = sizeof (struct man_node);
    for (p = pathv; *p != NULL; ) {
        if (flags & BMP_ISPATH) {
            if ((mand = path_to_manpath(*p)) == NULL)
                goto next;
            free(*p);
            *p = mand;
        }
        q = split(*p, ',');
        if (stat(q[0], &sb) != 0 || (sb.st_mode & S_IFDIR) == 0) {
            freev(q);
            goto next;
        }

        if (access(q[0], R_OK | X_OK) == 0) {
            /*
             * Some element exists.  Do not append DEFMANDIR as a
             * fallback.
             */
            flags &= ~BMP_FALLBACK_DEFMANDIR;

            if ((currp = (struct man_node *)calloc(1, s)) == NULL)
                err(1, "calloc");

            currp->frompath = (flags & BMP_ISPATH);

            if (manpage == NULL)
                lastp = manpage = currp;

            getpath(currp, p);
            getsect(currp, p);

            /*
             * If there are no new elements in this path,
             * do not add it to the manpage list.
             */
            if (dupcheck(currp, &didup) != 0) {
                freev(currp->secv);
                free(currp);
            } else {
                currp->next = NULL;
                if (currp != manpage)
                    lastp->next = currp;
                lastp = currp;
            }
        }
        freev(q);
next:
        /*
         * Special handling of appending DEFMANDIR. After all pathv
         * elements have been processed, append DEFMANDIR if needed.
         */
        if (p == &mandir)
            break;
        p++;
        if (*p != NULL)
            continue;
        if (flags & (BMP_APPEND_DEFMANDIR | BMP_FALLBACK_DEFMANDIR)) {
            p = &mandir;
            flags &= ~BMP_ISPATH;
        }
    }

    free_dupnode(didup);

    return (manpage);
}

/*
 * Store the mandir path into the manp structure.
 */
static void
getpath(struct man_node *manp, char **pv)
{
    char    *s = *pv;
    int i = 0;

    while (*s != '\0' && *s != ',')
        i++, s++;

    if ((manp->path = (char *)malloc(i + 1)) == NULL)
        err(1, "malloc");
    (void) strlcpy(manp->path, *pv, i + 1);
}

/*
 * Store the mandir's corresponding sections (submandir
 * directories) into the manp structure.
 */
static void
getsect(struct man_node *manp, char **pv)
{
    char    *sections;
    char    **sectp;

    /* Just store all sections when doing makewhatis or apropos/whatis */
    if (makewhatis || apropos) {
        manp->defsrch = 1;
        DPRINTF("-- Adding %s\n", manp->path);
        manp->secv = NULL;
        get_all_sect(manp);
    } else if (sargs) {
        DPRINTF("-- Adding %s: sections=%s\n", manp->path, mansec);
        manp->secv = split(mansec, ',');
        for (sectp = manp->secv; *sectp; sectp++)
            lower(*sectp);
    } else if ((sections = strchr(*pv, ',')) != NULL) {
        sections++;
        DPRINTF("-- Adding %s: sections=%s\n", manp->path, sections);
        manp->secv = split(sections, ',');
        for (sectp = manp->secv; *sectp; sectp++)
            lower(*sectp);
        if (*manp->secv == NULL)
            get_all_sect(manp);
    } else if ((sections = check_config(*pv)) != NULL) {
        manp->defsrch = 1;
        DPRINTF("-- Adding %s: sections=%s (from %s)\n", manp->path,
            sections, CONFIG);
        manp->secv = split(sections, ',');
        for (sectp = manp->secv; *sectp; sectp++)
            lower(*sectp);
        if (*manp->secv == NULL)
            get_all_sect(manp);
    } else {
        manp->defsrch = 1;
        DPRINTF("-- Adding %s: default search order\n", manp->path);
        manp->secv = NULL;
        get_all_sect(manp);
    }
}

/*
 * Get suffices of all sub-mandir directories in a mandir.
 */
static void
get_all_sect(struct man_node *manp)
{
    DIR *dp;
    char    **dirv;
    char    **dv;
    char    **p;
    char    *prev = NULL;
    char    *tmp = NULL;
    int maxentries = MAXTOKENS;
    int entries = 0;

    if ((dp = opendir(manp->path)) == 0)
        return;

    sortdir(dp, &dirv);

    (void) closedir(dp);

    if (manp->secv == NULL) {
        if ((manp->secv = malloc(maxentries * sizeof (char *))) == NULL)
            err(1, "malloc");
    }

    for (dv = dirv, p = manp->secv; *dv; dv++) {
        if (strcmp(*dv, CONFIG) == 0) {
            free(*dv);
            continue;
        }

        free(tmp);
        if ((tmp = strdup(*dv + 3)) == NULL)
            err(1, "strdup");

        if (prev != NULL && strcmp(prev, tmp) == 0) {
            free(*dv);
            continue;
        }

        free(prev);
        if ((prev = strdup(*dv + 3)) == NULL)
            err(1, "strdup");

        if ((*p = strdup(*dv + 3)) == NULL)
            err(1, "strdup");

        p++; entries++;

        if (entries == maxentries) {
            maxentries += MAXTOKENS;
            if ((manp->secv = realloc(manp->secv,
                sizeof (char *) * maxentries)) == NULL)
                err(1, "realloc");
            p = manp->secv + entries;
        }
        free(*dv);
    }
    free(tmp);
    free(prev);
    *p = NULL;
    free(dirv);
}

/*
 * Build whatis databases.
 */
static void
do_makewhatis(struct man_node *manp)
{
    struct man_node *p;
    char        *ldir;

    for (p = manp; p != NULL; p = p->next) {
        ldir = addlocale(p->path);
        if (*localedir != '\0' && getdirs(ldir, NULL, 0) > 0)
            mwpath(ldir);
        free(ldir);
        mwpath(p->path);
    }
}

/*
 * Count mandirs under the given manpath
 */
static int
getdirs(char *path, char ***dirv, int flag)
{
    DIR     *dp;
    struct dirent   *d;
    int     n = 0;
    int     maxentries = MAXDIRS;
    char        **dv = NULL;

    if ((dp = opendir(path)) == NULL)
        return (0);

    if (flag) {
        if ((*dirv = malloc(sizeof (char *) *
            maxentries)) == NULL)
            err(1, "malloc");
        dv = *dirv;
    }
    while ((d = readdir(dp))) {
        if (strncmp(d->d_name, "man", 3) != 0)
            continue;
        n++;

        if (flag) {
            if ((*dv = strdup(d->d_name + 3)) == NULL)
                err(1, "strdup");
            dv++;
            if ((dv - *dirv) == maxentries) {
                int entries = maxentries;

                maxentries += MAXTOKENS;
                if ((*dirv = realloc(*dirv,
                    sizeof (char *) * maxentries)) == NULL)
                    err(1, "realloc");
                dv = *dirv + entries;
            }
        }
    }

    (void) closedir(dp);
    return (n);
}


/*
 * Find matching whatis or apropos entries.
 */
static void
whatapro(struct man_node *manp, char *word)
{
    char        whatpath[MAXPATHLEN];
    struct man_node *b;
    char        *ldir;

    for (b = manp; b != NULL; b = b->next) {
        if (*localedir != '\0') {
            ldir = addlocale(b->path);
            if (getdirs(ldir, NULL, 0) != 0) {
                (void) snprintf(whatpath, sizeof (whatpath),
                    "%s/%s", ldir, WHATIS);
                search_whatis(whatpath, word);
            }
            free(ldir);
        }
        (void) snprintf(whatpath, sizeof (whatpath), "%s/%s", b->path,
            WHATIS);
        search_whatis(whatpath, word);
    }
}

static void
search_whatis(char *whatpath, char *word)
{
    FILE        *fp;
    char        *line = NULL;
    size_t      linecap = 0;
    char        *pkwd;
    regex_t     preg;
    char        **ss = NULL;
    char        s[MAXNAMELEN];
    int     i;

    if ((fp = fopen(whatpath, "r")) == NULL) {
        perror(whatpath);
        return;
    }

    DPRINTF("-- Found %s: %s\n", WHATIS, whatpath);

    /* Build keyword regex */
    if (asprintf(&pkwd, "%s%s%s", (whatis) ? "\\<" : "",
        word, (whatis) ? "\\>" : "") == -1)
        err(1, "asprintf");

    if (regcomp(&preg, pkwd, REG_BASIC | REG_ICASE | REG_NOSUB) != 0)
        err(1, "regcomp");

    if (sargs)
        ss = split(mansec, ',');

    while (getline(&line, &linecap, fp) > 0) {
        if (regexec(&preg, line, 0, NULL, 0) == 0) {
            if (sargs) {
                /* Section-restricted search */
                for (i = 0; ss[i] != NULL; i++) {
                    (void) snprintf(s, sizeof (s), "(%s)",
                        ss[i]);
                    if (strstr(line, s) != NULL) {
                        (void) printf("%s", line);
                        break;
                    }
                }
            } else {
                (void) printf("%s", line);
            }
        }
    }

    if (ss != NULL)
        freev(ss);
    free(pkwd);
    (void) fclose(fp);
}


/*
 * Split a string by specified separator.
 */
static char **
split(char *s1, char sep)
{
    char    **tokv, **vp;
    char    *mp = s1, *tp;
    int maxentries = MAXTOKENS;
    int entries = 0;

    if ((tokv = vp = malloc(maxentries * sizeof (char *))) == NULL)
        err(1, "malloc");

    for (; mp && *mp; mp = tp) {
        tp = strchr(mp, sep);
        if (mp == tp) {
            tp++;
            continue;
        }
        if (tp) {
            size_t  len;

            len = tp - mp;
            if ((*vp = (char *)malloc(sizeof (char) *
                len + 1)) == NULL)
                err(1, "malloc");
            (void) strncpy(*vp, mp, len);
            *(*vp + len) = '\0';
            tp++;
            vp++;
        } else {
            if ((*vp = strdup(mp)) == NULL)
                err(1, "strdup");
            vp++;
        }
        entries++;
        if (entries == maxentries) {
            maxentries += MAXTOKENS;
            if ((tokv = realloc(tokv,
                maxentries * sizeof (char *))) == NULL)
                err(1, "realloc");
            vp = tokv + entries;
        }
    }
    *vp = 0;

    return (tokv);
}

/*
 * Free a vector allocated by split()
 */
static void
freev(char **v)
{
    int i;
    if (v != NULL) {
        for (i = 0; v[i] != NULL; i++) {
            free(v[i]);
        }
        free(v);
    }
}

/*
 * Convert paths to full paths if necessary
 */
static void
fullpaths(struct man_node **manp_head)
{
    char        *cwd = NULL;
    char        *p;
    int     cwd_gotten = 0;
    struct man_node *manp = *manp_head;
    struct man_node *b;
    struct man_node *prev = NULL;

    for (b = manp; b != NULL; b = b->next) {
        if (*(b->path) == '/') {
            prev = b;
            continue;
        }

        if (!cwd_gotten) {
            cwd = getcwd(NULL, MAXPATHLEN);
            cwd_gotten = 1;
        }

        if (cwd) {
            /* Relative manpath with cwd: make absolute */
            if (asprintf(&p, "%s/%s", cwd, b->path) == -1)
                err(1, "asprintf");
            free(b->path);
            b->path = p;
        } else {
            /* Relative manpath but no cwd: omit path entry */
            if (prev)
                prev->next = b->next;
            else
                *manp_head = b->next;

            free_manp(b);
        }
    }
    free(cwd);
}

/*
 * Free a man_node structure and its contents
 */
static void
free_manp(struct man_node *manp)
{
    char    **p;

    free(manp->path);
    p = manp->secv;
    while ((p != NULL) && (*p != NULL)) {
        free(*p);
        p++;
    }
    free(manp->secv);
    free(manp);
}


/*
 * Map (in place) to lower case.
 */
static void
lower(char *s)
{

    if (s == 0)
        return;
    while (*s) {
        if (isupper(*s))
            *s = tolower(*s);
        s++;
    }
}


/*
 * Compare function for qsort().
 * Sort first by section, then by prefix.
 */
static int
cmp(const void *arg1, const void *arg2)
{
    int n;
    char    **p1 = (char **)arg1;
    char    **p2 = (char **)arg2;

    /* By section */
    if ((n = strcmp(*p1 + 3, *p2 + 3)) != 0)
        return (n);

    /* By prefix reversed */
    return (strncmp(*p2, *p1, 3));
}


/*
 * Find a manpage.
 */
static int
manual(struct man_node *manp, char *name)
{
    struct man_node *p;
    struct man_node *local;
    int     ndirs = 0;
    char        *ldir;
    char        *ldirs[2];
    char        *fullname = name;
    char        *slash;

    if ((slash = strrchr(name, '/')) != NULL)
        name = slash + 1;

    /* For each path in MANPATH */
    found = 0;

    for (p = manp; p != NULL; p = p->next) {
        DPRINTF("-- Searching mandir: %s\n", p->path);

        if (*localedir != '\0') {
            ldir = addlocale(p->path);
            ndirs = getdirs(ldir, NULL, 0);
            if (ndirs != 0) {
                ldirs[0] = ldir;
                ldirs[1] = NULL;
                local = build_manpath(ldirs, 0);
                DPRINTF("-- Locale specific subdir: %s\n",
                    ldir);
                mandir(local->secv, ldir, name, 1);
                free_manp(local);
            }
            free(ldir);
        }

        /*
         * Locale mandir not valid, man page in locale
         * mandir not found, or -a option present
         */
        if (ndirs == 0 || !found || all)
            mandir(p->secv, p->path, name, 0);

        if (found && !all)
            break;
    }

    if (!found) {
        if (sargs) {
            (void) fprintf(stderr, gettext(
                "No manual entry for %s in section(s) %s\n"),
                fullname, mansec);
        } else {
            (void) fprintf(stderr,
                gettext("No manual entry for %s\n"), fullname);
        }

    }

    return (!found);
}


/*
 * For a specified manual directory, read, store and sort section subdirs.
 * For each section specified, find and search matching subdirs.
 */
static void
mandir(char **secv, char *path, char *name, int lspec)
{
    DIR *dp;
    char    **dirv;
    char    **dv, **pdv;
    int len, dslen;

    if ((dp = opendir(path)) == NULL)
        return;

    if (lspec)
        DPRINTF("-- Searching mandir: %s\n", path);

    sortdir(dp, &dirv);

    /* Search in the order specified by MANSECTS */
    for (; *secv; secv++) {
        len = strlen(*secv);
        for (dv = dirv; *dv; dv++) {
            dslen = strlen(*dv + 3);
            if (dslen > len)
                len = dslen;
            if (**secv == '\\') {
                if (strcmp(*secv + 1, *dv + 3) != 0)
                    continue;
            } else if (strncasecmp(*secv, *dv + 3, len) != 0) {
                if (!all &&
                    (newsection = map_section(*secv, path))
                    == NULL) {
                    continue;
                }
                if (newsection == NULL)
                    newsection = "";
                if (strncmp(newsection, *dv + 3, len) != 0) {
                    continue;
                }
            }

            if (searchdir(path, *dv, name) == 0)
                continue;

            if (!all) {
                pdv = dirv;
                while (*pdv) {
                    free(*pdv);
                    pdv++;
                }
                (void) closedir(dp);
                free(dirv);
                return;
            }

            if (all && **dv == 'm' && *(dv + 1) &&
                strcmp(*(dv + 1) + 3, *dv + 3) == 0)
                    dv++;
        }
    }
    pdv = dirv;
    while (*pdv != NULL) {
        free(*pdv);
        pdv++;
    }
    free(dirv);
    (void) closedir(dp);
}

/*
 * Sort directories.
 */
static void
sortdir(DIR *dp, char ***dirv)
{
    struct dirent   *d;
    char        **dv;
    int     maxentries = MAXDIRS;
    int     entries = 0;

    if ((dv = *dirv = malloc(sizeof (char *) *
        maxentries)) == NULL)
        err(1, "malloc");
    dv = *dirv;

    while ((d = readdir(dp))) {
        if (strcmp(d->d_name, ".") == 0 ||
            strcmp(d->d_name, "..") == 0)
            continue;

        if (strncmp(d->d_name, "man", 3) == 0 ||
            strncmp(d->d_name, "cat", 3) == 0) {
            if ((*dv = strdup(d->d_name)) == NULL)
                err(1, "strdup");
            dv++;
            entries++;
            if (entries == maxentries) {
                maxentries += MAXDIRS;
                if ((*dirv = realloc(*dirv,
                    sizeof (char *) * maxentries)) == NULL)
                    err(1, "realloc");
                dv = *dirv + entries;
            }
        }
    }
    *dv = 0;

    qsort((void *)*dirv, dv - *dirv, sizeof (char *), cmp);

}


/*
 * Search a section subdir for a given manpage.
 */
static int
searchdir(char *path, char *dir, char *name)
{
    DIR     *sdp;
    struct dirent   *sd;
    char        sectpath[MAXPATHLEN];
    char        file[MAXNAMLEN];
    char        dname[MAXPATHLEN];
    char        *last;
    int     nlen;

    (void) snprintf(sectpath, sizeof (sectpath), "%s/%s", path, dir);
    (void) snprintf(file, sizeof (file), "%s.", name);

    if ((sdp = opendir(sectpath)) == NULL)
        return (0);

    while ((sd = readdir(sdp))) {
        char    *pname;

        if ((pname = strdup(sd->d_name)) == NULL)
            err(1, "strdup");
        if ((last = strrchr(pname, '.')) != NULL &&
            (strcmp(last, ".gz") == 0 || strcmp(last, ".bz2") == 0))
            *last = '\0';
        last = strrchr(pname, '.');
        nlen = last - pname;
        (void) snprintf(dname, sizeof (dname), "%.*s.", nlen, pname);
        if (strcmp(dname, file) == 0 ||
            strcmp(pname, name) == 0) {
            (void) format(path, dir, name, sd->d_name);
            (void) closedir(sdp);
            free(pname);
            return (1);
        }
        free(pname);
    }
    (void) closedir(sdp);

    return (0);
}

/*
 * Check the hash table of old directory names to see if there is a
 * new directory name.
 */
static char *
map_section(char *section, char *path)
{
    int i;
    char    fullpath[MAXPATHLEN];

    if (list)  /* -l option fall through */
        return (NULL);

    for (i = 0; map[i].new_name != NULL; i++) {
        if (strcmp(section, map[i].old_name) == 0) {
            (void) snprintf(fullpath, sizeof (fullpath),
                "%s/man%s", path, map[i].new_name);
            if (!access(fullpath, R_OK | X_OK)) {
                return (map[i].new_name);
            } else {
                return (NULL);
            }
        }
    }

    return (NULL);
}

/*
 * Format the manpage.
 */
static int
format(char *path, char *dir, char *name, char *pg)
{
    char        manpname[MAXPATHLEN], catpname[MAXPATHLEN];
    char        cmdbuf[BUFSIZ], tmpbuf[BUFSIZ];
    char        *cattool;
    struct stat sbman, sbcat;

    found++;

    if (list) {
        (void) printf(gettext("%s(%s)\t-M %s\n"), name, dir + 3, path);
        return (-1);
    }

    (void) snprintf(manpname, sizeof (manpname), "%s/man%s/%s", path,
        dir + 3, pg);
    (void) snprintf(catpname, sizeof (catpname), "%s/cat%s/%s", path,
        dir + 3, pg);

    /* Can't do PS output if manpage doesn't exist */
    if (stat(manpname, &sbman) != 0 && (psoutput|lintout))
        return (-1);

    /*
     * If both manpage and catpage do not exist, manpname is
     * broken symlink, most likely.
     */
    if (stat(catpname, &sbcat) != 0 && stat(manpname, &sbman) != 0)
        err(1, "%s", manpname);

    /* Setup cattool */
    if (fnmatch("*.gz", manpname, 0) == 0)
        cattool = "gzcat";
    else if (fnmatch("*.bz2", manpname, 0) == 0)
        cattool = "bzcat";
    else
        cattool = "cat";

    if (psoutput) {
        (void) snprintf(cmdbuf, BUFSIZ,
            "cd %s; %s %s | mandoc -Tps | lp -Tpostscript",
            path, cattool, manpname);
        DPRINTF("-- Using manpage: %s\n", manpname);
        goto cmd;
    } else if (lintout) {
        (void) snprintf(cmdbuf, BUFSIZ,
            "cd %s; %s %s | mandoc -Tlint",
            path, cattool, manpname);
        DPRINTF("-- Linting manpage: %s\n", manpname);
        goto cmd;
    }

    /*
     * Output catpage if:
     * - manpage doesn't exist
     * - output width is standard and catpage is recent enough
     */
    if (stat(manpname, &sbman) != 0 || (manwidth == 0 &&
        stat(catpname, &sbcat) == 0 && sbcat.st_mtime >= sbman.st_mtime)) {
        DPRINTF("-- Using catpage: %s\n", catpname);
        (void) snprintf(cmdbuf, BUFSIZ, "%s %s", pager, catpname);
        goto cmd;
    }

    DPRINTF("-- Using manpage: %s\n", manpname);
    if (manwidth > 0)
        (void) snprintf(tmpbuf, BUFSIZ, "-Owidth=%d ", manwidth);
    (void) snprintf(cmdbuf, BUFSIZ, "cd %s; %s %s | mandoc %s| %s",
        path, cattool, manpname, (manwidth > 0) ? tmpbuf : "", pager);

cmd:
    DPRINTF("-- Command: %s\n", cmdbuf);

    if (!debug)
        return (system(cmdbuf) == 0);
    else
        return (0);
}

/*
 * Add <localedir> to the path.
 */
static char *
addlocale(char *path)
{
    char    *tmp;

    if (asprintf(&tmp, "%s/%s", path, localedir) == -1)
        err(1, "asprintf");

    return (tmp);
}

/*
 * Get the order of sections from man.cf.
 */
static char *
check_config(char *path)
{
    FILE        *fp;
    char        *rc = NULL;
    char        *sect = NULL;
    char        fname[MAXPATHLEN];
    char        *line = NULL;
    char        *nl;
    size_t      linecap = 0;

    (void) snprintf(fname, MAXPATHLEN, "%s/%s", path, CONFIG);

    if ((fp = fopen(fname, "r")) == NULL)
        return (NULL);

    while (getline(&line, &linecap, fp) > 0) {
        if ((rc = strstr(line, "MANSECTS=")) != NULL)
            break;
    }

    (void) fclose(fp);

    if (rc != NULL) {
        if ((nl = strchr(rc, '\n')) != NULL)
            *nl = '\0';
        sect = strchr(rc, '=') + 1;
    }

    return (sect);
}

/*
 * Initialize the bintoman array with appropriate device and inode info.
 */
static void
init_bintoman(void)
{
    int i;
    struct stat sb;

    for (i = 0; bintoman[i].bindir != NULL; i++) {
        if (stat(bintoman[i].bindir, &sb) == 0) {
            bintoman[i].dev = sb.st_dev;
            bintoman[i].ino = sb.st_ino;
        } else {
            bintoman[i].dev = NODEV;
        }
    }
}

/*
 * If a duplicate is found, return 1.
 * If a duplicate is not found, add it to the dupnode list and return 0.
 */
static int
dupcheck(struct man_node *mnp, struct dupnode **dnp)
{
    struct dupnode  *curdnp;
    struct secnode  *cursnp;
    struct stat     sb;
    int         i;
    int     rv = 1;
    int     dupfound;

    /* If the path doesn't exist, treat it as a duplicate */
    if (stat(mnp->path, &sb) != 0)
        return (1);

    /* If no sections were found in the man dir, treat it as duplicate */
    if (mnp->secv == NULL)
        return (1);

    /*
     * Find the dupnode structure for the previous time this directory
     * was looked at.  Device and inode numbers are compared so that
     * directories that are reached via different paths (e.g. /usr/man and
     * /usr/share/man) are treated as equivalent.
     */
    for (curdnp = *dnp; curdnp != NULL; curdnp = curdnp->next) {
        if (curdnp->dev == sb.st_dev && curdnp->ino == sb.st_ino)
            break;
    }

    /*
     * First time this directory has been seen. Add a new node to the
     * head of the list. Since all entries are guaranteed to be unique
     * copy all sections to new node.
     */
    if (curdnp == NULL) {
        if ((curdnp = calloc(1, sizeof (struct dupnode))) == NULL)
            err(1, "calloc");
        for (i = 0; mnp->secv[i] != NULL; i++) {
            if ((cursnp = calloc(1, sizeof (struct secnode)))
                == NULL)
                err(1, "calloc");
            cursnp->next = curdnp->secl;
            curdnp->secl = cursnp;
            if ((cursnp->secp = strdup(mnp->secv[i])) == NULL)
                err(1, "strdup");
        }
        curdnp->dev = sb.st_dev;
        curdnp->ino = sb.st_ino;
        curdnp->next = *dnp;
        *dnp = curdnp;
        return (0);
    }

    /*
     * Traverse the section vector in the man_node and the section list
     * in dupnode cache to eliminate all duplicates from man_node.
     */
    for (i = 0; mnp->secv[i] != NULL; i++) {
        dupfound = 0;
        for (cursnp = curdnp->secl; cursnp != NULL;
            cursnp = cursnp->next) {
            if (strcmp(mnp->secv[i], cursnp->secp) == 0) {
                dupfound = 1;
                break;
            }
        }
        if (dupfound) {
            mnp->secv[i][0] = '\0';
            continue;
        }


        /*
         * Update curdnp and set return value to indicate that this
         * was not all duplicates.
         */
        if ((cursnp = calloc(1, sizeof (struct secnode))) == NULL)
            err(1, "calloc");
        cursnp->next = curdnp->secl;
        curdnp->secl = cursnp;
        if ((cursnp->secp = strdup(mnp->secv[i])) == NULL)
            err(1, "strdup");
        rv = 0;
    }

    return (rv);
}

/*
 * Given a bindir, return corresponding mandir.
 */
static char *
path_to_manpath(char *bindir)
{
    char        *mand, *p;
    int     i;
    struct stat sb;

    /* First look for known translations for specific bin paths */
    if (stat(bindir, &sb) != 0) {
        return (NULL);
    }
    for (i = 0; bintoman[i].bindir != NULL; i++) {
        if (sb.st_dev == bintoman[i].dev &&
            sb.st_ino == bintoman[i].ino) {
            if ((mand = strdup(bintoman[i].mandir)) == NULL)
                err(1, "strdup");
            if ((p = strchr(mand, ',')) != NULL)
                *p = '\0';
            if (stat(mand, &sb) != 0) {
                free(mand);
                return (NULL);
            }
            if (p != NULL)
                *p = ',';
            return (mand);
        }
    }

    /*
     * No specific translation found.  Try `dirname $bindir`/share/man
     * and `dirname $bindir`/man
     */
    if ((mand = malloc(MAXPATHLEN)) == NULL)
        err(1, "malloc");
    if (strlcpy(mand, bindir, MAXPATHLEN) >= MAXPATHLEN) {
        free(mand);
        return (NULL);
    }

    /*
     * Advance to end of buffer, strip trailing /'s then remove last
     * directory component.
     */
    for (p = mand; *p != '\0'; p++)
        ;
    for (; p > mand && *p == '/'; p--)
        ;
    for (; p > mand && *p != '/'; p--)
        ;
    if (p == mand && *p == '.') {
        if (realpath("..", mand) == NULL) {
            free(mand);
            return (NULL);
        }
        for (; *p != '\0'; p++)
            ;
    } else {
        *p = '\0';
    }

    if (strlcat(mand, "/share/man", MAXPATHLEN) >= MAXPATHLEN) {
        free(mand);
        return (NULL);
    }

    if ((stat(mand, &sb) == 0) && S_ISDIR(sb.st_mode)) {
        return (mand);
    }

    /*
     * Strip the /share/man off and try /man
     */
    *p = '\0';
    if (strlcat(mand, "/man", MAXPATHLEN) >= MAXPATHLEN) {
        free(mand);
        return (NULL);
    }
    if ((stat(mand, &sb) == 0) && S_ISDIR(sb.st_mode)) {
        return (mand);
    }

    /*
     * No man or share/man directory found
     */
    free(mand);
    return (NULL);
}

/*
 * Free a linked list of dupnode structs.
 */
void
free_dupnode(struct dupnode *dnp)
{
    struct dupnode *dnp2;
    struct secnode *snp;

    while (dnp != NULL) {
        dnp2 = dnp;
        dnp = dnp->next;
        while (dnp2->secl != NULL) {
            snp = dnp2->secl;
            dnp2->secl = dnp2->secl->next;
            free(snp->secp);
            free(snp);
        }
        free(dnp2);
    }
}

/*
 * Print manp linked list to stdout.
 */
void
print_manpath(struct man_node *manp)
{
    char    colon[2] = "\0\0";
    char    **secp;

    for (; manp != NULL; manp = manp->next) {
        (void) printf("%s%s", colon, manp->path);
        colon[0] = ':';

        /*
         * If man.cf or a directory scan was used to create section
         * list, do not print section list again.  If the output of
         * man -p is used to set MANPATH, subsequent runs of man
         * will re-read man.cf and/or scan man directories as
         * required.
         */
        if (manp->defsrch != 0)
            continue;

        for (secp = manp->secv; *secp != NULL; secp++) {
            /*
             * Section deduplication may have eliminated some
             * sections from the vector. Avoid displaying this
             * detail which would appear as ",," in output
             */
            if ((*secp)[0] != '\0')
                (void) printf(",%s", *secp);
        }
    }
    (void) printf("\n");
}

static void
usage_man(void)
{

    (void) fprintf(stderr, gettext(
"usage: man [-alptw] [-M path] [-s section] name ...\n"
"       man [-M path] [-s section] -k keyword ...\n"
"       man [-M path] [-s section] -f keyword ...\n"));

    exit(1);
}

static void
usage_whatapro(void)
{

    (void) fprintf(stderr, gettext(
"usage: %s [-M path] [-s section] keyword ...\n"),
        whatis ? "whatis" : "apropos");

    exit(1);
}

static void
usage_catman(void)
{
    (void) fprintf(stderr, gettext(
"usage: catman [-M path] [-w]\n"));

    exit(1);
}

static void
usage_makewhatis(void)
{
    (void) fprintf(stderr, gettext("usage: makewhatis\n"));

    exit(1);
}