tmpfiles: move exclamation mark into right place

[elogind.git] / src / tmpfiles / tmpfiles.c

diff --git a/src/tmpfiles/tmpfiles.c b/src/tmpfiles/tmpfiles.c
index 6e0c093a82c58174ccfeb44efad79e69e32d96e2..7da94ed57b80dc5a1650184e10663f8daf8de24e 100644 (file)
--- a/src/tmpfiles/tmpfiles.c
+++ b/src/tmpfiles/tmpfiles.c
@@ -38,15 +38,18 @@
 #include <sys/param.h>
 #include <glob.h>
 #include <fnmatch.h>
 #include <sys/param.h>
 #include <glob.h>
 #include <fnmatch.h>

+#include <sys/capability.h>

 
 #include "log.h"
 #include "util.h"
 
 #include "log.h"
 #include "util.h"

+#include "macro.h"

 #include "mkdir.h"
 #include "path-util.h"
 #include "strv.h"
 #include "label.h"
 #include "set.h"
 #include "conf-files.h"
 #include "mkdir.h"
 #include "path-util.h"
 #include "strv.h"
 #include "label.h"
 #include "set.h"
 #include "conf-files.h"

+#include "capability.h"

 
 /* This reads all files listed in /etc/tmpfiles.d/?*.conf and creates
  * them in the file system. This is intended to be used to create
 
 /* This reads all files listed in /etc/tmpfiles.d/?*.conf and creates
  * them in the file system. This is intended to be used to create


@@ -67,6 +70,7 @@ typedef enum ItemType {
 
         /* These ones take globs */
         IGNORE_PATH = 'x',
 
         /* These ones take globs */
         IGNORE_PATH = 'x',

+        IGNORE_DIRECTORY_PATH = 'X',

         REMOVE_PATH = 'r',
         RECURSIVE_REMOVE_PATH = 'R',
         RELABEL_PATH = 'z',
         REMOVE_PATH = 'r',
         RECURSIVE_REMOVE_PATH = 'R',
         RELABEL_PATH = 'z',


@@ -89,6 +93,8 @@ typedef struct Item {
         bool gid_set:1;
         bool mode_set:1;
         bool age_set:1;
         bool gid_set:1;
         bool mode_set:1;
         bool age_set:1;

+
+        bool keep_first_level:1;

 } Item;
 
 static Hashmap *items = NULL, *globs = NULL;
 } Item;
 
 static Hashmap *items = NULL, *globs = NULL;


@@ -100,18 +106,20 @@ static bool arg_remove = false;
 
 static const char *arg_prefix = NULL;
 
 
 static const char *arg_prefix = NULL;
 

