chiark / gitweb /
tmpfiles: add missing missing.h include
[elogind.git] / src / tmpfiles / tmpfiles.c
index e0b0e94..614644a 100644 (file)
 #include <sys/param.h>
 #include <glob.h>
 #include <fnmatch.h>
+#include <sys/capability.h>
 
 #include "log.h"
 #include "util.h"
+#include "macro.h"
+#include "missing.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
@@ -67,6 +71,7 @@ typedef enum ItemType {
 
         /* These ones take globs */
         IGNORE_PATH = 'x',
+        IGNORE_DIRECTORY_PATH = 'X',
         REMOVE_PATH = 'r',
         RECURSIVE_REMOVE_PATH = 'R',
         RELABEL_PATH = 'z',
@@ -102,18 +107,20 @@ static bool arg_remove = false;
 
 static const char *arg_prefix = NULL;
 
-static const char * const 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) {
-        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) {
@@ -128,7 +135,7 @@ static struct Item* find_glob(Hashmap *h, const char *match) {
 }
 
 static void load_unix_sockets(void) {
-        FILE *f = NULL;
+        FILE _cleanup_fclose_ *f = NULL;
         char line[LINE_MAX];
 
         if (unix_sockets)
@@ -188,15 +195,11 @@ static void load_unix_sockets(void) {
                 }
         }
 
-        fclose(f);
         return;
 
 fail:
         set_free_free(unix_sockets);
         unix_sockets = NULL;
-
-        if (f)
-                fclose(f);
 }
 
 static bool unix_socket_alive(const char *fn) {
@@ -211,7 +214,44 @@ static bool unix_socket_alive(const char *fn) {
         return true;
 }
 
+static int dir_is_mount_point(DIR *d, const char *subdir) {
+        struct file_handle *h;
+        int mount_id_parent, mount_id;
+        int r_p, r;
+
+        h = alloca(MAX_HANDLE_SZ);
+
+        h->handle_bytes = MAX_HANDLE_SZ;
+        r_p = name_to_handle_at(dirfd(d), ".", h, &mount_id_parent, 0);
+        if (r_p < 0)
+                r_p = -errno;
+
+        h->handle_bytes = MAX_HANDLE_SZ;
+        r = name_to_handle_at(dirfd(d), subdir, h, &mount_id, 0);
+        if (r < 0)
+                r = -errno;
+
+        /* got no handle; make no assumptions, return error */
+        if (r_p < 0 && r < 0)
+                return r_p;
+
+        /* got both handles; if they differ, it is a mount point */
+        if (r_p >= 0 && r >= 0)
+                return mount_id_parent != mount_id;
+
+        /* got only one handle; assume different mount points if one
+         * of both queries was not supported by the filesystem */
+        if (r_p == -ENOSYS || r_p == -ENOTSUP || r == -ENOSYS || r == -ENOTSUP)
+                return true;
+
+        /* return error */
+        if (r_p < 0)
+                return r_p;
+        return r;
+}
+
 static int dir_cleanup(
+                Item *i,
                 const char *p,
                 DIR *d,
                 const struct stat *ds,
@@ -224,12 +264,12 @@ static int dir_cleanup(
         struct dirent *dent;
         struct timespec times[2];
         bool deleted = false;
-        char *sub_path = NULL;
         int r = 0;
 
         while ((dent = readdir(d))) {
                 struct stat s;
                 usec_t age;
+                char _cleanup_free_ *sub_path = NULL;
 
                 if (streq(dent->d_name, ".") ||
                     streq(dent->d_name, ".."))
@@ -249,16 +289,18 @@ static int dir_cleanup(
                 if (s.st_dev != rootdev)
                         continue;
 
+                /* Try to detect bind mounts of the same filesystem instance; they
+                 * do not differ in device major/minors. This type of query is not
+                 * supported on all kernels or filesystem types though. */
+                if (S_ISDIR(s.st_mode) && dir_is_mount_point(d, dent->d_name) > 0)
+                        continue;
+
                 /* Do not delete read-only files owned by root */
                 if (s.st_uid == 0 && !(s.st_mode & S_IWUSR))
                         continue;
 
-                free(sub_path);
-                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;
                 }
 
@@ -279,7 +321,7 @@ static int dir_cleanup(
                         if (maxdepth <= 0)
                                 log_warning("Reached max depth on %s.", sub_path);
                         else {
-                                DIR *sub_dir;
+                                DIR _cleanup_closedir_ *sub_dir;
                                 int q;
 
                                 sub_dir = xopendirat(dirfd(d), dent->d_name, O_NOFOLLOW|O_NOATIME);
@@ -292,8 +334,7 @@ static int dir_cleanup(
                                         continue;
                                 }
 
-                                q = dir_cleanup(sub_path, sub_dir, &s, cutoff, rootdev, false, maxdepth-1, false);
-                                closedir(sub_dir);
+                                q = dir_cleanup(i, sub_path, sub_dir, &s, cutoff, rootdev, false, maxdepth-1, false);
 
                                 if (q < 0)
                                         r = q;
@@ -315,12 +356,14 @@ static int dir_cleanup(
                         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;
+                                        }
                                 }
                         }
 
@@ -385,95 +428,95 @@ finish:
                         log_error("utimensat(%s): %m", p);
         }
 
-        free(sub_path);
-
         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;
 
-                log_error("Failed to open directory %s: %m", i->path);
+                log_error("Failed to create file %s: %m", path);
                 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, i->keep_first_level);
+                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, false);
+        return 0;
 }
 
 static int recursive_relabel_children(Item *i, const char *path) {
-        DIR *d;
+        DIR _cleanup_closedir_ *d;
         int ret = 0;
 
         /* This returns the first error we run into, but nevertheless
@@ -484,12 +527,13 @@ static int recursive_relabel_children(Item *i, const char *path) {
                 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;
+                char _cleanup_free_ *entry_path = NULL;
 
-                r = readdir_r(d, &buf, &de);
+                r = readdir_r(d, &buf.de, &de);
                 if (r != 0) {
                         if (ret == 0)
                                 ret = -r;
@@ -514,7 +558,6 @@ static int recursive_relabel_children(Item *i, const char *path) {
                         if (lstat(entry_path, &st) < 0) {
                                 if (ret == 0 && errno != ENOENT)
                                         ret = -errno;
-                                free(entry_path);
                                 continue;
                         }
 
@@ -527,7 +570,6 @@ static int recursive_relabel_children(Item *i, const char *path) {
                 if (r < 0) {
                         if (ret == 0 && r != -ENOENT)
                                 ret = r;
-                        free(entry_path);
                         continue;
                 }
 
@@ -536,12 +578,8 @@ static int recursive_relabel_children(Item *i, const char *path) {
                         if (r < 0 && ret == 0)
                                 ret = r;
                 }
-
-                free(entry_path);
         }
 
-        closedir(d);
-
         return ret;
 }
 
@@ -599,80 +637,23 @@ static int create_item(Item *i) {
         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 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;
-        }
 
         case TRUNCATE_DIRECTORY:
         case CREATE_DIRECTORY:
@@ -762,7 +743,19 @@ static int create_item(Item *i) {
 
         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);
@@ -828,6 +821,7 @@ static int remove_item_instance(Item *i, const char *instance) {
         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:
@@ -845,7 +839,7 @@ static int remove_item_instance(Item *i, const char *instance) {
         case RECURSIVE_REMOVE_PATH:
                 /* FIXME: we probably should use dir_cleanup() here
                  * instead of rm_rf() so that 'x' is honoured. */
-                r = rm_rf(instance, false, i->type == RECURSIVE_REMOVE_PATH, false);
+                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;
@@ -872,6 +866,7 @@ static int remove_item(Item *i) {
         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:
@@ -887,6 +882,77 @@ static int remove_item(Item *i) {
         return r;
 }
 
+static int clean_item_instance(Item *i, const char* instance) {
+        DIR _cleanup_closedir_ *d = NULL;
+        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);
+                return -errno;
+        }
+
+        if (!S_ISDIR(s.st_mode)) {
+                log_error("%s is not a directory.", i->path);
+                return -ENOTDIR;
+        }
+
+        if (fstatat(dirfd(d), "..", &ps, AT_SYMLINK_NOFOLLOW) != 0) {
+                log_error("stat(%s/..) failed: %m", i->path);
+                return -errno;
+        }
+
+        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);
+        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;
 
