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