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/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.
+ - `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.
Bad:
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`
+ - `src/basic/forward.h`
+ - `src/libsystemd/forward.h`
+ - `src/shared/forward.h`
Header files that extend other header files can include the original header
file. For example, `iovec-util.h` includes `sys/uio.h`. To identify headers
```c
// source.h
- #include "basic-forward.h"
+ #include "forward.h"
void my_function_that_logs(size_t sz);
]
libsystemd_includes = [include_directories(
+ 'src/libsystemd',
'src/libsystemd/sd-bus',
- 'src/libsystemd/sd-common',
'src/libsystemd/sd-device',
'src/libsystemd/sd-event',
'src/libsystemd/sd-future',
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_architectures(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_blame(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_calendar(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_capabilities(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_cat_config(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_chid(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_compare_versions(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_condition(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_critical_chain(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_dlopen_metadata(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_dot(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_dump(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_exit_status(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_fdstore(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_filesystems(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_has_tpm2(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_identify_tpm2(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_image_policy(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_elf_inspection(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_log_control(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_malloc(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_nvpcrs(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_pcrs(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_plot(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum AnalyzeSecurityFlags {
ANALYZE_SECURITY_SHORT = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_service_watchdogs(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_smbios11(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_srk(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_syscall_filters(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "unit-def.h"
typedef struct BootTimes {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_time(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_timespan(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_timestamp(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_unit_files(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_unit_gdb(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_unit_paths(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_unit_shell(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct ExecCommand ExecCommand;
typedef struct Unit Unit;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_verify(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum RecursiveErrors RecursiveErrors;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
const char* af_to_name(int id) _const_;
int af_from_name(const char *name) _pure_;
#include <stdlib.h>
-#include "basic-forward.h"
+#include "forward.h"
#include "memory-util.h" /* IWYU pragma: keep */
#if HAS_FEATURE_MEMORY_SANITIZER
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
/* Limits the use of ANSI colors to a subset. */
typedef enum ColorMode {
#include <endian.h>
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
extern int saved_argc;
extern char **saved_argv;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#define AUDIT_SESSION_INVALID UINT32_MAX
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef enum BtrfsSubvolFlags {
BTRFS_SUBVOL_RO = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
extern const char* const systemd_features;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "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 <linux/capability.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
int capsule_name_is_valid(const char *name);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#define SYSTEMD_CGROUP_CONTROLLER "_systemd"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#include "dlopen-note.h"
typedef enum Compression {
#include <sys/stat.h>
-#include "basic-forward.h"
+#include "forward.h"
typedef enum ConfFilesFlags {
CONF_FILES_EXECUTABLE = 1 << 0, /* inode must be marked executable */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "../fundamental/confidential-virt.h" /* IWYU pragma: export */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
int encode_devnode_name(const char *str, char *str_enc, size_t len);
int allow_listed_char_for_devnode(char c, const char *additional);
#include <sys/sysmacros.h>
-#include "basic-forward.h"
+#include "forward.h"
int parse_devnum(const char *s, dev_t *ret);
#include <dirent.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "forward.h"
#include "path-util.h" /* IWYU pragma: keep */
bool dirent_is_file(const struct dirent *de) _pure_;
#include <dlfcn.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "forward.h"
void* safe_dlclose(void *dl);
#include "sd-dlopen.h"
-#include "basic-forward.h"
+#include "forward.h"
#include "strv.h"
/* Prevent dlopen helper functions (e.g., dlopen_libfoo()) from being inlined or cloned by the compiler/LTO.
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#include "sd-id128.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#define ENVIRONMENT_ASSIGNMENTS_MAX 16384U
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
const char* errno_name_no_fallback(int id) _const_;
int errno_from_name(const char *name) _pure_;
#include <string.h>
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
struct hw_addr_data {
size_t length;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef enum ExtractFlags {
EXTRACT_RELAX = 1 << 0, /* Allow unbalanced quote and eat up trailing backslash. */
#include <fcntl.h>
#include <stdio.h>
-#include "basic-forward.h"
+#include "forward.h"
/* maximum length of fdname */
#define FDNAME_MAX 255
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef struct sd_future sd_future;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#define LONG_LINE_MAX (1U*1024U*1024U)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "stat-util.h"
#define FILESYSTEM_MAGIC_MAX 10
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "cgroup-util.h"
#include "stdio-util.h" /* IWYU pragma: keep */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "lock-util.h"
/* The following macros add 1 when converting things, since 0 is a valid mode, while the pointer
#include <glob.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "forward.h"
typedef DIR* (*opendir_t)(const char *);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef enum Glyph {
GLYPH_SPACE,
*/
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
char *utf8_prev_char (const char *p);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#include "hash-funcs.h"
#include "iterator.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
char octchar(int x) _const_;
int unoctchar(char c) _const_;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#include "strv.h"
/* HOST_NAME_MAX should be 64 on linux, but musl uses the one by POSIX (255). */
#include <netinet/in.h>
-#include "basic-forward.h"
+#include "forward.h"
union in_addr_union {
struct in_addr in;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
bool in_initrd(void);
void in_initrd_force(bool value);
#include <sys/inotify.h> /* IWYU pragma: export */
#include <syslog.h>
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
/* On most architectures POLL* and EPOLL* share numeric values, but sparc allocates POLLRDHUP at
* 0x800 while EPOLLRDHUP is 0x2000 everywhere. Always go through these helpers when crossing
#include <sys/uio.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "forward.h"
#include "../fundamental/iovec-util.h" /* IWYU pragma: export */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
struct iovec_wrapper {
struct iovec *iovec;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
/* The head of the linked list. Use this in the structure that shall
* contain the head of the linked list */
#include <libintl.h> /* IWYU pragma: export */
#include <locale.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
typedef struct LockFile {
int dir_fd;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "list.h"
/*
#include <string.h>
#include <syslog.h>
-#include "basic-forward.h"
+#include "forward.h"
typedef enum LogTarget{
LOG_TARGET_CONSOLE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
int memfd_create_wrapper(const char *name, unsigned mode);
#include <string.h>
-#include "basic-forward.h"
+#include "forward.h"
#include "../fundamental/memory-util.h" /* IWYU pragma: export */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
struct pool;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef struct MemStream {
FILE *f;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef enum MkdirFlags {
MKDIR_FOLLOW_SYMLINK = 1 << 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
typedef enum NamespaceType {
NAMESPACE_CGROUP,
#include <string.h>
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#include "hashmap.h"
typedef struct OrderedSet OrderedSet;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef enum ImageClass {
IMAGE_MACHINE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef unsigned long loadavg_t;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
/*
* For details about the file format see RFC:
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
int parse_percent_unbounded(const char *p);
int parse_percent(const char *p);
#include <sys/pidfd.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "forward.h"
int pidfd_get_namespace(int fd, unsigned long ns_type_cmd);
#include <signal.h>
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
typedef struct Prioq Prioq;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef enum ProcCmdlineFlags {
PROC_CMDLINE_RD_STRICT = 1 << 0, /* Only look at options with the "rd." prefix when in the initrd and only
#include "fileio.h"
#include "format-util.h"
-#include "basic-forward.h"
+#include "forward.h"
#include "string-util.h"
#define procfs_file_alloca(pid, field) \
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#include "parse-util.h"
typedef enum PressureType {
#include <pthread.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
/* Returns random bytes suitable for most uses, but may be insecure sometimes. */
void random_bytes(void *p, size_t n) _nonnull_if_nonzero_(1, 2);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
pid_t raw_clone(unsigned long flags);
#include <dirent.h>
-#include "basic-forward.h"
+#include "forward.h"
typedef enum RecurseDirFlags {
/* Interpreted by readdir_all() */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#define _RLIMIT_MAX RLIMIT_NLIMITS
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef enum RuntimeScope {
RUNTIME_SCOPE_SYSTEM, /* for the system */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "hashmap.h"
#define set_free_and_replace(a, b) \
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "../fundamental/sha256.h" /* IWYU pragma: export */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
void sigbus_install(void);
void sigbus_reset(void);
#include <signal.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "forward.h"
int reset_all_signal_handlers(void);
int reset_signal_mask(void);
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
struct siphash {
uint64_t v0;
#include <sys/socket.h>
#include <sys/un.h>
-#include "basic-forward.h"
+#include "forward.h"
#include "memory-util.h"
#include "missing-network.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#ifdef __CHECKER__
#define __sd_bitwise __attribute__((__bitwise__))
#include <sys/stat.h> /* IWYU pragma: export */
#include <sys/statfs.h> /* IWYU pragma: export */
-#include "basic-forward.h"
+#include "forward.h"
int stat_verify_regular(const struct stat *st);
int statx_verify_regular(const struct statx *stx);
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef void (*free_func_t)(void *p);
#include <printf.h>
#include <stdio.h>
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
struct strbuf {
char *buf;
#include <stdio.h>
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#include "../fundamental/string-util.h" /* IWYU pragma: export */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "../fundamental/strv.h" /* IWYU pragma: export */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
int fsync_directory_of_file(int fd);
int fsync_full(int fd);
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
#include "stdio-util.h"
char* sysctl_normalize(char *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
DECLARE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int);
bool log_facility_unshifted_is_valid(int faciliy);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
/* Erase characters until the end of the line */
#define ANSI_ERASE_TO_END_OF_LINE "\x1B[K"
#include <limits.h>
#include <time.h>
-#include "basic-forward.h"
+#include "forward.h"
#define PRI_NSEC PRIu64
#define PRI_USEC PRIu64
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
typedef struct UIDRangeEntry {
uid_t start, nr;
#include <sys/stat.h>
-#include "basic-forward.h"
+#include "forward.h"
static inline void umaskp(mode_t *u) {
umask(*u);
#include <endian.h>
-#include "basic-forward.h"
+#include "forward.h"
#include "../fundamental/unaligned.h" /* IWYU pragma: export */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
#define UNIT_NAME_MAX 256
#include <pwd.h>
#include <shadow.h>
-#include "basic-forward.h"
+#include "forward.h"
#include "errno-util.h"
/* Users managed by systemd-homed. See https://systemd.io/UIDS-GIDS for details
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 "basic-forward.h"
+#include "forward.h"
typedef enum Virtualization {
VIRTUALIZATION_NONE = 0,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "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 */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_cleanup(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_install(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_remove(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_link(int argc, char *argv[], uintptr_t data, void *userdata);
int verb_link_auto(int argc, char *argv[], uintptr_t data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int install_random_seed(const char *esp, int esp_fd);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_reboot_to_firmware(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_set_efivar(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_status(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_list(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_kernel_identify(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_kernel_inspect(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_unlink(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum InstallSource {
INSTALL_SOURCE_IMAGE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct XMLIntrospectOps {
int (*on_path)(const char *path, void *userdata);
#include "core-forward.h"
#include "macro.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum RestrictFileSystemAccess {
RESTRICT_FILESYSTEM_ACCESS_NO,
/* IWYU pragma: always_keep */
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "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 "shared-forward.h"
+#include "forward.h"
int unit_exec_context_build_json(sd_json_variant **ret, const char *name, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef struct CoredumpConfig CoredumpConfig;
typedef struct CoredumpContext CoredumpContext;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int coredump_vacuum(int exclude_fd, uint64_t keep_free, uint64_t max_use);
#pragma once
#include "cryptenroll.h"
-#include "shared-forward.h"
+#include "forward.h"
int load_volume_key_fido2(const EnrollContext *c, struct crypt_device *cd, struct iovec *ret_vk);
int enroll_fido2(const EnrollContext *c, struct crypt_device *cd, const struct iovec *volume_key);
#pragma once
#include "cryptenroll.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef struct EnrolledSlot {
int slot;
#pragma once
#include "cryptenroll.h"
-#include "shared-forward.h"
+#include "forward.h"
int load_volume_key_empty(const EnrollContext *c, struct crypt_device *cd, struct iovec *ret_vk);
int load_volume_key_keyfile(const EnrollContext *c, struct crypt_device *cd, struct iovec *ret_vk);
#pragma once
#include "cryptenroll.h"
-#include "shared-forward.h"
+#include "forward.h"
int enroll_pkcs11(const EnrollContext *c, struct crypt_device *cd, const struct iovec *volume_key);
#pragma once
#include "cryptenroll.h"
-#include "shared-forward.h"
+#include "forward.h"
/* When c->interactive is unset, the generated recovery key is returned via ret_recovery_key
* instead of being printed to stdout/stderr + rendered as a QR code. */
#pragma once
#include "cryptenroll.h"
-#include "shared-forward.h"
+#include "forward.h"
int load_volume_key_tpm2(const EnrollContext *c, struct crypt_device *cd, struct iovec *ret_vk);
int enroll_tpm2(const EnrollContext *c, struct crypt_device *cd, const struct iovec *volume_key, int *ret_slot_to_wipe);
#pragma once
#include "cryptenroll.h"
-#include "shared-forward.h"
+#include "forward.h"
/* Wipes the slots selected by c->wipe_slots / c->n_wipe_slots / c->wipe_slots_scope /
* c->wipe_slots_mask, except for c->wipe_except_slot (set to -1 for none). If ret_wiped_slots/
#pragma once
#include "crypto-util.h"
+#include "forward.h"
#include "libfido2-util.h"
-#include "shared-forward.h"
typedef enum EnrollType {
ENROLL_PASSWORD,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "pkcs11-padding.h"
-#include "shared-forward.h"
int decrypt_pkcs11_key(
const char *volume_name,
#pragma once
#include "cryptsetup-util.h"
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
/* for more information see libcryptsetup.h crypt-tokens section */
#pragma once
+#include "forward.h"
#include "pkcs11-util.h"
-#include "shared-forward.h"
int acquire_luks2_key(
struct crypt_device *cd,
#include <stdio.h>
-#include "shared-forward.h"
+#include "forward.h"
#include "fileio.h"
#include "log.h"
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef struct KernelHibernateLocation KernelHibernateLocation;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int identity_add_recovery_key(sd_json_variant **v);
/* IWYU pragma: always_keep */
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef struct Manager Manager;
typedef struct Home Home;
/* IWYU pragma: always_keep */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef enum HomeSetupFlags HomeSetupFlags;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int user_record_check_password_quality(UserRecord *hr, UserRecord *secret, sd_bus_error *error);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "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
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "imds-util.h"
-#include "shared-forward.h"
/* Helpers shared between imds-tool.c and imds-tool-metrics.c for talking to systemd-imdsd. */
#pragma once
#include "compress.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef struct RawExport RawExport;
#include "compress.h"
#include "import-common.h"
-#include "shared-forward.h"
typedef struct TarExport TarExport;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum ImportFlags {
/* Public Flags (i.e. accessible via D-Bus, must stay stable! */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "import-common.h"
typedef struct RawImport RawImport;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "import-common.h"
typedef struct TarImport TarImport;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
bool oci_image_is_valid(const char *n);
int oci_registry_is_valid(const char *n);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum PullJobState PullJobState;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum {
INTEGRITY_ALGORITHM_CRC32,
#include "compress.h"
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef struct CompressionConfig {
Compression algorithm;
#pragma once
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
bool header_value_is_valid(const char *value);
#pragma once
#include "compress.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "journal-importer.h"
#include "journal-remote-write.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "journal-remote-parse.h"
#include "journal-remote-write.h"
#pragma once
#include "curl-util.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "journal-compression-util.h"
typedef enum {
#include <stdio.h> /* IWYU pragma: keep */
-#include "sd-forward.h"
+#include "forward.h"
#include "alloc-util.h" /* IWYU pragma: keep */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int journal_add_unit_matches(
sd_journal *j,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#define METRIC_IO_SYSTEMD_JOURNAL_PREFIX "io.systemd.Journal."
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int action_print_header(void);
int action_verify(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
#include "pcre2-util.h"
typedef enum JournalctlAction {
/* IWYU pragma: always_keep */
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef enum Storage Storage;
typedef enum SplitMode SplitMode;
Copyright © 2014 Axis Communications AB. All rights reserved.
***/
-#include "sd-forward.h"
+#include "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);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
#include "sparse-endian.h"
struct in_pktinfo;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
#include "network-common.h"
#include "sparse-endian.h"
#include "dhcp6-option.h"
#include "dhcp6-protocol.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "time-util.h"
struct sd_dhcp6_lease {
#include "sd-dhcp6-option.h" /* IWYU pragma: export */
-#include "sd-forward.h"
+#include "forward.h"
#include "list.h"
#include "sparse-endian.h"
Copyright © 2014 Intel Corporation. All rights reserved.
***/
-#include "sd-forward.h"
+#include "forward.h"
#include "sparse-endian.h"
struct DHCP6Message {
#include "sd-dns-resolver.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "socket-netlink.h"
/* Represents a "designated resolver" */
#include <netinet/in.h>
-#include "sd-forward.h"
+#include "forward.h"
#include "time-util.h"
typedef struct ICMP6Packet {
#include <netinet/in.h>
-#include "sd-forward.h"
+#include "forward.h"
#define IN6_ADDR_ALL_ROUTERS_MULTICAST \
((const struct in6_addr) { { { \
#include <netinet/ip.h>
#include <netinet/udp.h>
-#include "sd-forward.h"
+#include "forward.h"
#include "sparse-endian.h"
#include "sd-lldp-rx.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "memory-util.h"
#include "time-util.h"
#include "sd-lldp-rx.h" /* IWYU pragma: export */
#include "network-common.h"
-#include "sd-forward.h"
+#include "forward.h"
struct sd_lldp_rx {
unsigned n_ref;
#include "sd-event.h"
#include "sd-ndisc.h" /* IWYU pragma: export */
-#include "sd-forward.h"
+#include "forward.h"
#include "network-common.h"
#include "time-util.h"
#include <linux/in6.h>
-#include "sd-forward.h"
+#include "forward.h"
typedef struct sd_ndisc_neighbor {
unsigned n_ref;
#include <netinet/ip6.h>
#include "sd-dns-resolver.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "time-util.h"
#include <linux/in6.h>
-#include "sd-forward.h"
+#include "forward.h"
typedef struct sd_ndisc_redirect {
unsigned n_ref;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
typedef struct sd_ndisc_router_solicit {
unsigned n_ref;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
size_t serialize_in_addrs(FILE *f,
const struct in_addr *addresses,
#include <netinet/in.h>
-#include "sd-forward.h"
+#include "forward.h"
#include "network-common.h"
#include "time-util.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
#define TLV_TAG_PAD UINT32_C(0)
#define TLV_TAG_END UINT32_C(0xFF)
/* IWYU pragma: always_keep */
-#include "basic-forward.h" /* IWYU pragma: export */
+#include "../basic/forward.h" /* IWYU pragma: export */
typedef void (*_sd_destroy_t)(void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
int container_get_leader(RuntimeScope scope, const char *machine, pid_t *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
typedef struct sd_bus_creds {
bool allocated;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
int bus_creds_dump(sd_bus_creds *c, FILE *f, bool terse);
#include "sd-bus-protocol.h"
#include "errno-util.h"
-#include "sd-forward.h"
+#include "forward.h"
bool bus_error_is_dirty(sd_bus_error *e);
/* IWYU pragma: always_keep */
-#include "sd-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef enum BusAuth BusAuth;
typedef enum BusSlotType BusSlotType;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
int bus_call_future(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_future **ret);
int future_get_bus_reply(sd_future *f, sd_bus_error *reterr_error, sd_bus_message **ret_reply);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
#define MEMFD_CACHE_MAX 32
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
void bus_socket_setup(sd_bus *b);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
bool bus_type_is_valid(char c) _const_;
bool bus_type_is_basic(char c) _const_;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
#include "iterator.h"
#define OLDEST_UDEV_DATABASE_VERSION 1
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
typedef enum MonitorNetlinkGroup {
MONITOR_GROUP_NONE,
#include "sd-device.h" /* IWYU pragma: export */
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
#include "log.h"
#define device_unref_and_replace_new_ref(a, b) \
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
int future_new_io(sd_event *e, int fd, uint32_t events, sd_future **ret);
int future_new_time(sd_event *e, clockid_t clock, uint64_t usec, uint64_t accuracy, int result, sd_future **ret);
#include "sd-event.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "inotify-util.h"
#include "list.h"
#include "ratelimit.h"
#include "sd-event.h"
-#include "sd-forward.h"
+#include "forward.h"
#define PROTECT_EVENT(e) \
_unused_ _cleanup_(sd_event_unrefp) sd_event *_ref = sd_event_ref(e);
#include <sys/stat.h>
-#include "sd-forward.h"
+#include "forward.h"
#include "iterator.h"
#include "sparse-endian.h"
#include "sd-id128.h"
#include "errno-util.h"
-#include "sd-forward.h"
+#include "forward.h"
bool id128_is_valid(const char *s) _pure_;
#include "sd-id128.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "sparse-endian.h"
#define CATALOG_SIGNATURE { 'R', 'H', 'H', 'H', 'K', 'S', 'L', 'P' }
#pragma once
#include "journal-def.h"
-#include "sd-forward.h"
+#include "forward.h"
typedef struct JournalAuthOps {
JournalAuthContext* (*free)(JournalAuthContext *c);
#include "sd-id128.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "sparse-endian.h"
/* Make sure not to make this smaller than the maximum coredump size.
#include <sys/stat.h>
#include "compress.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "journal-def.h"
#include "mmap-cache.h"
#include "ratelimit.h"
#include "journal-file.h"
#include "list.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "time-util.h"
#define JOURNAL_FILES_MAX 7168u
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
#include "journal-def.h"
typedef struct MMapCache MMapCache;
#pragma once
-#include "sd-forward.h"
+#include "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 <sys/socket.h>
-#include "sd-forward.h"
+#include "forward.h"
#include "list.h"
#include "log.h"
#include "sd-json.h"
#include "log.h"
-#include "sd-forward.h"
+#include "forward.h"
#include "string-util.h" /* IWYU pragma: keep */
#define JSON_VARIANT_REPLACE(v, q) \
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
#define CTRL_GENL_NAME "nlctrl"
#include <linux/netlink.h>
#include <sys/socket.h>
-#include "sd-forward.h"
+#include "forward.h"
#include "list.h"
#include "netlink-types.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
#include "netlink-internal.h"
int netlink_slot_allocate(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
typedef enum NLAType {
NETLINK_TYPE_UNSPEC, /* NLA_UNSPEC */
#include <linux/rtnetlink.h>
-#include "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "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 "sd-forward.h"
+#include "forward.h"
#include "runtime-scope.h"
typedef enum LookupPathsFlags {
#include "sd-varlink.h"
#include "sd-varlink-idl.h"
-#include "sd-forward.h"
+#include "forward.h"
bool varlink_idl_field_name_is_valid(const char *name);
bool varlink_idl_symbol_name_is_valid(const char *name);
#include "json-stream.h"
#include "list.h"
#include "pidref.h"
-#include "sd-forward.h"
+#include "forward.h"
typedef enum VarlinkState {
/* Client side states */
#include "sd-varlink.h"
-#include "sd-forward.h"
+#include "forward.h"
int varlink_get_peer_pidref(sd_varlink *v, PidRef *ret);
#include "libudev.h"
-#include "shared-forward.h"
+#include "forward.h"
struct udev_device;
#include "libudev.h"
-#include "shared-forward.h"
+#include "forward.h"
struct udev_list;
#include "libudev.h"
-#include "shared-forward.h"
#include "device-nodes.h"
/**
#include "libudev.h"
-#include "shared-forward.h"
+#include "forward.h"
/* Cleanup functions */
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev*, udev_unref);
#include <sys/stat.h>
#include <syslog.h>
-#include "shared-forward.h"
+#include "forward.h"
#include "locale-setup.h"
#include "vconsole-util.h"
#pragma once
#include "dlfcn-util.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_XKBCOMMON
#ifndef SYSTEMD_CFLAGS_MARKER_LIBXKBCOMMON
/* IWYU pragma: always_keep */
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef enum InhibitWhat InhibitWhat;
typedef enum KillWhom KillWhom;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "output-mode.h"
int show_sysfs(const char *seat, const char *prefix, unsigned columns, OutputFlags flags);
/* IWYU pragma: always_keep */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef struct Machine Machine;
typedef struct Manager Manager;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "ratelimit.h"
#define MOUNTFS_WORKERS_MIN 3
#pragma once
#include "netdev.h"
-#include "shared-forward.h"
typedef enum BareUDPProtocol {
BARE_UDP_PROTOCOL_IPV4 = ETH_P_IP,
#include <linux/batman_adv.h>
-#include "shared-forward.h"
#include "netdev.h"
#define BATADV_GENL_NAME "batadv"
#pragma once
#include "bond-util.h"
-#include "shared-forward.h"
#include "netdev.h"
typedef struct Bond {
#pragma once
#include "netdev.h"
-#include "shared-forward.h"
#define LINK_BRIDGE_PORT_PRIORITY_INVALID 128U
#define LINK_BRIDGE_PORT_PRIORITY_MAX 63U
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "netdev.h"
typedef struct Dummy {
#include "in-addr-util.h"
#include "netdev.h"
-#include "shared-forward.h"
typedef enum FooOverUDPEncapType {
NETDEV_FOO_OVER_UDP_ENCAP_UNSPEC = FOU_ENCAP_UNSPEC,
#include "in-addr-util.h"
#include "netdev.h"
-#include "shared-forward.h"
#define GENEVE_VID_MAX (1u << 24) - 1
#include <linux/l2tp.h>
#include "in-addr-util.h"
-#include "shared-forward.h"
#include "netdev.h"
typedef enum L2tpL2specType {
#include <linux/if_macsec.h>
#include <net/ethernet.h>
-#include "shared-forward.h"
#include "netdev.h"
#include "sparse-endian.h"
#include "fou-tunnel.h"
#include "netdev.h"
#include "networkd-link.h"
-#include "shared-forward.h"
/* For IFLA_IPTUN_PROTO attribute */
typedef enum TunnelMode {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "netdev.h"
typedef struct TunTap {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "netdev.h"
typedef struct VLan {
#include "in-addr-util.h"
#include "list.h"
#include "netdev.h"
-#include "networkd-forward.h"
#include "socket-util.h"
typedef struct WireguardIPmask {
#include <linux/nl80211.h>
-#include "shared-forward.h"
#include "netdev.h"
typedef struct WLan {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "netdev.h"
typedef struct Xfrm {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_list_address_labels(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_edit(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_cat(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_dhcp_lease(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
-
#include "dhcp-message.h"
+#include "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);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct LinkInfo LinkInfo;
#include "dhcp-message.h"
#include "ether-addr-util.h"
#include "ethtool-util.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "in-addr-util.h"
typedef struct VxLanInfo {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_list_links(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int dump_lldp_neighbors(sd_varlink *vl, Table *table, int ifindex);
int verb_link_lldp_status(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_link_delete(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_link_varlink_simple_method(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_link_status(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int system_status(sd_netlink *rtnl, sd_hwdb *hwdb);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int varlink_connect_networkd(sd_varlink **ret_varlink);
int reload_networkd(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "pager.h"
extern PagerFlags arg_pager_flags;
#include "conf-parser-forward.h" /* IWYU pragma: export */
#include "dhcp-forward.h" /* IWYU pragma: export */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef enum NetDevLocalAddressType NetDevLocalAddressType;
typedef enum NetworkConfigSource NetworkConfigSource;
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
#include "tclass.h"
#include <linux/pkt_sched.h>
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct EnhancedTransmissionSelection {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct FirstInFirstOut {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct FairQueueingControlledDelay {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct FlowQueuePIE {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct FairQueueing {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct GenericRandomEarlyDetection {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct HeavyHitterFilter {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
#include "tclass.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
-#include "shared-forward.h"
#include "mq.h"
const QDiscVTable mq_vtable = {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct ClassfulMultiQueueing {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct BandMultiQueueing {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct NetworkEmulator {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct ProportionalIntegralControllerEnhanced {
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
#include "tclass.h"
* Copyright © 2020 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct StochasticFairBlue {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct StochasticFairnessQueueing {
* Copyright © 2019 VMware, Inc. */
#pragma once
-#include "shared-forward.h"
#include "qdisc.h"
typedef struct TokenBucketFilter {
#include <linux/pkt_sched.h>
-#include "shared-forward.h"
+#include "networkd-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 "shared-forward.h"
#include "qdisc.h"
typedef struct TrivialLinkEqualizer {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "network-util.h"
typedef struct DNSConfiguration DNSConfiguration;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "network-util.h"
typedef struct DNSConfiguration DNSConfiguration;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int bind_user_setup(const MachineBindUserContext *c, const char *root);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "nspawn-settings.h"
int create_subcgroup(
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "list.h"
typedef struct ExposePort {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "volatile-util.h"
typedef enum MountSettingsMask {
#include <linux/if.h>
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
#include "nspawn-settings.h"
int oci_load(FILE *f, const char *bundle, Settings **ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "nspawn-settings.h"
typedef enum AllocateScopeFlags {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int setup_seccomp(
uint64_t cap_list_retain,
#include "capability-util.h"
#include "conf-parser-forward.h"
#include "cpu-set-util.h"
+#include "forward.h"
#include "rlimit-util.h"
#include "seccomp-util.h"
-#include "shared-forward.h"
#include "volatile-util.h"
typedef struct CustomMount CustomMount;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int stub_pid1(sd_id128_t uuid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int userns_chown_at(int fd, const char *fname, uid_t uid, gid_t gid, int flags);
int userns_lchown(const char *p, uid_t uid, gid_t gid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "ratelimit.h"
#define NSRESOURCE_WORKERS_MIN 5
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
struct userns_restrict_bpf;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
struct userns_restrict_bpf;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int _nss_systemd_block(bool b);
bool _nss_systemd_is_blocked(void);
#include <nss.h>
#include <pwd.h>
-#include "shared-forward.h"
+#include "forward.h"
#include "userdb.h"
UserDBFlags nss_glue_userdb_flags(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
extern const BusObjectImplementation manager_object;
#include "conf-parser-forward.h"
#include "constants.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "oomd-conf.h"
#include "oomd-util.h"
#pragma once
#include "cgroup-util.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "psi-util.h"
#define DUMP_ON_KILL_COUNT 10u
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "runtime-scope.h"
-#include "shared-forward.h"
#include "string-util.h"
typedef struct PortableMetadata {
/* IWYU pragma: always_keep */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef struct Manager Manager;
typedef struct Operation Operation;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "sparse-endian.h"
/* ISO9660 is 5 blocks:
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
int vl_method_list_candidate_devices(
sd_varlink *link,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#define METRIC_IO_SYSTEMD_BASIC_PREFIX "io.systemd.Basic."
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#define METRIC_IO_SYSTEMD_CGROUP_PREFIX "io.systemd.CGroup."
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#define METRIC_IO_SYSTEMD_FILES_PREFIX "io.systemd.Files."
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "iovec-wrapper.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum ExecutionMode {
MODE_RESOLVE_HOST,
#pragma once
#include "crypto-util.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_OPENSSL
/* IWYU pragma: always_keep */
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef enum DnsAnswerFlags DnsAnswerFlags;
typedef enum DnsCacheMode DnsCacheMode;
#include <openssl/asn1.h>
-#include "shared-forward.h"
+#include "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"
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_ACL
#ifndef SYSTEMD_CFLAGS_MARKER_LIBACL
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int acpi_get_boot_usec(usec_t *ret_loader_start, usec_t *ret_loader_exit);
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_APPARMOR
# ifndef SYSTEMD_CFLAGS_MARKER_LIBAPPARMOR
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
typedef enum AskPasswordFlags {
ASK_PASSWORD_ACCEPT_CACHED = 1 << 0, /* read from kernel keyring */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* These functions implement various potentially slow operations that are executed asynchronously. They are
* carefully written to not use pthreads, but use fork() or clone() (without CLONE_VM) so that the child does
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* See source file for an API description. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int base_filesystem_create_fd(int fd, const char *root, uid_t uid, gid_t gid);
int base_filesystem_create(const char *root, uid_t uid, gid_t gid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int on_ac_power(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "iterator.h"
typedef struct Bitmap {
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_BLKID
# ifndef SYSTEMD_CFLAGS_MARKER_LIBBLKID
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum BlockDevListFlags {
BLOCKDEV_LIST_SHOW_SYMLINKS = 1 << 0, /* Pick up symlinks to block devices too */
#include <sys/sysmacros.h>
-#include "shared-forward.h"
+#include "forward.h"
#include "stdio-util.h"
#define SYS_BLOCK_PATH_MAX(suffix) \
#include <linux/if_bonding.h>
-#include "shared-forward.h"
+#include "forward.h"
/*
* Maximum number of targets supported by the kernel for a single
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum BootEntryTokenType {
BOOT_ENTRY_TOKEN_MACHINE_ID,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int boot_timestamps(const dual_timestamp *n, dual_timestamp *firmware, dual_timestamp *loader);
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "../fundamental/bootspec.h" /* IWYU pragma: export */
#include <bpf/libbpf.h>
-#include "shared-forward.h"
+#include "forward.h"
bool bpf_can_link_program(struct bpf_program *prog);
bool bpf_can_link_lsm_program(struct bpf_program *prog);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* This encapsulates three different concepts: the loaded BPF program, the BPF code, and the attachment to a
* cgroup. Typically our BPF programs go through all three stages: we build the code, we load it, and finally
#include <syslog.h>
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_LIBBPF
#ifndef SYSTEMD_CFLAGS_MARKER_LIBBPF
#include <linux/if_bridge.h>
-#include "shared-forward.h"
+#include "forward.h"
typedef enum BridgeState {
NETDEV_BRIDGE_STATE_DISABLED = BR_STATE_DISABLED,
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "../basic/btrfs-util.h" /* IWYU pragma: export */
#include "sd-bus.h" /* IWYU pragma: keep */
-#include "shared-forward.h"
+#include "forward.h"
int bus_property_get_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *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 "shared-forward.h"
+#include "forward.h"
typedef struct BusLocator {
const char *destination;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
extern const BusObjectImplementation log_control_object;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int bus_message_read_id128(sd_bus_message *m, sd_id128_t *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct BusObjectVtablePair {
const sd_bus_vtable *vtable;
#include "sd-json.h"
#include "sd-varlink.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum PolkitFlags {
POLKIT_ALLOW_INTERACTIVE = 1 << 0, /* Allow interactive auth (typically not required, because can be derived from bus message/link automatically) */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum BusPrintPropertyFlags {
BUS_PRINT_PROPERTY_ONLY_VALUE = 1 << 0, /* e.g. systemctl --value */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int unit_show_processes(sd_bus *bus, const char *unit, const char *cgroup_path, const char *prefix, unsigned n_columns, OutputFlags flags, sd_bus_error *reterr_error);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "forward.h"
#include "log.h"
-#include "shared-forward.h"
typedef enum BusTransport {
BUS_TRANSPORT_LOCAL,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct BusWaitForJobs BusWaitForJobs;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct BusWaitForUnits BusWaitForUnits;
/* A structure for specifying (possibly repetitive) points in calendar
* time, a la cron */
-#include "shared-forward.h"
+#include "forward.h"
typedef struct CalendarComponent {
int start;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int cg_weight_parse(const char *s, uint64_t *ret);
int cg_cpu_weight_parse(const char *s, uint64_t *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int show_cgroup_by_path(const char *path, const char *prefix, size_t n_columns, OutputFlags flags);
int show_cgroup(const char *path, const char *prefix, size_t n_columns, OutputFlags flags);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int path_chown_recursive(const char *path, uid_t uid, gid_t gid, mode_t mask, int flags);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
/* All our long-running services should implement a SIGRTMIN+18 handler that can be used to trigger certain
* actions that affect service runtime. The specific action is indicated via the "value integer" you can pass
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#define COMPARE_OPERATOR_CHARS "!<=>"
#define COMPARE_OPERATOR_WITH_FNMATCH_CHARS COMPARE_OPERATOR_CHARS "$"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "list.h"
-#include "shared-forward.h"
typedef enum ConditionType {
CONDITION_ARCHITECTURE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum CopyFlags {
COPY_REFLINK = 1 << 0, /* Try to reflink */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum CoredumpFilter {
COREDUMP_FILTER_PRIVATE_ANONYMOUS = 0,
#include <sched.h>
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
#define CREDENTIAL_NAME_MAX FDNAME_MAX
#pragma once
#include "dlopen-note.h"
+#include "forward.h"
#include "iovec-util.h"
#include "sha256.h"
-#include "shared-forward.h"
typedef enum CertificateSourceType {
OPENSSL_CERTIFICATE_SOURCE_FILE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int acquire_fido2_key(
const char *volume_name,
#include <sys/uio.h>
-#include "crypto-util.h"
-#include "shared-forward.h"
+#include "forward.h"
int acquire_tpm2_key(
const char *volume_name,
#include "dlfcn-util.h"
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_LIBCRYPTSETUP
#ifndef SYSTEMD_CFLAGS_MARKER_LIBCRYPTSETUP
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_LIBCURL
#ifndef SYSTEMD_CFLAGS_MARKER_LIBCURL
#include "sd-daemon.h" /* IWYU pragma: export */
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int copy_data_fd(int fd);
int memfd_clone_fd(int fd, const char *name, int mode);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int dev_setup(const char *prefix, uid_t uid, gid_t gid);
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "os-util.h"
typedef enum ImageType {
#include "sd-id128.h"
#include "architecture.h"
+#include "forward.h"
#include "gpt.h"
#include "iovec-util.h"
-#include "shared-forward.h"
typedef struct DecryptedImage DecryptedImage;
#pragma once
#include "../basic/dlopen-note.h" /* IWYU pragma: export */
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_ACL
# define LIBACL_NOTE(priority) \
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "ordered-set.h"
-#include "shared-forward.h"
/* A simple array of resource records. We keep track of the originating ifindex for each RR where that makes
* sense, so that we can qualify A and AAAA RRs referring to a local link with the right ifindex.
#include <sys/uio.h>
+#include "forward.h"
#include "in-addr-util.h"
-#include "shared-forward.h"
typedef struct DNSServer {
struct iovec addr;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum DNSLabelFlags {
DNS_LABEL_LDH = 1 << 0, /* Follow the "LDH" rule — only letters, digits, and internal hyphens. */
#include <netinet/ip6.h>
#include <netinet/udp.h>
+#include "forward.h"
#include "in-addr-util.h"
#include "memory-util.h"
#include "resolved-def.h"
-#include "shared-forward.h"
#include "sparse-endian.h"
typedef enum DnsProtocol {
#include "sd-json.h"
-#include "shared-forward.h"
+#include "forward.h"
#define DNS_QUESTION_ITEMS_MAX 128U
#include "dns-def.h"
#include "dns-type.h"
+#include "forward.h"
#include "list.h"
-#include "shared-forward.h"
/* DNSKEY RR flags */
#define DNSKEY_FLAG_SEP (UINT16_C(1) << 0)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int drop_in_file(
const char *dir,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#define DROPIN_MARKER_START "### Anything between here and the comment below will become the contents of the drop-in file"
#define DROPIN_MARKER_END "### Edits below this comment will be discarded"
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
/* Various calls that interface with EFI variables implementing https://systemd.io/BOOT_LOADER_INTERFACE */
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
int dlopen_dw(int log_level) _dlopen_loader_;
int dlopen_elf(int log_level) _dlopen_loader_;
#include <linux/ethtool.h>
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
#define N_ADVERTISE 4
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef int (*gather_stdout_callback_t) (int fd, void *arg);
#pragma once
#include "bitmap.h"
-#include "shared-forward.h"
+#include "forward.h"
/* This defines pretty names for the LSB 'start' verb exit codes. Note that they shouldn't be confused with
* the LSB 'status' verb exit codes which are defined very differently. For details see:
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* Given an image name (for logging purposes), a set of os-release values from the host and a key-value pair
* vector of extension-release variables, check that the distro and (system extension level or distro
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum FactoryResetMode {
FACTORY_RESET_UNSUPPORTED, /* feature not available on this OS */
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_LIBFDISK
#ifndef SYSTEMD_CFLAGS_MARKER_LIBFDISK
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "iterator.h"
-#include "shared-forward.h"
FDSet* fdset_new(void);
FDSet* fdset_free(FDSet *s);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int fido2_generate_salt(struct iovec *ret_salt);
int fido2_read_salt_file(const char *filename, uint64_t offset, const char *client, const char *node, struct iovec *ret_salt);
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int find_esp_and_warn_at_full(int rfd, const char *path, int unprivileged_mode, char **ret_path, int *ret_fd, 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_full(const char *root, const char *path, int unprivileged_mode, char **ret_path, int *ret_fd, 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 "shared-forward.h"
+#include "forward.h"
int fw_nftables_add_masquerade(
sd_netlink *nfnl,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* Parsed value of the systemd.firstboot= kernel command line option, honoured by systemd-firstboot,
* homectl's firstboot logic and systemd-cryptenroll. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "output-mode.h"
-#include "shared-forward.h"
typedef void (*fork_notify_handler_t)(void *userdata);
#include "sd-json.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "log.h"
#include "pager.h"
/* IWYU pragma: always_keep */
-#include "sd-forward.h" /* IWYU pragma: export */
+#include "../libsystemd/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);
typedef enum UserRecordLoadFlags UserRecordLoadFlags;
typedef enum UserStorage UserStorage;
+typedef struct Argon2IdParameters Argon2IdParameters;
typedef struct AskPasswordRequest AskPasswordRequest;
typedef struct Bitmap Bitmap;
typedef struct BootConfig BootConfig;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "sd-forward.h"
+#include "forward.h"
#define FSPRG_RECOMMENDED_SECPAR 1536
#define FSPRG_RECOMMENDED_SEEDLEN (96/8)
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
#include "main-func.h"
int generator_open_unit_file_full(const char *dir, const char *source, const char *filename, FILE **ret_file, char **ret_final_path, char **ret_temp_path);
#include <linux/if_link.h>
-#include "shared-forward.h"
+#include "forward.h"
typedef enum GeneveDF {
NETDEV_GENEVE_DF_UNSET = GENEVE_DF_UNSET,
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
int dlopen_gnutls(int log_level) _dlopen_loader_;
#include "sd-id128.h"
#include "architecture.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "sparse-endian.h"
/* maximum length of gpt label */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "user-record.h"
typedef struct GroupRecord {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* represents values for /sys/power/resume & /sys/power/resume_offset and the corresponding path */
typedef struct HibernationDevice {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum HostnameSource {
HOSTNAME_STATIC, /* from /etc/hostname */
#include "sd-hwdb.h" /* IWYU pragma: export */
-#include "shared-forward.h"
+#include "forward.h"
bool hwdb_should_reload(sd_hwdb *hwdb);
int hwdb_update(const char *root, const char *hwdb_bin_dir, bool strict, bool compat);
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum Id128PrettyPrintMode {
ID128_PRINT_ID128,
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_LIBIDN2
#ifndef SYSTEMD_CFLAGS_MARKER_LIBIDN2
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
bool use_ima(void);
#include "conf-parser-forward.h"
#include "dissect-image.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "gpt.h"
typedef enum PartitionPolicyFlags {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum ImportType {
IMPORT_RAW,
#pragma once
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "in-addr-util.h"
struct in_addr_prefix {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* Builds a new CPIO archive containing each credential as a
* file under .extra/system_credentials/<id>.cred, writes it to a
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum InstallFileFlags {
INSTALL_REPLACE = 1 << 0, /* Replace an existing inode */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int install_name_printf(
RuntimeScope scope,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "runtime-scope.h"
-#include "shared-forward.h"
#include "unit-file.h"
typedef enum UnitFilePresetMode {
#include <sys/ioprio.h> /* IWYU pragma: export */
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
const char* ip_protocol_to_name(int id);
int ip_protocol_from_name(const char *name);
#include <linux/if_link.h>
-#include "shared-forward.h"
+#include "forward.h"
typedef enum IPVlanMode {
NETDEV_IPVLAN_MODE_L2 = IPVLAN_MODE_L2,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "journal-authenticate-internal.h" /* IWYU pragma: export */
-#include "shared-forward.h"
void journal_auth_init(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "journal-file.h" /* IWYU pragma: export */
-#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 "shared-forward.h"
+#include "forward.h"
#include "iovec-wrapper.h"
#include "time-util.h"
#include "sd-journal.h" /* IWYU pragma: export */
-#include "shared-forward.h"
+#include "forward.h"
int journal_access_blocked(sd_journal *j);
int journal_access_check_and_warn(sd_journal *j, bool quiet, bool want_other_users);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int keymap_directories(char ***ret);
int get_keymaps(char ***ret);
#pragma once
#include "fd-util.h"
-#include "shared-forward.h"
+#include "forward.h"
int load_kernel_install_conf_at(
const char *root,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum KernelImageType {
KERNEL_IMAGE_TYPE_UNKNOWN,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int broadcast_signal(int sig, bool wait_for_exit, bool send_sighup, usec_t timeout);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "../basic/label-util.h" /* IWYU pragma: export */
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_LIBARCHIVE
#ifndef SYSTEMD_CFLAGS_MARKER_LIBARCHIVE
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
int dlopen_libaudit(int log_level) _dlopen_loader_;
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_LIBCRYPT
int make_salt(char **ret);
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#define FIDO2_SALT_SIZE 32U
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_LIBMOUNT
#ifndef SYSTEMD_CFLAGS_MARKER_LIBMOUNT
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "in-addr-util.h"
struct local_address {
#include <sys/stat.h>
-#include "shared-forward.h"
+#include "forward.h"
#include "locale-util.h"
typedef struct LocaleContext {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
void log_set_assert_return_is_critical(bool b);
void log_set_assert_return_is_critical_from_env(void);
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
/* Some helpers for setting up loopback block devices */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
-#include "sd-forward.h"
+#include "forward.h"
#define LUO_SESSION_NAME "systemd"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct MachineBindUserData {
/* The host's user/group records */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct MachineCredential {
char *id;
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum MachineIdSetupFlags {
MACHINE_ID_SETUP_FORCE_TRANSIENT = 1 << 0,
#include "sd-id128.h"
+#include "forward.h"
#include "runtime-scope.h"
-#include "shared-forward.h"
typedef struct MachineRegistration {
const char *name;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "storage-util.h"
typedef enum ImageFormat {
#include <linux/if_link.h>
-#include "shared-forward.h"
+#include "forward.h"
typedef enum MacVlanMode {
NETDEV_MACVLAN_MODE_PRIVATE = MACVLAN_MODE_PRIVATE,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "static-destruct.h" /* IWYU pragma: keep */
void main_prepare(int argc, char *argv[]);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum MetricFamilyType {
METRIC_FAMILY_TYPE_COUNTER,
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_MICROHTTPD
#ifndef SYSTEMD_CFLAGS_MARKER_LIBMICROHTTPD
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "../basic/mkdir.h" /* IWYU pragma: export */
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum MakeFilesystemFlags {
MKFS_QUIET = 1 << 0, /* Suppress mkfs command output */
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_KMOD
#ifndef SYSTEMD_CFLAGS_MARKER_LIBKMOD
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
typedef struct SubMount {
char *path;
#pragma once
#include "discover-image.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum MStackFlags {
MSTACK_MKDIR = 1 << 0, /* when mounting, create top-level inode to mount on top */
#include <linux/nl80211.h>
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef struct NetMatch {
Set *hw_addr;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* So here's the deal: net_id is supposed to be an exercise in providing stable names for network devices. However, we
* also want to keep updating the naming scheme used in future versions of net_id. These two goals of course are
#include <net/ethernet.h>
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef enum SRIOVAttribute {
SR_IOV_VF_MAC,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
bool netif_has_carrier(uint8_t operstate, unsigned flags);
int net_get_type_string(sd_device *device, uint16_t iftype, char **ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int notify_socket_prepare_full(
sd_event *event,
#include <sched.h>
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
#include "user-util.h"
/* Helpful constants for the only numbers of UIDs that can currently be allocated */
#include <pwd.h>
#include <resolv.h>
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
static inline bool mpol_is_valid(int t) {
return t >= MPOL_DEFAULT && t <= MPOL_WEIGHTED_INTERLEAVE;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "list.h"
typedef enum OpenFileFlag {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* Option namespace/group explanation:
* the list of options is split into namespaces, and a namespace is split into groups.
#include "sd-id128.h"
-#include "shared-forward.h"
+#include "forward.h"
int osc_context_open_boot(char **ret_seq);
int osc_context_open_container(const char *name, char **ret_seq, sd_id128_t *ret_context_id);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum OutputMode {
OUTPUT_SHORT,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum PagerFlags {
PAGER_DISABLE = 1 << 0,
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_PAM
#ifndef SYSTEMD_CFLAGS_MARKER_LIBPAM
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int parse_boolean_argument(const char *optname, const char *s, bool *ret);
int parse_tristate_argument_with_auto(const char *optname, const char *s, int *ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum PathSimplifyWarnFlags {
PATH_CHECK_FATAL = 1 << 0, /* If not set, then error message is appended with 'ignoring'. */
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_PASSWDQC
int suggest_passwords(void);
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_PWQUALITY
int suggest_passwords(void);
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_PCRE2
#ifndef SYSTEMD_CFLAGS_MARKER_LIBPCRE2
#include <sys/uio.h>
-#include "shared-forward.h"
+#include "forward.h"
int pcrextend_file_system_word(const char *path, char **ret, char **ret_normalized_path);
int pcrextend_machine_id_word(char **ret);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
typedef enum Pkcs11RsaPadding {
PKCS11_RSA_PADDING_PKCS1V15, /* CKM_RSA_PKCS, RFC 8017 PKCS#1 v1.5 (legacy) */
#include "ask-password-api.h"
#include "dlfcn-util.h"
#include "dlopen-note.h"
+#include "forward.h"
#include "pkcs11-padding.h"
-#include "shared-forward.h"
bool pkcs11_uri_valid(const char *uri);
#pragma once
#include "errno-util.h"
-#include "shared-forward.h"
+#include "forward.h"
int plymouth_connect(int flags);
int plymouth_send_raw(const void *raw, size_t size, int flags);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int polkit_agent_open(void);
void polkit_agent_close(void);
#pragma once
#include "constants.h"
-#include "shared-forward.h"
+#include "forward.h"
#define PORTABLE_PROFILE_DIRS CONF_PATHS_NULSTR("systemd/portable/profile")
#include "ansi-color.h"
#include "fileio.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "glyph-util.h"
#define CYLON_BUFFER_EXTRA (2*STRLEN(ANSI_RED) + STRLEN(ANSI_HIGHLIGHT_RED) + 2*STRLEN(ANSI_NORMAL))
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
typedef struct PTYForward PTYForward;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef int (*qmp_event_callback_t)(
QmpClient *client,
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
int print_qrcode_full(
FILE *out,
#include <linux/quota.h> /* IWYU pragma: export */
#include <sys/quota.h> /* IWYU pragma: export */
-#include "shared-forward.h"
+#include "forward.h"
/* Wrapper around the QCMD() macro of linux/quota.h that removes some undefined behaviour. A typical quota
* command such as QCMD(Q_GETQUOTA, USRQUOTA) cannot be resolved on platforms where "int" is 32-bit, as it is
#include <linux/reboot.h> /* IWYU pragma: export */
#include <sys/reboot.h> /* IWYU pragma: export */
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "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 "sd-forward.h"
-
-#include "shared-forward.h"
+#include "forward.h"
typedef enum RereadPartitionTableFlags {
REREADPT_FORCE_UEVENT = 1 << 0, /* Force a "change" uevent out on partitions we didn't resize/remove/add */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "stat-util.h"
int resize_fs(int fd, uint64_t sz, uint64_t *ret_size);
#include "sd-json.h"
-#include "shared-forward.h"
+#include "forward.h"
typedef struct ResolveRecordParameters {
DnsQuestion *question;
#pragma once
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
/* 127.0.0.53 in native endian (The IP address we listen on with the full DNS stub, i.e. that does LLMNR/mDNS, and stuff) */
#define INADDR_DNS_STUB ((in_addr_t) 0x7f000035U)
#include <sys/uio.h>
+#include "forward.h"
#include "in-addr-util.h"
-#include "shared-forward.h"
typedef struct ResolveError {
int rcode;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "time-util.h"
/* Input + Output: The various protocols we can use */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum RemoveFlags {
REMOVE_ONLY_DIRECTORIES = 1 << 0, /* Only remove empty directories, no files */
#include "dlopen-note.h"
#include "errno-util.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_SECCOMP
#ifndef SYSTEMD_CFLAGS_MARKER_LIBSECCOMP
#include <linux/securebits.h>
-#include "shared-forward.h"
+#include "forward.h"
int secure_bits_to_strv(int i, char ***ret);
DECLARE_STRING_TABLE_LOOKUP_WITH_FALLBACK(secure_bits, int);
#include <sys/socket.h>
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_SELINUX
#ifndef SYSTEMD_CFLAGS_MARKER_LIBSELINUX
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int serialize_item(FILE *f, const char *key, const char *value);
int serialize_item_escaped(FILE *f, const char *key, const char *value);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int service_parse_argv(
const char *service,
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
typedef enum SleepOperation {
SLEEP_SUSPEND,
Author: Auke Kok <auke-jan.h.kok@intel.com>
***/
-#include "shared-forward.h"
+#include "forward.h"
typedef enum SmackAttr {
SMACK_ATTR_ACCESS,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int read_smbios11_field(unsigned i, size_t max_size, char **ret_data, size_t *ret_size);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* create_ephemeral_snapshot - create a snapshot of the given directory.
*
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* Bidirectional forwarder using splice().
*
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum SocketAddressBindIPv6Only {
SOCKET_ADDRESS_DEFAULT,
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
typedef int (*SpecifierCallback)(char specifier, const void *data, const char *root, const void *userdata, char **ret);
#pragma once
#include "dlopen-note.h"
-#include "shared-forward.h"
+#include "forward.h"
#if HAVE_OPENSSL
#ifndef SYSTEMD_CFLAGS_MARKER_LIBOPENSSL
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum SwitchRootFlags {
SWITCH_ROOT_DESTROY_OLD_ROOT = 1 << 0, /* rm -rf old root when switching – under the condition
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "string-util.h"
#define _test_table(type, name, lookup, reverse, size, sparse) \
#include <unistd.h>
#include "errno-list.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "log.h"
#include "log-assert-critical.h"
#include "static-destruct.h" /* IWYU pragma: keep */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
bool mac_tomoyo_use(void);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "tpm2-util.h" /* IWYU pragma: keep */
/* Definitions as per "TCG PC Client Specific Platform Firmware Profile Specification"
#include "bitfield.h"
#include "crypto-util.h"
#include "dlopen-note.h"
+#include "forward.h"
#include "iovec-util.h"
-#include "shared-forward.h"
#include "sha256.h"
typedef enum TPM2Flags {
#include <sys/uio.h>
-#include "shared-forward.h"
+#include "forward.h"
#define TSM_REPORT_DATA_SIZE 64U
#pragma once
#include "conf-parser.h"
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
#include "unit-def.h"
typedef enum UnitFileState {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* Synthesize UserRecord and GroupRecord objects from NSS data */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
const char* user_record_state_color(const char *state);
#include "sd-id128.h"
#include "bitfield.h"
+#include "forward.h"
#include "pkcs11-padding.h"
#include "rlimit-util.h"
-#include "shared-forward.h"
typedef enum UserDisposition {
USER_INTRINSIC, /* root and nobody */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
/* This could be put together with CONF_PATHS_NULSTR, with the exception of the /run/host/ part in the
* middle, which we use here, but not otherwise. */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "group-record.h"
#include "user-record.h"
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#if ENABLE_UTMP
#include <utmpx.h>
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int varlink_server_serialize(sd_varlink_server *s, const char *name, 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 "shared-forward.h"
+#include "forward.h"
typedef struct X11Context {
char *layout;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_log_control_common(sd_bus *bus, const char *destination, const char *verb, const char *value);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#define VERB_ANY (UINT_MAX)
#pragma once
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
#define VLANID_MAX 4094
#define VLANID_INVALID UINT16_MAX
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum VolatileMode {
VOLATILE_NO,
#include <sys/stat.h>
#include "architecture.h"
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
#if ENABLE_UTMP || ENABLE_LOGIND
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
const char* watchdog_get_device(void);
usec_t watchdog_get_last_ping(clockid_t clock);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int wifi_get_interface(sd_netlink *genl, int ifindex, enum nl80211_iftype *ret_iftype, char **ret_ssid);
int wifi_get_station(sd_netlink *genl, int ifindex, struct ether_addr *ret_bssid);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
enum {
XML_END,
Copyright © 2010 ProFUSION embedded systems
***/
-#include "shared-forward.h"
+#include "forward.h"
int dm_detach_all(bool *changed, bool last_try);
Copyright © 2010 ProFUSION embedded systems
***/
-#include "shared-forward.h"
+#include "forward.h"
int loopback_detach_all(bool *changed, bool last_try);
Copyright © 2010 ProFUSION embedded systems
***/
-#include "shared-forward.h"
+#include "forward.h"
int md_detach_all(bool *changed, bool last_try);
Copyright © 2010 ProFUSION embedded systems
***/
-#include "shared-forward.h"
+#include "forward.h"
#include "list.h"
int swapoff_all(bool *changed);
Copyright © 2010 ProFUSION embedded systems
***/
-#include "shared-forward.h"
+#include "forward.h"
#include "list.h"
int umount_all(bool *changed, bool last_try);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_add_dependency(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_cancel(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_clean_or_freeze(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_cat(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_edit(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_enable(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_is_active(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_is_failed(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_is_enabled(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_is_system_running(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_kill(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_list_dependencies(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_list_jobs(int argc, char *argv[], uintptr_t _data, void *userdata);
#pragma once
#include "bus-map-properties.h"
-#include "shared-forward.h"
+#include "forward.h"
int verb_list_machines(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_list_unit_files(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_log_setting(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_service_log_setting(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_bind(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_mount_image(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_preset_all(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_reset_failed(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_service_watchdogs(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_get_default(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_set_default(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_show_environment(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_set_environment(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_set_property(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_show(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_start_special(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_start_system_special(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_switch_root(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_trivial_method(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
int verb_whoami(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
enum action {
ACTION_SYSTEMCTL,
#pragma once
#include "conf-parser-forward.h"
-#include "shared-forward.h"
+#include "forward.h"
CONFIG_PARSER_PROTOTYPE(config_parse_url_specifiers);
CONFIG_PARSER_PROTOTYPE(config_parse_url_specifiers_many);
/* IWYU pragma: always_keep */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef struct Context Context;
typedef struct Instance Instance;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef enum UpdateSetFlags {
UPDATE_NEWEST = 1 << 0,
* Contact: fsprg@point-at-infinity.org
*/
-#include "sd-forward.h"
+#include "forward.h"
#ifdef __cplusplus
extern "C" {
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
int dlopen_gcrypt(int log_level);
#include <nss.h>
-#include "shared-forward.h"
+#include "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 <stdlib.h>
#include "dlfcn-util.h"
-#include "shared-forward.h"
+#include "forward.h"
int main(int argc, char **argv) {
void *handles[argc - 1];
#define __STDC_WANT_IEC_60559_TYPES_EXT__
#include <float.h>
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int hwclock_get(struct tm *tm);
int hwclock_set(const struct tm *tm);
/* IWYU pragma: always_keep */
#include "conf-parser-forward.h" /* IWYU pragma: export */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef enum ServerType ServerType;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int is_fido_security_token_desc(const uint8_t *desc, size_t desc_len);
#include <mtd/mtd-user.h>
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
#include "list.h"
#include "net-condition.h"
/* SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
-#include "basic-forward.h"
+#include "forward.h"
/*
* Copyright © IBM Corp. 2003
/* IWYU pragma: always_keep */
-#include "shared-forward.h" /* IWYU pragma: export */
+#include "forward.h" /* IWYU pragma: export */
typedef struct UdevCtrl UdevCtrl;
typedef struct UdevEvent UdevEvent;
#include "sd-device.h"
-#include "shared-forward.h"
+#include "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 "shared-forward.h"
+#include "forward.h"
int verb_cat_main(int argc, char *argv[], uintptr_t _data, void *userdata);
int verb_info_main(int argc, char *argv[], uintptr_t _data, void *userdata);
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#include "ratelimit.h"
#define USERDB_WORKERS_MIN 3
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "machine-util.h"
-#include "shared-forward.h"
#include "vmspawn-qmp.h"
/* Empty/NULL defaults to virtio-blk; otherwise delegates to disk_type_from_string(). */
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct RuntimeMount {
bool read_only;
#include <net/ethernet.h>
+#include "forward.h"
#include "machine-util.h"
-#include "shared-forward.h"
#define VMSPAWN_PCIE_HOTPLUG_SPARES 10
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct SocketServicePair {
char **exec_start_pre;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include "forward.h"
#include "machine-util.h"
-#include "shared-forward.h"
typedef struct ExtraDrive {
char *path;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
#if defined(__x86_64__) || defined(__i386__) || defined(__arm__) || defined(__aarch64__)
# define ARCHITECTURE_SUPPORTS_SMBIOS 1
#pragma once
#include "cleanup-util.h"
-#include "shared-forward.h"
+#include "forward.h"
#include "vmspawn-qmp.h"
typedef struct VmspawnVarlinkContext VmspawnVarlinkContext;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
-#include "shared-forward.h"
+#include "forward.h"
typedef struct XdgAutostartService {
char *name;
projects / thirdparty / systemd.git / commitdiff
