mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.234 and 1.264

version 1.234, 2016/10/22 10:09:27

version 1.264, 2020/01/25 22:59:22

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

Line 19

#include "config.h"

#include <sys/types.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include <assert.h>

#include <ctype.h>

Line 52

#include "roff.h"

#include "mdoc.h"

#include "man.h"

#include "mandoc_parse.h"

#include "manconf.h"

#include "mansearch.h"

#include "dba_array.h"

Line 110 typedef int (*mdoc_fp)(struct mpage *, const struct ro

Line 111 typedef int (*mdoc_fp)(struct mpage *, const struct ro

struct mdoc_handler {

mdoc_fp fp; /* optional handler */

uint64_t mask; /* set unless handler returns 0 */

int taboo; /* node flags that must not be set */

};

Line 138 static void parse_mdoc(struct mpage *, const struct r

Line 140 static void parse_mdoc(struct mpage *, const struct r

const struct roff_node *);

static int parse_mdoc_head(struct mpage *, const struct roff_meta *,

const struct roff_node *);

static int parse_mdoc_Fa(struct mpage *, const struct roff_meta *,

const struct roff_node *);

static int parse_mdoc_Fd(struct mpage *, const struct roff_meta *,

const struct roff_node *);

static void parse_mdoc_fname(struct mpage *, const struct roff_node *);

Line 158 static int parse_mdoc_Xr(struct mpage *, const struct

Line 162 static int parse_mdoc_Xr(struct mpage *, const struct

static void putkey(const struct mpage *, char *, uint64_t);

static void putkeys(const struct mpage *, char *, size_t, uint64_t);

static void putmdockey(const struct mpage *,

const struct roff_node *, uint64_t);

const struct roff_node *, uint64_t, int);

static int render_string(char **, size_t *);

static void say(const char *, const char *, ...)

__attribute__((__format__ (printf, 2, 3)));

__attribute__((__format__ (__printf__, 2, 3)));

static int set_basedir(const char *, int);

static int treescan(void);

static size_t utf8(unsigned int, char [7]);

Line 175 static int write_utf8; /* write UTF-8 output; else A

Line 179 static int write_utf8; /* write UTF-8 output; else A

static int exitcode; /* to be returned by main */

static enum op op; /* operational mode */

static char basedir[PATH_MAX]; /* current base directory */

static size_t basedir_len; /* strlen(basedir) */

static struct mpage *mpage_head; /* list of distinct manual pages */

static struct ohash mpages; /* table of distinct manual pages */

static struct ohash mlinks; /* table of directory entries */

Line 182 static struct ohash names; /* table of all names */

Line 187 static struct ohash names; /* table of all names */

static struct ohash strings; /* table of all strings */

static uint64_t name_mask;

static const struct mdoc_handler mdocs[MDOC_MAX] = {

static const struct mdoc_handler mdoc_handlers[MDOC_MAX - MDOC_Dd] = {

{ NULL, 0 }, /* Ap */

{ NULL, 0, NODE_NOPRT }, /* Dd */

{ NULL, 0 }, /* Dd */

{ NULL, 0, NODE_NOPRT }, /* Dt */

{ NULL, 0 }, /* Dt */

{ NULL, 0, NODE_NOPRT }, /* Os */

{ NULL, 0 }, /* Os */

{ parse_mdoc_Sh, TYPE_Sh, 0 }, /* Sh */

{ parse_mdoc_Sh, TYPE_Sh }, /* Sh */

{ parse_mdoc_head, TYPE_Ss, 0 }, /* Ss */

{ parse_mdoc_head, TYPE_Ss }, /* Ss */

{ NULL, 0, 0 }, /* Pp */

{ NULL, 0 }, /* Pp */

{ NULL, 0, 0 }, /* D1 */

{ NULL, 0 }, /* D1 */

{ NULL, 0, 0 }, /* Dl */

{ NULL, 0 }, /* Dl */

{ NULL, 0, 0 }, /* Bd */

{ NULL, 0 }, /* Bd */

{ NULL, 0, 0 }, /* Ed */

{ NULL, 0 }, /* Ed */

{ NULL, 0, 0 }, /* Bl */

{ NULL, 0 }, /* Bl */

{ NULL, 0, 0 }, /* El */

{ NULL, 0 }, /* El */

{ NULL, 0, 0 }, /* It */

{ NULL, 0 }, /* It */

{ NULL, 0, 0 }, /* Ad */

{ NULL, 0 }, /* Ad */

{ NULL, TYPE_An, 0 }, /* An */

{ NULL, TYPE_An }, /* An */

{ NULL, 0, 0 }, /* Ap */

{ NULL, TYPE_Ar }, /* Ar */

{ NULL, TYPE_Ar, 0 }, /* Ar */

{ NULL, TYPE_Cd }, /* Cd */

{ NULL, TYPE_Cd, 0 }, /* Cd */

{ NULL, TYPE_Cm }, /* Cm */

{ NULL, TYPE_Cm, 0 }, /* Cm */

{ NULL, TYPE_Dv }, /* Dv */

{ NULL, TYPE_Dv, 0 }, /* Dv */

{ NULL, TYPE_Er }, /* Er */

{ NULL, TYPE_Er, 0 }, /* Er */

{ NULL, TYPE_Ev }, /* Ev */

{ NULL, TYPE_Ev, 0 }, /* Ev */

{ NULL, 0 }, /* Ex */

{ NULL, 0, 0 }, /* Ex */

{ NULL, TYPE_Fa }, /* Fa */

{ parse_mdoc_Fa, 0, 0 }, /* Fa */

{ parse_mdoc_Fd, 0 }, /* Fd */

{ parse_mdoc_Fd, 0, 0 }, /* Fd */

{ NULL, TYPE_Fl }, /* Fl */

{ NULL, TYPE_Fl, 0 }, /* Fl */

{ parse_mdoc_Fn, 0 }, /* Fn */

{ parse_mdoc_Fn, 0, 0 }, /* Fn */

{ NULL, TYPE_Ft }, /* Ft */

{ NULL, TYPE_Ft | TYPE_Vt, 0 }, /* Ft */

{ NULL, TYPE_Ic }, /* Ic */

{ NULL, TYPE_Ic, 0 }, /* Ic */

{ NULL, TYPE_In }, /* In */

{ NULL, TYPE_In, 0 }, /* In */

{ NULL, TYPE_Li }, /* Li */

{ NULL, TYPE_Li, 0 }, /* Li */

{ parse_mdoc_Nd, 0 }, /* Nd */

{ parse_mdoc_Nd, 0, 0 }, /* Nd */

{ parse_mdoc_Nm, 0 }, /* Nm */

{ parse_mdoc_Nm, 0, 0 }, /* Nm */

{ NULL, 0 }, /* Op */

{ NULL, 0, 0 }, /* Op */

{ NULL, 0 }, /* Ot */

{ NULL, 0, 0 }, /* Ot */

{ NULL, TYPE_Pa }, /* Pa */

{ NULL, TYPE_Pa, NODE_NOSRC }, /* Pa */

{ NULL, 0 }, /* Rv */

{ NULL, 0, 0 }, /* Rv */

{ NULL, TYPE_St }, /* St */

{ NULL, TYPE_St, 0 }, /* St */

{ parse_mdoc_Va, TYPE_Va }, /* Va */

{ parse_mdoc_Va, TYPE_Va, 0 }, /* Va */

{ parse_mdoc_Va, TYPE_Vt }, /* Vt */

{ parse_mdoc_Va, TYPE_Vt, 0 }, /* Vt */

{ parse_mdoc_Xr, 0 }, /* Xr */

{ parse_mdoc_Xr, 0, 0 }, /* Xr */

{ NULL, 0 }, /* %A */

{ NULL, 0, 0 }, /* %A */

{ NULL, 0 }, /* %B */

{ NULL, 0, 0 }, /* %B */

{ NULL, 0 }, /* %D */

{ NULL, 0, 0 }, /* %D */

{ NULL, 0 }, /* %I */

{ NULL, 0, 0 }, /* %I */

{ NULL, 0 }, /* %J */

{ NULL, 0, 0 }, /* %J */

{ NULL, 0 }, /* %N */

{ NULL, 0, 0 }, /* %N */

{ NULL, 0 }, /* %O */

{ NULL, 0, 0 }, /* %O */

{ NULL, 0 }, /* %P */

{ NULL, 0, 0 }, /* %P */

{ NULL, 0 }, /* %R */

{ NULL, 0, 0 }, /* %R */

{ NULL, 0 }, /* %T */

{ NULL, 0, 0 }, /* %T */

{ NULL, 0 }, /* %V */

{ NULL, 0, 0 }, /* %V */

{ NULL, 0 }, /* Ac */

{ NULL, 0, 0 }, /* Ac */

{ NULL, 0 }, /* Ao */

{ NULL, 0, 0 }, /* Ao */

{ NULL, 0 }, /* Aq */

{ NULL, 0, 0 }, /* Aq */

{ NULL, TYPE_At }, /* At */

{ NULL, TYPE_At, 0 }, /* At */

{ NULL, 0 }, /* Bc */

{ NULL, 0, 0 }, /* Bc */

{ NULL, 0 }, /* Bf */

{ NULL, 0, 0 }, /* Bf */

{ NULL, 0 }, /* Bo */

{ NULL, 0, 0 }, /* Bo */

{ NULL, 0 }, /* Bq */

{ NULL, 0, 0 }, /* Bq */

{ NULL, TYPE_Bsx }, /* Bsx */

{ NULL, TYPE_Bsx, NODE_NOSRC }, /* Bsx */

{ NULL, TYPE_Bx }, /* Bx */

{ NULL, TYPE_Bx, NODE_NOSRC }, /* Bx */

{ NULL, 0 }, /* Db */

{ NULL, 0, 0 }, /* Db */

{ NULL, 0 }, /* Dc */

{ NULL, 0, 0 }, /* Dc */

{ NULL, 0 }, /* Do */

{ NULL, 0, 0 }, /* Do */

{ NULL, 0 }, /* Dq */

{ NULL, 0, 0 }, /* Dq */

{ NULL, 0 }, /* Ec */

{ NULL, 0, 0 }, /* Ec */

{ NULL, 0 }, /* Ef */

{ NULL, 0, 0 }, /* Ef */

{ NULL, TYPE_Em }, /* Em */

{ NULL, TYPE_Em, 0 }, /* Em */

{ NULL, 0 }, /* Eo */

{ NULL, 0, 0 }, /* Eo */

{ NULL, TYPE_Fx }, /* Fx */

{ NULL, TYPE_Fx, NODE_NOSRC }, /* Fx */

{ NULL, TYPE_Ms }, /* Ms */

{ NULL, TYPE_Ms, 0 }, /* Ms */

{ NULL, 0 }, /* No */

{ NULL, 0, 0 }, /* No */

{ NULL, 0 }, /* Ns */

{ NULL, 0, 0 }, /* Ns */

{ NULL, TYPE_Nx }, /* Nx */

{ NULL, TYPE_Nx, NODE_NOSRC }, /* Nx */

{ NULL, TYPE_Ox }, /* Ox */

{ NULL, TYPE_Ox, NODE_NOSRC }, /* Ox */

{ NULL, 0 }, /* Pc */

{ NULL, 0, 0 }, /* Pc */

{ NULL, 0 }, /* Pf */

{ NULL, 0, 0 }, /* Pf */

{ NULL, 0 }, /* Po */

{ NULL, 0, 0 }, /* Po */

{ NULL, 0 }, /* Pq */

{ NULL, 0, 0 }, /* Pq */

{ NULL, 0 }, /* Qc */

{ NULL, 0, 0 }, /* Qc */

{ NULL, 0 }, /* Ql */

{ NULL, 0, 0 }, /* Ql */

{ NULL, 0 }, /* Qo */

{ NULL, 0, 0 }, /* Qo */

{ NULL, 0 }, /* Qq */

{ NULL, 0, 0 }, /* Qq */

{ NULL, 0 }, /* Re */

{ NULL, 0, 0 }, /* Re */

{ NULL, 0 }, /* Rs */

{ NULL, 0, 0 }, /* Rs */

{ NULL, 0 }, /* Sc */

{ NULL, 0, 0 }, /* Sc */

{ NULL, 0 }, /* So */

{ NULL, 0, 0 }, /* So */

{ NULL, 0 }, /* Sq */

{ NULL, 0, 0 }, /* Sq */

{ NULL, 0 }, /* Sm */

{ NULL, 0, 0 }, /* Sm */

{ NULL, 0 }, /* Sx */

{ NULL, 0, 0 }, /* Sx */

{ NULL, TYPE_Sy }, /* Sy */

{ NULL, TYPE_Sy, 0 }, /* Sy */

{ NULL, TYPE_Tn }, /* Tn */

{ NULL, TYPE_Tn, 0 }, /* Tn */

{ NULL, 0 }, /* Ux */

{ NULL, 0, NODE_NOSRC }, /* Ux */

{ NULL, 0 }, /* Xc */

{ NULL, 0, 0 }, /* Xc */

{ NULL, 0 }, /* Xo */

{ NULL, 0, 0 }, /* Xo */

{ parse_mdoc_Fo, 0 }, /* Fo */

{ parse_mdoc_Fo, 0, 0 }, /* Fo */

{ NULL, 0 }, /* Fc */

{ NULL, 0, 0 }, /* Fc */

{ NULL, 0 }, /* Oo */

{ NULL, 0, 0 }, /* Oo */

{ NULL, 0 }, /* Oc */

{ NULL, 0, 0 }, /* Oc */

{ NULL, 0 }, /* Bk */

{ NULL, 0, 0 }, /* Bk */

{ NULL, 0 }, /* Ek */

{ NULL, 0, 0 }, /* Ek */

{ NULL, 0 }, /* Bt */

{ NULL, 0, 0 }, /* Bt */

{ NULL, 0 }, /* Hf */

{ NULL, 0, 0 }, /* Hf */

{ NULL, 0 }, /* Fr */

{ NULL, 0, 0 }, /* Fr */

{ NULL, 0 }, /* Ud */

{ NULL, 0, 0 }, /* Ud */

{ NULL, TYPE_Lb }, /* Lb */

{ NULL, TYPE_Lb, NODE_NOSRC }, /* Lb */

{ NULL, 0 }, /* Lp */

{ NULL, 0, 0 }, /* Lp */

{ NULL, TYPE_Lk }, /* Lk */

{ NULL, TYPE_Lk, 0 }, /* Lk */

{ NULL, TYPE_Mt }, /* Mt */

{ NULL, TYPE_Mt, NODE_NOSRC }, /* Mt */

{ NULL, 0 }, /* Brq */

{ NULL, 0, 0 }, /* Brq */

{ NULL, 0 }, /* Bro */

{ NULL, 0, 0 }, /* Bro */

{ NULL, 0 }, /* Brc */

{ NULL, 0, 0 }, /* Brc */

{ NULL, 0 }, /* %C */

{ NULL, 0, 0 }, /* %C */

{ NULL, 0 }, /* Es */

{ NULL, 0, 0 }, /* Es */

{ NULL, 0 }, /* En */

{ NULL, 0, 0 }, /* En */

{ NULL, TYPE_Dx }, /* Dx */

{ NULL, TYPE_Dx, NODE_NOSRC }, /* Dx */

{ NULL, 0 }, /* %Q */

{ NULL, 0, 0 }, /* %Q */

{ NULL, 0 }, /* br */

{ NULL, 0, 0 }, /* %U */

{ NULL, 0 }, /* sp */

{ NULL, 0, 0 }, /* Ta */

{ NULL, 0 }, /* %U */

{ NULL, 0 }, /* Ta */

{ NULL, 0 }, /* ll */

};

Line 320 mandocdb(int argc, char *argv[])

Line 322 mandocdb(int argc, char *argv[])

int ch, i;

#if HAVE_PLEDGE

if (pledge("stdio rpath wpath cpath fattr flock proc exec", NULL) == -1) {

if (pledge("stdio rpath wpath cpath", NULL) == -1) {

warn("pledge");

return (int)MANDOCLEVEL_SYSERR;

}

Line 341 mandocdb(int argc, char *argv[])

Line 343 mandocdb(int argc, char *argv[])

* clobber each other.

#define CHECKOP(_op, _ch) do \

if (OP_DEFAULT != (_op)) { \

if ((_op) != OP_DEFAULT) { \

warnx("-%c: Conflicting option", (_ch)); \

goto usage; \

} while (/*CONSTCOND*/0)

mparse_options = MPARSE_VALIDATE;

path_arg = NULL;

op = OP_DEFAULT;

while (-1 != (ch = getopt(argc, argv, "aC:Dd:npQT:tu:v")))

while ((ch = getopt(argc, argv, "aC:Dd:npQT:tu:v")) != -1)

switch (ch) {

case 'a':

use_all = 1;

Line 377 mandocdb(int argc, char *argv[])

Line 380 mandocdb(int argc, char *argv[])

mparse_options |= MPARSE_QUICK;

break;

case 'T':

if (strcmp(optarg, "utf8")) {

if (strcmp(optarg, "utf8") != 0) {

warnx("-T%s: Unsupported output format",

optarg);

goto usage;

Line 414 mandocdb(int argc, char *argv[])

Line 417 mandocdb(int argc, char *argv[])

}

#endif

if (OP_CONFFILE == op && argc > 0) {

if (op == OP_CONFFILE && argc > 0) {

warnx("-C: Too many arguments");

goto usage;

}

exitcode = (int)MANDOCLEVEL_OK;

mchars_alloc();

mp = mparse_alloc(mparse_options, MANDOCLEVEL_BADARG, NULL, NULL);

mp = mparse_alloc(mparse_options, MANDOC_OS_OTHER, NULL);

mandoc_ohash_init(&mpages, 6, offsetof(struct mpage, inodev));

mandoc_ohash_init(&mlinks, 6, offsetof(struct mlink, file));

if (OP_UPDATE == op || OP_DELETE == op || OP_TEST == op) {

if (op == OP_UPDATE || op == OP_DELETE || op == OP_TEST) {

* Most of these deal with a specific directory.

* Jump into that directory first.

if (OP_TEST != op && 0 == set_basedir(path_arg, 1))

if (op != OP_TEST && set_basedir(path_arg, 1) == 0)

goto out;

dba = nodb ? dba_new(128) : dba_read(MANDOC_DB);

Line 440 mandocdb(int argc, char *argv[])

Line 443 mandocdb(int argc, char *argv[])

* The existing database is usable. Process

* all files specified on the command-line.

#if HAVE_PLEDGE

if (!nodb) {

if (pledge("stdio rpath wpath cpath fattr flock", NULL) == -1) {

warn("pledge");

exitcode = (int)MANDOCLEVEL_SYSERR;

goto out;

}

#endif

use_all = 1;

for (i = 0; i < argc; i++)

filescan(argv[i]);

Line 461 mandocdb(int argc, char *argv[])

Line 455 mandocdb(int argc, char *argv[])

" from scratch", strerror(errno));

exitcode = (int)MANDOCLEVEL_OK;

op = OP_DEFAULT;

if (0 == treescan())

if (treescan() == 0)

goto out;

dba = dba_new(128);

}

if (OP_DELETE != op)

if (op != OP_DELETE)

mpages_merge(dba, mp);

if (nodb == 0)

dbwrite(dba);

Line 499 mandocdb(int argc, char *argv[])

Line 493 mandocdb(int argc, char *argv[])

sz = strlen(conf.manpath.paths[j]);

if (sz && conf.manpath.paths[j][sz - 1] == '/')

conf.manpath.paths[j][--sz] = '\0';

if (0 == sz)

if (sz == 0)

continue;

if (j) {

Line 509 mandocdb(int argc, char *argv[])

Line 503 mandocdb(int argc, char *argv[])

offsetof(struct mlink, file));

}

if ( ! set_basedir(conf.manpath.paths[j], argc > 0))

if (set_basedir(conf.manpath.paths[j], argc > 0) == 0)

continue;

if (0 == treescan())

if (treescan() == 0)

continue;

dba = dba_new(128);

mpages_merge(dba, mp);

Line 588 treescan(void)

Line 582 treescan(void)

const char *argv[2];

argv[0] = ".";

argv[1] = (char *)NULL;

argv[1] = NULL;

f = fts_open((char * const *)argv, FTS_PHYSICAL | FTS_NOCHDIR,

fts_compare);

Line 615 treescan(void)

Line 609 treescan(void)

say(path, "&realpath");

continue;

}

if (strstr(buf, basedir) != buf

if (strncmp(buf, basedir, basedir_len) != 0

#ifdef HOMEBREWDIR

&& strstr(buf, HOMEBREWDIR) != buf

&& strncmp(buf, HOMEBREWDIR, strlen(HOMEBREWDIR))

#endif

) {

if (warnings) say("",

Line 793 filescan(const char *file)

Line 787 filescan(const char *file)

assert(use_all);

if (0 == strncmp(file, "./", 2))

if (strncmp(file, "./", 2) == 0)

file += 2;

Line 803 filescan(const char *file)

Line 797 filescan(const char *file)

* we want to use the orginal file name, while for

* regular files, we want to use the real path.

if (-1 == lstat(file, &st)) {

if (lstat(file, &st) == -1) {

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, "&lstat");

return;

} else if (0 == ((S_IFREG | S_IFLNK) & st.st_mode)) {

} else if ((st.st_mode & (S_IFREG | S_IFLNK)) == 0) {

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, "Not a regular file");

return;

Line 817 filescan(const char *file)

Line 811 filescan(const char *file)

* We have to resolve the file name to the real path

* in any case for the base directory check.

if (NULL == realpath(file, buf)) {

if (realpath(file, buf) == NULL) {

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, "&realpath");

return;

}

if (OP_TEST == op)

if (op == OP_TEST)

start = buf;

else if (strstr(buf, basedir) == buf)

else if (strncmp(buf, basedir, basedir_len) == 0)

start = buf + strlen(basedir);

start = buf + basedir_len;

#ifdef HOMEBREWDIR

else if (strstr(buf, HOMEBREWDIR) == buf)

else if (strncmp(buf, HOMEBREWDIR, strlen(HOMEBREWDIR)) == 0)

start = buf;

#endif

else {

Line 846 filescan(const char *file)

Line 840 filescan(const char *file)

* Note the stat(2) can still fail if the link target

* doesn't exist.

if (S_IFLNK & st.st_mode) {

if (st.st_mode & S_IFLNK) {

if (-1 == stat(buf, &st)) {

if (stat(buf, &st) == -1) {

exitcode = (int)MANDOCLEVEL_BADARG;

say(file, "&stat");

return;

Line 857 filescan(const char *file)

Line 851 filescan(const char *file)

return;

}

start = buf;

if (OP_TEST != op && strstr(buf, basedir) == buf)

if (op != OP_TEST && strncmp(buf, basedir, basedir_len) == 0)

start += strlen(basedir);

start += basedir_len;

}

mlink = mandoc_calloc(1, sizeof(struct mlink));

Line 871 filescan(const char *file)

Line 865 filescan(const char *file)

}

* In test mode or when the original name is absolute

* but outside our tree, guess the base directory.

if (op == OP_TEST || (start == buf && *start == '/')) {

if (strncmp(buf, "man/", 4) == 0)

start = buf + 4;

else if ((start = strstr(buf, "/man/")) != NULL)

start += 5;

else

start = buf;

}

* First try to guess our directory structure.

* If we find a separator, try to look for man* or cat*.

* If we find one of these and what's underneath is a directory,

* assume it's an architecture.

if (NULL != (p = strchr(start, '/'))) {

if ((p = strchr(start, '/')) != NULL) {

*p++ = '\0';

if (0 == strncmp(start, "man", 3)) {

if (strncmp(start, "man", 3) == 0) {

mlink->dform = FORM_SRC;

mlink->dsec = start + 3;

} else if (0 == strncmp(start, "cat", 3)) {

} else if (strncmp(start, "cat", 3) == 0) {

mlink->dform = FORM_CAT;

mlink->dsec = start + 3;

}

start = p;

if (NULL != mlink->dsec && NULL != (p = strchr(start, '/'))) {

if (mlink->dsec != NULL && (p = strchr(start, '/')) != NULL) {

*p++ = '\0';

mlink->arch = start;

start = p;

Line 899 filescan(const char *file)

Line 907 filescan(const char *file)

* Suffix of `.0' indicates a catpage, `.1-9' is a manpage.

p = strrchr(start, '\0');

while (p-- > start && '/' != *p && '.' != *p)

while (p-- > start && *p != '/' && *p != '.')

/* Loop. */ ;

continue;

if ('.' == *p) {

if (*p == '.') {

*p++ = '\0';

mlink->fsec = p;

}

Line 912 filescan(const char *file)

Line 920 filescan(const char *file)

* Use the filename portion of the path.

mlink->name = start;

if (NULL != (p = strrchr(start, '/'))) {

if ((p = strrchr(start, '/')) != NULL) {

mlink->name = p + 1;

*p = '\0';

}

Line 1109 mpages_merge(struct dba *dba, struct mparse *mp)

Line 1117 mpages_merge(struct dba *dba, struct mparse *mp)

{

struct mpage *mpage, *mpage_dest;

struct mlink *mlink, *mlink_dest;

struct roff_man *man;

struct roff_meta *meta;

char *sodest;

char *cp;

int fd;

Line 1123 mpages_merge(struct dba *dba, struct mparse *mp)

Line 1130 mpages_merge(struct dba *dba, struct mparse *mp)

mandoc_ohash_init(&names, 4, offsetof(struct str, key));

mandoc_ohash_init(&strings, 6, offsetof(struct str, key));

mparse_reset(mp);

man = NULL;

meta = NULL;

sodest = NULL;

if ((fd = mparse_open(mp, mlink->file)) == -1) {

say(mlink->file, "&open");

Line 1138 mpages_merge(struct dba *dba, struct mparse *mp)

Line 1144 mpages_merge(struct dba *dba, struct mparse *mp)

if (mlink->dform != FORM_CAT || mlink->fform != FORM_CAT) {

mparse_readfd(mp, fd, mlink->file);

close(fd);

mparse_result(mp, &man, &sodest);

fd = -1;

meta = mparse_result(mp);

}

if (sodest != NULL) {

if (meta != NULL && meta->sodest != NULL) {

mlink_dest = ohash_find(&mlinks,

ohash_qlookup(&mlinks, sodest));

ohash_qlookup(&mlinks, meta->sodest));

if (mlink_dest == NULL) {

mandoc_asprintf(&cp, "%s.gz", sodest);

mandoc_asprintf(&cp, "%s.gz", meta->sodest);

mlink_dest = ohash_find(&mlinks,

ohash_qlookup(&mlinks, cp));

free(cp);

Line 1180 mpages_merge(struct dba *dba, struct mparse *mp)

Line 1187 mpages_merge(struct dba *dba, struct mparse *mp)

mlink->next = mlink_dest->next;

mlink_dest->next = mpage->mlinks;

mpage->mlinks = NULL;

goto nextpage;

}

goto nextpage;

meta->macroset = MACROSET_NONE;

} else if (man != NULL && man->macroset == MACROSET_MDOC) {

}

mdoc_validate(man);

if (meta != NULL && meta->macroset == MACROSET_MDOC) {

mpage->form = FORM_SRC;

mpage->sec = man->meta.msec;

mpage->sec = meta->msec;

mpage->sec = mandoc_strdup(

mpage->sec == NULL ? "" : mpage->sec);

mpage->arch = man->meta.arch;

mpage->arch = meta->arch;

mpage->arch = mandoc_strdup(

mpage->arch == NULL ? "" : mpage->arch);

mpage->title = mandoc_strdup(man->meta.title);

mpage->title = mandoc_strdup(meta->title);

} else if (man != NULL && man->macroset == MACROSET_MAN) {

} else if (meta != NULL && meta->macroset == MACROSET_MAN) {

man_validate(man);

if (*meta->msec != '\0' || *meta->title != '\0') {

mpage->form = FORM_SRC;

mpage->sec = mandoc_strdup(man->meta.msec);

mpage->sec = mandoc_strdup(meta->msec);

mpage->arch = mandoc_strdup(mlink->arch);

mpage->title = mandoc_strdup(man->meta.title);

mpage->title = mandoc_strdup(meta->title);

} else {

} else

mpage->form = FORM_CAT;

meta = NULL;

}

assert(mpage->desc == NULL);

if (meta == NULL || meta->sodest != NULL) {

mpage->sec = mandoc_strdup(mlink->dsec);

mpage->arch = mandoc_strdup(mlink->arch);

mpage->title = mandoc_strdup(mlink->name);

if (meta == NULL) {

mpage->form = FORM_CAT;

parse_cat(mpage, fd);

} else

mpage->form = FORM_SRC;

} else if (meta->macroset == MACROSET_MDOC)

parse_mdoc(mpage, meta, meta->first);

else

parse_man(mpage, meta, meta->first);

if (mpage->desc == NULL) {

mpage->desc = mandoc_strdup(mlink->name);

if (warnings)

say(mlink->file, "No one-line description, "

"using filename \"%s\"", mlink->name);

}

assert(mpage->desc == NULL);

for (mlink = mpage->mlinks;

if (man != NULL && man->macroset == MACROSET_MDOC)

mlink != NULL;

parse_mdoc(mpage, &man->meta, man->first);

mlink = mlink->next) {

else if (man != NULL)

putkey(mpage, mlink->name, NAME_FILE);

parse_man(mpage, &man->meta, man->first);

if (warnings && !use_all)

else

parse_cat(mpage, fd);

if (mpage->desc == NULL)

mpage->desc = mandoc_strdup(mpage->mlinks->name);

if (warnings && !use_all)

for (mlink = mpage->mlinks; mlink;

mlink = mlink->next)

mlink_check(mpage, mlink);

}

dbadd(dba, mpage);

mlink = mpage->mlinks;

ohash_delete(&strings);

Line 1233 static void

Line 1251 static void

parse_cat(struct mpage *mpage, int fd)

{

FILE *stream;

char *line, *p, *title;

struct mlink *mlink;

char *line, *p, *title, *sec;

size_t linesz, plen, titlesz;

ssize_t len;

int offs;

stream = (-1 == fd) ?

mlink = mpage->mlinks;

fopen(mpage->mlinks->file, "r") :

stream = fd == -1 ? fopen(mlink->file, "r") : fdopen(fd, "r");

fdopen(fd, "r");

if (stream == NULL) {

if (NULL == stream) {

if (fd != -1)

if (-1 != fd)

close(fd);

if (warnings)

say(mpage->mlinks->file, "&fopen");

say(mlink->file, "&fopen");

return;

}

line = NULL;

linesz = 0;

/* Skip to first blank line. */

/* Parse the section number from the header line. */

while (getline(&line, &linesz, stream) != -1)

while (getline(&line, &linesz, stream) != -1) {

if (*line == '\n')

continue;

if ((sec = strchr(line, '(')) == NULL)

break;

if ((p = strchr(++sec, ')')) == NULL)

break;

free(mpage->sec);

mpage->sec = mandoc_strndup(sec, p - sec);

if (warnings && *mlink->dsec != '\0' &&

strcasecmp(mpage->sec, mlink->dsec))

say(mlink->file,

"Section \"%s\" manual in %s directory",

mpage->sec, mlink->dsec);

break;

}

/* Skip to first blank line. */

while (line == NULL || *line != '\n')

if (getline(&line, &linesz, stream) == -1)

break;

* Assume the first line that is not indented

* is the first section header. Skip to it.

Line 1301 parse_cat(struct mpage *mpage, int fd)

Line 1338 parse_cat(struct mpage *mpage, int fd)

if (NULL == title || '\0' == *title) {

if (warnings)

say(mpage->mlinks->file,

say(mlink->file, "Cannot find NAME section");

"Cannot find NAME section");

fclose(stream);

free(title);

return;

Line 1321 parse_cat(struct mpage *mpage, int fd)

Line 1357 parse_cat(struct mpage *mpage, int fd)

/* Skip to next word. */ ;

} else {

if (warnings)

say(mpage->mlinks->file,

say(mlink->file, "No dash in title line, "

"No dash in title line");

"reusing \"%s\" as one-line description", title);

p = title;

}

Line 1340 parse_cat(struct mpage *mpage, int fd)

Line 1376 parse_cat(struct mpage *mpage, int fd)

plen -= 2;

}

mpage->desc = mandoc_strdup(p);

* Cut off excessive one-line descriptions.

* Bad pages are not worth better heuristics.

mpage->desc = mandoc_strndup(p, 150);

fclose(stream);

free(title);

}

Line 1359 putkey(const struct mpage *mpage, char *value, uint64_

Line 1400 putkey(const struct mpage *mpage, char *value, uint64_

static void

putmdockey(const struct mpage *mpage,

const struct roff_node *n, uint64_t m)

const struct roff_node *n, uint64_t m, int taboo)

{

for ( ; NULL != n; n = n->next) {

if (n->flags & taboo)

continue;

if (NULL != n->child)

putmdockey(mpage, n->child, m);

putmdockey(mpage, n->child, m, taboo);

if (n->type == ROFFT_TEXT)

putkey(mpage, n->string, m);

}

Line 1482 parse_man(struct mpage *mpage, const struct roff_meta

Line 1525 parse_man(struct mpage *mpage, const struct roff_meta

while (' ' == *start)

start++;

mpage->desc = mandoc_strdup(start);

* Cut off excessive one-line descriptions.

* Bad pages are not worth better heuristics.

mpage->desc = mandoc_strndup(start, 150);

free(title);

return;

}

Line 1499 static void

Line 1547 static void

parse_mdoc(struct mpage *mpage, const struct roff_meta *meta,

const struct roff_node *n)

{

const struct mdoc_handler *handler;

assert(NULL != n);

for (n = n->child; n != NULL; n = n->next) {

for (n = n->child; NULL != n; n = n->next) {

if (n->tok == TOKEN_NONE || n->tok < ROFF_MAX)

continue;

assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);

handler = mdoc_handlers + (n->tok - MDOC_Dd);

if (n->flags & handler->taboo)

continue;

switch (n->type) {

case ROFFT_ELEM:

case ROFFT_BLOCK:

case ROFFT_HEAD:

case ROFFT_BODY:

case ROFFT_TAIL:

if (NULL != mdocs[n->tok].fp)

if (handler->fp != NULL &&

if (0 == (*mdocs[n->tok].fp)(mpage, meta, n))

(*handler->fp)(mpage, meta, n) == 0)

break;

if (mdocs[n->tok].mask)

if (handler->mask)

putmdockey(mpage, n->child,

mdocs[n->tok].mask);

handler->mask, handler->taboo);

break;

default:

assert(n->type != ROFFT_ROOT);

continue;

}

if (NULL != n->child)

Line 1525 parse_mdoc(struct mpage *mpage, const struct roff_meta

Line 1579 parse_mdoc(struct mpage *mpage, const struct roff_meta

}

static int

parse_mdoc_Fa(struct mpage *mpage, const struct roff_meta *meta,

const struct roff_node *n)

{

uint64_t mask;

mask = TYPE_Fa;

if (n->sec == SEC_SYNOPSIS)

mask |= TYPE_Vt;

putmdockey(mpage, n->child, mask, 0);

return 0;

}

static int

parse_mdoc_Fd(struct mpage *mpage, const struct roff_meta *meta,

const struct roff_node *n)

{

Line 1593 static int

Line 1661 static int

parse_mdoc_Fn(struct mpage *mpage, const struct roff_meta *meta,

const struct roff_node *n)

{

uint64_t mask;

if (n->child == NULL)

return 0;

parse_mdoc_fname(mpage, n->child);

for (n = n->child->next; n != NULL; n = n->next)

n = n->child->next;

if (n->type == ROFFT_TEXT)

if (n != NULL && n->type == ROFFT_TEXT) {

putkey(mpage, n->string, TYPE_Fa);

mask = TYPE_Fa;

if (n->sec == SEC_SYNOPSIS)

mask |= TYPE_Vt;

putmdockey(mpage, n, mask, 0);

}

return 0;

}

Line 1681 parse_mdoc_Nm(struct mpage *mpage, const struct roff_m

Line 1754 parse_mdoc_Nm(struct mpage *mpage, const struct roff_m

{

if (SEC_NAME == n->sec)

putmdockey(mpage, n->child, NAME_TITLE);

putmdockey(mpage, n->child, NAME_TITLE, 0);

else if (n->sec == SEC_SYNOPSIS && n->type == ROFFT_HEAD) {

if (n->child == NULL)

putkey(mpage, meta->name, NAME_SYN);

else

putmdockey(mpage, n->child, NAME_SYN);

putmdockey(mpage, n->child, NAME_SYN, 0);

}

if ( ! (mpage->name_head_done ||

n->child == NULL || n->child->string == NULL ||

Line 2072 dbprune(struct dba *dba)

Line 2145 dbprune(struct dba *dba)

static void

dbwrite(struct dba *dba)

{

char tfn[32];

struct stat sb1, sb2;

int status;

char tfn[33], *cp1, *cp2;

pid_t child;

off_t i;

int fd1, fd2;

* Do not write empty databases, and delete existing ones

* when makewhatis -u causes them to become empty.

dba_array_start(dba->pages);

if (dba_array_next(dba->pages) == NULL) {

if (unlink(MANDOC_DB) == -1 && errno != ENOENT)

say(MANDOC_DB, "&unlink");

return;

}

* Build the database in a temporary file,

* then atomically move it into place.

if (dba_write(MANDOC_DB "~", dba) != -1) {

if (rename(MANDOC_DB "~", MANDOC_DB) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

Line 2085 dbwrite(struct dba *dba)

Line 2176 dbwrite(struct dba *dba)

return;

}

* We lack write permission and cannot replace the database

* file, but let's at least check whether the data changed.

(void)strlcpy(tfn, "/tmp/mandocdb.XXXXXXXX", sizeof(tfn));

if (mkdtemp(tfn) == NULL) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&%s", tfn);

return;

}

cp1 = cp2 = MAP_FAILED;

fd1 = fd2 = -1;

(void)strlcat(tfn, "/" MANDOC_DB, sizeof(tfn));

if (dba_write(tfn, dba) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(tfn, "&dba_write");

goto out;

goto err;

}

if ((fd1 = open(MANDOC_DB, O_RDONLY, 0)) == -1) {

switch (child = fork()) {

say(MANDOC_DB, "&open");

case -1:

goto err;

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&fork cmp");

return;

case 0:

execlp("cmp", "cmp", "-s", tfn, MANDOC_DB, (char *)NULL);

say("", "&exec cmp");

exit(0);

default:

break;

}

if (waitpid(child, &status, 0) == -1) {

if ((fd2 = open(tfn, O_RDONLY, 0)) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(tfn, "&open");

say("", "&wait cmp");

goto err;

} else if (WIFSIGNALED(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "cmp died from signal %d", WTERMSIG(status));

} else if (WEXITSTATUS(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB,

"Data changed, but cannot replace database");

}

if (fstat(fd1, &sb1) == -1) {

say(MANDOC_DB, "&fstat");

goto err;

}

if (fstat(fd2, &sb2) == -1) {

say(tfn, "&fstat");

goto err;

}

if (sb1.st_size != sb2.st_size)

goto err;

if ((cp1 = mmap(NULL, sb1.st_size, PROT_READ, MAP_PRIVATE,

fd1, 0)) == MAP_FAILED) {

say(MANDOC_DB, "&mmap");

goto err;

}

if ((cp2 = mmap(NULL, sb2.st_size, PROT_READ, MAP_PRIVATE,

fd2, 0)) == MAP_FAILED) {

say(tfn, "&mmap");

goto err;

}

for (i = 0; i < sb1.st_size; i++)

if (cp1[i] != cp2[i])

goto err;

goto out;

err:

exitcode = (int)MANDOCLEVEL_SYSERR;

say(MANDOC_DB, "Data changed, but cannot replace database");

out:

if (cp1 != MAP_FAILED)

munmap(cp1, sb1.st_size);

if (cp2 != MAP_FAILED)

munmap(cp2, sb2.st_size);

if (fd1 != -1)

close(fd1);

if (fd2 != -1)

close(fd2);

unlink(tfn);

*strrchr(tfn, '/') = '\0';

switch (child = fork()) {

rmdir(tfn);

case -1:

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&fork rm");

return;

case 0:

execlp("rm", "rm", "-rf", tfn, (char *)NULL);

say("", "&exec rm");

exit((int)MANDOCLEVEL_SYSERR);

default:

break;

}

if (waitpid(child, &status, 0) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&wait rm");

} else if (WIFSIGNALED(status) || WEXITSTATUS(status)) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "%s: Cannot remove temporary directory", tfn);

}

static int

Line 2152 set_basedir(const char *targetdir, int report_baddir)

Line 2251 set_basedir(const char *targetdir, int report_baddir)

static char startdir[PATH_MAX];

static int getcwd_status; /* 1 = ok, 2 = failure */

static int chdir_status; /* 1 = changed directory */

char *cp;

* Remember the original working directory, if possible.

Line 2161 set_basedir(const char *targetdir, int report_baddir)

Line 2259 set_basedir(const char *targetdir, int report_baddir)

* Do not error out if the current directory is not

* searchable: Maybe it won't be needed after all.

if (0 == getcwd_status) {

if (getcwd_status == 0) {

if (NULL == getcwd(startdir, sizeof(startdir))) {

if (getcwd(startdir, sizeof(startdir)) == NULL) {

getcwd_status = 2;

(void)strlcpy(startdir, strerror(errno),

sizeof(startdir));

Line 2175 set_basedir(const char *targetdir, int report_baddir)

Line 2273 set_basedir(const char *targetdir, int report_baddir)

* Do not use it any longer, not even for messages.

*basedir = '\0';

basedir_len = 0;

* If and only if the directory was changed earlier and

* the next directory to process is given as a relative path,

* first go back, or bail out if that is impossible.

if (chdir_status && '/' != *targetdir) {

if (chdir_status && *targetdir != '/') {

if (2 == getcwd_status) {

if (getcwd_status == 2) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "getcwd: %s", startdir);

return 0;

}

if (-1 == chdir(startdir)) {

if (chdir(startdir) == -1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&chdir %s", startdir);

return 0;

Line 2199 set_basedir(const char *targetdir, int report_baddir)

Line 2298 set_basedir(const char *targetdir, int report_baddir)

* pathname and append a trailing slash, such that

* we can reliably check whether files are inside.

if (NULL == realpath(targetdir, basedir)) {

if (realpath(targetdir, basedir) == NULL) {

if (report_baddir || errno != ENOENT) {

exitcode = (int)MANDOCLEVEL_BADARG;

say("", "&%s: realpath", targetdir);

}

*basedir = '\0';

return 0;

} else if (-1 == chdir(basedir)) {

} else if (chdir(basedir) == -1) {

if (report_baddir || errno != ENOENT) {

exitcode = (int)MANDOCLEVEL_BADARG;

say("", "&chdir");

}

*basedir = '\0';

return 0;

}

chdir_status = 1;

cp = strchr(basedir, '\0');

basedir_len = strlen(basedir);

if ('/' != cp[-1]) {

if (basedir[basedir_len - 1] != '/') {

if (cp - basedir >= PATH_MAX - 1) {

if (basedir_len >= PATH_MAX - 1) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "Filename too long");

*basedir = '\0';

basedir_len = 0;

return 0;

}

*cp++ = '/';

basedir[basedir_len++] = '/';

*cp = '\0';

basedir[basedir_len] = '\0';

}

return 1;

}

Line 2232 say(const char *file, const char *format, ...)

Line 2335 say(const char *file, const char *format, ...)

va_list ap;

int use_errno;

if ('\0' != *basedir)

if (*basedir != '\0')

fprintf(stderr, "%s", basedir);

if ('\0' != *basedir && '\0' != *file)

if (*basedir != '\0' && *file != '\0')

fputc('/', stderr);

if ('\0' != *file)

if (*file != '\0')

fprintf(stderr, "%s", file);

use_errno = 1;

if (NULL != format) {

if (format != NULL) {

switch (*format) {

case '&':

format++;

Line 2253 say(const char *file, const char *format, ...)

Line 2356 say(const char *file, const char *format, ...)

break;

}

if (NULL != format) {

if (format != NULL) {

if ('\0' != *basedir || '\0' != *file)

if (*basedir != '\0' || *file != '\0')

fputs(": ", stderr);

va_start(ap, format);

vfprintf(stderr, format, ap);

va_end(ap);

}

if (use_errno) {

if ('\0' != *basedir || '\0' != *file || NULL != format)

if (*basedir != '\0' || *file != '\0' || format != NULL)

fputs(": ", stderr);

perror(NULL);

} else

CVSweb