xref: /illumos-gate/usr/src/cmd/man/makewhatis.c (revision 186c806e1377410853ef84873c5f064d8e980262)
1 /*
2  * Copyright (c) 2002 John Rochester
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    in this position and unchanged.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 /*
30  * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
31  * Copyright 2014 Garrett D'Amore <garrett@damore.org>
32  * Copyright 2022 Oxide Computer Company
33  */
34 
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <sys/param.h>
38 
39 #include <ctype.h>
40 #include <dirent.h>
41 #include <err.h>
42 #include <signal.h>
43 #include <stddef.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <unistd.h>
48 
49 #include "man.h"
50 #include "stringlist.h"
51 
52 
53 /* Information collected about each man page in a section */
54 struct page_info {
55 	char	*filename;
56 	char	*name;
57 	char	*suffix;
58 	ino_t	inode;
59 };
60 
61 /* An expanding string */
62 struct sbuf {
63 	char	*content;	/* the start of the buffer */
64 	char	*end;		/* just past the end of the content */
65 	char	*last;		/* the last allocated character */
66 };
67 
68 /* Remove the last amount characters from the sbuf */
69 #define	sbuf_retract(sbuf, amount) ((sbuf)->end -= (amount))
70 /* Return the length of the sbuf content */
71 #define	sbuf_length(sbuf) ((sbuf)->end - (sbuf)->content)
72 
73 typedef char *edited_copy(char *from, char *to, int length);
74 
75 /*
76  * While the whatis line is being formed, it is stored in whatis_proto.
77  * When finished, it is reformatted into whatis_final and then appended
78  * to whatis_lines.
79  */
80 static struct sbuf	*whatis_proto;
81 static struct sbuf	*whatis_final;
82 static stringlist	*whatis_lines;	/* collected output lines */
83 
84 static char tempfile[MAXPATHLEN];	/* path of temporary file, if any */
85 
86 #define	MDOC_COMMANDS	"ArDvErEvFlLiNmPa"
87 
88 
89 /* Free a struct page_info and its content */
90 static void
free_page_info(struct page_info * info)91 free_page_info(struct page_info *info)
92 {
93 
94 	free(info->filename);
95 	free(info->name);
96 	free(info->suffix);
97 	free(info);
98 }
99 
100 /*
101  * Allocate and fill in a new struct page_info given the
102  * name of the man section directory and the dirent of the file.
103  * If the file is not a man page, return NULL.
104  */
105 static struct page_info *
new_page_info(char * dir,struct dirent * dirent)106 new_page_info(char *dir, struct dirent *dirent)
107 {
108 	struct page_info *info;
109 	int		basename_length;
110 	char		*suffix;
111 	struct stat	st;
112 
113 	if ((info = malloc(sizeof (struct page_info))) == NULL)
114 		err(1, "malloc");
115 	basename_length = strlen(dirent->d_name);
116 	suffix = &dirent->d_name[basename_length];
117 	if (asprintf(&info->filename, "%s/%s", dir, dirent->d_name) == -1)
118 		err(1, "asprintf");
119 	for (;;) {
120 		if (--suffix == dirent->d_name || !isalnum(*suffix)) {
121 			if (*suffix == '.')
122 				break;
123 			free(info->filename);
124 			free(info);
125 			return (NULL);
126 		}
127 	}
128 	*suffix++ = '\0';
129 	info->name = strdup(dirent->d_name);
130 	info->suffix = strdup(suffix);
131 	if (stat(info->filename, &st) < 0) {
132 		warn("%s", info->filename);
133 		free_page_info(info);
134 		return (NULL);
135 	}
136 	if (!S_ISREG(st.st_mode)) {
137 		free_page_info(info);
138 		return (NULL);
139 	}
140 	info->inode = st.st_ino;
141 	return (info);
142 }
143 
144 /*
145  * Reset sbuf length to 0.
146  */
147 static void
sbuf_clear(struct sbuf * sbuf)148 sbuf_clear(struct sbuf *sbuf)
149 {
150 
151 	sbuf->end = sbuf->content;
152 }
153 
154 /*
155  * Allocate a new sbuf.
156  */
157 static struct sbuf *
new_sbuf(void)158 new_sbuf(void)
159 {
160 	struct sbuf	*sbuf;
161 
162 	if ((sbuf = malloc(sizeof (struct sbuf))) == NULL)
163 		err(1, "malloc");
164 	if ((sbuf->content = (char *)malloc(LINE_ALLOC)) == NULL)
165 		err(1, "malloc");
166 	sbuf->last = sbuf->content + LINE_ALLOC - 1;
167 	sbuf_clear(sbuf);
168 
169 	return (sbuf);
170 }
171 
172 /*
173  * Ensure that there is enough room in the sbuf
174  * for nchars more characters.
175  */
176 static void
sbuf_need(struct sbuf * sbuf,int nchars)177 sbuf_need(struct sbuf *sbuf, int nchars)
178 {
179 	char *new_content;
180 	size_t size, cntsize;
181 	size_t grow = 128;
182 
183 	while (grow < nchars) {
184 		grow += 128;	/* we grow in chunks of 128 bytes */
185 	}
186 
187 	/* Grow if the buffer isn't big enough */
188 	if (sbuf->end + nchars > sbuf->last) {
189 		size = sbuf->last + 1 - sbuf->content;
190 		size += grow;
191 		cntsize = sbuf->end - sbuf->content;
192 
193 		if ((new_content = realloc(sbuf->content, size)) == NULL) {
194 			perror("realloc");
195 			if (tempfile[0] != '\0')
196 				(void) unlink(tempfile);
197 			exit(1);
198 		}
199 		sbuf->content = new_content;
200 		sbuf->end = new_content + cntsize;
201 		sbuf->last = new_content + size - 1;
202 	}
203 }
204 
205 /*
206  * Append a string of a given length to the sbuf.
207  */
208 static void
sbuf_append(struct sbuf * sbuf,const char * text,int length)209 sbuf_append(struct sbuf *sbuf, const char *text, int length)
210 {
211 	if (length > 0) {
212 		sbuf_need(sbuf, length);
213 		(void) memcpy(sbuf->end, text, length);
214 		sbuf->end += length;
215 	}
216 }
217 
218 /*
219  * Append a null-terminated string to the sbuf.
220  */
221 static void
sbuf_append_str(struct sbuf * sbuf,char * text)222 sbuf_append_str(struct sbuf *sbuf, char *text)
223 {
224 
225 	sbuf_append(sbuf, text, strlen(text));
226 }
227 
228 /*
229  * Append an edited null-terminated string to the sbuf.
230  */
231 static void
sbuf_append_edited(struct sbuf * sbuf,char * text,edited_copy copy)232 sbuf_append_edited(struct sbuf *sbuf, char *text, edited_copy copy)
233 {
234 	int	length;
235 
236 	if ((length = strlen(text)) > 0) {
237 		sbuf_need(sbuf, length);
238 		sbuf->end = copy(text, sbuf->end, length);
239 	}
240 }
241 
242 /*
243  * Strip any of a set of chars from the end of the sbuf.
244  */
245 static void
sbuf_strip(struct sbuf * sbuf,const char * set)246 sbuf_strip(struct sbuf *sbuf, const char *set)
247 {
248 
249 	while (sbuf->end > sbuf->content && strchr(set, sbuf->end[-1]) != NULL)
250 		sbuf->end--;
251 }
252 
253 /*
254  * Return the null-terminated string built by the sbuf.
255  */
256 static char *
sbuf_content(struct sbuf * sbuf)257 sbuf_content(struct sbuf *sbuf)
258 {
259 
260 	*sbuf->end = '\0';
261 	return (sbuf->content);
262 }
263 
264 /*
265  * Return true if no man page exists in the directory with
266  * any of the names in the stringlist.
267  */
268 static int
no_page_exists(char * dir,stringlist * names,char * suffix)269 no_page_exists(char *dir, stringlist *names, char *suffix)
270 {
271 	char	path[MAXPATHLEN];
272 	char	*suffixes[] = { "", ".gz", ".bz2", NULL };
273 	size_t	i;
274 	int	j;
275 
276 	for (i = 0; i < names->sl_cur; i++) {
277 		for (j = 0; suffixes[j] != NULL; j++) {
278 			(void) snprintf(path, MAXPATHLEN, "%s/%s.%s%s",
279 			    dir, names->sl_str[i], suffix, suffixes[j]);
280 			if (access(path, F_OK) == 0) {
281 				return (0);
282 			}
283 		}
284 	}
285 	return (1);
286 }
287 
288 /* ARGSUSED sig */
289 static void
trap_signal(int sig)290 trap_signal(int sig)
291 {
292 
293 	if (tempfile[0] != '\0')
294 		(void) unlink(tempfile);
295 
296 	exit(1);
297 }
298 
299 /*
300  * Attempt to open an output file.
301  * Return NULL if unsuccessful.
302  */
303 static FILE *
open_output(char * name)304 open_output(char *name)
305 {
306 	FILE	*output;
307 
308 	whatis_lines = sl_init();
309 	(void) snprintf(tempfile, MAXPATHLEN, "%s.tmp", name);
310 	name = tempfile;
311 	if ((output = fopen(name, "w")) == NULL) {
312 		warn("%s", name);
313 		return (NULL);
314 	}
315 	return (output);
316 }
317 
318 static int
linesort(const void * a,const void * b)319 linesort(const void *a, const void *b)
320 {
321 
322 	return (strcmp((*(const char * const *)a), (*(const char * const *)b)));
323 }
324 
325 /*
326  * Write the unique sorted lines to the output file.
327  */
328 static void
finish_output(FILE * output,char * name)329 finish_output(FILE *output, char *name)
330 {
331 	size_t	i;
332 	char	*prev = NULL;
333 
334 	qsort(whatis_lines->sl_str, whatis_lines->sl_cur, sizeof (char *),
335 	    linesort);
336 	for (i = 0; i < whatis_lines->sl_cur; i++) {
337 		char *line = whatis_lines->sl_str[i];
338 		if (i > 0 && strcmp(line, prev) == 0)
339 			continue;
340 		prev = line;
341 		(void) fputs(line, output);
342 		(void) putc('\n', output);
343 	}
344 	(void) fclose(output);
345 	sl_free(whatis_lines, 1);
346 	(void) rename(tempfile, name);
347 	(void) unlink(tempfile);
348 }
349 
350 static FILE *
open_whatis(char * mandir)351 open_whatis(char *mandir)
352 {
353 	char	filename[MAXPATHLEN];
354 
355 	(void) snprintf(filename, MAXPATHLEN, "%s/%s", mandir, WHATIS);
356 	return (open_output(filename));
357 }
358 
359 static void
finish_whatis(FILE * output,char * mandir)360 finish_whatis(FILE *output, char *mandir)
361 {
362 	char	filename[MAXPATHLEN];
363 
364 	(void) snprintf(filename, MAXPATHLEN, "%s/%s", mandir, WHATIS);
365 	finish_output(output, filename);
366 }
367 
368 /*
369  * Remove trailing spaces from a string, returning a pointer to just
370  * beyond the new last character.
371  */
372 static char *
trim_rhs(char * str)373 trim_rhs(char *str)
374 {
375 	char	*rhs;
376 
377 	rhs = &str[strlen(str)];
378 	while (--rhs > str && isspace(*rhs))
379 		;
380 	*++rhs = '\0';
381 	return (rhs);
382 }
383 
384 /*
385  * Return a pointer to the next non-space character in the string.
386  */
387 static char *
skip_spaces(char * s)388 skip_spaces(char *s)
389 {
390 
391 	while (*s != '\0' && isspace(*s))
392 		s++;
393 
394 	return (s);
395 }
396 
397 /*
398  * Return whether the line is of one of the forms:
399  *	.Sh NAME
400  *	.Sh "NAME"
401  *	etc.
402  * assuming that section_start is ".Sh".
403  */
404 static int
name_section_line(char * line,const char * section_start)405 name_section_line(char *line, const char *section_start)
406 {
407 	char		*rhs;
408 
409 	if (strncmp(line, section_start, 3) != 0)
410 		return (0);
411 	line = skip_spaces(line + 3);
412 	rhs = trim_rhs(line);
413 	if (*line == '"') {
414 		line++;
415 		if (*--rhs == '"')
416 			*rhs = '\0';
417 	}
418 	if (strcmp(line, "NAME") == 0)
419 		return (1);
420 
421 	return (0);
422 }
423 
424 /*
425  * Copy characters while removing the most common nroff/troff markup:
426  *	\(em, \(mi, \s[+-N], \&
427  *	\fF, \f(fo, \f[font]
428  *	\*s, \*(st, \*[stringvar]
429  */
430 static char *
de_nroff_copy(char * from,char * to,int fromlen)431 de_nroff_copy(char *from, char *to, int fromlen)
432 {
433 	char	*from_end = &from[fromlen];
434 
435 	while (from < from_end) {
436 		switch (*from) {
437 		case '\\':
438 			switch (*++from) {
439 			case '(':
440 				if (strncmp(&from[1], "em", 2) == 0 ||
441 				    strncmp(&from[1], "mi", 2) == 0) {
442 					from += 3;
443 					continue;
444 				}
445 				break;
446 			case 's':
447 				if (*++from == '-')
448 					from++;
449 				while (isdigit(*from))
450 					from++;
451 				continue;
452 			case 'f':
453 			case '*':
454 				if (*++from == '(') {
455 					from += 3;
456 				} else if (*from == '[') {
457 					while (*++from != ']' &&
458 					    from < from_end)
459 						;
460 					from++;
461 				} else {
462 					from++;
463 				}
464 				continue;
465 			case '&':
466 				from++;
467 				continue;
468 			}
469 			break;
470 		}
471 		*to++ = *from++;
472 	}
473 	return (to);
474 }
475 
476 /*
477  * Append a string with the nroff formatting removed.
478  */
479 static void
add_nroff(char * text)480 add_nroff(char *text)
481 {
482 
483 	sbuf_append_edited(whatis_proto, text, de_nroff_copy);
484 }
485 
486 /*
487  * Appends "name(suffix), " to whatis_final
488  */
489 static void
add_whatis_name(char * name,char * suffix)490 add_whatis_name(char *name, char *suffix)
491 {
492 
493 	if (*name != '\0') {
494 		sbuf_append_str(whatis_final, name);
495 		sbuf_append(whatis_final, "(", 1);
496 		sbuf_append_str(whatis_final, suffix);
497 		sbuf_append(whatis_final, "), ", 3);
498 	}
499 }
500 
501 /*
502  * Processes an old-style man(7) line. This ignores commands with only
503  * a single number argument.
504  */
505 static void
process_man_line(char * line)506 process_man_line(char *line)
507 {
508 	char	*p;
509 
510 	if (*line == '.') {
511 		while (isalpha(*++line))
512 			;
513 		p = line = skip_spaces(line);
514 		while (*p != '\0') {
515 			if (!isdigit(*p))
516 				break;
517 			p++;
518 		}
519 		if (*p == '\0')
520 			return;
521 	} else
522 		line = skip_spaces(line);
523 	if (*line != '\0') {
524 		add_nroff(line);
525 		sbuf_append(whatis_proto, " ", 1);
526 	}
527 }
528 
529 /*
530  * Processes a new-style mdoc(7) line.
531  */
532 static void
process_mdoc_line(char * line)533 process_mdoc_line(char *line)
534 {
535 	int	xref;
536 	int	arg = 0;
537 	char	*line_end = &line[strlen(line)];
538 	int	orig_length = sbuf_length(whatis_proto);
539 	char	*next;
540 
541 	if (*line == '\0')
542 		return;
543 	if (line[0] != '.' || !isupper(line[1]) || !islower(line[2])) {
544 		add_nroff(skip_spaces(line));
545 		sbuf_append(whatis_proto, " ", 1);
546 		return;
547 	}
548 	xref = strncmp(line, ".Xr", 3) == 0;
549 	line += 3;
550 	while ((line = skip_spaces(line)) < line_end) {
551 		if (*line == '"') {
552 			next = ++line;
553 			for (;;) {
554 				next = strchr(next, '"');
555 				if (next == NULL)
556 					break;
557 				(void) memmove(next, next + 1, strlen(next));
558 				line_end--;
559 				if (*next != '"')
560 					break;
561 				next++;
562 			}
563 		} else {
564 			next = strpbrk(line, " \t");
565 		}
566 		if (next != NULL)
567 			*next++ = '\0';
568 		else
569 			next = line_end;
570 		if (isupper(*line) && islower(line[1]) && line[2] == '\0') {
571 			if (strcmp(line, "Ns") == 0) {
572 				arg = 0;
573 				line = next;
574 				continue;
575 			}
576 			if (strstr(line, MDOC_COMMANDS) != NULL) {
577 				line = next;
578 				continue;
579 			}
580 		}
581 		if (arg > 0 && strchr(",.:;?!)]", *line) == 0) {
582 			if (xref) {
583 				sbuf_append(whatis_proto, "(", 1);
584 				add_nroff(line);
585 				sbuf_append(whatis_proto, ")", 1);
586 				xref = 0;
587 			} else {
588 				sbuf_append(whatis_proto, " ", 1);
589 			}
590 		}
591 		add_nroff(line);
592 		arg++;
593 		line = next;
594 	}
595 	if (sbuf_length(whatis_proto) > orig_length)
596 		sbuf_append(whatis_proto, " ", 1);
597 }
598 
599 /*
600  * Collect a list of comma-separated names from the text.
601  */
602 static void
collect_names(stringlist * names,char * text)603 collect_names(stringlist *names, char *text)
604 {
605 	char	*arg;
606 
607 	for (;;) {
608 		arg = text;
609 		text = strchr(text, ',');
610 		if (text != NULL)
611 			*text++ = '\0';
612 		(void) sl_add(names, arg);
613 		if (text == NULL)
614 			return;
615 		if (*text == ' ')
616 			text++;
617 	}
618 }
619 
620 enum { STATE_UNKNOWN, STATE_MANSTYLE, STATE_MDOCNAME, STATE_MDOCDESC };
621 
622 /*
623  * Process a man page source into a single whatis line and add it
624  * to whatis_lines.
625  */
626 static void
process_page(struct page_info * page,char * section_dir)627 process_page(struct page_info *page, char *section_dir)
628 {
629 	FILE		*fp;
630 	stringlist	*names;
631 	char		*descr;
632 	int		state = STATE_UNKNOWN;
633 	size_t		i;
634 	char		*line = NULL;
635 	size_t		linecap = 0;
636 
637 	sbuf_clear(whatis_proto);
638 	if ((fp = fopen(page->filename, "r")) == NULL) {
639 		warn("%s", page->filename);
640 		return;
641 	}
642 	while (getline(&line, &linecap, fp) > 0) {
643 		/* Skip comments */
644 		if (strncmp(line, ".\\\"", 3) == 0)
645 			continue;
646 		switch (state) {
647 		/* Haven't reached the NAME section yet */
648 		case STATE_UNKNOWN:
649 			if (name_section_line(line, ".SH"))
650 				state = STATE_MANSTYLE;
651 			else if (name_section_line(line, ".Sh"))
652 				state = STATE_MDOCNAME;
653 			continue;
654 		/* Inside an old-style .SH NAME section */
655 		case STATE_MANSTYLE: {
656 			char *altline;
657 
658 			if (strncmp(line, ".SH", 3) == 0 ||
659 			    strncmp(line, ".SS", 3) == 0)
660 				break;
661 			(void) trim_rhs(line);
662 			if (strcmp(line, ".") == 0)
663 				continue;
664 			altline = line;
665 			if (strncmp(altline, ".IX", 3) == 0) {
666 				altline += 3;
667 				altline = skip_spaces(altline);
668 			}
669 			process_man_line(altline);
670 			continue;
671 		}
672 		/* Inside a new-style .Sh NAME section (the .Nm part) */
673 		case STATE_MDOCNAME:
674 			(void) trim_rhs(line);
675 			if (strncmp(line, ".Nm", 3) == 0) {
676 				process_mdoc_line(line);
677 				continue;
678 			} else {
679 				if (strcmp(line, ".") == 0)
680 					continue;
681 				sbuf_append(whatis_proto, "- ", 2);
682 				state = STATE_MDOCDESC;
683 			}
684 			/* FALLTHROUGH */
685 		/* Inside a new-style .Sh NAME section (after the .Nm-s) */
686 		case STATE_MDOCDESC:
687 			if (strncmp(line, ".Sh", 3) == 0)
688 				break;
689 			(void) trim_rhs(line);
690 			if (strcmp(line, ".") == 0)
691 				continue;
692 			process_mdoc_line(line);
693 			continue;
694 		}
695 		break;
696 	}
697 	(void) fclose(fp);
698 	sbuf_strip(whatis_proto, " \t.-");
699 	line = sbuf_content(whatis_proto);
700 	/*
701 	 * Line now contains the appropriate data, but without the
702 	 * proper indentation or the section appended to each name.
703 	 */
704 	descr = strstr(line, " - ");
705 	if (descr == NULL) {
706 		descr = strchr(line, ' ');
707 		if (descr == NULL)
708 			return;
709 		*descr++ = '\0';
710 	} else {
711 		*descr = '\0';
712 		descr += 3;
713 	}
714 	names = sl_init();
715 	collect_names(names, line);
716 	sbuf_clear(whatis_final);
717 	if (!sl_find(names, page->name) &&
718 	    no_page_exists(section_dir, names, page->suffix)) {
719 		/*
720 		 * Add the page name since that's the only
721 		 * thing that man(1) will find.
722 		 */
723 		add_whatis_name(page->name, page->suffix);
724 	}
725 	for (i = 0; i < names->sl_cur; i++)
726 		add_whatis_name(names->sl_str[i], page->suffix);
727 	sl_free(names, 0);
728 	/* Remove last ", " */
729 	sbuf_retract(whatis_final, 2);
730 	while (sbuf_length(whatis_final) < INDENT)
731 		sbuf_append(whatis_final, " ", 1);
732 	sbuf_append(whatis_final, " - ", 3);
733 	sbuf_append_str(whatis_final, skip_spaces(descr));
734 	(void) sl_add(whatis_lines, strdup(sbuf_content(whatis_final)));
735 }
736 
737 /*
738  * Sort pages first by inode number, then by name.
739  */
740 static int
pagesort(const void * a,const void * b)741 pagesort(const void *a, const void *b)
742 {
743 	const struct page_info *p1 = *(struct page_info * const *) a;
744 	const struct page_info *p2 = *(struct page_info * const *) b;
745 
746 	if (p1->inode == p2->inode)
747 		return (strcmp(p1->name, p2->name));
748 
749 	return (p1->inode - p2->inode);
750 }
751 
752 /*
753  * Process a single man section.
754  */
755 static void
process_section(char * section_dir)756 process_section(char *section_dir)
757 {
758 	struct dirent	**entries;
759 	int		nentries;
760 	struct page_info **pages;
761 	int		npages = 0;
762 	int		i;
763 	ino_t		prev_inode = 0;
764 
765 	/* Scan the man section directory for pages */
766 	nentries = scandir(section_dir, &entries, NULL, alphasort);
767 
768 	/* Collect information about man pages */
769 	pages = (struct page_info **)calloc(nentries,
770 	    sizeof (struct page_info *));
771 	for (i = 0; i < nentries; i++) {
772 		struct page_info *info = new_page_info(section_dir, entries[i]);
773 		if (info != NULL)
774 			pages[npages++] = info;
775 		free(entries[i]);
776 	}
777 	free(entries);
778 	qsort(pages, npages, sizeof (struct page_info *), pagesort);
779 
780 	/* Process each unique page */
781 	for (i = 0; i < npages; i++) {
782 		struct page_info *page = pages[i];
783 		if (page->inode != prev_inode) {
784 			prev_inode = page->inode;
785 			process_page(page, section_dir);
786 		}
787 		free_page_info(page);
788 	}
789 	free(pages);
790 }
791 
792 /*
793  * Return whether the directory entry is a man page section.
794  */
795 static int
select_sections(const struct dirent * entry)796 select_sections(const struct dirent *entry)
797 {
798 	const char	*p = &entry->d_name[3];
799 
800 	if (strncmp(entry->d_name, "man", 3) != 0)
801 		return (0);
802 	while (*p != '\0') {
803 		if (!isalnum(*p++))
804 			return (0);
805 	}
806 	return (1);
807 }
808 
809 /*
810  * Process a single top-level man directory by finding all the
811  * sub-directories named man* and processing each one in turn.
812  */
813 void
mwpath(char * path)814 mwpath(char *path)
815 {
816 	FILE		*fp = NULL;
817 	struct dirent	**entries;
818 	int		nsections;
819 	int		i;
820 
821 	(void) signal(SIGINT, trap_signal);
822 	(void) signal(SIGHUP, trap_signal);
823 	(void) signal(SIGQUIT, trap_signal);
824 	(void) signal(SIGTERM, trap_signal);
825 
826 	whatis_proto = new_sbuf();
827 	whatis_final = new_sbuf();
828 
829 	nsections = scandir(path, &entries, select_sections, alphasort);
830 	if ((fp = open_whatis(path)) == NULL)
831 		return;
832 	for (i = 0; i < nsections; i++) {
833 		char	section_dir[MAXPATHLEN];
834 
835 		(void) snprintf(section_dir, MAXPATHLEN, "%s/%s",
836 		    path, entries[i]->d_name);
837 		process_section(section_dir);
838 		free(entries[i]);
839 	}
840 	free(entries);
841 	finish_whatis(fp, path);
842 }
843