src/pathchk.c

   1 /* pathchk -- check whether pathnames are valid or portable
   2    Copyright (C) 1991-2003 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Usage: pathchk [-p] [--portability] path...
  19
  20    For each PATH, print a message if any of these conditions are false:
  21    * all existing leading directories in PATH have search (execute) permission
  22    * strlen (PATH) <= PATH_MAX
  23    * strlen (each_directory_in_PATH) <= NAME_MAX
  24
  25    Exit status:
  26    0                    All PATH names passed all of the tests.
  27    1                    An error occurred.
  28
  29    Options:
  30    -p, --portability    Instead of performing length checks on the
  31                         underlying filesystem, test the length of the
  32                         pathname and its components against the POSIX
  33                         minimum limits for portability, _POSIX_NAME_MAX
  34                         and _POSIX_PATH_MAX in 2.9.2.  Also check that
  35                         the pathname contains no character not in the
  36                         portable filename character set.
  37
  38    David MacKenzie <djm@gnu.ai.mit.edu>
  39    and Jim Meyering <meyering@cs.utexas.edu> */
  40
  41 #include <config.h>
  42 #include <stdio.h>
  43 #include <getopt.h>
  44 #include <sys/types.h>
  45
  46 #include <errno.h>
  47 #ifndef errno
  48 extern int errno;
  49 #endif
  50
  51 #include "system.h"
  52 #include "error.h"
  53 #include "long-options.h"
  54 #include "closeout.h"
  55
  56 /* The official name of this program (e.g., no `g' prefix).  */
  57 #define PROGRAM_NAME "pathchk"
  58
  59 #define AUTHORS N_ ("David MacKenzie and Jim Meyering")
  60
  61 #define NEED_PATHCONF_WRAPPER 0
  62 #if HAVE_PATHCONF
  63 # ifndef PATH_MAX
  64 #  define PATH_MAX_FOR(p) pathconf_wrapper ((p), _PC_PATH_MAX)
  65 #  define NEED_PATHCONF_WRAPPER 1
  66 # endif /* not PATH_MAX */
  67 # ifndef NAME_MAX
  68 #  define NAME_MAX_FOR(p) pathconf_wrapper ((p), _PC_NAME_MAX);
  69 #  undef NEED_PATHCONF_WRAPPER
  70 #  define NEED_PATHCONF_WRAPPER 1
  71 # endif /* not NAME_MAX */
  72
  73 #else
  74
  75 # include <sys/param.h>
  76 # ifndef PATH_MAX
  77 #  ifdef MAXPATHLEN
  78 #   define PATH_MAX MAXPATHLEN
  79 #  else /* not MAXPATHLEN */
  80 #   define PATH_MAX _POSIX_PATH_MAX
  81 #  endif /* not MAXPATHLEN */
  82 # endif /* not PATH_MAX */
  83
  84 # ifndef NAME_MAX
  85 #  ifdef MAXNAMLEN
  86 #   define NAME_MAX MAXNAMLEN
  87 #  else /* not MAXNAMLEN */
  88 #   define NAME_MAX _POSIX_NAME_MAX
  89 #  endif /* not MAXNAMLEN */
  90 # endif /* not NAME_MAX */
  91
  92 #endif
  93
  94 #ifndef _POSIX_PATH_MAX
  95 # define _POSIX_PATH_MAX 255
  96 #endif
  97 #ifndef _POSIX_NAME_MAX
  98 # define _POSIX_NAME_MAX 14
  99 #endif
 100
 101 #ifndef PATH_MAX_FOR
 102 # define PATH_MAX_FOR(p) PATH_MAX
 103 #endif
 104 #ifndef NAME_MAX_FOR
 105 # define NAME_MAX_FOR(p) NAME_MAX
 106 #endif
 107
 108 static int validate_path (char *path, int portability);
 109
 110 /* The name this program was run with. */
 111 char *program_name;
 112
 113 static struct option const longopts[] =
 114 {
 115   {"portability", no_argument, NULL, 'p'},
 116   {NULL, 0, NULL, 0}
 117 };
 118
 119 #if NEED_PATHCONF_WRAPPER
 120 /* Distinguish between the cases when pathconf fails and when it reports there
 121    is no limit (the latter is the case for PATH_MAX on the Hurd).  When there
 122    is no limit, return LONG_MAX.  Otherwise, return pathconf's return value.  */
 123
 124 static long int
 125 pathconf_wrapper (const char *filename, int param)
 126 {
 127   long int ret;
 128
 129   errno = 0;
 130   ret = pathconf (filename, param);
 131   if (ret < 0 && errno == 0)
 132     return LONG_MAX;
 133
 134   return ret;
 135 }
 136 #endif
 137
 138 void
 139 usage (int status)
 140 {
 141   if (status != 0)
 142     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 143              program_name);
 144   else
 145     {
 146       printf (_("Usage: %s [OPTION]... NAME...\n"), program_name);
 147       fputs (_("\
 148 Diagnose unportable constructs in NAME.\n\
 149 \n\
 150   -p, --portability   check for all POSIX systems, not only this one\n\
 151 "), stdout);
 152       fputs (HELP_OPTION_DESCRIPTION, stdout);
 153       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 154       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 155     }
 156   exit (status);
 157 }
 158
 159 int
 160 main (int argc, char **argv)
 161 {
 162   int exit_status = 0;
 163   int check_portability = 0;
 164   int optc;
 165
 166   program_name = argv[0];
 167   setlocale (LC_ALL, "");
 168   bindtextdomain (PACKAGE, LOCALEDIR);
 169   textdomain (PACKAGE);
 170
 171   atexit (close_stdout);
 172
 173   parse_long_options (argc, argv, PROGRAM_NAME, GNU_PACKAGE, VERSION,
 174                       AUTHORS, usage);
 175
 176   while ((optc = getopt_long (argc, argv, "p", longopts, NULL)) != -1)
 177     {
 178       switch (optc)
 179         {
 180         case 0:
 181           break;
 182
 183         case 'p':
 184           check_portability = 1;
 185           break;
 186
 187         default:
 188           usage (EXIT_FAILURE);
 189         }
 190     }
 191
 192   if (optind == argc)
 193     {
 194       error (0, 0, _("too few arguments"));
 195       usage (EXIT_FAILURE);
 196     }
 197
 198   for (; optind < argc; ++optind)
 199     exit_status |= validate_path (argv[optind], check_portability);
 200
 201   exit (exit_status);
 202 }
 203
 204 /* Each element is nonzero if the corresponding ASCII character is
 205    in the POSIX portable character set, and zero if it is not.
 206    In addition, the entry for `/' is nonzero to simplify checking. */
 207 static char const portable_chars[256] =
 208 {
 209   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0-15 */
 210   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16-31 */
 211   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, /* 32-47 */
 212   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 48-63 */
 213   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 64-79 */
 214   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 80-95 */
 215   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 96-111 */
 216   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 112-127 */
 217   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 218   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 219   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 220   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 221   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 222   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 223   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 224   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 225 };
 226
 227 /* If PATH contains only portable characters, return 1, else 0.  */
 228
 229 static int
 230 portable_chars_only (const char *path)
 231 {
 232   const char *p;
 233
 234   for (p = path; *p; ++p)
 235     if (portable_chars[(unsigned char) *p] == 0)
 236       {
 237         error (0, 0, _("path `%s' contains nonportable character `%c'"),
 238                path, *p);
 239         return 0;
 240       }
 241   return 1;
 242 }
 243
 244 /* Return 1 if PATH is a usable leading directory, 0 if not,
 245    2 if it doesn't exist.  */
 246
 247 static int
 248 dir_ok (const char *path)
 249 {
 250   struct stat stats;
 251
 252   if (stat (path, &stats))
 253     return 2;
 254
 255   if (!S_ISDIR (stats.st_mode))
 256     {
 257       error (0, 0, _("`%s' is not a directory"), path);
 258       return 0;
 259     }
 260
 261   /* Use access to test for search permission because
 262      testing permission bits of st_mode can lose with new
 263      access control mechanisms.  Of course, access loses if you're
 264      running setuid. */
 265   if (access (path, X_OK) != 0)
 266     {
 267       if (errno == EACCES)
 268         error (0, 0, _("directory `%s' is not searchable"), path);
 269       else
 270         error (0, errno, "%s", path);
 271       return 0;
 272     }
 273
 274   return 1;
 275 }
 276
 277 /* Make sure that
 278    strlen (PATH) <= PATH_MAX
 279    && strlen (each-existing-directory-in-PATH) <= NAME_MAX
 280
 281    If PORTABILITY is nonzero, compare against _POSIX_PATH_MAX and
 282    _POSIX_NAME_MAX instead, and make sure that PATH contains no
 283    characters not in the POSIX portable filename character set, which
 284    consists of A-Z, a-z, 0-9, ., _, -.
 285
 286    Make sure that all leading directories along PATH that exist have
 287    `x' permission.
 288
 289    Return 0 if all of these tests are successful, 1 if any fail. */
 290
 291 static int
 292 validate_path (char *path, int portability)
 293 {
 294   long int path_max;
 295   int last_elem;                /* Nonzero if checking last element of path. */
 296   int exists IF_LINT (= 0);     /* 2 if the path element exists.  */
 297   char *slash;
 298   char *parent;                 /* Last existing leading directory so far.  */
 299
 300   if (portability && !portable_chars_only (path))
 301     return 1;
 302
 303   if (*path == '\0')
 304     return 0;
 305
 306   /* Figure out the parent of the first element in PATH.  */
 307   parent = xstrdup (*path == '/' ? "/" : ".");
 308
 309   slash = path;
 310   last_elem = 0;
 311   while (1)
 312     {
 313       long int name_max;
 314       long int length;          /* Length of partial path being checked. */
 315       char *start;              /* Start of path element being checked. */
 316
 317       /* Find the end of this element of the path.
 318          Then chop off the rest of the path after this element. */
 319       while (*slash == '/')
 320         slash++;
 321       start = slash;
 322       slash = strchr (slash, '/');
 323       if (slash != NULL)
 324         *slash = '\0';
 325       else
 326         {
 327           last_elem = 1;
 328           slash = strchr (start, '\0');
 329         }
 330
 331       if (!last_elem)
 332         {
 333           exists = dir_ok (path);
 334           if (exists == 0)
 335             {
 336               free (parent);
 337               return 1;
 338             }
 339         }
 340
 341       length = slash - start;
 342       /* Since we know that `parent' is a directory, it's ok to call
 343          pathconf with it as the argument.  (If `parent' isn't a directory
 344          or doesn't exist, the behavior of pathconf is undefined.)
 345          But if `parent' is a directory and is on a remote file system,
 346          it's likely that pathconf can't give us a reasonable value
 347          and will return -1.  (NFS and tempfs are not POSIX . . .)
 348          In that case, we have no choice but to assume the pessimal
 349          POSIX minimums.  */
 350       name_max = portability ? _POSIX_NAME_MAX : NAME_MAX_FOR (parent);
 351       if (name_max < 0)
 352         name_max = _POSIX_NAME_MAX;
 353       if (length > name_max)
 354         {
 355           error (0, 0, _("name `%s' has length %ld; exceeds limit of %ld"),
 356                  start, length, name_max);
 357           free (parent);
 358           return 1;
 359         }
 360
 361       if (last_elem)
 362         break;
 363
 364       if (exists == 1)
 365         {
 366           free (parent);
 367           parent = xstrdup (path);
 368         }
 369
 370       *slash++ = '/';
 371     }
 372
 373   /* `parent' is now the last existing leading directory in the whole path,
 374      so it's ok to call pathconf with it as the argument.  */
 375   path_max = portability ? _POSIX_PATH_MAX : PATH_MAX_FOR (parent);
 376   if (path_max < 0)
 377     path_max = _POSIX_PATH_MAX;
 378   free (parent);
 379   if (strlen (path) > (size_t) path_max)
 380     {
 381       error (0, 0, _("path `%s' has length %d; exceeds limit of %ld"),
 382              path, strlen (path), path_max);
 383       return 1;
 384     }
 385
 386   return 0;
 387 }