src/chmod.c

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