97a9a944b5887e91042b019776c41d5dd74557aferikabele

97a9a944b5887e91042b019776c41d5dd74557aferikabele#ifndef fooutilhfoo

a945f35eff8b6a88009ce73de6d4c862ce58de3cslive#define fooutilhfoo

a945f35eff8b6a88009ce73de6d4c862ce58de3cslive

ad74a0524a06bfe11b7de9e3b4ce7233ab3bd3f7nd

ad74a0524a06bfe11b7de9e3b4ce7233ab3bd3f7nd#include <inttypes.h>

e1e8390280254f7f0580d701e583f670643d4f3fnilgun#include <time.h>

e1e8390280254f7f0580d701e583f670643d4f3fnilgun#include <sys/time.h>

3b3b7fc78d1f5bfc2769903375050048ff41ff26nd#include <stdarg.h>

5a58787efeb02a1c3f06569d019ad81fd2efa06end#include <stdbool.h>

5a58787efeb02a1c3f06569d019ad81fd2efa06end#include <stdlib.h>

5a58787efeb02a1c3f06569d019ad81fd2efa06end#include <stdio.h>

5a58787efeb02a1c3f06569d019ad81fd2efa06end#include <signal.h>

5a58787efeb02a1c3f06569d019ad81fd2efa06end#include <sched.h>

5a58787efeb02a1c3f06569d019ad81fd2efa06end#include <limits.h>

5a58787efeb02a1c3f06569d019ad81fd2efa06end#include <sys/stat.h>

06ba4a61654b3763ad65f52283832ebf058fdf1cslive#include <dirent.h>

ced7ef1f8c0df1805da0e87dbc5a1b6282910573nd

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive#include "macro.h"

ced7ef1f8c0df1805da0e87dbc5a1b6282910573nd

b21197dc8e6b8c764fdcc24d4bae8b0eebb6bc4endtypedef uint64_t usec_t;

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slivetypedef struct dual_timestamp {

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive usec_t realtime;

97a9a944b5887e91042b019776c41d5dd74557aferikabele usec_t monotonic;

f8396ed8364b56ec8adeaa49cac35a929758a29eslive} dual_timestamp;

ffb01336be79c64046b636e59fa8ddca8ec029edsf

f8396ed8364b56ec8adeaa49cac35a929758a29eslive#define MSEC_PER_SEC 1000ULL

f8396ed8364b56ec8adeaa49cac35a929758a29eslive#define USEC_PER_SEC 1000000ULL

5a58787efeb02a1c3f06569d019ad81fd2efa06end#define USEC_PER_MSEC 1000ULL

5a58787efeb02a1c3f06569d019ad81fd2efa06end#define NSEC_PER_SEC 1000000000ULL

5a58787efeb02a1c3f06569d019ad81fd2efa06end#define NSEC_PER_MSEC 1000000ULL

5a58787efeb02a1c3f06569d019ad81fd2efa06end#define NSEC_PER_USEC 1000ULL

deeee6bb6fd94c0ba5f3730b58abd9d299c89ccdnd

4db28ee269aa06f7c6232e11cd01f58c3349af23noodl#define USEC_PER_MINUTE (60ULL*USEC_PER_SEC)

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define USEC_PER_HOUR (60ULL*USEC_PER_MINUTE)

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define USEC_PER_DAY (24ULL*USEC_PER_HOUR)

4a31db3c3a0202003c1b9f87affa7cc143e120e5sf#define USEC_PER_WEEK (7ULL*USEC_PER_DAY)

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define USEC_PER_MONTH (2629800ULL*USEC_PER_SEC)

ffb01336be79c64046b636e59fa8ddca8ec029edsf#define USEC_PER_YEAR (31557600ULL*USEC_PER_SEC)

117c1f888a14e73cdd821dc6c23eb0411144a41cnd

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define WHITESPACE " \t\n\r"

2bc7f1cf720973a67f8ff7a8d523e40569ae5b6cnd#define NEWLINE "\n\r"

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define QUOTES "\"\'"

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define COMMENTS "#;\n"

