src/pathchk.c

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