style: compare return value of getopt() against -1 rather than EOF
[games.git] / gnu / usr.bin / man / manpath / manpath.c
1 /*
2  * manpath.c
3  *
4  * Copyright (c) 1990, 1991, John W. Eaton.
5  *
6  * You may distribute under the terms of the GNU General Public
7  * License as specified in the file COPYING that comes with the man
8  * distribution.
9  *
10  * John W. Eaton
11  * jwe@che.utexas.edu
12  * Department of Chemical Engineering
13  * The University of Texas at Austin
14  * Austin, Texas  78712
15  *
16  * $FreeBSD: src/gnu/usr.bin/man/manpath/manpath.c,v 1.11.2.2 2003/02/15 05:33:06 kris Exp $
17  * $DragonFly: src/gnu/usr.bin/man/manpath/manpath.c,v 1.5 2008/07/10 18:29:51 swildner Exp $
18  */
19
20 #define MANPATH_MAIN
21
22 #include <stdio.h>
23 #include <string.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include "config.h"
27 #include "manpath.h"
28 #include "gripes.h"
29
30 #ifdef STDC_HEADERS
31 #include <stdlib.h>
32 #else
33 extern int fprintf ();
34 extern int strcmp ();
35 extern int strncmp ();
36 extern char *memcpy ();
37 extern char *getenv();
38 extern char *malloc();
39 extern void free ();
40 extern int exit ();
41 #endif
42
43 extern char *strdup ();
44 extern int is_directory ();
45
46 #ifndef MAIN
47 extern int debug;
48 #endif
49
50 #ifdef MAIN
51
52 #ifndef STDC_HEADERS
53 extern char *strcpy ();
54 extern int fflush ();
55 #endif
56
57 char *prognam;
58 int debug;
59 int locale;
60 char *man_locales;
61
62 /*
63  * Examine user's PATH and print a reasonable MANPATH.
64  */
65 int
66 main(argc, argv)
67      int argc;
68      char **argv;
69 {
70   int c;
71   int quiet;
72   char *mp;
73   extern int getopt ();
74   extern char *mkprogname ();
75   void usage ();
76   char *manpath ();
77
78   quiet = 1;
79
80   prognam = mkprogname (argv[0]);
81
82   while ((c = getopt (argc, argv, "dhLq?")) != -1)
83     {
84       switch (c)
85         {
86         case 'd':
87           debug++;
88           break;
89         case 'L':
90           locale++;
91           break;
92         case 'q':
93           quiet = 0;
94           break;
95         case '?':
96         case 'h':
97         default:
98           usage();
99           break;
100         }
101     }
102
103   mp = manpath (quiet);
104
105   fprintf (stdout, "%s\n", mp);
106   fflush (stdout);
107
108   return 0;
109 }
110
111 void
112 usage ()
113 {
114   fprintf (stderr, "usage: %s [-dLq]\n", prognam);
115   exit (1);
116 }
117 #endif /* MAIN */
118
119 /*
120  * If the environment variable MANPATH is set, return it.
121  * If the environment variable PATH is set and has a nonzero length,
122  * try to determine the corresponding manpath, otherwise, return the
123  * default manpath.
124  *
125  * The manpath.config file is used to map system wide /bin directories
126  * to top level man page directories.
127  *
128  * For directories which are in the user's path but not in the
129  * manpath.config file, see if there is a subdirectory `man' or `MAN'.
130  * If so, add that directory to the path.  Example:  user has
131  * $HOME/bin in his path and the directory $HOME/bin/man exists -- the
132  * directory $HOME/bin/man will be added to the manpath.
133  *
134  * Also search for a `man' directory next to the directory on the path.
135  * Example: $HOME/bin will look for $HOME/man
136  */
137 char *
138 manpath (perrs)
139      register int perrs;
140 {
141   register int len;
142   register char *manpathlist;
143   register char *path;
144   int  get_dirlist ();
145   char *def_path ();
146   char *get_manpath ();
147
148   if (get_dirlist ())
149       gripe_reading_mp_config (config_file);
150
151 #ifdef MAIN
152   if (locale)
153     {
154       if ((manpathlist = getenv ("MANLOCALES")) != NULL)
155         /*
156          * This must be it.
157          */
158         {
159           if (perrs)
160             fprintf (stderr, "(Warning: MANLOCALES environment variable set)\n");
161           return strdup (manpathlist);
162         }
163       return (man_locales ? man_locales : "");
164     }
165 #endif /* MAIN */
166
167   if ((manpathlist = getenv ("MANPATH")) != NULL)
168     /*
169      * This must be it.
170      */
171     {
172       if (perrs)
173         fprintf (stderr, "(Warning: MANPATH environment variable set)\n");
174       return strdup (manpathlist);
175     }
176   else if ((path = getenv ("PATH")) == NULL)
177     /*
178      * Things aren't going to work well, but hey...
179      */
180     {
181       if (perrs)
182         fprintf (stderr, "Warning: path not set\n");
183       return def_path (perrs);
184     }
185   else
186     {
187       if ((len = strlen (path)) == 0)
188         /*
189          * Things aren't going to work well here either...
190          */
191         {
192           if (perrs)
193             fprintf (stderr, "Warning: path set but has zero length\n");
194           return def_path (perrs);
195         }
196       return get_manpath (perrs, path);
197     }
198 }
199
200 /*
201  * Get the list of bin directories and the corresponding man
202  * directories from the manpath.config file.
203  *
204  * This is ugly.
205  */
206 int
207 get_dirlist ()
208 {
209   int i;
210   char *bp;
211   char *p;
212   char buf[BUFSIZ];
213   DIRLIST *dlp = list;
214   FILE *config;
215
216   if ((config = fopen (config_file, "r")) == NULL)
217     gripe_getting_mp_config (config_file);
218
219   while ((bp = fgets (buf, BUFSIZ, config)) != NULL)
220     {
221       while (*bp && (*bp == ' ' || *bp == '\t'))
222         bp++;
223
224       if (*bp == '#' || *bp == '\n')
225         continue;
226
227       if (!strncmp ("MANDATORY_MANPATH", bp, 17) ||
228           !strncmp ("OPTIONAL_MANPATH", bp, 16))
229         {
230           if ((p = strchr (bp, ' ')) == NULL &&
231               (p = strchr (bp, '\t')) == NULL) {
232             fclose(config);
233             return -1;
234           }
235
236           dlp->type = *bp == 'M'? MANPATH_MANDATORY: MANPATH_OPTIONAL;
237
238           bp = p;
239
240           while (*bp && *bp != '\n' && (*bp == ' ' || *bp == '\t'))
241             bp++;
242
243           i = 0;
244           while (*bp && *bp != '\n' && *bp != ' ' && *bp != '\t')
245             dlp->mandir[i++] = *bp++;
246           dlp->mandir[i] = '\0';
247
248           if (debug)
249             fprintf (stderr, "found %s man directory %s\n",
250                      dlp->type == MANPATH_MANDATORY? "mandatory": "optional",
251                      dlp->mandir);
252         }
253       else if (!strncmp ("MANPATH_MAP", bp, 11))
254         {
255           if ((p = strchr (bp, ' ')) == NULL &&
256               (p = strchr (bp, '\t')) == NULL) {
257             fclose(config);
258             return -1;
259           }
260
261           bp = p;
262
263           dlp->type = MANPATH_MAP;
264
265           while (*bp && *bp != '\n' && (*bp == ' ' || *bp == '\t'))
266             bp++;
267
268           i = 0;
269           while (*bp && *bp != '\n' && *bp != ' ' && *bp != '\t')
270             dlp->bin[i++] = *bp++;
271           dlp->bin[i] = '\0';
272
273           while (*bp && *bp != '\n' && (*bp == ' ' || *bp == '\t'))
274             bp++;
275
276           i = 0;
277           while (*bp && *bp != '\n' && *bp != ' ' && *bp != '\t')
278             dlp->mandir[i++] = *bp++;
279           dlp->mandir[i] = '\0';
280
281           if (debug)
282             fprintf (stderr, "found manpath map %s --> %s\n",
283                      dlp->bin, dlp->mandir);
284         }
285       else if (!strncmp ("MANLOCALES", bp, 10))
286         {
287           if ((p = strchr (bp, ' ')) == NULL &&
288               (p = strchr (bp, '\t')) == NULL) {
289             fclose(config);
290             return -1;
291           }
292
293           bp = p;
294
295           while (*bp && *bp != '\n' && (*bp == ' ' || *bp == '\t'))
296             bp++;
297
298           for (p = bp; *p && *p != '\n'; p++)
299                 ;
300           do {
301                 *p-- = '\0';
302           } while (p >= bp && (*p == ' ' || *p == '\t'));
303
304 #ifdef MAIN
305           if (man_locales != NULL)
306                 free (man_locales);
307
308           if ((man_locales = strdup (bp)) == NULL) {
309                 fclose(config);
310                 return -1;
311           }
312 #endif  /* MAIN */
313
314           if (debug)
315             fprintf (stderr, "found man locales: %s\n", bp);
316         }
317       else
318         {
319           gripe_reading_mp_config (config_file);
320         }
321       dlp++;
322     }
323
324   fclose(config);
325   dlp->bin[0] = '\0';
326   dlp->mandir[0] = '\0';
327   dlp->type = MANPATH_NONE;
328
329   return 0;
330 }
331
332 /*
333  * Construct the default manpath.  This picks up mandatory
334  * and optional (if they exist) manpaths only.
335  */
336 char *
337 def_path (perrs)
338      int perrs;
339 {
340   register int len;
341   register char *manpathlist, *p;
342   register DIRLIST *dlp;
343
344   len = 0;
345   dlp = list;
346   while (dlp->type != MANPATH_NONE) {
347     if (dlp->type == MANPATH_MANDATORY || dlp->type == MANPATH_OPTIONAL)
348       len += strlen (dlp->mandir) + 1;
349     dlp++;
350   }
351
352   manpathlist = (char *) malloc (len);
353   if (manpathlist == NULL)
354     gripe_alloc (len, "manpathlist");
355
356   *manpathlist = '\0';
357
358   dlp = list;
359   p = manpathlist;
360   while (dlp->type != MANPATH_NONE) {
361     if (dlp->type == MANPATH_MANDATORY || dlp->type == MANPATH_OPTIONAL) {
362       int status;
363       char *path = dlp->mandir;
364
365       status = is_directory(path);
366
367       if (status < 0 && perrs && dlp->type == MANPATH_MANDATORY)
368         {
369           fprintf (stderr, "Warning: couldn't stat file %s!\n", path);
370         }
371       else if (status == 0 && perrs)
372         {
373           fprintf (stderr, "Warning: %s isn't a directory!\n", path);
374         }
375       else if (status == 1)
376         {
377           len = strlen (path);
378           memcpy (p, path, len);
379           p += len;
380           *p++ = ':';
381         }
382     }
383     dlp++;
384   }
385
386   p[-1] = '\0';
387
388   return manpathlist;
389 }
390
391 /*
392  * For each directory in the user's path, see if it is one of the
393  * directories listed in the manpath.config file.  If so, and it is
394  * not already in the manpath, add it.  If the directory is not listed
395  * in the manpath.config file, see if there is a subdirectory `man' or
396  * `MAN'.  If so, and it is not already in the manpath, add it.
397  * Example:  user has $HOME/bin in his path and the directory
398  * $HOME/bin/man exists -- the directory $HOME/bin/man will be added
399  * to the manpath.
400  */
401 char *
402 get_manpath (perrs, path)
403      register int perrs;
404      register char *path;
405 {
406   register int len;
407   register char *tmppath;
408   register char *t;
409   register char *p;
410   register char **lp;
411   register char *end;
412   register char *manpathlist;
413   register DIRLIST *dlp;
414   void add_dir_to_list ();
415   char *has_subdirs ();
416   int fnd = 0;
417
418   tmppath = strdup (path);
419
420   for (p = tmppath; ; p = end+1)
421     {
422       if ((end = strchr(p, ':')) != NULL)
423         *end = '\0';
424
425       if (debug)
426         fprintf (stderr, "\npath directory %s ", p);
427
428       if (*p != '/')
429         {
430           if (debug)
431             fprintf (stderr, "is not an absolute pathname\n");
432
433           goto found;   /* skip. */
434         }
435
436       /*
437        * The directory we're working on is in the config file.
438        * If we haven't added it to the list yet, do.
439        */
440       for (dlp = list; dlp->mandir[0] != '\0'; dlp++)
441         if (dlp->bin[0] != '\0' && !strcmp (p, dlp->bin))
442           {
443             if (debug && !fnd)
444               fprintf (stderr, "is in the config file\n");
445
446             add_dir_to_list (tmplist, dlp->mandir, perrs);
447             fnd++;
448           }
449       if (fnd)
450         {
451           fnd = 0;
452           goto found;
453         }
454
455       /*
456        * The directory we're working on isn't in the config file.  See
457        * if it has man or MAN subdirectories.  If so, and it hasn't
458        * been added to the list, do.
459        */
460       if (debug)
461         fprintf (stderr, "is not in the config file\n");
462
463       t = has_subdirs (p);
464       if (t != NULL)
465         {
466           if (debug)
467             fprintf (stderr, "but it does have a man or MAN subdirectory\n");
468
469           add_dir_to_list (tmplist, t, perrs);
470           free (t);
471         }
472       else
473         {
474           if (debug)
475             fprintf (stderr, "and doesn't have man or MAN subdirectories\n");
476         }
477
478     found:
479
480       if (!end)
481         break;
482     }
483
484   if (debug)
485     fprintf (stderr, "\nadding mandatory man directories\n\n");
486
487   dlp = list;
488   while (dlp->type != MANPATH_NONE) {
489     if (dlp->type == MANPATH_MANDATORY || dlp->type == MANPATH_OPTIONAL)
490       add_dir_to_list (tmplist, dlp->mandir,
491         dlp->type == MANPATH_MANDATORY? perrs: 0);
492     dlp++;
493   }
494
495   len = 0;
496   lp = tmplist;
497   while (*lp != NULL)
498     {
499       len += strlen (*lp) + 1;
500       lp++;
501     }
502
503   if (!len)
504     return strdup("");
505
506   manpathlist = (char *) malloc (len);
507   if (manpathlist == NULL)
508     gripe_alloc (len, "manpathlist");
509
510   *manpathlist = '\0';
511
512   lp = tmplist;
513   p = manpathlist;
514   while (*lp != NULL)
515     {
516       len = strlen (*lp);
517       memcpy (p, *lp, len);
518       p += len;
519       *p++ = ':';
520       lp++;
521     }
522
523   p[-1] = '\0';
524
525   return manpathlist;
526 }
527
528 /*
529  * Add a directory to the manpath list if it isn't already there.
530  */
531 void
532 add_dir_to_list (lp, dir, perrs)
533      char **lp;
534      char *dir;
535      int perrs;
536 {
537   extern char *strdup ();
538   int status;
539
540   while (*lp != NULL)
541     {
542       if (!strcmp (*lp, dir))
543         {
544           if (debug)
545             fprintf (stderr, "%s is already in the manpath\n", dir);
546           return;
547         }
548       lp++;
549     }
550   /*
551    * Not found -- add it.
552    */
553   status = is_directory(dir);
554
555   if (status < 0 && perrs)
556     {
557       fprintf (stderr, "Warning: couldn't stat file %s!\n", dir);
558     }
559   else if (status == 0 && perrs)
560     {
561       fprintf (stderr, "Warning: %s isn't a directory!\n", dir);
562     }
563   else if (status == 1)
564     {
565       if (debug)
566         fprintf (stderr, "adding %s to manpath\n", dir);
567
568       *lp = strdup (dir);
569     }
570 }
571
572 /*
573  * Check to see if the current directory has man or MAN
574  * subdirectories.
575  */
576 char *
577 has_subdirs (p)
578      register char *p;
579 {
580   int len;
581   register char *t;
582
583   len = strlen (p);
584
585   t = (char *) malloc ((unsigned) len + 5);
586   if (t == NULL)
587     gripe_alloc (len+5, "p\n");
588
589   memcpy (t, p, len);
590   strcpy (t + len, "/man");
591
592   if (is_directory (t) == 1)
593     return t;
594
595   strcpy (t + len, "/MAN");
596
597   if (is_directory (t) == 1)
598     return t;
599
600   /* If the path ends in `bin' then replace with `man' and see if that works. */
601   if (len > 3 && strncmp(t+len-4, "/bin", 4) == 0) {
602     strcpy(t+len-4, "/man");
603
604     if (is_directory(t) == 1) 
605        return t;
606   }
607
608   return NULL;
609 }