?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Patrick Welche <prlw1@cam.ac.uk>
[netbsd-mini2440.git] / libexec / makewhatis / makewhatis.c
blob7a458423b6283ec52e3ea1cc8baa22a141ea2f8d
1 /* $NetBSD: makewhatis.c,v 1.46 2008/11/16 06:26:12 dholland Exp $ */
2
3 /*-
4 * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Matthias Scheler.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #if HAVE_NBTOOL_CONFIG_H
33 #include "nbtool_config.h"
34 #endif
35
36 #include <sys/cdefs.h>
37 #if !defined(lint)
38 __COPYRIGHT("@(#) Copyright (c) 1999\
39 The NetBSD Foundation, Inc. All rights reserved.");
40 __RCSID("$NetBSD: makewhatis.c,v 1.46 2008/11/16 06:26:12 dholland Exp $");
41 #endif /* not lint */
42
43 #include <sys/types.h>
44 #include <sys/param.h>
45 #include <sys/queue.h>
46 #include <sys/stat.h>
47 #include <sys/wait.h>
48
49 #include <ctype.h>
50 #include <err.h>
51 #include <errno.h>
52 #include <fcntl.h>
53 #include <fts.h>
54 #include <glob.h>
55 #include <locale.h>
56 #include <paths.h>
57 #include <signal.h>
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <string.h>
61 #include <unistd.h>
62 #include <zlib.h>
63 #include <util.h>
64
65 #include <man/manconf.h>
66 #include <man/pathnames.h>
67
68 #ifndef NROFF
69 #define NROFF "nroff"
70 #endif
71
72 typedef struct manpagestruct manpage;
73 struct manpagestruct {
74 manpage *mp_left, *mp_right;
75 ino_t mp_inode;
76 size_t mp_sdoff;
77 size_t mp_sdlen;
78 char mp_name[1];
79 };
80
81 typedef struct whatisstruct whatis;
82 struct whatisstruct {
83 whatis *wi_left, *wi_right;
84 char *wi_data;
85 char wi_prefix[1];
86 };
87
88 int main(int, char * const *);
89 static char *findwhitespace(char *);
90 static char *strmove(char *, char *);
91 static char *GetS(gzFile, char *, size_t);
92 static int pathnamesection(const char *, const char *);
93 static int manpagesection(char *);
94 static char *createsectionstring(char *);
95 static void addmanpage(manpage **, ino_t, char *, size_t, size_t);
96 static void addwhatis(whatis **, char *, char *);
97 static char *makesection(int);
98 static char *makewhatisline(const char *, const char *, const char *);
99 static void catpreprocess(char *);
100 static char *parsecatpage(const char *, gzFile *);
101 static int manpreprocess(char *);
102 static char *nroff(const char *, gzFile *);
103 static char *parsemanpage(const char *, gzFile *, int);
104 static char *getwhatisdata(char *);
105 static void processmanpages(manpage **, whatis **);
106 static void dumpwhatis(FILE *, whatis *);
107 static int makewhatis(char * const *manpath);
108
109 static char * const default_manpath[] = {
110 "/usr/share/man",
111 NULL
112 };
113
114 static const char *sectionext = "0123456789ln";
115 static const char *whatisdb = _PATH_WHATIS;
116 static const char *whatisdb_new = _PATH_WHATIS ".new";
117 static int dowarn = 0;
118
119 #define ISALPHA(c) isalpha((unsigned char)(c))
120 #define ISDIGIT(c) isdigit((unsigned char)(c))
121 #define ISSPACE(c) isspace((unsigned char)(c))
122
123 int
124 main(int argc, char *const *argv)
125 {
126 char * const *manpath;
127 int c, dofork;
128 const char *conffile;
129 ENTRY *ep;
130 TAG *tp;
131 int rv, jobs, status;
132 glob_t pg;
133 char *paths[2], **p, *sl;
134 int retval;
135
136 dofork = 1;
137 conffile = NULL;
138 jobs = 0;
139 retval = EXIT_SUCCESS;
140
141 (void)setlocale(LC_ALL, "");
142
143 while ((c = getopt(argc, argv, "C:fw")) != -1) {
144 switch (c) {
145 case 'C':
146 conffile = optarg;
147 break;
148 case 'f':
149 /* run all processing on foreground */
150 dofork = 0;
151 break;
152 case 'w':
153 dowarn++;
154 break;
155 default:
156 fprintf(stderr, "Usage: %s [-fw] [-C file] [manpath ...]\n",
157 getprogname());
158 exit(EXIT_FAILURE);
159 }
160 }
161 argc -= optind;
162 argv += optind;
163
164 if (argc >= 1) {
165 manpath = &argv[0];
166
167 mkwhatis:
168 return makewhatis(manpath);
169 }
170
171 /*
172 * Try read config file, fallback to default_manpath[]
173 * if man.conf not available.
174 */
175 config(conffile);
176 if ((tp = gettag("_whatdb", 0)) == NULL) {
177 manpath = default_manpath;
178 goto mkwhatis;
179 }
180
181 /* Build individual databases */
182 paths[1] = NULL;
183 TAILQ_FOREACH(ep, &tp->entrylist, q) {
184 if ((rv = glob(ep->s,
185 GLOB_BRACE | GLOB_NOSORT | GLOB_ERR | GLOB_NOCHECK,
186 NULL, &pg)) != 0)
187 err(EXIT_FAILURE, "glob('%s')", ep->s);
188
189 /* We always have something to work with here */
190 for (p = pg.gl_pathv; *p; p++) {
191 sl = strrchr(*p, '/');
192 if (sl == NULL) {
193 err(EXIT_FAILURE, "glob: _whatdb entry '%s' "
194 "doesn't contain slash", ep->s);
195 }
196
197 /*
198 * Cut the last component of path, leaving just
199 * the directory. We will use the result as root
200 * for manpage search.
201 * glob malloc()s space for the paths, so it's
202 * okay to change it in-place.
203 */
204 *sl = '\0';
205 paths[0] = *p;
206
207 if (!dofork) {
208 /* Do not fork child */
209 makewhatis(paths);
210 continue;
211 }
212
213 switch (fork()) {
214 case 0:
215 exit(makewhatis(paths));
216 break;
217 case -1:
218 warn("fork");
219 makewhatis(paths);
220 break;
221 default:
222 jobs++;
223 break;
224 }
225
226 }
227
228 globfree(&pg);
229 }
230
231 /* Wait for the childern to finish */
232 while (jobs > 0) {
233 (void)wait(&status);
234 if (!WIFEXITED(status) || WEXITSTATUS(status) != EXIT_SUCCESS)
235 retval = EXIT_FAILURE;
236 jobs--;
237 }
238
239 return retval;
240 }
241
242 static int
243 makewhatis(char * const * manpath)
244 {
245 FTS *fts;
246 FTSENT *fe;
247 manpage *source;
248 whatis *dest;
249 FILE *out;
250 size_t sdoff, sdlen;
251 int outfd;
252 struct stat st_before, st_after;
253
254 if ((fts = fts_open(manpath, FTS_LOGICAL, NULL)) == NULL)
255 err(EXIT_FAILURE, "Cannot open `%s'", *manpath);
256
257 source = NULL;
258 while ((fe = fts_read(fts)) != NULL) {
259 switch (fe->fts_info) {
260 case FTS_F:
261 if (manpagesection(fe->fts_path) >= 0) {
262 /*
263 * Get manpage subdirectory prefix. Most
264 * commonly, this is arch-specific subdirectory.
265 */
266 if (fe->fts_level >= 3) {
267 int sl;
268 const char *s, *lsl;
269
270 lsl = NULL;
271 s = &fe->fts_path[fe->fts_pathlen - 1];
272 for(sl = fe->fts_level - 1; sl > 0;
273 sl--) {
274 s--;
275 while (s[0] != '/')
276 s--;
277 if (lsl == NULL)
278 lsl = s;
279 }
280
281 /*
282 * Include trailing '/', so we get
283 * 'arch/'.
284 */
285 sdoff = s + 1 - fe->fts_path;
286 sdlen = lsl - s + 1;
287 } else {
288 sdoff = 0;
289 sdlen = 0;
290 }
291
292 addmanpage(&source, fe->fts_statp->st_ino,
293 fe->fts_path, sdoff, sdlen);
294 }
295 /*FALLTHROUGH*/
296 case FTS_D:
297 case FTS_DC:
298 case FTS_DEFAULT:
299 case FTS_DP:
300 case FTS_SL:
301 case FTS_DOT:
302 case FTS_W:
303 case FTS_NSOK:
304 case FTS_INIT:
305 break;
306 case FTS_SLNONE:
307 warnx("Symbolic link with no target: `%s'",
308 fe->fts_path);
309 break;
310 case FTS_DNR:
311 warnx("Unreadable directory: `%s'", fe->fts_path);
312 break;
313 case FTS_NS:
314 errno = fe->fts_errno;
315 warn("Cannot stat `%s'", fe->fts_path);
316 break;
317 case FTS_ERR:
318 errno = fe->fts_errno;
319 warn("Error reading `%s'", fe->fts_path);
320 break;
321 default:
322 errx(EXIT_FAILURE, "Unknown info %d returned from fts "
323 " for path: `%s'", fe->fts_info, fe->fts_path);
324 }
325 }
326
327 (void)fts_close(fts);
328
329 dest = NULL;
330 processmanpages(&source, &dest);
331
332 if (chdir(manpath[0]) == -1)
333 err(EXIT_FAILURE, "Cannot change dir to `%s'", manpath[0]);
334
335 /*
336 * makewhatis runs unattended, so it needs to be able to
337 * recover if the last run crashed out. Therefore, if
338 * whatisdb_new exists and is more than (arbitrarily) sixteen
339 * hours old, nuke it. If it exists but is not so old, refuse
340 * to run until it's cleaned up, in case another makewhatis is
341 * already running. Also, open the output with O_EXCL to make
342 * sure we get our own, in case two copies start exactly at
343 * once. (Unlikely? Maybe, maybe not, if two copies of cron
344 * end up running.)
345 *
346 * Similarly, before renaming the file after we finish writing
347 * to it, make sure it's still the same file we opened. This
348 * can't be completely race-free, but getting caught by it
349 * would require an unexplained sixteen-hour-or-more lag
350 * between the last mtime update when we wrote to it and when
351 * we get to the stat call *and* another makewhatis starting
352 * out to write at exactly the wrong moment. Not impossible,
353 * but not likely enough to worry about.
354 *
355 * This is maybe unnecessarily elaborate, but generating
356 * corrupted output isn't so good either.
357 */
358
359 if (stat(whatisdb_new, &st_before) == 0) {
360 if (st_before.st_mtime - time(NULL) > 16*60*60) {
361 /* Don't complain if someone else just removed it. */
362 if (unlink(whatisdb_new) == -1 && errno != ENOENT) {
363 err(EXIT_FAILURE, "Could not remove `%s'",
364 whatisdb_new);
365 } else {
366 warnx("Removed stale `%s'", whatisdb_new);
367 }
368 } else {
369 errx(EXIT_FAILURE, "The file `%s' already exists "
370 "-- am I already running?", whatisdb_new);
371 }
372 } else if (errno != ENOENT) {
373 /* Something unexpected happened. */
374 err(EXIT_FAILURE, "Cannot stat `%s'", whatisdb_new);
375 }
376
377 outfd = open(whatisdb_new, O_WRONLY|O_CREAT|O_EXCL,
378 S_IRUSR|S_IRGRP|S_IROTH);
379 if (outfd < 0)
380 err(EXIT_FAILURE, "Cannot open `%s'", whatisdb_new);
381
382 if (fstat(outfd, &st_before) == -1)
383 err(EXIT_FAILURE, "Cannot fstat `%s'", whatisdb_new);
384
385 if ((out = fdopen(outfd, "w")) == NULL)
386 err(EXIT_FAILURE, "Cannot fdopen `%s'", whatisdb_new);
387
388 dumpwhatis(out, dest);
389 if (fchmod(fileno(out), S_IRUSR|S_IRGRP|S_IROTH) == -1)
390 err(EXIT_FAILURE, "Cannot chmod `%s'", whatisdb_new);
391 if (fclose(out) != 0)
392 err(EXIT_FAILURE, "Cannot close `%s'", whatisdb_new);
393
394 if (stat(whatisdb_new, &st_after) == -1)
395 err(EXIT_FAILURE, "Cannot stat `%s' (after writing)",
396 whatisdb_new);
397
398 if (st_before.st_dev != st_after.st_dev ||
399 st_before.st_ino != st_after.st_ino) {
400 errx(EXIT_FAILURE, "The file `%s' changed under me; giving up",
401 whatisdb_new);
402 }
403
404 if (rename(whatisdb_new, whatisdb) == -1)
405 err(EXIT_FAILURE, "Could not rename `%s' to `%s'",
406 whatisdb_new, whatisdb);
407
408 return EXIT_SUCCESS;
409 }
410
411 static char *
412 findwhitespace(char *str)
413 {
414 while (!ISSPACE(*str))
415 if (*str++ == '\0') {
416 str = NULL;
417 break;
418 }
419
420 return str;
421 }
422
423 static char *
424 strmove(char *dest, char *src)
425 {
426 return memmove(dest, src, strlen(src) + 1);
427 }
428
429 static char *
430 GetS(gzFile in, char *buffer, size_t length)
431 {
432 char *ptr;
433
434 if (((ptr = gzgets(in, buffer, (int)length)) != NULL) && (*ptr == '\0'))
435 ptr = NULL;
436
437 return ptr;
438 }
439
440 static char *
441 makesection(int s)
442 {
443 char sectionbuffer[24];
444 if (s == -1)
445 return NULL;
446 (void)snprintf(sectionbuffer, sizeof(sectionbuffer),
447 " (%c) - ", sectionext[s]);
448 return estrdup(sectionbuffer);
449 }
450
451 static int
452 pathnamesection(const char *pat, const char *name)
453 {
454 char *ptr, *ext;
455 size_t len = strlen(pat);
456
457
458 while ((ptr = strstr(name, pat)) != NULL) {
459 if ((ext = strchr(sectionext, ptr[len])) != NULL) {
460 return ext - sectionext;
461 }
462 name = ptr + 1;
463 }
464 return -1;
465 }
466
467
468 static int
469 manpagesection(char *name)
470 {
471 char *ptr;
472
473 if ((ptr = strrchr(name, '/')) != NULL)
474 ptr++;
475 else
476 ptr = name;
477
478 while ((ptr = strchr(ptr, '.')) != NULL) {
479 int section;
480
481 ptr++;
482 section = 0;
483 while (sectionext[section] != '\0')
484 if (sectionext[section] == *ptr)
485 return section;
486 else
487 section++;
488 }
489 return -1;
490 }
491
492 static char *
493 createsectionstring(char *section_id)
494 {
495 char *section;
496
497 if (asprintf(&section, " (%s) - ", section_id) < 0)
498 err(EXIT_FAILURE, "malloc failed");
499 return section;
500 }
501
502 static void
503 addmanpage(manpage **tree, ino_t inode, char *name, size_t sdoff, size_t sdlen)
504 {
505 manpage *mp;
506
507 while ((mp = *tree) != NULL) {
508 if (mp->mp_inode == inode)
509 return;
510 tree = inode < mp->mp_inode ? &mp->mp_left : &mp->mp_right;
511 }
512
513 mp = emalloc(sizeof(manpage) + strlen(name));
514 mp->mp_left = NULL;
515 mp->mp_right = NULL;
516 mp->mp_inode = inode;
517 mp->mp_sdoff = sdoff;
518 mp->mp_sdlen = sdlen;
519 (void)strcpy(mp->mp_name, name);
520 *tree = mp;
521 }
522
523 static void
524 addwhatis(whatis **tree, char *data, char *prefix)
525 {
526 whatis *wi;
527 int result;
528
529 while (ISSPACE(*data))
530 data++;
531
532 if (*data == '/') {
533 char *ptr;
534
535 ptr = ++data;
536 while ((*ptr != '\0') && !ISSPACE(*ptr))
537 if (*ptr++ == '/')
538 data = ptr;
539 }
540
541 while ((wi = *tree) != NULL) {
542 result = strcmp(data, wi->wi_data);
543 if (result == 0) result = strcmp(prefix, wi->wi_prefix);
544 if (result == 0) return;
545 tree = result < 0 ? &wi->wi_left : &wi->wi_right;
546 }
547
548 wi = emalloc(sizeof(whatis) + strlen(prefix));
549
550 wi->wi_left = NULL;
551 wi->wi_right = NULL;
552 wi->wi_data = data;
553 if (prefix[0] != '\0')
554 (void) strcpy(wi->wi_prefix, prefix);
555 else
556 wi->wi_prefix[0] = '\0';
557 *tree = wi;
558 }
559
560 static void
561 catpreprocess(char *from)
562 {
563 char *to;
564
565 to = from;
566 while (ISSPACE(*from)) from++;
567
568 while (*from != '\0')
569 if (ISSPACE(*from)) {
570 while (ISSPACE(*++from));
571 if (*from != '\0')
572 *to++ = ' ';
573 }
574 else if (*(from + 1) == '\b')
575 from += 2;
576 else
577 *to++ = *from++;
578
579 *to = '\0';
580 }
581
582 static char *
583 makewhatisline(const char *file, const char *line, const char *section)
584 {
585 static const char *del[] = {
586 " - ",
587 " -- ",
588 "- ",
589 " -",
590 NULL
591 };
592 size_t i, pos;
593 size_t llen, slen, dlen;
594 char *result, *ptr;
595
596 ptr = NULL;
597 if (section == NULL) {
598 if (dowarn)
599 warnx("%s: No section provided for `%s'", file, line);
600 return estrdup(line);
601 }
602
603 for (i = 0; del[i]; i++)
604 if ((ptr = strstr(line, del[i])) != NULL)
605 break;
606
607 if (del[i] == NULL) {
608 if (dowarn)
609 warnx("%s: Bad format line `%s'", file, line);
610 return estrdup(line);
611 }
612
613 slen = strlen(section);
614 llen = strlen(line);
615 dlen = strlen(del[i]);
616
617 result = emalloc(llen - dlen + slen + 1);
618 pos = ptr - line;
619
620 (void)memcpy(result, line, pos);
621 (void)memcpy(&result[pos], section, slen);
622 (void)strcpy(&result[pos + slen], &line[pos + dlen]);
623 return result;
624 }
625
626 static char *
627 parsecatpage(const char *name, gzFile *in)
628 {
629 char buffer[8192];
630 char *section, *ptr, *last;
631 size_t size;
632
633 do {
634 if (GetS(in, buffer, sizeof(buffer)) == NULL)
635 return NULL;
636 }
637 while (buffer[0] == '\n');
638
639 section = NULL;
640 if ((ptr = strchr(buffer, '(')) != NULL) {
641 if ((last = strchr(ptr + 1, ')')) !=NULL) {
642 size_t length;
643
644 length = last - ptr + 1;
645 section = emalloc(length + 5);
646 *section = ' ';
647 (void) memcpy(section + 1, ptr, length);
648 (void) strcpy(section + 1 + length, " - ");
649 }
650 }
651
652 for (;;) {
653 if (GetS(in, buffer, sizeof(buffer)) == NULL) {
654 free(section);
655 return NULL;
656 }
657 catpreprocess(buffer);
658 if (strncmp(buffer, "NAME", 4) == 0)
659 break;
660 }
661 if (section == NULL)
662 section = makesection(pathnamesection("/cat", name));
663
664 ptr = last = buffer;
665 size = sizeof(buffer) - 1;
666 while ((size > 0) && (GetS(in, ptr, size) != NULL)) {
667 int length;
668
669 catpreprocess(ptr);
670
671 length = strlen(ptr);
672 if (length == 0) {
673 *last = '\0';
674
675 ptr = makewhatisline(name, buffer, section);
676 free(section);
677 return ptr;
678 }
679 if ((length > 1) && (ptr[length - 1] == '-') &&
680 ISALPHA(ptr[length - 2]))
681 last = &ptr[--length];
682 else {
683 last = &ptr[length++];
684 *last = ' ';
685 }
686
687 ptr += length;
688 size -= length;
689 }
690
691 free(section);
692
693 return NULL;
694 }
695
696 static int
697 manpreprocess(char *line)
698 {
699 char *from, *to;
700
701 to = from = line;
702 while (ISSPACE(*from))
703 from++;
704 if (strncmp(from, ".\\\"", 3) == 0)
705 return 1;
706
707 while (*from != '\0')
708 if (ISSPACE(*from)) {
709 while (ISSPACE(*++from));
710 if ((*from != '\0') && (*from != ','))
711 *to++ = ' ';
712 } else if (*from == '\\') {
713 switch (*++from) {
714 case '\0':
715 case '-':
716 break;
717 case 'f':
718 case 's':
719 from++;
720 if ((*from=='+') || (*from=='-'))
721 from++;
722 while (ISDIGIT(*from))
723 from++;
724 break;
725 default:
726 from++;
727 }
728 } else {
729 if (*from == '"')
730 from++;
731 else
732 *to++ = *from++;
733 }
734
735 *to = '\0';
736
737 if (strncasecmp(line, ".Xr", 3) == 0) {
738 char *sect;
739
740 from = line + 3;
741 if (ISSPACE(*from))
742 from++;
743
744 if ((sect = findwhitespace(from)) != NULL) {
745 size_t length;
746 char *trail;
747
748 *sect++ = '\0';
749 if ((trail = findwhitespace(sect)) != NULL)
750 *trail++ = '\0';
751 length = strlen(from);
752 (void) memmove(line, from, length);
753 line[length++] = '(';
754 to = &line[length];
755 length = strlen(sect);
756 (void) memmove(to, sect, length);
757 if (trail == NULL) {
758 (void) strcpy(&to[length], ")");
759 } else {
760 to += length;
761 *to++ = ')';
762 length = strlen(trail);
763 (void) memmove(to, trail, length + 1);
764 }
765 }
766 }
767
768 return 0;
769 }
770
771 static char *
772 nroff(const char *inname, gzFile *in)
773 {
774 char tempname[MAXPATHLEN], buffer[65536], *data;
775 int tempfd, bytes, pipefd[2], status;
776 static int devnull = -1;
777 pid_t child;
778
779 if (gzrewind(in) < 0)
780 err(EXIT_FAILURE, "Cannot rewind pipe");
781
782 if ((devnull < 0) &&
783 ((devnull = open(_PATH_DEVNULL, O_WRONLY, 0)) < 0))
784 err(EXIT_FAILURE, "Cannot open `/dev/null'");
785
786 (void)strlcpy(tempname, _PATH_TMP "makewhatis.XXXXXX",
787 sizeof(tempname));
788 if ((tempfd = mkstemp(tempname)) == -1)
789 err(EXIT_FAILURE, "Cannot create temp file");
790
791 while ((bytes = gzread(in, buffer, sizeof(buffer))) > 0)
792 if (write(tempfd, buffer, (size_t)bytes) != bytes) {
793 bytes = -1;
794 break;
795 }
796
797 if (bytes < 0) {
798 (void)close(tempfd);
799 (void)unlink(tempname);
800 err(EXIT_FAILURE, "Read from pipe failed");
801 }
802 if (lseek(tempfd, (off_t)0, SEEK_SET) == (off_t)-1) {
803 (void)close(tempfd);
804 (void)unlink(tempname);
805 err(EXIT_FAILURE, "Cannot rewind temp file");
806 }
807 if (pipe(pipefd) == -1) {
808 (void)close(tempfd);
809 (void)unlink(tempname);
810 err(EXIT_FAILURE, "Cannot create pipe");
811 }
812
813 switch (child = vfork()) {
814 case -1:
815 (void)close(pipefd[1]);
816 (void)close(pipefd[0]);
817 (void)close(tempfd);
818 (void)unlink(tempname);
819 err(EXIT_FAILURE, "Fork failed");
820 /* NOTREACHED */
821 case 0:
822 (void)close(pipefd[0]);
823 if (tempfd != STDIN_FILENO) {
824 (void)dup2(tempfd, STDIN_FILENO);
825 (void)close(tempfd);
826 }
827 if (pipefd[1] != STDOUT_FILENO) {
828 (void)dup2(pipefd[1], STDOUT_FILENO);
829 (void)close(pipefd[1]);
830 }
831 if (devnull != STDERR_FILENO) {
832 (void)dup2(devnull, STDERR_FILENO);
833 (void)close(devnull);
834 }
835 (void)execlp(NROFF, NROFF, "-S", "-man", NULL);
836 _exit(EXIT_FAILURE);
837 /*NOTREACHED*/
838 default:
839 (void)close(pipefd[1]);
840 (void)close(tempfd);
841 break;
842 }
843
844 if ((in = gzdopen(pipefd[0], "r")) == NULL) {
845 if (errno == 0)
846 errno = ENOMEM;
847 (void)close(pipefd[0]);
848 (void)kill(child, SIGTERM);
849 while (waitpid(child, NULL, 0) != child);
850 (void)unlink(tempname);
851 err(EXIT_FAILURE, "Cannot read from pipe");
852 }
853
854 data = parsecatpage(inname, in);
855 while (gzread(in, buffer, sizeof(buffer)) > 0);
856 (void)gzclose(in);
857
858 while (waitpid(child, &status, 0) != child);
859 if ((data != NULL) &&
860 !(WIFEXITED(status) && (WEXITSTATUS(status) == 0))) {
861 free(data);
862 errx(EXIT_FAILURE, NROFF " on `%s' exited with %d status",
863 inname, WEXITSTATUS(status));
864 }
865
866 (void)unlink(tempname);
867 return data;
868 }
869
870 static char *
871 parsemanpage(const char *name, gzFile *in, int defaultsection)
872 {
873 char *section, buffer[8192], *ptr;
874
875 section = NULL;
876 do {
877 if (GetS(in, buffer, sizeof(buffer) - 1) == NULL) {
878 free(section);
879 return NULL;
880 }
881 if (manpreprocess(buffer))
882 continue;
883 if (strncasecmp(buffer, ".Dt", 3) == 0) {
884 char *end;
885
886 ptr = &buffer[3];
887 if (ISSPACE(*ptr))
888 ptr++;
889 if ((ptr = findwhitespace(ptr)) == NULL)
890 continue;
891
892 if ((end = findwhitespace(++ptr)) != NULL)
893 *end = '\0';
894
895 free(section);
896 section = createsectionstring(ptr);
897 }
898 else if (strncasecmp(buffer, ".TH", 3) == 0) {
899 ptr = &buffer[3];
900 while (ISSPACE(*ptr))
901 ptr++;
902 if ((ptr = findwhitespace(ptr)) != NULL) {
903 char *next;
904
905 while (ISSPACE(*ptr))
906 ptr++;
907 if ((next = findwhitespace(ptr)) != NULL)
908 *next = '\0';
909 free(section);
910 section = createsectionstring(ptr);
911 }
912 }
913 else if (strncasecmp(buffer, ".Ds", 3) == 0) {
914 free(section);
915 return NULL;
916 }
917 } while (strncasecmp(buffer, ".Sh NAME", 8) != 0);
918
919 do {
920 if (GetS(in, buffer, sizeof(buffer) - 1) == NULL) {
921 free(section);
922 return NULL;
923 }
924 } while (manpreprocess(buffer));
925
926 if (strncasecmp(buffer, ".Nm", 3) == 0) {
927 size_t length, offset;
928
929 ptr = &buffer[3];
930 while (ISSPACE(*ptr))
931 ptr++;
932
933 length = strlen(ptr);
934 if ((length > 1) && (ptr[length - 1] == ',') &&
935 ISSPACE(ptr[length - 2])) {
936 ptr[--length] = '\0';
937 ptr[length - 1] = ',';
938 }
939 (void) memmove(buffer, ptr, length + 1);
940
941 offset = length + 3;
942 ptr = &buffer[offset];
943 for (;;) {
944 size_t more;
945
946 if ((sizeof(buffer) == offset) ||
947 (GetS(in, ptr, sizeof(buffer) - offset)
948 == NULL)) {
949 free(section);
950 return NULL;
951 }
952 if (manpreprocess(ptr))
953 continue;
954
955 if (strncasecmp(ptr, ".Nm", 3) != 0) break;
956
957 ptr += 3;
958 if (ISSPACE(*ptr))
959 ptr++;
960
961 buffer[length++] = ' ';
962 more = strlen(ptr);
963 if ((more > 1) && (ptr[more - 1] == ',') &&
964 ISSPACE(ptr[more - 2])) {
965 ptr[--more] = '\0';
966 ptr[more - 1] = ',';
967 }
968
969 (void) memmove(&buffer[length], ptr, more + 1);
970 length += more;
971 offset = length + 3;
972
973 ptr = &buffer[offset];
974 }
975
976 if (strncasecmp(ptr, ".Nd", 3) == 0) {
977 (void) strlcpy(&buffer[length], " -",
978 sizeof(buffer) - length);
979
980 while (strncasecmp(ptr, ".Sh", 3) != 0) {
981 int more;
982
983 if (*ptr == '.') {
984 char *space;
985
986 if (strncasecmp(ptr, ".Nd", 3) != 0 ||
987 strchr(ptr, '[') != NULL) {
988 free(section);
989 return NULL;
990 }
991 space = findwhitespace(ptr);
992 if (space == NULL) {
993 ptr = "";
994 } else {
995 space++;
996 (void) strmove(ptr, space);
997 }
998 }
999
1000 if (*ptr != '\0') {
1001 buffer[offset - 1] = ' ';
1002 more = strlen(ptr) + 1;
1003 offset += more;
1004 }
1005 ptr = &buffer[offset];
1006 if ((sizeof(buffer) == offset) ||
1007 (GetS(in, ptr, sizeof(buffer) - offset)
1008 == NULL)) {
1009 free(section);
1010 return NULL;
1011 }
1012 if (manpreprocess(ptr))
1013 *ptr = '\0';
1014 }
1015 }
1016 }
1017 else {
1018 int offset;
1019
1020 if (*buffer == '.') {
1021 char *space;
1022
1023 if ((space = findwhitespace(&buffer[1])) == NULL) {
1024 free(section);
1025 return NULL;
1026 }
1027 space++;
1028 (void) strmove(buffer, space);
1029 }
1030
1031 offset = strlen(buffer) + 1;
1032 for (;;) {
1033 int more;
1034
1035 ptr = &buffer[offset];
1036 if ((sizeof(buffer) == offset) ||
1037 (GetS(in, ptr, sizeof(buffer) - offset)
1038 == NULL)) {
1039 free(section);
1040 return NULL;
1041 }
1042 if (manpreprocess(ptr) || (*ptr == '\0'))
1043 continue;
1044
1045 if ((strncasecmp(ptr, ".Sh", 3) == 0) ||
1046 (strncasecmp(ptr, ".Ss", 3) == 0))
1047 break;
1048
1049 if (*ptr == '.') {
1050 char *space;
1051
1052 if ((space = findwhitespace(ptr)) == NULL) {
1053 continue;
1054 }
1055
1056 space++;
1057 (void) memmove(ptr, space, strlen(space) + 1);
1058 }
1059
1060 buffer[offset - 1] = ' ';
1061 more = strlen(ptr);
1062 if ((more > 1) && (ptr[more - 1] == ',') &&
1063 ISSPACE(ptr[more - 2])) {
1064 ptr[more - 1] = '\0';
1065 ptr[more - 2] = ',';
1066 }
1067 else more++;
1068 offset += more;
1069 }
1070 }
1071
1072 if (section == NULL)
1073 section = makesection(defaultsection);
1074
1075 ptr = makewhatisline(name, buffer, section);
1076 free(section);
1077 return ptr;
1078 }
1079
1080 static char *
1081 getwhatisdata(char *name)
1082 {
1083 gzFile *in;
1084 char *data;
1085 int section;
1086
1087 if ((in = gzopen(name, "r")) == NULL) {
1088 if (errno == 0)
1089 errno = ENOMEM;
1090 err(EXIT_FAILURE, "Cannot open `%s'", name);
1091 /* NOTREACHED */
1092 }
1093
1094 section = manpagesection(name);
1095 if (section == 0) {
1096 data = parsecatpage(name, in);
1097 } else {
1098 data = parsemanpage(name, in, section);
1099 if (data == NULL)
1100 data = nroff(name, in);
1101 }
1102
1103 (void) gzclose(in);
1104 return data;
1105 }
1106
1107 static void
1108 processmanpages(manpage **source, whatis **dest)
1109 {
1110 manpage *mp;
1111 char sd[128];
1112
1113 mp = *source;
1114 *source = NULL;
1115
1116 while (mp != NULL) {
1117 manpage *obsolete;
1118 char *data;
1119
1120 if (mp->mp_left != NULL)
1121 processmanpages(&mp->mp_left, dest);
1122
1123 if ((data = getwhatisdata(mp->mp_name)) != NULL) {
1124 /* Pass eventual directory prefix to addwhatis() */
1125 if (mp->mp_sdlen > 0 && mp->mp_sdlen < sizeof(sd)-1)
1126 strlcpy(sd, &mp->mp_name[mp->mp_sdoff],
1127 mp->mp_sdlen);
1128 else
1129 sd[0] = '\0';
1130
1131 addwhatis(dest, data, sd);
1132 }
1133
1134 obsolete = mp;
1135 mp = mp->mp_right;
1136 free(obsolete);
1137 }
1138 }
1139
1140 static void
1141 dumpwhatis(FILE *out, whatis *tree)
1142 {
1143 while (tree != NULL) {
1144 if (tree->wi_left)
1145 dumpwhatis(out, tree->wi_left);
1146
1147 if ((tree->wi_data[0] && fputs(tree->wi_prefix, out) == EOF) ||
1148 (fputs(tree->wi_data, out) == EOF) ||
1149 (fputc('\n', out) == EOF))
1150 err(EXIT_FAILURE, "Write failed");
1151
1152 tree = tree->wi_right;
1153 }
1154 }
NetBSD on the FriendlyARM MINI2440