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