1 /* chmod -- change permission modes of files
2 Copyright (C) 1989-2023 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 3 of the License, or
7 (at your option) 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, see <https://www.gnu.org/licenses/>. */
16
17 /* Written by David MacKenzie <djm@gnu.ai.mit.edu> */
18
19 #include <config.h>
20 #include <stdio.h>
21 #include <getopt.h>
22 #include <sys/types.h>
23
24 #include "system.h"
25 #include "assure.h"
26 #include "dev-ino.h"
27 #include "filemode.h"
28 #include "ignore-value.h"
29 #include "modechange.h"
30 #include "quote.h"
31 #include "root-dev-ino.h"
32 #include "xfts.h"
33
34 /* The official name of this program (e.g., no 'g' prefix). */
35 #define PROGRAM_NAME "chmod"
36
37 #define AUTHORS \
38 proper_name ("David MacKenzie"), \
39 proper_name ("Jim Meyering")
40
41 struct change_status
42 {
43 enum
44 {
45 CH_NO_STAT,
46 CH_FAILED,
47 CH_NOT_APPLIED,
48 CH_NO_CHANGE_REQUESTED,
49 CH_SUCCEEDED
50 }
51 status;
52 mode_t old_mode;
53 mode_t new_mode;
54 };
55
56 enum Verbosity
57 {
58 /* Print a message for each file that is processed. */
59 V_high,
60
61 /* Print a message for each file whose attributes we change. */
62 V_changes_only,
63
64 /* Do not be verbose. This is the default. */
65 V_off
66 };
67
68 /* The desired change to the mode. */
69 static struct mode_change *change;
70
71 /* The initial umask value, if it might be needed. */
72 static mode_t umask_value;
73
74 /* If true, change the modes of directories recursively. */
75 static bool recurse;
76
77 /* If true, force silence (suppress most of error messages). */
78 static bool force_silent;
79
80 /* If true, diagnose surprises from naive misuses like "chmod -r file".
81 POSIX allows diagnostics here, as portable code is supposed to use
82 "chmod -- -r file". */
83 static bool diagnose_surprises;
84
85 /* Level of verbosity. */
86 static enum Verbosity verbosity = V_off;
87
88 /* Pointer to the device and inode numbers of '/', when --recursive.
89 Otherwise nullptr. */
90 static struct dev_ino *root_dev_ino;
91
92 /* For long options that have no equivalent short option, use a
93 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
94 enum
95 {
96 NO_PRESERVE_ROOT = CHAR_MAX + 1,
97 PRESERVE_ROOT,
98 REFERENCE_FILE_OPTION
99 };
100
101 static struct option const long_options[] =
102 {
103 {"changes", no_argument, nullptr, 'c'},
104 {"recursive", no_argument, nullptr, 'R'},
105 {"no-preserve-root", no_argument, nullptr, NO_PRESERVE_ROOT},
106 {"preserve-root", no_argument, nullptr, PRESERVE_ROOT},
107 {"quiet", no_argument, nullptr, 'f'},
108 {"reference", required_argument, nullptr, REFERENCE_FILE_OPTION},
109 {"silent", no_argument, nullptr, 'f'},
110 {"verbose", no_argument, nullptr, 'v'},
111 {GETOPT_HELP_OPTION_DECL},
112 {GETOPT_VERSION_OPTION_DECL},
113 {nullptr, 0, nullptr, 0}
114 };
115
116 /* Return true if the chmodable permission bits of FILE changed.
117 The old mode was OLD_MODE, but it was changed to NEW_MODE. */
118
119 static bool
120 mode_changed (int dir_fd, char const *file, char const *file_full_name,
121 mode_t old_mode, mode_t new_mode)
122 {
123 if (new_mode & (S_ISUID | S_ISGID | S_ISVTX))
124 {
125 /* The new mode contains unusual bits that the call to chmod may
126 have silently cleared. Check whether they actually changed. */
127
128 struct stat new_stats;
129
130 if (fstatat (dir_fd, file, &new_stats, 0) != 0)
131 {
132 if (! force_silent)
133 error (0, errno, _("getting new attributes of %s"),
134 quoteaf (file_full_name));
135 return false;
136 }
137
138 new_mode = new_stats.st_mode;
139 }
140
141 return ((old_mode ^ new_mode) & CHMOD_MODE_BITS) != 0;
142 }
143
144 /* Tell the user how/if the MODE of FILE has been changed.
145 CH describes what (if anything) has happened. */
146
147 static void
148 describe_change (char const *file, struct change_status const *ch)
149 {
150 char perms[12]; /* "-rwxrwxrwx" ls-style modes. */
151 char old_perms[12];
152 char const *fmt;
153 char const *quoted_file = quoteaf (file);
154
155 switch (ch->status)
156 {
157 case CH_NOT_APPLIED:
158 printf (_("neither symbolic link %s nor referent has been changed\n"),
159 quoted_file);
160 return;
161
162 case CH_NO_STAT:
163 printf (_("%s could not be accessed\n"), quoted_file);
164 return;
165
166 default:
167 break;
168 }
169
170 unsigned long int
171 old_m = ch->old_mode & CHMOD_MODE_BITS,
172 m = ch->new_mode & CHMOD_MODE_BITS;
173
174 strmode (ch->new_mode, perms);
175 perms[10] = '\0'; /* Remove trailing space. */
176
177 strmode (ch->old_mode, old_perms);
178 old_perms[10] = '\0'; /* Remove trailing space. */
179
180 switch (ch->status)
181 {
182 case CH_SUCCEEDED:
183 fmt = _("mode of %s changed from %04lo (%s) to %04lo (%s)\n");
184 break;
185 case CH_FAILED:
186 fmt = _("failed to change mode of %s from %04lo (%s) to %04lo (%s)\n");
187 break;
188 case CH_NO_CHANGE_REQUESTED:
189 fmt = _("mode of %s retained as %04lo (%s)\n");
190 printf (fmt, quoted_file, m, &perms[1]);
191 return;
192 default:
193 affirm (false);
194 }
195 printf (fmt, quoted_file, old_m, &old_perms[1], m, &perms[1]);
196 }
197
198 /* Change the mode of FILE.
199 Return true if successful. This function is called
200 once for every file system object that fts encounters. */
201
202 static bool
203 process_file (FTS *fts, FTSENT *ent)
204 {
205 char const *file_full_name = ent->fts_path;
206 char const *file = ent->fts_accpath;
207 const struct stat *file_stats = ent->fts_statp;
208 struct change_status ch = { 0, };
209 ch.status = CH_NO_STAT;
210
211 switch (ent->fts_info)
212 {
213 case FTS_DP:
214 return true;
215
216 case FTS_NS:
217 /* For a top-level file or directory, this FTS_NS (stat failed)
218 indicator is determined at the time of the initial fts_open call.
219 With programs like chmod, chown, and chgrp, that modify
220 permissions, it is possible that the file in question is
221 accessible when control reaches this point. So, if this is
222 the first time we've seen the FTS_NS for this file, tell
223 fts_read to stat it "again". */
224 if (ent->fts_level == 0 && ent->fts_number == 0)
225 {
226 ent->fts_number = 1;
227 fts_set (fts, ent, FTS_AGAIN);
228 return true;
229 }
230 if (! force_silent)
231 error (0, ent->fts_errno, _("cannot access %s"),
232 quoteaf (file_full_name));
233 break;
234
235 case FTS_ERR:
236 if (! force_silent)
237 error (0, ent->fts_errno, "%s", quotef (file_full_name));
238 break;
239
240 case FTS_DNR:
241 if (! force_silent)
242 error (0, ent->fts_errno, _("cannot read directory %s"),
243 quoteaf (file_full_name));
244 break;
245
246 case FTS_SLNONE:
247 if (! force_silent)
248 error (0, 0, _("cannot operate on dangling symlink %s"),
249 quoteaf (file_full_name));
250 break;
251
252 case FTS_DC: /* directory that causes cycles */
253 if (cycle_warning_required (fts, ent))
254 {
255 emit_cycle_warning (file_full_name);
256 return false;
257 }
258 FALLTHROUGH;
259 default:
260 ch.status = CH_NOT_APPLIED;
261 break;
262 }
263
264 if (ch.status == CH_NOT_APPLIED
265 && ROOT_DEV_INO_CHECK (root_dev_ino, file_stats))
266 {
267 ROOT_DEV_INO_WARN (file_full_name);
268 /* Tell fts not to traverse into this hierarchy. */
269 fts_set (fts, ent, FTS_SKIP);
270 /* Ensure that we do not process "/" on the second visit. */
271 ignore_value (fts_read (fts));
272 return false;
273 }
274
275 if (ch.status == CH_NOT_APPLIED && ! S_ISLNK (file_stats->st_mode))
276 {
277 ch.old_mode = file_stats->st_mode;
278 ch.new_mode = mode_adjust (ch.old_mode, S_ISDIR (ch.old_mode) != 0,
279 umask_value, change, nullptr);
280 if (chmodat (fts->fts_cwd_fd, file, ch.new_mode) == 0)
281 ch.status = CH_SUCCEEDED;
282 else
283 {
284 if (! force_silent)
285 error (0, errno, _("changing permissions of %s"),
286 quoteaf (file_full_name));
287 ch.status = CH_FAILED;
288 }
289 }
290
291 if (verbosity != V_off)
292 {
293 if (ch.status == CH_SUCCEEDED
294 && !mode_changed (fts->fts_cwd_fd, file, file_full_name,
295 ch.old_mode, ch.new_mode))
296 ch.status = CH_NO_CHANGE_REQUESTED;
297
298 if (ch.status == CH_SUCCEEDED || verbosity == V_high)
299 describe_change (file_full_name, &ch);
300 }
301
302 if (CH_NO_CHANGE_REQUESTED <= ch.status && diagnose_surprises)
303 {
304 mode_t naively_expected_mode =
305 mode_adjust (ch.old_mode, S_ISDIR (ch.old_mode) != 0,
306 0, change, nullptr);
307 if (ch.new_mode & ~naively_expected_mode)
308 {
309 char new_perms[12];
310 char naively_expected_perms[12];
311 strmode (ch.new_mode, new_perms);
312 strmode (naively_expected_mode, naively_expected_perms);
313 new_perms[10] = naively_expected_perms[10] = '\0';
314 error (0, 0,
315 _("%s: new permissions are %s, not %s"),
316 quotef (file_full_name),
317 new_perms + 1, naively_expected_perms + 1);
318 ch.status = CH_FAILED;
319 }
320 }
321
322 if ( ! recurse)
323 fts_set (fts, ent, FTS_SKIP);
324
325 return CH_NOT_APPLIED <= ch.status;
326 }
327
328 /* Recursively change the modes of the specified FILES (the last entry
329 of which is null). BIT_FLAGS controls how fts works.
330 Return true if successful. */
331
332 static bool
333 process_files (char **files, int bit_flags)
334 {
335 bool ok = true;
336
337 FTS *fts = xfts_open (files, bit_flags, nullptr);
338
339 while (true)
340 {
341 FTSENT *ent;
342
343 ent = fts_read (fts);
344 if (ent == nullptr)
345 {
346 if (errno != 0)
347 {
348 /* FIXME: try to give a better message */
349 if (! force_silent)
350 error (0, errno, _("fts_read failed"));
351 ok = false;
352 }
353 break;
354 }
355
356 ok &= process_file (fts, ent);
357 }
358
359 if (fts_close (fts) != 0)
360 {
361 error (0, errno, _("fts_close failed"));
362 ok = false;
363 }
364
365 return ok;
366 }
367
368 void
369 usage (int status)
370 {
371 if (status != EXIT_SUCCESS)
372 emit_try_help ();
373 else
374 {
375 printf (_("\
376 Usage: %s [OPTION]... MODE[,MODE]... FILE...\n\
377 or: %s [OPTION]... OCTAL-MODE FILE...\n\
378 or: %s [OPTION]... --reference=RFILE FILE...\n\
379 "),
380 program_name, program_name, program_name);
381 fputs (_("\
382 Change the mode of each FILE to MODE.\n\
383 With --reference, change the mode of each FILE to that of RFILE.\n\
384 \n\
385 "), stdout);
386 fputs (_("\
387 -c, --changes like verbose but report only when a change is made\n\
388 -f, --silent, --quiet suppress most error messages\n\
389 -v, --verbose output a diagnostic for every file processed\n\
390 "), stdout);
391 fputs (_("\
392 --no-preserve-root do not treat '/' specially (the default)\n\
393 --preserve-root fail to operate recursively on '/'\n\
394 "), stdout);
395 fputs (_("\
396 --reference=RFILE use RFILE's mode instead of specifying MODE values.\n\
397 RFILE is always dereferenced if a symbolic link.\n\
398 "), stdout);
399 fputs (_("\
400 -R, --recursive change files and directories recursively\n\
401 "), stdout);
402 fputs (HELP_OPTION_DESCRIPTION, stdout);
403 fputs (VERSION_OPTION_DESCRIPTION, stdout);
404 fputs (_("\
405 \n\
406 Each MODE is of the form '[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=][0-7]+'.\n\
407 "), stdout);
408 emit_ancillary_info (PROGRAM_NAME);
409 }
410 exit (status);
411 }
412
413 /* Parse the ASCII mode given on the command line into a linked list
414 of 'struct mode_change' and apply that to each file argument. */
415
416 int
417 main (int argc, char **argv)
418 {
419 char *mode = nullptr;
420 idx_t mode_len = 0;
421 idx_t mode_alloc = 0;
422 bool ok;
423 bool preserve_root = false;
424 char const *reference_file = nullptr;
425 int c;
426
427 initialize_main (&argc, &argv);
428 set_program_name (argv[0]);
429 setlocale (LC_ALL, "");
430 bindtextdomain (PACKAGE, LOCALEDIR);
431 textdomain (PACKAGE);
432
433 atexit (close_stdout);
434
435 recurse = force_silent = diagnose_surprises = false;
436
437 while ((c = getopt_long (argc, argv,
438 ("Rcfvr::w::x::X::s::t::u::g::o::a::,::+::=::"
439 "0::1::2::3::4::5::6::7::"),
440 long_options, nullptr))
441 != -1)
442 {
443 switch (c)
444 {
445 case 'r':
446 case 'w':
447 case 'x':
448 case 'X':
449 case 's':
450 case 't':
451 case 'u':
452 case 'g':
453 case 'o':
454 case 'a':
455 case ',':
456 case '+':
457 case '=':
458 case '0': case '1': case '2': case '3':
459 case '4': case '5': case '6': case '7':
460 /* Support non-portable uses like "chmod -w", but diagnose
461 surprises due to umask confusion. Even though "--", "--r",
462 etc., are valid modes, there is no "case '-'" here since
463 getopt_long reserves leading "--" for long options. */
464 {
465 /* Allocate a mode string (e.g., "-rwx") by concatenating
466 the argument containing this option. If a previous mode
467 string was given, concatenate the previous string, a
468 comma, and the new string (e.g., "-s,-rwx"). */
469
470 char const *arg = argv[optind - 1];
471 idx_t arg_len = strlen (arg);
472 idx_t mode_comma_len = mode_len + !!mode_len;
473 idx_t new_mode_len = mode_comma_len + arg_len;
474 assume (0 <= new_mode_len); /* Pacify GCC bug #109613. */
475 if (mode_alloc <= new_mode_len)
476 mode = xpalloc (mode, &mode_alloc,
477 new_mode_len + 1 - mode_alloc, -1, 1);
478 mode[mode_len] = ',';
479 memcpy (mode + mode_comma_len, arg, arg_len + 1);
480 mode_len = new_mode_len;
481
482 diagnose_surprises = true;
483 }
484 break;
485 case NO_PRESERVE_ROOT:
486 preserve_root = false;
487 break;
488 case PRESERVE_ROOT:
489 preserve_root = true;
490 break;
491 case REFERENCE_FILE_OPTION:
492 reference_file = optarg;
493 break;
494 case 'R':
495 recurse = true;
496 break;
497 case 'c':
498 verbosity = V_changes_only;
499 break;
500 case 'f':
501 force_silent = true;
502 break;
503 case 'v':
504 verbosity = V_high;
505 break;
506 case_GETOPT_HELP_CHAR;
507 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
508 default:
509 usage (EXIT_FAILURE);
510 }
511 }
512
513 if (reference_file)
514 {
515 if (mode)
516 {
517 error (0, 0, _("cannot combine mode and --reference options"));
518 usage (EXIT_FAILURE);
519 }
520 }
521 else
522 {
523 if (!mode)
524 mode = argv[optind++];
525 }
526
527 if (optind >= argc)
528 {
529 if (!mode || mode != argv[optind - 1])
530 error (0, 0, _("missing operand"));
531 else
532 error (0, 0, _("missing operand after %s"), quote (argv[argc - 1]));
533 usage (EXIT_FAILURE);
534 }
535
536 if (reference_file)
537 {
538 change = mode_create_from_ref (reference_file);
539 if (!change)
540 error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
541 quoteaf (reference_file));
542 }
543 else
544 {
545 change = mode_compile (mode);
546 if (!change)
547 {
548 error (0, 0, _("invalid mode: %s"), quote (mode));
549 usage (EXIT_FAILURE);
550 }
551 umask_value = umask (0);
552 }
553
554 if (recurse && preserve_root)
555 {
556 static struct dev_ino dev_ino_buf;
557 root_dev_ino = get_root_dev_ino (&dev_ino_buf);
558 if (root_dev_ino == nullptr)
559 error (EXIT_FAILURE, errno, _("failed to get attributes of %s"),
560 quoteaf ("/"));
561 }
562 else
563 {
564 root_dev_ino = nullptr;
565 }
566
567 ok = process_files (argv + optind,
568 FTS_COMFOLLOW | FTS_PHYSICAL | FTS_DEFER_STAT);
569
570 main_exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
571 }