Split out of #37344.
#include "sd-bus.h"
+#include "argv-util.h"
#include "bus-internal.h"
#include "log.h"
#include "string-util.h"
#include "sd-journal.h"
#include "alloc-util.h"
+#include "argv-util.h"
#include "chattr-util.h"
#include "dirent-util.h"
#include "fd-util.h"
#include "journal-internal.h"
#include "logs-show.h"
#include "macro.h"
+#include "output-mode.h"
#include "path-util.h"
#include "rm-rf.h"
#include "string-util.h"
+#include "strv.h"
#include "tests.h"
#include "tmpfile-util.h"
#include "sd-journal.h"
#include "alloc-util.h"
+#include "argv-util.h"
#include "chattr-util.h"
#include "iovec-util.h"
#include "journal-file-util.h"
#include <fcntl.h>
#include <unistd.h>
+#include "argv-util.h"
#include "chattr-util.h"
#include "iovec-util.h"
#include "journal-authenticate.h"
#include "sd-login.h"
#include "alloc-util.h"
+#include "argv-util.h"
#include "errno-list.h"
#include "fd-util.h"
#include "format-util.h"
#include "sd-login.h"
#include "alloc-util.h"
+#include "format-util.h"
#include "main-func.h"
#include "parse-util.h"
+#include "strv.h"
#include "tests.h"
static const char *arg_verb = NULL; /* NULL means all */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stdbool.h>
#include <sys/stat.h>
-#include <sys/types.h>
#include "acl-util.h"
#include "alloc-util.h"
#include "errno-util.h"
#include "extract-word.h"
-#include "log.h"
#include "string-util.h"
#include "strv.h"
#include "user-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <unistd.h>
+#include "forward.h"
int fd_acl_make_read_only_fallback(int fd);
int fd_acl_make_writable_fallback(int fd);
#if HAVE_ACL
-#include <acl/libacl.h>
-#include <stdbool.h>
-#include <sys/acl.h>
-
-#include "macro.h"
-#include "memory-util.h"
+#include <acl/libacl.h> /* IWYU pragma: export */
+#include <sys/acl.h> /* IWYU pragma: export */
int calc_acl_mask_if_needed(acl_t *acl_p);
int add_base_acls_if_needed(acl_t *acl_p, const char *path);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <stddef.h>
-#include <stdint.h>
#include <string.h>
#include <unistd.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <time-util.h>
+#include "forward.h"
int acpi_get_boot_usec(usec_t *ret_loader_start, usec_t *ret_loader_exit);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <stddef.h>
+#include <syslog.h>
#include "alloc-util.h"
#include "apparmor-util.h"
#include "fileio.h"
-#include "log.h"
#include "parse-util.h"
#if HAVE_APPARMOR
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <stdbool.h>
-
-#include "dlfcn-util.h"
+#include "forward.h"
#if HAVE_APPARMOR
# include <sys/apparmor.h>
-#include "memory-util.h"
+# include "dlfcn-util.h"
extern DLSYM_PROTOTYPE(aa_change_onexec);
extern DLSYM_PROTOTYPE(aa_change_profile);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
#include "ask-password-agent.h"
+#include "bus-util.h"
#include "exec-util.h"
#include "log.h"
#include "process-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "bus-util.h"
+#include "forward.h"
int ask_password_agent_open(void);
void ask_password_agent_close(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <inttypes.h>
-#include <limits.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
+#include <poll.h>
#include <stdio.h>
-#include <stdlib.h>
#include <sys/inotify.h>
#include <sys/signalfd.h>
#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/uio.h>
-#include <sys/un.h>
#include <termios.h>
#include <unistd.h>
#include "ansi-color.h"
#include "ask-password-api.h"
#include "creds-util.h"
-#include "env-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
#include "iovec-util.h"
#include "keyring-util.h"
#include "log.h"
-#include "macro.h"
-#include "memory-util.h"
#include "missing_syscall.h"
-#include "mkdir-label.h"
#include "nulstr-util.h"
#include "parse-util.h"
#include "path-lookup.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "time-util.h"
+#include "forward.h"
typedef enum AskPasswordFlags {
ASK_PASSWORD_ACCEPT_CACHED = 1 << 0, /* read from kernel keyring */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stddef.h>
+#include <sched.h>
#include <sys/prctl.h>
#include <sys/wait.h>
#include <unistd.h>
#include "errno-util.h"
#include "fd-util.h"
#include "log.h"
-#include "macro.h"
#include "process-util.h"
+#include "rm-rf.h"
#include "signal-util.h"
int asynchronous_sync(PidRef *ret_pid) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
-
-#include "macro.h"
-#include "pidref.h"
-#include "rm-rf.h"
+#include "forward.h"
/* These functions implement various potentially slow operations that are executed asynchronously. They are
* carefully written to not use pthreads, but use fork() or clone() (without CLONE_VM) so that the child does
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
+#include <poll.h>
#include <sys/eventfd.h>
-#include <sys/types.h>
#include <unistd.h>
#include "barrier.h"
#include "errno-util.h"
#include "fd-util.h"
#include "io-util.h"
-#include "macro.h"
/**
* Barriers
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdint.h>
-#include <sys/types.h>
-
-#include "macro.h"
-#include "memory-util.h"
+#include "forward.h"
/* See source file for an API description. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <stdbool.h>
-#include <stdlib.h>
#include <sys/stat.h>
#include <syslog.h>
#include <unistd.h>
#include "alloc-util.h"
-#include "architecture.h"
#include "base-filesystem.h"
#include "errno-util.h"
#include "fd-util.h"
#include "log.h"
-#include "macro.h"
#include "nulstr-util.h"
#include "path-util.h"
-#include "string-util.h"
#include "umask-util.h"
#include "user-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
+#include "forward.h"
int base_filesystem_create_fd(int fd, const char *root, uid_t uid, gid_t gid);
int base_filesystem_create(const char *root, uid_t uid, gid_t gid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-device.h"
+#include "forward.h"
int on_ac_power(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <sys/stat.h>
-#include <sys/statvfs.h>
#include <sys/vfs.h>
#include "binfmt-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
#include <string.h>
#include "alloc-util.h"
#include "bitmap.h"
-#include "hashmap.h"
-#include "macro.h"
#include "memory-util.h"
/* Bitmaps are only meant to store relatively small numbers
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "hashmap.h"
-#include "macro.h"
+#include "forward.h"
+#include "iterator.h"
typedef struct Bitmap {
uint64_t *bitmaps;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-
#if HAVE_BLKID
-#include <errno.h>
+#include "sd-id128.h"
#include "blkid-util.h"
#include "string-util.h"
#include <blkid.h>
-#include "sd-id128.h"
-
-#include "memory-util.h"
+#include "forward.h"
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(blkid_probe, blkid_free_probe, NULL);
#include "blockdev-list.h"
#include "blockdev-util.h"
#include "device-util.h"
-#include "macro.h"
#include "strv.h"
#include "terminal-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
+
typedef enum BlockDevListFlags {
BLOCKDEV_LIST_SHOW_SYMLINKS = 1 << 0,
BLOCKDEV_LIST_REQUIRE_PARTITION_SCANNING = 1 << 1,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/blkpg.h>
+#include <linux/fs.h>
#include <sys/file.h>
#include <sys/ioctl.h>
-#include <sys/mount.h>
+#include <sys/stat.h>
#include <unistd.h>
#include "sd-device.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
-#include "missing_magic.h"
#include "parse-util.h"
+#include "path-util.h"
+#include "string-util.h"
static int fd_get_devnum(int fd, BlockDeviceLookupFlag flags, dev_t *ret) {
struct stat st;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
+#include <sys/sysmacros.h>
-#include "sd-device.h"
-
-#include "macro.h"
+#include "forward.h"
#include "stdio-util.h"
-#include "string-util.h"
#define SYS_BLOCK_PATH_MAX(suffix) \
(STRLEN("/sys/dev/block/") + DECIMAL_STR_MAX(dev_t) + 1 + DECIMAL_STR_MAX(dev_t) + STRLEN(suffix))
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
#include <linux/if_bonding.h>
-#include <netinet/in.h>
-#include "macro.h"
+#include "forward.h"
/*
* Maximum number of targets supported by the kernel for a single
#include "chase.h"
#include "fd-util.h"
#include "fileio.h"
-#include "id128-util.h"
#include "log.h"
#include "os-util.h"
#include "path-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
#include "sd-id128.h"
+#include "forward.h"
+
typedef enum BootEntryTokenType {
BOOT_ENTRY_TOKEN_MACHINE_ID,
BOOT_ENTRY_TOKEN_OS_IMAGE_ID,
#include "acpi-fpdt.h"
#include "boot-timestamps.h"
#include "efi-loader.h"
-#include "macro.h"
#include "time-util.h"
int boot_timestamps(const dual_timestamp *n, dual_timestamp *firmware, dual_timestamp *loader) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <time-util.h>
+#include "forward.h"
int boot_timestamps(const dual_timestamp *n, dual_timestamp *firmware, dual_timestamp *loader);
#include <fnmatch.h>
#include <unistd.h>
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "bootspec.h"
#include "bootspec-fundamental.h"
#include "chase.h"
-#include "conf-files.h"
#include "devnum-util.h"
#include "dirent-util.h"
#include "efi-loader.h"
+#include "efivars.h"
#include "env-file.h"
-#include "errno-util.h"
+#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
#include "find-esp.h"
#include "pe-binary.h"
#include "pretty-print.h"
#include "recurse-dir.h"
+#include "set.h"
#include "sort-util.h"
#include "stat-util.h"
#include "string-table.h"
+#include "string-util.h"
#include "strv.h"
-#include "terminal-util.h"
#include "uki.h"
-#include "unaligned.h"
static const char* const boot_entry_type_table[_BOOT_ENTRY_TYPE_MAX] = {
[BOOT_ENTRY_CONF] = "Boot Loader Specification Type #1 (.conf)",
#pragma once
-#include <errno.h>
-#include <inttypes.h>
-#include <stdbool.h>
-#include <sys/types.h>
-
-#include "sd-json.h"
-
-#include "set.h"
-#include "string-util.h"
+#include "forward.h"
typedef enum BootEntryType {
BOOT_ENTRY_CONF, /* Boot Loader Specification Type #1 entries: *.conf files */
#include "bpf-dlopen.h"
#include "dlfcn-util.h"
#include "log.h"
-#include "strv.h"
#if HAVE_LIBBPF
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
#include <syslog.h>
#if HAVE_LIBBPF
-#include <bpf/bpf.h>
-#include <bpf/libbpf.h>
+#include <bpf/bpf.h> /* IWYU pragma: export */
+#include <bpf/libbpf.h> /* IWYU pragma: export */
-#include "bpf-compat.h"
+#include "bpf-compat.h" /* IWYU pragma: export */
#include "dlfcn-util.h"
+#include "forward.h"
extern DLSYM_PROTOTYPE(bpf_link__destroy);
extern DLSYM_PROTOTYPE(bpf_link__fd);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-
#pragma once
#if HAVE_LIBBPF
-#include <stdio.h>
#include <bpf/libbpf.h>
-#include "fdset.h"
-#include "macro.h"
+#include "forward.h"
bool bpf_can_link_program(struct bpf_program *prog);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
+#include <linux/bpf.h>
#include <linux/bpf_insn.h>
-#include <sys/stat.h>
-#include <sys/types.h>
#include <unistd.h>
#include "alloc-util.h"
#include "bpf-program.h"
#include "errno-util.h"
#include "escape.h"
+#include "extract-word.h"
#include "fd-util.h"
+#include "fdset.h"
+#include "log.h"
#include "memory-util.h"
#include "missing_syscall.h"
#include "parse-util.h"
#include "path-util.h"
#include "serialize.h"
+#include "set.h"
#include "string-table.h"
+#include "string-util.h"
static const char *const bpf_cgroup_attach_type_table[__MAX_BPF_ATTACH_TYPE] = {
[BPF_CGROUP_INET_INGRESS] = "ingress",
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <linux/bpf.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <sys/syscall.h>
-
-#include "fdset.h"
-#include "list.h"
-#include "macro.h"
-
-typedef struct BPFProgram BPFProgram;
+#include "forward.h"
/* This encapsulates three different concepts: the loaded BPF program, the BPF code, and the attachment to a
* cgroup. Typically our BPF programs go through all three stages: we build the code, we load it, and finally
* we attach it, but it might happen that we operate with programs that aren't loaded or aren't attached, or
* where we don't have the code. */
-struct BPFProgram {
+typedef struct BPFProgram {
/* The loaded BPF program, if loaded */
int kernel_fd;
uint32_t prog_type;
char *attached_path;
int attached_type;
uint32_t attached_flags;
-};
+} BPFProgram;
int bpf_program_supported(void);
#pragma once
#include <linux/if_bridge.h>
-#include <netinet/in.h>
-#include "conf-parser.h"
+#include "forward.h"
typedef enum BridgeState {
NETDEV_BRIDGE_STATE_DISABLED = BR_STATE_DISABLED,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <inttypes.h>
#include <linux/btrfs.h>
#include <linux/btrfs_tree.h>
-#include <linux/loop.h>
#include <linux/magic.h>
-#include <stddef.h>
#include <stdio.h>
-#include <stdlib.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/sysmacros.h>
#include <unistd.h>
#include "alloc-util.h"
-#include "blockdev-util.h"
#include "btrfs-util.h"
#include "chase.h"
#include "chattr-util.h"
#include "copy.h"
#include "errno-util.h"
#include "fd-util.h"
-#include "fileio.h"
#include "fs-util.h"
-#include "io-util.h"
#include "log.h"
-#include "macro.h"
-#include "missing_fs.h"
#include "path-util.h"
#include "rm-rf.h"
-#include "smack-util.h"
#include "sparse-endian.h"
#include "stat-util.h"
#include "string-util.h"
return -ENXIO;
}
+bool btrfs_might_be_subvol(const struct stat *st) {
+ if (!st)
+ return false;
+
+ /* Returns true if this 'struct stat' looks like it could refer to a btrfs subvolume. To make a final
+ * decision, needs to be combined with an fstatfs() check to see if this is actually btrfs. */
+
+ return S_ISDIR(st->st_mode) && st->st_ino == 256;
+}
+
int btrfs_forget_device(const char *path) {
_cleanup_close_ int control_fd = -EBADF;
struct btrfs_ioctl_vol_args args = {};
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdint.h>
-#include <sys/types.h>
-
#include "sd-id128.h"
-#include "btrfs.h"
-#include "copy.h"
-#include "time-util.h"
+#include "btrfs.h" /* IWYU pragma: export */
+#include "forward.h"
typedef struct BtrfsSubvolInfo {
uint64_t subvol_id;
int btrfs_log_dev_root(int level, int ret, const char *p);
-static inline bool btrfs_might_be_subvol(const struct stat *st) {
- if (!st)
- return false;
-
- /* Returns true if this 'struct stat' looks like it could refer to a btrfs subvolume. To make a final
- * decision, needs to be combined with an fstatfs() check to see if this is actually btrfs. */
-
- return S_ISDIR(st->st_mode) && st->st_ino == 256;
-}
+bool btrfs_might_be_subvol(const struct stat *st);
int btrfs_forget_device(const char *path);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-bus.h"
+
#include "bus-get-properties.h"
#include "bus-message-util.h"
-#include "log.h"
#include "rlimit-util.h"
-#include "stdio-util.h"
#include "string-util.h"
BUS_DEFINE_PROPERTY_GET_GLOBAL(bus_property_get_bool_false, "b", 0);
#include "sd-bus.h"
-#include "macro.h"
+#include "forward.h"
int bus_property_get_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
int bus_property_set_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *error);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "assert-util.h"
+#include "sd-bus.h"
+
#include "bus-locator.h"
-#include "macro.h"
const BusLocator* const bus_home_mgr = &(BusLocator){
.destination = "org.freedesktop.home1",
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
+#include "forward.h"
typedef struct BusLocator {
const char *destination;
#include "alloc-util.h"
#include "bus-get-properties.h"
#include "bus-log-control-api.h"
-#include "bus-util.h"
+#include "bus-object.h"
#include "log.h"
#include "syslog-util.h"
+int bus_log_control_api_register(sd_bus *bus) {
+ return bus_add_implementation(bus, &log_control_object, NULL);
+}
+
int bus_property_get_log_level(
sd_bus *bus,
const char *path,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
-
-#include "bus-object.h"
+#include "forward.h"
extern const BusObjectImplementation log_control_object;
-static inline int bus_log_control_api_register(sd_bus *bus) {
- return bus_add_implementation(bus, &log_control_object, NULL);
-}
+
+int bus_log_control_api_register(sd_bus *bus);
int bus_property_get_log_level(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
int bus_property_set_log_level(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *error);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "alloc-util.h"
+#include "sd-bus.h"
+
#include "bus-map-properties.h"
-#include "bus-message.h"
#include "bus-message-util.h"
#include "bus-util.h"
-#include "log.h"
+#include "string-util.h"
#include "strv.h"
int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
+#include "forward.h"
typedef int (*bus_property_set_t) (sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata);
#include <unistd.h>
+#include "sd-bus.h"
+
#include "alloc-util.h"
#include "bus-message-util.h"
#include "bus-util.h"
#include "copy.h"
+#include "in-addr-util.h"
#include "resolve-util.h"
+#include "set.h"
+#include "socket-netlink.h"
int bus_message_read_id128(sd_bus_message *m, sd_id128_t *ret) {
const void *a;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
-
-#include "in-addr-util.h"
-#include "set.h"
-#include "socket-netlink.h"
+#include "forward.h"
int bus_message_read_id128(sd_bus_message *m, sd_id128_t *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-bus.h"
+
#include "alloc-util.h"
#include "bus-introspect.h"
#include "bus-object.h"
#include "log.h"
-#include "macro.h"
+#include "ordered-set.h"
#include "string-util.h"
#include "strv.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdio.h>
-
-#include "sd-bus.h"
-
-typedef struct BusObjectImplementation BusObjectImplementation;
+#include "forward.h"
typedef struct BusObjectVtablePair {
const sd_bus_vtable *vtable;
sd_bus_object_find_t object_find;
} BusObjectVtablePair;
-struct BusObjectImplementation {
+typedef struct BusObjectImplementation {
const char *path;
const char *interface;
const sd_bus_vtable **vtables;
sd_bus_node_enumerator_t node_enumerator;
bool manager;
const BusObjectImplementation **children;
-};
+} BusObjectImplementation;
#define BUS_VTABLES(...) ((const sd_bus_vtable* []){ __VA_ARGS__, NULL })
#define BUS_FALLBACK_VTABLES(...) ((const BusObjectVtablePair[]) { __VA_ARGS__, {} })
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "bus-internal.h"
+#include "sd-bus.h"
+#include "sd-event.h"
+
#include "bus-message.h"
#include "bus-polkit.h"
#include "bus-util.h"
+#include "errno-util.h"
+#include "hashmap.h"
+#include "list.h"
#include "log.h"
-#include "process-util.h"
+#include "pidref.h"
+#include "string-util.h"
#include "strv.h"
-#include "user-util.h"
#include "varlink-util.h"
static int bus_message_check_good_user(sd_bus_message *m, uid_t good_user) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
+#include "sd-json.h"
#include "sd-varlink.h"
-#include "hashmap.h"
-#include "user-util.h"
+#include "forward.h"
typedef enum PolkitFlags {
POLKIT_ALLOW_INTERACTIVE = 1 << 0, /* Allow interactive auth (typically not required, because can be derived from bus message/link automatically) */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-bus.h"
+
#include "alloc-util.h"
#include "bus-print-properties.h"
#include "cap-list.h"
#include "mountpoint-util.h"
#include "nsflags.h"
#include "parse-util.h"
-#include "stdio-util.h"
+#include "set.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"
-#include "user-util.h"
int bus_print_property_value(const char *name, const char *expected_value, BusPrintPropertyFlags flags, const char *value) {
assert(name);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "sd-bus.h"
-
-#include "macro.h"
-#include "set.h"
+#include "forward.h"
typedef enum BusPrintPropertyFlags {
BUS_PRINT_PROPERTY_ONLY_VALUE = 1 << 0, /* e.g. systemctl --value */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-bus.h"
+
#include "ansi-color.h"
#include "bus-locator.h"
#include "bus-unit-procs.h"
+#include "format-util.h"
#include "glyph-util.h"
#include "hashmap.h"
#include "list.h"
#include "log.h"
-#include "macro.h"
+#include "output-mode.h"
#include "path-util.h"
#include "process-util.h"
#include "sort-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
-
-#include "output-mode.h"
+#include "forward.h"
int unit_show_processes(sd_bus *bus, const char *unit, const char *cgroup_path, const char *prefix, unsigned n_columns, OutputFlags flags, sd_bus_error *error);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "af-list.h"
+#include <paths.h>
+#include <sys/mount.h>
+
+#include "sd-bus.h"
+
#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-error.h"
#include "cgroup-setup.h"
#include "cgroup-util.h"
#include "condition.h"
+#include "constants.h"
#include "coredump-util.h"
#include "cpu-set-util.h"
-#include "dissect-image.h"
#include "escape.h"
#include "exec-util.h"
#include "exit-status.h"
-#include "fileio.h"
+#include "extract-word.h"
#include "firewall-util.h"
#include "hexdecoct.h"
#include "hostname-util.h"
#include "in-addr-util.h"
+#include "install.h"
#include "ioprio-util.h"
#include "ip-protocol-list.h"
-#include "libmount-util.h"
-#include "locale-util.h"
#include "log.h"
-#include "macro.h"
-#include "missing_fs.h"
#include "mountpoint-util.h"
#include "nsflags.h"
#include "numa-util.h"
#include "parse-util.h"
#include "path-util.h"
#include "percent-util.h"
+#include "pidref.h"
#include "process-util.h"
#include "rlimit-util.h"
#include "seccomp-util.h"
#include "securebits-util.h"
#include "signal-util.h"
#include "socket-util.h"
-#include "sort-util.h"
-#include "stdio-util.h"
#include "string-util.h"
#include "syslog-util.h"
-#include "terminal-util.h"
+#include "time-util.h"
#include "unit-def.h"
-#include "user-util.h"
-#include "utf8.h"
int bus_parse_unit_info(sd_bus_message *message, UnitInfo *u) {
assert(message);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
-
-#include "install.h"
-#include "pidref.h"
-#include "unit-def.h"
+#include "forward.h"
typedef enum ExecDirectoryFlags {
EXEC_DIRECTORY_READ_ONLY = 1 << 0, /* Public API via DBUS, do not change */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <inttypes.h>
+#include <malloc.h>
#include <stdlib.h>
-#include <sys/ioctl.h>
-#include <sys/resource.h>
#include <sys/socket.h>
+#include <sys/stat.h>
#include <unistd.h>
#include "sd-bus.h"
#include "chase.h"
#include "daemon-util.h"
#include "env-util.h"
+#include "errno-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
#include "memfd-util.h"
#include "memstream-util.h"
#include "path-util.h"
+#include "pidref.h"
#include "socket-util.h"
#include "stdio-util.h"
#include "string-table.h"
+#include "string-util.h"
#include "strv.h"
+#include "time-util.h"
#include "uid-classification.h"
static int name_owner_change_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
"Failed to connect to %s scope bus via %s transport: %m", runtime_scope_to_string(scope), bus_transport_to_string(transport));
}
+int bus_log_connect_error(int r, BusTransport transport, RuntimeScope scope) {
+ return bus_log_connect_full(LOG_ERR, r, transport, scope);
+}
+
int bus_async_unregister_and_exit(sd_event *e, sd_bus *bus, const char *name) {
const char *match;
const char *unique;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/types.h>
+#include "sd-bus.h" /* IWYU pragma: export */
-#include "sd-bus.h"
-#include "sd-event.h"
-
-#include "errno-util.h"
#include "log.h"
-#include "macro.h"
-#include "pidref.h"
-#include "runtime-scope.h"
-#include "set.h"
-#include "string-util.h"
-#include "time-util.h"
+#include "forward.h"
typedef enum BusTransport {
BUS_TRANSPORT_LOCAL,
int bus_log_address_error(int r, BusTransport transport);
int bus_log_connect_full(int log_level, int r, BusTransport transport, RuntimeScope scope);
-static inline int bus_log_connect_error(int r, BusTransport transport, RuntimeScope scope) {
- return bus_log_connect_full(LOG_ERR, r, transport, scope);
-}
+int bus_log_connect_error(int r, BusTransport transport, RuntimeScope scope);
#define bus_log_parse_error(r) \
log_error_errno(r, "Failed to parse bus message: %m")
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-bus.h"
+
#include "alloc-util.h"
#include "bus-internal.h"
#include "bus-util.h"
#include "bus-wait-for-jobs.h"
+#include "errno-util.h"
#include "escape.h"
#include "log.h"
#include "set.h"
+#include "string-util.h"
#include "strv.h"
#include "unit-def.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
-
-#include "macro.h"
-#include "memory-util.h"
+#include "forward.h"
typedef struct BusWaitForJobs BusWaitForJobs;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-bus.h"
+
#include "alloc-util.h"
#include "bus-error.h"
#include "bus-map-properties.h"
#include "hashmap.h"
#include "log.h"
#include "string-util.h"
-#include "strv.h"
#include "unit-def.h"
typedef struct WaitForItem {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-bus.h"
-
-#include "macro.h"
-#include "memory-util.h"
+#include "forward.h"
typedef struct BusWaitForUnits BusWaitForUnits;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <ctype.h>
-#include <errno.h>
-#include <limits.h>
-#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include "alloc-util.h"
#include "calendarspec.h"
#include "errno-util.h"
-#include "fd-util.h"
-#include "fileio.h"
#include "log.h"
-#include "macro.h"
#include "memstream-util.h"
#include "parse-util.h"
#include "process-util.h"
/* A structure for specifying (possibly repetitive) points in calendar
* time, a la cron */
-#include <stdbool.h>
-
-#include "memory-util.h"
-#include "time-util.h"
+#include "forward.h"
typedef struct CalendarComponent {
int start;
#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
+#include "format-util.h"
#include "fs-util.h"
#include "log.h"
#include "missing_magic.h"
#include "path-util.h"
#include "process-util.h"
#include "recurse-dir.h"
+#include "set.h"
+#include "stat-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "user-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdint.h>
-#include <sys/types.h>
-
-#include "cgroup-util.h"
+#include "forward.h"
int cg_weight_parse(const char *s, uint64_t *ret);
int cg_cpu_weight_parse(const char *s, uint64_t *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <dirent.h>
-#include <errno.h>
-#include <stddef.h>
#include <stdio.h>
-#include <stdlib.h>
+
+#include "sd-bus.h"
#include "alloc-util.h"
#include "ansi-color.h"
#include "escape.h"
#include "fd-util.h"
#include "format-util.h"
+#include "glyph-util.h"
#include "hostname-util.h"
-#include "locale-util.h"
#include "log.h"
-#include "macro.h"
#include "nulstr-util.h"
#include "output-mode.h"
-#include "parse-util.h"
#include "path-util.h"
#include "process-util.h"
+#include "runtime-scope.h"
#include "sort-util.h"
#include "string-util.h"
#include "terminal-util.h"
-#include "unit-name.h"
+#include "unit-def.h"
#include "xattr-util.h"
static void show_pid_array(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <sys/types.h>
-
-#include "sd-bus.h"
-
-#include "logs-show.h"
-#include "output-mode.h"
+#include "forward.h"
int show_cgroup_by_path(const char *path, const char *prefix, size_t n_columns, OutputFlags flags);
int show_cgroup(const char *controller, const char *path, const char *prefix, size_t n_columns, OutputFlags flags);
#include <fcntl.h>
#include <sys/stat.h>
-#include <sys/types.h>
#include "chown-recursive.h"
#include "dirent-util.h"
#include "errno-util.h"
#include "fd-util.h"
#include "fs-util.h"
-#include "macro.h"
-#include "stdio-util.h"
+#include "path-util.h"
#include "strv.h"
#include "user-util.h"
#include "xattr-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
+#include "forward.h"
int path_chown_recursive(const char *path, uid_t uid, gid_t gid, mode_t mask, int flags);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <limits.h>
#include <mqueue.h>
-#include <stdbool.h>
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include "fileio.h"
#include "format-util.h"
#include "log.h"
-#include "macro.h"
-#include "string-util.h"
-#include "strv.h"
+#include "path-util.h"
#include "user-util.h"
static bool match_uid_gid(uid_t subject_uid, gid_t subject_gid, uid_t delete_uid, gid_t delete_gid) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
-
-#include "user-util.h"
+#include "forward.h"
int clean_ipc_internal(uid_t uid, gid_t gid, bool rm);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <stdio.h>
-#include <sys/ioctl.h>
#include <sys/time.h>
#include "alloc-util.h"
#include "clock-util.h"
-#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
-#include "macro.h"
#include "string-util.h"
+#include "time-util.h"
int clock_is_localtime(const char *adjtime_path) {
int r;
#include <math.h>
-#include "assert-util.h"
#include "color-util.h"
-#include "macro.h"
void rgb_to_hsv(double r, double g, double b,
double *ret_h, double *ret_s, double *ret_v) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <inttypes.h>
+#include "forward.h"
void rgb_to_hsv(double r, double g, double b,
double *ret_h, double *ret_s, double *ret_v);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <malloc.h>
+#include <sys/signalfd.h>
+
+#include "sd-event.h"
+
+#include "alloc-util.h"
#include "common-signal.h"
-#include "fd-util.h"
-#include "fileio.h"
+#include "format-util.h"
#include "log.h"
#include "memstream-util.h"
#include "process-util.h"
#include "signal-util.h"
+#include "string-util.h"
int sigrtmin18_handler(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
struct sigrtmin18_info *info = userdata;
#include <syslog.h>
-#include "sd-event.h"
+#include "forward.h"
/* All our long-running services should implement a SIGRTMIN+18 handler that can be used to trigger certain
* actions that affect service runtime. The specific action is indicated via the "value integer" you can pass
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <stdbool.h>
+#include "forward.h"
#define COMPARE_OPERATOR_CHARS "!<=>"
#define COMPARE_OPERATOR_WITH_FNMATCH_CHARS COMPARE_OPERATOR_CHARS "$"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <ctype.h>
-#include <errno.h>
#include <fcntl.h>
#include <fnmatch.h>
#include <gnu/libc-version.h>
-#include <limits.h>
-#include <stdlib.h>
#include <sys/stat.h>
-#include <sys/types.h>
#include <sys/utsname.h>
#include <time.h>
#include <unistd.h>
#include "confidential-virt.h"
#include "cpu-set-util.h"
#include "creds-util.h"
-#include "efi-api.h"
#include "efi-loader.h"
+#include "efivars.h"
#include "env-file.h"
#include "env-util.h"
#include "extract-word.h"
#include "fs-util.h"
#include "glob-util.h"
#include "hostname-setup.h"
-#include "hostname-util.h"
#include "id128-util.h"
#include "ima-util.h"
#include "initrd-util.h"
#include "libaudit-util.h"
#include "limits-util.h"
#include "list.h"
-#include "macro.h"
+#include "log.h"
#include "mountpoint-util.h"
#include "nulstr-util.h"
#include "os-util.h"
#include "parse-util.h"
#include "path-util.h"
#include "percent-util.h"
+#include "pidref.h"
#include "proc-cmdline.h"
#include "process-util.h"
#include "psi-util.h"
#include "stat-util.h"
#include "string-table.h"
#include "string-util.h"
+#include "strv.h"
+#include "time-util.h"
#include "tomoyo-util.h"
#include "tpm2-util.h"
#include "uid-classification.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <stdbool.h>
-#include <stdio.h>
-
#include "list.h"
-#include "macro.h"
+#include "forward.h"
typedef enum ConditionType {
CONDITION_ARCHITECTURE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <limits.h>
#include <linux/ipv6.h>
-#include <stdint.h>
#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
#include "sd-id128.h"
#include "in-addr-prefix-util.h"
#include "ip-protocol-list.h"
#include "log.h"
-#include "macro.h"
#include "missing_network.h"
#include "nulstr-util.h"
#include "parse-helpers.h"
#include "rlimit-util.h"
#include "set.h"
#include "signal-util.h"
+#include "siphash24.h"
#include "socket-util.h"
#include "stat-util.h"
#include "string-util.h"
return 0;
}
+int hashmap_by_section_find_unused_line(
+ Hashmap *entries_by_section,
+ const char *filename,
+ unsigned *ret) {
+
+ return _hashmap_by_section_find_unused_line(HASHMAP_BASE(entries_by_section), filename, ret);
+}
+
+int ordered_hashmap_by_section_find_unused_line(
+ OrderedHashmap *entries_by_section,
+ const char *filename,
+ unsigned *ret) {
+
+ return _hashmap_by_section_find_unused_line(HASHMAP_BASE(entries_by_section), filename, ret);
+}
+
#define DEFINE_PARSER(type, vartype, conv_func) \
DEFINE_CONFIG_PARSE_PTR(config_parse_##type, conv_func, vartype)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <sys/stat.h>
#include <syslog.h>
+#include "alloc-util.h"
#include "conf-parser-forward.h"
-#include "hashmap.h"
+#include "forward.h"
#include "log.h"
-#include "memory-util.h"
/* An abstract parser for simple, line based, shallow configuration files consisting of variable assignments only. */
HashmapBase *entries_by_section,
const char *filename,
unsigned *ret);
-static inline int hashmap_by_section_find_unused_line(
- Hashmap *entries_by_section,
- const char *filename,
- unsigned *ret) {
- return _hashmap_by_section_find_unused_line(HASHMAP_BASE(entries_by_section), filename, ret);
-}
-static inline int ordered_hashmap_by_section_find_unused_line(
- OrderedHashmap *entries_by_section,
- const char *filename,
- unsigned *ret) {
- return _hashmap_by_section_find_unused_line(HASHMAP_BASE(entries_by_section), filename, ret);
-}
+
+int hashmap_by_section_find_unused_line(Hashmap *entries_by_section, const char *filename, unsigned *ret);
+int ordered_hashmap_by_section_find_unused_line(OrderedHashmap *entries_by_section, const char *filename, unsigned *ret);
static inline bool section_is_invalid(ConfigSection *section) {
/* If this returns false, then it does _not_ mean the section is valid. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
#include <linux/btrfs.h>
-#include <stddef.h>
#include <stdio.h>
-#include <stdlib.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/sendfile.h>
#include <sys/sysmacros.h>
-#include <sys/xattr.h>
#include <unistd.h>
#include "alloc-util.h"
-#include "btrfs-util.h"
#include "chattr-util.h"
#include "copy.h"
#include "dirent-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
-#include "io-util.h"
+#include "hashmap.h"
#include "log.h"
-#include "macro.h"
-#include "missing_fs.h"
-#include "missing_syscall.h"
-#include "mkdir-label.h"
#include "mountpoint-util.h"
#include "nulstr-util.h"
+#include "path-util.h"
#include "rm-rf.h"
#include "selinux-util.h"
#include "signal-util.h"
#include "stat-util.h"
+#include "set.h"
#include "stdio-util.h"
#include "string-util.h"
-#include "strv.h"
#include "sync-util.h"
-#include "time-util.h"
#include "tmpfile-util.h"
#include "umask-util.h"
#include "user-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <fcntl.h>
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include "set.h"
+#include "forward.h"
typedef enum CopyFlags {
COPY_REFLINK = 1 << 0, /* Try to reflink */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <pwd.h>
-
-#include "macro.h"
+#include "forward.h"
typedef enum CoredumpFilter {
COREDUMP_FILTER_PRIVATE_ANONYMOUS = 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stddef.h>
#include <stdio.h>
#include <syslog.h>
+#include <unistd.h>
#include "alloc-util.h"
#include "cpu-set-util.h"
-#include "dirent-util.h"
-#include "errno-util.h"
#include "extract-word.h"
-#include "fd-util.h"
#include "hexdecoct.h"
#include "log.h"
-#include "macro.h"
-#include "memory-util.h"
#include "parse-util.h"
-#include "stat-util.h"
#include "string-util.h"
-#include "strv.h"
char* cpu_set_to_string(const CPUSet *a) {
_cleanup_free_ char *str = NULL;
#include <sched.h>
-#include "memory-util.h"
-#include "missing_syscall.h"
+#include "forward.h"
/* This wraps the libc interface with a variable to keep the allocated size. */
typedef struct CPUSet {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <pwd.h>
#include <sys/file.h>
+#include <unistd.h>
+#include "efivars.h"
+#include "time-util.h"
#if HAVE_OPENSSL
#include <openssl/err.h>
#include "alloc-util.h"
#include "blockdev-util.h"
-#include "capability-util.h"
#include "chattr-util.h"
-#include "constants.h"
#include "copy.h"
#include "creds-util.h"
#include "efi-api.h"
#include "recurse-dir.h"
#include "sparse-endian.h"
#include "stat-util.h"
+#include "string-util.h"
#include "tmpfile-util.h"
#include "tpm2-util.h"
#include "user-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <inttypes.h>
-#include <stdbool.h>
-#include <sys/types.h>
-
#include "sd-id128.h"
#include "fd-util.h"
-#include "time-util.h"
+#include "forward.h"
#define CREDENTIAL_NAME_MAX FDNAME_MAX
#include "sd-json.h"
+#include "alloc-util.h"
#include "ask-password-api.h"
#include "cryptsetup-fido2.h"
+#include "cryptsetup-util.h"
#include "env-util.h"
#include "fido2-util.h"
-#include "fileio.h"
-#include "hexdecoct.h"
#include "iovec-util.h"
#include "libfido2-util.h"
-#include "parse-util.h"
-#include "random-util.h"
+#include "log.h"
+
#include "strv.h"
int acquire_fido2_key(
void **ret_decrypted_key,
size_t *ret_decrypted_key_size) {
+#if HAVE_LIBCRYPTSETUP && HAVE_LIBFIDO2
_cleanup_(erase_and_freep) char *envpw = NULL;
_cleanup_strv_free_erase_ char **pins = NULL;
_cleanup_(iovec_done_erase) struct iovec loaded_salt = {};
askpw_flags &= ~ASK_PASSWORD_ACCEPT_CACHED;
}
+#else
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "FIDO2 token support not available.");
+#endif
}
int acquire_fido2_key_auto(
void **ret_decrypted_key,
size_t *ret_decrypted_key_size) {
+#if HAVE_LIBCRYPTSETUP && HAVE_LIBFIDO2
_cleanup_free_ void *cid = NULL;
size_t cid_size = 0;
int r, ret = -ENOENT;
log_info("Unlocked volume via automatically discovered security FIDO2 token.");
return ret;
+#else
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "FIDO2 token support not available.");
+#endif
}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
-
-#include "ask-password-api.h"
-#include "cryptsetup-util.h"
-#include "libfido2-util.h"
-#include "log.h"
-#include "time-util.h"
-
-#if HAVE_LIBFIDO2
+#include "forward.h"
int acquire_fido2_key(
const char *volume_name,
AskPasswordFlags askpw_flags,
void **ret_decrypted_key,
size_t *ret_decrypted_key_size);
-
-#else
-
-static inline int acquire_fido2_key(
- const char *volume_name,
- const char *friendly_name,
- const char *device,
- const char *rp_id,
- const void *cid,
- size_t cid_size,
- const char *key_file,
- size_t key_file_size,
- uint64_t key_file_offset,
- const struct iovec *key_data,
- usec_t until,
- Fido2EnrollFlags required,
- const char *askpw_credential,
- AskPasswordFlags askpw_flags,
- void **ret_decrypted_key,
- size_t *ret_decrypted_key_size) {
-
- return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
- "FIDO2 token support not available.");
-}
-
-static inline int acquire_fido2_key_auto(
- struct crypt_device *cd,
- const char *name,
- const char *friendly_name,
- const char *fido2_device,
- usec_t until,
- const char *askpw_credential,
- AskPasswordFlags askpw_flags,
- void **ret_decrypted_key,
- size_t *ret_decrypted_key_size) {
-
- return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
- "FIDO2 token support not available.");
-}
-#endif
#include "alloc-util.h"
#include "ask-password-api.h"
#include "cryptsetup-tpm2.h"
+#include "cryptsetup-util.h"
#include "env-util.h"
#include "fileio.h"
#include "hexdecoct.h"
-#include "parse-util.h"
+#include "log.h"
#include "random-util.h"
-#include "sha256.h"
+#include "strv.h"
#include "tpm2-util.h"
+#if HAVE_LIBCRYPTSETUP && HAVE_TPM2
static int get_pin(
usec_t until,
const char *askpw_credential,
return r;
}
+#endif
int acquire_tpm2_key(
const char *volume_name,
AskPasswordFlags askpw_flags,
struct iovec *ret_decrypted_key) {
+#if HAVE_LIBCRYPTSETUP && HAVE_TPM2
_cleanup_(sd_json_variant_unrefp) sd_json_variant *signature_json = NULL;
_cleanup_(iovec_done) struct iovec loaded_blob = {};
_cleanup_free_ char *auto_device = NULL;
return r;
}
+#else
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "TPM2 support not available.");
+#endif
}
int find_tpm2_auto_data(
int *ret_keyslot,
int *ret_token) {
+#if HAVE_LIBCRYPTSETUP && HAVE_TPM2
int r, token;
assert(cd);
}
return log_error_errno(SYNTHETIC_ERRNO(ENXIO), "No valid TPM2 token data found.");
+#else
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "TPM2 support not available.");
+#endif
}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
+#include <sys/uio.h>
-#include "ask-password-api.h"
-#include "cryptsetup-util.h"
-#include "log.h"
-#include "time-util.h"
-#include "tpm2-util.h"
-
-#if HAVE_TPM2
+#include "forward.h"
int acquire_tpm2_key(
const char *volume_name,
TPM2Flags *ret_flags,
int *ret_keyslot,
int *ret_token);
-
-#else
-
-static inline int acquire_tpm2_key(
- const char *volume_name,
- const char *device,
- uint32_t hash_pcr_mask,
- uint16_t pcr_bank,
- const struct iovec *pubkey,
- uint32_t pubkey_pcr_mask,
- const char *signature_path,
- const char *pcrlock_path,
- uint16_t primary_alg,
- const char *key_file,
- size_t key_file_size,
- uint64_t key_file_offset,
- const struct iovec blobs[],
- size_t n_blobs,
- const struct iovec policy_hash[],
- size_t n_policy_hash,
- const struct iovec *salt,
- const struct iovec *srk,
- const struct iovec *pcrlock_nv,
- TPM2Flags flags,
- usec_t until,
- const char *askpw_credential,
- AskPasswordFlags askpw_flags,
- struct iovec *ret_decrypted_key) {
-
- return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
- "TPM2 support not available.");
-}
-
-static inline int find_tpm2_auto_data(
- struct crypt_device *cd,
- uint32_t search_pcr_mask,
- int start_token,
- uint32_t *ret_hash_pcr_mask,
- uint16_t *ret_pcr_bank,
- struct iovec *ret_pubkey,
- uint32_t *ret_pubkey_pcr_mask,
- uint16_t *ret_primary_alg,
- struct iovec **ret_blobs,
- size_t *ret_n_blobs,
- struct iovec **ret_policy_hash,
- size_t *ret_n_policy_hash,
- struct iovec *ret_salt,
- struct iovec *ret_srk,
- struct iovec *ret_pcrlock_nv,
- TPM2Flags *ret_flags,
- int *ret_keyslot,
- int *ret_token) {
-
- return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
- "TPM2 support not available.");
-}
-
-#endif
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <stdlib.h>
+
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "cryptsetup-util.h"
#include "dlfcn-util.h"
#include "log.h"
#include "parse-util.h"
+#include "string-util.h"
+#include "strv.h"
#if HAVE_LIBCRYPTSETUP
static void *cryptsetup_dl = NULL;
return keyslot;
}
+
+const char* mangle_none(const char *s) {
+ /* A helper that turns cryptsetup/integritysetup/veritysetup "options" strings into NULL if they are effectively empty */
+ return isempty(s) || STR_IN_SET(s, "-", "none") ? NULL : s;
+}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-json.h"
-
-#include "alloc-util.h"
#include "dlfcn-util.h"
-#include "macro.h"
-#include "string-util.h"
-#include "strv.h"
+#include "forward.h"
#if HAVE_LIBCRYPTSETUP
-#include <libcryptsetup.h>
+#include <libcryptsetup.h> /* IWYU pragma: export */
/* These next two are defined in libcryptsetup.h from cryptsetup version 2.3.4 forwards. */
#ifndef CRYPT_ACTIVATE_NO_READ_WORKQUEUE
int cryptsetup_get_keyslot_from_token(sd_json_variant *v);
-static inline const char* mangle_none(const char *s) {
- /* A helper that turns cryptsetup/integritysetup/veritysetup "options" strings into NULL if they are effectively empty */
- return isempty(s) || STR_IN_SET(s, "-", "none") ? NULL : s;
-}
+const char* mangle_none(const char *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-daemon.h"
+
#include "alloc-util.h"
#include "daemon-util.h"
#include "fd-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "sd-daemon.h" /* IWYU pragma: export */
-#include "sd-daemon.h"
-
-#include "macro.h"
+#include "forward.h"
#define NOTIFY_READY_MESSAGE "READY=1\n" "STATUS=Processing requests..."
#define NOTIFY_STOPPING_MESSAGE "STOPPING=1\n" "STATUS=Shutting down..."
return stop;
}
-/* This is intended to be used with _cleanup_ attribute. */
static inline void notify_on_cleanup(const char **p) {
if (*p)
(void) sd_notify(false, *p);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <sys/stat.h>
+#include <unistd.h>
+
#include "copy.h"
#include "data-fd-util.h"
#include "fd-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stddef.h>
-#include <stdint.h>
+#include "forward.h"
int copy_data_fd(int fd);
int memfd_clone_fd(int fd, const char *name, int mode);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stdlib.h>
#include <sys/sysmacros.h>
#include <unistd.h>
#include "fd-util.h"
#include "fs-util.h"
#include "label-util.h"
-#include "lock-util.h"
#include "log.h"
#include "mkdir-label.h"
#include "nulstr-util.h"
#include "path-util.h"
#include "stat-util.h"
-#include "terminal-util.h"
#include "umask-util.h"
#include "user-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
+#include "forward.h"
int dev_setup(const char *prefix, uid_t uid, gid_t gid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stddef.h>
+#include "forward.h"
int encode_devnode_name(const char *str, char *str_enc, size_t len);
int allow_listed_char_for_devnode(char c, const char *additional);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
#include <linux/loop.h>
#include <linux/magic.h>
#include <stdio.h>
-#include <stdlib.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
+#include <sys/sysmacros.h>
#include <unistd.h>
+#include "sd-json.h"
#include "sd-path.h"
#include "alloc-util.h"
#include "lock-util.h"
#include "log.h"
#include "loop-util.h"
-#include "macro.h"
-#include "missing_fs.h"
#include "mkdir.h"
#include "nulstr-util.h"
#include "os-util.h"
#include "path-util.h"
#include "rm-rf.h"
+#include "runtime-scope.h"
#include "stat-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"
-#include "utf8.h"
#include "vpick.h"
#include "xattr-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdint.h>
-
#include "sd-id128.h"
-#include "sd-json.h"
-#include "hashmap.h"
-#include "image-policy.h"
-#include "lock-util.h"
-#include "macro.h"
+#include "forward.h"
#include "os-util.h"
-#include "path-util.h"
-#include "runtime-scope.h"
-#include "string-util.h"
-#include "time-util.h"
typedef enum ImageType {
IMAGE_DIRECTORY,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#if HAVE_VALGRIND_MEMCHECK_H
-#include <valgrind/memcheck.h>
-#endif
-
#include <fnmatch.h>
-#include <linux/dm-ioctl.h>
#include <linux/loop.h>
#include <sys/file.h>
#include <sys/mount.h>
-#include <sys/prctl.h>
-#include <sys/wait.h>
-#include <sysexits.h>
#if HAVE_OPENSSL
#include <openssl/err.h>
#include "constants.h"
#include "copy.h"
#include "cryptsetup-util.h"
-#include "device-nodes.h"
#include "device-private.h"
-#include "device-util.h"
#include "devnum-util.h"
-#include "discover-image.h"
#include "dissect-image.h"
#include "dm-util.h"
#include "env-file.h"
#include "env-util.h"
+#include "errno-util.h"
#include "extension-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
-#include "fs-util.h"
+#include "format-util.h"
#include "fsck-util.h"
#include "gpt.h"
+#include "hash-funcs.h"
#include "hexdecoct.h"
#include "hostname-setup.h"
-#include "id128-util.h"
+#include "image-policy.h"
#include "import-util.h"
#include "io-util.h"
#include "json-util.h"
-#include "missing_syscall.h"
+#include "loop-util.h"
#include "mkdir-label.h"
#include "mount-util.h"
#include "mountpoint-util.h"
#include "path-util.h"
#include "proc-cmdline.h"
#include "process-util.h"
-#include "raw-clone.h"
#include "resize-fs.h"
#include "signal-util.h"
-#include "sparse-endian.h"
+#include "siphash24.h"
#include "stat-util.h"
-#include "stdio-util.h"
-#include "string-table.h"
#include "string-util.h"
#include "strv.h"
-#include "tmpfile-util.h"
+#include "time-util.h"
#include "udev-util.h"
#include "user-util.h"
#include "xattr-util.h"
return _ARCHITECTURE_INVALID;
}
+bool dissected_image_is_portable(DissectedImage *m) {
+ return m && strv_env_pairs_get(m->os_release, "PORTABLE_PREFIXES");
+}
+
+bool dissected_image_is_initrd(DissectedImage *m) {
+ return m && !strv_isempty(m->initrd_release);
+}
+
int dissect_loop_device(
LoopDevice *loop,
const VeritySettings *verity,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
#include "sd-id128.h"
#include "architecture.h"
-#include "env-util.h"
+#include "forward.h"
#include "gpt.h"
#include "list.h"
-#include "loop-util.h"
-#include "macro.h"
-#include "os-util.h"
-#include "strv.h"
-typedef struct DissectedImage DissectedImage;
-typedef struct DissectedPartition DissectedPartition;
typedef struct DecryptedImage DecryptedImage;
-typedef struct MountOptions MountOptions;
-typedef struct VeritySettings VeritySettings;
-typedef struct ImageFilter ImageFilter;
-typedef struct ImagePolicy ImagePolicy;
-typedef struct ExtensionReleaseData ExtensionReleaseData;
-struct DissectedPartition {
+typedef struct DissectedPartition {
bool found:1;
bool ignored:1;
bool rw:1;
uint64_t offset;
uint64_t gpt_flags;
int fsmount_fd;
-};
+} DissectedPartition;
#define DISSECTED_PARTITION_NULL \
((DissectedPartition) { \
DISSECT_IMAGE_IDENTITY_UID = 1 << 29, /* Explicitly request an identity UID range mapping */
} DissectImageFlags;
-struct DissectedImage {
+typedef struct DissectedImage {
bool encrypted:1;
bool has_verity:1; /* verity available in image, but not necessarily used */
bool has_verity_sig:1; /* pkcs#7 signature embedded in image */
char **confext_release;
char **sysext_release;
int has_init_system;
-};
+} DissectedImage;
-struct MountOptions {
+typedef struct MountOptions {
PartitionDesignator partition_designator;
char *options;
LIST_FIELDS(MountOptions, mount_options);
-};
+} MountOptions;
-struct VeritySettings {
+typedef struct VeritySettings {
/* Binary root hash for the Verity Merkle tree */
void *root_hash;
size_t root_hash_size;
/* PARTITION_ROOT or PARTITION_USR, depending on what these Verity settings are for */
PartitionDesignator designator;
-};
+} VeritySettings;
#define VERITY_SETTINGS_DEFAULT (VeritySettings) { \
.designator = _PARTITION_DESIGNATOR_INVALID \
}
-struct ImageFilter {
+typedef struct ImageFilter {
/* A per designator glob matching against the partition label */
char *pattern[_PARTITION_DESIGNATOR_MAX];
-};
+} ImageFilter;
-struct ExtensionReleaseData {
+typedef struct ExtensionReleaseData {
char *os_release_id;
char *os_release_version_id;
char *os_release_sysext_level;
char *os_release_confext_level;
char *os_release_extension_scope;
-};
+} ExtensionReleaseData;
MountOptions* mount_options_free_all(MountOptions *options);
DEFINE_TRIVIAL_CLEANUP_FUNC(MountOptions*, mount_options_free_all);
return m && m->partitions[PARTITION_ESP].found && dissected_image_is_bootable_os(m);
}
-static inline bool dissected_image_is_portable(DissectedImage *m) {
- return m && strv_env_pairs_get(m->os_release, "PORTABLE_PREFIXES");
-}
-
-static inline bool dissected_image_is_initrd(DissectedImage *m) {
- return m && !strv_isempty(m->initrd_release);
-}
+bool dissected_image_is_portable(DissectedImage *m);
+bool dissected_image_is_initrd(DissectedImage *m);
DecryptedImage* decrypted_image_ref(DecryptedImage *p);
DecryptedImage* decrypted_image_unref(DecryptedImage *p);
#include <sys/socket.h>
#include "alloc-util.h"
+#include "dns-def.h"
#include "dns-domain.h"
#include "glyph-util.h"
-#include "hashmap.h"
+#include "hash-funcs.h"
#include "hexdecoct.h"
#include "hostname-util.h"
#include "idn-util.h"
#include "in-addr-util.h"
#include "log.h"
-#include "macro.h"
#include "parse-util.h"
+#include "siphash24.h"
#include "string-util.h"
#include "strv.h"
#include "utf8.h"
return r;
}
+int dns_name_parent(const char **name) {
+ return dns_label_unescape(name, NULL, DNS_LABEL_MAX, 0);
+}
+
#if HAVE_LIBIDN
int dns_label_apply_idna(const char *encoded, size_t encoded_size, char *decoded, size_t decoded_max) {
_cleanup_free_ uint32_t *input = NULL;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "dns-def.h"
-#include "hashmap.h"
-#include "in-addr-util.h"
+#include "forward.h"
typedef enum DNSLabelFlags {
DNS_LABEL_LDH = 1 << 0, /* Follow the "LDH" rule — only letters, digits, and internal hyphens. */
int dns_label_escape(const char *p, size_t l, char *dest, size_t sz);
int dns_label_escape_new(const char *p, size_t l, char **ret);
-static inline int dns_name_parent(const char **name) {
- return dns_label_unescape(name, NULL, DNS_LABEL_MAX, 0);
-}
+int dns_name_parent(const char **name);
#if HAVE_LIBIDN
int dns_label_apply_idna(const char *encoded, size_t encoded_size, char *decoded, size_t decoded_max);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stdarg.h>
#include <stdio.h>
-#include <stdlib.h>
#include "alloc-util.h"
#include "chase.h"
#include "conf-files.h"
-#include "dirent-util.h"
#include "dropin.h"
#include "escape.h"
-#include "fd-util.h"
#include "fileio.h"
-#include "hashmap.h"
#include "log.h"
-#include "macro.h"
-#include "mkdir.h"
#include "path-util.h"
#include "set.h"
+#include "stdio-util.h"
#include "string-util.h"
#include "strv.h"
+#include "unit-def.h"
#include "unit-name.h"
int drop_in_file(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "hashmap.h"
-#include "macro.h"
-#include "set.h"
-#include "unit-name.h"
+#include "forward.h"
int drop_in_file(
const char *dir,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
#include "alloc-util.h"
#include "copy.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stddef.h>
+#include "forward.h"
#define DROPIN_MARKER_START "### Anything between here and the comment below will become the contents of the drop-in file"
#define DROPIN_MARKER_END "### Edits below this comment will be discarded"
#include "sort-util.h"
#include "stat-util.h"
#include "stdio-util.h"
+#include "string-util.h"
#include "utf8.h"
-#if ENABLE_EFI
-
#define LOAD_OPTION_ACTIVE 0x00000001
#define MEDIA_DEVICE_PATH 0x04
#define MEDIA_HARDDRIVE_DP 0x01
struct device_path__packed device_path__contents _packed_;
assert_cc(sizeof(struct device_path) == sizeof(struct device_path__packed));
-int efi_reboot_to_firmware_supported(void) {
- _cleanup_free_ void *v = NULL;
- static int cache = -1;
- uint64_t b;
- size_t s;
- int r;
-
- if (cache > 0)
- return 0;
- if (cache == 0)
- return -EOPNOTSUPP;
-
- if (!is_efi_boot())
- goto not_supported;
-
- r = efi_get_variable(EFI_GLOBAL_VARIABLE_STR("OsIndicationsSupported"), NULL, &v, &s);
- if (r == -ENOENT)
- goto not_supported; /* variable doesn't exist? it's not supported then */
- if (r < 0)
- return r;
- if (s != sizeof(uint64_t))
- return -EINVAL;
-
- b = *(uint64_t*) v;
- if (!(b & EFI_OS_INDICATIONS_BOOT_TO_FW_UI))
- goto not_supported; /* bit unset? it's not supported then */
-
- cache = 1;
- return 0;
-
-not_supported:
- cache = 0;
- return -EOPNOTSUPP;
-}
-
+#if ENABLE_EFI
static int get_os_indications(uint64_t *ret) {
static struct stat cache_stat = {};
_cleanup_free_ void *v = NULL;
return 0;
}
+static ssize_t utf16_size(const uint16_t *s, size_t buf_len_bytes) {
+ size_t l = 0;
+
+ /* Returns the size of the string in bytes without the terminating two zero bytes */
+
+ while (l < buf_len_bytes / sizeof(uint16_t)) {
+ if (s[l] == 0)
+ return (l + 1) * sizeof(uint16_t);
+ l++;
+ }
+
+ return -EINVAL; /* The terminator was not found */
+}
+
+static void to_utf16(uint16_t *dest, const char *src) {
+ int i;
+
+ for (i = 0; src[i] != '\0'; i++)
+ dest[i] = src[i];
+ dest[i] = '\0';
+}
+
+static uint16_t *tilt_slashes(uint16_t *s) {
+ for (uint16_t *p = s; *p; p++)
+ if (*p == '/')
+ *p = '\\';
+
+ return s;
+}
+
+static int boot_id_hex(const char s[static 4]) {
+ int id = 0;
+
+ assert(s);
+
+ for (int i = 0; i < 4; i++)
+ if (s[i] >= '0' && s[i] <= '9')
+ id |= (s[i] - '0') << (3 - i) * 4;
+ else if (s[i] >= 'A' && s[i] <= 'F')
+ id |= (s[i] - 'A' + 10) << (3 - i) * 4;
+ else
+ return -EINVAL;
+
+ return id;
+}
+#endif
+
+int efi_reboot_to_firmware_supported(void) {
+#if ENABLE_EFI
+ _cleanup_free_ void *v = NULL;
+ static int cache = -1;
+ uint64_t b;
+ size_t s;
+ int r;
+
+ if (cache > 0)
+ return 0;
+ if (cache == 0)
+ return -EOPNOTSUPP;
+
+ if (!is_efi_boot())
+ goto not_supported;
+
+ r = efi_get_variable(EFI_GLOBAL_VARIABLE_STR("OsIndicationsSupported"), NULL, &v, &s);
+ if (r == -ENOENT)
+ goto not_supported; /* variable doesn't exist? it's not supported then */
+ if (r < 0)
+ return r;
+ if (s != sizeof(uint64_t))
+ return -EINVAL;
+
+ b = *(uint64_t*) v;
+ if (!(b & EFI_OS_INDICATIONS_BOOT_TO_FW_UI))
+ goto not_supported; /* bit unset? it's not supported then */
+
+ cache = 1;
+ return 0;
+
+not_supported:
+ cache = 0;
+ return -EOPNOTSUPP;
+#else
+ return -EOPNOTSUPP;
+#endif
+}
+
int efi_get_reboot_to_firmware(void) {
+#if ENABLE_EFI
int r;
uint64_t b;
return r;
return !!(b & EFI_OS_INDICATIONS_BOOT_TO_FW_UI);
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_set_reboot_to_firmware(bool value) {
+#if ENABLE_EFI
int r;
uint64_t b, b_new;
return efi_set_variable(EFI_GLOBAL_VARIABLE_STR("OsIndications"), &b_new, sizeof(uint64_t));
return 0;
-}
-
-static ssize_t utf16_size(const uint16_t *s, size_t buf_len_bytes) {
- size_t l = 0;
-
- /* Returns the size of the string in bytes without the terminating two zero bytes */
-
- while (l < buf_len_bytes / sizeof(uint16_t)) {
- if (s[l] == 0)
- return (l + 1) * sizeof(uint16_t);
- l++;
- }
-
- return -EINVAL; /* The terminator was not found */
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_get_boot_option(
sd_id128_t *ret_part_uuid,
char **ret_path,
bool *ret_active) {
-
+#if ENABLE_EFI
char variable[STRLEN(EFI_GLOBAL_VARIABLE_STR("Boot")) + 4 + 1];
_cleanup_free_ uint8_t *buf = NULL;
size_t l;
*ret_active = header->attr & LOAD_OPTION_ACTIVE;
return 0;
-}
-
-static void to_utf16(uint16_t *dest, const char *src) {
- int i;
-
- for (i = 0; src[i] != '\0'; i++)
- dest[i] = src[i];
- dest[i] = '\0';
-}
-
-static uint16_t *tilt_slashes(uint16_t *s) {
- for (uint16_t *p = s; *p; p++)
- if (*p == '/')
- *p = '\\';
-
- return s;
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_add_boot_option(
uint64_t psize,
sd_id128_t part_uuid,
const char *path) {
-
+#if ENABLE_EFI
size_t size, title_len, path_len;
_cleanup_free_ char *buf = NULL;
struct boot_option *option;
xsprintf(variable, EFI_GLOBAL_VARIABLE_STR("Boot%04X"), id);
return efi_set_variable(variable, buf, size);
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_remove_boot_option(uint16_t id) {
+#if ENABLE_EFI
char variable[STRLEN(EFI_GLOBAL_VARIABLE_STR("Boot")) + 4 + 1];
if (!is_efi_boot())
xsprintf(variable, EFI_GLOBAL_VARIABLE_STR("Boot%04X"), id);
return efi_set_variable(variable, NULL, 0);
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_get_boot_order(uint16_t **ret_order) {
+#if ENABLE_EFI
_cleanup_free_ void *buf = NULL;
size_t l;
int r;
*ret_order = TAKE_PTR(buf);
return (int) (l / sizeof(uint16_t));
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_set_boot_order(const uint16_t *order, size_t n) {
-
+#if ENABLE_EFI
if (!is_efi_boot())
return -EOPNOTSUPP;
return efi_set_variable(EFI_GLOBAL_VARIABLE_STR("BootOrder"), order, n * sizeof(uint16_t));
-}
-
-static int boot_id_hex(const char s[static 4]) {
- int id = 0;
-
- assert(s);
-
- for (int i = 0; i < 4; i++)
- if (s[i] >= '0' && s[i] <= '9')
- id |= (s[i] - '0') << (3 - i) * 4;
- else if (s[i] >= 'A' && s[i] <= 'F')
- id |= (s[i] - 'A' + 10) << (3 - i) * 4;
- else
- return -EINVAL;
-
- return id;
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_get_boot_options(uint16_t **ret_options) {
+#if ENABLE_EFI
_cleanup_closedir_ DIR *dir = NULL;
_cleanup_free_ uint16_t *list = NULL;
int count = 0;
*ret_options = TAKE_PTR(list);
return count;
+#else
+ return -EOPNOTSUPP;
+#endif
}
bool efi_has_tpm2(void) {
+#if ENABLE_EFI
static int cache = -1;
int r;
log_debug_errno(errno, "Unable to test whether /sys/kernel/security/tpm0/binary_bios_measurements exists, assuming it doesn't: %m");
return (cache = false);
-}
-
+#else
+ return -EOPNOTSUPP;
#endif
+}
sd_id128_t efi_guid_to_id128(const void *guid) {
const EFI_GUID *uuid = ASSERT_PTR(guid); /* cast is safe, because struct efi_guid is packed */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "efivars.h"
-#include "efivars-fundamental.h"
-#include "string-util.h"
+#include "sd-id128.h"
-/* Various calls for interfacing with EFI variables from the official UEFI specs. */
+#include "forward.h"
-#if ENABLE_EFI
+/* Various calls for interfacing with EFI variables from the official UEFI specs. */
int efi_reboot_to_firmware_supported(void);
int efi_get_reboot_to_firmware(void);
bool efi_has_tpm2(void);
-#else
-
-static inline int efi_reboot_to_firmware_supported(void) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_get_reboot_to_firmware(void) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_set_reboot_to_firmware(bool value) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_get_boot_option(uint16_t nr, char **ret_title, sd_id128_t *ret_part_uuid, char **ret_path, bool *ret_active) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_add_boot_option(uint16_t id, const char *title, uint32_t part, uint64_t pstart, uint64_t psize, sd_id128_t part_uuid, const char *path) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_remove_boot_option(uint16_t id) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_get_boot_order(uint16_t **ret_order) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_set_boot_order(const uint16_t *order, size_t n) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_get_boot_options(uint16_t **ret_options) {
- return -EOPNOTSUPP;
-}
-
-static inline bool efi_has_tpm2(void) {
- return false;
-}
-
-#endif
-
sd_id128_t efi_guid_to_id128(const void *guid);
void efi_id128_to_guid(sd_id128_t id, void *ret_guid);
#include "alloc-util.h"
#include "efi-api.h"
#include "efi-loader.h"
+#include "efivars.h"
#include "env-util.h"
#include "log.h"
#include "parse-util.h"
#include "path-util.h"
#include "stat-util.h"
+#include "string-util.h"
#include "strv.h"
+#include "time-util.h"
#include "tpm2-pcr.h"
#include "utf8.h"
#if ENABLE_EFI
-
static int read_usec(const char *variable, usec_t *ret) {
_cleanup_free_ char *j = NULL;
uint64_t x = 0;
return 0;
}
+static int get_device_part_uuid(const char *variable, sd_id128_t *ret) {
+ if (!is_efi_boot())
+ return -EOPNOTSUPP;
+
+ return efi_get_variable_id128(variable, ret);
+}
+#endif
+
int efi_loader_get_boot_usec(usec_t *ret_firmware, usec_t *ret_loader) {
+#if ENABLE_EFI
uint64_t x, y;
int r;
*ret_firmware = x;
*ret_loader = y;
return 0;
-}
-
-static int get_device_part_uuid(const char *variable, sd_id128_t *ret) {
- if (!is_efi_boot())
- return -EOPNOTSUPP;
-
- return efi_get_variable_id128(variable, ret);
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_loader_get_device_part_uuid(sd_id128_t *ret) {
+#if ENABLE_EFI
return get_device_part_uuid(EFI_LOADER_VARIABLE_STR("LoaderDevicePartUUID"), ret);
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_stub_get_device_part_uuid(sd_id128_t *ret) {
+#if ENABLE_EFI
return get_device_part_uuid(EFI_LOADER_VARIABLE_STR("StubDevicePartUUID"), ret);
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_loader_get_entries(char ***ret) {
+#if ENABLE_EFI
_cleanup_free_ char16_t *entries = NULL;
_cleanup_strv_free_ char **l = NULL;
size_t size;
*ret = TAKE_PTR(l);
return 0;
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_loader_get_features(uint64_t *ret) {
+#if ENABLE_EFI
_cleanup_free_ void *v = NULL;
size_t s;
int r;
memcpy(ret, v, sizeof(uint64_t));
return 0;
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_stub_get_features(uint64_t *ret) {
+#if ENABLE_EFI
_cleanup_free_ void *v = NULL;
size_t s;
int r;
memcpy(ret, v, sizeof(uint64_t));
return 0;
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_measured_uki(int log_level) {
+#if ENABLE_EFI
_cleanup_free_ char *pcr_string = NULL;
static int cached = -1;
unsigned pcr_nr;
pcr_nr, TPM2_PCR_KERNEL_BOOT);
return (cached = 1);
+#else
+ return log_full_errno(log_level, SYNTHETIC_ERRNO(EOPNOTSUPP), "Compiled without support for EFI");
+#endif
}
int efi_loader_get_config_timeout_one_shot(usec_t *ret) {
+#if ENABLE_EFI
_cleanup_free_ char *v = NULL;
static struct stat cache_stat = {};
struct stat new_stat;
cache_stat = new_stat;
*ret = cache = sec * USEC_PER_SEC; /* return in μs */
return 0;
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_loader_update_entry_one_shot_cache(char **cache, struct stat *cache_stat) {
+#if ENABLE_EFI
_cleanup_free_ char *v = NULL;
struct stat new_stat;
int r;
free_and_replace(*cache, v);
return 0;
+#else
+ return -EOPNOTSUPP;
+#endif
}
int efi_get_variable_id128(const char *variable, sd_id128_t *ret) {
+#if ENABLE_EFI
int r;
assert(variable);
return r;
return sd_id128_from_string(p, ret);
-}
-
+#else
+ return -EOPNOTSUPP;
#endif
+}
bool efi_loader_entry_name_valid(const char *s) {
if (!filename_is_valid(s)) /* Make sure entry names fit in filenames */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/stat.h>
-
-#include "efivars.h"
-#include "efivars-fundamental.h"
-#include "log.h"
+#include "forward.h"
/* Various calls that interface with EFI variables implementing https://systemd.io/BOOT_LOADER_INTERFACE */
-#if ENABLE_EFI
-
int efi_loader_get_device_part_uuid(sd_id128_t *ret);
int efi_stub_get_device_part_uuid(sd_id128_t *ret);
int efi_loader_get_boot_usec(usec_t *ret_firmware, usec_t *ret_loader);
int efi_get_variable_id128(const char *variable, sd_id128_t *ret);
-#else
-
-static inline int efi_loader_get_device_part_uuid(sd_id128_t *u) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_stub_get_device_part_uuid(sd_id128_t *ret) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_loader_get_boot_usec(usec_t *firmware, usec_t *loader) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_loader_get_entries(char ***ret) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_loader_get_features(uint64_t *ret) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_stub_get_features(uint64_t *ret) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_measured_uki(int log_level) {
- return log_full_errno(log_level, SYNTHETIC_ERRNO(EOPNOTSUPP),
- "Compiled without support for EFI");
-}
-
-static inline int efi_loader_get_config_timeout_one_shot(usec_t *ret) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_loader_update_entry_one_shot_cache(char **cache, struct stat *cache_stat) {
- return -EOPNOTSUPP;
-}
-
-static inline int efi_get_variable_id128(const char *variable, sd_id128_t *ret) {
- return -EOPNOTSUPP;
-}
-
-#endif
-
bool efi_loader_entry_name_valid(const char *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#if HAVE_ELFUTILS
-
#include <dwarf.h>
#include <elfutils/libdwelf.h>
#include <elfutils/libdwfl.h>
#include <libelf.h>
+#endif
#include <sys/prctl.h>
-#include <sys/resource.h>
-#include <sys/types.h>
#include <unistd.h>
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "dlfcn-util.h"
#include "elf-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
-#include "hexdecoct.h"
#include "io-util.h"
#include "log.h"
-#include "macro.h"
#include "memstream-util.h"
#include "path-util.h"
#include "process-util.h"
-#include "rlimit-util.h"
+#include "set.h"
#include "string-util.h"
#define FRAMES_MAX 64
/* The amount of data we're willing to write to each of the output pipes. */
#define COREDUMP_PIPE_MAX (1024*1024U)
+#if HAVE_ELFUTILS
+
static void *dw_dl = NULL;
static void *elf_dl = NULL;
return 0;
}
+#endif
+
int parse_elf_object(int fd, const char *executable, const char *root, bool fork_disable_dump, char **ret, sd_json_variant **ret_package_metadata) {
+#if HAVE_ELFUTILS
_cleanup_close_pair_ int error_pipe[2] = EBADF_PAIR,
return_pipe[2] = EBADF_PAIR,
json_pipe[2] = EBADF_PAIR;
*ret_package_metadata = TAKE_PTR(package_metadata);
return 0;
-}
-
+#else
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "elfutils disabled, parsing ELF objects not supported");
#endif
+}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-json.h"
-
-#include "log.h"
+#include "forward.h"
#if HAVE_ELFUTILS
int dlopen_dw(void);
int dlopen_elf(void);
+#endif
/* Parse an ELF object in a forked process, so that errors while iterating over
* untrusted and potentially malicious data do not propagate to the main caller's process.
* If fork_disable_dump, the child process will not dump core if it crashes. */
int parse_elf_object(int fd, const char *executable, const char *root, bool fork_disable_dump, char **ret, sd_json_variant **ret_package_metadata);
-#else
-static inline int parse_elf_object(int fd, const char *executable, const char *root, bool fork_disable_dump, char **ret, sd_json_variant **ret_package_metadata) {
- return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "elfutils disabled, parsing ELF objects not supported");
-}
-#endif
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <stdbool.h>
-
#include "env-util.h"
#include "mempool.h"
#include "process-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
+
/* These functions are split out of fileio.h (and not for example just flags to the functions they wrap) in order to
* optimize linking: This way, -lselinux is needed only for the callers of these functions that need selinux, but not
* for all */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/ethtool.h>
-#include <linux/netdevice.h>
#include <linux/sockios.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include "alloc-util.h"
#include "conf-parser.h"
+#include "errno-util.h"
+#include "ether-addr-util.h"
#include "ethtool-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "parse-util.h"
#include "socket-util.h"
#include "string-table.h"
+#include "string-util.h"
#include "strv.h"
#include "strxcpyx.h"
+#include "time-util.h"
static const char* const duplex_table[_DUP_MAX] = {
[DUP_FULL] = "full",
#pragma once
#include <linux/ethtool.h>
-#include <macro.h>
-#include <net/ethernet.h>
-#include "conf-parser.h"
-#include "ether-addr-util.h"
-#include "time-util.h"
+#include "conf-parser-forward.h"
+#include "forward.h"
#define N_ADVERTISE 4
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <dirent.h>
-#include <errno.h>
#include <stdio.h>
-#include <sys/prctl.h>
-#include <sys/types.h>
+#include <stdlib.h>
#include <unistd.h>
#include "alloc-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "hashmap.h"
-#include "macro.h"
-#include "missing_syscall.h"
+#include "log.h"
#include "path-util.h"
#include "process-util.h"
#include "serialize.h"
-#include "set.h"
-#include "signal-util.h"
#include "stat-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
+#include "time-util.h"
#define EXIT_SKIP_REMAINING 77
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "time-util.h"
+#include "forward.h"
typedef int (*gather_stdout_callback_t) (int fd, void *arg);
#include <sysexits.h>
#include "exit-status.h"
-#include "macro.h"
#include "parse-util.h"
-#include "set.h"
#include "string-util.h"
const ExitStatusMapping exit_status_mappings[256] = {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
#include "bitmap.h"
-#include "hashmap.h"
-#include "macro.h"
+#include "forward.h"
/* This defines pretty names for the LSB 'start' verb exit codes. Note that they shouldn't be confused with
* the LSB 'status' verb exit codes which are defined very differently. For details see:
#include "extension-util.h"
#include "log.h"
#include "os-util.h"
+#include "string-util.h"
#include "strv.h"
int extension_release_validate(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "os-util.h"
+#include "forward.h"
/* Given an image name (for logging purposes), a set of os-release values from the host and a key-value pair
* vector of extension-release variables, check that the distro and (system extension level or distro
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <unistd.h>
+
#include "sd-json.h"
#include "alloc-util.h"
#include "efivars.h"
#include "env-util.h"
#include "factory-reset.h"
+#include "log.h"
#include "os-util.h"
#include "proc-cmdline.h"
#include "string-table.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-
-#include "errno-list.h"
-#include "macro.h"
+#include "forward.h"
typedef enum FactoryResetMode {
FACTORY_RESET_UNSUPPORTED, /* feature not available on this OS */
#include "fdisk-util.h"
#include "log.h"
#include "parse-util.h"
+#include "string-util.h"
#if HAVE_LIBFDISK
#if HAVE_LIBFDISK
-#include <libfdisk.h>
+#include <libfdisk.h> /* IWYU pragma: export */
-#include "sd-id128.h"
-
-#include "memory-util.h"
+#include "forward.h"
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(struct fdisk_context*, fdisk_unref_context, NULL);
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(struct fdisk_partition*, fdisk_unref_partition, NULL);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <stddef.h>
#include <unistd.h>
#include "sd-daemon.h"
#include "fd-util.h"
#include "fdset.h"
#include "log.h"
-#include "macro.h"
#include "parse-util.h"
-#include "path-util.h"
#include "set.h"
#include "stat-util.h"
+#include "string-util.h"
#define MAKE_SET(s) ((Set*) s)
#define MAKE_FDSET(s) ((FDSet*) s)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "hashmap.h"
-#include "macro.h"
-#include "set.h"
-
-typedef struct FDSet FDSet;
+#include "forward.h"
+#include "iterator.h"
FDSet* fdset_new(void);
FDSet* fdset_free(FDSet *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <stdio.h>
+
#include "alloc-util.h"
#include "fido2-util.h"
#include "fileio.h"
+#include "iovec-util.h"
#include "libfido2-util.h"
#include "log.h"
#include "random-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdint.h>
-
-#include "iovec-util.h"
+#include "forward.h"
int fido2_generate_salt(struct iovec *ret_salt);
int fido2_read_salt_file(const char *filename, uint64_t offset, const char *client, const char *node, struct iovec *ret_salt);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/magic.h>
+#include <stdlib.h>
#include <sys/vfs.h>
+#include <unistd.h>
#include "sd-device.h"
+#include "sd-gpt.h"
#include "sd-id128.h"
#include "alloc-util.h"
#include "errno-util.h"
#include "fd-util.h"
#include "find-esp.h"
-#include "gpt.h"
#include "mount-util.h"
#include "parse-util.h"
#include "path-util.h"
#include "stat-util.h"
#include "string-util.h"
+#include "strv.h"
#include "virt.h"
typedef enum VerifyESPFlags {
#pragma once
-#include <inttypes.h>
-#include <stdbool.h>
-#include <sys/types.h>
-
-#include "sd-id128.h"
+#include "forward.h"
int find_esp_and_warn_at(int rfd, const char *path, int unprivileged_mode, char **ret_path, uint32_t *ret_part, uint64_t *ret_pstart, uint64_t *ret_psize, sd_id128_t *ret_uuid, dev_t *ret_devid);
int find_esp_and_warn(const char *root, const char *path, int unprivileged_mode, char **ret_path, uint32_t *ret_part, uint64_t *ret_pstart, uint64_t *ret_psize, sd_id128_t *ret_uuid, dev_t *ret_devid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <arpa/inet.h>
#include <endian.h>
-#include <errno.h>
#include <libiptc/libiptc.h>
-#include <linux/if.h>
#include <linux/netfilter/nf_nat.h>
#include <linux/netfilter/xt_addrtype.h>
#include <linux/netfilter_ipv4/ip_tables.h>
-#include <net/if.h>
-#include <stddef.h>
#include <string.h>
#include "alloc-util.h"
#include "dlfcn-util.h"
-#include "firewall-util.h"
#include "firewall-util-private.h"
#include "in-addr-util.h"
-#include "macro.h"
+#include "log.h"
#include "socket-util.h"
static DLSYM_PROTOTYPE(iptc_check_entry) = NULL;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <arpa/inet.h>
#include <endian.h>
-#include <errno.h>
-#include <linux/netfilter/nf_nat.h>
#include <linux/netfilter/nf_tables.h>
#include <linux/netfilter_ipv4.h>
#include <netinet/ip.h>
#include <netinet/ip6.h>
-#include <stddef.h>
+#include <stdlib.h>
#include <string.h>
#include "sd-netlink.h"
#include "firewall-util.h"
#include "firewall-util-private.h"
#include "in-addr-util.h"
-#include "macro.h"
+#include "log.h"
#include "netlink-internal.h"
-#include "netlink-util.h"
#include "parse-util.h"
#include "socket-util.h"
#include "string-table.h"
+#include "string-util.h"
#include "time-util.h"
#define NFT_SYSTEMD_DNAT_MAP_NAME "map_port_ipport"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "sd-netlink.h"
-
#include "firewall-util.h"
-#include "in-addr-util.h"
+#include "forward.h"
typedef enum FirewallBackend {
FW_BACKEND_NONE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stddef.h>
+#include <stdlib.h>
#include <string.h>
#include "alloc-util.h"
#include "log.h"
#include "netlink-util.h"
#include "string-table.h"
+#include "string-util.h"
static const char * const firewall_backend_table[_FW_BACKEND_MAX] = {
[FW_BACKEND_NONE] = "none",
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "conf-parser.h"
-#include "in-addr-util.h"
+#include "conf-parser-forward.h"
+#include "forward.h"
typedef struct FirewallContext FirewallContext;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <sys/types.h>
+#include <stdlib.h>
#include <unistd.h>
#include "build-path.h"
#include "escape.h"
#include "event-util.h"
#include "exit-status.h"
-#include "fd-util.h"
#include "fork-journal.h"
#include "log.h"
#include "notify-recv.h"
#include "parse-util.h"
+#include "pidref.h"
#include "process-util.h"
+#include "runtime-scope.h"
#include "signal-util.h"
-#include "socket-util.h"
#include "strv.h"
static int on_child_exit(sd_event_source *s, const siginfo_t *si, void *userdata) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "macro.h"
-#include "pidref.h"
-#include "runtime-scope.h"
-#include "set.h"
+#include "forward.h"
int journal_fork(RuntimeScope scope, char * const *units, PidRef *ret_pidref);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <ctype.h>
-#include <net/if.h>
#include <unistd.h>
#include "sd-id128.h"
#include "alloc-util.h"
#include "devnum-util.h"
-#include "fd-util.h"
#include "fileio.h"
#include "format-ifname.h"
#include "format-table.h"
#include "format-util.h"
-#include "fs-util.h"
#include "glyph-util.h"
#include "gunicode.h"
-#include "id128-util.h"
#include "in-addr-util.h"
-#include "log.h"
#include "memory-util.h"
#include "memstream-util.h"
#include "pager.h"
-#include "parse-util.h"
#include "path-util.h"
#include "pretty-print.h"
#include "process-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdio.h>
-#include <sys/types.h>
-
#include "sd-json.h"
-#include "macro.h"
-#include "memory-util.h"
+#include "forward.h"
+#include "log.h"
#include "pager.h"
typedef enum TableDataType {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include "fstab-util.h"
#include "initrd-util.h"
#include "libmount-util.h"
-#include "macro.h"
+#include "log.h"
#include "nulstr-util.h"
#include "parse-util.h"
#include "path-util.h"
return strdup(p);
}
+const char* fstab_path(void) {
+ return secure_getenv("SYSTEMD_FSTAB") ?: "/etc/fstab";
+}
+
bool fstab_is_bind(const char *options, const char *fstype) {
if (fstab_test_option(options, "bind\0" "rbind\0"))
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "assert-util.h"
-#include "macro.h"
+#include "forward.h"
bool fstab_enabled_full(int enabled);
static inline bool fstab_enabled(void) {
char* fstab_node_to_udev_node(const char *p);
-static inline const char* fstab_path(void) {
- return secure_getenv("SYSTEMD_FSTAB") ?: "/etc/fstab";
-}
+const char* fstab_path(void);
bool fstab_is_bind(const char *options, const char *fstype);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
+#include <stdlib.h>
+#include <sys/stat.h>
#include <unistd.h>
#include "alloc-util.h"
#include "generator.h"
#include "initrd-util.h"
#include "log.h"
-#include "macro.h"
#include "mkdir-label.h"
#include "mountpoint-util.h"
#include "parse-util.h"
#include "path-util.h"
-#include "process-util.h"
#include "special.h"
#include "specifier.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdio.h>
-
-#include "errno-list.h"
-#include "macro.h"
+#include "forward.h"
#include "main-func.h"
int generator_open_unit_file_full(const char *dest, const char *source, const char *name, FILE **ret_file, char **ret_final_path, char **ret_temp_path);
#include <linux/if_link.h>
-#include "conf-parser.h"
+#include "forward.h"
typedef enum GeneveDF {
NETDEV_GENEVE_DF_UNSET = GENEVE_DF_UNSET,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "alloc-util.h"
#include "gpt.h"
#include "string-table.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <uchar.h>
-
-#include "sd-gpt.h"
+#include "sd-gpt.h" /* IWYU pragma: export */
#include "sd-id128.h"
#include "architecture.h"
-#include "id128-util.h"
+#include "forward.h"
#include "sparse-endian.h"
/* maximum length of gpt label */
#include "group-record.h"
#include "json-util.h"
#include "log.h"
+#include "string-util.h"
#include "strv.h"
#include "uid-classification.h"
#include "user-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-json.h"
-
+#include "forward.h"
#include "user-record.h"
typedef struct GroupRecord {
Copyright © 2018 Dell Inc.
***/
+#include <linux/fiemap.h>
#include <linux/magic.h>
-#include <stddef.h>
#include <sys/ioctl.h>
-#include <unistd.h>
#include "alloc-util.h"
#include "blockdev-util.h"
#include "btrfs-util.h"
-#include "device-util.h"
#include "devnum-util.h"
#include "efivars.h"
#include "env-util.h"
-#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "hibernate-util.h"
#include "path-util.h"
#include "proc-cmdline.h"
#include "stat-util.h"
-#include "string-util.h"
-#include "strv.h"
#define HIBERNATION_SWAP_THRESHOLD 0.98
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <linux/fiemap.h>
-#include <stdint.h>
-#include <sys/types.h>
-
-#include "assert-util.h"
+#include "forward.h"
/* represents values for /sys/power/resume & /sys/power/resume_offset and the corresponding path */
typedef struct HibernationDevice {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <stdio.h>
-#include <stdlib.h>
#include <sys/utsname.h>
#include <unistd.h>
#include "hostname-util.h"
#include "initrd-util.h"
#include "log.h"
-#include "macro.h"
#include "proc-cmdline.h"
#include "siphash24.h"
#include "string-table.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-#include "macro.h"
+#include "forward.h"
typedef enum HostnameSource {
HOSTNAME_STATIC, /* from /etc/hostname */
#include <ctype.h>
#include <stdio.h>
#include <sys/stat.h>
+#include <unistd.h>
#include "alloc-util.h"
#include "conf-files.h"
-#include "env-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "strbuf.h"
#include "string-util.h"
#include "strv.h"
+#include "time-util.h"
#include "tmpfile-util.h"
#include "verbs.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "sd-hwdb.h" /* IWYU pragma: export */
-#include "sd-hwdb.h"
+#include "forward.h"
bool hwdb_should_reload(sd_hwdb *hwdb);
int hwdb_update(const char *root, const char *hwdb_bin_dir, bool strict, bool compat);
#include "id128-print.h"
#include "log.h"
#include "pretty-print.h"
-#include "terminal-util.h"
int id128_pretty_print_sample(const char *name, sd_id128_t id) {
_cleanup_free_ char *man_link = NULL, *mod_link = NULL;
#pragma once
-#include <errno.h>
-#include <stdbool.h>
-
#include "sd-id128.h"
+#include "forward.h"
+
typedef enum Id128PrettyPrintMode {
ID128_PRINT_ID128,
ID128_PRINT_UUID,
# include <stringprep.h>
#endif
-#include "alloc-util.h"
#include "dlfcn-util.h"
#include "idn-util.h"
#include "log.h"
# include <stringprep.h>
#endif
-#include <errno.h>
-#include <inttypes.h>
+#include "forward.h"
#if HAVE_LIBIDN2 || HAVE_LIBIDN
#include "dlfcn-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
bool use_ima(void);
#include "alloc-util.h"
#include "extract-word.h"
#include "image-policy.h"
+#include "log.h"
#include "logarithm.h"
#include "sort-util.h"
#include "string-util.h"
return 0;
}
+ImagePolicy* image_policy_free(ImagePolicy *p) {
+ return mfree(p);
+}
+
int image_policy_ignore_designators(const ImagePolicy *p, const PartitionDesignator table[], size_t n_table, ImagePolicy **ret) {
assert(p);
assert(table || n_table == 0);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "conf-parser.h"
-#include "dissect-image.h"
-#include "errno-list.h"
+#include "conf-parser-forward.h"
+#include "forward.h"
+#include "gpt.h"
typedef enum PartitionPolicyFlags {
/* Not all policy flags really make sense on all partition types, see comments. But even if they
int image_policy_intersect(const ImagePolicy *a, const ImagePolicy *b, ImagePolicy **ret);
-static inline ImagePolicy* image_policy_free(ImagePolicy *p) {
- return mfree(p);
-}
+ImagePolicy* image_policy_free(ImagePolicy *p);
DEFINE_TRIVIAL_CLEANUP_FUNC(ImagePolicy*, image_policy_free);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-
#include "alloc-util.h"
#include "btrfs-util.h"
#include "chattr-util.h"
#include "errno-util.h"
#include "import-util.h"
#include "log.h"
-#include "macro.h"
#include "nulstr-util.h"
-#include "path-util.h"
#include "string-table.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <stdbool.h>
-
-#include "macro.h"
+#include "forward.h"
typedef enum ImportType {
IMPORT_RAW,
#include "alloc-util.h"
#include "extract-word.h"
+#include "hash-funcs.h"
#include "hostname-util.h"
#include "in-addr-prefix-util.h"
+#include "log.h"
+#include "set.h"
+#include "siphash24.h"
#include "string-util.h"
/* 0.0.0.0/0 */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "conf-parser.h"
+#include "conf-parser-forward.h"
+#include "forward.h"
#include "in-addr-util.h"
-#include "set.h"
struct in_addr_prefix {
int family;
#pragma once
-#include <limits.h>
+#include "forward.h"
#if defined(__FreeBSD_kernel__)
# define INIT_FIFO "/etc/.initctl"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <unistd.h>
#include "btrfs-util.h"
#include "chattr-util.h"
#include "fs-util.h"
#include "install-file.h"
#include "log.h"
-#include "missing_syscall.h"
#include "rm-rf.h"
#include "sync-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
+
typedef enum InstallFileFlags {
INSTALL_REPLACE = 1 << 0, /* Replace an existing inode */
INSTALL_READ_ONLY = 1 << 1, /* Call fs_make_very_read_only() to make the inode comprehensively read-only */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stdio.h>
-#include <unistd.h>
-
#include "alloc-util.h"
-#include "format-util.h"
#include "install.h"
#include "install-printf.h"
-#include "macro.h"
#include "specifier.h"
#include "string-util.h"
#include "unit-name.h"
-#include "user-util.h"
static int specifier_prefix_and_instance(char specifier, const void *data, const char *root, const void *userdata, char **ret) {
const InstallInfo *i = ASSERT_PTR(userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "install.h"
-#include "unit-name.h"
+#include "forward.h"
int install_name_printf(
RuntimeScope scope,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
#include <fnmatch.h>
-#include <limits.h>
-#include <stddef.h>
#include <stdio.h>
-#include <stdlib.h>
#include <unistd.h>
#include "alloc-util.h"
#include "conf-parser.h"
#include "constants.h"
#include "dirent-util.h"
-#include "errno-list.h"
+#include "errno-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
+#include "glyph-util.h"
#include "hashmap.h"
#include "install.h"
#include "install-printf.h"
-#include "locale-util.h"
#include "log.h"
-#include "macro.h"
#include "mkdir-label.h"
#include "path-lookup.h"
#include "path-util.h"
#include "string-util.h"
#include "strv.h"
#include "unit-file.h"
+#include "unit-name.h"
#define UNIT_FILE_FOLLOW_SYMLINK_MAX 64
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-typedef enum UnitFilePresetMode UnitFilePresetMode;
-typedef enum InstallChangeType InstallChangeType;
-typedef enum UnitFileFlags UnitFileFlags;
-typedef enum InstallMode InstallMode;
-typedef struct InstallChange InstallChange;
-typedef struct UnitFileList UnitFileList;
-typedef struct InstallInfo InstallInfo;
-
-#include "hashmap.h"
-#include "macro.h"
-#include "path-lookup.h"
-#include "strv.h"
+#include "forward.h"
+#include "runtime-scope.h"
#include "unit-file.h"
-#include "unit-name.h"
-enum UnitFilePresetMode {
+typedef enum UnitFilePresetMode {
UNIT_FILE_PRESET_FULL,
UNIT_FILE_PRESET_ENABLE_ONLY,
UNIT_FILE_PRESET_DISABLE_ONLY,
_UNIT_FILE_PRESET_MODE_MAX,
_UNIT_FILE_PRESET_MODE_INVALID = -EINVAL,
-};
+} UnitFilePresetMode;
-enum InstallChangeType {
+typedef enum InstallChangeType {
INSTALL_CHANGE_SYMLINK,
INSTALL_CHANGE_UNLINK,
INSTALL_CHANGE_IS_MASKED,
_INSTALL_CHANGE_TYPE_MAX,
_INSTALL_CHANGE_INVALID = -EINVAL,
_INSTALL_CHANGE_ERRNO_MAX = -ERRNO_MAX, /* Ensure this type covers the whole negative errno range */
-};
+} InstallChangeType;
static inline bool INSTALL_CHANGE_TYPE_VALID(InstallChangeType t) {
return t >= _INSTALL_CHANGE_ERRNO_MAX && t < _INSTALL_CHANGE_TYPE_MAX;
}
-enum UnitFileFlags {
+typedef enum UnitFileFlags {
UNIT_FILE_RUNTIME = 1 << 0, /* Public API via DBUS, do not change */
UNIT_FILE_FORCE = 1 << 1, /* Public API via DBUS, do not change */
UNIT_FILE_PORTABLE = 1 << 2, /* Public API via DBUS, do not change */
UNIT_FILE_DRY_RUN = 1 << 3,
UNIT_FILE_IGNORE_AUXILIARY_FAILURE = 1 << 4,
_UNIT_FILE_FLAGS_MASK_PUBLIC = UNIT_FILE_RUNTIME|UNIT_FILE_PORTABLE|UNIT_FILE_FORCE,
-};
+} UnitFileFlags;
/* type can be either one of the INSTALL_CHANGE_SYMLINK, INSTALL_CHANGE_UNLINK, … listed above, or a negative
* errno value.
*
* If source is specified, it should be the contents of the path symlink. In case of an error, source should
* be the existing symlink contents or NULL. */
-struct InstallChange {
+typedef struct InstallChange {
int type; /* INSTALL_CHANGE_SYMLINK, … if positive, errno if negative */
char *path;
char *source;
-};
+} InstallChange;
static inline bool install_changes_have_modification(const InstallChange *changes, size_t n_changes) {
FOREACH_ARRAY(i, changes, n_changes)
return false;
}
-struct UnitFileList {
+typedef struct UnitFileList {
char *path;
UnitFileState state;
-};
+} UnitFileList;
-enum InstallMode {
+typedef enum InstallMode {
INSTALL_MODE_REGULAR,
INSTALL_MODE_LINKED,
INSTALL_MODE_ALIAS,
INSTALL_MODE_MASKED,
_INSTALL_MODE_MAX,
_INSTALL_MODE_INVALID = -EINVAL,
-};
+} InstallMode;
-struct InstallInfo {
+typedef struct InstallInfo {
char *name;
char *path;
char *root;
InstallMode install_mode;
bool auxiliary;
-};
+} InstallInfo;
int unit_file_enable(
RuntimeScope scope,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <netinet/in.h>
-
#include "alloc-util.h"
#include "ip-protocol-list.h"
-#include "macro.h"
#include "parse-util.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
const char* ip_protocol_to_name(int id);
int ip_protocol_from_name(const char *name);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <net/if.h>
-
#include "ipvlan-util.h"
#include "string-table.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
#include <linux/if_link.h>
-#include <netinet/in.h>
-#include "macro.h"
+#include "forward.h"
typedef enum IPVlanMode {
NETDEV_IPVLAN_MODE_L2 = IPVLAN_MODE_L2,
#include <pthread.h>
#include <unistd.h>
+#include "sd-event.h"
+
#include "alloc-util.h"
#include "chattr-util.h"
#include "copy.h"
#include "errno-util.h"
-#include "fd-util.h"
-#include "format-util.h"
#include "journal-authenticate.h"
#include "journal-file-util.h"
#include "log.h"
-#include "path-util.h"
-#include "random-util.h"
#include "set.h"
-#include "stat-util.h"
-#include "sync-util.h"
+#include "string-util.h"
#define PAYLOAD_BUFFER_SIZE (16U * 1024U)
#define MINIMUM_HOLE_SIZE (1U * 1024U * 1024U / 2U)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "journal-file.h"
+#include "journal-file.h" /* IWYU pragma: export */
+#include "forward.h"
int journal_file_set_offline(JournalFile *f, bool wait);
bool journal_file_is_offlining(JournalFile *f);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <malloc.h>
#include <unistd.h>
#include "alloc-util.h"
#include "errno-util.h"
#include "escape.h"
#include "fd-util.h"
-#include "io-util.h"
#include "journal-file.h"
#include "journal-importer.h"
-#include "journal-util.h"
#include "log.h"
#include "parse-util.h"
#include "string-util.h"
#pragma once
-#include <stdbool.h>
-#include <stddef.h>
-#include <sys/uio.h>
-
#include "sd-id128.h"
-#include "io-util.h"
+#include "forward.h"
#include "iovec-wrapper.h"
#include "time-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-bus.h"
+#include "sd-journal.h"
+
#include "acl-util.h"
#include "alloc-util.h"
#include "bus-error.h"
HASHMAP_FOREACH_KEY(path, code, j->errors) {
int err;
- err = abs(PTR_TO_INT(code));
+ err = ABS(PTR_TO_INT(code));
switch (err) {
case EACCES:
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <sys/types.h>
+#include "sd-journal.h" /* IWYU pragma: export */
-#include "sd-journal.h"
+#include "forward.h"
int journal_access_blocked(sd_journal *j);
int journal_access_check_and_warn(sd_journal *j, bool quiet, bool want_other_users);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
int keymap_directories(char ***ret);
int get_keymaps(char ***ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-
#include "alloc-util.h"
#include "conf-parser.h"
#include "kernel-config.h"
-#include "macro.h"
#include "path-util.h"
-#include "strv.h"
int load_kernel_install_conf(
const char *root,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "forward.h"
+
int load_kernel_install_conf(
const char *root,
const char *conf_root,
#include "alloc-util.h"
#include "env-file.h"
#include "fd-util.h"
-#include "fileio.h"
#include "kernel-image.h"
#include "log.h"
-#include "os-util.h"
-#include "parse-util.h"
#include "pe-binary.h"
#include "string-table.h"
+#include "string-util.h"
#define PE_SECTION_READ_MAX (16U*1024U)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-
-#include "macro.h"
+#include "forward.h"
typedef enum KernelImageType {
KERNEL_IMAGE_TYPE_UNKNOWN,
Copyright © 2010 ProFUSION embedded systems
***/
-#include <errno.h>
#include <signal.h>
#include <sys/wait.h>
-#include <unistd.h>
#include "alloc-util.h"
-#include "constants.h"
-#include "dirent-util.h"
#include "errno-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "initrd-util.h"
#include "killall.h"
#include "log.h"
-#include "parse-util.h"
+#include "pidref.h"
#include "process-util.h"
#include "set.h"
-#include "stdio-util.h"
#include "string-util.h"
#include "terminal-util.h"
+#include "time-util.h"
static int argv_has_at(const PidRef *pid) {
int r;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "time-util.h"
+#include "forward.h"
int broadcast_signal(int sig, bool wait_for_exit, bool send_sighup, usec_t timeout);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#include "btrfs-util.h"
#include "errno-util.h"
#include "fs-util.h"
-#include "label.h"
#include "label-util.h"
-#include "macro.h"
#include "selinux-util.h"
#include "smack-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <fcntl.h>
-#include <stdbool.h>
-#include <sys/types.h>
+#include "forward.h"
+#include "label.h" /* IWYU pragma: export */
typedef enum LabelFixFlags {
LABEL_IGNORE_ENOENT = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <syslog.h>
+
#include "libarchive-util.h"
-#include "log.h"
#if HAVE_LIBARCHIVE
static void *libarchive_dl = NULL;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-
-#include "dlfcn-util.h"
+#include "forward.h"
#if HAVE_LIBARCHIVE
-#include <archive.h>
-#include <archive_entry.h>
+#include <archive.h> /* IWYU pragma: export */
+#include <archive_entry.h> /* IWYU pragma: export */
-#include "memory-util.h"
+#include "dlfcn-util.h"
extern DLSYM_PROTOTYPE(archive_entry_free);
extern DLSYM_PROTOTYPE(archive_entry_new);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <linux/audit.h>
#include <linux/netlink.h>
#include <stdio.h>
#include <sys/socket.h>
+#include "errno-util.h"
#include "fd-util.h"
#include "iovec-util.h"
#include "libaudit-util.h"
#pragma once
#if HAVE_AUDIT
-# include <libaudit.h>
+# include <libaudit.h> /* IWYU pragma: export */
#endif
-#include <stdbool.h>
+#include "forward.h"
bool use_audit(void);
# include <unistd.h>
#endif
-#include <errno.h>
#include <stdlib.h>
#include "alloc-util.h"
#include "errno-util.h"
#include "libcrypt-util.h"
#include "log.h"
-#include "macro.h"
-#include "memory-util.h"
-#include "random-util.h"
#include "string-util.h"
#include "strv.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stddef.h>
+#include "forward.h"
int make_salt(char **ret);
int hash_password_full(const char *password, void **cd_data, int *cd_size, char **ret);
#include "dlfcn-util.h"
#include "format-table.h"
#include "glyph-util.h"
-#include "memory-util.h"
+#include "iovec-util.h"
#include "plymouth-util.h"
#include "string-util.h"
#include "strv.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-
-#include "iovec-util.h"
-#include "macro.h"
+#include "forward.h"
#define FIDO2_SALT_SIZE 32U
#include <stdio.h>
+#include "fstab-util.h"
#include "libmount-util.h"
#include "log.h"
return 0;
}
+int libmount_parse_fstab(
+ struct libmnt_table **ret_table,
+ struct libmnt_iter **ret_iter) {
+
+ return libmount_parse_full(fstab_path(), NULL, ret_table, ret_iter);
+}
+
int libmount_is_leaf(
struct libmnt_table *table,
struct libmnt_fs *fs) {
#pragma once
/* This needs to be after sys/mount.h */
-#include <libmount.h>
+#include <libmount.h> /* IWYU pragma: export */
-#include "fstab-util.h"
-#include "macro.h"
-#include "memory-util.h"
+#include "forward.h"
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(struct libmnt_table*, mnt_free_table, NULL);
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(struct libmnt_iter*, mnt_free_iter, NULL);
return libmount_parse_full(NULL, NULL, ret_table, ret_iter);
}
-static inline int libmount_parse_fstab(
- struct libmnt_table **ret_table,
- struct libmnt_iter **ret_iter) {
-
- return libmount_parse_full(fstab_path(), NULL, ret_table, ret_iter);
-}
+int libmount_parse_fstab(struct libmnt_table **ret_table, struct libmnt_iter **ret_iter);
int libmount_is_leaf(
struct libmnt_table *table,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <net/if_arp.h>
-
#include "sd-netlink.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "local-addresses.h"
#include "log.h"
-#include "macro.h"
#include "netlink-util.h"
+#include "socket-util.h"
#include "sort-util.h"
static int address_compare(const struct local_address *a, const struct local_address *b) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-netlink.h"
-
+#include "forward.h"
#include "in-addr-util.h"
struct local_address {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
+#include <stdlib.h>
#include <sys/stat.h>
+#include <unistd.h>
#include "alloc-util.h"
#include "env-file.h"
#include "errno-util.h"
#include "fd-util.h"
#include "locale-setup.h"
+#include "log.h"
#include "proc-cmdline.h"
#include "stat-util.h"
+#include "string-util.h"
#include "strv.h"
void locale_context_clear(LocaleContext *c) {
#include <sys/stat.h>
+#include "forward.h"
#include "locale-util.h"
typedef struct LocaleContext {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <fcntl.h>
#include <signal.h>
-#include <stdint.h>
-#include <stdlib.h>
#include <syslog.h>
#include <unistd.h>
#include "sd-messages.h"
#include "alloc-util.h"
-#include "fd-util.h"
#include "format-util.h"
#include "glyph-util.h"
#include "hashmap.h"
-#include "hostname-util.h"
#include "id128-util.h"
-#include "io-util.h"
#include "journal-internal.h"
#include "journal-util.h"
#include "locale-util.h"
#include "log.h"
#include "logs-show.h"
-#include "macro.h"
#include "output-mode.h"
#include "parse-util.h"
#include "pretty-print.h"
+#include "rlimit-util.h"
+#include "set.h"
+#include "sigbus.h"
#include "sparse-endian.h"
#include "stdio-util.h"
#include "string-table.h"
if (IN_SET(mode, OUTPUT_SHORT_ISO, OUTPUT_SHORT_ISO_PRECISE)) {
int h = tm.tm_gmtoff / 60 / 60,
- m = abs((int) ((tm.tm_gmtoff / 60) % 60));
+ m = ABS((int) ((tm.tm_gmtoff / 60) % 60));
assert_se(snprintf_ok(buf + tail, sizeof(buf) - tail, "%+03d:%02d", h, m));
}
*ret_n_ids = n_ids;
return n_ids > 0;
}
+
+void journal_browse_prepare(void) {
+ /* Increase max number of open files if we can, we might needs this when browsing journal files,
+ * which might be split up into many files. */
+ (void) rlimit_nofile_bump(HIGH_RLIMIT_NOFILE);
+
+ sigbus_install();
+}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <sys/types.h>
-
#include "sd-id128.h"
-#include "sd-journal.h"
-#include "macro.h"
-#include "output-mode.h"
-#include "rlimit-util.h"
-#include "set.h"
-#include "sigbus.h"
-#include "time-util.h"
+#include "forward.h"
typedef struct LogId {
sd_id128_t id; /* boot ID or invocation ID */
ret_ids, ret_n_ids);
}
-static inline void journal_browse_prepare(void) {
- /* Increase max number of open files if we can, we might needs this when browsing journal files,
- * which might be split up into many files. */
- (void) rlimit_nofile_bump(HIGH_RLIMIT_NOFILE);
-
- sigbus_install();
-}
+void journal_browse_prepare(void);
#include <valgrind/memcheck.h>
#endif
-#include <errno.h>
#include <fcntl.h>
-#include <linux/blkpg.h>
#include <linux/loop.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include "fileio.h"
#include "fs-util.h"
#include "loop-util.h"
-#include "missing_fs.h"
#include "parse-util.h"
#include "path-util.h"
#include "random-util.h"
#include "stat-util.h"
#include "stdio-util.h"
#include "string-util.h"
+#include "time-util.h"
static void cleanup_clear_loop_close(int *fd) {
if (*fd < 0)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <fcntl.h>
-
-#include "sd-device.h"
-
-#include "memory-util.h"
-#include "time-util.h"
-
-typedef struct LoopDevice LoopDevice;
+#include "forward.h"
/* Some helpers for setting up loopback block devices */
-struct LoopDevice {
+typedef struct LoopDevice {
unsigned n_ref;
int fd;
int lock_fd;
uint64_t diskseq; /* Block device sequence number, monothonically incremented by the kernel on create/attach, or 0 if we don't know */
uint32_t sector_size;
uint64_t device_size;
-};
+} LoopDevice;
/* Returns true if LoopDevice object is not actually a loopback device but some other block device we just wrap */
#define LOOP_DEVICE_IS_FOREIGN(d) ((d)->nr < 0)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
-#include <stdlib.h>
#include "sd-netlink.h"
+#include "errno-util.h"
#include "log.h"
#include "loopback-setup.h"
#include "missing_network.h"
-#include "netlink-util.h"
#include "time-util.h"
#define LOOPBACK_SETUP_TIMEOUT_USEC (5 * USEC_PER_SEC)
#include "fileio.h"
#include "log.h"
#include "machine-credential.h"
-#include "macro.h"
#include "memory-util.h"
#include "path-util.h"
#include "string-util-fundamental.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <sys/types.h>
+#include "forward.h"
typedef struct MachineCredential {
char *id;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
-#include <sched.h>
#include <sys/mount.h>
#include <unistd.h>
#include "chase.h"
#include "creds-util.h"
#include "fd-util.h"
+#include "fs-util.h"
#include "id128-util.h"
#include "initrd-util.h"
#include "io-util.h"
#include "log.h"
#include "machine-id-setup.h"
-#include "macro.h"
-#include "mkdir.h"
#include "mount-util.h"
#include "mountpoint-util.h"
#include "namespace-util.h"
#include "process-util.h"
#include "stat-util.h"
#include "string-util.h"
+#include "strv.h"
#include "sync-util.h"
#include "umask-util.h"
#include "virt.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
#include "sd-id128.h"
+#include "forward.h"
+
typedef enum MachineIdSetupFlags {
MACHINE_ID_SETUP_FORCE_TRANSIENT = 1 << 0,
MACHINE_ID_SETUP_FORCE_FIRMWARE = 1 << 1,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
+#include "sd-bus.h"
#include "btrfs-util.h"
#include "label-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "sd-bus.h"
+#include "forward.h"
int setup_machine_directory(sd_bus_error *error, bool use_btrfs_subvol, bool use_btrfs_quota);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "conf-parser.h"
#include "macvlan-util.h"
#include "string-table.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
#include <linux/if_link.h>
-#include "macro.h"
+#include "forward.h"
typedef enum MacVlanMode {
NETDEV_MACVLAN_MODE_PRIVATE = MACVLAN_MODE_PRIVATE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <stdlib.h>
#if HAVE_VALGRIND_VALGRIND_H
# include <valgrind/valgrind.h>
#endif
#include "polkit-agent.h"
#include "selinux-util.h"
#include "signal-util.h"
+#include "string-util.h"
void main_prepare(int argc, char *argv[]) {
assert_se(argc > 0 && !isempty(argv[0]));
/* exit with failure if raise() does not immediately abort the program. */
return EXIT_FAILURE;
}
+
+int exit_failure_if_negative(int result) {
+ return result < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
+}
+
+int exit_failure_if_nonzero(int result) {
+ return result < 0 ? EXIT_FAILURE : result;
+}
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdlib.h>
-
+#include "forward.h"
#include "static-destruct.h"
void main_prepare(int argc, char *argv[]);
return result_to_return_value(r); \
}
-static inline int exit_failure_if_negative(int result) {
- return result < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
-}
+int exit_failure_if_negative(int result);
/* Negative return values from impl are mapped to EXIT_FAILURE, and
* everything else means success! */
#define DEFINE_MAIN_FUNCTION(impl) \
_DEFINE_MAIN_FUNCTION(,impl(argc, argv), exit_failure_if_negative, exit_failure_if_negative)
-static inline int exit_failure_if_nonzero(int result) {
- return result < 0 ? EXIT_FAILURE : result;
-}
+int exit_failure_if_nonzero(int result);
/* Zero is mapped to EXIT_SUCCESS, negative values are mapped to EXIT_FAILURE,
* and positive values are propagated.
'coredump-util.c',
'cpu-set-util.c',
'creds-util.c',
+ 'cryptsetup-fido2.c',
+ 'cryptsetup-tpm2.c',
'cryptsetup-util.c',
'daemon-util.c',
'data-fd-util.c',
'resize-fs.c',
'resolve-util.c',
'rm-rf.c',
+ 'seccomp-util.c',
'securebits-util.c',
'selinux-util.c',
'serialize.c',
capture : true)
generated_sources += syscall_list_inc
+shared_sources += syscall_list_inc
if conf.get('ENABLE_UTMP') == 1
shared_sources += files('utmp-wtmp.c')
endif
-if conf.get('HAVE_SECCOMP') == 1
- shared_sources += files('seccomp-util.c')
- shared_sources += syscall_list_inc
-endif
-
if conf.get('HAVE_LIBIPTC') == 1
shared_sources += files('firewall-util-iptables.c')
endif
shared_sources += files('pam-util.c')
endif
-if conf.get('HAVE_LIBFIDO2') == 1 and conf.get('HAVE_LIBCRYPTSETUP') == 1
- shared_sources += files('cryptsetup-fido2.c')
-endif
-
-if conf.get('HAVE_TPM2') == 1 and conf.get('HAVE_LIBCRYPTSETUP') == 1
- shared_sources += files('cryptsetup-tpm2.c')
-endif
-
generate_ip_protocol_list = find_program('generate-ip-protocol-list.sh')
ip_protocol_list_txt = custom_target(
'ip-protocol-list.txt',
#include <sys/stat.h>
#include "errno-util.h"
+#include "label-util.h"
#include "mkdir-label.h"
#include "selinux-util.h"
#include "smack-util.h"
-#include "user-util.h"
int mkdirat_label(int dirfd, const char *path, mode_t mode) {
int r;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <fcntl.h>
-#include <sys/types.h>
-
+#include "forward.h"
#include "mkdir.h"
int mkdirat_label(int dirfd, const char *path, mode_t mode);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <stdlib.h>
#include <sys/mount.h>
#include <unistd.h>
-#include "dirent-util.h"
#include "fd-util.h"
#include "fileio.h"
+#include "format-util.h"
#include "fs-util.h"
-#include "id128-util.h"
#include "log.h"
#include "mkfs-util.h"
#include "mount-util.h"
#include "stat-util.h"
#include "stdio-util.h"
#include "string-util.h"
+#include "strv.h"
#include "tmpfile-util.h"
#include "utf8.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
#include "sd-id128.h"
-#include "strv.h"
+#include "forward.h"
int mkfs_exists(const char *fstype);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
+#include <syslog.h>
+#include "log.h"
#include "module-util.h"
#include "proc-cmdline.h"
#include "strv.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "dlfcn-util.h"
+#include "forward.h"
#if HAVE_KMOD
-#include <libkmod.h>
+#include <libkmod.h> /* IWYU pragma: export */
-#include "macro.h"
-#include "memory-util.h"
+#include "dlfcn-util.h"
extern DLSYM_PROTOTYPE(kmod_list_next);
extern DLSYM_PROTOTYPE(kmod_load_resources);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stdlib.h>
#include <sys/mount.h>
-#include <sys/statvfs.h>
#include <unistd.h>
#include "alloc-util.h"
-#include "bus-util.h"
-#include "cgroup-setup.h"
-#include "cgroup-util.h"
#include "conf-files.h"
#include "dev-setup.h"
-#include "dirent-util.h"
-#include "efi-loader.h"
+#include "efivars.h"
+#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
-#include "fs-util.h"
#include "label-util.h"
#include "log.h"
-#include "macro.h"
#include "mkdir-label.h"
#include "mount-setup.h"
#include "mount-util.h"
#include "mountpoint-util.h"
-#include "nulstr-util.h"
#include "path-util.h"
#include "recurse-dir.h"
-#include "set.h"
#include "smack-util.h"
+#include "string-util.h"
#include "strv.h"
-#include "user-util.h"
+#include "time-util.h"
#include "virt.h"
typedef enum MountMode {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
bool mount_point_is_api(const char *path);
bool mount_point_ignore(const char *path);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <linux/loop.h>
#include <stdlib.h>
#include <sys/mount.h>
#include <sys/stat.h>
-#include <sys/statvfs.h>
#include <unistd.h>
#include "alloc-util.h"
#include "chase.h"
#include "dissect-image.h"
-#include "exec-util.h"
+#include "errno-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
+#include "format-util.h"
#include "fs-util.h"
#include "fstab-util.h"
#include "glyph-util.h"
#include "hashmap.h"
-#include "initrd-util.h"
-#include "label-util.h"
#include "libmount-util.h"
#include "log.h"
#include "missing_syscall.h"
#include "mount-util.h"
#include "mountpoint-util.h"
#include "namespace-util.h"
-#include "parse-util.h"
+#include "os-util.h"
#include "path-util.h"
+#include "pidref.h"
#include "process-util.h"
#include "set.h"
#include "sort-util.h"
#include "stat-util.h"
-#include "stdio-util.h"
-#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "tmpfile-util.h"
return TAKE_FD(mnt_fd);
}
+char* umount_and_rmdir_and_free(char *p) {
+ if (!p)
+ return NULL;
+
+ PROTECT_ERRNO;
+ (void) umount_recursive(p, 0);
+ (void) rmdir(p);
+ return mfree(p);
+}
+
+char* umount_and_free(char *p) {
+ if (!p)
+ return NULL;
+
+ PROTECT_ERRNO;
+ (void) umount_recursive(p, 0);
+ return mfree(p);
+}
+
char* umount_and_unlink_and_free(char *p) {
if (!p)
return NULL;
#pragma once
#include <mntent.h>
-#include <stdio.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include "alloc-util.h"
-#include "dissect-image.h"
-#include "errno-util.h"
-#include "macro.h"
-#include "pidref.h"
+#include "forward.h"
typedef struct SubMount {
char *path;
int mount_flags_to_string(unsigned long flags, char **ret);
/* Useful for usage with _cleanup_(), unmounts, removes a directory and frees the pointer */
-static inline char* umount_and_rmdir_and_free(char *p) {
- if (!p)
- return NULL;
-
- PROTECT_ERRNO;
- (void) umount_recursive(p, 0);
- (void) rmdir(p);
- return mfree(p);
-}
+char* umount_and_rmdir_and_free(char *p);
DEFINE_TRIVIAL_CLEANUP_FUNC(char*, umount_and_rmdir_and_free);
-static inline char* umount_and_free(char *p) {
- if (!p)
- return NULL;
-
- PROTECT_ERRNO;
- (void) umount_recursive(p, 0);
- return mfree(p);
-}
+char* umount_and_free(char *p);
DEFINE_TRIVIAL_CLEANUP_FUNC(char*, umount_and_free);
char* umount_and_unlink_and_free(char *p);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fnmatch.h>
-#include <netinet/ether.h>
+
+#include "sd-device.h"
#include "alloc-util.h"
#include "condition.h"
#include "env-util.h"
+#include "extract-word.h"
#include "log.h"
#include "net-condition.h"
#include "netif-util.h"
-#include "network-util.h"
+#include "set.h"
#include "socket-util.h"
-#include "string-table.h"
+#include "string-util.h"
#include "strv.h"
#include "wifi-util.h"
#pragma once
#include <linux/nl80211.h>
-#include <stdbool.h>
-#include "sd-device.h"
-
-#include "conf-parser.h"
-#include "ether-addr-util.h"
-#include "set.h"
+#include "conf-parser-forward.h"
+#include "forward.h"
typedef struct NetMatch {
Set *hw_addr;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <stdlib.h>
+
#include "sd-device.h"
#include "alloc-util.h"
#include "device-private.h"
+#include "log.h"
#include "netif-naming-scheme.h"
#include "proc-cmdline.h"
#include "string-table.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "sd-device.h"
-
-#include "macro.h"
+#include "forward.h"
/* So here's the deal: net_id is supposed to be an exercise in providing stable names for network devices. However, we
* also want to keep updating the naming scheme used in future versions of net_id. These two goals of course are
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-device.h"
+#include "sd-netlink.h"
+
#include "alloc-util.h"
+#include "conf-parser.h"
#include "device-util.h"
+#include "ether-addr-util.h"
#include "netif-sriov.h"
-#include "netlink-util.h"
#include "parse-util.h"
#include "set.h"
+#include "siphash24.h"
#include "stdio-util.h"
#include "string-table.h"
#include "string-util.h"
#pragma once
#include <linux/if_link.h>
+#include <net/ethernet.h>
-#include "sd-device.h"
-#include "sd-netlink.h"
-
-#include "conf-parser.h"
-#include "ether-addr-util.h"
-#include "hashmap.h"
+#include "conf-parser-forward.h"
+#include "forward.h"
typedef enum SRIOVAttribute {
SR_IOV_VF_MAC,
#include <linux/if.h>
#include <linux/if_arp.h>
+#include "sd-device.h"
+#include "sd-id128.h"
+
#include "alloc-util.h"
#include "arphrd-util.h"
#include "device-util.h"
+#include "ether-addr-util.h"
#include "hexdecoct.h"
#include "log-link.h"
#include "memory-util.h"
#include "netif-util.h"
#include "siphash24.h"
#include "sparse-endian.h"
+#include "string-util.h"
#include "strv.h"
#define SHORTEN_IFNAME_HASH_KEY SD_ID128_MAKE(e1,90,a4,04,a8,ef,4b,51,8c,cc,c3,3a,9f,11,fc,a2)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <inttypes.h>
-#include <stdbool.h>
-
-#include "sd-device.h"
-#include "sd-id128.h"
-
-#include "ether-addr-util.h"
+#include "forward.h"
bool netif_has_carrier(uint8_t operstate, unsigned flags);
int net_get_type_string(sd_device *device, uint16_t iftype, char **ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-event.h"
+
+#include "alloc-util.h"
#include "async.h"
+#include "constants.h"
+#include "errno-util.h"
#include "fd-util.h"
+#include "fdset.h"
#include "log.h"
#include "notify-recv.h"
+#include "pidref.h"
#include "process-util.h"
#include "socket-util.h"
#include "strv.h"
-#include "user-util.h"
int notify_socket_prepare(
sd_event *event,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/socket.h>
-
-#include "sd-event.h"
-
-#include "fdset.h"
-#include "pidref.h"
+#include "forward.h"
int notify_socket_prepare(
sd_event *event,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-
#include "alloc-util.h"
#include "extract-word.h"
-#include "log.h"
#include "namespace-util.h"
#include "nsflags.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "missing_sched.h"
/* The combination of all namespace flags defined by the kernel. The right type for this isn't clear. setns() and
#include "sd-varlink.h"
+#include "alloc-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "json-util.h"
#include "namespace-util.h"
#include "nsresource.h"
#include "process-util.h"
+#include "string-util.h"
static int make_pid_name(char **ret) {
char comm[TASK_COMM_LEN];
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <inttypes.h>
+#include "forward.h"
int nsresource_allocate_userns(const char *name, uint64_t size);
int nsresource_register_userns(const char *name, int userns_fd);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <sched.h>
#include "alloc-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "log.h"
-#include "macro.h"
#include "missing_syscall.h"
#include "numa-util.h"
#include "parse-util.h"
#pragma once
#include "cpu-set-util.h"
+#include "forward.h"
#include "missing_syscall.h"
static inline bool mpol_is_valid(int t) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <fcntl.h>
-
#include "alloc-util.h"
#include "escape.h"
#include "extract-word.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-
+#include "forward.h"
#include "list.h"
-#include "macro.h"
-#include "memory-util.h"
typedef enum OpenFileFlag {
OPENFILE_READ_ONLY = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <endian.h>
-
#include "alloc-util.h"
#include "ask-password-api.h"
#include "fd-util.h"
#pragma once
#include "ask-password-api.h"
+#include "forward.h"
#include "iovec-util.h"
-#include "memory-util.h"
#include "sha256.h"
typedef enum CertificateSourceType {
#define X509_FINGERPRINT_SIZE SHA256_DIGEST_SIZE
#if HAVE_OPENSSL
-# include <openssl/bio.h>
-# include <openssl/bn.h>
-# include <openssl/crypto.h>
-# include <openssl/err.h>
-# include <openssl/evp.h>
-# include <openssl/opensslv.h>
-# include <openssl/pkcs7.h>
-# include <openssl/ssl.h>
-# include <openssl/ui.h>
-# include <openssl/x509v3.h>
+# include <openssl/bio.h> /* IWYU pragma: export */
+# include <openssl/bn.h> /* IWYU pragma: export */
+# include <openssl/crypto.h> /* IWYU pragma: export */
+# include <openssl/err.h> /* IWYU pragma: export */
+# include <openssl/evp.h> /* IWYU pragma: export */
+# include <openssl/opensslv.h> /* IWYU pragma: export */
+# include <openssl/pkcs7.h> /* IWYU pragma: export */
+# include <openssl/ssl.h> /* IWYU pragma: export */
+# include <openssl/ui.h> /* IWYU pragma: export */
+# include <openssl/x509v3.h> /* IWYU pragma: export */
# ifndef OPENSSL_VERSION_MAJOR
/* OPENSSL_VERSION_MAJOR macro was added in OpenSSL 3. Thus, if it doesn't exist, we must be before OpenSSL 3. */
# define OPENSSL_VERSION_MAJOR 1
# endif
# if OPENSSL_VERSION_MAJOR >= 3
-# include <openssl/core_names.h>
-# include <openssl/kdf.h>
-# include <openssl/param_build.h>
-# include <openssl/provider.h>
-# include <openssl/store.h>
+# include <openssl/core_names.h> /* IWYU pragma: export */
+# include <openssl/kdf.h> /* IWYU pragma: export */
+# include <openssl/param_build.h> /* IWYU pragma: export */
+# include <openssl/provider.h> /* IWYU pragma: export */
+# include <openssl/store.h> /* IWYU pragma: export */
# endif
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL_MACRO(void*, OPENSSL_free, NULL);
#include <sys/auxv.h>
#include "escape.h"
+#include "format-util.h"
#include "hostname-setup.h"
#include "id128-util.h"
#include "osc-context.h"
#include "sd-id128.h"
-#include "assert-util.h"
-#include "macro.h"
+#include "forward.h"
int osc_context_open_boot(char **ret_seq);
int osc_context_open_container(const char *name, char **ret_seq, sd_id128_t *ret_context_id);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "output-mode.h"
#include "string-table.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-json.h"
-
-#include "macro.h"
+#include "forward.h"
typedef enum OutputMode {
OUTPUT_SHORT,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stddef.h>
-#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
-#include <sys/prctl.h>
#include <unistd.h>
#include "sd-login.h"
#include "io-util.h"
#include "locale-util.h"
#include "log.h"
-#include "macro.h"
#include "pager.h"
#include "process-util.h"
-#include "rlimit-util.h"
#include "signal-util.h"
#include "string-util.h"
#include "strv.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "macro.h"
+#include "forward.h"
typedef enum PagerFlags {
PAGER_DISABLE = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <security/pam_ext.h>
-#include <stdlib.h>
#include <syslog.h>
+#include "sd-bus.h"
+
#include "alloc-util.h"
#include "bus-internal.h"
#include "errno-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
-#include "macro.h"
#include "pam-util.h"
#include "process-util.h"
#include "stdio-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <security/pam_modules.h>
+#include <security/pam_modules.h> /* IWYU pragma: export */
#include <syslog.h>
-#include "sd-bus.h"
-
-#include "macro.h"
+#include "forward.h"
void pam_log_setup(void);
#include "parse-util.h"
#include "path-util.h"
#include "signal-util.h"
-#include "stdio-util.h"
#include "string-table.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "sd-json.h"
+#include "forward.h"
int parse_boolean_argument(const char *optname, const char *s, bool *ret);
int parse_tristate_argument(const char *optname, const char *s, int *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdint.h>
+#include "forward.h"
typedef enum PathSimplifyWarnFlags {
PATH_CHECK_FATAL = 1 << 0, /* If not set, then error message is appended with 'ignoring'. */
#include "dlfcn-util.h"
#include "errno-util.h"
#include "log.h"
-#include "macro.h"
#include "memory-util.h"
#include "password-quality-util.h"
#include "strv.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "macro.h"
+#include "forward.h"
#if HAVE_PASSWDQC
#include <passwdqc.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <stdio.h>
#include <unistd.h>
#include "alloc-util.h"
#include "dlfcn-util.h"
#include "errno-util.h"
#include "log.h"
-#include "macro.h"
-#include "memory-util.h"
#include "password-quality-util.h"
#include "string-util.h"
#include "strv.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "macro.h"
+#include "forward.h"
#if HAVE_PWQUALITY
-/* pwquality.h uses size_t but doesn't include sys/types.h on its own */
#include <pwquality.h>
-#include <sys/types.h>
#include "dlfcn-util.h"
-#include "memory-util.h"
extern DLSYM_PROTOTYPE(pwquality_check);
extern DLSYM_PROTOTYPE(pwquality_default_settings);
#if HAVE_PASSWDQC
-#include "password-quality-util-passwdqc.h"
+#include "password-quality-util-passwdqc.h" /* IWYU pragma: export */
#elif HAVE_PWQUALITY
-#include "password-quality-util-pwquality.h"
+#include "password-quality-util-pwquality.h" /* IWYU pragma: export */
#else
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "dlfcn-util.h"
+#include "hash-funcs.h"
#include "log.h"
#include "pcre2-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "hash-funcs.h"
-#include "macro.h"
+#include "forward.h"
#if HAVE_PCRE2
#include "dlfcn-util.h"
#define PCRE2_CODE_UNIT_WIDTH 8
-#include <pcre2.h>
+#include <pcre2.h> /* IWYU pragma: export */
extern DLSYM_PROTOTYPE(pcre2_match_data_create);
extern DLSYM_PROTOTYPE(pcre2_match_data_free);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-device.h"
+#include "sd-id128.h"
#include "alloc-util.h"
#include "blkid-util.h"
#include "log.h"
#include "mountpoint-util.h"
#include "pcrextend-util.h"
+#include "string-util.h"
#include "strv.h"
static int device_get_file_system_word(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
-
-#include "macro-fundamental.h"
#include "openssl-util.h"
#include "sparse-endian.h"
#include "uki.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <fcntl.h>
-
#include "alloc-util.h"
#include "ask-password-api.h"
#include "dlfcn-util.h"
#include "env-util.h"
#include "escape.h"
-#include "fd-util.h"
#include "format-table.h"
-#include "io-util.h"
#include "log.h"
#include "memory-util.h"
-#if HAVE_OPENSSL
#include "openssl-util.h"
-#endif
#include "pkcs11-util.h"
#include "random-util.h"
#include "string-util.h"
DLSYM_PROTOTYPE(p11_kit_uri_new) = NULL;
DLSYM_PROTOTYPE(p11_kit_uri_parse) = NULL;
-int dlopen_p11kit(void) {
- ELF_NOTE_DLOPEN("p11-kit",
- "Support for PKCS11 hardware tokens",
- ELF_NOTE_DLOPEN_PRIORITY_SUGGESTED,
- "libp11-kit.so.0");
-
- return dlopen_many_sym_or_warn(
- &p11kit_dl,
- "libp11-kit.so.0", LOG_DEBUG,
- DLSYM_ARG(p11_kit_module_get_name),
- DLSYM_ARG(p11_kit_modules_finalize_and_release),
- DLSYM_ARG(p11_kit_modules_load_and_initialize),
- DLSYM_ARG(p11_kit_strerror),
- DLSYM_ARG(p11_kit_uri_format),
- DLSYM_ARG(p11_kit_uri_free),
- DLSYM_ARG(p11_kit_uri_get_attributes),
- DLSYM_ARG(p11_kit_uri_get_attribute),
- DLSYM_ARG(p11_kit_uri_set_attribute),
- DLSYM_ARG(p11_kit_uri_get_module_info),
- DLSYM_ARG(p11_kit_uri_get_slot_info),
- DLSYM_ARG(p11_kit_uri_get_token_info),
- DLSYM_ARG(p11_kit_uri_match_token_info),
- DLSYM_ARG(p11_kit_uri_message),
- DLSYM_ARG(p11_kit_uri_new),
- DLSYM_ARG(p11_kit_uri_parse));
-}
-
int uri_from_string(const char *p, P11KitUri **ret) {
_cleanup_(sym_p11_kit_uri_freep) P11KitUri *uri = NULL;
int r;
}
#endif
+int dlopen_p11kit(void) {
+#if HAVE_P11KIT
+ ELF_NOTE_DLOPEN("p11-kit",
+ "Support for PKCS11 hardware tokens",
+ ELF_NOTE_DLOPEN_PRIORITY_SUGGESTED,
+ "libp11-kit.so.0");
+
+ return dlopen_many_sym_or_warn(
+ &p11kit_dl,
+ "libp11-kit.so.0", LOG_DEBUG,
+ DLSYM_ARG(p11_kit_module_get_name),
+ DLSYM_ARG(p11_kit_modules_finalize_and_release),
+ DLSYM_ARG(p11_kit_modules_load_and_initialize),
+ DLSYM_ARG(p11_kit_strerror),
+ DLSYM_ARG(p11_kit_uri_format),
+ DLSYM_ARG(p11_kit_uri_free),
+ DLSYM_ARG(p11_kit_uri_get_attributes),
+ DLSYM_ARG(p11_kit_uri_get_attribute),
+ DLSYM_ARG(p11_kit_uri_set_attribute),
+ DLSYM_ARG(p11_kit_uri_get_module_info),
+ DLSYM_ARG(p11_kit_uri_get_slot_info),
+ DLSYM_ARG(p11_kit_uri_get_token_info),
+ DLSYM_ARG(p11_kit_uri_match_token_info),
+ DLSYM_ARG(p11_kit_uri_message),
+ DLSYM_ARG(p11_kit_uri_new),
+ DLSYM_ARG(p11_kit_uri_parse));
+#else
+ return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "p11kit support is not compiled in.");
+#endif
+}
+
int pkcs11_list_tokens(void) {
#if HAVE_P11KIT
_cleanup_(table_unrefp) Table *t = NULL;
#if HAVE_OPENSSL
# include <openssl/evp.h>
-# include <openssl/x509.h>
#endif
-#include <stdbool.h>
#if HAVE_P11KIT
-# include <p11-kit/p11-kit.h>
-# include <p11-kit/uri.h>
+# include <p11-kit/p11-kit.h> /* IWYU pragma: export */
+# include <p11-kit/uri.h> /* IWYU pragma: export */
#endif
#include "ask-password-api.h"
#include "dlfcn-util.h"
-#include "log.h"
-#include "memory-util.h"
-#include "time-util.h"
+#include "forward.h"
bool pkcs11_uri_valid(const char *uri);
P11KitUri *uri,
void *userdata);
-int dlopen_p11kit(void);
-
-#else
-
-static inline int dlopen_p11kit(void) {
- return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "p11kit support is not compiled in.");
-}
-
#endif
+int dlopen_p11kit(void);
+
typedef struct {
const char *friendly_name;
usec_t until;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "alloc-util.h"
#include "fd-util.h"
#include "io-util.h"
#include "log.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
-
#include "errno-util.h"
+#include "forward.h"
int plymouth_connect(int flags);
int plymouth_send_raw(const void *raw, size_t size, int flags);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <poll.h>
#include <signal.h>
-#include <stdlib.h>
#include <unistd.h>
+#include "bus-util.h"
#include "exec-util.h"
#include "fd-util.h"
#include "io-util.h"
#include "log.h"
-#include "macro.h"
#include "polkit-agent.h"
#include "process-util.h"
#include "stdio-util.h"
-#include "time-util.h"
#if ENABLE_POLKIT
static pid_t agent_pid = 0;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "bus-util.h"
+#include "forward.h"
int polkit_agent_open(void);
void polkit_agent_close(void);
#include "alloc-util.h"
#include "fs-util.h"
-#include "log.h"
#include "nulstr-util.h"
#include "portable-util.h"
#include "string-util.h"
#pragma once
#include "constants.h"
-#include "macro.h"
+#include "forward.h"
#define PORTABLE_PROFILE_DIRS CONF_PATHS_NULSTR("systemd/portable/profile")
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <sys/utsname.h>
+#include <unistd.h>
#include "alloc-util.h"
#include "color-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "log.h"
-#include "pager.h"
#include "path-util.h"
#include "pretty-print.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include <stdio.h>
#include <string.h>
#include "ansi-color.h"
-#include "assert-util.h"
#include "fileio.h"
+#include "forward.h"
#include "glyph-util.h"
-#include "terminal-util.h"
#define CYLON_BUFFER_EXTRA (2*STRLEN(ANSI_RED) + STRLEN(ANSI_HIGHLIGHT_RED) + 2*STRLEN(ANSI_NORMAL))
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <limits.h>
#include <signal.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
#include <string.h>
-#include <sys/epoll.h>
#include <sys/ioctl.h>
-#include <sys/time.h>
#include <termios.h>
#include <unistd.h>
#include "fd-util.h"
#include "io-util.h"
#include "log.h"
-#include "macro.h"
#include "ptyfwd.h"
#include "stat-util.h"
+#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
#include "time-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "sd-event.h"
-
-#include "memory-util.h"
+#include "forward.h"
typedef struct PTYForward PTYForward;
#if HAVE_QRENCODE
#include <qrencode.h>
+#include <stdio.h>
#include "ansi-color.h"
#include "dlfcn-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <limits.h>
-#include <stdbool.h>
-#include <stdio.h>
+#include "forward.h"
#if HAVE_QRENCODE
int dlopen_qrencode(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <stdint.h>
#include <sys/quota.h>
#include <sys/stat.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <inttypes.h>
-#include <sys/quota.h>
-#include <sys/types.h>
+#include <sys/quota.h> /* IWYU pragma: export */
+
+#include "forward.h"
/* Wrapper around the QCMD() macro of linux/quota.h that removes some undefined behaviour. A typical quota
* command such as QCMD(Q_GETQUOTA, USRQUOTA) cannot be resolved on platforms where "int" is 32-bit, as it is
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
+#include <linux/reboot.h>
#include <stdint.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
+#include <sys/reboot.h>
#include <unistd.h>
#if HAVE_XENCTRL
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
bool reboot_parameter_is_valid(const char *parameter);
int update_reboot_parameter_and_warn(const char *parameter, bool keep);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-
#include "alloc-util.h"
-#include "memory-util.h"
#include "random-util.h"
#include "recovery-key.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
+
/* 256 bit keys = 32 bytes */
#define RECOVERY_KEY_MODHEX_RAW_LENGTH 32
#include <sys/ioctl.h>
#include <sys/vfs.h>
-#include "blockdev-util.h"
-#include "fs-util.h"
-#include "log.h"
#include "missing_fs.h"
#include "missing_magic.h"
#include "missing_xfs.h"
#include "resize-fs.h"
#include "stat-util.h"
+#include "stdio-util.h"
+#include "string-util-fundamental.h"
int resize_fs(int fd, uint64_t sz, uint64_t *ret_size) {
struct statfs sfs;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <inttypes.h>
-
+#include "forward.h"
#include "stat-util.h"
int resize_fs(int fd, uint64_t sz, uint64_t *ret_size);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "conf-parser.h"
+#include "in-addr-util.h"
#include "resolve-util.h"
#include "string-table.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "conf-parser.h"
-#include "in-addr-util.h"
-#include "macro.h"
+#include "conf-parser-forward.h"
+#include "forward.h"
/* 127.0.0.53 in native endian (The IP address we listen on with the full DNS stub, i.e. that does LLMNR/mDNS, and stuff) */
#define INADDR_DNS_STUB ((in_addr_t) 0x7f000035U)
/* 127.0.0.2 is an address we always map to the local hostname. This is different from 127.0.0.1 which maps to "localhost" */
#define INADDR_LOCALADDRESS ((in_addr_t) 0x7f000002U)
-typedef enum DnsCacheMode DnsCacheMode;
-
-enum DnsCacheMode {
+typedef enum DnsCacheMode {
DNS_CACHE_MODE_NO,
DNS_CACHE_MODE_YES,
DNS_CACHE_MODE_NO_NEGATIVE,
_DNS_CACHE_MODE_MAX,
_DNS_CACHE_MODE_INVALID = -EINVAL,
-};
-
-typedef enum ResolveSupport ResolveSupport;
-typedef enum DnssecMode DnssecMode;
-typedef enum DnsOverTlsMode DnsOverTlsMode;
+} DnsCacheMode;
/* Do not change the order, see link_get_llmnr_support() or link_get_mdns_support(). */
-enum ResolveSupport {
+typedef enum ResolveSupport {
RESOLVE_SUPPORT_NO,
RESOLVE_SUPPORT_RESOLVE,
RESOLVE_SUPPORT_YES,
_RESOLVE_SUPPORT_MAX,
_RESOLVE_SUPPORT_INVALID = -EINVAL,
-};
+} ResolveSupport;
-enum DnssecMode {
+typedef enum DnssecMode {
/* No DNSSEC validation is done */
DNSSEC_NO,
_DNSSEC_MODE_MAX,
_DNSSEC_MODE_INVALID = -EINVAL,
-};
+} DnssecMode;
-enum DnsOverTlsMode {
+typedef enum DnsOverTlsMode {
/* No connection is made for DNS-over-TLS */
DNS_OVER_TLS_NO,
_DNS_OVER_TLS_MODE_MAX,
_DNS_OVER_TLS_MODE_INVALID = -EINVAL,
-};
+} DnsOverTlsMode;
CONFIG_PARSER_PROTOTYPE(config_parse_resolve_support);
CONFIG_PARSER_PROTOTYPE(config_parse_dnssec_mode);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <stdbool.h>
-#include <stddef.h>
#include <unistd.h>
#include "alloc-util.h"
#include "fd-util.h"
#include "fs-util.h"
#include "log.h"
-#include "macro.h"
#include "missing_magic.h"
#include "mountpoint-util.h"
#include "path-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <fcntl.h>
-#include <sys/stat.h>
-
-#include "memory-util.h"
+#include "forward.h"
typedef enum RemoveFlags {
REMOVE_ONLY_DIRECTORIES = 1 << 0, /* Only remove empty directories, no files */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
#include <linux/seccomp.h>
-#include <stddef.h>
+#include <sched.h>
#include <sys/mman.h>
#include <sys/prctl.h>
#include <sys/shm.h>
#include <sys/stat.h>
-/* clang-format off */
-/* include missing_syscall_def.h earlier to make __SNR_foo mapped to __NR_foo. */
-#include "missing_syscall_def.h"
-#include <seccomp.h>
-/* clang-format on */
-
#include "af-list.h"
#include "alloc-util.h"
#include "env-util.h"
#include "errno-list.h"
#include "log.h"
-#include "macro.h"
#include "namespace-util.h"
#include "nsflags.h"
#include "nulstr-util.h"
+#include "parse-util.h"
#include "process-util.h"
#include "seccomp-util.h"
#include "set.h"
#include "string-util.h"
#include "strv.h"
+#if HAVE_SECCOMP
+
/* This array will be modified at runtime as seccomp_restrict_archs is called. */
uint32_t seccomp_local_archs[] = {
return 0;
}
+
+#endif
+
+bool seccomp_errno_or_action_is_valid(int n) {
+ return n == SECCOMP_ERROR_NUMBER_KILL || errno_is_valid(n);
+}
+
+int seccomp_parse_errno_or_action(const char *p) {
+ if (streq_ptr(p, "kill"))
+ return SECCOMP_ERROR_NUMBER_KILL;
+ return parse_errno(p);
+}
+
+const char* seccomp_errno_or_action_to_string(int num) {
+ if (num == SECCOMP_ERROR_NUMBER_KILL)
+ return "kill";
+ return errno_to_name(num);
+}
#pragma once
#if HAVE_SECCOMP
-#include <seccomp.h>
+#include <seccomp.h> /* IWYU pragma: export */
#endif
-#include <stdbool.h>
-#include <stdint.h>
-#include "errno-list.h"
#include "errno-util.h"
-#include "parse-util.h"
-#include "set.h"
-#include "string-util.h"
+#include "forward.h"
#if HAVE_SECCOMP
SECCOMP_ERROR_NUMBER_KILL = INT_MAX - 1,
};
-static inline bool seccomp_errno_or_action_is_valid(int n) {
- return n == SECCOMP_ERROR_NUMBER_KILL || errno_is_valid(n);
-}
+bool seccomp_errno_or_action_is_valid(int n);
-static inline int seccomp_parse_errno_or_action(const char *p) {
- if (streq_ptr(p, "kill"))
- return SECCOMP_ERROR_NUMBER_KILL;
- return parse_errno(p);
-}
+int seccomp_parse_errno_or_action(const char *p);
-static inline const char* seccomp_errno_or_action_to_string(int num) {
- if (num == SECCOMP_ERROR_NUMBER_KILL)
- return "kill";
- return errno_to_name(num);
-}
+const char* seccomp_errno_or_action_to_string(int num);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <stdio.h>
#include "alloc-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
#include <linux/securebits.h>
-#include <stdbool.h>
+
+#include "forward.h"
int secure_bits_to_string_alloc(int i, char **s);
int secure_bits_from_string(const char *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <stddef.h>
#include <string.h>
+#include <sys/socket.h>
#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
#include <sys/un.h>
#include <syslog.h>
#include "errno-util.h"
#include "fd-util.h"
#include "label.h"
+#include "label-util.h"
#include "log.h"
-#include "macro.h"
#include "mallinfo-util.h"
#include "path-util.h"
#include "selinux-util.h"
-#include "stdio-util.h"
#include "string-util.h"
#include "time-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <fcntl.h>
-#include <stdbool.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-
-#include "assert-util.h"
-#include "label-util.h"
-#include "macro.h"
+#include "forward.h"
#if HAVE_SELINUX
-#include <selinux/selinux.h>
-
-#include "memory-util.h"
+#include <selinux/selinux.h> /* IWYU pragma: export */
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(char*, freecon, NULL);
#else
#include <fcntl.h>
+#include "sd-id128.h"
+
#include "alloc-util.h"
#include "env-util.h"
#include "escape.h"
+#include "extract-word.h"
#include "fd-util.h"
+#include "fdset.h"
#include "fileio.h"
+#include "format-util.h"
#include "hexdecoct.h"
+#include "image-policy.h"
+#include "log.h"
#include "memfd-util.h"
#include "missing_mman.h"
-#include "missing_syscall.h"
#include "parse-util.h"
-#include "process-util.h"
+#include "pidref.h"
+#include "ratelimit.h"
#include "serialize.h"
+#include "set.h"
+#include "string-util.h"
#include "strv.h"
+#include "time-util.h"
int serialize_item(FILE *f, const char *key, const char *value) {
assert(f);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdio.h>
-
-#include "sd-id128.h"
-
-#include "fdset.h"
-#include "image-policy.h"
-#include "macro.h"
-#include "pidref.h"
-#include "ratelimit.h"
-#include "set.h"
-#include "string-util.h"
-#include "time-util.h"
+#include "forward.h"
int serialize_item(FILE *f, const char *key, const char *value);
int serialize_item_escaped(FILE *f, const char *key, const char *value);
#include "alloc-util.h"
#include "build.h"
+#include "bus-object.h"
#include "log.h"
#include "pretty-print.h"
#include "service-util.h"
-#include "terminal-util.h"
static int help(const char *program_path, const char *service, const char *description, bool bus_introspect) {
_cleanup_free_ char *link = NULL;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "bus-object.h"
+#include "forward.h"
int service_parse_argv(
const char *service,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <sys/statvfs.h>
+#include <unistd.h>
#include "acl-util.h"
#include "alloc-util.h"
#include "dirent-util.h"
#include "fd-util.h"
#include "fileio.h"
+#include "fs-util.h"
#include "log.h"
#include "missing_magic.h"
#include "shift-uid.h"
#include "stat-util.h"
+#include "string-util.h"
#include "user-util.h"
/* While we are chmod()ing a directory tree, we set the top-level UID base to this "busy" base, so that we can always
#pragma once
-#include <sys/types.h>
+#include "forward.h"
int path_patch_uid(const char *path, uid_t shift, uid_t range);
#include "alloc-util.h"
#include "conf-parser.h"
-#include "constants.h"
-#include "device-util.h"
-#include "devnum-util.h"
-#include "errno-util.h"
#include "extract-word.h"
-#include "fd-util.h"
#include "fileio.h"
#include "hibernate-util.h"
#include "log.h"
-#include "macro.h"
-#include "path-util.h"
#include "sleep-config.h"
-#include "stat-util.h"
-#include "stdio-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
return 0;
}
+bool SLEEP_NEEDS_MEM_SLEEP(const SleepConfig *sc, SleepOperation operation) {
+ assert(sc);
+ assert(operation >= 0 && operation < _SLEEP_OPERATION_CONFIG_MAX);
+
+ /* As per https://docs.kernel.org/admin-guide/pm/sleep-states.html#basic-sysfs-interfaces-for-system-suspend-and-hibernation,
+ * /sys/power/mem_sleep is honored if /sys/power/state is set to "mem" (common for suspend)
+ * or /sys/power/disk is set to "suspend" (hybrid-sleep). */
+
+ return strv_contains(sc->states[operation], "mem") ||
+ strv_contains(sc->modes[operation], "suspend");
+}
+
int sleep_state_supported(char * const *states) {
_cleanup_free_ char *supported_sysfs = NULL;
const char *found;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "strv.h"
-#include "time-util.h"
+#include "forward.h"
typedef enum SleepOperation {
SLEEP_SUSPEND,
int parse_sleep_config(SleepConfig **sleep_config);
-static inline bool SLEEP_NEEDS_MEM_SLEEP(const SleepConfig *sc, SleepOperation operation) {
- assert(sc);
- assert(operation >= 0 && operation < _SLEEP_OPERATION_CONFIG_MAX);
-
- /* As per https://docs.kernel.org/admin-guide/pm/sleep-states.html#basic-sysfs-interfaces-for-system-suspend-and-hibernation,
- * /sys/power/mem_sleep is honored if /sys/power/state is set to "mem" (common for suspend)
- * or /sys/power/disk is set to "suspend" (hybrid-sleep). */
-
- return strv_contains(sc->states[operation], "mem") ||
- strv_contains(sc->modes[operation], "suspend");
-}
+bool SLEEP_NEEDS_MEM_SLEEP(const SleepConfig *sc, SleepOperation operation);
typedef enum SleepSupport {
SLEEP_SUPPORTED,
Author: Auke Kok <auke-jan.h.kok@intel.com>
***/
-#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
-#include <sys/xattr.h>
#include <unistd.h>
#include "alloc-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "label.h"
+#include "label-util.h"
#include "log.h"
-#include "macro.h"
#include "path-util.h"
#include "process-util.h"
#include "smack-util.h"
-#include "stdio-util.h"
#include "string-table.h"
#include "xattr-util.h"
-#if ENABLE_SMACK
-
#define SMACK_FLOOR_LABEL "_"
#define SMACK_STAR_LABEL "*"
bool mac_smack_use(void) {
+#if ENABLE_SMACK
static int cached_use = -1;
if (cached_use < 0)
cached_use = access("/sys/fs/smackfs/", F_OK) >= 0;
return cached_use;
+#else
+ return false;
+#endif
}
+#if ENABLE_SMACK
+
static const char* const smack_attr_table[_SMACK_ATTR_MAX] = {
[SMACK_ATTR_ACCESS] = "security.SMACK64",
[SMACK_ATTR_EXEC] = "security.SMACK64EXEC",
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(smack_attr, SmackAttr);
+#endif
+
int mac_smack_read_at(int fd, const char *path, SmackAttr attr, char **ret) {
+#if ENABLE_SMACK
assert(fd >= 0 || fd == AT_FDCWD);
assert(attr >= 0 && attr < _SMACK_ATTR_MAX);
assert(ret);
}
return getxattr_at_malloc(fd, path, smack_attr_to_string(attr), /* at_flags = */ 0, ret, /* ret_size= */ NULL);
+#else
+return -EOPNOTSUPP;
+#endif
}
int mac_smack_apply_at(int fd, const char *path, SmackAttr attr, const char *label) {
+#if ENABLE_SMACK
assert(fd >= 0 || fd == AT_FDCWD);
assert(attr >= 0 && attr < _SMACK_ATTR_MAX);
return xremovexattr(fd, path, /* at_flags = */ 0, smack_attr_to_string(attr));
return xsetxattr(fd, path, /* at_flags = */ 0, smack_attr_to_string(attr), label);
+#else
+ return 0;
+#endif
}
int mac_smack_apply_pid(pid_t pid, const char *label) {
+#if ENABLE_SMACK
const char *p;
assert(pid >= 0);
p = procfs_file_alloca(pid, "attr/current");
return write_string_file(p, label, WRITE_STRING_FILE_DISABLE_BUFFER);
+#else
+ return 0;
+#endif
}
+#if ENABLE_SMACK
+
static int smack_fix_fd(
int fd,
const char *label_path,
return 0;
}
+#endif
+
int mac_smack_fix_full(
int atfd,
const char *inode_path,
const char *label_path,
LabelFixFlags flags) {
+#if ENABLE_SMACK
_cleanup_close_ int opened_fd = -EBADF;
_cleanup_free_ char *p = NULL;
int r, inode_fd;
}
return smack_fix_fd(inode_fd, label_path, flags);
-}
+#else
+ return 0;
#endif
+}
+
+int mac_smack_fix(const char *path, LabelFixFlags flags) {
+ return mac_smack_fix_full(AT_FDCWD, path, path, flags);
+}
int renameat_and_apply_smack_floor_label(int fdf, const char *from, int fdt, const char *to) {
Author: Auke Kok <auke-jan.h.kok@intel.com>
***/
-#include <errno.h>
-#include <stdbool.h>
-#include <sys/types.h>
-
-#include "label-util.h"
-#include "macro.h"
+#include "forward.h"
typedef enum SmackAttr {
SMACK_ATTR_ACCESS,
_SMACK_ATTR_INVALID = -EINVAL,
} SmackAttr;
-#if ENABLE_SMACK
bool mac_smack_use(void);
int mac_smack_read_at(int fd, const char *path, SmackAttr attr, char **ret);
int mac_smack_apply_pid(pid_t pid, const char *label);
int mac_smack_fix_full(int atfd, const char *inode_path, const char *label_path, LabelFixFlags flags);
-#else
-static inline bool mac_smack_use(void) {
- return false;
-}
-
-static inline int mac_smack_read_at(int fd, const char *path, SmackAttr attr, char **ret) {
- return -EOPNOTSUPP;
-}
-
-static inline int mac_smack_apply_at(int fd, const char *path, SmackAttr attr, const char *label) {
- return 0;
-}
-
-static inline int mac_smack_apply_pid(pid_t pid, const char *label) {
- return 0;
-}
-
-static inline int mac_smack_fix_full(int atfd, const char *inode_path, const char *label_path, LabelFixFlags flags) {
- return 0;
-}
-#endif
int mac_smack_init(void);
return mac_smack_apply_at(fd, NULL, attr, label);
}
-static inline int mac_smack_fix(const char *path, LabelFixFlags flags) {
- return mac_smack_fix_full(AT_FDCWD, path, path, flags);
-}
+int mac_smack_fix(const char *path, LabelFixFlags flags);
int renameat_and_apply_smack_floor_label(int fdf, const char *from, int fdt, const char *to);
static inline int rename_and_apply_smack_floor_label(const char *from, const char *to) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <stdio.h>
+
#include "alloc-util.h"
-#include "assert-util.h"
#include "fileio.h"
-#include "macro.h"
#include "smbios11.h"
#include "virt.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/types.h>
+#include "forward.h"
int read_smbios11_field(unsigned i, size_t max_size, char **ret_data, size_t *ret_size);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <netinet/in.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <string.h>
-#include <sys/un.h>
#include <unistd.h>
-#include "alloc-util.h"
+#include "errno-util.h"
#include "fd-util.h"
#include "fs-util.h"
#include "log.h"
-#include "macro.h"
-#include "missing_socket.h"
#include "mkdir-label.h"
#include "selinux-util.h"
#include "socket-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <arpa/inet.h>
-#include <errno.h>
#include <linux/net_namespace.h>
#include <linux/unix_diag.h>
-#include <net/if.h>
#include <string.h>
#include <sys/stat.h>
#include "sd-netlink.h"
#include "alloc-util.h"
-#include "errno-util.h"
#include "extract-word.h"
#include "fd-util.h"
#include "log.h"
-#include "memory-util.h"
#include "namespace-util.h"
#include "netlink-sock-diag.h"
#include "netlink-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "in-addr-util.h"
-#include "macro.h"
-#include "socket-util.h"
int make_socket_fd(int log_level, const char* address, int type, int flags);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdlib.h>
#include <sys/utsname.h>
+#include <unistd.h>
#include "sd-id128.h"
#include "alloc-util.h"
#include "architecture.h"
#include "chase.h"
-#include "fd-util.h"
#include "format-util.h"
#include "fs-util.h"
#include "hostname-setup.h"
#include "hostname-util.h"
#include "id128-util.h"
-#include "macro.h"
#include "os-util.h"
-#include "path-lookup.h"
#include "path-util.h"
+#include "runtime-scope.h"
#include "specifier.h"
#include "string-util.h"
#include "strv.h"
return strdup_to(ret, p);
}
+char* specifier_escape(const char *string) {
+ return strreplace(string, "%", "%%");
+}
+
int specifier_escape_strv(char **l, char ***ret) {
_cleanup_strv_free_ char **z = NULL;
char **p, **q;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "string-util.h"
+#include "forward.h"
typedef int (*SpecifierCallback)(char specifier, const void *data, const char *root, const void *userdata, char **ret);
{ 'T', specifier_tmp_dir, NULL }, \
{ 'V', specifier_var_tmp_dir, NULL }
-static inline char* specifier_escape(const char *string) {
- return strreplace(string, "%", "%%");
-}
+char* specifier_escape(const char *string);
int specifier_escape_strv(char **l, char ***ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
-#include <limits.h>
-#include <stdbool.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <unistd.h>
#include "alloc-util.h"
#include "base-filesystem.h"
#include "chase.h"
-#include "creds-util.h"
+#include "errno-util.h"
#include "fd-util.h"
-#include "initrd-util.h"
#include "log.h"
#include "missing_syscall.h"
#include "mkdir-label.h"
#include "mount-util.h"
#include "mountpoint-util.h"
-#include "path-util.h"
#include "rm-rf.h"
-#include "stdio-util.h"
-#include "string-util.h"
-#include "strv.h"
+#include "stat-util.h"
#include "switch-root.h"
-#include "user-util.h"
int switch_root(const char *new_root,
const char *old_root_after, /* path below the new root, where to place the old root after the transition; may be NULL to unmount it */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
typedef enum SwitchRootFlags {
SWITCH_ROOT_DESTROY_OLD_ROOT = 1 << 0, /* rm -rf old root when switching – under the condition
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
-#include <inttypes.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
+#include "forward.h"
#include "string-util.h"
#define _test_table(type, name, lookup, reverse, size, sparse) \
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <sched.h>
-#include <signal.h>
#include <stdlib.h>
#include <sys/mman.h>
-#include <sys/mount.h>
+#include <sys/prctl.h>
#include <sys/wait.h>
#include "sd-bus.h"
+#include "sd-daemon.h"
#include "alloc-util.h"
+#include "argv-util.h"
#include "bus-error.h"
#include "bus-locator.h"
#include "bus-util.h"
#include "cgroup-util.h"
#include "env-file.h"
#include "env-util.h"
+#include "errno-util.h"
+#include "extract-word.h"
#include "fd-util.h"
#include "fs-util.h"
#include "hexdecoct.h"
#include "log.h"
-#include "mountpoint-util.h"
#include "namespace-util.h"
#include "path-util.h"
#include "process-util.h"
#include "random-util.h"
+#include "rlimit-util.h"
#include "strv.h"
#include "tests.h"
#include "tmpfile-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <sys/prctl.h>
-#include <unistd.h>
-
-#include "sd-daemon.h"
-
-#include "argv-util.h"
#include "errno-util.h"
-#include "extract-word.h"
#include "forward.h"
#include "log.h"
-#include "macro.h"
-#include "process-util.h"
-#include "rlimit-util.h"
-#include "signal-util.h"
#include "static-destruct.h"
+#include "signal-util.h"
#include "stdio-util.h"
-#include "strv.h"
+#include "string-util.h"
static inline void log_set_assert_return_is_criticalp(bool *p) {
log_set_assert_return_is_critical(*p);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <fcntl.h>
-#include <stdio.h>
+#include "forward.h"
/* These functions are split out of tmpfile-util.h (and not for example just flags to the functions they
* wrap) in order to optimize linking: this way, -lselinux is needed only for the callers of these functions
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
bool mac_tomoyo_use(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <uchar.h>
-
+#include "forward.h"
#include "tpm2-util.h"
/* Definitions as per "TCG PC Client Specific Platform Firmware Profile Specification"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <sys/file.h>
+#include <unistd.h>
#include "alloc-util.h"
#include "ansi-color.h"
#include "initrd-util.h"
#include "io-util.h"
#include "json-util.h"
-#include "lock-util.h"
#include "log.h"
#include "logarithm.h"
#include "memory-util.h"
#include "mkdir.h"
-#include "nulstr-util.h"
-#include "parse-util.h"
+#include "ordered-set.h"
#include "random-util.h"
#include "recurse-dir.h"
-#include "sha256.h"
+#include "siphash24.h"
#include "sort-util.h"
#include "sparse-endian.h"
#include "stat-util.h"
#include "string-table.h"
+#include "string-util.h"
+#include "strv.h"
#include "sync-util.h"
#include "time-util.h"
+#include "tpm2-pcr.h"
#include "tpm2-util.h"
-#include "user-util.h"
#include "virt.h"
#if HAVE_OPENSSL
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "sd-json.h"
-
#include "bitfield.h"
-#include "io-util.h"
-#include "macro.h"
+#include "forward.h"
#include "openssl-util.h"
-#include "ordered-set.h"
-#include "sha256.h"
-#include "tpm2-pcr.h"
typedef enum TPM2Flags {
TPM2_FLAGS_USE_PIN = 1 << 0,
#if HAVE_TPM2
-#include <tss2/tss2_esys.h>
-#include <tss2/tss2_mu.h>
-#include <tss2/tss2_rc.h>
+#include <tss2/tss2_esys.h> /* IWYU pragma: export */
+#include <tss2/tss2_mu.h> /* IWYU pragma: export */
+#include <tss2/tss2_rc.h> /* IWYU pragma: export */
int dlopen_tpm2(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <ctype.h>
-#include <errno.h>
+#include <time.h>
#include <unistd.h>
+#include "sd-event.h"
+#include "sd-id128.h"
+
#include "alloc-util.h"
#include "device-nodes.h"
#include "device-private.h"
#include "device-util.h"
-#include "env-file.h"
#include "errno-util.h"
-#include "fd-util.h"
-#include "id128-util.h"
+#include "hashmap.h"
#include "log.h"
-#include "macro.h"
-#include "parse-util.h"
#include "path-util.h"
-#include "signal-util.h"
#include "stat-util.h"
#include "string-util.h"
#include "strv.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-device.h"
-
#include "conf-parser.h"
-#include "hashmap.h"
-#include "time-util.h"
+#include "forward.h"
int udev_parse_config_full(const ConfigTableItem config_table[]);
int udev_parse_config(void);
#include "dirent-util.h"
#include "fd-util.h"
#include "fs-util.h"
+#include "glyph-util.h"
#include "initrd-util.h"
#include "log.h"
-#include "macro.h"
#include "path-lookup.h"
#include "set.h"
+#include "siphash24.h"
#include "special.h"
#include "stat-util.h"
#include "string-util.h"
#include "strv.h"
+#include "time-util.h"
#include "unit-file.h"
+#include "unit-name.h"
int unit_symlink_name_compatible(const char *symlink, const char *target, bool instance_propagation) {
_cleanup_free_ char *template = NULL;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
+#include "unit-def.h"
-#include "hashmap.h"
-#include "path-lookup.h"
-#include "time-util.h"
-#include "unit-name.h"
-
-typedef enum UnitFileState UnitFileState;
-
-enum UnitFileState {
+typedef enum UnitFileState {
UNIT_FILE_ENABLED,
UNIT_FILE_ENABLED_RUNTIME,
UNIT_FILE_LINKED,
UNIT_FILE_BAD,
_UNIT_FILE_STATE_MAX,
_UNIT_FILE_STATE_INVALID = -EINVAL,
-};
+} UnitFileState;
static inline bool unit_type_may_alias(UnitType type) {
return IN_SET(type,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <gshadow.h>
+
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "errno-util.h"
#include "format-util.h"
+#include "group-record.h"
#include "libcrypt-util.h"
#include "log.h"
+#include "string-util.h"
#include "strv.h"
+#include "time-util.h"
+#include "user-record.h"
#include "user-record-nss.h"
#include "user-util.h"
#include "utf8.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <grp.h>
-#include <gshadow.h>
-#include <pwd.h>
-#include <shadow.h>
-
-#include "group-record.h"
-#include "user-record.h"
+#include "forward.h"
/* Synthesize UserRecord and GroupRecord objects from NSS data */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "alloc-util.h"
#include "cap-list.h"
#include "format-util.h"
-#include "fs-util.h"
#include "glyph-util.h"
#include "hashmap.h"
#include "hexdecoct.h"
-#include "log.h"
#include "path-util.h"
#include "percent-util.h"
#include "pretty-print.h"
#include "process-util.h"
#include "rlimit-util.h"
#include "sha256.h"
+#include "string-util.h"
#include "strv.h"
-#include "terminal-util.h"
+#include "time-util.h"
+#include "user-record.h"
+#include "group-record.h"
#include "user-record-show.h"
#include "user-util.h"
#include "userdb.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "group-record.h"
-#include "user-record.h"
+#include "forward.h"
const char* user_record_state_color(const char *state);
#include "cap-list.h"
#include "cgroup-util.h"
#include "dns-domain.h"
-#include "env-util.h"
-#include "fs-util.h"
#include "glyph-util.h"
-#include "hexdecoct.h"
+#include "hashmap.h"
#include "hostname-setup.h"
-#include "hostname-util.h"
#include "json-util.h"
#include "locale-util.h"
#include "log.h"
#include "rlimit-util.h"
#include "sha256.h"
#include "string-table.h"
+#include "string-util.h"
#include "strv.h"
+#include "time-util.h"
#include "uid-classification.h"
#include "user-record.h"
#include "user-util.h"
-#include "utf8.h"
#define DEFAULT_RATELIMIT_BURST 30
#define DEFAULT_RATELIMIT_INTERVAL_USEC (1*USEC_PER_MINUTE)
return h;
}
+sd_json_dispatch_flags_t USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(UserRecordLoadFlags flags) {
+ return (FLAGS_SET(flags, USER_RECORD_LOG) ? SD_JSON_LOG : 0) |
+ (FLAGS_SET(flags, USER_RECORD_PERMISSIVE) ? SD_JSON_PERMISSIVE : 0);
+}
+
static void pkcs11_encrypted_key_done(Pkcs11EncryptedKey *k) {
if (!k)
return;
name[0] != '.';
}
+bool userdb_match_is_set(const UserDBMatch *match) {
+ if (!match)
+ return false;
+
+ return !strv_isempty(match->fuzzy_names) ||
+ !FLAGS_SET(match->disposition_mask, USER_DISPOSITION_MASK_ALL) ||
+ match->uid_min > 0 ||
+ match->uid_max < UID_INVALID-1;
+}
+
+void userdb_match_done(UserDBMatch *match) {
+ assert(match);
+ strv_free(match->fuzzy_names);
+}
+
bool user_name_fuzzy_match(const char *names[], size_t n_names, char **matches) {
assert(names || n_names == 0);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <inttypes.h>
-#include <sys/types.h>
-
#include "sd-id128.h"
-#include "sd-json.h"
#include "bitfield.h"
-#include "hashmap.h"
#include "rlimit-util.h"
-#include "strv.h"
-#include "time-util.h"
-#include "user-util.h"
+#include "forward.h"
typedef enum UserDisposition {
USER_INTRINSIC, /* root and nobody */
return (f >> 21) & _USER_RECORD_MASK_MAX;
}
-static inline sd_json_dispatch_flags_t USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(UserRecordLoadFlags flags) {
- return (FLAGS_SET(flags, USER_RECORD_LOG) ? SD_JSON_LOG : 0) |
- (FLAGS_SET(flags, USER_RECORD_PERMISSIVE) ? SD_JSON_PERMISSIVE : 0);
-}
+sd_json_dispatch_flags_t USER_RECORD_LOAD_FLAGS_TO_JSON_DISPATCH_FLAGS(UserRecordLoadFlags flags);
typedef struct Pkcs11EncryptedKey {
/* The encrypted passphrase, which can be decrypted with the private key indicated below */
INDEXES_TO_MASK(uint64_t, USER_INTRINSIC, USER_SYSTEM), \
.uid_min = 0, \
.uid_max = UID_NOBODY - 1, \
- }
+ }
-static inline bool userdb_match_is_set(const UserDBMatch *match) {
- if (!match)
- return false;
+bool userdb_match_is_set(const UserDBMatch *match);
- return !strv_isempty(match->fuzzy_names) ||
- !FLAGS_SET(match->disposition_mask, USER_DISPOSITION_MASK_ALL) ||
- match->uid_min > 0 ||
- match->uid_max < UID_INVALID-1;
-}
-
-static inline void userdb_match_done(UserDBMatch *match) {
- assert(match);
- strv_free(match->fuzzy_names);
-}
+void userdb_match_done(UserDBMatch *match);
bool user_name_fuzzy_match(const char *names[], size_t n_names, char **matches);
bool user_record_match(UserRecord *u, const UserDBMatch *match);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-json.h"
+
#include "alloc-util.h"
#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
#include "group-record.h"
-#include "log.h"
#include "path-util.h"
#include "stdio-util.h"
+#include "string-util.h"
#include "user-util.h"
+#include "userdb.h"
#include "userdb-dropin.h"
static int load_user(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "constants.h"
-#include "group-record.h"
-#include "user-record.h"
-#include "userdb.h"
+#include "forward.h"
/* This could be put together with CONF_PATHS_NULSTR, with the exception of the /run/host/ part in the
* middle, which we use here, but not otherwise. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <sys/auxv.h>
+#include <gshadow.h>
+#include <stdlib.h>
+#include "sd-event.h"
#include "sd-varlink.h"
#include "alloc-util.h"
#include "format-util.h"
#include "json-util.h"
#include "log.h"
-#include "missing_syscall.h"
#include "parse-util.h"
#include "set.h"
-#include "socket-util.h"
+#include "string-util.h"
#include "strv.h"
#include "uid-classification.h"
#include "user-record-nss.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <sys/socket.h>
-#include <sys/un.h>
-
+#include "forward.h"
#include "group-record.h"
#include "user-record.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
-#include <sys/time.h>
#include <sys/utsname.h>
-#include <unistd.h>
#include <utmpx.h>
-#include "alloc-util.h"
-#include "errno-util.h"
-#include "hostname-util.h"
#include "log.h"
-#include "macro.h"
#include "memory-util.h"
-#include "path-util.h"
#include "string-util.h"
#include "time-util.h"
-#include "user-util.h"
#include "utmp-wtmp.h"
int utmp_get_runlevel(int *runlevel, int *previous) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-#include <sys/types.h>
-
-#include "assert-util.h"
-#include "time-util.h"
+#include "forward.h"
#if ENABLE_UTMP
#include <utmpx.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "bus-polkit.h"
#include "varlink-idl-common.h"
#include "varlink-io.systemd.Login.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "build.h"
#include "varlink-idl-common.h"
#include "varlink-io.systemd.Manager.h"
/* SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
-#include "sd-varlink.h"
#include "sd-varlink-idl.h"
extern const sd_varlink_interface vl_interface_io_systemd_Udev;
#include "env-util.h"
#include "json-util.h"
#include "log.h"
-#include "string-util.h"
#include "strv.h"
#include "utf8.h"
#include "varlink-io.systemd.service.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-event.h"
+
+#include "alloc-util.h"
+#include "fdset.h"
#include "log.h"
#include "parse-util.h"
#include "socket-util.h"
+#include "string-util.h"
#include "varlink-internal.h"
#include "varlink-serialize.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdio.h>
-
-#include "sd-varlink.h"
-
-#include "fdset.h"
+#include "forward.h"
int varlink_server_serialize(sd_varlink_server *s, FILE *f, FDSet *fds);
int varlink_server_deserialize_one(sd_varlink_server *s, const char *value, FDSet *fds);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include <stdlib.h>
+#include <unistd.h>
+
#include "alloc-util.h"
#include "env-util.h"
#include "extract-word.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
typedef struct X11Context {
char *layout;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-bus.h"
+
#include "alloc-util.h"
#include "bus-error.h"
+#include "bus-locator.h"
#include "log.h"
#include "string-util.h"
-#include "strv.h"
#include "syslog-util.h"
#include "verb-log-control.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "bus-locator.h"
+#include "forward.h"
int verb_log_control_common(sd_bus *bus, const char *destination, const char *verb, const char *value);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <getopt.h>
-#include <stdbool.h>
-#include <stddef.h>
#include "env-util.h"
#include "log.h"
-#include "macro.h"
-#include "process-util.h"
#include "string-util.h"
#include "strv.h"
#include "verbs.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
#define VERB_ANY (UINT_MAX)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "conf-parser.h"
+#include "log.h"
#include "parse-util.h"
#include "string-util.h"
#include "vlan-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <inttypes.h>
-#include <stdbool.h>
-
-#include "conf-parser.h"
+#include "conf-parser-forward.h"
+#include "forward.h"
#define VLANID_MAX 4094
#define VLANID_INVALID UINT16_MAX
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-
#include "alloc-util.h"
-#include "macro.h"
-#include "parse-util.h"
#include "proc-cmdline.h"
#include "string-table.h"
-#include "string-util.h"
#include "volatile-util.h"
int query_volatile_mode(VolatileMode *ret) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <errno.h>
+#include "forward.h"
typedef enum VolatileMode {
VOLATILE_NO,
#include "bitfield.h"
#include "chase.h"
#include "fd-util.h"
-#include "fs-util.h"
#include "log.h"
#include "parse-util.h"
#include "path-util.h"
#include "recurse-dir.h"
+#include "stat-util.h"
#include "string-util.h"
#include "strv.h"
#include "vpick.h"
#pragma once
#include <sys/stat.h>
-#include <sys/types.h>
#include "architecture.h"
+#include "forward.h"
typedef enum PickFlags {
PICK_ARCHITECTURE = 1 << 0, /* Look for an architecture suffix */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <string.h>
#include <unistd.h>
#include "sd-login.h"
#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
+#include "time-util.h"
#include "user-util.h"
#include "utmp-wtmp.h"
#include "wall.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
+#include "forward.h"
#if ENABLE_UTMP || ENABLE_LOGIND
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
#include <fcntl.h>
#include <linux/watchdog.h>
#include <sys/ioctl.h>
+#include <sys/stat.h>
#include <syslog.h>
#include <unistd.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "time-util.h"
+#include "forward.h"
const char* watchdog_get_device(void);
usec_t watchdog_get_last_ping(clockid_t clock);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <stdbool.h>
-
#include "string-util.h"
#include "strv.h"
#include "utf8.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include <stdbool.h>
-
-#include "macro.h"
+#include "forward.h"
bool http_url_is_valid(const char *url) _pure_;
bool file_url_is_valid(const char *url) _pure_;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#include "sd-netlink.h"
+
+#include "alloc-util.h"
+#include "ether-addr-util.h"
#include "log.h"
#include "string-table.h"
#include "string-util.h"
#include <linux/nl80211.h>
-#include "sd-netlink.h"
-
-#include "ether-addr-util.h"
+#include "forward.h"
int wifi_get_interface(sd_netlink *genl, int ifindex, enum nl80211_iftype *ret_iftype, char **ret_ssid);
int wifi_get_station(sd_netlink *genl, int ifindex, struct ether_addr *ret_bssid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include <errno.h>
-#include <stddef.h>
-
-#include "log.h"
-#include "macro.h"
#include "string-util.h"
#include "xml.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
+
enum {
XML_END,
XML_TEXT,
projects / thirdparty / systemd.git / commitdiff
