sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/commands/simple/man.c

695 lines
16 KiB
C
Executable file
Raw Blame History

/* man 2.5 - display online manual pages Author: Kees J. Bot
* 17 Mar 1993
*/
#define nil NULL
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <stdarg.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/wait.h>
/* Defaults: */
char MANPATH[]= "/usr/local/man:/usr/man:/usr/gnu/man";
char PAGER[]= "more";
/* Comment at the start to let tbl(1) be run before n/troff. */
char TBL_MAGIC[] = ".\\\"t\n";
#define arraysize(a) (sizeof(a) / sizeof((a)[0]))
#define arraylimit(a) ((a) + arraysize(a))
#define between(a, c, z) ((unsigned) ((c) - (a)) <= (unsigned) ((z) - (a)))
/* Section 1x uses special macros under Minix. */
#if __minix
#define SEC1xSPECIAL 1
#else
#define SEC1xSPECIAL 0
#endif
int searchwhatis(FILE *wf, char *title, char **ppage, char **psection)
/* Search a whatis file for the next occurence of "title". Return the basename
* of the page to read and the section it is in. Return 0 on failure, 1 on
* success, -1 on EOF or error.
*/
{
static char page[256], section[32];
char alias[256];
int found= 0;
int c;
/* Each whatis line should have the format:
* page, title, title (section) - descriptive text
*/
/* Search the file for a line with the title. */
do {
int first= 1;
char *pc= section;
c= fgetc(wf);
/* Search the line for the title. */
do {
char *pa= alias;
while (c == ' ' || c == '\t' || c == ',') c= fgetc(wf);
while (c != ' ' && c != '\t' && c != ','
&& c != '(' && c != '\n' && c != EOF
) {
if (pa < arraylimit(alias)-1) *pa++= c;
c= getc(wf);
}
*pa= 0;
if (first) { strcpy(page, alias); first= 0; }
if (strcmp(alias, title) == 0) found= 1;
} while (c != '(' && c != '\n' && c != EOF);
if (c != '(') {
found= 0;
} else {
while ((c= fgetc(wf)) != ')' && c != '\n' && c != EOF) {
if ('A' <= c && c <= 'Z') c= c - 'A' + 'a';
if (pc < arraylimit(section)-1) *pc++= c;
}
*pc= 0;
if (c != ')' || pc == section) found= 0;
}
while (c != EOF && c != '\n') c= getc(wf);
} while (!found && c != EOF);
if (found) {
*ppage= page;
*psection= section;
}
return c == EOF ? -1 : found;
}
int searchwindex(FILE *wf, char *title, char **ppage, char **psection)
/* Search a windex file for the next occurence of "title". Return the basename
* of the page to read and the section it is in. Return 0 on failure, 1 on
* success, -1 on EOF or error.
*/
{
static char page[256], section[32];
static long low, high;
long mid0, mid1;
int c;
unsigned char *pt;
char *pc;
/* Each windex line should have the format:
* title page (section) - descriptive text
* The file is sorted.
*/
if (ftell(wf) == 0) {
/* First read of this file, initialize. */
low= 0;
fseek(wf, (off_t) 0, SEEK_END);
high= ftell(wf);
}
/* Binary search for the title. */
while (low <= high) {
pt= (unsigned char *) title;
mid0= mid1= (low + high) >> 1;
if (mid0 == 0) {
if (fseek(wf, (off_t) 0, SEEK_SET) != 0)
return -1;
} else {
if (fseek(wf, (off_t) mid0 - 1, SEEK_SET) != 0)
return -1;
/* Find the start of a line. */
while ((c= getc(wf)) != EOF && c != '\n')
mid1++;
if (ferror(wf)) return -1;
}
/* See if the line has the title we seek. */
for (;;) {
if ((c= getc(wf)) == ' ' || c == '\t') c= 0;
if (c == 0 || c != *pt) break;
pt++;
}
/* Halve the search range. */
if (c == EOF || *pt <= c) {
high= mid0 - 1;
} else {
low= mid1 + 1;
}
}
/* Look for the title from 'low' onwards. */
if (fseek(wf, (off_t) low, SEEK_SET) != 0)
return -1;
do {
if (low != 0) {
/* Find the start of a line. */
while ((c= getc(wf)) != EOF && c != '\n')
low++;
if (ferror(wf)) return -1;
}
/* See if the line has the title we seek. */
pt= (unsigned char *) title;
for (;;) {
if ((c= getc(wf)) == EOF) return 0;
low++;
if (c == ' ' || c == '\t') c= 0;
if (c == 0 || c != *pt) break;
pt++;
}
} while (c < *pt);
if (*pt != c) return 0; /* Not found. */
/* Get page and section. */
while ((c= fgetc(wf)) == ' ' || c == '\t') {}
pc= page;
while (c != ' ' && c != '\t' && c != '(' && c != '\n' && c != EOF) {
if (pc < arraylimit(page)-1) *pc++= c;
c= getc(wf);
}
if (pc == page) return 0;
*pc= 0;
while (c == ' ' || c == '\t') c= fgetc(wf);
if (c != '(') return 0;
pc= section;
while ((c= fgetc(wf)) != ')' && c != '\n' && c != EOF) {
if ('A' <= c && c <= 'Z') c= c - 'A' + 'a';
if (pc < arraylimit(section)-1) *pc++= c;
}
*pc= 0;
if (c != ')' || pc == section) return 0;
while (c != EOF && c != '\n') c= getc(wf);
if (c != '\n') return 0;
*ppage= page;
*psection= section;
return 1;
}
char ALL[]= ""; /* Magic sequence of all sections. */
int all= 0; /* Show all pages with a given title. */
int whatis= 0; /* man -f word == whatis word. */
int apropos= 0; /* man -k word == apropos word. */
int quiet= 0; /* man -q == quietly check. */
enum ROFF { NROFF, TROFF } rofftype= NROFF;
char *roff[] = { "nroff", "troff" };
int shown; /* True if something has been shown. */
int tty; /* True if displaying on a terminal. */
char *manpath; /* The manual directory path. */
char *pager; /* The pager to use. */
char *pipeline[8][8]; /* An 8 command pipeline of 7 arguments each. */
char *(*plast)[8] = pipeline;
void putinline(char *arg1, ...)
/* Add a command to the pipeline. */
{
va_list ap;
char **argv;
argv= *plast++;
*argv++= arg1;
va_start(ap, arg1);
while ((*argv++= va_arg(ap, char *)) != nil) {}
va_end(ap);
}
void execute(int set_mp, char *file)
/* Execute the pipeline build with putinline(). (This is a lot of work to
* avoid a call to system(), but it so much fun to do it right!)
*/
{
char *(*plp)[8], **argv;
char *mp;
int fd0, pfd[2], err[2];
pid_t pid;
int r, status;
int last;
void (*isav)(int sig), (*qsav)(int sig), (*tsav)(int sig);
if (tty) {
/* Must run this through a pager. */
putinline(pager, (char *) nil);
}
if (plast == pipeline) {
/* No commands at all? */
putinline("cat", (char *) nil);
}
/* Add the file as argument to the first command. */
argv= pipeline[0];
while (*argv != nil) argv++;
*argv++= file;
*argv= nil;
/* Start the commands. */
fd0= 0;
for (plp= pipeline; plp < plast; plp++) {
argv= *plp;
last= (plp+1 == plast);
/* Create an error pipe and pipe between this command and the next. */
if (pipe(err) < 0 || (!last && pipe(pfd) < 0)) {
fprintf(stderr, "man: can't create a pipe: %s\n", strerror(errno));
exit(1);
}
(void) fcntl(err[1], F_SETFD, fcntl(err[1], F_GETFD) | FD_CLOEXEC);
if ((pid = fork()) < 0) {
fprintf(stderr, "man: cannot fork: %s\n", strerror(errno));
exit(1);
}
if (pid == 0) {
/* Child. */
if (set_mp) {
mp= malloc((8 + strlen(manpath) + 1) * sizeof(*mp));
if (mp != nil) {
strcpy(mp, "MANPATH=");
strcat(mp, manpath);
(void) putenv(mp);
}
}
if (fd0 != 0) {
dup2(fd0, 0);
close(fd0);
}
if (!last) {
close(pfd[0]);
if (pfd[1] != 1) {
dup2(pfd[1], 1);
close(pfd[1]);
}
}
close(err[0]);
execvp(argv[0], argv);
(void) write(err[1], &errno, sizeof(errno));
_exit(1);
}
close(err[1]);
if (read(err[0], &errno, sizeof(errno)) != 0) {
fprintf(stderr, "man: %s: %s\n", argv[0],
strerror(errno));
exit(1);
}
close(err[0]);
if (!last) {
close(pfd[1]);
fd0= pfd[0];
}
set_mp= 0;
}
/* Wait for the last command to finish. */
isav= signal(SIGINT, SIG_IGN);
qsav= signal(SIGQUIT, SIG_IGN);
tsav= signal(SIGTERM, SIG_IGN);
while ((r= wait(&status)) != pid) {
if (r < 0) {
fprintf(stderr, "man: wait(): %s\n", strerror(errno));
exit(1);
}
}
(void) signal(SIGINT, isav);
(void) signal(SIGQUIT, qsav);
(void) signal(SIGTERM, tsav);
if (status != 0) exit(1);
plast= pipeline;
}
void keyword(char *keyword)
/* Make an apropos(1) or whatis(1) call. */
{
putinline(apropos ? "apropos" : "whatis",
all ? "-a" : (char *) nil,
(char *) nil);
if (tty) {
printf("Looking for keyword '%s'\n", keyword);
fflush(stdout);
}
execute(1, keyword);
}
enum pagetype { CAT, CATZ, MAN, MANZ, SMAN, SMANZ };
int showpage(char *page, enum pagetype ptype, char *macros)
/* Show a manual page if it exists using the proper decompression and
* formatting tools.
*/
{
struct stat st;
/* We want a normal file without X bits if not a full path. */
if (stat(page, &st) < 0) return 0;
if (!S_ISREG(st.st_mode)) return 0;
if ((st.st_mode & 0111) && page[0] != '/') return 0;
/* Do we only care if it exists? */
if (quiet) { shown= 1; return 1; }
if (ptype == CATZ || ptype == MANZ || ptype == SMANZ) {
putinline("zcat", (char *) nil);
}
if (ptype == SMAN || ptype == SMANZ) {
/* Change SGML into regular *roff. */
putinline("/usr/lib/sgml/sgml2roff", (char *) nil);
putinline("tbl", (char *) nil);
putinline("eqn", (char *) nil);
}
if (ptype == MAN) {
/* Do we need tbl? */
FILE *fp;
int c;
char *tp = TBL_MAGIC;
if ((fp = fopen(page, "r")) == nil) {
fprintf(stderr, "man: %s: %s\n", page, strerror(errno));
exit(1);
}
c= fgetc(fp);
for (;;) {
if (c == *tp || (c == '\'' && *tp == '.')) {
if (*++tp == 0) {
/* A match, add tbl. */
putinline("tbl", (char *) nil);
break;
}
} else {
/* No match. */
break;
}
while ((c = fgetc(fp)) == ' ' || c == '\t') {}
}
fclose(fp);
}
if (ptype == MAN || ptype == MANZ || ptype == SMAN || ptype == SMANZ) {
putinline(roff[rofftype], macros, (char *) nil);
}
if (tty) {
printf("%s %s\n",
ptype == CAT || ptype == CATZ ? "Showing" : "Formatting", page);
fflush(stdout);
}
execute(0, page);
shown= 1;
return 1;
}
int member(char *word, char *list)
/* True if word is a member of a comma separated list. */
{
size_t len= strlen(word);
if (list == ALL) return 1;
while (*list != 0) {
if (strncmp(word, list, len) == 0
&& (list[len] == 0 || list[len] == ','))
return 1;
while (*list != 0 && *list != ',') list++;
if (*list == ',') list++;
}
return 0;
}
int trymandir(char *mandir, char *title, char *section)
/* Search the whatis file of the manual directory for a page of the given
* section and display it.
*/
{
FILE *wf;
char whatis[1024], pagename[1024], *wpage, *wsection;
int rsw, rsp;
int ntries;
int (*searchidx)(FILE *, char *, char **, char **);
struct searchnames {
enum pagetype ptype;
char *pathfmt;
} *sp;
static struct searchnames searchN[] = {
{ CAT, "%s/cat%s/%s.%s" }, /* SysV */
{ CATZ, "%s/cat%s/%s.%s.Z" },
{ MAN, "%s/man%s/%s.%s" },
{ MANZ, "%s/man%s/%s.%s.Z" },
{ SMAN, "%s/sman%s/%s.%s" }, /* Solaris */
{ SMANZ,"%s/sman%s/%s.%s.Z" },
{ CAT, "%s/cat%.1s/%s.%s" }, /* BSD */
{ CATZ, "%s/cat%.1s/%s.%s.Z" },
{ MAN, "%s/man%.1s/%s.%s" },
{ MANZ, "%s/man%.1s/%s.%s.Z" },
};
if (strlen(mandir) + 1 + 6 + 1 > arraysize(whatis)) return 0;
/* Prefer a fast windex database if available. */
sprintf(whatis, "%s/windex", mandir);
if ((wf= fopen(whatis, "r")) != nil) {
searchidx= searchwindex;
} else {
/* Use a classic whatis database. */
sprintf(whatis, "%s/whatis", mandir);
if ((wf= fopen(whatis, "r")) == nil) return 0;
searchidx= searchwhatis;
}
rsp= 0;
while (!rsp && (rsw= (*searchidx)(wf, title, &wpage, &wsection)) == 1) {
if (!member(wsection, section)) continue;
/* When looking for getc(1S) we try:
* cat1s/getc.1s
* cat1s/getc.1s.Z
* man1s/getc.1s
* man1s/getc.1s.Z
* sman1s/getc.1s
* sman1s/getc.1s.Z
* cat1/getc.1s
* cat1/getc.1s.Z
* man1/getc.1s
* man1/getc.1s.Z
*/
if (strlen(mandir) + 2 * strlen(wsection) + strlen(wpage)
+ 10 > arraysize(pagename))
continue;
sp= searchN;
ntries= arraysize(searchN);
do {
if (sp->ptype <= CATZ && rofftype != NROFF)
continue;
sprintf(pagename, sp->pathfmt,
mandir, wsection, wpage, wsection);
rsp= showpage(pagename, sp->ptype,
(SEC1xSPECIAL && strcmp(wsection, "1x") == 0) ? "-mnx" : "-man");
} while (sp++, !rsp && --ntries != 0);
if (all) rsp= 0;
}
if (rsw < 0 && ferror(wf)) {
fprintf(stderr, "man: %s: %s\n", whatis, strerror(errno));
exit(1);
}
fclose(wf);
return rsp;
}
int trysubmandir(char *mandir, char *title, char *section)
/* Search the subdirectories of this manual directory for whatis files, they
* may have manual pages that override the ones in the major directory.
*/
{
char submandir[1024];
DIR *md;
struct dirent *entry;
if ((md= opendir(mandir)) == nil) return 0;
while ((entry= readdir(md)) != nil) {
if (strcmp(entry->d_name, ".") == 0
|| strcmp(entry->d_name, "..") == 0) continue;
if ((strncmp(entry->d_name, "man", 3) == 0
|| strncmp(entry->d_name, "cat", 3) == 0)
&& between('0', entry->d_name[3], '9')) continue;
if (strlen(mandir) + 1 + strlen(entry->d_name) + 1
> arraysize(submandir)) continue;
sprintf(submandir, "%s/%s", mandir, entry->d_name);
if (trymandir(submandir, title, section) && !all) {
closedir(md);
return 1;
}
}
closedir(md);
return 0;
}
void searchmanpath(char *title, char *section)
/* Search the manual path for a manual page describing "title." */
{
char mandir[1024];
char *pp= manpath, *pd;
for (;;) {
while (*pp != 0 && *pp == ':') pp++;
if (*pp == 0) break;
pd= mandir;
while (*pp != 0 && *pp != ':') {
if (pd < arraylimit(mandir)) *pd++= *pp;
pp++;
}
if (pd == arraylimit(mandir)) continue; /* forget it */
*pd= 0;
if (trysubmandir(mandir, title, section) && !all) break;
if (trymandir(mandir, title, section) && !all) break;
}
}
void usage(void)
{
fprintf(stderr, "Usage: man -[antfkq] [-M path] [-s section] title ...\n");
exit(1);
}
int main(int argc, char **argv)
{
char *title, *section= ALL;
int i;
int nomoreopt= 0;
char *opt;
if ((pager= getenv("PAGER")) == nil) pager= PAGER;
if ((manpath= getenv("MANPATH")) == nil) manpath= MANPATH;
tty= isatty(1);
i= 1;
do {
while (i < argc && argv[i][0] == '-' && !nomoreopt) {
opt= argv[i++]+1;
if (opt[0] == '-' && opt[1] == 0) {
nomoreopt= 1;
break;
}
while (*opt != 0) {
switch (*opt++) {
case 'a':
all= 1;
break;
case 'f':
whatis= 1;
break;
case 'k':
apropos= 1;
break;
case 'q':
quiet= 1;
break;
case 'n':
rofftype= NROFF;
apropos= whatis= 0;
break;
case 't':
rofftype= TROFF;
apropos= whatis= 0;
break;
case 's':
if (*opt == 0) {
if (i == argc) usage();
section= argv[i++];
} else {
section= opt;
opt= "";
}
break;
case 'M':
if (*opt == 0) {
if (i == argc) usage();
manpath= argv[i++];
} else {
manpath= opt;
opt= "";
}
break;
default:
usage();
}
}
}
if (i >= argc) usage();
if (between('0', argv[i][0], '9') && i+1 < argc) {
/* Old BSD style section designation? */
section= argv[i++];
}
if (i == argc) usage();
title= argv[i++];
if (whatis || apropos) {
keyword(title);
} else {
shown= 0;
searchmanpath(title, section);
if (!shown) (void) showpage(title, MAN, "-man");
if (!shown) {
if (!quiet) {
fprintf(stderr,
"man: no manual on %s\n",
title);
}
exit(1);
}
}
} while (i < argc);
return 0;
}
Reference in a new issue View git blame Copy permalink