src/chmod.c

   1 /* chmod -- change permission modes of files
   2    Copyright (C) 89, 90, 91, 1995-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 "quote.h"
  32 #include "savedir.h"
  33 #include "xfts.h"
  34
  35 /* The official name of this program (e.g., no `g' prefix).  */
  36 #define PROGRAM_NAME "chmod"
  37
  38 #define AUTHORS "David MacKenzie", "Jim Meyering"
  39
  40 enum Change_status
  41 {
  42   CH_SUCCEEDED,
  43   CH_FAILED,
  44   CH_NO_CHANGE_REQUESTED
  45 };
  46
  47 enum Verbosity
  48 {
  49   /* Print a message for each file that is processed.  */
  50   V_high,
  51
  52   /* Print a message for each file whose attributes we change.  */
  53   V_changes_only,
  54
  55   /* Do not be verbose.  This is the default. */
  56   V_off
  57 };
  58
  59 /* The name the program was run with. */
  60 char *program_name;
  61
  62 /* If nonzero, change the modes of directories recursively. */
  63 static int recurse;
  64
  65 /* If nonzero, force silence (no error messages). */
  66 static int force_silent;
  67
  68 /* Level of verbosity.  */
  69 static enum Verbosity verbosity = V_off;
  70
  71 /* The argument to the --reference option.  Use the owner and group IDs
  72    of this file.  This file must exist.  */
  73 static char *reference_file;
  74
  75 /* Pointer to the device and inode numbers of `/', when --recursive.
  76    Otherwise NULL.  */
  77 static struct dev_ino *root_dev_ino;
  78
  79 /* For long options that have no equivalent short option, use a
  80    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
  81 enum
  82 {
  83   NO_PRESERVE_ROOT = CHAR_MAX + 1,
  84   PRESERVE_ROOT,
  85   REFERENCE_FILE_OPTION
  86 };
  87
  88 static struct option const long_options[] =
  89 {
  90   {"recursive", no_argument, 0, 'R'},
  91   {"changes", no_argument, 0, 'c'},
  92   {"preserve-root", no_argument, 0, PRESERVE_ROOT},
  93   {"no-preserve-root", no_argument, 0, NO_PRESERVE_ROOT},
  94   {"quiet", no_argument, 0, 'f'},
  95   {"reference", required_argument, 0, REFERENCE_FILE_OPTION},
  96   {"silent", no_argument, 0, 'f'},
  97   {"verbose", no_argument, 0, 'v'},
  98   {GETOPT_HELP_OPTION_DECL},
  99   {GETOPT_VERSION_OPTION_DECL},
 100   {0, 0, 0, 0}
 101 };
 102
 103 static int
 104 mode_changed (const char *file, mode_t old_mode)
 105 {
 106   struct stat new_stats;
 107
 108   if (stat (file, &new_stats))
 109     {
 110       if (force_silent == 0)
 111         error (0, errno, _("getting new attributes of %s"), quote (file));
 112       return 0;
 113     }
 114
 115   return old_mode != new_stats.st_mode;
 116 }
 117
 118 /* Tell the user how/if the MODE of FILE has been changed.
 119    CHANGED describes what (if anything) has happened. */
 120
 121 static void
 122 describe_change (const char *file, mode_t mode,
 123                  enum Change_status changed)
 124 {
 125   char perms[11];               /* "-rwxrwxrwx" ls-style modes. */
 126   const char *fmt;
 127
 128   mode_string (mode, perms);
 129   perms[10] = '\0';             /* `mode_string' does not null terminate. */
 130   switch (changed)
 131     {
 132     case CH_SUCCEEDED:
 133       fmt = _("mode of %s changed to %04lo (%s)\n");
 134       break;
 135     case CH_FAILED:
 136       fmt = _("failed to change mode of %s to %04lo (%s)\n");
 137       break;
 138     case CH_NO_CHANGE_REQUESTED:
 139       fmt = _("mode of %s retained as %04lo (%s)\n");
 140       break;
 141     default:
 142       abort ();
 143     }
 144   printf (fmt, quote (file),
 145           (unsigned long) (mode & CHMOD_MODE_BITS), &perms[1]);
 146 }
 147
 148 /* Change the mode of FILE according to the list of operations CHANGES.
 149    Return 0 if successful, 1 if errors occurred.  This function is called
 150    once for every file system object that fts encounters.  */
 151
 152 static int
 153 process_file (FTS *fts, FTSENT *ent, const struct mode_change *changes)
 154 {
 155   const char *file_full_name = ent->fts_path;
 156   const char *file = ent->fts_accpath;
 157   const struct stat *sb = ent->fts_statp;
 158   mode_t newmode;
 159   int errors = 0;
 160   int fail;
 161   int saved_errno;
 162
 163   switch (ent->fts_info)
 164     {
 165     case FTS_NS:
 166       error (0, ent->fts_errno, _("cannot access %s"), quote (file_full_name));
 167       return 1;
 168
 169     case FTS_ERR:
 170       /* if (S_ISDIR (ent->fts_statp->st_mode) && FIXME */
 171       error (0, ent->fts_errno, _("%s"), quote (file_full_name));
 172       return 1;
 173
 174     case FTS_DNR:
 175       error (0, ent->fts_errno, _("cannot read directory %s"),
 176              quote (file_full_name));
 177       return 1;
 178
 179     default:
 180       break;
 181     }
 182
 183   /* If this is the second (post-order) encounter with a directory,
 184      then return right away.  */
 185   if (ent->fts_info == FTS_DP)
 186     return 0;
 187
 188   if (root_dev_ino && SAME_INODE (*sb, *root_dev_ino))
 189     {
 190       if (STREQ (file_full_name, "/"))
 191         error (0, 0, _("it is dangerous to operate recursively on %s"),
 192                quote (file_full_name));
 193       else
 194         error (0, 0,
 195                _("it is dangerous to operate recursively on %s (same as %s)"),
 196                quote_n (0, file_full_name), quote_n (1, "/"));
 197       error (0, 0, _("use --no-preserve-root to override this failsafe"));
 198       return 1;
 199     }
 200
 201   if (S_ISLNK (sb->st_mode))
 202     return 0;
 203
 204   newmode = mode_adjust (sb->st_mode, changes);
 205
 206   fail = chmod (file, newmode);
 207   saved_errno = errno;
 208
 209   if (verbosity == V_high
 210       || (verbosity == V_changes_only
 211           && !fail && mode_changed (file, sb->st_mode)))
 212     describe_change (file_full_name, newmode,
 213                      (fail ? CH_FAILED : CH_SUCCEEDED));
 214
 215   if (fail)
 216     {
 217       if (force_silent == 0)
 218         error (0, saved_errno, _("changing permissions of %s"),
 219                quote (file_full_name));
 220       errors = 1;
 221     }
 222
 223   if ( ! recurse)
 224     fts_set (fts, ent, FTS_SKIP);
 225
 226   return errors;
 227 }
 228
 229 /* Recursively change the modes of the specified FILES (the last entry
 230    of which is NULL) according to the list of operations CHANGES.
 231    BIT_FLAGS controls how fts works.
 232    If the fts_open call fails, exit nonzero.
 233    Otherwise, return nonzero upon error.  */
 234
 235 static int
 236 process_files (char **files, int bit_flags, const struct mode_change *changes)
 237 {
 238   int fail = 0;
 239
 240   FTS *fts = xfts_open (files, bit_flags, NULL);
 241
 242   while (1)
 243     {
 244       FTSENT *ent;
 245
 246       ent = fts_read (fts);
 247       if (ent == NULL)
 248         {
 249           if (errno != 0)
 250             {
 251               /* FIXME: try to give a better message  */
 252               error (0, errno, _("fts_read failed"));
 253               fail = 1;
 254             }
 255           break;
 256         }
 257
 258       fail |= process_file (fts, ent, changes);
 259     }
 260
 261   /* Ignore failure, since the only way it can do so is in failing to
 262      return to the original directory, and since we're about to exit,
 263      that doesn't matter.  */
 264   fts_close (fts);
 265
 266   return fail;
 267 }
 268
 269 void
 270 usage (int status)
 271 {
 272   if (status != 0)
 273     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 274              program_name);
 275   else
 276     {
 277       printf (_("\
 278 Usage: %s [OPTION]... MODE[,MODE]... FILE...\n\
 279   or:  %s [OPTION]... OCTAL-MODE FILE...\n\
 280   or:  %s [OPTION]... --reference=RFILE FILE...\n\
 281 "),
 282               program_name, program_name, program_name);
 283       fputs (_("\
 284 Change the mode of each FILE to MODE.\n\
 285 \n\
 286   -c, --changes           like verbose but report only when a change is made\n\
 287       --preserve-root     fail to operate recursively on `/'\n\
 288       --no-preserve-root  do not treat `/' specially (the default)\n\
 289   -f, --silent, --quiet   suppress most error messages\n\
 290   -v, --verbose           output a diagnostic for every file processed\n\
 291       --reference=RFILE   use RFILE's mode instead of MODE values\n\
 292   -R, --recursive         change files and directories recursively\n\
 293 "), stdout);
 294       fputs (HELP_OPTION_DESCRIPTION, stdout);
 295       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 296       fputs (_("\
 297 \n\
 298 Each MODE is one or more of the letters ugoa, one of the symbols +-= and\n\
 299 one or more of the letters rwxXstugo.\n\
 300 "), stdout);
 301       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 302     }
 303   exit (status);
 304 }
 305
 306 /* Call lstat to get the device and inode numbers for `/'.
 307    Upon failure, return NULL.  Otherwise, set the members of
 308    *ROOT_D_I accordingly and return ROOT_D_I.  */
 309 static struct dev_ino *
 310 get_root_dev_ino (struct dev_ino *root_d_i)
 311 {
 312   struct stat statbuf;
 313   if (lstat ("/", &statbuf))
 314     return NULL;
 315   root_d_i->st_ino = statbuf.st_ino;
 316   root_d_i->st_dev = statbuf.st_dev;
 317   return root_d_i;
 318 }
 319
 320 /* Parse the ASCII mode given on the command line into a linked list
 321    of `struct mode_change' and apply that to each file argument. */
 322
 323 int
 324 main (int argc, char **argv)
 325 {
 326   struct mode_change *changes;
 327   int fail = 0;
 328   int modeind = 0;              /* Index of the mode argument in `argv'. */
 329   int thisind;
 330   bool preserve_root = false;
 331   int c;
 332
 333   initialize_main (&argc, &argv);
 334   program_name = argv[0];
 335   setlocale (LC_ALL, "");
 336   bindtextdomain (PACKAGE, LOCALEDIR);
 337   textdomain (PACKAGE);
 338
 339   atexit (close_stdout);
 340
 341   recurse = force_silent = 0;
 342
 343   while (1)
 344     {
 345       thisind = optind ? optind : 1;
 346
 347       c = getopt_long (argc, argv, "RcfvrwxXstugoa,+-=", long_options, NULL);
 348       if (c == -1)
 349         break;
 350
 351       switch (c)
 352         {
 353         case 0:
 354           break;
 355         case 'r':
 356         case 'w':
 357         case 'x':
 358         case 'X':
 359         case 's':
 360         case 't':
 361         case 'u':
 362         case 'g':
 363         case 'o':
 364         case 'a':
 365         case ',':
 366         case '+':
 367         case '-':
 368         case '=':
 369           if (modeind != 0 && modeind != thisind)
 370             {
 371               static char char_string[2] = {0, 0};
 372               char_string[0] = c;
 373               error (EXIT_FAILURE, 0,
 374                      _("invalid character %s in mode string %s"),
 375                      quote_n (0, char_string), quote_n (1, argv[thisind]));
 376             }
 377           modeind = thisind;
 378           break;
 379         case NO_PRESERVE_ROOT:
 380           preserve_root = false;
 381           break;
 382         case PRESERVE_ROOT:
 383           preserve_root = true;
 384           break;
 385         case REFERENCE_FILE_OPTION:
 386           reference_file = optarg;
 387           break;
 388         case 'R':
 389           recurse = 1;
 390           break;
 391         case 'c':
 392           verbosity = V_changes_only;
 393           break;
 394         case 'f':
 395           force_silent = 1;
 396           break;
 397         case 'v':
 398           verbosity = V_high;
 399           break;
 400         case_GETOPT_HELP_CHAR;
 401         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 402         default:
 403           usage (EXIT_FAILURE);
 404         }
 405     }
 406
 407   if (modeind == 0 && reference_file == NULL)
 408     modeind = optind++;
 409
 410   if (optind >= argc)
 411     {
 412       error (0, 0, _("too few arguments"));
 413       usage (EXIT_FAILURE);
 414     }
 415
 416   changes = (reference_file ? mode_create_from_ref (reference_file)
 417              : mode_compile (argv[modeind], MODE_MASK_ALL));
 418
 419   if (changes == MODE_INVALID)
 420     error (EXIT_FAILURE, 0,
 421            _("invalid mode string: %s"), quote (argv[modeind]));
 422   else if (changes == MODE_MEMORY_EXHAUSTED)
 423     xalloc_die ();
 424   else if (changes == MODE_BAD_REFERENCE)
 425     error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
 426            quote (reference_file));
 427
 428   if (recurse && preserve_root)
 429     {
 430       static struct dev_ino dev_ino_buf;
 431       root_dev_ino = get_root_dev_ino (&dev_ino_buf);
 432       if (root_dev_ino == NULL)
 433         error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
 434                quote ("/"));
 435     }
 436   else
 437     {
 438       root_dev_ino = NULL;
 439     }
 440
 441   fail = process_files (argv + optind, FTS_COMFOLLOW, changes);
 442
 443   exit (fail ? EXIT_FAILURE : EXIT_SUCCESS);
 444 }