home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / fontutils-0.6-base.tgz / fontutils-0.6-base.tar / fsf / fontutils / lib / pathsrch.c < prev    next >
C/C++ Source or Header  |  1992-07-25  |  15KB  |  508 lines
  1. /* pathsrch.c: look for files based on paths, i.e., colon-separated
  2.    lists of directories.  
  3.    
  4.    Perhaps we should allow % specifiers in the paths for the resolution, etc.
  5.  
  6. Copyright (C) 1992 Free Software Foundation, Inc.
  7.  
  8. This program is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 2, or (at your option)
  11. any later version.
  12.  
  13. This program is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with this program; if not, write to the Free Software
  20. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. #include "config.h"
  23.  
  24. #include "c-pathch.h"
  25. #include "c-namemx.h"
  26. #include "c-pathmx.h"
  27. #include "paths.h"
  28. #include "xstat.h"
  29.  
  30. #include <ctype.h>
  31. #if !defined (DOS) && !defined (VMS) && !defined (VMCMS)
  32. #include <pwd.h>
  33. #endif
  34. #include "dirio.h"
  35. #include "pathsrch.h"
  36.  
  37. /* Access bit to test whether the filename F is readable.  */
  38. #ifndef R_OK
  39. #define R_OK 4
  40. #endif
  41.  
  42. static boolean absolute_p P1H(string filename);
  43. static void add_directory P3H(string **, unsigned *, string);
  44. static void expand_subdir P3H(string **, unsigned *, string);
  45. static string *find_dir_list P1H(string);
  46. static string readable P1H(string);
  47. static void save_dir_list P2H(string, string *);
  48. static string truncate_pathname P1H(string);
  49.  
  50. /* If FILENAME is absolute or explicitly relative (i.e., starts with
  51.    `/', `./', or `../'), or if DIR_LIST is null, we return whether
  52.    FILENAME is readable as-is.  Otherwise, we test if FILENAME is in any of
  53.    the directories listed in DIR_LIST.  (The last entry of DIR_LIST must
  54.    be null.)  We return the complete path if found, NULL else.
  55.    
  56.    In the interests of doing minimal work here, we assume that each
  57.    element of DIR_LIST already ends with a `/'.
  58.    
  59.    DIR_LIST is most conveniently made by calling `initialize_path_list'.
  60.    This is a separate routine because we allow recursive searching, and
  61.    it may take some time to discover the list of directories.  
  62.    We do not want to incur that overhead every time we want to look for
  63.    a file.
  64.    
  65.    (Actually, `/' is not hardwired into this routine; we use PATH_SEP,
  66.    defined above.)  */
  67.  
  68. string
  69. find_path_filename P2C(string, filename,  string *, dir_list)
  70. {
  71.   string found_name = NULL;
  72.   
  73.   /* Do this before testing for absolute-ness, as a leading ~ will be an
  74.      absolute pathname.  */
  75.   filename = expand_tilde (filename);
  76.   
  77.   /* If FILENAME is absolute or explicitly relative, or if DIR_LIST is
  78.      null, only check if FILENAME is readable.  */
  79.   if (absolute_p (filename) || dir_list == NULL)
  80.     found_name = readable (filename);
  81.   else
  82.     { /* Test if FILENAME is in any of the directories in DIR_LIST.  */
  83.       string save_filename = filename;
  84.       
  85.       while (*dir_list != NULL)
  86.         {
  87.           filename = concat (*dir_list, save_filename);
  88.           found_name = readable (filename);
  89.           if (found_name == NULL)
  90.             {
  91.               free (filename);
  92.               dir_list++;
  93.             }
  94.           else
  95.             {
  96.               if (found_name != filename)
  97.                 free (filename);
  98.               break;
  99.             }
  100.         }
  101.     }
  102.   
  103.   return found_name;
  104. }
  105.  
  106.  
  107. /* If NAME is readable, return it.  If the error is ENAMETOOLONG,
  108.    truncate any too-long path components and return the result (unless
  109.    there were no too-long components, i.e., a overall too-long name
  110.    caused the error, in which case return NULL).  On any other error,
  111.    return NULL.
  112.    
  113.    POSIX invented this brain-damage of not necessarily truncating
  114.    pathname components; the system's behavior is defined by the value of
  115.    the symbol _POSIX_NO_TRUNC, but you can't change it dynamically!  */
  116.  
  117. static string
  118. readable (name)
  119.     string name;
  120. {
  121.   string ret;
  122.   
  123.   if (access (name, R_OK) == 0 && !dir_p (name))
  124.     ret = name;
  125. #ifdef ENAMETOOLONG
  126.   else if (errno == ENAMETOOLONG)
  127.     { 
  128.       ret = truncate_pathname (name);
  129.  
  130.       /* Perhaps some other error will occur with the truncated name, so
  131.          let's call access again.  */
  132.       if (!(access (ret, R_OK) == 0 && !dir_p (ret)))
  133.         { /* Failed.  */
  134.           free (ret);
  135.           ret = NULL;
  136.         }
  137.     }
  138. #endif
  139.   else
  140.     ret = NULL; /* Some other error.  */
  141.   
  142.   return ret;
  143. }
  144.  
  145.  
  146.  
  147. /* Truncate any too-long path components in NAME, returning the result.  */
  148.  
  149. static string
  150. truncate_pathname (name)
  151.     string name;
  152. {
  153.   unsigned c_len = 0;        /* Length of current component.  */
  154.   unsigned ret_len = 0; /* Length of constructed result.  */
  155.   string ret = (string) xmalloc (PATH_MAX + 1);
  156.  
  157.   for (; *name; name++)
  158.     {
  159.       if (*name == PATH_SEP)
  160.         { /* At a directory delimiter, reset component length.  */
  161.           c_len = 0;
  162.         }
  163.       else if (c_len > NAME_MAX)
  164.         { /* If past the max for a component, ignore this character.  */
  165.           continue;
  166.         }
  167.  
  168.       /* If we've already copied the max, give up.  */
  169.       if (ret_len == PATH_MAX)
  170.         {
  171.           free (ret);
  172.           return NULL;
  173.         }
  174.  
  175.       /* Copy this character.  */
  176.       ret[ret_len++] = *name;
  177.       c_len++;
  178.     }
  179.   ret[ret_len] = 0;
  180.  
  181.   return ret;
  182. }
  183.  
  184.  
  185. /* Return true if FILENAME is absolute or explicitly relative, else
  186.    false.  */
  187.  
  188. static boolean
  189. absolute_p P1C(string, filename)
  190. {
  191.   boolean absolute = *filename == PATH_SEP
  192. #ifdef DOS
  193.                       || isalpha (*filename) && filename[1] == ':'
  194. #endif
  195.               ;
  196.   boolean explicit_relative
  197.     = (*filename == '.'
  198.        && (filename[1] == PATH_SEP
  199.            || (filename[1] == '.' && filename[2] == PATH_SEP)));
  200.  
  201.   return absolute || explicit_relative;
  202. }
  203.  
  204. /* Return a NULL-terminated array of directory names, each name ending
  205.    with PATH_SEP, created by parsing the PATH_DELIMITER-separated list
  206.    in the value of the environment variable ENV_NAME, or DEFAULT_PATH if
  207.    the envvar is not set.
  208.    
  209.    A leading or trailing colon in the value of ENV_NAME is replaced by
  210.    DEFAULT_PATH.
  211.    
  212.    Any element of the path that ends with double PATH_SEP characters
  213.    (e.g., `foo//') is replaced by all its subdirectories.
  214.  
  215.    If ENV_NAME is null, only parse DEFAULT_PATH.  If both are null, do
  216.    nothing and return NULL.  */
  217.  
  218. string *
  219. initialize_path_list P2C(string, env_name,  string, default_path)
  220. {
  221.   string dir, path;
  222.   string *dir_list;
  223.   unsigned dir_count = 0;
  224.   string env_value = env_name ? getenv (env_name) : NULL;
  225.   string orig_path = expand_default (env_value, default_path);
  226.  
  227.   if (orig_path == NULL || *orig_path == 0)
  228.     return NULL;
  229.  
  230.   /* If we've already seen this colon-separated list, then just get it
  231.      back instead of going back to the filesystem.  */
  232.   dir_list = find_dir_list (orig_path);
  233.   if (dir_list != NULL)
  234.     return dir_list;
  235.   
  236.   /* Be sure `path' is in writable memory.  */
  237.   path = (orig_path == env_value || orig_path == default_path
  238.           ? xstrdup (orig_path) : orig_path);
  239.  
  240.   /* Find each element in the path in turn.  */
  241.   for (dir = strtok (path, PATH_DELIMITER_STRING); dir != NULL;
  242.        dir = strtok (NULL, PATH_DELIMITER_STRING))
  243.     {
  244.       int len;
  245.       /* If the path starts with ~ or ~user, expand it.  Do this
  246.          before calling `expand_subdir' or `add_directory', so that
  247.          1) we don't expand the same ~ for every subdirectory; and 
  248.          2) pathnames in `expand_subdir' don't have a `~' in them
  249.             (since the system won't grok `~/foo' as a directory).  */
  250.       dir = expand_tilde (dir);
  251.       len = strlen (dir);
  252.  
  253.       /* If `dir' is the empty string, ignore it.  */
  254.       if (len == 0)
  255.         continue;
  256.  
  257.       /* If `dir' ends in double slashes, do subdirectories (and remove
  258.          the second slash, so the final pathnames we return don't look
  259.          like foo//bar).  Because we obviously want to do subdirectories
  260.          of `dir', we don't check if it is a leaf.  This means that if
  261.          `dir' is `foo//', and `foo' contains only symlinks (so our leaf
  262.          test below would be true), the symlinks are chased.  */
  263.       if (len > 2 && dir[len - 1] == PATH_SEP && dir[len - 2] == PATH_SEP)
  264.         {
  265.           dir[len - 1] = 0;
  266.           if (dir_p (dir))
  267.             {
  268.               add_directory (&dir_list, &dir_count, dir);
  269.               expand_subdir (&dir_list, &dir_count, dir);
  270.         }
  271.         }
  272.       else
  273.         { /* Don't bother to add the directory if it doesn't exist.  */
  274.           if (dir_p (dir))
  275.             add_directory (&dir_list, &dir_count, dir);
  276.     }
  277.     }
  278.   
  279.   /* Add the terminating null entry to `dir_list'.  */
  280.   dir_count++;
  281.   XRETALLOC (dir_list, dir_count, string);
  282.   dir_list[dir_count - 1] = NULL;
  283.   
  284.   /* Save the directory list we just found.  */
  285.   save_dir_list (orig_path, dir_list);
  286.  
  287.   return dir_list;
  288. }
  289.  
  290. /* Subroutines for `initialize_path_list'.  */
  291.  
  292. /* Add a newly-allocated copy of DIR to the end of the array pointed to
  293.    by DIR_LIST_PTR. Increment DIR_COUNT_PTR.  Append a `/' to DIR if
  294.    necessary.  We assume DIR is a directory, to avoid unnecessary an
  295.    unnecessary call to `stat'.  */
  296.  
  297. static void
  298. add_directory (dir_list_ptr, dir_count_ptr, dir)
  299.     string **dir_list_ptr;
  300.     unsigned *dir_count_ptr;
  301.     string dir;
  302. {
  303.   /* If `dir' does not end with a `/', add it.  We can't just
  304.      write it in place, since that would overwrite the null that
  305.      strtok may have put in.  So we always make a copy of DIR.  */
  306.   dir = (dir[strlen (dir) - 1] == PATH_SEP ? xstrdup (dir)
  307.          : concat (dir, PATH_SEP_STRING));
  308.  
  309.   /* Add `dir' to the list of the directories.  */
  310.   (*dir_count_ptr)++;
  311.   XRETALLOC (*dir_list_ptr, *dir_count_ptr, string);
  312.   (*dir_list_ptr)[*dir_count_ptr - 1] = dir;
  313. }
  314.  
  315.  
  316. /* Add DIRNAME to DIR_LIST and look for subdirectories, recursively.  We
  317.    assume DIRNAME is the name of a directory.  */
  318.  
  319. static void
  320. expand_subdir (dir_list_ptr, dir_count_ptr, dirname)
  321.     string **dir_list_ptr;
  322.     unsigned *dir_count_ptr;
  323.     string dirname;
  324. {
  325.   DIR *dir;
  326.   struct dirent *e;
  327.   unsigned length;
  328.   char potential[PATH_MAX];
  329.   struct stat st;
  330.   
  331.    /* We will be looking at its contents.  */
  332.   dir = opendir (dirname);
  333.   if (dir == NULL)
  334.     return;
  335.   
  336.   /* Compute the length of DIRNAME, since it's loop-invariant.  */
  337.   length = strlen (dirname);
  338.  
  339.   /* Construct the part of the pathname that doesn't change.  */
  340.   strcpy (potential, dirname);
  341.   if (potential[length - 1] != PATH_SEP)
  342.     {
  343.       potential[length] = PATH_SEP;
  344.       potential[length + 1] = 0;
  345.       length++;
  346.     }
  347.   
  348.   while ((e = readdir (dir)) != NULL)
  349.     { /* If it's . or .., never mind.  */
  350.       if (!(e->d_name[0] == '.'
  351.             && (e->d_name[1] == 0
  352.                 || (e->d_name[1] == '.' && e->d_name[2] == 0))))
  353.         { /* If it's not a directory, we will skip it on the
  354.              recursive call.  */
  355.           strcat (potential, e->d_name);
  356.  
  357.           /* If we can't stat it, or if it isn't a directory, continue.  */
  358.           if (stat (potential, &st) == 0 && S_ISDIR (st.st_mode))
  359.             { /* It's a subdirectory; add `potential' to the list.  */
  360.               add_directory (dir_list_ptr, dir_count_ptr, potential);
  361.  
  362.               /* If it's not a leaf, quit.  Assume that leaf
  363.                  directories have two links (one for . and one for ..).
  364.                  This means that symbolic links to directories do not affect
  365.                  the leaf-ness.  This is arguably wrong, but the only
  366.                  alternative I know of is to stat every entry in the
  367.                  directory, and that is unacceptably slow.  */
  368.               if (st.st_nlink > 2)
  369.                 { /* All criteria are met; find subdirectories.  */
  370.                   expand_subdir (dir_list_ptr, dir_count_ptr, potential);
  371.                 }
  372.             }
  373.  
  374.           /* ``Remove'' the directory entry name.  */
  375.           potential[length] = 0;
  376.         }
  377.     }
  378.   
  379.   closedir (dir);
  380. }
  381.  
  382. /* These routines, while not strictly needed to be exported, are
  383.    plausibly useful to be called by outsiders.  */
  384.  
  385. /* Replace a leading or trailing `:' in ENV_PATH with DEFAULT_PATH.  If
  386.    neither is present, return ENV_PATH if that is non-null, else
  387.    DEFAULT_PATH.  */
  388.  
  389. string 
  390. expand_default (env_path, default_path)
  391.    string env_path;
  392.    string default_path;
  393. {
  394.   string expansion;
  395.   
  396.   if (env_path == NULL)
  397.     expansion = default_path;
  398.   else if (*env_path == PATH_DELIMITER)
  399.     expansion = concat (default_path, env_path);
  400.   else if (env_path[strlen (env_path) - 1] == PATH_DELIMITER)
  401.     expansion = concat (env_path, default_path);
  402.   else
  403.     expansion = env_path;
  404.   
  405.   return expansion;
  406. }
  407.  
  408.  
  409. /* Expand a leading ~ or ~user, Unix-style, unless we are some weirdo
  410.    operating system.  */
  411.  
  412. string
  413. expand_tilde P1C(string, name)
  414. {
  415. #if defined (DOS) || defined (VMS) || defined (VMCMS)
  416.   return name;
  417. #else
  418.   string expansion;
  419.   string home;
  420.   
  421.   /* If no leading tilde, do nothing.  */
  422.   if (*name != '~')
  423.     expansion = name;
  424.   
  425.   /* If `~' or `~/', use $HOME if it exists, or `.' if it doesn't.  */
  426.   else if (name[1] == PATH_SEP || name[1] == 0)
  427.     {
  428.       home = getenv ("HOME");
  429.       if (home == NULL)
  430.         home = ".";
  431.         
  432.       expansion
  433.         = name[1] == 0 ? home : concat3 (home, PATH_SEP_STRING, name + 2);
  434.     }
  435.   
  436.   /* If `~user' or `~user/', look up user in the passwd database.  */
  437.   else
  438.     {
  439.       struct passwd *p;
  440.       string user;
  441.       unsigned c = 2;
  442.       while (name[c] != PATH_SEP && name[c] != 0)
  443.         c++;
  444.       
  445.       user = (string) xmalloc (c);
  446.       strncpy (user, name + 1, c - 1);
  447.       user[c - 1] = 0;
  448.       
  449.       /* We only need the cast here for those (old deficient) systems
  450.          which do not declare `getpwnam' in <pwd.h>.  */
  451.       p = (struct passwd *) getpwnam (user);
  452.       free (user);
  453.       /* If no such user, just use `.'.  */
  454.       home = p == NULL ? "." : p->pw_dir;
  455.       
  456.       expansion = name[c] == 0 ? home : concat (home, name + c);
  457.     }
  458.   
  459.   return expansion;
  460. #endif /* not (DOS or VMS or VM/CMS) */
  461. }
  462.  
  463. /* Routines to save and retrieve a directory list keyed by the original
  464.    colon-separated path.  This is useful because 1) it can take a
  465.    significant amount of time to discover all the subdirectories of a
  466.    given directory, and 2) many paths all have the same basic default,
  467.    and thus would recompute the directory list.  */
  468.  
  469. typedef struct
  470. {
  471.   string path;
  472.   string *dir_list;
  473. } saved_path_entry;
  474.  
  475. static saved_path_entry *saved_paths = NULL;
  476. static unsigned saved_paths_length = 0;
  477.  
  478.  
  479. /* We implement the data structure as a simple linear list, since it's
  480.    unlikely to ever be more than a dozen or so elements long.  We don't
  481.    bother to check here if PATH has already been saved; we always add it
  482.    to our list.  */
  483.  
  484. static void
  485. save_dir_list P2C(string, path,  string *, dir_list)
  486. {
  487.   saved_paths_length++;
  488.   XRETALLOC (saved_paths, saved_paths_length, saved_path_entry);
  489.   saved_paths[saved_paths_length - 1].path = path;
  490.   saved_paths[saved_paths_length - 1].dir_list = dir_list;
  491. }
  492.  
  493. /* When we retrieve, just check the list in order.  */
  494.  
  495. static string *
  496. find_dir_list P1C(string, path)
  497. {
  498.   unsigned p;
  499.   
  500.   for (p = 0; p < saved_paths_length; p++)
  501.     {
  502.       if (strcmp (saved_paths[p].path, path) == 0)
  503.         return saved_paths[p].dir_list;
  504.     }
  505.   
  506.   return NULL;
  507. }
  508.