(long_options): Replace 12 with CHAR_MAX + 1.
[platform/upstream/coreutils.git] / 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 static 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 <fileutils-bugs@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 }