]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/tmpfiles/tmpfiles.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tmpfiles: fix compilation without acl support
[thirdparty/systemd.git] / src / tmpfiles / tmpfiles.c
CommitLineData
5008d581
LP		 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
3b63d2d3 6 Copyright 2010 Lennart Poettering, Kay Sievers
3f93da98 7 Copyright 2015 Zbigniew Jędrzejewski-Szmek
5008d581
LP		 8
9 systemd is free software; you can redistribute it and/or modify it
5430f7f2
LP		 10 under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
5008d581
LP		 12 (at your option) any later version.
13
14 systemd is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
5430f7f2 17 Lesser General Public License for more details.
5008d581 18
5430f7f2 19 You should have received a copy of the GNU Lesser General Public License
5008d581
LP		 20 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21***/
22
23#include <unistd.h>
24#include <fcntl.h>
25#include <errno.h>
26#include <string.h>
5008d581
LP		 27#include <limits.h>
28#include <dirent.h>
29#include <grp.h>
30#include <pwd.h>
3b63d2d3
LP		 31#include <stdio.h>
32#include <stdlib.h>
33#include <stddef.h>
34#include <getopt.h>
35#include <stdbool.h>
36#include <time.h>
b8bb3e8f
LP		 37#include <glob.h>
38#include <fnmatch.h>
505ef0e3
ZJS		 39#include <sys/stat.h>
40#include <sys/types.h>
41#include <sys/param.h>
ebf4e801 42#include <sys/xattr.h>
5008d581
LP		 43
44#include "log.h"
45#include "util.h"
54693d9b 46#include "macro.h"
d39efe74 47#include "missing.h"
49e942b2 48#include "mkdir.h"
9eb977db 49#include "path-util.h"
5008d581
LP		 50#include "strv.h"
51#include "label.h"
3b63d2d3 52#include "set.h"
2c21044f 53#include "conf-files.h"
cb7ed9df 54#include "capability.h"
1731e34a 55#include "specifier.h"
eb9da376 56#include "build.h"
849958d1 57#include "copy.h"
d7b8eec7
LP		 58#include "selinux-util.h"
59#include "btrfs-util.h"
f8eeeaf9 60#include "acl-util.h"
5008d581 61
01000479 62/* This reads all files listed in /etc/tmpfiles.d/?*.conf and creates
5008d581 63 * them in the file system. This is intended to be used to create
db019b8d
KS		 64 * properly owned directories beneath /tmp, /var/tmp, /run, which are
65 * volatile and hence need to be recreated on bootup. */
5008d581 66
66ccd038 67typedef enum ItemType {
b8bb3e8f 68 /* These ones take file names */
3b63d2d3
LP		 69 CREATE_FILE = 'f',
70 TRUNCATE_FILE = 'F',
71 CREATE_DIRECTORY = 'd',
72 TRUNCATE_DIRECTORY = 'D',
d7b8eec7 73 CREATE_SUBVOLUME = 'v',
ee17ee7c 74 CREATE_FIFO = 'p',
468d726b
LP		 75 CREATE_SYMLINK = 'L',
76 CREATE_CHAR_DEVICE = 'c',
77 CREATE_BLOCK_DEVICE = 'b',
849958d1 78 COPY_FILES = 'C',
b8bb3e8f
LP		 79
80 /* These ones take globs */
b705ab6a
ZJS		 81 SET_XATTR = 't',
82 RECURSIVE_SET_XATTR = 'T',
83 SET_ACL = 'a',
84 RECURSIVE_SET_ACL = 'A',
cde684a2 85 WRITE_FILE = 'w',
3b63d2d3 86 IGNORE_PATH = 'x',
78a92a5a 87 IGNORE_DIRECTORY_PATH = 'X',
3b63d2d3 88 REMOVE_PATH = 'r',
a8d88783 89 RECURSIVE_REMOVE_PATH = 'R',
e73a03e0 90 ADJUST_MODE = 'm', /* legacy, 'z' is identical to this */
777b87e7 91 RELABEL_PATH = 'z',
e73a03e0 92 RECURSIVE_RELABEL_PATH = 'Z',
66ccd038 93} ItemType;
3b63d2d3
LP		 94
95typedef struct Item {
66ccd038 96 ItemType type;
3b63d2d3
LP		 97
98 char *path;
468d726b 99 char *argument;
ebf4e801 100 char **xattrs;
f8eeeaf9
ZJS		 101#ifdef HAVE_ACL
102 acl_t acl_access;
103 acl_t acl_default;
104#endif
5008d581
LP		 105 uid_t uid;
106 gid_t gid;
3b63d2d3
LP		 107 mode_t mode;
108 usec_t age;
109
468d726b
LP		 110 dev_t major_minor;
111
3b63d2d3
LP		 112 bool uid_set:1;
113 bool gid_set:1;
114 bool mode_set:1;
115 bool age_set:1;
abef3f91 116 bool mask_perms:1;
24f3a374
LP		 117
118 bool keep_first_level:1;
1910cd0e 119
2e78fa79
LP		 120 bool force:1;
121
1910cd0e 122 bool done:1;
3b63d2d3
LP		 123} Item;
124
3f93da98
ZJS		 125typedef struct ItemArray {
126 Item *items;
127 size_t count;
128 size_t size;
129} ItemArray;
130
3b63d2d3
LP		 131static bool arg_create = false;
132static bool arg_clean = false;
133static bool arg_remove = false;
81815651 134static bool arg_boot = false;
3b63d2d3 135
7bc040fa
LP		 136static char **arg_include_prefixes = NULL;
137static char **arg_exclude_prefixes = NULL;
cf9a4abd 138static char *arg_root = NULL;
fba6e687 139
7f0a55d4 140static const char conf_file_dirs[] = CONF_DIRS_NULSTR("tmpfiles");
9125670f 141
3b63d2d3
LP		 142#define MAX_DEPTH 256
143
7bc040fa
LP		 144static Hashmap *items = NULL, *globs = NULL;
145static Set *unix_sockets = NULL;
146
66ccd038 147static bool needs_glob(ItemType t) {
cde684a2
LP		 148 return IN_SET(t,
149 WRITE_FILE,
150 IGNORE_PATH,
151 IGNORE_DIRECTORY_PATH,
152 REMOVE_PATH,
153 RECURSIVE_REMOVE_PATH,
e73a03e0 154 ADJUST_MODE,
cde684a2 155 RELABEL_PATH,
b705ab6a
ZJS		 156 RECURSIVE_RELABEL_PATH,
157 SET_XATTR,
158 RECURSIVE_SET_XATTR,
159 SET_ACL,
160 RECURSIVE_SET_ACL);
b8bb3e8f
LP		 161}
162
3f93da98
ZJS		 163static bool takes_ownership(ItemType t) {
164 return IN_SET(t,
165 CREATE_FILE,
166 TRUNCATE_FILE,
167 CREATE_DIRECTORY,
168 TRUNCATE_DIRECTORY,
169 CREATE_SUBVOLUME,
170 CREATE_FIFO,
171 CREATE_SYMLINK,
172 CREATE_CHAR_DEVICE,
173 CREATE_BLOCK_DEVICE,
174 COPY_FILES,
175
176 WRITE_FILE,
177 IGNORE_PATH,
178 IGNORE_DIRECTORY_PATH,
179 REMOVE_PATH,
180 RECURSIVE_REMOVE_PATH);
181}
182
b8bb3e8f 183static struct Item* find_glob(Hashmap *h, const char *match) {
3f93da98 184 ItemArray *j;
b8bb3e8f
LP		 185 Iterator i;
186
3f93da98
ZJS		 187 HASHMAP_FOREACH(j, h, i) {
188 unsigned n;
189
190 for (n = 0; n < j->count; n++) {
191 Item *item = j->items + n;
192
193 if (fnmatch(item->path, match, FNM_PATHNAME|FNM_PERIOD) == 0)
194 return item;
195 }
196 }
b8bb3e8f
LP		 197
198 return NULL;
199}
200
17b90525 201static void load_unix_sockets(void) {
7fd1b19b 202 _cleanup_fclose_ FILE *f = NULL;
17b90525
LP		 203 char line[LINE_MAX];
204
205 if (unix_sockets)
206 return;
207
208 /* We maintain a cache of the sockets we found in
209 * /proc/net/unix to speed things up a little. */
210
d5099efc 211 unix_sockets = set_new(&string_hash_ops);
fdcad0c2 212 if (!unix_sockets)
17b90525
LP		 213 return;
214
fdcad0c2
LP		 215 f = fopen("/proc/net/unix", "re");
216 if (!f)
17b90525
LP		 217 return;
218
fdcad0c2
LP		 219 /* Skip header */
220 if (!fgets(line, sizeof(line), f))
17b90525
LP		 221 goto fail;
222
223 for (;;) {
224 char *p, *s;
225 int k;
226
fdcad0c2 227 if (!fgets(line, sizeof(line), f))
17b90525
LP		 228 break;
229
230 truncate_nl(line);
231
fdcad0c2
LP		 232 p = strchr(line, ':');
233 if (!p)
234 continue;
235
236 if (strlen(p) < 37)
17b90525
LP		 237 continue;
238
fdcad0c2 239 p += 37;
17b90525 240 p += strspn(p, WHITESPACE);
fdcad0c2 241 p += strcspn(p, WHITESPACE); /* skip one more word */
17b90525
LP		 242 p += strspn(p, WHITESPACE);
243
244 if (*p != '/')
245 continue;
246
fdcad0c2
LP		 247 s = strdup(p);
248 if (!s)
17b90525
LP		 249 goto fail;
250
4ff21d85
LP		 251 path_kill_slashes(s);
252
ef42202a
ZJS		 253 k = set_consume(unix_sockets, s);
254 if (k < 0 && k != -EEXIST)
255 goto fail;
17b90525
LP		 256 }
257
258 return;
259
260fail:
261 set_free_free(unix_sockets);
262 unix_sockets = NULL;
17b90525
LP		 263}
264
265static bool unix_socket_alive(const char *fn) {
266 assert(fn);
267
268 load_unix_sockets();
269
270 if (unix_sockets)
271 return !!set_get(unix_sockets, (char*) fn);
272
273 /* We don't know, so assume yes */
274 return true;
275}
276
99d680ac 277static int dir_is_mount_point(DIR *d, const char *subdir) {
cde684a2 278
2695c5c4 279 union file_handle_union h = FILE_HANDLE_INIT;
99d680ac
KS		 280 int mount_id_parent, mount_id;
281 int r_p, r;
282
370c860f 283 r_p = name_to_handle_at(dirfd(d), ".", &h.handle, &mount_id_parent, 0);
99d680ac
KS		 284 if (r_p < 0)
285 r_p = -errno;
286
370c860f
DR		 287 h.handle.handle_bytes = MAX_HANDLE_SZ;
288 r = name_to_handle_at(dirfd(d), subdir, &h.handle, &mount_id, 0);
99d680ac
KS		 289 if (r < 0)
290 r = -errno;
291
292 /* got no handle; make no assumptions, return error */
293 if (r_p < 0 && r < 0)
294 return r_p;
295
296 /* got both handles; if they differ, it is a mount point */
297 if (r_p >= 0 && r >= 0)
298 return mount_id_parent != mount_id;
299
300 /* got only one handle; assume different mount points if one
301 * of both queries was not supported by the filesystem */
e7aab541 302 if (r_p == -ENOSYS || r_p == -EOPNOTSUPP || r == -ENOSYS || r == -EOPNOTSUPP)
99d680ac
KS		 303 return true;
304
305 /* return error */
306 if (r_p < 0)
307 return r_p;
308 return r;
309}
310
df99a9ef
ZJS		 311static DIR* xopendirat_nomod(int dirfd, const char *path) {
312 DIR *dir;
313
314 dir = xopendirat(dirfd, path, O_NOFOLLOW|O_NOATIME);
315 if (!dir) {
316 log_debug_errno(errno, "Cannot open %sdirectory \"%s\": %m",
317 dirfd == AT_FDCWD ? "" : "sub", path);
318 if (errno == EPERM) {
319 dir = xopendirat(dirfd, path, O_NOFOLLOW);
320 if (!dir)
321 log_debug_errno(errno, "Cannot open %sdirectory \"%s\": %m",
322 dirfd == AT_FDCWD ? "" : "sub", path);
323 }
324 }
325
326 return dir;
327}
328
329static DIR* opendir_nomod(const char *path) {
330 return xopendirat_nomod(AT_FDCWD, path);
331}
332
3b63d2d3 333static int dir_cleanup(
78a92a5a 334 Item *i,
3b63d2d3
LP		 335 const char *p,
336 DIR *d,
337 const struct stat *ds,
338 usec_t cutoff,
339 dev_t rootdev,
340 bool mountpoint,
24f3a374 341 int maxdepth,
265ffa1e
LP		 342 bool keep_this_level) {
343
3b63d2d3
LP		 344 struct dirent *dent;
345 struct timespec times[2];
346 bool deleted = false;
3b63d2d3
LP		 347 int r = 0;
348
349 while ((dent = readdir(d))) {
350 struct stat s;
351 usec_t age;
7fd1b19b 352 _cleanup_free_ char *sub_path = NULL;
3b63d2d3 353
7fcb4b9b 354 if (STR_IN_SET(dent->d_name, ".", ".."))
3b63d2d3 355 continue;
5008d581 356
3b63d2d3 357 if (fstatat(dirfd(d), dent->d_name, &s, AT_SYMLINK_NOFOLLOW) < 0) {
ca2f4176
KS		 358 if (errno == ENOENT)
359 continue;
5008d581 360
ca2f4176
KS		 361 /* FUSE, NFS mounts, SELinux might return EACCES */
362 if (errno == EACCES)
56f64d95 363 log_debug_errno(errno, "stat(%s/%s) failed: %m", p, dent->d_name);
ca2f4176 364 else
56f64d95 365 log_error_errno(errno, "stat(%s/%s) failed: %m", p, dent->d_name);
ca2f4176 366 r = -errno;
3b63d2d3
LP		 367 continue;
368 }
369
370 /* Stay on the same filesystem */
582deb84
ZJS		 371 if (s.st_dev != rootdev) {
372 log_debug("Ignoring \"%s/%s\": different filesystem.", p, dent->d_name);
3b63d2d3 373 continue;
582deb84 374 }
3b63d2d3 375
99d680ac
KS		 376 /* Try to detect bind mounts of the same filesystem instance; they
377 * do not differ in device major/minors. This type of query is not
378 * supported on all kernels or filesystem types though. */
582deb84
ZJS		 379 if (S_ISDIR(s.st_mode) && dir_is_mount_point(d, dent->d_name) > 0) {
380 log_debug("Ignoring \"%s/%s\": different mount of the same filesystem.",
381 p, dent->d_name);
99d680ac 382 continue;
582deb84 383 }
99d680ac 384
3b63d2d3 385 /* Do not delete read-only files owned by root */
582deb84
ZJS		 386 if (s.st_uid == 0 && !(s.st_mode & S_IWUSR)) {
387 log_debug("Ignoring \"%s/%s\": read-only and owner by root.", p, dent->d_name);
3b63d2d3 388 continue;
582deb84 389 }
3b63d2d3 390
cde684a2
LP		 391 sub_path = strjoin(p, "/", dent->d_name, NULL);
392 if (!sub_path) {
0d0f0c50 393 r = log_oom();
3b63d2d3
LP		 394 goto finish;
395 }
396
397 /* Is there an item configured for this path? */
582deb84
ZJS		 398 if (hashmap_get(items, sub_path)) {
399 log_debug("Ignoring \"%s\": a separate entry exists.", sub_path);
3b63d2d3 400 continue;
582deb84 401 }
3b63d2d3 402
582deb84
ZJS		 403 if (find_glob(globs, sub_path)) {
404 log_debug("Ignoring \"%s\": a separate glob exists.", sub_path);
b8bb3e8f 405 continue;
582deb84 406 }
b8bb3e8f 407
3b63d2d3
LP		 408 if (S_ISDIR(s.st_mode)) {
409
410 if (mountpoint &&
411 streq(dent->d_name, "lost+found") &&
582deb84
ZJS		 412 s.st_uid == 0) {
413 log_debug("Ignoring \"%s\".", sub_path);
3b63d2d3 414 continue;
582deb84 415 }
3b63d2d3
LP		 416
417 if (maxdepth <= 0)
582deb84 418 log_warning("Reached max depth on \"%s\".", sub_path);
3b63d2d3 419 else {
7fd1b19b 420 _cleanup_closedir_ DIR *sub_dir;
3b63d2d3
LP		 421 int q;
422
df99a9ef 423 sub_dir = xopendirat_nomod(dirfd(d), dent->d_name);
cde684a2 424 if (!sub_dir) {
582deb84
ZJS		 425 if (errno != ENOENT)
426 r = log_error_errno(errno, "opendir(%s) failed: %m", sub_path);
3b63d2d3
LP		 427
428 continue;
429 }
430
78a92a5a 431 q = dir_cleanup(i, sub_path, sub_dir, &s, cutoff, rootdev, false, maxdepth-1, false);
3b63d2d3
LP		 432 if (q < 0)
433 r = q;
434 }
435
24f3a374
LP		 436 /* Note: if you are wondering why we don't
437 * support the sticky bit for excluding
438 * directories from cleaning like we do it for
439 * other file system objects: well, the sticky
440 * bit already has a meaning for directories,
441 * so we don't want to overload that. */
442
582deb84
ZJS		 443 if (keep_this_level) {
444 log_debug("Keeping \"%s\".", sub_path);
24f3a374 445 continue;
582deb84 446 }
24f3a374 447
3b63d2d3 448 /* Ignore ctime, we change it when deleting */
582deb84
ZJS		 449 age = timespec_load(&s.st_mtim);
450 if (age >= cutoff) {
451 char a[FORMAT_TIMESTAMP_MAX];
452 /* Follows spelling in stat(1). */
453 log_debug("Directory \"%s\": modify time %s is too new.",
454 sub_path,
455 format_timestamp_us(a, sizeof(a), age));
3b63d2d3 456 continue;
582deb84
ZJS		 457 }
458
459 age = timespec_load(&s.st_atim);
460 if (age >= cutoff) {
461 char a[FORMAT_TIMESTAMP_MAX];
462 log_debug("Directory \"%s\": access time %s is too new.",
463 sub_path,
464 format_timestamp_us(a, sizeof(a), age));
465 continue;
466 }
3b63d2d3 467
61253220
ZJS		 468 log_debug("Removing directory \"%s\".", sub_path);
469 if (unlinkat(dirfd(d), dent->d_name, AT_REMOVEDIR) < 0)
470 if (errno != ENOENT && errno != ENOTEMPTY) {
471 log_error_errno(errno, "rmdir(%s): %m", sub_path);
472 r = -errno;
3b63d2d3 473 }
3b63d2d3
LP		 474
475 } else {
9c73736d
LP		 476 /* Skip files for which the sticky bit is
477 * set. These are semantics we define, and are
478 * unknown elsewhere. See XDG_RUNTIME_DIR
479 * specification for details. */
582deb84
ZJS		 480 if (s.st_mode & S_ISVTX) {
481 log_debug("Skipping \"%s\": sticky bit set.", sub_path);
9c73736d 482 continue;
582deb84 483 }
9c73736d 484
582deb84
ZJS		 485 if (mountpoint && S_ISREG(s.st_mode))
486 if ((streq(dent->d_name, ".journal") && s.st_uid == 0) ||
487 streq(dent->d_name, "aquota.user") ||
488 streq(dent->d_name, "aquota.group")) {
489 log_debug("Skipping \"%s\".", sub_path);
3b63d2d3 490 continue;
582deb84 491 }
3b63d2d3 492
17b90525 493 /* Ignore sockets that are listed in /proc/net/unix */
582deb84
ZJS		 494 if (S_ISSOCK(s.st_mode) && unix_socket_alive(sub_path)) {
495 log_debug("Skipping \"%s\": live socket.", sub_path);
17b90525 496 continue;
582deb84 497 }
17b90525 498
78ab08eb 499 /* Ignore device nodes */
582deb84
ZJS		 500 if (S_ISCHR(s.st_mode) || S_ISBLK(s.st_mode)) {
501 log_debug("Skipping \"%s\": a device.", sub_path);
78ab08eb 502 continue;
582deb84 503 }
78ab08eb 504
24f3a374
LP		 505 /* Keep files on this level around if this is
506 * requested */
582deb84
ZJS		 507 if (keep_this_level) {
508 log_debug("Keeping \"%s\".", sub_path);
24f3a374 509 continue;
582deb84 510 }
24f3a374 511
582deb84
ZJS		 512 age = timespec_load(&s.st_mtim);
513 if (age >= cutoff) {
514 char a[FORMAT_TIMESTAMP_MAX];
515 /* Follows spelling in stat(1). */
516 log_debug("File \"%s\": modify time %s is too new.",
517 sub_path,
518 format_timestamp_us(a, sizeof(a), age));
3b63d2d3 519 continue;
582deb84 520 }
3b63d2d3 521
582deb84
ZJS		 522 age = timespec_load(&s.st_atim);
523 if (age >= cutoff) {
524 char a[FORMAT_TIMESTAMP_MAX];
525 log_debug("File \"%s\": access time %s is too new.",
526 sub_path,
527 format_timestamp_us(a, sizeof(a), age));
528 continue;
529 }
3b63d2d3 530
582deb84
ZJS		 531 age = timespec_load(&s.st_ctim);
532 if (age >= cutoff) {
533 char a[FORMAT_TIMESTAMP_MAX];
534 log_debug("File \"%s\": change time %s is too new.",
535 sub_path,
536 format_timestamp_us(a, sizeof(a), age));
537 continue;
3b63d2d3
LP		 538 }
539
582deb84
ZJS		 540 log_debug("unlink \"%s\"", sub_path);
541
542 if (unlinkat(dirfd(d), dent->d_name, 0) < 0)
543 if (errno != ENOENT)
544 r = log_error_errno(errno, "unlink(%s): %m", sub_path);
545
3b63d2d3
LP		 546 deleted = true;
547 }
548 }
549
550finish:
551 if (deleted) {
582deb84
ZJS		 552 usec_t age1, age2;
553 char a[FORMAT_TIMESTAMP_MAX], b[FORMAT_TIMESTAMP_MAX];
554
3b63d2d3
LP		 555 /* Restore original directory timestamps */
556 times[0] = ds->st_atim;
557 times[1] = ds->st_mtim;
558
582deb84
ZJS		 559 age1 = timespec_load(&ds->st_atim);
560 age2 = timespec_load(&ds->st_mtim);
561 log_debug("Restoring access and modification time on \"%s\": %s, %s",
562 p,
563 format_timestamp_us(a, sizeof(a), age1),
564 format_timestamp_us(b, sizeof(b), age2));
3b63d2d3 565 if (futimens(dirfd(d), times) < 0)
56f64d95 566 log_error_errno(errno, "utimensat(%s): %m", p);
3b63d2d3
LP		 567 }
568
3b63d2d3
LP		 569 return r;
570}
571
b705ab6a 572static int path_set_perms(Item *i, const char *path) {
1924a97d
MO		 573 struct stat st;
574 bool st_valid;
575
cde684a2
LP		 576 assert(i);
577 assert(path);
578
1924a97d
MO		 579 st_valid = stat(path, &st) == 0;
580
062e01bb 581 /* not using i->path directly because it may be a glob */
abef3f91
LP		 582 if (i->mode_set) {
583 mode_t m = i->mode;
584
1924a97d
MO		 585 if (i->mask_perms && st_valid) {
586 if (!(st.st_mode & 0111))
587 m &= ~0111;
588 if (!(st.st_mode & 0222))
589 m &= ~0222;
590 if (!(st.st_mode & 0444))
591 m &= ~0444;
592 if (!S_ISDIR(st.st_mode))
593 m &= ~07000; /* remove sticky/sgid/suid bit, unless directory */
abef3f91
LP		 594 }
595
582deb84
ZJS		 596 if (st_valid && m == (st.st_mode & 07777))
597 log_debug("\"%s\" has right mode %o", path, st.st_mode);
598 else {
599 log_debug("chmod \"%s\" to mode %o", path, m);
4a62c710
MS		 600 if (chmod(path, m) < 0)
601 return log_error_errno(errno, "chmod(%s) failed: %m", path);
062e01bb 602 }
abef3f91 603 }
062e01bb 604
582deb84
ZJS		 605 if ((!st_valid || i->uid != st.st_uid || i->gid != st.st_gid) &&
606 (i->uid_set || i->gid_set)) {
607 log_debug("chown \"%s\" to "UID_FMT"."GID_FMT,
608 path,
609 i->uid_set ? i->uid : UID_INVALID,
610 i->gid_set ? i->gid : GID_INVALID);
062e01bb 611 if (chown(path,
fed1e721 612 i->uid_set ? i->uid : UID_INVALID,
505ef0e3 613 i->gid_set ? i->gid : GID_INVALID) < 0)
062e01bb 614
505ef0e3 615 return log_error_errno(errno, "chown(%s) failed: %m", path);
582deb84 616 }
062e01bb 617
9855d6c7 618 return label_fix(path, false, false);
062e01bb
MS		 619}
620
ebf4e801
MW		 621static int get_xattrs_from_arg(Item *i) {
622 char *xattr;
623 const char *p;
624 int r;
625
626 assert(i);
505ef0e3 627 assert(i->argument);
ebf4e801 628
ebf4e801
MW		 629 p = i->argument;
630
631 while ((r = unquote_first_word(&p, &xattr, false)) > 0) {
505ef0e3 632 _cleanup_free_ char *tmp = NULL, *name = NULL,
4cd552bc 633 *value = NULL, *value2 = NULL, *_xattr = xattr;
505ef0e3 634
ebf4e801
MW		 635 r = split_pair(xattr, "=", &name, &value);
636 if (r < 0) {
637 log_warning("Illegal xattr found: \"%s\" - ignoring.", xattr);
ebf4e801
MW		 638 continue;
639 }
505ef0e3
ZJS		 640
641 if (strempty(name) || strempty(value)) {
642 log_warning("Malformed xattr found: \"%s\" - ignoring.", xattr);
ebf4e801
MW		 643 continue;
644 }
505ef0e3 645
ebf4e801
MW		 646 tmp = unquote(value, "\"");
647 if (!tmp)
648 return log_oom();
505ef0e3
ZJS		 649
650 value2 = cunescape(tmp);
651 if (!value2)
ebf4e801 652 return log_oom();
505ef0e3
ZJS		 653
654 if (strv_push_pair(&i->xattrs, name, value2) < 0)
ebf4e801 655 return log_oom();
505ef0e3 656 name = value2 = NULL;
ebf4e801
MW		 657 }
658
659 return r;
660}
661
b705ab6a 662static int path_set_xattrs(Item *i, const char *path) {
ebf4e801
MW		 663 char **name, **value;
664
665 assert(i);
666 assert(path);
667
ebf4e801
MW		 668 STRV_FOREACH_PAIR(name, value, i->xattrs) {
669 int n;
505ef0e3 670
ebf4e801 671 n = strlen(*value);
582deb84 672 log_debug("\"%s\": setting xattr \"%s=%s\"", path, *name, *value);
ebf4e801 673 if (lsetxattr(path, *name, *value, n, 0) < 0) {
505ef0e3
ZJS		 674 log_error("Setting extended attribute %s=%s on %s failed: %m",
675 *name, *value, path);
ebf4e801
MW		 676 return -errno;
677 }
678 }
679 return 0;
680}
681
f8eeeaf9
ZJS		 682static int get_acls_from_arg(Item *item) {
683#ifdef HAVE_ACL
684 int r;
f8eeeaf9
ZJS		 685
686 assert(item);
687
50d9e46d
ZJS		 688 /* If force (= modify) is set, we will not modify the acl
689 * afterwards, so the mask can be added now if necessary. */
690 r = parse_acl(item->argument, &item->acl_access, &item->acl_default, !item->force);
f8eeeaf9
ZJS		 691 if (r < 0)
692 log_warning_errno(errno, "Failed to parse ACL \"%s\": %m. Ignoring",
693 item->argument);
694#else
695 log_warning_errno(ENOSYS, "ACLs are not supported. Ignoring");
696#endif
697
698 return 0;
699}
700
35888b67 701#ifdef HAVE_ACL
50d9e46d 702static int path_set_acl(const char *path, acl_type_t type, acl_t acl, bool modify) {
dd4105b0 703 _cleanup_(acl_freep) acl_t dup = NULL;
50d9e46d 704 int r;
582deb84 705 _cleanup_(acl_free_charpp) char *t = NULL;
50d9e46d
ZJS		 706
707 if (modify) {
dd4105b0 708 r = acls_for_file(path, type, acl, &dup);
50d9e46d
ZJS		 709 if (r < 0)
710 return r;
50d9e46d 711
dd4105b0
ZJS		 712 r = calc_acl_mask_if_needed(&dup);
713 if (r < 0)
714 return r;
715 } else {
716 dup = acl_dup(acl);
717 if (!dup)
718 return -errno;
719
720 /* the mask was already added earlier if needed */
721 }
722
723 r = add_base_acls_if_needed(&dup, path);
724 if (r < 0)
725 return r;
726
582deb84
ZJS		 727 t = acl_to_any_text(dup, NULL, ',', TEXT_ABBREVIATE);
728 log_debug("\"%s\": setting %s ACL \"%s\"", path,
729 type == ACL_TYPE_ACCESS ? "access" : "default",
730 strna(t));
50d9e46d 731
582deb84
ZJS		 732 r = acl_set_file(path, type, dup);
733 if (r < 0)
734 return log_error_errno(-errno,
735 "Setting %s ACL \"%s\" on %s failed: %m",
736 type == ACL_TYPE_ACCESS ? "access" : "default",
737 strna(t), path);
738 return 0;
50d9e46d 739}
35888b67 740#endif
50d9e46d 741
b705ab6a 742static int path_set_acls(Item *item, const char *path) {
f8eeeaf9
ZJS		 743#ifdef HAVE_ACL
744 int r;
745
746 assert(item);
747 assert(path);
748
749 if (item->acl_access) {
50d9e46d
ZJS		 750 r = path_set_acl(path, ACL_TYPE_ACCESS, item->acl_access, item->force);
751 if (r < 0)
752 return r;
f8eeeaf9
ZJS		 753 }
754
755 if (item->acl_default) {
50d9e46d
ZJS		 756 r = path_set_acl(path, ACL_TYPE_DEFAULT, item->acl_default, item->force);
757 if (r < 0)
758 return r;
f8eeeaf9
ZJS		 759 }
760#endif
761
762 return 0;
763}
764
d4e9eb91 765static int write_one_file(Item *i, const char *path) {
43ad6e31
LP		 766 _cleanup_close_ int fd = -1;
767 int flags, r = 0;
d4e9eb91 768 struct stat st;
d4e9eb91 769
874f1947
LP		 770 assert(i);
771 assert(path);
772
43ad6e31
LP		 773 flags = i->type == CREATE_FILE ? O_CREAT|O_APPEND|O_NOFOLLOW :
774 i->type == TRUNCATE_FILE ? O_CREAT|O_TRUNC|O_NOFOLLOW : 0;
d4e9eb91 775
43ad6e31 776 RUN_WITH_UMASK(0000) {
ecabcf8b 777 mac_selinux_create_file_prepare(path, S_IFREG);
43ad6e31 778 fd = open(path, flags|O_NDELAY|O_CLOEXEC|O_WRONLY|O_NOCTTY, i->mode);
ecabcf8b 779 mac_selinux_create_file_clear();
5c0d398d 780 }
d4e9eb91
DR		 781
782 if (fd < 0) {
582deb84
ZJS		 783 if (i->type == WRITE_FILE && errno == ENOENT) {
784 log_debug_errno(errno, "Not writing \"%s\": %m", path);
d4e9eb91 785 return 0;
582deb84 786 }
d4e9eb91 787
56f64d95 788 log_error_errno(errno, "Failed to create file %s: %m", path);
d4e9eb91
DR		 789 return -errno;
790 }
791
792 if (i->argument) {
cde684a2 793 _cleanup_free_ char *unescaped;
582deb84
ZJS		 794
795 log_debug("%s to \"%s\".",
796 i->type == CREATE_FILE ? "Appending" : "Writing", path);
d4e9eb91 797
54693d9b 798 unescaped = cunescape(i->argument);
43ad6e31 799 if (!unescaped)
54693d9b 800 return log_oom();
d4e9eb91 801
582deb84
ZJS		 802 r = loop_write(fd, unescaped, strlen(unescaped), false);
803 if (r < 0)
804 return log_error_errno(r, "Failed to write file \"%s\": %m", path);
805 } else
806 log_debug("\"%s\" has been created.", path);
d4e9eb91 807
43ad6e31 808 fd = safe_close(fd);
3612fbc1 809
4a62c710
MS		 810 if (stat(path, &st) < 0)
811 return log_error_errno(errno, "stat(%s) failed: %m", path);
d4e9eb91
DR		 812
813 if (!S_ISREG(st.st_mode)) {
814 log_error("%s is not a file.", path);
815 return -EEXIST;
816 }
817
b705ab6a 818 r = path_set_perms(i, path);
d4e9eb91
DR		 819 if (r < 0)
820 return r;
821
822 return 0;
823}
824
081043cf
ZJS		 825typedef int (*action_t)(Item *, const char *);
826
827static int item_do_children(Item *i, const char *path, action_t action) {
7fd1b19b 828 _cleanup_closedir_ DIR *d;
e73a03e0
LP		 829 int r = 0;
830
831 assert(i);
832 assert(path);
a8d88783
MS		 833
834 /* This returns the first error we run into, but nevertheless
835 * tries to go on */
836
df99a9ef
ZJS		 837 d = opendir_nomod(path);
838 if (!d)
e73a03e0 839 return errno == ENOENT || errno == ENOTDIR ? 0 : -errno;
a8d88783
MS		 840
841 for (;;) {
e73a03e0 842 _cleanup_free_ char *p = NULL;
7d5e9c0f 843 struct dirent *de;
e73a03e0 844 int q;
a8d88783 845
d78096b3
FW		 846 errno = 0;
847 de = readdir(d);
e73a03e0
LP		 848 if (!de) {
849 if (errno != 0 && r == 0)
850 r = -errno;
a8d88783 851
a8d88783 852 break;
e73a03e0 853 }
a8d88783 854
7fcb4b9b 855 if (STR_IN_SET(de->d_name, ".", ".."))
a8d88783
MS		 856 continue;
857
e73a03e0
LP		 858 p = strjoin(path, "/", de->d_name, NULL);
859 if (!p)
860 return -ENOMEM;
a8d88783 861
081043cf 862 q = action(i, p);
e73a03e0
LP		 863 if (q < 0 && q != -ENOENT && r == 0)
864 r = q;
a8d88783 865
e73a03e0 866 if (IN_SET(de->d_type, DT_UNKNOWN, DT_DIR)) {
081043cf 867 q = item_do_children(i, p, action);
e73a03e0
LP		 868 if (q < 0 && r == 0)
869 r = q;
a8d88783 870 }
a8d88783
MS		 871 }
872
e73a03e0 873 return r;
a8d88783
MS		 874}
875
081043cf 876static int glob_item(Item *i, action_t action, bool recursive) {
df99a9ef 877 _cleanup_globfree_ glob_t g = {
ebf31a1f
ZJS		 878 .gl_closedir = (void (*)(void *)) closedir,
879 .gl_readdir = (struct dirent *(*)(void *)) readdir,
880 .gl_opendir = (void *(*)(const char *)) opendir_nomod,
df99a9ef
ZJS		 881 .gl_lstat = lstat,
882 .gl_stat = stat,
883 };
e73a03e0 884 int r = 0, k;
99e68c0b
MS		 885 char **fn;
886
99e68c0b 887 errno = 0;
df99a9ef 888 k = glob(i->path, GLOB_NOSORT|GLOB_BRACE|GLOB_ALTDIRFUNC, NULL, &g);
081043cf
ZJS		 889 if (k != 0 && k != GLOB_NOMATCH)
890 return log_error_errno(errno ?: EIO, "glob(%s) failed: %m", i->path);
99e68c0b 891
c84a9488
ZJS		 892 STRV_FOREACH(fn, g.gl_pathv) {
893 k = action(i, *fn);
e73a03e0 894 if (k < 0 && r == 0)
99e68c0b 895 r = k;
081043cf
ZJS		 896
897 if (recursive) {
898 k = item_do_children(i, *fn, action);
899 if (k < 0 && r == 0)
900 r = k;
901 }
c84a9488 902 }
99e68c0b 903
99e68c0b
MS		 904 return r;
905}
906
294929f8
ZJS		 907typedef enum {
908 CREATION_NORMAL,
909 CREATION_EXISTING,
910 CREATION_FORCE,
7a7d5db7
LP		 911 _CREATION_MODE_MAX,
912 _CREATION_MODE_INVALID = -1
294929f8
ZJS		 913} CreationMode;
914
7a7d5db7
LP		 915static const char *creation_mode_verb_table[_CREATION_MODE_MAX] = {
916 [CREATION_NORMAL] = "Created",
917 [CREATION_EXISTING] = "Found existing",
918 [CREATION_FORCE] = "Created replacement",
919};
920
921DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(creation_mode_verb, CreationMode);
294929f8 922
3b63d2d3 923static int create_item(Item *i) {
3b63d2d3 924 struct stat st;
df28bc08 925 int r = 0;
294929f8 926 CreationMode creation;
5008d581 927
3b63d2d3 928 assert(i);
5008d581 929
582deb84
ZJS		 930 log_debug("Running create action for entry %c %s", (char) i->type, i->path);
931
3b63d2d3
LP		 932 switch (i->type) {
933
934 case IGNORE_PATH:
78a92a5a 935 case IGNORE_DIRECTORY_PATH:
3b63d2d3
LP		 936 case REMOVE_PATH:
937 case RECURSIVE_REMOVE_PATH:
938 return 0;
5008d581 939
3b63d2d3 940 case CREATE_FILE:
31ed59c5 941 case TRUNCATE_FILE:
1845fdd9
DR		 942 r = write_one_file(i, i->path);
943 if (r < 0)
944 return r;
945 break;
265ffa1e 946
849958d1 947 case COPY_FILES:
582deb84 948 log_debug("Copying tree \"%s\" to \"%s\".", i->argument, i->path);
e156347e 949 r = copy_tree(i->argument, i->path, false);
849958d1 950 if (r < 0) {
e156347e
LP		 951 struct stat a, b;
952
8d3d7072
MS		 953 if (r != -EEXIST)
954 return log_error_errno(r, "Failed to copy files to %s: %m", i->path);
e156347e 955
4a62c710
MS		 956 if (stat(i->argument, &a) < 0)
957 return log_error_errno(errno, "stat(%s) failed: %m", i->argument);
e156347e 958
4a62c710
MS		 959 if (stat(i->path, &b) < 0)
960 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
e156347e
LP		 961
962 if ((a.st_mode ^ b.st_mode) & S_IFMT) {
963 log_debug("Can't copy to %s, file exists already and is of different type", i->path);
964 return 0;
965 }
849958d1
LP		 966 }
967
b705ab6a 968 r = path_set_perms(i, i->path);
849958d1
LP		 969 if (r < 0)
970 return r;
971
972 break;
973
d4e9eb91 974 case WRITE_FILE:
081043cf 975 r = glob_item(i, write_one_file, false);
f05bc3f7
MS		 976 if (r < 0)
977 return r;
5008d581 978
3b63d2d3
LP		 979 break;
980
3b63d2d3 981 case CREATE_DIRECTORY:
d7b8eec7
LP		 982 case TRUNCATE_DIRECTORY:
983 case CREATE_SUBVOLUME:
5008d581 984
d7b8eec7 985 RUN_WITH_UMASK(0000)
5c0d398d 986 mkdir_parents_label(i->path, 0755);
d7b8eec7 987
582deb84
ZJS		 988 if (i->type == CREATE_SUBVOLUME)
989 RUN_WITH_UMASK((~i->mode) & 0777) {
d7b8eec7 990 r = btrfs_subvol_make(i->path);
582deb84
ZJS		 991 log_debug_errno(r, "Creating subvolume \"%s\": %m", i->path);
992 }
993 else
d7b8eec7
LP		 994 r = 0;
995
582deb84 996 if (IN_SET(i->type, CREATE_DIRECTORY, TRUNCATE_DIRECTORY) || r == -ENOTTY)
d7b8eec7
LP		 997 RUN_WITH_UMASK(0000)
998 r = mkdir_label(i->path, i->mode);
5008d581 999
e156347e 1000 if (r < 0) {
f647962d 1001 if (r != -EEXIST)
582deb84 1002 return log_error_errno(r, "Failed to create directory or subvolume \"%s\": %m", i->path);
5008d581 1003
4a62c710
MS		 1004 if (stat(i->path, &st) < 0)
1005 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
5008d581 1006
e156347e 1007 if (!S_ISDIR(st.st_mode)) {
582deb84 1008 log_debug("\"%s\" already exists and is not a directory.", i->path);
e156347e
LP		 1009 return 0;
1010 }
294929f8
ZJS		 1011
1012 creation = CREATION_EXISTING;
1013 } else
1014 creation = CREATION_NORMAL;
7a7d5db7 1015 log_debug("%s directory \"%s\".", creation_mode_verb_to_string(creation), i->path);
5008d581 1016
b705ab6a 1017 r = path_set_perms(i, i->path);
f05bc3f7
MS		 1018 if (r < 0)
1019 return r;
3b63d2d3
LP		 1020
1021 break;
ee17ee7c
LP		 1022
1023 case CREATE_FIFO:
1024
5c0d398d 1025 RUN_WITH_UMASK(0000) {
ecabcf8b 1026 mac_selinux_create_file_prepare(i->path, S_IFIFO);
5c0d398d 1027 r = mkfifo(i->path, i->mode);
ecabcf8b 1028 mac_selinux_create_file_clear();
5c0d398d 1029 }
ee17ee7c 1030
1554afae 1031 if (r < 0) {
4a62c710
MS		 1032 if (errno != EEXIST)
1033 return log_error_errno(errno, "Failed to create fifo %s: %m", i->path);
ee17ee7c 1034
4a62c710
MS		 1035 if (stat(i->path, &st) < 0)
1036 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
ee17ee7c 1037
1554afae
LP		 1038 if (!S_ISFIFO(st.st_mode)) {
1039
1040 if (i->force) {
1041
1042 RUN_WITH_UMASK(0000) {
ecabcf8b 1043 mac_selinux_create_file_prepare(i->path, S_IFIFO);
1554afae 1044 r = mkfifo_atomic(i->path, i->mode);
ecabcf8b 1045 mac_selinux_create_file_clear();
1554afae
LP		 1046 }
1047
f647962d
MS		 1048 if (r < 0)
1049 return log_error_errno(r, "Failed to create fifo %s: %m", i->path);
294929f8 1050 creation = CREATION_FORCE;
1554afae
LP		 1051 } else {
1052 log_debug("%s is not a fifo.", i->path);
1053 return 0;
1054 }
294929f8
ZJS		 1055 } else
1056 creation = CREATION_EXISTING;
1057 } else
1058 creation = CREATION_NORMAL;
7a7d5db7 1059 log_debug("%s fifo \"%s\".", creation_mode_verb_to_string(creation), i->path);
ee17ee7c 1060
b705ab6a 1061 r = path_set_perms(i, i->path);
f05bc3f7
MS		 1062 if (r < 0)
1063 return r;
ee17ee7c
LP		 1064
1065 break;
a8d88783 1066
2e78fa79 1067 case CREATE_SYMLINK:
468d726b 1068
ecabcf8b 1069 mac_selinux_create_file_prepare(i->path, S_IFLNK);
468d726b 1070 r = symlink(i->argument, i->path);
ecabcf8b 1071 mac_selinux_create_file_clear();
e9a5ef7c 1072
468d726b 1073 if (r < 0) {
2e78fa79 1074 _cleanup_free_ char *x = NULL;
468d726b 1075
4a62c710
MS		 1076 if (errno != EEXIST)
1077 return log_error_errno(errno, "symlink(%s, %s) failed: %m", i->argument, i->path);
2e78fa79
LP		 1078
1079 r = readlink_malloc(i->path, &x);
1080 if (r < 0 || !streq(i->argument, x)) {
1081
1082 if (i->force) {
ecabcf8b 1083 mac_selinux_create_file_prepare(i->path, S_IFLNK);
2e78fa79 1084 r = symlink_atomic(i->argument, i->path);
ecabcf8b 1085 mac_selinux_create_file_clear();
2e78fa79 1086
f647962d
MS		 1087 if (r < 0)
1088 return log_error_errno(r, "symlink(%s, %s) failed: %m", i->argument, i->path);
294929f8 1089 creation = CREATION_FORCE;
1554afae 1090 } else {
582deb84 1091 log_debug("\"%s\" is not a symlink or does not point to the correct path.", i->path);
1554afae
LP		 1092 return 0;
1093 }
294929f8
ZJS		 1094 } else
1095 creation = CREATION_EXISTING;
1096 } else
1097 creation = CREATION_NORMAL;
7a7d5db7 1098 log_debug("%s symlink \"%s\".", creation_mode_verb_to_string(creation), i->path);
468d726b 1099
468d726b 1100 break;
468d726b
LP		 1101
1102 case CREATE_BLOCK_DEVICE:
1103 case CREATE_CHAR_DEVICE: {
cb7ed9df
LP		 1104 mode_t file_type;
1105
1106 if (have_effective_cap(CAP_MKNOD) == 0) {
1107 /* In a container we lack CAP_MKNOD. We
ab06eef8 1108 shouldn't attempt to create the device node in
cb7ed9df
LP		 1109 that case to avoid noise, and we don't support
1110 virtualized devices in containers anyway. */
1111
1112 log_debug("We lack CAP_MKNOD, skipping creation of device node %s.", i->path);
1113 return 0;
1114 }
1115
1554afae 1116 file_type = i->type == CREATE_BLOCK_DEVICE ? S_IFBLK : S_IFCHR;
468d726b 1117
5c0d398d 1118 RUN_WITH_UMASK(0000) {
ecabcf8b 1119 mac_selinux_create_file_prepare(i->path, file_type);
5c0d398d 1120 r = mknod(i->path, i->mode | file_type, i->major_minor);
ecabcf8b 1121 mac_selinux_create_file_clear();
5c0d398d 1122 }
468d726b 1123
6555ad8e
KS		 1124 if (r < 0) {
1125 if (errno == EPERM) {
1126 log_debug("We lack permissions, possibly because of cgroup configuration; "
1127 "skipping creation of device node %s.", i->path);
1128 return 0;
1129 }
1130
4a62c710
MS		 1131 if (errno != EEXIST)
1132 return log_error_errno(errno, "Failed to create device node %s: %m", i->path);
468d726b 1133
4a62c710
MS		 1134 if (stat(i->path, &st) < 0)
1135 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
468d726b 1136
1554afae
LP		 1137 if ((st.st_mode & S_IFMT) != file_type) {
1138
1139 if (i->force) {
1140
1141 RUN_WITH_UMASK(0000) {
ecabcf8b 1142 mac_selinux_create_file_prepare(i->path, file_type);
1554afae 1143 r = mknod_atomic(i->path, i->mode | file_type, i->major_minor);
ecabcf8b 1144 mac_selinux_create_file_clear();
1554afae
LP		 1145 }
1146
f647962d 1147 if (r < 0)
294929f8
ZJS		 1148 return log_error_errno(r, "Failed to create device node \"%s\": %m", i->path);
1149 creation = CREATION_FORCE;
1554afae
LP		 1150 } else {
1151 log_debug("%s is not a device node.", i->path);
1152 return 0;
1153 }
294929f8
ZJS		 1154 } else
1155 creation = CREATION_EXISTING;
1156 } else
1157 creation = CREATION_NORMAL;
1158 log_debug("%s %s device node \"%s\" %u:%u.",
7a7d5db7 1159 creation_mode_verb_to_string(creation),
582deb84
ZJS		 1160 i->type == CREATE_BLOCK_DEVICE ? "block" : "char",
1161 i->path, major(i->mode), minor(i->mode));
468d726b 1162
b705ab6a 1163 r = path_set_perms(i, i->path);
468d726b
LP		 1164 if (r < 0)
1165 return r;
1166
1167 break;
1168 }
1169
e73a03e0 1170 case ADJUST_MODE:
777b87e7 1171 case RELABEL_PATH:
b705ab6a 1172 r = glob_item(i, path_set_perms, false);
777b87e7 1173 if (r < 0)
96ca8194 1174 return r;
777b87e7
MS		 1175 break;
1176
a8d88783 1177 case RECURSIVE_RELABEL_PATH:
b705ab6a 1178 r = glob_item(i, path_set_perms, true);
a8d88783
MS		 1179 if (r < 0)
1180 return r;
ebf4e801 1181 break;
e73a03e0 1182
ebf4e801 1183 case SET_XATTR:
b705ab6a
ZJS		 1184 r = glob_item(i, path_set_xattrs, false);
1185 if (r < 0)
1186 return r;
1187 break;
1188
1189 case RECURSIVE_SET_XATTR:
1190 r = glob_item(i, path_set_xattrs, true);
ebf4e801
MW		 1191 if (r < 0)
1192 return r;
e73a03e0 1193 break;
f8eeeaf9
ZJS		 1194
1195 case SET_ACL:
b705ab6a 1196 r = glob_item(i, path_set_acls, false);
f8eeeaf9
ZJS		 1197 if (r < 0)
1198 return r;
b705ab6a
ZJS		 1199 break;
1200
1201 case RECURSIVE_SET_ACL:
1202 r = glob_item(i, path_set_acls, true);
1203 if (r < 0)
1204 return r;
1205 break;
3b63d2d3
LP		 1206 }
1207
3b63d2d3
LP		 1208 log_debug("%s created successfully.", i->path);
1209
f05bc3f7 1210 return 0;
3b63d2d3
LP		 1211}
1212
a0896123 1213static int remove_item_instance(Item *i, const char *instance) {
3b63d2d3
LP		 1214 int r;
1215
1216 assert(i);
1217
1218 switch (i->type) {
1219
3b63d2d3 1220 case REMOVE_PATH:
4a62c710 1221 if (remove(instance) < 0 && errno != ENOENT)
3f93da98 1222 return log_error_errno(errno, "rm(%s): %m", instance);
3b63d2d3
LP		 1223
1224 break;
1225
1226 case TRUNCATE_DIRECTORY:
1227 case RECURSIVE_REMOVE_PATH:
d139b24a
LP		 1228 /* FIXME: we probably should use dir_cleanup() here
1229 * instead of rm_rf() so that 'x' is honoured. */
582deb84 1230 log_debug("rm -rf \"%s\"", instance);
f56d5db9 1231 r = rm_rf_dangerous(instance, false, i->type == RECURSIVE_REMOVE_PATH, false);
f647962d
MS		 1232 if (r < 0 && r != -ENOENT)
1233 return log_error_errno(r, "rm_rf(%s): %m", instance);
3b63d2d3
LP		 1234
1235 break;
7fcb4b9b
ZJS		 1236
1237 default:
1238 assert_not_reached("wut?");
3b63d2d3
LP		 1239 }
1240
1241 return 0;
1242}
1243
a0896123 1244static int remove_item(Item *i) {
99e68c0b
MS		 1245 int r = 0;
1246
b8bb3e8f
LP		 1247 assert(i);
1248
582deb84
ZJS		 1249 log_debug("Running remove action for entry %c %s", (char) i->type, i->path);
1250
b8bb3e8f
LP		 1251 switch (i->type) {
1252
1253 case CREATE_FILE:
1254 case TRUNCATE_FILE:
1255 case CREATE_DIRECTORY:
d7b8eec7 1256 case CREATE_SUBVOLUME:
ee17ee7c 1257 case CREATE_FIFO:
468d726b
LP		 1258 case CREATE_SYMLINK:
1259 case CREATE_CHAR_DEVICE:
1260 case CREATE_BLOCK_DEVICE:
b8bb3e8f 1261 case IGNORE_PATH:
78a92a5a 1262 case IGNORE_DIRECTORY_PATH:
e73a03e0 1263 case ADJUST_MODE:
777b87e7 1264 case RELABEL_PATH:
a8d88783 1265 case RECURSIVE_RELABEL_PATH:
31ed59c5 1266 case WRITE_FILE:
849958d1 1267 case COPY_FILES:
ebf4e801 1268 case SET_XATTR:
b705ab6a 1269 case RECURSIVE_SET_XATTR:
f8eeeaf9 1270 case SET_ACL:
b705ab6a 1271 case RECURSIVE_SET_ACL:
b8bb3e8f
LP		 1272 break;
1273
1274 case REMOVE_PATH:
1275 case TRUNCATE_DIRECTORY:
99e68c0b 1276 case RECURSIVE_REMOVE_PATH:
081043cf 1277 r = glob_item(i, remove_item_instance, false);
99e68c0b 1278 break;
b8bb3e8f
LP		 1279 }
1280
99e68c0b 1281 return r;
b8bb3e8f
LP		 1282}
1283
78a92a5a 1284static int clean_item_instance(Item *i, const char* instance) {
7fd1b19b 1285 _cleanup_closedir_ DIR *d = NULL;
78a92a5a
MS		 1286 struct stat s, ps;
1287 bool mountpoint;
78a92a5a 1288 usec_t cutoff, n;
582deb84 1289 char timestamp[FORMAT_TIMESTAMP_MAX];
78a92a5a
MS		 1290
1291 assert(i);
1292
1293 if (!i->age_set)
1294 return 0;
1295
1296 n = now(CLOCK_REALTIME);
1297 if (n < i->age)
1298 return 0;
1299
1300 cutoff = n - i->age;
1301
df99a9ef 1302 d = opendir_nomod(instance);
78a92a5a 1303 if (!d) {
582deb84
ZJS		 1304 if (errno == ENOENT || errno == ENOTDIR) {
1305 log_debug_errno(errno, "Directory \"%s\": %m", instance);
78a92a5a 1306 return 0;
582deb84 1307 }
78a92a5a 1308
582deb84 1309 log_error_errno(errno, "Failed to open directory %s: %m", instance);
78a92a5a
MS		 1310 return -errno;
1311 }
1312
4a62c710
MS		 1313 if (fstat(dirfd(d), &s) < 0)
1314 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
78a92a5a
MS		 1315
1316 if (!S_ISDIR(s.st_mode)) {
1317 log_error("%s is not a directory.", i->path);
19fbec19 1318 return -ENOTDIR;
78a92a5a
MS		 1319 }
1320
4a62c710
MS		 1321 if (fstatat(dirfd(d), "..", &ps, AT_SYMLINK_NOFOLLOW) != 0)
1322 return log_error_errno(errno, "stat(%s/..) failed: %m", i->path);
78a92a5a
MS		 1323
1324 mountpoint = s.st_dev != ps.st_dev ||
1325 (s.st_dev == ps.st_dev && s.st_ino == ps.st_ino);
1326
582deb84
ZJS		 1327 log_debug("Cleanup threshold for %s \"%s\" is %s",
1328 mountpoint ? "mount point" : "directory",
1329 instance,
1330 format_timestamp_us(timestamp, sizeof(timestamp), cutoff));
1331
1332 return dir_cleanup(i, instance, d, &s, cutoff, s.st_dev, mountpoint,
1333 MAX_DEPTH, i->keep_first_level);
78a92a5a
MS		 1334}
1335
1336static int clean_item(Item *i) {
1337 int r = 0;
1338
1339 assert(i);
1340
582deb84
ZJS		 1341 log_debug("Running clean action for entry %c %s", (char) i->type, i->path);
1342
78a92a5a
MS		 1343 switch (i->type) {
1344 case CREATE_DIRECTORY:
d7b8eec7 1345 case CREATE_SUBVOLUME:
78a92a5a
MS		 1346 case TRUNCATE_DIRECTORY:
1347 case IGNORE_PATH:
849958d1 1348 case COPY_FILES:
78a92a5a
MS		 1349 clean_item_instance(i, i->path);
1350 break;
1351 case IGNORE_DIRECTORY_PATH:
081043cf 1352 r = glob_item(i, clean_item_instance, false);
78a92a5a
MS		 1353 break;
1354 default:
1355 break;
1356 }
1357
1358 return r;
1359}
1360
3f93da98
ZJS		 1361static int process_item_array(ItemArray *array);
1362
3b63d2d3 1363static int process_item(Item *i) {
1e95893a 1364 int r, q, p, t = 0;
9348f0e6 1365 _cleanup_free_ char *prefix = NULL;
3b63d2d3
LP		 1366
1367 assert(i);
1368
1910cd0e
LP		 1369 if (i->done)
1370 return 0;
1371
1372 i->done = true;
1373
9348f0e6
ZJS		 1374 prefix = malloc(strlen(i->path) + 1);
1375 if (!prefix)
1376 return log_oom();
1377
1910cd0e 1378 PATH_FOREACH_PREFIX(prefix, i->path) {
3f93da98 1379 ItemArray *j;
1910cd0e
LP		 1380
1381 j = hashmap_get(items, prefix);
1db50423
ZJS		 1382 if (j) {
1383 int s;
1384
3f93da98 1385 s = process_item_array(j);
1db50423
ZJS		 1386 if (s < 0 && t == 0)
1387 t = s;
1388 }
1910cd0e
LP		 1389 }
1390
3b63d2d3 1391 r = arg_create ? create_item(i) : 0;
a0896123 1392 q = arg_remove ? remove_item(i) : 0;
3b63d2d3
LP		 1393 p = arg_clean ? clean_item(i) : 0;
1394
1db50423
ZJS		 1395 return t < 0 ? t :
1396 r < 0 ? r :
1397 q < 0 ? q :
1398 p;
3b63d2d3
LP		 1399}
1400
3f93da98
ZJS		 1401static int process_item_array(ItemArray *array) {
1402 unsigned n;
1403 int r = 0, k;
753615e8 1404
3f93da98
ZJS		 1405 assert(array);
1406
1407 for (n = 0; n < array->count; n++) {
1408 k = process_item(array->items + n);
1409 if (k < 0 && r == 0)
1410 r = k;
1411 }
1412
1413 return r;
1414}
3b63d2d3 1415
3f93da98
ZJS		 1416static void item_free_contents(Item *i) {
1417 assert(i);
3b63d2d3 1418 free(i->path);
468d726b 1419 free(i->argument);
ebf4e801 1420 strv_free(i->xattrs);
f8eeeaf9
ZJS		 1421
1422#ifdef HAVE_ACL
1423 acl_free(i->acl_access);
1424 acl_free(i->acl_default);
1425#endif
3b63d2d3
LP		 1426}
1427
3f93da98
ZJS		 1428static void item_array_free(ItemArray *a) {
1429 unsigned n;
1430
1431 if (!a)
1432 return;
1433
1434 for (n = 0; n < a->count; n++)
1435 item_free_contents(a->items + n);
1436 free(a->items);
1437 free(a);
1438}
e2f2fb78 1439
3f93da98 1440static bool item_compatible(Item *a, Item *b) {
bfe95f35
LP		 1441 assert(a);
1442 assert(b);
3f93da98 1443 assert(streq(a->path, b->path));
bfe95f35 1444
3f93da98
ZJS		 1445 if (takes_ownership(a->type) && takes_ownership(b->type))
1446 /* check if the items are the same */
1447 return streq_ptr(a->argument, b->argument) &&
bfe95f35 1448
3f93da98
ZJS		 1449 a->uid_set == b->uid_set &&
1450 a->uid == b->uid &&
bfe95f35 1451
3f93da98
ZJS		 1452 a->gid_set == b->gid_set &&
1453 a->gid == b->gid &&
bfe95f35 1454
3f93da98
ZJS		 1455 a->mode_set == b->mode_set &&
1456 a->mode == b->mode &&
bfe95f35 1457
3f93da98
ZJS		 1458 a->age_set == b->age_set &&
1459 a->age == b->age &&
bfe95f35 1460
3f93da98 1461 a->mask_perms == b->mask_perms &&
bfe95f35 1462
3f93da98 1463 a->keep_first_level == b->keep_first_level &&
468d726b 1464
3f93da98 1465 a->major_minor == b->major_minor;
468d726b 1466
bfe95f35
LP		 1467 return true;
1468}
1469
a2aced4a
DR		 1470static bool should_include_path(const char *path) {
1471 char **prefix;
1472
abef3f91 1473 STRV_FOREACH(prefix, arg_exclude_prefixes)
582deb84
ZJS		 1474 if (path_startswith(path, *prefix)) {
1475 log_debug("Entry \"%s\" matches exclude prefix \"%s\", skipping.",
1476 path, *prefix);
5c795114 1477 return false;
582deb84 1478 }
a2aced4a 1479
abef3f91 1480 STRV_FOREACH(prefix, arg_include_prefixes)
582deb84
ZJS		 1481 if (path_startswith(path, *prefix)) {
1482 log_debug("Entry \"%s\" matches include prefix \"%s\".", path, *prefix);
a2aced4a 1483 return true;
582deb84 1484 }
a2aced4a 1485
5c795114
DR		 1486 /* no matches, so we should include this path only if we
1487 * have no whitelist at all */
582deb84
ZJS		 1488 if (strv_length(arg_include_prefixes) == 0)
1489 return true;
1490
1491 log_debug("Entry \"%s\" does not match any include prefix, skipping.", path);
1492 return false;
a2aced4a
DR		 1493}
1494
fba6e687 1495static int parse_line(const char *fname, unsigned line, const char *buffer) {
1731e34a
LP		 1496
1497 static const Specifier specifier_table[] = {
1498 { 'm', specifier_machine_id, NULL },
1499 { 'b', specifier_boot_id, NULL },
1500 { 'H', specifier_host_name, NULL },
1501 { 'v', specifier_kernel_release, NULL },
1502 {}
1503 };
1504
cde684a2 1505 _cleanup_free_ char *action = NULL, *mode = NULL, *user = NULL, *group = NULL, *age = NULL, *path = NULL;
3f93da98
ZJS		 1506 _cleanup_(item_free_contents) Item i = {};
1507 ItemArray *existing;
bfe95f35 1508 Hashmap *h;
3f93da98 1509 int r, c = -1, pos;
5f255144 1510 bool force = false, boot = false;
3b63d2d3
LP		 1511
1512 assert(fname);
1513 assert(line >= 1);
1514 assert(buffer);
1515
19fbec19 1516 r = sscanf(buffer,
c4708f13
ZJS		 1517 "%ms %ms %ms %ms %ms %ms %n",
1518 &action,
1731e34a 1519 &path,
bd40a2d8
LP		 1520 &mode,
1521 &user,
1522 &group,
468d726b 1523 &age,
3f93da98 1524 &c);
19fbec19 1525 if (r < 2) {
3b63d2d3 1526 log_error("[%s:%u] Syntax error.", fname, line);
7f2c1f4d 1527 return -EIO;
5008d581
LP		 1528 }
1529
2e78fa79
LP		 1530 if (isempty(action)) {
1531 log_error("[%s:%u] Command too short '%s'.", fname, line, action);
c4708f13 1532 return -EINVAL;
2e78fa79
LP		 1533 }
1534
5f255144
ZJS		 1535 for (pos = 1; action[pos]; pos++) {
1536 if (action[pos] == '!' && !boot)
1537 boot = true;
1538 else if (action[pos] == '+' && !force)
1539 force = true;
1540 else {
1541 log_error("[%s:%u] Unknown modifiers in command '%s'",
1542 fname, line, action);
1543 return -EINVAL;
1544 }
2e78fa79
LP		 1545 }
1546
582deb84
ZJS		 1547 if (boot && !arg_boot) {
1548 log_debug("Ignoring entry %s \"%s\" because --boot is not specified.",
1549 action, path);
c4708f13 1550 return 0;
582deb84 1551 }
c4708f13 1552
3f93da98
ZJS		 1553 i.type = action[0];
1554 i.force = force;
2e78fa79 1555
3f93da98 1556 r = specifier_printf(path, specifier_table, NULL, &i.path);
1731e34a
LP		 1557 if (r < 0) {
1558 log_error("[%s:%u] Failed to replace specifiers: %s", fname, line, path);
1559 return r;
1560 }
1561
3f93da98
ZJS		 1562 if (c >= 0) {
1563 c += strspn(buffer+c, WHITESPACE);
1564 if (buffer[c] != 0 && (buffer[c] != '-' || buffer[c+1] != 0)) {
1565 i.argument = unquote(buffer+c, "\"");
1566 if (!i.argument)
0d0f0c50 1567 return log_oom();
31ed59c5
LP		 1568 }
1569 }
1570
3f93da98 1571 switch (i.type) {
468d726b 1572
777b87e7
MS		 1573 case CREATE_FILE:
1574 case TRUNCATE_FILE:
1575 case CREATE_DIRECTORY:
d7b8eec7 1576 case CREATE_SUBVOLUME:
777b87e7
MS		 1577 case TRUNCATE_DIRECTORY:
1578 case CREATE_FIFO:
1579 case IGNORE_PATH:
78a92a5a 1580 case IGNORE_DIRECTORY_PATH:
777b87e7
MS		 1581 case REMOVE_PATH:
1582 case RECURSIVE_REMOVE_PATH:
e73a03e0 1583 case ADJUST_MODE:
777b87e7
MS		 1584 case RELABEL_PATH:
1585 case RECURSIVE_RELABEL_PATH:
1586 break;
468d726b
LP		 1587
1588 case CREATE_SYMLINK:
3f93da98
ZJS		 1589 if (!i.argument) {
1590 i.argument = strappend("/usr/share/factory/", i.path);
1591 if (!i.argument)
2f3b873a 1592 return log_oom();
468d726b
LP		 1593 }
1594 break;
1595
31ed59c5 1596 case WRITE_FILE:
3f93da98 1597 if (!i.argument) {
31ed59c5 1598 log_error("[%s:%u] Write file requires argument.", fname, line);
7f2c1f4d 1599 return -EBADMSG;
31ed59c5
LP		 1600 }
1601 break;
1602
849958d1 1603 case COPY_FILES:
3f93da98
ZJS		 1604 if (!i.argument) {
1605 i.argument = strappend("/usr/share/factory/", i.path);
1606 if (!i.argument)
2f3b873a 1607 return log_oom();
3f93da98 1608 } else if (!path_is_absolute(i.argument)) {
849958d1
LP		 1609 log_error("[%s:%u] Source path is not absolute.", fname, line);
1610 return -EBADMSG;
1611 }
1612
3f93da98 1613 path_kill_slashes(i.argument);
849958d1
LP		 1614 break;
1615
468d726b
LP		 1616 case CREATE_CHAR_DEVICE:
1617 case CREATE_BLOCK_DEVICE: {
1618 unsigned major, minor;
1619
3f93da98 1620 if (!i.argument) {
468d726b 1621 log_error("[%s:%u] Device file requires argument.", fname, line);
7f2c1f4d 1622 return -EBADMSG;
468d726b
LP		 1623 }
1624
3f93da98
ZJS		 1625 if (sscanf(i.argument, "%u:%u", &major, &minor) != 2) {
1626 log_error("[%s:%u] Can't parse device file major/minor '%s'.", fname, line, i.argument);
7f2c1f4d 1627 return -EBADMSG;
468d726b
LP		 1628 }
1629
3f93da98 1630 i.major_minor = makedev(major, minor);
468d726b
LP		 1631 break;
1632 }
1633
ebf4e801 1634 case SET_XATTR:
b705ab6a 1635 case RECURSIVE_SET_XATTR:
3f93da98 1636 if (!i.argument) {
ebf4e801
MW		 1637 log_error("[%s:%u] Set extended attribute requires argument.", fname, line);
1638 return -EBADMSG;
1639 }
3f93da98 1640 r = get_xattrs_from_arg(&i);
ebf4e801
MW		 1641 if (r < 0)
1642 return r;
1643 break;
1644
f8eeeaf9 1645 case SET_ACL:
b705ab6a 1646 case RECURSIVE_SET_ACL:
f8eeeaf9
ZJS		 1647 if (!i.argument) {
1648 log_error("[%s:%u] Set ACLs requires argument.", fname, line);
1649 return -EBADMSG;
1650 }
1651 r = get_acls_from_arg(&i);
1652 if (r < 0)
1653 return r;
1654 break;
1655
777b87e7 1656 default:
582deb84 1657 log_error("[%s:%u] Unknown command type '%c'.", fname, line, (char) i.type);
7f2c1f4d 1658 return -EBADMSG;
3b63d2d3 1659 }
468d726b 1660
3f93da98
ZJS		 1661 if (!path_is_absolute(i.path)) {
1662 log_error("[%s:%u] Path '%s' not absolute.", fname, line, i.path);
7f2c1f4d 1663 return -EBADMSG;
3b63d2d3
LP		 1664 }
1665
3f93da98 1666 path_kill_slashes(i.path);
3b63d2d3 1667
3f93da98 1668 if (!should_include_path(i.path))
7f2c1f4d 1669 return 0;
5008d581 1670
cf9a4abd 1671 if (arg_root) {
cde684a2
LP		 1672 char *p;
1673
3f93da98 1674 p = strappend(arg_root, i.path);
cf9a4abd
MM		 1675 if (!p)
1676 return log_oom();
1677
3f93da98
ZJS		 1678 free(i.path);
1679 i.path = p;
cf9a4abd
MM		 1680 }
1681
3b63d2d3 1682 if (user && !streq(user, "-")) {
4b67834e
LP		 1683 const char *u = user;
1684
3f93da98 1685 r = get_user_creds(&u, &i.uid, NULL, NULL, NULL);
4b67834e 1686 if (r < 0) {
3b63d2d3 1687 log_error("[%s:%u] Unknown user '%s'.", fname, line, user);
7f2c1f4d 1688 return r;
3b63d2d3
LP		 1689 }
1690
3f93da98 1691 i.uid_set = true;
3b63d2d3
LP		 1692 }
1693
1694 if (group && !streq(group, "-")) {
4b67834e
LP		 1695 const char *g = group;
1696
3f93da98 1697 r = get_group_creds(&g, &i.gid);
4b67834e 1698 if (r < 0) {
3b63d2d3 1699 log_error("[%s:%u] Unknown group '%s'.", fname, line, group);
7f2c1f4d 1700 return r;
3b63d2d3
LP		 1701 }
1702
3f93da98 1703 i.gid_set = true;
3b63d2d3
LP		 1704 }
1705
1706 if (mode && !streq(mode, "-")) {
abef3f91 1707 const char *mm = mode;
3b63d2d3
LP		 1708 unsigned m;
1709
abef3f91 1710 if (*mm == '~') {
3f93da98 1711 i.mask_perms = true;
abef3f91
LP		 1712 mm++;
1713 }
1714
1715 if (sscanf(mm, "%o", &m) != 1) {
3b63d2d3 1716 log_error("[%s:%u] Invalid mode '%s'.", fname, line, mode);
7f2c1f4d 1717 return -ENOENT;
3b63d2d3
LP		 1718 }
1719
3f93da98
ZJS		 1720 i.mode = m;
1721 i.mode_set = true;
3b63d2d3 1722 } else
3f93da98
ZJS		 1723 i.mode = IN_SET(i.type, CREATE_DIRECTORY, CREATE_SUBVOLUME, TRUNCATE_DIRECTORY)
1724 ? 0755 : 0644;
3b63d2d3
LP		 1725
1726 if (age && !streq(age, "-")) {
24f3a374
LP		 1727 const char *a = age;
1728
1729 if (*a == '~') {
3f93da98 1730 i.keep_first_level = true;
24f3a374
LP		 1731 a++;
1732 }
1733
3f93da98 1734 if (parse_sec(a, &i.age) < 0) {
3b63d2d3 1735 log_error("[%s:%u] Invalid age '%s'.", fname, line, age);
7f2c1f4d 1736 return -EBADMSG;
3b63d2d3
LP		 1737 }
1738
3f93da98 1739 i.age_set = true;
3b63d2d3
LP		 1740 }
1741
3f93da98 1742 h = needs_glob(i.type) ? globs : items;
bfe95f35 1743
3f93da98 1744 existing = hashmap_get(h, i.path);
468d726b 1745 if (existing) {
3f93da98
ZJS		 1746 unsigned n;
1747
1748 for (n = 0; n < existing->count; n++) {
1749 if (!item_compatible(existing->items + n, &i))
505ef0e3 1750 log_warning("[%s:%u] Duplicate line for path \"%s\", ignoring.",
3f93da98 1751 fname, line, i.path);
ebf4e801
MW		 1752 }
1753 } else {
3f93da98
ZJS		 1754 existing = new0(ItemArray, 1);
1755 r = hashmap_put(h, i.path, existing);
1756 if (r < 0)
1757 return log_oom();
bfe95f35
LP		 1758 }
1759
3f93da98
ZJS		 1760 if (!GREEDY_REALLOC(existing->items, existing->size, existing->count + 1))
1761 return log_oom();
5008d581 1762
3f93da98
ZJS		 1763 memcpy(existing->items + existing->count++, &i, sizeof(i));
1764 zero(i);
7f2c1f4d 1765 return 0;
5008d581
LP		 1766}
1767
601185b4 1768static void help(void) {
522d4a49
LP		 1769 printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
1770 "Creates, deletes and cleans up volatile and temporary files and directories.\n\n"
5c795114 1771 " -h --help Show this help\n"
eb9da376 1772 " --version Show package version\n"
5c795114
DR		 1773 " --create Create marked files/directories\n"
1774 " --clean Clean up marked directories\n"
1775 " --remove Remove marked files/directories\n"
81815651 1776 " --boot Execute actions only safe at boot\n"
79ca888f
ZJS		 1777 " --prefix=PATH Only apply rules with the specified prefix\n"
1778 " --exclude-prefix=PATH Ignore rules with the specified prefix\n"
cf9a4abd 1779 " --root=PATH Operate on an alternate filesystem root\n",
3b63d2d3 1780 program_invocation_short_name);
3b63d2d3
LP		 1781}
1782
1783static int parse_argv(int argc, char *argv[]) {
1784
1785 enum {
eb9da376 1786 ARG_VERSION = 0x100,
3b63d2d3
LP		 1787 ARG_CREATE,
1788 ARG_CLEAN,
fba6e687 1789 ARG_REMOVE,
81815651 1790 ARG_BOOT,
5c795114
DR		 1791 ARG_PREFIX,
1792 ARG_EXCLUDE_PREFIX,
cf9a4abd 1793 ARG_ROOT,
3b63d2d3
LP		 1794 };
1795
1796 static const struct option options[] = {
5c795114 1797 { "help", no_argument, NULL, 'h' },
eb9da376 1798 { "version", no_argument, NULL, ARG_VERSION },
5c795114
DR		 1799 { "create", no_argument, NULL, ARG_CREATE },
1800 { "clean", no_argument, NULL, ARG_CLEAN },
1801 { "remove", no_argument, NULL, ARG_REMOVE },
81815651 1802 { "boot", no_argument, NULL, ARG_BOOT },
5c795114
DR		 1803 { "prefix", required_argument, NULL, ARG_PREFIX },
1804 { "exclude-prefix", required_argument, NULL, ARG_EXCLUDE_PREFIX },
cf9a4abd 1805 { "root", required_argument, NULL, ARG_ROOT },
eb9da376 1806 {}
3b63d2d3
LP		 1807 };
1808
1809 int c;
1810
1811 assert(argc >= 0);
1812 assert(argv);
1813
601185b4 1814 while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
3b63d2d3
LP		 1815
1816 switch (c) {
1817
1818 case 'h':
601185b4
ZJS		 1819 help();
1820 return 0;
eb9da376
LP		 1821
1822 case ARG_VERSION:
1823 puts(PACKAGE_STRING);
1824 puts(SYSTEMD_FEATURES);
3b63d2d3
LP		 1825 return 0;
1826
1827 case ARG_CREATE:
1828 arg_create = true;
1829 break;
1830
1831 case ARG_CLEAN:
1832 arg_clean = true;
1833 break;
1834
1835 case ARG_REMOVE:
1836 arg_remove = true;
1837 break;
1838
81815651
ZJS		 1839 case ARG_BOOT:
1840 arg_boot = true;
c4708f13
ZJS		 1841 break;
1842
fba6e687 1843 case ARG_PREFIX:
7bc040fa 1844 if (strv_push(&arg_include_prefixes, optarg) < 0)
a2aced4a 1845 return log_oom();
fba6e687
LP		 1846 break;
1847
5c795114 1848 case ARG_EXCLUDE_PREFIX:
7bc040fa 1849 if (strv_push(&arg_exclude_prefixes, optarg) < 0)
5c795114
DR		 1850 return log_oom();
1851 break;
1852
cf9a4abd 1853 case ARG_ROOT:
753615e8 1854 free(arg_root);
cf9a4abd
MM		 1855 arg_root = path_make_absolute_cwd(optarg);
1856 if (!arg_root)
1857 return log_oom();
753615e8 1858
cf9a4abd
MM		 1859 path_kill_slashes(arg_root);
1860 break;
1861
3b63d2d3
LP		 1862 case '?':
1863 return -EINVAL;
1864
1865 default:
eb9da376 1866 assert_not_reached("Unhandled option");
3b63d2d3 1867 }
3b63d2d3
LP		 1868
1869 if (!arg_clean && !arg_create && !arg_remove) {
35b8ca3a 1870 log_error("You need to specify at least one of --clean, --create or --remove.");
3b63d2d3
LP		 1871 return -EINVAL;
1872 }
1873
1874 return 1;
1875}
1876
fba6e687 1877static int read_config_file(const char *fn, bool ignore_enoent) {
1731e34a
LP		 1878 _cleanup_fclose_ FILE *f = NULL;
1879 char line[LINE_MAX];
78a92a5a 1880 Iterator iterator;
1731e34a 1881 unsigned v = 0;
78a92a5a 1882 Item *i;
1731e34a 1883 int r;
fba6e687
LP		 1884
1885 assert(fn);
1886
cf9a4abd 1887 r = search_and_fopen_nulstr(fn, "re", arg_root, conf_file_dirs, &f);
fabe5c0e 1888 if (r < 0) {
582deb84
ZJS		 1889 if (ignore_enoent && r == -ENOENT) {
1890 log_debug_errno(r, "Failed to open \"%s\": %m", fn);
fba6e687 1891 return 0;
582deb84 1892 }
fba6e687 1893
8d3d7072 1894 return log_error_errno(r, "Failed to open '%s', ignoring: %m", fn);
fba6e687 1895 }
582deb84 1896 log_debug("Reading config file \"%s\".", fn);
fba6e687 1897
1731e34a
LP		 1898 FOREACH_LINE(line, f, break) {
1899 char *l;
fba6e687
LP		 1900 int k;
1901
fba6e687
LP		 1902 v++;
1903
1904 l = strstrip(line);
1905 if (*l == '#' || *l == 0)
1906 continue;
1907
1731e34a
LP		 1908 k = parse_line(fn, v, l);
1909 if (k < 0 && r == 0)
1910 r = k;
fba6e687
LP		 1911 }
1912
78a92a5a
MS		 1913 /* we have to determine age parameter for each entry of type X */
1914 HASHMAP_FOREACH(i, globs, iterator) {
1915 Iterator iter;
1916 Item *j, *candidate_item = NULL;
1917
1918 if (i->type != IGNORE_DIRECTORY_PATH)
1919 continue;
1920
1921 HASHMAP_FOREACH(j, items, iter) {
d7b8eec7 1922 if (j->type != CREATE_DIRECTORY && j->type != TRUNCATE_DIRECTORY && j->type != CREATE_SUBVOLUME)
78a92a5a
MS		 1923 continue;
1924
1925 if (path_equal(j->path, i->path)) {
1926 candidate_item = j;
1927 break;
1928 }
1929
1930 if ((!candidate_item && path_startswith(i->path, j->path)) ||
1931 (candidate_item && path_startswith(j->path, candidate_item->path) && (fnmatch(i->path, j->path, FNM_PATHNAME | FNM_PERIOD) == 0)))
1932 candidate_item = j;
1933 }
1934
9ed2a35e 1935 if (candidate_item && candidate_item->age_set) {
78a92a5a
MS		 1936 i->age = candidate_item->age;
1937 i->age_set = true;
1938 }
1939 }
1940
fba6e687 1941 if (ferror(f)) {
56f64d95 1942 log_error_errno(errno, "Failed to read from file %s: %m", fn);
fba6e687
LP		 1943 if (r == 0)
1944 r = -EIO;
1945 }
1946
fba6e687
LP		 1947 return r;
1948}
1949
5008d581 1950int main(int argc, char *argv[]) {
fabe5c0e 1951 int r, k;
3f93da98 1952 ItemArray *a;
3b63d2d3
LP		 1953 Iterator iterator;
1954
fdcad0c2
LP		 1955 r = parse_argv(argc, argv);
1956 if (r <= 0)
753615e8 1957 goto finish;
5008d581 1958
eb0ca9eb 1959 log_set_target(LOG_TARGET_AUTO);
5008d581
LP		 1960 log_parse_environment();
1961 log_open();
1962
4c12626c
LP		 1963 umask(0022);
1964
cc56fafe 1965 mac_selinux_init(NULL);
5008d581 1966
d5099efc
MS		 1967 items = hashmap_new(&string_hash_ops);
1968 globs = hashmap_new(&string_hash_ops);
b8bb3e8f
LP		 1969
1970 if (!items || !globs) {
fabe5c0e 1971 r = log_oom();
3b63d2d3
LP		 1972 goto finish;
1973 }
1974
fabe5c0e 1975 r = 0;
5008d581 1976
fba6e687
LP		 1977 if (optind < argc) {
1978 int j;
5008d581 1979
9125670f 1980 for (j = optind; j < argc; j++) {
fabe5c0e
LP		 1981 k = read_config_file(argv[j], false);
1982 if (k < 0 && r == 0)
1983 r = k;
9125670f 1984 }
5008d581 1985
fba6e687 1986 } else {
fabe5c0e
LP		 1987 _cleanup_strv_free_ char **files = NULL;
1988 char **f;
5008d581 1989
cf9a4abd 1990 r = conf_files_list_nulstr(&files, ".conf", arg_root, conf_file_dirs);
44143309 1991 if (r < 0) {
da927ba9 1992 log_error_errno(r, "Failed to enumerate tmpfiles.d files: %m");
44143309
KS		 1993 goto finish;
1994 }
3b63d2d3 1995
772f8371 1996 STRV_FOREACH(f, files) {
fabe5c0e
LP		 1997 k = read_config_file(*f, true);
1998 if (k < 0 && r == 0)
1999 r = k;
5008d581 2000 }
772f8371 2001 }
5008d581 2002
3f93da98
ZJS		 2003 HASHMAP_FOREACH(a, globs, iterator) {
2004 k = process_item_array(a);
1db50423
ZJS		 2005 if (k < 0 && r == 0)
2006 r = k;
2007 }
b8bb3e8f 2008
3f93da98
ZJS		 2009 HASHMAP_FOREACH(a, items, iterator) {
2010 k = process_item_array(a);
1db50423
ZJS		 2011 if (k < 0 && r == 0)
2012 r = k;
2013 }
3b63d2d3 2014
5008d581 2015finish:
3f93da98
ZJS		 2016 while ((a = hashmap_steal_first(items)))
2017 item_array_free(a);
3b63d2d3 2018
3f93da98
ZJS		 2019 while ((a = hashmap_steal_first(globs)))
2020 item_array_free(a);
17b90525 2021
3b63d2d3 2022 hashmap_free(items);
b8bb3e8f 2023 hashmap_free(globs);
5008d581 2024
7bc040fa
LP		 2025 free(arg_include_prefixes);
2026 free(arg_exclude_prefixes);
cf9a4abd 2027 free(arg_root);
a2aced4a 2028
17b90525
LP		 2029 set_free_free(unix_sockets);
2030
cc56fafe 2031 mac_selinux_finish();
29003cff 2032
fabe5c0e 2033 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
5008d581 2034}
Unnamed repository; edit this file 'description' to name the repository.