src/chmod.c

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