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