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

Diff for /mandoc/manpath.c between version 1.1 and 1.14

version 1.1, 2011/11/23 09:47:38 version 1.14, 2014/04/20 16:46:05
Line 26 
Line 26 
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   
 #include "mandoc.h"  #include "mandoc_aux.h"
 #include "manpath.h"  #include "manpath.h"
   
 #define MAN_CONF_FILE   "/etc/man.conf"  #define MAN_CONF_FILE   "/etc/man.conf"
 #define MAN_CONF_KEY    "_whatdb"  #define MAN_CONF_KEY    "_whatdb"
   
 static  void     manpath_add(struct manpaths *, const char *);  static  void     manpath_add(struct manpaths *, const char *);
   static  void     manpath_parseline(struct manpaths *, char *);
   
 void  void
 manpath_parse(struct manpaths *dirs, char *defp, char *auxp)  manpath_parse(struct manpaths *dirs, const char *file,
                   char *defp, char *auxp)
 {  {
   #ifdef  USE_MANPATH
           char             cmd[(PATH_MAX * 3) + 20];
           FILE            *stream;
           char            *buf;
           size_t           sz, bsz;
   
         if (NULL != getenv("MANPATH"))          strlcpy(cmd, "manpath", sizeof(cmd));
                 defp = getenv("MANPATH");          if (file) {
                   strlcat(cmd, " -C ", sizeof(cmd));
                   strlcat(cmd, file, sizeof(cmd));
           }
           if (auxp) {
                   strlcat(cmd, " -m ", sizeof(cmd));
                   strlcat(cmd, auxp, sizeof(cmd));
           }
           if (defp) {
                   strlcat(cmd, " -M ", sizeof(cmd));
                   strlcat(cmd, defp, sizeof(cmd));
           }
   
         if (NULL == defp)          /* Open manpath(1).  Ignore errors. */
                 manpath_parseconf(dirs);  
         else  
                 manpath_parseline(dirs, defp);  
   
           stream = popen(cmd, "r");
           if (NULL == stream)
                   return;
   
           buf = NULL;
           bsz = 0;
   
           /* Read in as much output as we can. */
   
           do {
                   buf = mandoc_realloc(buf, bsz + 1024);
                   sz = fread(buf + bsz, 1, 1024, stream);
                   bsz += sz;
           } while (sz > 0);
   
           if ( ! ferror(stream) && feof(stream) &&
                           bsz && '\n' == buf[bsz - 1]) {
                   buf[bsz - 1] = '\0';
                   manpath_parseline(dirs, buf);
           }
   
           free(buf);
           pclose(stream);
   #else
           char            *insert;
   
           /* Always prepend -m. */
         manpath_parseline(dirs, auxp);          manpath_parseline(dirs, auxp);
   
           /* If -M is given, it overrides everything else. */
           if (NULL != defp) {
                   manpath_parseline(dirs, defp);
                   return;
           }
   
           /* MANPATH and man.conf(5) cooperate. */
           defp = getenv("MANPATH");
           if (NULL == file)
                   file = MAN_CONF_FILE;
   
           /* No MANPATH; use man.conf(5) only. */
           if (NULL == defp || '\0' == defp[0]) {
                   manpath_manconf(dirs, file);
                   return;
           }
   
           /* Prepend man.conf(5) to MANPATH. */
           if (':' == defp[0]) {
                   manpath_manconf(dirs, file);
                   manpath_parseline(dirs, defp);
                   return;
           }
   
           /* Append man.conf(5) to MANPATH. */
           if (':' == defp[strlen(defp) - 1]) {
                   manpath_parseline(dirs, defp);
                   manpath_manconf(dirs, file);
                   return;
           }
   
           /* Insert man.conf(5) into MANPATH. */
           insert = strstr(defp, "::");
           if (NULL != insert) {
                   *insert++ = '\0';
                   manpath_parseline(dirs, defp);
                   manpath_manconf(dirs, file);
                   manpath_parseline(dirs, insert + 1);
                   return;
           }
   
           /* MANPATH overrides man.conf(5) completely. */
           manpath_parseline(dirs, defp);
   #endif
 }  }
   
 /*  /*
  * 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)
 {  {
         char    *dir;          char    *dir;
   
Line 69  manpath_parseline(struct manpaths *dirs, char *path) 
Line 156  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)
 {  {
         char             buf[PATH_MAX];          char             buf[PATH_MAX];
         char            *cp;          char            *cp;
         int              i;          size_t           i;
   
         if (NULL == (cp = realpath(dir, buf)))          if (NULL == (cp = realpath(dir, buf)))
                 return;                  return;
Line 82  manpath_add(struct manpaths *dirs, const char *dir) 
Line 169  manpath_add(struct manpaths *dirs, const char *dir) 
                 if (0 == strcmp(dirs->paths[i], dir))                  if (0 == strcmp(dirs->paths[i], dir))
                         return;                          return;
   
         dirs->paths = mandoc_realloc          dirs->paths = mandoc_realloc(dirs->paths,
                 (dirs->paths,              (dirs->sz + 1) * sizeof(char *));
                  ((size_t)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)  manpath_free(struct manpaths *p)
 {  {
         FILE            *stream;          size_t           i;
 #ifdef  USE_MANPATH  
         char            *buf;  
         size_t           sz, bsz;  
   
         /* Open manpath(1).  Ignore errors. */          for (i = 0; i < p->sz; i++)
                   free(p->paths[i]);
   
         stream = popen("manpath", "r");          free(p->paths);
         if (NULL == stream)  }
                 return;  
   
         buf = NULL;  void
         bsz = 0;  manpath_manconf(struct manpaths *dirs, const char *file)
   {
         /* Read in as much output as we can. */          FILE            *stream;
   
         do {  
                 buf = mandoc_realloc(buf, bsz + 1024);  
                 sz = fread(buf + (int)bsz, 1, 1024, stream);  
                 bsz += sz;  
         } while (sz > 0);  
   
         if ( ! ferror(stream) && feof(stream) &&  
                         bsz && '\n' == buf[bsz - 1]) {  
                 buf[bsz - 1] = '\0';  
                 manpath_parseline(dirs, buf);  
         }  
   
         free(buf);  
         pclose(stream);  
 #else  
         char            *p, *q;          char            *p, *q;
         size_t           len, keysz;          size_t           len, keysz;
   
         keysz = strlen(MAN_CONF_KEY);          keysz = strlen(MAN_CONF_KEY);
         assert(keysz > 0);          assert(keysz > 0);
   
         if (NULL == (stream = fopen(MAN_CONF_FILE, "r")))          if (NULL == (stream = fopen(file, "r")))
                 return;                  return;
   
         while (NULL != (p = fgetln(stream, &len))) {          while (NULL != (p = fgetln(stream, &len))) {
Line 141  manpath_parseconf(struct manpaths *dirs)
Line 208  manpath_parseconf(struct manpaths *dirs)
                 if (strncmp(MAN_CONF_KEY, p, keysz))                  if (strncmp(MAN_CONF_KEY, p, keysz))
                         continue;                          continue;
                 p += keysz;                  p += keysz;
                 while (isspace(*p))                  while (isspace((unsigned char)*p))
                         p++;                          p++;
                 if ('\0' == *p)                  if ('\0' == *p)
                         continue;                          continue;
Line 152  manpath_parseconf(struct manpaths *dirs)
Line 219  manpath_parseconf(struct manpaths *dirs)
         }          }
   
         fclose(stream);          fclose(stream);
 #endif  
 }  
   
 void  
 manpath_free(struct manpaths *p)  
 {  
         int              i;  
   
         for (i = 0; i < p->sz; i++)  
                 free(p->paths[i]);  
   
         free(p->paths);  
 }  }

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.14

CVSweb