Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
bf28682f65
NetBSD/usr.sbin/catman/catman.c
christos d89a86ddb3 enlarge buffer sizes
2019-10-12 17:26:26 +00:00

641 lines
15 KiB
C
Raw Blame History

/* $NetBSD: catman.c,v 1.38 2019/10/12 17:26:26 christos Exp $ */
/*
* Copyright (c) 1998 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Author: Baldassare Dante Profeta <dante@mclink.it>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: catman.c,v 1.38 2019/10/12 17:26:26 christos Exp $");
#endif /* not lint */
#include <sys/types.h>
#include <sys/queue.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/utsname.h>
#include <ctype.h>
#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <fnmatch.h>
#include <limits.h>
#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <glob.h>
#include "manconf.h"
#include "pathnames.h"
int f_nowhatis = 0;
int f_noaction = 0;
int f_noformat = 0;
int f_ignerr = 0;
int f_noprint = 0;
int dowhatis = 0;
TAG *defp; /* pointer to _default list */
static void setdefentries(char *, char *, const char *);
static void uniquepath(void);
static void catman(void);
static void scanmandir(const char *, const char *);
static int splitentry(char *, char *, size_t, char *, size_t);
static void setcatsuffix(char *, const char *, const char *);
static void makecat(const char *, const char *, const char *, const char *);
static void makewhatis(void);
static void dosystem(const char *);
__dead static void usage(void);
int
main(int argc, char * const *argv)
{
char *m_path = NULL;
char *m_add = NULL;
int c;
while ((c = getopt(argc, argv, "km:M:npsw")) != -1) {
switch (c) {
case 'k':
f_ignerr = 1;
break;
case 'n':
f_nowhatis = 1;
break;
case 'p':
f_noaction = 1;
break;
case 's':
f_noprint = 1;
break;
case 'w':
f_noformat = 1;
break;
case 'm':
m_add = optarg;
break;
case 'M':
m_path = optarg;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (f_noprint && f_noaction)
f_noprint = 0;
if (argc > 1)
usage();
config(_PATH_MANCONF);
setdefentries(m_path, m_add, (argc == 0) ? NULL : argv[argc-1]);
uniquepath();
if (f_noformat == 0 || f_nowhatis == 0)
catman();
if (f_nowhatis == 0 && dowhatis)
makewhatis();
return(0);
}
static void
setdefentries(char *m_path, char *m_add, const char *sections)
{
TAG *defnewp, *sectnewp, *subp;
ENTRY *e_defp, *e_subp;
const char *p, *slashp;
char *machine;
char buf[MAXPATHLEN * 2];
int i;
/* Get the machine type. */
if ((machine = getenv("MACHINE")) == NULL) {
struct utsname utsname;
if (uname(&utsname) == -1) {
perror("uname");
exit(1);
}
machine = utsname.machine;
}
/* If there's no _default list, create an empty one. */
defp = gettag("_default", 1);
subp = gettag("_subdir", 1);
if (defp == NULL || subp == NULL)
err(1, "malloc");
/*
* 0: If one or more sections was specified, rewrite _subdir list.
*/
if (sections != NULL) {
if ((sectnewp = gettag("_section_new", 1)) == NULL)
err(1, "malloc");
for (p = sections; *p;) {
i = snprintf(buf, sizeof(buf), "man%c", *p++);
for (; *p && !isdigit((unsigned char)*p) && i < (int)sizeof(buf) - 1; i++)
buf[i] = *p++;
buf[i] = '\0';
if (addentry(sectnewp, buf, 0) < 0)
err(1, "malloc");
}
subp = sectnewp;
}
/*
* 1: If the user specified a MANPATH variable, or set the -M
* option, we replace the _default list with the user's list,
* appending the entries in the _subdir list and the machine.
*/
if (m_path == NULL)
m_path = getenv("MANPATH");
if (m_path != NULL) {
while ((e_defp = TAILQ_FIRST(&defp->entrylist)) != NULL) {
free(e_defp->s);
TAILQ_REMOVE(&defp->entrylist, e_defp, q);
}
for (p = strtok(m_path, ":");
p != NULL; p = strtok(NULL, ":")) {
slashp = p[strlen(p) - 1] == '/' ? "" : "/";
TAILQ_FOREACH(e_subp, &subp->entrylist, q) {
if (!strncmp(e_subp->s, "cat", 3))
continue;
(void)snprintf(buf, sizeof(buf), "%s%s%s{/%s,}",
p, slashp, e_subp->s, machine);
if (addentry(defp, buf, 0) < 0)
err(1, "malloc");
}
}
}
/*
* 2: If the user did not specify MANPATH, -M or a section, rewrite
* the _default list to include the _subdir list and the machine.
*/
if (m_path == NULL) {
defp = gettag("_default", 1);
defnewp = gettag("_default_new1", 1);
if (defp == NULL || defnewp == NULL)
err(1, "malloc");
TAILQ_FOREACH(e_defp, &defp->entrylist, q) {
slashp =
e_defp->s[strlen(e_defp->s) - 1] == '/' ? "" : "/";
TAILQ_FOREACH(e_subp, &subp->entrylist, q) {
if (!strncmp(e_subp->s, "cat", 3))
continue;
(void)snprintf(buf, sizeof(buf), "%s%s%s{/%s,}",
e_defp->s, slashp, e_subp->s, machine);
if (addentry(defnewp, buf, 0) < 0)
err(1, "malloc");
}
}
defp = defnewp;
}
/*
* 3: If the user set the -m option, insert the user's list before
* whatever list we have, again appending the _subdir list and
* the machine.
*/
if (m_add != NULL)
for (p = strtok(m_add, ":"); p != NULL; p = strtok(NULL, ":")) {
slashp = p[strlen(p) - 1] == '/' ? "" : "/";
TAILQ_FOREACH(e_subp, &subp->entrylist, q) {
if (!strncmp(e_subp->s, "cat", 3))
continue;
(void)snprintf(buf, sizeof(buf), "%s%s%s{/%s,}",
p, slashp, e_subp->s, machine);
if (addentry(defp, buf, 1) < 0)
err(1, "malloc");
}
}
}
/*
* Remove entries (directory) which are symbolic links to other entries.
* Some examples are showed below:
* 1) if /usr/X11 -> /usr/X11R6 then remove all /usr/X11/man entries.
* 2) if /usr/local/man -> /usr/share/man then remove all /usr/local/man
* entries
*/
static void
uniquepath(void)
{
TAG *defnewp;
ENTRY *e_defp;
glob_t manpaths;
struct stat st1;
struct stat st2;
struct stat st3;
int len, lnk, gflags;
size_t i, j;
char path[PATH_MAX], *p;
gflags = 0;
TAILQ_FOREACH(e_defp, &defp->entrylist, q) {
glob(e_defp->s, GLOB_BRACE | GLOB_NOSORT | gflags, NULL,
&manpaths);
gflags = GLOB_APPEND;
}
if ((defnewp = gettag("_default_new2", 1)) == NULL)
err(1, "malloc");
for (i = 0; i < manpaths.gl_pathc; i++) {
lnk = 0;
lstat(manpaths.gl_pathv[i], &st1);
for (j = 0; j < manpaths.gl_pathc; j++) {
if (i != j) {
lstat(manpaths.gl_pathv[j], &st2);
if (st1.st_ino == st2.st_ino) {
strlcpy(path, manpaths.gl_pathv[i],
sizeof(path));
for (p = path; *(p+1) != '\0';) {
p = dirname(p);
lstat(p, &st3);
if (S_ISLNK(st3.st_mode)) {
lnk = 1;
break;
}
}
} else {
len = readlink(manpaths.gl_pathv[i],
path, sizeof(path) - 1);
if (len == -1)
continue;
path[len] = '\0';
if (!strcmp(path, manpaths.gl_pathv[j]))
lnk = 1;
}
if (lnk)
break;
}
}
if (!lnk) {
if (addentry(defnewp, manpaths.gl_pathv[i], 0) < 0)
err(1, "malloc");
}
}
globfree(&manpaths);
defp = defnewp;
}
static void
catman(void)
{
ENTRY *e_path;
const char *mandir;
char catdir[PATH_MAX], *cp;
TAILQ_FOREACH(e_path, &defp->entrylist, q) {
mandir = e_path->s;
strlcpy(catdir, mandir, sizeof(catdir));
if (!(cp = strstr(catdir, "man/man")))
continue;
cp += 4; *cp++ = 'c'; *cp++ = 'a'; *cp = 't';
scanmandir(catdir, mandir);
}
}
static void
scanmandir(const char *catdir, const char *mandir)
{
TAG *buildp, *crunchp;
ENTRY *e_build, *e_crunch;
char manpage[2 * PATH_MAX];
char catpage[2 * PATH_MAX];
char linkname[PATH_MAX];
char buffer[PATH_MAX], *bp;
char tmp[2 * PATH_MAX];
char buildsuff[256], buildcmd[256];
char crunchsuff[256], crunchcmd[256];
char match[2 * 256];
struct stat manstat;
struct stat catstat;
struct stat lnkstat;
struct dirent *dp;
DIR *dirp;
int len, error;
if ((dirp = opendir(mandir)) == 0) {
warn("can't open %s", mandir);
return;
}
if (stat(catdir, &catstat) < 0) {
if (errno != ENOENT) {
warn("can't stat %s", catdir);
closedir(dirp);
return;
}
if (f_noprint == 0)
printf("mkdir %s\n", catdir);
if (f_noaction == 0 && mkdir(catdir, 0755) < 0) {
warn("can't create %s", catdir);
closedir(dirp);
return;
}
}
while ((dp = readdir(dirp)) != NULL) {
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
snprintf(manpage, sizeof(manpage), "%s/%s", mandir, dp->d_name);
snprintf(catpage, sizeof(catpage), "%s/%s", catdir, dp->d_name);
e_build = NULL;
if ((buildp = gettag("_build", 1)) == NULL)
err(1, "malloc");
TAILQ_FOREACH(e_build, &buildp->entrylist, q) {
splitentry(e_build->s, buildsuff, sizeof(buildsuff),
buildcmd, sizeof(buildcmd));
snprintf(match, sizeof(match), "*%s",
buildsuff);
if (!fnmatch(match, manpage, 0))
break;
}
if (e_build == NULL)
continue;
e_crunch = NULL;
if ((crunchp = gettag("_crunch", 1)) == NULL)
err(1, "malloc");
TAILQ_FOREACH(e_crunch, &crunchp->entrylist, q) {
splitentry(e_crunch->s, crunchsuff, sizeof(crunchsuff),
crunchcmd, sizeof(crunchcmd));
snprintf(match, sizeof(match), "*%s", crunchsuff);
if (!fnmatch(match, manpage, 0))
break;
}
if (lstat(manpage, &manstat) <0) {
warn("can't stat %s", manpage);
continue;
} else {
if (S_ISLNK(manstat.st_mode)) {
strlcpy(buffer, catpage, sizeof(buffer));
strlcpy(linkname, basename(buffer),
sizeof(linkname));
len = readlink(manpage, buffer,
sizeof(buffer) - 1);
if (len == -1) {
warn("can't stat read symbolic link %s",
manpage);
continue;
}
buffer[len] = '\0';
if (strcmp(buffer, basename(buffer)) == 0) {
bp = basename(buffer);
strlcpy(tmp, manpage, sizeof(tmp));
snprintf(manpage, sizeof(manpage),
"%s/%s", dirname(tmp), bp);
strlcpy(tmp, catpage, sizeof(tmp));
snprintf(catpage, sizeof(catpage),
"%s/%s", dirname(tmp), buffer);
} else {
*linkname = '\0';
}
}
else
*linkname = '\0';
}
if (!e_crunch) {
*crunchsuff = *crunchcmd = '\0';
}
setcatsuffix(catpage, buildsuff, crunchsuff);
if (*linkname != '\0')
setcatsuffix(linkname, buildsuff, crunchsuff);
if (stat(manpage, &manstat) < 0) {
warn("can't stat %s", manpage);
continue;
}
if (!S_ISREG(manstat.st_mode)) {
warnx("not a regular file %s", manpage);
continue;
}
if ((error = stat(catpage, &catstat)) &&
errno != ENOENT) {
warn("can't stat %s", catpage);
continue;
}
if ((error && errno == ENOENT) ||
manstat.st_mtime > catstat.st_mtime) {
if (f_noformat) {
dowhatis = 1;
} else {
/*
* reformat out of date manpage
*/
makecat(manpage, catpage, buildcmd, crunchcmd);
dowhatis = 1;
}
}
if (*linkname != '\0') {
strlcpy(tmp, catpage, sizeof(tmp));
snprintf(tmp, sizeof(tmp), "%s/%s", dirname(tmp),
linkname);
if ((error = lstat(tmp, &lnkstat)) &&
errno != ENOENT) {
warn("can't stat %s", tmp);
continue;
}
if (error && errno == ENOENT) {
if (f_noformat) {
dowhatis = 1;
} else {
/*
* create symbolic link
*/
if (f_noprint == 0)
printf("ln -s %s %s\n", catpage,
linkname);
if (f_noaction == 0) {
strlcpy(tmp, catpage,
sizeof(tmp));
if (chdir(dirname(tmp)) == -1) {
warn("can't chdir");
continue;
}
if (symlink(catpage, linkname)
== -1) {
warn("can't create"
" symbolic"
" link %s",
linkname);
continue;
}
}
dowhatis = 1;
}
}
}
}
closedir(dirp);
}
static int
splitentry(char *s, char *first, size_t firstlen, char *second,
size_t secondlen)
{
char *c;
for (c = s; *c != '\0' && !isspace((unsigned char)*c); ++c)
;
if (*c == '\0')
return(0);
if ((size_t)(c - s + 1) > firstlen)
return(0);
strncpy(first, s, c-s);
first[c-s] = '\0';
for (; *c != '\0' && isspace((unsigned char)*c); ++c)
;
if (strlcpy(second, c, secondlen) >= secondlen)
return(0);
return(1);
}
static void
setcatsuffix(char *catpage, const char *suffix, const char *crunchsuff)
{
TAG *tp;
char *p;
for (p = catpage + strlen(catpage); p != catpage; p--)
if (!fnmatch(suffix, p, 0)) {
if ((tp = gettag("_suffix", 1)) == NULL)
err(1, "malloc");
if (! TAILQ_EMPTY(&tp->entrylist)) {
sprintf(p, "%s%s",
TAILQ_FIRST(&tp->entrylist)->s, crunchsuff);
} else {
sprintf(p, ".0%s", crunchsuff);
}
break;
}
}
static void
makecat(const char *manpage, const char *catpage, const char *buildcmd,
const char *crunchcmd)
{
char crunchbuf[1024];
char sysbuf[2048 + 128];
size_t len;
len = snprintf(sysbuf, sizeof(sysbuf), buildcmd, manpage);
if (len > sizeof(sysbuf))
errx(1, "snprintf");
if (*crunchcmd != '\0') {
snprintf(crunchbuf, sizeof(crunchbuf), crunchcmd, catpage);
snprintf(sysbuf + len, sizeof(sysbuf) - len, " | %s",
crunchbuf);
} else {
snprintf(sysbuf + len, sizeof(sysbuf) - len, " > %s", catpage);
}
if (f_noprint == 0)
printf("%s\n", sysbuf);
if (f_noaction == 0)
dosystem(sysbuf);
}
static void
makewhatis(void)
{
TAG *whatdbp;
ENTRY *e_whatdb;
char sysbuf[1024];
if ((whatdbp = gettag("_whatdb", 1)) == NULL)
err(1, "malloc");
TAILQ_FOREACH(e_whatdb, &whatdbp->entrylist, q) {
snprintf(sysbuf, sizeof(sysbuf), "%s %s",
_PATH_MAKEWHATIS, dirname(e_whatdb->s));
if (f_noprint == 0)
printf("%s\n", sysbuf);
if (f_noaction == 0)
dosystem(sysbuf);
}
}
static void
dosystem(const char *cmd)
{
int status;
if ((status = system(cmd)) == 0)
return;
if (status == -1)
err(1, "cannot execute action");
if (WIFSIGNALED(status))
errx(1, "child was signaled to quit. aborting");
if (WIFSTOPPED(status))
errx(1, "child was stopped. aborting");
if (f_ignerr == 0)
errx(1, "*** Exited %d", status);
warnx("*** Exited %d (continuing)", status);
}
static void
usage(void)
{
(void)fprintf(stderr,
"usage: catman [-knpsw] [-m manpath] [sections]\n");
(void)fprintf(stderr,
" catman [-knpsw] [-M manpath] [sections]\n");
exit(1);
}
Reference in New Issue View Git Blame Copy Permalink