src/basic/util.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 #pragma once
   4
   5 /***
   6   This file is part of systemd.
   7
   8   Copyright 2010 Lennart Poettering
   9
  10   systemd is free software; you can redistribute it and/or modify it
  11   under the terms of the GNU Lesser General Public License as published by
  12   the Free Software Foundation; either version 2.1 of the License, or
  13   (at your option) any later version.
  14
  15   systemd is distributed in the hope that it will be useful, but
  16   WITHOUT ANY WARRANTY; without even the implied warranty of
  17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18   Lesser General Public License for more details.
  19
  20   You should have received a copy of the GNU Lesser General Public License
  21   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  22 ***/
  23
  24 #include <alloca.h>
  25 #include <dirent.h>
  26 #include <fcntl.h>
  27 #include <inttypes.h>
  28 #include <limits.h>
  29 #include <locale.h>
  30 #include <mntent.h>
  31 #include <stdarg.h>
  32 #include <stdbool.h>
  33 #include <stddef.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <sys/inotify.h>
  37 #include <sys/socket.h>
  38 #include <sys/stat.h>
  39 #include <sys/statfs.h>
  40 #include <sys/types.h>
  41 #include <time.h>
  42 #include <unistd.h>
  43
  44 #include "formats-util.h"
  45 #include "macro.h"
  46 #include "missing.h"
  47 #include "time-util.h"
  48
  49 /* What is interpreted as whitespace? */
  50 #define WHITESPACE " \t\n\r"
  51 #define NEWLINE    "\n\r"
  52 #define QUOTES     "\"\'"
  53 #define COMMENTS   "#;"
  54 #define GLOB_CHARS "*?["
  55
  56 /* What characters are special in the shell? */
  57 /* must be escaped outside and inside double-quotes */
  58 #define SHELL_NEED_ESCAPE "\"\\`$"
  59 /* can be escaped or double-quoted */
  60 #define SHELL_NEED_QUOTES SHELL_NEED_ESCAPE GLOB_CHARS "'()<>|&;"
  61
  62 #define FORMAT_BYTES_MAX 8
  63
  64 size_t page_size(void) _pure_;
  65 #define PAGE_ALIGN(l) ALIGN_TO((l), page_size())
  66
  67 #define streq(a,b) (strcmp((a),(b)) == 0)
  68 #define strneq(a, b, n) (strncmp((a), (b), (n)) == 0)
  69 #define strcaseeq(a,b) (strcasecmp((a),(b)) == 0)
  70 #define strncaseeq(a, b, n) (strncasecmp((a), (b), (n)) == 0)
  71
  72 bool streq_ptr(const char *a, const char *b) _pure_;
  73 int strcmp_ptr(const char *a, const char *b) _pure_;
  74
  75 #define new(t, n) ((t*) malloc_multiply(sizeof(t), (n)))
  76
  77 #define new0(t, n) ((t*) calloc((n), sizeof(t)))
  78
  79 #define newa(t, n) ((t*) alloca(sizeof(t)*(n)))
  80
  81 #define newa0(t, n) ((t*) alloca0(sizeof(t)*(n)))
  82
  83 #define newdup(t, p, n) ((t*) memdup_multiply(p, sizeof(t), (n)))
  84
  85 #define malloc0(n) (calloc(1, (n)))
  86
  87 static inline void *mfree(void *memory) {
  88         free(memory);
  89         return NULL;
  90 }
  91
  92 static inline const char* yes_no(bool b) {
  93         return b ? "yes" : "no";
  94 }
  95
  96 static inline const char* true_false(bool b) {
  97         return b ? "true" : "false";
  98 }
  99
 100 static inline const char* one_zero(bool b) {
 101         return b ? "1" : "0";
 102 }
 103
 104 static inline const char* strempty(const char *s) {
 105         return s ? s : "";
 106 }
 107
 108 static inline const char* strnull(const char *s) {
 109         return s ? s : "(null)";
 110 }
 111
 112 static inline const char *strna(const char *s) {
 113         return s ? s : "n/a";
 114 }
 115
 116 static inline bool isempty(const char *p) {
 117         return !p || !p[0];
 118 }
 119
 120 static inline char *startswith(const char *s, const char *prefix) {
 121         size_t l;
 122
 123         l = strlen(prefix);
 124         if (strncmp(s, prefix, l) == 0)
 125                 return (char*) s + l;
 126
 127         return NULL;
 128 }
 129
 130 static inline char *startswith_no_case(const char *s, const char *prefix) {
 131         size_t l;
 132
 133         l = strlen(prefix);
 134         if (strncasecmp(s, prefix, l) == 0)
 135                 return (char*) s + l;
 136
 137         return NULL;
 138 }
 139
 140 char *endswith(const char *s, const char *postfix) _pure_;
 141 char *endswith_no_case(const char *s, const char *postfix) _pure_;
 142
 143 char *first_word(const char *s, const char *word) _pure_;
 144
 145 int close_nointr(int fd);
 146 int safe_close(int fd);
 147 void safe_close_pair(int p[]);
 148
 149 void close_many(const int fds[], unsigned n_fd);
 150
 151 int fclose_nointr(FILE *f);
 152 FILE* safe_fclose(FILE *f);
 153 DIR* safe_closedir(DIR *f);
 154
 155 int parse_size(const char *t, uint64_t base, uint64_t *size);
 156
 157 int parse_boolean(const char *v) _pure_;
 158 int parse_pid(const char *s, pid_t* ret_pid);
 159 int parse_uid(const char *s, uid_t* ret_uid);
 160 #define parse_gid(s, ret_gid) parse_uid(s, ret_gid)
 161
 162 bool uid_is_valid(uid_t uid);
 163
 164 static inline bool gid_is_valid(gid_t gid) {
 165         return uid_is_valid((uid_t) gid);
 166 }
 167
 168 int safe_atou(const char *s, unsigned *ret_u);
 169 int safe_atoi(const char *s, int *ret_i);
 170
 171 int safe_atollu(const char *s, unsigned long long *ret_u);
 172 int safe_atolli(const char *s, long long int *ret_i);
 173
 174 int safe_atod(const char *s, double *ret_d);
 175
 176 int safe_atou8(const char *s, uint8_t *ret);
 177
 178 #if LONG_MAX == INT_MAX
 179 static inline int safe_atolu(const char *s, unsigned long *ret_u) {
 180         assert_cc(sizeof(unsigned long) == sizeof(unsigned));
 181         return safe_atou(s, (unsigned*) ret_u);
 182 }
 183 static inline int safe_atoli(const char *s, long int *ret_u) {
 184         assert_cc(sizeof(long int) == sizeof(int));
 185         return safe_atoi(s, (int*) ret_u);
 186 }
 187 #else
 188 static inline int safe_atolu(const char *s, unsigned long *ret_u) {
 189         assert_cc(sizeof(unsigned long) == sizeof(unsigned long long));
 190         return safe_atollu(s, (unsigned long long*) ret_u);
 191 }
 192 static inline int safe_atoli(const char *s, long int *ret_u) {
 193         assert_cc(sizeof(long int) == sizeof(long long int));
 194         return safe_atolli(s, (long long int*) ret_u);
 195 }
 196 #endif
 197
 198 static inline int safe_atou32(const char *s, uint32_t *ret_u) {
 199         assert_cc(sizeof(uint32_t) == sizeof(unsigned));
 200         return safe_atou(s, (unsigned*) ret_u);
 201 }
 202
 203 static inline int safe_atoi32(const char *s, int32_t *ret_i) {
 204         assert_cc(sizeof(int32_t) == sizeof(int));
 205         return safe_atoi(s, (int*) ret_i);
 206 }
 207
 208 static inline int safe_atou64(const char *s, uint64_t *ret_u) {
 209         assert_cc(sizeof(uint64_t) == sizeof(unsigned long long));
 210         return safe_atollu(s, (unsigned long long*) ret_u);
 211 }
 212
 213 static inline int safe_atoi64(const char *s, int64_t *ret_i) {
 214         assert_cc(sizeof(int64_t) == sizeof(long long int));
 215         return safe_atolli(s, (long long int*) ret_i);
 216 }
 217
 218 int safe_atou16(const char *s, uint16_t *ret);
 219 int safe_atoi16(const char *s, int16_t *ret);
 220
 221 const char* split(const char **state, size_t *l, const char *separator, bool quoted);
 222
 223 #define FOREACH_WORD(word, length, s, state)                            \
 224         _FOREACH_WORD(word, length, s, WHITESPACE, false, state)
 225
 226 #define FOREACH_WORD_SEPARATOR(word, length, s, separator, state)       \
 227         _FOREACH_WORD(word, length, s, separator, false, state)
 228
 229 #define FOREACH_WORD_QUOTED(word, length, s, state)                     \
 230         _FOREACH_WORD(word, length, s, WHITESPACE, true, state)
 231
 232 #define _FOREACH_WORD(word, length, s, separator, quoted, state)        \
 233         for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted)))
 234
 235 char *strappend(const char *s, const char *suffix);
 236 char *strnappend(const char *s, const char *suffix, size_t length);
 237
 238 int readlinkat_malloc(int fd, const char *p, char **ret);
 239 int readlink_malloc(const char *p, char **r);
 240 int readlink_value(const char *p, char **ret);
 241 int readlink_and_make_absolute(const char *p, char **r);
 242 int readlink_and_canonicalize(const char *p, char **r);
 243
 244 char *strstrip(char *s);
 245 char *delete_chars(char *s, const char *bad);
 246 char *truncate_nl(char *s);
 247
 248 char *file_in_same_dir(const char *path, const char *filename);
 249
 250 int rmdir_parents(const char *path, const char *stop);
 251
 252 char hexchar(int x) _const_;
 253 int unhexchar(char c) _const_;
 254 char octchar(int x) _const_;
 255 int unoctchar(char c) _const_;
 256 char decchar(int x) _const_;
 257 int undecchar(char c) _const_;
 258 char base32hexchar(int x) _const_;
 259 int unbase32hexchar(char c) _const_;
 260 char base64char(int x) _const_;
 261 int unbase64char(char c) _const_;
 262
 263 char *cescape(const char *s);
 264 size_t cescape_char(char c, char *buf);
 265
 266 typedef enum UnescapeFlags {
 267         UNESCAPE_RELAX = 1,
 268 } UnescapeFlags;
 269
 270 int cunescape(const char *s, UnescapeFlags flags, char **ret);
 271 int cunescape_length(const char *s, size_t length, UnescapeFlags flags, char **ret);
 272 int cunescape_length_with_prefix(const char *s, size_t length, const char *prefix, UnescapeFlags flags, char **ret);
 273
 274 char *xescape(const char *s, const char *bad);
 275
 276 char *ascii_strlower(char *path);
 277
 278 bool dirent_is_file(const struct dirent *de) _pure_;
 279 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) _pure_;
 280
 281 bool hidden_file(const char *filename) _pure_;
 282
 283 bool chars_intersect(const char *a, const char *b) _pure_;
 284
 285 /* For basic lookup tables with strictly enumerated entries */
 286 #define _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope)          \
 287         scope const char *name##_to_string(type i) {                    \
 288                 if (i < 0 || i >= (type) ELEMENTSOF(name##_table))      \
 289                         return NULL;                                    \
 290                 return name##_table[i];                                 \
 291         }
 292
 293 ssize_t string_table_lookup(const char * const *table, size_t len, const char *key);
 294
 295 #define _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,scope)        \
 296         scope type name##_from_string(const char *s) {                  \
 297                 return (type) string_table_lookup(name##_table, ELEMENTSOF(name##_table), s); \
 298         }
 299
 300 #define _DEFINE_STRING_TABLE_LOOKUP(name,type,scope)                    \
 301         _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,scope)          \
 302         _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,scope)        \
 303         struct __useless_struct_to_allow_trailing_semicolon__
 304
 305 #define DEFINE_STRING_TABLE_LOOKUP(name,type) _DEFINE_STRING_TABLE_LOOKUP(name,type,)
 306 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP(name,type) _DEFINE_STRING_TABLE_LOOKUP(name,type,static)
 307 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(name,type) _DEFINE_STRING_TABLE_LOOKUP_TO_STRING(name,type,static)
 308 #define DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(name,type) _DEFINE_STRING_TABLE_LOOKUP_FROM_STRING(name,type,static)
 309
 310 /* For string conversions where numbers are also acceptable */
 311 #define DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(name,type,max)         \
 312         int name##_to_string_alloc(type i, char **str) {                \
 313                 char *s;                                                \
 314                 if (i < 0 || i > max)                                   \
 315                         return -ERANGE;                                 \
 316                 if (i < (type) ELEMENTSOF(name##_table)) {              \
 317                         s = strdup(name##_table[i]);                    \
 318                         if (!s)                                         \
 319                                 return -ENOMEM;                         \
 320                 } else {                                                \
 321                         if (asprintf(&s, "%i", i) < 0)                  \
 322                                 return -ENOMEM;                         \
 323                 }                                                       \
 324                 *str = s;                                               \
 325                 return 0;                                               \
 326         }                                                               \
 327         type name##_from_string(const char *s) {                        \
 328                 type i;                                                 \
 329                 unsigned u = 0;                                         \
 330                 if (!s)                                                 \
 331                         return (type) -1;                               \
 332                 for (i = 0; i < (type) ELEMENTSOF(name##_table); i++)   \
 333                         if (streq_ptr(name##_table[i], s))              \
 334                                 return i;                               \
 335                 if (safe_atou(s, &u) >= 0 && u <= max)                  \
 336                         return (type) u;                                \
 337                 return (type) -1;                                       \
 338         }                                                               \
 339         struct __useless_struct_to_allow_trailing_semicolon__
 340
 341 int fd_nonblock(int fd, bool nonblock);
 342 int fd_cloexec(int fd, bool cloexec);
 343
 344 int close_all_fds(const int except[], unsigned n_except);
 345
 346 bool fstype_is_network(const char *fstype);
 347
 348 int flush_fd(int fd);
 349
 350 int fopen_temporary(const char *path, FILE **_f, char **_temp_path);
 351
 352 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll);
 353 int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll);
 354 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll);
 355
 356 bool is_device_path(const char *path);
 357
 358 int dir_is_empty(const char *path);
 359 char* dirname_malloc(const char *path);
 360
 361 char* lookup_uid(uid_t uid);
 362 char* getlogname_malloc(void);
 363 char* getusername_malloc(void);
 364
 365 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid);
 366 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid);
 367
 368 typedef long statfs_f_type_t;
 369
 370 bool is_fs_type(const struct statfs *s, statfs_f_type_t magic_value) _pure_;
 371 int fd_check_fstype(int fd, statfs_f_type_t magic_value);
 372 int path_check_fstype(const char *path, statfs_f_type_t magic_value);
 373
 374 bool is_temporary_fs(const struct statfs *s) _pure_;
 375 int fd_is_temporary_fs(int fd);
 376
 377 int pipe_eof(int fd);
 378
 379 #define xsprintf(buf, fmt, ...) \
 380         assert_message_se((size_t) snprintf(buf, ELEMENTSOF(buf), fmt, __VA_ARGS__) < ELEMENTSOF(buf), \
 381                           "xsprintf: " #buf "[] must be big enough")
 382
 383 int files_same(const char *filea, const char *fileb);
 384
 385 int running_in_chroot(void);
 386
 387 char *ellipsize(const char *s, size_t length, unsigned percent);
 388                                    /* bytes                 columns */
 389 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent);
 390
 391 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode);
 392 int touch(const char *path);
 393
 394 noreturn void freeze(void);
 395
 396 bool null_or_empty(struct stat *st) _pure_;
 397 int null_or_empty_path(const char *fn);
 398 int null_or_empty_fd(int fd);
 399
 400 DIR *xopendirat(int dirfd, const char *name, int flags);
 401
 402 char *fstab_node_to_udev_node(const char *p);
 403
 404 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]);
 405
 406 bool nulstr_contains(const char*nulstr, const char *needle);
 407
 408 bool plymouth_running(void);
 409
 410 char* strshorten(char *s, size_t l);
 411
 412 int symlink_idempotent(const char *from, const char *to);
 413
 414 int symlink_atomic(const char *from, const char *to);
 415 int mknod_atomic(const char *path, mode_t mode, dev_t dev);
 416 int mkfifo_atomic(const char *path, mode_t mode);
 417
 418 int fchmod_umask(int fd, mode_t mode);
 419
 420 bool display_is_local(const char *display) _pure_;
 421 int socket_from_display(const char *display, char **path);
 422
 423 int get_user_creds(const char **username, uid_t *uid, gid_t *gid, const char **home, const char **shell);
 424 int get_group_creds(const char **groupname, gid_t *gid);
 425
 426 int in_gid(gid_t gid);
 427 int in_group(const char *name);
 428
 429 char* uid_to_name(uid_t uid);
 430 char* gid_to_name(gid_t gid);
 431
 432 int glob_exists(const char *path);
 433 int glob_extend(char ***strv, const char *path);
 434
 435 int dirent_ensure_type(DIR *d, struct dirent *de);
 436
 437 int get_files_in_directory(const char *path, char ***list);
 438
 439 char *strjoin(const char *x, ...) _sentinel_;
 440
 441 bool is_main_thread(void);
 442
 443 static inline bool _pure_ in_charset(const char *s, const char* charset) {
 444         assert(s);
 445         assert(charset);
 446         return s[strspn(s, charset)] == '\0';
 447 }
 448
 449 int block_get_whole_disk(dev_t d, dev_t *ret);
 450
 451 #define NULSTR_FOREACH(i, l)                                    \
 452         for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
 453
 454 #define NULSTR_FOREACH_PAIR(i, j, l)                             \
 455         for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr((j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))
 456
 457 int ioprio_class_to_string_alloc(int i, char **s);
 458 int ioprio_class_from_string(const char *s);
 459
 460 const char *sigchld_code_to_string(int i) _const_;
 461 int sigchld_code_from_string(const char *s) _pure_;
 462
 463 int log_facility_unshifted_to_string_alloc(int i, char **s);
 464 int log_facility_unshifted_from_string(const char *s);
 465 bool log_facility_unshifted_is_valid(int faciliy);
 466
 467 int log_level_to_string_alloc(int i, char **s);
 468 int log_level_from_string(const char *s);
 469 bool log_level_is_valid(int level);
 470
 471 int sched_policy_to_string_alloc(int i, char **s);
 472 int sched_policy_from_string(const char *s);
 473
 474 const char *rlimit_to_string(int i) _const_;
 475 int rlimit_from_string(const char *s) _pure_;
 476
 477 int ip_tos_to_string_alloc(int i, char **s);
 478 int ip_tos_from_string(const char *s);
 479
 480 extern int saved_argc;
 481 extern char **saved_argv;
 482
 483 bool kexec_loaded(void);
 484
 485 int prot_from_flags(int flags) _const_;
 486
 487 char *format_bytes(char *buf, size_t l, uint64_t t);
 488
 489 int fd_wait_for_event(int fd, int event, usec_t timeout);
 490
 491 void* memdup(const void *p, size_t l) _alloc_(2);
 492
 493 int fd_inc_sndbuf(int fd, size_t n);
 494 int fd_inc_rcvbuf(int fd, size_t n);
 495
 496 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...);
 497
 498 int setrlimit_closest(int resource, const struct rlimit *rlim);
 499
 500 bool http_url_is_valid(const char *url) _pure_;
 501 bool documentation_url_is_valid(const char *url) _pure_;
 502
 503 bool http_etag_is_valid(const char *etag);
 504
 505 bool in_initrd(void);
 506
 507 int get_home_dir(char **ret);
 508 int get_shell(char **_ret);
 509
 510 static inline void freep(void *p) {
 511         free(*(void**) p);
 512 }
 513
 514 static inline void closep(int *fd) {
 515         safe_close(*fd);
 516 }
 517
 518 static inline void umaskp(mode_t *u) {
 519         umask(*u);
 520 }
 521
 522 static inline void close_pairp(int (*p)[2]) {
 523         safe_close_pair(*p);
 524 }
 525
 526 static inline void fclosep(FILE **f) {
 527         safe_fclose(*f);
 528 }
 529
 530 DEFINE_TRIVIAL_CLEANUP_FUNC(FILE*, pclose);
 531 DEFINE_TRIVIAL_CLEANUP_FUNC(DIR*, closedir);
 532 DEFINE_TRIVIAL_CLEANUP_FUNC(FILE*, endmntent);
 533
 534 #define _cleanup_free_ _cleanup_(freep)
 535 #define _cleanup_close_ _cleanup_(closep)
 536 #define _cleanup_umask_ _cleanup_(umaskp)
 537 #define _cleanup_globfree_ _cleanup_(globfree)
 538 #define _cleanup_fclose_ _cleanup_(fclosep)
 539 #define _cleanup_pclose_ _cleanup_(pclosep)
 540 #define _cleanup_closedir_ _cleanup_(closedirp)
 541 #define _cleanup_endmntent_ _cleanup_(endmntentp)
 542 #define _cleanup_close_pair_ _cleanup_(close_pairp)
 543
 544 _malloc_  _alloc_(1, 2) static inline void *malloc_multiply(size_t a, size_t b) {
 545         if (_unlikely_(b != 0 && a > ((size_t) -1) / b))
 546                 return NULL;
 547
 548         return malloc(a * b);
 549 }
 550
 551 _alloc_(2, 3) static inline void *realloc_multiply(void *p, size_t a, size_t b) {
 552         if (_unlikely_(b != 0 && a > ((size_t) -1) / b))
 553                 return NULL;
 554
 555         return realloc(p, a * b);
 556 }
 557
 558 _alloc_(2, 3) static inline void *memdup_multiply(const void *p, size_t a, size_t b) {
 559         if (_unlikely_(b != 0 && a > ((size_t) -1) / b))
 560                 return NULL;
 561
 562         return memdup(p, a * b);
 563 }
 564
 565 bool filename_is_valid(const char *p) _pure_;
 566 bool path_is_safe(const char *p) _pure_;
 567 bool string_is_safe(const char *p) _pure_;
 568 bool string_has_cc(const char *p, const char *ok) _pure_;
 569
 570 /**
 571  * Check if a string contains any glob patterns.
 572  */
 573 _pure_ static inline bool string_is_glob(const char *p) {
 574         return !!strpbrk(p, GLOB_CHARS);
 575 }
 576
 577 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
 578                  int (*compar) (const void *, const void *, void *),
 579                  void *arg);
 580
 581 #define _(String) gettext (String)
 582 #define N_(String) String
 583 void init_gettext(void);
 584 bool is_locale_utf8(void);
 585
 586 typedef enum DrawSpecialChar {
 587         DRAW_TREE_VERTICAL,
 588         DRAW_TREE_BRANCH,
 589         DRAW_TREE_RIGHT,
 590         DRAW_TREE_SPACE,
 591         DRAW_TRIANGULAR_BULLET,
 592         DRAW_BLACK_CIRCLE,
 593         DRAW_ARROW,
 594         DRAW_DASH,
 595         _DRAW_SPECIAL_CHAR_MAX
 596 } DrawSpecialChar;
 597
 598 const char *draw_special_char(DrawSpecialChar ch);
 599
 600 char *strreplace(const char *text, const char *old_string, const char *new_string);
 601
 602 char *strip_tab_ansi(char **p, size_t *l);
 603
 604 int on_ac_power(void);
 605
 606 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f);
 607 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f);
 608
 609 #define FOREACH_LINE(line, f, on_error)                         \
 610         for (;;)                                                \
 611                 if (!fgets(line, sizeof(line), f)) {            \
 612                         if (ferror(f)) {                        \
 613                                 on_error;                       \
 614                         }                                       \
 615                         break;                                  \
 616                 } else
 617
 618 #define FOREACH_DIRENT(de, d, on_error)                                 \
 619         for (errno = 0, de = readdir(d);; errno = 0, de = readdir(d))   \
 620                 if (!de) {                                              \
 621                         if (errno > 0) {                                \
 622                                 on_error;                               \
 623                         }                                               \
 624                         break;                                          \
 625                 } else if (hidden_file((de)->d_name))                   \
 626                         continue;                                       \
 627                 else
 628
 629 #define FOREACH_DIRENT_ALL(de, d, on_error)                             \
 630         for (errno = 0, de = readdir(d);; errno = 0, de = readdir(d))   \
 631                 if (!de) {                                              \
 632                         if (errno > 0) {                                \
 633                                 on_error;                               \
 634                         }                                               \
 635                         break;                                          \
 636                 } else
 637
 638 static inline void *mempset(void *s, int c, size_t n) {
 639         memset(s, c, n);
 640         return (uint8_t*)s + n;
 641 }
 642
 643 char *hexmem(const void *p, size_t l);
 644 int unhexmem(const char *p, size_t l, void **mem, size_t *len);
 645
 646 char *base32hexmem(const void *p, size_t l, bool padding);
 647 int unbase32hexmem(const char *p, size_t l, bool padding, void **mem, size_t *len);
 648
 649 char *base64mem(const void *p, size_t l);
 650 int unbase64mem(const char *p, size_t l, void **mem, size_t *len);
 651
 652 char *strextend(char **x, ...) _sentinel_;
 653 char *strrep(const char *s, unsigned n);
 654
 655 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size);
 656 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size);
 657 #define GREEDY_REALLOC(array, allocated, need)                          \
 658         greedy_realloc((void**) &(array), &(allocated), (need), sizeof((array)[0]))
 659
 660 #define GREEDY_REALLOC0(array, allocated, need)                         \
 661         greedy_realloc0((void**) &(array), &(allocated), (need), sizeof((array)[0]))
 662
 663 static inline void _reset_errno_(int *saved_errno) {
 664         errno = *saved_errno;
 665 }
 666
 667 #define PROTECT_ERRNO _cleanup_(_reset_errno_) __attribute__((unused)) int _saved_errno_ = errno
 668
 669 static inline int negative_errno(void) {
 670         /* This helper should be used to shut up gcc if you know 'errno' is
 671          * negative. Instead of "return -errno;", use "return negative_errno();"
 672          * It will suppress bogus gcc warnings in case it assumes 'errno' might
 673          * be 0 and thus the caller's error-handling might not be triggered. */
 674         assert_return(errno > 0, -EINVAL);
 675         return -errno;
 676 }
 677
 678 struct _umask_struct_ {
 679         mode_t mask;
 680         bool quit;
 681 };
 682
 683 static inline void _reset_umask_(struct _umask_struct_ *s) {
 684         umask(s->mask);
 685 };
 686
 687 #define RUN_WITH_UMASK(mask)                                            \
 688         for (_cleanup_(_reset_umask_) struct _umask_struct_ _saved_umask_ = { umask(mask), false }; \
 689              !_saved_umask_.quit ;                                      \
 690              _saved_umask_.quit = true)
 691
 692 static inline unsigned u64log2(uint64_t n) {
 693 #if __SIZEOF_LONG_LONG__ == 8
 694         return (n > 1) ? (unsigned) __builtin_clzll(n) ^ 63U : 0;
 695 #else
 696 #error "Wut?"
 697 #endif
 698 }
 699
 700 static inline unsigned u32ctz(uint32_t n) {
 701 #if __SIZEOF_INT__ == 4
 702         return __builtin_ctz(n);
 703 #else
 704 #error "Wut?"
 705 #endif
 706 }
 707
 708 static inline unsigned log2i(int x) {
 709         assert(x > 0);
 710
 711         return __SIZEOF_INT__ * 8 - __builtin_clz(x) - 1;
 712 }
 713
 714 static inline unsigned log2u(unsigned x) {
 715         assert(x > 0);
 716
 717         return sizeof(unsigned) * 8 - __builtin_clz(x) - 1;
 718 }
 719
 720 static inline unsigned log2u_round_up(unsigned x) {
 721         assert(x > 0);
 722
 723         if (x == 1)
 724                 return 0;
 725
 726         return log2u(x - 1) + 1;
 727 }
 728
 729 static inline bool logind_running(void) {
 730         return access("/run/systemd/seats/", F_OK) >= 0;
 731 }
 732
 733 #define DECIMAL_STR_WIDTH(x)                            \
 734         ({                                              \
 735                 typeof(x) _x_ = (x);                    \
 736                 unsigned ans = 1;                       \
 737                 while (_x_ /= 10)                       \
 738                         ans++;                          \
 739                 ans;                                    \
 740         })
 741
 742 int unlink_noerrno(const char *path);
 743
 744 #define alloca0(n)                                      \
 745         ({                                              \
 746                 char *_new_;                            \
 747                 size_t _len_ = n;                       \
 748                 _new_ = alloca(_len_);                  \
 749                 (void *) memset(_new_, 0, _len_);       \
 750         })
 751
 752 /* It's not clear what alignment glibc/gcc alloca() guarantee, hence provide a guaranteed safe version */
 753 #define alloca_align(size, align)                                       \
 754         ({                                                              \
 755                 void *_ptr_;                                            \
 756                 size_t _mask_ = (align) - 1;                            \
 757                 _ptr_ = alloca((size) + _mask_);                        \
 758                 (void*)(((uintptr_t)_ptr_ + _mask_) & ~_mask_);         \
 759         })
 760
 761 #define alloca0_align(size, align)                                      \
 762         ({                                                              \
 763                 void *_new_;                                            \
 764                 size_t _size_ = (size);                                 \
 765                 _new_ = alloca_align(_size_, (align));                  \
 766                 (void*)memset(_new_, 0, _size_);                        \
 767         })
 768
 769 #define strjoina(a, ...)                                                \
 770         ({                                                              \
 771                 const char *_appendees_[] = { a, __VA_ARGS__ };         \
 772                 char *_d_, *_p_;                                        \
 773                 int _len_ = 0;                                          \
 774                 unsigned _i_;                                           \
 775                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
 776                         _len_ += strlen(_appendees_[_i_]);              \
 777                 _p_ = _d_ = alloca(_len_ + 1);                          \
 778                 for (_i_ = 0; _i_ < ELEMENTSOF(_appendees_) && _appendees_[_i_]; _i_++) \
 779                         _p_ = stpcpy(_p_, _appendees_[_i_]);            \
 780                 *_p_ = 0;                                               \
 781                 _d_;                                                    \
 782         })
 783
 784 bool id128_is_valid(const char *s) _pure_;
 785
 786 int split_pair(const char *s, const char *sep, char **l, char **r);
 787
 788 int shall_restore_state(void);
 789
 790 /**
 791  * Normal qsort requires base to be nonnull. Here were require
 792  * that only if nmemb > 0.
 793  */
 794 static inline void qsort_safe(void *base, size_t nmemb, size_t size, comparison_fn_t compar) {
 795         if (nmemb <= 1)
 796                 return;
 797
 798         assert(base);
 799         qsort(base, nmemb, size, compar);
 800 }
 801
 802 /* Normal memmem() requires haystack to be nonnull, which is annoying for zero-length buffers */
 803 static inline void *memmem_safe(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) {
 804
 805         if (needlelen <= 0)
 806                 return (void*) haystack;
 807
 808         if (haystacklen < needlelen)
 809                 return NULL;
 810
 811         assert(haystack);
 812         assert(needle);
 813
 814         return memmem(haystack, haystacklen, needle, needlelen);
 815 }
 816
 817 int proc_cmdline(char **ret);
 818 int parse_proc_cmdline(int (*parse_word)(const char *key, const char *value));
 819 int get_proc_cmdline_key(const char *parameter, char **value);
 820
 821 int container_get_leader(const char *machine, pid_t *pid);
 822
 823 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *userns_fd, int *root_fd);
 824 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int userns_fd, int root_fd);
 825
 826 int getpeercred(int fd, struct ucred *ucred);
 827 int getpeersec(int fd, char **ret);
 828
 829 int writev_safe(int fd, const struct iovec *w, int j);
 830
 831 int mkostemp_safe(char *pattern, int flags);
 832 int open_tmpfile(const char *path, int flags);
 833
 834 int fd_warn_permissions(const char *path, int fd);
 835
 836 #ifndef PERSONALITY_INVALID
 837 /* personality(7) documents that 0xffffffffUL is used for querying the
 838  * current personality, hence let's use that here as error
 839  * indicator. */
 840 #define PERSONALITY_INVALID 0xffffffffLU
 841 #endif
 842
 843 unsigned long personality_from_string(const char *p);
 844 const char *personality_to_string(unsigned long);
 845
 846 uint64_t physical_memory(void);
 847
 848 void hexdump(FILE *f, const void *p, size_t s);
 849
 850 union file_handle_union {
 851         struct file_handle handle;
 852         char padding[sizeof(struct file_handle) + MAX_HANDLE_SZ];
 853 };
 854 #define FILE_HANDLE_INIT { .handle.handle_bytes = MAX_HANDLE_SZ }
 855
 856 int update_reboot_param_file(const char *param);
 857
 858 int umount_recursive(const char *target, int flags);
 859
 860 int bind_remount_recursive(const char *prefix, bool ro);
 861
 862 int fflush_and_check(FILE *f);
 863
 864 int tempfn_xxxxxx(const char *p, const char *extra, char **ret);
 865 int tempfn_random(const char *p, const char *extra, char **ret);
 866 int tempfn_random_child(const char *p, const char *extra, char **ret);
 867
 868 int take_password_lock(const char *root);
 869
 870 int is_symlink(const char *path);
 871 int is_dir(const char *path, bool follow);
 872 int is_device_node(const char *path);
 873
 874 typedef enum ExtractFlags {
 875         EXTRACT_RELAX           = 1,
 876         EXTRACT_CUNESCAPE       = 2,
 877         EXTRACT_CUNESCAPE_RELAX = 4,
 878         EXTRACT_QUOTES          = 8,
 879         EXTRACT_DONT_COALESCE_SEPARATORS = 16,
 880 } ExtractFlags;
 881
 882 int extract_first_word(const char **p, char **ret, const char *separators, ExtractFlags flags);
 883 int extract_first_word_and_warn(const char **p, char **ret, const char *separators, ExtractFlags flags, const char *unit, const char *filename, unsigned line, const char *rvalue);
 884 int extract_many_words(const char **p, const char *separators, ExtractFlags flags, ...) _sentinel_;
 885
 886 int free_and_strdup(char **p, const char *s);
 887
 888 #define INOTIFY_EVENT_MAX (sizeof(struct inotify_event) + NAME_MAX + 1)
 889
 890 #define FOREACH_INOTIFY_EVENT(e, buffer, sz) \
 891         for ((e) = &buffer.ev;                                \
 892              (uint8_t*) (e) < (uint8_t*) (buffer.raw) + (sz); \
 893              (e) = (struct inotify_event*) ((uint8_t*) (e) + sizeof(struct inotify_event) + (e)->len))
 894
 895 union inotify_event_buffer {
 896         struct inotify_event ev;
 897         uint8_t raw[INOTIFY_EVENT_MAX];
 898 };
 899
 900 #define laccess(path, mode) faccessat(AT_FDCWD, (path), (mode), AT_SYMLINK_NOFOLLOW)
 901
 902 ssize_t fgetxattrat_fake(int dirfd, const char *filename, const char *attribute, void *value, size_t size, int flags);
 903
 904 int fd_setcrtime(int fd, usec_t usec);
 905 int fd_getcrtime(int fd, usec_t *usec);
 906 int path_getcrtime(const char *p, usec_t *usec);
 907 int fd_getcrtime_at(int dirfd, const char *name, usec_t *usec, int flags);
 908
 909 int same_fd(int a, int b);
 910
 911 int chattr_fd(int fd, unsigned value, unsigned mask);
 912 int chattr_path(const char *p, unsigned value, unsigned mask);
 913
 914 int read_attr_fd(int fd, unsigned *ret);
 915 int read_attr_path(const char *p, unsigned *ret);
 916
 917 #define RLIMIT_MAKE_CONST(lim) ((struct rlimit) { lim, lim })
 918
 919 ssize_t sparse_write(int fd, const void *p, size_t sz, size_t run_length);
 920
 921 void sigkill_wait(pid_t *pid);
 922 #define _cleanup_sigkill_wait_ _cleanup_(sigkill_wait)
 923
 924 int syslog_parse_priority(const char **p, int *priority, bool with_facility);
 925
 926 void cmsg_close_all(struct msghdr *mh);
 927
 928 int rename_noreplace(int olddirfd, const char *oldpath, int newdirfd, const char *newpath);
 929
 930 char *shell_escape(const char *s, const char *bad);
 931 char *shell_maybe_quote(const char *s);
 932
 933 int parse_mode(const char *s, mode_t *ret);
 934
 935 int mount_move_root(const char *path);
 936
 937 int reset_uid_gid(void);
 938
 939 int getxattr_malloc(const char *path, const char *name, char **value, bool allow_symlink);
 940 int fgetxattr_malloc(int fd, const char *name, char **value);
 941
 942 int send_one_fd(int transport_fd, int fd, int flags);
 943 int receive_one_fd(int transport_fd, int flags);
 944
 945 void nop_signal_handler(int sig);
 946
 947 int version(void);
 948
 949 bool fdname_is_valid(const char *s);
 950
 951 bool oom_score_adjust_is_valid(int oa);
 952
 953 #define memory_erase(p, l) memset((p), 'x', (l))
 954 void string_erase(char *x);
 955
 956 char *string_free_erase(char *s);
 957 DEFINE_TRIVIAL_CLEANUP_FUNC(char *, string_free_erase);
 958 #define _cleanup_string_free_erase_ _cleanup_(string_free_erasep)