/* SPDX-License-Identifier: LGPL-2.1-or-later */ #include "alloc-util.h" #include "dirent-util.h" #include "fd-util.h" #include "fileio.h" #include "missing_syscall.h" #include "mountpoint-util.h" #include "recurse-dir.h" #include "sort-util.h" #define DEFAULT_RECURSION_MAX 100 static int sort_func(struct dirent * const *a, struct dirent * const *b) { return strcmp((*a)->d_name, (*b)->d_name); } static bool ignore_dirent(const struct dirent *de, RecurseDirFlags flags) { assert(de); /* Depending on flag either ignore everything starting with ".", or just "." itself and ".." */ return FLAGS_SET(flags, RECURSE_DIR_IGNORE_DOT) ? de->d_name[0] == '.' : dot_or_dot_dot(de->d_name); } int readdir_all(int dir_fd, RecurseDirFlags flags, DirectoryEntries **ret) { _cleanup_free_ DirectoryEntries *de = NULL; struct dirent *entry; DirectoryEntries *nde; size_t add, sz, j; int r; assert(dir_fd >= 0); /* Returns an array with pointers to "struct dirent" directory entries, optionally sorted. Free the * array with readdir_all_freep(). * * Start with space for up to 8 directory entries. We expect at least 2 ("." + ".."), hence hopefully * 8 will cover most cases comprehensively. (Note that most likely a lot more entries will actually * fit in the buffer, given we calculate maximum file name length here.) */ de = malloc(offsetof(DirectoryEntries, buffer) + DIRENT_SIZE_MAX * 8); if (!de) return -ENOMEM; de->buffer_size = 0; for (;;) { size_t bs; ssize_t n; bs = MIN(MALLOC_SIZEOF_SAFE(de) - offsetof(DirectoryEntries, buffer), (size_t) SSIZE_MAX); assert(bs > de->buffer_size); n = getdents64(dir_fd, (uint8_t*) de->buffer + de->buffer_size, bs - de->buffer_size); if (n < 0) return -errno; if (n == 0) break; msan_unpoison((uint8_t*) de->buffer + de->buffer_size, n); de->buffer_size += n; if (de->buffer_size < bs - DIRENT_SIZE_MAX) /* Still room for one more entry, then try to * fill it up without growing the structure. */ continue; if (bs >= SSIZE_MAX - offsetof(DirectoryEntries, buffer)) return -EFBIG; bs = bs >= (SSIZE_MAX - offsetof(DirectoryEntries, buffer))/2 ? SSIZE_MAX - offsetof(DirectoryEntries, buffer) : bs * 2; nde = realloc(de, bs); if (!nde) return -ENOMEM; de = nde; } de->n_entries = 0; FOREACH_DIRENT_IN_BUFFER(entry, de->buffer, de->buffer_size) { if (ignore_dirent(entry, flags)) continue; if (FLAGS_SET(flags, RECURSE_DIR_ENSURE_TYPE)) { r = dirent_ensure_type(dir_fd, entry); if (r == -ENOENT) /* dentry gone by now? no problem, let's just suppress it */ continue; if (r < 0) return r; } de->n_entries++; } sz = ALIGN(offsetof(DirectoryEntries, buffer) + de->buffer_size); add = sizeof(struct dirent*) * de->n_entries; if (add > SIZE_MAX - add) return -ENOMEM; nde = realloc(de, sz + add); if (!nde) return -ENOMEM; de = nde; de->entries = (struct dirent**) ((uint8_t*) de + ALIGN(offsetof(DirectoryEntries, buffer) + de->buffer_size)); j = 0; FOREACH_DIRENT_IN_BUFFER(entry, de->buffer, de->buffer_size) { if (ignore_dirent(entry, flags)) continue; /* If d_type == DT_UNKNOWN that means we failed to ensure the type in the earlier loop and * didn't include the dentry in de->n_entries and as such should skip it here as well. */ if (FLAGS_SET(flags, RECURSE_DIR_ENSURE_TYPE) && entry->d_type == DT_UNKNOWN) continue; de->entries[j++] = entry; } assert(j == de->n_entries); if (FLAGS_SET(flags, RECURSE_DIR_SORT)) typesafe_qsort(de->entries, de->n_entries, sort_func); if (ret) *ret = TAKE_PTR(de); return 0; } int recurse_dir( int dir_fd, const char *path, unsigned statx_mask, unsigned n_depth_max, RecurseDirFlags flags, recurse_dir_func_t func, void *userdata) { _cleanup_free_ DirectoryEntries *de = NULL; STRUCT_STATX_DEFINE(root_sx); int r; assert(dir_fd >= 0); assert(func); /* This is a lot like ftw()/nftw(), but a lot more modern, i.e. built around openat()/statx()/O_PATH, * and under the assumption that fds are not as 'expensive' as they used to be. */ if (n_depth_max == 0) return -EOVERFLOW; if (n_depth_max == UINT_MAX) /* special marker for "default" */ n_depth_max = DEFAULT_RECURSION_MAX; if (FLAGS_SET(flags, RECURSE_DIR_TOPLEVEL)) { if (statx_mask != 0) { r = statx_fallback(dir_fd, "", AT_EMPTY_PATH, statx_mask, &root_sx); if (r < 0) return r; } r = func(RECURSE_DIR_ENTER, path, -1, /* we have no parent fd */ dir_fd, NULL, /* we have no dirent */ statx_mask != 0 ? &root_sx : NULL, userdata); if (IN_SET(r, RECURSE_DIR_LEAVE_DIRECTORY, RECURSE_DIR_SKIP_ENTRY)) return 0; if (r != RECURSE_DIR_CONTINUE) return r; } /* Mask out RECURSE_DIR_ENSURE_TYPE so we can do it ourselves and avoid an extra statx() call. */ r = readdir_all(dir_fd, flags & ~RECURSE_DIR_ENSURE_TYPE, &de); if (r < 0) return r; for (size_t i = 0; i < de->n_entries; i++) { _cleanup_close_ int inode_fd = -EBADF, subdir_fd = -EBADF; _cleanup_free_ char *joined = NULL; STRUCT_STATX_DEFINE(sx); bool sx_valid = false; const char *p; /* For each directory entry we'll do one of the following: * * 1) If the entry refers to a directory, we'll open it as O_DIRECTORY 'subdir_fd' and then statx() the opened directory via that new fd (if requested) * 2) Otherwise, if RECURSE_DIR_INODE_FD is set we'll open it as O_PATH 'inode_fd' and then statx() the opened inode via that new fd (if requested) * 3) Otherwise, we'll statx() the directory entry via the directory fd we are currently looking at (if requested) */ if (path) { joined = path_join(path, de->entries[i]->d_name); if (!joined) return -ENOMEM; p = joined; } else p = de->entries[i]->d_name; if (IN_SET(de->entries[i]->d_type, DT_UNKNOWN, DT_DIR)) { subdir_fd = openat(dir_fd, de->entries[i]->d_name, O_DIRECTORY|O_NOFOLLOW|O_CLOEXEC); if (subdir_fd < 0) { if (errno == ENOENT) /* Vanished by now, go for next file immediately */ continue; /* If it is a subdir but we failed to open it, then fail */ if (!IN_SET(errno, ENOTDIR, ELOOP)) { log_debug_errno(errno, "Failed to open directory '%s': %m", p); assert(errno <= RECURSE_DIR_SKIP_OPEN_DIR_ERROR_MAX - RECURSE_DIR_SKIP_OPEN_DIR_ERROR_BASE); r = func(RECURSE_DIR_SKIP_OPEN_DIR_ERROR_BASE + errno, p, dir_fd, -1, de->entries[i], NULL, userdata); if (r == RECURSE_DIR_LEAVE_DIRECTORY) break; if (!IN_SET(r, RECURSE_DIR_CONTINUE, RECURSE_DIR_SKIP_ENTRY)) return r; continue; } /* If it's not a subdir, then let's handle it like a regular inode below */ } else { /* If we managed to get a DIR* off the inode, it's definitely a directory. */ de->entries[i]->d_type = DT_DIR; if (statx_mask != 0 || (flags & RECURSE_DIR_SAME_MOUNT)) { r = statx_fallback(subdir_fd, "", AT_EMPTY_PATH, statx_mask, &sx); if (r < 0) return r; sx_valid = true; } } } if (subdir_fd < 0) { /* It's not a subdirectory. */ if (flags & RECURSE_DIR_INODE_FD) { inode_fd = openat(dir_fd, de->entries[i]->d_name, O_PATH|O_NOFOLLOW|O_CLOEXEC); if (inode_fd < 0) { if (errno == ENOENT) /* Vanished by now, go for next file immediately */ continue; log_debug_errno(errno, "Failed to open directory entry '%s': %m", p); assert(errno <= RECURSE_DIR_SKIP_OPEN_INODE_ERROR_MAX - RECURSE_DIR_SKIP_OPEN_INODE_ERROR_BASE); r = func(RECURSE_DIR_SKIP_OPEN_INODE_ERROR_BASE + errno, p, dir_fd, -1, de->entries[i], NULL, userdata); if (r == RECURSE_DIR_LEAVE_DIRECTORY) break; if (!IN_SET(r, RECURSE_DIR_CONTINUE, RECURSE_DIR_SKIP_ENTRY)) return r; continue; } /* If we open the inode, then verify it's actually a non-directory, like we * assume. Let's guarantee that we never pass statx data of a directory where * caller expects a non-directory */ r = statx_fallback(inode_fd, "", AT_EMPTY_PATH, statx_mask | STATX_TYPE, &sx); if (r < 0) return r; assert(sx.stx_mask & STATX_TYPE); sx_valid = true; if (S_ISDIR(sx.stx_mode)) { /* What? It's a directory now? Then someone must have quickly * replaced it. Let's handle that gracefully: convert it to a * directory fd — which should be riskless now that we pinned the * inode. */ subdir_fd = fd_reopen(inode_fd, O_DIRECTORY|O_CLOEXEC); if (subdir_fd < 0) return subdir_fd; inode_fd = safe_close(inode_fd); } } else if (statx_mask != 0 || (de->entries[i]->d_type == DT_UNKNOWN && (flags & RECURSE_DIR_ENSURE_TYPE))) { r = statx_fallback(dir_fd, de->entries[i]->d_name, AT_SYMLINK_NOFOLLOW, statx_mask | STATX_TYPE, &sx); if (r == -ENOENT) /* Vanished by now? Go for next file immediately */ continue; if (r < 0) { log_debug_errno(r, "Failed to stat directory entry '%s': %m", p); assert(errno <= RECURSE_DIR_SKIP_STAT_INODE_ERROR_MAX - RECURSE_DIR_SKIP_STAT_INODE_ERROR_BASE); r = func(RECURSE_DIR_SKIP_STAT_INODE_ERROR_BASE + -r, p, dir_fd, -1, de->entries[i], NULL, userdata); if (r == RECURSE_DIR_LEAVE_DIRECTORY) break; if (!IN_SET(r, RECURSE_DIR_CONTINUE, RECURSE_DIR_SKIP_ENTRY)) return r; continue; } assert(sx.stx_mask & STATX_TYPE); sx_valid = true; if (S_ISDIR(sx.stx_mode)) { /* So it suddenly is a directory, but we couldn't open it as such * earlier? That is weird, and probably means somebody is racing * against us. We could of course retry and open it as a directory * again, but the chance to win here is limited. Hence, let's * propagate this as EISDIR error instead. That way we make this * something that can be reasonably handled, even though we give the * guarantee that RECURSE_DIR_ENTRY is strictly issued for * non-directory dirents. */ log_debug_errno(r, "Non-directory entry '%s' suddenly became a directory: %m", p); r = func(RECURSE_DIR_SKIP_STAT_INODE_ERROR_BASE + EISDIR, p, dir_fd, -1, de->entries[i], NULL, userdata); if (r == RECURSE_DIR_LEAVE_DIRECTORY) break; if (!IN_SET(r, RECURSE_DIR_CONTINUE, RECURSE_DIR_SKIP_ENTRY)) return r; continue; } } } if (sx_valid) { /* Copy over the data we acquired through statx() if we acquired any */ if (sx.stx_mask & STATX_TYPE) { assert((subdir_fd < 0) == !S_ISDIR(sx.stx_mode)); de->entries[i]->d_type = IFTODT(sx.stx_mode); } if (sx.stx_mask & STATX_INO) de->entries[i]->d_ino = sx.stx_ino; } if (subdir_fd >= 0) { if (FLAGS_SET(flags, RECURSE_DIR_SAME_MOUNT)) { bool is_mount; if (sx_valid && FLAGS_SET(sx.stx_attributes_mask, STATX_ATTR_MOUNT_ROOT)) is_mount = FLAGS_SET(sx.stx_attributes, STATX_ATTR_MOUNT_ROOT); else { r = fd_is_mount_point(dir_fd, de->entries[i]->d_name, 0); if (r < 0) log_debug_errno(r, "Failed to determine whether %s is a submount, assuming not: %m", p); is_mount = r > 0; } if (is_mount) { r = func(RECURSE_DIR_SKIP_MOUNT, p, dir_fd, subdir_fd, de->entries[i], statx_mask != 0 ? &sx : NULL, /* only pass sx if user asked for it */ userdata); if (r == RECURSE_DIR_LEAVE_DIRECTORY) break; if (!IN_SET(r, RECURSE_DIR_CONTINUE, RECURSE_DIR_SKIP_ENTRY)) return r; continue; } } if (n_depth_max <= 1) { /* When we reached max depth, generate a special event */ r = func(RECURSE_DIR_SKIP_DEPTH, p, dir_fd, subdir_fd, de->entries[i], statx_mask != 0 ? &sx : NULL, /* only pass sx if user asked for it */ userdata); if (r == RECURSE_DIR_LEAVE_DIRECTORY) break; if (!IN_SET(r, RECURSE_DIR_CONTINUE, RECURSE_DIR_SKIP_ENTRY)) return r; continue; } r = func(RECURSE_DIR_ENTER, p, dir_fd, subdir_fd, de->entries[i], statx_mask != 0 ? &sx : NULL, /* only pass sx if user asked for it */ userdata); if (r == RECURSE_DIR_LEAVE_DIRECTORY) break; if (r == RECURSE_DIR_SKIP_ENTRY) continue; if (r != RECURSE_DIR_CONTINUE) return r; r = recurse_dir(subdir_fd, p, statx_mask, n_depth_max - 1, flags &~ RECURSE_DIR_TOPLEVEL, /* we already called the callback for this entry */ func, userdata); if (r != 0) return r; r = func(RECURSE_DIR_LEAVE, p, dir_fd, subdir_fd, de->entries[i], statx_mask != 0 ? &sx : NULL, /* only pass sx if user asked for it */ userdata); } else /* Non-directory inode */ r = func(RECURSE_DIR_ENTRY, p, dir_fd, inode_fd, de->entries[i], statx_mask != 0 ? &sx : NULL, /* only pass sx if user asked for it */ userdata); if (r == RECURSE_DIR_LEAVE_DIRECTORY) break; if (!IN_SET(r, RECURSE_DIR_SKIP_ENTRY, RECURSE_DIR_CONTINUE)) return r; } if (FLAGS_SET(flags, RECURSE_DIR_TOPLEVEL)) { r = func(RECURSE_DIR_LEAVE, path, -1, dir_fd, NULL, statx_mask != 0 ? &root_sx : NULL, userdata); if (!IN_SET(r, RECURSE_DIR_LEAVE_DIRECTORY, RECURSE_DIR_SKIP_ENTRY, RECURSE_DIR_CONTINUE)) return r; } return 0; } int recurse_dir_at( int atfd, const char *path, unsigned statx_mask, unsigned n_depth_max, RecurseDirFlags flags, recurse_dir_func_t func, void *userdata) { _cleanup_close_ int fd = -EBADF; assert(atfd >= 0 || atfd == AT_FDCWD); assert(func); fd = openat(atfd, path ?: ".", O_DIRECTORY|O_CLOEXEC); if (fd < 0) return -errno; return recurse_dir(fd, path, statx_mask, n_depth_max, flags, func, userdata); }