117c1f888a14e73cdd821dc6c23eb0411144a41cnd

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define FORMAT_TIMESTAMP_MAX 64

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define FORMAT_TIMESTAMP_PRETTY_MAX 256

117c1f888a14e73cdd821dc6c23eb0411144a41cnd#define FORMAT_TIMESPAN_MAX 64

87ffb6e33f3cbef3b9bb406cc2d27039fa336eaatrawick

4db28ee269aa06f7c6232e11cd01f58c3349af23noodl#define ANSI_HIGHLIGHT_ON "\x1B[1;31m"

5a58787efeb02a1c3f06569d019ad81fd2efa06end#define ANSI_HIGHLIGHT_GREEN_ON "\x1B[1;32m"

5a58787efeb02a1c3f06569d019ad81fd2efa06end#define ANSI_HIGHLIGHT_OFF "\x1B[0m"

5a58787efeb02a1c3f06569d019ad81fd2efa06end

5a58787efeb02a1c3f06569d019ad81fd2efa06endusec_t now(clockid_t clock);

5a58787efeb02a1c3f06569d019ad81fd2efa06end

5a58787efeb02a1c3f06569d019ad81fd2efa06enddual_timestamp* dual_timestamp_get(dual_timestamp *ts);

654d8eb036bedc99e90e11910ee02d3421417697rbowendual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u);

5a58787efeb02a1c3f06569d019ad81fd2efa06end

5a58787efeb02a1c3f06569d019ad81fd2efa06end#define dual_timestamp_is_set(ts) ((ts)->realtime > 0)

5a58787efeb02a1c3f06569d019ad81fd2efa06end

5a58787efeb02a1c3f06569d019ad81fd2efa06endusec_t timespec_load(const struct timespec *ts);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickstruct timespec *timespec_store(struct timespec *ts, usec_t u);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickusec_t timeval_load(const struct timeval *tv);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickstruct timeval *timeval_store(struct timeval *tv, usec_t u);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

06ba4a61654b3763ad65f52283832ebf058fdf1cslivesize_t page_size(void);

654d8eb036bedc99e90e11910ee02d3421417697rbowen#define PAGE_ALIGN(l) ALIGN_TO((l), page_size())

06ba4a61654b3763ad65f52283832ebf058fdf1cslive

06ba4a61654b3763ad65f52283832ebf058fdf1cslive#define streq(a,b) (strcmp((a),(b)) == 0)

06ba4a61654b3763ad65f52283832ebf058fdf1cslive#define strneq(a, b, n) (strncmp((a), (b), (n)) == 0)

92510838f2eb125726e15c5eb4f7a23c7a0396e4slive

97a9a944b5887e91042b019776c41d5dd74557aferikabelebool streq_ptr(const char *a, const char *b);

654d8eb036bedc99e90e11910ee02d3421417697rbowen

92510838f2eb125726e15c5eb4f7a23c7a0396e4slive#define new(t, n) ((t*) malloc(sizeof(t)*(n)))

97a9a944b5887e91042b019776c41d5dd74557aferikabele

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive#define new0(t, n) ((t*) calloc((n), sizeof(t)))

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive

92510838f2eb125726e15c5eb4f7a23c7a0396e4slive#define malloc0(n) (calloc((n), 1))

92510838f2eb125726e15c5eb4f7a23c7a0396e4slive

ffb01336be79c64046b636e59fa8ddca8ec029edsfstatic inline const char* yes_no(bool b) {

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick return b ? "yes" : "no";

ffb01336be79c64046b636e59fa8ddca8ec029edsf}

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickstatic inline const char* strempty(const char *s) {

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick return s ? s : "";

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick}

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickstatic inline const char* strnull(const char *s) {

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick return s ? s : "(null)";

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick}

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

ffb01336be79c64046b636e59fa8ddca8ec029edsfstatic inline const char *strna(const char *s) {

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick return s ? s : "n/a";

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick}

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickstatic inline bool is_path_absolute(const char *p) {

77c77cf89621f21c8e2bbad63058b5eaa5f88d4ajim return *p == '/';

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick}

