[BACK]Return to manpath.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/manpath.c between version 1.4 and 1.38

version 1.4, 2011/11/26 22:38:11 version 1.38, 2019/05/03 18:23:53
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2011,2014,2015,2017,2018 Ingo Schwarze <schwarze@openbsd.org>
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.   * copyright notice and this permission notice appear in all copies.
  *   *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
 #ifdef HAVE_CONFIG_H  
 #include "config.h"  #include "config.h"
 #endif  
   
 #include <sys/types.h>  #include <sys/types.h>
 #include <assert.h>  #include <sys/stat.h>
   
 #include <ctype.h>  #include <ctype.h>
   #if HAVE_ERR
   #include <err.h>
   #endif
 #include <limits.h>  #include <limits.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   
 #include "mandoc.h"  #include "mandoc_aux.h"
 #include "manpath.h"  #include "manconf.h"
   
 #define MAN_CONF_FILE   "/etc/man.conf"  static  void     manconf_file(struct manconf *, const char *);
 #define MAN_CONF_KEY    "_whatdb"  static  void     manpath_add(struct manpaths *, const char *, int);
   static  void     manpath_parseline(struct manpaths *, char *, int);
   
 static  void     manpath_add(struct manpaths *, const char *);  
   
 void  void
 manpath_parse(struct manpaths *dirs, char *defp, char *auxp)  manconf_parse(struct manconf *conf, const char *file,
                   char *defp, char *auxp)
 {  {
           char            *insert;
   
         manpath_parseline(dirs, auxp);          /* Always prepend -m. */
           manpath_parseline(&conf->manpath, auxp, 1);
   
         if (NULL == defp)          /* If -M is given, it overrides everything else. */
                 defp = getenv("MANPATH");          if (NULL != defp) {
                   manpath_parseline(&conf->manpath, defp, 1);
                   return;
           }
   
         if (NULL == defp)          /* MANPATH and man.conf(5) cooperate. */
                 manpath_parseconf(dirs);          defp = getenv("MANPATH");
         else          if (NULL == file)
                 manpath_parseline(dirs, defp);                  file = MAN_CONF_FILE;
   
           /* No MANPATH; use man.conf(5) only. */
           if (NULL == defp || '\0' == defp[0]) {
                   manconf_file(conf, file);
                   return;
           }
   
           /* Prepend man.conf(5) to MANPATH. */
           if (':' == defp[0]) {
                   manconf_file(conf, file);
                   manpath_parseline(&conf->manpath, defp, 0);
                   return;
           }
   
           /* Append man.conf(5) to MANPATH. */
           if (':' == defp[strlen(defp) - 1]) {
                   manpath_parseline(&conf->manpath, defp, 0);
                   manconf_file(conf, file);
                   return;
           }
   
           /* Insert man.conf(5) into MANPATH. */
           insert = strstr(defp, "::");
           if (NULL != insert) {
                   *insert++ = '\0';
                   manpath_parseline(&conf->manpath, defp, 0);
                   manconf_file(conf, file);
                   manpath_parseline(&conf->manpath, insert + 1, 0);
                   return;
           }
   
           /* MANPATH overrides man.conf(5) completely. */
           manpath_parseline(&conf->manpath, defp, 0);
 }  }
   
   void
   manpath_base(struct manpaths *dirs)
   {
           char path_base[] = MANPATH_BASE;
           manpath_parseline(dirs, path_base, 0);
   }
   
 /*  /*
  * Parse a FULL pathname from a colon-separated list of arrays.   * Parse a FULL pathname from a colon-separated list of arrays.
  */   */
 void  static void
 manpath_parseline(struct manpaths *dirs, char *path)  manpath_parseline(struct manpaths *dirs, char *path, int complain)
 {  {
         char    *dir;          char    *dir;
   
Line 62  manpath_parseline(struct manpaths *dirs, char *path)
Line 110  manpath_parseline(struct manpaths *dirs, char *path)
                 return;                  return;
   
         for (dir = strtok(path, ":"); dir; dir = strtok(NULL, ":"))          for (dir = strtok(path, ":"); dir; dir = strtok(NULL, ":"))
                 manpath_add(dirs, dir);                  manpath_add(dirs, dir, complain);
 }  }
   
 /*  /*
Line 70  manpath_parseline(struct manpaths *dirs, char *path)
Line 118  manpath_parseline(struct manpaths *dirs, char *path)
  * Grow the array one-by-one for simplicity's sake.   * Grow the array one-by-one for simplicity's sake.
  */   */
 static void  static void
 manpath_add(struct manpaths *dirs, const char *dir)  manpath_add(struct manpaths *dirs, const char *dir, int complain)
 {  {
         char             buf[PATH_MAX];          char             buf[PATH_MAX];
           struct stat      sb;
         char            *cp;          char            *cp;
         int              i;          size_t           i;
   
         if (NULL == (cp = realpath(dir, buf)))          if (NULL == (cp = realpath(dir, buf))) {
                   if (complain)
                           warn("manpath: %s", dir);
                 return;                  return;
           }
   
         for (i = 0; i < dirs->sz; i++)          for (i = 0; i < dirs->sz; i++)
                 if (0 == strcmp(dirs->paths[i], dir))                  if (0 == strcmp(dirs->paths[i], dir))
                         return;                          return;
   
         dirs->paths = mandoc_realloc          if (stat(cp, &sb) == -1) {
                 (dirs->paths,                  if (complain)
                  ((size_t)dirs->sz + 1) * sizeof(char *));                          warn("manpath: %s", dir);
                   return;
           }
   
           dirs->paths = mandoc_reallocarray(dirs->paths,
               dirs->sz + 1, sizeof(char *));
   
         dirs->paths[dirs->sz++] = mandoc_strdup(cp);          dirs->paths[dirs->sz++] = mandoc_strdup(cp);
 }  }
   
 void  void
 manpath_parseconf(struct manpaths *dirs)  manconf_free(struct manconf *conf)
 {  {
 #ifdef  USE_MANPATH          size_t           i;
         FILE            *stream;  
         char            *buf;  
         size_t           sz, bsz;  
   
         /* Open manpath(1).  Ignore errors. */          for (i = 0; i < conf->manpath.sz; i++)
                   free(conf->manpath.paths[i]);
   
         stream = popen("manpath", "r");          free(conf->manpath.paths);
         if (NULL == stream)          free(conf->output.includes);
                 return;          free(conf->output.man);
           free(conf->output.paper);
           free(conf->output.style);
   }
   
         buf = NULL;  static void
         bsz = 0;  manconf_file(struct manconf *conf, const char *file)
   {
           const char *const toks[] = { "manpath", "output", "_whatdb" };
           char manpath_default[] = MANPATH_DEFAULT;
   
         /* Read in as much output as we can. */          FILE            *stream;
           char            *line, *cp, *ep;
           size_t           linesz, tok, toklen;
           ssize_t          linelen;
   
         do {          if ((stream = fopen(file, "r")) == NULL)
                 buf = mandoc_realloc(buf, bsz + 1024);                  goto out;
                 sz = fread(buf + (int)bsz, 1, 1024, stream);  
                 bsz += sz;  
         } while (sz > 0);  
   
         if ( ! ferror(stream) && feof(stream) &&          line = NULL;
                         bsz && '\n' == buf[bsz - 1]) {          linesz = 0;
                 buf[bsz - 1] = '\0';  
                 manpath_parseline(dirs, buf);  
         }  
   
         free(buf);          while ((linelen = getline(&line, &linesz, stream)) != -1) {
         pclose(stream);                  cp = line;
 #else                  ep = cp + linelen - 1;
         manpath_manconf(MAN_CONF_FILE, dirs);                  while (ep > cp && isspace((unsigned char)*ep))
 #endif                          *ep-- = '\0';
 }                  while (isspace((unsigned char)*cp))
                           cp++;
                   if (cp == ep || *cp == '#')
                           continue;
   
 void                  for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {
 manpath_free(struct manpaths *p)                          toklen = strlen(toks[tok]);
 {                          if (cp + toklen < ep &&
         int              i;                              isspace((unsigned char)cp[toklen]) &&
                               strncmp(cp, toks[tok], toklen) == 0) {
                                   cp += toklen;
                                   while (isspace((unsigned char)*cp))
                                           cp++;
                                   break;
                           }
                   }
   
         for (i = 0; i < p->sz; i++)                  switch (tok) {
                 free(p->paths[i]);                  case 2:  /* _whatdb */
                           while (ep > cp && ep[-1] != '/')
                                   ep--;
                           if (ep == cp)
                                   continue;
                           *ep = '\0';
                           /* FALLTHROUGH */
                   case 0:  /* manpath */
                           manpath_add(&conf->manpath, cp, 0);
                           *manpath_default = '\0';
                           break;
                   case 1:  /* output */
                           manconf_output(&conf->output, cp, 1);
                           break;
                   default:
                           break;
                   }
           }
           free(line);
           fclose(stream);
   
         free(p->paths);  out:
           if (*manpath_default != '\0')
                   manpath_parseline(&conf->manpath, manpath_default, 0);
 }  }
   
 void  int
 manpath_manconf(const char *file, struct manpaths *dirs)  manconf_output(struct manoutput *conf, const char *cp, int fromfile)
 {  {
         FILE            *stream;          const char *const toks[] = {
         char            *p, *q;              "includes", "man", "paper", "style", "indent", "width",
         size_t           len, keysz;              "tag", "fragment", "mdoc", "noval", "toc"
           };
           const size_t ntoks = sizeof(toks) / sizeof(toks[0]);
   
         keysz = strlen(MAN_CONF_KEY);          const char      *errstr;
         assert(keysz > 0);          char            *oldval;
           size_t           len, tok;
   
         if (NULL == (stream = fopen(file, "r")))          for (tok = 0; tok < ntoks; tok++) {
                 return;                  len = strlen(toks[tok]);
                   if ( ! strncmp(cp, toks[tok], len) &&
         while (NULL != (p = fgetln(stream, &len))) {                      strchr(" =  ", cp[len]) != NULL) {
                 if (0 == len || '\n' != p[--len])                          cp += len;
                           if (*cp == '=')
                                   cp++;
                           while (isspace((unsigned char)*cp))
                                   cp++;
                         break;                          break;
                 p[len] = '\0';                  }
                 while (isspace((unsigned char)*p))  
                         p++;  
                 if (strncmp(MAN_CONF_KEY, p, keysz))  
                         continue;  
                 p += keysz;  
                 while (isspace(*p))  
                         p++;  
                 if ('\0' == *p)  
                         continue;  
                 if (NULL == (q = strrchr(p, '/')))  
                         continue;  
                 *q = '\0';  
                 manpath_add(dirs, p);  
         }          }
   
         fclose(stream);          if (tok < 6 && *cp == '\0') {
                   warnx("-O %s=?: Missing argument value", toks[tok]);
                   return -1;
           }
           if (tok > 6 && tok < ntoks && *cp != '\0') {
                   warnx("-O %s: Does not take a value: %s", toks[tok], cp);
                   return -1;
           }
   
           switch (tok) {
           case 0:
                   if (conf->includes != NULL) {
                           oldval = mandoc_strdup(conf->includes);
                           break;
                   }
                   conf->includes = mandoc_strdup(cp);
                   return 0;
           case 1:
                   if (conf->man != NULL) {
                           oldval = mandoc_strdup(conf->man);
                           break;
                   }
                   conf->man = mandoc_strdup(cp);
                   return 0;
           case 2:
                   if (conf->paper != NULL) {
                           oldval = mandoc_strdup(conf->paper);
                           break;
                   }
                   conf->paper = mandoc_strdup(cp);
                   return 0;
           case 3:
                   if (conf->style != NULL) {
                           oldval = mandoc_strdup(conf->style);
                           break;
                   }
                   conf->style = mandoc_strdup(cp);
                   return 0;
           case 4:
                   if (conf->indent) {
                           mandoc_asprintf(&oldval, "%zu", conf->indent);
                           break;
                   }
                   conf->indent = strtonum(cp, 0, 1000, &errstr);
                   if (errstr == NULL)
                           return 0;
                   warnx("-O indent=%s is %s", cp, errstr);
                   return -1;
           case 5:
                   if (conf->width) {
                           mandoc_asprintf(&oldval, "%zu", conf->width);
                           break;
                   }
                   conf->width = strtonum(cp, 1, 1000, &errstr);
                   if (errstr == NULL)
                           return 0;
                   warnx("-O width=%s is %s", cp, errstr);
                   return -1;
           case 6:
                   if (conf->tag != NULL) {
                           oldval = mandoc_strdup(conf->tag);
                           break;
                   }
                   conf->tag = mandoc_strdup(cp);
                   return 0;
           case 7:
                   conf->fragment = 1;
                   return 0;
           case 8:
                   conf->mdoc = 1;
                   return 0;
           case 9:
                   conf->noval = 1;
                   return 0;
           case 10:
                   conf->toc = 1;
                   return 0;
           default:
                   if (fromfile)
                           warnx("-O %s: Bad argument", cp);
                   return -1;
           }
           if (fromfile == 0)
                   warnx("-O %s=%s: Option already set to %s",
                       toks[tok], cp, oldval);
           free(oldval);
           return -1;
 }  }

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.38

CVSweb