-static const char *conf_file_dirs[] = {
-        "/etc/tmpfiles.d",
-        "/run/tmpfiles.d",
-        "/usr/local/lib/tmpfiles.d",
-        "/usr/lib/tmpfiles.d",
-        NULL
-};
+static const char conf_file_dirs[] =
+        "/etc/tmpfiles.d\0"
+        "/run/tmpfiles.d\0"
+        "/usr/local/lib/tmpfiles.d\0"
+        "/usr/lib/tmpfiles.d\0"
+#ifdef HAVE_SPLIT_USR
+        "/lib/tmpfiles.d\0"
+#endif
+        ;

 
 #define MAX_DEPTH 256
 
 static bool needs_glob(ItemType t) {
 
 #define MAX_DEPTH 256
 
 static bool needs_glob(ItemType t) {

-        return t == IGNORE_PATH || t == REMOVE_PATH || t == RECURSIVE_REMOVE_PATH || t == RELABEL_PATH || t == RECURSIVE_RELABEL_PATH;
+        return t == IGNORE_PATH || t == IGNORE_DIRECTORY_PATH || t == REMOVE_PATH || t == RECURSIVE_REMOVE_PATH || t == RELABEL_PATH || t == RECURSIVE_RELABEL_PATH;

 }
 
 static struct Item* find_glob(Hashmap *h, const char *match) {
 }
 
 static struct Item* find_glob(Hashmap *h, const char *match) {


@@ -210,13 +218,15 @@ static bool unix_socket_alive(const char *fn) {
 }
 
 static int dir_cleanup(
 }
 
 static int dir_cleanup(

+                Item *i,

                 const char *p,
                 DIR *d,
                 const struct stat *ds,
                 usec_t cutoff,
                 dev_t rootdev,
                 bool mountpoint,
                 const char *p,
                 DIR *d,
                 const struct stat *ds,
                 usec_t cutoff,
                 dev_t rootdev,
                 bool mountpoint,

-                int maxdepth)
+                int maxdepth,
+                bool keep_this_level)

 {
         struct dirent *dent;
         struct timespec times[2];
 {
         struct dirent *dent;
         struct timespec times[2];


@@ -254,8 +264,7 @@ static int dir_cleanup(
                 sub_path = NULL;
 
                 if (asprintf(&sub_path, "%s/%s", p, dent->d_name) < 0) {
                 sub_path = NULL;
 
                 if (asprintf(&sub_path, "%s/%s", p, dent->d_name) < 0) {

-                        log_error("Out of memory");
-                        r = -ENOMEM;
+                        r = log_oom();

                         goto finish;
                 }
 
                         goto finish;
                 }
 


@@ -289,25 +298,37 @@ static int dir_cleanup(
                                         continue;
                                 }
 
                                         continue;
                                 }
 

-                                q = dir_cleanup(sub_path, sub_dir, &s, cutoff, rootdev, false, maxdepth-1);
+                                q = dir_cleanup(i, sub_path, sub_dir, &s, cutoff, rootdev, false, maxdepth-1, false);

                                 closedir(sub_dir);
 
                                 if (q < 0)
                                         r = q;
                         }
 
                                 closedir(sub_dir);
 
                                 if (q < 0)
                                         r = q;
                         }
 

+                        /* Note: if you are wondering why we don't
+                         * support the sticky bit for excluding
+                         * directories from cleaning like we do it for
+                         * other file system objects: well, the sticky
+                         * bit already has a meaning for directories,
+                         * so we don't want to overload that. */
+
+                        if (keep_this_level)
+                                continue;
+

                         /* Ignore ctime, we change it when deleting */
                         age = MAX(timespec_load(&s.st_mtim),
                                   timespec_load(&s.st_atim));
                         if (age >= cutoff)
                                 continue;
 
                         /* Ignore ctime, we change it when deleting */
                         age = MAX(timespec_load(&s.st_mtim),
                                   timespec_load(&s.st_atim));
                         if (age >= cutoff)
                                 continue;
 

-                        log_debug("rmdir '%s'\n", sub_path);
+                        if (i->type != IGNORE_DIRECTORY_PATH || !streq(dent->d_name, p)) {
+                                log_debug("rmdir '%s'\n", sub_path);

 
 

-                        if (unlinkat(dirfd(d), dent->d_name, AT_REMOVEDIR) < 0) {
-                                if (errno != ENOENT && errno != ENOTEMPTY) {
-                                        log_error("rmdir(%s): %m", sub_path);
-                                        r = -errno;
+                                if (unlinkat(dirfd(d), dent->d_name, AT_REMOVEDIR) < 0) {
+                                        if (errno != ENOENT && errno != ENOTEMPTY) {
+                                                log_error("rmdir(%s): %m", sub_path);
+                                                r = -errno;
+                                        }

                                 }
                         }
 
                                 }
                         }
 


@@ -337,6 +358,11 @@ static int dir_cleanup(
                         if (S_ISCHR(s.st_mode) || S_ISBLK(s.st_mode))
                                 continue;
 
                         if (S_ISCHR(s.st_mode) || S_ISBLK(s.st_mode))
                                 continue;
 

+                        /* Keep files on this level around if this is
+                         * requested */
+                        if (keep_this_level)
+                                continue;
+

                         age = MAX3(timespec_load(&s.st_mtim),
                                    timespec_load(&s.st_atim),
                                    timespec_load(&s.st_ctim));
                         age = MAX3(timespec_load(&s.st_mtim),
                                    timespec_load(&s.st_atim),
                                    timespec_load(&s.st_ctim));


@@ -372,86 +398,88 @@ finish:
         return r;
 }
 
         return r;
 }
 

