src/pathchk.c

   1 /* pathchk -- check whether pathnames are valid or portable
   2    Copyright (C) 91, 92, 93, 1994 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
  16    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 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.1
  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 "version.h"
  47 #include "system.h"
  48 #include "safe-stat.h"
  49
  50 #ifdef _POSIX_VERSION
  51 #include <limits.h>
  52 #ifndef PATH_MAX
  53 #define PATH_MAX_FOR(p) pathconf ((p), _PC_PATH_MAX)
  54 #endif /* not PATH_MAX */
  55 #ifndef NAME_MAX
  56 #define NAME_MAX_FOR(p) pathconf ((p), _PC_NAME_MAX);
  57 #endif /* not NAME_MAX */
  58
  59 #else /* not _POSIX_VERSION */
  60
  61 #include <sys/param.h>
  62 #ifndef PATH_MAX
  63 #ifdef MAXPATHLEN
  64 #define PATH_MAX MAXPATHLEN
  65 #else /* not MAXPATHLEN */
  66 #define PATH_MAX _POSIX_PATH_MAX
  67 #endif /* not MAXPATHLEN */
  68 #endif /* not PATH_MAX */
  69
  70 #ifndef NAME_MAX
  71 #ifdef MAXNAMLEN
  72 #define NAME_MAX MAXNAMLEN
  73 #else /* not MAXNAMLEN */
  74 #define NAME_MAX _POSIX_NAME_MAX
  75 #endif /* not MAXNAMLEN */
  76 #endif /* not NAME_MAX */
  77
  78 #endif /* not _POSIX_VERSION */
  79
  80 #ifndef _POSIX_PATH_MAX
  81 #define _POSIX_PATH_MAX 255
  82 #endif
  83 #ifndef _POSIX_NAME_MAX
  84 #define _POSIX_NAME_MAX 14
  85 #endif
  86
  87 #ifndef PATH_MAX_FOR
  88 #define PATH_MAX_FOR(p) PATH_MAX
  89 #endif
  90 #ifndef NAME_MAX_FOR
  91 #define NAME_MAX_FOR(p) NAME_MAX
  92 #endif
  93
  94 char *xstrdup ();
  95 void error ();
  96
  97 static int validate_path ();
  98 static void usage ();
  99
 100 /* The name this program was run with. */
 101 char *program_name;
 102
 103 /* If non-zero, display usage information and exit.  */
 104 static int show_help;
 105
 106 /* If non-zero, print the version on standard output and exit.  */
 107 static int show_version;
 108
 109 static struct option const longopts[] =
 110 {
 111   {"help", no_argument, &show_help, 1},
 112   {"portability", no_argument, NULL, 'p'},
 113   {"version", no_argument, &show_version, 1},
 114   {NULL, 0, NULL, 0}
 115 };
 116
 117 void
 118 main (argc, argv)
 119      int argc;
 120      char **argv;
 121 {
 122   int exit_status = 0;
 123   int check_portability = 0;
 124   int optc;
 125
 126   program_name = argv[0];
 127
 128   while ((optc = getopt_long (argc, argv, "p", longopts, (int *) 0)) != EOF)
 129     {
 130       switch (optc)
 131         {
 132         case 0:
 133           break;
 134
 135         case 'p':
 136           check_portability = 1;
 137           break;
 138
 139         default:
 140           usage (1);
 141         }
 142     }
 143
 144   if (show_version)
 145     {
 146       printf ("pathchk - %s\n", version_string);
 147       exit (0);
 148     }
 149
 150   if (show_help)
 151     usage (0);
 152
 153   if (optind == argc)
 154     usage (1);
 155
 156   for (; optind < argc; ++optind)
 157     exit_status |= validate_path (argv[optind], check_portability);
 158
 159   exit (exit_status);
 160 }
 161
 162 /* Each element is nonzero if the corresponding ASCII character is
 163    in the POSIX portable character set, and zero if it is not.
 164    In addition, the entry for `/' is nonzero to simplify checking. */
 165 static char const portable_chars[256] =
 166 {
 167   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0-15 */
 168   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 16-31 */
 169   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, /* 32-47 */
 170   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 48-63 */
 171   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 64-79 */
 172   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 80-95 */
 173   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 96-111 */
 174   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 112-127 */
 175   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 176   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 177   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 178   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 179   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 180   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 181   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 182   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 183 };
 184
 185 /* If PATH contains only portable characters, return 1, else 0.  */
 186
 187 static int
 188 portable_chars_only (path)
 189      const char *path;
 190 {
 191   const char *p;
 192
 193   for (p = path; *p; ++p)
 194     if (portable_chars[(const unsigned char) *p] == 0)
 195       {
 196         error (0, 0, "path `%s' contains nonportable character `%c'",
 197                path, *p);
 198         return 0;
 199       }
 200   return 1;
 201 }
 202
 203 /* Return 1 if PATH is a usable leading directory, 0 if not,
 204    2 if it doesn't exist.  */
 205
 206 static int
 207 dir_ok (path)
 208      const char *path;
 209 {
 210   struct stat stats;
 211
 212   if (SAFE_STAT (path, &stats))
 213     return 2;
 214
 215   if (!S_ISDIR (stats.st_mode))
 216     {
 217       error (0, 0, "`%s' is not a directory", path);
 218       return 0;
 219     }
 220
 221   /* Use access to test for search permission because
 222      testing permission bits of st_mode can lose with new
 223      access control mechanisms.  Of course, access loses if you're
 224      running setuid. */
 225   if (access (path, X_OK) != 0)
 226     {
 227       if (errno == EACCES)
 228         error (0, 0, "directory `%s' is not searchable", path);
 229       else
 230         error (0, errno, "%s", path);
 231       return 0;
 232     }
 233
 234   return 1;
 235 }
 236
 237 /* Make sure that
 238    strlen (PATH) <= PATH_MAX
 239    && strlen (each-existing-directory-in-PATH) <= NAME_MAX
 240
 241    If PORTABILITY is nonzero, compare against _POSIX_PATH_MAX and
 242    _POSIX_NAME_MAX instead, and make sure that PATH contains no
 243    characters not in the POSIX portable filename character set, which
 244    consists of A-Z, a-z, 0-9, ., _, -.
 245
 246    Make sure that all leading directories along PATH that exist have
 247    `x' permission.
 248
 249    Return 0 if all of these tests are successful, 1 if any fail. */
 250
 251 static int
 252 validate_path (path, portability)
 253      char *path;
 254      int portability;
 255 {
 256   int path_max;
 257   int last_elem;                /* Nonzero if checking last element of path. */
 258   int exists;                   /* 2 if the path element exists.  */
 259   char *slash;
 260   char *parent;                 /* Last existing leading directory so far.  */
 261
 262   if (portability && !portable_chars_only (path))
 263     return 1;
 264
 265   if (*path == '\0')
 266     return 0;
 267
 268 #ifdef lint
 269   /* Suppress `used before initialized' warning.  */
 270   exists = 0;
 271 #endif
 272
 273   /* Figure out the parent of the first element in PATH.  */
 274   parent = xstrdup (*path == '/' ? "/" : ".");
 275
 276   slash = path;
 277   last_elem = 0;
 278   while (1)
 279     {
 280       int name_max;
 281       int length;               /* Length of partial path being checked. */
 282       char *start;              /* Start of path element being checked. */
 283
 284       /* Find the end of this element of the path.
 285          Then chop off the rest of the path after this element. */
 286       while (*slash == '/')
 287         slash++;
 288       start = slash;
 289       slash = index (slash, '/');
 290       if (slash != NULL)
 291         *slash = '\0';
 292       else
 293         {
 294           last_elem = 1;
 295           slash = index (start, '\0');
 296         }
 297
 298       if (!last_elem)
 299         {
 300           exists = dir_ok (path);
 301           if (dir_ok == 0)
 302             {
 303               free (parent);
 304               return 1;
 305             }
 306         }
 307
 308       length = slash - start;
 309       /* Since we know that `parent' is a directory, it's ok to call
 310          pathconf with it as the argument.  (If `parent' isn't a directory
 311          or doesn't exist, the behavior of pathconf is undefined.)
 312          But if `parent' is a directory and is on a remote file system,
 313          it's likely that pathconf can't give us a reasonable value
 314          and will return -1.  (NFS and tempfs are not POSIX . . .)
 315          In that case, we have no choice but to assume the pessimal
 316          POSIX minimums.  */
 317       name_max = portability ? _POSIX_NAME_MAX : NAME_MAX_FOR (parent);
 318       if (name_max < 0)
 319         name_max = _POSIX_NAME_MAX;
 320       if (length > name_max)
 321         {
 322           error (0, 0, "name `%s' has length %d; exceeds limit of %d",
 323                  start, length, name_max);
 324           free (parent);
 325           return 1;
 326         }
 327
 328       if (last_elem)
 329         break;
 330
 331       if (exists == 1)
 332         {
 333           free (parent);
 334           parent = xstrdup (path);
 335         }
 336
 337       *slash++ = '/';
 338     }
 339
 340   /* `parent' is now the last existing leading directory in the whole path,
 341      so it's ok to call pathconf with it as the argument.  */
 342   path_max = portability ? _POSIX_PATH_MAX : PATH_MAX_FOR (parent);
 343   if (path_max < 0)
 344     path_max = _POSIX_PATH_MAX;
 345   free (parent);
 346   if (strlen (path) > path_max)
 347     {
 348       error (0, 0, "path `%s' has length %d; exceeds limit of %d",
 349              path, strlen (path), path_max);
 350       return 1;
 351     }
 352
 353   return 0;
 354 }
 355
 356 static void
 357 usage (status)
 358      int status;
 359 {
 360   if (status != 0)
 361     fprintf (stderr, "Try `%s --help' for more information.\n",
 362              program_name);
 363   else
 364     {
 365       printf ("Usage: %s [OPTION]... PATH...\n", program_name);
 366       printf ("\
 367 \n\
 368   -p, --portability   check for all POSIX systems, not only this one\n\
 369       --help          display this help and exit\n\
 370       --version       output version information and exit\n\
 371 ");
 372     }
 373   exit (status);
 374 }