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


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