manpath.c

   1 /*      $Id: manpath.c,v 1.27 2015/10/11 21:12:55 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 AUTHORS DISCLAIM ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS 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 <ctype.h>
  24 #include <err.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 "manconf.h"
  32
  33 #if !HAVE_MANPATH
  34 static  void     manconf_file(struct manconf *, const char *);
  35 #endif
  36 static  void     manpath_add(struct manpaths *, const char *, int);
  37 static  void     manpath_parseline(struct manpaths *, char *, int);
  38
  39
  40 void
  41 manconf_parse(struct manconf *conf, const char *file,
  42                 char *defp, char *auxp)
  43 {
  44 #if HAVE_MANPATH
  45         char             cmd[(PATH_MAX * 3) + 20];
  46         FILE            *stream;
  47         char            *buf;
  48         size_t           sz, bsz;
  49
  50         strlcpy(cmd, "manpath", sizeof(cmd));
  51         if (file) {
  52                 strlcat(cmd, " -C ", sizeof(cmd));
  53                 strlcat(cmd, file, sizeof(cmd));
  54         }
  55         if (auxp) {
  56                 strlcat(cmd, " -m ", sizeof(cmd));
  57                 strlcat(cmd, auxp, sizeof(cmd));
  58         }
  59         if (defp) {
  60                 strlcat(cmd, " -M ", sizeof(cmd));
  61                 strlcat(cmd, defp, sizeof(cmd));
  62         }
  63
  64         /* Open manpath(1).  Ignore errors. */
  65
  66         stream = popen(cmd, "r");
  67         if (NULL == stream)
  68                 return;
  69
  70         buf = NULL;
  71         bsz = 0;
  72
  73         /* Read in as much output as we can. */
  74
  75         do {
  76                 buf = mandoc_realloc(buf, bsz + 1024);
  77                 sz = fread(buf + bsz, 1, 1024, stream);
  78                 bsz += sz;
  79         } while (sz > 0);
  80
  81         if ( ! ferror(stream) && feof(stream) &&
  82                         bsz && '\n' == buf[bsz - 1]) {
  83                 buf[bsz - 1] = '\0';
  84                 manpath_parseline(&conf->manpath, buf, 1);
  85         }
  86
  87         free(buf);
  88         pclose(stream);
  89 #else
  90         char            *insert;
  91
  92         /* Always prepend -m. */
  93         manpath_parseline(&conf->manpath, auxp, 1);
  94
  95         /* If -M is given, it overrides everything else. */
  96         if (NULL != defp) {
  97                 manpath_parseline(&conf->manpath, 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                 manconf_file(conf, file);
 109                 return;
 110         }
 111
 112         /* Prepend man.conf(5) to MANPATH. */
 113         if (':' == defp[0]) {
 114                 manconf_file(conf, file);
 115                 manpath_parseline(&conf->manpath, defp, 0);
 116                 return;
 117         }
 118
 119         /* Append man.conf(5) to MANPATH. */
 120         if (':' == defp[strlen(defp) - 1]) {
 121                 manpath_parseline(&conf->manpath, defp, 0);
 122                 manconf_file(conf, file);
 123                 return;
 124         }
 125
 126         /* Insert man.conf(5) into MANPATH. */
 127         insert = strstr(defp, "::");
 128         if (NULL != insert) {
 129                 *insert++ = '\0';
 130                 manpath_parseline(&conf->manpath, defp, 0);
 131                 manconf_file(conf, file);
 132                 manpath_parseline(&conf->manpath, insert + 1, 0);
 133                 return;
 134         }
 135
 136         /* MANPATH overrides man.conf(5) completely. */
 137         manpath_parseline(&conf->manpath, defp, 0);
 138 #endif
 139 }
 140
 141 /*
 142  * Parse a FULL pathname from a colon-separated list of arrays.
 143  */
 144 static void
 145 manpath_parseline(struct manpaths *dirs, char *path, int complain)
 146 {
 147         char    *dir;
 148
 149         if (NULL == path)
 150                 return;
 151
 152         for (dir = strtok(path, ":"); dir; dir = strtok(NULL, ":"))
 153                 manpath_add(dirs, dir, complain);
 154 }
 155
 156 /*
 157  * Add a directory to the array, ignoring bad directories.
 158  * Grow the array one-by-one for simplicity's sake.
 159  */
 160 static void
 161 manpath_add(struct manpaths *dirs, const char *dir, int complain)
 162 {
 163         char             buf[PATH_MAX];
 164         struct stat      sb;
 165         char            *cp;
 166         size_t           i;
 167
 168         if (NULL == (cp = realpath(dir, buf))) {
 169                 if (complain)
 170                         warn("manpath: %s", dir);
 171                 return;
 172         }
 173
 174         for (i = 0; i < dirs->sz; i++)
 175                 if (0 == strcmp(dirs->paths[i], dir))
 176                         return;
 177
 178         if (stat(cp, &sb) == -1) {
 179                 if (complain)
 180                         warn("manpath: %s", dir);
 181                 return;
 182         }
 183
 184         dirs->paths = mandoc_reallocarray(dirs->paths,
 185             dirs->sz + 1, sizeof(char *));
 186
 187         dirs->paths[dirs->sz++] = mandoc_strdup(cp);
 188 }
 189
 190 void
 191 manconf_free(struct manconf *conf)
 192 {
 193         size_t           i;
 194
 195         for (i = 0; i < conf->manpath.sz; i++)
 196                 free(conf->manpath.paths[i]);
 197
 198         free(conf->manpath.paths);
 199         free(conf->output.includes);
 200         free(conf->output.man);
 201         free(conf->output.paper);
 202         free(conf->output.style);
 203 }
 204
 205 #if !HAVE_MANPATH
 206 static void
 207 manconf_file(struct manconf *conf, const char *file)
 208 {
 209         const char *const toks[] = { "manpath", "output", "_whatdb" };
 210         char manpath_default[] = MANPATH_DEFAULT;
 211
 212         FILE            *stream;
 213         char            *cp, *ep;
 214         size_t           len, tok;
 215
 216         if ((stream = fopen(file, "r")) == NULL)
 217                 goto out;
 218
 219         while ((cp = fgetln(stream, &len)) != NULL) {
 220                 ep = cp + len;
 221                 if (ep[-1] != '\n')
 222                         break;
 223                 *--ep = '\0';
 224                 while (isspace((unsigned char)*cp))
 225                         cp++;
 226                 if (*cp == '#')
 227                         continue;
 228
 229                 for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {
 230                         len = strlen(toks[tok]);
 231                         if (cp + len < ep &&
 232                             isspace((unsigned char)cp[len]) &&
 233                             !strncmp(cp, toks[tok], len)) {
 234                                 cp += len;
 235                                 while (isspace((unsigned char)*cp))
 236                                         cp++;
 237                                 break;
 238                         }
 239                 }
 240
 241                 switch (tok) {
 242                 case 2:  /* _whatdb */
 243                         while (ep > cp && ep[-1] != '/')
 244                                 ep--;
 245                         if (ep == cp)
 246                                 continue;
 247                         *ep = '\0';
 248                         /* FALLTHROUGH */
 249                 case 0:  /* manpath */
 250                         manpath_add(&conf->manpath, cp, 0);
 251                         *manpath_default = '\0';
 252                         break;
 253                 case 1:  /* output */
 254                         manconf_output(&conf->output, cp);
 255                         break;
 256                 default:
 257                         break;
 258                 }
 259         }
 260         fclose(stream);
 261
 262 out:
 263         if (*manpath_default != '\0')
 264                 manpath_parseline(&conf->manpath, manpath_default, 0);
 265 }
 266 #endif
 267
 268 void
 269 manconf_output(struct manoutput *conf, const char *cp)
 270 {
 271         const char *const toks[] = {
 272             "includes", "man", "paper", "style",
 273             "indent", "width", "fragment", "mdoc"
 274         };
 275
 276         size_t   len, tok;
 277
 278         for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {
 279                 len = strlen(toks[tok]);
 280                 if ( ! strncmp(cp, toks[tok], len) &&
 281                     strchr(" =  ", cp[len]) != NULL) {
 282                         cp += len;
 283                         if (*cp == '=')
 284                                 cp++;
 285                         while (isspace((unsigned char)*cp))
 286                                 cp++;
 287                         break;
 288                 }
 289         }
 290
 291         if (tok < 6 && *cp == '\0')
 292                 return;
 293
 294         switch (tok) {
 295         case 0:
 296                 if (conf->includes == NULL)
 297                         conf->includes = mandoc_strdup(cp);
 298                 break;
 299         case 1:
 300                 if (conf->man == NULL)
 301                         conf->man = mandoc_strdup(cp);
 302                 break;
 303         case 2:
 304                 if (conf->paper == NULL)
 305                         conf->paper = mandoc_strdup(cp);
 306                 break;
 307         case 3:
 308                 if (conf->style == NULL)
 309                         conf->style = mandoc_strdup(cp);
 310                 break;
 311         case 4:
 312                 if (conf->indent == 0)
 313                         conf->indent = strtonum(cp, 0, 1000, NULL);
 314                 break;
 315         case 5:
 316                 if (conf->width == 0)
 317                         conf->width = strtonum(cp, 58, 1000, NULL);
 318                 break;
 319         case 6:
 320                 conf->fragment = 1;
 321                 break;
 322         case 7:
 323                 conf->mdoc = 1;
 324                 break;
 325         default:
 326                 break;
 327         }
 328 }