Merge pull request #32868 from keszybz/more-whomification

Fix confusion between killer and prey

src/basic/af-list.c

@@ -12,7 +12,7 @@ static const struct af_name* lookup_af(register const char *str, register 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;
@@ -39,7 +39,7 @@ int af_max(void) {
         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" :

src/basic/af-list.h

@@ -5,7 +5,7 @@
 
 #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) {

src/basic/architecture.h

@@ -242,5 +242,5 @@ Architecture uname_architecture(void);
 #  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_;

src/basic/arphrd-util.h

@@ -4,7 +4,7 @@
 #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);

src/basic/bus-label.c

@@ -7,7 +7,7 @@
 #include "hexdecoct.h"
 #include "macro.h"
 
-char *bus_label_escape(const char *s) {
+char* bus_label_escape(const char *s) {
         char *r, *t;
         const char *f;
 
@@ -42,7 +42,7 @@ char *bus_label_escape(const char *s) {
         return r;
 }
 
-char *bus_label_unescape_n(const char *f, size_t l) {
+char* bus_label_unescape_n(const char *f, size_t l) {
         char *r, *t;
         size_t i;
 

src/basic/bus-label.h

@@ -6,9 +6,9 @@
 
 #include "string-util.h"
 
-char *bus_label_escape(const char *s);
-char *bus_label_unescape_n(const char *f, size_t l);
+char* bus_label_escape(const char *s);
+char* bus_label_unescape_n(const char *f, size_t l);
 
-static inline char *bus_label_unescape(const char *f) {
+static inline char* bus_label_unescape(const char *f) {
         return bus_label_unescape_n(f, strlen_ptr(f));
 }

src/basic/cap-list.c

@@ -18,7 +18,7 @@ static const struct capability_name* lookup_capability(register const char *str,
 #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())
@@ -27,7 +27,7 @@ const char *capability_to_name(int id) {
         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)

src/basic/cap-list.h

@@ -8,8 +8,8 @@
  * "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);

src/basic/cgroup-util.c

@@ -1691,7 +1691,7 @@ int cg_escape(const char *p, char **ret) {
         return 0;
 }
 
-char *cg_unescape(const char *p) {
+char* cg_unescape(const char *p) {
         assert(p);
 
         /* The return value of this function (unlike cg_escape())

src/basic/cgroup-util.h

@@ -298,7 +298,7 @@ int cg_path_decode_unit(const char *cgroup, char **ret_unit);
 
 bool cg_needs_escape(const char *p);
 int cg_escape(const char *p, char **ret);
-char *cg_unescape(const char *p) _pure_;
+char* cg_unescape(const char *p) _pure_;
 
 bool cg_controller_is_valid(const char *p);
 

src/basic/confidential-virt.h

@@ -21,5 +21,5 @@ typedef enum ConfidentialVirtualization {
 
 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_;

src/basic/env-util.c

@@ -552,7 +552,7 @@ char* strv_env_get_n(char * const *l, const char *name, size_t k, ReplaceEnvFlag
         return NULL;
 }
 
-char *strv_env_pairs_get(char **l, const char *name) {
+char* strv_env_pairs_get(char **l, const char *name) {
         char *result = NULL;
 
         assert(name);

src/basic/env-util.h

@@ -59,7 +59,7 @@ static inline char* strv_env_get(char * const *x, const char *n) {
         return strv_env_get_n(x, n, SIZE_MAX, 0);
 }
 
-char *strv_env_pairs_get(char **l, const char *name) _pure_;
+char* strv_env_pairs_get(char **l, const char *name) _pure_;
 
 int getenv_bool(const char *p);
 int secure_getenv_bool(const char *p);

src/basic/errno-list.c

@@ -12,7 +12,7 @@ static const struct errno_name* lookup_errno(register const char *str,
 #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;

src/basic/errno-list.h

@@ -8,7 +8,7 @@
  */
 #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;

src/basic/ether-addr-util.c

@@ -11,7 +11,7 @@
 #include "macro.h"
 #include "string-util.h"
 
-char *hw_addr_to_string_full(
+char* hw_addr_to_string_full(
                 const struct hw_addr_data *addr,
                 HardwareAddressToStringFlags flags,
                 char buffer[static HW_ADDR_TO_STRING_MAX]) {

src/basic/ether-addr-util.h

@@ -36,11 +36,11 @@ typedef enum HardwareAddressToStringFlags {
 } HardwareAddressToStringFlags;
 
 #define HW_ADDR_TO_STRING_MAX (3*HW_ADDR_MAX_SIZE)
-char *hw_addr_to_string_full(
+char* hw_addr_to_string_full(
                 const struct hw_addr_data *addr,
                 HardwareAddressToStringFlags flags,
                 char buffer[static HW_ADDR_TO_STRING_MAX]);
-static inline char *hw_addr_to_string(const struct hw_addr_data *addr, char buffer[static HW_ADDR_TO_STRING_MAX]) {
+static inline char* hw_addr_to_string(const struct hw_addr_data *addr, char buffer[static HW_ADDR_TO_STRING_MAX]) {
         return hw_addr_to_string_full(addr, 0, buffer);
 }
 

src/basic/fd-util.c

@@ -1091,7 +1091,7 @@ int fds_are_same_mount(int fd1, int fd2) {
         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";
@@ -1104,7 +1104,7 @@ const char *accmode_to_string(int flags) {
         }
 }
 
-char *format_proc_pid_fd_path(char buf[static PROC_PID_FD_PATH_MAX], pid_t pid, int fd) {
+char* format_proc_pid_fd_path(char buf[static PROC_PID_FD_PATH_MAX], pid_t pid, int fd) {
         assert(buf);
         assert(fd >= 0);
         assert(pid >= 0);

src/basic/fd-util.h

@@ -141,7 +141,7 @@ int fds_are_same_mount(int fd1, int fd2);
 #define PROC_FD_PATH_MAX \
         (STRLEN("/proc/self/fd/") + DECIMAL_STR_MAX(int))
 
-static inline char *format_proc_fd_path(char buf[static PROC_FD_PATH_MAX], int fd) {
+static inline char* format_proc_fd_path(char buf[static PROC_FD_PATH_MAX], int fd) {
         assert(buf);
         assert(fd >= 0);
         assert_se(snprintf_ok(buf, PROC_FD_PATH_MAX, "/proc/self/fd/%i", fd));
@@ -155,7 +155,7 @@ static inline char *format_proc_fd_path(char buf[static PROC_FD_PATH_MAX], int f
 #define PROC_PID_FD_PATH_MAX \
         (STRLEN("/proc//fd/") + DECIMAL_STR_MAX(pid_t) + DECIMAL_STR_MAX(int))
 
-char *format_proc_pid_fd_path(char buf[static PROC_PID_FD_PATH_MAX], pid_t pid, int fd);
+char* format_proc_pid_fd_path(char buf[static PROC_PID_FD_PATH_MAX], pid_t pid, int fd);
 
 /* Kinda the same as FORMAT_PROC_FD_PATH(), but goes by PID rather than "self" symlink */
 #define FORMAT_PROC_PID_FD_PATH(pid, fd)                                \
@@ -163,7 +163,7 @@ char *format_proc_pid_fd_path(char buf[static PROC_PID_FD_PATH_MAX], pid_t pid,
 
 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)                           \

src/basic/filesystems.c

@@ -3,7 +3,7 @@
 #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"

src/basic/filesystems.h

@@ -34,7 +34,7 @@ extern const FilesystemSet filesystem_sets[];
 
 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);
 

src/basic/format-util.c

@@ -37,7 +37,7 @@ int format_ifname_full_alloc(int ifindex, FormatIfnameFlag flag, char **ret) {
         return strdup_to(ret, buf);
 }
 
-char *format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) {
+char* format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) {
         typedef struct {
                 const char *suffix;
                 uint64_t factor;

src/basic/format-util.h

@@ -81,7 +81,7 @@ static inline int format_ifname_alloc(int ifindex, char **ret) {
         return format_ifname_full_alloc(ifindex, 0, ret);
 }
 
-static inline char *_format_ifname_full(int ifindex, FormatIfnameFlag flag, char buf[static IF_NAMESIZE]) {
+static inline char* _format_ifname_full(int ifindex, FormatIfnameFlag flag, char buf[static IF_NAMESIZE]) {
         (void) format_ifname_full(ifindex, flag, buf);
         return buf;
 }
@@ -97,10 +97,10 @@ typedef enum {
 
 #define FORMAT_BYTES_MAX 16U
 
-char *format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) _warn_unused_result_;
+char* format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) _warn_unused_result_;
 
 _warn_unused_result_
-static inline char *format_bytes(char *buf, size_t l, uint64_t t) {
+static inline char* format_bytes(char *buf, size_t l, uint64_t t) {
         return format_bytes_full(buf, l, t, FORMAT_BYTES_USE_IEC | FORMAT_BYTES_BELOW_POINT | FORMAT_BYTES_TRAILING_B);
 }
 

src/basic/glyph-util.c

@@ -23,7 +23,7 @@ bool emoji_enabled(void) {
         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

src/basic/glyph-util.h

@@ -61,16 +61,16 @@ typedef enum SpecialGlyph {
 
 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) : " ";
 }

src/basic/hexdecoct.c

@@ -55,7 +55,7 @@ int unhexchar(char c) {
         return -EINVAL;
 }
 
-char *hexmem(const void *p, size_t l) {
+char* hexmem(const void *p, size_t l) {
         const uint8_t *x;
         char *r, *z;
 
@@ -188,7 +188,7 @@ int unbase32hexchar(char c) {
         return -EINVAL;
 }
 
-char *base32hexmem(const void *p, size_t l, bool padding) {
+char* base32hexmem(const void *p, size_t l, bool padding) {
         char *r, *z;
         const uint8_t *x;
         size_t len;

src/basic/hexdecoct.h

@@ -17,7 +17,7 @@ int undecchar(char c) _const_;
 char hexchar(int x) _const_;
 int unhexchar(char c) _const_;
 
-char *hexmem(const void *p, size_t l);
+char* hexmem(const void *p, size_t l);
 int unhexmem_full(const char *p, size_t l, bool secure, void **ret_data, size_t *ret_size);
 static inline int unhexmem(const char *p, void **ret_data, size_t *ret_size) {
         return unhexmem_full(p, SIZE_MAX, false, ret_data, ret_size);
@@ -30,7 +30,7 @@ char base64char(int x) _const_;
 char urlsafe_base64char(int x) _const_;
 int unbase64char(char c) _const_;
 
-char *base32hexmem(const void *p, size_t l, bool padding);
+char* base32hexmem(const void *p, size_t l, bool padding);
 int unbase32hexmem(const char *p, size_t l, bool padding, void **mem, size_t *len);
 
 ssize_t base64mem_full(const void *p, size_t l, size_t line_break, char **ret);

src/basic/log.c

@@ -1741,7 +1741,7 @@ void log_setup(void) {
                 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)

src/basic/log.h

@@ -49,7 +49,7 @@ static inline void clear_log_syntax_callback(dummy_t *dummy) {
           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);
@@ -432,8 +432,8 @@ typedef struct LogRateLimit {
 #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;

src/basic/mountpoint-util.c

@@ -647,7 +647,7 @@ int mount_nofollow(
         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:

src/basic/mountpoint-util.h

@@ -70,7 +70,7 @@ int mount_nofollow(
                 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);
 

src/basic/os-util.c

@@ -476,7 +476,7 @@ int os_release_support_ended(const char *support_end, bool quiet, usec_t *ret_eo
         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. */

src/basic/os-util.h

@@ -57,4 +57,4 @@ int load_os_release_pairs_with_prefix(const char *root, const char *prefix, char
 
 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);

src/basic/path-util.h

@@ -203,7 +203,7 @@ bool dot_or_dot_dot(const char *path);
 
 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 */

src/basic/proc-cmdline.c

@@ -253,7 +253,7 @@ static bool relaxed_equal_char(char a, char b) {
                 (a == '-' && b == '_');
 }
 
-char *proc_cmdline_key_startswith(const char *s, const char *prefix) {
+char* proc_cmdline_key_startswith(const char *s, const char *prefix) {
         assert(s);
         assert(prefix);
 

src/basic/proc-cmdline.h

@@ -28,7 +28,7 @@ int proc_cmdline_get_bool(const char *key, ProcCmdlineFlags flags, bool *ret);
 int proc_cmdline_get_key_many_internal(ProcCmdlineFlags flags, ...);
 #define proc_cmdline_get_key_many(flags, ...) proc_cmdline_get_key_many_internal(flags, __VA_ARGS__, NULL)
 
-char *proc_cmdline_key_startswith(const char *s, const char *prefix);
+char* proc_cmdline_key_startswith(const char *s, const char *prefix);
 bool proc_cmdline_key_streq(const char *x, const char *y);
 
 /* A little helper call, to be used in proc_cmdline_parse_t callbacks */

src/basic/process-util.h

@@ -113,12 +113,12 @@ bool oom_score_adjust_is_valid(int oa);
 #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);

src/basic/replace-var.c

@@ -36,7 +36,7 @@ static int get_variable(const char *b, char **r) {
         return 1;
 }
 
-char *replace_var(const char *text, char *(*lookup)(const char *variable, void *userdata), void *userdata) {
+char* replace_var(const char *text, char *(*lookup)(const char *variable, void *userdata), void *userdata) {
         char *r, *t;
         const char *f;
         size_t l;

src/basic/replace-var.h

@@ -1,4 +1,4 @@
 /* SPDX-License-Identifier: LGPL-2.1-or-later */
 #pragma once
 
-char *replace_var(const char *text, char *(*lookup)(const char *variable, void *userdata), void *userdata);
+char* replace_var(const char *text, char *(*lookup)(const char *variable, void *userdata), void *userdata);

src/basic/rlimit-util.h

@@ -6,7 +6,7 @@
 #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_;
 

src/basic/runtime-scope.h

@@ -13,7 +13,7 @@ typedef enum RuntimeScope {
         _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_;

src/basic/signal-util.c

@@ -151,7 +151,7 @@ static const char *const static_signal_table[] = {
 
 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;
 

src/basic/signal-util.h

@@ -37,7 +37,7 @@ int sigset_add_many_internal(sigset_t *ss, ...);
 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);

src/basic/string-table.h

@@ -15,7 +15,7 @@ ssize_t string_table_lookup(const char * const *table, size_t len, const char *k
 
 /* 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];                                 \

src/basic/string-util.c

@@ -46,7 +46,7 @@ char* first_word(const char *s, const char *word) {
         return (char*) nw;
 }
 
-char *strnappend(const char *s, const char *suffix, size_t b) {
+char* strnappend(const char *s, const char *suffix, size_t b) {
         size_t a;
         char *r;
 
@@ -77,7 +77,7 @@ char *strnappend(const char *s, const char *suffix, size_t b) {
         return r;
 }
 
-char *strjoin_real(const char *x, ...) {
+char* strjoin_real(const char *x, ...) {
         va_list ap;
         size_t l = 1;
         char *r, *p;
@@ -109,7 +109,7 @@ char *strjoin_real(const char *x, ...) {
         return r;
 }
 
-char *strstrip(char *s) {
+char* strstrip(char *s) {
         if (!s)
                 return NULL;
 
@@ -118,7 +118,7 @@ char *strstrip(char *s) {
         return delete_trailing_chars(skip_leading_chars(s, WHITESPACE), WHITESPACE);
 }
 
-char *delete_chars(char *s, const char *bad) {
+char* delete_chars(char *s, const char *bad) {
         char *f, *t;
 
         /* Drops all specified bad characters, regardless where in the string */
@@ -141,7 +141,7 @@ char *delete_chars(char *s, const char *bad) {
         return s;
 }
 
-char *delete_trailing_chars(char *s, const char *bad) {
+char* delete_trailing_chars(char *s, const char *bad) {
         char *c = s;
 
         /* Drops all specified bad characters, at the end of the string */
@@ -161,7 +161,7 @@ char *delete_trailing_chars(char *s, const char *bad) {
         return s;
 }
 
-char *truncate_nl_full(char *s, size_t *ret_len) {
+char* truncate_nl_full(char *s, size_t *ret_len) {
         size_t n;
 
         assert(s);
@@ -189,7 +189,7 @@ char ascii_toupper(char x) {
         return x;
 }
 
-char *ascii_strlower(char *t) {
+char* ascii_strlower(char *t) {
         assert(t);
 
         for (char *p = t; *p; p++)
@@ -198,7 +198,7 @@ char *ascii_strlower(char *t) {
         return t;
 }
 
-char *ascii_strupper(char *t) {
+char* ascii_strupper(char *t) {
         assert(t);
 
         for (char *p = t; *p; p++)
@@ -207,7 +207,7 @@ char *ascii_strupper(char *t) {
         return t;
 }
 
-char *ascii_strlower_n(char *t, size_t n) {
+char* ascii_strlower_n(char *t, size_t n) {
         if (n <= 0)
                 return t;
 
@@ -389,7 +389,7 @@ static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_le
         return t;
 }
 
-char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
+char* ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
         size_t x, k, len, len2;
         const char *i, *j;
         int r;
@@ -524,7 +524,7 @@ char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigne
         return e;
 }
 
-char *cellescape(char *buf, size_t len, const char *s) {
+char* cellescape(char *buf, size_t len, const char *s) {
         /* Escape and ellipsize s into buffer buf of size len. Only non-control ASCII
          * characters are copied as they are, everything else is escaped. The result
          * is different then if escaping and ellipsization was performed in two
@@ -630,7 +630,7 @@ int strgrowpad0(char **s, size_t l) {
         return 0;
 }
 
-char *strreplace(const char *text, const char *old_string, const char *new_string) {
+char* strreplace(const char *text, const char *old_string, const char *new_string) {
         size_t l, old_len, new_len;
         char *t, *ret = NULL;
         const char *f;
@@ -692,7 +692,7 @@ static void advance_offsets(
                 shift[1] += size;
 }
 
-char *strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]) {
+char* strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]) {
         const char *begin = NULL;
         enum {
                 STATE_OTHER,
@@ -824,7 +824,7 @@ char *strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]) {
         return *ibuf;
 }
 
-char *strextend_with_separator_internal(char **x, const char *separator, ...) {
+char* strextend_with_separator_internal(char **x, const char *separator, ...) {
         size_t f, l, l_separator;
         bool need_separator;
         char *nr, *p;
@@ -980,7 +980,7 @@ oom:
         return -ENOMEM;
 }
 
-char *strextendn(char **x, const char *s, size_t l) {
+char* strextendn(char **x, const char *s, size_t l) {
         assert(x);
         assert(s || l == 0);
 
@@ -1007,7 +1007,7 @@ char *strextendn(char **x, const char *s, size_t l) {
         return *x;
 }
 
-char *strrep(const char *s, unsigned n) {
+char* strrep(const char *s, unsigned n) {
         char *r, *p;
         size_t l;
 
@@ -1288,7 +1288,7 @@ bool streq_skip_trailing_chars(const char *s1, const char *s2, const char *ok) {
         return in_charset(s1, ok) && in_charset(s2, ok);
 }
 
-char *string_replace_char(char *str, char old_char, char new_char) {
+char* string_replace_char(char *str, char old_char, char new_char) {
         assert(str);
         assert(old_char != '\0');
         assert(new_char != '\0');
@@ -1358,14 +1358,14 @@ size_t strspn_from_end(const char *str, const char *accept) {
         return n;
 }
 
-char *strdupspn(const char *a, const char *accept) {
+char* strdupspn(const char *a, const char *accept) {
         if (isempty(a) || isempty(accept))
                 return strdup("");
 
         return strndup(a, strspn(a, accept));
 }
 
-char *strdupcspn(const char *a, const char *reject) {
+char* strdupcspn(const char *a, const char *reject) {
         if (isempty(a))
                 return strdup("");
         if (isempty(reject))
@@ -1374,7 +1374,7 @@ char *strdupcspn(const char *a, const char *reject) {
         return strndup(a, strcspn(a, reject));
 }
 
-char *find_line_startswith(const char *haystack, const char *needle) {
+char* find_line_startswith(const char *haystack, const char *needle) {
         char *p;
 
         assert(haystack);
@@ -1485,7 +1485,7 @@ ssize_t strlevenshtein(const char *x, const char *y) {
         return t1[yl];
 }
 
-char *strrstr(const char *haystack, const char *needle) {
+char* strrstr(const char *haystack, const char *needle) {
         /* Like strstr() but returns the last rather than the first occurrence of "needle" in "haystack". */
 
         if (!haystack || !needle)

src/basic/string-util.h

@@ -33,7 +33,7 @@ static inline char* strstr_ptr(const char *haystack, const char *needle) {
         return strstr(haystack, needle);
 }
 
-static inline char *strstrafter(const char *haystack, const char *needle) {
+static inline char* strstrafter(const char *haystack, const char *needle) {
         char *p;
 
         /* Returns NULL if not found, or pointer to first character after needle if found */
@@ -49,7 +49,7 @@ static inline const char* strnull(const char *s) {
         return s ?: "(null)";
 }
 
-static inline const char *strna(const char *s) {
+static inline const char* strna(const char *s) {
         return s ?: "n/a";
 }
 
@@ -81,11 +81,11 @@ static inline const char* enabled_disabled(bool b) {
                 (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;
 }
 
@@ -95,7 +95,7 @@ static inline bool empty_or_dash(const char *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)                                \
@@ -104,11 +104,11 @@ static inline const char *empty_or_dash_to_null(const char *p) {
                 (typeof(p)) (empty_or_dash(_p) ? NULL : _p);    \
         })
 
-char *first_word(const char *s, const char *word) _pure_;
+char* first_word(const char *s, const char *word) _pure_;
 
-char *strnappend(const char *s, const char *suffix, size_t length);
+char* strnappend(const char *s, const char *suffix, size_t length);
 
-char *strjoin_real(const char *x, ...) _sentinel_;
+char* strjoin_real(const char *x, ...) _sentinel_;
 #define strjoin(a, ...) strjoin_real((a), __VA_ARGS__, NULL)
 
 #define strjoina(a, ...)                                                \
@@ -126,11 +126,11 @@ char *strjoin_real(const char *x, ...) _sentinel_;
                 _d_;                                                    \
         })
 
-char *strstrip(char *s);
-char *delete_chars(char *s, const char *bad);
-char *delete_trailing_chars(char *s, const char *bad);
-char *truncate_nl_full(char *s, size_t *ret_len);
-static inline char *truncate_nl(char *s) {
+char* strstrip(char *s);
+char* delete_chars(char *s, const char *bad);
+char* delete_trailing_chars(char *s, const char *bad);
+char* truncate_nl_full(char *s, size_t *ret_len);
+static inline char* truncate_nl(char *s) {
         return truncate_nl_full(s, NULL);
 }
 
@@ -145,11 +145,11 @@ static inline char* skip_leading_chars(const char *s, const char *bad) {
 }
 
 char ascii_tolower(char x);
-char *ascii_strlower(char *s);
-char *ascii_strlower_n(char *s, size_t n);
+char* ascii_strlower(char *s);
+char* ascii_strlower_n(char *s, size_t n);
 
 char ascii_toupper(char x);
-char *ascii_strupper(char *s);
+char* ascii_strupper(char *s);
 
 int ascii_strcasecmp_n(const char *a, const char *b, size_t n);
 int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m);
@@ -172,12 +172,12 @@ static inline bool char_is_cc(char p) {
 }
 bool string_has_cc(const char *p, const char *ok) _pure_;
 
-char *ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
-static inline char *ellipsize(const char *s, size_t length, unsigned percent) {
+char* ellipsize_mem(const char *s, size_t old_length_bytes, size_t new_length_columns, unsigned percent);
+static inline char* ellipsize(const char *s, size_t length, unsigned percent) {
         return ellipsize_mem(s, strlen(s), length, percent);
 }
 
-char *cellescape(char *buf, size_t len, const char *s);
+char* cellescape(char *buf, size_t len, const char *s);
 
 /* This limit is arbitrary, enough to give some idea what the string contains */
 #define CELLESCAPE_DEFAULT_LENGTH 64
@@ -186,20 +186,20 @@ char* strshorten(char *s, size_t l);
 
 int strgrowpad0(char **s, size_t l);
 
-char *strreplace(const char *text, const char *old_string, const char *new_string);
+char* strreplace(const char *text, const char *old_string, const char *new_string);
 
-char *strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]);
+char* strip_tab_ansi(char **ibuf, size_t *_isz, size_t highlight[2]);
 
-char *strextend_with_separator_internal(char **x, const char *separator, ...) _sentinel_;
+char* strextend_with_separator_internal(char **x, const char *separator, ...) _sentinel_;
 #define strextend_with_separator(x, separator, ...) strextend_with_separator_internal(x, separator, __VA_ARGS__, NULL)
 #define strextend(x, ...) strextend_with_separator_internal(x, NULL, __VA_ARGS__, NULL)
 
-char *strextendn(char **x, const char *s, size_t l);
+char* strextendn(char **x, const char *s, size_t l);
 
 int strextendf_with_separator(char **x, const char *separator, const char *format, ...) _printf_(3,4);
 #define strextendf(x, ...) strextendf_with_separator(x, NULL, __VA_ARGS__)
 
-char *strrep(const char *s, unsigned n);
+char* strrep(const char *s, unsigned n);
 
 #define strrepa(s, n)                                           \
         ({                                                      \
@@ -285,7 +285,7 @@ static inline int string_contains_word(const char *string, const char *separator
 
 bool streq_skip_trailing_chars(const char *s1, const char *s2, const char *ok);
 
-char *string_replace_char(char *str, char old_char, char new_char);
+char* string_replace_char(char *str, char old_char, char new_char);
 
 typedef enum MakeCStringMode {
         MAKE_CSTRING_REFUSE_TRAILING_NUL,
@@ -299,10 +299,10 @@ int make_cstring(const char *s, size_t n, MakeCStringMode mode, char **ret);
 
 size_t strspn_from_end(const char *str, const char *accept);
 
-char *strdupspn(const char *a, const char *accept);
-char *strdupcspn(const char *a, const char *reject);
+char* strdupspn(const char *a, const char *accept);
+char* strdupcspn(const char *a, const char *reject);
 
-char *find_line_startswith(const char *haystack, const char *needle);
+char* find_line_startswith(const char *haystack, const char *needle);
 
 bool version_is_valid(const char *s);
 
@@ -310,4 +310,4 @@ bool version_is_valid_versionspec(const char *s);
 
 ssize_t strlevenshtein(const char *x, const char *y);
 
-char *strrstr(const char *haystack, const char *needle);
+char* strrstr(const char *haystack, const char *needle);

src/basic/sysctl-util.c

@@ -15,7 +15,7 @@
 #include "string-util.h"
 #include "sysctl-util.h"
 
-char *sysctl_normalize(char *s) {
+char* sysctl_normalize(char *s) {
         char *n;
 
         n = strpbrk(s, "/.");

src/basic/sysctl-util.h

@@ -8,7 +8,7 @@
 #include "stdio-util.h"
 #include "string-util.h"
 
-char *sysctl_normalize(char *s);
+char* sysctl_normalize(char *s);
 int sysctl_read(const char *property, char **value);
 int sysctl_write(const char *property, const char *value);
 int sysctl_writef(const char *property, const char *format, ...) _printf_(2, 3);

src/basic/terminal-util.c

@@ -790,7 +790,7 @@ bool tty_is_vc_resolve(const char *tty) {
         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";
 }
 

src/basic/terminal-util.h

@@ -160,7 +160,7 @@ bool tty_is_vc(const char *tty);
 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);
 
@@ -198,15 +198,15 @@ static inline bool colors_enabled(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) : "";
 }

src/basic/time-util.c

@@ -312,7 +312,7 @@ struct timeval *timeval_store(struct timeval *tv, usec_t u) {
         return tv;
 }
 
-char *format_timestamp_style(
+char* format_timestamp_style(
                 char *buf,
                 size_t l,
                 usec_t t,

src/basic/unit-def.c

@@ -6,7 +6,7 @@
 #include "unit-def.h"
 #include "unit-name.h"
 
-char *unit_dbus_path_from_name(const char *name) {
+char* unit_dbus_path_from_name(const char *name) {
         _cleanup_free_ char *e = NULL;
 
         assert(name);
@@ -58,7 +58,7 @@ const char* unit_dbus_interface_from_type(UnitType t) {
         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);

src/basic/unit-def.h

@@ -280,28 +280,28 @@ typedef enum NotifyAccess {
         _NOTIFY_ACCESS_INVALID = -EINVAL,
 } NotifyAccess;
 
-char *unit_dbus_path_from_name(const char *name);
+char* unit_dbus_path_from_name(const char *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_;
@@ -334,10 +334,10 @@ SwapState swap_state_from_string(const char *s) _pure_;
 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_;

src/basic/unit-name.c

@@ -331,7 +331,7 @@ static char *do_escape(const char *f, char *t) {
         return t;
 }
 
-char *unit_name_escape(const char *f) {
+char* unit_name_escape(const char *f) {
         char *r, *t;
 
         assert(f);

src/basic/unit-name.h

@@ -35,7 +35,7 @@ int unit_name_change_suffix(const char *n, const char *suffix, char **ret);
 int unit_name_build(const char *prefix, const char *instance, const char *suffix, char **ret);
 int unit_name_build_from_type(const char *prefix, const char *instance, UnitType type, char **ret);
 
-char *unit_name_escape(const char *f);
+char* unit_name_escape(const char *f);
 int unit_name_unescape(const char *f, char **ret);
 int unit_name_path_escape(const char *f, char **ret);
 int unit_name_path_unescape(const char *f, char **ret);

src/basic/utf8.c

@@ -153,7 +153,7 @@ char* utf8_is_valid_n(const char *str, size_t len_bytes) {
         return (char*) str;
 }
 
-char *utf8_escape_invalid(const char *str) {
+char* utf8_escape_invalid(const char *str) {
         char *p, *s;
 
         assert(str);
@@ -195,7 +195,7 @@ int utf8_char_console_width(const char *str) {
         return unichar_iswide(c) ? 2 : 1;
 }
 
-char *utf8_escape_non_printable_full(const char *str, size_t console_width, bool force_ellipsis) {
+char* utf8_escape_non_printable_full(const char *str, size_t console_width, bool force_ellipsis) {
         char *p, *s, *prev_s;
         size_t n = 0; /* estimated print width */
 
@@ -359,7 +359,7 @@ size_t utf8_encode_unichar(char *out_utf8, char32_t g) {
         return 0;
 }
 
-char *utf16_to_utf8(const char16_t *s, size_t length /* bytes! */) {
+char* utf16_to_utf8(const char16_t *s, size_t length /* bytes! */) {
         const uint8_t *f;
         char *r, *t;
 

src/basic/utf8.h

@@ -29,16 +29,16 @@ int utf8_to_ascii(const char *str, char replacement_char, char **ret);
 bool utf8_is_printable_newline(const char* str, size_t length, bool allow_newline) _pure_;
 #define utf8_is_printable(str, length) utf8_is_printable_newline(str, length, true)
 
-char *utf8_escape_invalid(const char *s);
-char *utf8_escape_non_printable_full(const char *str, size_t console_width, bool force_ellipsis);
-static inline char *utf8_escape_non_printable(const char *str) {
+char* utf8_escape_invalid(const char *s);
+char* utf8_escape_non_printable_full(const char *str, size_t console_width, bool force_ellipsis);
+static inline char* utf8_escape_non_printable(const char *str) {
         return utf8_escape_non_printable_full(str, SIZE_MAX, false);
 }
 
 size_t utf8_encode_unichar(char *out_utf8, char32_t g);
 size_t utf16_encode_unichar(char16_t *out, char32_t c);
 
-char *utf16_to_utf8(const char16_t *s, size_t length /* bytes! */);
+char* utf16_to_utf8(const char16_t *s, size_t length /* bytes! */);
 char16_t *utf8_to_utf16(const char *s, size_t length);
 
 size_t char16_strlen(const char16_t *s); /* returns the number of 16-bit words in the string (not bytes!) */

src/basic/virt.h

@@ -65,6 +65,6 @@ Virtualization detect_virtualization(void);
 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);