mandoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/main.c between version 1.339 and 1.351

version 1.339, 2019/07/28 18:36:06

version 1.351, 2020/07/20 16:57:30

Line 1

/* $Id$ */

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

Line 15

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

* Main program for mandoc(1), man(1), apropos(1), whatis(1), and help(1).

#include "config.h"

Line 32

Line 34

#include <errno.h>

#include <fcntl.h>

#include <glob.h>

#include <limits.h>

#if HAVE_SANDBOX_INIT

#include <sandbox.h>

#endif

Line 52

Line 55

#include "man.h"

#include "mandoc_parse.h"

#include "tag.h"

#include "term_tag.h"

#include "main.h"

#include "manconf.h"

#include "mansearch.h"

Line 95 static int fs_lookup(const struct manpaths *,

Line 99 static int fs_lookup(const struct manpaths *,

const char *, const char *,

struct manpage **, size_t *);

static int fs_search(const struct mansearch *,

const struct manpaths *, int, char**,

const struct manpaths *, const char *,

struct manpage **, size_t *);

static void glob_esc(char **, const char *, const char *);

static void outdata_alloc(struct outstate *, struct manoutput *);

static void parse(struct mparse *, int, const char *,

struct outstate *, struct manoutput *);

static void passthrough(int, int);

static void process_onefile(struct mparse *, struct manpage *,

int, struct outstate *, struct manconf *);

static void run_pager(struct tag_files *);

static void run_pager(struct outstate *, char *);

static pid_t spawn_pager(struct tag_files *);

static pid_t spawn_pager(struct outstate *, char *);

static void usage(enum argmode) __attribute__((__noreturn__));

static int woptions(char *, enum mandoc_os *, int *);

Line 325 main(int argc, char *argv[])

Line 330 main(int argc, char *argv[])

/* Postprocess options. */

if (outmode == OUTMODE_DEF) {

switch (outmode) {

case OUTMODE_DEF:

switch (search.argmode) {

case ARG_FILE:

outmode = OUTMODE_ALL;

Line 338 main(int argc, char *argv[])

Line 344 main(int argc, char *argv[])

outmode = OUTMODE_LST;

break;

}

break;

case OUTMODE_FLN:

if (search.argmode == ARG_FILE)

outmode = OUTMODE_ALL;

break;

case OUTMODE_ALL:

break;

case OUTMODE_LST:

case OUTMODE_ONE:

abort();

}

if (oarg != NULL) {

Line 436 main(int argc, char *argv[])

Line 452 main(int argc, char *argv[])

/* man(1): Resolve each name individually. */

if (search.argmode == ARG_NAME) {

if (argc < 1)

if (argc < 1) {

usage(ARG_NAME);

if (outmode != OUTMODE_FLN)

usage(ARG_NAME);

if (conf.manpath.sz == 0) {

warnx("The manpath is empty.");

mandoc_msg_setrc(MANDOCLEVEL_BADARG);

} else {

for (i = 0; i + 1 < conf.manpath.sz; i++)

printf("%s:", conf.manpath.paths[i]);

printf("%s\n", conf.manpath.paths[i]);

}

manconf_free(&conf);

return (int)mandoc_msg_getrc();

}

for (res = NULL, ressz = 0; argc > 0; argc--, argv++) {

(void)mansearch(&search, &conf.manpath,

1, argv, &resn, &resnsz);

if (resnsz == 0)

(void)fs_search(&search, &conf.manpath,

1, argv, &resn, &resnsz);

*argv, &resn, &resnsz);

if (resnsz == 0 && strchr(*argv, '/') == NULL) {

if (search.arch != NULL &&

arch_valid(search.arch, OSENUM) == 0)

warnx("Unknown architecture \"%s\".",

search.arch);

else if (search.sec != NULL)

warnx("No entry for %s in "

"section %s of the manual.",

*argv, search.sec);

else

warnx("No entry for %s in "

"the manual.", *argv);

mandoc_msg_setrc(MANDOCLEVEL_BADARG);

continue;

}

if (resnsz == 0) {

if (strchr(*argv, '/') == NULL) {

mandoc_msg_setrc(MANDOCLEVEL_BADARG);

continue;

}

if (access(*argv, R_OK) == -1) {

mandoc_msg_setinfilename(*argv);

mandoc_msg(MANDOCERR_BADARG_BAD,

Line 562 main(int argc, char *argv[])

Line 601 main(int argc, char *argv[])

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

startdir = open(".", O_RDONLY | O_DIRECTORY);

for (i = 0; i < ressz; i++) {

process_onefile(mp, res + i, startdir, &outst, &conf);

if (outst.wstop && mandoc_msg_getrc() != MANDOCLEVEL_OK)

Line 572 main(int argc, char *argv[])

Line 610 main(int argc, char *argv[])

(void)fchdir(startdir);

close(startdir);

}

if (conf.output.tag != NULL && conf.output.tag_found == 0) {

mandoc_msg(MANDOCERR_TAG, 0, 0, "%s", conf.output.tag);

conf.output.tag = NULL;

}

if (outst.outdata != NULL) {

switch (outst.outtype) {

case OUTT_HTML:

Line 601 out:

Line 642 out:

manconf_free(&conf);

if (outst.tag_files != NULL) {

fclose(stdout);

if (term_tag_close() != -1)

tag_write();

run_pager(&outst, conf.output.tag);

run_pager(outst.tag_files);

term_tag_unlink();

tag_unlink();

} else if (outst.had_output && outst.outtype != OUTT_LINT)

mandoc_msg_summary();

Line 639 usage(enum argmode argmode)

Line 679 usage(enum argmode argmode)

exit((int)MANDOCLEVEL_BADARG);

}

static void

glob_esc(char **dst, const char *src, const char *suffix)

{

while (*src != '\0') {

if (strchr("*?[", *src) != NULL)

*(*dst)++ = '\\';

*(*dst)++ = *src++;

}

while (*suffix != '\0')

*(*dst)++ = *suffix++;

}

static int

fs_lookup(const struct manpaths *paths, size_t ipath,

const char *sec, const char *arch, const char *name,

Line 647 fs_lookup(const struct manpaths *paths, size_t ipath,

Line 699 fs_lookup(const struct manpaths *paths, size_t ipath,

struct stat sb;

glob_t globinfo;

struct manpage *page;

char *file;

char *file, *cp;

int globres;

enum form form;

const char *const slman = "/man";

const char *const slash = "/";

const char *const sglob = ".[01-9]*";

form = FORM_SRC;

mandoc_asprintf(&file, "%s/man%s/%s.%s",

paths->paths[ipath], sec, name, sec);

Line 674 fs_lookup(const struct manpaths *paths, size_t ipath,

Line 730 fs_lookup(const struct manpaths *paths, size_t ipath,

free(file);

}

mandoc_asprintf(&file, "%s/man%s/%s.[01-9]*",

cp = file = mandoc_malloc(strlen(paths->paths[ipath]) * 2 +

paths->paths[ipath], sec, name);

strlen(slman) + strlen(sec) * 2 + strlen(slash) +

strlen(name) * 2 + strlen(sglob) + 1);

glob_esc(&cp, paths->paths[ipath], slman);

glob_esc(&cp, sec, slash);

glob_esc(&cp, name, sglob);

*cp = '\0';

globres = glob(file, 0, NULL, &globinfo);

if (globres != 0 && globres != GLOB_NOMATCH)

mandoc_msg(MANDOCERR_GLOB, 0, 0,

Line 718 found:

Line 779 found:

static int

fs_search(const struct mansearch *cfg, const struct manpaths *paths,

int argc, char **argv, struct manpage **res, size_t *ressz)

const char *name, struct manpage **res, size_t *ressz)

{

const char *const sections[] =

{"1", "8", "6", "2", "3", "5", "7", "4", "9", "3p"};

const size_t nsec = sizeof(sections)/sizeof(sections[0]);

size_t ipath, isec, lastsz;

size_t ipath, isec;

assert(cfg->argmode == ARG_NAME);

if (res != NULL)

*res = NULL;

*ressz = lastsz = 0;

*ressz = 0;

while (argc) {

for (ipath = 0; ipath < paths->sz; ipath++) {

if (cfg->sec != NULL) {

if (fs_lookup(paths, ipath, cfg->sec, cfg->arch,

if (fs_lookup(paths, ipath, cfg->sec,

name, res, ressz) != -1 && cfg->firstmatch)

cfg->arch, *argv, res, ressz) != -1 &&

return 0;

cfg->firstmatch)

} else {

return 0;

for (isec = 0; isec < nsec; isec++)

} else for (isec = 0; isec < nsec; isec++)

if (fs_lookup(paths, ipath, sections[isec],

cfg->arch, *argv, res, ressz) != -1 &&

cfg->arch, name, res, ressz) != -1 &&

cfg->firstmatch)

return 0;

}

if (res != NULL && *ressz == lastsz &&

strchr(*argv, '/') == NULL) {

if (cfg->arch != NULL &&

arch_valid(cfg->arch, OSENUM) == 0)

warnx("Unknown architecture \"%s\".",

cfg->arch);

else if (cfg->sec == NULL)

warnx("No entry for %s in the manual.",

*argv);

else

warnx("No entry for %s in section %s "

"of the manual.", *argv, cfg->sec);

}

lastsz = *ressz;

argv++;

argc--;

}

return -1;

}

Line 794 process_onefile(struct mparse *mp, struct manpage *res

Line 837 process_onefile(struct mparse *mp, struct manpage *res

if (outst->use_pager) {

outst->use_pager = 0;

outst->tag_files = tag_init(conf->output.tag);

outst->tag_files = term_tag_init();

}

if (outst->had_output && outst->outtype <= OUTT_UTF8) {

if (outst->outdata == NULL)

outdata_alloc(outst, &conf->output);

Line 814 process_onefile(struct mparse *mp, struct manpage *res

Line 856 process_onefile(struct mparse *mp, struct manpage *res

if (outst->tag_files != NULL) {

mandoc_msg(MANDOCERR_WRITE, 0, 0, "%s: %s",

outst->tag_files->ofn, strerror(errno));

tag_unlink();

term_tag_unlink();

outst->tag_files = NULL;

} else

mandoc_msg(MANDOCERR_WRITE, 0, 0, "%s",

Line 854 parse(struct mparse *mp, int fd, const char *file,

Line 896 parse(struct mparse *mp, int fd, const char *file,

if (outst->outdata == NULL)

outdata_alloc(outst, outconf);

else if (outst->outtype == OUTT_HTML)

html_reset(outst);

html_reset(outst->outdata);

mandoc_xr_reset();

meta = mparse_result(mp);

Line 909 parse(struct mparse *mp, int fd, const char *file,

Line 951 parse(struct mparse *mp, int fd, const char *file,

break;

}

if (outconf->tag != NULL && outconf->tag_found == 0 &&

tag_exists(outconf->tag))

outconf->tag_found = 1;

if (mandoc_msg_getmin() < MANDOCERR_STYLE)

check_xr();

}

Line 934 check_xr(void)

Line 979 check_xr(void)

search.firstmatch = 1;

if (mansearch(&search, &paths, 1, &xr->name, NULL, &sz))

continue;

if (fs_search(&search, &paths, 1, &xr->name, NULL, &sz) != -1)

if (fs_search(&search, &paths, xr->name, NULL, &sz) != -1)

continue;

if (xr->count == 1)

mandoc_msg(MANDOCERR_XR_BAD, xr->line,

Line 1099 woptions(char *arg, enum mandoc_os *os_e, int *wstop)

Line 1144 woptions(char *arg, enum mandoc_os *os_e, int *wstop)

* then fork the pager and wait for the user to close it.

static void

run_pager(struct tag_files *tag_files)

run_pager(struct outstate *outst, char *tag_target)

{

int signum, status;

pid_t man_pgid, tc_pgid;

pid_t pager_pid, wait_pid;

man_pgid = getpgid(0);

tag_files->tcpgid = man_pgid == getpid() ? getpgid(getppid()) :

outst->tag_files->tcpgid =

man_pgid;

man_pgid == getpid() ? getpgid(getppid()) : man_pgid;

pager_pid = 0;

signum = SIGSTOP;

for (;;) {

/* Stop here until moved to the foreground. */

tc_pgid = tcgetpgrp(tag_files->ofd);

tc_pgid = tcgetpgrp(STDOUT_FILENO);

if (tc_pgid != man_pgid) {

if (tc_pgid == pager_pid) {

(void)tcsetpgrp(tag_files->ofd, man_pgid);

(void)tcsetpgrp(STDOUT_FILENO, man_pgid);

if (signum == SIGTTIN)

continue;

} else

tag_files->tcpgid = tc_pgid;

outst->tag_files->tcpgid = tc_pgid;

kill(0, signum);

continue;

}

Line 1129 run_pager(struct tag_files *tag_files)

Line 1174 run_pager(struct tag_files *tag_files)

/* Once in the foreground, activate the pager. */

if (pager_pid) {

(void)tcsetpgrp(tag_files->ofd, pager_pid);

(void)tcsetpgrp(STDOUT_FILENO, pager_pid);

kill(pager_pid, SIGCONT);

} else

pager_pid = spawn_pager(tag_files);

pager_pid = spawn_pager(outst, tag_target);

/* Wait for the pager to stop or exit. */

Line 1153 run_pager(struct tag_files *tag_files)

Line 1198 run_pager(struct tag_files *tag_files)

}

static pid_t

spawn_pager(struct tag_files *tag_files)

spawn_pager(struct outstate *outst, char *tag_target)

{

const struct timespec timeout = { 0, 100000000 }; /* 0.1s */

#define MAX_PAGER_ARGS 16

Line 1166 spawn_pager(struct tag_files *tag_files)

Line 1211 spawn_pager(struct tag_files *tag_files)

int argc, use_ofn;

pid_t pager_pid;

assert(outst->tag_files->ofd == -1);

assert(outst->tag_files->tfs == NULL);

pager = getenv("MANPAGER");

if (pager == NULL || *pager == '\0')

pager = getenv("PAGER");

if (pager == NULL || *pager == '\0')

pager = "more -s";

pager = BINM_PAGER;

cp = mandoc_strdup(pager);

Line 1195 spawn_pager(struct tag_files *tag_files)

Line 1243 spawn_pager(struct tag_files *tag_files)

use_ofn = 1;

#if HAVE_LESS_T

if (*tag_files->tfn != '\0' && (cmdlen = strlen(argv[0])) >= 4) {

if (*outst->tag_files->tfn != '\0' &&

(cmdlen = strlen(argv[0])) >= 4) {

cp = argv[0] + cmdlen - 4;

if (strcmp(cp, "less") == 0) {

argv[argc++] = mandoc_strdup("-T");

argv[argc++] = tag_files->tfn;

argv[argc++] = outst->tag_files->tfn;

if (tag_files->tagname != NULL) {

if (tag_target != NULL) {

argv[argc++] = mandoc_strdup("-t");

argv[argc++] = tag_files->tagname;

argv[argc++] = tag_target;

use_ofn = 0;

}

#endif

if (use_ofn)

if (use_ofn) {

argv[argc++] = tag_files->ofn;

if (outst->outtype == OUTT_HTML && tag_target != NULL)

mandoc_asprintf(&argv[argc], "file://%s#%s",

outst->tag_files->ofn, tag_target);

else

argv[argc] = outst->tag_files->ofn;

argc++;

}

argv[argc] = NULL;

switch (pager_pid = fork()) {

Line 1220 spawn_pager(struct tag_files *tag_files)

Line 1275 spawn_pager(struct tag_files *tag_files)

break;

default:

(void)setpgid(pager_pid, 0);

(void)tcsetpgrp(tag_files->ofd, pager_pid);

(void)tcsetpgrp(STDOUT_FILENO, pager_pid);

#if HAVE_PLEDGE

if (pledge("stdio rpath tmppath tty proc", NULL) == -1) {

mandoc_msg(MANDOCERR_PLEDGE, 0, 0,

Line 1228 spawn_pager(struct tag_files *tag_files)

Line 1283 spawn_pager(struct tag_files *tag_files)

exit(mandoc_msg_getrc());

}

#endif

tag_files->pager_pid = pager_pid;

outst->tag_files->pager_pid = pager_pid;

return pager_pid;

}

/* The child process becomes the pager. */

* The child process becomes the pager.

if (dup2(tag_files->ofd, STDOUT_FILENO) == -1) {

* Do not start it before controlling the terminal.

mandoc_msg(MANDOCERR_DUP, 0, 0, "%s", strerror(errno));

_exit(mandoc_msg_getrc());

}

close(tag_files->ofd);

assert(tag_files->tfd == -1);

/* Do not start the pager before controlling the terminal. */

while (tcgetpgrp(STDOUT_FILENO) != getpid())

nanosleep(&timeout, NULL);

CVSweb