src/pathchk.c

   1 /* pathchk -- check whether file names are valid or portable
   2    Copyright (C) 1991-2007 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 #include <config.h>
  19 #include <stdio.h>
  20 #include <getopt.h>
  21 #include <sys/types.h>
  22 #if HAVE_WCHAR_H
  23 # include <wchar.h>
  24 #endif
  25
  26 #include "system.h"
  27 #include "error.h"
  28 #include "quote.h"
  29 #include "quotearg.h"
  30
  31 #if ! (HAVE_MBRLEN && HAVE_MBSTATE_T)
  32 # define mbrlen(s, n, ps) 1
  33 # define mbstate_t int
  34 #endif
  35
  36 /* The official name of this program (e.g., no `g' prefix).  */
  37 #define PROGRAM_NAME "pathchk"
  38
  39 #define AUTHORS "Paul Eggert", "David MacKenzie", "Jim Meyering"
  40
  41 #ifndef _POSIX_PATH_MAX
  42 # define _POSIX_PATH_MAX 256
  43 #endif
  44 #ifndef _POSIX_NAME_MAX
  45 # define _POSIX_NAME_MAX 14
  46 #endif
  47
  48 #ifdef _XOPEN_NAME_MAX
  49 # define NAME_MAX_MINIMUM _XOPEN_NAME_MAX
  50 #else
  51 # define NAME_MAX_MINIMUM _POSIX_NAME_MAX
  52 #endif
  53 #ifdef _XOPEN_PATH_MAX
  54 # define PATH_MAX_MINIMUM _XOPEN_PATH_MAX
  55 #else
  56 # define PATH_MAX_MINIMUM _POSIX_PATH_MAX
  57 #endif
  58
  59 #if ! (HAVE_PATHCONF && defined _PC_NAME_MAX && defined _PC_PATH_MAX)
  60 # ifndef _PC_NAME_MAX
  61 #  define _PC_NAME_MAX 0
  62 #  define _PC_PATH_MAX 1
  63 # endif
  64 # ifndef pathconf
  65 #  define pathconf(file, flag) \
  66      (flag == _PC_NAME_MAX ? NAME_MAX_MINIMUM : PATH_MAX_MINIMUM)
  67 # endif
  68 #endif
  69
  70 static bool validate_file_name (char *, bool, bool);
  71
  72 /* The name this program was run with. */
  73 char *program_name;
  74
  75 /* For long options that have no equivalent short option, use a
  76    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  77 enum
  78 {
  79   PORTABILITY_OPTION = CHAR_MAX + 1
  80 };
  81
  82 static struct option const longopts[] =
  83 {
  84   {"portability", no_argument, NULL, PORTABILITY_OPTION},
  85   {GETOPT_HELP_OPTION_DECL},
  86   {GETOPT_VERSION_OPTION_DECL},
  87   {NULL, 0, NULL, 0}
  88 };
  89
  90 void
  91 usage (int status)
  92 {
  93   if (status != EXIT_SUCCESS)
  94     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  95              program_name);
  96   else
  97     {
  98       printf (_("Usage: %s [OPTION]... NAME...\n"), program_name);
  99       fputs (_("\
 100 Diagnose unportable constructs in NAME.\n\
 101 \n\
 102   -p                  check for most POSIX systems\n\
 103   -P                  check for empty names and leading \"-\"\n\
 104       --portability   check for all POSIX systems (equivalent to -p -P)\n\
 105 "), stdout);
 106       fputs (HELP_OPTION_DESCRIPTION, stdout);
 107       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 108       emit_bug_reporting_address ();
 109     }
 110   exit (status);
 111 }
 112
 113 int
 114 main (int argc, char **argv)
 115 {
 116   bool ok = true;
 117   bool check_basic_portability = false;
 118   bool check_extra_portability = false;
 119   int optc;
 120
 121   initialize_main (&argc, &argv);
 122   program_name = argv[0];
 123   setlocale (LC_ALL, "");
 124   bindtextdomain (PACKAGE, LOCALEDIR);
 125   textdomain (PACKAGE);
 126
 127   atexit (close_stdout);
 128
 129   while ((optc = getopt_long (argc, argv, "+pP", longopts, NULL)) != -1)
 130     {
 131       switch (optc)
 132         {
 133         case PORTABILITY_OPTION:
 134           check_basic_portability = true;
 135           check_extra_portability = true;
 136           break;
 137
 138         case 'p':
 139           check_basic_portability = true;
 140           break;
 141
 142         case 'P':
 143           check_extra_portability = true;
 144           break;
 145
 146         case_GETOPT_HELP_CHAR;
 147
 148         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 149
 150         default:
 151           usage (EXIT_FAILURE);
 152         }
 153     }
 154
 155   if (optind == argc)
 156     {
 157       error (0, 0, _("missing operand"));
 158       usage (EXIT_FAILURE);
 159     }
 160
 161   for (; optind < argc; ++optind)
 162     ok &= validate_file_name (argv[optind],
 163                               check_basic_portability, check_extra_portability);
 164
 165   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 166 }
 167
 168 /* If FILE contains a component with a leading "-", report an error
 169    and return false; otherwise, return true.  */
 170
 171 static bool
 172 no_leading_hyphen (char const *file)
 173 {
 174   char const *p;
 175
 176   for (p = file;  (p = strchr (p, '-'));  p++)
 177     if (p == file || p[-1] == '/')
 178       {
 179         error (0, 0, _("leading `-' in a component of file name %s"),
 180                quote (file));
 181         return false;
 182       }
 183
 184   return true;
 185 }
 186
 187 /* If FILE (of length FILELEN) contains only portable characters,
 188    return true, else report an error and return false.  */
 189
 190 static bool
 191 portable_chars_only (char const *file, size_t filelen)
 192 {
 193   size_t validlen = strspn (file,
 194                             ("/"
 195                              "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 196                              "abcdefghijklmnopqrstuvwxyz"
 197                              "0123456789._-"));
 198   char const *invalid = file + validlen;
 199
 200   if (*invalid)
 201     {
 202       mbstate_t mbstate = { 0, };
 203       size_t charlen = mbrlen (invalid, filelen - validlen, &mbstate);
 204       error (0, 0,
 205              _("nonportable character %s in file name %s"),
 206              quotearg_n_style_mem (1, locale_quoting_style, invalid,
 207                                    (charlen <= MB_LEN_MAX ? charlen : 1)),
 208              quote_n (0, file));
 209       return false;
 210     }
 211
 212   return true;
 213 }
 214
 215 /* Return the address of the start of the next file name component in F.  */
 216
 217 static char *
 218 component_start (char *f)
 219 {
 220   while (*f == '/')
 221     f++;
 222   return f;
 223 }
 224
 225 /* Return the size of the file name component F.  F must be nonempty.  */
 226
 227 static size_t
 228 component_len (char const *f)
 229 {
 230   size_t len;
 231   for (len = 1; f[len] != '/' && f[len]; len++)
 232     continue;
 233   return len;
 234 }
 235
 236 /* Make sure that
 237    strlen (FILE) <= PATH_MAX
 238    && strlen (each-existing-directory-in-FILE) <= NAME_MAX
 239
 240    If CHECK_BASIC_PORTABILITY is true, compare against _POSIX_PATH_MAX and
 241    _POSIX_NAME_MAX instead, and make sure that FILE contains no
 242    characters not in the POSIX portable filename character set, which
 243    consists of A-Z, a-z, 0-9, ., _, - (plus / for separators).
 244
 245    If CHECK_BASIC_PORTABILITY is false, make sure that all leading directories
 246    along FILE that exist are searchable.
 247
 248    If CHECK_EXTRA_PORTABILITY is true, check that file name components do not
 249    begin with "-".
 250
 251    If either CHECK_BASIC_PORTABILITY or CHECK_EXTRA_PORTABILITY is true,
 252    check that the file name is not empty.
 253
 254    Return true if all of these tests are successful, false if any fail.  */
 255
 256 static bool
 257 validate_file_name (char *file, bool check_basic_portability,
 258                     bool check_extra_portability)
 259 {
 260   size_t filelen = strlen (file);
 261
 262   /* Start of file name component being checked.  */
 263   char *start;
 264
 265   /* True if component lengths need to be checked.  */
 266   bool check_component_lengths;
 267
 268   /* True if the file is known to exist.  */
 269   bool file_exists = false;
 270
 271   if (check_extra_portability && ! no_leading_hyphen (file))
 272     return false;
 273
 274   if ((check_basic_portability | check_extra_portability)
 275       && filelen == 0)
 276     {
 277       /* Fail, since empty names are not portable.  As of
 278          2005-01-06 POSIX does not address whether "pathchk -p ''"
 279          should (or is allowed to) fail, so this is not a
 280          conformance violation.  */
 281       error (0, 0, _("empty file name"));
 282       return false;
 283     }
 284
 285   if (check_basic_portability)
 286     {
 287       if (! portable_chars_only (file, filelen))
 288         return false;
 289     }
 290   else
 291     {
 292       /* Check whether a file name component is in a directory that
 293          is not searchable, or has some other serious problem.
 294          POSIX does not allow "" as a file name, but some non-POSIX
 295          hosts do (as an alias for "."), so allow "" if lstat does.  */
 296
 297       struct stat st;
 298       if (lstat (file, &st) == 0)
 299         file_exists = true;
 300       else if (errno != ENOENT || filelen == 0)
 301         {
 302           error (0, errno, "%s", file);
 303           return false;
 304         }
 305     }
 306
 307   if (check_basic_portability
 308       || (! file_exists && PATH_MAX_MINIMUM <= filelen))
 309     {
 310       size_t maxsize;
 311
 312       if (check_basic_portability)
 313         maxsize = _POSIX_PATH_MAX;
 314       else
 315         {
 316           long int size;
 317           char const *dir = (*file == '/' ? "/" : ".");
 318           errno = 0;
 319           size = pathconf (dir, _PC_PATH_MAX);
 320           if (size < 0 && errno != 0)
 321             {
 322               error (0, errno,
 323                      _("%s: unable to determine maximum file name length"),
 324                      dir);
 325               return false;
 326             }
 327           maxsize = MIN (size, SIZE_MAX);
 328         }
 329
 330       if (maxsize <= filelen)
 331         {
 332           unsigned long int len = filelen;
 333           unsigned long int maxlen = maxsize - 1;
 334           error (0, 0, _("limit %lu exceeded by length %lu of file name %s"),
 335                  maxlen, len, quote (file));
 336           return false;
 337         }
 338     }
 339
 340   /* Check whether pathconf (..., _PC_NAME_MAX) can be avoided, i.e.,
 341      whether all file name components are so short that they are valid
 342      in any file system on this platform.  If CHECK_BASIC_PORTABILITY, though,
 343      it's more convenient to check component lengths below.  */
 344
 345   check_component_lengths = check_basic_portability;
 346   if (! check_component_lengths && ! file_exists)
 347     {
 348       for (start = file; *(start = component_start (start)); )
 349         {
 350           size_t length = component_len (start);
 351
 352           if (NAME_MAX_MINIMUM < length)
 353             {
 354               check_component_lengths = true;
 355               break;
 356             }
 357
 358           start += length;
 359         }
 360     }
 361
 362   if (check_component_lengths)
 363     {
 364       /* The limit on file name components for the current component.
 365          This defaults to NAME_MAX_MINIMUM, for the sake of non-POSIX
 366          systems (NFS, say?) where pathconf fails on "." or "/" with
 367          errno == ENOENT.  */
 368       size_t name_max = NAME_MAX_MINIMUM;
 369
 370       /* If nonzero, the known limit on file name components.  */
 371       size_t known_name_max = (check_basic_portability ? _POSIX_NAME_MAX : 0);
 372
 373       for (start = file; *(start = component_start (start)); )
 374         {
 375           size_t length;
 376
 377           if (known_name_max)
 378             name_max = known_name_max;
 379           else
 380             {
 381               long int len;
 382               char const *dir = (start == file ? "." : file);
 383               char c = *start;
 384               errno = 0;
 385               *start = '\0';
 386               len = pathconf (dir, _PC_NAME_MAX);
 387               *start = c;
 388               if (0 <= len)
 389                 name_max = MIN (len, SIZE_MAX);
 390               else
 391                 switch (errno)
 392                   {
 393                   case 0:
 394                     /* There is no limit.  */
 395                     name_max = SIZE_MAX;
 396                     break;
 397
 398                   case ENOENT:
 399                     /* DIR does not exist; use its parent's maximum.  */
 400                     known_name_max = name_max;
 401                     break;
 402
 403                   default:
 404                     *start = '\0';
 405                     error (0, errno, "%s", dir);
 406                     *start = c;
 407                     return false;
 408                   }
 409             }
 410
 411           length = component_len (start);
 412
 413           if (name_max < length)
 414             {
 415               unsigned long int len = length;
 416               unsigned long int maxlen = name_max;
 417               char c = start[len];
 418               start[len] = '\0';
 419               error (0, 0,
 420                      _("limit %lu exceeded by length %lu "
 421                        "of file name component %s"),
 422                      maxlen, len, quote (start));
 423               start[len] = c;
 424               return false;
 425             }
 426
 427           start += length;
 428         }
 429     }
 430
 431   return true;
 432 }