@@ -956,7 +1022,8 @@ static bool item_equal(Item *a, Item *b) {
 
 static int parse_line(const char *fname, unsigned line, const char *buffer) {
         Item *i, *existing;
-        char *mode = NULL, *user = NULL, *group = NULL, *age = NULL;
+        char _cleanup_free_
+                *mode = NULL, *user = NULL, *group = NULL, *age = NULL;
         char type;
         Hashmap *h;
         int r, n = -1;
@@ -966,26 +1033,19 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
         assert(buffer);
 
         i = new0(Item, 1);
-        if (!i) {
-                log_error("Out of memory");
-                return -ENOMEM;
-        }
+        if (!i)
+                return log_oom();
 
-        if (sscanf(buffer,
-                   "%c "
-                   "%ms "
-                   "%ms "
-                   "%ms "
-                   "%ms "
-                   "%ms "
-                   "%n",
+        r = sscanf(buffer,
+                   "%c %ms %ms %ms %ms %ms %n",
                    &type,
                    &i->path,
                    &mode,
                    &user,
                    &group,
                    &age,
-                   &n) < 2) {
+                   &n);
+        if (r < 2) {
                 log_error("[%s:%u] Syntax error.", fname, line);
                 r = -EIO;
                 goto finish;
@@ -995,10 +1055,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, "\"");
-                        if (!i->argument) {
-                                log_error("Out of memory");
-                                return -ENOMEM;
-                        }
+                        if (!i->argument)
+                                return log_oom();
                 }
         }
 
@@ -1010,6 +1068,7 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
         case TRUNCATE_DIRECTORY:
         case CREATE_FIFO:
         case IGNORE_PATH:
+        case IGNORE_DIRECTORY_PATH:
         case REMOVE_PATH:
         case RECURSIVE_REMOVE_PATH:
         case RELABEL_PATH:
@@ -1076,7 +1135,7 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
         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;
@@ -1153,11 +1212,6 @@ static int parse_line(const char *fname, unsigned line, const char *buffer) {
         r = 0;
 
 finish:
-        free(user);
-        free(group);
-        free(mode);
-        free(age);
-
         if (i)
                 item_free(i);
 
@@ -1245,18 +1299,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;
-        int r = 0;
+        int r;
+        Iterator iterator;
+        Item *i;
 
         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;
 
-                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);
@@ -1278,43 +1333,47 @@ static int read_config_file(const char *fn, bool ignore_enoent) {
                                 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 r;
+        int r, k;
         Item *i;
         Iterator iterator;
 
@@ -1334,47 +1393,36 @@ int main(int argc, char *argv[]) {
         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;
         }
 
-        r = EXIT_SUCCESS;
+        r = 0;
 
         if (optind < argc) {
                 int j;
 
                 for (j = optind; j < argc; j++) {
-                        char *fragment;
-
-                        fragment = resolve_fragment(argv[j], (const char**) 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 {
-                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));
-                        r = EXIT_FAILURE;
                         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)
@@ -1397,5 +1445,5 @@ finish:
 
         label_finish();
 
-        return r;
+        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 }