]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/tmpfiles/tmpfiles.c
projects / thirdparty / systemd.git / blob
? search:


a934cbff9199c54cc6c64b7789f7da88ab49db8d
[thirdparty/systemd.git] / src / tmpfiles / tmpfiles.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <errno.h>
4 #include <fcntl.h>
5 #include <fnmatch.h>
6 #include <getopt.h>
7 #include <glob.h>
8 #include <limits.h>
9 #include <linux/fs.h>
10 #include <stdbool.h>
11 #include <stddef.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <sys/stat.h>
16 #include <sys/xattr.h>
17 #include <sysexits.h>
18 #include <time.h>
19 #include <unistd.h>
20
21 #include "sd-path.h"
22
23 #include "acl-util.h"
24 #include "alloc-util.h"
25 #include "btrfs-util.h"
26 #include "capability-util.h"
27 #include "chattr-util.h"
28 #include "conf-files.h"
29 #include "copy.h"
30 #include "def.h"
31 #include "dirent-util.h"
32 #include "escape.h"
33 #include "fd-util.h"
34 #include "fileio.h"
35 #include "format-util.h"
36 #include "fs-util.h"
37 #include "glob-util.h"
38 #include "io-util.h"
39 #include "label.h"
40 #include "log.h"
41 #include "macro.h"
42 #include "missing.h"
43 #include "mkdir.h"
44 #include "mount-util.h"
45 #include "pager.h"
46 #include "parse-util.h"
47 #include "path-lookup.h"
48 #include "path-util.h"
49 #include "rm-rf.h"
50 #include "selinux-util.h"
51 #include "set.h"
52 #include "specifier.h"
53 #include "stat-util.h"
54 #include "stdio-util.h"
55 #include "string-table.h"
56 #include "string-util.h"
57 #include "strv.h"
58 #include "terminal-util.h"
59 #include "umask-util.h"
60 #include "user-util.h"
61 #include "util.h"
62
63 /* This reads all files listed in /etc/tmpfiles.d/?*.conf and creates
64 * them in the file system. This is intended to be used to create
65 * properly owned directories beneath /tmp, /var/tmp, /run, which are
66 * volatile and hence need to be recreated on bootup. */
67
68 typedef enum ItemType {
69 /* These ones take file names */
70 CREATE_FILE = 'f',
71 TRUNCATE_FILE = 'F',
72 CREATE_DIRECTORY = 'd',
73 TRUNCATE_DIRECTORY = 'D',
74 CREATE_SUBVOLUME = 'v',
75 CREATE_SUBVOLUME_INHERIT_QUOTA = 'q',
76 CREATE_SUBVOLUME_NEW_QUOTA = 'Q',
77 CREATE_FIFO = 'p',
78 CREATE_SYMLINK = 'L',
79 CREATE_CHAR_DEVICE = 'c',
80 CREATE_BLOCK_DEVICE = 'b',
81 COPY_FILES = 'C',
82
83 /* These ones take globs */
84 WRITE_FILE = 'w',
85 EMPTY_DIRECTORY = 'e',
86 SET_XATTR = 't',
87 RECURSIVE_SET_XATTR = 'T',
88 SET_ACL = 'a',
89 RECURSIVE_SET_ACL = 'A',
90 SET_ATTRIBUTE = 'h',
91 RECURSIVE_SET_ATTRIBUTE = 'H',
92 IGNORE_PATH = 'x',
93 IGNORE_DIRECTORY_PATH = 'X',
94 REMOVE_PATH = 'r',
95 RECURSIVE_REMOVE_PATH = 'R',
96 RELABEL_PATH = 'z',
97 RECURSIVE_RELABEL_PATH = 'Z',
98 ADJUST_MODE = 'm', /* legacy, 'z' is identical to this */
99 } ItemType;
100
101 typedef struct Item {
102 ItemType type;
103
104 char *path;
105 char *argument;
106 char **xattrs;
107 #if HAVE_ACL
108 acl_t acl_access;
109 acl_t acl_default;
110 #endif
111 uid_t uid;
112 gid_t gid;
113 mode_t mode;
114 usec_t age;
115
116 dev_t major_minor;
117 unsigned attribute_value;
118 unsigned attribute_mask;
119
120 bool uid_set:1;
121 bool gid_set:1;
122 bool mode_set:1;
123 bool age_set:1;
124 bool mask_perms:1;
125 bool attribute_set:1;
126
127 bool keep_first_level:1;
128
129 bool force:1;
130
131 bool done:1;
132 } Item;
133
134 typedef struct ItemArray {
135 Item *items;
136 size_t count;
137 size_t size;
138 } ItemArray;
139
140 typedef enum DirectoryType {
141 DIRECTORY_RUNTIME = 0,
142 DIRECTORY_STATE,
143 DIRECTORY_CACHE,
144 DIRECTORY_LOGS,
145 _DIRECTORY_TYPE_MAX,
146 } DirectoryType;
147
148 static bool arg_cat_config = false;
149 static bool arg_user = false;
150 static bool arg_create = false;
151 static bool arg_clean = false;
152 static bool arg_remove = false;
153 static bool arg_boot = false;
154 static bool arg_no_pager = false;
155
156 static char **arg_include_prefixes = NULL;
157 static char **arg_exclude_prefixes = NULL;
158 static char *arg_root = NULL;
159 static char *arg_replace = NULL;
160
161 #define MAX_DEPTH 256
162
163 static OrderedHashmap *items = NULL, *globs = NULL;
164 static Set *unix_sockets = NULL;
165
166 static int specifier_machine_id_safe(char specifier, void *data, void *userdata, char **ret);
167 static int specifier_directory(char specifier, void *data, void *userdata, char **ret);
168
169 static const Specifier specifier_table[] = {
170 { 'm', specifier_machine_id_safe, NULL },
171 { 'b', specifier_boot_id, NULL },
172 { 'H', specifier_host_name, NULL },
173 { 'v', specifier_kernel_release, NULL },
174
175 { 'U', specifier_user_id, NULL },
176 { 'u', specifier_user_name, NULL },
177 { 'h', specifier_user_home, NULL },
178
179 { 't', specifier_directory, UINT_TO_PTR(DIRECTORY_RUNTIME) },
180 { 'S', specifier_directory, UINT_TO_PTR(DIRECTORY_STATE) },
181 { 'C', specifier_directory, UINT_TO_PTR(DIRECTORY_CACHE) },
182 { 'L', specifier_directory, UINT_TO_PTR(DIRECTORY_LOGS) },
183 { 'T', specifier_tmp_dir, NULL },
184 { 'V', specifier_var_tmp_dir, NULL },
185 {}
186 };
187
188 static int specifier_machine_id_safe(char specifier, void *data, void *userdata, char **ret) {
189 int r;
190
191 /* If /etc/machine_id is missing or empty (e.g. in a chroot environment)
192 * return a recognizable error so that the caller can skip the rule
193 * gracefully. */
194
195 r = specifier_machine_id(specifier, data, userdata, ret);
196 if (IN_SET(r, -ENOENT, -ENOMEDIUM))
197 return -ENXIO;
198
199 return r;
200 }
201
202 static int specifier_directory(char specifier, void *data, void *userdata, char **ret) {
203 struct table_entry {
204 uint64_t type;
205 const char *suffix;
206 };
207
208 static const struct table_entry paths_system[] = {
209 [DIRECTORY_RUNTIME] = { SD_PATH_SYSTEM_RUNTIME },
210 [DIRECTORY_STATE] = { SD_PATH_SYSTEM_STATE_PRIVATE },
211 [DIRECTORY_CACHE] = { SD_PATH_SYSTEM_STATE_CACHE },
212 [DIRECTORY_LOGS] = { SD_PATH_SYSTEM_STATE_LOGS },
213 };
214
215 static const struct table_entry paths_user[] = {
216 [DIRECTORY_RUNTIME] = { SD_PATH_USER_RUNTIME },
217 [DIRECTORY_STATE] = { SD_PATH_USER_CONFIGURATION },
218 [DIRECTORY_CACHE] = { SD_PATH_USER_STATE_CACHE },
219 [DIRECTORY_LOGS] = { SD_PATH_USER_CONFIGURATION, "log" },
220 };
221
222 unsigned i;
223 const struct table_entry *paths;
224
225 assert_cc(ELEMENTSOF(paths_system) == ELEMENTSOF(paths_user));
226 paths = arg_user ? paths_user : paths_system;
227
228 i = PTR_TO_UINT(data);
229 assert(i < ELEMENTSOF(paths_system));
230
231 return sd_path_home(paths[i].type, paths[i].suffix, ret);
232 }
233
234 static int log_unresolvable_specifier(const char *filename, unsigned line) {
235 static bool notified = false;
236
237 /* In system mode, this is called when /etc is not fully initialized (e.g.
238 * in a chroot environment) where some specifiers are unresolvable. In user
239 * mode, this is called when some variables are not defined. These cases are
240 * not considered as an error so log at LOG_NOTICE only for the first time
241 * and then downgrade this to LOG_DEBUG for the rest. */
242
243 log_full(notified ? LOG_DEBUG : LOG_NOTICE,
244 "[%s:%u] Failed to resolve specifier: %s, skipping",
245 filename, line,
246 arg_user ? "Required $XDG_... variable not defined" : "uninitialized /etc detected");
247
248 if (!notified)
249 log_notice("All rules containing unresolvable specifiers will be skipped.");
250
251 notified = true;
252 return 0;
253 }
254
255 static int user_config_paths(char*** ret) {
256 _cleanup_strv_free_ char **config_dirs = NULL, **data_dirs = NULL;
257 _cleanup_free_ char *persistent_config = NULL, *runtime_config = NULL, *data_home = NULL;
258 _cleanup_strv_free_ char **res = NULL;
259 int r;
260
261 r = xdg_user_dirs(&config_dirs, &data_dirs);
262 if (r < 0)
263 return r;
264
265 r = xdg_user_config_dir(&persistent_config, "/user-tmpfiles.d");
266 if (r < 0 && r != -ENXIO)
267 return r;
268
269 r = xdg_user_runtime_dir(&runtime_config, "/user-tmpfiles.d");
270 if (r < 0 && r != -ENXIO)
271 return r;
272
273 r = xdg_user_data_dir(&data_home, "/user-tmpfiles.d");
274 if (r < 0 && r != -ENXIO)
275 return r;
276
277 r = strv_extend_strv_concat(&res, config_dirs, "/user-tmpfiles.d");
278 if (r < 0)
279 return r;
280
281 r = strv_extend(&res, persistent_config);
282 if (r < 0)
283 return r;
284
285 r = strv_extend(&res, runtime_config);
286 if (r < 0)
287 return r;
288
289 r = strv_extend(&res, data_home);
290 if (r < 0)
291 return r;
292
293 r = strv_extend_strv_concat(&res, data_dirs, "/user-tmpfiles.d");
294 if (r < 0)
295 return r;
296
297 r = path_strv_make_absolute_cwd(res);
298 if (r < 0)
299 return r;
300
301 *ret = TAKE_PTR(res);
302 return 0;
303 }
304
305 static bool needs_glob(ItemType t) {
306 return IN_SET(t,
307 WRITE_FILE,
308 IGNORE_PATH,
309 IGNORE_DIRECTORY_PATH,
310 REMOVE_PATH,
311 RECURSIVE_REMOVE_PATH,
312 EMPTY_DIRECTORY,
313 ADJUST_MODE,
314 RELABEL_PATH,
315 RECURSIVE_RELABEL_PATH,
316 SET_XATTR,
317 RECURSIVE_SET_XATTR,
318 SET_ACL,
319 RECURSIVE_SET_ACL,
320 SET_ATTRIBUTE,
321 RECURSIVE_SET_ATTRIBUTE);
322 }
323
324 static bool takes_ownership(ItemType t) {
325 return IN_SET(t,
326 CREATE_FILE,
327 TRUNCATE_FILE,
328 CREATE_DIRECTORY,
329 EMPTY_DIRECTORY,
330 TRUNCATE_DIRECTORY,
331 CREATE_SUBVOLUME,
332 CREATE_SUBVOLUME_INHERIT_QUOTA,
333 CREATE_SUBVOLUME_NEW_QUOTA,
334 CREATE_FIFO,
335 CREATE_SYMLINK,
336 CREATE_CHAR_DEVICE,
337 CREATE_BLOCK_DEVICE,
338 COPY_FILES,
339 WRITE_FILE,
340 IGNORE_PATH,
341 IGNORE_DIRECTORY_PATH,
342 REMOVE_PATH,
343 RECURSIVE_REMOVE_PATH);
344 }
345
346 static struct Item* find_glob(OrderedHashmap *h, const char *match) {
347 ItemArray *j;
348 Iterator i;
349
350 ORDERED_HASHMAP_FOREACH(j, h, i) {
351 unsigned n;
352
353 for (n = 0; n < j->count; n++) {
354 Item *item = j->items + n;
355
356 if (fnmatch(item->path, match, FNM_PATHNAME|FNM_PERIOD) == 0)
357 return item;
358 }
359 }
360
361 return NULL;
362 }
363
364 static void load_unix_sockets(void) {
365 _cleanup_fclose_ FILE *f = NULL;
366 int r;
367
368 if (unix_sockets)
369 return;
370
371 /* We maintain a cache of the sockets we found in /proc/net/unix to speed things up a little. */
372
373 unix_sockets = set_new(&path_hash_ops);
374 if (!unix_sockets) {
375 log_oom();
376 return;
377 }
378
379 f = fopen("/proc/net/unix", "re");
380 if (!f) {
381 log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_WARNING, errno,
382 "Failed to open /proc/net/unix, ignoring: %m");
383 goto fail;
384 }
385
386 /* Skip header */
387 r = read_line(f, LONG_LINE_MAX, NULL);
388 if (r < 0) {
389 log_warning_errno(r, "Failed to skip /proc/net/unix header line: %m");
390 goto fail;
391 }
392 if (r == 0) {
393 log_warning("Premature end of file reading /proc/net/unix.");
394 goto fail;
395 }
396
397 for (;;) {
398 _cleanup_free_ char *line = NULL;
399 char *p, *s;
400
401 r = read_line(f, LONG_LINE_MAX, &line);
402 if (r < 0) {
403 log_warning_errno(r, "Failed to read /proc/net/unix line, ignoring: %m");
404 goto fail;
405 }
406 if (r == 0) /* EOF */
407 break;
408
409 p = strchr(line, ':');
410 if (!p)
411 continue;
412
413 if (strlen(p) < 37)
414 continue;
415
416 p += 37;
417 p += strspn(p, WHITESPACE);
418 p += strcspn(p, WHITESPACE); /* skip one more word */
419 p += strspn(p, WHITESPACE);
420
421 if (*p != '/')
422 continue;
423
424 s = strdup(p);
425 if (!s) {
426 log_oom();
427 goto fail;
428 }
429
430 path_simplify(s, false);
431
432 r = set_consume(unix_sockets, s);
433 if (r < 0 && r != -EEXIST) {
434 log_warning_errno(r, "Failed to add AF_UNIX socket to set, ignoring: %m");
435 goto fail;
436 }
437 }
438
439 return;
440
441 fail:
442 unix_sockets = set_free_free(unix_sockets);
443 }
444
445 static bool unix_socket_alive(const char *fn) {
446 assert(fn);
447
448 load_unix_sockets();
449
450 if (unix_sockets)
451 return !!set_get(unix_sockets, (char*) fn);
452
453 /* We don't know, so assume yes */
454 return true;
455 }
456
457 static int dir_is_mount_point(DIR *d, const char *subdir) {
458
459 int mount_id_parent, mount_id;
460 int r_p, r;
461
462 r_p = name_to_handle_at_loop(dirfd(d), ".", NULL, &mount_id_parent, 0);
463 if (r_p < 0)
464 r_p = -errno;
465
466 r = name_to_handle_at_loop(dirfd(d), subdir, NULL, &mount_id, 0);
467 if (r < 0)
468 r = -errno;
469
470 /* got no handle; make no assumptions, return error */
471 if (r_p < 0 && r < 0)
472 return r_p;
473
474 /* got both handles; if they differ, it is a mount point */
475 if (r_p >= 0 && r >= 0)
476 return mount_id_parent != mount_id;
477
478 /* got only one handle; assume different mount points if one
479 * of both queries was not supported by the filesystem */
480 if (IN_SET(r_p, -ENOSYS, -EOPNOTSUPP) || IN_SET(r, -ENOSYS, -EOPNOTSUPP))
481 return true;
482
483 /* return error */
484 if (r_p < 0)
485 return r_p;
486 return r;
487 }
488
489 static DIR* xopendirat_nomod(int dirfd, const char *path) {
490 DIR *dir;
491
492 dir = xopendirat(dirfd, path, O_NOFOLLOW|O_NOATIME);
493 if (dir)
494 return dir;
495
496 log_debug_errno(errno, "Cannot open %sdirectory \"%s\": %m", dirfd == AT_FDCWD ? "" : "sub", path);
497 if (errno != EPERM)
498 return NULL;
499
500 dir = xopendirat(dirfd, path, O_NOFOLLOW);
501 if (!dir)
502 log_debug_errno(errno, "Cannot open %sdirectory \"%s\": %m", dirfd == AT_FDCWD ? "" : "sub", path);
503
504 return dir;
505 }
506
507 static DIR* opendir_nomod(const char *path) {
508 return xopendirat_nomod(AT_FDCWD, path);
509 }
510
511 static int dir_cleanup(
512 Item *i,
513 const char *p,
514 DIR *d,
515 const struct stat *ds,
516 usec_t cutoff,
517 dev_t rootdev,
518 bool mountpoint,
519 int maxdepth,
520 bool keep_this_level) {
521
522 struct dirent *dent;
523 struct timespec times[2];
524 bool deleted = false;
525 int r = 0;
526
527 FOREACH_DIRENT_ALL(dent, d, break) {
528 struct stat s;
529 usec_t age;
530 _cleanup_free_ char *sub_path = NULL;
531
532 if (dot_or_dot_dot(dent->d_name))
533 continue;
534
535 if (fstatat(dirfd(d), dent->d_name, &s, AT_SYMLINK_NOFOLLOW) < 0) {
536 if (errno == ENOENT)
537 continue;
538
539 /* FUSE, NFS mounts, SELinux might return EACCES */
540 r = log_full_errno(errno == EACCES ? LOG_DEBUG : LOG_ERR, errno,
541 "stat(%s/%s) failed: %m", p, dent->d_name);
542 continue;
543 }
544
545 /* Stay on the same filesystem */
546 if (s.st_dev != rootdev) {
547 log_debug("Ignoring \"%s/%s\": different filesystem.", p, dent->d_name);
548 continue;
549 }
550
551 /* Try to detect bind mounts of the same filesystem instance; they
552 * do not differ in device major/minors. This type of query is not
553 * supported on all kernels or filesystem types though. */
554 if (S_ISDIR(s.st_mode) && dir_is_mount_point(d, dent->d_name) > 0) {
555 log_debug("Ignoring \"%s/%s\": different mount of the same filesystem.",
556 p, dent->d_name);
557 continue;
558 }
559
560 sub_path = strjoin(p, "/", dent->d_name);
561 if (!sub_path) {
562 r = log_oom();
563 goto finish;
564 }
565
566 /* Is there an item configured for this path? */
567 if (ordered_hashmap_get(items, sub_path)) {
568 log_debug("Ignoring \"%s\": a separate entry exists.", sub_path);
569 continue;
570 }
571
572 if (find_glob(globs, sub_path)) {
573 log_debug("Ignoring \"%s\": a separate glob exists.", sub_path);
574 continue;
575 }
576
577 if (S_ISDIR(s.st_mode)) {
578
579 if (mountpoint &&
580 streq(dent->d_name, "lost+found") &&
581 s.st_uid == 0) {
582 log_debug("Ignoring \"%s\".", sub_path);
583 continue;
584 }
585
586 if (maxdepth <= 0)
587 log_warning("Reached max depth on \"%s\".", sub_path);
588 else {
589 _cleanup_closedir_ DIR *sub_dir;
590 int q;
591
592 sub_dir = xopendirat_nomod(dirfd(d), dent->d_name);
593 if (!sub_dir) {
594 if (errno != ENOENT)
595 r = log_error_errno(errno, "opendir(%s) failed: %m", sub_path);
596
597 continue;
598 }
599
600 q = dir_cleanup(i, sub_path, sub_dir, &s, cutoff, rootdev, false, maxdepth-1, false);
601 if (q < 0)
602 r = q;
603 }
604
605 /* Note: if you are wondering why we don't
606 * support the sticky bit for excluding
607 * directories from cleaning like we do it for
608 * other file system objects: well, the sticky
609 * bit already has a meaning for directories,
610 * so we don't want to overload that. */
611
612 if (keep_this_level) {
613 log_debug("Keeping \"%s\".", sub_path);
614 continue;
615 }
616
617 /* Ignore ctime, we change it when deleting */
618 age = timespec_load(&s.st_mtim);
619 if (age >= cutoff) {
620 char a[FORMAT_TIMESTAMP_MAX];
621 /* Follows spelling in stat(1). */
622 log_debug("Directory \"%s\": modify time %s is too new.",
623 sub_path,
624 format_timestamp_us(a, sizeof(a), age));
625 continue;
626 }
627
628 age = timespec_load(&s.st_atim);
629 if (age >= cutoff) {
630 char a[FORMAT_TIMESTAMP_MAX];
631 log_debug("Directory \"%s\": access time %s is too new.",
632 sub_path,
633 format_timestamp_us(a, sizeof(a), age));
634 continue;
635 }
636
637 log_debug("Removing directory \"%s\".", sub_path);
638 if (unlinkat(dirfd(d), dent->d_name, AT_REMOVEDIR) < 0)
639 if (!IN_SET(errno, ENOENT, ENOTEMPTY))
640 r = log_error_errno(errno, "rmdir(%s): %m", sub_path);
641
642 } else {
643 /* Skip files for which the sticky bit is
644 * set. These are semantics we define, and are
645 * unknown elsewhere. See XDG_RUNTIME_DIR
646 * specification for details. */
647 if (s.st_mode & S_ISVTX) {
648 log_debug("Skipping \"%s\": sticky bit set.", sub_path);
649 continue;
650 }
651
652 if (mountpoint && S_ISREG(s.st_mode))
653 if (s.st_uid == 0 && STR_IN_SET(dent->d_name,
654 ".journal",
655 "aquota.user",
656 "aquota.group")) {
657 log_debug("Skipping \"%s\".", sub_path);
658 continue;
659 }
660
661 /* Ignore sockets that are listed in /proc/net/unix */
662 if (S_ISSOCK(s.st_mode) && unix_socket_alive(sub_path)) {
663 log_debug("Skipping \"%s\": live socket.", sub_path);
664 continue;
665 }
666
667 /* Ignore device nodes */
668 if (S_ISCHR(s.st_mode) || S_ISBLK(s.st_mode)) {
669 log_debug("Skipping \"%s\": a device.", sub_path);
670 continue;
671 }
672
673 /* Keep files on this level around if this is
674 * requested */
675 if (keep_this_level) {
676 log_debug("Keeping \"%s\".", sub_path);
677 continue;
678 }
679
680 age = timespec_load(&s.st_mtim);
681 if (age >= cutoff) {
682 char a[FORMAT_TIMESTAMP_MAX];
683 /* Follows spelling in stat(1). */
684 log_debug("File \"%s\": modify time %s is too new.",
685 sub_path,
686 format_timestamp_us(a, sizeof(a), age));
687 continue;
688 }
689
690 age = timespec_load(&s.st_atim);
691 if (age >= cutoff) {
692 char a[FORMAT_TIMESTAMP_MAX];
693 log_debug("File \"%s\": access time %s is too new.",
694 sub_path,
695 format_timestamp_us(a, sizeof(a), age));
696 continue;
697 }
698
699 age = timespec_load(&s.st_ctim);
700 if (age >= cutoff) {
701 char a[FORMAT_TIMESTAMP_MAX];
702 log_debug("File \"%s\": change time %s is too new.",
703 sub_path,
704 format_timestamp_us(a, sizeof(a), age));
705 continue;
706 }
707
708 log_debug("unlink \"%s\"", sub_path);
709
710 if (unlinkat(dirfd(d), dent->d_name, 0) < 0)
711 if (errno != ENOENT)
712 r = log_error_errno(errno, "unlink(%s): %m", sub_path);
713
714 deleted = true;
715 }
716 }
717
718 finish:
719 if (deleted) {
720 usec_t age1, age2;
721 char a[FORMAT_TIMESTAMP_MAX], b[FORMAT_TIMESTAMP_MAX];
722
723 /* Restore original directory timestamps */
724 times[0] = ds->st_atim;
725 times[1] = ds->st_mtim;
726
727 age1 = timespec_load(&ds->st_atim);
728 age2 = timespec_load(&ds->st_mtim);
729 log_debug("Restoring access and modification time on \"%s\": %s, %s",
730 p,
731 format_timestamp_us(a, sizeof(a), age1),
732 format_timestamp_us(b, sizeof(b), age2));
733 if (futimens(dirfd(d), times) < 0)
734 log_error_errno(errno, "utimensat(%s): %m", p);
735 }
736
737 return r;
738 }
739
740 static bool dangerous_hardlinks(void) {
741 _cleanup_free_ char *value = NULL;
742 static int cached = -1;
743 int r;
744
745 /* Check whether the fs.protected_hardlinks sysctl is on. If we can't determine it we assume its off, as that's
746 * what the upstream default is. */
747
748 if (cached >= 0)
749 return cached;
750
751 r = read_one_line_file("/proc/sys/fs/protected_hardlinks", &value);
752 if (r < 0) {
753 log_debug_errno(r, "Failed to read fs.protected_hardlinks sysctl: %m");
754 return true;
755 }
756
757 r = parse_boolean(value);
758 if (r < 0) {
759 log_debug_errno(r, "Failed to parse fs.protected_hardlinks sysctl: %m");
760 return true;
761 }
762
763 cached = r == 0;
764 return cached;
765 }
766
767 static bool hardlink_vulnerable(const struct stat *st) {
768 assert(st);
769
770 return !S_ISDIR(st->st_mode) && st->st_nlink > 1 && dangerous_hardlinks();
771 }
772
773 static int fd_set_perms(Item *i, int fd, const struct stat *st) {
774 _cleanup_free_ char *path = NULL;
775 struct stat stbuf;
776 int r;
777
778 assert(i);
779 assert(fd);
780
781 r = fd_get_path(fd, &path);
782 if (r < 0)
783 return r;
784
785 if (!i->mode_set && !i->uid_set && !i->gid_set)
786 goto shortcut;
787
788 if (!st) {
789 if (fstat(fd, &stbuf) < 0)
790 return log_error_errno(errno, "fstat(%s) failed: %m", path);
791 st = &stbuf;
792 }
793
794 if (hardlink_vulnerable(st)) {
795 log_error("Refusing to set permissions on hardlinked file %s while the fs.protected_hardlinks sysctl is turned off.", path);
796 return -EPERM;
797 }
798
799 if (i->mode_set) {
800 if (S_ISLNK(st->st_mode))
801 log_debug("Skipping mode fix for symlink %s.", path);
802 else {
803 mode_t m = i->mode;
804
805 if (i->mask_perms) {
806 if (!(st->st_mode & 0111))
807 m &= ~0111;
808 if (!(st->st_mode & 0222))
809 m &= ~0222;
810 if (!(st->st_mode & 0444))
811 m &= ~0444;
812 if (!S_ISDIR(st->st_mode))
813 m &= ~07000; /* remove sticky/sgid/suid bit, unless directory */
814 }
815
816 if (m == (st->st_mode & 07777))
817 log_debug("\"%s\" has correct mode %o already.", path, st->st_mode);
818 else {
819 log_debug("Changing \"%s\" to mode %o.", path, m);
820 if (fchmod_opath(fd, m) < 0)
821 return log_error_errno(errno, "fchmod() of %s failed: %m", path);
822 }
823 }
824 }
825
826 if ((i->uid_set && i->uid != st->st_uid) ||
827 (i->gid_set && i->gid != st->st_gid)) {
828 log_debug("Changing \"%s\" to owner "UID_FMT":"GID_FMT,
829 path,
830 i->uid_set ? i->uid : UID_INVALID,
831 i->gid_set ? i->gid : GID_INVALID);
832
833 if (fchownat(fd,
834 "",
835 i->uid_set ? i->uid : UID_INVALID,
836 i->gid_set ? i->gid : GID_INVALID,
837 AT_EMPTY_PATH) < 0)
838 return log_error_errno(errno, "fchownat() of %s failed: %m", path);
839 }
840
841 shortcut:
842 return label_fix(path, 0);
843 }
844
845 static int path_open_parent_safe(const char *path) {
846 _cleanup_free_ char *dn = NULL;
847 int fd;
848
849 if (path_equal(path, "/") || !path_is_normalized(path)) {
850 log_error("Failed to open parent of '%s': invalid path.", path);
851 return -EINVAL;
852 }
853
854 dn = dirname_malloc(path);
855 if (!dn)
856 return log_oom();
857
858 fd = chase_symlinks(dn, NULL, CHASE_OPEN|CHASE_SAFE, NULL);
859 if (fd == -EPERM)
860 return log_error_errno(fd, "Unsafe symlinks encountered in %s, refusing.", path);
861 if (fd < 0)
862 return log_error_errno(fd, "Failed to validate path %s: %m", path);
863
864 return fd;
865 }
866
867 static int path_set_perms(Item *i, const char *path) {
868 _cleanup_close_ int fd = -1;
869
870 assert(i);
871 assert(path);
872
873 fd = open(path, O_NOFOLLOW|O_CLOEXEC|O_PATH);
874 if (fd < 0)
875 return log_error_errno(errno, "Failed to open \"%s\" to adjust permissions: %m", path);
876
877 return fd_set_perms(i, fd, NULL);
878 }
879
880 static int parse_xattrs_from_arg(Item *i) {
881 const char *p;
882 int r;
883
884 assert(i);
885 assert(i->argument);
886
887 p = i->argument;
888
889 for (;;) {
890 _cleanup_free_ char *name = NULL, *value = NULL, *xattr = NULL;
891
892 r = extract_first_word(&p, &xattr, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE);
893 if (r < 0)
894 log_warning_errno(r, "Failed to parse extended attribute '%s', ignoring: %m", p);
895 if (r <= 0)
896 break;
897
898 r = split_pair(xattr, "=", &name, &value);
899 if (r < 0) {
900 log_warning_errno(r, "Failed to parse extended attribute, ignoring: %s", xattr);
901 continue;
902 }
903
904 if (isempty(name) || isempty(value)) {
905 log_warning("Malformed extended attribute found, ignoring: %s", xattr);
906 continue;
907 }
908
909 if (strv_push_pair(&i->xattrs, name, value) < 0)
910 return log_oom();
911
912 name = value = NULL;
913 }
914
915 return 0;
916 }
917
918 static int fd_set_xattrs(Item *i, int fd, const struct stat *st) {
919 char procfs_path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
920 _cleanup_free_ char *path = NULL;
921 char **name, **value;
922 int r;
923
924 assert(i);
925 assert(fd);
926
927 r = fd_get_path(fd, &path);
928 if (r < 0)
929 return r;
930
931 xsprintf(procfs_path, "/proc/self/fd/%i", fd);
932
933 STRV_FOREACH_PAIR(name, value, i->xattrs) {
934 log_debug("Setting extended attribute '%s=%s' on %s.", *name, *value, path);
935 if (setxattr(procfs_path, *name, *value, strlen(*value), 0) < 0)
936 return log_error_errno(errno, "Setting extended attribute %s=%s on %s failed: %m",
937 *name, *value, path);
938 }
939 return 0;
940 }
941
942 static int path_set_xattrs(Item *i, const char *path) {
943 _cleanup_close_ int fd = -1;
944
945 assert(i);
946 assert(path);
947
948 fd = open(path, O_CLOEXEC|O_NOFOLLOW|O_PATH);
949 if (fd < 0)
950 return log_error_errno(errno, "Cannot open '%s': %m", path);
951
952 return fd_set_xattrs(i, fd, NULL);
953 }
954
955 static int parse_acls_from_arg(Item *item) {
956 #if HAVE_ACL
957 int r;
958
959 assert(item);
960
961 /* If force (= modify) is set, we will not modify the acl
962 * afterwards, so the mask can be added now if necessary. */
963
964 r = parse_acl(item->argument, &item->acl_access, &item->acl_default, !item->force);
965 if (r < 0)
966 log_warning_errno(r, "Failed to parse ACL \"%s\": %m. Ignoring", item->argument);
967 #else
968 log_warning_errno(ENOSYS, "ACLs are not supported. Ignoring");
969 #endif
970
971 return 0;
972 }
973
974 #if HAVE_ACL
975 static int path_set_acl(const char *path, const char *pretty, acl_type_t type, acl_t acl, bool modify) {
976 _cleanup_(acl_free_charpp) char *t = NULL;
977 _cleanup_(acl_freep) acl_t dup = NULL;
978 int r;
979
980 /* Returns 0 for success, positive error if already warned,
981 * negative error otherwise. */
982
983 if (modify) {
984 r = acls_for_file(path, type, acl, &dup);
985 if (r < 0)
986 return r;
987
988 r = calc_acl_mask_if_needed(&dup);
989 if (r < 0)
990 return r;
991 } else {
992 dup = acl_dup(acl);
993 if (!dup)
994 return -errno;
995
996 /* the mask was already added earlier if needed */
997 }
998
999 r = add_base_acls_if_needed(&dup, path);
1000 if (r < 0)
1001 return r;
1002
1003 t = acl_to_any_text(dup, NULL, ',', TEXT_ABBREVIATE);
1004 log_debug("Setting %s ACL %s on %s.",
1005 type == ACL_TYPE_ACCESS ? "access" : "default",
1006 strna(t), pretty);
1007
1008 r = acl_set_file(path, type, dup);
1009 if (r < 0)
1010 /* Return positive to indicate we already warned */
1011 return -log_error_errno(errno,
1012 "Setting %s ACL \"%s\" on %s failed: %m",
1013 type == ACL_TYPE_ACCESS ? "access" : "default",
1014 strna(t), pretty);
1015
1016 return 0;
1017 }
1018 #endif
1019
1020 static int fd_set_acls(Item *item, int fd, const struct stat *st) {
1021 int r = 0;
1022 #if HAVE_ACL
1023 char procfs_path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
1024 _cleanup_free_ char *path = NULL;
1025 struct stat stbuf;
1026
1027 assert(item);
1028 assert(fd);
1029
1030 r = fd_get_path(fd, &path);
1031 if (r < 0)
1032 return r;
1033
1034 if (!st) {
1035 if (fstat(fd, &stbuf) < 0)
1036 return log_error_errno(errno, "fstat(%s) failed: %m", path);
1037 st = &stbuf;
1038 }
1039
1040 if (hardlink_vulnerable(st)) {
1041 log_error("Refusing to set ACLs on hardlinked file %s while the fs.protected_hardlinks sysctl is turned off.", path);
1042 return -EPERM;
1043 }
1044
1045 if (S_ISLNK(st->st_mode)) {
1046 log_debug("Skipping ACL fix for symlink %s.", path);
1047 return 0;
1048 }
1049
1050 xsprintf(procfs_path, "/proc/self/fd/%i", fd);
1051
1052 if (item->acl_access)
1053 r = path_set_acl(procfs_path, path, ACL_TYPE_ACCESS, item->acl_access, item->force);
1054
1055 /* set only default acls to folders */
1056 if (r == 0 && item->acl_default && S_ISDIR(st->st_mode))
1057 r = path_set_acl(procfs_path, path, ACL_TYPE_DEFAULT, item->acl_default, item->force);
1058
1059 if (r > 0)
1060 return -r; /* already warned */
1061 if (r == -EOPNOTSUPP) {
1062 log_debug_errno(r, "ACLs not supported by file system at %s", path);
1063 return 0;
1064 }
1065 if (r < 0)
1066 return log_error_errno(r, "ACL operation on \"%s\" failed: %m", path);
1067 #endif
1068 return r;
1069 }
1070
1071 static int path_set_acls(Item *item, const char *path) {
1072 int r = 0;
1073 #if HAVE_ACL
1074 _cleanup_close_ int fd = -1;
1075
1076 assert(item);
1077 assert(path);
1078
1079 fd = open(path, O_NOFOLLOW|O_CLOEXEC|O_PATH);
1080 if (fd < 0)
1081 return log_error_errno(errno, "Adjusting ACL of %s failed: %m", path);
1082
1083 r = fd_set_acls(item, fd, NULL);
1084 #endif
1085 return r;
1086 }
1087
1088 #define ATTRIBUTES_ALL \
1089 (FS_NOATIME_FL | \
1090 FS_SYNC_FL | \
1091 FS_DIRSYNC_FL | \
1092 FS_APPEND_FL | \
1093 FS_COMPR_FL | \
1094 FS_NODUMP_FL | \
1095 FS_EXTENT_FL | \
1096 FS_IMMUTABLE_FL | \
1097 FS_JOURNAL_DATA_FL | \
1098 FS_SECRM_FL | \
1099 FS_UNRM_FL | \
1100 FS_NOTAIL_FL | \
1101 FS_TOPDIR_FL | \
1102 FS_NOCOW_FL)
1103
1104 static int parse_attribute_from_arg(Item *item) {
1105
1106 static const struct {
1107 char character;
1108 unsigned value;
1109 } attributes[] = {
1110 { 'A', FS_NOATIME_FL }, /* do not update atime */
1111 { 'S', FS_SYNC_FL }, /* Synchronous updates */
1112 { 'D', FS_DIRSYNC_FL }, /* dirsync behaviour (directories only) */
1113 { 'a', FS_APPEND_FL }, /* writes to file may only append */
1114 { 'c', FS_COMPR_FL }, /* Compress file */
1115 { 'd', FS_NODUMP_FL }, /* do not dump file */
1116 { 'e', FS_EXTENT_FL }, /* Extents */
1117 { 'i', FS_IMMUTABLE_FL }, /* Immutable file */
1118 { 'j', FS_JOURNAL_DATA_FL }, /* Reserved for ext3 */
1119 { 's', FS_SECRM_FL }, /* Secure deletion */
1120 { 'u', FS_UNRM_FL }, /* Undelete */
1121 { 't', FS_NOTAIL_FL }, /* file tail should not be merged */
1122 { 'T', FS_TOPDIR_FL }, /* Top of directory hierarchies */
1123 { 'C', FS_NOCOW_FL }, /* Do not cow file */
1124 };
1125
1126 enum {
1127 MODE_ADD,
1128 MODE_DEL,
1129 MODE_SET
1130 } mode = MODE_ADD;
1131
1132 unsigned value = 0, mask = 0;
1133 const char *p;
1134
1135 assert(item);
1136
1137 p = item->argument;
1138 if (p) {
1139 if (*p == '+') {
1140 mode = MODE_ADD;
1141 p++;
1142 } else if (*p == '-') {
1143 mode = MODE_DEL;
1144 p++;
1145 } else if (*p == '=') {
1146 mode = MODE_SET;
1147 p++;
1148 }
1149 }
1150
1151 if (isempty(p) && mode != MODE_SET) {
1152 log_error("Setting file attribute on '%s' needs an attribute specification.", item->path);
1153 return -EINVAL;
1154 }
1155
1156 for (; p && *p ; p++) {
1157 unsigned i, v;
1158
1159 for (i = 0; i < ELEMENTSOF(attributes); i++)
1160 if (*p == attributes[i].character)
1161 break;
1162
1163 if (i >= ELEMENTSOF(attributes)) {
1164 log_error("Unknown file attribute '%c' on '%s'.", *p, item->path);
1165 return -EINVAL;
1166 }
1167
1168 v = attributes[i].value;
1169
1170 SET_FLAG(value, v, IN_SET(mode, MODE_ADD, MODE_SET));
1171
1172 mask |= v;
1173 }
1174
1175 if (mode == MODE_SET)
1176 mask |= ATTRIBUTES_ALL;
1177
1178 assert(mask != 0);
1179
1180 item->attribute_mask = mask;
1181 item->attribute_value = value;
1182 item->attribute_set = true;
1183
1184 return 0;
1185 }
1186
1187 static int fd_set_attribute(Item *item, int fd, const struct stat *st) {
1188 _cleanup_close_ int procfs_fd = -1;
1189 _cleanup_free_ char *path = NULL;
1190 struct stat stbuf;
1191 unsigned f;
1192 int r;
1193
1194 if (!item->attribute_set || item->attribute_mask == 0)
1195 return 0;
1196
1197 r = fd_get_path(fd, &path);
1198 if (r < 0)
1199 return r;
1200
1201 if (!st) {
1202 if (fstat(fd, &stbuf) < 0)
1203 return log_error_errno(errno, "fstat(%s) failed: %m", path);
1204 st = &stbuf;
1205 }
1206
1207 /* Issuing the file attribute ioctls on device nodes is not
1208 * safe, as that will be delivered to the drivers, not the
1209 * file system containing the device node. */
1210 if (!S_ISREG(st->st_mode) && !S_ISDIR(st->st_mode)) {
1211 log_error("Setting file flags is only supported on regular files and directories, cannot set on '%s'.", path);
1212 return -EINVAL;
1213 }
1214
1215 f = item->attribute_value & item->attribute_mask;
1216
1217 /* Mask away directory-specific flags */
1218 if (!S_ISDIR(st->st_mode))
1219 f &= ~FS_DIRSYNC_FL;
1220
1221 procfs_fd = fd_reopen(fd, O_RDONLY|O_CLOEXEC|O_NOATIME);
1222 if (procfs_fd < 0)
1223 return -errno;
1224
1225 r = chattr_fd(procfs_fd, f, item->attribute_mask);
1226 if (r < 0)
1227 log_full_errno(IN_SET(r, -ENOTTY, -EOPNOTSUPP) ? LOG_DEBUG : LOG_WARNING,
1228 r,
1229 "Cannot set file attribute for '%s', value=0x%08x, mask=0x%08x: %m",
1230 path, item->attribute_value, item->attribute_mask);
1231
1232 return 0;
1233 }
1234
1235 static int path_set_attribute(Item *item, const char *path) {
1236 _cleanup_close_ int fd = -1;
1237
1238 if (!item->attribute_set || item->attribute_mask == 0)
1239 return 0;
1240
1241 fd = open(path, O_CLOEXEC|O_NOFOLLOW|O_PATH);
1242 if (fd < 0)
1243 return log_error_errno(errno, "Cannot open '%s': %m", path);
1244
1245 return fd_set_attribute(item, fd, NULL);
1246 }
1247
1248 static int write_one_file(Item *i, const char *path) {
1249 _cleanup_close_ int fd = -1, dir_fd = -1;
1250 char *bn;
1251 int r;
1252
1253 assert(i);
1254 assert(path);
1255 assert(i->argument);
1256 assert(i->type == WRITE_FILE);
1257
1258 /* Validate the path and keep the fd on the directory for opening the
1259 * file so we're sure that it can't be changed behind our back. */
1260 dir_fd = path_open_parent_safe(path);
1261 if (dir_fd < 0)
1262 return dir_fd;
1263
1264 bn = basename(path);
1265
1266 /* Follows symlinks */
1267 fd = openat(dir_fd, bn, O_NONBLOCK|O_CLOEXEC|O_WRONLY|O_NOCTTY, i->mode);
1268 if (fd < 0) {
1269 if (errno == ENOENT) {
1270 log_debug_errno(errno, "Not writing missing file \"%s\": %m", path);
1271 return 0;
1272 }
1273 return log_error_errno(errno, "Failed to open file \"%s\": %m", path);
1274 }
1275
1276 /* 'w' is allowed to write into any kind of files. */
1277 log_debug("Writing to \"%s\".", path);
1278
1279 r = loop_write(fd, i->argument, strlen(i->argument), false);
1280 if (r < 0)
1281 return log_error_errno(r, "Failed to write file \"%s\": %m", path);
1282
1283 return fd_set_perms(i, fd, NULL);
1284 }
1285
1286 static int create_file(Item *i, const char *path) {
1287 _cleanup_close_ int fd = -1, dir_fd = -1;
1288 struct stat stbuf, *st = NULL;
1289 int r = 0;
1290 char *bn;
1291
1292 assert(i);
1293 assert(path);
1294 assert(i->type == CREATE_FILE);
1295
1296 /* 'f' operates on regular files exclusively. */
1297
1298 /* Validate the path and keep the fd on the directory for opening the
1299 * file so we're sure that it can't be changed behind our back. */
1300 dir_fd = path_open_parent_safe(path);
1301 if (dir_fd < 0)
1302 return dir_fd;
1303
1304 bn = basename(path);
1305
1306 RUN_WITH_UMASK(0000) {
1307 mac_selinux_create_file_prepare(path, S_IFREG);
1308 fd = openat(dir_fd, bn, O_CREAT|O_EXCL|O_NOFOLLOW|O_NONBLOCK|O_CLOEXEC|O_WRONLY|O_NOCTTY, i->mode);
1309 mac_selinux_create_file_clear();
1310 }
1311
1312 if (fd < 0) {
1313 /* Even on a read-only filesystem, open(2) returns EEXIST if the
1314 * file already exists. It returns EROFS only if it needs to
1315 * create the file. */
1316 if (errno != EEXIST)
1317 return log_error_errno(errno, "Failed to create file %s: %m", path);
1318
1319 /* Re-open the file. At that point it must exist since open(2)
1320 * failed with EEXIST. We still need to check if the perms/mode
1321 * need to be changed. For read-only filesystems, we let
1322 * fd_set_perms() report the error if the perms need to be
1323 * modified. */
1324 fd = openat(dir_fd, bn, O_NOFOLLOW|O_CLOEXEC|O_PATH, i->mode);
1325 if (fd < 0)
1326 return log_error_errno(errno, "Failed to re-open file %s: %m", path);
1327
1328 if (fstat(fd, &stbuf) < 0)
1329 return log_error_errno(errno, "stat(%s) failed: %m", path);
1330
1331 if (!S_ISREG(stbuf.st_mode)) {
1332 log_error("%s exists and is not a regular file.", path);
1333 return -EEXIST;
1334 }
1335
1336 st = &stbuf;
1337 } else {
1338
1339 log_debug("\"%s\" has been created.", path);
1340
1341 if (i->argument) {
1342 log_debug("Writing to \"%s\".", path);
1343
1344 r = loop_write(fd, i->argument, strlen(i->argument), false);
1345 if (r < 0)
1346 return log_error_errno(r, "Failed to write file \"%s\": %m", path);
1347 }
1348 }
1349
1350 return fd_set_perms(i, fd, st);
1351 }
1352
1353 static int truncate_file(Item *i, const char *path) {
1354 _cleanup_close_ int fd = -1, dir_fd = -1;
1355 struct stat stbuf, *st = NULL;
1356 bool erofs = false;
1357 int r = 0;
1358 char *bn;
1359
1360 assert(i);
1361 assert(path);
1362 assert(i->type == TRUNCATE_FILE);
1363
1364 /* We want to operate on regular file exclusively especially since
1365 * O_TRUNC is unspecified if the file is neither a regular file nor a
1366 * fifo nor a terminal device. Therefore we first open the file and make
1367 * sure it's a regular one before truncating it. */
1368
1369 /* Validate the path and keep the fd on the directory for opening the
1370 * file so we're sure that it can't be changed behind our back. */
1371 dir_fd = path_open_parent_safe(path);
1372 if (dir_fd < 0)
1373 return dir_fd;
1374
1375 bn = basename(path);
1376
1377 RUN_WITH_UMASK(0000) {
1378 mac_selinux_create_file_prepare(path, S_IFREG);
1379 fd = openat(dir_fd, bn, O_CREAT|O_NOFOLLOW|O_NONBLOCK|O_CLOEXEC|O_WRONLY|O_NOCTTY, i->mode);
1380 mac_selinux_create_file_clear();
1381 }
1382
1383 if (fd < 0) {
1384 if (errno != EROFS)
1385 return log_error_errno(errno, "Failed to open/create file %s: %m", path);
1386
1387 /* On a read-only filesystem, we don't want to fail if the
1388 * target is already empty and the perms are set. So we still
1389 * proceed with the sanity checks and let the remaining
1390 * operations fail with EROFS if they try to modify the target
1391 * file. */
1392
1393 fd = openat(dir_fd, bn, O_NOFOLLOW|O_CLOEXEC|O_PATH, i->mode);
1394 if (fd < 0) {
1395 if (errno == ENOENT) {
1396 log_error("Cannot create file %s on a read-only file system.", path);
1397 return -EROFS;
1398 }
1399
1400 return log_error_errno(errno, "Failed to re-open file %s: %m", path);
1401 }
1402
1403 erofs = true;
1404 }
1405
1406 if (fstat(fd, &stbuf) < 0)
1407 return log_error_errno(errno, "stat(%s) failed: %m", path);
1408
1409 if (!S_ISREG(stbuf.st_mode)) {
1410 log_error("%s exists and is not a regular file.", path);
1411 return -EEXIST;
1412 }
1413
1414 if (stbuf.st_size > 0) {
1415 if (ftruncate(fd, 0) < 0) {
1416 r = erofs ? -EROFS : -errno;
1417 return log_error_errno(r, "Failed to truncate file %s: %m", path);
1418 }
1419 } else
1420 st = &stbuf;
1421
1422 log_debug("\"%s\" has been created.", path);
1423
1424 if (i->argument) {
1425 log_debug("Writing to \"%s\".", path);
1426
1427 r = loop_write(fd, i->argument, strlen(i->argument), false);
1428 if (r < 0) {
1429 r = erofs ? -EROFS : r;
1430 return log_error_errno(r, "Failed to write file %s: %m", path);
1431 }
1432 }
1433
1434 return fd_set_perms(i, fd, st);
1435 }
1436
1437 static int copy_files(Item *i) {
1438 _cleanup_close_ int dfd = -1, fd = -1;
1439 char *bn;
1440 int r;
1441
1442 log_debug("Copying tree \"%s\" to \"%s\".", i->argument, i->path);
1443
1444 bn = basename(i->path);
1445
1446 /* Validate the path and use the returned directory fd for copying the
1447 * target so we're sure that the path can't be changed behind our
1448 * back. */
1449 dfd = path_open_parent_safe(i->path);
1450 if (dfd < 0)
1451 return dfd;
1452
1453 r = copy_tree_at(AT_FDCWD, i->argument,
1454 dfd, bn,
1455 i->uid_set ? i->uid : UID_INVALID,
1456 i->gid_set ? i->gid : GID_INVALID,
1457 COPY_REFLINK);
1458 if (r < 0) {
1459 struct stat a, b;
1460
1461 /* If the target already exists on read-only filesystems, trying
1462 * to create the target will not fail with EEXIST but with
1463 * EROFS. */
1464 if (r == -EROFS && faccessat(dfd, bn, F_OK, AT_SYMLINK_NOFOLLOW) == 0)
1465 r = -EEXIST;
1466
1467 if (r != -EEXIST)
1468 return log_error_errno(r, "Failed to copy files to %s: %m", i->path);
1469
1470 if (stat(i->argument, &a) < 0)
1471 return log_error_errno(errno, "stat(%s) failed: %m", i->argument);
1472
1473 if (fstatat(dfd, bn, &b, AT_SYMLINK_NOFOLLOW) < 0)
1474 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
1475
1476 if ((a.st_mode ^ b.st_mode) & S_IFMT) {
1477 log_debug("Can't copy to %s, file exists already and is of different type", i->path);
1478 return 0;
1479 }
1480 }
1481
1482 fd = openat(dfd, bn, O_NOFOLLOW|O_CLOEXEC|O_PATH);
1483 if (fd < 0)
1484 return log_error_errno(errno, "Failed to openat(%s): %m", i->path);
1485
1486 return fd_set_perms(i, fd, NULL);
1487 }
1488
1489 typedef enum {
1490 CREATION_NORMAL,
1491 CREATION_EXISTING,
1492 CREATION_FORCE,
1493 _CREATION_MODE_MAX,
1494 _CREATION_MODE_INVALID = -1
1495 } CreationMode;
1496
1497 static const char *creation_mode_verb_table[_CREATION_MODE_MAX] = {
1498 [CREATION_NORMAL] = "Created",
1499 [CREATION_EXISTING] = "Found existing",
1500 [CREATION_FORCE] = "Created replacement",
1501 };
1502
1503 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(creation_mode_verb, CreationMode);
1504
1505 static int create_directory_or_subvolume(const char *path, mode_t mode, bool subvol) {
1506 _cleanup_close_ int pfd = -1;
1507 CreationMode creation;
1508 int r;
1509
1510 assert(path);
1511
1512 pfd = path_open_parent_safe(path);
1513 if (pfd < 0)
1514 return pfd;
1515
1516 if (subvol) {
1517 if (btrfs_is_subvol(empty_to_root(arg_root)) <= 0)
1518
1519 /* Don't create a subvolume unless the root directory is
1520 * one, too. We do this under the assumption that if the
1521 * root directory is just a plain directory (i.e. very
1522 * light-weight), we shouldn't try to split it up into
1523 * subvolumes (i.e. more heavy-weight). Thus, chroot()
1524 * environments and suchlike will get a full brtfs
1525 * subvolume set up below their tree only if they
1526 * specifically set up a btrfs subvolume for the root
1527 * dir too. */
1528
1529 subvol = false;
1530 else {
1531 RUN_WITH_UMASK((~mode) & 0777)
1532 r = btrfs_subvol_make_fd(pfd, basename(path));
1533 }
1534 } else
1535 r = 0;
1536
1537 if (!subvol || r == -ENOTTY)
1538 RUN_WITH_UMASK(0000)
1539 r = mkdirat_label(pfd, basename(path), mode);
1540
1541 if (r < 0) {
1542 int k;
1543
1544 if (!IN_SET(r, -EEXIST, -EROFS))
1545 return log_error_errno(r, "Failed to create directory or subvolume \"%s\": %m", path);
1546
1547 k = is_dir_fd(pfd);
1548 if (k == -ENOENT && r == -EROFS)
1549 return log_error_errno(r, "%s does not exist and cannot be created as the file system is read-only.", path);
1550 if (k < 0)
1551 return log_error_errno(k, "Failed to check if %s exists: %m", path);
1552 if (!k) {
1553 log_warning("\"%s\" already exists and is not a directory.", path);
1554 return -EEXIST;
1555 }
1556
1557 creation = CREATION_EXISTING;
1558 } else
1559 creation = CREATION_NORMAL;
1560
1561 log_debug("%s directory \"%s\".", creation_mode_verb_to_string(creation), path);
1562
1563 r = openat(pfd, basename(path), O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
1564 if (r < 0)
1565 return -errno;
1566 return r;
1567 }
1568
1569 static int create_directory(Item *i, const char *path) {
1570 _cleanup_close_ int fd = -1;
1571
1572 assert(i);
1573 assert(IN_SET(i->type, CREATE_DIRECTORY, TRUNCATE_DIRECTORY));
1574
1575 fd = create_directory_or_subvolume(path, i->mode, false);
1576 if (fd == -EEXIST)
1577 return 0;
1578 if (fd < 0)
1579 return fd;
1580
1581 return fd_set_perms(i, fd, NULL);
1582 }
1583
1584 static int create_subvolume(Item *i, const char *path) {
1585 _cleanup_close_ int fd = -1;
1586 int r, q = 0;
1587
1588 assert(i);
1589 assert(IN_SET(i->type, CREATE_SUBVOLUME, CREATE_SUBVOLUME_NEW_QUOTA, CREATE_SUBVOLUME_INHERIT_QUOTA));
1590
1591 fd = create_directory_or_subvolume(path, i->mode, true);
1592 if (fd == -EEXIST)
1593 return 0;
1594 if (fd < 0)
1595 return fd;
1596
1597 if (IN_SET(i->type, CREATE_SUBVOLUME_NEW_QUOTA, CREATE_SUBVOLUME_INHERIT_QUOTA)) {
1598 r = btrfs_subvol_auto_qgroup_fd(fd, 0, i->type == CREATE_SUBVOLUME_NEW_QUOTA);
1599 if (r == -ENOTTY)
1600 log_debug_errno(r, "Couldn't adjust quota for subvolume \"%s\" (unsupported fs or dir not a subvolume): %m", i->path);
1601 else if (r == -EROFS)
1602 log_debug_errno(r, "Couldn't adjust quota for subvolume \"%s\" (fs is read-only).", i->path);
1603 else if (r == -ENOPROTOOPT)
1604 log_debug_errno(r, "Couldn't adjust quota for subvolume \"%s\" (quota support is disabled).", i->path);
1605 else if (r < 0)
1606 q = log_error_errno(r, "Failed to adjust quota for subvolume \"%s\": %m", i->path);
1607 else if (r > 0)
1608 log_debug("Adjusted quota for subvolume \"%s\".", i->path);
1609 else if (r == 0)
1610 log_debug("Quota for subvolume \"%s\" already in place, no change made.", i->path);
1611 }
1612
1613 r = fd_set_perms(i, fd, NULL);
1614 if (q < 0)
1615 return q;
1616
1617 return r;
1618 }
1619
1620 static int empty_directory(Item *i, const char *path) {
1621 int r;
1622
1623 assert(i);
1624 assert(i->type == EMPTY_DIRECTORY);
1625
1626 r = is_dir(path, false);
1627 if (r == -ENOENT) {
1628 /* Option "e" operates only on existing objects. Do not
1629 * print errors about non-existent files or directories */
1630 log_debug("Skipping missing directory: %s", path);
1631 return 0;
1632 }
1633 if (r < 0)
1634 return log_error_errno(r, "is_dir() failed on path %s: %m", path);
1635 if (r == 0) {
1636 log_error("'%s' already exists and is not a directory.", path);
1637 return -EEXIST;
1638 }
1639
1640 return path_set_perms(i, path);
1641 }
1642
1643 static int create_device(Item *i, mode_t file_type) {
1644 _cleanup_close_ int dfd = -1, fd = -1;
1645 CreationMode creation;
1646 char *bn;
1647 int r;
1648
1649 assert(i);
1650 assert(IN_SET(file_type, S_IFBLK, S_IFCHR));
1651
1652 bn = basename(i->path);
1653
1654 /* Validate the path and use the returned directory fd for copying the
1655 * target so we're sure that the path can't be changed behind our
1656 * back. */
1657 dfd = path_open_parent_safe(i->path);
1658 if (dfd < 0)
1659 return dfd;
1660
1661 RUN_WITH_UMASK(0000) {
1662 mac_selinux_create_file_prepare(i->path, file_type);
1663 r = mknodat(dfd, bn, i->mode | file_type, i->major_minor);
1664 mac_selinux_create_file_clear();
1665 }
1666
1667 if (r < 0) {
1668 struct stat st;
1669
1670 if (errno == EPERM) {
1671 log_debug("We lack permissions, possibly because of cgroup configuration; "
1672 "skipping creation of device node %s.", i->path);
1673 return 0;
1674 }
1675
1676 if (errno != EEXIST)
1677 return log_error_errno(errno, "Failed to create device node %s: %m", i->path);
1678
1679 if (fstatat(dfd, bn, &st, 0) < 0)
1680 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
1681
1682 if ((st.st_mode & S_IFMT) != file_type) {
1683
1684 if (i->force) {
1685
1686 RUN_WITH_UMASK(0000) {
1687 mac_selinux_create_file_prepare(i->path, file_type);
1688 /* FIXME: need to introduce mknodat_atomic() */
1689 r = mknod_atomic(i->path, i->mode | file_type, i->major_minor);
1690 mac_selinux_create_file_clear();
1691 }
1692
1693 if (r < 0)
1694 return log_error_errno(r, "Failed to create device node \"%s\": %m", i->path);
1695 creation = CREATION_FORCE;
1696 } else {
1697 log_debug("%s is not a device node.", i->path);
1698 return 0;
1699 }
1700 } else
1701 creation = CREATION_EXISTING;
1702 } else
1703 creation = CREATION_NORMAL;
1704
1705 log_debug("%s %s device node \"%s\" %u:%u.",
1706 creation_mode_verb_to_string(creation),
1707 i->type == CREATE_BLOCK_DEVICE ? "block" : "char",
1708 i->path, major(i->mode), minor(i->mode));
1709
1710 fd = openat(dfd, bn, O_NOFOLLOW|O_CLOEXEC|O_PATH);
1711 if (fd < 0)
1712 return log_error_errno(errno, "Failed to openat(%s): %m", i->path);
1713
1714 return fd_set_perms(i, fd, NULL);
1715 }
1716
1717 static int create_fifo(Item *i, const char *path) {
1718 CreationMode creation;
1719 struct stat st;
1720 int r;
1721
1722 RUN_WITH_UMASK(0000) {
1723 mac_selinux_create_file_prepare(path, S_IFIFO);
1724 r = mkfifo(path, i->mode);
1725 mac_selinux_create_file_clear();
1726 }
1727
1728 if (r < 0) {
1729 if (errno != EEXIST)
1730 return log_error_errno(errno, "Failed to create fifo %s: %m", path);
1731
1732 if (lstat(path, &st) < 0)
1733 return log_error_errno(errno, "stat(%s) failed: %m", path);
1734
1735 if (!S_ISFIFO(st.st_mode)) {
1736
1737 if (i->force) {
1738 RUN_WITH_UMASK(0000) {
1739 mac_selinux_create_file_prepare(path, S_IFIFO);
1740 r = mkfifo_atomic(path, i->mode);
1741 mac_selinux_create_file_clear();
1742 }
1743
1744 if (r < 0)
1745 return log_error_errno(r, "Failed to create fifo %s: %m", path);
1746 creation = CREATION_FORCE;
1747 } else {
1748 log_warning("\"%s\" already exists and is not a fifo.", path);
1749 return 0;
1750 }
1751 } else
1752 creation = CREATION_EXISTING;
1753 } else
1754 creation = CREATION_NORMAL;
1755 log_debug("%s fifo \"%s\".", creation_mode_verb_to_string(creation), path);
1756
1757 return path_set_perms(i, path);
1758 }
1759
1760 typedef int (*action_t)(Item *, const char *);
1761 typedef int (*fdaction_t)(Item *, int fd, const struct stat *st);
1762
1763 static int item_do(Item *i, int fd, fdaction_t action) {
1764 struct stat st;
1765 int r = 0, q;
1766
1767 assert(i);
1768 assert(fd >= 0);
1769
1770 if (fstat(fd, &st) < 0) {
1771 r = -errno;
1772 goto finish;
1773 }
1774
1775 /* This returns the first error we run into, but nevertheless
1776 * tries to go on */
1777 r = action(i, fd, &st);
1778
1779 if (S_ISDIR(st.st_mode)) {
1780 char procfs_path[STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
1781 _cleanup_closedir_ DIR *d = NULL;
1782 struct dirent *de;
1783
1784 /* The passed 'fd' was opened with O_PATH. We need to convert
1785 * it into a 'regular' fd before reading the directory content. */
1786 xsprintf(procfs_path, "/proc/self/fd/%i", fd);
1787
1788 d = opendir(procfs_path);
1789 if (!d) {
1790 r = r ?: -errno;
1791 goto finish;
1792 }
1793
1794 FOREACH_DIRENT_ALL(de, d, q = -errno; goto finish) {
1795 int de_fd;
1796
1797 if (dot_or_dot_dot(de->d_name))
1798 continue;
1799
1800 de_fd = openat(fd, de->d_name, O_NOFOLLOW|O_CLOEXEC|O_PATH);
1801 if (de_fd >= 0)
1802 /* pass ownership of dirent fd over */
1803 q = item_do(i, de_fd, action);
1804 else
1805 q = -errno;
1806
1807 if (q < 0 && r == 0)
1808 r = q;
1809 }
1810 }
1811 finish:
1812 safe_close(fd);
1813 return r;
1814 }
1815
1816 static int glob_item(Item *i, action_t action) {
1817 _cleanup_globfree_ glob_t g = {
1818 .gl_opendir = (void *(*)(const char *)) opendir_nomod,
1819 };
1820 int r = 0, k;
1821 char **fn;
1822
1823 k = safe_glob(i->path, GLOB_NOSORT|GLOB_BRACE, &g);
1824 if (k < 0 && k != -ENOENT)
1825 return log_error_errno(k, "glob(%s) failed: %m", i->path);
1826
1827 STRV_FOREACH(fn, g.gl_pathv) {
1828 k = action(i, *fn);
1829 if (k < 0 && r == 0)
1830 r = k;
1831 }
1832
1833 return r;
1834 }
1835
1836 static int glob_item_recursively(Item *i, fdaction_t action) {
1837 _cleanup_globfree_ glob_t g = {
1838 .gl_opendir = (void *(*)(const char *)) opendir_nomod,
1839 };
1840 int r = 0, k;
1841 char **fn;
1842
1843 k = safe_glob(i->path, GLOB_NOSORT|GLOB_BRACE, &g);
1844 if (k < 0 && k != -ENOENT)
1845 return log_error_errno(k, "glob(%s) failed: %m", i->path);
1846
1847 STRV_FOREACH(fn, g.gl_pathv) {
1848 _cleanup_close_ int fd = -1;
1849
1850 /* Make sure we won't trigger/follow file object (such as
1851 * device nodes, automounts, ...) pointed out by 'fn' with
1852 * O_PATH. Note, when O_PATH is used, flags other than
1853 * O_CLOEXEC, O_DIRECTORY, and O_NOFOLLOW are ignored. */
1854
1855 fd = open(*fn, O_CLOEXEC|O_NOFOLLOW|O_PATH);
1856 if (fd < 0) {
1857 r = r ?: -errno;
1858 continue;
1859 }
1860
1861 k = item_do(i, fd, action);
1862 if (k < 0 && r == 0)
1863 r = k;
1864
1865 /* we passed fd ownership to the previous call */
1866 fd = -1;
1867 }
1868
1869 return r;
1870 }
1871
1872 static int create_item(Item *i) {
1873 CreationMode creation;
1874 int r = 0;
1875
1876 assert(i);
1877
1878 log_debug("Running create action for entry %c %s", (char) i->type, i->path);
1879
1880 switch (i->type) {
1881
1882 case IGNORE_PATH:
1883 case IGNORE_DIRECTORY_PATH:
1884 case REMOVE_PATH:
1885 case RECURSIVE_REMOVE_PATH:
1886 return 0;
1887
1888 case CREATE_FILE:
1889 RUN_WITH_UMASK(0000)
1890 (void) mkdir_parents_label(i->path, 0755);
1891
1892 r = create_file(i, i->path);
1893 if (r < 0)
1894 return r;
1895 break;
1896
1897 case TRUNCATE_FILE:
1898 RUN_WITH_UMASK(0000)
1899 (void) mkdir_parents_label(i->path, 0755);
1900
1901 r = truncate_file(i, i->path);
1902 if (r < 0)
1903 return r;
1904 break;
1905
1906 case COPY_FILES:
1907 RUN_WITH_UMASK(0000)
1908 (void) mkdir_parents_label(i->path, 0755);
1909
1910 r = copy_files(i);
1911 if (r < 0)
1912 return r;
1913 break;
1914
1915 case WRITE_FILE:
1916 r = glob_item(i, write_one_file);
1917 if (r < 0)
1918 return r;
1919
1920 break;
1921
1922 case CREATE_DIRECTORY:
1923 case TRUNCATE_DIRECTORY:
1924 RUN_WITH_UMASK(0000)
1925 (void) mkdir_parents_label(i->path, 0755);
1926
1927 r = create_directory(i, i->path);
1928 if (r < 0)
1929 return r;
1930 break;
1931
1932 case CREATE_SUBVOLUME:
1933 case CREATE_SUBVOLUME_INHERIT_QUOTA:
1934 case CREATE_SUBVOLUME_NEW_QUOTA:
1935 RUN_WITH_UMASK(0000)
1936 (void) mkdir_parents_label(i->path, 0755);
1937
1938 r = create_subvolume(i, i->path);
1939 if (r < 0)
1940 return r;
1941 break;
1942
1943 case EMPTY_DIRECTORY:
1944 r = glob_item(i, empty_directory);
1945 if (r < 0)
1946 return r;
1947 break;
1948
1949 case CREATE_FIFO:
1950 RUN_WITH_UMASK(0000)
1951 (void) mkdir_parents_label(i->path, 0755);
1952
1953 r = create_fifo(i, i->path);
1954 if (r < 0)
1955 return r;
1956 break;
1957
1958 case CREATE_SYMLINK: {
1959 RUN_WITH_UMASK(0000)
1960 (void) mkdir_parents_label(i->path, 0755);
1961
1962 mac_selinux_create_file_prepare(i->path, S_IFLNK);
1963 r = symlink(i->argument, i->path);
1964 mac_selinux_create_file_clear();
1965
1966 if (r < 0) {
1967 _cleanup_free_ char *x = NULL;
1968
1969 if (errno != EEXIST)
1970 return log_error_errno(errno, "symlink(%s, %s) failed: %m", i->argument, i->path);
1971
1972 r = readlink_malloc(i->path, &x);
1973 if (r < 0 || !streq(i->argument, x)) {
1974
1975 if (i->force) {
1976 mac_selinux_create_file_prepare(i->path, S_IFLNK);
1977 r = symlink_atomic(i->argument, i->path);
1978 mac_selinux_create_file_clear();
1979
1980 if (IN_SET(r, -EISDIR, -EEXIST, -ENOTEMPTY)) {
1981 r = rm_rf(i->path, REMOVE_ROOT|REMOVE_PHYSICAL);
1982 if (r < 0)
1983 return log_error_errno(r, "rm -fr %s failed: %m", i->path);
1984
1985 mac_selinux_create_file_prepare(i->path, S_IFLNK);
1986 r = symlink(i->argument, i->path) < 0 ? -errno : 0;
1987 mac_selinux_create_file_clear();
1988 }
1989 if (r < 0)
1990 return log_error_errno(r, "symlink(%s, %s) failed: %m", i->argument, i->path);
1991
1992 creation = CREATION_FORCE;
1993 } else {
1994 log_debug("\"%s\" is not a symlink or does not point to the correct path.", i->path);
1995 return 0;
1996 }
1997 } else
1998 creation = CREATION_EXISTING;
1999 } else
2000
2001 creation = CREATION_NORMAL;
2002 log_debug("%s symlink \"%s\".", creation_mode_verb_to_string(creation), i->path);
2003 break;
2004 }
2005
2006 case CREATE_BLOCK_DEVICE:
2007 case CREATE_CHAR_DEVICE:
2008 if (have_effective_cap(CAP_MKNOD) == 0) {
2009 /* In a container we lack CAP_MKNOD. We
2010 shouldn't attempt to create the device node in
2011 that case to avoid noise, and we don't support
2012 virtualized devices in containers anyway. */
2013
2014 log_debug("We lack CAP_MKNOD, skipping creation of device node %s.", i->path);
2015 return 0;
2016 }
2017
2018 RUN_WITH_UMASK(0000)
2019 (void) mkdir_parents_label(i->path, 0755);
2020
2021 r = create_device(i, i->type == CREATE_BLOCK_DEVICE ? S_IFBLK : S_IFCHR);
2022 if (r < 0)
2023 return r;
2024
2025 break;
2026
2027 case ADJUST_MODE:
2028 case RELABEL_PATH:
2029 r = glob_item(i, path_set_perms);
2030 if (r < 0)
2031 return r;
2032 break;
2033
2034 case RECURSIVE_RELABEL_PATH:
2035 r = glob_item_recursively(i, fd_set_perms);
2036 if (r < 0)
2037 return r;
2038 break;
2039
2040 case SET_XATTR:
2041 r = glob_item(i, path_set_xattrs);
2042 if (r < 0)
2043 return r;
2044 break;
2045
2046 case RECURSIVE_SET_XATTR:
2047 r = glob_item_recursively(i, fd_set_xattrs);
2048 if (r < 0)
2049 return r;
2050 break;
2051
2052 case SET_ACL:
2053 r = glob_item(i, path_set_acls);
2054 if (r < 0)
2055 return r;
2056 break;
2057
2058 case RECURSIVE_SET_ACL:
2059 r = glob_item_recursively(i, fd_set_acls);
2060 if (r < 0)
2061 return r;
2062 break;
2063
2064 case SET_ATTRIBUTE:
2065 r = glob_item(i, path_set_attribute);
2066 if (r < 0)
2067 return r;
2068 break;
2069
2070 case RECURSIVE_SET_ATTRIBUTE:
2071 r = glob_item_recursively(i, fd_set_attribute);
2072 if (r < 0)
2073 return r;
2074 break;
2075 }
2076
2077 return 0;
2078 }
2079
2080 static int remove_item_instance(Item *i, const char *instance) {
2081 int r;
2082
2083 assert(i);
2084
2085 switch (i->type) {
2086
2087 case REMOVE_PATH:
2088 if (remove(instance) < 0 && errno != ENOENT)
2089 return log_error_errno(errno, "rm(%s): %m", instance);
2090
2091 break;
2092
2093 case TRUNCATE_DIRECTORY:
2094 case RECURSIVE_REMOVE_PATH:
2095 /* FIXME: we probably should use dir_cleanup() here
2096 * instead of rm_rf() so that 'x' is honoured. */
2097 log_debug("rm -rf \"%s\"", instance);
2098 r = rm_rf(instance, (i->type == RECURSIVE_REMOVE_PATH ? REMOVE_ROOT|REMOVE_SUBVOLUME : 0) | REMOVE_PHYSICAL);
2099 if (r < 0 && r != -ENOENT)
2100 return log_error_errno(r, "rm_rf(%s): %m", instance);
2101
2102 break;
2103
2104 default:
2105 assert_not_reached("wut?");
2106 }
2107
2108 return 0;
2109 }
2110
2111 static int remove_item(Item *i) {
2112 assert(i);
2113
2114 log_debug("Running remove action for entry %c %s", (char) i->type, i->path);
2115
2116 switch (i->type) {
2117
2118 case REMOVE_PATH:
2119 case TRUNCATE_DIRECTORY:
2120 case RECURSIVE_REMOVE_PATH:
2121 return glob_item(i, remove_item_instance);
2122
2123 default:
2124 return 0;
2125 }
2126 }
2127
2128 static int clean_item_instance(Item *i, const char* instance) {
2129 _cleanup_closedir_ DIR *d = NULL;
2130 struct stat s, ps;
2131 bool mountpoint;
2132 usec_t cutoff, n;
2133 char timestamp[FORMAT_TIMESTAMP_MAX];
2134
2135 assert(i);
2136
2137 if (!i->age_set)
2138 return 0;
2139
2140 n = now(CLOCK_REALTIME);
2141 if (n < i->age)
2142 return 0;
2143
2144 cutoff = n - i->age;
2145
2146 d = opendir_nomod(instance);
2147 if (!d) {
2148 if (IN_SET(errno, ENOENT, ENOTDIR)) {
2149 log_debug_errno(errno, "Directory \"%s\": %m", instance);
2150 return 0;
2151 }
2152
2153 return log_error_errno(errno, "Failed to open directory %s: %m", instance);
2154 }
2155
2156 if (fstat(dirfd(d), &s) < 0)
2157 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
2158
2159 if (!S_ISDIR(s.st_mode)) {
2160 log_error("%s is not a directory.", i->path);
2161 return -ENOTDIR;
2162 }
2163
2164 if (fstatat(dirfd(d), "..", &ps, AT_SYMLINK_NOFOLLOW) != 0)
2165 return log_error_errno(errno, "stat(%s/..) failed: %m", i->path);
2166
2167 mountpoint = s.st_dev != ps.st_dev || s.st_ino == ps.st_ino;
2168
2169 log_debug("Cleanup threshold for %s \"%s\" is %s",
2170 mountpoint ? "mount point" : "directory",
2171 instance,
2172 format_timestamp_us(timestamp, sizeof(timestamp), cutoff));
2173
2174 return dir_cleanup(i, instance, d, &s, cutoff, s.st_dev, mountpoint,
2175 MAX_DEPTH, i->keep_first_level);
2176 }
2177
2178 static int clean_item(Item *i) {
2179 assert(i);
2180
2181 log_debug("Running clean action for entry %c %s", (char) i->type, i->path);
2182
2183 switch (i->type) {
2184 case CREATE_DIRECTORY:
2185 case CREATE_SUBVOLUME:
2186 case CREATE_SUBVOLUME_INHERIT_QUOTA:
2187 case CREATE_SUBVOLUME_NEW_QUOTA:
2188 case TRUNCATE_DIRECTORY:
2189 case IGNORE_PATH:
2190 case COPY_FILES:
2191 clean_item_instance(i, i->path);
2192 return 0;
2193 case EMPTY_DIRECTORY:
2194 case IGNORE_DIRECTORY_PATH:
2195 return glob_item(i, clean_item_instance);
2196 default:
2197 return 0;
2198 }
2199 }
2200
2201 static int process_item_array(ItemArray *array);
2202
2203 static int process_item(Item *i) {
2204 int r, q, p, t = 0;
2205 _cleanup_free_ char *prefix = NULL;
2206
2207 assert(i);
2208
2209 if (i->done)
2210 return 0;
2211
2212 i->done = true;
2213
2214 prefix = malloc(strlen(i->path) + 1);
2215 if (!prefix)
2216 return log_oom();
2217
2218 PATH_FOREACH_PREFIX(prefix, i->path) {
2219 ItemArray *j;
2220
2221 j = ordered_hashmap_get(items, prefix);
2222 if (j) {
2223 int s;
2224
2225 s = process_item_array(j);
2226 if (s < 0 && t == 0)
2227 t = s;
2228 }
2229 }
2230
2231 if (chase_symlinks(i->path, NULL, CHASE_NO_AUTOFS, NULL) == -EREMOTE)
2232 return t;
2233
2234 r = arg_create ? create_item(i) : 0;
2235 q = arg_remove ? remove_item(i) : 0;
2236 p = arg_clean ? clean_item(i) : 0;
2237
2238 return t < 0 ? t :
2239 r < 0 ? r :
2240 q < 0 ? q :
2241 p;
2242 }
2243
2244 static int process_item_array(ItemArray *array) {
2245 unsigned n;
2246 int r = 0, k;
2247
2248 assert(array);
2249
2250 for (n = 0; n < array->count; n++) {
2251 k = process_item(array->items + n);
2252 if (k < 0 && r == 0)
2253 r = k;
2254 }
2255
2256 return r;
2257 }
2258
2259 static void item_free_contents(Item *i) {
2260 assert(i);
2261 free(i->path);
2262 free(i->argument);
2263 strv_free(i->xattrs);
2264
2265 #if HAVE_ACL
2266 acl_free(i->acl_access);
2267 acl_free(i->acl_default);
2268 #endif
2269 }
2270
2271 static void item_array_free(ItemArray *a) {
2272 unsigned n;
2273
2274 if (!a)
2275 return;
2276
2277 for (n = 0; n < a->count; n++)
2278 item_free_contents(a->items + n);
2279 free(a->items);
2280 free(a);
2281 }
2282
2283 static int item_compare(const void *a, const void *b) {
2284 const Item *x = a, *y = b;
2285
2286 /* Make sure that the ownership taking item is put first, so
2287 * that we first create the node, and then can adjust it */
2288
2289 if (takes_ownership(x->type) && !takes_ownership(y->type))
2290 return -1;
2291 if (!takes_ownership(x->type) && takes_ownership(y->type))
2292 return 1;
2293
2294 return (int) x->type - (int) y->type;
2295 }
2296
2297 static bool item_compatible(Item *a, Item *b) {
2298 assert(a);
2299 assert(b);
2300 assert(streq(a->path, b->path));
2301
2302 if (takes_ownership(a->type) && takes_ownership(b->type))
2303 /* check if the items are the same */
2304 return streq_ptr(a->argument, b->argument) &&
2305
2306 a->uid_set == b->uid_set &&
2307 a->uid == b->uid &&
2308
2309 a->gid_set == b->gid_set &&
2310 a->gid == b->gid &&
2311
2312 a->mode_set == b->mode_set &&
2313 a->mode == b->mode &&
2314
2315 a->age_set == b->age_set &&
2316 a->age == b->age &&
2317
2318 a->mask_perms == b->mask_perms &&
2319
2320 a->keep_first_level == b->keep_first_level &&
2321
2322 a->major_minor == b->major_minor;
2323
2324 return true;
2325 }
2326
2327 static bool should_include_path(const char *path) {
2328 char **prefix;
2329
2330 STRV_FOREACH(prefix, arg_exclude_prefixes)
2331 if (path_startswith(path, *prefix)) {
2332 log_debug("Entry \"%s\" matches exclude prefix \"%s\", skipping.",
2333 path, *prefix);
2334 return false;
2335 }
2336
2337 STRV_FOREACH(prefix, arg_include_prefixes)
2338 if (path_startswith(path, *prefix)) {
2339 log_debug("Entry \"%s\" matches include prefix \"%s\".", path, *prefix);
2340 return true;
2341 }
2342
2343 /* no matches, so we should include this path only if we
2344 * have no whitelist at all */
2345 if (strv_isempty(arg_include_prefixes))
2346 return true;
2347
2348 log_debug("Entry \"%s\" does not match any include prefix, skipping.", path);
2349 return false;
2350 }
2351
2352 static int specifier_expansion_from_arg(Item *i) {
2353 _cleanup_free_ char *unescaped = NULL, *resolved = NULL;
2354 char **xattr;
2355 int r;
2356
2357 assert(i);
2358
2359 if (i->argument == NULL)
2360 return 0;
2361
2362 switch (i->type) {
2363 case COPY_FILES:
2364 case CREATE_SYMLINK:
2365 case CREATE_FILE:
2366 case TRUNCATE_FILE:
2367 case WRITE_FILE:
2368 r = cunescape(i->argument, 0, &unescaped);
2369 if (r < 0)
2370 return log_error_errno(r, "Failed to unescape parameter to write: %s", i->argument);
2371
2372 r = specifier_printf(unescaped, specifier_table, NULL, &resolved);
2373 if (r < 0)
2374 return r;
2375
2376 free_and_replace(i->argument, resolved);
2377 break;
2378
2379 case SET_XATTR:
2380 case RECURSIVE_SET_XATTR:
2381 assert(i->xattrs);
2382
2383 STRV_FOREACH (xattr, i->xattrs) {
2384 r = specifier_printf(*xattr, specifier_table, NULL, &resolved);
2385 if (r < 0)
2386 return r;
2387
2388 free_and_replace(*xattr, resolved);
2389 }
2390 break;
2391
2392 default:
2393 break;
2394 }
2395 return 0;
2396 }
2397
2398 static int patch_var_run(const char *fname, unsigned line, char **path) {
2399 const char *k;
2400 char *n;
2401
2402 assert(path);
2403 assert(*path);
2404
2405 /* Optionally rewrites lines referencing /var/run/, to use /run/ instead. Why bother? tmpfiles merges lines in
2406 * some cases and detects conflicts in others. If files/directories are specified through two equivalent lines
2407 * this is problematic as neither case will be detected. Ideally we'd detect these cases by resolving symlinks
2408 * early, but that's precisely not what we can do here as this code very likely is running very early on, at a
2409 * time where the paths in question are not available yet, or even more importantly, our own tmpfiles rules
2410 * might create the paths that are intermediary to the listed paths. We can't really cover the generic case,
2411 * but the least we can do is cover the specific case of /var/run vs. /run, as /var/run is a legacy name for
2412 * /run only, and we explicitly document that and require that on systemd systems the former is a symlink to
2413 * the latter. Moreover files below this path are by far the primary usecase for tmpfiles.d/. */
2414
2415 k = path_startswith(*path, "/var/run/");
2416 if (isempty(k)) /* Don't complain about other paths than /var/run, and not about /var/run itself either. */
2417 return 0;
2418
2419 n = strjoin("/run/", k);
2420 if (!n)
2421 return log_oom();
2422
2423 /* Also log about this briefly. We do so at LOG_NOTICE level, as we fixed up the situation automatically, hence
2424 * there's no immediate need for action by the user. However, in the interest of making things less confusing
2425 * to the user, let's still inform the user that these snippets should really be updated. */
2426
2427 log_notice("[%s:%u] Line references path below legacy directory /var/run/, updating %s → %s; please update the tmpfiles.d/ drop-in file accordingly.", fname, line, *path, n);
2428
2429 free(*path);
2430 *path = n;
2431
2432 return 0;
2433 }
2434
2435 static int parse_line(const char *fname, unsigned line, const char *buffer, bool *invalid_config) {
2436
2437 _cleanup_free_ char *action = NULL, *mode = NULL, *user = NULL, *group = NULL, *age = NULL, *path = NULL;
2438 _cleanup_(item_free_contents) Item i = {};
2439 ItemArray *existing;
2440 OrderedHashmap *h;
2441 int r, pos;
2442 bool force = false, boot = false;
2443
2444 assert(fname);
2445 assert(line >= 1);
2446 assert(buffer);
2447
2448 r = extract_many_words(
2449 &buffer,
2450 NULL,
2451 EXTRACT_QUOTES,
2452 &action,
2453 &path,
2454 &mode,
2455 &user,
2456 &group,
2457 &age,
2458 NULL);
2459 if (r < 0) {
2460 if (IN_SET(r, -EINVAL, -EBADSLT))
2461 /* invalid quoting and such or an unknown specifier */
2462 *invalid_config = true;
2463 return log_error_errno(r, "[%s:%u] Failed to parse line: %m", fname, line);
2464 } else if (r < 2) {
2465 *invalid_config = true;
2466 log_error("[%s:%u] Syntax error.", fname, line);
2467 return -EIO;
2468 }
2469
2470 if (!isempty(buffer) && !streq(buffer, "-")) {
2471 i.argument = strdup(buffer);
2472 if (!i.argument)
2473 return log_oom();
2474 }
2475
2476 if (isempty(action)) {
2477 *invalid_config = true;
2478 log_error("[%s:%u] Command too short '%s'.", fname, line, action);
2479 return -EINVAL;
2480 }
2481
2482 for (pos = 1; action[pos]; pos++) {
2483 if (action[pos] == '!' && !boot)
2484 boot = true;
2485 else if (action[pos] == '+' && !force)
2486 force = true;
2487 else {
2488 *invalid_config = true;
2489 log_error("[%s:%u] Unknown modifiers in command '%s'",
2490 fname, line, action);
2491 return -EINVAL;
2492 }
2493 }
2494
2495 if (boot && !arg_boot) {
2496 log_debug("Ignoring entry %s \"%s\" because --boot is not specified.",
2497 action, path);
2498 return 0;
2499 }
2500
2501 i.type = action[0];
2502 i.force = force;
2503
2504 r = specifier_printf(path, specifier_table, NULL, &i.path);
2505 if (r == -ENXIO)
2506 return log_unresolvable_specifier(fname, line);
2507 if (r < 0) {
2508 if (IN_SET(r, -EINVAL, -EBADSLT))
2509 *invalid_config = true;
2510 return log_error_errno(r, "[%s:%u] Failed to replace specifiers: %s", fname, line, path);
2511 }
2512
2513 r = patch_var_run(fname, line, &i.path);
2514 if (r < 0)
2515 return r;
2516
2517 switch (i.type) {
2518
2519 case CREATE_DIRECTORY:
2520 case CREATE_SUBVOLUME:
2521 case CREATE_SUBVOLUME_INHERIT_QUOTA:
2522 case CREATE_SUBVOLUME_NEW_QUOTA:
2523 case EMPTY_DIRECTORY:
2524 case TRUNCATE_DIRECTORY:
2525 case CREATE_FIFO:
2526 case IGNORE_PATH:
2527 case IGNORE_DIRECTORY_PATH:
2528 case REMOVE_PATH:
2529 case RECURSIVE_REMOVE_PATH:
2530 case ADJUST_MODE:
2531 case RELABEL_PATH:
2532 case RECURSIVE_RELABEL_PATH:
2533 if (i.argument)
2534 log_warning("[%s:%u] %c lines don't take argument fields, ignoring.", fname, line, i.type);
2535
2536 break;
2537
2538 case CREATE_FILE:
2539 case TRUNCATE_FILE:
2540 break;
2541
2542 case CREATE_SYMLINK:
2543 if (!i.argument) {
2544 i.argument = strappend("/usr/share/factory/", i.path);
2545 if (!i.argument)
2546 return log_oom();
2547 }
2548 break;
2549
2550 case WRITE_FILE:
2551 if (!i.argument) {
2552 *invalid_config = true;
2553 log_error("[%s:%u] Write file requires argument.", fname, line);
2554 return -EBADMSG;
2555 }
2556 break;
2557
2558 case COPY_FILES:
2559 if (!i.argument) {
2560 i.argument = strappend("/usr/share/factory/", i.path);
2561 if (!i.argument)
2562 return log_oom();
2563 } else if (!path_is_absolute(i.argument)) {
2564 *invalid_config = true;
2565 log_error("[%s:%u] Source path is not absolute.", fname, line);
2566 return -EBADMSG;
2567 }
2568
2569 path_simplify(i.argument, false);
2570 break;
2571
2572 case CREATE_CHAR_DEVICE:
2573 case CREATE_BLOCK_DEVICE: {
2574 unsigned major, minor;
2575
2576 if (!i.argument) {
2577 *invalid_config = true;
2578 log_error("[%s:%u] Device file requires argument.", fname, line);
2579 return -EBADMSG;
2580 }
2581
2582 if (sscanf(i.argument, "%u:%u", &major, &minor) != 2) {
2583 *invalid_config = true;
2584 log_error("[%s:%u] Can't parse device file major/minor '%s'.", fname, line, i.argument);
2585 return -EBADMSG;
2586 }
2587
2588 i.major_minor = makedev(major, minor);
2589 break;
2590 }
2591
2592 case SET_XATTR:
2593 case RECURSIVE_SET_XATTR:
2594 if (!i.argument) {
2595 *invalid_config = true;
2596 log_error("[%s:%u] Set extended attribute requires argument.", fname, line);
2597 return -EBADMSG;
2598 }
2599 r = parse_xattrs_from_arg(&i);
2600 if (r < 0)
2601 return r;
2602 break;
2603
2604 case SET_ACL:
2605 case RECURSIVE_SET_ACL:
2606 if (!i.argument) {
2607 *invalid_config = true;
2608 log_error("[%s:%u] Set ACLs requires argument.", fname, line);
2609 return -EBADMSG;
2610 }
2611 r = parse_acls_from_arg(&i);
2612 if (r < 0)
2613 return r;
2614 break;
2615
2616 case SET_ATTRIBUTE:
2617 case RECURSIVE_SET_ATTRIBUTE:
2618 if (!i.argument) {
2619 *invalid_config = true;
2620 log_error("[%s:%u] Set file attribute requires argument.", fname, line);
2621 return -EBADMSG;
2622 }
2623 r = parse_attribute_from_arg(&i);
2624 if (IN_SET(r, -EINVAL, -EBADSLT))
2625 *invalid_config = true;
2626 if (r < 0)
2627 return r;
2628 break;
2629
2630 default:
2631 log_error("[%s:%u] Unknown command type '%c'.", fname, line, (char) i.type);
2632 *invalid_config = true;
2633 return -EBADMSG;
2634 }
2635
2636 if (!path_is_absolute(i.path)) {
2637 log_error("[%s:%u] Path '%s' not absolute.", fname, line, i.path);
2638 *invalid_config = true;
2639 return -EBADMSG;
2640 }
2641
2642 path_simplify(i.path, false);
2643
2644 if (!should_include_path(i.path))
2645 return 0;
2646
2647 r = specifier_expansion_from_arg(&i);
2648 if (r == -ENXIO)
2649 return log_unresolvable_specifier(fname, line);
2650 if (r < 0) {
2651 if (IN_SET(r, -EINVAL, -EBADSLT))
2652 *invalid_config = true;
2653 return log_error_errno(r, "[%s:%u] Failed to substitute specifiers in argument: %m",
2654 fname, line);
2655 }
2656
2657 if (arg_root) {
2658 char *p;
2659
2660 p = prefix_root(arg_root, i.path);
2661 if (!p)
2662 return log_oom();
2663
2664 free(i.path);
2665 i.path = p;
2666 }
2667
2668 if (!isempty(user) && !streq(user, "-")) {
2669 const char *u = user;
2670
2671 r = get_user_creds(&u, &i.uid, NULL, NULL, NULL);
2672 if (r < 0) {
2673 *invalid_config = true;
2674 return log_error_errno(r, "[%s:%u] Unknown user '%s'.", fname, line, user);
2675 }
2676
2677 i.uid_set = true;
2678 }
2679
2680 if (!isempty(group) && !streq(group, "-")) {
2681 const char *g = group;
2682
2683 r = get_group_creds(&g, &i.gid);
2684 if (r < 0) {
2685 *invalid_config = true;
2686 log_error("[%s:%u] Unknown group '%s'.", fname, line, group);
2687 return r;
2688 }
2689
2690 i.gid_set = true;
2691 }
2692
2693 if (!isempty(mode) && !streq(mode, "-")) {
2694 const char *mm = mode;
2695 unsigned m;
2696
2697 if (*mm == '~') {
2698 i.mask_perms = true;
2699 mm++;
2700 }
2701
2702 if (parse_mode(mm, &m) < 0) {
2703 *invalid_config = true;
2704 log_error("[%s:%u] Invalid mode '%s'.", fname, line, mode);
2705 return -EBADMSG;
2706 }
2707
2708 i.mode = m;
2709 i.mode_set = true;
2710 } else
2711 i.mode = IN_SET(i.type, CREATE_DIRECTORY, TRUNCATE_DIRECTORY, CREATE_SUBVOLUME, CREATE_SUBVOLUME_INHERIT_QUOTA, CREATE_SUBVOLUME_NEW_QUOTA) ? 0755 : 0644;
2712
2713 if (!isempty(age) && !streq(age, "-")) {
2714 const char *a = age;
2715
2716 if (*a == '~') {
2717 i.keep_first_level = true;
2718 a++;
2719 }
2720
2721 if (parse_sec(a, &i.age) < 0) {
2722 *invalid_config = true;
2723 log_error("[%s:%u] Invalid age '%s'.", fname, line, age);
2724 return -EBADMSG;
2725 }
2726
2727 i.age_set = true;
2728 }
2729
2730 h = needs_glob(i.type) ? globs : items;
2731
2732 existing = ordered_hashmap_get(h, i.path);
2733 if (existing) {
2734 unsigned n;
2735
2736 for (n = 0; n < existing->count; n++) {
2737 if (!item_compatible(existing->items + n, &i)) {
2738 log_notice("[%s:%u] Duplicate line for path \"%s\", ignoring.",
2739 fname, line, i.path);
2740 return 0;
2741 }
2742 }
2743 } else {
2744 existing = new0(ItemArray, 1);
2745 if (!existing)
2746 return log_oom();
2747
2748 r = ordered_hashmap_put(h, i.path, existing);
2749 if (r < 0)
2750 return log_oom();
2751 }
2752
2753 if (!GREEDY_REALLOC(existing->items, existing->size, existing->count + 1))
2754 return log_oom();
2755
2756 memcpy(existing->items + existing->count++, &i, sizeof(i));
2757
2758 /* Sort item array, to enforce stable ordering of application */
2759 qsort_safe(existing->items, existing->count, sizeof(Item), item_compare);
2760
2761 zero(i);
2762 return 0;
2763 }
2764
2765 static int cat_config(char **config_dirs, char **args) {
2766 _cleanup_strv_free_ char **files = NULL;
2767 int r;
2768
2769 r = conf_files_list_with_replacement(arg_root, config_dirs, arg_replace, &files, NULL);
2770 if (r < 0)
2771 return r;
2772
2773 return cat_files(NULL, files, 0);
2774 }
2775
2776 static void help(void) {
2777 printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
2778 "Creates, deletes and cleans up volatile and temporary files and directories.\n\n"
2779 " -h --help Show this help\n"
2780 " --user Execute user configuration\n"
2781 " --version Show package version\n"
2782 " --cat-config Show configuration files\n"
2783 " --create Create marked files/directories\n"
2784 " --clean Clean up marked directories\n"
2785 " --remove Remove marked files/directories\n"
2786 " --boot Execute actions only safe at boot\n"
2787 " --prefix=PATH Only apply rules with the specified prefix\n"
2788 " --exclude-prefix=PATH Ignore rules with the specified prefix\n"
2789 " --root=PATH Operate on an alternate filesystem root\n"
2790 " --replace=PATH Treat arguments as replacement for PATH\n"
2791 " --no-pager Do not pipe output into a pager\n"
2792 , program_invocation_short_name);
2793 }
2794
2795 static int parse_argv(int argc, char *argv[]) {
2796
2797 enum {
2798 ARG_VERSION = 0x100,
2799 ARG_CAT_CONFIG,
2800 ARG_USER,
2801 ARG_CREATE,
2802 ARG_CLEAN,
2803 ARG_REMOVE,
2804 ARG_BOOT,
2805 ARG_PREFIX,
2806 ARG_EXCLUDE_PREFIX,
2807 ARG_ROOT,
2808 ARG_REPLACE,
2809 ARG_NO_PAGER,
2810 };
2811
2812 static const struct option options[] = {
2813 { "help", no_argument, NULL, 'h' },
2814 { "user", no_argument, NULL, ARG_USER },
2815 { "version", no_argument, NULL, ARG_VERSION },
2816 { "cat-config", no_argument, NULL, ARG_CAT_CONFIG },
2817 { "create", no_argument, NULL, ARG_CREATE },
2818 { "clean", no_argument, NULL, ARG_CLEAN },
2819 { "remove", no_argument, NULL, ARG_REMOVE },
2820 { "boot", no_argument, NULL, ARG_BOOT },
2821 { "prefix", required_argument, NULL, ARG_PREFIX },
2822 { "exclude-prefix", required_argument, NULL, ARG_EXCLUDE_PREFIX },
2823 { "root", required_argument, NULL, ARG_ROOT },
2824 { "replace", required_argument, NULL, ARG_REPLACE },
2825 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
2826 {}
2827 };
2828
2829 int c, r;
2830
2831 assert(argc >= 0);
2832 assert(argv);
2833
2834 while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
2835
2836 switch (c) {
2837
2838 case 'h':
2839 help();
2840 return 0;
2841
2842 case ARG_VERSION:
2843 return version();
2844
2845 case ARG_CAT_CONFIG:
2846 arg_cat_config = true;
2847 break;
2848
2849 case ARG_USER:
2850 arg_user = true;
2851 break;
2852
2853 case ARG_CREATE:
2854 arg_create = true;
2855 break;
2856
2857 case ARG_CLEAN:
2858 arg_clean = true;
2859 break;
2860
2861 case ARG_REMOVE:
2862 arg_remove = true;
2863 break;
2864
2865 case ARG_BOOT:
2866 arg_boot = true;
2867 break;
2868
2869 case ARG_PREFIX:
2870 if (strv_push(&arg_include_prefixes, optarg) < 0)
2871 return log_oom();
2872 break;
2873
2874 case ARG_EXCLUDE_PREFIX:
2875 if (strv_push(&arg_exclude_prefixes, optarg) < 0)
2876 return log_oom();
2877 break;
2878
2879 case ARG_ROOT:
2880 r = parse_path_argument_and_warn(optarg, true, &arg_root);
2881 if (r < 0)
2882 return r;
2883 break;
2884
2885 case ARG_REPLACE:
2886 if (!path_is_absolute(optarg) ||
2887 !endswith(optarg, ".conf")) {
2888 log_error("The argument to --replace= must an absolute path to a config file");
2889 return -EINVAL;
2890 }
2891
2892 arg_replace = optarg;
2893 break;
2894
2895 case ARG_NO_PAGER:
2896 arg_no_pager = true;
2897 break;
2898
2899 case '?':
2900 return -EINVAL;
2901
2902 default:
2903 assert_not_reached("Unhandled option");
2904 }
2905
2906 if (!arg_clean && !arg_create && !arg_remove && !arg_cat_config) {
2907 log_error("You need to specify at least one of --clean, --create or --remove.");
2908 return -EINVAL;
2909 }
2910
2911 if (arg_replace && arg_cat_config) {
2912 log_error("Option --replace= is not supported with --cat-config");
2913 return -EINVAL;
2914 }
2915
2916 if (arg_replace && optind >= argc) {
2917 log_error("When --replace= is given, some configuration items must be specified");
2918 return -EINVAL;
2919 }
2920
2921 return 1;
2922 }
2923
2924 static int read_config_file(char **config_dirs, const char *fn, bool ignore_enoent, bool *invalid_config) {
2925 _cleanup_fclose_ FILE *_f = NULL;
2926 FILE *f;
2927 char line[LINE_MAX];
2928 Iterator iterator;
2929 unsigned v = 0;
2930 Item *i;
2931 int r = 0;
2932
2933 assert(fn);
2934
2935 if (streq(fn, "-")) {
2936 log_debug("Reading config from stdin…");
2937 fn = "<stdin>";
2938 f = stdin;
2939 } else {
2940 r = search_and_fopen(fn, "re", arg_root, (const char**) config_dirs, &_f);
2941 if (r < 0) {
2942 if (ignore_enoent && r == -ENOENT) {
2943 log_debug_errno(r, "Failed to open \"%s\", ignoring: %m", fn);
2944 return 0;
2945 }
2946
2947 return log_error_errno(r, "Failed to open '%s': %m", fn);
2948 }
2949 log_debug("Reading config file \"%s\"…", fn);
2950 f = _f;
2951 }
2952
2953 FOREACH_LINE(line, f, break) {
2954 char *l;
2955 int k;
2956 bool invalid_line = false;
2957
2958 v++;
2959
2960 l = strstrip(line);
2961 if (IN_SET(*l, 0, '#'))
2962 continue;
2963
2964 k = parse_line(fn, v, l, &invalid_line);
2965 if (k < 0) {
2966 if (invalid_line)
2967 /* Allow reporting with a special code if the caller requested this */
2968 *invalid_config = true;
2969 else if (r == 0)
2970 /* The first error becomes our return value */
2971 r = k;
2972 }
2973 }
2974
2975 /* we have to determine age parameter for each entry of type X */
2976 ORDERED_HASHMAP_FOREACH(i, globs, iterator) {
2977 Iterator iter;
2978 Item *j, *candidate_item = NULL;
2979
2980 if (i->type != IGNORE_DIRECTORY_PATH)
2981 continue;
2982
2983 ORDERED_HASHMAP_FOREACH(j, items, iter) {
2984 if (!IN_SET(j->type, CREATE_DIRECTORY, TRUNCATE_DIRECTORY, CREATE_SUBVOLUME, CREATE_SUBVOLUME_INHERIT_QUOTA, CREATE_SUBVOLUME_NEW_QUOTA))
2985 continue;
2986
2987 if (path_equal(j->path, i->path)) {
2988 candidate_item = j;
2989 break;
2990 }
2991
2992 if ((!candidate_item && path_startswith(i->path, j->path)) ||
2993 (candidate_item && path_startswith(j->path, candidate_item->path) && (fnmatch(i->path, j->path, FNM_PATHNAME | FNM_PERIOD) == 0)))
2994 candidate_item = j;
2995 }
2996
2997 if (candidate_item && candidate_item->age_set) {
2998 i->age = candidate_item->age;
2999 i->age_set = true;
3000 }
3001 }
3002
3003 if (ferror(f)) {
3004 log_error_errno(errno, "Failed to read from file %s: %m", fn);
3005 if (r == 0)
3006 r = -EIO;
3007 }
3008
3009 return r;
3010 }
3011
3012 static int parse_arguments(char **config_dirs, char **args, bool *invalid_config) {
3013 char **arg;
3014 int r;
3015
3016 STRV_FOREACH(arg, args) {
3017 r = read_config_file(config_dirs, *arg, false, invalid_config);
3018 if (r < 0)
3019 return r;
3020 }
3021
3022 return 0;
3023 }
3024
3025 static int read_config_files(char **config_dirs, char **args, bool *invalid_config) {
3026 _cleanup_strv_free_ char **files = NULL;
3027 _cleanup_free_ char *p = NULL;
3028 char **f;
3029 int r;
3030
3031 r = conf_files_list_with_replacement(arg_root, config_dirs, arg_replace, &files, &p);
3032 if (r < 0)
3033 return r;
3034
3035 STRV_FOREACH(f, files)
3036 if (p && path_equal(*f, p)) {
3037 log_debug("Parsing arguments at position \"%s\"…", *f);
3038
3039 r = parse_arguments(config_dirs, args, invalid_config);
3040 if (r < 0)
3041 return r;
3042 } else
3043 /* Just warn, ignore result otherwise.
3044 * read_config_file() has some debug output, so no need to print anything. */
3045 (void) read_config_file(config_dirs, *f, true, invalid_config);
3046
3047 return 0;
3048 }
3049
3050 int main(int argc, char *argv[]) {
3051 int r, k, r_process = 0;
3052 ItemArray *a;
3053 Iterator iterator;
3054 _cleanup_strv_free_ char **config_dirs = NULL;
3055 bool invalid_config = false;
3056
3057 r = parse_argv(argc, argv);
3058 if (r <= 0)
3059 goto finish;
3060
3061 log_set_target(LOG_TARGET_AUTO);
3062 log_parse_environment();
3063 log_open();
3064
3065 if (arg_user) {
3066 r = user_config_paths(&config_dirs);
3067 if (r < 0) {
3068 log_error_errno(r, "Failed to initialize configuration directory list: %m");
3069 goto finish;
3070 }
3071 } else {
3072 config_dirs = strv_split_nulstr(CONF_PATHS_NULSTR("tmpfiles.d"));
3073 if (!config_dirs) {
3074 r = log_oom();
3075 goto finish;
3076 }
3077 }
3078
3079 if (DEBUG_LOGGING) {
3080 _cleanup_free_ char *t = NULL;
3081
3082 t = strv_join(config_dirs, "\n\t");
3083 if (t)
3084 log_debug("Looking for configuration files in (higher priority first):\n\t%s", t);
3085 }
3086
3087 if (arg_cat_config) {
3088 (void) pager_open(arg_no_pager, false);
3089
3090 r = cat_config(config_dirs, argv + optind);
3091 goto finish;
3092 }
3093
3094 umask(0022);
3095
3096 mac_selinux_init();
3097
3098 items = ordered_hashmap_new(&string_hash_ops);
3099 globs = ordered_hashmap_new(&string_hash_ops);
3100
3101 if (!items || !globs) {
3102 r = log_oom();
3103 goto finish;
3104 }
3105
3106 /* If command line arguments are specified along with --replace, read all
3107 * configuration files and insert the positional arguments at the specified
3108 * place. Otherwise, if command line arguments are specified, execute just
3109 * them, and finally, without --replace= or any positional arguments, just
3110 * read configuration and execute it.
3111 */
3112 if (arg_replace || optind >= argc)
3113 r = read_config_files(config_dirs, argv + optind, &invalid_config);
3114 else
3115 r = parse_arguments(config_dirs, argv + optind, &invalid_config);
3116 if (r < 0)
3117 goto finish;
3118
3119 /* The non-globbing ones usually create things, hence we apply
3120 * them first */
3121 ORDERED_HASHMAP_FOREACH(a, items, iterator) {
3122 k = process_item_array(a);
3123 if (k < 0 && r_process == 0)
3124 r_process = k;
3125 }
3126
3127 /* The globbing ones usually alter things, hence we apply them
3128 * second. */
3129 ORDERED_HASHMAP_FOREACH(a, globs, iterator) {
3130 k = process_item_array(a);
3131 if (k < 0 && r_process == 0)
3132 r_process = k;
3133 }
3134
3135 finish:
3136 pager_close();
3137
3138 ordered_hashmap_free_with_destructor(items, item_array_free);
3139 ordered_hashmap_free_with_destructor(globs, item_array_free);
3140
3141 free(arg_include_prefixes);
3142 free(arg_exclude_prefixes);
3143 free(arg_root);
3144
3145 set_free_free(unix_sockets);
3146
3147 mac_selinux_finish();
3148
3149 if (r < 0 || ERRNO_IS_RESOURCE(-r_process))
3150 return EXIT_FAILURE;
3151 else if (invalid_config)
3152 return EX_DATAERR;
3153 else if (r_process < 0)
3154 return EX_CANTCREAT;
3155 else
3156 return EXIT_SUCCESS;
3157 }
Unnamed repository; edit this file 'description' to name the repository.