src/shared/util.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <signal.h>
  28 #include <stdio.h>
  29 #include <syslog.h>
  30 #include <sched.h>
  31 #include <sys/resource.h>
  32 #include <linux/sched.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <dirent.h>
  37 #include <sys/ioctl.h>
  38 #include <linux/vt.h>
  39 #include <linux/tiocl.h>
  40 #include <termios.h>
  41 #include <stdarg.h>
  42 #include <sys/poll.h>
  43 #include <ctype.h>
  44 #include <sys/prctl.h>
  45 #include <sys/utsname.h>
  46 #include <pwd.h>
  47 #include <netinet/ip.h>
  48 #include <linux/kd.h>
  49 #include <dlfcn.h>
  50 #include <sys/wait.h>
  51 #include <sys/time.h>
  52 #include <glob.h>
  53 #include <grp.h>
  54 #include <sys/mman.h>
  55 #include <sys/vfs.h>
  56 #include <sys/mount.h>
  57 #include <linux/magic.h>
  58 #include <limits.h>
  59 #include <langinfo.h>
  60 #include <locale.h>
  61 #include <sys/personality.h>
  62 #include <sys/xattr.h>
  63 #include <libgen.h>
  64 #include <sys/statvfs.h>
  65 #include <linux/fs.h>
  66 #undef basename
  67
  68 #ifdef HAVE_SYS_AUXV_H
  69 #include <sys/auxv.h>
  70 #endif
  71
  72 #include "macro.h"
  73 #include "util.h"
  74 #include "ioprio.h"
  75 #include "missing.h"
  76 #include "log.h"
  77 #include "strv.h"
  78 #include "label.h"
  79 #include "mkdir.h"
  80 #include "path-util.h"
  81 #include "exit-status.h"
  82 #include "hashmap.h"
  83 #include "env-util.h"
  84 #include "fileio.h"
  85 #include "device-nodes.h"
  86 #include "utf8.h"
  87 #include "gunicode.h"
  88 #include "virt.h"
  89 #include "def.h"
  90 #include "sparse-endian.h"
  91
  92 int saved_argc = 0;
  93 char **saved_argv = NULL;
  94
  95 static volatile unsigned cached_columns = 0;
  96 static volatile unsigned cached_lines = 0;
  97
  98 size_t page_size(void) {
  99         static thread_local size_t pgsz = 0;
 100         long r;
 101
 102         if (_likely_(pgsz > 0))
 103                 return pgsz;
 104
 105         r = sysconf(_SC_PAGESIZE);
 106         assert(r > 0);
 107
 108         pgsz = (size_t) r;
 109         return pgsz;
 110 }
 111
 112 bool streq_ptr(const char *a, const char *b) {
 113
 114         /* Like streq(), but tries to make sense of NULL pointers */
 115
 116         if (a && b)
 117                 return streq(a, b);
 118
 119         if (!a && !b)
 120                 return true;
 121
 122         return false;
 123 }
 124
 125 char* endswith(const char *s, const char *postfix) {
 126         size_t sl, pl;
 127
 128         assert(s);
 129         assert(postfix);
 130
 131         sl = strlen(s);
 132         pl = strlen(postfix);
 133
 134         if (pl == 0)
 135                 return (char*) s + sl;
 136
 137         if (sl < pl)
 138                 return NULL;
 139
 140         if (memcmp(s + sl - pl, postfix, pl) != 0)
 141                 return NULL;
 142
 143         return (char*) s + sl - pl;
 144 }
 145
 146 char* first_word(const char *s, const char *word) {
 147         size_t sl, wl;
 148         const char *p;
 149
 150         assert(s);
 151         assert(word);
 152
 153         /* Checks if the string starts with the specified word, either
 154          * followed by NUL or by whitespace. Returns a pointer to the
 155          * NUL or the first character after the whitespace. */
 156
 157         sl = strlen(s);
 158         wl = strlen(word);
 159
 160         if (sl < wl)
 161                 return NULL;
 162
 163         if (wl == 0)
 164                 return (char*) s;
 165
 166         if (memcmp(s, word, wl) != 0)
 167                 return NULL;
 168
 169         p = s + wl;
 170         if (*p == 0)
 171                 return (char*) p;
 172
 173         if (!strchr(WHITESPACE, *p))
 174                 return NULL;
 175
 176         p += strspn(p, WHITESPACE);
 177         return (char*) p;
 178 }
 179
 180 static size_t cescape_char(char c, char *buf) {
 181         char * buf_old = buf;
 182
 183         switch (c) {
 184
 185                 case '\a':
 186                         *(buf++) = '\\';
 187                         *(buf++) = 'a';
 188                         break;
 189                 case '\b':
 190                         *(buf++) = '\\';
 191                         *(buf++) = 'b';
 192                         break;
 193                 case '\f':
 194                         *(buf++) = '\\';
 195                         *(buf++) = 'f';
 196                         break;
 197                 case '\n':
 198                         *(buf++) = '\\';
 199                         *(buf++) = 'n';
 200                         break;
 201                 case '\r':
 202                         *(buf++) = '\\';
 203                         *(buf++) = 'r';
 204                         break;
 205                 case '\t':
 206                         *(buf++) = '\\';
 207                         *(buf++) = 't';
 208                         break;
 209                 case '\v':
 210                         *(buf++) = '\\';
 211                         *(buf++) = 'v';
 212                         break;
 213                 case '\\':
 214                         *(buf++) = '\\';
 215                         *(buf++) = '\\';
 216                         break;
 217                 case '"':
 218                         *(buf++) = '\\';
 219                         *(buf++) = '"';
 220                         break;
 221                 case '\'':
 222                         *(buf++) = '\\';
 223                         *(buf++) = '\'';
 224                         break;
 225
 226                 default:
 227                         /* For special chars we prefer octal over
 228                          * hexadecimal encoding, simply because glib's
 229                          * g_strescape() does the same */
 230                         if ((c < ' ') || (c >= 127)) {
 231                                 *(buf++) = '\\';
 232                                 *(buf++) = octchar((unsigned char) c >> 6);
 233                                 *(buf++) = octchar((unsigned char) c >> 3);
 234                                 *(buf++) = octchar((unsigned char) c);
 235                         } else
 236                                 *(buf++) = c;
 237                         break;
 238         }
 239
 240         return buf - buf_old;
 241 }
 242
 243 int close_nointr(int fd) {
 244         assert(fd >= 0);
 245
 246         if (close(fd) >= 0)
 247                 return 0;
 248
 249         /*
 250          * Just ignore EINTR; a retry loop is the wrong thing to do on
 251          * Linux.
 252          *
 253          * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
 254          * https://bugzilla.gnome.org/show_bug.cgi?id=682819
 255          * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
 256          * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
 257          */
 258         if (errno == EINTR)
 259                 return 0;
 260
 261         return -errno;
 262 }
 263
 264 int safe_close(int fd) {
 265
 266         /*
 267          * Like close_nointr() but cannot fail. Guarantees errno is
 268          * unchanged. Is a NOP with negative fds passed, and returns
 269          * -1, so that it can be used in this syntax:
 270          *
 271          * fd = safe_close(fd);
 272          */
 273
 274         if (fd >= 0) {
 275                 PROTECT_ERRNO;
 276
 277                 /* The kernel might return pretty much any error code
 278                  * via close(), but the fd will be closed anyway. The
 279                  * only condition we want to check for here is whether
 280                  * the fd was invalid at all... */
 281
 282                 assert_se(close_nointr(fd) != -EBADF);
 283         }
 284
 285         return -1;
 286 }
 287
 288 void close_many(const int fds[], unsigned n_fd) {
 289         unsigned i;
 290
 291         assert(fds || n_fd <= 0);
 292
 293         for (i = 0; i < n_fd; i++)
 294                 safe_close(fds[i]);
 295 }
 296
 297 int unlink_noerrno(const char *path) {
 298         PROTECT_ERRNO;
 299         int r;
 300
 301         r = unlink(path);
 302         if (r < 0)
 303                 return -errno;
 304
 305         return 0;
 306 }
 307
 308 int parse_boolean(const char *v) {
 309         assert(v);
 310
 311         if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
 312                 return 1;
 313         else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
 314                 return 0;
 315
 316         return -EINVAL;
 317 }
 318
 319 int parse_pid(const char *s, pid_t* ret_pid) {
 320         unsigned long ul = 0;
 321         pid_t pid;
 322         int r;
 323
 324         assert(s);
 325         assert(ret_pid);
 326
 327         r = safe_atolu(s, &ul);
 328         if (r < 0)
 329                 return r;
 330
 331         pid = (pid_t) ul;
 332
 333         if ((unsigned long) pid != ul)
 334                 return -ERANGE;
 335
 336         if (pid <= 0)
 337                 return -ERANGE;
 338
 339         *ret_pid = pid;
 340         return 0;
 341 }
 342
 343 int parse_uid(const char *s, uid_t* ret_uid) {
 344         unsigned long ul = 0;
 345         uid_t uid;
 346         int r;
 347
 348         assert(s);
 349         assert(ret_uid);
 350
 351         r = safe_atolu(s, &ul);
 352         if (r < 0)
 353                 return r;
 354
 355         uid = (uid_t) ul;
 356
 357         if ((unsigned long) uid != ul)
 358                 return -ERANGE;
 359
 360         /* Some libc APIs use UID_INVALID as special placeholder */
 361         if (uid == (uid_t) 0xFFFFFFFF)
 362                 return -ENXIO;
 363
 364         /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
 365         if (uid == (uid_t) 0xFFFF)
 366                 return -ENXIO;
 367
 368         *ret_uid = uid;
 369         return 0;
 370 }
 371
 372 int safe_atou(const char *s, unsigned *ret_u) {
 373         char *x = NULL;
 374         unsigned long l;
 375
 376         assert(s);
 377         assert(ret_u);
 378
 379         errno = 0;
 380         l = strtoul(s, &x, 0);
 381
 382         if (!x || x == s || *x || errno)
 383                 return errno > 0 ? -errno : -EINVAL;
 384
 385         if ((unsigned long) (unsigned) l != l)
 386                 return -ERANGE;
 387
 388         *ret_u = (unsigned) l;
 389         return 0;
 390 }
 391
 392 int safe_atoi(const char *s, int *ret_i) {
 393         char *x = NULL;
 394         long l;
 395
 396         assert(s);
 397         assert(ret_i);
 398
 399         errno = 0;
 400         l = strtol(s, &x, 0);
 401
 402         if (!x || x == s || *x || errno)
 403                 return errno > 0 ? -errno : -EINVAL;
 404
 405         if ((long) (int) l != l)
 406                 return -ERANGE;
 407
 408         *ret_i = (int) l;
 409         return 0;
 410 }
 411
 412 int safe_atou8(const char *s, uint8_t *ret) {
 413         char *x = NULL;
 414         unsigned long l;
 415
 416         assert(s);
 417         assert(ret);
 418
 419         errno = 0;
 420         l = strtoul(s, &x, 0);
 421
 422         if (!x || x == s || *x || errno)
 423                 return errno > 0 ? -errno : -EINVAL;
 424
 425         if ((unsigned long) (uint8_t) l != l)
 426                 return -ERANGE;
 427
 428         *ret = (uint8_t) l;
 429         return 0;
 430 }
 431
 432 int safe_atou16(const char *s, uint16_t *ret) {
 433         char *x = NULL;
 434         unsigned long l;
 435
 436         assert(s);
 437         assert(ret);
 438
 439         errno = 0;
 440         l = strtoul(s, &x, 0);
 441
 442         if (!x || x == s || *x || errno)
 443                 return errno > 0 ? -errno : -EINVAL;
 444
 445         if ((unsigned long) (uint16_t) l != l)
 446                 return -ERANGE;
 447
 448         *ret = (uint16_t) l;
 449         return 0;
 450 }
 451
 452 int safe_atoi16(const char *s, int16_t *ret) {
 453         char *x = NULL;
 454         long l;
 455
 456         assert(s);
 457         assert(ret);
 458
 459         errno = 0;
 460         l = strtol(s, &x, 0);
 461
 462         if (!x || x == s || *x || errno)
 463                 return errno > 0 ? -errno : -EINVAL;
 464
 465         if ((long) (int16_t) l != l)
 466                 return -ERANGE;
 467
 468         *ret = (int16_t) l;
 469         return 0;
 470 }
 471
 472 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 473         char *x = NULL;
 474         unsigned long long l;
 475
 476         assert(s);
 477         assert(ret_llu);
 478
 479         errno = 0;
 480         l = strtoull(s, &x, 0);
 481
 482         if (!x || x == s || *x || errno)
 483                 return errno ? -errno : -EINVAL;
 484
 485         *ret_llu = l;
 486         return 0;
 487 }
 488
 489 int safe_atolli(const char *s, long long int *ret_lli) {
 490         char *x = NULL;
 491         long long l;
 492
 493         assert(s);
 494         assert(ret_lli);
 495
 496         errno = 0;
 497         l = strtoll(s, &x, 0);
 498
 499         if (!x || x == s || *x || errno)
 500                 return errno ? -errno : -EINVAL;
 501
 502         *ret_lli = l;
 503         return 0;
 504 }
 505
 506 int safe_atod(const char *s, double *ret_d) {
 507         char *x = NULL;
 508         double d = 0;
 509
 510         assert(s);
 511         assert(ret_d);
 512
 513         RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
 514                 errno = 0;
 515                 d = strtod(s, &x);
 516         }
 517
 518         if (!x || x == s || *x || errno)
 519                 return errno ? -errno : -EINVAL;
 520
 521         *ret_d = (double) d;
 522         return 0;
 523 }
 524
 525 static size_t strcspn_escaped(const char *s, const char *reject) {
 526         bool escaped = false;
 527         int n;
 528
 529         for (n=0; s[n]; n++) {
 530                 if (escaped)
 531                         escaped = false;
 532                 else if (s[n] == '\\')
 533                         escaped = true;
 534                 else if (strchr(reject, s[n]))
 535                         break;
 536         }
 537
 538         /* if s ends in \, return index of previous char */
 539         return n - escaped;
 540 }
 541
 542 /* Split a string into words. */
 543 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
 544         const char *current;
 545
 546         current = *state;
 547
 548         if (!*current) {
 549                 assert(**state == '\0');
 550                 return NULL;
 551         }
 552
 553         current += strspn(current, separator);
 554         if (!*current) {
 555                 *state = current;
 556                 return NULL;
 557         }
 558
 559         if (quoted && strchr("\'\"", *current)) {
 560                 char quotechars[2] = {*current, '\0'};
 561
 562                 *l = strcspn_escaped(current + 1, quotechars);
 563                 if (current[*l + 1] == '\0' ||
 564                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
 565                         /* right quote missing or garbage at the end */
 566                         *state = current;
 567                         return NULL;
 568                 }
 569                 assert(current[*l + 1] == quotechars[0]);
 570                 *state = current++ + *l + 2;
 571         } else if (quoted) {
 572                 *l = strcspn_escaped(current, separator);
 573                 if (current[*l] && !strchr(separator, current[*l])) {
 574                         /* unfinished escape */
 575                         *state = current;
 576                         return NULL;
 577                 }
 578                 *state = current + *l;
 579         } else {
 580                 *l = strcspn(current, separator);
 581                 *state = current + *l;
 582         }
 583
 584         return current;
 585 }
 586
 587 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
 588         int r;
 589         _cleanup_free_ char *line = NULL;
 590         long unsigned ppid;
 591         const char *p;
 592
 593         assert(pid >= 0);
 594         assert(_ppid);
 595
 596         if (pid == 0) {
 597                 *_ppid = getppid();
 598                 return 0;
 599         }
 600
 601         p = procfs_file_alloca(pid, "stat");
 602         r = read_one_line_file(p, &line);
 603         if (r < 0)
 604                 return r;
 605
 606         /* Let's skip the pid and comm fields. The latter is enclosed
 607          * in () but does not escape any () in its value, so let's
 608          * skip over it manually */
 609
 610         p = strrchr(line, ')');
 611         if (!p)
 612                 return -EIO;
 613
 614         p++;
 615
 616         if (sscanf(p, " "
 617                    "%*c "  /* state */
 618                    "%lu ", /* ppid */
 619                    &ppid) != 1)
 620                 return -EIO;
 621
 622         if ((long unsigned) (pid_t) ppid != ppid)
 623                 return -ERANGE;
 624
 625         *_ppid = (pid_t) ppid;
 626
 627         return 0;
 628 }
 629
 630 int fchmod_umask(int fd, mode_t m) {
 631         mode_t u;
 632         int r;
 633
 634         u = umask(0777);
 635         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 636         umask(u);
 637
 638         return r;
 639 }
 640
 641 char *truncate_nl(char *s) {
 642         assert(s);
 643
 644         s[strcspn(s, NEWLINE)] = 0;
 645         return s;
 646 }
 647
 648 int get_process_state(pid_t pid) {
 649         const char *p;
 650         char state;
 651         int r;
 652         _cleanup_free_ char *line = NULL;
 653
 654         assert(pid >= 0);
 655
 656         p = procfs_file_alloca(pid, "stat");
 657         r = read_one_line_file(p, &line);
 658         if (r < 0)
 659                 return r;
 660
 661         p = strrchr(line, ')');
 662         if (!p)
 663                 return -EIO;
 664
 665         p++;
 666
 667         if (sscanf(p, " %c", &state) != 1)
 668                 return -EIO;
 669
 670         return (unsigned char) state;
 671 }
 672
 673 int get_process_comm(pid_t pid, char **name) {
 674         const char *p;
 675         int r;
 676
 677         assert(name);
 678         assert(pid >= 0);
 679
 680         p = procfs_file_alloca(pid, "comm");
 681
 682         r = read_one_line_file(p, name);
 683         if (r == -ENOENT)
 684                 return -ESRCH;
 685
 686         return r;
 687 }
 688
 689 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
 690         _cleanup_fclose_ FILE *f = NULL;
 691         char *r = NULL, *k;
 692         const char *p;
 693         int c;
 694
 695         assert(line);
 696         assert(pid >= 0);
 697
 698         p = procfs_file_alloca(pid, "cmdline");
 699
 700         f = fopen(p, "re");
 701         if (!f)
 702                 return -errno;
 703
 704         if (max_length == 0) {
 705                 size_t len = 0, allocated = 0;
 706
 707                 while ((c = getc(f)) != EOF) {
 708
 709                         if (!GREEDY_REALLOC(r, allocated, len+2)) {
 710                                 free(r);
 711                                 return -ENOMEM;
 712                         }
 713
 714                         r[len++] = isprint(c) ? c : ' ';
 715                 }
 716
 717                 if (len > 0)
 718                         r[len-1] = 0;
 719
 720         } else {
 721                 bool space = false;
 722                 size_t left;
 723
 724                 r = new(char, max_length);
 725                 if (!r)
 726                         return -ENOMEM;
 727
 728                 k = r;
 729                 left = max_length;
 730                 while ((c = getc(f)) != EOF) {
 731
 732                         if (isprint(c)) {
 733                                 if (space) {
 734                                         if (left <= 4)
 735                                                 break;
 736
 737                                         *(k++) = ' ';
 738                                         left--;
 739                                         space = false;
 740                                 }
 741
 742                                 if (left <= 4)
 743                                         break;
 744
 745                                 *(k++) = (char) c;
 746                                 left--;
 747                         }  else
 748                                 space = true;
 749                 }
 750
 751                 if (left <= 4) {
 752                         size_t n = MIN(left-1, 3U);
 753                         memcpy(k, "...", n);
 754                         k[n] = 0;
 755                 } else
 756                         *k = 0;
 757         }
 758
 759         /* Kernel threads have no argv[] */
 760         if (isempty(r)) {
 761                 _cleanup_free_ char *t = NULL;
 762                 int h;
 763
 764                 free(r);
 765
 766                 if (!comm_fallback)
 767                         return -ENOENT;
 768
 769                 h = get_process_comm(pid, &t);
 770                 if (h < 0)
 771                         return h;
 772
 773                 r = strjoin("[", t, "]", NULL);
 774                 if (!r)
 775                         return -ENOMEM;
 776         }
 777
 778         *line = r;
 779         return 0;
 780 }
 781
 782 int is_kernel_thread(pid_t pid) {
 783         const char *p;
 784         size_t count;
 785         char c;
 786         bool eof;
 787         FILE *f;
 788
 789         if (pid == 0)
 790                 return 0;
 791
 792         assert(pid > 0);
 793
 794         p = procfs_file_alloca(pid, "cmdline");
 795         f = fopen(p, "re");
 796         if (!f)
 797                 return -errno;
 798
 799         count = fread(&c, 1, 1, f);
 800         eof = feof(f);
 801         fclose(f);
 802
 803         /* Kernel threads have an empty cmdline */
 804
 805         if (count <= 0)
 806                 return eof ? 1 : -errno;
 807
 808         return 0;
 809 }
 810
 811 int get_process_capeff(pid_t pid, char **capeff) {
 812         const char *p;
 813
 814         assert(capeff);
 815         assert(pid >= 0);
 816
 817         p = procfs_file_alloca(pid, "status");
 818
 819         return get_status_field(p, "\nCapEff:", capeff);
 820 }
 821
 822 static int get_process_link_contents(const char *proc_file, char **name) {
 823         int r;
 824
 825         assert(proc_file);
 826         assert(name);
 827
 828         r = readlink_malloc(proc_file, name);
 829         if (r < 0)
 830                 return r == -ENOENT ? -ESRCH : r;
 831
 832         return 0;
 833 }
 834
 835 int get_process_exe(pid_t pid, char **name) {
 836         const char *p;
 837         char *d;
 838         int r;
 839
 840         assert(pid >= 0);
 841
 842         p = procfs_file_alloca(pid, "exe");
 843         r = get_process_link_contents(p, name);
 844         if (r < 0)
 845                 return r;
 846
 847         d = endswith(*name, " (deleted)");
 848         if (d)
 849                 *d = '\0';
 850
 851         return 0;
 852 }
 853
 854 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
 855         _cleanup_fclose_ FILE *f = NULL;
 856         char line[LINE_MAX];
 857         const char *p;
 858
 859         assert(field);
 860         assert(uid);
 861
 862         if (pid == 0)
 863                 return getuid();
 864
 865         p = procfs_file_alloca(pid, "status");
 866         f = fopen(p, "re");
 867         if (!f)
 868                 return -errno;
 869
 870         FOREACH_LINE(line, f, return -errno) {
 871                 char *l;
 872
 873                 l = strstrip(line);
 874
 875                 if (startswith(l, field)) {
 876                         l += strlen(field);
 877                         l += strspn(l, WHITESPACE);
 878
 879                         l[strcspn(l, WHITESPACE)] = 0;
 880
 881                         return parse_uid(l, uid);
 882                 }
 883         }
 884
 885         return -EIO;
 886 }
 887
 888 int get_process_uid(pid_t pid, uid_t *uid) {
 889         return get_process_id(pid, "Uid:", uid);
 890 }
 891
 892 int get_process_gid(pid_t pid, gid_t *gid) {
 893         assert_cc(sizeof(uid_t) == sizeof(gid_t));
 894         return get_process_id(pid, "Gid:", gid);
 895 }
 896
 897 int get_process_cwd(pid_t pid, char **cwd) {
 898         const char *p;
 899
 900         assert(pid >= 0);
 901
 902         p = procfs_file_alloca(pid, "cwd");
 903
 904         return get_process_link_contents(p, cwd);
 905 }
 906
 907 int get_process_root(pid_t pid, char **root) {
 908         const char *p;
 909
 910         assert(pid >= 0);
 911
 912         p = procfs_file_alloca(pid, "root");
 913
 914         return get_process_link_contents(p, root);
 915 }
 916
 917 int get_process_environ(pid_t pid, char **env) {
 918         _cleanup_fclose_ FILE *f = NULL;
 919         _cleanup_free_ char *outcome = NULL;
 920         int c;
 921         const char *p;
 922         size_t allocated = 0, sz = 0;
 923
 924         assert(pid >= 0);
 925         assert(env);
 926
 927         p = procfs_file_alloca(pid, "environ");
 928
 929         f = fopen(p, "re");
 930         if (!f)
 931                 return -errno;
 932
 933         while ((c = fgetc(f)) != EOF) {
 934                 if (!GREEDY_REALLOC(outcome, allocated, sz + 5))
 935                         return -ENOMEM;
 936
 937                 if (c == '\0')
 938                         outcome[sz++] = '\n';
 939                 else
 940                         sz += cescape_char(c, outcome + sz);
 941         }
 942
 943         outcome[sz] = '\0';
 944         *env = outcome;
 945         outcome = NULL;
 946
 947         return 0;
 948 }
 949
 950 char *strnappend(const char *s, const char *suffix, size_t b) {
 951         size_t a;
 952         char *r;
 953
 954         if (!s && !suffix)
 955                 return strdup("");
 956
 957         if (!s)
 958                 return strndup(suffix, b);
 959
 960         if (!suffix)
 961                 return strdup(s);
 962
 963         assert(s);
 964         assert(suffix);
 965
 966         a = strlen(s);
 967         if (b > ((size_t) -1) - a)
 968                 return NULL;
 969
 970         r = new(char, a+b+1);
 971         if (!r)
 972                 return NULL;
 973
 974         memcpy(r, s, a);
 975         memcpy(r+a, suffix, b);
 976         r[a+b] = 0;
 977
 978         return r;
 979 }
 980
 981 char *strappend(const char *s, const char *suffix) {
 982         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
 983 }
 984
 985 int readlinkat_malloc(int fd, const char *p, char **ret) {
 986         size_t l = 100;
 987         int r;
 988
 989         assert(p);
 990         assert(ret);
 991
 992         for (;;) {
 993                 char *c;
 994                 ssize_t n;
 995
 996                 c = new(char, l);
 997                 if (!c)
 998                         return -ENOMEM;
 999
1000                 n = readlinkat(fd, p, c, l-1);
1001                 if (n < 0) {
1002                         r = -errno;
1003                         free(c);
1004                         return r;
1005                 }
1006
1007                 if ((size_t) n < l-1) {
1008                         c[n] = 0;
1009                         *ret = c;
1010                         return 0;
1011                 }
1012
1013                 free(c);
1014                 l *= 2;
1015         }
1016 }
1017
1018 int readlink_malloc(const char *p, char **ret) {
1019         return readlinkat_malloc(AT_FDCWD, p, ret);
1020 }
1021
1022 int readlink_value(const char *p, char **ret) {
1023         _cleanup_free_ char *link = NULL;
1024         char *value;
1025         int r;
1026
1027         r = readlink_malloc(p, &link);
1028         if (r < 0)
1029                 return r;
1030
1031         value = basename(link);
1032         if (!value)
1033                 return -ENOENT;
1034
1035         value = strdup(value);
1036         if (!value)
1037                 return -ENOMEM;
1038
1039         *ret = value;
1040
1041         return 0;
1042 }
1043
1044 int readlink_and_make_absolute(const char *p, char **r) {
1045         _cleanup_free_ char *target = NULL;
1046         char *k;
1047         int j;
1048
1049         assert(p);
1050         assert(r);
1051
1052         j = readlink_malloc(p, &target);
1053         if (j < 0)
1054                 return j;
1055
1056         k = file_in_same_dir(p, target);
1057         if (!k)
1058                 return -ENOMEM;
1059
1060         *r = k;
1061         return 0;
1062 }
1063
1064 int readlink_and_canonicalize(const char *p, char **r) {
1065         char *t, *s;
1066         int j;
1067
1068         assert(p);
1069         assert(r);
1070
1071         j = readlink_and_make_absolute(p, &t);
1072         if (j < 0)
1073                 return j;
1074
1075         s = canonicalize_file_name(t);
1076         if (s) {
1077                 free(t);
1078                 *r = s;
1079         } else
1080                 *r = t;
1081
1082         path_kill_slashes(*r);
1083
1084         return 0;
1085 }
1086
1087 int reset_all_signal_handlers(void) {
1088         int sig, r = 0;
1089
1090         for (sig = 1; sig < _NSIG; sig++) {
1091                 struct sigaction sa = {
1092                         .sa_handler = SIG_DFL,
1093                         .sa_flags = SA_RESTART,
1094                 };
1095
1096                 /* These two cannot be caught... */
1097                 if (sig == SIGKILL || sig == SIGSTOP)
1098                         continue;
1099
1100                 /* On Linux the first two RT signals are reserved by
1101                  * glibc, and sigaction() will return EINVAL for them. */
1102                 if ((sigaction(sig, &sa, NULL) < 0))
1103                         if (errno != EINVAL && r == 0)
1104                                 r = -errno;
1105         }
1106
1107         return r;
1108 }
1109
1110 int reset_signal_mask(void) {
1111         sigset_t ss;
1112
1113         if (sigemptyset(&ss) < 0)
1114                 return -errno;
1115
1116         if (sigprocmask(SIG_SETMASK, &ss, NULL) < 0)
1117                 return -errno;
1118
1119         return 0;
1120 }
1121
1122 char *strstrip(char *s) {
1123         char *e;
1124
1125         /* Drops trailing whitespace. Modifies the string in
1126          * place. Returns pointer to first non-space character */
1127
1128         s += strspn(s, WHITESPACE);
1129
1130         for (e = strchr(s, 0); e > s; e --)
1131                 if (!strchr(WHITESPACE, e[-1]))
1132                         break;
1133
1134         *e = 0;
1135
1136         return s;
1137 }
1138
1139 char *delete_chars(char *s, const char *bad) {
1140         char *f, *t;
1141
1142         /* Drops all whitespace, regardless where in the string */
1143
1144         for (f = s, t = s; *f; f++) {
1145                 if (strchr(bad, *f))
1146                         continue;
1147
1148                 *(t++) = *f;
1149         }
1150
1151         *t = 0;
1152
1153         return s;
1154 }
1155
1156 char *file_in_same_dir(const char *path, const char *filename) {
1157         char *e, *ret;
1158         size_t k;
1159
1160         assert(path);
1161         assert(filename);
1162
1163         /* This removes the last component of path and appends
1164          * filename, unless the latter is absolute anyway or the
1165          * former isn't */
1166
1167         if (path_is_absolute(filename))
1168                 return strdup(filename);
1169
1170         e = strrchr(path, '/');
1171         if (!e)
1172                 return strdup(filename);
1173
1174         k = strlen(filename);
1175         ret = new(char, (e + 1 - path) + k + 1);
1176         if (!ret)
1177                 return NULL;
1178
1179         memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);
1180         return ret;
1181 }
1182
1183 int rmdir_parents(const char *path, const char *stop) {
1184         size_t l;
1185         int r = 0;
1186
1187         assert(path);
1188         assert(stop);
1189
1190         l = strlen(path);
1191
1192         /* Skip trailing slashes */
1193         while (l > 0 && path[l-1] == '/')
1194                 l--;
1195
1196         while (l > 0) {
1197                 char *t;
1198
1199                 /* Skip last component */
1200                 while (l > 0 && path[l-1] != '/')
1201                         l--;
1202
1203                 /* Skip trailing slashes */
1204                 while (l > 0 && path[l-1] == '/')
1205                         l--;
1206
1207                 if (l <= 0)
1208                         break;
1209
1210                 if (!(t = strndup(path, l)))
1211                         return -ENOMEM;
1212
1213                 if (path_startswith(stop, t)) {
1214                         free(t);
1215                         return 0;
1216                 }
1217
1218                 r = rmdir(t);
1219                 free(t);
1220
1221                 if (r < 0)
1222                         if (errno != ENOENT)
1223                                 return -errno;
1224         }
1225
1226         return 0;
1227 }
1228
1229 char hexchar(int x) {
1230         static const char table[16] = "0123456789abcdef";
1231
1232         return table[x & 15];
1233 }
1234
1235 int unhexchar(char c) {
1236
1237         if (c >= '0' && c <= '9')
1238                 return c - '0';
1239
1240         if (c >= 'a' && c <= 'f')
1241                 return c - 'a' + 10;
1242
1243         if (c >= 'A' && c <= 'F')
1244                 return c - 'A' + 10;
1245
1246         return -EINVAL;
1247 }
1248
1249 char *hexmem(const void *p, size_t l) {
1250         char *r, *z;
1251         const uint8_t *x;
1252
1253         z = r = malloc(l * 2 + 1);
1254         if (!r)
1255                 return NULL;
1256
1257         for (x = p; x < (const uint8_t*) p + l; x++) {
1258                 *(z++) = hexchar(*x >> 4);
1259                 *(z++) = hexchar(*x & 15);
1260         }
1261
1262         *z = 0;
1263         return r;
1264 }
1265
1266 void *unhexmem(const char *p, size_t l) {
1267         uint8_t *r, *z;
1268         const char *x;
1269
1270         assert(p);
1271
1272         z = r = malloc((l + 1) / 2 + 1);
1273         if (!r)
1274                 return NULL;
1275
1276         for (x = p; x < p + l; x += 2) {
1277                 int a, b;
1278
1279                 a = unhexchar(x[0]);
1280                 if (x+1 < p + l)
1281                         b = unhexchar(x[1]);
1282                 else
1283                         b = 0;
1284
1285                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1286         }
1287
1288         *z = 0;
1289         return r;
1290 }
1291
1292 char octchar(int x) {
1293         return '0' + (x & 7);
1294 }
1295
1296 int unoctchar(char c) {
1297
1298         if (c >= '0' && c <= '7')
1299                 return c - '0';
1300
1301         return -EINVAL;
1302 }
1303
1304 char decchar(int x) {
1305         return '0' + (x % 10);
1306 }
1307
1308 int undecchar(char c) {
1309
1310         if (c >= '0' && c <= '9')
1311                 return c - '0';
1312
1313         return -EINVAL;
1314 }
1315
1316 char *cescape(const char *s) {
1317         char *r, *t;
1318         const char *f;
1319
1320         assert(s);
1321
1322         /* Does C style string escaping. */
1323
1324         r = new(char, strlen(s)*4 + 1);
1325         if (!r)
1326                 return NULL;
1327
1328         for (f = s, t = r; *f; f++)
1329                 t += cescape_char(*f, t);
1330
1331         *t = 0;
1332
1333         return r;
1334 }
1335
1336 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1337         char *r, *t;
1338         const char *f;
1339         size_t pl;
1340
1341         assert(s);
1342
1343         /* Undoes C style string escaping, and optionally prefixes it. */
1344
1345         pl = prefix ? strlen(prefix) : 0;
1346
1347         r = new(char, pl+length+1);
1348         if (!r)
1349                 return NULL;
1350
1351         if (prefix)
1352                 memcpy(r, prefix, pl);
1353
1354         for (f = s, t = r + pl; f < s + length; f++) {
1355                 size_t remaining = s + length - f;
1356                 assert(remaining > 0);
1357
1358                 if (*f != '\\') {        /* a literal literal */
1359                         *(t++) = *f;
1360                         continue;
1361                 }
1362
1363                 if (--remaining == 0) {  /* copy trailing backslash verbatim */
1364                         *(t++) = *f;
1365                         break;
1366                 }
1367
1368                 f++;
1369
1370                 switch (*f) {
1371
1372                 case 'a':
1373                         *(t++) = '\a';
1374                         break;
1375                 case 'b':
1376                         *(t++) = '\b';
1377                         break;
1378                 case 'f':
1379                         *(t++) = '\f';
1380                         break;
1381                 case 'n':
1382                         *(t++) = '\n';
1383                         break;
1384                 case 'r':
1385                         *(t++) = '\r';
1386                         break;
1387                 case 't':
1388                         *(t++) = '\t';
1389                         break;
1390                 case 'v':
1391                         *(t++) = '\v';
1392                         break;
1393                 case '\\':
1394                         *(t++) = '\\';
1395                         break;
1396                 case '"':
1397                         *(t++) = '"';
1398                         break;
1399                 case '\'':
1400                         *(t++) = '\'';
1401                         break;
1402
1403                 case 's':
1404                         /* This is an extension of the XDG syntax files */
1405                         *(t++) = ' ';
1406                         break;
1407
1408                 case 'x': {
1409                         /* hexadecimal encoding */
1410                         int a = -1, b = -1;
1411
1412                         if (remaining >= 2) {
1413                                 a = unhexchar(f[1]);
1414                                 b = unhexchar(f[2]);
1415                         }
1416
1417                         if (a < 0 || b < 0 || (a == 0 && b == 0)) {
1418                                 /* Invalid escape code, let's take it literal then */
1419                                 *(t++) = '\\';
1420                                 *(t++) = 'x';
1421                         } else {
1422                                 *(t++) = (char) ((a << 4) | b);
1423                                 f += 2;
1424                         }
1425
1426                         break;
1427                 }
1428
1429                 case '0':
1430                 case '1':
1431                 case '2':
1432                 case '3':
1433                 case '4':
1434                 case '5':
1435                 case '6':
1436                 case '7': {
1437                         /* octal encoding */
1438                         int a = -1, b = -1, c = -1;
1439
1440                         if (remaining >= 3) {
1441                                 a = unoctchar(f[0]);
1442                                 b = unoctchar(f[1]);
1443                                 c = unoctchar(f[2]);
1444                         }
1445
1446                         if (a < 0 || b < 0 || c < 0 || (a == 0 && b == 0 && c == 0)) {
1447                                 /* Invalid escape code, let's take it literal then */
1448                                 *(t++) = '\\';
1449                                 *(t++) = f[0];
1450                         } else {
1451                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1452                                 f += 2;
1453                         }
1454
1455                         break;
1456                 }
1457
1458                 default:
1459                         /* Invalid escape code, let's take it literal then */
1460                         *(t++) = '\\';
1461                         *(t++) = *f;
1462                         break;
1463                 }
1464         }
1465
1466         *t = 0;
1467         return r;
1468 }
1469
1470 char *cunescape_length(const char *s, size_t length) {
1471         return cunescape_length_with_prefix(s, length, NULL);
1472 }
1473
1474 char *cunescape(const char *s) {
1475         assert(s);
1476
1477         return cunescape_length(s, strlen(s));
1478 }
1479
1480 char *xescape(const char *s, const char *bad) {
1481         char *r, *t;
1482         const char *f;
1483
1484         /* Escapes all chars in bad, in addition to \ and all special
1485          * chars, in \xFF style escaping. May be reversed with
1486          * cunescape. */
1487
1488         r = new(char, strlen(s) * 4 + 1);
1489         if (!r)
1490                 return NULL;
1491
1492         for (f = s, t = r; *f; f++) {
1493
1494                 if ((*f < ' ') || (*f >= 127) ||
1495                     (*f == '\\') || strchr(bad, *f)) {
1496                         *(t++) = '\\';
1497                         *(t++) = 'x';
1498                         *(t++) = hexchar(*f >> 4);
1499                         *(t++) = hexchar(*f);
1500                 } else
1501                         *(t++) = *f;
1502         }
1503
1504         *t = 0;
1505
1506         return r;
1507 }
1508
1509 char *ascii_strlower(char *t) {
1510         char *p;
1511
1512         assert(t);
1513
1514         for (p = t; *p; p++)
1515                 if (*p >= 'A' && *p <= 'Z')
1516                         *p = *p - 'A' + 'a';
1517
1518         return t;
1519 }
1520
1521 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1522         assert(filename);
1523
1524         return
1525                 filename[0] == '.' ||
1526                 streq(filename, "lost+found") ||
1527                 streq(filename, "aquota.user") ||
1528                 streq(filename, "aquota.group") ||
1529                 endswith(filename, ".rpmnew") ||
1530                 endswith(filename, ".rpmsave") ||
1531                 endswith(filename, ".rpmorig") ||
1532                 endswith(filename, ".dpkg-old") ||
1533                 endswith(filename, ".dpkg-new") ||
1534                 endswith(filename, ".dpkg-tmp") ||
1535                 endswith(filename, ".swp");
1536 }
1537
1538 bool hidden_file(const char *filename) {
1539         assert(filename);
1540
1541         if (endswith(filename, "~"))
1542                 return true;
1543
1544         return hidden_file_allow_backup(filename);
1545 }
1546
1547 int fd_nonblock(int fd, bool nonblock) {
1548         int flags, nflags;
1549
1550         assert(fd >= 0);
1551
1552         flags = fcntl(fd, F_GETFL, 0);
1553         if (flags < 0)
1554                 return -errno;
1555
1556         if (nonblock)
1557                 nflags = flags | O_NONBLOCK;
1558         else
1559                 nflags = flags & ~O_NONBLOCK;
1560
1561         if (nflags == flags)
1562                 return 0;
1563
1564         if (fcntl(fd, F_SETFL, nflags) < 0)
1565                 return -errno;
1566
1567         return 0;
1568 }
1569
1570 int fd_cloexec(int fd, bool cloexec) {
1571         int flags, nflags;
1572
1573         assert(fd >= 0);
1574
1575         flags = fcntl(fd, F_GETFD, 0);
1576         if (flags < 0)
1577                 return -errno;
1578
1579         if (cloexec)
1580                 nflags = flags | FD_CLOEXEC;
1581         else
1582                 nflags = flags & ~FD_CLOEXEC;
1583
1584         if (nflags == flags)
1585                 return 0;
1586
1587         if (fcntl(fd, F_SETFD, nflags) < 0)
1588                 return -errno;
1589
1590         return 0;
1591 }
1592
1593 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1594         unsigned i;
1595
1596         assert(n_fdset == 0 || fdset);
1597
1598         for (i = 0; i < n_fdset; i++)
1599                 if (fdset[i] == fd)
1600                         return true;
1601
1602         return false;
1603 }
1604
1605 int close_all_fds(const int except[], unsigned n_except) {
1606         _cleanup_closedir_ DIR *d = NULL;
1607         struct dirent *de;
1608         int r = 0;
1609
1610         assert(n_except == 0 || except);
1611
1612         d = opendir("/proc/self/fd");
1613         if (!d) {
1614                 int fd;
1615                 struct rlimit rl;
1616
1617                 /* When /proc isn't available (for example in chroots)
1618                  * the fallback is brute forcing through the fd
1619                  * table */
1620
1621                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1622                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1623
1624                         if (fd_in_set(fd, except, n_except))
1625                                 continue;
1626
1627                         if (close_nointr(fd) < 0)
1628                                 if (errno != EBADF && r == 0)
1629                                         r = -errno;
1630                 }
1631
1632                 return r;
1633         }
1634
1635         while ((de = readdir(d))) {
1636                 int fd = -1;
1637
1638                 if (hidden_file(de->d_name))
1639                         continue;
1640
1641                 if (safe_atoi(de->d_name, &fd) < 0)
1642                         /* Let's better ignore this, just in case */
1643                         continue;
1644
1645                 if (fd < 3)
1646                         continue;
1647
1648                 if (fd == dirfd(d))
1649                         continue;
1650
1651                 if (fd_in_set(fd, except, n_except))
1652                         continue;
1653
1654                 if (close_nointr(fd) < 0) {
1655                         /* Valgrind has its own FD and doesn't want to have it closed */
1656                         if (errno != EBADF && r == 0)
1657                                 r = -errno;
1658                 }
1659         }
1660
1661         return r;
1662 }
1663
1664 bool chars_intersect(const char *a, const char *b) {
1665         const char *p;
1666
1667         /* Returns true if any of the chars in a are in b. */
1668         for (p = a; *p; p++)
1669                 if (strchr(b, *p))
1670                         return true;
1671
1672         return false;
1673 }
1674
1675 bool fstype_is_network(const char *fstype) {
1676         static const char table[] =
1677                 "cifs\0"
1678                 "smbfs\0"
1679                 "sshfs\0"
1680                 "ncpfs\0"
1681                 "ncp\0"
1682                 "nfs\0"
1683                 "nfs4\0"
1684                 "gfs\0"
1685                 "gfs2\0"
1686                 "glusterfs\0";
1687
1688         const char *x;
1689
1690         x = startswith(fstype, "fuse.");
1691         if (x)
1692                 fstype = x;
1693
1694         return nulstr_contains(table, fstype);
1695 }
1696
1697 int chvt(int vt) {
1698         _cleanup_close_ int fd;
1699
1700         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1701         if (fd < 0)
1702                 return -errno;
1703
1704         if (vt < 0) {
1705                 int tiocl[2] = {
1706                         TIOCL_GETKMSGREDIRECT,
1707                         0
1708                 };
1709
1710                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1711                         return -errno;
1712
1713                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1714         }
1715
1716         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1717                 return -errno;
1718
1719         return 0;
1720 }
1721
1722 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1723         struct termios old_termios, new_termios;
1724         char c, line[LINE_MAX];
1725
1726         assert(f);
1727         assert(ret);
1728
1729         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1730                 new_termios = old_termios;
1731
1732                 new_termios.c_lflag &= ~ICANON;
1733                 new_termios.c_cc[VMIN] = 1;
1734                 new_termios.c_cc[VTIME] = 0;
1735
1736                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1737                         size_t k;
1738
1739                         if (t != USEC_INFINITY) {
1740                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1741                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1742                                         return -ETIMEDOUT;
1743                                 }
1744                         }
1745
1746                         k = fread(&c, 1, 1, f);
1747
1748                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1749
1750                         if (k <= 0)
1751                                 return -EIO;
1752
1753                         if (need_nl)
1754                                 *need_nl = c != '\n';
1755
1756                         *ret = c;
1757                         return 0;
1758                 }
1759         }
1760
1761         if (t != USEC_INFINITY) {
1762                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1763                         return -ETIMEDOUT;
1764         }
1765
1766         errno = 0;
1767         if (!fgets(line, sizeof(line), f))
1768                 return errno ? -errno : -EIO;
1769
1770         truncate_nl(line);
1771
1772         if (strlen(line) != 1)
1773                 return -EBADMSG;
1774
1775         if (need_nl)
1776                 *need_nl = false;
1777
1778         *ret = line[0];
1779         return 0;
1780 }
1781
1782 int ask_char(char *ret, const char *replies, const char *text, ...) {
1783         int r;
1784
1785         assert(ret);
1786         assert(replies);
1787         assert(text);
1788
1789         for (;;) {
1790                 va_list ap;
1791                 char c;
1792                 bool need_nl = true;
1793
1794                 if (on_tty())
1795                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1796
1797                 va_start(ap, text);
1798                 vprintf(text, ap);
1799                 va_end(ap);
1800
1801                 if (on_tty())
1802                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1803
1804                 fflush(stdout);
1805
1806                 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1807                 if (r < 0) {
1808
1809                         if (r == -EBADMSG) {
1810                                 puts("Bad input, please try again.");
1811                                 continue;
1812                         }
1813
1814                         putchar('\n');
1815                         return r;
1816                 }
1817
1818                 if (need_nl)
1819                         putchar('\n');
1820
1821                 if (strchr(replies, c)) {
1822                         *ret = c;
1823                         return 0;
1824                 }
1825
1826                 puts("Read unexpected character, please try again.");
1827         }
1828 }
1829
1830 int ask_string(char **ret, const char *text, ...) {
1831         assert(ret);
1832         assert(text);
1833
1834         for (;;) {
1835                 char line[LINE_MAX];
1836                 va_list ap;
1837
1838                 if (on_tty())
1839                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1840
1841                 va_start(ap, text);
1842                 vprintf(text, ap);
1843                 va_end(ap);
1844
1845                 if (on_tty())
1846                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1847
1848                 fflush(stdout);
1849
1850                 errno = 0;
1851                 if (!fgets(line, sizeof(line), stdin))
1852                         return errno ? -errno : -EIO;
1853
1854                 if (!endswith(line, "\n"))
1855                         putchar('\n');
1856                 else {
1857                         char *s;
1858
1859                         if (isempty(line))
1860                                 continue;
1861
1862                         truncate_nl(line);
1863                         s = strdup(line);
1864                         if (!s)
1865                                 return -ENOMEM;
1866
1867                         *ret = s;
1868                         return 0;
1869                 }
1870         }
1871 }
1872
1873 int reset_terminal_fd(int fd, bool switch_to_text) {
1874         struct termios termios;
1875         int r = 0;
1876
1877         /* Set terminal to some sane defaults */
1878
1879         assert(fd >= 0);
1880
1881         /* We leave locked terminal attributes untouched, so that
1882          * Plymouth may set whatever it wants to set, and we don't
1883          * interfere with that. */
1884
1885         /* Disable exclusive mode, just in case */
1886         ioctl(fd, TIOCNXCL);
1887
1888         /* Switch to text mode */
1889         if (switch_to_text)
1890                 ioctl(fd, KDSETMODE, KD_TEXT);
1891
1892         /* Enable console unicode mode */
1893         ioctl(fd, KDSKBMODE, K_UNICODE);
1894
1895         if (tcgetattr(fd, &termios) < 0) {
1896                 r = -errno;
1897                 goto finish;
1898         }
1899
1900         /* We only reset the stuff that matters to the software. How
1901          * hardware is set up we don't touch assuming that somebody
1902          * else will do that for us */
1903
1904         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1905         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1906         termios.c_oflag |= ONLCR;
1907         termios.c_cflag |= CREAD;
1908         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1909
1910         termios.c_cc[VINTR]    =   03;  /* ^C */
1911         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1912         termios.c_cc[VERASE]   = 0177;
1913         termios.c_cc[VKILL]    =  025;  /* ^X */
1914         termios.c_cc[VEOF]     =   04;  /* ^D */
1915         termios.c_cc[VSTART]   =  021;  /* ^Q */
1916         termios.c_cc[VSTOP]    =  023;  /* ^S */
1917         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1918         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1919         termios.c_cc[VWERASE]  =  027;  /* ^W */
1920         termios.c_cc[VREPRINT] =  022;  /* ^R */
1921         termios.c_cc[VEOL]     =    0;
1922         termios.c_cc[VEOL2]    =    0;
1923
1924         termios.c_cc[VTIME]  = 0;
1925         termios.c_cc[VMIN]   = 1;
1926
1927         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1928                 r = -errno;
1929
1930 finish:
1931         /* Just in case, flush all crap out */
1932         tcflush(fd, TCIOFLUSH);
1933
1934         return r;
1935 }
1936
1937 int reset_terminal(const char *name) {
1938         _cleanup_close_ int fd = -1;
1939
1940         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1941         if (fd < 0)
1942                 return fd;
1943
1944         return reset_terminal_fd(fd, true);
1945 }
1946
1947 int open_terminal(const char *name, int mode) {
1948         int fd, r;
1949         unsigned c = 0;
1950
1951         /*
1952          * If a TTY is in the process of being closed opening it might
1953          * cause EIO. This is horribly awful, but unlikely to be
1954          * changed in the kernel. Hence we work around this problem by
1955          * retrying a couple of times.
1956          *
1957          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1958          */
1959
1960         assert(!(mode & O_CREAT));
1961
1962         for (;;) {
1963                 fd = open(name, mode, 0);
1964                 if (fd >= 0)
1965                         break;
1966
1967                 if (errno != EIO)
1968                         return -errno;
1969
1970                 /* Max 1s in total */
1971                 if (c >= 20)
1972                         return -errno;
1973
1974                 usleep(50 * USEC_PER_MSEC);
1975                 c++;
1976         }
1977
1978         r = isatty(fd);
1979         if (r < 0) {
1980                 safe_close(fd);
1981                 return -errno;
1982         }
1983
1984         if (!r) {
1985                 safe_close(fd);
1986                 return -ENOTTY;
1987         }
1988
1989         return fd;
1990 }
1991
1992 int flush_fd(int fd) {
1993         struct pollfd pollfd = {
1994                 .fd = fd,
1995                 .events = POLLIN,
1996         };
1997
1998         for (;;) {
1999                 char buf[LINE_MAX];
2000                 ssize_t l;
2001                 int r;
2002
2003                 r = poll(&pollfd, 1, 0);
2004                 if (r < 0) {
2005                         if (errno == EINTR)
2006                                 continue;
2007
2008                         return -errno;
2009
2010                 } else if (r == 0)
2011                         return 0;
2012
2013                 l = read(fd, buf, sizeof(buf));
2014                 if (l < 0) {
2015
2016                         if (errno == EINTR)
2017                                 continue;
2018
2019                         if (errno == EAGAIN)
2020                                 return 0;
2021
2022                         return -errno;
2023                 } else if (l == 0)
2024                         return 0;
2025         }
2026 }
2027
2028 int acquire_terminal(
2029                 const char *name,
2030                 bool fail,
2031                 bool force,
2032                 bool ignore_tiocstty_eperm,
2033                 usec_t timeout) {
2034
2035         int fd = -1, notify = -1, r = 0, wd = -1;
2036         usec_t ts = 0;
2037
2038         assert(name);
2039
2040         /* We use inotify to be notified when the tty is closed. We
2041          * create the watch before checking if we can actually acquire
2042          * it, so that we don't lose any event.
2043          *
2044          * Note: strictly speaking this actually watches for the
2045          * device being closed, it does *not* really watch whether a
2046          * tty loses its controlling process. However, unless some
2047          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2048          * its tty otherwise this will not become a problem. As long
2049          * as the administrator makes sure not configure any service
2050          * on the same tty as an untrusted user this should not be a
2051          * problem. (Which he probably should not do anyway.) */
2052
2053         if (timeout != USEC_INFINITY)
2054                 ts = now(CLOCK_MONOTONIC);
2055
2056         if (!fail && !force) {
2057                 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
2058                 if (notify < 0) {
2059                         r = -errno;
2060                         goto fail;
2061                 }
2062
2063                 wd = inotify_add_watch(notify, name, IN_CLOSE);
2064                 if (wd < 0) {
2065                         r = -errno;
2066                         goto fail;
2067                 }
2068         }
2069
2070         for (;;) {
2071                 struct sigaction sa_old, sa_new = {
2072                         .sa_handler = SIG_IGN,
2073                         .sa_flags = SA_RESTART,
2074                 };
2075
2076                 if (notify >= 0) {
2077                         r = flush_fd(notify);
2078                         if (r < 0)
2079                                 goto fail;
2080                 }
2081
2082                 /* We pass here O_NOCTTY only so that we can check the return
2083                  * value TIOCSCTTY and have a reliable way to figure out if we
2084                  * successfully became the controlling process of the tty */
2085                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2086                 if (fd < 0)
2087                         return fd;
2088
2089                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2090                  * if we already own the tty. */
2091                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2092
2093                 /* First, try to get the tty */
2094                 if (ioctl(fd, TIOCSCTTY, force) < 0)
2095                         r = -errno;
2096
2097                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2098
2099                 /* Sometimes it makes sense to ignore TIOCSCTTY
2100                  * returning EPERM, i.e. when very likely we already
2101                  * are have this controlling terminal. */
2102                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
2103                         r = 0;
2104
2105                 if (r < 0 && (force || fail || r != -EPERM)) {
2106                         goto fail;
2107                 }
2108
2109                 if (r >= 0)
2110                         break;
2111
2112                 assert(!fail);
2113                 assert(!force);
2114                 assert(notify >= 0);
2115
2116                 for (;;) {
2117                         union inotify_event_buffer buffer;
2118                         struct inotify_event *e;
2119                         ssize_t l;
2120
2121                         if (timeout != USEC_INFINITY) {
2122                                 usec_t n;
2123
2124                                 n = now(CLOCK_MONOTONIC);
2125                                 if (ts + timeout < n) {
2126                                         r = -ETIMEDOUT;
2127                                         goto fail;
2128                                 }
2129
2130                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2131                                 if (r < 0)
2132                                         goto fail;
2133
2134                                 if (r == 0) {
2135                                         r = -ETIMEDOUT;
2136                                         goto fail;
2137                                 }
2138                         }
2139
2140                         l = read(notify, &buffer, sizeof(buffer));
2141                         if (l < 0) {
2142                                 if (errno == EINTR || errno == EAGAIN)
2143                                         continue;
2144
2145                                 r = -errno;
2146                                 goto fail;
2147                         }
2148
2149                         FOREACH_INOTIFY_EVENT(e, buffer, l) {
2150                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2151                                         r = -EIO;
2152                                         goto fail;
2153                                 }
2154                         }
2155
2156                         break;
2157                 }
2158
2159                 /* We close the tty fd here since if the old session
2160                  * ended our handle will be dead. It's important that
2161                  * we do this after sleeping, so that we don't enter
2162                  * an endless loop. */
2163                 fd = safe_close(fd);
2164         }
2165
2166         safe_close(notify);
2167
2168         r = reset_terminal_fd(fd, true);
2169         if (r < 0)
2170                 log_warning_errno(r, "Failed to reset terminal: %m");
2171
2172         return fd;
2173
2174 fail:
2175         safe_close(fd);
2176         safe_close(notify);
2177
2178         return r;
2179 }
2180
2181 int release_terminal(void) {
2182         static const struct sigaction sa_new = {
2183                 .sa_handler = SIG_IGN,
2184                 .sa_flags = SA_RESTART,
2185         };
2186
2187         _cleanup_close_ int fd = -1;
2188         struct sigaction sa_old;
2189         int r = 0;
2190
2191         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2192         if (fd < 0)
2193                 return -errno;
2194
2195         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2196          * by our own TIOCNOTTY */
2197         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2198
2199         if (ioctl(fd, TIOCNOTTY) < 0)
2200                 r = -errno;
2201
2202         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2203
2204         return r;
2205 }
2206
2207 int sigaction_many(const struct sigaction *sa, ...) {
2208         va_list ap;
2209         int r = 0, sig;
2210
2211         va_start(ap, sa);
2212         while ((sig = va_arg(ap, int)) > 0)
2213                 if (sigaction(sig, sa, NULL) < 0)
2214                         r = -errno;
2215         va_end(ap);
2216
2217         return r;
2218 }
2219
2220 int ignore_signals(int sig, ...) {
2221         struct sigaction sa = {
2222                 .sa_handler = SIG_IGN,
2223                 .sa_flags = SA_RESTART,
2224         };
2225         va_list ap;
2226         int r = 0;
2227
2228         if (sigaction(sig, &sa, NULL) < 0)
2229                 r = -errno;
2230
2231         va_start(ap, sig);
2232         while ((sig = va_arg(ap, int)) > 0)
2233                 if (sigaction(sig, &sa, NULL) < 0)
2234                         r = -errno;
2235         va_end(ap);
2236
2237         return r;
2238 }
2239
2240 int default_signals(int sig, ...) {
2241         struct sigaction sa = {
2242                 .sa_handler = SIG_DFL,
2243                 .sa_flags = SA_RESTART,
2244         };
2245         va_list ap;
2246         int r = 0;
2247
2248         if (sigaction(sig, &sa, NULL) < 0)
2249                 r = -errno;
2250
2251         va_start(ap, sig);
2252         while ((sig = va_arg(ap, int)) > 0)
2253                 if (sigaction(sig, &sa, NULL) < 0)
2254                         r = -errno;
2255         va_end(ap);
2256
2257         return r;
2258 }
2259
2260 void safe_close_pair(int p[]) {
2261         assert(p);
2262
2263         if (p[0] == p[1]) {
2264                 /* Special case pairs which use the same fd in both
2265                  * directions... */
2266                 p[0] = p[1] = safe_close(p[0]);
2267                 return;
2268         }
2269
2270         p[0] = safe_close(p[0]);
2271         p[1] = safe_close(p[1]);
2272 }
2273
2274 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2275         uint8_t *p = buf;
2276         ssize_t n = 0;
2277
2278         assert(fd >= 0);
2279         assert(buf);
2280
2281         while (nbytes > 0) {
2282                 ssize_t k;
2283
2284                 k = read(fd, p, nbytes);
2285                 if (k < 0) {
2286                         if (errno == EINTR)
2287                                 continue;
2288
2289                         if (errno == EAGAIN && do_poll) {
2290
2291                                 /* We knowingly ignore any return value here,
2292                                  * and expect that any error/EOF is reported
2293                                  * via read() */
2294
2295                                 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2296                                 continue;
2297                         }
2298
2299                         return n > 0 ? n : -errno;
2300                 }
2301
2302                 if (k == 0)
2303                         return n;
2304
2305                 p += k;
2306                 nbytes -= k;
2307                 n += k;
2308         }
2309
2310         return n;
2311 }
2312
2313 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2314         const uint8_t *p = buf;
2315
2316         assert(fd >= 0);
2317         assert(buf);
2318
2319         errno = 0;
2320
2321         while (nbytes > 0) {
2322                 ssize_t k;
2323
2324                 k = write(fd, p, nbytes);
2325                 if (k < 0) {
2326                         if (errno == EINTR)
2327                                 continue;
2328
2329                         if (errno == EAGAIN && do_poll) {
2330                                 /* We knowingly ignore any return value here,
2331                                  * and expect that any error/EOF is reported
2332                                  * via write() */
2333
2334                                 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2335                                 continue;
2336                         }
2337
2338                         return -errno;
2339                 }
2340
2341                 if (k == 0) /* Can't really happen */
2342                         return -EIO;
2343
2344                 p += k;
2345                 nbytes -= k;
2346         }
2347
2348         return 0;
2349 }
2350
2351 int parse_size(const char *t, off_t base, off_t *size) {
2352
2353         /* Soo, sometimes we want to parse IEC binary suffxies, and
2354          * sometimes SI decimal suffixes. This function can parse
2355          * both. Which one is the right way depends on the
2356          * context. Wikipedia suggests that SI is customary for
2357          * hardrware metrics and network speeds, while IEC is
2358          * customary for most data sizes used by software and volatile
2359          * (RAM) memory. Hence be careful which one you pick!
2360          *
2361          * In either case we use just K, M, G as suffix, and not Ki,
2362          * Mi, Gi or so (as IEC would suggest). That's because that's
2363          * frickin' ugly. But this means you really need to make sure
2364          * to document which base you are parsing when you use this
2365          * call. */
2366
2367         struct table {
2368                 const char *suffix;
2369                 unsigned long long factor;
2370         };
2371
2372         static const struct table iec[] = {
2373                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2374                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2375                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2376                 { "G", 1024ULL*1024ULL*1024ULL },
2377                 { "M", 1024ULL*1024ULL },
2378                 { "K", 1024ULL },
2379                 { "B", 1 },
2380                 { "", 1 },
2381         };
2382
2383         static const struct table si[] = {
2384                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2385                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2386                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2387                 { "G", 1000ULL*1000ULL*1000ULL },
2388                 { "M", 1000ULL*1000ULL },
2389                 { "K", 1000ULL },
2390                 { "B", 1 },
2391                 { "", 1 },
2392         };
2393
2394         const struct table *table;
2395         const char *p;
2396         unsigned long long r = 0;
2397         unsigned n_entries, start_pos = 0;
2398
2399         assert(t);
2400         assert(base == 1000 || base == 1024);
2401         assert(size);
2402
2403         if (base == 1000) {
2404                 table = si;
2405                 n_entries = ELEMENTSOF(si);
2406         } else {
2407                 table = iec;
2408                 n_entries = ELEMENTSOF(iec);
2409         }
2410
2411         p = t;
2412         do {
2413                 long long l;
2414                 unsigned long long l2;
2415                 double frac = 0;
2416                 char *e;
2417                 unsigned i;
2418
2419                 errno = 0;
2420                 l = strtoll(p, &e, 10);
2421
2422                 if (errno > 0)
2423                         return -errno;
2424
2425                 if (l < 0)
2426                         return -ERANGE;
2427
2428                 if (e == p)
2429                         return -EINVAL;
2430
2431                 if (*e == '.') {
2432                         e++;
2433                         if (*e >= '0' && *e <= '9') {
2434                                 char *e2;
2435
2436                                 /* strotoull itself would accept space/+/- */
2437                                 l2 = strtoull(e, &e2, 10);
2438
2439                                 if (errno == ERANGE)
2440                                         return -errno;
2441
2442                                 /* Ignore failure. E.g. 10.M is valid */
2443                                 frac = l2;
2444                                 for (; e < e2; e++)
2445                                         frac /= 10;
2446                         }
2447                 }
2448
2449                 e += strspn(e, WHITESPACE);
2450
2451                 for (i = start_pos; i < n_entries; i++)
2452                         if (startswith(e, table[i].suffix)) {
2453                                 unsigned long long tmp;
2454                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2455                                         return -ERANGE;
2456                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2457                                 if (tmp > ULLONG_MAX - r)
2458                                         return -ERANGE;
2459
2460                                 r += tmp;
2461                                 if ((unsigned long long) (off_t) r != r)
2462                                         return -ERANGE;
2463
2464                                 p = e + strlen(table[i].suffix);
2465
2466                                 start_pos = i + 1;
2467                                 break;
2468                         }
2469
2470                 if (i >= n_entries)
2471                         return -EINVAL;
2472
2473         } while (*p);
2474
2475         *size = r;
2476
2477         return 0;
2478 }
2479
2480 int make_stdio(int fd) {
2481         int r, s, t;
2482
2483         assert(fd >= 0);
2484
2485         r = dup2(fd, STDIN_FILENO);
2486         s = dup2(fd, STDOUT_FILENO);
2487         t = dup2(fd, STDERR_FILENO);
2488
2489         if (fd >= 3)
2490                 safe_close(fd);
2491
2492         if (r < 0 || s < 0 || t < 0)
2493                 return -errno;
2494
2495         /* Explicitly unset O_CLOEXEC, since if fd was < 3, then
2496          * dup2() was a NOP and the bit hence possibly set. */
2497         fd_cloexec(STDIN_FILENO, false);
2498         fd_cloexec(STDOUT_FILENO, false);
2499         fd_cloexec(STDERR_FILENO, false);
2500
2501         return 0;
2502 }
2503
2504 int make_null_stdio(void) {
2505         int null_fd;
2506
2507         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2508         if (null_fd < 0)
2509                 return -errno;
2510
2511         return make_stdio(null_fd);
2512 }
2513
2514 bool is_device_path(const char *path) {
2515
2516         /* Returns true on paths that refer to a device, either in
2517          * sysfs or in /dev */
2518
2519         return
2520                 path_startswith(path, "/dev/") ||
2521                 path_startswith(path, "/sys/");
2522 }
2523
2524 int dir_is_empty(const char *path) {
2525         _cleanup_closedir_ DIR *d;
2526
2527         d = opendir(path);
2528         if (!d)
2529                 return -errno;
2530
2531         for (;;) {
2532                 struct dirent *de;
2533
2534                 errno = 0;
2535                 de = readdir(d);
2536                 if (!de && errno != 0)
2537                         return -errno;
2538
2539                 if (!de)
2540                         return 1;
2541
2542                 if (!hidden_file(de->d_name))
2543                         return 0;
2544         }
2545 }
2546
2547 char* dirname_malloc(const char *path) {
2548         char *d, *dir, *dir2;
2549
2550         d = strdup(path);
2551         if (!d)
2552                 return NULL;
2553         dir = dirname(d);
2554         assert(dir);
2555
2556         if (dir != d) {
2557                 dir2 = strdup(dir);
2558                 free(d);
2559                 return dir2;
2560         }
2561
2562         return dir;
2563 }
2564
2565 int dev_urandom(void *p, size_t n) {
2566         static int have_syscall = -1;
2567         int r, fd;
2568         ssize_t k;
2569
2570         /* Gathers some randomness from the kernel. This call will
2571          * never block, and will always return some data from the
2572          * kernel, regardless if the random pool is fully initialized
2573          * or not. It thus makes no guarantee for the quality of the
2574          * returned entropy, but is good enough for or usual usecases
2575          * of seeding the hash functions for hashtable */
2576
2577         /* Use the getrandom() syscall unless we know we don't have
2578          * it, or when the requested size is too large for it. */
2579         if (have_syscall != 0 || (size_t) (int) n != n) {
2580                 r = getrandom(p, n, GRND_NONBLOCK);
2581                 if (r == (int) n) {
2582                         have_syscall = true;
2583                         return 0;
2584                 }
2585
2586                 if (r < 0) {
2587                         if (errno == ENOSYS)
2588                                 /* we lack the syscall, continue with
2589                                  * reading from /dev/urandom */
2590                                 have_syscall = false;
2591                         else if (errno == EAGAIN)
2592                                 /* not enough entropy for now. Let's
2593                                  * remember to use the syscall the
2594                                  * next time, again, but also read
2595                                  * from /dev/urandom for now, which
2596                                  * doesn't care about the current
2597                                  * amount of entropy.  */
2598                                 have_syscall = true;
2599                         else
2600                                 return -errno;
2601                 } else
2602                         /* too short read? */
2603                         return -EIO;
2604         }
2605
2606         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2607         if (fd < 0)
2608                 return errno == ENOENT ? -ENOSYS : -errno;
2609
2610         k = loop_read(fd, p, n, true);
2611         safe_close(fd);
2612
2613         if (k < 0)
2614                 return (int) k;
2615         if ((size_t) k != n)
2616                 return -EIO;
2617
2618         return 0;
2619 }
2620
2621 void initialize_srand(void) {
2622         static bool srand_called = false;
2623         unsigned x;
2624 #ifdef HAVE_SYS_AUXV_H
2625         void *auxv;
2626 #endif
2627
2628         if (srand_called)
2629                 return;
2630
2631         x = 0;
2632
2633 #ifdef HAVE_SYS_AUXV_H
2634         /* The kernel provides us with a bit of entropy in auxv, so
2635          * let's try to make use of that to seed the pseudo-random
2636          * generator. It's better than nothing... */
2637
2638         auxv = (void*) getauxval(AT_RANDOM);
2639         if (auxv)
2640                 x ^= *(unsigned*) auxv;
2641 #endif
2642
2643         x ^= (unsigned) now(CLOCK_REALTIME);
2644         x ^= (unsigned) gettid();
2645
2646         srand(x);
2647         srand_called = true;
2648 }
2649
2650 void random_bytes(void *p, size_t n) {
2651         uint8_t *q;
2652         int r;
2653
2654         r = dev_urandom(p, n);
2655         if (r >= 0)
2656                 return;
2657
2658         /* If some idiot made /dev/urandom unavailable to us, he'll
2659          * get a PRNG instead. */
2660
2661         initialize_srand();
2662
2663         for (q = p; q < (uint8_t*) p + n; q ++)
2664                 *q = rand();
2665 }
2666
2667 void rename_process(const char name[8]) {
2668         assert(name);
2669
2670         /* This is a like a poor man's setproctitle(). It changes the
2671          * comm field, argv[0], and also the glibc's internally used
2672          * name of the process. For the first one a limit of 16 chars
2673          * applies, to the second one usually one of 10 (i.e. length
2674          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2675          * "systemd"). If you pass a longer string it will be
2676          * truncated */
2677
2678         prctl(PR_SET_NAME, name);
2679
2680         if (program_invocation_name)
2681                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2682
2683         if (saved_argc > 0) {
2684                 int i;
2685
2686                 if (saved_argv[0])
2687                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2688
2689                 for (i = 1; i < saved_argc; i++) {
2690                         if (!saved_argv[i])
2691                                 break;
2692
2693                         memzero(saved_argv[i], strlen(saved_argv[i]));
2694                 }
2695         }
2696 }
2697
2698 void sigset_add_many(sigset_t *ss, ...) {
2699         va_list ap;
2700         int sig;
2701
2702         assert(ss);
2703
2704         va_start(ap, ss);
2705         while ((sig = va_arg(ap, int)) > 0)
2706                 assert_se(sigaddset(ss, sig) == 0);
2707         va_end(ap);
2708 }
2709
2710 int sigprocmask_many(int how, ...) {
2711         va_list ap;
2712         sigset_t ss;
2713         int sig;
2714
2715         assert_se(sigemptyset(&ss) == 0);
2716
2717         va_start(ap, how);
2718         while ((sig = va_arg(ap, int)) > 0)
2719                 assert_se(sigaddset(&ss, sig) == 0);
2720         va_end(ap);
2721
2722         if (sigprocmask(how, &ss, NULL) < 0)
2723                 return -errno;
2724
2725         return 0;
2726 }
2727
2728 char* gethostname_malloc(void) {
2729         struct utsname u;
2730
2731         assert_se(uname(&u) >= 0);
2732
2733         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2734                 return strdup(u.nodename);
2735
2736         return strdup(u.sysname);
2737 }
2738
2739 bool hostname_is_set(void) {
2740         struct utsname u;
2741
2742         assert_se(uname(&u) >= 0);
2743
2744         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2745 }
2746
2747 char *lookup_uid(uid_t uid) {
2748         long bufsize;
2749         char *name;
2750         _cleanup_free_ char *buf = NULL;
2751         struct passwd pwbuf, *pw = NULL;
2752
2753         /* Shortcut things to avoid NSS lookups */
2754         if (uid == 0)
2755                 return strdup("root");
2756
2757         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2758         if (bufsize <= 0)
2759                 bufsize = 4096;
2760
2761         buf = malloc(bufsize);
2762         if (!buf)
2763                 return NULL;
2764
2765         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2766                 return strdup(pw->pw_name);
2767
2768         if (asprintf(&name, UID_FMT, uid) < 0)
2769                 return NULL;
2770
2771         return name;
2772 }
2773
2774 char* getlogname_malloc(void) {
2775         uid_t uid;
2776         struct stat st;
2777
2778         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2779                 uid = st.st_uid;
2780         else
2781                 uid = getuid();
2782
2783         return lookup_uid(uid);
2784 }
2785
2786 char *getusername_malloc(void) {
2787         const char *e;
2788
2789         e = getenv("USER");
2790         if (e)
2791                 return strdup(e);
2792
2793         return lookup_uid(getuid());
2794 }
2795
2796 int getttyname_malloc(int fd, char **ret) {
2797         size_t l = 100;
2798         int r;
2799
2800         assert(fd >= 0);
2801         assert(ret);
2802
2803         for (;;) {
2804                 char path[l];
2805
2806                 r = ttyname_r(fd, path, sizeof(path));
2807                 if (r == 0) {
2808                         const char *p;
2809                         char *c;
2810
2811                         p = startswith(path, "/dev/");
2812                         c = strdup(p ?: path);
2813                         if (!c)
2814                                 return -ENOMEM;
2815
2816                         *ret = c;
2817                         return 0;
2818                 }
2819
2820                 if (r != ERANGE)
2821                         return -r;
2822
2823                 l *= 2;
2824         }
2825
2826         return 0;
2827 }
2828
2829 int getttyname_harder(int fd, char **r) {
2830         int k;
2831         char *s;
2832
2833         k = getttyname_malloc(fd, &s);
2834         if (k < 0)
2835                 return k;
2836
2837         if (streq(s, "tty")) {
2838                 free(s);
2839                 return get_ctty(0, NULL, r);
2840         }
2841
2842         *r = s;
2843         return 0;
2844 }
2845
2846 int get_ctty_devnr(pid_t pid, dev_t *d) {
2847         int r;
2848         _cleanup_free_ char *line = NULL;
2849         const char *p;
2850         unsigned long ttynr;
2851
2852         assert(pid >= 0);
2853
2854         p = procfs_file_alloca(pid, "stat");
2855         r = read_one_line_file(p, &line);
2856         if (r < 0)
2857                 return r;
2858
2859         p = strrchr(line, ')');
2860         if (!p)
2861                 return -EIO;
2862
2863         p++;
2864
2865         if (sscanf(p, " "
2866                    "%*c "  /* state */
2867                    "%*d "  /* ppid */
2868                    "%*d "  /* pgrp */
2869                    "%*d "  /* session */
2870                    "%lu ", /* ttynr */
2871                    &ttynr) != 1)
2872                 return -EIO;
2873
2874         if (major(ttynr) == 0 && minor(ttynr) == 0)
2875                 return -ENOENT;
2876
2877         if (d)
2878                 *d = (dev_t) ttynr;
2879
2880         return 0;
2881 }
2882
2883 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2884         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2885         _cleanup_free_ char *s = NULL;
2886         const char *p;
2887         dev_t devnr;
2888         int k;
2889
2890         assert(r);
2891
2892         k = get_ctty_devnr(pid, &devnr);
2893         if (k < 0)
2894                 return k;
2895
2896         sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
2897
2898         k = readlink_malloc(fn, &s);
2899         if (k < 0) {
2900
2901                 if (k != -ENOENT)
2902                         return k;
2903
2904                 /* This is an ugly hack */
2905                 if (major(devnr) == 136) {
2906                         asprintf(&b, "pts/%u", minor(devnr));
2907                         goto finish;
2908                 }
2909
2910                 /* Probably something like the ptys which have no
2911                  * symlink in /dev/char. Let's return something
2912                  * vaguely useful. */
2913
2914                 b = strdup(fn + 5);
2915                 goto finish;
2916         }
2917
2918         if (startswith(s, "/dev/"))
2919                 p = s + 5;
2920         else if (startswith(s, "../"))
2921                 p = s + 3;
2922         else
2923                 p = s;
2924
2925         b = strdup(p);
2926
2927 finish:
2928         if (!b)
2929                 return -ENOMEM;
2930
2931         *r = b;
2932         if (_devnr)
2933                 *_devnr = devnr;
2934
2935         return 0;
2936 }
2937
2938 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2939         _cleanup_closedir_ DIR *d = NULL;
2940         int ret = 0;
2941
2942         assert(fd >= 0);
2943
2944         /* This returns the first error we run into, but nevertheless
2945          * tries to go on. This closes the passed fd. */
2946
2947         d = fdopendir(fd);
2948         if (!d) {
2949                 safe_close(fd);
2950
2951                 return errno == ENOENT ? 0 : -errno;
2952         }
2953
2954         for (;;) {
2955                 struct dirent *de;
2956                 bool is_dir, keep_around;
2957                 struct stat st;
2958                 int r;
2959
2960                 errno = 0;
2961                 de = readdir(d);
2962                 if (!de) {
2963                         if (errno != 0 && ret == 0)
2964                                 ret = -errno;
2965                         return ret;
2966                 }
2967
2968                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2969                         continue;
2970
2971                 if (de->d_type == DT_UNKNOWN ||
2972                     honour_sticky ||
2973                     (de->d_type == DT_DIR && root_dev)) {
2974                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2975                                 if (ret == 0 && errno != ENOENT)
2976                                         ret = -errno;
2977                                 continue;
2978                         }
2979
2980                         is_dir = S_ISDIR(st.st_mode);
2981                         keep_around =
2982                                 honour_sticky &&
2983                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2984                                 (st.st_mode & S_ISVTX);
2985                 } else {
2986                         is_dir = de->d_type == DT_DIR;
2987                         keep_around = false;
2988                 }
2989
2990                 if (is_dir) {
2991                         int subdir_fd;
2992
2993                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2994                         if (root_dev && st.st_dev != root_dev->st_dev)
2995                                 continue;
2996
2997                         subdir_fd = openat(fd, de->d_name,
2998                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2999                         if (subdir_fd < 0) {
3000                                 if (ret == 0 && errno != ENOENT)
3001                                         ret = -errno;
3002                                 continue;
3003                         }
3004
3005                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
3006                         if (r < 0 && ret == 0)
3007                                 ret = r;
3008
3009                         if (!keep_around)
3010                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3011                                         if (ret == 0 && errno != ENOENT)
3012                                                 ret = -errno;
3013                                 }
3014
3015                 } else if (!only_dirs && !keep_around) {
3016
3017                         if (unlinkat(fd, de->d_name, 0) < 0) {
3018                                 if (ret == 0 && errno != ENOENT)
3019                                         ret = -errno;
3020                         }
3021                 }
3022         }
3023 }
3024
3025 _pure_ static int is_temporary_fs(struct statfs *s) {
3026         assert(s);
3027
3028         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
3029                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
3030 }
3031
3032 int is_fd_on_temporary_fs(int fd) {
3033         struct statfs s;
3034
3035         if (fstatfs(fd, &s) < 0)
3036                 return -errno;
3037
3038         return is_temporary_fs(&s);
3039 }
3040
3041 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3042         struct statfs s;
3043
3044         assert(fd >= 0);
3045
3046         if (fstatfs(fd, &s) < 0) {
3047                 safe_close(fd);
3048                 return -errno;
3049         }
3050
3051         /* We refuse to clean disk file systems with this call. This
3052          * is extra paranoia just to be sure we never ever remove
3053          * non-state data */
3054         if (!is_temporary_fs(&s)) {
3055                 log_error("Attempted to remove disk file system, and we can't allow that.");
3056                 safe_close(fd);
3057                 return -EPERM;
3058         }
3059
3060         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
3061 }
3062
3063 static int file_is_priv_sticky(const char *p) {
3064         struct stat st;
3065
3066         assert(p);
3067
3068         if (lstat(p, &st) < 0)
3069                 return -errno;
3070
3071         return
3072                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3073                 (st.st_mode & S_ISVTX);
3074 }
3075
3076 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
3077         int fd, r;
3078         struct statfs s;
3079
3080         assert(path);
3081
3082         /* We refuse to clean the root file system with this
3083          * call. This is extra paranoia to never cause a really
3084          * seriously broken system. */
3085         if (path_equal(path, "/")) {
3086                 log_error("Attempted to remove entire root file system, and we can't allow that.");
3087                 return -EPERM;
3088         }
3089
3090         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3091         if (fd < 0) {
3092
3093                 if (errno != ENOTDIR && errno != ELOOP)
3094                         return -errno;
3095
3096                 if (!dangerous) {
3097                         if (statfs(path, &s) < 0)
3098                                 return -errno;
3099
3100                         if (!is_temporary_fs(&s)) {
3101                                 log_error("Attempted to remove disk file system, and we can't allow that.");
3102                                 return -EPERM;
3103                         }
3104                 }
3105
3106                 if (delete_root && !only_dirs)
3107                         if (unlink(path) < 0 && errno != ENOENT)
3108                                 return -errno;
3109
3110                 return 0;
3111         }
3112
3113         if (!dangerous) {
3114                 if (fstatfs(fd, &s) < 0) {
3115                         safe_close(fd);
3116                         return -errno;
3117                 }
3118
3119                 if (!is_temporary_fs(&s)) {
3120                         log_error("Attempted to remove disk file system, and we can't allow that.");
3121                         safe_close(fd);
3122                         return -EPERM;
3123                 }
3124         }
3125
3126         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
3127         if (delete_root) {
3128
3129                 if (honour_sticky && file_is_priv_sticky(path) > 0)
3130                         return r;
3131
3132                 if (rmdir(path) < 0 && errno != ENOENT) {
3133                         if (r == 0)
3134                                 r = -errno;
3135                 }
3136         }
3137
3138         return r;
3139 }
3140
3141 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3142         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
3143 }
3144
3145 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3146         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
3147 }
3148
3149 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3150         assert(path);
3151
3152         /* Under the assumption that we are running privileged we
3153          * first change the access mode and only then hand out
3154          * ownership to avoid a window where access is too open. */
3155
3156         if (mode != MODE_INVALID)
3157                 if (chmod(path, mode) < 0)
3158                         return -errno;
3159
3160         if (uid != UID_INVALID || gid != GID_INVALID)
3161                 if (chown(path, uid, gid) < 0)
3162                         return -errno;
3163
3164         return 0;
3165 }
3166
3167 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3168         assert(fd >= 0);
3169
3170         /* Under the assumption that we are running privileged we
3171          * first change the access mode and only then hand out
3172          * ownership to avoid a window where access is too open. */
3173
3174         if (mode != MODE_INVALID)
3175                 if (fchmod(fd, mode) < 0)
3176                         return -errno;
3177
3178         if (uid != UID_INVALID || gid != GID_INVALID)
3179                 if (fchown(fd, uid, gid) < 0)
3180                         return -errno;
3181
3182         return 0;
3183 }
3184
3185 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3186         cpu_set_t *r;
3187         unsigned n = 1024;
3188
3189         /* Allocates the cpuset in the right size */
3190
3191         for (;;) {
3192                 if (!(r = CPU_ALLOC(n)))
3193                         return NULL;
3194
3195                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3196                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3197
3198                         if (ncpus)
3199                                 *ncpus = n;
3200
3201                         return r;
3202                 }
3203
3204                 CPU_FREE(r);
3205
3206                 if (errno != EINVAL)
3207                         return NULL;
3208
3209                 n *= 2;
3210         }
3211 }
3212
3213 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3214         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3215         _cleanup_free_ char *s = NULL;
3216         _cleanup_close_ int fd = -1;
3217         struct iovec iovec[6] = {};
3218         int n = 0;
3219         static bool prev_ephemeral;
3220
3221         assert(format);
3222
3223         /* This is independent of logging, as status messages are
3224          * optional and go exclusively to the console. */
3225
3226         if (vasprintf(&s, format, ap) < 0)
3227                 return log_oom();
3228
3229         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3230         if (fd < 0)
3231                 return fd;
3232
3233         if (ellipse) {
3234                 char *e;
3235                 size_t emax, sl;
3236                 int c;
3237
3238                 c = fd_columns(fd);
3239                 if (c <= 0)
3240                         c = 80;
3241
3242                 sl = status ? sizeof(status_indent)-1 : 0;
3243
3244                 emax = c - sl - 1;
3245                 if (emax < 3)
3246                         emax = 3;
3247
3248                 e = ellipsize(s, emax, 50);
3249                 if (e) {
3250                         free(s);
3251                         s = e;
3252                 }
3253         }
3254
3255         if (prev_ephemeral)
3256                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3257         prev_ephemeral = ephemeral;
3258
3259         if (status) {
3260                 if (!isempty(status)) {
3261                         IOVEC_SET_STRING(iovec[n++], "[");
3262                         IOVEC_SET_STRING(iovec[n++], status);
3263                         IOVEC_SET_STRING(iovec[n++], "] ");
3264                 } else
3265                         IOVEC_SET_STRING(iovec[n++], status_indent);
3266         }
3267
3268         IOVEC_SET_STRING(iovec[n++], s);
3269         if (!ephemeral)
3270                 IOVEC_SET_STRING(iovec[n++], "\n");
3271
3272         if (writev(fd, iovec, n) < 0)
3273                 return -errno;
3274
3275         return 0;
3276 }
3277
3278 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3279         va_list ap;
3280         int r;
3281
3282         assert(format);
3283
3284         va_start(ap, format);
3285         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3286         va_end(ap);
3287
3288         return r;
3289 }
3290
3291 char *replace_env(const char *format, char **env) {
3292         enum {
3293                 WORD,
3294                 CURLY,
3295                 VARIABLE
3296         } state = WORD;
3297
3298         const char *e, *word = format;
3299         char *r = NULL, *k;
3300
3301         assert(format);
3302
3303         for (e = format; *e; e ++) {
3304
3305                 switch (state) {
3306
3307                 case WORD:
3308                         if (*e == '$')
3309                                 state = CURLY;
3310                         break;
3311
3312                 case CURLY:
3313                         if (*e == '{') {
3314                                 k = strnappend(r, word, e-word-1);
3315                                 if (!k)
3316                                         goto fail;
3317
3318                                 free(r);
3319                                 r = k;
3320
3321                                 word = e-1;
3322                                 state = VARIABLE;
3323
3324                         } else if (*e == '$') {
3325                                 k = strnappend(r, word, e-word);
3326                                 if (!k)
3327                                         goto fail;
3328
3329                                 free(r);
3330                                 r = k;
3331
3332                                 word = e+1;
3333                                 state = WORD;
3334                         } else
3335                                 state = WORD;
3336                         break;
3337
3338                 case VARIABLE:
3339                         if (*e == '}') {
3340                                 const char *t;
3341
3342                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3343
3344                                 k = strappend(r, t);
3345                                 if (!k)
3346                                         goto fail;
3347
3348                                 free(r);
3349                                 r = k;
3350
3351                                 word = e+1;
3352                                 state = WORD;
3353                         }
3354                         break;
3355                 }
3356         }
3357
3358         k = strnappend(r, word, e-word);
3359         if (!k)
3360                 goto fail;
3361
3362         free(r);
3363         return k;
3364
3365 fail:
3366         free(r);
3367         return NULL;
3368 }
3369
3370 char **replace_env_argv(char **argv, char **env) {
3371         char **ret, **i;
3372         unsigned k = 0, l = 0;
3373
3374         l = strv_length(argv);
3375
3376         ret = new(char*, l+1);
3377         if (!ret)
3378                 return NULL;
3379
3380         STRV_FOREACH(i, argv) {
3381
3382                 /* If $FOO appears as single word, replace it by the split up variable */
3383                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3384                         char *e;
3385                         char **w, **m;
3386                         unsigned q;
3387
3388                         e = strv_env_get(env, *i+1);
3389                         if (e) {
3390                                 int r;
3391
3392                                 r = strv_split_quoted(&m, e, true);
3393                                 if (r < 0) {
3394                                         ret[k] = NULL;
3395                                         strv_free(ret);
3396                                         return NULL;
3397