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