inline functions that require the full definition of a struct into the
implementation file so that only a forward declaration of the struct is
required and not the full definition.
- - `src/basic/forward.h` contains forward declarations for common types. If
- possible, only include `forward.h` in header files which makes circular
- header dependencies a non-issue.
+ - `src/basic/basic-forward.h` contains forward declarations for common types.
+ If possible, only include `basic-forward.h` in header files which makes
+ circular header dependencies a non-issue.
Bad:
incremental builds as much as possible.
To avoid having to include other headers in header files, always include
- `forward.h` in each header file and then add other required includes as
- needed. `forward.h` already includes generic headers and contains forward
- declarations for common types which should be sufficient for most header
- files. For each extra include you add on top of `forward.h`, check if it can
- be replaced by adding another forward declaration to `forward.h`. Depending on
- the daemon, there might be a specific forward header to include (e.g.
- `resolved-forward.h` for systemd-resolved header files).
+ the corresponding forward declaration header in each header file and then add
+ other required includes as needed. The forward declaration header already
+ includes generic headers and contains forward declarations for common types
+ which should be sufficient for most header files. For each extra include you
+ add on top of, check if it can be replaced by adding another forward
+ declaration to the forward declaration header. Depending on the daemon, there
+ might be a specific forward header to include (e.g. `resolved-forward.h` for
+ systemd-resolved header files).
+
+ For common code, there are three different forward declaration headers:
+
+ - `src/basic`: `basic-forward.h`
+ - `src/libsystemd`: `sd-forward.h`
+ - `src/libsystemd-network`: `sd-forward.h`
+ - `src/shared`: `shared-forward.h`
Header files that extend other header files can include the original header
file. For example, `iovec-util.h` includes `iovec-fundamental.h` and
```c
// source.h
- #include "forward.h"
+ #include "basic-forward.h"
void my_function_that_logs(size_t sz);
libsystemd_includes = [basic_includes, include_directories(
'src/libsystemd/sd-bus',
+ 'src/libsystemd/sd-common',
'src/libsystemd/sd-device',
'src/libsystemd/sd-event',
'src/libsystemd/sd-hwdb',
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "unit-def.h"
typedef struct BootTimes {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct ExecCommand ExecCommand;
typedef struct Unit Unit;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum RecursiveErrors RecursiveErrors;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
const char* af_to_name(int id) _const_;
int af_from_name(const char *name) _pure_;
#include <stdlib.h>
-#include "forward.h"
+#include "basic-forward.h"
#include "memory-util.h"
#if HAS_FEATURE_MEMORY_SANITIZER
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* Limits the use of ANSI colors to a subset. */
typedef enum ColorMode {
#include <endian.h> /* IWYU pragma: keep */
-#include "forward.h"
+#include "basic-forward.h"
/* A cleaned up architecture definition. We don't want to get lost in
* processor features, models, generations or even ABIs. Hence we
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
extern int saved_argc;
extern char **saved_argv;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
const char* arphrd_to_name(int id) _const_;
int arphrd_from_name(const char *name) _pure_;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#define AUDIT_SESSION_INVALID UINT32_MAX
--- /dev/null
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#pragma once
+
+/* IWYU pragma: always_keep */
+
+#include <errno.h> /* IWYU pragma: export */
+#include <inttypes.h> /* IWYU pragma: export */
+#include <limits.h> /* IWYU pragma: export */
+#include <paths.h> /* IWYU pragma: export */
+#include <stdarg.h> /* IWYU pragma: export */
+#include <stdbool.h> /* IWYU pragma: export */
+#include <stddef.h> /* IWYU pragma: export */
+#include <stdint.h> /* IWYU pragma: export */
+#include <sys/types.h> /* IWYU pragma: export */
+#include <uchar.h> /* IWYU pragma: export */
+
+#include "assert-util.h" /* IWYU pragma: export */
+#include "cleanup-util.h" /* IWYU pragma: export */
+#include "macro.h" /* IWYU pragma: export */
+
+/* Generic types */
+
+typedef uint64_t usec_t;
+typedef uint64_t nsec_t;
+
+/* Libc/Linux forward declarations */
+
+struct dirent;
+struct ether_addr;
+struct fiemap;
+struct file_handle;
+struct glob_t;
+struct group;
+struct icmp6_hdr;
+struct in_addr;
+struct in6_addr;
+struct inotify_event;
+struct iovec;
+struct mount_attr;
+struct msghdr;
+struct passwd;
+struct pollfd;
+struct rlimit;
+struct sgrp;
+struct shadow;
+struct signalfd_siginfo;
+struct siphash;
+struct sockaddr;
+struct spwd;
+struct stat;
+struct statfs;
+struct statx_timestamp;
+struct statx;
+struct termios;
+struct tm;
+struct ucred;
+
+/* To forward declare FILE and DIR, we have to declare the internal struct names for them. Since these are
+ * used for C++ symbol name mangling, they're effectively part of the ABI and won't actually change. */
+typedef struct _IO_FILE FILE;
+typedef struct __dirstream DIR;
+
+/* 3rd-party library forward declarations */
+
+enum bpf_map_type;
+
+struct fdisk_context;
+struct fdisk_table;
+struct crypt_device;
+
+/* basic/ forward declarations */
+
+typedef void (*hash_func_t)(const void *p, struct siphash *state);
+typedef int (*compare_func_t)(const void *a, const void *b);
+typedef compare_func_t comparison_fn_t;
+typedef int (*comparison_userdata_fn_t)(const void *, const void *, void *);
+
+struct hash_ops;
+struct hw_addr_data;
+struct in_addr_data;
+struct iovec_wrapper;
+union in_addr_union;
+union sockaddr_union;
+
+typedef enum CGroupFlags CGroupFlags;
+typedef enum CGroupMask CGroupMask;
+typedef enum ChaseFlags ChaseFlags;
+typedef enum ExtractFlags ExtractFlags;
+typedef enum Glyph Glyph;
+typedef enum ImageClass ImageClass;
+typedef enum JobMode JobMode;
+typedef enum RuntimeScope RuntimeScope;
+typedef enum TimestampStyle TimestampStyle;
+typedef enum UnitActiveState UnitActiveState;
+typedef enum UnitDependency UnitDependency;
+typedef enum UnitType UnitType;
+
+typedef struct Hashmap Hashmap;
+typedef struct HashmapBase HashmapBase;
+typedef struct IteratedCache IteratedCache;
+typedef struct Iterator Iterator;
+typedef struct OrderedHashmap OrderedHashmap;
+typedef struct OrderedSet OrderedSet;
+typedef struct Set Set;
+
+typedef struct dual_timestamp dual_timestamp;
+typedef struct triple_timestamp triple_timestamp;
+typedef struct ConfFile ConfFile;
+typedef struct LockFile LockFile;
+typedef struct PidRef PidRef;
+typedef struct Prioq Prioq;
+typedef struct RateLimit RateLimit;
+typedef struct SocketAddress SocketAddress;
+
+/* Constants */
+
+/* We duplicate various commonly used constants here so we can keep most static inline functions without
+ * having to include the full header that provides these constants. */
+
+#define AT_FDCWD -100
+#define AT_EMPTY_PATH 0x1000
+#define AT_SYMLINK_FOLLOW 0x400
+#define AT_SYMLINK_NOFOLLOW 0x100
+
+#define MODE_INVALID ((mode_t) -1)
+
+#define UID_INVALID ((uid_t) -1)
+#define GID_INVALID ((gid_t) -1)
+
+#define USEC_INFINITY ((usec_t) UINT64_MAX)
+#define NSEC_INFINITY ((nsec_t) UINT64_MAX)
+
+/* MAX_ERRNO is defined as 4095 in linux/err.h. We use the same value here. */
+#define ERRNO_MAX 4095
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* Bit index (0-based) to mask of specified type. Assertion failure if index is out of range. */
#define _INDEX_TO_MASK(type, i, uniq) \
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "forward.h"
+#include "basic-forward.h"
int btrfs_validate_subvolume_name(const char *name);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
extern const char* const systemd_features;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
char* bus_label_escape(const char *s);
char* bus_label_unescape_n(const char *f, size_t l);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* Space for capability_to_string() in case we write out a numeric capability because we don't know the name
* for it. "0x3e" is the largest string we might output, in both sensese of the word "largest": two chars for
#include <sys/capability.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
/* Special marker used when storing a capabilities mask as "unset". This would need to be updated as soon as
* Linux learns more than 63 caps. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int capsule_name_is_valid(const char *name);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#define SYSTEMD_CGROUP_CONTROLLER_LEGACY "name=systemd"
#define SYSTEMD_CGROUP_CONTROLLER_HYBRID "name=unified"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum ChaseFlags {
CHASE_PREFIX_ROOT = 1 << 0, /* The specified path will be prefixed by the specified root before beginning the iteration */
#include <linux/fs.h>
-#include "forward.h"
+#include "basic-forward.h"
/* The chattr() flags to apply when creating a new file *before* writing to it. In particular, flags such as
* FS_NOCOW_FL don't work if applied a-posteriori. All other flags are fine (or even necessary, think
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum Compression {
COMPRESSION_NONE,
#include <sys/stat.h>
-#include "forward.h"
+#include "basic-forward.h"
typedef enum ConfFilesFlags {
CONF_FILES_EXECUTABLE = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum ConfidentialVirtualization {
CONFIDENTIAL_VIRTUALIZATION_NONE = 0,
#include <sys/sysmacros.h>
-#include "forward.h"
+#include "basic-forward.h"
int parse_devnum(const char *s, dev_t *ret);
#include <dirent.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
#include "path-util.h"
bool dirent_is_file(const struct dirent *de) _pure_;
#include <dlfcn.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
void* safe_dlclose(void *dl);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* Length of a single label, with all escaping removed, excluding any trailing dot or NUL byte */
#define DNS_LABEL_MAX 63
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "sd-id128.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int parse_env_filev(FILE *f, const char *fname, va_list ap);
int parse_env_file_fdv(int fd, const char *fname, va_list ap);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
size_t sc_arg_max(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
const char* errno_name_no_fallback(int id) _const_;
int errno_from_name(const char *name) _pure_;
#include <string.h>
-#include "forward.h"
+#include "basic-forward.h"
/* strerror(3) says that glibc uses a maximum length of 1024 bytes. */
#define ERRNO_BUF_LEN 1024
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* What characters are special in the shell? */
/* must be escaped outside and inside double-quotes */
#include <netinet/in.h>
#include <net/ethernet.h>
-#include "forward.h"
+#include "basic-forward.h"
/* This is MAX_ADDR_LEN as defined in linux/netdevice.h, but net/if_arp.h
* defines a macro of the same name with a much lower size. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum ExtractFlags {
EXTRACT_RELAX = 1 << 0, /* Allow unbalanced quote and eat up trailing backslash. */
#include <fcntl.h>
#include <stdio.h>
-#include "forward.h"
+#include "basic-forward.h"
/* maximum length of fdname */
#define FDNAME_MAX 255
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#define LONG_LINE_MAX (1U*1024U*1024U)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "stat-util.h"
#define FILESYSTEM_MAGIC_MAX 10
#pragma once
#include "cgroup-util.h"
-#include "forward.h"
+#include "basic-forward.h"
#include "stdio-util.h"
assert_cc(sizeof(pid_t) == sizeof(int32_t));
+++ /dev/null
-/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#pragma once
-
-/* IWYU pragma: always_keep */
-
-#include <errno.h> /* IWYU pragma: export */
-#include <inttypes.h> /* IWYU pragma: export */
-#include <limits.h> /* IWYU pragma: export */
-#include <paths.h> /* IWYU pragma: export */
-#include <stdarg.h> /* IWYU pragma: export */
-#include <stdbool.h> /* IWYU pragma: export */
-#include <stddef.h> /* IWYU pragma: export */
-#include <stdint.h> /* IWYU pragma: export */
-#include <sys/types.h> /* IWYU pragma: export */
-#include <uchar.h> /* IWYU pragma: export */
-
-#include "assert-util.h" /* IWYU pragma: export */
-#include "cleanup-util.h" /* IWYU pragma: export */
-#include "macro.h" /* IWYU pragma: export */
-
-/* Generic types */
-
-typedef uint64_t usec_t;
-typedef uint64_t nsec_t;
-
-/* Libc/Linux forward declarations */
-
-struct dirent;
-struct ether_addr;
-struct fiemap;
-struct file_handle;
-struct glob_t;
-struct group;
-struct icmp6_hdr;
-struct in_addr;
-struct in6_addr;
-struct inotify_event;
-struct iovec;
-struct mount_attr;
-struct msghdr;
-struct passwd;
-struct pollfd;
-struct rlimit;
-struct sgrp;
-struct shadow;
-struct signalfd_siginfo;
-struct siphash;
-struct sockaddr;
-struct spwd;
-struct stat;
-struct statfs;
-struct statx_timestamp;
-struct statx;
-struct termios;
-struct tm;
-struct ucred;
-
-/* To forward declare FILE and DIR, we have to declare the internal struct names for them. Since these are
- * used for C++ symbol name mangling, they're effectively part of the ABI and won't actually change. */
-typedef struct _IO_FILE FILE;
-typedef struct __dirstream DIR;
-
-/* 3rd-party library forward declarations */
-
-enum bpf_map_type;
-
-struct fdisk_context;
-struct fdisk_table;
-struct crypt_device;
-
-/* basic/ forward declarations */
-
-typedef void (*hash_func_t)(const void *p, struct siphash *state);
-typedef int (*compare_func_t)(const void *a, const void *b);
-typedef compare_func_t comparison_fn_t;
-typedef int (*comparison_userdata_fn_t)(const void *, const void *, void *);
-
-struct hash_ops;
-struct hw_addr_data;
-struct in_addr_data;
-struct iovec_wrapper;
-union in_addr_union;
-union sockaddr_union;
-
-typedef enum CGroupFlags CGroupFlags;
-typedef enum CGroupMask CGroupMask;
-typedef enum ChaseFlags ChaseFlags;
-typedef enum ExtractFlags ExtractFlags;
-typedef enum Glyph Glyph;
-typedef enum ImageClass ImageClass;
-typedef enum JobMode JobMode;
-typedef enum RuntimeScope RuntimeScope;
-typedef enum TimestampStyle TimestampStyle;
-typedef enum UnitActiveState UnitActiveState;
-typedef enum UnitDependency UnitDependency;
-
-typedef struct Hashmap Hashmap;
-typedef struct HashmapBase HashmapBase;
-typedef struct IteratedCache IteratedCache;
-typedef struct Iterator Iterator;
-typedef struct OrderedHashmap OrderedHashmap;
-typedef struct OrderedSet OrderedSet;
-typedef struct Set Set;
-
-typedef struct dual_timestamp dual_timestamp;
-typedef struct triple_timestamp triple_timestamp;
-typedef struct ConfFile ConfFile;
-typedef struct LockFile LockFile;
-typedef struct PidRef PidRef;
-typedef struct Prioq Prioq;
-typedef struct RateLimit RateLimit;
-typedef struct SocketAddress SocketAddress;
-
-/* libsystemd/ and libsystemd-network/ forward declarations */
-
-typedef void (*_sd_destroy_t)(void *userdata);
-
-typedef union sd_id128 sd_id128_t;
-
-typedef struct sd_event sd_event;
-typedef struct sd_event_source sd_event_source;
-
-typedef int (*sd_event_handler_t)(sd_event_source *s, void *userdata);
-typedef int (*sd_event_io_handler_t)(sd_event_source *s, int fd, uint32_t revents, void *userdata);
-typedef int (*sd_event_time_handler_t)(sd_event_source *s, uint64_t usec, void *userdata);
-typedef int (*sd_event_signal_handler_t)(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata);
-typedef int (*sd_event_inotify_handler_t)(sd_event_source *s, const struct inotify_event *event, void *userdata);
-typedef _sd_destroy_t sd_event_destroy_t;
-
-enum ENUM_TYPE_S64(sd_json_format_flags_t);
-enum ENUM_TYPE_S64(sd_json_dispatch_flags_t);
-enum ENUM_TYPE_S64(sd_json_variant_type_t);
-enum ENUM_TYPE_S64(sd_json_parse_flags_t);
-
-typedef enum sd_json_format_flags_t sd_json_format_flags_t;
-typedef enum sd_json_dispatch_flags_t sd_json_dispatch_flags_t;
-typedef enum sd_json_variant_type_t sd_json_variant_type_t;
-typedef enum sd_json_parse_flags_t sd_json_parse_flags_t;
-
-typedef struct sd_json_variant sd_json_variant;
-
-typedef struct sd_bus sd_bus;
-typedef struct sd_bus_error sd_bus_error;
-typedef struct sd_bus_error_map sd_bus_error_map;
-typedef struct sd_bus_message sd_bus_message;
-typedef struct sd_bus_slot sd_bus_slot;
-typedef struct sd_bus_creds sd_bus_creds;
-typedef struct sd_bus_track sd_bus_track;
-typedef struct sd_bus_vtable sd_bus_vtable;
-
-typedef int (*sd_bus_message_handler_t)(sd_bus_message *m, void *userdata, sd_bus_error *ret_error);
-typedef int (*sd_bus_property_get_t)(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *ret_error);
-typedef int (*sd_bus_property_set_t)(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *ret_error);
-typedef int (*sd_bus_object_find_t)(sd_bus *bus, const char *path, const char *interface, void *userdata, void **ret_found, sd_bus_error *ret_error);
-typedef int (*sd_bus_node_enumerator_t)(sd_bus *bus, const char *prefix, void *userdata, char ***ret_nodes, sd_bus_error *ret_error);
-typedef int (*sd_bus_track_handler_t)(sd_bus_track *track, void *userdata);
-typedef _sd_destroy_t sd_bus_destroy_t;
-
-enum ENUM_TYPE_S64(sd_device_action_t);
-
-typedef enum sd_device_action_t sd_device_action_t;
-
-typedef struct sd_device sd_device;
-typedef struct sd_device_enumerator sd_device_enumerator;
-typedef struct sd_device_monitor sd_device_monitor;
-
-typedef struct sd_netlink sd_netlink;
-typedef struct sd_netlink_message sd_netlink_message;
-typedef struct sd_netlink_slot sd_netlink_slot;
-
-typedef int (*sd_netlink_message_handler_t)(sd_netlink *nl, sd_netlink_message *m, void *userdata);
-typedef _sd_destroy_t sd_netlink_destroy_t;
-
-typedef struct sd_network_monitor sd_network_monitor;
-
-enum ENUM_TYPE_S64(sd_dhcp_lease_server_type_t);
-enum ENUM_TYPE_S64(sd_lldp_rx_event_t);
-enum ENUM_TYPE_S64(sd_lldp_multicast_mode_t);
-enum ENUM_TYPE_S64(sd_ndisc_event_t);
-
-typedef enum sd_dhcp_lease_server_type_t sd_dhcp_lease_server_type_t;
-typedef enum sd_lldp_rx_event_t sd_lldp_rx_event_t;
-typedef enum sd_lldp_multicast_mode_t sd_lldp_multicast_mode_t;
-typedef enum sd_ndisc_event_t sd_ndisc_event_t;
-
-typedef struct sd_ipv4ll sd_ipv4ll;
-typedef struct sd_dhcp_client sd_dhcp_client;
-typedef struct sd_dhcp_lease sd_dhcp_lease;
-typedef struct sd_dhcp_route sd_dhcp_route;
-typedef struct sd_dns_resolver sd_dns_resolver;
-typedef struct sd_dhcp_server sd_dhcp_server;
-typedef struct sd_ndisc sd_ndisc;
-typedef struct sd_radv sd_radv;
-typedef struct sd_dhcp6_client sd_dhcp6_client;
-typedef struct sd_dhcp6_lease sd_dhcp6_lease;
-typedef struct sd_lldp_tx sd_lldp_tx;
-typedef struct sd_lldp_rx sd_lldp_rx;
-typedef struct sd_lldp_neighbor sd_lldp_neighbor;
-
-typedef struct ICMP6Packet ICMP6Packet;
-
-enum ENUM_TYPE_S64(sd_varlink_method_flags_t);
-enum ENUM_TYPE_S64(sd_varlink_interface_flags_t);
-enum ENUM_TYPE_S64(sd_varlink_symbol_type_t);
-enum ENUM_TYPE_S64(sd_varlink_field_type_t);
-enum ENUM_TYPE_S64(sd_varlink_field_direction_t);
-enum ENUM_TYPE_S64(sd_varlink_field_flags_t);
-enum ENUM_TYPE_S64(sd_varlink_idl_format_flags_t);
-enum ENUM_TYPE_S64(sd_varlink_reply_flags_t);
-enum ENUM_TYPE_S64(sd_varlink_server_flags_t);
-enum ENUM_TYPE_S64(sd_varlink_invocation_flags_t);
-
-typedef enum sd_varlink_method_flags_t sd_varlink_method_flags_t;
-typedef enum sd_varlink_interface_flags_t sd_varlink_interface_flags_t;
-typedef enum sd_varlink_symbol_type_t sd_varlink_symbol_type_t;
-typedef enum sd_varlink_field_type_t sd_varlink_field_type_t;
-typedef enum sd_varlink_field_direction_t sd_varlink_field_direction_t;
-typedef enum sd_varlink_field_flags_t sd_varlink_field_flags_t;
-typedef enum sd_varlink_idl_format_flags_t sd_varlink_idl_format_flags_t;
-typedef enum sd_varlink_reply_flags_t sd_varlink_reply_flags_t;
-typedef enum sd_varlink_server_flags_t sd_varlink_server_flags_t;
-typedef enum sd_varlink_invocation_flags_t sd_varlink_invocation_flags_t;
-
-typedef struct sd_varlink sd_varlink;
-typedef struct sd_varlink_server sd_varlink_server;
-typedef struct sd_varlink_field sd_varlink_field;
-typedef struct sd_varlink_symbol sd_varlink_symbol;
-typedef struct sd_varlink_interface sd_varlink_interface;
-
-typedef struct sd_journal sd_journal;
-
-typedef struct sd_resolve sd_resolve;
-typedef struct sd_resolve_query sd_resolve_query;
-
-typedef struct sd_hwdb sd_hwdb;
-
-/* shared/ forward declarations */
-
-typedef int (*copy_progress_bytes_t)(uint64_t n_bytes, uint64_t bytes_per_second, void *userdata);
-typedef int (*copy_progress_path_t)(const char *path, const struct stat *st, void *userdata);
-
-struct local_address;
-struct in_addr_prefix;
-struct in_addr_full;
-
-typedef enum AskPasswordFlags AskPasswordFlags;
-typedef enum BootEntryTokenType BootEntryTokenType;
-typedef enum BusPrintPropertyFlags BusPrintPropertyFlags;
-typedef enum BusTransport BusTransport;
-typedef enum CatFlags CatFlags;
-typedef enum CertificateSourceType CertificateSourceType;
-typedef enum DnsCacheMode DnsCacheMode;
-typedef enum DnsOverTlsMode DnsOverTlsMode;
-typedef enum DnssecMode DnssecMode;
-typedef enum Fido2EnrollFlags Fido2EnrollFlags;
-typedef enum KeySourceType KeySourceType;
-typedef enum LabelFixFlags LabelFixFlags;
-typedef enum MountInNamespaceFlags MountInNamespaceFlags;
-typedef enum NamePolicy NamePolicy;
-typedef enum OutputFlags OutputFlags;
-typedef enum OutputMode OutputMode;
-typedef enum PagerFlags PagerFlags;
-typedef enum PatternCompileCase PatternCompileCase;
-typedef enum RemoveFlags RemoveFlags;
-typedef enum ResolveSupport ResolveSupport;
-typedef enum TPM2Flags TPM2Flags;
-typedef enum Tpm2Support Tpm2Support;
-typedef enum Tpm2UserspaceEventType Tpm2UserspaceEventType;
-typedef enum UnitFileFlags UnitFileFlags;
-typedef enum UnitFilePresetMode UnitFilePresetMode;
-typedef enum UnitFileState UnitFileState;
-typedef enum UnitType UnitType;
-typedef enum UserDBFlags UserDBFlags;
-typedef enum UserRecordLoadFlags UserRecordLoadFlags;
-typedef enum UserStorage UserStorage;
-
-typedef struct Bitmap Bitmap;
-typedef struct BPFProgram BPFProgram;
-typedef struct BusObjectImplementation BusObjectImplementation;
-typedef struct CalendarSpec CalendarSpec;
-typedef struct Condition Condition;
-typedef struct ConfigSection ConfigSection;
-typedef struct ConfigTableItem ConfigTableItem;
-typedef struct CPUSet CPUSet;
-typedef struct FDSet FDSet;
-typedef struct Fido2HmacSalt Fido2HmacSalt;
-typedef struct GroupRecord GroupRecord;
-typedef struct Image Image;
-typedef struct ImagePolicy ImagePolicy;
-typedef struct InstallInfo InstallInfo;
-typedef struct LookupPaths LookupPaths;
-typedef struct LoopDevice LoopDevice;
-typedef struct MachineBindUserContext MachineBindUserContext;
-typedef struct MachineCredentialContext MachineCredentialContext;
-typedef struct MountOptions MountOptions;
-typedef struct OpenFile OpenFile;
-typedef struct Pkcs11EncryptedKey Pkcs11EncryptedKey;
-typedef struct Table Table;
-typedef struct Tpm2Context Tpm2Context;
-typedef struct Tpm2Handle Tpm2Handle;
-typedef struct Tpm2PCRValue Tpm2PCRValue;
-typedef struct UnitInfo UnitInfo;
-typedef struct UserRecord UserRecord;
-typedef struct VeritySettings VeritySettings;
-
-/* Constants */
-
-/* We duplicate various commonly used constants here so we can keep most static inline functions without
- * having to include the full header that provides these constants. */
-
-#define AT_FDCWD -100
-#define AT_EMPTY_PATH 0x1000
-#define AT_SYMLINK_FOLLOW 0x400
-#define AT_SYMLINK_NOFOLLOW 0x100
-
-#define MODE_INVALID ((mode_t) -1)
-
-#define UID_INVALID ((uid_t) -1)
-#define GID_INVALID ((gid_t) -1)
-
-#define USEC_INFINITY ((usec_t) UINT64_MAX)
-#define NSEC_INFINITY ((nsec_t) UINT64_MAX)
-
-/* MAX_ERRNO is defined as 4095 in linux/err.h. We use the same value here. */
-#define ERRNO_MAX 4095
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "lock-util.h"
/* The following macros add 1 when converting things, since 0 is a valid mode, while the pointer
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int dlopen_gcrypt(void);
#include <glob.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
typedef DIR* (*opendir_t)(const char *);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum Glyph {
GLYPH_SPACE,
*/
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
char *utf8_prev_char (const char *p);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef void (*hash_func_t)(const void *p, struct siphash *state);
typedef int (*compare_func_t)(const void *a, const void *b);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "hash-funcs.h"
#include "iterator.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
char octchar(int x) _const_;
int unoctchar(char c) _const_;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "sha256.h"
/* Unoptimized implementation based on FIPS 198. 'res' has to be allocated by
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "strv.h"
char* get_default_hostname_raw(void);
#include <netinet/in.h>
-#include "forward.h"
+#include "basic-forward.h"
union in_addr_union {
struct in_addr in;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
bool in_initrd(void);
void in_initrd_force(bool value);
#include <sys/inotify.h> /* IWYU pragma: export */
#include <syslog.h>
-#include "forward.h"
+#include "basic-forward.h"
#define INOTIFY_EVENT_MAX (offsetof(struct inotify_event, name) + NAME_MAX + 1)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int flush_fd(int fd);
#include <sys/uio.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
#include "iovec-util-fundamental.h" /* IWYU pragma: export */
extern const struct iovec iovec_nul_byte; /* Points to a single NUL byte */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
struct iovec_wrapper {
struct iovec *iovec;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* Ideally the Iterator would be an opaque struct, but it is instantiated
* by hashmap users, so the definition has to be here. Do not use its fields
#include <sys/keyctl.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
/* Like TAKE_PTR() but for key_serial_t, resetting them to -1 */
#define TAKE_KEY_SERIAL(key_serial) TAKE_GENERIC(key_serial, key_serial_t, -1)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef struct LabelOps {
int (*pre)(int dir_fd, const char *path, mode_t mode);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
uint64_t physical_memory(void);
uint64_t physical_memory_scale(uint64_t v, uint64_t max);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* The head of the linked list. Use this in the structure that shall
* contain the head of the linked list */
#include <locale.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
typedef enum LocaleVariable {
/* We don't list LC_ALL here on purpose. People should be
/* Include here so consumers have LOCK_{EX,SH,NB} available. */
#include <sys/file.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
typedef struct LockFile {
int dir_fd;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "list.h"
/*
#include <string.h>
#include <syslog.h>
-#include "forward.h"
+#include "basic-forward.h"
typedef enum LogTarget{
LOG_TARGET_CONSOLE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#define SD_LOGIND_ROOT_CHECK_INHIBITORS (UINT64_C(1) << 0)
#define SD_LOGIND_REBOOT_VIA_KEXEC (UINT64_C(1) << 1)
#include <math.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
/* On some optimization level, iszero(x) is converted to (x == 0.0), and emits warning -Wfloat-equal.
* The argument must be a floating point, i.e. one of float, double, or long double. */
#include <sys/mman.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
int memfd_create_wrapper(const char *name, unsigned mode);
#include <string.h>
-#include "forward.h"
+#include "basic-forward.h"
#include "memory-util-fundamental.h" /* IWYU pragma: export */
size_t page_size(void) _pure_;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
struct pool;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef struct MemStream {
FILE *f;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum MkdirFlags {
MKDIR_FOLLOW_SYMLINK = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* The limit used for /dev itself. 4MB should be enough since device nodes and symlinks don't
* consume any space and udev isn't supposed to create regular file either. There's no limit on the
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum NamespaceType {
NAMESPACE_CGROUP,
#include <string.h>
-#include "forward.h"
+#include "basic-forward.h"
#define NULSTR_FOREACH(i, l) \
for (typeof(*(l)) *(i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "hashmap.h"
typedef struct OrderedSet OrderedSet;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum ImageClass {
IMAGE_MACHINE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef unsigned long loadavg_t;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#define PATH_SPLIT_BIN(x) x "sbin:" x "bin"
#define PATH_SPLIT_BIN_NULSTR(x) x "sbin\0" x "bin\0"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/*
* For details about the file format see RFC:
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int parse_percent_unbounded(const char *p);
int parse_percent(const char *p);
#include <sys/pidfd.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
int pidfd_get_namespace(int fd, unsigned long ns_type_cmd);
#include <signal.h>
-#include "forward.h"
+#include "basic-forward.h"
/* An embeddable structure carrying a reference to a process. Supposed to be used when tracking processes
* continuously. This combines a PID, a modern Linux pidfd and the 64bit inode number of the pidfd into one
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef struct Prioq Prioq;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum ProcCmdlineFlags {
PROC_CMDLINE_STRIP_RD_PREFIX = 1 << 0, /* automatically strip "rd." prefix if it is set (and we are in the initrd, since otherwise we'd not consider it anyway) */
#include "fileio.h"
#include "format-util.h"
-#include "forward.h"
+#include "basic-forward.h"
#include "string-util.h"
#define procfs_file_alloca(pid, field) \
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int procfs_get_pid_max(uint64_t *ret);
int procfs_get_threads_max(uint64_t *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "parse-util.h"
typedef enum PressureType {
#include <pthread.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
static inline pthread_mutex_t* pthread_mutex_lock_assert(pthread_mutex_t *mutex) {
assert_se(pthread_mutex_lock(mutex) == 0);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
void random_bytes(void *p, size_t n) _nonnull_if_nonzero_(1, 2); /* Returns random bytes suitable for most uses, but may be insecure sometimes. */
int crypto_random_bytes(void *p, size_t n) _nonnull_if_nonzero_(1, 2); /* Returns secure random bytes after waiting for the RNG to initialize. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef struct RateLimit {
usec_t interval; /* Keep those two fields first so they can be initialized easily: */
#include <sched.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
pid_t raw_clone(unsigned long flags);
#include <dirent.h>
-#include "forward.h"
+#include "basic-forward.h"
typedef enum RecurseDirFlags {
/* Interpreted by readdir_all() */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
char* replace_var(const char *text, char *(*lookup)(const char *variable, void *userdata), void *userdata);
#include <sys/resource.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
#define _RLIMIT_MAX RLIMIT_NLIMITS
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum RuntimeScope {
RUNTIME_SCOPE_SYSTEM, /* for the system */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "hashmap.h"
#define set_free_and_replace(a, b) \
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "sha256-fundamental.h" /* IWYU pragma: export */
int sha256_fd(int fd, uint64_t max_size, uint8_t ret[static SHA256_DIGEST_SIZE]);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
void sigbus_install(void);
void sigbus_reset(void);
#include <signal.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
int reset_all_signal_handlers(void);
int reset_signal_mask(void);
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
struct siphash {
uint64_t v0;
#include <sys/socket.h>
#include <sys/un.h>
-#include "forward.h"
+#include "basic-forward.h"
#include "memory-util.h"
#include "missing-network.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
comparison_userdata_fn_t compar, void *arg);
#include <byteswap.h>
#include <endian.h>
-#include "forward.h"
+#include "basic-forward.h"
#ifdef __CHECKER__
#define __sd_bitwise __attribute__((__bitwise__))
#include <sys/stat.h> /* IWYU pragma: export */
#include <sys/statfs.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "basic-forward.h"
int stat_verify_regular(const struct stat *st);
int verify_regular_at(int fd, const char *path, bool follow);
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef void (*free_func_t)(void *p);
#include <printf.h>
#include <stdio.h>
-#include "forward.h"
+#include "basic-forward.h"
_printf_(3, 4)
static inline char* snprintf_ok(char *buf, size_t len, const char *format, ...) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
struct strbuf {
char *buf;
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
const char* string_table_lookup_to_string(const char * const *table, size_t len, ssize_t i) _const_;
#include <string.h>
#include "alloc-util.h"
-#include "forward.h"
+#include "basic-forward.h"
#include "string-util-fundamental.h" /* IWYU pragma: export */
static inline char* strstr_ptr(const char *haystack, const char *needle) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "strv-fundamental.h" /* IWYU pragma: export */
char* strv_find(char * const *l, const char *name) _pure_;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
size_t strnpcpy_full(char **dest, size_t size, const char *src, size_t len, bool *ret_truncated);
static inline size_t strnpcpy(char **dest, size_t size, const char *src, size_t len) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int fsync_directory_of_file(int fd);
int fsync_full(int fd);
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#include "stdio-util.h"
char* sysctl_normalize(char *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int log_facility_unshifted_to_string_alloc(int i, char **s);
int log_facility_unshifted_from_string(const char *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* Erase characters until the end of the line */
#define ANSI_ERASE_TO_END_OF_LINE "\x1B[K"
#include <time.h>
-#include "forward.h"
+#include "basic-forward.h"
#define PRI_NSEC PRIu64
#define PRI_USEC PRIu64
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int fopen_temporary_at(int dir_fd, const char *path, FILE **ret_file, char **ret_path);
static inline int fopen_temporary(const char *path, FILE **ret_file, char **ret_path) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* The container base should have the last 16 bit set to zero */
assert_cc((CONTAINER_UID_BASE_MIN & 0xFFFFU) == 0);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef struct UIDRangeEntry {
uid_t start, nr;
#include <sys/stat.h>
-#include "forward.h"
+#include "basic-forward.h"
static inline void umaskp(mode_t *u) {
umask(*u);
#include <endian.h>
-#include "forward.h"
+#include "basic-forward.h"
#include "unaligned-fundamental.h" /* IWYU pragma: export */
/* BE */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
/* The enum order is used to order unit jobs in the job queue
* when other criteria (cpu weight, nice level) are identical.
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#define UNIT_NAME_MAX 256
#include <pwd.h>
#include <shadow.h>
-#include "forward.h"
+#include "basic-forward.h"
/* Users managed by systemd-homed. See https://systemd.io/UIDS-GIDS for details how this range fits into the rest of the world */
#define HOME_UID_MIN ((uid_t) 60001)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
#define UTF8_REPLACEMENT_CHARACTER "\xef\xbf\xbd"
#define UTF8_BYTE_ORDER_MARK "\xef\xbb\xbf"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
typedef enum Virtualization {
VIRTUALIZATION_NONE = 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "basic-forward.h"
int getxattr_at_malloc(int fd, const char *path, const char *name, int at_flags, char **ret, size_t *ret_size);
static inline int getxattr_malloc(const char *path, const char *name, char **ret, size_t *ret_size) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "forward.h"
+#include "shared-forward.h"
int verb_reboot_to_firmware(int argc, char *argv[], void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "forward.h"
+#include "shared-forward.h"
int verb_status(int argc, char *argv[], void *userdata);
int verb_list(int argc, char *argv[], void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "forward.h"
+#include "shared-forward.h"
int verb_kernel_identify(int argc, char *argv[], void *userdata);
int verb_kernel_inspect(int argc, char *argv[], void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum InstallSource {
INSTALL_SOURCE_IMAGE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct XMLIntrospectOps {
int (*on_path)(const char *path, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int get_core_audit_fd(void);
void close_core_audit_fd(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int clock_reset_timewarp(void);
void clock_apply_epoch(bool allow_backwards);
#pragma once
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
#include "unit-def.h" /* IWYU pragma: export */
typedef enum CGroupDevicePermissions CGroupDevicePermissions;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum CrashAction {
CRASH_FREEZE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "core-forward.h"
int lookup_paths_mkdir_generator(LookupPaths *p);
void lookup_paths_trim_generator(LookupPaths *p);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum KillMode {
/* The kill mode is a property of a unit. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "crash-handler.h"
extern bool arg_dump_core;
#include "cgroup.h"
#include "common-signal.h"
#include "execute.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "log.h"
#include "path-lookup.h"
#include "show-status.h"
Copyright © 2016 Djalal Harouni
***/
-#include "forward.h"
+#include "core-forward.h"
#include "list.h"
#include "runtime-scope.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int mac_selinux_setup(bool *loaded_policy);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* Manager status */
Nathaniel Chen <nathaniel.chen@intel.com>
***/
-#include "forward.h"
+#include "shared-forward.h"
int mac_smack_setup(bool *loaded_policy);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* Flags that identify the various "atomic" behaviours a specific dependency type implies. Each dependency is
* a combination of one or more of these flags that define what they actually entail. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int unit_cgroup_context_build_json(sd_json_variant **ret, const char *name, void *userdata);
int unit_cgroup_runtime_build_json(sd_json_variant **ret, const char *name, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int rlimit_build_json(sd_json_variant **ret, const char *name, void *userdata);
int rlimit_table_build_json(sd_json_variant **ret, const char *name, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int vl_method_get_user_record(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata);
int vl_method_get_group_record(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int vl_method_describe_manager(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#define VARLINK_ERROR_UNIT_NO_SUCH_UNIT "io.systemd.Unit.NoSuchUnit"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int coredump_vacuum(int exclude_fd, uint64_t keep_free, uint64_t max_use);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int load_volume_key_fido2(struct crypt_device *cd, const char *cd_node, const char *device, void *ret_vk, size_t *ret_vks);
int enroll_fido2(struct crypt_device *cd, const struct iovec *volume_key, const char *device, Fido2EnrollFlags lock_with, int cred_alg, const char *salt_file, bool parameters_in_header);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int list_enrolled(struct crypt_device *cd);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int load_volume_key_password(struct crypt_device *cd, const char* cd_node, void *ret_vk, size_t *ret_vks);
int enroll_password(struct crypt_device *cd, const struct iovec *volume_key);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int enroll_pkcs11(struct crypt_device *cd, const struct iovec *volume_key, const char *uri);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int enroll_recovery(struct crypt_device *cd, const struct iovec *volume_key);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int load_volume_key_tpm2(struct crypt_device *cd, const char *cd_node, const char *device, void *ret_vk, size_t *ret_vks);
int enroll_tpm2(struct crypt_device *cd, const struct iovec *volume_key, const char *device, uint32_t seal_key_handle, const char *device_key, Tpm2PCRValue *hash_pcr_values, size_t n_hash_pcr_values, const char *pubkey_path, bool load_pcr_pubkey, uint32_t pubkey_pcr_mask, const char *signature_path, bool use_pin, const char *pcrlock_path, int *ret_slot_to_wipe);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum WipeScope WipeScope;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum EnrollType {
ENROLL_PASSWORD,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int find_key_file(const char *key_file, char **search_path, const char *bindname, struct iovec *ret_key);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int decrypt_pkcs11_key(
const char *volume_name,
#include <libcryptsetup.h>
-#include "forward.h"
+#include "shared-forward.h"
/* crypt_dump() internal indentation magic */
#define CRYPT_DUMP_LINE_SEP "\n\t "
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* for more information see libcryptsetup.h crypt-tokens section */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int acquire_luks2_key(
struct crypt_device *cd,
#include <stdio.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "fileio.h"
#include "log.h"
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef struct KernelHibernateLocation KernelHibernateLocation;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "homed-forward.h"
/* Flags supported by UpdateEx() */
#define SD_HOMED_UPDATE_OFFLINE (UINT64_C(1) << 0)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int identity_add_fido2_parameters(sd_json_variant **v, const char *device, Fido2EnrollFlags lock_with, int cred_alg);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int identity_add_token_pin(sd_json_variant **v, const char *pin);
int identity_add_pkcs11_key_data(sd_json_variant **v, const char *token_uri);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int identity_add_recovery_key(sd_json_variant **v);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "homed-forward.h"
int bus_message_read_secret(sd_bus_message *m, UserRecord **ret, sd_bus_error *error);
int bus_message_read_home_record(sd_bus_message *m, UserRecordLoadFlags flags, UserRecord **ret, sd_bus_error *error);
#pragma once
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef struct Manager Manager;
typedef struct Home Home;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "homed-forward.h"
#include "pidref.h"
#include "stat-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef enum HomeSetupFlags HomeSetupFlags;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int user_record_check_password_quality(UserRecord *hr, UserRecord *secret, sd_bus_error *error);
#include <openssl/evp.h>
-#include "forward.h"
+#include "shared-forward.h"
int user_record_sign(UserRecord *ur, EVP_PKEY *private_key, UserRecord **ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* We intentionally use snake_case instead of the usual camelCase here to further
* reduce the chance of collision with a field any legitimate user record may ever
#include <curl/curl.h>
-#include "forward.h"
+#include "shared-forward.h"
typedef struct CurlGlue CurlGlue;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "import-compress.h"
typedef struct RawExport RawExport;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "import-compress.h"
typedef struct TarExport TarExport;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum ImportFlags {
/* Public Flags (i.e. accessible via D-Bus, must stay stable! */
#include <zstd.h>
#endif
-#include "forward.h"
+#include "shared-forward.h"
typedef enum ImportCompressType {
IMPORT_COMPRESS_UNKNOWN,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "import-common.h"
typedef struct RawImport RawImport;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "import-common.h"
typedef struct TarImport TarImport;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "import-common.h"
#include "import-util.h"
#include "pull-job.h"
#include <curl/curl.h>
#include <sys/stat.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "import-compress.h"
#include "openssl-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "import-common.h"
#include "import-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "import-common.h"
#include "import-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int parse_integrity_options(
const char *options,
#include "compress.h"
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef struct CompressionConfig {
Compression algorithm;
#pragma once
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
bool header_value_is_valid(const char *value);
#pragma once
#include "compress.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "journal-importer.h"
#include "journal-remote-write.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "journal-remote-parse.h"
#include "journal-remote-write.h"
#include <curl/curl.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "journal-compression-util.h"
typedef enum {
#include <microhttpd.h>
-#include "forward.h"
+#include "shared-forward.h"
/* Those defines are added when options are renamed. If the old names
* are not '#define'd, then they are not deprecated yet and there are
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int add_filters(sd_journal *j, char **matches);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int action_print_header(void);
int action_verify(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "logs-show.h"
/* The lists below are supposed to return the superset of unit names possibly matched by rules added with
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "pcre2-util.h"
typedef enum JournalctlAction {
#pragma once
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef enum Storage Storage;
typedef enum SplitMode SplitMode;
Copyright © 2014 Axis Communications AB. All rights reserved.
***/
-#include "forward.h"
+#include "sd-forward.h"
int arp_update_filter(int fd, const struct in_addr *a, const struct ether_addr *mac);
int arp_network_bind_raw_socket(int ifindex, const struct in_addr *a, const struct ether_addr *mac);
#include "sd-dhcp-client-id.h"
#include "dhcp-duid-internal.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "sparse-endian.h"
/* RFC 2132 section 9.14: its minimum length is 2.
#include "sd-dhcp-client.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "network-common.h"
typedef enum DHCPState {
#include "sd-id128.h"
#include "ether-addr-util.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "sparse-endian.h"
#define SYSTEMD_PEN 43793
#include "dhcp-client-id-internal.h"
#include "dhcp-option.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "list.h"
struct sd_dhcp_route {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
#include "sparse-endian.h"
int dhcp_network_bind_raw_socket(
#include "sd-dhcp-option.h" /* IWYU pragma: export */
#include "dhcp-protocol.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "hash-funcs.h"
struct sd_dhcp_option {
#pragma once
#include "dhcp-protocol.h"
-#include "forward.h"
+#include "sd-forward.h"
int bootp_message_init(
DHCPMessage *message,
#include "sd-dhcp-protocol.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "sparse-endian.h"
#include "time-util.h"
#include "dhcp-client-id-internal.h"
#include "dhcp-option.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "network-common.h"
#include "sparse-endian.h"
#include "dhcp-client-id-internal.h"
#include "dhcp-server-internal.h"
-#include "forward.h"
+#include "sd-forward.h"
typedef struct sd_dhcp_server_lease {
unsigned n_ref;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
#include "sd-dhcp6-client.h"
int dhcp6_client_set_state_callback(
#include "dhcp-duid-internal.h"
#include "dhcp6-option.h"
#include "dhcp6-protocol.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "network-common.h"
#include "sparse-endian.h"
#include "dhcp6-option.h"
#include "dhcp6-protocol.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "time-util.h"
struct sd_dhcp6_lease {
#include "sd-dhcp6-option.h" /* IWYU pragma: export */
-#include "forward.h"
+#include "sd-forward.h"
#include "list.h"
#include "sparse-endian.h"
Copyright © 2014 Intel Corporation. All rights reserved.
***/
-#include "forward.h"
+#include "sd-forward.h"
#include "sparse-endian.h"
struct DHCP6Message {
#include "sd-dns-resolver.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "socket-netlink.h"
/* https://www.iana.org/assignments/dns-svcb/dns-svcb.xhtml#dns-svcparamkeys */
#include <netinet/in.h>
-#include "forward.h"
+#include "sd-forward.h"
#include "time-util.h"
typedef struct ICMP6Packet {
#include <netinet/in.h>
-#include "forward.h"
+#include "sd-forward.h"
#define IN6_ADDR_ALL_ROUTERS_MULTICAST \
((const struct in6_addr) { { { \
#include "sd-lldp-rx.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "memory-util.h"
#include "time-util.h"
#include "sd-lldp-rx.h" /* IWYU pragma: export */
#include "network-common.h"
-#include "forward.h"
+#include "sd-forward.h"
struct sd_lldp_rx {
unsigned n_ref;
#include "sd-event.h"
#include "sd-ndisc.h" /* IWYU pragma: export */
-#include "forward.h"
+#include "sd-forward.h"
#include "network-common.h"
#include "time-util.h"
#include <linux/in6.h>
-#include "forward.h"
+#include "sd-forward.h"
typedef struct sd_ndisc_neighbor {
unsigned n_ref;
#include <linux/in6.h>
-#include "forward.h"
+#include "sd-forward.h"
typedef struct sd_ndisc_redirect {
unsigned n_ref;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
typedef struct sd_ndisc_router_solicit {
unsigned n_ref;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
#include "log-link.h"
#include "sparse-endian.h"
#include "time-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
size_t serialize_in_addrs(FILE *f,
const struct in_addr *addresses,
#include <netinet/in.h>
-#include "forward.h"
+#include "sd-forward.h"
#include "network-common.h"
#include "time-util.h"
#include "_sd-common.h"
-#include "forward.h"
+#include "sd-forward.h"
_SD_BEGIN_DECLARATIONS;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
int bus_container_connect_socket(sd_bus *b);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
int bus_add_match_internal(sd_bus *bus, const char *match, uint64_t timeout_usec, uint64_t *ret_counter);
int bus_add_match_internal_async(sd_bus *bus, sd_bus_slot **ret, const char *match, sd_bus_message_handler_t callback, void *userdata, uint64_t timeout_usec);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
typedef struct sd_bus_creds {
bool allocated;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
int bus_creds_dump(sd_bus_creds *c, FILE *f, bool terse);
#include "sd-bus-protocol.h"
#include "errno-util.h"
-#include "forward.h"
+#include "sd-forward.h"
bool bus_error_is_dirty(sd_bus_error *e);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
typedef enum BusAuth BusAuth;
typedef enum BusSlotType BusSlotType;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
#define MEMFD_CACHE_MAX 32
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
bool signature_is_single(const char *s, bool allow_dict_entry);
bool signature_is_pair(const char *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
void bus_socket_setup(sd_bus *b);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
void bus_track_dispatch(sd_bus_track *track);
void bus_track_close(sd_bus_track *track);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
bool bus_type_is_valid(char c) _const_;
bool bus_type_is_basic(char c) _const_;
--- /dev/null
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#pragma once
+
+/* IWYU pragma: always_keep */
+
+#include "basic-forward.h" /* IWYU pragma: export */
+
+typedef void (*_sd_destroy_t)(void *userdata);
+
+typedef union sd_id128 sd_id128_t;
+
+typedef struct sd_event sd_event;
+typedef struct sd_event_source sd_event_source;
+
+typedef int (*sd_event_handler_t)(sd_event_source *s, void *userdata);
+typedef int (*sd_event_io_handler_t)(sd_event_source *s, int fd, uint32_t revents, void *userdata);
+typedef int (*sd_event_time_handler_t)(sd_event_source *s, uint64_t usec, void *userdata);
+typedef int (*sd_event_signal_handler_t)(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata);
+typedef int (*sd_event_inotify_handler_t)(sd_event_source *s, const struct inotify_event *event, void *userdata);
+typedef _sd_destroy_t sd_event_destroy_t;
+
+enum ENUM_TYPE_S64(sd_json_format_flags_t);
+enum ENUM_TYPE_S64(sd_json_dispatch_flags_t);
+enum ENUM_TYPE_S64(sd_json_variant_type_t);
+enum ENUM_TYPE_S64(sd_json_parse_flags_t);
+
+typedef enum sd_json_format_flags_t sd_json_format_flags_t;
+typedef enum sd_json_dispatch_flags_t sd_json_dispatch_flags_t;
+typedef enum sd_json_variant_type_t sd_json_variant_type_t;
+typedef enum sd_json_parse_flags_t sd_json_parse_flags_t;
+
+typedef struct sd_json_variant sd_json_variant;
+
+typedef struct sd_bus sd_bus;
+typedef struct sd_bus_error sd_bus_error;
+typedef struct sd_bus_error_map sd_bus_error_map;
+typedef struct sd_bus_message sd_bus_message;
+typedef struct sd_bus_slot sd_bus_slot;
+typedef struct sd_bus_creds sd_bus_creds;
+typedef struct sd_bus_track sd_bus_track;
+typedef struct sd_bus_vtable sd_bus_vtable;
+
+typedef int (*sd_bus_message_handler_t)(sd_bus_message *m, void *userdata, sd_bus_error *ret_error);
+typedef int (*sd_bus_property_get_t)(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *ret_error);
+typedef int (*sd_bus_property_set_t)(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *ret_error);
+typedef int (*sd_bus_object_find_t)(sd_bus *bus, const char *path, const char *interface, void *userdata, void **ret_found, sd_bus_error *ret_error);
+typedef int (*sd_bus_node_enumerator_t)(sd_bus *bus, const char *prefix, void *userdata, char ***ret_nodes, sd_bus_error *ret_error);
+typedef int (*sd_bus_track_handler_t)(sd_bus_track *track, void *userdata);
+typedef _sd_destroy_t sd_bus_destroy_t;
+
+enum ENUM_TYPE_S64(sd_device_action_t);
+
+typedef enum sd_device_action_t sd_device_action_t;
+
+typedef struct sd_device sd_device;
+typedef struct sd_device_enumerator sd_device_enumerator;
+typedef struct sd_device_monitor sd_device_monitor;
+
+typedef struct sd_netlink sd_netlink;
+typedef struct sd_netlink_message sd_netlink_message;
+typedef struct sd_netlink_slot sd_netlink_slot;
+
+typedef int (*sd_netlink_message_handler_t)(sd_netlink *nl, sd_netlink_message *m, void *userdata);
+typedef _sd_destroy_t sd_netlink_destroy_t;
+
+typedef struct sd_network_monitor sd_network_monitor;
+
+enum ENUM_TYPE_S64(sd_dhcp_lease_server_type_t);
+enum ENUM_TYPE_S64(sd_lldp_rx_event_t);
+enum ENUM_TYPE_S64(sd_lldp_multicast_mode_t);
+enum ENUM_TYPE_S64(sd_ndisc_event_t);
+
+typedef enum sd_dhcp_lease_server_type_t sd_dhcp_lease_server_type_t;
+typedef enum sd_lldp_rx_event_t sd_lldp_rx_event_t;
+typedef enum sd_lldp_multicast_mode_t sd_lldp_multicast_mode_t;
+typedef enum sd_ndisc_event_t sd_ndisc_event_t;
+
+typedef struct sd_ipv4ll sd_ipv4ll;
+typedef struct sd_dhcp_client sd_dhcp_client;
+typedef struct sd_dhcp_lease sd_dhcp_lease;
+typedef struct sd_dhcp_route sd_dhcp_route;
+typedef struct sd_dns_resolver sd_dns_resolver;
+typedef struct sd_dhcp_server sd_dhcp_server;
+typedef struct sd_ndisc sd_ndisc;
+typedef struct sd_radv sd_radv;
+typedef struct sd_dhcp6_client sd_dhcp6_client;
+typedef struct sd_dhcp6_lease sd_dhcp6_lease;
+typedef struct sd_lldp_tx sd_lldp_tx;
+typedef struct sd_lldp_rx sd_lldp_rx;
+typedef struct sd_lldp_neighbor sd_lldp_neighbor;
+
+typedef struct ICMP6Packet ICMP6Packet;
+
+enum ENUM_TYPE_S64(sd_varlink_method_flags_t);
+enum ENUM_TYPE_S64(sd_varlink_interface_flags_t);
+enum ENUM_TYPE_S64(sd_varlink_symbol_type_t);
+enum ENUM_TYPE_S64(sd_varlink_field_type_t);
+enum ENUM_TYPE_S64(sd_varlink_field_direction_t);
+enum ENUM_TYPE_S64(sd_varlink_field_flags_t);
+enum ENUM_TYPE_S64(sd_varlink_idl_format_flags_t);
+enum ENUM_TYPE_S64(sd_varlink_reply_flags_t);
+enum ENUM_TYPE_S64(sd_varlink_server_flags_t);
+enum ENUM_TYPE_S64(sd_varlink_invocation_flags_t);
+
+typedef enum sd_varlink_method_flags_t sd_varlink_method_flags_t;
+typedef enum sd_varlink_interface_flags_t sd_varlink_interface_flags_t;
+typedef enum sd_varlink_symbol_type_t sd_varlink_symbol_type_t;
+typedef enum sd_varlink_field_type_t sd_varlink_field_type_t;
+typedef enum sd_varlink_field_direction_t sd_varlink_field_direction_t;
+typedef enum sd_varlink_field_flags_t sd_varlink_field_flags_t;
+typedef enum sd_varlink_idl_format_flags_t sd_varlink_idl_format_flags_t;
+typedef enum sd_varlink_reply_flags_t sd_varlink_reply_flags_t;
+typedef enum sd_varlink_server_flags_t sd_varlink_server_flags_t;
+typedef enum sd_varlink_invocation_flags_t sd_varlink_invocation_flags_t;
+
+typedef struct sd_varlink sd_varlink;
+typedef struct sd_varlink_server sd_varlink_server;
+typedef struct sd_varlink_field sd_varlink_field;
+typedef struct sd_varlink_symbol sd_varlink_symbol;
+typedef struct sd_varlink_interface sd_varlink_interface;
+
+typedef struct sd_journal sd_journal;
+
+typedef struct sd_resolve sd_resolve;
+typedef struct sd_resolve_query sd_resolve_query;
+
+typedef struct sd_hwdb sd_hwdb;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
typedef enum MatchInitializedType {
MATCH_INITIALIZED_NO, /* only devices without a db entry */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
int update_match_strv(Hashmap **match_strv, const char *key, const char *value, bool clear_on_null);
bool device_match_sysattr(sd_device *device, Hashmap *match_sysattr, Hashmap *nomatch_sysattr);
#include "sd-device.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "iterator.h"
#define LATEST_UDEV_DATABASE_VERSION 1
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
typedef enum MonitorNetlinkGroup {
MONITOR_GROUP_NONE,
#include "sd-device.h" /* IWYU pragma: export */
-#include "forward.h"
+#include "sd-forward.h"
int device_new_from_mode_and_devnum(sd_device **ret, mode_t mode, dev_t devnum);
int device_new_from_nulstr(sd_device **ret, char *nulstr, size_t len);
#include "sd-device.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "log.h"
#define device_unref_and_replace(a, b) \
#include "sd-event.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "inotify-util.h"
#include "list.h"
#include "ratelimit.h"
#include "sd-event.h"
-#include "forward.h"
+#include "sd-forward.h"
extern const struct hash_ops event_source_hash_ops;
#include <sys/stat.h>
-#include "forward.h"
+#include "sd-forward.h"
#include "iterator.h"
#include "sparse-endian.h"
#include "sd-id128.h"
#include "errno-util.h"
-#include "forward.h"
+#include "sd-forward.h"
bool id128_is_valid(const char *s) _pure_;
#include <stdio.h>
-#include "forward.h"
+#include "sd-forward.h"
const char* audit_type_to_string(int type);
int audit_type_from_string(const char *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
int catalog_import_file(OrderedHashmap **h, int fd, const char *path);
int catalog_update(const char *database, const char *root, const char* const *dirs);
* Contact: fsprg@point-at-infinity.org
*/
-#include "forward.h"
+#include "sd-forward.h"
#ifdef __cplusplus
extern "C" {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
#include "journal-file.h"
int journal_file_append_tag(JournalFile *f);
#include "sd-id128.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "sparse-endian.h"
/*
#include <sys/stat.h>
#include "compress.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "gcrypt-util.h"
#include "journal-def.h"
#include "mmap-cache.h"
#include "journal-file.h"
#include "list.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "time-util.h"
#define JOURNAL_FILES_MAX 7168u
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
int journal_directory_vacuum(const char *directory, uint64_t max_use, uint64_t n_max_files, usec_t max_retention_usec, usec_t *oldest_usec, bool verbose);
/* SPDX-License-Identifier: LicenseRef-lookup3-public-domain */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
uint32_t jenkins_hashword(const uint32_t *k, size_t length, uint32_t initval) _pure_;
void jenkins_hashword2(const uint32_t *k, size_t length, uint32_t *pc, uint32_t *pb);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
#include "journal-def.h"
typedef struct MMapCache MMapCache;
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
/* This header should include all prototypes only the JSON parser itself and
* its tests need access to. Normal code consuming the JSON parser should not
#include "sd-json.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "log.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
#define CTRL_GENL_NAME "nlctrl"
#include <linux/netlink.h>
#include <sys/socket.h>
-#include "forward.h"
+#include "sd-forward.h"
#include "list.h"
#include "netlink-types.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
#include "netlink-internal.h"
int netlink_slot_allocate(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "sd-forward.h"
typedef enum NLAType {
NETLINK_TYPE_UNSPEC, /* NLA_UNSPEC */
#include <linux/rtnetlink.h>
-#include "forward.h"
+#include "sd-forward.h"
#include "in-addr-util.h"
#define RTA_FLAGS(rta) ((rta)->rta_type & ~NLA_TYPE_MASK)
#include <sys/socket.h>
#include "constants.h"
-#include "forward.h"
+#include "sd-forward.h"
#define NETWORK_DIRS ((const char* const*) CONF_PATHS_STRV("systemd/network"))
#define NETWORK_DIRS_NULSTR CONF_PATHS_NULSTR("systemd/network")
#include "sd-path.h"
-#include "forward.h"
+#include "sd-forward.h"
#include "runtime-scope.h"
typedef enum LookupPathsFlags {
#include "sd-varlink.h"
#include "sd-varlink-idl.h"
-#include "forward.h"
+#include "sd-forward.h"
bool varlink_idl_field_name_is_valid(const char *name);
bool varlink_idl_symbol_name_is_valid(const char *name);
#include "sd-varlink.h"
#include "list.h"
-#include "forward.h"
+#include "sd-forward.h"
typedef enum VarlinkState {
/* Client side states */
#include "sd-varlink.h"
-#include "forward.h"
+#include "sd-forward.h"
int varlink_get_peer_pidref(sd_varlink *v, PidRef *ret);
#include "libudev.h"
-#include "forward.h"
+#include "shared-forward.h"
struct udev_device;
#include "libudev.h"
-#include "forward.h"
+#include "shared-forward.h"
struct udev_list;
#include "libudev.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "device-nodes.h"
/**
#include "libudev.h"
-#include "forward.h"
+#include "shared-forward.h"
/* Cleanup functions */
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev*, udev_unref);
#include <sys/stat.h>
#include <syslog.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "locale-setup.h"
#include "vconsole-util.h"
#pragma once
#include "dlfcn-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_XKBCOMMON
#include <xkbcommon/xkbcommon.h>
#pragma once
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef enum InhibitWhat InhibitWhat;
typedef enum KillWhom KillWhom;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
#include "logind-forward.h"
#include "time-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "output-mode.h"
int show_sysfs(const char *seat, const char *prefix, unsigned columns, OutputFlags flags);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef struct Machine Machine;
typedef struct Manager Manager;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "ratelimit.h"
#define MOUNTFS_WORKERS_MIN 3
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef enum BareUDPProtocol {
#include <linux/batman_adv.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
#define BATADV_GENL_NAME "batadv"
#pragma once
#include "bond-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef struct Bond {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
#define LINK_BRIDGE_PORT_PRIORITY_INVALID 128U
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef struct Dummy {
#include <linux/fou.h>
#include "in-addr-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef enum FooOverUDPEncapType {
#include <linux/if_link.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "in-addr-util.h"
#include "netdev.h"
#include <linux/l2tp.h>
#include "in-addr-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef enum L2tpL2specType {
#include <linux/if_macsec.h>
#include <net/ethernet.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
#include "sparse-endian.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "fou-tunnel.h"
#include "netdev.h"
#include "networkd-link.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef struct TunTap {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef struct VLan {
#include <linux/nl80211.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef struct WLan {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "netdev.h"
typedef struct Xfrm {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int dump_list(Table *table, const char *key, char * const *l);
int ieee_oui(sd_hwdb *hwdb, const struct ether_addr *mac, char **ret);
#include "ether-addr-util.h"
#include "ethtool-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "in-addr-util.h"
typedef struct VxLanInfo {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int dump_lldp_neighbors(sd_varlink *vl, Table *table, int ifindex);
int link_lldp_status(int argc, char *argv[], void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int system_status(sd_netlink *rtnl, sd_hwdb *hwdb);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int varlink_connect_networkd(sd_varlink **ret_varlink);
bool networkd_is_running(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "pager.h"
extern PagerFlags arg_pager_flags;
#pragma once
#include "firewall-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "in-addr-util.h"
#include "networkd-forward.h"
#include "networkd-util.h"
#include <linux/neighbour.h>
#include <net/ethernet.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "in-addr-util.h"
#include "networkd-forward.h"
#pragma once
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef enum NetDevLocalAddressType NetDevLocalAddressType;
typedef enum NetworkConfigSource NetworkConfigSource;
#include <linux/nl80211.h>
#include "ether-addr-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "network-util.h"
#include "networkd-bridge-vlan.h"
#include "networkd-forward.h"
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
#include "tclass.h"
#include <linux/pkt_sched.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct EnhancedTransmissionSelection {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct FirstInFirstOut {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct FairQueueingControlledDelay {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct FlowQueuePIE {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct FairQueueing {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct GenericRandomEarlyDetection {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct HeavyHitterFilter {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
#include "tclass.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "forward.h"
+#include "shared-forward.h"
#include "mq.h"
const QDiscVTable mq_vtable = {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct ClassfulMultiQueueing {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct BandMultiQueueing {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct NetworkEmulator {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct ProportionalIntegralControllerEnhanced {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
#include "tclass.h"
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct StochasticFairBlue {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct StochasticFairnessQueueing {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct TokenBucketFilter {
#include <linux/pkt_sched.h>
-#include "forward.h"
+#include "shared-forward.h"
int tc_init(double *ret_ticks_in_usec, uint32_t *ret_hz);
int tc_time_to_tick(usec_t t, uint32_t *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "qdisc.h"
typedef struct TrivialLinkEqualizer {
#include <sys/uio.h>
-#include "forward.h"
+#include "shared-forward.h"
typedef struct DNSServer {
struct iovec addr;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "network-util.h"
typedef struct DNSConfiguration DNSConfiguration;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "network-util.h"
typedef struct DNSConfiguration DNSConfiguration;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "forward.h"
+#include "shared-forward.h"
int bind_user_setup(const MachineBindUserContext *c, const char *root);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "nspawn-settings.h"
int create_subcgroup(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
typedef struct ExposePort {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "volatile-util.h"
typedef enum MountSettingsMask {
#include <linux/if.h>
-#include "forward.h"
+#include "shared-forward.h"
int test_network_interfaces_initialized(char **iface_pairs);
int resolve_network_interface_names(char **iface_pairs);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "nspawn-settings.h"
int oci_load(FILE *f, const char *path, Settings **ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "nspawn-settings.h"
int register_machine(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int setup_seccomp(uint64_t cap_list_retain, char **syscall_allow_list, char **syscall_deny_list);
#include "capability-util.h"
#include "conf-parser-forward.h"
#include "cpu-set-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "rlimit-util.h"
#include "seccomp-util.h"
#include "volatile-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int change_uid_gid_raw(uid_t uid, gid_t gid, const gid_t *supplementary_gids, size_t n_supplementary_gids, bool chown_stdio);
int change_uid_gid(const char *user, bool chown_stdio, char **ret_home);
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
int stub_pid1(sd_id128_t uuid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int userns_lchown(const char *p, uid_t uid, gid_t gid);
int userns_mkdir(const char *root, const char *path, mode_t mode, uid_t uid, gid_t gid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "ratelimit.h"
#define NSRESOURCE_WORKERS_MIN 5
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#define USER_NAMESPACE_CGROUPS_DELEGATE_MAX 16U
#define USER_NAMESPACE_NETIFS_DELEGATE_MAX 16U
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_VMLINUX_H
#include "bpf/userns-restrict/userns-restrict-skel.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int _nss_systemd_block(bool b);
bool _nss_systemd_is_blocked(void);
#include <nss.h>
#include <pwd.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "userdb.h"
UserDBFlags nss_glue_userdb_flags(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
extern const BusObjectImplementation manager_object;
#pragma once
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "oomd-util.h"
/* Polling interval for monitoring stats */
#pragma once
#include "cgroup-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "psi-util.h"
#define DUMP_ON_KILL_COUNT 10u
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "tpm2-event-log.h"
int validate_firmware_event(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "runtime-scope.h"
#include "string-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef struct Manager Manager;
typedef struct Operation Operation;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* DNS record types, taken from
* http://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml.
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum ExecutionMode {
MODE_RESOLVE_HOST,
#pragma once
#include "dns-def.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
#include "ratelimit.h"
#include "resolve-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "in-addr-util.h"
#include "list.h"
#include "resolved-conf.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
#include "resolved-dns-packet.h"
#include "resolved-dnstls.h"
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
extern const BusObjectImplementation dnssd_object;
#pragma once
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef enum DnsAnswerFlags DnsAnswerFlags;
typedef enum DnsCacheMode DnsCacheMode;
#include <sys/stat.h>
#include "common-signal.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
#include "resolve-util.h"
#include "resolved-dns-browse-services.h"
#include <openssl/asn1t.h>
-#include "forward.h"
+#include "shared-forward.h"
#define SPC_INDIRECT_DATA_OBJID "1.3.6.1.4.1.311.2.1.4"
#define SPC_PE_IMAGE_DATA_OBJID "1.3.6.1.4.1.311.2.1.15"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int fd_acl_make_read_only_fallback(int fd);
int fd_acl_make_writable_fallback(int fd);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_APPARMOR
# include <sys/apparmor.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int ask_password_agent_open(void);
void ask_password_agent_close(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum AskPasswordFlags {
ASK_PASSWORD_ACCEPT_CACHED = 1 << 0, /* read from kernel keyring */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* See source file for an API description. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 "forward.h"
+#include "shared-forward.h"
int on_ac_power(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "iterator.h"
typedef struct Bitmap {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_BLKID
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum BlockDevListFlags {
BLOCKDEV_LIST_SHOW_SYMLINKS = 1 << 0, /* Pick up symlinks to block devices too */
#include <sys/sysmacros.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "stdio-util.h"
#define SYS_BLOCK_PATH_MAX(suffix) \
#include <linux/if_bonding.h>
-#include "forward.h"
+#include "shared-forward.h"
/*
* Maximum number of targets supported by the kernel for a single
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum BootEntryTokenType {
BOOT_ENTRY_TOKEN_MACHINE_ID,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int boot_timestamps(const dual_timestamp *n, dual_timestamp *firmware, dual_timestamp *loader);
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum BootEntryType {
BOOT_ENTRY_TYPE1, /* Boot Loader Specification Type #1 entries: *.conf files */
#include "bpf-compat.h" /* IWYU pragma: export */
#include "dlfcn-util.h"
-#include "forward.h"
+#include "shared-forward.h"
extern DLSYM_PROTOTYPE(bpf_link__destroy);
extern DLSYM_PROTOTYPE(bpf_link__fd);
#include <bpf/libbpf.h>
-#include "forward.h"
+#include "shared-forward.h"
bool bpf_can_link_program(struct bpf_program *prog);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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
#include <linux/if_bridge.h>
-#include "forward.h"
+#include "shared-forward.h"
typedef enum BridgeState {
NETDEV_BRIDGE_STATE_DISABLED = BR_STATE_DISABLED,
#include "sd-id128.h"
#include "btrfs.h" /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-forward.h"
typedef struct BtrfsSubvolInfo {
uint64_t subvol_id;
#include "sd-bus.h"
-#include "forward.h"
+#include "shared-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 *reterr_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 *reterr_error);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct BusLocator {
const char *destination;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
extern const BusObjectImplementation log_control_object;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef int (*bus_property_set_t)(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int bus_message_read_id128(sd_bus_message *m, sd_id128_t *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct BusObjectVtablePair {
const sd_bus_vtable *vtable;
#include "sd-json.h"
#include "sd-varlink.h"
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum BusPrintPropertyFlags {
BUS_PRINT_PROPERTY_ONLY_VALUE = 1 << 0, /* e.g. systemctl --value */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 *reterr_error);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum ExecDirectoryFlags {
EXEC_DIRECTORY_READ_ONLY = 1 << 0, /* Public API via DBUS, do not change */
#include "sd-bus.h" /* IWYU pragma: export */
#include "log.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum BusTransport {
BUS_TRANSPORT_LOCAL,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct BusWaitForJobs BusWaitForJobs;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct BusWaitForUnits BusWaitForUnits;
/* A structure for specifying (possibly repetitive) points in calendar
* time, a la cron */
-#include "forward.h"
+#include "shared-forward.h"
typedef struct CalendarComponent {
int start;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-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);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int clean_ipc_internal(uid_t uid, gid_t gid, bool rm);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
void rgb_to_hsv(double r, double g, double b,
double *ret_h, double *ret_s, double *ret_v);
#include <syslog.h>
-#include "forward.h"
+#include "shared-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 "forward.h"
+#include "shared-forward.h"
#define COMPARE_OPERATOR_CHARS "!<=>"
#define COMPARE_OPERATOR_WITH_FNMATCH_CHARS COMPARE_OPERATOR_CHARS "$"
#pragma once
#include "list.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum ConditionType {
CONDITION_ARCHITECTURE,
#include "alloc-util.h"
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "log.h"
/* An abstract parser for simple, line based, shallow configuration files consisting of variable assignments only. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum CopyFlags {
COPY_REFLINK = 1 << 0, /* Try to reflink */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum CoredumpFilter {
COREDUMP_FILTER_PRIVATE_ANONYMOUS = 0,
#include <sched.h>
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
/* This wraps the libc interface with a variable to keep the allocated size. */
typedef struct CPUSet {
#include "sd-id128.h"
#include "fd-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#define CREDENTIAL_NAME_MAX FDNAME_MAX
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int acquire_fido2_key(
const char *volume_name,
#include <sys/uio.h>
-#include "forward.h"
+#include "shared-forward.h"
int acquire_tpm2_key(
const char *volume_name,
#pragma once
#include "dlfcn-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_LIBCRYPTSETUP
#include <libcryptsetup.h> /* IWYU pragma: export */
#include "sd-daemon.h" /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-forward.h"
#define NOTIFY_READY_MESSAGE "READY=1\n" "STATUS=Processing requests..."
#define NOTIFY_STOPPING_MESSAGE "STOPPING=1\n" "STATUS=Shutting down..."
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int dev_setup(const char *prefix, uid_t uid, gid_t gid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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);
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "os-util.h"
typedef enum ImageType {
#include "sd-id128.h"
#include "architecture.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "gpt.h"
#include "list.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum DNSLabelFlags {
DNS_LABEL_LDH = 1 << 0, /* Follow the "LDH" rule — only letters, digits, and internal hyphens. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int drop_in_file(
const char *dir,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
/* Various calls for interfacing with EFI variables from the official UEFI specs. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* Various calls that interface with EFI variables implementing https://systemd.io/BOOT_LOADER_INTERFACE */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int dlopen_dw(void);
int dlopen_elf(void);
#include <linux/ethtool.h>
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
#define N_ADVERTISE 4
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef int (*gather_stdout_callback_t) (int fd, void *arg);
#pragma once
#include "bitmap.h"
-#include "forward.h"
+#include "shared-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:
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum FactoryResetMode {
FACTORY_RESET_UNSUPPORTED, /* feature not available on this OS */
#include <libfdisk.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "iterator.h"
FDSet* fdset_new(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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);
#pragma once
-#include "forward.h"
+#include "shared-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);
#pragma once
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
int fw_nftables_add_masquerade(
sd_netlink *nfnl,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int fork_notify(char * const *cmdline, PidRef *ret_pidref);
#include "sd-json.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "log.h"
#include "pager.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
bool fstab_enabled_full(int enabled);
static inline bool fstab_enabled(void) {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 "forward.h"
+#include "shared-forward.h"
typedef enum GeneveDF {
NETDEV_GENEVE_DF_UNSET = GENEVE_DF_UNSET,
#include "sd-id128.h"
#include "architecture.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "sparse-endian.h"
/* maximum length of gpt label */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "user-record.h"
typedef struct GroupRecord {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum HostnameSource {
HOSTNAME_STATIC, /* from /etc/hostname */
#include "sd-hwdb.h" /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-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 "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum Id128PrettyPrintMode {
ID128_PRINT_ID128,
# include <stringprep.h>
#endif
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_LIBIDN2 || HAVE_LIBIDN
#include "dlfcn-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
bool use_ima(void);
#pragma once
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "gpt.h"
typedef enum PartitionPolicyFlags {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum ImportType {
IMPORT_RAW,
#pragma once
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "in-addr-util.h"
struct in_addr_prefix {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum InstallFileFlags {
INSTALL_REPLACE = 1 << 0, /* Replace an existing inode */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int install_name_printf(
RuntimeScope scope,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "runtime-scope.h"
#include "unit-file.h"
#include <sys/ioprio.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-forward.h"
static inline int ioprio_prio_class(int value) {
return IOPRIO_PRIO_CLASS(value);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
const char* ip_protocol_to_name(int id);
int ip_protocol_from_name(const char *name);
#include <linux/if_link.h>
-#include "forward.h"
+#include "shared-forward.h"
typedef enum IPVlanMode {
NETDEV_IPVLAN_MODE_L2 = IPVLAN_MODE_L2,
#pragma once
#include "journal-file.h" /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-forward.h"
int journal_file_set_offline(JournalFile *f, bool wait);
bool journal_file_is_offlining(JournalFile *f);
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "iovec-wrapper.h"
#include "time-util.h"
#include "sd-journal.h" /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-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 "forward.h"
+#include "shared-forward.h"
int keymap_directories(char ***ret);
int get_keymaps(char ***ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "forward.h"
+#include "shared-forward.h"
int load_kernel_install_conf(
const char *root,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum KernelImageType {
KERNEL_IMAGE_TYPE_UNKNOWN,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "label.h" /* IWYU pragma: export */
typedef enum LabelFixFlags {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_LIBARCHIVE
#include <archive.h> /* IWYU pragma: export */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int dlopen_libaudit(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int make_salt(char **ret);
int hash_password_full(const char *password, void **cd_data, int *cd_size, char **ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#define FIDO2_SALT_SIZE 32U
#include <libmount.h> /* IWYU pragma: export */
#include "dlfcn-util.h"
-#include "forward.h"
+#include "shared-forward.h"
extern DLSYM_PROTOTYPE(mnt_free_iter);
extern DLSYM_PROTOTYPE(mnt_free_table);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "in-addr-util.h"
struct local_address {
#include <sys/stat.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "locale-util.h"
typedef struct LocaleContext {
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef struct LogId {
sd_id128_t id; /* boot ID or invocation ID */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* Some helpers for setting up loopback block devices */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct MachineBindUserData {
/* The host's user/group records */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct MachineCredential {
char *id;
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum MachineIdSetupFlags {
MACHINE_ID_SETUP_FORCE_TRANSIENT = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int setup_machine_directory(sd_bus_error *error, bool use_btrfs_subvol, bool use_btrfs_quota);
#include <linux/if_link.h>
-#include "forward.h"
+#include "shared-forward.h"
typedef enum MacVlanMode {
NETDEV_MACVLAN_MODE_PRIVATE = MACVLAN_MODE_PRIVATE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "static-destruct.h"
void main_prepare(int argc, char *argv[]);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "mkdir.h"
int mkdirat_label(int dirfd, const char *path, mode_t mode);
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum MakeFilesystemFlags {
MKFS_QUIET = 1 << 0, /* Suppress mkfs command output */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_KMOD
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
bool mount_point_is_api(const char *path) _pure_;
bool mount_point_ignore(const char *path) _pure_;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct SubMount {
char *path;
#include <linux/nl80211.h>
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef struct NetMatch {
Set *hw_addr;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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
#include <net/ethernet.h>
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum SRIOVAttribute {
SR_IOV_VF_MAC,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int notify_socket_prepare_full(
sd_event *event,
#include <sched.h>
-#include "forward.h"
+#include "shared-forward.h"
/* The combination of all namespace flags defined by the kernel. The right type for this isn't clear. setns() and
* unshare() expect these flags to be passed as (signed) "int", while clone() wants them as "unsigned long". The latter
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int nsresource_allocate_userns(const char *name, uint64_t size);
int nsresource_register_userns(const char *name, int userns_fd);
#include <pwd.h>
#include <resolv.h>
-#include "forward.h"
+#include "shared-forward.h"
#include "signal-util.h"
extern sd_json_dispatch_flags_t nss_json_dispatch_flags;
#include <sys/mempolicy.h>
#include "cpu-set-util.h"
-#include "forward.h"
+#include "shared-forward.h"
static inline bool mpol_is_valid(int t) {
return t >= MPOL_DEFAULT && t <= MPOL_LOCAL;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
typedef enum OpenFileFlag {
#pragma once
#include "ask-password-api.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "iovec-util.h"
#include "sha256.h"
#include "sd-id128.h"
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum OutputMode {
OUTPUT_SHORT,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum PagerFlags {
PAGER_DISABLE = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_PAM
#include <security/pam_appl.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 "forward.h"
+#include "shared-forward.h"
typedef enum PathSimplifyWarnFlags {
PATH_CHECK_FATAL = 1 << 0, /* If not set, then error message is appended with 'ignoring'. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_PASSWDQC
#include <passwdqc.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_PWQUALITY
#include <pwquality.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_PCRE2
#include "ask-password-api.h"
#include "dlfcn-util.h"
-#include "forward.h"
+#include "shared-forward.h"
bool pkcs11_uri_valid(const char *uri);
#pragma once
#include "errno-util.h"
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int polkit_agent_open(void);
void polkit_agent_close(void);
#pragma once
#include "constants.h"
-#include "forward.h"
+#include "shared-forward.h"
#define PORTABLE_PROFILE_DIRS CONF_PATHS_NULSTR("systemd/portable/profile")
#include "ansi-color.h"
#include "fileio.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "glyph-util.h"
#define CYLON_BUFFER_EXTRA (2*STRLEN(ANSI_RED) + STRLEN(ANSI_HIGHLIGHT_RED) + 2*STRLEN(ANSI_NORMAL))
#include <stdbool.h>
-#include "forward.h"
+#include "shared-forward.h"
typedef enum PromptFlags {
PROMPT_MAY_SKIP = 1 << 0, /* Question may be skipped */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct PTYForward PTYForward;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int print_qrcode_full(
FILE *out,
#include <linux/quota.h> /* IWYU pragma: export */
#include <sys/quota.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-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
#include <linux/reboot.h> /* IWYU pragma: export */
#include <sys/reboot.h> /* IWYU pragma: export */
-#include "forward.h"
+#include "shared-forward.h"
/* glibc defines the reboot() API call, which is a wrapper around the system call of the same name, but
* without the extra "arg" parameter. Since we need that parameter for some calls, let's add a "raw" wrapper
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* 256 bit keys = 32 bytes */
#define RECOVERY_KEY_MODHEX_RAW_LENGTH 32
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "stat-util.h"
int resize_fs(int fd, uint64_t sz, uint64_t *ret_size);
#pragma once
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-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)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum RemoveFlags {
REMOVE_ONLY_DIRECTORIES = 1 << 0, /* Only remove empty directories, no files */
#pragma once
#include "errno-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_SECCOMP
#include <seccomp.h> /* IWYU pragma: export */
#include <linux/securebits.h>
-#include "forward.h"
+#include "shared-forward.h"
int secure_bits_to_string_alloc(int i, char **s);
int secure_bits_from_string(const char *s);
#include <sys/socket.h>
-#include "forward.h"
+#include "shared-forward.h"
#if HAVE_SELINUX
#include <selinux/avc.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int service_parse_argv(
const char *service,
--- /dev/null
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+#pragma once
+
+/* IWYU pragma: always_keep */
+
+#include "sd-forward.h" /* IWYU pragma: export */
+
+typedef int (*copy_progress_bytes_t)(uint64_t n_bytes, uint64_t bytes_per_second, void *userdata);
+typedef int (*copy_progress_path_t)(const char *path, const struct stat *st, void *userdata);
+
+struct local_address;
+struct in_addr_prefix;
+struct in_addr_full;
+
+typedef enum AskPasswordFlags AskPasswordFlags;
+typedef enum BootEntryTokenType BootEntryTokenType;
+typedef enum BusPrintPropertyFlags BusPrintPropertyFlags;
+typedef enum BusTransport BusTransport;
+typedef enum CatFlags CatFlags;
+typedef enum CertificateSourceType CertificateSourceType;
+typedef enum DnsCacheMode DnsCacheMode;
+typedef enum DnsOverTlsMode DnsOverTlsMode;
+typedef enum DnssecMode DnssecMode;
+typedef enum Fido2EnrollFlags Fido2EnrollFlags;
+typedef enum KeySourceType KeySourceType;
+typedef enum LabelFixFlags LabelFixFlags;
+typedef enum MountInNamespaceFlags MountInNamespaceFlags;
+typedef enum NamePolicy NamePolicy;
+typedef enum OutputFlags OutputFlags;
+typedef enum OutputMode OutputMode;
+typedef enum PagerFlags PagerFlags;
+typedef enum PatternCompileCase PatternCompileCase;
+typedef enum RemoveFlags RemoveFlags;
+typedef enum ResolveSupport ResolveSupport;
+typedef enum TPM2Flags TPM2Flags;
+typedef enum Tpm2Support Tpm2Support;
+typedef enum Tpm2UserspaceEventType Tpm2UserspaceEventType;
+typedef enum UnitFileFlags UnitFileFlags;
+typedef enum UnitFilePresetMode UnitFilePresetMode;
+typedef enum UnitFileState UnitFileState;
+typedef enum UserDBFlags UserDBFlags;
+typedef enum UserRecordLoadFlags UserRecordLoadFlags;
+typedef enum UserStorage UserStorage;
+
+typedef struct Bitmap Bitmap;
+typedef struct BPFProgram BPFProgram;
+typedef struct BusObjectImplementation BusObjectImplementation;
+typedef struct CalendarSpec CalendarSpec;
+typedef struct Condition Condition;
+typedef struct ConfigSection ConfigSection;
+typedef struct ConfigTableItem ConfigTableItem;
+typedef struct CPUSet CPUSet;
+typedef struct FDSet FDSet;
+typedef struct Fido2HmacSalt Fido2HmacSalt;
+typedef struct GroupRecord GroupRecord;
+typedef struct Image Image;
+typedef struct ImagePolicy ImagePolicy;
+typedef struct InstallInfo InstallInfo;
+typedef struct LookupPaths LookupPaths;
+typedef struct LoopDevice LoopDevice;
+typedef struct MachineBindUserContext MachineBindUserContext;
+typedef struct MachineCredentialContext MachineCredentialContext;
+typedef struct MountOptions MountOptions;
+typedef struct OpenFile OpenFile;
+typedef struct Pkcs11EncryptedKey Pkcs11EncryptedKey;
+typedef struct Table Table;
+typedef struct Tpm2Context Tpm2Context;
+typedef struct Tpm2Handle Tpm2Handle;
+typedef struct Tpm2PCRValue Tpm2PCRValue;
+typedef struct UnitInfo UnitInfo;
+typedef struct UserRecord UserRecord;
+typedef struct VeritySettings VeritySettings;
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int path_patch_uid(const char *path, uid_t shift, uid_t range);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum SleepOperation {
SLEEP_SUSPEND,
Author: Auke Kok <auke-jan.h.kok@intel.com>
***/
-#include "forward.h"
+#include "shared-forward.h"
typedef enum SmackAttr {
SMACK_ATTR_ACCESS,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "in-addr-util.h"
int make_socket_fd(int log_level, const char* address, int type, int flags);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef int (*SpecifierCallback)(char specifier, const void *data, const char *root, const void *userdata, char **ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 "forward.h"
+#include "shared-forward.h"
#include "string-util.h"
#define _test_table(type, name, lookup, reverse, size, sparse) \
#include "errno-list.h"
#include "errno-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "log.h"
#include "static-destruct.h"
#include "signal-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 "forward.h"
+#include "shared-forward.h"
bool mac_tomoyo_use(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "tpm2-util.h"
/* Definitions as per "TCG PC Client Specific Platform Firmware Profile Specification"
#pragma once
#include "bitfield.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "openssl-util.h"
typedef enum TPM2Flags {
#pragma once
#include "conf-parser.h"
-#include "forward.h"
+#include "shared-forward.h"
int udev_parse_config_full(const ConfigTableItem config_table[]);
int udev_parse_config(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "unit-def.h"
typedef enum UnitFileState {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
/* Synthesize UserRecord and GroupRecord objects from NSS data */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
const char* user_record_state_color(const char *state);
#include "bitfield.h"
#include "rlimit-util.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum UserDisposition {
USER_INTRINSIC, /* root and nobody */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "group-record.h"
#include "user-record.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if ENABLE_UTMP
#include <utmpx.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct X11Context {
char *layout;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#define VERB_ANY (UINT_MAX)
#pragma once
#include "conf-parser-forward.h"
-#include "forward.h"
+#include "shared-forward.h"
#define VLANID_MAX 4094
#define VLANID_INVALID UINT16_MAX
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum VolatileMode {
VOLATILE_NO,
#include <sys/stat.h>
#include "architecture.h"
-#include "forward.h"
+#include "shared-forward.h"
typedef enum PickFlags {
PICK_ARCHITECTURE = 1 << 0, /* Look for an architecture suffix */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if ENABLE_UTMP || ENABLE_LOGIND
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
bool http_url_is_valid(const char *url) _pure_;
bool file_url_is_valid(const char *url) _pure_;
#include <linux/nl80211.h>
-#include "forward.h"
+#include "shared-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 */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
enum {
XML_END,
Copyright © 2010 ProFUSION embedded systems
***/
-#include "forward.h"
+#include "shared-forward.h"
int dm_detach_all(bool *changed, bool last_try);
Copyright © 2010 ProFUSION embedded systems
***/
-#include "forward.h"
+#include "shared-forward.h"
int loopback_detach_all(bool *changed, bool last_try);
Copyright © 2010 ProFUSION embedded systems
***/
-#include "forward.h"
+#include "shared-forward.h"
int md_detach_all(bool *changed, bool last_try);
Copyright © 2010 ProFUSION embedded systems
***/
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
int swapoff_all(bool *changed);
Copyright © 2010 ProFUSION embedded systems
***/
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
int umount_all(bool *changed, bool last_try);
#pragma once
#include "bus-map-properties.h"
-#include "forward.h"
+#include "shared-forward.h"
int verb_list_machines(int argc, char *argv[], void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
enum action {
ACTION_SYSTEMCTL,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef struct Context Context;
typedef struct PartitionInfo PartitionInfo;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum UpdateSetFlags {
UPDATE_NEWEST = 1 << 0,
#include <nss.h>
-#include "forward.h"
+#include "shared-forward.h"
const char* nss_status_to_string(enum nss_status status, char *buf, size_t buf_len);
void* nss_open_handle(const char *dir, const char *module, int flags);
#include <dlfcn.h>
#include <stdlib.h>
-#include "forward.h"
+#include "shared-forward.h"
int main(int argc, char **argv) {
void *handles[argc - 1];
#define __STDC_WANT_IEC_60559_TYPES_EXT__
#include <float.h>
-#include "forward.h"
+#include "shared-forward.h"
/* Print information about various types. Useful when diagnosing
* gcc diagnostics on an unfamiliar architecture. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int hwclock_get(struct tm *tm);
int hwclock_set(const struct tm *tm);
#pragma once
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef enum ServerType ServerType;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int name_to_uid_offline(const char *root, const char *user, uid_t *ret_uid, Hashmap **cache);
int name_to_gid_offline(const char *root, const char *group, gid_t *ret_gid, Hashmap **cache);
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int is_fido_security_token_desc(const uint8_t *desc, size_t desc_len);
#include <mtd/mtd-user.h>
-#include "forward.h"
+#include "shared-forward.h"
/* Full oob structure as written on the flash */
struct sm_oob {
#include "cpu-set-util.h"
#include "ether-addr-util.h"
#include "ethtool-util.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
#include "net-condition.h"
/* SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "udev-event.h"
typedef struct UdevBuiltin {
/* SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int device_add_errno(sd_device *dev, int error);
int device_add_exit_status(sd_device *dev, int status);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h" /* IWYU pragma: export */
+#include "shared-forward.h" /* IWYU pragma: export */
typedef struct UdevCtrl UdevCtrl;
typedef struct UdevEvent UdevEvent;
#include "sd-event.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "list.h"
#include "udev-config.h"
#include "udev-forward.h"
/* SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int udev_node_apply_permissions(
sd_device *dev,
#include "device-private.h"
#include "device-util.h"
#include "errno-util.h"
-#include "forward.h"
+#include "shared-forward.h"
/* Each trace point can have different number of additional arguments. Note that when the macro is used only
* additional arguments are listed in the macro invocation!
#include "sd-device.h"
-#include "forward.h"
+#include "shared-forward.h"
#include "udev-def.h"
int find_device(const char *id, const char *prefix, sd_device **ret);
/* SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
int cat_main(int argc, char *argv[], void *userdata);
int info_main(int argc, char *argv[], void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#include "ratelimit.h"
#define USERDB_WORKERS_MIN 3
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct RuntimeMount {
bool read_only;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "forward.h"
+#include "shared-forward.h"
int register_machine(
sd_bus *bus,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct SocketServicePair {
char **exec_start_pre;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef enum ConsoleMode {
CONSOLE_INTERACTIVE, /* ptyfwd */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
#if defined(__x86_64__) || defined(__i386__) || defined(__arm__) || defined(__aarch64__)
# define ARCHITECTURE_SUPPORTS_SMBIOS 1
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "forward.h"
+#include "shared-forward.h"
typedef struct XdgAutostartService {
char *name;
projects / thirdparty / systemd.git / commitdiff
