gperf_test_format = '''
#include <string.h>
-const char * in_word_set(const char *, @0@);
+const char* in_word_set(const char *, @0@);
@1@
'''
gperf_snippet = run_command(sh, '-c', 'echo foo,bar | "$1" -L ANSI-C', '_', gperf,
#include "af-from-name.h"
#include "af-to-name.h"
-const char *af_to_name(int id) {
+const char* af_to_name(int id) {
if (id <= 0)
return NULL;
return ELEMENTSOF(af_names);
}
-const char *af_to_ipv4_ipv6(int id) {
+const char* af_to_ipv4_ipv6(int id) {
/* Pretty often we want to map the address family to the typically used protocol name for IPv4 +
* IPv6. Let's add special helpers for that. */
return id == AF_INET ? "ipv4" :
#include "string-util.h"
-const char *af_to_name(int id);
+const char* af_to_name(int id);
int af_from_name(const char *name);
static inline const char* af_to_name_short(int id) {
# error "Please register your architecture here!"
#endif
-const char *architecture_to_string(Architecture a) _const_;
+const char* architecture_to_string(Architecture a) _const_;
Architecture architecture_from_string(const char *s) _pure_;
#include <inttypes.h>
#include <stddef.h>
-const char *arphrd_to_name(int id);
+const char* arphrd_to_name(int id);
int arphrd_from_name(const char *name);
size_t arphrd_to_hw_addr_len(uint16_t arphrd);
#include "cap-from-name.h"
#include "cap-to-name.h"
-const char *capability_to_name(int id) {
+const char* capability_to_name(int id) {
if (id < 0)
return NULL;
if (id >= capability_list_length())
return capability_names[id];
}
-const char *capability_to_string(int id, char buf[static CAPABILITY_TO_STRING_MAX]) {
+const char* capability_to_string(int id, char buf[static CAPABILITY_TO_STRING_MAX]) {
const char *p;
if (id < 0)
* "0x", two bytes for the hex value, and one trailing NUL byte. */
#define CAPABILITY_TO_STRING_MAX (2 + 2 + 1)
-const char *capability_to_name(int id);
-const char *capability_to_string(int id, char buf[static CAPABILITY_TO_STRING_MAX]);
+const char* capability_to_name(int id);
+const char* capability_to_string(int id, char buf[static CAPABILITY_TO_STRING_MAX]);
#define CAPABILITY_TO_STRING(id) capability_to_string(id, (char[CAPABILITY_TO_STRING_MAX]) {})
int capability_from_name(const char *name);
ConfidentialVirtualization detect_confidential_virtualization(void);
-const char *confidential_virtualization_to_string(ConfidentialVirtualization v) _const_;
+const char* confidential_virtualization_to_string(ConfidentialVirtualization v) _const_;
ConfidentialVirtualization confidential_virtualization_from_string(const char *s) _pure_;
#include "errno-from-name.h"
#include "errno-to-name.h"
-const char *errno_to_name(int id) {
+const char* errno_to_name(int id) {
if (id < 0)
id = -id;
*/
#define ERRNO_MAX 4095
-const char *errno_to_name(int id);
+const char* errno_to_name(int id);
int errno_from_name(const char *name);
static inline bool errno_is_valid(int n) {
return n > 0 && n <= ERRNO_MAX;
return statx_mount_same(&st1.nsx, &st2.nsx);
}
-const char *accmode_to_string(int flags) {
+const char* accmode_to_string(int flags) {
switch (flags & O_ACCMODE) {
case O_RDONLY:
return "ro";
int proc_fd_enoent_errno(void);
-const char *accmode_to_string(int flags);
+const char* accmode_to_string(int flags);
/* Like ASSERT_PTR, but for fds */
#define ASSERT_FD(fd) \
#include "filesystems-gperf.h"
#include "stat-util.h"
-const char *fs_type_to_string(statfs_f_type_t magic) {
+const char* fs_type_to_string(statfs_f_type_t magic) {
switch (magic) {
#include "filesystem-switch-case.h"
const FilesystemSet *filesystem_set_find(const char *name);
-const char *fs_type_to_string(statfs_f_type_t magic);
+const char* fs_type_to_string(statfs_f_type_t magic);
int fs_type_from_string(const char *name, const statfs_f_type_t **ret);
bool fs_in_group(const struct statfs *s, enum FilesystemGroups fs_group);
return cached_emoji_enabled;
}
-const char *special_glyph_full(SpecialGlyph code, bool force_utf) {
+const char* special_glyph_full(SpecialGlyph code, bool force_utf) {
/* A list of a number of interesting unicode glyphs we can use to decorate our output. It's probably wise to be
* conservative here, and primarily stick to the glyphs defined in the eurlatgr font, so that display still
bool emoji_enabled(void);
-const char *special_glyph_full(SpecialGlyph code, bool force_utf) _const_;
+const char* special_glyph_full(SpecialGlyph code, bool force_utf) _const_;
-static inline const char *special_glyph(SpecialGlyph code) {
+static inline const char* special_glyph(SpecialGlyph code) {
return special_glyph_full(code, false);
}
-static inline const char *special_glyph_check_mark(bool b) {
+static inline const char* special_glyph_check_mark(bool b) {
return b ? special_glyph(SPECIAL_GLYPH_CHECK_MARK) : special_glyph(SPECIAL_GLYPH_CROSS_MARK);
}
-static inline const char *special_glyph_check_mark_space(bool b) {
+static inline const char* special_glyph_check_mark_space(bool b) {
return b ? special_glyph(SPECIAL_GLYPH_CHECK_MARK) : " ";
}
log_show_color(true);
}
-const char *_log_set_prefix(const char *prefix, bool force) {
+const char* _log_set_prefix(const char *prefix, bool force) {
const char *old = log_prefix;
if (prefix || force)
set_log_syntax_callback(/* cb= */ NULL, /* userdata= */ NULL);
}
-const char *log_target_to_string(LogTarget target) _const_;
+const char* log_target_to_string(LogTarget target) _const_;
LogTarget log_target_from_string(const char *s) _pure_;
void log_set_target(LogTarget target);
void log_set_target_and_open(LogTarget target);
#define log_ratelimit_error_errno(error, ...) log_ratelimit_full_errno(LOG_ERR, error, __VA_ARGS__)
#define log_ratelimit_emergency_errno(error, ...) log_ratelimit_full_errno(log_emergency_level(), error, __VA_ARGS__)
-const char *_log_set_prefix(const char *prefix, bool force);
-static inline const char *_log_unset_prefixp(const char **p) {
+const char* _log_set_prefix(const char *prefix, bool force);
+static inline const char* _log_unset_prefixp(const char **p) {
assert(p);
_log_set_prefix(*p, true);
return NULL;
return mount_fd(source, fd, filesystemtype, mountflags, data);
}
-const char *mount_propagation_flag_to_string(unsigned long flags) {
+const char* mount_propagation_flag_to_string(unsigned long flags) {
switch (flags & (MS_SHARED|MS_SLAVE|MS_PRIVATE)) {
case 0:
unsigned long mountflags,
const void *data);
-const char *mount_propagation_flag_to_string(unsigned long flags);
+const char* mount_propagation_flag_to_string(unsigned long flags);
int mount_propagation_flag_from_string(const char *name, unsigned long *ret);
bool mount_propagation_flag_is_valid(unsigned long flag);
return DIV_ROUND_UP(now(CLOCK_REALTIME), USEC_PER_SEC) > (usec_t) eol;
}
-const char *os_release_pretty_name(const char *pretty_name, const char *name) {
+const char* os_release_pretty_name(const char *pretty_name, const char *name) {
/* Distills a "pretty" name to show from os-release data. First argument is supposed to be the
* PRETTY_NAME= field, the second one the NAME= field. This function is trivial, of course, and
* exists mostly to ensure we use the same logic wherever possible. */
int os_release_support_ended(const char *support_end, bool quiet, usec_t *ret_eol);
-const char *os_release_pretty_name(const char *pretty_name, const char *name);
+const char* os_release_pretty_name(const char *pretty_name, const char *name);
bool path_implies_directory(const char *path);
-static inline const char *skip_dev_prefix(const char *p) {
+static inline const char* skip_dev_prefix(const char *p) {
const char *e;
/* Drop any /dev prefix if there is any */
#define OPINIONATED_PERSONALITY_MASK 0xFFUL
unsigned long personality_from_string(const char *p);
-const char *personality_to_string(unsigned long);
+const char* personality_to_string(unsigned long);
int safe_personality(unsigned long p);
int opinionated_personality(unsigned long *ret);
-const char *sigchld_code_to_string(int i) _const_;
+const char* sigchld_code_to_string(int i) _const_;
int sigchld_code_from_string(const char *s) _pure_;
int sched_policy_to_string_alloc(int i, char **s);
#include "macro.h"
#include "missing_resource.h"
-const char *rlimit_to_string(int i) _const_;
+const char* rlimit_to_string(int i) _const_;
int rlimit_from_string(const char *s) _pure_;
int rlimit_from_string_harder(const char *s) _pure_;
_RUNTIME_SCOPE_INVALID = -EINVAL,
} RuntimeScope;
-const char *runtime_scope_to_string(RuntimeScope scope) _const_;
+const char* runtime_scope_to_string(RuntimeScope scope) _const_;
RuntimeScope runtime_scope_from_string(const char *s) _const_;
-const char *runtime_scope_cmdline_option_to_string(RuntimeScope scope) _const_;
+const char* runtime_scope_cmdline_option_to_string(RuntimeScope scope) _const_;
DEFINE_PRIVATE_STRING_TABLE_LOOKUP(static_signal, int);
-const char *signal_to_string(int signo) {
+const char* signal_to_string(int signo) {
static thread_local char buf[STRLEN("RTMIN+") + DECIMAL_STR_MAX(int)];
const char *name;
int sigprocmask_many_internal(int how, sigset_t *old, ...);
#define sigprocmask_many(...) sigprocmask_many_internal(__VA_ARGS__, -1)
-const char *signal_to_string(int i) _const_;
+const char* signal_to_string(int i) _const_;
int signal_from_string(const char *s) _pure_;
void nop_signal_handler(int sig);
/* For basic lookup tables with strictly enumerated entries */
#define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope) \
- scope const char *name##_to_string(type i) { \
+ scope const char* name##_to_string(type i) { \
if (i < 0 || i >= (type) ELEMENTSOF(name##_table)) \
return NULL; \
return name##_table[i]; \
return s ?: "(null)";
}
-static inline const char *strna(const char *s) {
+static inline const char* strna(const char *s) {
return s ?: "n/a";
}
(typeof(p)) (isempty(_p) ? NULL : _p); \
})
-static inline const char *empty_to_na(const char *p) {
+static inline const char* empty_to_na(const char *p) {
return isempty(p) ? "n/a" : p;
}
-static inline const char *empty_to_dash(const char *str) {
+static inline const char* empty_to_dash(const char *str) {
return isempty(str) ? "-" : str;
}
(str[0] == '-' && str[1] == 0);
}
-static inline const char *empty_or_dash_to_null(const char *p) {
+static inline const char* empty_or_dash_to_null(const char *p) {
return empty_or_dash(p) ? NULL : p;
}
#define empty_or_dash_to_null(p) \
return tty_is_vc(tty);
}
-const char *default_term_for_tty(const char *tty) {
+const char* default_term_for_tty(const char *tty) {
return tty && tty_is_vc_resolve(tty) ? "linux" : "vt220";
}
bool tty_is_vc_resolve(const char *tty);
bool tty_is_console(const char *tty) _pure_;
int vtnr_from_tty(const char *tty);
-const char *default_term_for_tty(const char *tty);
+const char* default_term_for_tty(const char *tty);
int make_console_stdio(void);
} \
}
-static inline const char *ansi_underline(void) {
+static inline const char* ansi_underline(void) {
return underline_enabled() ? ANSI_UNDERLINE : "";
}
-static inline const char *ansi_add_underline(void) {
+static inline const char* ansi_add_underline(void) {
return underline_enabled() ? ANSI_ADD_UNDERLINE : "";
}
-static inline const char *ansi_add_underline_grey(void) {
+static inline const char* ansi_add_underline_grey(void) {
return underline_enabled() ?
(colors_enabled() ? ANSI_ADD_UNDERLINE_GREY : ANSI_ADD_UNDERLINE) : "";
}
return table[t];
}
-const char *unit_dbus_interface_from_name(const char *name) {
+const char* unit_dbus_interface_from_name(const char *name) {
UnitType t;
t = unit_name_to_type(name);
int unit_name_from_dbus_path(const char *path, char **name);
const char* unit_dbus_interface_from_type(UnitType t);
-const char *unit_dbus_interface_from_name(const char *name);
+const char* unit_dbus_interface_from_name(const char *name);
-const char *unit_type_to_string(UnitType i) _const_;
+const char* unit_type_to_string(UnitType i) _const_;
UnitType unit_type_from_string(const char *s) _pure_;
const char* unit_type_to_capitalized_string(UnitType t);
-const char *unit_load_state_to_string(UnitLoadState i) _const_;
+const char* unit_load_state_to_string(UnitLoadState i) _const_;
UnitLoadState unit_load_state_from_string(const char *s) _pure_;
-const char *unit_active_state_to_string(UnitActiveState i) _const_;
+const char* unit_active_state_to_string(UnitActiveState i) _const_;
UnitActiveState unit_active_state_from_string(const char *s) _pure_;
-const char *freezer_state_to_string(FreezerState i) _const_;
+const char* freezer_state_to_string(FreezerState i) _const_;
FreezerState freezer_state_from_string(const char *s) _pure_;
FreezerState freezer_state_finish(FreezerState i) _const_;
-const char *unit_marker_to_string(UnitMarker m) _const_;
+const char* unit_marker_to_string(UnitMarker m) _const_;
UnitMarker unit_marker_from_string(const char *s) _pure_;
const char* automount_state_to_string(AutomountState i) _const_;
const char* target_state_to_string(TargetState i) _const_;
TargetState target_state_from_string(const char *s) _pure_;
-const char *timer_state_to_string(TimerState i) _const_;
+const char* timer_state_to_string(TimerState i) _const_;
TimerState timer_state_from_string(const char *s) _pure_;
-const char *unit_dependency_to_string(UnitDependency i) _const_;
+const char* unit_dependency_to_string(UnitDependency i) _const_;
UnitDependency unit_dependency_from_string(const char *s) _pure_;
const char* notify_access_to_string(NotifyAccess i) _const_;
int running_in_userns(void);
int running_in_chroot(void);
-const char *virtualization_to_string(Virtualization v) _const_;
+const char* virtualization_to_string(Virtualization v) _const_;
Virtualization virtualization_from_string(const char *s) _pure_;
bool has_cpu_with_flag(const char *flag);
return r;
}
-const char *get_efi_arch(void) {
+const char* get_efi_arch(void) {
/* Detect EFI firmware architecture of the running system. On mixed mode systems, it could be 32-bit
* while the kernel is running in 64-bit. */
int sync_everything(void);
-const char *get_efi_arch(void);
+const char* get_efi_arch(void);
int get_file_version(int fd, char **ret);
extern ImagePolicy *arg_image_policy;
extern bool arg_varlink;
-static inline const char *arg_dollar_boot_path(void) {
+static inline const char* arg_dollar_boot_path(void) {
/* $BOOT shall be the XBOOTLDR partition if it exists, and otherwise the ESP */
return arg_xbootldr_path ?: arg_esp_path;
}
return buf;
}
-const char *cgroup_device_permissions_to_string(CGroupDevicePermissions p) {
+const char* cgroup_device_permissions_to_string(CGroupDevicePermissions p) {
static const char *table[_CGROUP_DEVICE_PERMISSIONS_MAX] = {
/* Lets simply define a table with every possible combination. As long as those are just 8 we
* can get away with it. If this ever grows to more we need to revisit this logic though. */
unit_invalidate_cgroup_members_masks(slice);
}
-const char *unit_get_realized_cgroup_path(Unit *u, CGroupMask mask) {
+const char* unit_get_realized_cgroup_path(Unit *u, CGroupMask mask) {
/* Returns the realized cgroup path of the specified unit where all specified controllers are available. */
void unit_add_family_to_cgroup_realize_queue(Unit *u);
-const char *unit_get_realized_cgroup_path(Unit *u, CGroupMask mask);
+const char* unit_get_realized_cgroup_path(Unit *u, CGroupMask mask);
int unit_default_cgroup_path(const Unit *u, char **ret);
int unit_set_cgroup_path(Unit *u, const char *path);
int unit_pick_cgroup_path(Unit *u);
const char* cgroup_pressure_watch_to_string(CGroupPressureWatch a) _const_;
CGroupPressureWatch cgroup_pressure_watch_from_string(const char *s) _pure_;
-const char *cgroup_device_permissions_to_string(CGroupDevicePermissions p) _const_;
+const char* cgroup_device_permissions_to_string(CGroupDevicePermissions p) _const_;
CGroupDevicePermissions cgroup_device_permissions_from_string(const char *s) _pure_;
const char* cgroup_ip_accounting_metric_to_string(CGroupIPAccountingMetric m) _const_;
EXEC_OUTPUT_JOURNAL_AND_CONSOLE);
}
-const char *exec_context_tty_path(const ExecContext *context) {
+const char* exec_context_tty_path(const ExecContext *context) {
assert(context);
if (context->stdio_as_fds)
int exec_context_get_clean_directories(ExecContext *c, char **prefix, ExecCleanMask mask, char ***ret);
int exec_context_get_clean_mask(ExecContext *c, ExecCleanMask *ret);
-const char *exec_context_tty_path(const ExecContext *context);
+const char* exec_context_tty_path(const ExecContext *context);
int exec_context_apply_tty_size(const ExecContext *context, int tty_fd, const char *tty_path);
void exec_context_tty_reset(const ExecContext *context, const ExecParameters *p);
void kill_context_init(KillContext *c);
void kill_context_dump(KillContext *c, FILE *f, const char *prefix);
-const char *kill_mode_to_string(KillMode k) _const_;
+const char* kill_mode_to_string(KillMode k) _const_;
KillMode kill_mode_from_string(const char *s) _pure_;
-const char *kill_whom_to_string(KillWhom k) _const_;
+const char* kill_whom_to_string(KillWhom k) _const_;
KillWhom kill_whom_from_string(const char *s) _pure_;
static inline int restart_kill_signal(const KillContext *c) {
extern const UnitVTable timer_vtable;
extern const ActivationDetailsVTable activation_details_timer_vtable;
-const char *timer_base_to_string(TimerBase i) _const_;
+const char* timer_base_to_string(TimerBase i) _const_;
TimerBase timer_base_from_string(const char *s) _pure_;
char* timer_base_to_usec_string(TimerBase i);
return unit_set_slice(u, slice);
}
-const char *unit_slice_name(Unit *u) {
+const char* unit_slice_name(Unit *u) {
Unit *slice;
assert(u);
int unit_set_slice(Unit *u, Unit *slice);
int unit_set_default_slice(Unit *u);
-const char *unit_description(Unit *u) _pure_;
-const char *unit_status_string(Unit *u, char **combined);
+const char* unit_description(Unit *u) _pure_;
+const char* unit_status_string(Unit *u, char **combined);
bool unit_has_name(const Unit *u, const char *name);
Unit *unit_following(Unit *u);
int unit_following_set(Unit *u, Set **s);
-const char *unit_slice_name(Unit *u);
+const char* unit_slice_name(Unit *u);
bool unit_stop_pending(Unit *u) _pure_;
bool unit_inactive_or_pending(Unit *u) _pure_;
/* for more information see libcryptsetup.h crypt-tokens section */
-const char *cryptsetup_token_version(void);
+const char* cryptsetup_token_version(void);
int cryptsetup_token_open(struct crypt_device *cd, int token,
char **password, size_t *password_len, void *usrptr);
return sd_bus_message_append(m, "s", formatted);
}
-const char *home_record_dir(void) {
+const char* home_record_dir(void) {
return secure_getenv("SYSTEMD_HOME_RECORD_DIR") ?: "/var/lib/systemd/home/";
}
-const char *home_system_blob_dir(void) {
+const char* home_system_blob_dir(void) {
return secure_getenv("SYSTEMD_HOME_SYSTEM_BLOB_DIR") ?: "/var/cache/systemd/home/";
}
* operations permit a *very* long timeout */
#define HOME_SLOW_BUS_CALL_TIMEOUT_USEC (2*USEC_PER_MINUTE)
-const char *home_record_dir(void);
-const char *home_system_blob_dir(void);
+const char* home_record_dir(void);
+const char* home_system_blob_dir(void);
bool home_is_busy(Home *h);
-const char *home_state_to_string(HomeState state);
+const char* home_state_to_string(HomeState state);
HomeState home_state_from_string(const char *s);
CONFIG_PARSER_PROTOTYPE(config_parse_compress);
CONFIG_PARSER_PROTOTYPE(config_parse_forward_to_socket);
-const char *storage_to_string(Storage s) _const_;
+const char* storage_to_string(Storage s) _const_;
Storage storage_from_string(const char *s) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_split_mode);
-const char *split_mode_to_string(SplitMode s) _const_;
+const char* split_mode_to_string(SplitMode s) _const_;
SplitMode split_mode_from_string(const char *s) _pure_;
int server_new(Server **ret);
_DHCP_STATE_INVALID = -EINVAL,
} DHCPState;
-const char *dhcp_state_to_string(DHCPState s) _const_;
+const char* dhcp_state_to_string(DHCPState s) _const_;
typedef struct sd_dhcp_client sd_dhcp_client;
return size >= MIN_DUID_DATA_LEN && size <= MAX_DUID_DATA_LEN;
}
-const char *duid_type_to_string(DUIDType t) _const_;
+const char* duid_type_to_string(DUIDType t) _const_;
int dhcp_duid_to_string_internal(uint16_t type, const void *data, size_t data_size, char **ret);
int dhcp_identifier_set_iaid(
DHCP6_FQDN_FLAG_N = 1 << 2,
} DHCP6FQDNFlag;
-const char *dhcp6_state_to_string(DHCP6State s) _const_;
-const char *dhcp6_message_type_to_string(DHCP6MessageType s) _const_;
+const char* dhcp6_state_to_string(DHCP6State s) _const_;
+const char* dhcp6_message_type_to_string(DHCP6MessageType s) _const_;
DHCP6MessageType dhcp6_message_type_from_string(const char *s) _pure_;
-const char *dhcp6_message_status_to_string(DHCP6Status s) _const_;
+const char* dhcp6_message_status_to_string(DHCP6Status s) _const_;
DHCP6Status dhcp6_message_status_from_string(const char *s) _pure_;
int dhcp6_message_status_to_errno(DHCP6Status s);
return 0;
}
-const char *bus_message_type_to_string(uint8_t u) {
+const char* bus_message_type_to_string(uint8_t u) {
if (u == SD_BUS_MESSAGE_SIGNAL)
return "signal";
else if (u == SD_BUS_MESSAGE_METHOD_CALL)
bool path_simple_pattern(const char *pattern, const char *value) _pure_;
int bus_message_type_from_string(const char *s, uint8_t *u);
-const char *bus_message_type_to_string(uint8_t u) _pure_;
+const char* bus_message_type_to_string(uint8_t u) _pure_;
#define error_name_is_valid interface_name_is_valid
int device_set_action(sd_device *device, sd_device_action_t a);
sd_device_action_t device_action_from_string(const char *s) _pure_;
-const char *device_action_to_string(sd_device_action_t a) _const_;
+const char* device_action_to_string(sd_device_action_t a) _const_;
void dump_device_action_table(void);
#include "alloc-util.h"
#include "macro.h"
-const char *audit_type_to_string(int type);
+const char* audit_type_to_string(int type);
int audit_type_from_string(const char *s);
/* This is inspired by DNS TYPEnnn formatting */
free(array);
}
-_public_ const char *sd_json_variant_string(sd_json_variant *v) {
+_public_ const char* sd_json_variant_string(sd_json_variant *v) {
if (!v)
return NULL;
if (v == JSON_VARIANT_MAGIC_EMPTY_STRING)
struct udev_list_entry;
struct udev_list_entry *udev_list_entry_get_next(struct udev_list_entry *list_entry);
struct udev_list_entry *udev_list_entry_get_by_name(struct udev_list_entry *list_entry, const char *name);
-const char *udev_list_entry_get_name(struct udev_list_entry *list_entry);
-const char *udev_list_entry_get_value(struct udev_list_entry *list_entry);
+const char* udev_list_entry_get_name(struct udev_list_entry *list_entry);
+const char* udev_list_entry_get_value(struct udev_list_entry *list_entry);
/**
* udev_list_entry_foreach:
* @list_entry: entry to store the current position
struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device,
const char *subsystem, const char *devtype);
/* retrieve device properties */
-const char *udev_device_get_devpath(struct udev_device *udev_device);
-const char *udev_device_get_subsystem(struct udev_device *udev_device);
-const char *udev_device_get_devtype(struct udev_device *udev_device);
-const char *udev_device_get_syspath(struct udev_device *udev_device);
-const char *udev_device_get_sysname(struct udev_device *udev_device);
-const char *udev_device_get_sysnum(struct udev_device *udev_device);
-const char *udev_device_get_devnode(struct udev_device *udev_device);
+const char* udev_device_get_devpath(struct udev_device *udev_device);
+const char* udev_device_get_subsystem(struct udev_device *udev_device);
+const char* udev_device_get_devtype(struct udev_device *udev_device);
+const char* udev_device_get_syspath(struct udev_device *udev_device);
+const char* udev_device_get_sysname(struct udev_device *udev_device);
+const char* udev_device_get_sysnum(struct udev_device *udev_device);
+const char* udev_device_get_devnode(struct udev_device *udev_device);
int udev_device_get_is_initialized(struct udev_device *udev_device);
struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device);
struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device);
struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device);
struct udev_list_entry *udev_device_get_current_tags_list_entry(struct udev_device *udev_device);
struct udev_list_entry *udev_device_get_sysattr_list_entry(struct udev_device *udev_device);
-const char *udev_device_get_property_value(struct udev_device *udev_device, const char *key);
-const char *udev_device_get_driver(struct udev_device *udev_device);
+const char* udev_device_get_property_value(struct udev_device *udev_device, const char *key);
+const char* udev_device_get_driver(struct udev_device *udev_device);
dev_t udev_device_get_devnum(struct udev_device *udev_device);
-const char *udev_device_get_action(struct udev_device *udev_device);
+const char* udev_device_get_action(struct udev_device *udev_device);
unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device);
unsigned long long int udev_device_get_usec_since_initialized(struct udev_device *udev_device);
-const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr);
+const char* udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr);
int udev_device_set_sysattr_value(struct udev_device *udev_device, const char *sysattr, const char *value);
int udev_device_has_tag(struct udev_device *udev_device, const char *tag);
int udev_device_has_current_tag(struct udev_device *udev_device, const char *tag);
return inhibited;
}
-const char *inhibit_what_to_string(InhibitWhat w) {
+const char* inhibit_what_to_string(InhibitWhat w) {
static thread_local char buffer[STRLEN(
"shutdown:"
"sleep:"
return w > 0 && w < _INHIBIT_WHAT_MAX;
}
-const char *inhibit_what_to_string(InhibitWhat k);
+const char* inhibit_what_to_string(InhibitWhat k);
int inhibit_what_from_string(const char *s);
-const char *inhibit_mode_to_string(InhibitMode k);
+const char* inhibit_mode_to_string(InhibitMode k);
InhibitMode inhibit_mode_from_string(const char *s);
const char* session_class_to_string(SessionClass t) _const_;
SessionClass session_class_from_string(const char *s) _pure_;
-const char *kill_whom_to_string(KillWhom k) _const_;
+const char* kill_whom_to_string(KillWhom k) _const_;
KillWhom kill_whom_from_string(const char *s) _pure_;
const char* tty_validity_to_string(TTYValidity t) _const_;
const char* machine_state_to_string(MachineState t) _const_;
MachineState machine_state_from_string(const char *s) _pure_;
-const char *kill_whom_to_string(KillWhom k) _const_;
+const char* kill_whom_to_string(KillWhom k) _const_;
KillWhom kill_whom_from_string(const char *s) _pure_;
int machine_openpt(Machine *m, int flags, char **ret_slave);
DEFINE_NETDEV_CAST(BAREUDP, BareUDP);
extern const NetDevVTable bare_udp_vtable;
-const char *bare_udp_protocol_to_string(BareUDPProtocol d) _const_;
+const char* bare_udp_protocol_to_string(BareUDPProtocol d) _const_;
BareUDPProtocol bare_udp_protocol_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_bare_udp_iftype);
DEFINE_NETDEV_CAST(FOU, FouTunnel);
extern const NetDevVTable foutnl_vtable;
-const char *fou_encap_type_to_string(FooOverUDPEncapType d) _const_;
+const char* fou_encap_type_to_string(FooOverUDPEncapType d) _const_;
FooOverUDPEncapType fou_encap_type_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_fou_encap_type);
DEFINE_NETDEV_CAST(GENEVE, Geneve);
extern const NetDevVTable geneve_vtable;
-const char *geneve_df_to_string(GeneveDF d) _const_;
+const char* geneve_df_to_string(GeneveDF d) _const_;
GeneveDF geneve_df_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_geneve_vni);
_NETDEV_LOCAL_ADDRESS_TYPE_INVALID = -EINVAL,
} NetDevLocalAddressType;
-const char *netdev_local_address_type_to_string(NetDevLocalAddressType t) _const_;
+const char* netdev_local_address_type_to_string(NetDevLocalAddressType t) _const_;
NetDevLocalAddressType netdev_local_address_type_from_string(const char *s) _pure_;
int link_get_local_address(
int link_request_stacked_netdev(Link *link, NetDev *netdev);
-const char *netdev_kind_to_string(NetDevKind d) _const_;
+const char* netdev_kind_to_string(NetDevKind d) _const_;
NetDevKind netdev_kind_from_string(const char *d) _pure_;
static inline NetDevCreateType netdev_get_create_type(NetDev *netdev) {
extern const NetDevVTable ip6tnl_vtable;
extern const NetDevVTable erspan_vtable;
-const char *ip6tnl_mode_to_string(Ip6TnlMode d) _const_;
+const char* ip6tnl_mode_to_string(Ip6TnlMode d) _const_;
Ip6TnlMode ip6tnl_mode_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_ip6tnl_mode);
DEFINE_NETDEV_CAST(VXLAN, VxLan);
extern const NetDevVTable vxlan_vtable;
-const char *df_to_string(VxLanDF d) _const_;
+const char* df_to_string(VxLanDF d) _const_;
VxLanDF df_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_vxlan_address);
int link_get_captive_portal(Link *link, const char **ret);
-const char *dhcp_option_data_type_to_string(DHCPOptionDataType d) _const_;
+const char* dhcp_option_data_type_to_string(DHCPOptionDataType d) _const_;
DHCPOptionDataType dhcp_option_data_type_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp);
int manager_rtnl_process_link(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
int link_flags_to_string_alloc(uint32_t flags, char **ret);
-const char *kernel_operstate_to_string(int t) _const_;
+const char* kernel_operstate_to_string(int t) _const_;
void link_required_operstate_for_online(Link *link, LinkOperationalStateRange *ret);
AddressFamily link_required_family_for_online(Link *link);
Address **ret);
int route_type_from_string(const char *s) _pure_;
-const char *route_type_to_string(int t) _const_;
+const char* route_type_to_string(int t) _const_;
int route_scope_from_string(const char *s);
int route_scope_to_string_alloc(int t, char **ret);
int32_t suppress_ifgroup;
} RoutingPolicyRule;
-const char *fr_act_type_full_to_string(int t) _const_;
+const char* fr_act_type_full_to_string(int t) _const_;
RoutingPolicyRule *routing_policy_rule_free(RoutingPolicyRule *rule);
CONFIG_PARSER_PROTOTYPE(config_parse_ip_masquerade);
CONFIG_PARSER_PROTOTYPE(config_parse_mud_url);
-const char *network_config_source_to_string(NetworkConfigSource s) _const_;
+const char* network_config_source_to_string(NetworkConfigSource s) _const_;
int network_config_state_to_string_alloc(NetworkConfigState s, char **ret);
0); \
}
-const char *address_family_to_string(AddressFamily b) _const_;
+const char* address_family_to_string(AddressFamily b) _const_;
AddressFamily address_family_from_string(const char *s) _pure_;
AddressFamily link_local_address_family_from_string(const char *s) _pure_;
-const char *routing_policy_rule_address_family_to_string(AddressFamily b) _const_;
+const char* routing_policy_rule_address_family_to_string(AddressFamily b) _const_;
AddressFamily routing_policy_rule_address_family_from_string(const char *s) _pure_;
-const char *nexthop_address_family_to_string(AddressFamily b) _const_;
+const char* nexthop_address_family_to_string(AddressFamily b) _const_;
AddressFamily nexthop_address_family_from_string(const char *s) _pure_;
-const char *duplicate_address_detection_address_family_to_string(AddressFamily b) _const_;
+const char* duplicate_address_detection_address_family_to_string(AddressFamily b) _const_;
AddressFamily duplicate_address_detection_address_family_from_string(const char *s) _pure_;
AddressFamily dhcp_deprecated_address_family_from_string(const char *s) _pure_;
-const char *dhcp_lease_server_type_to_string(sd_dhcp_lease_server_type_t t) _const_;
+const char* dhcp_lease_server_type_to_string(sd_dhcp_lease_server_type_t t) _const_;
sd_dhcp_lease_server_type_t dhcp_lease_server_type_from_string(const char *s) _pure_;
int log_link_message_full_errno(Link *link, sd_netlink_message *m, int level, int err, const char *msg);
CONFIG_PARSER_PROTOTYPE(config_parse_userns_ownership);
CONFIG_PARSER_PROTOTYPE(config_parse_bind_user);
-const char *resolv_conf_mode_to_string(ResolvConfMode a) _const_;
+const char* resolv_conf_mode_to_string(ResolvConfMode a) _const_;
ResolvConfMode resolv_conf_mode_from_string(const char *s) _pure_;
-const char *timezone_mode_to_string(TimezoneMode a) _const_;
+const char* timezone_mode_to_string(TimezoneMode a) _const_;
TimezoneMode timezone_mode_from_string(const char *s) _pure_;
-const char *user_namespace_ownership_to_string(UserNamespaceOwnership a) _const_;
+const char* user_namespace_ownership_to_string(UserNamespaceOwnership a) _const_;
UserNamespaceOwnership user_namespace_ownership_from_string(const char *s) _pure_;
int parse_link_journal(const char *s, LinkJournal *ret_mode, bool *ret_try);
void portable_changes_free(PortableChange *changes, size_t n_changes);
-const char *portable_change_type_to_string(int t) _const_;
+const char* portable_change_type_to_string(int t) _const_;
int portable_change_type_from_string(const char *t) _pure_;
-const char *portable_state_to_string(PortableState t) _const_;
+const char* portable_state_to_string(PortableState t) _const_;
PortableState portable_state_from_string(const char *t) _pure_;
}
}
-const char *dns_class_to_string(uint16_t class) {
+const char* dns_class_to_string(uint16_t class) {
switch (class) {
bool dns_class_is_valid_rr(uint16_t class);
/* TYPE?? follows http://tools.ietf.org/html/rfc3597#section-5 */
-const char *dns_type_to_string(int type);
+const char* dns_type_to_string(int type);
int dns_type_from_string(const char *s);
-const char *dns_class_to_string(uint16_t class);
+const char* dns_class_to_string(uint16_t class);
int dns_class_from_string(const char *name);
/* https://tools.ietf.org/html/draft-ietf-dane-protocol-23#section-7.2 */
-const char *tlsa_cert_usage_to_string(uint8_t cert_usage);
+const char* tlsa_cert_usage_to_string(uint8_t cert_usage);
/* https://tools.ietf.org/html/draft-ietf-dane-protocol-23#section-7.3 */
-const char *tlsa_selector_to_string(uint8_t selector);
+const char* tlsa_selector_to_string(uint8_t selector);
/* https://tools.ietf.org/html/draft-ietf-dane-protocol-23#section-7.4 */
-const char *tlsa_matching_type_to_string(uint8_t selector);
+const char* tlsa_matching_type_to_string(uint8_t selector);
/* https://tools.ietf.org/html/rfc6844#section-5.1 */
#define CAA_FLAG_CRITICAL (1u << 7)
};
DEFINE_STRING_TABLE_LOOKUP(dns_rcode, int);
-const char *format_dns_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]) {
+const char* format_dns_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]) {
const char *p = dns_rcode_to_string(i);
if (p)
return p;
};
DEFINE_STRING_TABLE_LOOKUP_TO_STRING(dns_ede_rcode, int);
-const char *format_dns_ede_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]) {
+const char* format_dns_ede_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]) {
const char *p = dns_ede_rcode_to_string(i);
if (p)
return p;
};
DEFINE_STRING_TABLE_LOOKUP_TO_STRING(dns_svc_param_key, int);
-const char *format_dns_svc_param_key(uint16_t i, char buf[static DECIMAL_STR_MAX(uint16_t)+3]) {
+const char* format_dns_svc_param_key(uint16_t i, char buf[static DECIMAL_STR_MAX(uint16_t)+3]) {
const char *p = dns_svc_param_key_to_string(i);
if (p)
return p;
const char* dns_rcode_to_string(int i) _const_;
int dns_rcode_from_string(const char *s) _pure_;
-const char *format_dns_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]);
+const char* format_dns_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]);
#define FORMAT_DNS_RCODE(i) format_dns_rcode(i, (char [DECIMAL_STR_MAX(int)]) {})
const char* dns_ede_rcode_to_string(int i) _const_;
-const char *format_dns_ede_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]);
+const char* format_dns_ede_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]);
#define FORMAT_DNS_EDE_RCODE(i) format_dns_ede_rcode(i, (char [DECIMAL_STR_MAX(int)]) {})
const char* dns_protocol_to_string(DnsProtocol p) _const_;
};
const char* dns_svc_param_key_to_string(int i) _const_;
-const char *format_dns_svc_param_key(uint16_t i, char buf[static DECIMAL_STR_MAX(uint16_t)+3]);
+const char* format_dns_svc_param_key(uint16_t i, char buf[static DECIMAL_STR_MAX(uint16_t)+3]);
#define FORMAT_DNS_SVC_PARAM_KEY(i) format_dns_svc_param_key(i, (char [DECIMAL_STR_MAX(uint16_t)+3]) {})
#define LLMNR_MULTICAST_IPV4_ADDRESS ((struct in_addr) { .s_addr = htobe32(224U << 24 | 252U) })
}
}
-const char *dns_query_string(DnsQuery *q) {
+const char* dns_query_string(DnsQuery *q) {
const char *name;
int r;
DnsQuestion* dns_query_question_for_protocol(DnsQuery *q, DnsProtocol protocol);
-const char *dns_query_string(DnsQuery *q);
+const char* dns_query_string(DnsQuery *q);
DEFINE_TRIVIAL_CLEANUP_FUNC(DnsQuery*, dns_query_free);
return 1;
}
-const char *dns_question_first_name(DnsQuestion *q) {
+const char* dns_question_first_name(DnsQuestion *q) {
if (!q)
return NULL;
void dns_question_dump(DnsQuestion *q, FILE *f);
-const char *dns_question_first_name(DnsQuestion *q);
+const char* dns_question_first_name(DnsQuestion *q);
static inline DnsResourceKey *dns_question_first_key(DnsQuestion *q) {
return (q && q->n_keys > 0) ? q->items[0].key : NULL;
return strv_join(params, " ");
}
-const char *dns_resource_record_to_string(DnsResourceRecord *rr) {
+const char* dns_resource_record_to_string(DnsResourceRecord *rr) {
_cleanup_free_ char *s = NULL, *t = NULL;
char k[DNS_RESOURCE_KEY_STRING_MAX];
int r;
return 53;
}
-const char *dns_server_string(DnsServer *server) {
+const char* dns_server_string(DnsServer *server) {
assert(server);
if (!server->server_string)
return server->server_string;
}
-const char *dns_server_string_full(DnsServer *server) {
+const char* dns_server_string_full(DnsServer *server) {
assert(server);
if (!server->server_string_full)
int dns_server_adjust_opt(DnsServer *server, DnsPacket *packet, DnsServerFeatureLevel level);
-const char *dns_server_string(DnsServer *server);
-const char *dns_server_string_full(DnsServer *server);
+const char* dns_server_string(DnsServer *server);
+const char* dns_server_string_full(DnsServer *server);
int dns_server_ifindex(const DnsServer *s);
uint16_t dns_server_port(const DnsServer *s);
_NETDEV_BOND_PRIMARY_RESELECT_INVALID = -EINVAL,
} BondPrimaryReselect;
-const char *bond_mode_to_string(BondMode d) _const_;
+const char* bond_mode_to_string(BondMode d) _const_;
BondMode bond_mode_from_string(const char *d) _pure_;
-const char *bond_xmit_hash_policy_to_string(BondXmitHashPolicy d) _const_;
+const char* bond_xmit_hash_policy_to_string(BondXmitHashPolicy d) _const_;
BondXmitHashPolicy bond_xmit_hash_policy_from_string(const char *d) _pure_;
-const char *bond_lacp_rate_to_string(BondLacpRate d) _const_;
+const char* bond_lacp_rate_to_string(BondLacpRate d) _const_;
BondLacpRate bond_lacp_rate_from_string(const char *d) _pure_;
-const char *bond_fail_over_mac_to_string(BondFailOverMac d) _const_;
+const char* bond_fail_over_mac_to_string(BondFailOverMac d) _const_;
BondFailOverMac bond_fail_over_mac_from_string(const char *d) _pure_;
-const char *bond_ad_select_to_string(BondAdSelect d) _const_;
+const char* bond_ad_select_to_string(BondAdSelect d) _const_;
BondAdSelect bond_ad_select_from_string(const char *d) _pure_;
-const char *bond_arp_validate_to_string(BondArpValidate d) _const_;
+const char* bond_arp_validate_to_string(BondArpValidate d) _const_;
BondArpValidate bond_arp_validate_from_string(const char *d) _pure_;
-const char *bond_arp_all_targets_to_string(BondArpAllTargets d) _const_;
+const char* bond_arp_all_targets_to_string(BondArpAllTargets d) _const_;
BondArpAllTargets bond_arp_all_targets_from_string(const char *d) _pure_;
-const char *bond_primary_reselect_to_string(BondPrimaryReselect d) _const_;
+const char* bond_primary_reselect_to_string(BondPrimaryReselect d) _const_;
BondPrimaryReselect bond_primary_reselect_from_string(const char *d) _pure_;
int bpf_map_lookup_element(int fd, const void *key, void *value);
int bpf_cgroup_attach_type_from_string(const char *str) _pure_;
-const char *bpf_cgroup_attach_type_to_string(int attach_type) _const_;
+const char* bpf_cgroup_attach_type_to_string(int attach_type) _const_;
DEFINE_TRIVIAL_CLEANUP_FUNC(BPFProgram*, bpf_program_free);
_NETDEV_BRIDGE_STATE_INVALID = -EINVAL,
} BridgeState;
-const char *bridge_state_to_string(BridgeState d) _const_;
+const char* bridge_state_to_string(BridgeState d) _const_;
BridgeState bridge_state_from_string(const char *d) _pure_;
/* Do this only on new enough compilers that actually support the "symver" attribute. Given this is a debug
* feature, let's simply not bother on older compilers */
#if BUILD_MODE_DEVELOPER && defined(__has_attribute) && __has_attribute(symver)
-const char *my_crypt_token_external_path(void); /* prototype for our own implementation */
+const char* my_crypt_token_external_path(void); /* prototype for our own implementation */
/* We use the "symver" attribute to mark this implementation as the default implementation, and drop the
* SD_SHARED namespace we by default attach to our symbols via a version script. */
int cryptsetup_get_keyslot_from_token(sd_json_variant *v);
-static inline const char *mangle_none(const char *s) {
+static inline const char* mangle_none(const char *s) {
/* A helper that turns cryptsetup/integritysetup/veritysetup "options" strings into NULL if they are effectively empty */
return isempty(s) || STR_IN_SET(s, "-", "none") ? NULL : s;
}
int image_to_json(const struct Image *i, sd_json_variant **ret);
-const char *image_root_to_string(ImageClass c) _const_;
+const char* image_root_to_string(ImageClass c) _const_;
extern const struct hash_ops image_hash_ops;
int partition_pick_mount_options(PartitionDesignator d, const char *fstype, bool rw, bool discard, char **ret_options, unsigned long *ret_ms_flags);
-static inline const char *dissected_partition_fstype(const DissectedPartition *m) {
+static inline const char* dissected_partition_fstype(const DissectedPartition *m) {
assert(m);
return m->decrypted_node ? m->decrypted_fstype : m->fstype;
int ethtool_set_flow_control(int *fd, const char *ifname, int rx, int tx, int autoneg);
int ethtool_set_nic_coalesce_settings(int *ethtool_fd, const char *ifname, const netdev_coalesce_param *coalesce);
-const char *duplex_to_string(Duplex d) _const_;
+const char* duplex_to_string(Duplex d) _const_;
Duplex duplex_from_string(const char *d) _pure_;
int wol_options_to_string_alloc(uint32_t opts, char **ret);
-const char *port_to_string(NetDevPort port) _const_;
+const char* port_to_string(NetDevPort port) _const_;
NetDevPort port_from_string(const char *port) _pure_;
-const char *mdi_to_string(int mdi) _const_;
+const char* mdi_to_string(int mdi) _const_;
-const char *ethtool_link_mode_bit_to_string(enum ethtool_link_mode_bit_indices val) _const_;
+const char* ethtool_link_mode_bit_to_string(enum ethtool_link_mode_bit_indices val) _const_;
enum ethtool_link_mode_bit_indices ethtool_link_mode_bit_from_string(const char *str) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_duplex);
sd_netlink *nfnl;
};
-const char *firewall_backend_to_string(FirewallBackend b) _const_;
+const char* firewall_backend_to_string(FirewallBackend b) _const_;
int fw_nftables_init(FirewallContext *ctx);
int fw_nftables_init_full(FirewallContext *ctx, bool init_tables);
void nft_set_context_clear(NFTSetContext *s);
int nft_set_context_dup(const NFTSetContext *src, NFTSetContext *dst);
-const char *nfproto_to_string(int i) _const_;
+const char* nfproto_to_string(int i) _const_;
int nfproto_from_string(const char *s) _pure_;
-const char *nft_set_source_to_string(int i) _const_;
+const char* nft_set_source_to_string(int i) _const_;
int nft_set_source_from_string(const char *s) _pure_;
int nft_set_element_modify_iprange(
_NETDEV_GENEVE_DF_INVALID = -EINVAL,
} GeneveDF;
-const char *geneve_df_to_string(GeneveDF d) _const_;
+const char* geneve_df_to_string(GeneveDF d) _const_;
GeneveDF geneve_df_from_string(const char *d) _pure_;
return NULL;
}
-const char *gpt_partition_type_uuid_to_string(sd_id128_t id) {
+const char* gpt_partition_type_uuid_to_string(sd_id128_t id) {
const GptPartitionType *pt;
pt = gpt_partition_type_find_by_uuid(id);
return pt->name;
}
-const char *gpt_partition_type_uuid_to_string_harder(
+const char* gpt_partition_type_uuid_to_string_harder(
sd_id128_t id,
char buffer[static SD_ID128_UUID_STRING_MAX]) {
};
}
-const char *gpt_partition_type_mountpoint_nulstr(GptPartitionType type) {
+const char* gpt_partition_type_mountpoint_nulstr(GptPartitionType type) {
return partition_mountpoint_to_string(type.designator);
}
const char* partition_designator_to_string(PartitionDesignator d) _const_;
PartitionDesignator partition_designator_from_string(const char *name) _pure_;
-const char *gpt_partition_type_uuid_to_string(sd_id128_t id);
-const char *gpt_partition_type_uuid_to_string_harder(
+const char* gpt_partition_type_uuid_to_string(sd_id128_t id);
+const char* gpt_partition_type_uuid_to_string_harder(
sd_id128_t id,
char buffer[static SD_ID128_UUID_STRING_MAX]);
GptPartitionType gpt_partition_type_override_architecture(GptPartitionType type, Architecture arch);
-const char *gpt_partition_type_mountpoint_nulstr(GptPartitionType type);
+const char* gpt_partition_type_mountpoint_nulstr(GptPartitionType type);
bool gpt_partition_type_knows_read_only(GptPartitionType type);
bool gpt_partition_type_knows_growfs(GptPartitionType type);
return 0;
}
-const char *group_record_group_name_and_realm(GroupRecord *h) {
+const char* group_record_group_name_and_realm(GroupRecord *h) {
assert(h);
/* Return the pre-initialized joined string if it is defined */
int group_record_build(GroupRecord **ret, ...);
int group_record_clone(GroupRecord *g, UserRecordLoadFlags flags, GroupRecord **ret);
-const char *group_record_group_name_and_realm(GroupRecord *h);
+const char* group_record_group_name_and_realm(GroupRecord *h);
UserDisposition group_record_disposition(GroupRecord *h);
_PRESET_ACTION_ERRNO_MAX = -ERRNO_MAX, /* Ensure this type covers the whole negative errno range */
} PresetAction;
-const char *preset_action_past_tense_to_string(PresetAction action);
+const char* preset_action_past_tense_to_string(PresetAction action);
void unit_file_presets_done(UnitFilePresets *p);
PresetAction unit_file_query_preset(RuntimeScope scope, const char *root_dir, const char *name, UnitFilePresets *cached);
-const char *unit_file_state_to_string(UnitFileState s) _const_;
+const char* unit_file_state_to_string(UnitFileState s) _const_;
UnitFileState unit_file_state_from_string(const char *s) _pure_;
/* from_string conversion is unreliable because of the overlap between -EPERM and -1 for error. */
-const char *install_change_type_to_string(InstallChangeType t) _const_;
+const char* install_change_type_to_string(InstallChangeType t) _const_;
InstallChangeType install_change_type_from_string(const char *s) _pure_;
-const char *unit_file_preset_mode_to_string(UnitFilePresetMode m) _const_;
+const char* unit_file_preset_mode_to_string(UnitFilePresetMode m) _const_;
UnitFilePresetMode unit_file_preset_mode_from_string(const char *s) _pure_;
#include "ip-protocol-from-name.h"
#include "ip-protocol-to-name.h"
-const char *ip_protocol_to_name(int id) {
+const char* ip_protocol_to_name(int id) {
if (id < 0)
return NULL;
return p;
}
-const char *ip_protocol_to_tcp_udp(int id) {
+const char* ip_protocol_to_tcp_udp(int id) {
return IN_SET(id, IPPROTO_TCP, IPPROTO_UDP) ?
ip_protocol_to_name(id) : NULL;
}
#include <stdbool.h>
-const char *ip_protocol_to_name(int id);
+const char* ip_protocol_to_name(int id);
int ip_protocol_from_name(const char *name);
int parse_ip_protocol_full(const char *s, bool relaxed);
static inline int parse_ip_protocol(const char *s) {
return parse_ip_protocol_full(s, false);
}
-const char *ip_protocol_to_tcp_udp(int id);
+const char* ip_protocol_to_tcp_udp(int id);
int ip_protocol_from_tcp_udp(const char *ip_protocol);
_NETDEV_IPVLAN_FLAGS_INVALID = -EINVAL,
} IPVlanFlags;
-const char *ipvlan_mode_to_string(IPVlanMode d) _const_;
+const char* ipvlan_mode_to_string(IPVlanMode d) _const_;
IPVlanMode ipvlan_mode_from_string(const char *d) _pure_;
-const char *ipvlan_flags_to_string(IPVlanFlags d) _const_;
+const char* ipvlan_flags_to_string(IPVlanFlags d) _const_;
IPVlanFlags ipvlan_flags_from_string(const char *d) _pure_;
_NETDEV_MACVLAN_MODE_INVALID = -EINVAL,
} MacVlanMode;
-const char *macvlan_mode_to_string(MacVlanMode d) _const_;
+const char* macvlan_mode_to_string(MacVlanMode d) _const_;
MacVlanMode macvlan_mode_from_string(const char *d) _pure_;
_NAMEPOLICY_INVALID = -EINVAL,
} NamePolicy;
-const char *name_policy_to_string(NamePolicy p) _const_;
+const char* name_policy_to_string(NamePolicy p) _const_;
NamePolicy name_policy_from_string(const char *p) _pure_;
-const char *alternative_names_policy_to_string(NamePolicy p) _const_;
+const char* alternative_names_policy_to_string(NamePolicy p) _const_;
NamePolicy alternative_names_policy_from_string(const char *p) _pure_;
int device_get_sysattr_int_filtered(sd_device *device, const char *sysattr, int *ret_value);
return 0;
}
-const char *net_get_persistent_name(sd_device *device) {
+const char* net_get_persistent_name(sd_device *device) {
assert(device);
/* fetch some persistent data unique (on this machine) to this device */
bool netif_has_carrier(uint8_t operstate, unsigned flags);
int net_get_type_string(sd_device *device, uint16_t iftype, char **ret);
-const char *net_get_persistent_name(sd_device *device);
+const char* net_get_persistent_name(sd_device *device);
int net_get_unique_predictable_data(sd_device *device, bool use_sysname, uint64_t *ret);
int net_get_unique_predictable_data_from_name(const char *name, const sd_id128_t *key, uint64_t *ret);
int net_verify_hardware_address(
return 0;
}
-const char *namespace_single_flag_to_string(unsigned long flag) {
+const char* namespace_single_flag_to_string(unsigned long flag) {
for (unsigned i = 0; namespace_info[i].proc_name; i++)
if (namespace_info[i].clone_flag == flag)
return namespace_info[i].proc_name;
int namespace_flags_from_string(const char *name, unsigned long *ret);
int namespace_flags_to_string(unsigned long flags, char **ret);
-const char *namespace_single_flag_to_string(unsigned long flag);
+const char* namespace_single_flag_to_string(unsigned long flag);
#define RED_CROSS_MARK_MAX (STRLEN(ANSI_HIGHLIGHT_RED) + STRLEN("✗") + STRLEN(ANSI_NORMAL) + 1)
#define GREEN_CHECK_MARK_MAX (STRLEN(ANSI_HIGHLIGHT_GREEN) + STRLEN("✓") + STRLEN(ANSI_NORMAL) + 1)
-static inline const char *red_cross_mark_internal(char buffer[static RED_CROSS_MARK_MAX]) {
+static inline const char* red_cross_mark_internal(char buffer[static RED_CROSS_MARK_MAX]) {
assert(buffer);
assert_se(stpcpy(stpcpy(stpcpy(buffer, ansi_highlight_red()), special_glyph(SPECIAL_GLYPH_CROSS_MARK)), ansi_normal()) < buffer + RED_CROSS_MARK_MAX);
return buffer;
}
-static inline const char *green_check_mark_internal(char buffer[static GREEN_CHECK_MARK_MAX]) {
+static inline const char* green_check_mark_internal(char buffer[static GREEN_CHECK_MARK_MAX]) {
assert(buffer);
assert_se(stpcpy(stpcpy(stpcpy(buffer, ansi_highlight_green()), special_glyph(SPECIAL_GLYPH_CHECK_MARK)), ansi_normal()) < buffer + GREEN_CHECK_MARK_MAX);
return buffer;
return parse_errno(p);
}
-static inline const char *seccomp_errno_or_action_to_string(int num) {
+static inline const char* seccomp_errno_or_action_to_string(int num) {
if (num == SECCOMP_ERROR_NUMBER_KILL)
return "kill";
return errno_to_name(num);
return in_addr_full_new(family, &a, port, ifindex, server_name, ret);
}
-const char *in_addr_full_to_string(struct in_addr_full *a) {
+const char* in_addr_full_to_string(struct in_addr_full *a) {
assert(a);
if (!a->cached_server_string)
DEFINE_TRIVIAL_CLEANUP_FUNC(struct in_addr_full*, in_addr_full_free);
int in_addr_full_new(int family, const union in_addr_union *a, uint16_t port, int ifindex, const char *server_name, struct in_addr_full **ret);
int in_addr_full_new_from_string(const char *s, struct in_addr_full **ret);
-const char *in_addr_full_to_string(struct in_addr_full *a);
+const char* in_addr_full_to_string(struct in_addr_full *a);
int netns_get_nsid(int netnsfd, uint32_t *ret);
return enter_cgroup(ret_cgroup, false);
}
-const char *ci_environment(void) {
+const char* ci_environment(void) {
/* We return a string because we might want to provide multiple bits of information later on: not
* just the general CI environment type, but also whether we're sanitizing or not, etc. The caller is
* expected to use strstr on the returned value. */
}
/* Provide a convenient way to check if we're running in CI. */
-const char *ci_environment(void);
+const char* ci_environment(void);
typedef struct TestFunc {
union f {
return CMP(ASSERT_PTR(a)->event_type, ASSERT_PTR(b)->event_type);
}
-const char *tpm2_log_event_type_to_string(uint32_t type) {
+const char* tpm2_log_event_type_to_string(uint32_t type) {
tpm2_log_event_type_info *found, key = {
.event_type = type,
#define LOAD_OPTIONS_EVENT_TAG_ID UINT32_C(0x8F3B22ED)
#endif
-const char *tpm2_log_event_type_to_string(uint32_t type) _const_;
+const char* tpm2_log_event_type_to_string(uint32_t type) _const_;
#if HAVE_TPM2
DEFINE_STRING_TABLE_LOOKUP(tpm2_userspace_event_type, Tpm2UserspaceEventType);
-const char *tpm2_userspace_log_path(void) {
+const char* tpm2_userspace_log_path(void) {
return secure_getenv("SYSTEMD_MEASURE_LOG_USERSPACE") ?: "/run/log/systemd/tpm2-measure.log";
}
-const char *tpm2_firmware_log_path(void) {
+const char* tpm2_firmware_log_path(void) {
return secure_getenv("SYSTEMD_MEASURE_LOG_FIRMWARE") ?: "/sys/kernel/security/tpm0/binary_bios_measurements";
}
}
}
-const char *tpm2_hash_alg_to_string(uint16_t alg) {
+const char* tpm2_hash_alg_to_string(uint16_t alg) {
switch (alg) {
case TPM2_ALG_SHA1:
return "sha1";
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown hash algorithm name '%s'", alg);
}
-const char *tpm2_asym_alg_to_string(uint16_t alg) {
+const char* tpm2_asym_alg_to_string(uint16_t alg) {
switch (alg) {
case TPM2_ALG_ECC:
return "ecc";
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown asymmetric algorithm name '%s'", alg);
}
-const char *tpm2_sym_alg_to_string(uint16_t alg) {
+const char* tpm2_sym_alg_to_string(uint16_t alg) {
switch (alg) {
#if HAVE_TPM2
case TPM2_ALG_AES:
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown symmetric algorithm name '%s'", alg);
}
-const char *tpm2_sym_mode_to_string(uint16_t mode) {
+const char* tpm2_sym_mode_to_string(uint16_t mode) {
switch (mode) {
#if HAVE_TPM2
case TPM2_ALG_CTR:
int tpm2_get_good_pcr_banks_strv(Tpm2Context *c, uint32_t pcr_mask, char ***ret);
int tpm2_get_best_pcr_bank(Tpm2Context *c, uint32_t pcr_mask, TPMI_ALG_HASH *ret);
-const char *tpm2_userspace_log_path(void);
-const char *tpm2_firmware_log_path(void);
+const char* tpm2_userspace_log_path(void);
+const char* tpm2_firmware_log_path(void);
typedef enum Tpm2UserspaceEventType {
TPM2_EVENT_PHASE,
int tpm2_hash_alg_to_size(uint16_t alg);
-const char *tpm2_hash_alg_to_string(uint16_t alg) _const_;
+const char* tpm2_hash_alg_to_string(uint16_t alg) _const_;
int tpm2_hash_alg_from_string(const char *alg) _pure_;
-const char *tpm2_asym_alg_to_string(uint16_t alg) _const_;
+const char* tpm2_asym_alg_to_string(uint16_t alg) _const_;
int tpm2_asym_alg_from_string(const char *alg) _pure_;
-const char *tpm2_sym_alg_to_string(uint16_t alg) _const_;
+const char* tpm2_sym_alg_to_string(uint16_t alg) _const_;
int tpm2_sym_alg_from_string(const char *alg) _pure_;
-const char *tpm2_sym_mode_to_string(uint16_t mode) _const_;
+const char* tpm2_sym_mode_to_string(uint16_t mode) _const_;
int tpm2_sym_mode_from_string(const char *mode) _pure_;
char *tpm2_pcr_mask_to_string(uint32_t mask);
};
int tpm2_pcr_index_from_string(const char *s) _pure_;
-const char *tpm2_pcr_index_to_string(int pcr) _const_;
+const char* tpm2_pcr_index_to_string(int pcr) _const_;
/* The first and last NV index handle that is not registered to any company, as per TCG's "Registry of
* Reserved TPM 2.0 Handles and Localities", section 2.2.2. */
#include "user-util.h"
#include "userdb.h"
-const char *user_record_state_color(const char *state) {
+const char* user_record_state_color(const char *state) {
if (STR_IN_SET(state, "unfixated", "absent"))
return ansi_grey();
else if (streq(state, "active"))
#include "user-record.h"
#include "group-record.h"
-const char *user_record_state_color(const char *state);
+const char* user_record_state_color(const char *state);
void user_record_show(UserRecord *hr, bool show_full_group_info);
void group_record_show(GroupRecord *gr, bool show_full_user_info);
return 0;
}
-const char *user_record_user_name_and_realm(UserRecord *h) {
+const char* user_record_user_name_and_realm(UserRecord *h) {
assert(h);
/* Return the pre-initialized joined string if it is defined */
return USER_CLASSIC;
}
-const char *user_record_file_system_type(UserRecord *h) {
+const char* user_record_file_system_type(UserRecord *h) {
assert(h);
return h->file_system_type ?: "btrfs";
}
-const char *user_record_skeleton_directory(UserRecord *h) {
+const char* user_record_skeleton_directory(UserRecord *h) {
assert(h);
return h->skeleton_directory ?: "/etc/skel";
return user_record_home_directory_real(h);
}
-const char *user_record_image_path(UserRecord *h) {
+const char* user_record_image_path(UserRecord *h) {
assert(h);
if (h->image_path)
user_record_home_directory_real(h) : NULL;
}
-const char *user_record_cifs_user_name(UserRecord *h) {
+const char* user_record_cifs_user_name(UserRecord *h) {
assert(h);
return h->cifs_user_name ?: h->user_name;
return NOLOGIN;
}
-const char *user_record_shell(UserRecord *h) {
+const char* user_record_shell(UserRecord *h) {
const char *shell;
assert(h);
return shell;
}
-const char *user_record_real_name(UserRecord *h) {
+const char* user_record_real_name(UserRecord *h) {
assert(h);
return h->real_name ?: h->user_name;
return true;
}
-const char *user_record_luks_cipher(UserRecord *h) {
+const char* user_record_luks_cipher(UserRecord *h) {
assert(h);
return h->luks_cipher ?: "aes";
}
-const char *user_record_luks_cipher_mode(UserRecord *h) {
+const char* user_record_luks_cipher_mode(UserRecord *h) {
assert(h);
return h->luks_cipher_mode ?: "xts-plain64";
return CLAMP(UINT64_C(1) << (63 - __builtin_clzl(h->luks_sector_size)), 512U, 4096U);
}
-const char *user_record_luks_pbkdf_hash_algorithm(UserRecord *h) {
+const char* user_record_luks_pbkdf_hash_algorithm(UserRecord *h) {
assert(h);
return h->luks_pbkdf_hash_algorithm ?: "sha512";
int user_record_load(UserRecord *h, sd_json_variant *v, UserRecordLoadFlags flags);
int user_record_build(UserRecord **ret, ...);
-const char *user_record_user_name_and_realm(UserRecord *h);
+const char* user_record_user_name_and_realm(UserRecord *h);
UserStorage user_record_storage(UserRecord *h);
-const char *user_record_file_system_type(UserRecord *h);
-const char *user_record_skeleton_directory(UserRecord *h);
+const char* user_record_file_system_type(UserRecord *h);
+const char* user_record_skeleton_directory(UserRecord *h);
mode_t user_record_access_mode(UserRecord *h);
-const char *user_record_home_directory(UserRecord *h);
-const char *user_record_image_path(UserRecord *h);
+const char* user_record_home_directory(UserRecord *h);
+const char* user_record_image_path(UserRecord *h);
unsigned long user_record_mount_flags(UserRecord *h);
-const char *user_record_cifs_user_name(UserRecord *h);
-const char *user_record_shell(UserRecord *h);
-const char *user_record_real_name(UserRecord *h);
+const char* user_record_cifs_user_name(UserRecord *h);
+const char* user_record_shell(UserRecord *h);
+const char* user_record_real_name(UserRecord *h);
bool user_record_luks_discard(UserRecord *h);
bool user_record_luks_offline_discard(UserRecord *h);
-const char *user_record_luks_cipher(UserRecord *h);
-const char *user_record_luks_cipher_mode(UserRecord *h);
+const char* user_record_luks_cipher(UserRecord *h);
+const char* user_record_luks_cipher_mode(UserRecord *h);
uint64_t user_record_luks_volume_key_size(UserRecord *h);
const char* user_record_luks_pbkdf_type(UserRecord *h);
uint64_t user_record_luks_pbkdf_force_iterations(UserRecord *h);
uint64_t user_record_luks_pbkdf_memory_cost(UserRecord *h);
uint64_t user_record_luks_pbkdf_parallel_threads(UserRecord *h);
uint64_t user_record_luks_sector_size(UserRecord *h);
-const char *user_record_luks_pbkdf_hash_algorithm(UserRecord *h);
+const char* user_record_luks_pbkdf_hash_algorithm(UserRecord *h);
gid_t user_record_gid(UserRecord *h);
UserDisposition user_record_disposition(UserRecord *h);
int user_record_removable(UserRecord *h);
return r;
}
-const char *watchdog_get_device(void) {
+const char* watchdog_get_device(void) {
return watchdog_device;
}
#include "time-util.h"
-const char *watchdog_get_device(void);
+const char* watchdog_get_device(void);
usec_t watchdog_get_last_ping(clockid_t clock);
int watchdog_set_device(const char *path);
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);
-const char *nl80211_iftype_to_string(enum nl80211_iftype iftype) _const_;
+const char* nl80211_iftype_to_string(enum nl80211_iftype iftype) _const_;
enum nl80211_iftype nl80211_iftype_from_string(const char *s) _pure_;
-const char *nl80211_cmd_to_string(int cmd) _const_;
+const char* nl80211_cmd_to_string(int cmd) _const_;
int sd_device_get_usec_initialized(sd_device *device, uint64_t *ret);
int sd_device_get_usec_since_initialized(sd_device *device, uint64_t *ret);
-const char *sd_device_get_tag_first(sd_device *device);
-const char *sd_device_get_tag_next(sd_device *device);
-const char *sd_device_get_current_tag_first(sd_device *device);
-const char *sd_device_get_current_tag_next(sd_device *device);
-const char *sd_device_get_devlink_first(sd_device *device);
-const char *sd_device_get_devlink_next(sd_device *device);
-const char *sd_device_get_property_first(sd_device *device, const char **value);
-const char *sd_device_get_property_next(sd_device *device, const char **value);
-const char *sd_device_get_sysattr_first(sd_device *device);
-const char *sd_device_get_sysattr_next(sd_device *device);
+const char* sd_device_get_tag_first(sd_device *device);
+const char* sd_device_get_tag_next(sd_device *device);
+const char* sd_device_get_current_tag_first(sd_device *device);
+const char* sd_device_get_current_tag_next(sd_device *device);
+const char* sd_device_get_devlink_first(sd_device *device);
+const char* sd_device_get_devlink_next(sd_device *device);
+const char* sd_device_get_property_first(sd_device *device, const char **value);
+const char* sd_device_get_property_next(sd_device *device, const char **value);
+const char* sd_device_get_sysattr_first(sd_device *device);
+const char* sd_device_get_sysattr_next(sd_device *device);
sd_device *sd_device_get_child_first(sd_device *device, const char **ret_suffix);
sd_device *sd_device_get_child_next(sd_device *device, const char **ret_suffix);
int resource_resolve_path(Resource *rr, const char *root, const char *node);
ResourceType resource_type_from_string(const char *s) _pure_;
-const char *resource_type_to_string(ResourceType t) _const_;
+const char* resource_type_to_string(ResourceType t) _const_;
PathRelativeTo path_relative_to_from_string(const char *s) _pure_;
-const char *path_relative_to_to_string(PathRelativeTo r) _const_;
+const char* path_relative_to_to_string(PathRelativeTo r) _const_;
return -strverscmp_improved((*a)->version, (*b)->version);
}
-const char *update_set_flags_to_color(UpdateSetFlags flags) {
+const char* update_set_flags_to_color(UpdateSetFlags flags) {
if (flags == 0 || (flags & UPDATE_OBSOLETE))
return (flags & UPDATE_NEWEST) ? ansi_highlight_grey() : ansi_grey();
return NULL;
}
-const char *update_set_flags_to_glyph(UpdateSetFlags flags) {
+const char* update_set_flags_to_glyph(UpdateSetFlags flags) {
if (flags == 0 || (flags & UPDATE_OBSOLETE))
return special_glyph(SPECIAL_GLYPH_MULTIPLICATION_SIGN);
int update_set_cmp(UpdateSet *const*a, UpdateSet *const*b);
-const char *update_set_flags_to_color(UpdateSetFlags flags);
-const char *update_set_flags_to_glyph(UpdateSetFlags flags);
+const char* update_set_flags_to_color(UpdateSetFlags flags);
+const char* update_set_flags_to_glyph(UpdateSetFlags flags);
int link_get_config(LinkConfigContext *ctx, Link *link);
int link_apply_config(LinkConfigContext *ctx, sd_netlink **rtnl, Link *link, EventMode mode);
-const char *mac_address_policy_to_string(MACAddressPolicy p) _const_;
+const char* mac_address_policy_to_string(MACAddressPolicy p) _const_;
MACAddressPolicy mac_address_policy_from_string(const char *p) _pure_;
/* gperf lookup function */
fprintf(stderr, " %-14s %s\n", builtins[i]->name, builtins[i]->help);
}
-const char *udev_builtin_name(UdevBuiltinCommand cmd) {
+const char* udev_builtin_name(UdevBuiltinCommand cmd) {
assert(cmd >= 0 && cmd < _UDEV_BUILTIN_MAX);
if (!builtins[cmd])
void udev_builtin_init(void);
void udev_builtin_exit(void);
UdevBuiltinCommand udev_builtin_lookup(const char *command);
-const char *udev_builtin_name(UdevBuiltinCommand cmd);
+const char* udev_builtin_name(UdevBuiltinCommand cmd);
bool udev_builtin_run_once(UdevBuiltinCommand cmd);
int udev_builtin_run(UdevEvent *event, UdevBuiltinCommand cmd, const char *command);
void udev_builtin_list(void);
int udev_rules_apply_static_dev_perms(UdevRules *rules);
ResolveNameTiming resolve_name_timing_from_string(const char *s) _pure_;
-const char *resolve_name_timing_to_string(ResolveNameTiming i) _const_;
+const char* resolve_name_timing_to_string(ResolveNameTiming i) _const_;
_SETTING_FORCE_ENUM_WIDTH = UINT64_MAX
} SettingsMask;
-const char *console_mode_to_string(ConsoleMode m) _const_;
+const char* console_mode_to_string(ConsoleMode m) _const_;
ConsoleMode console_mode_from_string(const char *s) _pure_;
bool supports_sb;
} OvmfConfig;
-static inline const char *ovmf_config_format(const OvmfConfig *c) {
+static inline const char* ovmf_config_format(const OvmfConfig *c) {
return ASSERT_PTR(c)->format ?: "raw";
}
-static inline const char *ovmf_config_vars_format(const OvmfConfig *c) {
+static inline const char* ovmf_config_vars_format(const OvmfConfig *c) {
return ASSERT_PTR(c)->vars_format ?: "raw";
}
projects / thirdparty / systemd.git / commitdiff