ced7ef1f8c0df1805da0e87dbc5a1b6282910573nd

ced7ef1f8c0df1805da0e87dbc5a1b6282910573ndstatic inline bool isempty(const char *p) {

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick return !p || !p[0];

ffb01336be79c64046b636e59fa8ddca8ec029edsf}

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickbool endswith(const char *s, const char *postfix);

ced7ef1f8c0df1805da0e87dbc5a1b6282910573ndbool startswith(const char *s, const char *prefix);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickbool startswith_no_case(const char *s, const char *prefix);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickbool first_word(const char *s, const char *word);

4a31db3c3a0202003c1b9f87affa7cc143e120e5sf

4a31db3c3a0202003c1b9f87affa7cc143e120e5sfint close_nointr(int fd);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickvoid close_nointr_nofail(int fd);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickvoid close_many(const int fds[], unsigned n_fd);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

ffb01336be79c64046b636e59fa8ddca8ec029edsfint parse_boolean(const char *v);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickint parse_usec(const char *t, usec_t *usec);

92510838f2eb125726e15c5eb4f7a23c7a0396e4sliveint parse_bytes(const char *t, off_t *bytes);

92510838f2eb125726e15c5eb4f7a23c7a0396e4sliveint parse_pid(const char *s, pid_t* ret_pid);

97a9a944b5887e91042b019776c41d5dd74557aferikabeleint parse_uid(const char *s, uid_t* ret_uid);

92510838f2eb125726e15c5eb4f7a23c7a0396e4slive#define parse_gid(s, ret_uid) parse_uid(s, ret_uid)

ea8a727ff298d2f5368b55b7ae8d87091ae106e7nd

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawickint safe_atou(const char *s, unsigned *ret_u);

ea8a727ff298d2f5368b55b7ae8d87091ae106e7ndint safe_atoi(const char *s, int *ret_i);

ffb01336be79c64046b636e59fa8ddca8ec029edsf

ea8a727ff298d2f5368b55b7ae8d87091ae106e7ndint safe_atollu(const char *s, unsigned long long *ret_u);

ea8a727ff298d2f5368b55b7ae8d87091ae106e7ndint safe_atolli(const char *s, long long int *ret_i);

8a6d5edcb07aeccca7afba02a17dd6904d6b206ctrawick

ea8a727ff298d2f5368b55b7ae8d87091ae106e7nd#if __WORDSIZE == 32

06ba4a61654b3763ad65f52283832ebf058fdf1cslivestatic inline int safe_atolu(const char *s, unsigned long *ret_u) {

e8d485701957d5c6de870111c112e168a894d49and assert_cc(sizeof(unsigned long) == sizeof(unsigned));

e8d485701957d5c6de870111c112e168a894d49and return safe_atou(s, (unsigned*) ret_u);

654d8eb036bedc99e90e11910ee02d3421417697rbowen}

654d8eb036bedc99e90e11910ee02d3421417697rbowenstatic inline int safe_atoli(const char *s, long int *ret_u) {

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive assert_cc(sizeof(long int) == sizeof(int));

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive return safe_atoi(s, (int*) ret_u);

9bcfc3697a91b5215893a7d0206865b13fc72148nd}

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive#else

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slivestatic inline int safe_atolu(const char *s, unsigned long *ret_u) {

06ba4a61654b3763ad65f52283832ebf058fdf1cslive assert_cc(sizeof(unsigned long) == sizeof(unsigned long long));

4a31db3c3a0202003c1b9f87affa7cc143e120e5sf return safe_atollu(s, (unsigned long long*) ret_u);

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slive}

9b6a3a558cc90ffdaa0b50bd02546ffec424ded7slivestatic inline int safe_atoli(const char *s, long int *ret_u) {

709e3a21ba73b8433462959cd56c773454b34441trawick assert_cc(sizeof(long int) == sizeof(long long int));

709e3a21ba73b8433462959cd56c773454b34441trawick return safe_atolli(s, (long long int*) ret_u);

709e3a21ba73b8433462959cd56c773454b34441trawick}

