src/chmod.c

   1 /* chmod -- change permission modes of files
   2    Copyright (C) 89, 90, 91, 1995-2006 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 /* Written by David MacKenzie <djm@gnu.ai.mit.edu> */
  19
  20 #include <config.h>
  21 #include <stdio.h>
  22 #include <getopt.h>
  23 #include <sys/types.h>
  24
  25 #include "system.h"
  26 #include "dev-ino.h"
  27 #include "dirname.h"
  28 #include "error.h"
  29 #include "filemode.h"
  30 #include "modechange.h"
  31 #include "openat.h"
  32 #include "quote.h"
  33 #include "quotearg.h"
  34 #include "root-dev-ino.h"
  35 #include "xfts.h"
  36
  37 /* The official name of this program (e.g., no `g' prefix).  */
  38 #define PROGRAM_NAME "chmod"
  39
  40 #define AUTHORS "David MacKenzie", "Jim Meyering"
  41
  42 enum Change_status
  43 {
  44   CH_NOT_APPLIED,
  45   CH_SUCCEEDED,
  46   CH_FAILED,
  47   CH_NO_CHANGE_REQUESTED
  48 };
  49
  50 enum Verbosity
  51 {
  52   /* Print a message for each file that is processed.  */
  53   V_high,
  54
  55   /* Print a message for each file whose attributes we change.  */
  56   V_changes_only,
  57
  58   /* Do not be verbose.  This is the default. */
  59   V_off
  60 };
  61
  62 /* The name the program was run with. */
  63 char *program_name;
  64
  65 /* The desired change to the mode.  */
  66 static struct mode_change *change;
  67
  68 /* The initial umask value, if it might be needed.  */
  69 static mode_t umask_value;
  70
  71 /* If true, change the modes of directories recursively. */
  72 static bool recurse;
  73
  74 /* If true, force silence (no error messages). */
  75 static bool force_silent;
  76
  77 /* If true, diagnose surprises from naive misuses like "chmod -r file".
  78    POSIX allows diagnostics here, as portable code is supposed to use
  79    "chmod -- -r file".  */
  80 static bool diagnose_surprises;
  81
  82 /* Level of verbosity.  */
  83 static enum Verbosity verbosity = V_off;
  84
  85 /* Pointer to the device and inode numbers of `/', when --recursive.
  86    Otherwise NULL.  */
  87 static struct dev_ino *root_dev_ino;
  88
  89 /* For long options that have no equivalent short option, use a
  90    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  91 enum
  92 {
  93   NO_PRESERVE_ROOT = CHAR_MAX + 1,
  94   PRESERVE_ROOT,
  95   REFERENCE_FILE_OPTION
  96 };
  97
  98 static struct option const long_options[] =
  99 {
 100   {"changes", no_argument, NULL, 'c'},
 101   {"recursive", no_argument, NULL, 'R'},
 102   {"no-preserve-root", no_argument, NULL, NO_PRESERVE_ROOT},
 103   {"preserve-root", no_argument, NULL, PRESERVE_ROOT},
 104   {"quiet", no_argument, NULL, 'f'},
 105   {"reference", required_argument, NULL, REFERENCE_FILE_OPTION},
 106   {"silent", no_argument, NULL, 'f'},
 107   {"verbose", no_argument, NULL, 'v'},
 108   {GETOPT_HELP_OPTION_DECL},
 109   {GETOPT_VERSION_OPTION_DECL},
 110   {NULL, 0, NULL, 0}
 111 };
 112
 113 /* Return true if the chmodable permission bits of FILE changed.
 114    The old mode was OLD_MODE, but it was changed to NEW_MODE.  */
 115
 116 static bool
 117 mode_changed (char const *file, mode_t old_mode, mode_t new_mode)
 118 {
 119   if (new_mode & (S_ISUID | S_ISGID | S_ISVTX))
 120     {
 121       /* The new mode contains unusual bits that the call to chmod may
 122          have silently cleared.  Check whether they actually changed.  */
 123
 124       struct stat new_stats;
 125
 126       if (stat (file, &new_stats) != 0)
 127         {
 128           if (!force_silent)
 129             error (0, errno, _("getting new attributes of %s"), quote (file));
 130           return false;
 131         }
 132
 133       new_mode = new_stats.st_mode;
 134     }
 135
 136   return ((old_mode ^ new_mode) & CHMOD_MODE_BITS) != 0;
 137 }
 138
 139 /* Tell the user how/if the MODE of FILE has been changed.
 140    CHANGED describes what (if anything) has happened. */
 141
 142 static void
 143 describe_change (const char *file, mode_t mode,
 144                  enum Change_status changed)
 145 {
 146   char perms[12];               /* "-rwxrwxrwx" ls-style modes. */
 147   const char *fmt;
 148
 149   if (changed == CH_NOT_APPLIED)
 150     {
 151       printf (_("neither symbolic link %s nor referent has been changed\n"),
 152               quote (file));
 153       return;
 154     }
 155
 156   strmode (mode, perms);
 157   perms[10] = '\0';             /* Remove trailing space.  */
 158   switch (changed)
 159     {
 160     case CH_SUCCEEDED:
 161       fmt = _("mode of %s changed to %04lo (%s)\n");
 162       break;
 163     case CH_FAILED:
 164       fmt = _("failed to change mode of %s to %04lo (%s)\n");
 165       break;
 166     case CH_NO_CHANGE_REQUESTED:
 167       fmt = _("mode of %s retained as %04lo (%s)\n");
 168       break;
 169     default:
 170       abort ();
 171     }
 172   printf (fmt, quote (file),
 173           (unsigned long int) (mode & CHMOD_MODE_BITS), &perms[1]);
 174 }
 175
 176 /* Change the mode of FILE.
 177    Return true if successful.  This function is called
 178    once for every file system object that fts encounters.  */
 179
 180 static bool
 181 process_file (FTS *fts, FTSENT *ent)
 182 {
 183   char const *file_full_name = ent->fts_path;
 184   char const *file = ent->fts_accpath;
 185   const struct stat *file_stats = ent->fts_statp;
 186   mode_t old_mode IF_LINT (= 0);
 187   mode_t new_mode IF_LINT (= 0);
 188   bool ok = true;
 189   bool chmod_succeeded = false;
 190
 191   switch (ent->fts_info)
 192     {
 193     case FTS_DP:
 194       return true;
 195
 196     case FTS_NS:
 197       error (0, ent->fts_errno, _("cannot access %s"), quote (file_full_name));
 198       ok = false;
 199       break;
 200
 201     case FTS_ERR:
 202       error (0, ent->fts_errno, _("%s"), quote (file_full_name));
 203       ok = false;
 204       break;
 205
 206     case FTS_DNR:
 207       error (0, ent->fts_errno, _("cannot read directory %s"),
 208              quote (file_full_name));
 209       ok = false;
 210       break;
 211
 212     default:
 213       break;
 214     }
 215
 216   if (ok && ROOT_DEV_INO_CHECK (root_dev_ino, file_stats))
 217     {
 218       ROOT_DEV_INO_WARN (file_full_name);
 219       ok = false;
 220     }
 221
 222   if (ok)
 223     {
 224       old_mode = file_stats->st_mode;
 225       new_mode = mode_adjust (old_mode, S_ISDIR (old_mode) != 0, umask_value,
 226                               change, NULL);
 227
 228       if (! S_ISLNK (old_mode))
 229         {
 230           if (chmodat (fts->fts_cwd_fd, file, new_mode) == 0)
 231             chmod_succeeded = true;
 232           else
 233             {
 234               if (! force_silent)
 235                 error (0, errno, _("changing permissions of %s"),
 236                        quote (file_full_name));
 237               ok = false;
 238             }
 239         }
 240     }
 241
 242   if (verbosity != V_off)
 243     {
 244       bool changed = (chmod_succeeded
 245                       && mode_changed (file, old_mode, new_mode));
 246
 247       if (changed || verbosity == V_high)
 248         {
 249           enum Change_status ch_status =
 250             (!ok ? CH_FAILED
 251              : !chmod_succeeded ? CH_NOT_APPLIED
 252              : !changed ? CH_NO_CHANGE_REQUESTED
 253              : CH_SUCCEEDED);
 254           describe_change (file_full_name, new_mode, ch_status);
 255         }
 256     }
 257
 258   if (chmod_succeeded & diagnose_surprises)
 259     {
 260       mode_t naively_expected_mode =
 261         mode_adjust (old_mode, S_ISDIR (old_mode) != 0, 0, change, NULL);
 262       if (new_mode & ~naively_expected_mode)
 263         {
 264           char new_perms[12];
 265           char naively_expected_perms[12];
 266           strmode (new_mode, new_perms);
 267           strmode (naively_expected_mode, naively_expected_perms);
 268           new_perms[10] = naively_expected_perms[10] = '\0';
 269           error (0, 0,
 270                  _("%s: new permissions are %s, not %s"),
 271                  quotearg_colon (file_full_name),
 272                  new_perms + 1, naively_expected_perms + 1);
 273           ok = false;
 274         }
 275     }
 276
 277   if ( ! recurse)
 278     fts_set (fts, ent, FTS_SKIP);
 279
 280   return ok;
 281 }
 282
 283 /* Recursively change the modes of the specified FILES (the last entry
 284    of which is NULL).  BIT_FLAGS controls how fts works.
 285    Return true if successful.  */
 286
 287 static bool
 288 process_files (char **files, int bit_flags)
 289 {
 290   bool ok = true;
 291
 292   FTS *fts = xfts_open (files, bit_flags, NULL);
 293
 294   while (1)
 295     {
 296       FTSENT *ent;
 297
 298       ent = fts_read (fts);
 299       if (ent == NULL)
 300         {
 301           if (errno != 0)
 302             {
 303               /* FIXME: try to give a better message  */
 304               error (0, errno, _("fts_read failed"));
 305               ok = false;
 306             }
 307           break;
 308         }
 309
 310       ok &= process_file (fts, ent);
 311     }
 312
 313   /* Ignore failure, since the only way it can do so is in failing to
 314      return to the original directory, and since we're about to exit,
 315      that doesn't matter.  */
 316   fts_close (fts);
 317
 318   return ok;
 319 }
 320
 321 void
 322 usage (int status)
 323 {
 324   if (status != EXIT_SUCCESS)
 325     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 326              program_name);
 327   else
 328     {
 329       printf (_("\
 330 Usage: %s [OPTION]... MODE[,MODE]... FILE...\n\
 331   or:  %s [OPTION]... OCTAL-MODE FILE...\n\
 332   or:  %s [OPTION]... --reference=RFILE FILE...\n\
 333 "),
 334               program_name, program_name, program_name);
 335       fputs (_("\
 336 Change the mode of each FILE to MODE.\n\
 337 \n\
 338   -c, --changes           like verbose but report only when a change is made\n\
 339 "), stdout);
 340       fputs (_("\
 341       --no-preserve-root  do not treat `/' specially (the default)\n\
 342       --preserve-root     fail to operate recursively on `/'\n\
 343 "), stdout);
 344       fputs (_("\
 345   -f, --silent, --quiet   suppress most error messages\n\
 346   -v, --verbose           output a diagnostic for every file processed\n\
 347       --reference=RFILE   use RFILE's mode instead of MODE values\n\
 348   -R, --recursive         change files and directories recursively\n\
 349 "), stdout);
 350       fputs (HELP_OPTION_DESCRIPTION, stdout);
 351       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 352       fputs (_("\
 353 \n\
 354 Each MODE is of the form `[ugoa]*([-+=]([rwxXst]*|[ugo]))+'.\n\
 355 "), stdout);
 356       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 357     }
 358   exit (status);
 359 }
 360
 361 /* Parse the ASCII mode given on the command line into a linked list
 362    of `struct mode_change' and apply that to each file argument. */
 363
 364 int
 365 main (int argc, char **argv)
 366 {
 367   char *mode = NULL;
 368   size_t mode_len = 0;
 369   size_t mode_alloc = 0;
 370   bool ok;
 371   bool preserve_root = false;
 372   char const *reference_file = NULL;
 373   int c;
 374
 375   initialize_main (&argc, &argv);
 376   program_name = argv[0];
 377   setlocale (LC_ALL, "");
 378   bindtextdomain (PACKAGE, LOCALEDIR);
 379   textdomain (PACKAGE);
 380
 381   atexit (close_stdout);
 382
 383   recurse = force_silent = diagnose_surprises = false;
 384
 385   while ((c = getopt_long (argc, argv,
 386                            "Rcfvr::w::x::X::s::t::u::g::o::a::,::+::=::",
 387                            long_options, NULL))
 388          != -1)
 389     {
 390       switch (c)
 391         {
 392         case 'r':
 393         case 'w':
 394         case 'x':
 395         case 'X':
 396         case 's':
 397         case 't':
 398         case 'u':
 399         case 'g':
 400         case 'o':
 401         case 'a':
 402         case ',':
 403         case '+':
 404         case '=':
 405           /* Support nonportable uses like "chmod -w", but diagnose
 406              surprises due to umask confusion.  Even though "--", "--r",
 407              etc., are valid modes, there is no "case '-'" here since
 408              getopt_long reserves leading "--" for long options.  */
 409           {
 410             /* Allocate a mode string (e.g., "-rwx") by concatenating
 411                the argument containing this option.  If a previous mode
 412                string was given, concatenate the previous string, a
 413                comma, and the new string (e.g., "-s,-rwx").  */
 414
 415             char const *arg = argv[optind - 1];
 416             size_t arg_len = strlen (arg);
 417             size_t mode_comma_len = mode_len + !!mode_len;
 418             size_t new_mode_len = mode_comma_len + arg_len;
 419             if (mode_alloc <= new_mode_len)
 420               {
 421                 mode_alloc = new_mode_len + 1;
 422                 mode = X2REALLOC (mode, &mode_alloc);
 423               }
 424             mode[mode_len] = ',';
 425             strcpy (mode + mode_comma_len, arg);
 426             mode_len = new_mode_len;
 427
 428             diagnose_surprises = true;
 429           }
 430           break;
 431         case NO_PRESERVE_ROOT:
 432           preserve_root = false;
 433           break;
 434         case PRESERVE_ROOT:
 435           preserve_root = true;
 436           break;
 437         case REFERENCE_FILE_OPTION:
 438           reference_file = optarg;
 439           break;
 440         case 'R':
 441           recurse = true;
 442           break;
 443         case 'c':
 444           verbosity = V_changes_only;
 445           break;
 446         case 'f':
 447           force_silent = true;
 448           break;
 449         case 'v':
 450           verbosity = V_high;
 451           break;
 452         case_GETOPT_HELP_CHAR;
 453         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 454         default:
 455           usage (EXIT_FAILURE);
 456         }
 457     }
 458
 459   if (reference_file)
 460     {
 461       if (mode)
 462         {
 463           error (0, 0, _("cannot combine mode and --reference options"));
 464           usage (EXIT_FAILURE);
 465         }
 466     }
 467   else
 468     {
 469       if (!mode)
 470         mode = argv[optind++];
 471     }
 472
 473   if (optind >= argc)
 474     {
 475       if (!mode || mode != argv[optind - 1])
 476         error (0, 0, _("missing operand"));
 477       else
 478         error (0, 0, _("missing operand after %s"), quote (argv[argc - 1]));
 479       usage (EXIT_FAILURE);
 480     }
 481
 482   if (reference_file)
 483     {
 484       change = mode_create_from_ref (reference_file);
 485       if (!change)
 486         error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
 487                quote (reference_file));
 488     }
 489   else
 490     {
 491       change = mode_compile (mode);
 492       if (!change)
 493         {
 494           error (0, 0, _("invalid mode: %s"), quote (mode));
 495           usage (EXIT_FAILURE);
 496         }
 497       umask_value = umask (0);
 498     }
 499
 500   if (recurse & preserve_root)
 501     {
 502       static struct dev_ino dev_ino_buf;
 503       root_dev_ino = get_root_dev_ino (&dev_ino_buf);
 504       if (root_dev_ino == NULL)
 505         error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
 506                quote ("/"));
 507     }
 508   else
 509     {
 510       root_dev_ino = NULL;
 511     }
 512
 513   ok = process_files (argv + optind, FTS_COMFOLLOW | FTS_PHYSICAL);
 514
 515   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 516 }