-static int clean_item(Item *i) {
-        DIR *d;
-        struct stat s, ps;
-        bool mountpoint;
-        int r;
-        usec_t cutoff, n;
+static int item_set_perms(Item *i, const char *path) {
+        /* not using i->path directly because it may be a glob */
+        if (i->mode_set)
+                if (chmod(path, i->mode) < 0) {
+                        log_error("chmod(%s) failed: %m", path);
+                        return -errno;
+                }

 
 

-        assert(i);
+        if (i->uid_set || i->gid_set)
+                if (chown(path,
+                          i->uid_set ? i->uid : (uid_t) -1,
+                          i->gid_set ? i->gid : (gid_t) -1) < 0) {

 
 

-        if (i->type != CREATE_DIRECTORY &&
-            i->type != TRUNCATE_DIRECTORY &&
-            i->type != IGNORE_PATH)
-                return 0;
+                        log_error("chown(%s) failed: %m", path);
+                        return -errno;
+                }

 
 

-        if (!i->age_set || i->age <= 0)
-                return 0;
+        return label_fix(path, false, false);
+}

 
 

-        n = now(CLOCK_REALTIME);
-        if (n < i->age)
-                return 0;
+static int write_one_file(Item *i, const char *path) {
+        int r, e, fd, flags;
+        struct stat st;
+        mode_t u;

 
 

-        cutoff = n - i->age;
+        flags = i->type == CREATE_FILE ? O_CREAT|O_APPEND :
+                i->type == TRUNCATE_FILE ? O_CREAT|O_TRUNC : 0;

 
 

-        d = opendir(i->path);
-        if (!d) {
-                if (errno == ENOENT)
+        u = umask(0);
+        label_context_set(path, S_IFREG);
+        fd = open(path, flags|O_NDELAY|O_CLOEXEC|O_WRONLY|O_NOCTTY|O_NOFOLLOW, i->mode);
+        e = errno;
+        label_context_clear();
+        umask(u);
+        errno = e;
+
+        if (fd < 0) {
+                if (i->type == WRITE_FILE && errno == ENOENT)

                         return 0;
 
                         return 0;
 

-                log_error("Failed to open directory %s: %m", i->path);
+                log_error("Failed to create file %s: %m", path);

                 return -errno;
         }
 
                 return -errno;
         }
 

-        if (fstat(dirfd(d), &s) < 0) {
-                log_error("stat(%s) failed: %m", i->path);
-                r = -errno;
-                goto finish;
-        }
+        if (i->argument) {
+                ssize_t n;
+                size_t l;
+                _cleanup_free_ char *unescaped;

 
 

-        if (!S_ISDIR(s.st_mode)) {
-                log_error("%s is not a directory.", i->path);
-                r = -ENOTDIR;
-                goto finish;
-        }
-
-        if (fstatat(dirfd(d), "..", &ps, AT_SYMLINK_NOFOLLOW) != 0) {
-                log_error("stat(%s/..) failed: %m", i->path);
-                r = -errno;
-                goto finish;
-        }
-
-        mountpoint = s.st_dev != ps.st_dev ||
-                     (s.st_dev == ps.st_dev && s.st_ino == ps.st_ino);
+                unescaped = cunescape(i->argument);
+                if (unescaped == NULL) {
+                        close_nointr_nofail(fd);
+                        return log_oom();
+                }

 
 

-        r = dir_cleanup(i->path, d, &s, cutoff, s.st_dev, mountpoint, MAX_DEPTH);
+                l = strlen(unescaped);
+                n = write(fd, unescaped, l);

 
 

-finish:
-        if (d)
-                closedir(d);
+                if (n < 0 || (size_t) n < l) {
+                        log_error("Failed to write file %s: %s", path, n < 0 ? strerror(-n) : "Short write");
+                        close_nointr_nofail(fd);
+                        return n < 0 ? n : -EIO;
+                }
+        }

 
 

-        return r;
-}
+        close_nointr_nofail(fd);

 
 

-static int item_set_perms(Item *i, const char *path) {
-        /* not using i->path directly because it may be a glob */
-        if (i->mode_set)
-                if (chmod(path, i->mode) < 0) {
-                        log_error("chmod(%s) failed: %m", path);
-                        return -errno;
-                }
+        if (stat(path, &st) < 0) {
+                log_error("stat(%s) failed: %m", path);
+                return -errno;
+        }

 
 

-        if (i->uid_set || i->gid_set)
-                if (chown(path,
-                          i->uid_set ? i->uid : (uid_t) -1,
-                          i->gid_set ? i->gid : (gid_t) -1) < 0) {
+        if (!S_ISREG(st.st_mode)) {
+                log_error("%s is not a file.", path);
+                return -EEXIST;
+        }

 
 

-                        log_error("chown(%s) failed: %m", path);
-                        return -errno;
-                }
+        r = item_set_perms(i, path);
+        if (r < 0)
+                return r;

 
 

-        return label_fix(path, false);
+        return 0;

 }
 
 static int recursive_relabel_children(Item *i, const char *path) {
 }
 
 static int recursive_relabel_children(Item *i, const char *path) {


@@ -466,12 +494,13 @@ static int recursive_relabel_children(Item *i, const char *path) {
                 return errno == ENOENT ? 0 : -errno;
 
         for (;;) {
                 return errno == ENOENT ? 0 : -errno;
 
         for (;;) {

-                struct dirent buf, *de;
+                struct dirent *de;
+                union dirent_storage buf;

                 bool is_dir;
                 int r;
                 char *entry_path;
 
                 bool is_dir;
                 int r;
                 char *entry_path;
 

-                r = readdir_r(d, &buf, &de);
+                r = readdir_r(d, &buf.de, &de);

                 if (r != 0) {
                         if (ret == 0)
                                 ret = -r;
                 if (r != 0) {
                         if (ret == 0)
                                 ret = -r;


@@ -581,80 +610,23 @@ static int create_item(Item *i) {
         switch (i->type) {
 
         case IGNORE_PATH:
         switch (i->type) {
 
         case IGNORE_PATH:

+        case IGNORE_DIRECTORY_PATH:

         case REMOVE_PATH:
         case RECURSIVE_REMOVE_PATH:
                 return 0;
 
         case CREATE_FILE:
         case TRUNCATE_FILE:
         case REMOVE_PATH:
         case RECURSIVE_REMOVE_PATH:
                 return 0;
 
         case CREATE_FILE:
         case TRUNCATE_FILE:

-        case WRITE_FILE: {
-                int fd, flags;
-
-                flags = i->type == CREATE_FILE ? O_CREAT|O_APPEND :
-                        i->type == TRUNCATE_FILE ? O_CREAT|O_TRUNC : 0;
-
-                u = umask(0);
-                label_context_set(i->path, S_IFREG);
-                fd = open(i->path, flags|O_NDELAY|O_CLOEXEC|O_WRONLY|O_NOCTTY|O_NOFOLLOW, i->mode);
-                e = errno;
-                label_context_clear();
-                umask(u);
-                errno = e;
-
-                if (fd < 0) {
-                        if (i->type == WRITE_FILE && errno == ENOENT)
-                                break;
-
-                        log_error("Failed to create file %s: %m", i->path);
-                        return -errno;
-                }
-
-                if (i->argument) {
-                        ssize_t n;
-                        size_t l;
-                        struct iovec iovec[2];
-                        static const char new_line = '\n';
-
-                        l = strlen(i->argument);
-
-                        zero(iovec);
-                        iovec[0].iov_base = i->argument;
-                        iovec[0].iov_len = l;
-
-                        iovec[1].iov_base = (void*) &new_line;
-                        iovec[1].iov_len = 1;
-
-                        n = writev(fd, iovec, 2);
-
-                        /* It's OK if we don't write the trailing
-                         * newline, hence we check for l, instead of
-                         * l+1 here. Files in /sys often refuse
-                         * writing of the trailing newline. */
-                        if (n < 0 || (size_t) n < l) {
-                                log_error("Failed to write file %s: %s", i->path, n < 0 ? strerror(-n) : "Short write");
-                                close_nointr_nofail(fd);
-                                return n < 0 ? n : -EIO;
-                        }
-                }
-
-                close_nointr_nofail(fd);
-
-                if (stat(i->path, &st) < 0) {
-                        log_error("stat(%s) failed: %m", i->path);
-                        return -errno;
-                }
-
-                if (!S_ISREG(st.st_mode)) {
-                        log_error("%s is not a file.", i->path);
-                        return -EEXIST;
-                }
-
-                r = item_set_perms(i, i->path);
+                r = write_one_file(i, i->path);
+                if (r < 0)
+                        return r;
+                break;
+        case WRITE_FILE:
+                r = glob_item(i, write_one_file);

                 if (r < 0)
                         return r;
 
                 break;
                 if (r < 0)
                         return r;
 
                 break;

-        }

 
         case TRUNCATE_DIRECTORY:
         case CREATE_DIRECTORY:
 
         case TRUNCATE_DIRECTORY:
         case CREATE_DIRECTORY:


@@ -744,7 +716,19 @@ static int create_item(Item *i) {
 
         case CREATE_BLOCK_DEVICE:
         case CREATE_CHAR_DEVICE: {
 
         case CREATE_BLOCK_DEVICE:
         case CREATE_CHAR_DEVICE: {

-                mode_t file_type = (i->type == CREATE_BLOCK_DEVICE ? S_IFBLK : S_IFCHR);
+                mode_t file_type;
+
+                if (have_effective_cap(CAP_MKNOD) == 0) {
+                        /* In a container we lack CAP_MKNOD. We
+                        shouldnt attempt to create the device node in
+                        that case to avoid noise, and we don't support
+                        virtualized devices in containers anyway. */
+
+                        log_debug("We lack CAP_MKNOD, skipping creation of device node %s.", i->path);
+                        return 0;
+                }
+
+                file_type = (i->type == CREATE_BLOCK_DEVICE ? S_IFBLK : S_IFCHR);

 
                 u = umask(0);
                 label_context_set(i->path, file_type);
 
                 u = umask(0);
                 label_context_set(i->path, file_type);


@@ -810,6 +794,7 @@ static int remove_item_instance(Item *i, const char *instance) {
         case CREATE_BLOCK_DEVICE:
         case CREATE_CHAR_DEVICE:
         case IGNORE_PATH:
         case CREATE_BLOCK_DEVICE:
         case CREATE_CHAR_DEVICE:
         case IGNORE_PATH:

+        case IGNORE_DIRECTORY_PATH:

         case RELABEL_PATH:
         case RECURSIVE_RELABEL_PATH:
         case WRITE_FILE:
         case RELABEL_PATH:
         case RECURSIVE_RELABEL_PATH:
         case WRITE_FILE:


@@ -825,7 +810,9 @@ static int remove_item_instance(Item *i, const char *instance) {
 
         case TRUNCATE_DIRECTORY:
         case RECURSIVE_REMOVE_PATH:
 
         case TRUNCATE_DIRECTORY:
         case RECURSIVE_REMOVE_PATH:

-                r = rm_rf(instance, false, i->type == RECURSIVE_REMOVE_PATH, false);
+                /* FIXME: we probably should use dir_cleanup() here
+                 * instead of rm_rf() so that 'x' is honoured. */
+                r = rm_rf_dangerous(instance, false, i->type == RECURSIVE_REMOVE_PATH, false);

                 if (r < 0 && r != -ENOENT) {
                         log_error("rm_rf(%s): %s", instance, strerror(-r));
                         return r;
                 if (r < 0 && r != -ENOENT) {
                         log_error("rm_rf(%s): %s", instance, strerror(-r));
                         return r;


@@ -852,6 +839,7 @@ static int remove_item(Item *i) {
         case CREATE_CHAR_DEVICE:
         case CREATE_BLOCK_DEVICE:
         case IGNORE_PATH:
         case CREATE_CHAR_DEVICE:
         case CREATE_BLOCK_DEVICE:
         case IGNORE_PATH:

+        case IGNORE_DIRECTORY_PATH:

         case RELABEL_PATH:
         case RECURSIVE_RELABEL_PATH:
         case WRITE_FILE:
         case RELABEL_PATH:
         case RECURSIVE_RELABEL_PATH:
         case WRITE_FILE:


@@ -867,6 +855,84 @@ static int remove_item(Item *i) {
         return r;
 }
 
         return r;
 }
 

+static int clean_item_instance(Item *i, const char* instance) {
+        DIR *d;
+        struct stat s, ps;
+        bool mountpoint;
+        int r;
+        usec_t cutoff, n;
+
+        assert(i);
+
+        if (!i->age_set)
+                return 0;
+
+        n = now(CLOCK_REALTIME);
+        if (n < i->age)
+                return 0;
+
+        cutoff = n - i->age;
+
+        d = opendir(instance);
+        if (!d) {
+                if (errno == ENOENT || errno == ENOTDIR)
+                        return 0;
+
+                log_error("Failed to open directory %s: %m", i->path);
+                return -errno;
+        }
+
+        if (fstat(dirfd(d), &s) < 0) {
+                log_error("stat(%s) failed: %m", i->path);
+                r = -errno;
+                goto finish;
+        }
+
+        if (!S_ISDIR(s.st_mode)) {
+                log_error("%s is not a directory.", i->path);
+                r = -ENOTDIR;
+                goto finish;
+        }
+
+        if (fstatat(dirfd(d), "..", &ps, AT_SYMLINK_NOFOLLOW) != 0) {
+                log_error("stat(%s/..) failed: %m", i->path);
+                r = -errno;
+                goto finish;
+        }
+
+        mountpoint = s.st_dev != ps.st_dev ||
+                     (s.st_dev == ps.st_dev && s.st_ino == ps.st_ino);
+
+        r = dir_cleanup(i, instance, d, &s, cutoff, s.st_dev, mountpoint, MAX_DEPTH, i->keep_first_level);
+
+finish:
+        if (d)
+                closedir(d);
+
+        return r;
+}
+
+static int clean_item(Item *i) {
+        int r = 0;
+
+        assert(i);
+
+        switch (i->type) {
+        case CREATE_DIRECTORY:
+        case TRUNCATE_DIRECTORY:
+        case IGNORE_PATH:
+                clean_item_instance(i, i->path);
+                break;
+        case IGNORE_DIRECTORY_PATH:
+                r = glob_item(i, clean_item_instance);
+                break;
+        default:
+                break;
+        }
+
+        return r;
+}
+

 static int process_item(Item *i) {
         int r, q, p;
 
 static int process_item(Item *i) {
         int r, q, p;
 


@@ -946,10 +1012,8 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
         assert(buffer);
 
         i = new0(Item, 1);
         assert(buffer);
 
         i = new0(Item, 1);

-        if (!i) {
-                log_error("Out of memory");
-                return -ENOMEM;
-        }
+        if (!i)
+                return log_oom();

 
         if (sscanf(buffer,
                    "%c "
 
         if (sscanf(buffer,
                    "%c "


@@ -975,10 +1039,8 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
                 n += strspn(buffer+n, WHITESPACE);
                 if (buffer[n] != 0 && (buffer[n] != '-' || buffer[n+1] != 0)) {
                         i->argument = unquote(buffer+n, "\"");
                 n += strspn(buffer+n, WHITESPACE);
                 if (buffer[n] != 0 && (buffer[n] != '-' || buffer[n+1] != 0)) {
                         i->argument = unquote(buffer+n, "\"");

-                        if (!i->argument) {
-                                log_error("Out of memory");
-                                return -ENOMEM;
-                        }
+                        if (!i->argument)
+                                return log_oom();

                 }
         }
 
                 }
         }
 


@@ -990,6 +1052,7 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
         case TRUNCATE_DIRECTORY:
         case CREATE_FIFO:
         case IGNORE_PATH:
         case TRUNCATE_DIRECTORY:
         case CREATE_FIFO:
         case IGNORE_PATH:

+        case IGNORE_DIRECTORY_PATH:

         case REMOVE_PATH:
         case RECURSIVE_REMOVE_PATH:
         case RELABEL_PATH:
         case REMOVE_PATH:
         case RECURSIVE_REMOVE_PATH:
         case RELABEL_PATH:


@@ -1056,7 +1119,7 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
         if (user && !streq(user, "-")) {
                 const char *u = user;
 
         if (user && !streq(user, "-")) {
                 const char *u = user;
 

-                r = get_user_creds(&u, &i->uid, NULL, NULL);
+                r = get_user_creds(&u, &i->uid, NULL, NULL, NULL);

                 if (r < 0) {
                         log_error("[%s:%u] Unknown user '%s'.", fname, line, user);
                         goto finish;
                 if (r < 0) {
                         log_error("[%s:%u] Unknown user '%s'.", fname, line, user);
                         goto finish;


@@ -1094,7 +1157,14 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
                         i->type == TRUNCATE_DIRECTORY ? 0755 : 0644;
 
         if (age && !streq(age, "-")) {
                         i->type == TRUNCATE_DIRECTORY ? 0755 : 0644;
 
         if (age && !streq(age, "-")) {

-                if (parse_usec(age, &i->age) < 0) {
+                const char *a = age;
+
+                if (*a == '~') {
+                        i->keep_first_level = true;
+                        a++;
+                }
+
+                if (parse_usec(a, &i->age) < 0) {

                         log_error("[%s:%u] Invalid age '%s'.", fname, line, age);
                         r = -EBADMSG;
                         goto finish;
                         log_error("[%s:%u] Invalid age '%s'.", fname, line, age);
                         r = -EBADMSG;
                         goto finish;


@@ -1218,18 +1288,19 @@ static int parse_argv(int argc, char *argv[]) {
 static int read_config_file(const char *fn, bool ignore_enoent) {
         FILE *f;
         unsigned v = 0;
 static int read_config_file(const char *fn, bool ignore_enoent) {
         FILE *f;
         unsigned v = 0;

-        int r = 0;
+        int r;
+        Iterator iterator;
+        Item *i;

 
         assert(fn);
 
 
         assert(fn);
 

-        f = fopen(fn, "re");
-        if (!f) {
-
-                if (ignore_enoent && errno == ENOENT)
+        r = search_and_fopen_nulstr(fn, "re", conf_file_dirs, &f);
+        if (r < 0) {
+                if (ignore_enoent && r == -ENOENT)

                         return 0;
 
                         return 0;
 

-                log_error("Failed to open %s: %m", fn);
-                return -errno;
+                log_error("Failed to open '%s', ignoring: %s", fn, strerror(-r));
+                return r;

         }
 
         log_debug("apply: %s\n", fn);
         }
 
         log_debug("apply: %s\n", fn);


@@ -1251,43 +1322,47 @@ static int read_config_file(const char *fn, bool ignore_enoent) {
                                 r = k;
         }
 
                                 r = k;
         }
 

-        if (ferror(f)) {
-                log_error("Failed to read from file %s: %m", fn);
-                if (r == 0)
-                        r = -EIO;
-        }
+        /* we have to determine age parameter for each entry of type X */
+        HASHMAP_FOREACH(i, globs, iterator) {
+                Iterator iter;
+                Item *j, *candidate_item = NULL;

 
 

-        fclose(f);
-
-        return r;
-}
+                if (i->type != IGNORE_DIRECTORY_PATH)
+                        continue;

 
 

-static char *resolve_fragment(const char *fragment, const char **search_paths) {
-        const char **p;
-        char *resolved_path;
+                HASHMAP_FOREACH(j, items, iter) {
+                        if (j->type != CREATE_DIRECTORY && j->type != TRUNCATE_DIRECTORY)
+                                continue;

 
 

-        if (is_path(fragment))
-                return strdup(fragment);
+                        if (path_equal(j->path, i->path)) {
+                                candidate_item = j;
+                                break;
+                        }

 
 

-        STRV_FOREACH(p, search_paths) {
-                resolved_path = join(*p, "/", fragment, NULL);
-                if (resolved_path == NULL) {
-                        log_error("Out of memory");
-                        return NULL;
+                        if ((!candidate_item && path_startswith(i->path, j->path)) ||
+                            (candidate_item && path_startswith(j->path, candidate_item->path) && (fnmatch(i->path, j->path, FNM_PATHNAME | FNM_PERIOD) == 0)))
+                                candidate_item = j;

                 }
 
                 }
 

-                if (access(resolved_path, F_OK) == 0)
-                        return resolved_path;
+                if (candidate_item) {
+                        i->age = candidate_item->age;
+                        i->age_set = true;
+                }
+        }

 
 

-                free(resolved_path);
+        if (ferror(f)) {
+                log_error("Failed to read from file %s: %m", fn);
+                if (r == 0)
+                        r = -EIO;

         }
 
         }
 

-        errno = ENOENT;
-        return NULL;
+        fclose(f);
+
+        return r;

 }
 
 int main(int argc, char *argv[]) {
 }
 
 int main(int argc, char *argv[]) {

-        int r;
+        int r, k;

         Item *i;
         Iterator iterator;
 
         Item *i;
         Iterator iterator;
 


@@ -1307,47 +1382,36 @@ int main(int argc, char *argv[]) {
         globs = hashmap_new(string_hash_func, string_compare_func);
 
         if (!items || !globs) {
         globs = hashmap_new(string_hash_func, string_compare_func);
 
         if (!items || !globs) {

-                log_error("Out of memory");
-                r = EXIT_FAILURE;
+                r = log_oom();

                 goto finish;
         }
 
                 goto finish;
         }
 

-        r = EXIT_SUCCESS;
+        r = 0;

 
         if (optind < argc) {
                 int j;
 
                 for (j = optind; j < argc; j++) {
 
         if (optind < argc) {
                 int j;
 
                 for (j = optind; j < argc; j++) {

-                        char *fragment;
-
-                        fragment = resolve_fragment(argv[j], conf_file_dirs);
-                        if (!fragment) {
-                                log_error("Failed to find a %s file: %m", argv[j]);
-                                r = EXIT_FAILURE;
-                                goto finish;
-                        }
-                        if (read_config_file(fragment, false) < 0)
-                                r = EXIT_FAILURE;
-                        free(fragment);
+                        k = read_config_file(argv[j], false);
+                        if (k < 0 && r == 0)
+                                r = k;

                 }
 
         } else {
                 }
 
         } else {

-                char **files, **f;
+                _cleanup_strv_free_ char **files = NULL;
+                char **f;

 
 

-                r = conf_files_list_strv(&files, ".conf",
-                                    (const char **)conf_file_dirs);
+                r = conf_files_list_nulstr(&files, ".conf", NULL, conf_file_dirs);

                 if (r < 0) {
                         log_error("Failed to enumerate tmpfiles.d files: %s", strerror(-r));
                 if (r < 0) {
                         log_error("Failed to enumerate tmpfiles.d files: %s", strerror(-r));

-                        r = EXIT_FAILURE;

                         goto finish;
                 }
 
                 STRV_FOREACH(f, files) {
                         goto finish;
                 }
 
                 STRV_FOREACH(f, files) {

-                        if (read_config_file(*f, true) < 0)
-                                r = EXIT_FAILURE;
+                        k = read_config_file(*f, true);
+                        if (k < 0 && r == 0)
+                                r = k;

                 }
                 }

-
-                strv_free(files);

         }
 
         HASHMAP_FOREACH(i, globs, iterator)
         }
 
         HASHMAP_FOREACH(i, globs, iterator)


@@ -1370,5 +1434,5 @@ finish:
 
         label_finish();
 
 
         label_finish();
 

-        return r;
+        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;

 }
 }