709e3a21ba73b8433462959cd56c773454b34441trawick#endif

709e3a21ba73b8433462959cd56c773454b34441trawick

709e3a21ba73b8433462959cd56c773454b34441trawickstatic inline int safe_atou32(const char *s, uint32_t *ret_u) {

709e3a21ba73b8433462959cd56c773454b34441trawick assert_cc(sizeof(uint32_t) == sizeof(unsigned));

5a58787efeb02a1c3f06569d019ad81fd2efa06end return safe_atou(s, (unsigned*) ret_u);

5a58787efeb02a1c3f06569d019ad81fd2efa06end}

3b3b7fc78d1f5bfc2769903375050048ff41ff26nd

ad74a0524a06bfe11b7de9e3b4ce7233ab3bd3f7ndstatic inline int safe_atoi32(const char *s, int32_t *ret_i) {

ad74a0524a06bfe11b7de9e3b4ce7233ab3bd3f7nd assert_cc(sizeof(int32_t) == sizeof(int));

e1e8390280254f7f0580d701e583f670643d4f3fnilgun return safe_atoi(s, (int*) ret_i);

e1e8390280254f7f0580d701e583f670643d4f3fnilgun}

3b3b7fc78d1f5bfc2769903375050048ff41ff26nd

9c1260efa52c82c2a58e5b5f20cd6902563d95f5rbowenstatic inline int safe_atou64(const char *s, uint64_t *ret_u) {

5a58787efeb02a1c3f06569d019ad81fd2efa06end assert_cc(sizeof(uint64_t) == sizeof(unsigned long long));

5a58787efeb02a1c3f06569d019ad81fd2efa06end return safe_atollu(s, (unsigned long long*) ret_u);

}

static inline int safe_atoi64(const char *s, int64_t *ret_i) {

assert_cc(sizeof(int64_t) == sizeof(long long int));

return safe_atolli(s, (long long int*) ret_i);

}

char *split(const char *c, size_t *l, const char *separator, char **state);

char *split_quoted(const char *c, size_t *l, char **state);

#define FOREACH_WORD(word, length, s, state) \

for ((state) = NULL, (word) = split((s), &(length), WHITESPACE, &(state)); (word); (word) = split((s), &(length), WHITESPACE, &(state)))

#define FOREACH_WORD_SEPARATOR(word, length, s, separator, state) \

for ((state) = NULL, (word) = split((s), &(length), (separator), &(state)); (word); (word) = split((s), &(length), (separator), &(state)))

#define FOREACH_WORD_QUOTED(word, length, s, state) \

for ((state) = NULL, (word) = split_quoted((s), &(length), &(state)); (word); (word) = split_quoted((s), &(length), &(state)))

char **split_path_and_make_absolute(const char *p);

pid_t get_parent_of_pid(pid_t pid, pid_t *ppid);

int get_starttime_of_pid(pid_t pid, unsigned long long *st);

int write_one_line_file(const char *fn, const char *line);

int write_one_line_file_atomic(const char *fn, const char *line);

int read_one_line_file(const char *fn, char **line);

int read_full_file(const char *fn, char **contents, size_t *size);

int parse_env_file(const char *fname, const char *separator, ...) _sentinel_;

int load_env_file(const char *fname, char ***l);

int write_env_file(const char *fname, char **l);

char *strappend(const char *s, const char *suffix);

char *strnappend(const char *s, const char *suffix, size_t length);

char *replace_env(const char *format, char **env);

char **replace_env_argv(char **argv, char **env);

int readlink_malloc(const char *p, char **r);

int readlink_and_make_absolute(const char *p, char **r);

int readlink_and_canonicalize(const char *p, char **r);

char *file_name_from_path(const char *p);

bool is_path(const char *p);

bool path_is_absolute(const char *p);

