src/chmod.c

   1 /* chmod -- change permission modes of files
   2    Copyright (C) 89, 90, 91, 1995-1999 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 "closeout.h"
  27 #include "error.h"
  28 #include "filemode.h"
  29 #include "long-options.h"
  30 #include "modechange.h"
  31 #include "savedir.h"
  32
  33 enum Change_status
  34 {
  35   CH_SUCCEEDED,
  36   CH_FAILED,
  37   CH_NO_CHANGE_REQUESTED
  38 };
  39
  40 enum Verbosity
  41 {
  42   /* Print a message for each file that is processed.  */
  43   V_high,
  44
  45   /* Print a message for each file whose attributes we change.  */
  46   V_changes_only,
  47
  48   /* Do not be verbose.  This is the default. */
  49   V_off
  50 };
  51
  52 void strip_trailing_slashes ();
  53
  54 static int change_dir_mode PARAMS ((const char *dir,
  55                                     const struct mode_change *changes,
  56                                     const struct stat *statp));
  57
  58 /* The name the program was run with. */
  59 char *program_name;
  60
  61 /* If nonzero, change the modes of directories recursively. */
  62 static int recurse;
  63
  64 /* If nonzero, force silence (no error messages). */
  65 static int force_silent;
  66
  67 /* Level of verbosity.  */
  68 static enum Verbosity verbosity = V_off;
  69
  70 /* The argument to the --reference option.  Use the owner and group IDs
  71    of this file.  This file must exist.  */
  72 static char *reference_file;
  73
  74 static struct option const long_options[] =
  75 {
  76   {"recursive", no_argument, 0, 'R'},
  77   {"changes", no_argument, 0, 'c'},
  78   {"silent", no_argument, 0, 'f'},
  79   {"quiet", no_argument, 0, 'f'},
  80   {"reference", required_argument, 0, CHAR_MAX + 1},
  81   {"verbose", no_argument, 0, 'v'},
  82   {0, 0, 0, 0}
  83 };
  84
  85 /* Tell the user how/if the MODE of FILE has been changed.
  86    CHANGED describes what (if anything) has happened. */
  87
  88 static void
  89 describe_change (const char *file, short unsigned int mode,
  90                  enum Change_status changed)
  91 {
  92   char perms[11];               /* "-rwxrwxrwx" ls-style modes. */
  93   const char *fmt;
  94
  95   mode_string (mode, perms);
  96   perms[10] = '\0';             /* `mode_string' does not null terminate. */
  97   switch (changed)
  98     {
  99     case CH_SUCCEEDED:
 100       fmt = _("mode of %s changed to %04o (%s)\n");
 101       break;
 102     case CH_FAILED:
 103       fmt = _("failed to change mode of %s to %04o (%s)\n");
 104       break;
 105     case CH_NO_CHANGE_REQUESTED:
 106       fmt = _("mode of %s retained as %04o (%s)\n");
 107       break;
 108     default:
 109       abort ();
 110     }
 111   printf (fmt, file, mode & 07777, &perms[1]);
 112 }
 113
 114 /* Change the mode of FILE according to the list of operations CHANGES.
 115    If DEREF_SYMLINK is nonzero and FILE is a symbolic link, change the
 116    mode of the referenced file.  If DEREF_SYMLINK is zero, ignore symbolic
 117    links.  Return 0 if successful, 1 if errors occurred. */
 118
 119 static int
 120 change_file_mode (const char *file, const struct mode_change *changes,
 121                   const int deref_symlink)
 122 {
 123   struct stat file_stats;
 124   unsigned short newmode;
 125   int errors = 0;
 126
 127   if (lstat (file, &file_stats))
 128     {
 129       if (force_silent == 0)
 130         error (0, errno, "%s", file);
 131       return 1;
 132     }
 133 #ifdef S_ISLNK
 134   if (S_ISLNK (file_stats.st_mode))
 135     {
 136       if (! deref_symlink)
 137         return 0;
 138       else
 139         if (stat (file, &file_stats))
 140           {
 141             if (force_silent == 0)
 142               error (0, errno, "%s", file);
 143             return 1;
 144           }
 145     }
 146 #endif
 147
 148   newmode = mode_adjust (file_stats.st_mode, changes);
 149
 150   if (newmode != (file_stats.st_mode & 07777))
 151     {
 152       int fail = chmod (file, (int) newmode);
 153
 154       if (verbosity == V_high || (verbosity == V_changes_only && !fail))
 155         describe_change (file, newmode, (fail ? CH_FAILED : CH_SUCCEEDED));
 156
 157       if (fail)
 158         {
 159           if (force_silent == 0)
 160             error (0, errno, "%s", file);
 161           errors = 1;
 162         }
 163     }
 164   else if (verbosity == V_high)
 165     describe_change (file, newmode, CH_NO_CHANGE_REQUESTED);
 166
 167   if (recurse && S_ISDIR (file_stats.st_mode))
 168     errors |= change_dir_mode (file, changes, &file_stats);
 169   return errors;
 170 }
 171
 172 /* Recursively change the modes of the files in directory DIR
 173    according to the list of operations CHANGES.
 174    STATP points to the results of lstat on DIR.
 175    Return 0 if successful, 1 if errors occurred. */
 176
 177 static int
 178 change_dir_mode (const char *dir, const struct mode_change *changes,
 179                  const struct stat *statp)
 180 {
 181   char *name_space, *namep;
 182   char *path;                   /* Full path of each entry to process. */
 183   unsigned dirlength;           /* Length of DIR and '\0'. */
 184   unsigned filelength;          /* Length of each pathname to process. */
 185   unsigned pathlength;          /* Bytes allocated for `path'. */
 186   int errors = 0;
 187
 188   errno = 0;
 189   name_space = savedir (dir, (unsigned int) statp->st_size);
 190   if (name_space == NULL)
 191     {
 192       if (errno)
 193         {
 194           if (force_silent == 0)
 195             error (0, errno, "%s", dir);
 196           return 1;
 197         }
 198       else
 199         error (1, 0, _("virtual memory exhausted"));
 200     }
 201
 202   dirlength = strlen (dir) + 1; /* + 1 is for the trailing '/'. */
 203   pathlength = dirlength + 1;
 204   /* Give `path' a dummy value; it will be reallocated before first use. */
 205   path = xmalloc (pathlength);
 206   strcpy (path, dir);
 207   path[dirlength - 1] = '/';
 208
 209   for (namep = name_space; *namep; namep += filelength - dirlength)
 210     {
 211       filelength = dirlength + strlen (namep) + 1;
 212       if (filelength > pathlength)
 213         {
 214           pathlength = filelength * 2;
 215           path = xrealloc (path, pathlength);
 216         }
 217       strcpy (path + dirlength, namep);
 218       errors |= change_file_mode (path, changes, 0);
 219     }
 220   free (path);
 221   free (name_space);
 222   return errors;
 223 }
 224
 225 void
 226 usage (int status)
 227 {
 228   if (status != 0)
 229     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 230              program_name);
 231   else
 232     {
 233       printf (_("\
 234 Usage: %s [OPTION]... MODE[,MODE]... FILE...\n\
 235   or:  %s [OPTION]... OCTAL-MODE FILE...\n\
 236   or:  %s [OPTION]... --reference=RFILE FILE...\n\
 237 "),
 238               program_name, program_name, program_name);
 239       printf (_("\
 240 Change the mode of each FILE to MODE.\n\
 241 \n\
 242   -c, --changes           like verbose but report only when a change is made\n\
 243   -f, --silent, --quiet   suppress most error messages\n\
 244   -v, --verbose           output a diagnostic for every file processed\n\
 245       --reference=RFILE   use RFILE's mode instead of MODE values\n\
 246   -R, --recursive         change files and directories recursively\n\
 247       --help              display this help and exit\n\
 248       --version           output version information and exit\n\
 249 \n\
 250 Each MODE is one or more of the letters ugoa, one of the symbols +-= and\n\
 251 one or more of the letters rwxXstugo.\n\
 252 "));
 253       puts (_("\nReport bugs to <bug-fileutils@gnu.org>."));
 254       close_stdout ();
 255     }
 256   exit (status);
 257 }
 258
 259 /* Parse the ASCII mode given on the command line into a linked list
 260    of `struct mode_change' and apply that to each file argument. */
 261
 262 int
 263 main (int argc, char **argv)
 264 {
 265   struct mode_change *changes;
 266   int errors = 0;
 267   int modeind = 0;              /* Index of the mode argument in `argv'. */
 268   int thisind;
 269   int c;
 270
 271   program_name = argv[0];
 272   setlocale (LC_ALL, "");
 273   bindtextdomain (PACKAGE, LOCALEDIR);
 274   textdomain (PACKAGE);
 275
 276   parse_long_options (argc, argv, "chmod", GNU_PACKAGE, VERSION,
 277                       "David MacKenzie", usage);
 278
 279   recurse = force_silent = 0;
 280
 281   while (1)
 282     {
 283       thisind = optind ? optind : 1;
 284
 285       c = getopt_long (argc, argv, "RcfvrwxXstugoa,+-=", long_options, NULL);
 286       if (c == -1)
 287         break;
 288
 289       switch (c)
 290         {
 291         case 0:
 292           break;
 293         case 'r':
 294         case 'w':
 295         case 'x':
 296         case 'X':
 297         case 's':
 298         case 't':
 299         case 'u':
 300         case 'g':
 301         case 'o':
 302         case 'a':
 303         case ',':
 304         case '+':
 305         case '-':
 306         case '=':
 307           if (modeind != 0 && modeind != thisind)
 308             error (1, 0, _("invalid mode"));
 309           modeind = thisind;
 310           break;
 311         case CHAR_MAX + 1:
 312           reference_file = optarg;
 313           break;
 314         case 'R':
 315           recurse = 1;
 316           break;
 317         case 'c':
 318           verbosity = V_changes_only;
 319           break;
 320         case 'f':
 321           force_silent = 1;
 322           break;
 323         case 'v':
 324           verbosity = V_high;
 325           break;
 326         default:
 327           usage (1);
 328         }
 329     }
 330
 331   if (modeind == 0 && reference_file == NULL)
 332     modeind = optind++;
 333
 334   if (optind >= argc)
 335     {
 336       error (0, 0, _("too few arguments"));
 337       usage (1);
 338     }
 339
 340   changes = (reference_file ? mode_create_from_ref (reference_file)
 341              : mode_compile (argv[modeind], MODE_MASK_ALL));
 342
 343   if (changes == MODE_INVALID)
 344     error (1, 0, _("invalid mode"));
 345   else if (changes == MODE_MEMORY_EXHAUSTED)
 346     error (1, 0, _("virtual memory exhausted"));
 347   else if (changes == MODE_BAD_REFERENCE)
 348     error (1, errno, "%s", reference_file);
 349
 350   for (; optind < argc; ++optind)
 351     {
 352       strip_trailing_slashes (argv[optind]);
 353       errors |= change_file_mode (argv[optind], changes, 1);
 354     }
 355
 356   if (verbosity != V_off)
 357     close_stdout ();
 358   exit (errors);
 359 }