manpath.c

   1 /*      $Id: manpath.c,v 1.21 2015/03/22 18:14:30 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2011, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
   4  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include "config.h"
  19
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22
  23 #include <assert.h>
  24 #include <ctype.h>
  25 #include <limits.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "mandoc_aux.h"
  31 #include "manpath.h"
  32
  33 #define MAN_CONF_FILE   "/etc/man.conf"
  34 #define MAN_CONF_KEY    "_whatdb"
  35
  36 static  void     manpath_add(struct manpaths *, const char *, int);
  37 static  void     manpath_parseline(struct manpaths *, char *, int);
  38
  39 void
  40 manpath_parse(struct manpaths *dirs, const char *file,
  41                 char *defp, char *auxp)
  42 {
  43 #if HAVE_MANPATH
  44         char             cmd[(PATH_MAX * 3) + 20];
  45         FILE            *stream;
  46         char            *buf;
  47         size_t           sz, bsz;
  48
  49         strlcpy(cmd, "manpath", sizeof(cmd));
  50         if (file) {
  51                 strlcat(cmd, " -C ", sizeof(cmd));
  52                 strlcat(cmd, file, sizeof(cmd));
  53         }
  54         if (auxp) {
  55                 strlcat(cmd, " -m ", sizeof(cmd));
  56                 strlcat(cmd, auxp, sizeof(cmd));
  57         }
  58         if (defp) {
  59                 strlcat(cmd, " -M ", sizeof(cmd));
  60                 strlcat(cmd, defp, sizeof(cmd));
  61         }
  62
  63         /* Open manpath(1).  Ignore errors. */
  64
  65         stream = popen(cmd, "r");
  66         if (NULL == stream)
  67                 return;
  68
  69         buf = NULL;
  70         bsz = 0;
  71
  72         /* Read in as much output as we can. */
  73
  74         do {
  75                 buf = mandoc_realloc(buf, bsz + 1024);
  76                 sz = fread(buf + bsz, 1, 1024, stream);
  77                 bsz += sz;
  78         } while (sz > 0);
  79
  80         if ( ! ferror(stream) && feof(stream) &&
  81                         bsz && '\n' == buf[bsz - 1]) {
  82                 buf[bsz - 1] = '\0';
  83                 manpath_parseline(dirs, buf, 1);
  84         }
  85
  86         free(buf);
  87         pclose(stream);
  88 #else
  89         char             manpath_default[] = MANPATH_DEFAULT;
  90         char            *insert;
  91
  92         /* Always prepend -m. */
  93         manpath_parseline(dirs, auxp, 1);
  94
  95         /* If -M is given, it overrides everything else. */
  96         if (NULL != defp) {
  97                 manpath_parseline(dirs, defp, 1);
  98                 return;
  99         }
 100
 101         /* MANPATH and man.conf(5) cooperate. */
 102         defp = getenv("MANPATH");
 103         if (NULL == file)
 104                 file = MAN_CONF_FILE;
 105
 106         /* No MANPATH; use man.conf(5) only. */
 107         if (NULL == defp || '\0' == defp[0]) {
 108                 manpath_manconf(dirs, file);
 109                 if (dirs->sz == 0)
 110                         manpath_parseline(dirs, manpath_default, 0);
 111                 return;
 112         }
 113
 114         /* Prepend man.conf(5) to MANPATH. */
 115         if (':' == defp[0]) {
 116                 manpath_manconf(dirs, file);
 117                 manpath_parseline(dirs, defp, 0);
 118                 return;
 119         }
 120
 121         /* Append man.conf(5) to MANPATH. */
 122         if (':' == defp[strlen(defp) - 1]) {
 123                 manpath_parseline(dirs, defp, 0);
 124                 manpath_manconf(dirs, file);
 125                 return;
 126         }
 127
 128         /* Insert man.conf(5) into MANPATH. */
 129         insert = strstr(defp, "::");
 130         if (NULL != insert) {
 131                 *insert++ = '\0';
 132                 manpath_parseline(dirs, defp, 0);
 133                 manpath_manconf(dirs, file);
 134                 manpath_parseline(dirs, insert + 1, 0);
 135                 return;
 136         }
 137
 138         /* MANPATH overrides man.conf(5) completely. */
 139         manpath_parseline(dirs, defp, 0);
 140 #endif
 141 }
 142
 143 /*
 144  * Parse a FULL pathname from a colon-separated list of arrays.
 145  */
 146 static void
 147 manpath_parseline(struct manpaths *dirs, char *path, int complain)
 148 {
 149         char    *dir;
 150
 151         if (NULL == path)
 152                 return;
 153
 154         for (dir = strtok(path, ":"); dir; dir = strtok(NULL, ":"))
 155                 manpath_add(dirs, dir, complain);
 156 }
 157
 158 /*
 159  * Add a directory to the array, ignoring bad directories.
 160  * Grow the array one-by-one for simplicity's sake.
 161  */
 162 static void
 163 manpath_add(struct manpaths *dirs, const char *dir, int complain)
 164 {
 165         char             buf[PATH_MAX];
 166         struct stat      sb;
 167         char            *cp;
 168         size_t           i;
 169
 170         if (NULL == (cp = realpath(dir, buf))) {
 171                 if (complain) {
 172                         fputs("manpath: ", stderr);
 173                         perror(dir);
 174                 }
 175                 return;
 176         }
 177
 178         for (i = 0; i < dirs->sz; i++)
 179                 if (0 == strcmp(dirs->paths[i], dir))
 180                         return;
 181
 182         if (stat(cp, &sb) == -1) {
 183                 if (complain) {
 184                         fputs("manpath: ", stderr);
 185                         perror(dir);
 186                 }
 187                 return;
 188         }
 189
 190         dirs->paths = mandoc_reallocarray(dirs->paths,
 191             dirs->sz + 1, sizeof(char *));
 192
 193         dirs->paths[dirs->sz++] = mandoc_strdup(cp);
 194 }
 195
 196 void
 197 manpath_free(struct manpaths *p)
 198 {
 199         size_t           i;
 200
 201         for (i = 0; i < p->sz; i++)
 202                 free(p->paths[i]);
 203
 204         free(p->paths);
 205 }
 206
 207 void
 208 manpath_manconf(struct manpaths *dirs, const char *file)
 209 {
 210         FILE            *stream;
 211         char            *p, *q;
 212         size_t           len, keysz;
 213
 214         keysz = strlen(MAN_CONF_KEY);
 215         assert(keysz > 0);
 216
 217         if (NULL == (stream = fopen(file, "r")))
 218                 return;
 219
 220         while (NULL != (p = fgetln(stream, &len))) {
 221                 if (0 == len || '\n' != p[--len])
 222                         break;
 223                 p[len] = '\0';
 224                 while (isspace((unsigned char)*p))
 225                         p++;
 226                 if (strncmp(MAN_CONF_KEY, p, keysz))
 227                         continue;
 228                 p += keysz;
 229                 while (isspace((unsigned char)*p))
 230                         p++;
 231                 if ('\0' == *p)
 232                         continue;
 233                 if (NULL == (q = strrchr(p, '/')))
 234                         continue;
 235                 *q = '\0';
 236                 manpath_add(dirs, p, 0);
 237         }
 238
 239         fclose(stream);
 240 }