char *path_make_absolute(const char *p, const char *prefix);

char *path_make_absolute_cwd(const char *p);

char **strv_path_make_absolute_cwd(char **l);

char **strv_path_canonicalize(char **l);

char **strv_path_remove_empty(char **l);

int reset_all_signal_handlers(void);

char *strstrip(char *s);

char *delete_chars(char *s, const char *bad);

char *truncate_nl(char *s);

char *file_in_same_dir(const char *path, const char *filename);

int safe_mkdir(const char *path, mode_t mode, uid_t uid, gid_t gid);

int mkdir_parents(const char *path, mode_t mode);

int mkdir_p(const char *path, mode_t mode);

int parent_of_path(const char *path, char **parent);

int rmdir_parents(const char *path, const char *stop);

int get_process_name(pid_t pid, char **name);

int get_process_cmdline(pid_t pid, size_t max_length, char **line);

char hexchar(int x);

int unhexchar(char c);

char octchar(int x);

int unoctchar(char c);

char decchar(int x);

int undecchar(char c);

char *cescape(const char *s);

char *cunescape(const char *s);

char *cunescape_length(const char *s, size_t length);

char *xescape(const char *s, const char *bad);

char *bus_path_escape(const char *s);

char *bus_path_unescape(const char *s);

char *path_kill_slashes(char *path);

bool path_startswith(const char *path, const char *prefix);

bool path_equal(const char *a, const char *b);

char *ascii_strlower(char *path);

bool dirent_is_file(struct dirent *de);

bool ignore_file(const char *filename);

bool chars_intersect(const char *a, const char *b);

char *format_timestamp(char *buf, size_t l, usec_t t);

char *format_timestamp_pretty(char *buf, size_t l, usec_t t);

char *format_timespan(char *buf, size_t l, usec_t t);

int make_stdio(int fd);

int make_null_stdio(void);

unsigned long long random_ull(void);

#define DEFINE_STRING_TABLE_LOOKUP(name,type) \

const char *name##_to_string(type i) { \

