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                                 }
3398                         } else
3399                                 m = NULL;
3400
3401                         q = strv_length(m);
3402                         l = l + q - 1;
3403
3404                         w = realloc(ret, sizeof(char*) * (l+1));
3405                         if (!w) {
3406                                 ret[k] = NULL;
3407                                 strv_free(ret);
3408                                 strv_free(m);
3409                                 return NULL;
3410                         }
3411
3412                         ret = w;
3413                         if (m) {
3414                                 memcpy(ret + k, m, q * sizeof(char*));
3415                                 free(m);
3416                         }
3417
3418                         k += q;
3419                         continue;
3420                 }
3421
3422                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3423                 ret[k] = replace_env(*i, env);
3424                 if (!ret[k]) {
3425                         strv_free(ret);
3426                         return NULL;
3427                 }
3428                 k++;
3429         }
3430
3431         ret[k] = NULL;
3432         return ret;
3433 }
3434
3435 int fd_columns(int fd) {
3436         struct winsize ws = {};
3437
3438         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3439                 return -errno;
3440
3441         if (ws.ws_col <= 0)
3442                 return -EIO;
3443
3444         return ws.ws_col;
3445 }
3446
3447 unsigned columns(void) {
3448         const char *e;
3449         int c;
3450
3451         if (_likely_(cached_columns > 0))
3452                 return cached_columns;
3453
3454         c = 0;
3455         e = getenv("COLUMNS");
3456         if (e)
3457                 (void) safe_atoi(e, &c);
3458
3459         if (c <= 0)
3460                 c = fd_columns(STDOUT_FILENO);
3461
3462         if (c <= 0)
3463                 c = 80;
3464
3465         cached_columns = c;
3466         return cached_columns;
3467 }
3468
3469 int fd_lines(int fd) {
3470         struct winsize ws = {};
3471
3472         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3473                 return -errno;
3474
3475         if (ws.ws_row <= 0)
3476                 return -EIO;
3477
3478         return ws.ws_row;
3479 }
3480
3481 unsigned lines(void) {
3482         const char *e;
3483         int l;
3484
3485         if (_likely_(cached_lines > 0))
3486                 return cached_lines;
3487
3488         l = 0;
3489         e = getenv("LINES");
3490         if (e)
3491                 (void) safe_atoi(e, &l);
3492
3493         if (l <= 0)
3494                 l = fd_lines(STDOUT_FILENO);
3495
3496         if (l <= 0)
3497                 l = 24;
3498
3499         cached_lines = l;
3500         return cached_lines;
3501 }
3502
3503 /* intended to be used as a SIGWINCH sighandler */
3504 void columns_lines_cache_reset(int signum) {
3505         cached_columns = 0;
3506         cached_lines = 0;
3507 }
3508
3509 bool on_tty(void) {
3510         static int cached_on_tty = -1;
3511
3512         if (_unlikely_(cached_on_tty < 0))
3513                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3514
3515         return cached_on_tty;
3516 }
3517
3518 int files_same(const char *filea, const char *fileb) {
3519         struct stat a, b;
3520
3521         if (stat(filea, &a) < 0)
3522                 return -errno;
3523
3524         if (stat(fileb, &b) < 0)
3525                 return -errno;
3526
3527         return a.st_dev == b.st_dev &&
3528                a.st_ino == b.st_ino;
3529 }
3530
3531 int running_in_chroot(void) {
3532         int ret;
3533
3534         ret = files_same("/proc/1/root", "/");
3535         if (ret < 0)
3536                 return ret;
3537
3538         return ret == 0;
3539 }
3540
3541 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3542         size_t x;
3543         char *r;
3544
3545         assert(s);
3546         assert(percent <= 100);
3547         assert(new_length >= 3);
3548
3549         if (old_length <= 3 || old_length <= new_length)
3550                 return strndup(s, old_length);
3551
3552         r = new0(char, new_length+1);
3553         if (!r)
3554                 return NULL;
3555
3556         x = (new_length * percent) / 100;
3557
3558         if (x > new_length - 3)
3559                 x = new_length - 3;
3560
3561         memcpy(r, s, x);
3562         r[x] = '.';
3563         r[x+1] = '.';
3564         r[x+2] = '.';
3565         memcpy(r + x + 3,
3566                s + old_length - (new_length - x - 3),
3567                new_length - x - 3);
3568
3569         return r;
3570 }
3571
3572 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3573         size_t x;
3574         char *e;
3575         const char *i, *j;
3576         unsigned k, len, len2;
3577
3578         assert(s);
3579         assert(percent <= 100);
3580         assert(new_length >= 3);
3581
3582         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3583         if (ascii_is_valid(s))
3584                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3585
3586         if (old_length <= 3 || old_length <= new_length)
3587                 return strndup(s, old_length);
3588
3589         x = (new_length * percent) / 100;
3590
3591         if (x > new_length - 3)
3592                 x = new_length - 3;
3593
3594         k = 0;
3595         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3596                 int c;
3597
3598                 c = utf8_encoded_to_unichar(i);
3599                 if (c < 0)
3600                         return NULL;
3601                 k += unichar_iswide(c) ? 2 : 1;
3602         }
3603
3604         if (k > x) /* last character was wide and went over quota */
3605                 x ++;
3606
3607         for (j = s + old_length; k < new_length && j > i; ) {
3608                 int c;
3609
3610                 j = utf8_prev_char(j);
3611                 c = utf8_encoded_to_unichar(j);
3612                 if (c < 0)
3613                         return NULL;
3614                 k += unichar_iswide(c) ? 2 : 1;
3615         }
3616         assert(i <= j);
3617
3618         /* we don't actually need to ellipsize */
3619         if (i == j)
3620                 return memdup(s, old_length + 1);
3621
3622         /* make space for ellipsis */
3623         j = utf8_next_char(j);
3624
3625         len = i - s;
3626         len2 = s + old_length - j;
3627         e = new(char, len + 3 + len2 + 1);
3628         if (!e)
3629                 return NULL;
3630
3631         /*
3632         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3633                old_length, new_length, x, len, len2, k);
3634         */
3635
3636         memcpy(e, s, len);
3637         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3638         e[len + 1] = 0x80;
3639         e[len + 2] = 0xa6;
3640
3641         memcpy(e + len + 3, j, len2 + 1);
3642
3643         return e;
3644 }
3645
3646 char *ellipsize(const char *s, size_t length, unsigned percent) {
3647         return ellipsize_mem(s, strlen(s), length, percent);
3648 }
3649
3650 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3651         _cleanup_close_ int fd;
3652         int r;
3653
3654         assert(path);
3655
3656         if (parents)
3657                 mkdir_parents(path, 0755);
3658
3659         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3660         if (fd < 0)
3661                 return -errno;
3662
3663         if (mode > 0) {
3664                 r = fchmod(fd, mode);
3665                 if (r < 0)
3666                         return -errno;
3667         }
3668
3669         if (uid != UID_INVALID || gid != GID_INVALID) {
3670                 r = fchown(fd, uid, gid);
3671                 if (r < 0)
3672                         return -errno;
3673         }
3674
3675         if (stamp != USEC_INFINITY) {
3676                 struct timespec ts[2];
3677
3678                 timespec_store(&ts[0], stamp);
3679                 ts[1] = ts[0];
3680                 r = futimens(fd, ts);
3681         } else
3682                 r = futimens(fd, NULL);
3683         if (r < 0)
3684                 return -errno;
3685
3686         return 0;
3687 }
3688
3689 int touch(const char *path) {
3690         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
3691 }
3692
3693 char *unquote(const char *s, const char* quotes) {
3694         size_t l;
3695         assert(s);
3696
3697         /* This is rather stupid, simply removes the heading and
3698          * trailing quotes if there is one. Doesn't care about
3699          * escaping or anything. We should make this smarter one
3700          * day... */
3701
3702         l = strlen(s);
3703         if (l < 2)
3704                 return strdup(s);
3705
3706         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3707                 return strndup(s+1, l-2);
3708
3709         return strdup(s);
3710 }
3711
3712 char *normalize_env_assignment(const char *s) {
3713         _cleanup_free_ char *value = NULL;
3714         const char *eq;
3715         char *p, *name;
3716
3717         eq = strchr(s, '=');
3718         if (!eq) {
3719                 char *r, *t;
3720
3721                 r = strdup(s);
3722                 if (!r)
3723                         return NULL;
3724
3725                 t = strstrip(r);
3726                 if (t != r)
3727                         memmove(r, t, strlen(t) + 1);
3728
3729                 return r;
3730         }
3731
3732         name = strndupa(s, eq - s);
3733         p = strdupa(eq + 1);
3734
3735         value = unquote(strstrip(p), QUOTES);
3736         if (!value)
3737                 return NULL;
3738
3739         return strjoin(strstrip(name), "=", value, NULL);
3740 }
3741
3742 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3743         siginfo_t dummy;
3744
3745         assert(pid >= 1);
3746
3747         if (!status)
3748                 status = &dummy;
3749
3750         for (;;) {
3751                 zero(*status);
3752
3753                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3754
3755                         if (errno == EINTR)
3756                                 continue;
3757
3758                         return -errno;
3759                 }
3760
3761                 return 0;
3762         }
3763 }
3764
3765 /*
3766  * Return values:
3767  * < 0 : wait_for_terminate() failed to get the state of the
3768  *       process, the process was terminated by a signal, or
3769  *       failed for an unknown reason.
3770  * >=0 : The process terminated normally, and its exit code is
3771  *       returned.
3772  *
3773  * That is, success is indicated by a return value of zero, and an
3774  * error is indicated by a non-zero value.
3775  *
3776  * A warning is emitted if the process terminates abnormally,
3777  * and also if it returns non-zero unless check_exit_code is true.
3778  */
3779 int wait_for_terminate_and_warn(const char *name, pid_t pid, bool check_exit_code) {
3780         int r;
3781         siginfo_t status;
3782
3783         assert(name);
3784         assert(pid > 1);
3785
3786         r = wait_for_terminate(pid, &status);
3787         if (r < 0)
3788                 return log_warning_errno(r, "Failed to wait for %s: %m", name);
3789
3790         if (status.si_code == CLD_EXITED) {
3791                 if (status.si_status != 0)
3792                         log_full(check_exit_code ? LOG_WARNING : LOG_DEBUG,
3793                                  "%s failed with error code %i.", name, status.si_status);
3794                 else
3795                         log_debug("%s succeeded.", name);
3796
3797                 return status.si_status;
3798         } else if (status.si_code == CLD_KILLED ||
3799                    status.si_code == CLD_DUMPED) {
3800
3801                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3802                 return -EPROTO;
3803         }
3804
3805         log_warning("%s failed due to unknown reason.", name);
3806         return -EPROTO;
3807 }
3808
3809 noreturn void freeze(void) {
3810
3811         /* Make sure nobody waits for us on a socket anymore */
3812         close_all_fds(NULL, 0);
3813
3814         sync();
3815
3816         for (;;)
3817                 pause();
3818 }
3819
3820 bool null_or_empty(struct stat *st) {
3821         assert(st);
3822
3823         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3824                 return true;
3825
3826         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3827                 return true;
3828
3829         return false;
3830 }
3831
3832 int null_or_empty_path(const char *fn) {
3833         struct stat st;
3834
3835         assert(fn);
3836
3837         if (stat(fn, &st) < 0)
3838                 return -errno;
3839
3840         return null_or_empty(&st);
3841 }
3842
3843 int null_or_empty_fd(int fd) {
3844         struct stat st;
3845
3846         assert(fd >= 0);
3847
3848         if (fstat(fd, &st) < 0)
3849                 return -errno;
3850
3851         return null_or_empty(&st);
3852 }
3853
3854 DIR *xopendirat(int fd, const char *name, int flags) {
3855         int nfd;
3856         DIR *d;
3857
3858         assert(!(flags & O_CREAT));
3859
3860         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3861         if (nfd < 0)
3862                 return NULL;
3863
3864         d = fdopendir(nfd);
3865         if (!d) {
3866                 safe_close(nfd);
3867                 return NULL;
3868         }
3869
3870         return d;
3871 }
3872
3873 int signal_from_string_try_harder(const char *s) {
3874         int signo;
3875         assert(s);
3876
3877         signo = signal_from_string(s);
3878         if (signo <= 0)
3879                 if (startswith(s, "SIG"))
3880                         return signal_from_string(s+3);
3881
3882         return signo;
3883 }
3884
3885 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3886         _cleanup_free_ char *t = NULL, *u = NULL;
3887         size_t enc_len;
3888
3889         u = unquote(tagvalue, "\"\'");
3890         if (!u)
3891                 return NULL;
3892
3893         enc_len = strlen(u) * 4 + 1;
3894         t = new(char, enc_len);
3895         if (!t)
3896                 return NULL;
3897
3898         if (encode_devnode_name(u, t, enc_len) < 0)
3899                 return NULL;
3900
3901         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3902 }
3903
3904 char *fstab_node_to_udev_node(const char *p) {
3905         assert(p);
3906
3907         if (startswith(p, "LABEL="))
3908                 return tag_to_udev_node(p+6, "label");
3909
3910         if (startswith(p, "UUID="))
3911                 return tag_to_udev_node(p+5, "uuid");
3912
3913         if (startswith(p, "PARTUUID="))
3914                 return tag_to_udev_node(p+9, "partuuid");
3915
3916         if (startswith(p, "PARTLABEL="))
3917                 return tag_to_udev_node(p+10, "partlabel");
3918
3919         return strdup(p);
3920 }
3921
3922 bool tty_is_vc(const char *tty) {
3923         assert(tty);
3924
3925         return vtnr_from_tty(tty) >= 0;
3926 }
3927
3928 bool tty_is_console(const char *tty) {
3929         assert(tty);
3930
3931         if (startswith(tty, "/dev/"))
3932                 tty += 5;
3933
3934         return streq(tty, "console");
3935 }
3936
3937 int vtnr_from_tty(const char *tty) {
3938         int i, r;
3939
3940         assert(tty);
3941
3942         if (startswith(tty, "/dev/"))
3943                 tty += 5;
3944
3945         if (!startswith(tty, "tty") )
3946                 return -EINVAL;
3947
3948         if (tty[3] < '0' || tty[3] > '9')
3949                 return -EINVAL;
3950
3951         r = safe_atoi(tty+3, &i);
3952         if (r < 0)
3953                 return r;
3954
3955         if (i < 0 || i > 63)
3956                 return -EINVAL;
3957
3958         return i;
3959 }
3960
3961 char *resolve_dev_console(char **active) {
3962         char *tty;
3963
3964         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3965          * (i.e. not read-only-mounted which is a sign for container setups) */
3966
3967         if (path_is_read_only_fs("/sys") > 0)
3968                 return NULL;
3969
3970         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3971                 return NULL;
3972
3973         /* If multiple log outputs are configured the last one is what
3974          * /dev/console points to */
3975         tty = strrchr(*active, ' ');
3976         if (tty)
3977                 tty++;
3978         else
3979                 tty = *active;
3980
3981         if (streq(tty, "tty0")) {
3982                 char *tmp;
3983
3984                 /* Get the active VC (e.g. tty1) */
3985                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3986                         free(*active);
3987                         tty = *active = tmp;
3988                 }
3989         }
3990
3991         return tty;
3992 }
3993
3994 bool tty_is_vc_resolve(const char *tty) {
3995         _cleanup_free_ char *active = NULL;
3996
3997         assert(tty);
3998
3999         if (startswith(tty, "/dev/"))
4000                 tty += 5;
4001
4002         if (streq(tty, "console")) {
4003                 tty = resolve_dev_console(&active);
4004                 if (!tty)
4005                         return false;
4006         }
4007
4008         return tty_is_vc(tty);
4009 }
4010
4011 const char *default_term_for_tty(const char *tty) {
4012         assert(tty);
4013
4014         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt220";
4015 }
4016
4017 bool dirent_is_file(const struct dirent *de) {
4018         assert(de);
4019
4020         if (hidden_file(de->d_name))
4021                 return false;
4022
4023         if (de->d_type != DT_REG &&
4024             de->d_type != DT_LNK &&
4025             de->d_type != DT_UNKNOWN)
4026                 return false;
4027
4028         return true;
4029 }
4030
4031 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4032         assert(de);
4033
4034         if (de->d_type != DT_REG &&
4035             de->d_type != DT_LNK &&
4036             de->d_type != DT_UNKNOWN)
4037                 return false;
4038
4039         if (hidden_file_allow_backup(de->d_name))
4040                 return false;
4041
4042         return endswith(de->d_name, suffix);
4043 }
4044
4045 static int do_execute(char **directories, usec_t timeout, char *argv[]) {
4046         _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
4047         _cleanup_set_free_free_ Set *seen = NULL;
4048         char **directory;
4049
4050         /* We fork this all off from a child process so that we can
4051          * somewhat cleanly make use of SIGALRM to set a time limit */
4052
4053         reset_all_signal_handlers();
4054         reset_signal_mask();
4055
4056         assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4057
4058         pids = hashmap_new(NULL);
4059         if (!pids)
4060                 return log_oom();
4061
4062         seen = set_new(&string_hash_ops);
4063         if (!seen)
4064                 return log_oom();
4065
4066         STRV_FOREACH(directory, directories) {
4067                 _cleanup_closedir_ DIR *d;
4068                 struct dirent *de;
4069
4070                 d = opendir(*directory);
4071                 if (!d) {
4072                         if (errno == ENOENT)
4073                                 continue;
4074
4075                         return log_error_errno(errno, "Failed to open directory %s: %m", *directory);
4076                 }
4077
4078                 FOREACH_DIRENT(de, d, break) {
4079                         _cleanup_free_ char *path = NULL;
4080                         pid_t pid;
4081                         int r;
4082
4083                         if (!dirent_is_file(de))
4084                                 continue;
4085
4086                         if (set_contains(seen, de->d_name)) {
4087                                 log_debug("%1$s/%2$s skipped (%2$s was already seen).", *directory, de->d_name);
4088                                 continue;
4089                         }
4090
4091                         r = set_put_strdup(seen, de->d_name);
4092                         if (r < 0)
4093                                 return log_oom();
4094
4095                         path = strjoin(*directory, "/", de->d_name, NULL);
4096                         if (!path)
4097                                 return log_oom();
4098
4099                         if (null_or_empty_path(path)) {
4100                                 log_debug("%s is empty (a mask).", path);
4101                                 continue;
4102                         } else
4103                                 log_debug("%s will be executed.", path);
4104
4105                         pid = fork();
4106                         if (pid < 0) {
4107                                 log_error_errno(errno, "Failed to fork: %m");
4108                                 continue;
4109                         } else if (pid == 0) {
4110                                 char *_argv[2];
4111
4112                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4113
4114                                 if (!argv) {
4115                                         _argv[0] = path;
4116                                         _argv[1] = NULL;
4117                                         argv = _argv;
4118                                 } else
4119                                         argv[0] = path;
4120
4121                                 execv(path, argv);
4122                                 return log_error_errno(errno, "Failed to execute %s: %m", path);
4123                         }
4124
4125                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
4126
4127                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
4128                         if (r < 0)
4129                                 return log_oom();
4130                         path = NULL;
4131                 }
4132         }
4133
4134         /* Abort execution of this process after the timout. We simply
4135          * rely on SIGALRM as default action terminating the process,
4136          * and turn on alarm(). */
4137
4138         if (timeout != USEC_INFINITY)
4139                 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
4140
4141         while (!hashmap_isempty(pids)) {
4142                 _cleanup_free_ char *path = NULL;
4143                 pid_t pid;
4144
4145                 pid = PTR_TO_UINT(hashmap_first_key(pids));
4146                 assert(pid > 0);
4147
4148                 path = hashmap_remove(pids, UINT_TO_PTR(pid));
4149                 assert(path);
4150
4151                 wait_for_terminate_and_warn(path, pid, true);
4152         }
4153
4154         return 0;
4155 }
4156
4157 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]) {
4158         pid_t executor_pid;
4159         int r;
4160         char *name;
4161         char **dirs = (char**) directories;
4162
4163         assert(!strv_isempty(dirs));
4164
4165         name = basename(dirs[0]);
4166         assert(!isempty(name));
4167
4168         /* Executes all binaries in the directories in parallel and waits
4169          * for them to finish. Optionally a timeout is applied. If a file
4170          * with the same name exists in more than one directory, the
4171          * earliest one wins. */
4172
4173         executor_pid = fork();
4174         if (executor_pid < 0) {
4175                 log_error_errno(errno, "Failed to fork: %m");
4176                 return;
4177
4178         } else if (executor_pid == 0) {
4179                 r = do_execute(dirs, timeout, argv);
4180                 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
4181         }
4182
4183         wait_for_terminate_and_warn(name, executor_pid, true);
4184 }
4185
4186 int kill_and_sigcont(pid_t pid, int sig) {
4187         int r;
4188
4189         r = kill(pid, sig) < 0 ? -errno : 0;
4190
4191         if (r >= 0)
4192                 kill(pid, SIGCONT);
4193
4194         return r;
4195 }
4196
4197 bool nulstr_contains(const char*nulstr, const char *needle) {
4198         const char *i;
4199
4200         if (!nulstr)
4201                 return false;
4202
4203         NULSTR_FOREACH(i, nulstr)
4204                 if (streq(i, needle))
4205                         return true;
4206
4207         return false;
4208 }
4209
4210 bool plymouth_running(void) {
4211         return access("/run/plymouth/pid", F_OK) >= 0;
4212 }
4213
4214 char* strshorten(char *s, size_t l) {
4215         assert(s);
4216
4217         if (l < strlen(s))
4218                 s[l] = 0;
4219
4220         return s;
4221 }
4222
4223 static bool hostname_valid_char(char c) {
4224         return
4225                 (c >= 'a' && c <= 'z') ||
4226                 (c >= 'A' && c <= 'Z') ||
4227                 (c >= '0' && c <= '9') ||
4228                 c == '-' ||
4229                 c == '_' ||
4230                 c == '.';
4231 }
4232
4233 bool hostname_is_valid(const char *s) {
4234         const char *p;
4235         bool dot;
4236
4237         if (isempty(s))
4238                 return false;
4239
4240         for (p = s, dot = true; *p; p++) {
4241                 if (*p == '.') {
4242                         if (dot)
4243                                 return false;
4244
4245                         dot = true;
4246                 } else {
4247                         if (!hostname_valid_char(*p))
4248                                 return false;
4249
4250                         dot = false;
4251                 }
4252         }
4253
4254         if (dot)
4255                 return false;
4256
4257         if (p-s > HOST_NAME_MAX)
4258                 return false;
4259
4260         return true;
4261 }
4262
4263 char* hostname_cleanup(char *s, bool lowercase) {
4264         char *p, *d;
4265         bool dot;
4266
4267         for (p = s, d = s, dot = true; *p; p++) {
4268                 if (*p == '.') {
4269                         if (dot)
4270                                 continue;
4271
4272                         *(d++) = '.';
4273                         dot = true;
4274                 } else if (hostname_valid_char(*p)) {
4275                         *(d++) = lowercase ? tolower(*p) : *p;
4276                         dot = false;
4277                 }
4278
4279         }
4280
4281         if (dot && d > s)
4282                 d[-1] = 0;
4283         else
4284                 *d = 0;
4285
4286         strshorten(s, HOST_NAME_MAX);
4287
4288         return s;
4289 }
4290
4291 bool machine_name_is_valid(const char *s) {
4292
4293         if (!hostname_is_valid(s))
4294                 return false;
4295
4296         /* Machine names should be useful hostnames, but also be
4297          * useful in unit names, hence we enforce a stricter length
4298          * limitation. */
4299
4300         if (strlen(s) > 64)
4301                 return false;
4302
4303         return true;
4304 }
4305
4306 bool image_name_is_valid(const char *s) {
4307         if (!filename_is_valid(s))
4308                 return false;
4309
4310         if (string_has_cc(s, NULL))
4311                 return false;
4312
4313         if (!utf8_is_valid(s))
4314                 return false;
4315
4316         /* Temporary files for atomically creating new files */
4317         if (startswith(s, ".#"))
4318                 return false;
4319
4320         return true;
4321 }
4322
4323 int pipe_eof(int fd) {
4324         struct pollfd pollfd = {
4325                 .fd = fd,
4326                 .events = POLLIN|POLLHUP,
4327         };
4328
4329         int r;
4330
4331         r = poll(&pollfd, 1, 0);
4332         if (r < 0)
4333                 return -errno;
4334
4335         if (r == 0)
4336                 return 0;
4337
4338         return pollfd.revents & POLLHUP;
4339 }
4340
4341 int fd_wait_for_event(int fd, int event, usec_t t) {
4342
4343         struct pollfd pollfd = {
4344                 .fd = fd,
4345                 .events = event,
4346         };
4347
4348         struct timespec ts;
4349         int r;
4350
4351         r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
4352         if (r < 0)
4353                 return -errno;
4354
4355         if (r == 0)
4356                 return 0;
4357
4358         return pollfd.revents;
4359 }
4360
4361 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4362         FILE *f;
4363         char *t;
4364         int r, fd;
4365
4366         assert(path);
4367         assert(_f);
4368         assert(_temp_path);
4369
4370         r = tempfn_xxxxxx(path, &t);
4371         if (r < 0)
4372                 return r;
4373
4374         fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
4375         if (fd < 0) {
4376                 free(t);
4377                 return -errno;
4378         }
4379
4380         f = fdopen(fd, "we");
4381         if (!f) {
4382                 unlink(t);
4383                 free(t);
4384                 return -errno;
4385         }
4386
4387         *_f = f;
4388         *_temp_path = t;
4389
4390         return 0;
4391 }
4392
4393 int terminal_vhangup_fd(int fd) {
4394         assert(fd >= 0);
4395
4396         if (ioctl(fd, TIOCVHANGUP) < 0)
4397                 return -errno;
4398
4399         return 0;
4400 }
4401
4402 int terminal_vhangup(const char *name) {
4403         _cleanup_close_ int fd;
4404
4405         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4406         if (fd < 0)
4407                 return fd;
4408
4409         return terminal_vhangup_fd(fd);
4410 }
4411
4412 int vt_disallocate(const char *name) {
4413         int fd, r;
4414         unsigned u;
4415
4416         /* Deallocate the VT if possible. If not possible
4417          * (i.e. because it is the active one), at least clear it
4418          * entirely (including the scrollback buffer) */
4419
4420         if (!startswith(name, "/dev/"))
4421                 return -EINVAL;
4422
4423         if (!tty_is_vc(name)) {
4424                 /* So this is not a VT. I guess we cannot deallocate
4425                  * it then. But let's at least clear the screen */
4426
4427                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4428                 if (fd < 0)
4429                         return fd;
4430
4431                 loop_write(fd,
4432                            "\033[r"    /* clear scrolling region */
4433                            "\033[H"    /* move home */
4434                            "\033[2J",  /* clear screen */
4435                            10, false);
4436                 safe_close(fd);
4437
4438                 return 0;
4439         }
4440
4441         if (!startswith(name, "/dev/tty"))
4442                 return -EINVAL;
4443
4444         r = safe_atou(name+8, &u);
4445         if (r < 0)
4446                 return r;
4447
4448         if (u <= 0)
4449                 return -EINVAL;
4450
4451         /* Try to deallocate */
4452         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4453         if (fd < 0)
4454                 return fd;
4455
4456         r = ioctl(fd, VT_DISALLOCATE, u);
4457         safe_close(fd);
4458
4459         if (r >= 0)
4460                 return 0;
4461
4462         if (errno != EBUSY)
4463                 return -errno;
4464
4465         /* Couldn't deallocate, so let's clear it fully with
4466          * scrollback */
4467         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4468         if (fd < 0)
4469                 return fd;
4470
4471         loop_write(fd,
4472                    "\033[r"   /* clear scrolling region */
4473                    "\033[H"   /* move home */
4474                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4475                    10, false);
4476         safe_close(fd);
4477
4478         return 0;
4479 }
4480
4481 int symlink_atomic(const char *from, const char *to) {
4482         _cleanup_free_ char *t = NULL;
4483         int r;
4484
4485         assert(from);
4486         assert(to);
4487
4488         r = tempfn_random(to, &t);
4489         if (r < 0)
4490                 return r;
4491
4492         if (symlink(from, t) < 0)
4493                 return -errno;
4494
4495         if (rename(t, to) < 0) {
4496                 unlink_noerrno(t);
4497                 return -errno;
4498         }
4499
4500         return 0;
4501 }
4502
4503 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
4504         _cleanup_free_ char *t = NULL;
4505         int r;
4506
4507         assert(path);
4508
4509         r = tempfn_random(path, &t);
4510         if (r < 0)
4511                 return r;
4512
4513         if (mknod(t, mode, dev) < 0)
4514                 return -errno;
4515
4516         if (rename(t, path) < 0) {
4517                 unlink_noerrno(t);
4518                 return -errno;
4519         }
4520
4521         return 0;
4522 }
4523
4524 int mkfifo_atomic(const char *path, mode_t mode) {
4525         _cleanup_free_ char *t = NULL;
4526         int r;
4527
4528         assert(path);
4529
4530         r = tempfn_random(path, &t);
4531         if (r < 0)
4532                 return r;
4533
4534         if (mkfifo(t, mode) < 0)
4535                 return -errno;
4536
4537         if (rename(t, path) < 0) {
4538                 unlink_noerrno(t);
4539                 return -errno;
4540         }
4541
4542         return 0;
4543 }
4544
4545 bool display_is_local(const char *display) {
4546         assert(display);
4547
4548         return
4549                 display[0] == ':' &&
4550                 display[1] >= '0' &&
4551                 display[1] <= '9';
4552 }
4553
4554 int socket_from_display(const char *display, char **path) {
4555         size_t k;
4556         char *f, *c;
4557
4558         assert(display);
4559         assert(path);
4560
4561         if (!display_is_local(display))
4562                 return -EINVAL;
4563
4564         k = strspn(display+1, "0123456789");
4565
4566         f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4567         if (!f)
4568                 return -ENOMEM;
4569
4570         c = stpcpy(f, "/tmp/.X11-unix/X");
4571         memcpy(c, display+1, k);
4572         c[k] = 0;
4573
4574         *path = f;
4575
4576         return 0;
4577 }
4578
4579 int get_user_creds(
4580                 const char **username,
4581                 uid_t *uid, gid_t *gid,
4582                 const char **home,
4583                 const char **shell) {
4584
4585         struct passwd *p;
4586         uid_t u;
4587
4588         assert(username);
4589         assert(*username);
4590
4591         /* We enforce some special rules for uid=0: in order to avoid
4592          * NSS lookups for root we hardcode its data. */
4593
4594         if (streq(*username, "root") || streq(*username, "0")) {
4595                 *username = "root";
4596
4597                 if (uid)
4598                         *uid = 0;
4599
4600                 if (gid)
4601                         *gid = 0;
4602
4603                 if (home)
4604                         *home = "/root";
4605
4606                 if (shell)
4607                         *shell = "/bin/sh";
4608
4609                 return 0;
4610         }
4611
4612         if (parse_uid(*username, &u) >= 0) {
4613                 errno = 0;
4614                 p = getpwuid(u);
4615
4616                 /* If there are multiple users with the same id, make
4617                  * sure to leave $USER to the configured value instead
4618                  * of the first occurrence in the database. However if
4619                  * the uid was configured by a numeric uid, then let's
4620                  * pick the real username from /etc/passwd. */
4621                 if (p)
4622                         *username = p->pw_name;
4623         } else {
4624                 errno = 0;
4625                 p = getpwnam(*username);
4626         }
4627
4628         if (!p)
4629                 return errno > 0 ? -errno : -ESRCH;
4630
4631         if (uid)
4632                 *uid = p->pw_uid;
4633
4634         if (gid)
4635                 *gid = p->pw_gid;
4636
4637         if (home)
4638                 *home = p->pw_dir;
4639
4640         if (shell)
4641                 *shell = p->pw_shell;
4642
4643         return 0;
4644 }
4645
4646 char* uid_to_name(uid_t uid) {
4647         struct passwd *p;
4648         char *r;
4649
4650         if (uid == 0)
4651                 return strdup("root");
4652
4653         p = getpwuid(uid);
4654         if (p)
4655                 return strdup(p->pw_name);
4656
4657         if (asprintf(&r, UID_FMT, uid) < 0)
4658                 return NULL;
4659
4660         return r;
4661 }
4662
4663 char* gid_to_name(gid_t gid) {
4664         struct group *p;
4665         char *r;
4666
4667         if (gid == 0)
4668                 return strdup("root");
4669
4670         p = getgrgid(gid);
4671         if (p)
4672                 return strdup(p->gr_name);
4673
4674         if (asprintf(&r, GID_FMT, gid) < 0)
4675                 return NULL;
4676
4677         return r;
4678 }
4679
4680 int get_group_creds(const char **groupname, gid_t *gid) {
4681         struct group *g;
4682         gid_t id;
4683
4684         assert(groupname);
4685
4686         /* We enforce some special rules for gid=0: in order to avoid
4687          * NSS lookups for root we hardcode its data. */
4688
4689         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4690                 *groupname = "root";
4691
4692                 if (gid)
4693                         *gid = 0;
4694
4695                 return 0;
4696         }
4697
4698         if (parse_gid(*groupname, &id) >= 0) {
4699                 errno = 0;
4700                 g = getgrgid(id);
4701
4702                 if (g)
4703                         *groupname = g->gr_name;
4704         } else {
4705                 errno = 0;
4706                 g = getgrnam(*groupname);
4707         }
4708
4709         if (!g)
4710                 return errno > 0 ? -errno : -ESRCH;
4711
4712         if (gid)
4713                 *gid = g->gr_gid;
4714
4715         return 0;
4716 }
4717
4718 int in_gid(gid_t gid) {
4719         gid_t *gids;
4720         int ngroups_max, r, i;
4721
4722         if (getgid() == gid)
4723                 return 1;
4724
4725         if (getegid() == gid)
4726                 return 1;
4727
4728         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4729         assert(ngroups_max > 0);
4730
4731         gids = alloca(sizeof(gid_t) * ngroups_max);
4732
4733         r = getgroups(ngroups_max, gids);
4734         if (r < 0)
4735                 return -errno;
4736
4737         for (i = 0; i < r; i++)
4738                 if (gids[i] == gid)
4739                         return 1;
4740
4741         return 0;
4742 }
4743
4744 int in_group(const char *name) {
4745         int r;
4746         gid_t gid;
4747
4748         r = get_group_creds(&name, &gid);
4749         if (r < 0)
4750                 return r;
4751
4752         return in_gid(gid);
4753 }
4754
4755 int glob_exists(const char *path) {
4756         _cleanup_globfree_ glob_t g = {};
4757         int k;
4758
4759         assert(path);
4760
4761         errno = 0;
4762         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4763
4764         if (k == GLOB_NOMATCH)
4765                 return 0;
4766         else if (k == GLOB_NOSPACE)
4767                 return -ENOMEM;
4768         else if (k == 0)
4769                 return !strv_isempty(g.gl_pathv);
4770         else
4771                 return errno ? -errno : -EIO;
4772 }
4773
4774 int glob_extend(char ***strv, const char *path) {
4775         _cleanup_globfree_ glob_t g = {};
4776         int k;
4777         char **p;
4778
4779         errno = 0;
4780         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4781
4782         if (k == GLOB_NOMATCH)
4783                 return -ENOENT;
4784         else if (k == GLOB_NOSPACE)
4785                 return -ENOMEM;
4786         else if (k != 0 || strv_isempty(g.gl_pathv))
4787                 return errno ? -errno : -EIO;
4788
4789         STRV_FOREACH(p, g.gl_pathv) {
4790                 k = strv_extend(strv, *p);
4791                 if (k < 0)
4792                         break;
4793         }
4794
4795         return k;
4796 }
4797
4798 int dirent_ensure_type(DIR *d, struct dirent *de) {
4799         struct stat st;
4800
4801         assert(d);
4802         assert(de);
4803
4804         if (de->d_type != DT_UNKNOWN)
4805                 return 0;
4806
4807         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4808                 return -errno;
4809
4810         de->d_type =
4811                 S_ISREG(st.st_mode)  ? DT_REG  :
4812                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4813                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4814                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4815                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4816                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4817                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4818                                        DT_UNKNOWN;
4819
4820         return 0;
4821 }
4822
4823 int get_files_in_directory(const char *path, char ***list) {
4824         _cleanup_closedir_ DIR *d = NULL;
4825         size_t bufsize = 0, n = 0;
4826         _cleanup_strv_free_ char **l = NULL;
4827
4828         assert(path);
4829
4830         /* Returns all files in a directory in *list, and the number
4831          * of files as return value. If list is NULL returns only the
4832          * number. */
4833
4834         d = opendir(path);
4835         if (!d)
4836                 return -errno;
4837
4838         for (;;) {
4839                 struct dirent *de;
4840
4841                 errno = 0;
4842                 de = readdir(d);
4843                 if (!de && errno != 0)
4844                         return -errno;
4845                 if (!de)
4846                         break;
4847
4848                 dirent_ensure_type(d, de);
4849
4850                 if (!dirent_is_file(de))
4851                         continue;
4852
4853                 if (list) {
4854                         /* one extra slot is needed for the terminating NULL */
4855                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
4856                                 return -ENOMEM;
4857
4858                         l[n] = strdup(de->d_name);
4859                         if (!l[n])
4860                                 return -ENOMEM;
4861
4862                         l[++n] = NULL;
4863                 } else
4864                         n++;
4865         }
4866
4867         if (list) {
4868                 *list = l;
4869                 l = NULL; /* avoid freeing */
4870         }
4871
4872         return n;
4873 }
4874
4875 char *strjoin(const char *x, ...) {
4876         va_list ap;
4877         size_t l;
4878         char *r, *p;
4879
4880         va_start(ap, x);
4881
4882         if (x) {
4883                 l = strlen(x);
4884
4885                 for (;;) {
4886                         const char *t;
4887                         size_t n;
4888
4889                         t = va_arg(ap, const char *);
4890                         if (!t)
4891                                 break;
4892
4893                         n = strlen(t);
4894                         if (n > ((size_t) -1) - l) {
4895                                 va_end(ap);
4896                                 return NULL;
4897                         }
4898
4899                         l += n;
4900                 }
4901         } else
4902                 l = 0;
4903
4904         va_end(ap);
4905
4906         r = new(char, l+1);
4907         if (!r)
4908                 return NULL;
4909
4910         if (x) {
4911                 p = stpcpy(r, x);
4912
4913                 va_start(ap, x);
4914
4915                 for (;;) {
4916                         const char *t;
4917
4918                         t = va_arg(ap, const char *);
4919                         if (!t)
4920                                 break;
4921
4922                         p = stpcpy(p, t);
4923                 }
4924
4925                 va_end(ap);
4926         } else
4927                 r[0] = 0;
4928
4929         return r;
4930 }
4931
4932 bool is_main_thread(void) {
4933         static thread_local int cached = 0;
4934
4935         if (_unlikely_(cached == 0))
4936                 cached = getpid() == gettid() ? 1 : -1;
4937
4938         return cached > 0;
4939 }
4940
4941 int block_get_whole_disk(dev_t d, dev_t *ret) {
4942         char *p, *s;
4943         int r;
4944         unsigned n, m;
4945
4946         assert(ret);
4947
4948         /* If it has a queue this is good enough for us */
4949         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4950                 return -ENOMEM;
4951
4952         r = access(p, F_OK);
4953         free(p);
4954
4955         if (r >= 0) {
4956                 *ret = d;
4957                 return 0;
4958         }
4959
4960         /* If it is a partition find the originating device */
4961         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4962                 return -ENOMEM;
4963
4964         r = access(p, F_OK);
4965         free(p);
4966
4967         if (r < 0)
4968                 return -ENOENT;
4969
4970         /* Get parent dev_t */
4971         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4972                 return -ENOMEM;
4973
4974         r = read_one_line_file(p, &s);
4975         free(p);
4976
4977         if (r < 0)
4978                 return r;
4979
4980         r = sscanf(s, "%u:%u", &m, &n);
4981         free(s);
4982
4983         if (r != 2)
4984                 return -EINVAL;
4985
4986         /* Only return this if it is really good enough for us. */
4987         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4988                 return -ENOMEM;
4989
4990         r = access(p, F_OK);
4991         free(p);
4992
4993         if (r >= 0) {
4994                 *ret = makedev(m, n);
4995                 return 0;
4996         }
4997
4998         return -ENOENT;
4999 }
5000
5001 static const char *const ioprio_class_table[] = {
5002         [IOPRIO_CLASS_NONE] = "none",
5003         [IOPRIO_CLASS_RT] = "realtime",
5004         [IOPRIO_CLASS_BE] = "best-effort",
5005         [IOPRIO_CLASS_IDLE] = "idle"
5006 };
5007
5008 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
5009
5010 static const char *const sigchld_code_table[] = {
5011         [CLD_EXITED] = "exited",
5012         [CLD_KILLED] = "killed",
5013         [CLD_DUMPED] = "dumped",
5014         [CLD_TRAPPED] = "trapped",
5015         [CLD_STOPPED] = "stopped",
5016         [CLD_CONTINUED] = "continued",
5017 };
5018
5019 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
5020
5021 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
5022         [LOG_FAC(LOG_KERN)] = "kern",
5023         [LOG_FAC(LOG_USER)] = "user",
5024         [LOG_FAC(LOG_MAIL)] = "mail",
5025         [LOG_FAC(LOG_DAEMON)] = "daemon",
5026         [LOG_FAC(LOG_AUTH)] = "auth",
5027         [LOG_FAC(LOG_SYSLOG)] = "syslog",
5028         [LOG_FAC(LOG_LPR)] = "lpr",
5029         [LOG_FAC(LOG_NEWS)] = "news",
5030         [LOG_FAC(LOG_UUCP)] = "uucp",
5031         [LOG_FAC(LOG_CRON)] = "cron",
5032         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5033         [LOG_FAC(LOG_FTP)] = "ftp",
5034         [LOG_FAC(LOG_LOCAL0)] = "local0",
5035         [LOG_FAC(LOG_LOCAL1)] = "local1",
5036         [LOG_FAC(LOG_LOCAL2)] = "local2",
5037         [LOG_FAC(LOG_LOCAL3)] = "local3",
5038         [LOG_FAC(LOG_LOCAL4)] = "local4",
5039         [LOG_FAC(LOG_LOCAL5)] = "local5",
5040         [LOG_FAC(LOG_LOCAL6)] = "local6",
5041         [LOG_FAC(LOG_LOCAL7)] = "local7"
5042 };
5043
5044 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
5045
5046 static const char *const log_level_table[] = {
5047         [LOG_EMERG] = "emerg",
5048         [LOG_ALERT] = "alert",
5049         [LOG_CRIT] = "crit",
5050         [LOG_ERR] = "err",
5051         [LOG_WARNING] = "warning",
5052         [LOG_NOTICE] = "notice",
5053         [LOG_INFO] = "info",
5054         [LOG_DEBUG] = "debug"
5055 };
5056
5057 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
5058
5059 static const char* const sched_policy_table[] = {
5060         [SCHED_OTHER] = "other",
5061         [SCHED_BATCH] = "batch",
5062         [SCHED_IDLE] = "idle",
5063         [SCHED_FIFO] = "fifo",
5064         [SCHED_RR] = "rr"
5065 };
5066
5067 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
5068
5069 static const char* const rlimit_table[_RLIMIT_MAX] = {
5070         [RLIMIT_CPU] = "LimitCPU",
5071         [RLIMIT_FSIZE] = "LimitFSIZE",
5072         [RLIMIT_DATA] = "LimitDATA",
5073         [RLIMIT_STACK] = "LimitSTACK",
5074         [RLIMIT_CORE] = "LimitCORE",
5075         [RLIMIT_RSS] = "LimitRSS",
5076         [RLIMIT_NOFILE] = "LimitNOFILE",
5077         [RLIMIT_AS] = "LimitAS",
5078         [RLIMIT_NPROC] = "LimitNPROC",
5079         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5080         [RLIMIT_LOCKS] = "LimitLOCKS",
5081         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5082         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5083         [RLIMIT_NICE] = "LimitNICE",
5084         [RLIMIT_RTPRIO] = "LimitRTPRIO",
5085         [RLIMIT_RTTIME] = "LimitRTTIME"
5086 };
5087
5088 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5089
5090 static const char* const ip_tos_table[] = {
5091         [IPTOS_LOWDELAY] = "low-delay",
5092         [IPTOS_THROUGHPUT] = "throughput",
5093         [IPTOS_RELIABILITY] = "reliability",
5094         [IPTOS_LOWCOST] = "low-cost",
5095 };
5096
5097 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
5098
5099 static const char *const __signal_table[] = {
5100         [SIGHUP] = "HUP",
5101         [SIGINT] = "INT",
5102         [SIGQUIT] = "QUIT",
5103         [SIGILL] = "ILL",
5104         [SIGTRAP] = "TRAP",
5105         [SIGABRT] = "ABRT",
5106         [SIGBUS] = "BUS",
5107         [SIGFPE] = "FPE",
5108         [SIGKILL] = "KILL",
5109         [SIGUSR1] = "USR1",
5110         [SIGSEGV] = "SEGV",
5111         [SIGUSR2] = "USR2",
5112         [SIGPIPE] = "PIPE",
5113         [SIGALRM] = "ALRM",
5114         [SIGTERM] = "TERM",
5115 #ifdef SIGSTKFLT
5116         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
5117 #endif
5118         [SIGCHLD] = "CHLD",
5119         [SIGCONT] = "CONT",
5120         [SIGSTOP] = "STOP",
5121         [SIGTSTP] = "TSTP",
5122         [SIGTTIN] = "TTIN",
5123         [SIGTTOU] = "TTOU",
5124         [SIGURG] = "URG",
5125         [SIGXCPU] = "XCPU",
5126         [SIGXFSZ] = "XFSZ",
5127         [SIGVTALRM] = "VTALRM",
5128         [SIGPROF] = "PROF",
5129         [SIGWINCH] = "WINCH",
5130         [SIGIO] = "IO",
5131         [SIGPWR] = "PWR",
5132         [SIGSYS] = "SYS"
5133 };
5134
5135 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5136
5137 const char *signal_to_string(int signo) {
5138         static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
5139         const char *name;
5140
5141         name = __signal_to_string(signo);
5142         if (name)
5143                 return name;
5144
5145         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5146                 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
5147         else
5148                 snprintf(buf, sizeof(buf), "%d", signo);
5149
5150         return buf;
5151 }
5152
5153 int signal_from_string(const char *s) {
5154         int signo;
5155         int offset = 0;
5156         unsigned u;
5157
5158         signo = __signal_from_string(s);
5159         if (signo > 0)
5160                 return signo;
5161
5162         if (startswith(s, "RTMIN+")) {
5163                 s += 6;
5164                 offset = SIGRTMIN;
5165         }
5166         if (safe_atou(s, &u) >= 0) {
5167                 signo = (int) u + offset;
5168                 if (signo > 0 && signo < _NSIG)
5169                         return signo;
5170         }
5171         return -EINVAL;
5172 }
5173
5174 bool kexec_loaded(void) {
5175        bool loaded = false;
5176        char *s;
5177
5178        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5179                if (s[0] == '1')
5180                        loaded = true;
5181                free(s);
5182        }
5183        return loaded;
5184 }
5185
5186 int prot_from_flags(int flags) {
5187
5188         switch (flags & O_ACCMODE) {
5189
5190         case O_RDONLY:
5191                 return PROT_READ;
5192
5193         case O_WRONLY:
5194                 return PROT_WRITE;
5195
5196         case O_RDWR:
5197                 return PROT_READ|PROT_WRITE;
5198
5199         default:
5200                 return -EINVAL;
5201         }
5202 }
5203
5204 char *format_bytes(char *buf, size_t l, off_t t) {
5205         unsigned i;
5206
5207         static const struct {
5208                 const char *suffix;
5209                 off_t factor;
5210         } table[] = {
5211                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5212                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5213                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5214                 { "G", 1024ULL*1024ULL*1024ULL },
5215                 { "M", 1024ULL*1024ULL },
5216                 { "K", 1024ULL },
5217         };
5218
5219         if (t == (off_t) -1)
5220                 return NULL;
5221
5222         for (i = 0; i < ELEMENTSOF(table); i++) {
5223
5224                 if (t >= table[i].factor) {
5225                         snprintf(buf, l,
5226                                  "%llu.%llu%s",
5227                                  (unsigned long long) (t / table[i].factor),
5228                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5229                                  table[i].suffix);
5230
5231                         goto finish;
5232                 }
5233         }
5234
5235         snprintf(buf, l, "%lluB", (unsigned long long) t);
5236
5237 finish:
5238         buf[l-1] = 0;
5239         return buf;
5240
5241 }
5242
5243 void* memdup(const void *p, size_t l) {
5244         void *r;
5245
5246         assert(p);
5247
5248         r = malloc(l);
5249         if (!r)
5250                 return NULL;
5251
5252         memcpy(r, p, l);
5253         return r;
5254 }
5255
5256 int fd_inc_sndbuf(int fd, size_t n) {
5257         int r, value;
5258         socklen_t l = sizeof(value);
5259
5260         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5261         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5262                 return 0;
5263
5264         /* If we have the privileges we will ignore the kernel limit. */
5265
5266         value = (int) n;
5267         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
5268                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
5269                         return -errno;
5270
5271         return 1;
5272 }
5273
5274 int fd_inc_rcvbuf(int fd, size_t n) {
5275         int r, value;
5276         socklen_t l = sizeof(value);
5277
5278         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5279         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5280                 return 0;
5281
5282         /* If we have the privileges we will ignore the kernel limit. */
5283
5284         value = (int) n;
5285         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
5286                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
5287                         return -errno;
5288         return 1;
5289 }
5290
5291 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5292         bool stdout_is_tty, stderr_is_tty;
5293         pid_t parent_pid, agent_pid;
5294         sigset_t ss, saved_ss;
5295         unsigned n, i;
5296         va_list ap;
5297         char **l;
5298
5299         assert(pid);
5300         assert(path);
5301
5302         /* Spawns a temporary TTY agent, making sure it goes away when
5303          * we go away */
5304
5305         parent_pid = getpid();
5306
5307         /* First we temporarily block all signals, so that the new
5308          * child has them blocked initially. This way, we can be sure
5309          * that SIGTERMs are not lost we might send to the agent. */
5310         assert_se(sigfillset(&ss) >= 0);
5311         assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
5312
5313         agent_pid = fork();
5314         if (agent_pid < 0) {
5315                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5316                 return -errno;
5317         }
5318
5319         if (agent_pid != 0) {
5320                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5321                 *pid = agent_pid;
5322                 return 0;
5323         }
5324
5325         /* In the child:
5326          *
5327          * Make sure the agent goes away when the parent dies */
5328         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5329                 _exit(EXIT_FAILURE);
5330
5331         /* Make sure we actually can kill the agent, if we need to, in
5332          * case somebody invoked us from a shell script that trapped
5333          * SIGTERM or so... */
5334         reset_all_signal_handlers();
5335         reset_signal_mask();
5336
5337         /* Check whether our parent died before we were able
5338          * to set the death signal and unblock the signals */
5339         if (getppid() != parent_pid)
5340                 _exit(EXIT_SUCCESS);
5341
5342         /* Don't leak fds to the agent */
5343         close_all_fds(except, n_except);
5344
5345         stdout_is_tty = isatty(STDOUT_FILENO);
5346         stderr_is_tty = isatty(STDERR_FILENO);
5347
5348         if (!stdout_is_tty || !stderr_is_tty) {
5349                 int fd;
5350
5351                 /* Detach from stdout/stderr. and reopen
5352                  * /dev/tty for them. This is important to
5353                  * ensure that when systemctl is started via
5354                  * popen() or a similar call that expects to
5355                  * read EOF we actually do generate EOF and
5356                  * not delay this indefinitely by because we
5357                  * keep an unused copy of stdin around. */
5358                 fd = open("/dev/tty", O_WRONLY);
5359                 if (fd < 0) {
5360                         log_error_errno(errno, "Failed to open /dev/tty: %m");
5361                         _exit(EXIT_FAILURE);
5362                 }
5363
5364                 if (!stdout_is_tty)
5365                         dup2(fd, STDOUT_FILENO);
5366
5367                 if (!stderr_is_tty)
5368                         dup2(fd, STDERR_FILENO);
5369
5370                 if (fd > 2)
5371                         close(fd);
5372         }
5373
5374         /* Count arguments */
5375         va_start(ap, path);
5376         for (n = 0; va_arg(ap, char*); n++)
5377                 ;
5378         va_end(ap);
5379
5380         /* Allocate strv */
5381         l = alloca(sizeof(char *) * (n + 1));
5382
5383         /* Fill in arguments */
5384         va_start(ap, path);
5385         for (i = 0; i <= n; i++)
5386                 l[i] = va_arg(ap, char*);
5387         va_end(ap);
5388
5389         execv(path, l);
5390         _exit(EXIT_FAILURE);
5391 }
5392
5393 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5394         struct rlimit highest, fixed;
5395
5396         assert(rlim);
5397
5398         if (setrlimit(resource, rlim) >= 0)
5399                 return 0;
5400
5401         if (errno != EPERM)
5402                 return -errno;
5403
5404         /* So we failed to set the desired setrlimit, then let's try
5405          * to get as close as we can */
5406         assert_se(getrlimit(resource, &highest) == 0);
5407
5408         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5409         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5410
5411         if (setrlimit(resource, &fixed) < 0)
5412                 return -errno;
5413
5414         return 0;
5415 }
5416
5417 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5418         _cleanup_fclose_ FILE *f = NULL;
5419         char *value = NULL;
5420         int r;
5421         bool done = false;
5422         size_t l;
5423         const char *path;
5424
5425         assert(pid >= 0);
5426         assert(field);
5427         assert(_value);
5428
5429         path = procfs_file_alloca(pid, "environ");
5430
5431         f = fopen(path, "re");
5432         if (!f)
5433                 return -errno;
5434
5435         l = strlen(field);
5436         r = 0;
5437
5438         do {
5439                 char line[LINE_MAX];
5440                 unsigned i;
5441
5442                 for (i = 0; i < sizeof(line)-1; i++) {
5443                         int c;
5444
5445                         c = getc(f);
5446                         if (_unlikely_(c == EOF)) {
5447                                 done = true;
5448                                 break;
5449                         } else if (c == 0)
5450                                 break;
5451
5452                         line[i] = c;
5453                 }
5454                 line[i] = 0;
5455
5456                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5457                         value = strdup(line + l + 1);
5458                         if (!value)
5459                                 return -ENOMEM;
5460
5461                         r = 1;
5462                         break;
5463                 }
5464
5465         } while (!done);
5466
5467         *_value = value;
5468         return r;
5469 }
5470
5471 bool is_valid_documentation_url(const char *url) {
5472         assert(url);
5473
5474         if (startswith(url, "http://") && url[7])
5475                 return true;
5476
5477         if (startswith(url, "https://") && url[8])
5478                 return true;
5479
5480         if (startswith(url, "file:") && url[5])
5481                 return true;
5482
5483         if (startswith(url, "info:") && url[5])
5484                 return true;
5485
5486         if (startswith(url, "man:") && url[4])
5487                 return true;
5488
5489         return false;
5490 }
5491
5492 bool in_initrd(void) {
5493         static int saved = -1;
5494         struct statfs s;
5495
5496         if (saved >= 0)
5497                 return saved;
5498
5499         /* We make two checks here:
5500          *
5501          * 1. the flag file /etc/initrd-release must exist
5502          * 2. the root file system must be a memory file system
5503          *
5504          * The second check is extra paranoia, since misdetecting an
5505          * initrd can have bad bad consequences due the initrd
5506          * emptying when transititioning to the main systemd.
5507          */
5508
5509         saved = access("/etc/initrd-release", F_OK) >= 0 &&
5510                 statfs("/", &s) >= 0 &&
5511                 is_temporary_fs(&s);
5512
5513         return saved;
5514 }
5515
5516 void warn_melody(void) {
5517         _cleanup_close_ int fd = -1;
5518
5519         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5520         if (fd < 0)
5521                 return;
5522
5523         /* Yeah, this is synchronous. Kinda sucks. But well... */
5524
5525         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5526         usleep(125*USEC_PER_MSEC);
5527
5528         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5529         usleep(125*USEC_PER_MSEC);
5530
5531         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5532         usleep(125*USEC_PER_MSEC);
5533
5534         ioctl(fd, KIOCSOUND, 0);
5535 }
5536
5537 int make_console_stdio(void) {
5538         int fd, r;
5539
5540         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5541
5542         fd = acquire_terminal("/dev/console", false, true, true, USEC_INFINITY);
5543         if (fd < 0)
5544                 return log_error_errno(fd, "Failed to acquire terminal: %m");
5545
5546         r = make_stdio(fd);
5547         if (r < 0)
5548                 return log_error_errno(r, "Failed to duplicate terminal fd: %m");
5549
5550         return 0;
5551 }
5552
5553 int get_home_dir(char **_h) {
5554         struct passwd *p;
5555         const char *e;
5556         char *h;
5557         uid_t u;
5558
5559         assert(_h);
5560
5561         /* Take the user specified one */
5562         e = secure_getenv("HOME");
5563         if (e && path_is_absolute(e)) {
5564                 h = strdup(e);
5565                 if (!h)
5566                         return -ENOMEM;
5567
5568                 *_h = h;
5569                 return 0;
5570         }
5571
5572         /* Hardcode home directory for root to avoid NSS */
5573         u = getuid();
5574         if (u == 0) {
5575                 h = strdup("/root");
5576                 if (!h)
5577                         return -ENOMEM;
5578
5579                 *_h = h;
5580                 return 0;
5581         }
5582
5583         /* Check the database... */
5584         errno = 0;
5585         p = getpwuid(u);
5586         if (!p)
5587                 return errno > 0 ? -errno : -ESRCH;
5588
5589         if (!path_is_absolute(p->pw_dir))
5590                 return -EINVAL;
5591
5592         h = strdup(p->pw_dir);
5593         if (!h)
5594                 return -ENOMEM;
5595
5596         *_h = h;
5597         return 0;
5598 }
5599
5600 int get_shell(char **_s) {
5601         struct passwd *p;
5602         const char *e;
5603         char *s;
5604         uid_t u;
5605
5606         assert(_s);
5607
5608         /* Take the user specified one */
5609         e = getenv("SHELL");
5610         if (e) {
5611                 s = strdup(e);
5612                 if (!s)
5613                         return -ENOMEM;
5614
5615                 *_s = s;
5616                 return 0;
5617         }
5618
5619         /* Hardcode home directory for root to avoid NSS */
5620         u = getuid();
5621         if (u == 0) {
5622                 s = strdup("/bin/sh");
5623                 if (!s)
5624                         return -ENOMEM;
5625
5626                 *_s = s;
5627                 return 0;
5628         }
5629
5630         /* Check the database... */
5631         errno = 0;
5632         p = getpwuid(u);
5633         if (!p)
5634                 return errno > 0 ? -errno : -ESRCH;
5635
5636         if (!path_is_absolute(p->pw_shell))
5637                 return -EINVAL;
5638
5639         s = strdup(p->pw_shell);
5640         if (!s)
5641                 return -ENOMEM;
5642
5643         *_s = s;
5644         return 0;
5645 }
5646
5647 bool filename_is_valid(const char *p) {
5648
5649         if (isempty(p))
5650                 return false;
5651
5652         if (strchr(p, '/'))
5653                 return false;
5654
5655         if (streq(p, "."))
5656                 return false;
5657
5658         if (streq(p, ".."))
5659                 return false;
5660
5661         if (strlen(p) > FILENAME_MAX)
5662                 return false;
5663
5664         return true;
5665 }
5666
5667 bool string_is_safe(const char *p) {
5668         const char *t;
5669
5670         if (!p)
5671                 return false;
5672
5673         for (t = p; *t; t++) {
5674                 if (*t > 0 && *t < ' ')
5675                         return false;
5676
5677                 if (strchr("\\\"\'\0x7f", *t))
5678                         return false;
5679         }
5680
5681         return true;
5682 }
5683
5684 /**
5685  * Check if a string contains control characters. If 'ok' is non-NULL
5686  * it may be a string containing additional CCs to be considered OK.
5687  */
5688 bool string_has_cc(const char *p, const char *ok) {
5689         const char *t;
5690
5691         assert(p);
5692
5693         for (t = p; *t; t++) {
5694                 if (ok && strchr(ok, *t))
5695                         continue;
5696
5697                 if (*t > 0 && *t < ' ')
5698                         return true;
5699
5700                 if (*t == 127)
5701                         return true;
5702         }
5703
5704         return false;
5705 }
5706
5707 bool path_is_safe(const char *p) {
5708
5709         if (isempty(p))
5710                 return false;
5711
5712         if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5713                 return false;
5714
5715         if (strlen(p) > PATH_MAX)
5716                 return false;
5717
5718         /* The following two checks are not really dangerous, but hey, they still are confusing */
5719         if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5720                 return false;
5721
5722         if (strstr(p, "//"))
5723                 return false;
5724
5725         return true;
5726 }
5727
5728 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5729 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5730                  int (*compar) (const void *, const void *, void *), void *arg) {
5731         size_t l, u, idx;
5732         const void *p;
5733         int comparison;
5734
5735         l = 0;
5736         u = nmemb;
5737         while (l < u) {
5738                 idx = (l + u) / 2;
5739                 p = (void *)(((const char *) base) + (idx * size));
5740                 comparison = compar(key, p, arg);
5741                 if (comparison < 0)
5742                         u = idx;
5743                 else if (comparison > 0)
5744                         l = idx + 1;
5745                 else
5746                         return (void *)p;
5747         }
5748         return NULL;
5749 }
5750
5751 bool is_locale_utf8(void) {
5752         const char *set;
5753         static int cached_answer = -1;
5754
5755         if (cached_answer >= 0)
5756                 goto out;
5757
5758         if (!setlocale(LC_ALL, "")) {
5759                 cached_answer = true;
5760                 goto out;
5761         }
5762
5763         set = nl_langinfo(CODESET);
5764         if (!set) {
5765                 cached_answer = true;
5766                 goto out;
5767         }
5768
5769         if (streq(set, "UTF-8")) {
5770                 cached_answer = true;
5771                 goto out;
5772         }
5773
5774         /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5775          * unset and everything can do to UTF-8 nowadays. */
5776         set = setlocale(LC_CTYPE, NULL);
5777         if (!set) {
5778                 cached_answer = true;
5779                 goto out;
5780         }
5781
5782         /* Check result, but ignore the result if C was set
5783          * explicitly. */
5784         cached_answer =
5785                 streq(set, "C") &&
5786                 !getenv("LC_ALL") &&
5787                 !getenv("LC_CTYPE") &&
5788                 !getenv("LANG");
5789
5790 out:
5791         return (bool) cached_answer;
5792 }
5793
5794 const char *draw_special_char(DrawSpecialChar ch) {
5795         static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5796
5797                 /* UTF-8 */ {
5798                         [DRAW_TREE_VERTICAL]      = "\342\224\202 ",            /* │  */
5799                         [DRAW_TREE_BRANCH]        = "\342\224\234\342\224\200", /* ├─ */
5800                         [DRAW_TREE_RIGHT]         = "\342\224\224\342\224\200", /* └─ */
5801                         [DRAW_TREE_SPACE]         = "  ",                       /*    */
5802                         [DRAW_TRIANGULAR_BULLET]  = "\342\200\243",             /* ‣ */
5803                         [DRAW_BLACK_CIRCLE]       = "\342\227\217",             /* ● */
5804                         [DRAW_ARROW]              = "\342\206\222",             /* → */
5805                         [DRAW_DASH]               = "\342\200\223",             /* – */
5806                 },
5807
5808                 /* ASCII fallback */ {
5809                         [DRAW_TREE_VERTICAL]      = "| ",
5810                         [DRAW_TREE_BRANCH]        = "|-",
5811                         [DRAW_TREE_RIGHT]         = "`-",
5812                         [DRAW_TREE_SPACE]         = "  ",
5813                         [DRAW_TRIANGULAR_BULLET]  = ">",
5814                         [DRAW_BLACK_CIRCLE]       = "*",
5815                         [DRAW_ARROW]              = "->",
5816                         [DRAW_DASH]               = "-",
5817                 }
5818         };
5819
5820         return draw_table[!is_locale_utf8()][ch];
5821 }
5822
5823 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5824         const char *f;
5825         char *t, *r;
5826         size_t l, old_len, new_len;
5827
5828         assert(text);
5829         assert(old_string);
5830         assert(new_string);
5831
5832         old_len = strlen(old_string);
5833         new_len = strlen(new_string);
5834
5835         l = strlen(text);
5836         r = new(char, l+1);
5837         if (!r)
5838                 return NULL;
5839
5840         f = text;
5841         t = r;
5842         while (*f) {
5843                 char *a;
5844                 size_t d, nl;
5845
5846                 if (!startswith(f, old_string)) {
5847                         *(t++) = *(f++);
5848                         continue;
5849                 }
5850
5851                 d = t - r;
5852                 nl = l - old_len + new_len;
5853                 a = realloc(r, nl + 1);
5854                 if (!a)
5855                         goto oom;
5856
5857                 l = nl;
5858                 r = a;
5859                 t = r + d;
5860
5861                 t = stpcpy(t, new_string);
5862                 f += old_len;
5863         }
5864
5865         *t = 0;
5866         return r;
5867
5868 oom:
5869         free(r);
5870         return NULL;
5871 }
5872
5873 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5874         const char *i, *begin = NULL;
5875         enum {
5876                 STATE_OTHER,
5877                 STATE_ESCAPE,
5878                 STATE_BRACKET
5879         } state = STATE_OTHER;
5880         char *obuf = NULL;
5881         size_t osz = 0, isz;
5882         FILE *f;
5883
5884         assert(ibuf);
5885         assert(*ibuf);
5886
5887         /* Strips ANSI color and replaces TABs by 8 spaces */
5888
5889         isz = _isz ? *_isz : strlen(*ibuf);
5890
5891         f = open_memstream(&obuf, &osz);
5892         if (!f)
5893                 return NULL;
5894
5895         for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5896
5897                 switch (state) {
5898
5899                 case STATE_OTHER:
5900                         if (i >= *ibuf + isz) /* EOT */
5901                                 break;
5902                         else if (*i == '\x1B')
5903                                 state = STATE_ESCAPE;
5904                         else if (*i == '\t')
5905                                 fputs("        ", f);
5906                         else
5907                                 fputc(*i, f);
5908                         break;
5909
5910                 case STATE_ESCAPE:
5911                         if (i >= *ibuf + isz) { /* EOT */
5912                                 fputc('\x1B', f);
5913                                 break;
5914                         } else if (*i == '[') {
5915                                 state = STATE_BRACKET;
5916                                 begin = i + 1;
5917                         } else {
5918                                 fputc('\x1B', f);
5919                                 fputc(*i, f);
5920                                 state = STATE_OTHER;
5921                         }
5922
5923                         break;
5924
5925                 case STATE_BRACKET:
5926
5927                         if (i >= *ibuf + isz || /* EOT */
5928                             (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5929                                 fputc('\x1B', f);
5930                                 fputc('[', f);
5931                                 state = STATE_OTHER;
5932                                 i = begin-1;
5933                         } else if (*i == 'm')
5934                                 state = STATE_OTHER;
5935                         break;
5936                 }
5937         }
5938
5939         if (ferror(f)) {
5940                 fclose(f);
5941                 free(obuf);
5942                 return NULL;
5943         }
5944
5945         fclose(f);
5946
5947         free(*ibuf);
5948         *ibuf = obuf;
5949
5950         if (_isz)
5951                 *_isz = osz;
5952
5953         return obuf;
5954 }
5955
5956 int on_ac_power(void) {
5957         bool found_offline = false, found_online = false;
5958         _cleanup_closedir_ DIR *d = NULL;
5959
5960         d = opendir("/sys/class/power_supply");
5961         if (!d)
5962                 return -errno;
5963
5964         for (;;) {
5965                 struct dirent *de;
5966                 _cleanup_close_ int fd = -1, device = -1;
5967                 char contents[6];
5968                 ssize_t n;
5969
5970                 errno = 0;
5971                 de = readdir(d);
5972                 if (!de && errno != 0)
5973                         return -errno;
5974
5975                 if (!de)
5976                         break;
5977
5978                 if (hidden_file(de->d_name))
5979                         continue;
5980
5981                 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5982                 if (device < 0) {
5983                         if (errno == ENOENT || errno == ENOTDIR)
5984                                 continue;
5985
5986                         return -errno;
5987                 }
5988
5989                 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5990                 if (fd < 0) {
5991                         if (errno == ENOENT)
5992                                 continue;
5993
5994                         return -errno;
5995                 }
5996
5997                 n = read(fd, contents, sizeof(contents));
5998                 if (n < 0)
5999                         return -errno;
6000
6001                 if (n != 6 || memcmp(contents, "Mains\n", 6))
6002                         continue;
6003
6004                 safe_close(fd);
6005                 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
6006                 if (fd < 0) {
6007                         if (errno == ENOENT)
6008                                 continue;
6009
6010                         return -errno;
6011                 }
6012
6013                 n = read(fd, contents, sizeof(contents));
6014                 if (n < 0)
6015                         return -errno;
6016
6017                 if (n != 2 || contents[1] != '\n')
6018                         return -EIO;
6019
6020                 if (contents[0] == '1') {
6021                         found_online = true;
6022                         break;
6023                 } else if (contents[0] == '0')
6024                         found_offline = true;
6025                 else
6026                         return -EIO;
6027         }
6028
6029         return found_online || !found_offline;
6030 }
6031
6032 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
6033         char **i;
6034
6035         assert(path);
6036         assert(mode);
6037         assert(_f);
6038
6039         if (!path_strv_resolve_uniq(search, root))
6040                 return -ENOMEM;
6041
6042         STRV_FOREACH(i, search) {
6043                 _cleanup_free_ char *p = NULL;
6044                 FILE *f;
6045
6046                 if (root)
6047                         p = strjoin(root, *i, "/", path, NULL);
6048                 else
6049                         p = strjoin(*i, "/", path, NULL);
6050                 if (!p)
6051                         return -ENOMEM;
6052
6053                 f = fopen(p, mode);
6054                 if (f) {
6055                         *_f = f;
6056                         return 0;
6057                 }
6058
6059                 if (errno != ENOENT)
6060                         return -errno;
6061         }
6062
6063         return -ENOENT;
6064 }
6065
6066 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
6067         _cleanup_strv_free_ char **copy = NULL;
6068
6069         assert(path);
6070         assert(mode);
6071         assert(_f);
6072
6073         if (path_is_absolute(path)) {
6074                 FILE *f;
6075
6076                 f = fopen(path, mode);
6077                 if (f) {
6078                         *_f = f;
6079                         return 0;
6080                 }
6081
6082                 return -errno;
6083         }
6084
6085         copy = strv_copy((char**) search);
6086         if (!copy)
6087                 return -ENOMEM;
6088
6089         return search_and_fopen_internal(path, mode, root, copy, _f);
6090 }
6091
6092 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
6093         _cleanup_strv_free_ char **s = NULL;
6094
6095         if (path_is_absolute(path)) {
6096                 FILE *f;
6097
6098                 f = fopen(path, mode);
6099                 if (f) {
6100                         *_f = f;
6101                         return 0;
6102                 }
6103
6104                 return -errno;
6105         }
6106
6107         s = strv_split_nulstr(search);
6108         if (!s)
6109                 return -ENOMEM;
6110
6111         return search_and_fopen_internal(path, mode, root, s, _f);
6112 }
6113
6114 char *strextend(char **x, ...) {
6115         va_list ap;
6116         size_t f, l;
6117         char *r, *p;
6118
6119         assert(x);
6120
6121         l = f = *x ? strlen(*x) : 0;
6122
6123         va_start(ap, x);
6124         for (;;) {
6125                 const char *t;
6126                 size_t n;
6127
6128                 t = va_arg(ap, const char *);
6129                 if (!t)
6130                         break;
6131
6132                 n = strlen(t);
6133                 if (n > ((size_t) -1) - l) {
6134                         va_end(ap);
6135                         return NULL;
6136                 }
6137
6138                 l += n;
6139         }
6140         va_end(ap);
6141
6142         r = realloc(*x, l+1);
6143         if (!r)
6144                 return NULL;
6145
6146         p = r + f;
6147
6148         va_start(ap, x);
6149         for (;;) {
6150                 const char *t;
6151
6152                 t = va_arg(ap, const char *);
6153                 if (!t)
6154                         break;
6155
6156                 p = stpcpy(p, t);
6157         }
6158         va_end(ap);
6159
6160         *p = 0;
6161         *x = r;
6162
6163         return r + l;
6164 }
6165
6166 char *strrep(const char *s, unsigned n) {
6167         size_t l;
6168         char *r, *p;
6169         unsigned i;
6170
6171         assert(s);
6172
6173         l = strlen(s);
6174         p = r = malloc(l * n + 1);
6175         if (!r)
6176                 return NULL;
6177
6178         for (i = 0; i < n; i++)
6179                 p = stpcpy(p, s);
6180
6181         *p = 0;
6182         return r;
6183 }
6184
6185 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
6186         size_t a, newalloc;
6187         void *q;
6188
6189         assert(p);
6190         assert(allocated);
6191
6192         if (*allocated >= need)
6193                 return *p;
6194
6195         newalloc = MAX(need * 2, 64u / size);
6196         a = newalloc * size;
6197
6198         /* check for overflows */
6199         if (a < size * need)
6200                 return NULL;
6201
6202         q = realloc(*p, a);
6203         if (!q)
6204                 return NULL;
6205
6206         *p = q;
6207         *allocated = newalloc;
6208         return q;
6209 }
6210
6211 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
6212         size_t prev;
6213         uint8_t *q;
6214
6215         assert(p);
6216         assert(allocated);
6217
6218         prev = *allocated;
6219
6220         q = greedy_realloc(p, allocated, need, size);
6221         if (!q)
6222                 return NULL;
6223
6224         if (*allocated > prev)
6225                 memzero(q + prev * size, (*allocated - prev) * size);
6226
6227         return q;
6228 }
6229
6230 bool id128_is_valid(const char *s) {
6231         size_t i, l;
6232
6233         l = strlen(s);
6234         if (l == 32) {
6235
6236                 /* Simple formatted 128bit hex string */
6237
6238                 for (i = 0; i < l; i++) {
6239                         char c = s[i];
6240
6241                         if (!(c >= '0' && c <= '9') &&
6242                             !(c >= 'a' && c <= 'z') &&
6243                             !(c >= 'A' && c <= 'Z'))
6244                                 return false;
6245                 }
6246
6247         } else if (l == 36) {
6248
6249                 /* Formatted UUID */
6250
6251                 for (i = 0; i < l; i++) {
6252                         char c = s[i];
6253
6254                         if ((i == 8 || i == 13 || i == 18 || i == 23)) {
6255                                 if (c != '-')
6256                                         return false;
6257                         } else {
6258                                 if (!(c >= '0' && c <= '9') &&
6259                                     !(c >= 'a' && c <= 'z') &&
6260                                     !(c >= 'A' && c <= 'Z'))
6261                                         return false;
6262                         }
6263                 }
6264
6265         } else
6266                 return false;
6267
6268         return true;
6269 }
6270
6271 int split_pair(const char *s, const char *sep, char **l, char **r) {
6272         char *x, *a, *b;
6273
6274         assert(s);
6275         assert(sep);
6276         assert(l);
6277         assert(r);
6278
6279         if (isempty(sep))
6280                 return -EINVAL;
6281
6282         x = strstr(s, sep);
6283         if (!x)
6284                 return -EINVAL;
6285
6286         a = strndup(s, x - s);
6287         if (!a)
6288                 return -ENOMEM;
6289
6290         b = strdup(x + strlen(sep));
6291         if (!b) {
6292                 free(a);
6293                 return -ENOMEM;
6294         }
6295
6296         *l = a;
6297         *r = b;
6298
6299         return 0;
6300 }
6301
6302 int shall_restore_state(void) {
6303         _cleanup_free_ char *value = NULL;
6304         int r;
6305
6306         r = get_proc_cmdline_key("systemd.restore_state=", &value);
6307         if (r < 0)
6308                 return r;
6309         if (r == 0)
6310                 return true;
6311
6312         return parse_boolean(value) != 0;
6313 }
6314
6315 int proc_cmdline(char **ret) {
6316         assert(ret);
6317
6318         if (detect_container(NULL) > 0)
6319                 return get_process_cmdline(1, 0, false, ret);
6320         else
6321                 return read_one_line_file("/proc/cmdline", ret);
6322 }
6323
6324 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6325         _cleanup_free_ char *line = NULL;
6326         const char *p;
6327         int r;
6328
6329         assert(parse_item);
6330
6331         r = proc_cmdline(&line);
6332         if (r < 0)
6333                 return r;
6334
6335         p = line;
6336         for (;;) {
6337                 _cleanup_free_ char *word = NULL;
6338                 char *value = NULL;
6339
6340                 r = unquote_first_word(&p, &word, true);
6341                 if (r < 0)
6342                         return r;
6343                 if (r == 0)
6344                         break;
6345
6346                 /* Filter out arguments that are intended only for the
6347                  * initrd */
6348                 if (!in_initrd() && startswith(word, "rd."))
6349                         continue;
6350
6351                 value = strchr(word, '=');
6352                 if (value)
6353                         *(value++) = 0;
6354
6355                 r = parse_item(word, value);
6356                 if (r < 0)
6357                         return r;
6358         }
6359
6360         return 0;
6361 }
6362
6363 int get_proc_cmdline_key(const char *key, char **value) {
6364         _cleanup_free_ char *line = NULL, *ret = NULL;
6365         bool found = false;
6366         const char *p;
6367         int r;
6368
6369         assert(key);
6370
6371         r = proc_cmdline(&line);
6372         if (r < 0)
6373                 return r;
6374
6375         p = line;
6376         for (;;) {
6377                 _cleanup_free_ char *word = NULL;
6378                 const char *e;
6379
6380                 r = unquote_first_word(&p, &word, true);
6381                 if (r < 0)
6382                         return r;
6383                 if (r == 0)
6384                         break;
6385
6386                 /* Filter out arguments that are intended only for the
6387                  * initrd */
6388                 if (!in_initrd() && startswith(word, "rd."))
6389                         continue;
6390
6391                 if (value) {
6392                         e = startswith(word, key);
6393                         if (!e)
6394                                 continue;
6395
6396                         r = free_and_strdup(&ret, e);
6397                         if (r < 0)
6398                                 return r;
6399
6400                         found = true;
6401                 } else {
6402                         if (streq(word, key))
6403                                 found = true;
6404                 }
6405         }
6406
6407         if (value) {
6408                 *value = ret;
6409                 ret = NULL;
6410         }
6411
6412         return found;
6413
6414 }
6415
6416 int container_get_leader(const char *machine, pid_t *pid) {
6417         _cleanup_free_ char *s = NULL, *class = NULL;
6418         const char *p;
6419         pid_t leader;
6420         int r;
6421
6422         assert(machine);
6423         assert(pid);
6424
6425         p = strappenda("/run/systemd/machines/", machine);
6426         r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6427         if (r == -ENOENT)
6428                 return -EHOSTDOWN;
6429         if (r < 0)
6430                 return r;
6431         if (!s)
6432                 return -EIO;
6433
6434         if (!streq_ptr(class, "container"))
6435                 return -EIO;
6436
6437         r = parse_pid(s, &leader);
6438         if (r < 0)
6439                 return r;
6440         if (leader <= 1)
6441                 return -EIO;
6442
6443         *pid = leader;
6444         return 0;
6445 }
6446
6447 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
6448         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
6449         int rfd = -1;
6450
6451         assert(pid >= 0);
6452
6453         if (mntns_fd) {
6454                 const char *mntns;
6455
6456                 mntns = procfs_file_alloca(pid, "ns/mnt");
6457                 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6458                 if (mntnsfd < 0)
6459                         return -errno;
6460         }
6461
6462         if (pidns_fd) {
6463                 const char *pidns;
6464
6465                 pidns = procfs_file_alloca(pid, "ns/pid");
6466                 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6467                 if (pidnsfd < 0)
6468                         return -errno;
6469         }
6470
6471         if (netns_fd) {
6472                 const char *netns;
6473
6474                 netns = procfs_file_alloca(pid, "ns/net");
6475                 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6476                 if (netnsfd < 0)
6477                         return -errno;
6478         }
6479
6480         if (root_fd) {
6481                 const char *root;
6482
6483                 root = procfs_file_alloca(pid, "root");
6484                 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6485                 if (rfd < 0)
6486                         return -errno;
6487         }
6488
6489         if (pidns_fd)
6490                 *pidns_fd = pidnsfd;
6491
6492         if (mntns_fd)
6493                 *mntns_fd = mntnsfd;
6494
6495         if (netns_fd)
6496                 *netns_fd = netnsfd;
6497
6498         if (root_fd)
6499                 *root_fd = rfd;
6500
6501         pidnsfd = mntnsfd = netnsfd = -1;
6502
6503         return 0;
6504 }
6505
6506 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
6507
6508         if (pidns_fd >= 0)
6509                 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6510                         return -errno;
6511
6512         if (mntns_fd >= 0)
6513                 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6514                         return -errno;
6515
6516         if (netns_fd >= 0)
6517                 if (setns(netns_fd, CLONE_NEWNET) < 0)
6518                         return -errno;
6519
6520         if (root_fd >= 0) {
6521                 if (fchdir(root_fd) < 0)
6522                         return -errno;
6523
6524                 if (chroot(".") < 0)
6525                         return -errno;
6526         }
6527
6528         if (setresgid(0, 0, 0) < 0)
6529                 return -errno;
6530
6531         if (setgroups(0, NULL) < 0)
6532                 return -errno;
6533
6534         if (setresuid(0, 0, 0) < 0)
6535                 return -errno;
6536
6537         return 0;
6538 }
6539
6540 bool pid_is_unwaited(pid_t pid) {
6541         /* Checks whether a PID is still valid at all, including a zombie */
6542
6543         if (pid <= 0)
6544                 return false;
6545
6546         if (kill(pid, 0) >= 0)
6547                 return true;
6548
6549         return errno != ESRCH;
6550 }
6551
6552 bool pid_is_alive(pid_t pid) {
6553         int r;
6554
6555         /* Checks whether a PID is still valid and not a zombie */
6556
6557         if (pid <= 0)
6558                 return false;
6559
6560         r = get_process_state(pid);
6561         if (r == -ENOENT || r == 'Z')
6562                 return false;
6563
6564         return true;
6565 }
6566
6567 int getpeercred(int fd, struct ucred *ucred) {
6568         socklen_t n = sizeof(struct ucred);
6569         struct ucred u;
6570         int r;
6571
6572         assert(fd >= 0);
6573         assert(ucred);
6574
6575         r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6576         if (r < 0)
6577                 return -errno;
6578
6579         if (n != sizeof(struct ucred))
6580                 return -EIO;
6581
6582         /* Check if the data is actually useful and not suppressed due
6583          * to namespacing issues */
6584         if (u.pid <= 0)
6585                 return -ENODATA;
6586         if (u.uid == UID_INVALID)
6587                 return -ENODATA;
6588         if (u.gid == GID_INVALID)
6589                 return -ENODATA;
6590
6591         *ucred = u;
6592         return 0;
6593 }
6594
6595 int getpeersec(int fd, char **ret) {
6596         socklen_t n = 64;
6597         char *s;
6598         int r;
6599
6600         assert(fd >= 0);
6601         assert(ret);
6602
6603         s = new0(char, n);
6604         if (!s)
6605                 return -ENOMEM;
6606
6607         r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6608         if (r < 0) {
6609                 free(s);
6610
6611                 if (errno != ERANGE)
6612                         return -errno;
6613
6614                 s = new0(char, n);
6615                 if (!s)
6616                         return -ENOMEM;
6617
6618                 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6619                 if (r < 0) {
6620                         free(s);
6621                         return -errno;
6622                 }
6623         }
6624
6625         if (isempty(s)) {
6626                 free(s);
6627                 return -ENOTSUP;
6628         }
6629
6630         *ret = s;
6631         return 0;
6632 }
6633
6634 /* This is much like like mkostemp() but is subject to umask(). */
6635 int mkostemp_safe(char *pattern, int flags) {
6636         _cleanup_umask_ mode_t u;
6637         int fd;
6638
6639         assert(pattern);
6640
6641         u = umask(077);
6642
6643         fd = mkostemp(pattern, flags);
6644         if (fd < 0)
6645                 return -errno;
6646
6647         return fd;
6648 }
6649
6650 int open_tmpfile(const char *path, int flags) {
6651         char *p;
6652         int fd;
6653
6654         assert(path);
6655
6656 #ifdef O_TMPFILE
6657         /* Try O_TMPFILE first, if it is supported */
6658         fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6659         if (fd >= 0)
6660                 return fd;
6661 #endif
6662
6663         /* Fall back to unguessable name + unlinking */
6664         p = strappenda(path, "/systemd-tmp-XXXXXX");
6665
6666         fd = mkostemp_safe(p, flags);
6667         if (fd < 0)
6668                 return fd;
6669
6670         unlink(p);
6671         return fd;
6672 }
6673
6674 int fd_warn_permissions(const char *path, int fd) {
6675         struct stat st;
6676
6677         if (fstat(fd, &st) < 0)
6678                 return -errno;
6679
6680         if (st.st_mode & 0111)
6681                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6682
6683         if (st.st_mode & 0002)
6684                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6685
6686         if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6687                 log_warning("Configuration file %s is marked world-inaccessible. This has no effect as configuration data is accessible via APIs without restrictions. Proceeding anyway.", path);
6688
6689         return 0;
6690 }
6691
6692 unsigned long personality_from_string(const char *p) {
6693
6694         /* Parse a personality specifier. We introduce our own
6695          * identifiers that indicate specific ABIs, rather than just
6696          * hints regarding the register size, since we want to keep
6697          * things open for multiple locally supported ABIs for the
6698          * same register size. We try to reuse the ABI identifiers
6699          * used by libseccomp. */
6700
6701 #if defined(__x86_64__)
6702
6703         if (streq(p, "x86"))
6704                 return PER_LINUX32;
6705
6706         if (streq(p, "x86-64"))
6707                 return PER_LINUX;
6708
6709 #elif defined(__i386__)
6710
6711         if (streq(p, "x86"))
6712                 return PER_LINUX;
6713 #endif
6714
6715         /* personality(7) documents that 0xffffffffUL is used for
6716          * querying the current personality, hence let's use that here
6717          * as error indicator. */
6718         return 0xffffffffUL;
6719 }
6720
6721 const char* personality_to_string(unsigned long p) {
6722
6723 #if defined(__x86_64__)
6724
6725         if (p == PER_LINUX32)
6726                 return "x86";
6727
6728         if (p == PER_LINUX)
6729                 return "x86-64";
6730
6731 #elif defined(__i386__)
6732
6733         if (p == PER_LINUX)
6734                 return "x86";
6735 #endif
6736
6737         return NULL;
6738 }
6739
6740 uint64_t physical_memory(void) {
6741         long mem;
6742
6743         /* We return this as uint64_t in case we are running as 32bit
6744          * process on a 64bit kernel with huge amounts of memory */
6745
6746         mem = sysconf(_SC_PHYS_PAGES);
6747         assert(mem > 0);
6748
6749         return (uint64_t) mem * (uint64_t) page_size();
6750 }
6751
6752 void hexdump(FILE *f, const void *p, size_t s) {
6753         const uint8_t *b = p;
6754         unsigned n = 0;
6755
6756         assert(s == 0 || b);
6757
6758         while (s > 0) {
6759                 size_t i;
6760
6761                 fprintf(f, "%04x  ", n);
6762
6763                 for (i = 0; i < 16; i++) {
6764
6765                         if (i >= s)
6766                                 fputs("   ", f);
6767                         else
6768                                 fprintf(f, "%02x ", b[i]);
6769
6770                         if (i == 7)
6771                                 fputc(' ', f);
6772                 }
6773
6774                 fputc(' ', f);
6775
6776                 for (i = 0; i < 16; i++) {
6777
6778                         if (i >= s)
6779                                 fputc(' ', f);
6780                         else
6781                                 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
6782                 }
6783
6784                 fputc('\n', f);
6785
6786                 if (s < 16)
6787                         break;
6788
6789                 n += 16;
6790                 b += 16;
6791                 s -= 16;
6792         }
6793 }
6794
6795 int update_reboot_param_file(const char *param) {
6796         int r = 0;
6797
6798         if (param) {
6799
6800                 r = write_string_file(REBOOT_PARAM_FILE, param);
6801                 if (r < 0)
6802                         log_error("Failed to write reboot param to "
6803                                   REBOOT_PARAM_FILE": %s", strerror(-r));
6804         } else
6805                 unlink(REBOOT_PARAM_FILE);
6806
6807         return r;
6808 }
6809
6810 int umount_recursive(const char *prefix, int flags) {
6811         bool again;
6812         int n = 0, r;
6813
6814         /* Try to umount everything recursively below a
6815          * directory. Also, take care of stacked mounts, and keep
6816          * unmounting them until they are gone. */
6817
6818         do {
6819                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6820
6821                 again = false;
6822                 r = 0;
6823
6824                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6825                 if (!proc_self_mountinfo)
6826                         return -errno;
6827
6828                 for (;;) {
6829                         _cleanup_free_ char *path = NULL, *p = NULL;
6830                         int k;
6831
6832                         k = fscanf(proc_self_mountinfo,
6833                                    "%*s "       /* (1) mount id */
6834                                    "%*s "       /* (2) parent id */
6835                                    "%*s "       /* (3) major:minor */
6836                                    "%*s "       /* (4) root */
6837                                    "%ms "       /* (5) mount point */
6838                                    "%*s"        /* (6) mount options */
6839                                    "%*[^-]"     /* (7) optional fields */
6840                                    "- "         /* (8) separator */
6841                                    "%*s "       /* (9) file system type */
6842                                    "%*s"        /* (10) mount source */
6843                                    "%*s"        /* (11) mount options 2 */
6844                                    "%*[^\n]",   /* some rubbish at the end */
6845                                    &path);
6846                         if (k != 1) {
6847                                 if (k == EOF)
6848                                         break;
6849
6850                                 continue;
6851                         }
6852
6853                         p = cunescape(path);
6854                         if (!p)
6855                                 return -ENOMEM;
6856
6857                         if (!path_startswith(p, prefix))
6858                                 continue;
6859
6860                         if (umount2(p, flags) < 0) {
6861                                 r = -errno;
6862                                 continue;
6863                         }
6864
6865                         again = true;
6866                         n++;
6867
6868                         break;
6869                 }
6870
6871         } while (again);
6872
6873         return r ? r : n;
6874 }
6875
6876 static int get_mount_flags(const char *path, unsigned long *flags) {
6877         struct statvfs buf;
6878
6879         if (statvfs(path, &buf) < 0)
6880                 return -errno;
6881         *flags = buf.f_flag;
6882         return 0;
6883 }
6884
6885 int bind_remount_recursive(const char *prefix, bool ro) {
6886         _cleanup_set_free_free_ Set *done = NULL;
6887         _cleanup_free_ char *cleaned = NULL;
6888         int r;
6889
6890         /* Recursively remount a directory (and all its submounts)
6891          * read-only or read-write. If the directory is already
6892          * mounted, we reuse the mount and simply mark it
6893          * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
6894          * operation). If it isn't we first make it one. Afterwards we
6895          * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
6896          * submounts we can access, too. When mounts are stacked on
6897          * the same mount point we only care for each individual
6898          * "top-level" mount on each point, as we cannot
6899          * influence/access the underlying mounts anyway. We do not
6900          * have any effect on future submounts that might get
6901          * propagated, they migt be writable. This includes future
6902          * submounts that have been triggered via autofs. */
6903
6904         cleaned = strdup(prefix);
6905         if (!cleaned)
6906                 return -ENOMEM;
6907
6908         path_kill_slashes(cleaned);
6909
6910         done = set_new(&string_hash_ops);
6911         if (!done)
6912                 return -ENOMEM;
6913
6914         for (;;) {
6915                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6916                 _cleanup_set_free_free_ Set *todo = NULL;
6917                 bool top_autofs = false;
6918                 char *x;
6919                 unsigned long orig_flags;
6920
6921                 todo = set_new(&string_hash_ops);
6922                 if (!todo)
6923                         return -ENOMEM;
6924
6925                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6926                 if (!proc_self_mountinfo)
6927                         return -errno;
6928
6929                 for (;;) {
6930                         _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
6931                         int k;
6932
6933                         k = fscanf(proc_self_mountinfo,
6934                                    "%*s "       /* (1) mount id */
6935                                    "%*s "       /* (2) parent id */
6936                                    "%*s "       /* (3) major:minor */
6937                                    "%*s "       /* (4) root */
6938                                    "%ms "       /* (5) mount point */
6939                                    "%*s"        /* (6) mount options (superblock) */
6940                                    "%*[^-]"     /* (7) optional fields */
6941                                    "- "         /* (8) separator */
6942                                    "%ms "       /* (9) file system type */
6943                                    "%*s"        /* (10) mount source */
6944                                    "%*s"        /* (11) mount options (bind mount) */
6945                                    "%*[^\n]",   /* some rubbish at the end */
6946                                    &path,
6947                                    &type);
6948                         if (k != 2) {
6949                                 if (k == EOF)
6950                                         break;
6951
6952                                 continue;
6953                         }
6954
6955                         p = cunescape(path);
6956                         if (!p)
6957                                 return -ENOMEM;
6958
6959                         /* Let's ignore autofs mounts.  If they aren't
6960                          * triggered yet, we want to avoid triggering
6961                          * them, as we don't make any guarantees for
6962                          * future submounts anyway.  If they are
6963                          * already triggered, then we will find
6964                          * another entry for this. */
6965                         if (streq(type, "autofs")) {
6966                                 top_autofs = top_autofs || path_equal(cleaned, p);
6967                                 continue;
6968                         }
6969
6970                         if (path_startswith(p, cleaned) &&
6971                             !set_contains(done, p)) {
6972
6973                                 r = set_consume(todo, p);
6974                                 p = NULL;
6975
6976                                 if (r == -EEXIST)
6977                                         continue;
6978                                 if (r < 0)
6979                                         return r;
6980                         }
6981                 }
6982
6983                 /* If we have no submounts to process anymore and if
6984                  * the root is either already done, or an autofs, we
6985                  * are done */
6986                 if (set_isempty(todo) &&
6987                     (top_autofs || set_contains(done, cleaned)))
6988                         return 0;
6989
6990                 if (!set_contains(done, cleaned) &&
6991                     !set_contains(todo, cleaned)) {
6992                         /* The prefix directory itself is not yet a
6993                          * mount, make it one. */
6994                         if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
6995                                 return -errno;
6996
6997                         orig_flags = 0;
6998                         (void) get_mount_flags(cleaned, &orig_flags);
6999                         orig_flags &= ~MS_RDONLY;
7000
7001                         if (mount(NULL, prefix, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
7002                                 return -errno;
7003
7004                         x = strdup(cleaned);
7005                         if (!x)
7006                                 return -ENOMEM;
7007
7008                         r = set_consume(done, x);
7009                         if (r < 0)
7010                                 return r;
7011                 }
7012
7013                 while ((x = set_steal_first(todo))) {
7014
7015                         r = set_consume(done, x);
7016                         if (r == -EEXIST)
7017                                 continue;
7018                         if (r < 0)
7019                                 return r;
7020
7021                         /* Try to reuse the original flag set, but
7022                          * don't care for errors, in case of
7023                          * obstructed mounts */
7024                         orig_flags = 0;
7025                         (void) get_mount_flags(x, &orig_flags);
7026                         orig_flags &= ~MS_RDONLY;
7027
7028                         if (mount(NULL, x, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
7029
7030                                 /* Deal with mount points that are
7031                                  * obstructed by a later mount */
7032
7033                                 if (errno != ENOENT)
7034                                         return -errno;
7035                         }
7036
7037                 }
7038         }
7039 }
7040
7041 int fflush_and_check(FILE *f) {
7042         assert(f);
7043
7044         errno = 0;
7045         fflush(f);
7046
7047         if (ferror(f))
7048                 return errno ? -errno : -EIO;
7049
7050         return 0;
7051 }
7052
7053 int tempfn_xxxxxx(const char *p, char **ret) {
7054         const char *fn;
7055         char *t;
7056
7057         assert(p);
7058         assert(ret);
7059
7060         /*
7061          * Turns this:
7062          *         /foo/bar/waldo
7063          *
7064          * Into this:
7065          *         /foo/bar/.#waldoXXXXXX
7066          */
7067
7068         fn = basename(p);
7069         if (!filename_is_valid(fn))
7070                 return -EINVAL;
7071
7072         t = new(char, strlen(p) + 2 + 6 + 1);
7073         if (!t)
7074                 return -ENOMEM;
7075
7076         strcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn), "XXXXXX");
7077
7078         *ret = path_kill_slashes(t);
7079         return 0;
7080 }
7081
7082 int tempfn_random(const char *p, char **ret) {
7083         const char *fn;
7084         char *t, *x;
7085         uint64_t u;
7086         unsigned i;
7087
7088         assert(p);
7089         assert(ret);
7090
7091         /*
7092          * Turns this:
7093          *         /foo/bar/waldo
7094          *
7095          * Into this:
7096          *         /foo/bar/.#waldobaa2a261115984a9
7097          */
7098
7099         fn = basename(p);
7100         if (!filename_is_valid(fn))
7101                 return -EINVAL;
7102
7103         t = new(char, strlen(p) + 2 + 16 + 1);
7104         if (!t)
7105                 return -ENOMEM;
7106
7107         x = stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn);
7108
7109         u = random_u64();
7110         for (i = 0; i < 16; i++) {
7111                 *(x++) = hexchar(u & 0xF);
7112                 u >>= 4;
7113         }
7114
7115         *x = 0;
7116
7117         *ret = path_kill_slashes(t);
7118         return 0;
7119 }
7120
7121 int tempfn_random_child(const char *p, char **ret) {
7122         char *t, *x;
7123         uint64_t u;
7124         unsigned i;
7125
7126         assert(p);
7127         assert(ret);
7128
7129         /* Turns this:
7130          *         /foo/bar/waldo
7131          * Into this:
7132          *         /foo/bar/waldo/.#3c2b6219aa75d7d0
7133          */
7134
7135         t = new(char, strlen(p) + 3 + 16 + 1);
7136         if (!t)
7137                 return -ENOMEM;
7138
7139         x = stpcpy(stpcpy(t, p), "/.#");
7140
7141         u = random_u64();
7142         for (i = 0; i < 16; i++) {
7143                 *(x++) = hexchar(u & 0xF);
7144                 u >>= 4;
7145         }
7146
7147         *x = 0;
7148
7149         *ret = path_kill_slashes(t);
7150         return 0;
7151 }
7152
7153 /* make sure the hostname is not "localhost" */
7154 bool is_localhost(const char *hostname) {
7155         assert(hostname);
7156
7157         /* This tries to identify local host and domain names
7158          * described in RFC6761 plus the redhatism of .localdomain */
7159
7160         return streq(hostname, "localhost") ||
7161                streq(hostname, "localhost.") ||
7162                streq(hostname, "localdomain.") ||
7163                streq(hostname, "localdomain") ||
7164                endswith(hostname, ".localhost") ||
7165                endswith(hostname, ".localhost.") ||
7166                endswith(hostname, ".localdomain") ||
7167                endswith(hostname, ".localdomain.");
7168 }
7169
7170 int take_password_lock(const char *root) {
7171
7172         struct flock flock = {
7173                 .l_type = F_WRLCK,
7174                 .l_whence = SEEK_SET,
7175                 .l_start = 0,
7176                 .l_len = 0,
7177         };
7178
7179         const char *path;
7180         int fd, r;
7181
7182         /* This is roughly the same as lckpwdf(), but not as awful. We
7183          * don't want to use alarm() and signals, hence we implement
7184          * our own trivial version of this.
7185          *
7186          * Note that shadow-utils also takes per-database locks in
7187          * addition to lckpwdf(). However, we don't given that they
7188          * are redundant as they they invoke lckpwdf() first and keep
7189          * it during everything they do. The per-database locks are
7190          * awfully racy, and thus we just won't do them. */
7191
7192         if (root)
7193                 path = strappenda(root, "/etc/.pwd.lock");
7194         else
7195                 path = "/etc/.pwd.lock";
7196
7197         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
7198         if (fd < 0)
7199                 return -errno;
7200
7201         r = fcntl(fd, F_SETLKW, &flock);
7202         if (r < 0) {
7203                 safe_close(fd);
7204                 return -errno;
7205         }
7206
7207         return fd;
7208 }
7209
7210 int is_symlink(const char *path) {
7211         struct stat info;
7212
7213         if (lstat(path, &info) < 0)
7214                 return -errno;
7215
7216         return !!S_ISLNK(info.st_mode);
7217 }
7218
7219 int is_dir(const char* path, bool follow) {
7220         struct stat st;
7221         int r;
7222
7223         if (follow)
7224                 r = stat(path, &st);
7225         else
7226                 r = lstat(path, &st);
7227         if (r < 0)
7228                 return -errno;
7229
7230         return !!S_ISDIR(st.st_mode);
7231 }
7232
7233 int unquote_first_word(const char **p, char **ret, bool relax) {
7234         _cleanup_free_ char *s = NULL;
7235         size_t allocated = 0, sz = 0;
7236
7237         enum {
7238                 START,
7239                 VALUE,
7240                 VALUE_ESCAPE,
7241                 SINGLE_QUOTE,
7242                 SINGLE_QUOTE_ESCAPE,
7243                 DOUBLE_QUOTE,
7244                 DOUBLE_QUOTE_ESCAPE,
7245                 SPACE,
7246         } state = START;
7247
7248         assert(p);
7249         assert(*p);
7250         assert(ret);
7251
7252         /* Parses the first word of a string, and returns it in
7253          * *ret. Removes all quotes in the process. When parsing fails
7254          * (because of an uneven number of quotes or similar), leaves
7255          * the pointer *p at the first invalid character. */
7256
7257         for (;;) {
7258                 char c = **p;
7259
7260                 switch (state) {
7261
7262                 case START:
7263                         if (c == 0)
7264                                 goto finish;
7265                         else if (strchr(WHITESPACE, c))
7266                                 break;
7267
7268                         state = VALUE;
7269                         /* fallthrough */
7270
7271                 case VALUE:
7272                         if (c == 0)
7273                                 goto finish;
7274                         else if (c == '\'')
7275                                 state = SINGLE_QUOTE;
7276                         else if (c == '\\')
7277                                 state = VALUE_ESCAPE;
7278                         else if (c == '\"')
7279                                 state = DOUBLE_QUOTE;
7280                         else if (strchr(WHITESPACE, c))
7281                                 state = SPACE;
7282                         else {
7283                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7284                                         return -ENOMEM;
7285
7286                                 s[sz++] = c;
7287                         }
7288
7289                         break;
7290
7291                 case VALUE_ESCAPE:
7292                         if (c == 0) {
7293                                 if (relax)
7294                                         goto finish;
7295                                 return -EINVAL;
7296                         }
7297
7298                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7299                                 return -ENOMEM;
7300
7301                         s[sz++] = c;
7302                         state = VALUE;
7303
7304                         break;
7305
7306                 case SINGLE_QUOTE:
7307                         if (c == 0) {
7308                                 if (relax)
7309                                         goto finish;
7310                                 return -EINVAL;
7311                         } else if (c == '\'')
7312                                 state = VALUE;
7313                         else if (c == '\\')
7314                                 state = SINGLE_QUOTE_ESCAPE;
7315                         else {
7316                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7317                                         return -ENOMEM;
7318
7319                                 s[sz++] = c;
7320                         }
7321
7322                         break;
7323
7324                 case SINGLE_QUOTE_ESCAPE:
7325                         if (c == 0) {
7326                                 if (relax)
7327                                         goto finish;
7328                                 return -EINVAL;
7329                         }
7330
7331                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7332                                 return -ENOMEM;
7333
7334                         s[sz++] = c;
7335                         state = SINGLE_QUOTE;
7336                         break;
7337
7338                 case DOUBLE_QUOTE:
7339                         if (c == 0)
7340                                 return -EINVAL;
7341                         else if (c == '\"')
7342                                 state = VALUE;
7343                         else if (c == '\\')
7344                                 state = DOUBLE_QUOTE_ESCAPE;
7345                         else {
7346                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7347                                         return -ENOMEM;
7348
7349                                 s[sz++] = c;
7350                         }
7351
7352                         break;
7353
7354                 case DOUBLE_QUOTE_ESCAPE:
7355                         if (c == 0) {
7356                                 if (relax)
7357                                         goto finish;
7358                                 return -EINVAL;
7359                         }
7360
7361                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7362                                 return -ENOMEM;
7363
7364                         s[sz++] = c;
7365                         state = DOUBLE_QUOTE;
7366                         break;
7367
7368                 case SPACE:
7369                         if (c == 0)
7370                                 goto finish;
7371                         if (!strchr(WHITESPACE, c))
7372                                 goto finish;
7373
7374                         break;
7375                 }
7376
7377                 (*p) ++;
7378         }
7379
7380 finish:
7381         if (!s) {
7382                 *ret = NULL;
7383                 return 0;
7384         }
7385
7386         s[sz] = 0;
7387         *ret = s;
7388         s = NULL;
7389
7390         return 1;
7391 }
7392
7393 int unquote_many_words(const char **p, ...) {
7394         va_list ap;
7395         char **l;
7396         int n = 0, i, c, r;
7397
7398         /* Parses a number of words from a string, stripping any
7399          * quotes if necessary. */
7400
7401         assert(p);
7402
7403         /* Count how many words are expected */
7404         va_start(ap, p);
7405         for (;;) {
7406                 if (!va_arg(ap, char **))
7407                         break;
7408                 n++;
7409         }
7410         va_end(ap);
7411
7412         if (n <= 0)
7413                 return 0;
7414
7415         /* Read all words into a temporary array */
7416         l = newa0(char*, n);
7417         for (c = 0; c < n; c++) {
7418
7419                 r = unquote_first_word(p, &l[c], false);
7420                 if (r < 0) {
7421                         int j;
7422
7423                         for (j = 0; j < c; j++)
7424                                 free(l[j]);
7425
7426                         return r;
7427                 }
7428
7429                 if (r == 0)
7430                         break;
7431         }
7432
7433         /* If we managed to parse all words, return them in the passed
7434          * in parameters */
7435         va_start(ap, p);
7436         for (i = 0; i < n; i++) {
7437                 char **v;
7438
7439                 v = va_arg(ap, char **);
7440                 assert(v);
7441
7442                 *v = l[i];
7443         }
7444         va_end(ap);
7445
7446         return c;
7447 }
7448
7449 int free_and_strdup(char **p, const char *s) {
7450         char *t;
7451
7452         assert(p);
7453
7454         /* Replaces a string pointer with an strdup()ed new string,
7455          * possibly freeing the old one. */
7456
7457         if (s) {
7458                 t = strdup(s);
7459                 if (!t)
7460                         return -ENOMEM;
7461         } else
7462                 t = NULL;
7463
7464         free(*p);
7465         *p = t;
7466
7467         return 0;
7468 }
7469
7470 int sethostname_idempotent(const char *s) {
7471         int r;
7472         char buf[HOST_NAME_MAX + 1] = {};
7473
7474         assert(s);
7475
7476         r = gethostname(buf, sizeof(buf));
7477         if (r < 0)
7478                 return -errno;
7479
7480         if (streq(buf, s))
7481                 return 0;
7482
7483         r = sethostname(s, strlen(s));
7484         if (r < 0)
7485                 return -errno;
7486
7487         return 1;
7488 }
7489
7490 int ptsname_malloc(int fd, char **ret) {
7491         size_t l = 100;
7492
7493         assert(fd >= 0);
7494         assert(ret);
7495
7496         for (;;) {
7497                 char *c;
7498
7499                 c = new(char, l);
7500                 if (!c)
7501                         return -ENOMEM;
7502
7503                 if (ptsname_r(fd, c, l) == 0) {
7504                         *ret = c;
7505                         return 0;
7506                 }
7507                 if (errno != ERANGE) {
7508                         free(c);
7509                         return -errno;
7510                 }
7511
7512                 free(c);
7513                 l *= 2;
7514         }
7515 }
7516
7517 int openpt_in_namespace(pid_t pid, int flags) {
7518         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, rootfd = -1;
7519         _cleanup_close_pair_ int pair[2] = { -1, -1 };
7520         union {
7521                 struct cmsghdr cmsghdr;
7522                 uint8_t buf[CMSG_SPACE(sizeof(int))];
7523         } control = {};
7524         struct msghdr mh = {
7525                 .msg_control = &control,
7526                 .msg_controllen = sizeof(control),
7527         };
7528         struct cmsghdr *cmsg;
7529         siginfo_t si;
7530         pid_t child;
7531         int r;
7532
7533         assert(pid > 0);
7534
7535         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &rootfd);
7536         if (r < 0)
7537                 return r;
7538
7539         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
7540                 return -errno;
7541
7542         child = fork();
7543         if (child < 0)
7544                 return -errno;
7545
7546         if (child == 0) {
7547                 int master;
7548
7549                 pair[0] = safe_close(pair[0]);
7550
7551                 r = namespace_enter(pidnsfd, mntnsfd, -1, rootfd);
7552                 if (r < 0)
7553                         _exit(EXIT_FAILURE);
7554
7555                 master = posix_openpt(flags);
7556                 if (master < 0)
7557                         _exit(EXIT_FAILURE);
7558
7559                 cmsg = CMSG_FIRSTHDR(&mh);
7560                 cmsg->cmsg_level = SOL_SOCKET;
7561                 cmsg->cmsg_type = SCM_RIGHTS;
7562                 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
7563                 memcpy(CMSG_DATA(cmsg), &master, sizeof(int));
7564
7565                 mh.msg_controllen = cmsg->cmsg_len;
7566
7567                 if (sendmsg(pair[1], &mh, MSG_NOSIGNAL) < 0)
7568                         _exit(EXIT_FAILURE);
7569
7570                 _exit(EXIT_SUCCESS);
7571         }
7572
7573         pair[1] = safe_close(pair[1]);
7574
7575         r = wait_for_terminate(child, &si);
7576         if (r < 0)
7577                 return r;
7578         if (si.si_code != CLD_EXITED || si.si_status != EXIT_SUCCESS)
7579                 return -EIO;
7580
7581         if (recvmsg(pair[0], &mh, MSG_NOSIGNAL|MSG_CMSG_CLOEXEC) < 0)
7582                 return -errno;
7583
7584         for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg))
7585                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
7586                         int *fds;
7587                         unsigned n_fds;
7588
7589                         fds = (int*) CMSG_DATA(cmsg);
7590                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
7591
7592                         if (n_fds != 1) {
7593                                 close_many(fds, n_fds);
7594                                 return -EIO;
7595                         }
7596
7597                         return fds[0];
7598                 }
7599
7600         return -EIO;
7601 }
7602
7603 ssize_t fgetxattrat_fake(int dirfd, const char *filename, const char *attribute, void *value, size_t size, int flags) {
7604         _cleanup_close_ int fd = -1;
7605         ssize_t l;
7606
7607         /* The kernel doesn't have a fgetxattrat() command, hence let's emulate one */
7608
7609         fd = openat(dirfd, filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOATIME|(flags & AT_SYMLINK_NOFOLLOW ? O_NOFOLLOW : 0));
7610         if (fd < 0)
7611                 return -errno;
7612
7613         l = fgetxattr(fd, attribute, value, size);
7614         if (l < 0)
7615                 return -errno;
7616
7617         return l;
7618 }
7619
7620 static int parse_crtime(le64_t le, usec_t *usec) {
7621         uint64_t u;
7622
7623         assert(usec);
7624
7625         u = le64toh(le);
7626         if (u == 0 || u == (uint64_t) -1)
7627                 return -EIO;
7628
7629         *usec = (usec_t) u;
7630         return 0;
7631 }
7632
7633 int fd_getcrtime(int fd, usec_t *usec) {
7634         le64_t le;
7635         ssize_t n;
7636
7637         assert(fd >= 0);
7638         assert(usec);
7639
7640         /* Until Linux gets a real concept of birthtime/creation time,
7641          * let's fake one with xattrs */
7642
7643         n = fgetxattr(fd, "user.crtime_usec", &le, sizeof(le));
7644         if (n < 0)
7645                 return -errno;
7646         if (n != sizeof(le))
7647                 return -EIO;
7648
7649         return parse_crtime(le, usec);
7650 }
7651
7652 int fd_getcrtime_at(int dirfd, const char *name, usec_t *usec, int flags) {
7653         le64_t le;
7654         ssize_t n;
7655
7656         n = fgetxattrat_fake(dirfd, name, "user.crtime_usec", &le, sizeof(le), flags);
7657         if (n < 0)
7658                 return -errno;
7659         if (n != sizeof(le))
7660                 return -EIO;
7661
7662         return parse_crtime(le, usec);
7663 }
7664
7665 int path_getcrtime(const char *p, usec_t *usec) {
7666         le64_t le;
7667         ssize_t n;
7668
7669         assert(p);
7670         assert(usec);
7671
7672         n = getxattr(p, "user.crtime_usec", &le, sizeof(le));
7673         if (n < 0)
7674                 return -errno;
7675         if (n != sizeof(le))
7676                 return -EIO;
7677
7678         return parse_crtime(le, usec);
7679 }
7680
7681 int fd_setcrtime(int fd, usec_t usec) {
7682         le64_t le;
7683
7684         assert(fd >= 0);
7685
7686         if (usec <= 0)
7687                 usec = now(CLOCK_REALTIME);
7688
7689         le = htole64((uint64_t) usec);
7690         if (fsetxattr(fd, "user.crtime_usec", &le, sizeof(le), 0) < 0)
7691                 return -errno;
7692
7693         return 0;
7694 }
7695
7696 int same_fd(int a, int b) {
7697         struct stat sta, stb;
7698         pid_t pid;
7699         int r, fa, fb;
7700
7701         assert(a >= 0);
7702         assert(b >= 0);
7703
7704         /* Compares two file descriptors. Note that semantics are
7705          * quite different depending on whether we have kcmp() or we
7706          * don't. If we have kcmp() this will only return true for
7707          * dup()ed file descriptors, but not otherwise. If we don't
7708          * have kcmp() this will also return true for two fds of the same
7709          * file, created by separate open() calls. Since we use this
7710          * call mostly for filtering out duplicates in the fd store
7711          * this difference hopefully doesn't matter too much. */
7712
7713         if (a == b)
7714                 return true;
7715
7716         /* Try to use kcmp() if we have it. */
7717         pid = getpid();
7718         r = kcmp(pid, pid, KCMP_FILE, a, b);
7719         if (r == 0)
7720                 return true;
7721         if (r > 0)
7722                 return false;
7723         if (errno != ENOSYS)
7724                 return -errno;
7725
7726         /* We don't have kcmp(), use fstat() instead. */
7727         if (fstat(a, &sta) < 0)
7728                 return -errno;
7729
7730         if (fstat(b, &stb) < 0)
7731                 return -errno;
7732
7733         if ((sta.st_mode & S_IFMT) != (stb.st_mode & S_IFMT))
7734                 return false;
7735
7736         /* We consider all device fds different, since two device fds
7737          * might refer to quite different device contexts even though
7738          * they share the same inode and backing dev_t. */
7739
7740         if (S_ISCHR(sta.st_mode) || S_ISBLK(sta.st_mode))
7741                 return false;
7742
7743         if (sta.st_dev != stb.st_dev || sta.st_ino != stb.st_ino)
7744                 return false;
7745
7746         /* The fds refer to the same inode on disk, let's also check
7747          * if they have the same fd flags. This is useful to
7748          * distuingish the read and write side of a pipe created with
7749          * pipe(). */
7750         fa = fcntl(a, F_GETFL);
7751         if (fa < 0)
7752                 return -errno;
7753
7754         fb = fcntl(b, F_GETFL);
7755         if (fb < 0)
7756                 return -errno;
7757
7758         return fa == fb;
7759 }
7760
7761 int chattr_fd(int fd, bool b, unsigned mask) {
7762         unsigned old_attr, new_attr;
7763
7764         assert(fd >= 0);
7765
7766         if (mask == 0)
7767                 return 0;
7768
7769         if (ioctl(fd, FS_IOC_GETFLAGS, &old_attr) < 0)
7770                 return -errno;
7771
7772         if (b)
7773                 new_attr = old_attr | mask;
7774         else
7775                 new_attr = old_attr & ~mask;
7776
7777         if (new_attr == old_attr)
7778                 return 0;
7779
7780         if (ioctl(fd, FS_IOC_SETFLAGS, &new_attr) < 0)
7781                 return -errno;
7782
7783         return 0;
7784 }
7785
7786 int chattr_path(const char *p, bool b, unsigned mask) {
7787         _cleanup_close_ int fd = -1;
7788
7789         assert(p);
7790
7791         if (mask == 0)
7792                 return 0;
7793
7794         fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
7795         if (fd < 0)
7796                 return -errno;
7797
7798         return chattr_fd(fd, b, mask);
7799 }