if (i < 0 || i >= (type) ELEMENTSOF(name##_table)) \

return NULL; \

return name##_table[i]; \

} \

type name##_from_string(const char *s) { \

type i; \

unsigned u = 0; \

assert(s); \

for (i = 0; i < (type)ELEMENTSOF(name##_table); i++) \

if (name##_table[i] && \

streq(name##_table[i], s)) \

return i; \

if (safe_atou(s, &u) >= 0 && \

u < ELEMENTSOF(name##_table)) \

return (type) u; \

return (type) -1; \

} \

struct __useless_struct_to_allow_trailing_semicolon__

int fd_nonblock(int fd, bool nonblock);

int fd_cloexec(int fd, bool cloexec);

int close_all_fds(const int except[], unsigned n_except);

bool fstype_is_network(const char *fstype);

int chvt(int vt);

int read_one_char(FILE *f, char *ret, bool *need_nl);

int ask(char *ret, const char *replies, const char *text, ...);

int reset_terminal_fd(int fd);

int reset_terminal(const char *name);

int open_terminal(const char *name, int mode);

int acquire_terminal(const char *name, bool fail, bool force, bool ignore_tiocstty_eperm);

int release_terminal(void);

int flush_fd(int fd);

int ignore_signals(int sig, ...);

int default_signals(int sig, ...);

int sigaction_many(const struct sigaction *sa, ...);

int close_pipe(int p[]);

int fopen_temporary(const char *path, FILE **_f, char **_temp_path);

ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll);

ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll);

int path_is_mount_point(const char *path);

bool is_device_path(const char *path);

int dir_is_empty(const char *path);

void rename_process(const char name[8]);

void sigset_add_many(sigset_t *ss, ...);

char* gethostname_malloc(void);

char* getlogname_malloc(void);

int getttyname_malloc(int fd, char **r);

int getttyname_harder(int fd, char **r);

int get_ctty_devnr(pid_t pid, dev_t *d);

int get_ctty(pid_t, dev_t *_devnr, char **r);

int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid);

int rm_rf(const char *path, bool only_dirs, bool delete_root);

int pipe_eof(int fd);

cpu_set_t* cpu_set_malloc(unsigned *ncpus);

void status_vprintf(const char *format, va_list ap);

void status_printf(const char *format, ...);

void status_welcome(void);

int columns(void);

int running_in_chroot(void);

char *ellipsize(const char *s, unsigned length, unsigned percent);

int touch(const char *path);

char *unquote(const char *s, const char *quotes);

char *normalize_env_assignment(const char *s);

int wait_for_terminate(pid_t pid, siginfo_t *status);

int wait_for_terminate_and_warn(const char *name, pid_t pid);

_noreturn_ void freeze(void);

bool null_or_empty(struct stat *st);

int null_or_empty_path(const char *fn);

DIR *xopendirat(int dirfd, const char *name, int flags);

void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t);

void dual_timestamp_deserialize(const char *value, dual_timestamp *t);

char *fstab_node_to_udev_node(const char *p);

void filter_environ(const char *prefix);

bool tty_is_vc(const char *tty);

int vtnr_from_tty(const char *tty);

const char *default_term_for_tty(const char *tty);

int detect_vm(const char **id);

int detect_container(const char **id);

int detect_virtualization(const char **id);

void execute_directory(const char *directory, DIR *_d, char *argv[]);

int kill_and_sigcont(pid_t pid, int sig);

bool nulstr_contains(const char*nulstr, const char *needle);

bool plymouth_running(void);

void parse_syslog_priority(char **p, int *priority);

int have_effective_cap(int value);

bool hostname_is_valid(const char *s);

char* hostname_cleanup(char *s);

char* strshorten(char *s, size_t l);

int terminal_vhangup_fd(int fd);

int terminal_vhangup(const char *name);

int vt_disallocate(const char *name);

int copy_file(const char *from, const char *to);

int symlink_or_copy(const char *from, const char *to);

int symlink_or_copy_atomic(const char *from, const char *to);

int fchmod_umask(int fd, mode_t mode);

int conf_files_list(char ***strv, const char *suffix, const char *dir, ...);

int hwclock_is_localtime(void);

int hwclock_apply_localtime_delta(int *min);

int hwclock_reset_localtime_delta(void);

int hwclock_get_time(struct tm *tm);

int hwclock_set_time(const struct tm *tm);

int audit_session_from_pid(pid_t pid, uint32_t *id);

bool display_is_local(const char *display);

int socket_from_display(const char *display, char **path);

int get_user_creds(const char **username, uid_t *uid, gid_t *gid, const char **home);

int get_group_creds(const char **groupname, gid_t *gid);

int glob_exists(const char *path);

int dirent_ensure_type(DIR *d, struct dirent *de);

int in_search_path(const char *path, char **search);

int get_files_in_directory(const char *path, char ***list);

char *join(const char *x, ...) _sentinel_;

bool is_main_thread(void);

bool in_charset(const char *s, const char* charset);

int block_get_whole_disk(dev_t d, dev_t *ret);

#define NULSTR_FOREACH(i, l) \

for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)

#define NULSTR_FOREACH_PAIR(i, j, l) \

for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr((j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))

const char *ioprio_class_to_string(int i);

int ioprio_class_from_string(const char *s);

const char *sigchld_code_to_string(int i);

int sigchld_code_from_string(const char *s);

const char *log_facility_unshifted_to_string(int i);

int log_facility_unshifted_from_string(const char *s);

const char *log_level_to_string(int i);

int log_level_from_string(const char *s);

const char *sched_policy_to_string(int i);

int sched_policy_from_string(const char *s);

const char *rlimit_to_string(int i);

int rlimit_from_string(const char *s);

const char *ip_tos_to_string(int i);

int ip_tos_from_string(const char *s);

const char *signal_to_string(int i);

int signal_from_string(const char *s);

int signal_from_string_try_harder(const char *s);

extern int saved_argc;

extern char **saved_argv;

#endif