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/inotify.h>
  43 #include <sys/poll.h>
  44 #include <ctype.h>
  45 #include <sys/prctl.h>
  46 #include <sys/utsname.h>
  47 #include <pwd.h>
  48 #include <netinet/ip.h>
  49 #include <linux/kd.h>
  50 #include <dlfcn.h>
  51 #include <sys/wait.h>
  52 #include <sys/time.h>
  53 #include <glob.h>
  54 #include <grp.h>
  55 #include <sys/mman.h>
  56 #include <sys/vfs.h>
  57 #include <linux/magic.h>
  58 #include <limits.h>
  59 #include <langinfo.h>
  60 #include <locale.h>
  61 #include <libgen.h>
  62 #undef basename
  63
  64 #include "macro.h"
  65 #include "util.h"
  66 #include "ioprio.h"
  67 #include "missing.h"
  68 #include "log.h"
  69 #include "strv.h"
  70 #include "label.h"
  71 #include "path-util.h"
  72 #include "exit-status.h"
  73 #include "hashmap.h"
  74 #include "env-util.h"
  75 #include "fileio.h"
  76 #include "device-nodes.h"
  77 #include "utf8.h"
  78 #include "gunicode.h"
  79 #include "virt.h"
  80 #include "def.h"
  81
  82 int saved_argc = 0;
  83 char **saved_argv = NULL;
  84
  85 static volatile unsigned cached_columns = 0;
  86 static volatile unsigned cached_lines = 0;
  87
  88 size_t page_size(void) {
  89         static thread_local size_t pgsz = 0;
  90         long r;
  91
  92         if (_likely_(pgsz > 0))
  93                 return pgsz;
  94
  95         r = sysconf(_SC_PAGESIZE);
  96         assert(r > 0);
  97
  98         pgsz = (size_t) r;
  99         return pgsz;
 100 }
 101
 102 bool streq_ptr(const char *a, const char *b) {
 103
 104         /* Like streq(), but tries to make sense of NULL pointers */
 105
 106         if (a && b)
 107                 return streq(a, b);
 108
 109         if (!a && !b)
 110                 return true;
 111
 112         return false;
 113 }
 114
 115 char* endswith(const char *s, const char *postfix) {
 116         size_t sl, pl;
 117
 118         assert(s);
 119         assert(postfix);
 120
 121         sl = strlen(s);
 122         pl = strlen(postfix);
 123
 124         if (pl == 0)
 125                 return (char*) s + sl;
 126
 127         if (sl < pl)
 128                 return NULL;
 129
 130         if (memcmp(s + sl - pl, postfix, pl) != 0)
 131                 return NULL;
 132
 133         return (char*) s + sl - pl;
 134 }
 135
 136 bool first_word(const char *s, const char *word) {
 137         size_t sl, wl;
 138
 139         assert(s);
 140         assert(word);
 141
 142         sl = strlen(s);
 143         wl = strlen(word);
 144
 145         if (sl < wl)
 146                 return false;
 147
 148         if (wl == 0)
 149                 return true;
 150
 151         if (memcmp(s, word, wl) != 0)
 152                 return false;
 153
 154         return s[wl] == 0 ||
 155                 strchr(WHITESPACE, s[wl]);
 156 }
 157
 158 int close_nointr(int fd) {
 159         int r;
 160
 161         assert(fd >= 0);
 162         r = close(fd);
 163
 164         /* Just ignore EINTR; a retry loop is the wrong
 165          * thing to do on Linux.
 166          *
 167          * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
 168          * https://bugzilla.gnome.org/show_bug.cgi?id=682819
 169          * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
 170          * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
 171          */
 172         if (_unlikely_(r < 0 && errno == EINTR))
 173                 return 0;
 174         else if (r >= 0)
 175                 return r;
 176         else
 177                 return -errno;
 178 }
 179
 180 void close_nointr_nofail(int fd) {
 181         PROTECT_ERRNO;
 182
 183         /* like close_nointr() but cannot fail, and guarantees errno
 184          * is unchanged */
 185
 186         assert_se(close_nointr(fd) == 0);
 187 }
 188
 189 void close_many(const int fds[], unsigned n_fd) {
 190         unsigned i;
 191
 192         assert(fds || n_fd <= 0);
 193
 194         for (i = 0; i < n_fd; i++)
 195                 close_nointr_nofail(fds[i]);
 196 }
 197
 198 int unlink_noerrno(const char *path) {
 199         PROTECT_ERRNO;
 200         int r;
 201
 202         r = unlink(path);
 203         if (r < 0)
 204                 return -errno;
 205
 206         return 0;
 207 }
 208
 209 int parse_boolean(const char *v) {
 210         assert(v);
 211
 212         if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
 213                 return 1;
 214         else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
 215                 return 0;
 216
 217         return -EINVAL;
 218 }
 219
 220 int parse_pid(const char *s, pid_t* ret_pid) {
 221         unsigned long ul = 0;
 222         pid_t pid;
 223         int r;
 224
 225         assert(s);
 226         assert(ret_pid);
 227
 228         r = safe_atolu(s, &ul);
 229         if (r < 0)
 230                 return r;
 231
 232         pid = (pid_t) ul;
 233
 234         if ((unsigned long) pid != ul)
 235                 return -ERANGE;
 236
 237         if (pid <= 0)
 238                 return -ERANGE;
 239
 240         *ret_pid = pid;
 241         return 0;
 242 }
 243
 244 int parse_uid(const char *s, uid_t* ret_uid) {
 245         unsigned long ul = 0;
 246         uid_t uid;
 247         int r;
 248
 249         assert(s);
 250         assert(ret_uid);
 251
 252         r = safe_atolu(s, &ul);
 253         if (r < 0)
 254                 return r;
 255
 256         uid = (uid_t) ul;
 257
 258         if ((unsigned long) uid != ul)
 259                 return -ERANGE;
 260
 261         *ret_uid = uid;
 262         return 0;
 263 }
 264
 265 int safe_atou(const char *s, unsigned *ret_u) {
 266         char *x = NULL;
 267         unsigned long l;
 268
 269         assert(s);
 270         assert(ret_u);
 271
 272         errno = 0;
 273         l = strtoul(s, &x, 0);
 274
 275         if (!x || x == s || *x || errno)
 276                 return errno > 0 ? -errno : -EINVAL;
 277
 278         if ((unsigned long) (unsigned) l != l)
 279                 return -ERANGE;
 280
 281         *ret_u = (unsigned) l;
 282         return 0;
 283 }
 284
 285 int safe_atoi(const char *s, int *ret_i) {
 286         char *x = NULL;
 287         long l;
 288
 289         assert(s);
 290         assert(ret_i);
 291
 292         errno = 0;
 293         l = strtol(s, &x, 0);
 294
 295         if (!x || x == s || *x || errno)
 296                 return errno > 0 ? -errno : -EINVAL;
 297
 298         if ((long) (int) l != l)
 299                 return -ERANGE;
 300
 301         *ret_i = (int) l;
 302         return 0;
 303 }
 304
 305 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 306         char *x = NULL;
 307         unsigned long long l;
 308
 309         assert(s);
 310         assert(ret_llu);
 311
 312         errno = 0;
 313         l = strtoull(s, &x, 0);
 314
 315         if (!x || x == s || *x || errno)
 316                 return errno ? -errno : -EINVAL;
 317
 318         *ret_llu = l;
 319         return 0;
 320 }
 321
 322 int safe_atolli(const char *s, long long int *ret_lli) {
 323         char *x = NULL;
 324         long long l;
 325
 326         assert(s);
 327         assert(ret_lli);
 328
 329         errno = 0;
 330         l = strtoll(s, &x, 0);
 331
 332         if (!x || x == s || *x || errno)
 333                 return errno ? -errno : -EINVAL;
 334
 335         *ret_lli = l;
 336         return 0;
 337 }
 338
 339 int safe_atod(const char *s, double *ret_d) {
 340         char *x = NULL;
 341         double d = 0;
 342
 343         assert(s);
 344         assert(ret_d);
 345
 346         RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
 347                 errno = 0;
 348                 d = strtod(s, &x);
 349         }
 350
 351         if (!x || x == s || *x || errno)
 352                 return errno ? -errno : -EINVAL;
 353
 354         *ret_d = (double) d;
 355         return 0;
 356 }
 357
 358 /* Split a string into words. */
 359 char *split(const char *c, size_t *l, const char *separator, char **state) {
 360         char *current;
 361
 362         current = *state ? *state : (char*) c;
 363
 364         if (!*current || *c == 0)
 365                 return NULL;
 366
 367         current += strspn(current, separator);
 368         *l = strcspn(current, separator);
 369         *state = current+*l;
 370
 371         return (char*) current;
 372 }
 373
 374 /* Split a string into words, but consider strings enclosed in '' and
 375  * "" as words even if they include spaces. */
 376 char *split_quoted(const char *c, size_t *l, char **state) {
 377         const char *current, *e;
 378         bool escaped = false;
 379
 380         assert(c);
 381         assert(l);
 382         assert(state);
 383
 384         current = *state ? *state : c;
 385
 386         current += strspn(current, WHITESPACE);
 387
 388         if (*current == 0)
 389                 return NULL;
 390
 391         else if (*current == '\'') {
 392                 current ++;
 393
 394                 for (e = current; *e; e++) {
 395                         if (escaped)
 396                                 escaped = false;
 397                         else if (*e == '\\')
 398                                 escaped = true;
 399                         else if (*e == '\'')
 400                                 break;
 401                 }
 402
 403                 *l = e-current;
 404                 *state = (char*) (*e == 0 ? e : e+1);
 405
 406         } else if (*current == '\"') {
 407                 current ++;
 408
 409                 for (e = current; *e; e++) {
 410                         if (escaped)
 411                                 escaped = false;
 412                         else if (*e == '\\')
 413                                 escaped = true;
 414                         else if (*e == '\"')
 415                                 break;
 416                 }
 417
 418                 *l = e-current;
 419                 *state = (char*) (*e == 0 ? e : e+1);
 420
 421         } else {
 422                 for (e = current; *e; e++) {
 423                         if (escaped)
 424                                 escaped = false;
 425                         else if (*e == '\\')
 426                                 escaped = true;
 427                         else if (strchr(WHITESPACE, *e))
 428                                 break;
 429                 }
 430                 *l = e-current;
 431                 *state = (char*) e;
 432         }
 433
 434         return (char*) current;
 435 }
 436
 437 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
 438         int r;
 439         _cleanup_fclose_ FILE *f = NULL;
 440         char line[LINE_MAX];
 441         long unsigned ppid;
 442         const char *p;
 443
 444         assert(pid >= 0);
 445         assert(_ppid);
 446
 447         if (pid == 0) {
 448                 *_ppid = getppid();
 449                 return 0;
 450         }
 451
 452         p = procfs_file_alloca(pid, "stat");
 453         f = fopen(p, "re");
 454         if (!f)
 455                 return -errno;
 456
 457         if (!fgets(line, sizeof(line), f)) {
 458                 r = feof(f) ? -EIO : -errno;
 459                 return r;
 460         }
 461
 462         /* Let's skip the pid and comm fields. The latter is enclosed
 463          * in () but does not escape any () in its value, so let's
 464          * skip over it manually */
 465
 466         p = strrchr(line, ')');
 467         if (!p)
 468                 return -EIO;
 469
 470         p++;
 471
 472         if (sscanf(p, " "
 473                    "%*c "  /* state */
 474                    "%lu ", /* ppid */
 475                    &ppid) != 1)
 476                 return -EIO;
 477
 478         if ((long unsigned) (pid_t) ppid != ppid)
 479                 return -ERANGE;
 480
 481         *_ppid = (pid_t) ppid;
 482
 483         return 0;
 484 }
 485
 486 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
 487         _cleanup_fclose_ FILE *f = NULL;
 488         char line[LINE_MAX];
 489         const char *p;
 490
 491         assert(pid >= 0);
 492         assert(st);
 493
 494         if (pid == 0)
 495                 p = "/proc/self/stat";
 496         else
 497                 p = procfs_file_alloca(pid, "stat");
 498
 499         f = fopen(p, "re");
 500         if (!f)
 501                 return errno == ENOENT ? -ESRCH : -errno;
 502
 503         if (!fgets(line, sizeof(line), f)) {
 504                 if (ferror(f))
 505                         return -errno;
 506
 507                 return -EIO;
 508         }
 509
 510         /* Let's skip the pid and comm fields. The latter is enclosed
 511          * in () but does not escape any () in its value, so let's
 512          * skip over it manually */
 513
 514         p = strrchr(line, ')');
 515         if (!p)
 516                 return -EIO;
 517
 518         p++;
 519
 520         if (sscanf(p, " "
 521                    "%*c "  /* state */
 522                    "%*d "  /* ppid */
 523                    "%*d "  /* pgrp */
 524                    "%*d "  /* session */
 525                    "%*d "  /* tty_nr */
 526                    "%*d "  /* tpgid */
 527                    "%*u "  /* flags */
 528                    "%*u "  /* minflt */
 529                    "%*u "  /* cminflt */
 530                    "%*u "  /* majflt */
 531                    "%*u "  /* cmajflt */
 532                    "%*u "  /* utime */
 533                    "%*u "  /* stime */
 534                    "%*d "  /* cutime */
 535                    "%*d "  /* cstime */
 536                    "%*d "  /* priority */
 537                    "%*d "  /* nice */
 538                    "%*d "  /* num_threads */
 539                    "%*d "  /* itrealvalue */
 540                    "%llu "  /* starttime */,
 541                    st) != 1)
 542                 return -EIO;
 543
 544         return 0;
 545 }
 546
 547 int fchmod_umask(int fd, mode_t m) {
 548         mode_t u;
 549         int r;
 550
 551         u = umask(0777);
 552         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 553         umask(u);
 554
 555         return r;
 556 }
 557
 558 char *truncate_nl(char *s) {
 559         assert(s);
 560
 561         s[strcspn(s, NEWLINE)] = 0;
 562         return s;
 563 }
 564
 565 int get_process_comm(pid_t pid, char **name) {
 566         const char *p;
 567         int r;
 568
 569         assert(name);
 570         assert(pid >= 0);
 571
 572         if (pid == 0)
 573                 p = "/proc/self/comm";
 574         else
 575                 p = procfs_file_alloca(pid, "comm");
 576
 577         r = read_one_line_file(p, name);
 578         if (r == -ENOENT)
 579                 return -ESRCH;
 580
 581         return r;
 582 }
 583
 584 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
 585         _cleanup_fclose_ FILE *f = NULL;
 586         char *r = NULL, *k;
 587         const char *p;
 588         int c;
 589
 590         assert(line);
 591         assert(pid >= 0);
 592
 593         if (pid == 0)
 594                 p = "/proc/self/cmdline";
 595         else
 596                 p = procfs_file_alloca(pid, "cmdline");
 597
 598         f = fopen(p, "re");
 599         if (!f)
 600                 return -errno;
 601
 602         if (max_length == 0) {
 603                 size_t len = 0, allocated = 0;
 604
 605                 while ((c = getc(f)) != EOF) {
 606
 607                         if (!GREEDY_REALLOC(r, allocated, len+2)) {
 608                                 free(r);
 609                                 return -ENOMEM;
 610                         }
 611
 612                         r[len++] = isprint(c) ? c : ' ';
 613                 }
 614
 615                 if (len > 0)
 616                         r[len-1] = 0;
 617
 618         } else {
 619                 bool space = false;
 620                 size_t left;
 621
 622                 r = new(char, max_length);
 623                 if (!r)
 624                         return -ENOMEM;
 625
 626                 k = r;
 627                 left = max_length;
 628                 while ((c = getc(f)) != EOF) {
 629
 630                         if (isprint(c)) {
 631                                 if (space) {
 632                                         if (left <= 4)
 633                                                 break;
 634
 635                                         *(k++) = ' ';
 636                                         left--;
 637                                         space = false;
 638                                 }
 639
 640                                 if (left <= 4)
 641                                         break;
 642
 643                                 *(k++) = (char) c;
 644                                 left--;
 645                         }  else
 646                                 space = true;
 647                 }
 648
 649                 if (left <= 4) {
 650                         size_t n = MIN(left-1, 3U);
 651                         memcpy(k, "...", n);
 652                         k[n] = 0;
 653                 } else
 654                         *k = 0;
 655         }
 656
 657         /* Kernel threads have no argv[] */
 658         if (r == NULL || r[0] == 0) {
 659                 _cleanup_free_ char *t = NULL;
 660                 int h;
 661
 662                 free(r);
 663
 664                 if (!comm_fallback)
 665                         return -ENOENT;
 666
 667                 h = get_process_comm(pid, &t);
 668                 if (h < 0)
 669                         return h;
 670
 671                 r = strjoin("[", t, "]", NULL);
 672                 if (!r)
 673                         return -ENOMEM;
 674         }
 675
 676         *line = r;
 677         return 0;
 678 }
 679
 680 int is_kernel_thread(pid_t pid) {
 681         const char *p;
 682         size_t count;
 683         char c;
 684         bool eof;
 685         FILE *f;
 686
 687         if (pid == 0)
 688                 return 0;
 689
 690         assert(pid > 0);
 691
 692         p = procfs_file_alloca(pid, "cmdline");
 693         f = fopen(p, "re");
 694         if (!f)
 695                 return -errno;
 696
 697         count = fread(&c, 1, 1, f);
 698         eof = feof(f);
 699         fclose(f);
 700
 701         /* Kernel threads have an empty cmdline */
 702
 703         if (count <= 0)
 704                 return eof ? 1 : -errno;
 705
 706         return 0;
 707 }
 708
 709 int get_process_capeff(pid_t pid, char **capeff) {
 710         const char *p;
 711
 712         assert(capeff);
 713         assert(pid >= 0);
 714
 715         if (pid == 0)
 716                 p = "/proc/self/status";
 717         else
 718                 p = procfs_file_alloca(pid, "status");
 719
 720         return get_status_field(p, "\nCapEff:", capeff);
 721 }
 722
 723 int get_process_exe(pid_t pid, char **name) {
 724         const char *p;
 725         char *d;
 726         int r;
 727
 728         assert(pid >= 0);
 729         assert(name);
 730
 731         if (pid == 0)
 732                 p = "/proc/self/exe";
 733         else
 734                 p = procfs_file_alloca(pid, "exe");
 735
 736         r = readlink_malloc(p, name);
 737         if (r < 0)
 738                 return r == -ENOENT ? -ESRCH : r;
 739
 740         d = endswith(*name, " (deleted)");
 741         if (d)
 742                 *d = '\0';
 743
 744         return 0;
 745 }
 746
 747 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
 748         _cleanup_fclose_ FILE *f = NULL;
 749         char line[LINE_MAX];
 750         const char *p;
 751
 752         assert(field);
 753         assert(uid);
 754
 755         if (pid == 0)
 756                 return getuid();
 757
 758         p = procfs_file_alloca(pid, "status");
 759         f = fopen(p, "re");
 760         if (!f)
 761                 return -errno;
 762
 763         FOREACH_LINE(line, f, return -errno) {
 764                 char *l;
 765
 766                 l = strstrip(line);
 767
 768                 if (startswith(l, field)) {
 769                         l += strlen(field);
 770                         l += strspn(l, WHITESPACE);
 771
 772                         l[strcspn(l, WHITESPACE)] = 0;
 773
 774                         return parse_uid(l, uid);
 775                 }
 776         }
 777
 778         return -EIO;
 779 }
 780
 781 int get_process_uid(pid_t pid, uid_t *uid) {
 782         return get_process_id(pid, "Uid:", uid);
 783 }
 784
 785 int get_process_gid(pid_t pid, gid_t *gid) {
 786         assert_cc(sizeof(uid_t) == sizeof(gid_t));
 787         return get_process_id(pid, "Gid:", gid);
 788 }
 789
 790 char *strnappend(const char *s, const char *suffix, size_t b) {
 791         size_t a;
 792         char *r;
 793
 794         if (!s && !suffix)
 795                 return strdup("");
 796
 797         if (!s)
 798                 return strndup(suffix, b);
 799
 800         if (!suffix)
 801                 return strdup(s);
 802
 803         assert(s);
 804         assert(suffix);
 805
 806         a = strlen(s);
 807         if (b > ((size_t) -1) - a)
 808                 return NULL;
 809
 810         r = new(char, a+b+1);
 811         if (!r)
 812                 return NULL;
 813
 814         memcpy(r, s, a);
 815         memcpy(r+a, suffix, b);
 816         r[a+b] = 0;
 817
 818         return r;
 819 }
 820
 821 char *strappend(const char *s, const char *suffix) {
 822         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
 823 }
 824
 825 int readlink_malloc(const char *p, char **r) {
 826         size_t l = 100;
 827
 828         assert(p);
 829         assert(r);
 830
 831         for (;;) {
 832                 char *c;
 833                 ssize_t n;
 834
 835                 if (!(c = new(char, l)))
 836                         return -ENOMEM;
 837
 838                 if ((n = readlink(p, c, l-1)) < 0) {
 839                         int ret = -errno;
 840                         free(c);
 841                         return ret;
 842                 }
 843
 844                 if ((size_t) n < l-1) {
 845                         c[n] = 0;
 846                         *r = c;
 847                         return 0;
 848                 }
 849
 850                 free(c);
 851                 l *= 2;
 852         }
 853 }
 854
 855 int readlink_and_make_absolute(const char *p, char **r) {
 856         _cleanup_free_ char *target = NULL;
 857         char *k;
 858         int j;
 859
 860         assert(p);
 861         assert(r);
 862
 863         j = readlink_malloc(p, &target);
 864         if (j < 0)
 865                 return j;
 866
 867         k = file_in_same_dir(p, target);
 868         if (!k)
 869                 return -ENOMEM;
 870
 871         *r = k;
 872         return 0;
 873 }
 874
 875 int readlink_and_canonicalize(const char *p, char **r) {
 876         char *t, *s;
 877         int j;
 878
 879         assert(p);
 880         assert(r);
 881
 882         j = readlink_and_make_absolute(p, &t);
 883         if (j < 0)
 884                 return j;
 885
 886         s = canonicalize_file_name(t);
 887         if (s) {
 888                 free(t);
 889                 *r = s;
 890         } else
 891                 *r = t;
 892
 893         path_kill_slashes(*r);
 894
 895         return 0;
 896 }
 897
 898 int reset_all_signal_handlers(void) {
 899         int sig;
 900
 901         for (sig = 1; sig < _NSIG; sig++) {
 902                 struct sigaction sa = {
 903                         .sa_handler = SIG_DFL,
 904                         .sa_flags = SA_RESTART,
 905                 };
 906
 907                 if (sig == SIGKILL || sig == SIGSTOP)
 908                         continue;
 909
 910                 /* On Linux the first two RT signals are reserved by
 911                  * glibc, and sigaction() will return EINVAL for them. */
 912                 if ((sigaction(sig, &sa, NULL) < 0))
 913                         if (errno != EINVAL)
 914                                 return -errno;
 915         }
 916
 917         return 0;
 918 }
 919
 920 char *strstrip(char *s) {
 921         char *e;
 922
 923         /* Drops trailing whitespace. Modifies the string in
 924          * place. Returns pointer to first non-space character */
 925
 926         s += strspn(s, WHITESPACE);
 927
 928         for (e = strchr(s, 0); e > s; e --)
 929                 if (!strchr(WHITESPACE, e[-1]))
 930                         break;
 931
 932         *e = 0;
 933
 934         return s;
 935 }
 936
 937 char *delete_chars(char *s, const char *bad) {
 938         char *f, *t;
 939
 940         /* Drops all whitespace, regardless where in the string */
 941
 942         for (f = s, t = s; *f; f++) {
 943                 if (strchr(bad, *f))
 944                         continue;
 945
 946                 *(t++) = *f;
 947         }
 948
 949         *t = 0;
 950
 951         return s;
 952 }
 953
 954 bool in_charset(const char *s, const char* charset) {
 955         const char *i;
 956
 957         assert(s);
 958         assert(charset);
 959
 960         for (i = s; *i; i++)
 961                 if (!strchr(charset, *i))
 962                         return false;
 963
 964         return true;
 965 }
 966
 967 char *file_in_same_dir(const char *path, const char *filename) {
 968         char *e, *r;
 969         size_t k;
 970
 971         assert(path);
 972         assert(filename);
 973
 974         /* This removes the last component of path and appends
 975          * filename, unless the latter is absolute anyway or the
 976          * former isn't */
 977
 978         if (path_is_absolute(filename))
 979                 return strdup(filename);
 980
 981         if (!(e = strrchr(path, '/')))
 982                 return strdup(filename);
 983
 984         k = strlen(filename);
 985         if (!(r = new(char, e-path+1+k+1)))
 986                 return NULL;
 987
 988         memcpy(r, path, e-path+1);
 989         memcpy(r+(e-path)+1, filename, k+1);
 990
 991         return r;
 992 }
 993
 994 int rmdir_parents(const char *path, const char *stop) {
 995         size_t l;
 996         int r = 0;
 997
 998         assert(path);
 999         assert(stop);
1000
1001         l = strlen(path);
1002
1003         /* Skip trailing slashes */
1004         while (l > 0 && path[l-1] == '/')
1005                 l--;
1006
1007         while (l > 0) {
1008                 char *t;
1009
1010                 /* Skip last component */
1011                 while (l > 0 && path[l-1] != '/')
1012                         l--;
1013
1014                 /* Skip trailing slashes */
1015                 while (l > 0 && path[l-1] == '/')
1016                         l--;
1017
1018                 if (l <= 0)
1019                         break;
1020
1021                 if (!(t = strndup(path, l)))
1022                         return -ENOMEM;
1023
1024                 if (path_startswith(stop, t)) {
1025                         free(t);
1026                         return 0;
1027                 }
1028
1029                 r = rmdir(t);
1030                 free(t);
1031
1032                 if (r < 0)
1033                         if (errno != ENOENT)
1034                                 return -errno;
1035         }
1036
1037         return 0;
1038 }
1039
1040 char hexchar(int x) {
1041         static const char table[16] = "0123456789abcdef";
1042
1043         return table[x & 15];
1044 }
1045
1046 int unhexchar(char c) {
1047
1048         if (c >= '0' && c <= '9')
1049                 return c - '0';
1050
1051         if (c >= 'a' && c <= 'f')
1052                 return c - 'a' + 10;
1053
1054         if (c >= 'A' && c <= 'F')
1055                 return c - 'A' + 10;
1056
1057         return -1;
1058 }
1059
1060 char *hexmem(const void *p, size_t l) {
1061         char *r, *z;
1062         const uint8_t *x;
1063
1064         z = r = malloc(l * 2 + 1);
1065         if (!r)
1066                 return NULL;
1067
1068         for (x = p; x < (const uint8_t*) p + l; x++) {
1069                 *(z++) = hexchar(*x >> 4);
1070                 *(z++) = hexchar(*x & 15);
1071         }
1072
1073         *z = 0;
1074         return r;
1075 }
1076
1077 void *unhexmem(const char *p, size_t l) {
1078         uint8_t *r, *z;
1079         const char *x;
1080
1081         assert(p);
1082
1083         z = r = malloc((l + 1) / 2 + 1);
1084         if (!r)
1085                 return NULL;
1086
1087         for (x = p; x < p + l; x += 2) {
1088                 int a, b;
1089
1090                 a = unhexchar(x[0]);
1091                 if (x+1 < p + l)
1092                         b = unhexchar(x[1]);
1093                 else
1094                         b = 0;
1095
1096                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1097         }
1098
1099         *z = 0;
1100         return r;
1101 }
1102
1103 char octchar(int x) {
1104         return '0' + (x & 7);
1105 }
1106
1107 int unoctchar(char c) {
1108
1109         if (c >= '0' && c <= '7')
1110                 return c - '0';
1111
1112         return -1;
1113 }
1114
1115 char decchar(int x) {
1116         return '0' + (x % 10);
1117 }
1118
1119 int undecchar(char c) {
1120
1121         if (c >= '0' && c <= '9')
1122                 return c - '0';
1123
1124         return -1;
1125 }
1126
1127 char *cescape(const char *s) {
1128         char *r, *t;
1129         const char *f;
1130
1131         assert(s);
1132
1133         /* Does C style string escaping. */
1134
1135         r = new(char, strlen(s)*4 + 1);
1136         if (!r)
1137                 return NULL;
1138
1139         for (f = s, t = r; *f; f++)
1140
1141                 switch (*f) {
1142
1143                 case '\a':
1144                         *(t++) = '\\';
1145                         *(t++) = 'a';
1146                         break;
1147                 case '\b':
1148                         *(t++) = '\\';
1149                         *(t++) = 'b';
1150                         break;
1151                 case '\f':
1152                         *(t++) = '\\';
1153                         *(t++) = 'f';
1154                         break;
1155                 case '\n':
1156                         *(t++) = '\\';
1157                         *(t++) = 'n';
1158                         break;
1159                 case '\r':
1160                         *(t++) = '\\';
1161                         *(t++) = 'r';
1162                         break;
1163                 case '\t':
1164                         *(t++) = '\\';
1165                         *(t++) = 't';
1166                         break;
1167                 case '\v':
1168                         *(t++) = '\\';
1169                         *(t++) = 'v';
1170                         break;
1171                 case '\\':
1172                         *(t++) = '\\';
1173                         *(t++) = '\\';
1174                         break;
1175                 case '"':
1176                         *(t++) = '\\';
1177                         *(t++) = '"';
1178                         break;
1179                 case '\'':
1180                         *(t++) = '\\';
1181                         *(t++) = '\'';
1182                         break;
1183
1184                 default:
1185                         /* For special chars we prefer octal over
1186                          * hexadecimal encoding, simply because glib's
1187                          * g_strescape() does the same */
1188                         if ((*f < ' ') || (*f >= 127)) {
1189                                 *(t++) = '\\';
1190                                 *(t++) = octchar((unsigned char) *f >> 6);
1191                                 *(t++) = octchar((unsigned char) *f >> 3);
1192                                 *(t++) = octchar((unsigned char) *f);
1193                         } else
1194                                 *(t++) = *f;
1195                         break;
1196                 }
1197
1198         *t = 0;
1199
1200         return r;
1201 }
1202
1203 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1204         char *r, *t;
1205         const char *f;
1206         size_t pl;
1207
1208         assert(s);
1209
1210         /* Undoes C style string escaping, and optionally prefixes it. */
1211
1212         pl = prefix ? strlen(prefix) : 0;
1213
1214         r = new(char, pl+length+1);
1215         if (!r)
1216                 return r;
1217
1218         if (prefix)
1219                 memcpy(r, prefix, pl);
1220
1221         for (f = s, t = r + pl; f < s + length; f++) {
1222
1223                 if (*f != '\\') {
1224                         *(t++) = *f;
1225                         continue;
1226                 }
1227
1228                 f++;
1229
1230                 switch (*f) {
1231
1232                 case 'a':
1233                         *(t++) = '\a';
1234                         break;
1235                 case 'b':
1236                         *(t++) = '\b';
1237                         break;
1238                 case 'f':
1239                         *(t++) = '\f';
1240                         break;
1241                 case 'n':
1242                         *(t++) = '\n';
1243                         break;
1244                 case 'r':
1245                         *(t++) = '\r';
1246                         break;
1247                 case 't':
1248                         *(t++) = '\t';
1249                         break;
1250                 case 'v':
1251                         *(t++) = '\v';
1252                         break;
1253                 case '\\':
1254                         *(t++) = '\\';
1255                         break;
1256                 case '"':
1257                         *(t++) = '"';
1258                         break;
1259                 case '\'':
1260                         *(t++) = '\'';
1261                         break;
1262
1263                 case 's':
1264                         /* This is an extension of the XDG syntax files */
1265                         *(t++) = ' ';
1266                         break;
1267
1268                 case 'x': {
1269                         /* hexadecimal encoding */
1270                         int a, b;
1271
1272                         a = unhexchar(f[1]);
1273                         b = unhexchar(f[2]);
1274
1275                         if (a < 0 || b < 0) {
1276                                 /* Invalid escape code, let's take it literal then */
1277                                 *(t++) = '\\';
1278                                 *(t++) = 'x';
1279                         } else {
1280                                 *(t++) = (char) ((a << 4) | b);
1281                                 f += 2;
1282                         }
1283
1284                         break;
1285                 }
1286
1287                 case '0':
1288                 case '1':
1289                 case '2':
1290                 case '3':
1291                 case '4':
1292                 case '5':
1293                 case '6':
1294                 case '7': {
1295                         /* octal encoding */
1296                         int a, b, c;
1297
1298                         a = unoctchar(f[0]);
1299                         b = unoctchar(f[1]);
1300                         c = unoctchar(f[2]);
1301
1302                         if (a < 0 || b < 0 || c < 0) {
1303                                 /* Invalid escape code, let's take it literal then */
1304                                 *(t++) = '\\';
1305                                 *(t++) = f[0];
1306                         } else {
1307                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1308                                 f += 2;
1309                         }
1310
1311                         break;
1312                 }
1313
1314                 case 0:
1315                         /* premature end of string.*/
1316                         *(t++) = '\\';
1317                         goto finish;
1318
1319                 default:
1320                         /* Invalid escape code, let's take it literal then */
1321                         *(t++) = '\\';
1322                         *(t++) = *f;
1323                         break;
1324                 }
1325         }
1326
1327 finish:
1328         *t = 0;
1329         return r;
1330 }
1331
1332 char *cunescape_length(const char *s, size_t length) {
1333         return cunescape_length_with_prefix(s, length, NULL);
1334 }
1335
1336 char *cunescape(const char *s) {
1337         assert(s);
1338
1339         return cunescape_length(s, strlen(s));
1340 }
1341
1342 char *xescape(const char *s, const char *bad) {
1343         char *r, *t;
1344         const char *f;
1345
1346         /* Escapes all chars in bad, in addition to \ and all special
1347          * chars, in \xFF style escaping. May be reversed with
1348          * cunescape. */
1349
1350         r = new(char, strlen(s) * 4 + 1);
1351         if (!r)
1352                 return NULL;
1353
1354         for (f = s, t = r; *f; f++) {
1355
1356                 if ((*f < ' ') || (*f >= 127) ||
1357                     (*f == '\\') || strchr(bad, *f)) {
1358                         *(t++) = '\\';
1359                         *(t++) = 'x';
1360                         *(t++) = hexchar(*f >> 4);
1361                         *(t++) = hexchar(*f);
1362                 } else
1363                         *(t++) = *f;
1364         }
1365
1366         *t = 0;
1367
1368         return r;
1369 }
1370
1371 char *ascii_strlower(char *t) {
1372         char *p;
1373
1374         assert(t);
1375
1376         for (p = t; *p; p++)
1377                 if (*p >= 'A' && *p <= 'Z')
1378                         *p = *p - 'A' + 'a';
1379
1380         return t;
1381 }
1382
1383 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1384         assert(filename);
1385
1386         return
1387                 filename[0] == '.' ||
1388                 streq(filename, "lost+found") ||
1389                 streq(filename, "aquota.user") ||
1390                 streq(filename, "aquota.group") ||
1391                 endswith(filename, ".rpmnew") ||
1392                 endswith(filename, ".rpmsave") ||
1393                 endswith(filename, ".rpmorig") ||
1394                 endswith(filename, ".dpkg-old") ||
1395                 endswith(filename, ".dpkg-new") ||
1396                 endswith(filename, ".swp");
1397 }
1398
1399 bool ignore_file(const char *filename) {
1400         assert(filename);
1401
1402         if (endswith(filename, "~"))
1403                 return false;
1404
1405         return ignore_file_allow_backup(filename);
1406 }
1407
1408 int fd_nonblock(int fd, bool nonblock) {
1409         int flags;
1410
1411         assert(fd >= 0);
1412
1413         if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1414                 return -errno;
1415
1416         if (nonblock)
1417                 flags |= O_NONBLOCK;
1418         else
1419                 flags &= ~O_NONBLOCK;
1420
1421         if (fcntl(fd, F_SETFL, flags) < 0)
1422                 return -errno;
1423
1424         return 0;
1425 }
1426
1427 int fd_cloexec(int fd, bool cloexec) {
1428         int flags;
1429
1430         assert(fd >= 0);
1431
1432         if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1433                 return -errno;
1434
1435         if (cloexec)
1436                 flags |= FD_CLOEXEC;
1437         else
1438                 flags &= ~FD_CLOEXEC;
1439
1440         if (fcntl(fd, F_SETFD, flags) < 0)
1441                 return -errno;
1442
1443         return 0;
1444 }
1445
1446 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1447         unsigned i;
1448
1449         assert(n_fdset == 0 || fdset);
1450
1451         for (i = 0; i < n_fdset; i++)
1452                 if (fdset[i] == fd)
1453                         return true;
1454
1455         return false;
1456 }
1457
1458 int close_all_fds(const int except[], unsigned n_except) {
1459         DIR *d;
1460         struct dirent *de;
1461         int r = 0;
1462
1463         assert(n_except == 0 || except);
1464
1465         d = opendir("/proc/self/fd");
1466         if (!d) {
1467                 int fd;
1468                 struct rlimit rl;
1469
1470                 /* When /proc isn't available (for example in chroots)
1471                  * the fallback is brute forcing through the fd
1472                  * table */
1473
1474                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1475                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1476
1477                         if (fd_in_set(fd, except, n_except))
1478                                 continue;
1479
1480                         if (close_nointr(fd) < 0)
1481                                 if (errno != EBADF && r == 0)
1482                                         r = -errno;
1483                 }
1484
1485                 return r;
1486         }
1487
1488         while ((de = readdir(d))) {
1489                 int fd = -1;
1490
1491                 if (ignore_file(de->d_name))
1492                         continue;
1493
1494                 if (safe_atoi(de->d_name, &fd) < 0)
1495                         /* Let's better ignore this, just in case */
1496                         continue;
1497
1498                 if (fd < 3)
1499                         continue;
1500
1501                 if (fd == dirfd(d))
1502                         continue;
1503
1504                 if (fd_in_set(fd, except, n_except))
1505                         continue;
1506
1507                 if (close_nointr(fd) < 0) {
1508                         /* Valgrind has its own FD and doesn't want to have it closed */
1509                         if (errno != EBADF && r == 0)
1510                                 r = -errno;
1511                 }
1512         }
1513
1514         closedir(d);
1515         return r;
1516 }
1517
1518 bool chars_intersect(const char *a, const char *b) {
1519         const char *p;
1520
1521         /* Returns true if any of the chars in a are in b. */
1522         for (p = a; *p; p++)
1523                 if (strchr(b, *p))
1524                         return true;
1525
1526         return false;
1527 }
1528
1529 bool fstype_is_network(const char *fstype) {
1530         static const char table[] =
1531                 "cifs\0"
1532                 "smbfs\0"
1533                 "ncpfs\0"
1534                 "ncp\0"
1535                 "nfs\0"
1536                 "nfs4\0"
1537                 "gfs\0"
1538                 "gfs2\0";
1539
1540         return nulstr_contains(table, fstype);
1541 }
1542
1543 int chvt(int vt) {
1544         _cleanup_close_ int fd;
1545
1546         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1547         if (fd < 0)
1548                 return -errno;
1549
1550         if (vt < 0) {
1551                 int tiocl[2] = {
1552                         TIOCL_GETKMSGREDIRECT,
1553                         0
1554                 };
1555
1556                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1557                         return -errno;
1558
1559                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1560         }
1561
1562         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1563                 return -errno;
1564
1565         return 0;
1566 }
1567
1568 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1569         struct termios old_termios, new_termios;
1570         char c;
1571         char line[LINE_MAX];
1572
1573         assert(f);
1574         assert(ret);
1575
1576         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1577                 new_termios = old_termios;
1578
1579                 new_termios.c_lflag &= ~ICANON;
1580                 new_termios.c_cc[VMIN] = 1;
1581                 new_termios.c_cc[VTIME] = 0;
1582
1583                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1584                         size_t k;
1585
1586                         if (t != (usec_t) -1) {
1587                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1588                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1589                                         return -ETIMEDOUT;
1590                                 }
1591                         }
1592
1593                         k = fread(&c, 1, 1, f);
1594
1595                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1596
1597                         if (k <= 0)
1598                                 return -EIO;
1599
1600                         if (need_nl)
1601                                 *need_nl = c != '\n';
1602
1603                         *ret = c;
1604                         return 0;
1605                 }
1606         }
1607
1608         if (t != (usec_t) -1)
1609                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1610                         return -ETIMEDOUT;
1611
1612         if (!fgets(line, sizeof(line), f))
1613                 return -EIO;
1614
1615         truncate_nl(line);
1616
1617         if (strlen(line) != 1)
1618                 return -EBADMSG;
1619
1620         if (need_nl)
1621                 *need_nl = false;
1622
1623         *ret = line[0];
1624         return 0;
1625 }
1626
1627 int ask(char *ret, const char *replies, const char *text, ...) {
1628
1629         assert(ret);
1630         assert(replies);
1631         assert(text);
1632
1633         for (;;) {
1634                 va_list ap;
1635                 char c;
1636                 int r;
1637                 bool need_nl = true;
1638
1639                 if (on_tty())
1640                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1641
1642                 va_start(ap, text);
1643                 vprintf(text, ap);
1644                 va_end(ap);
1645
1646                 if (on_tty())
1647                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1648
1649                 fflush(stdout);
1650
1651                 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1652                 if (r < 0) {
1653
1654                         if (r == -EBADMSG) {
1655                                 puts("Bad input, please try again.");
1656                                 continue;
1657                         }
1658
1659                         putchar('\n');
1660                         return r;
1661                 }
1662
1663                 if (need_nl)
1664                         putchar('\n');
1665
1666                 if (strchr(replies, c)) {
1667                         *ret = c;
1668                         return 0;
1669                 }
1670
1671                 puts("Read unexpected character, please try again.");
1672         }
1673 }
1674
1675 int reset_terminal_fd(int fd, bool switch_to_text) {
1676         struct termios termios;
1677         int r = 0;
1678
1679         /* Set terminal to some sane defaults */
1680
1681         assert(fd >= 0);
1682
1683         /* We leave locked terminal attributes untouched, so that
1684          * Plymouth may set whatever it wants to set, and we don't
1685          * interfere with that. */
1686
1687         /* Disable exclusive mode, just in case */
1688         ioctl(fd, TIOCNXCL);
1689
1690         /* Switch to text mode */
1691         if (switch_to_text)
1692                 ioctl(fd, KDSETMODE, KD_TEXT);
1693
1694         /* Enable console unicode mode */
1695         ioctl(fd, KDSKBMODE, K_UNICODE);
1696
1697         if (tcgetattr(fd, &termios) < 0) {
1698                 r = -errno;
1699                 goto finish;
1700         }
1701
1702         /* We only reset the stuff that matters to the software. How
1703          * hardware is set up we don't touch assuming that somebody
1704          * else will do that for us */
1705
1706         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1707         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1708         termios.c_oflag |= ONLCR;
1709         termios.c_cflag |= CREAD;
1710         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1711
1712         termios.c_cc[VINTR]    =   03;  /* ^C */
1713         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1714         termios.c_cc[VERASE]   = 0177;
1715         termios.c_cc[VKILL]    =  025;  /* ^X */
1716         termios.c_cc[VEOF]     =   04;  /* ^D */
1717         termios.c_cc[VSTART]   =  021;  /* ^Q */
1718         termios.c_cc[VSTOP]    =  023;  /* ^S */
1719         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1720         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1721         termios.c_cc[VWERASE]  =  027;  /* ^W */
1722         termios.c_cc[VREPRINT] =  022;  /* ^R */
1723         termios.c_cc[VEOL]     =    0;
1724         termios.c_cc[VEOL2]    =    0;
1725
1726         termios.c_cc[VTIME]  = 0;
1727         termios.c_cc[VMIN]   = 1;
1728
1729         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1730                 r = -errno;
1731
1732 finish:
1733         /* Just in case, flush all crap out */
1734         tcflush(fd, TCIOFLUSH);
1735
1736         return r;
1737 }
1738
1739 int reset_terminal(const char *name) {
1740         int fd, r;
1741
1742         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1743         if (fd < 0)
1744                 return fd;
1745
1746         r = reset_terminal_fd(fd, true);
1747         close_nointr_nofail(fd);
1748
1749         return r;
1750 }
1751
1752 int open_terminal(const char *name, int mode) {
1753         int fd, r;
1754         unsigned c = 0;
1755
1756         /*
1757          * If a TTY is in the process of being closed opening it might
1758          * cause EIO. This is horribly awful, but unlikely to be
1759          * changed in the kernel. Hence we work around this problem by
1760          * retrying a couple of times.
1761          *
1762          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1763          */
1764
1765         assert(!(mode & O_CREAT));
1766
1767         for (;;) {
1768                 fd = open(name, mode, 0);
1769                 if (fd >= 0)
1770                         break;
1771
1772                 if (errno != EIO)
1773                         return -errno;
1774
1775                 /* Max 1s in total */
1776                 if (c >= 20)
1777                         return -errno;
1778
1779                 usleep(50 * USEC_PER_MSEC);
1780                 c++;
1781         }
1782
1783         if (fd < 0)
1784                 return -errno;
1785
1786         r = isatty(fd);
1787         if (r < 0) {
1788                 close_nointr_nofail(fd);
1789                 return -errno;
1790         }
1791
1792         if (!r) {
1793                 close_nointr_nofail(fd);
1794                 return -ENOTTY;
1795         }
1796
1797         return fd;
1798 }
1799
1800 int flush_fd(int fd) {
1801         struct pollfd pollfd = {
1802                 .fd = fd,
1803                 .events = POLLIN,
1804         };
1805
1806         for (;;) {
1807                 char buf[LINE_MAX];
1808                 ssize_t l;
1809                 int r;
1810
1811                 r = poll(&pollfd, 1, 0);
1812                 if (r < 0) {
1813                         if (errno == EINTR)
1814                                 continue;
1815
1816                         return -errno;
1817
1818                 } else if (r == 0)
1819                         return 0;
1820
1821                 l = read(fd, buf, sizeof(buf));
1822                 if (l < 0) {
1823
1824                         if (errno == EINTR)
1825                                 continue;
1826
1827                         if (errno == EAGAIN)
1828                                 return 0;
1829
1830                         return -errno;
1831                 } else if (l == 0)
1832                         return 0;
1833         }
1834 }
1835
1836 int acquire_terminal(
1837                 const char *name,
1838                 bool fail,
1839                 bool force,
1840                 bool ignore_tiocstty_eperm,
1841                 usec_t timeout) {
1842
1843         int fd = -1, notify = -1, r = 0, wd = -1;
1844         usec_t ts = 0;
1845
1846         assert(name);
1847
1848         /* We use inotify to be notified when the tty is closed. We
1849          * create the watch before checking if we can actually acquire
1850          * it, so that we don't lose any event.
1851          *
1852          * Note: strictly speaking this actually watches for the
1853          * device being closed, it does *not* really watch whether a
1854          * tty loses its controlling process. However, unless some
1855          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1856          * its tty otherwise this will not become a problem. As long
1857          * as the administrator makes sure not configure any service
1858          * on the same tty as an untrusted user this should not be a
1859          * problem. (Which he probably should not do anyway.) */
1860
1861         if (timeout != (usec_t) -1)
1862                 ts = now(CLOCK_MONOTONIC);
1863
1864         if (!fail && !force) {
1865                 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1866                 if (notify < 0) {
1867                         r = -errno;
1868                         goto fail;
1869                 }
1870
1871                 wd = inotify_add_watch(notify, name, IN_CLOSE);
1872                 if (wd < 0) {
1873                         r = -errno;
1874                         goto fail;
1875                 }
1876         }
1877
1878         for (;;) {
1879                 struct sigaction sa_old, sa_new = {
1880                         .sa_handler = SIG_IGN,
1881                         .sa_flags = SA_RESTART,
1882                 };
1883
1884                 if (notify >= 0) {
1885                         r = flush_fd(notify);
1886                         if (r < 0)
1887                                 goto fail;
1888                 }
1889
1890                 /* We pass here O_NOCTTY only so that we can check the return
1891                  * value TIOCSCTTY and have a reliable way to figure out if we
1892                  * successfully became the controlling process of the tty */
1893                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1894                 if (fd < 0)
1895                         return fd;
1896
1897                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1898                  * if we already own the tty. */
1899                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1900
1901                 /* First, try to get the tty */
1902                 if (ioctl(fd, TIOCSCTTY, force) < 0)
1903                         r = -errno;
1904
1905                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1906
1907                 /* Sometimes it makes sense to ignore TIOCSCTTY
1908                  * returning EPERM, i.e. when very likely we already
1909                  * are have this controlling terminal. */
1910                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1911                         r = 0;
1912
1913                 if (r < 0 && (force || fail || r != -EPERM)) {
1914                         goto fail;
1915                 }
1916
1917                 if (r >= 0)
1918                         break;
1919
1920                 assert(!fail);
1921                 assert(!force);
1922                 assert(notify >= 0);
1923
1924                 for (;;) {
1925                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1926                         ssize_t l;
1927                         struct inotify_event *e;
1928
1929                         if (timeout != (usec_t) -1) {
1930                                 usec_t n;
1931
1932                                 n = now(CLOCK_MONOTONIC);
1933                                 if (ts + timeout < n) {
1934                                         r = -ETIMEDOUT;
1935                                         goto fail;
1936                                 }
1937
1938                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1939                                 if (r < 0)
1940                                         goto fail;
1941
1942                                 if (r == 0) {
1943                                         r = -ETIMEDOUT;
1944                                         goto fail;
1945                                 }
1946                         }
1947
1948                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1949                         if (l < 0) {
1950
1951                                 if (errno == EINTR || errno == EAGAIN)
1952                                         continue;
1953
1954                                 r = -errno;
1955                                 goto fail;
1956                         }
1957
1958                         e = (struct inotify_event*) inotify_buffer;
1959
1960                         while (l > 0) {
1961                                 size_t step;
1962
1963                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
1964                                         r = -EIO;
1965                                         goto fail;
1966                                 }
1967
1968                                 step = sizeof(struct inotify_event) + e->len;
1969                                 assert(step <= (size_t) l);
1970
1971                                 e = (struct inotify_event*) ((uint8_t*) e + step);
1972                                 l -= step;
1973                         }
1974
1975                         break;
1976                 }
1977
1978                 /* We close the tty fd here since if the old session
1979                  * ended our handle will be dead. It's important that
1980                  * we do this after sleeping, so that we don't enter
1981                  * an endless loop. */
1982                 close_nointr_nofail(fd);
1983         }
1984
1985         if (notify >= 0)
1986                 close_nointr_nofail(notify);
1987
1988         r = reset_terminal_fd(fd, true);
1989         if (r < 0)
1990                 log_warning("Failed to reset terminal: %s", strerror(-r));
1991
1992         return fd;
1993
1994 fail:
1995         if (fd >= 0)
1996                 close_nointr_nofail(fd);
1997
1998         if (notify >= 0)
1999                 close_nointr_nofail(notify);
2000
2001         return r;
2002 }
2003
2004 int release_terminal(void) {
2005         int r = 0;
2006         struct sigaction sa_old, sa_new = {
2007                 .sa_handler = SIG_IGN,
2008                 .sa_flags = SA_RESTART,
2009         };
2010         _cleanup_close_ int fd;
2011
2012         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2013         if (fd < 0)
2014                 return -errno;
2015
2016         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2017          * by our own TIOCNOTTY */
2018         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2019
2020         if (ioctl(fd, TIOCNOTTY) < 0)
2021                 r = -errno;
2022
2023         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2024
2025         return r;
2026 }
2027
2028 int sigaction_many(const struct sigaction *sa, ...) {
2029         va_list ap;
2030         int r = 0, sig;
2031
2032         va_start(ap, sa);
2033         while ((sig = va_arg(ap, int)) > 0)
2034                 if (sigaction(sig, sa, NULL) < 0)
2035                         r = -errno;
2036         va_end(ap);
2037
2038         return r;
2039 }
2040
2041 int ignore_signals(int sig, ...) {
2042         struct sigaction sa = {
2043                 .sa_handler = SIG_IGN,
2044                 .sa_flags = SA_RESTART,
2045         };
2046         va_list ap;
2047         int r = 0;
2048
2049
2050         if (sigaction(sig, &sa, NULL) < 0)
2051                 r = -errno;
2052
2053         va_start(ap, sig);
2054         while ((sig = va_arg(ap, int)) > 0)
2055                 if (sigaction(sig, &sa, NULL) < 0)
2056                         r = -errno;
2057         va_end(ap);
2058
2059         return r;
2060 }
2061
2062 int default_signals(int sig, ...) {
2063         struct sigaction sa = {
2064                 .sa_handler = SIG_DFL,
2065                 .sa_flags = SA_RESTART,
2066         };
2067         va_list ap;
2068         int r = 0;
2069
2070         if (sigaction(sig, &sa, NULL) < 0)
2071                 r = -errno;
2072
2073         va_start(ap, sig);
2074         while ((sig = va_arg(ap, int)) > 0)
2075                 if (sigaction(sig, &sa, NULL) < 0)
2076                         r = -errno;
2077         va_end(ap);
2078
2079         return r;
2080 }
2081
2082 int close_pipe(int p[]) {
2083         int a = 0, b = 0;
2084
2085         assert(p);
2086
2087         if (p[0] >= 0) {
2088                 a = close_nointr(p[0]);
2089                 p[0] = -1;
2090         }
2091
2092         if (p[1] >= 0) {
2093                 b = close_nointr(p[1]);
2094                 p[1] = -1;
2095         }
2096
2097         return a < 0 ? a : b;
2098 }
2099
2100 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2101         uint8_t *p;
2102         ssize_t n = 0;
2103
2104         assert(fd >= 0);
2105         assert(buf);
2106
2107         p = buf;
2108
2109         while (nbytes > 0) {
2110                 ssize_t k;
2111
2112                 if ((k = read(fd, p, nbytes)) <= 0) {
2113
2114                         if (k < 0 && errno == EINTR)
2115                                 continue;
2116
2117                         if (k < 0 && errno == EAGAIN && do_poll) {
2118                                 struct pollfd pollfd = {
2119                                         .fd = fd,
2120                                         .events = POLLIN,
2121                                 };
2122
2123                                 if (poll(&pollfd, 1, -1) < 0) {
2124                                         if (errno == EINTR)
2125                                                 continue;
2126
2127                                         return n > 0 ? n : -errno;
2128                                 }
2129
2130                                 /* We knowingly ignore the revents value here,
2131                                  * and expect that any error/EOF is reported
2132                                  * via read()/write()
2133                                  */
2134
2135                                 continue;
2136                         }
2137
2138                         return n > 0 ? n : (k < 0 ? -errno : 0);
2139                 }
2140
2141                 p += k;
2142                 nbytes -= k;
2143                 n += k;
2144         }
2145
2146         return n;
2147 }
2148
2149 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2150         const uint8_t *p;
2151         ssize_t n = 0;
2152
2153         assert(fd >= 0);
2154         assert(buf);
2155
2156         p = buf;
2157
2158         while (nbytes > 0) {
2159                 ssize_t k;
2160
2161                 k = write(fd, p, nbytes);
2162                 if (k <= 0) {
2163
2164                         if (k < 0 && errno == EINTR)
2165                                 continue;
2166
2167                         if (k < 0 && errno == EAGAIN && do_poll) {
2168                                 struct pollfd pollfd = {
2169                                         .fd = fd,
2170                                         .events = POLLOUT,
2171                                 };
2172
2173                                 if (poll(&pollfd, 1, -1) < 0) {
2174                                         if (errno == EINTR)
2175                                                 continue;
2176
2177                                         return n > 0 ? n : -errno;
2178                                 }
2179
2180                                 /* We knowingly ignore the revents value here,
2181                                  * and expect that any error/EOF is reported
2182                                  * via read()/write()
2183                                  */
2184
2185                                 continue;
2186                         }
2187
2188                         return n > 0 ? n : (k < 0 ? -errno : 0);
2189                 }
2190
2191                 p += k;
2192                 nbytes -= k;
2193                 n += k;
2194         }
2195
2196         return n;
2197 }
2198
2199 int parse_bytes(const char *t, off_t *bytes) {
2200         static const struct {
2201                 const char *suffix;
2202                 unsigned long long factor;
2203         } table[] = {
2204                 { "B", 1 },
2205                 { "K", 1024ULL },
2206                 { "M", 1024ULL*1024ULL },
2207                 { "G", 1024ULL*1024ULL*1024ULL },
2208                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2209                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2210                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2211                 { "", 1 },
2212         };
2213
2214         const char *p;
2215         unsigned long long r = 0;
2216
2217         assert(t);
2218         assert(bytes);
2219
2220         p = t;
2221         do {
2222                 long long l;
2223                 char *e;
2224                 unsigned i;
2225
2226                 errno = 0;
2227                 l = strtoll(p, &e, 10);
2228
2229                 if (errno > 0)
2230                         return -errno;
2231
2232                 if (l < 0)
2233                         return -ERANGE;
2234
2235                 if (e == p)
2236                         return -EINVAL;
2237
2238                 e += strspn(e, WHITESPACE);
2239
2240                 for (i = 0; i < ELEMENTSOF(table); i++)
2241                         if (startswith(e, table[i].suffix)) {
2242                                 unsigned long long tmp;
2243                                 if ((unsigned long long) l > ULLONG_MAX / table[i].factor)
2244                                         return -ERANGE;
2245                                 tmp = l * table[i].factor;
2246                                 if (tmp > ULLONG_MAX - r)
2247                                         return -ERANGE;
2248
2249                                 r += tmp;
2250                                 if ((unsigned long long) (off_t) r != r)
2251                                         return -ERANGE;
2252
2253                                 p = e + strlen(table[i].suffix);
2254                                 break;
2255                         }
2256
2257                 if (i >= ELEMENTSOF(table))
2258                         return -EINVAL;
2259
2260         } while (*p);
2261
2262         *bytes = r;
2263
2264         return 0;
2265 }
2266
2267 int make_stdio(int fd) {
2268         int r, s, t;
2269
2270         assert(fd >= 0);
2271
2272         r = dup3(fd, STDIN_FILENO, 0);
2273         s = dup3(fd, STDOUT_FILENO, 0);
2274         t = dup3(fd, STDERR_FILENO, 0);
2275
2276         if (fd >= 3)
2277                 close_nointr_nofail(fd);
2278
2279         if (r < 0 || s < 0 || t < 0)
2280                 return -errno;
2281
2282         /* We rely here that the new fd has O_CLOEXEC not set */
2283
2284         return 0;
2285 }
2286
2287 int make_null_stdio(void) {
2288         int null_fd;
2289
2290         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2291         if (null_fd < 0)
2292                 return -errno;
2293
2294         return make_stdio(null_fd);
2295 }
2296
2297 bool is_device_path(const char *path) {
2298
2299         /* Returns true on paths that refer to a device, either in
2300          * sysfs or in /dev */
2301
2302         return
2303                 path_startswith(path, "/dev/") ||
2304                 path_startswith(path, "/sys/");
2305 }
2306
2307 int dir_is_empty(const char *path) {
2308         _cleanup_closedir_ DIR *d;
2309
2310         d = opendir(path);
2311         if (!d)
2312                 return -errno;
2313
2314         for (;;) {
2315                 struct dirent *de;
2316
2317                 errno = 0;
2318                 de = readdir(d);
2319                 if (!de && errno != 0)
2320                         return -errno;
2321
2322                 if (!de)
2323                         return 1;
2324
2325                 if (!ignore_file(de->d_name))
2326                         return 0;
2327         }
2328 }
2329
2330 char* dirname_malloc(const char *path) {
2331         char *d, *dir, *dir2;
2332
2333         d = strdup(path);
2334         if (!d)
2335                 return NULL;
2336         dir = dirname(d);
2337         assert(dir);
2338
2339         if (dir != d) {
2340                 dir2 = strdup(dir);
2341                 free(d);
2342                 return dir2;
2343         }
2344
2345         return dir;
2346 }
2347
2348 unsigned long long random_ull(void) {
2349         _cleanup_close_ int fd;
2350         uint64_t ull;
2351         ssize_t r;
2352
2353         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2354         if (fd < 0)
2355                 goto fallback;
2356
2357         r = loop_read(fd, &ull, sizeof(ull), true);
2358         if (r != sizeof(ull))
2359                 goto fallback;
2360
2361         return ull;
2362
2363 fallback:
2364         return random() * RAND_MAX + random();
2365 }
2366
2367 unsigned random_u(void) {
2368         _cleanup_close_ int fd;
2369         unsigned u;
2370         ssize_t r;
2371
2372         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2373         if (fd < 0)
2374                 goto fallback;
2375
2376         r = loop_read(fd, &u, sizeof(u), true);
2377         if (r != sizeof(u))
2378                 goto fallback;
2379
2380         return u;
2381
2382 fallback:
2383         return random() * RAND_MAX + random();
2384 }
2385
2386 void rename_process(const char name[8]) {
2387         assert(name);
2388
2389         /* This is a like a poor man's setproctitle(). It changes the
2390          * comm field, argv[0], and also the glibc's internally used
2391          * name of the process. For the first one a limit of 16 chars
2392          * applies, to the second one usually one of 10 (i.e. length
2393          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2394          * "systemd"). If you pass a longer string it will be
2395          * truncated */
2396
2397         prctl(PR_SET_NAME, name);
2398
2399         if (program_invocation_name)
2400                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2401
2402         if (saved_argc > 0) {
2403                 int i;
2404
2405                 if (saved_argv[0])
2406                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2407
2408                 for (i = 1; i < saved_argc; i++) {
2409                         if (!saved_argv[i])
2410                                 break;
2411
2412                         memset(saved_argv[i], 0, strlen(saved_argv[i]));
2413                 }
2414         }
2415 }
2416
2417 void sigset_add_many(sigset_t *ss, ...) {
2418         va_list ap;
2419         int sig;
2420
2421         assert(ss);
2422
2423         va_start(ap, ss);
2424         while ((sig = va_arg(ap, int)) > 0)
2425                 assert_se(sigaddset(ss, sig) == 0);
2426         va_end(ap);
2427 }
2428
2429 char* gethostname_malloc(void) {
2430         struct utsname u;
2431
2432         assert_se(uname(&u) >= 0);
2433
2434         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2435                 return strdup(u.nodename);
2436
2437         return strdup(u.sysname);
2438 }
2439
2440 bool hostname_is_set(void) {
2441         struct utsname u;
2442
2443         assert_se(uname(&u) >= 0);
2444
2445         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2446 }
2447
2448 static char *lookup_uid(uid_t uid) {
2449         long bufsize;
2450         char *name;
2451         _cleanup_free_ char *buf = NULL;
2452         struct passwd pwbuf, *pw = NULL;
2453
2454         /* Shortcut things to avoid NSS lookups */
2455         if (uid == 0)
2456                 return strdup("root");
2457
2458         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2459         if (bufsize <= 0)
2460                 bufsize = 4096;
2461
2462         buf = malloc(bufsize);
2463         if (!buf)
2464                 return NULL;
2465
2466         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2467                 return strdup(pw->pw_name);
2468
2469         if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
2470                 return NULL;
2471
2472         return name;
2473 }
2474
2475 char* getlogname_malloc(void) {
2476         uid_t uid;
2477         struct stat st;
2478
2479         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2480                 uid = st.st_uid;
2481         else
2482                 uid = getuid();
2483
2484         return lookup_uid(uid);
2485 }
2486
2487 char *getusername_malloc(void) {
2488         const char *e;
2489
2490         e = getenv("USER");
2491         if (e)
2492                 return strdup(e);
2493
2494         return lookup_uid(getuid());
2495 }
2496
2497 int getttyname_malloc(int fd, char **r) {
2498         char path[PATH_MAX], *c;
2499         int k;
2500
2501         assert(r);
2502
2503         k = ttyname_r(fd, path, sizeof(path));
2504         if (k > 0)
2505                 return -k;
2506
2507         char_array_0(path);
2508
2509         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2510         if (!c)
2511                 return -ENOMEM;
2512
2513         *r = c;
2514         return 0;
2515 }
2516
2517 int getttyname_harder(int fd, char **r) {
2518         int k;
2519         char *s;
2520
2521         k = getttyname_malloc(fd, &s);
2522         if (k < 0)
2523                 return k;
2524
2525         if (streq(s, "tty")) {
2526                 free(s);
2527                 return get_ctty(0, NULL, r);
2528         }
2529
2530         *r = s;
2531         return 0;
2532 }
2533
2534 int get_ctty_devnr(pid_t pid, dev_t *d) {
2535         _cleanup_fclose_ FILE *f = NULL;
2536         char line[LINE_MAX], *p;
2537         unsigned long ttynr;
2538         const char *fn;
2539
2540         assert(pid >= 0);
2541
2542         if (pid == 0)
2543                 fn = "/proc/self/stat";
2544         else
2545                 fn = procfs_file_alloca(pid, "stat");
2546
2547         f = fopen(fn, "re");
2548         if (!f)
2549                 return -errno;
2550
2551         if (!fgets(line, sizeof(line), f))
2552                 return feof(f) ? -EIO : -errno;
2553
2554         p = strrchr(line, ')');
2555         if (!p)
2556                 return -EIO;
2557
2558         p++;
2559
2560         if (sscanf(p, " "
2561                    "%*c "  /* state */
2562                    "%*d "  /* ppid */
2563                    "%*d "  /* pgrp */
2564                    "%*d "  /* session */
2565                    "%lu ", /* ttynr */
2566                    &ttynr) != 1)
2567                 return -EIO;
2568
2569         if (major(ttynr) == 0 && minor(ttynr) == 0)
2570                 return -ENOENT;
2571
2572         if (d)
2573                 *d = (dev_t) ttynr;
2574
2575         return 0;
2576 }
2577
2578 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2579         int k;
2580         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *s, *b, *p;
2581         dev_t devnr;
2582
2583         assert(r);
2584
2585         k = get_ctty_devnr(pid, &devnr);
2586         if (k < 0)
2587                 return k;
2588
2589         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2590
2591         k = readlink_malloc(fn, &s);
2592         if (k < 0) {
2593
2594                 if (k != -ENOENT)
2595                         return k;
2596
2597                 /* This is an ugly hack */
2598                 if (major(devnr) == 136) {
2599                         if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
2600                                 return -ENOMEM;
2601
2602                         *r = b;
2603                         if (_devnr)
2604                                 *_devnr = devnr;
2605
2606                         return 0;
2607                 }
2608
2609                 /* Probably something like the ptys which have no
2610                  * symlink in /dev/char. Let's return something
2611                  * vaguely useful. */
2612
2613                 b = strdup(fn + 5);
2614                 if (!b)
2615                         return -ENOMEM;
2616
2617                 *r = b;
2618                 if (_devnr)
2619                         *_devnr = devnr;
2620
2621                 return 0;
2622         }
2623
2624         if (startswith(s, "/dev/"))
2625                 p = s + 5;
2626         else if (startswith(s, "../"))
2627                 p = s + 3;
2628         else
2629                 p = s;
2630
2631         b = strdup(p);
2632         free(s);
2633
2634         if (!b)
2635                 return -ENOMEM;
2636
2637         *r = b;
2638         if (_devnr)
2639                 *_devnr = devnr;
2640
2641         return 0;
2642 }
2643
2644 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2645         DIR *d;
2646         int ret = 0;
2647
2648         assert(fd >= 0);
2649
2650         /* This returns the first error we run into, but nevertheless
2651          * tries to go on. This closes the passed fd. */
2652
2653         d = fdopendir(fd);
2654         if (!d) {
2655                 close_nointr_nofail(fd);
2656
2657                 return errno == ENOENT ? 0 : -errno;
2658         }
2659
2660         for (;;) {
2661                 struct dirent *de;
2662                 bool is_dir, keep_around;
2663                 struct stat st;
2664                 int r;
2665
2666                 errno = 0;
2667                 de = readdir(d);
2668                 if (!de && errno != 0) {
2669                         if (ret == 0)
2670                                 ret = -errno;
2671                         break;
2672                 }
2673
2674                 if (!de)
2675                         break;
2676
2677                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2678                         continue;
2679
2680                 if (de->d_type == DT_UNKNOWN ||
2681                     honour_sticky ||
2682                     (de->d_type == DT_DIR && root_dev)) {
2683                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2684                                 if (ret == 0 && errno != ENOENT)
2685                                         ret = -errno;
2686                                 continue;
2687                         }
2688
2689                         is_dir = S_ISDIR(st.st_mode);
2690                         keep_around =
2691                                 honour_sticky &&
2692                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2693                                 (st.st_mode & S_ISVTX);
2694                 } else {
2695                         is_dir = de->d_type == DT_DIR;
2696                         keep_around = false;
2697                 }
2698
2699                 if (is_dir) {
2700                         int subdir_fd;
2701
2702                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2703                         if (root_dev && st.st_dev != root_dev->st_dev)
2704                                 continue;
2705
2706                         subdir_fd = openat(fd, de->d_name,
2707                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2708                         if (subdir_fd < 0) {
2709                                 if (ret == 0 && errno != ENOENT)
2710                                         ret = -errno;
2711                                 continue;
2712                         }
2713
2714                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2715                         if (r < 0 && ret == 0)
2716                                 ret = r;
2717
2718                         if (!keep_around)
2719                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2720                                         if (ret == 0 && errno != ENOENT)
2721                                                 ret = -errno;
2722                                 }
2723
2724                 } else if (!only_dirs && !keep_around) {
2725
2726                         if (unlinkat(fd, de->d_name, 0) < 0) {
2727                                 if (ret == 0 && errno != ENOENT)
2728                                         ret = -errno;
2729                         }
2730                 }
2731         }
2732
2733         closedir(d);
2734
2735         return ret;
2736 }
2737
2738 _pure_ static int is_temporary_fs(struct statfs *s) {
2739         assert(s);
2740
2741         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2742                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2743 }
2744
2745 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2746         struct statfs s;
2747
2748         assert(fd >= 0);
2749
2750         if (fstatfs(fd, &s) < 0) {
2751                 close_nointr_nofail(fd);
2752                 return -errno;
2753         }
2754
2755         /* We refuse to clean disk file systems with this call. This
2756          * is extra paranoia just to be sure we never ever remove
2757          * non-state data */
2758         if (!is_temporary_fs(&s)) {
2759                 log_error("Attempted to remove disk file system, and we can't allow that.");
2760                 close_nointr_nofail(fd);
2761                 return -EPERM;
2762         }
2763
2764         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2765 }
2766
2767 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2768         int fd, r;
2769         struct statfs s;
2770
2771         assert(path);
2772
2773         /* We refuse to clean the root file system with this
2774          * call. This is extra paranoia to never cause a really
2775          * seriously broken system. */
2776         if (path_equal(path, "/")) {
2777                 log_error("Attempted to remove entire root file system, and we can't allow that.");
2778                 return -EPERM;
2779         }
2780
2781         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2782         if (fd < 0) {
2783
2784                 if (errno != ENOTDIR)
2785                         return -errno;
2786
2787                 if (!dangerous) {
2788                         if (statfs(path, &s) < 0)
2789                                 return -errno;
2790
2791                         if (!is_temporary_fs(&s)) {
2792                                 log_error("Attempted to remove disk file system, and we can't allow that.");
2793                                 return -EPERM;
2794                         }
2795                 }
2796
2797                 if (delete_root && !only_dirs)
2798                         if (unlink(path) < 0 && errno != ENOENT)
2799                                 return -errno;
2800
2801                 return 0;
2802         }
2803
2804         if (!dangerous) {
2805                 if (fstatfs(fd, &s) < 0) {
2806                         close_nointr_nofail(fd);
2807                         return -errno;
2808                 }
2809
2810                 if (!is_temporary_fs(&s)) {
2811                         log_error("Attempted to remove disk file system, and we can't allow that.");
2812                         close_nointr_nofail(fd);
2813                         return -EPERM;
2814                 }
2815         }
2816
2817         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2818         if (delete_root) {
2819
2820                 if (honour_sticky && file_is_priv_sticky(path) > 0)
2821                         return r;
2822
2823                 if (rmdir(path) < 0 && errno != ENOENT) {
2824                         if (r == 0)
2825                                 r = -errno;
2826                 }
2827         }
2828
2829         return r;
2830 }
2831
2832 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2833         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2834 }
2835
2836 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2837         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2838 }
2839
2840 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2841         assert(path);
2842
2843         /* Under the assumption that we are running privileged we
2844          * first change the access mode and only then hand out
2845          * ownership to avoid a window where access is too open. */
2846
2847         if (mode != (mode_t) -1)
2848                 if (chmod(path, mode) < 0)
2849                         return -errno;
2850
2851         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2852                 if (chown(path, uid, gid) < 0)
2853                         return -errno;
2854
2855         return 0;
2856 }
2857
2858 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2859         assert(fd >= 0);
2860
2861         /* Under the assumption that we are running privileged we
2862          * first change the access mode and only then hand out
2863          * ownership to avoid a window where access is too open. */
2864
2865         if (mode != (mode_t) -1)
2866                 if (fchmod(fd, mode) < 0)
2867                         return -errno;
2868
2869         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2870                 if (fchown(fd, uid, gid) < 0)
2871                         return -errno;
2872
2873         return 0;
2874 }
2875
2876 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2877         cpu_set_t *r;
2878         unsigned n = 1024;
2879
2880         /* Allocates the cpuset in the right size */
2881
2882         for (;;) {
2883                 if (!(r = CPU_ALLOC(n)))
2884                         return NULL;
2885
2886                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2887                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2888
2889                         if (ncpus)
2890                                 *ncpus = n;
2891
2892                         return r;
2893                 }
2894
2895                 CPU_FREE(r);
2896
2897                 if (errno != EINVAL)
2898                         return NULL;
2899
2900                 n *= 2;
2901         }
2902 }
2903
2904 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2905         static const char status_indent[] = "         "; /* "[" STATUS "] " */
2906         _cleanup_free_ char *s = NULL;
2907         _cleanup_close_ int fd = -1;
2908         struct iovec iovec[6] = {};
2909         int n = 0;
2910         static bool prev_ephemeral;
2911
2912         assert(format);
2913
2914         /* This is independent of logging, as status messages are
2915          * optional and go exclusively to the console. */
2916
2917         if (vasprintf(&s, format, ap) < 0)
2918                 return log_oom();
2919
2920         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2921         if (fd < 0)
2922                 return fd;
2923
2924         if (ellipse) {
2925                 char *e;
2926                 size_t emax, sl;
2927                 int c;
2928
2929                 c = fd_columns(fd);
2930                 if (c <= 0)
2931                         c = 80;
2932
2933                 sl = status ? sizeof(status_indent)-1 : 0;
2934
2935                 emax = c - sl - 1;
2936                 if (emax < 3)
2937                         emax = 3;
2938
2939                 e = ellipsize(s, emax, 75);
2940                 if (e) {
2941                         free(s);
2942                         s = e;
2943                 }
2944         }
2945
2946         if (prev_ephemeral)
2947                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2948         prev_ephemeral = ephemeral;
2949
2950         if (status) {
2951                 if (!isempty(status)) {
2952                         IOVEC_SET_STRING(iovec[n++], "[");
2953                         IOVEC_SET_STRING(iovec[n++], status);
2954                         IOVEC_SET_STRING(iovec[n++], "] ");
2955                 } else
2956                         IOVEC_SET_STRING(iovec[n++], status_indent);
2957         }
2958
2959         IOVEC_SET_STRING(iovec[n++], s);
2960         if (!ephemeral)
2961                 IOVEC_SET_STRING(iovec[n++], "\n");
2962
2963         if (writev(fd, iovec, n) < 0)
2964                 return -errno;
2965
2966         return 0;
2967 }
2968
2969 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2970         va_list ap;
2971         int r;
2972
2973         assert(format);
2974
2975         va_start(ap, format);
2976         r = status_vprintf(status, ellipse, ephemeral, format, ap);
2977         va_end(ap);
2978
2979         return r;
2980 }
2981
2982 int status_welcome(void) {
2983         _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
2984         int r;
2985
2986         r = parse_env_file("/etc/os-release", NEWLINE,
2987                            "PRETTY_NAME", &pretty_name,
2988                            "ANSI_COLOR", &ansi_color,
2989                            NULL);
2990
2991         if (r < 0 && r != -ENOENT)
2992                 log_warning("Failed to read /etc/os-release: %s", strerror(-r));
2993
2994         return status_printf(NULL, false, false,
2995                              "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
2996                              isempty(ansi_color) ? "1" : ansi_color,
2997                              isempty(pretty_name) ? "Linux" : pretty_name);
2998 }
2999
3000 char *replace_env(const char *format, char **env) {
3001         enum {
3002                 WORD,
3003                 CURLY,
3004                 VARIABLE
3005         } state = WORD;
3006
3007         const char *e, *word = format;
3008         char *r = NULL, *k;
3009
3010         assert(format);
3011
3012         for (e = format; *e; e ++) {
3013
3014                 switch (state) {
3015
3016                 case WORD:
3017                         if (*e == '$')
3018                                 state = CURLY;
3019                         break;
3020
3021                 case CURLY:
3022                         if (*e == '{') {
3023                                 if (!(k = strnappend(r, word, e-word-1)))
3024                                         goto fail;
3025
3026                                 free(r);
3027                                 r = k;
3028
3029                                 word = e-1;
3030                                 state = VARIABLE;
3031
3032                         } else if (*e == '$') {
3033                                 if (!(k = strnappend(r, word, e-word)))
3034                                         goto fail;
3035
3036                                 free(r);
3037                                 r = k;
3038
3039                                 word = e+1;
3040                                 state = WORD;
3041                         } else
3042                                 state = WORD;
3043                         break;
3044
3045                 case VARIABLE:
3046                         if (*e == '}') {
3047                                 const char *t;
3048
3049                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3050
3051                                 k = strappend(r, t);
3052                                 if (!k)
3053                                         goto fail;
3054
3055                                 free(r);
3056                                 r = k;
3057
3058                                 word = e+1;
3059                                 state = WORD;
3060                         }
3061                         break;
3062                 }
3063         }
3064
3065         if (!(k = strnappend(r, word, e-word)))
3066                 goto fail;
3067
3068         free(r);
3069         return k;
3070
3071 fail:
3072         free(r);
3073         return NULL;
3074 }
3075
3076 char **replace_env_argv(char **argv, char **env) {
3077         char **r, **i;
3078         unsigned k = 0, l = 0;
3079
3080         l = strv_length(argv);
3081
3082         if (!(r = new(char*, l+1)))
3083                 return NULL;
3084
3085         STRV_FOREACH(i, argv) {
3086
3087                 /* If $FOO appears as single word, replace it by the split up variable */
3088                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3089                         char *e;
3090                         char **w, **m;
3091                         unsigned q;
3092
3093                         e = strv_env_get(env, *i+1);
3094                         if (e) {
3095
3096                                 if (!(m = strv_split_quoted(e))) {
3097                                         r[k] = NULL;
3098                                         strv_free(r);
3099                                         return NULL;
3100                                 }
3101                         } else
3102                                 m = NULL;
3103
3104                         q = strv_length(m);
3105                         l = l + q - 1;
3106
3107                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3108                                 r[k] = NULL;
3109                                 strv_free(r);
3110                                 strv_free(m);
3111                                 return NULL;
3112                         }
3113
3114                         r = w;
3115                         if (m) {
3116                                 memcpy(r + k, m, q * sizeof(char*));
3117                                 free(m);
3118                         }
3119
3120                         k += q;
3121                         continue;
3122                 }
3123
3124                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3125                 if (!(r[k++] = replace_env(*i, env))) {
3126                         strv_free(r);
3127                         return NULL;
3128                 }
3129         }
3130
3131         r[k] = NULL;
3132         return r;
3133 }
3134
3135 int fd_columns(int fd) {
3136         struct winsize ws = {};
3137
3138         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3139                 return -errno;
3140
3141         if (ws.ws_col <= 0)
3142                 return -EIO;
3143
3144         return ws.ws_col;
3145 }
3146
3147 unsigned columns(void) {
3148         const char *e;
3149         int c;
3150
3151         if (_likely_(cached_columns > 0))
3152                 return cached_columns;
3153
3154         c = 0;
3155         e = getenv("COLUMNS");
3156         if (e)
3157                 safe_atoi(e, &c);
3158
3159         if (c <= 0)
3160                 c = fd_columns(STDOUT_FILENO);
3161
3162         if (c <= 0)
3163                 c = 80;
3164
3165         cached_columns = c;
3166         return c;
3167 }
3168
3169 int fd_lines(int fd) {
3170         struct winsize ws = {};
3171
3172         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3173                 return -errno;
3174
3175         if (ws.ws_row <= 0)
3176                 return -EIO;
3177
3178         return ws.ws_row;
3179 }
3180
3181 unsigned lines(void) {
3182         const char *e;
3183         unsigned l;
3184
3185         if (_likely_(cached_lines > 0))
3186                 return cached_lines;
3187
3188         l = 0;
3189         e = getenv("LINES");
3190         if (e)
3191                 safe_atou(e, &l);
3192
3193         if (l <= 0)
3194                 l = fd_lines(STDOUT_FILENO);
3195
3196         if (l <= 0)
3197                 l = 24;
3198
3199         cached_lines = l;
3200         return cached_lines;
3201 }
3202
3203 /* intended to be used as a SIGWINCH sighandler */
3204 void columns_lines_cache_reset(int signum) {
3205         cached_columns = 0;
3206         cached_lines = 0;
3207 }
3208
3209 bool on_tty(void) {
3210         static int cached_on_tty = -1;
3211
3212         if (_unlikely_(cached_on_tty < 0))
3213                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3214
3215         return cached_on_tty;
3216 }
3217
3218 int running_in_chroot(void) {
3219         struct stat a = {}, b = {};
3220
3221         /* Only works as root */
3222         if (stat("/proc/1/root", &a) < 0)
3223                 return -errno;
3224
3225         if (stat("/", &b) < 0)
3226                 return -errno;
3227
3228         return
3229                 a.st_dev != b.st_dev ||
3230                 a.st_ino != b.st_ino;
3231 }
3232
3233 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3234         size_t x;
3235         char *r;
3236
3237         assert(s);
3238         assert(percent <= 100);
3239         assert(new_length >= 3);
3240
3241         if (old_length <= 3 || old_length <= new_length)
3242                 return strndup(s, old_length);
3243
3244         r = new0(char, new_length+1);
3245         if (!r)
3246                 return NULL;
3247
3248         x = (new_length * percent) / 100;
3249
3250         if (x > new_length - 3)
3251                 x = new_length - 3;
3252
3253         memcpy(r, s, x);
3254         r[x] = '.';
3255         r[x+1] = '.';
3256         r[x+2] = '.';
3257         memcpy(r + x + 3,
3258                s + old_length - (new_length - x - 3),
3259                new_length - x - 3);
3260
3261         return r;
3262 }
3263
3264 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3265         size_t x;
3266         char *e;
3267         const char *i, *j;
3268         unsigned k, len, len2;
3269
3270         assert(s);
3271         assert(percent <= 100);
3272         assert(new_length >= 3);
3273
3274         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3275         if (ascii_is_valid(s))
3276                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3277
3278         if (old_length <= 3 || old_length <= new_length)
3279                 return strndup(s, old_length);
3280
3281         x = (new_length * percent) / 100;
3282
3283         if (x > new_length - 3)
3284                 x = new_length - 3;
3285
3286         k = 0;
3287         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3288                 int c;
3289
3290                 c = utf8_encoded_to_unichar(i);
3291                 if (c < 0)
3292                         return NULL;
3293                 k += unichar_iswide(c) ? 2 : 1;
3294         }
3295
3296         if (k > x) /* last character was wide and went over quota */
3297                 x ++;
3298
3299         for (j = s + old_length; k < new_length && j > i; ) {
3300                 int c;
3301
3302                 j = utf8_prev_char(j);
3303                 c = utf8_encoded_to_unichar(j);
3304                 if (c < 0)
3305                         return NULL;
3306                 k += unichar_iswide(c) ? 2 : 1;
3307         }
3308         assert(i <= j);
3309
3310         /* we don't actually need to ellipsize */
3311         if (i == j)
3312                 return memdup(s, old_length + 1);
3313
3314         /* make space for ellipsis */
3315         j = utf8_next_char(j);
3316
3317         len = i - s;
3318         len2 = s + old_length - j;
3319         e = new(char, len + 3 + len2 + 1);
3320         if (!e)
3321                 return NULL;
3322
3323         /*
3324         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3325                old_length, new_length, x, len, len2, k);
3326         */
3327
3328         memcpy(e, s, len);
3329         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3330         e[len + 1] = 0x80;
3331         e[len + 2] = 0xa6;
3332
3333         memcpy(e + len + 3, j, len2 + 1);
3334
3335         return e;
3336 }
3337
3338 char *ellipsize(const char *s, size_t length, unsigned percent) {
3339         return ellipsize_mem(s, strlen(s), length, percent);
3340 }
3341
3342 int touch(const char *path) {
3343         int fd;
3344
3345         assert(path);
3346
3347         /* This just opens the file for writing, ensuring it
3348          * exists. It doesn't call utimensat() the way /usr/bin/touch
3349          * does it. */
3350
3351         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3352         if (fd < 0)
3353                 return -errno;
3354
3355         close_nointr_nofail(fd);
3356         return 0;
3357 }
3358
3359 char *unquote(const char *s, const char* quotes) {
3360         size_t l;
3361         assert(s);
3362
3363         /* This is rather stupid, simply removes the heading and
3364          * trailing quotes if there is one. Doesn't care about
3365          * escaping or anything. We should make this smarter one
3366          * day...*/
3367
3368         l = strlen(s);
3369         if (l < 2)
3370                 return strdup(s);
3371
3372         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3373                 return strndup(s+1, l-2);
3374
3375         return strdup(s);
3376 }
3377
3378 char *normalize_env_assignment(const char *s) {
3379         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3380         char *eq, *r;
3381
3382         eq = strchr(s, '=');
3383         if (!eq) {
3384                 char *t;
3385
3386                 r = strdup(s);
3387                 if (!r)
3388                         return NULL;
3389
3390                 t = strstrip(r);
3391                 if (t == r)
3392                         return r;
3393
3394                 memmove(r, t, strlen(t) + 1);
3395                 return r;
3396         }
3397
3398         name = strndup(s, eq - s);
3399         if (!name)
3400                 return NULL;
3401
3402         p = strdup(eq + 1);
3403         if (!p)
3404                 return NULL;
3405
3406         value = unquote(strstrip(p), QUOTES);
3407         if (!value)
3408                 return NULL;
3409
3410         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3411                 r = NULL;
3412
3413         return r;
3414 }
3415
3416 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3417         siginfo_t dummy;
3418
3419         assert(pid >= 1);
3420
3421         if (!status)
3422                 status = &dummy;
3423
3424         for (;;) {
3425                 zero(*status);
3426
3427                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3428
3429                         if (errno == EINTR)
3430                                 continue;
3431
3432                         return -errno;
3433                 }
3434
3435                 return 0;
3436         }
3437 }
3438
3439 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3440         int r;
3441         siginfo_t status;
3442
3443         assert(name);
3444         assert(pid > 1);
3445
3446         r = wait_for_terminate(pid, &status);
3447         if (r < 0) {
3448                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3449                 return r;
3450         }
3451
3452         if (status.si_code == CLD_EXITED) {
3453                 if (status.si_status != 0) {
3454                         log_warning("%s failed with error code %i.", name, status.si_status);
3455                         return status.si_status;
3456                 }
3457
3458                 log_debug("%s succeeded.", name);
3459                 return 0;
3460
3461         } else if (status.si_code == CLD_KILLED ||
3462                    status.si_code == CLD_DUMPED) {
3463
3464                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3465                 return -EPROTO;
3466         }
3467
3468         log_warning("%s failed due to unknown reason.", name);
3469         return -EPROTO;
3470 }
3471
3472 noreturn void freeze(void) {
3473
3474         /* Make sure nobody waits for us on a socket anymore */
3475         close_all_fds(NULL, 0);
3476
3477         sync();
3478
3479         for (;;)
3480                 pause();
3481 }
3482
3483 bool null_or_empty(struct stat *st) {
3484         assert(st);
3485
3486         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3487                 return true;
3488
3489         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3490                 return true;
3491
3492         return false;
3493 }
3494
3495 int null_or_empty_path(const char *fn) {
3496         struct stat st;
3497
3498         assert(fn);
3499
3500         if (stat(fn, &st) < 0)
3501                 return -errno;
3502
3503         return null_or_empty(&st);
3504 }
3505
3506 DIR *xopendirat(int fd, const char *name, int flags) {
3507         int nfd;
3508         DIR *d;
3509
3510         assert(!(flags & O_CREAT));
3511
3512         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3513         if (nfd < 0)
3514                 return NULL;
3515
3516         d = fdopendir(nfd);
3517         if (!d) {
3518                 close_nointr_nofail(nfd);
3519                 return NULL;
3520         }
3521
3522         return d;
3523 }
3524
3525 int signal_from_string_try_harder(const char *s) {
3526         int signo;
3527         assert(s);
3528
3529         signo = signal_from_string(s);
3530         if (signo <= 0)
3531                 if (startswith(s, "SIG"))
3532                         return signal_from_string(s+3);
3533
3534         return signo;
3535 }
3536
3537 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3538         _cleanup_free_ char *t = NULL, *u = NULL;
3539         char *dn;
3540         size_t enc_len;
3541
3542         u = unquote(tagvalue, "\"\'");
3543         if (u == NULL)
3544                 return NULL;
3545
3546         enc_len = strlen(u) * 4 + 1;
3547         t = new(char, enc_len);
3548         if (t == NULL)
3549                 return NULL;
3550
3551         if (encode_devnode_name(u, t, enc_len) < 0)
3552                 return NULL;
3553
3554         if (asprintf(&dn, "/dev/disk/by-%s/%s", by, t) < 0)
3555                 return NULL;
3556
3557         return dn;
3558 }
3559
3560 char *fstab_node_to_udev_node(const char *p) {
3561         assert(p);
3562
3563         if (startswith(p, "LABEL="))
3564                 return tag_to_udev_node(p+6, "label");
3565
3566         if (startswith(p, "UUID="))
3567                 return tag_to_udev_node(p+5, "uuid");
3568
3569         if (startswith(p, "PARTUUID="))
3570                 return tag_to_udev_node(p+9, "partuuid");
3571
3572         if (startswith(p, "PARTLABEL="))
3573                 return tag_to_udev_node(p+10, "partlabel");
3574
3575         return strdup(p);
3576 }
3577
3578 bool tty_is_vc(const char *tty) {
3579         assert(tty);
3580
3581         if (startswith(tty, "/dev/"))
3582                 tty += 5;
3583
3584         return vtnr_from_tty(tty) >= 0;
3585 }
3586
3587 bool tty_is_console(const char *tty) {
3588         assert(tty);
3589
3590         if (startswith(tty, "/dev/"))
3591                 tty += 5;
3592
3593         return streq(tty, "console");
3594 }
3595
3596 int vtnr_from_tty(const char *tty) {
3597         int i, r;
3598
3599         assert(tty);
3600
3601         if (startswith(tty, "/dev/"))
3602                 tty += 5;
3603
3604         if (!startswith(tty, "tty") )
3605                 return -EINVAL;
3606
3607         if (tty[3] < '0' || tty[3] > '9')
3608                 return -EINVAL;
3609
3610         r = safe_atoi(tty+3, &i);
3611         if (r < 0)
3612                 return r;
3613
3614         if (i < 0 || i > 63)
3615                 return -EINVAL;
3616
3617         return i;
3618 }
3619
3620 char *resolve_dev_console(char **active) {
3621         char *tty;
3622
3623         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3624          * (i.e. not read-only-mounted which is a sign for container setups) */
3625
3626         if (path_is_read_only_fs("/sys") > 0)
3627                 return NULL;
3628
3629         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3630                 return NULL;
3631
3632         /* If multiple log outputs are configured the last one is what
3633          * /dev/console points to */
3634         tty = strrchr(*active, ' ');
3635         if (tty)
3636                 tty++;
3637         else
3638                 tty = *active;
3639
3640         if (streq(tty, "tty0")) {
3641                 char *tmp;
3642
3643                 /* Get the active VC (e.g. tty1) */
3644                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3645                         free(*active);
3646                         tty = *active = tmp;
3647                 }
3648         }
3649
3650         return tty;
3651 }
3652
3653 bool tty_is_vc_resolve(const char *tty) {
3654         _cleanup_free_ char *active = NULL;
3655
3656         assert(tty);
3657
3658         if (startswith(tty, "/dev/"))
3659                 tty += 5;
3660
3661         if (streq(tty, "console")) {
3662                 tty = resolve_dev_console(&active);
3663                 if (!tty)
3664                         return false;
3665         }
3666
3667         return tty_is_vc(tty);
3668 }
3669
3670 const char *default_term_for_tty(const char *tty) {
3671         assert(tty);
3672
3673         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3674 }
3675
3676 bool dirent_is_file(const struct dirent *de) {
3677         assert(de);
3678
3679         if (ignore_file(de->d_name))
3680                 return false;
3681
3682         if (de->d_type != DT_REG &&
3683             de->d_type != DT_LNK &&
3684             de->d_type != DT_UNKNOWN)
3685                 return false;
3686
3687         return true;
3688 }
3689
3690 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3691         assert(de);
3692
3693         if (de->d_type != DT_REG &&
3694             de->d_type != DT_LNK &&
3695             de->d_type != DT_UNKNOWN)
3696                 return false;
3697
3698         if (ignore_file_allow_backup(de->d_name))
3699                 return false;
3700
3701         return endswith(de->d_name, suffix);
3702 }
3703
3704 void execute_directory(const char *directory, DIR *d, char *argv[]) {
3705         DIR *_d = NULL;
3706         struct dirent *de;
3707         Hashmap *pids = NULL;
3708
3709         assert(directory);
3710
3711         /* Executes all binaries in a directory in parallel and
3712          * waits for them to finish. */
3713
3714         if (!d) {
3715                 if (!(_d = opendir(directory))) {
3716
3717                         if (errno == ENOENT)
3718                                 return;
3719
3720                         log_error("Failed to enumerate directory %s: %m", directory);
3721                         return;
3722                 }
3723
3724                 d = _d;
3725         }
3726
3727         if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
3728                 log_error("Failed to allocate set.");
3729                 goto finish;
3730         }
3731
3732         while ((de = readdir(d))) {
3733                 char *path;
3734                 pid_t pid;
3735                 int k;
3736
3737                 if (!dirent_is_file(de))
3738                         continue;
3739
3740                 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3741                         log_oom();
3742                         continue;
3743                 }
3744
3745                 if ((pid = fork()) < 0) {
3746                         log_error("Failed to fork: %m");
3747                         free(path);
3748                         continue;
3749                 }
3750
3751                 if (pid == 0) {
3752                         char *_argv[2];
3753                         /* Child */
3754
3755                         if (!argv) {
3756                                 _argv[0] = path;
3757                                 _argv[1] = NULL;
3758                                 argv = _argv;
3759                         } else
3760                                 argv[0] = path;
3761
3762                         execv(path, argv);
3763
3764                         log_error("Failed to execute %s: %m", path);
3765                         _exit(EXIT_FAILURE);
3766                 }
3767
3768                 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
3769
3770                 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
3771                         log_error("Failed to add PID to set: %s", strerror(-k));
3772                         free(path);
3773                 }
3774         }
3775
3776         while (!hashmap_isempty(pids)) {
3777                 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
3778                 siginfo_t si = {};
3779                 char *path;
3780
3781                 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
3782
3783                         if (errno == EINTR)
3784                                 continue;
3785
3786                         log_error("waitid() failed: %m");
3787                         goto finish;
3788                 }
3789
3790                 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
3791                         if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
3792                                 if (si.si_code == CLD_EXITED)
3793                                         log_error("%s exited with exit status %i.", path, si.si_status);
3794                                 else
3795                                         log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
3796                         } else
3797                                 log_debug("%s exited successfully.", path);
3798
3799                         free(path);
3800                 }
3801         }
3802
3803 finish:
3804         if (_d)
3805                 closedir(_d);
3806
3807         if (pids)
3808                 hashmap_free_free(pids);
3809 }
3810
3811 int kill_and_sigcont(pid_t pid, int sig) {
3812         int r;
3813
3814         r = kill(pid, sig) < 0 ? -errno : 0;
3815
3816         if (r >= 0)
3817                 kill(pid, SIGCONT);
3818
3819         return r;
3820 }
3821
3822 bool nulstr_contains(const char*nulstr, const char *needle) {
3823         const char *i;
3824
3825         if (!nulstr)
3826                 return false;
3827
3828         NULSTR_FOREACH(i, nulstr)
3829                 if (streq(i, needle))
3830                         return true;
3831
3832         return false;
3833 }
3834
3835 bool plymouth_running(void) {
3836         return access("/run/plymouth/pid", F_OK) >= 0;
3837 }
3838
3839 char* strshorten(char *s, size_t l) {
3840         assert(s);
3841
3842         if (l < strlen(s))
3843                 s[l] = 0;
3844
3845         return s;
3846 }
3847
3848 static bool hostname_valid_char(char c) {
3849         return
3850                 (c >= 'a' && c <= 'z') ||
3851                 (c >= 'A' && c <= 'Z') ||
3852                 (c >= '0' && c <= '9') ||
3853                 c == '-' ||
3854                 c == '_' ||
3855                 c == '.';
3856 }
3857
3858 bool hostname_is_valid(const char *s) {
3859         const char *p;
3860         bool dot;
3861
3862         if (isempty(s))
3863                 return false;
3864
3865         for (p = s, dot = true; *p; p++) {
3866                 if (*p == '.') {
3867                         if (dot)
3868                                 return false;
3869
3870                         dot = true;
3871                 } else {
3872                         if (!hostname_valid_char(*p))
3873                                 return false;
3874
3875                         dot = false;
3876                 }
3877         }
3878
3879         if (dot)
3880                 return false;
3881
3882         if (p-s > HOST_NAME_MAX)
3883                 return false;
3884
3885         return true;
3886 }
3887
3888 char* hostname_cleanup(char *s, bool lowercase) {
3889         char *p, *d;
3890         bool dot;
3891
3892         for (p = s, d = s, dot = true; *p; p++) {
3893                 if (*p == '.') {
3894                         if (dot)
3895                                 continue;
3896
3897                         *(d++) = '.';
3898                         dot = true;
3899                 } else if (hostname_valid_char(*p)) {
3900                         *(d++) = lowercase ? tolower(*p) : *p;
3901                         dot = false;
3902                 }
3903
3904         }
3905
3906         if (dot && d > s)
3907                 d[-1] = 0;
3908         else
3909                 *d = 0;
3910
3911         strshorten(s, HOST_NAME_MAX);
3912
3913         return s;
3914 }
3915
3916 int pipe_eof(int fd) {
3917         int r;
3918         struct pollfd pollfd = {
3919                 .fd = fd,
3920                 .events = POLLIN|POLLHUP,
3921         };
3922
3923         r = poll(&pollfd, 1, 0);
3924         if (r < 0)
3925                 return -errno;
3926
3927         if (r == 0)
3928                 return 0;
3929
3930         return pollfd.revents & POLLHUP;
3931 }
3932
3933 int fd_wait_for_event(int fd, int event, usec_t t) {
3934         int r;
3935         struct pollfd pollfd = {
3936                 .fd = fd,
3937                 .events = event,
3938         };
3939
3940         r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
3941         if (r < 0)
3942                 return -errno;
3943
3944         if (r == 0)
3945                 return 0;
3946
3947         return pollfd.revents;
3948 }
3949
3950 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3951         FILE *f;
3952         char *t;
3953         const char *fn;
3954         size_t k;
3955         int fd;
3956
3957         assert(path);
3958         assert(_f);
3959         assert(_temp_path);
3960
3961         t = new(char, strlen(path) + 1 + 6 + 1);
3962         if (!t)
3963                 return -ENOMEM;
3964
3965         fn = basename(path);
3966         k = fn - path;
3967         memcpy(t, path, k);
3968         t[k] = '.';
3969         stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
3970
3971         fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
3972         if (fd < 0) {
3973                 free(t);
3974                 return -errno;
3975         }
3976
3977         f = fdopen(fd, "we");
3978         if (!f) {
3979                 unlink(t);
3980                 free(t);
3981                 return -errno;
3982         }
3983
3984         *_f = f;
3985         *_temp_path = t;
3986
3987         return 0;
3988 }
3989
3990 int terminal_vhangup_fd(int fd) {
3991         assert(fd >= 0);
3992
3993         if (ioctl(fd, TIOCVHANGUP) < 0)
3994                 return -errno;
3995
3996         return 0;
3997 }
3998
3999 int terminal_vhangup(const char *name) {
4000         int fd, r;
4001
4002         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4003         if (fd < 0)
4004                 return fd;
4005
4006         r = terminal_vhangup_fd(fd);
4007         close_nointr_nofail(fd);
4008
4009         return r;
4010 }
4011
4012 int vt_disallocate(const char *name) {
4013         int fd, r;
4014         unsigned u;
4015
4016         /* Deallocate the VT if possible. If not possible
4017          * (i.e. because it is the active one), at least clear it
4018          * entirely (including the scrollback buffer) */
4019
4020         if (!startswith(name, "/dev/"))
4021                 return -EINVAL;
4022
4023         if (!tty_is_vc(name)) {
4024                 /* So this is not a VT. I guess we cannot deallocate
4025                  * it then. But let's at least clear the screen */
4026
4027                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4028                 if (fd < 0)
4029                         return fd;
4030
4031                 loop_write(fd,
4032                            "\033[r"    /* clear scrolling region */
4033                            "\033[H"    /* move home */
4034                            "\033[2J",  /* clear screen */
4035                            10, false);
4036                 close_nointr_nofail(fd);
4037
4038                 return 0;
4039         }
4040
4041         if (!startswith(name, "/dev/tty"))
4042                 return -EINVAL;
4043
4044         r = safe_atou(name+8, &u);
4045         if (r < 0)
4046                 return r;
4047
4048         if (u <= 0)
4049                 return -EINVAL;
4050
4051         /* Try to deallocate */
4052         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4053         if (fd < 0)
4054                 return fd;
4055
4056         r = ioctl(fd, VT_DISALLOCATE, u);
4057         close_nointr_nofail(fd);
4058
4059         if (r >= 0)
4060                 return 0;
4061
4062         if (errno != EBUSY)
4063                 return -errno;
4064
4065         /* Couldn't deallocate, so let's clear it fully with
4066          * scrollback */
4067         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4068         if (fd < 0)
4069                 return fd;
4070
4071         loop_write(fd,
4072                    "\033[r"   /* clear scrolling region */
4073                    "\033[H"   /* move home */
4074                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4075                    10, false);
4076         close_nointr_nofail(fd);
4077
4078         return 0;
4079 }
4080
4081 int copy_file(const char *from, const char *to, int flags) {
4082         _cleanup_close_ int fdf = -1;
4083         int r, fdt;
4084
4085         assert(from);
4086         assert(to);
4087
4088         fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4089         if (fdf < 0)
4090                 return -errno;
4091
4092         fdt = open(to, flags|O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
4093         if (fdt < 0)
4094                 return -errno;
4095
4096         for (;;) {
4097                 char buf[PIPE_BUF];
4098                 ssize_t n, k;
4099
4100                 n = read(fdf, buf, sizeof(buf));
4101                 if (n < 0) {
4102                         r = -errno;
4103
4104                         close_nointr(fdt);
4105                         unlink(to);
4106
4107                         return r;
4108                 }
4109
4110                 if (n == 0)
4111                         break;
4112
4113                 errno = 0;
4114                 k = loop_write(fdt, buf, n, false);
4115                 if (n != k) {
4116                         r = k < 0 ? k : (errno ? -errno : -EIO);
4117
4118                         close_nointr(fdt);
4119                         unlink(to);
4120
4121                         return r;
4122                 }
4123         }
4124
4125         r = close_nointr(fdt);
4126
4127         if (r < 0) {
4128                 unlink(to);
4129                 return r;
4130         }
4131
4132         return 0;
4133 }
4134
4135 int symlink_atomic(const char *from, const char *to) {
4136         char *x;
4137         _cleanup_free_ char *t;
4138         const char *fn;
4139         size_t k;
4140         unsigned long long ull;
4141         unsigned i;
4142         int r;
4143
4144         assert(from);
4145         assert(to);
4146
4147         t = new(char, strlen(to) + 1 + 16 + 1);
4148         if (!t)
4149                 return -ENOMEM;
4150
4151         fn = basename(to);
4152         k = fn-to;
4153         memcpy(t, to, k);
4154         t[k] = '.';
4155         x = stpcpy(t+k+1, fn);
4156
4157         ull = random_ull();
4158         for (i = 0; i < 16; i++) {
4159                 *(x++) = hexchar(ull & 0xF);
4160                 ull >>= 4;
4161         }
4162
4163         *x = 0;
4164
4165         if (symlink(from, t) < 0)
4166                 return -errno;
4167
4168         if (rename(t, to) < 0) {
4169                 r = -errno;
4170                 unlink(t);
4171                 return r;
4172         }
4173
4174         return 0;
4175 }
4176
4177 bool display_is_local(const char *display) {
4178         assert(display);
4179
4180         return
4181                 display[0] == ':' &&
4182                 display[1] >= '0' &&
4183                 display[1] <= '9';
4184 }
4185
4186 int socket_from_display(const char *display, char **path) {
4187         size_t k;
4188         char *f, *c;
4189
4190         assert(display);
4191         assert(path);
4192
4193         if (!display_is_local(display))
4194                 return -EINVAL;
4195
4196         k = strspn(display+1, "0123456789");
4197
4198         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
4199         if (!f)
4200                 return -ENOMEM;
4201
4202         c = stpcpy(f, "/tmp/.X11-unix/X");
4203         memcpy(c, display+1, k);
4204         c[k] = 0;
4205
4206         *path = f;
4207
4208         return 0;
4209 }
4210
4211 int get_user_creds(
4212                 const char **username,
4213                 uid_t *uid, gid_t *gid,
4214                 const char **home,
4215                 const char **shell) {
4216
4217         struct passwd *p;
4218         uid_t u;
4219
4220         assert(username);
4221         assert(*username);
4222
4223         /* We enforce some special rules for uid=0: in order to avoid
4224          * NSS lookups for root we hardcode its data. */
4225
4226         if (streq(*username, "root") || streq(*username, "0")) {
4227                 *username = "root";
4228
4229                 if (uid)
4230                         *uid = 0;
4231
4232                 if (gid)
4233                         *gid = 0;
4234
4235                 if (home)
4236                         *home = "/root";
4237
4238                 if (shell)
4239                         *shell = "/bin/sh";
4240
4241                 return 0;
4242         }
4243
4244         if (parse_uid(*username, &u) >= 0) {
4245                 errno = 0;
4246                 p = getpwuid(u);
4247
4248                 /* If there are multiple users with the same id, make
4249                  * sure to leave $USER to the configured value instead
4250                  * of the first occurrence in the database. However if
4251                  * the uid was configured by a numeric uid, then let's
4252                  * pick the real username from /etc/passwd. */
4253                 if (p)
4254                         *username = p->pw_name;
4255         } else {
4256                 errno = 0;
4257                 p = getpwnam(*username);
4258         }
4259
4260         if (!p)
4261                 return errno > 0 ? -errno : -ESRCH;
4262
4263         if (uid)
4264                 *uid = p->pw_uid;
4265
4266         if (gid)
4267                 *gid = p->pw_gid;
4268
4269         if (home)
4270                 *home = p->pw_dir;
4271
4272         if (shell)
4273                 *shell = p->pw_shell;
4274
4275         return 0;
4276 }
4277
4278 char* uid_to_name(uid_t uid) {
4279         struct passwd *p;
4280         char *r;
4281
4282         if (uid == 0)
4283                 return strdup("root");
4284
4285         p = getpwuid(uid);
4286         if (p)
4287                 return strdup(p->pw_name);
4288
4289         if (asprintf(&r, "%lu", (unsigned long) uid) < 0)
4290                 return NULL;
4291
4292         return r;
4293 }
4294
4295 char* gid_to_name(gid_t gid) {
4296         struct group *p;
4297         char *r;
4298
4299         if (gid == 0)
4300                 return strdup("root");
4301
4302         p = getgrgid(gid);
4303         if (p)
4304                 return strdup(p->gr_name);
4305
4306         if (asprintf(&r, "%lu", (unsigned long) gid) < 0)
4307                 return NULL;
4308
4309         return r;
4310 }
4311
4312 int get_group_creds(const char **groupname, gid_t *gid) {
4313         struct group *g;
4314         gid_t id;
4315
4316         assert(groupname);
4317
4318         /* We enforce some special rules for gid=0: in order to avoid
4319          * NSS lookups for root we hardcode its data. */
4320
4321         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4322                 *groupname = "root";
4323
4324                 if (gid)
4325                         *gid = 0;
4326
4327                 return 0;
4328         }
4329
4330         if (parse_gid(*groupname, &id) >= 0) {
4331                 errno = 0;
4332                 g = getgrgid(id);
4333
4334                 if (g)
4335                         *groupname = g->gr_name;
4336         } else {
4337                 errno = 0;
4338                 g = getgrnam(*groupname);
4339         }
4340
4341         if (!g)
4342                 return errno > 0 ? -errno : -ESRCH;
4343
4344         if (gid)
4345                 *gid = g->gr_gid;
4346
4347         return 0;
4348 }
4349
4350 int in_gid(gid_t gid) {
4351         gid_t *gids;
4352         int ngroups_max, r, i;
4353
4354         if (getgid() == gid)
4355                 return 1;
4356
4357         if (getegid() == gid)
4358                 return 1;
4359
4360         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4361         assert(ngroups_max > 0);
4362
4363         gids = alloca(sizeof(gid_t) * ngroups_max);
4364
4365         r = getgroups(ngroups_max, gids);
4366         if (r < 0)
4367                 return -errno;
4368
4369         for (i = 0; i < r; i++)
4370                 if (gids[i] == gid)
4371                         return 1;
4372
4373         return 0;
4374 }
4375
4376 int in_group(const char *name) {
4377         int r;
4378         gid_t gid;
4379
4380         r = get_group_creds(&name, &gid);
4381         if (r < 0)
4382                 return r;
4383
4384         return in_gid(gid);
4385 }
4386
4387 int glob_exists(const char *path) {
4388         _cleanup_globfree_ glob_t g = {};
4389         int k;
4390
4391         assert(path);
4392
4393         errno = 0;
4394         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4395
4396         if (k == GLOB_NOMATCH)
4397                 return 0;
4398         else if (k == GLOB_NOSPACE)
4399                 return -ENOMEM;
4400         else if (k == 0)
4401                 return !strv_isempty(g.gl_pathv);
4402         else
4403                 return errno ? -errno : -EIO;
4404 }
4405
4406 int glob_extend(char ***strv, const char *path) {
4407         _cleanup_globfree_ glob_t g = {};
4408         int k;
4409         char **p;
4410
4411         errno = 0;
4412         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4413
4414         if (k == GLOB_NOMATCH)
4415                 return -ENOENT;
4416         else if (k == GLOB_NOSPACE)
4417                 return -ENOMEM;
4418         else if (k != 0 || strv_isempty(g.gl_pathv))
4419                 return errno ? -errno : -EIO;
4420
4421         STRV_FOREACH(p, g.gl_pathv) {
4422                 k = strv_extend(strv, *p);
4423                 if (k < 0)
4424                         break;
4425         }
4426
4427         return k;
4428 }
4429
4430 int dirent_ensure_type(DIR *d, struct dirent *de) {
4431         struct stat st;
4432
4433         assert(d);
4434         assert(de);
4435
4436         if (de->d_type != DT_UNKNOWN)
4437                 return 0;
4438
4439         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4440                 return -errno;
4441
4442         de->d_type =
4443                 S_ISREG(st.st_mode)  ? DT_REG  :
4444                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4445                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4446                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4447                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4448                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4449                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4450                                        DT_UNKNOWN;
4451
4452         return 0;
4453 }
4454
4455 int in_search_path(const char *path, char **search) {
4456         char **i;
4457         _cleanup_free_ char *parent = NULL;
4458         int r;
4459
4460         r = path_get_parent(path, &parent);
4461         if (r < 0)
4462                 return r;
4463
4464         STRV_FOREACH(i, search)
4465                 if (path_equal(parent, *i))
4466                         return 1;
4467
4468         return 0;
4469 }
4470
4471 int get_files_in_directory(const char *path, char ***list) {
4472         _cleanup_closedir_ DIR *d = NULL;
4473         size_t bufsize = 0, n = 0;
4474         _cleanup_strv_free_ char **l = NULL;
4475
4476         assert(path);
4477
4478         /* Returns all files in a directory in *list, and the number
4479          * of files as return value. If list is NULL returns only the
4480          * number. */
4481
4482         d = opendir(path);
4483         if (!d)
4484                 return -errno;
4485
4486         for (;;) {
4487                 struct dirent *de;
4488
4489                 errno = 0;
4490                 de = readdir(d);
4491                 if (!de && errno != 0)
4492                         return -errno;
4493                 if (!de)
4494                         break;
4495
4496                 dirent_ensure_type(d, de);
4497
4498                 if (!dirent_is_file(de))
4499                         continue;
4500
4501                 if (list) {
4502                         /* one extra slot is needed for the terminating NULL */
4503                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
4504                                 return -ENOMEM;
4505
4506                         l[n] = strdup(de->d_name);
4507                         if (!l[n])
4508                                 return -ENOMEM;
4509
4510                         l[++n] = NULL;
4511                 } else
4512                         n++;
4513         }
4514
4515         if (list) {
4516                 *list = l;
4517                 l = NULL; /* avoid freeing */
4518         }
4519
4520         return n;
4521 }
4522
4523 char *strjoin(const char *x, ...) {
4524         va_list ap;
4525         size_t l;
4526         char *r, *p;
4527
4528         va_start(ap, x);
4529
4530         if (x) {
4531                 l = strlen(x);
4532
4533                 for (;;) {
4534                         const char *t;
4535                         size_t n;
4536
4537                         t = va_arg(ap, const char *);
4538                         if (!t)
4539                                 break;
4540
4541                         n = strlen(t);
4542                         if (n > ((size_t) -1) - l) {
4543                                 va_end(ap);
4544                                 return NULL;
4545                         }
4546
4547                         l += n;
4548                 }
4549         } else
4550                 l = 0;
4551
4552         va_end(ap);
4553
4554         r = new(char, l+1);
4555         if (!r)
4556                 return NULL;
4557
4558         if (x) {
4559                 p = stpcpy(r, x);
4560
4561                 va_start(ap, x);
4562
4563                 for (;;) {
4564                         const char *t;
4565
4566                         t = va_arg(ap, const char *);
4567                         if (!t)
4568                                 break;
4569
4570                         p = stpcpy(p, t);
4571                 }
4572
4573                 va_end(ap);
4574         } else
4575                 r[0] = 0;
4576
4577         return r;
4578 }
4579
4580 bool is_main_thread(void) {
4581         static thread_local int cached = 0;
4582
4583         if (_unlikely_(cached == 0))
4584                 cached = getpid() == gettid() ? 1 : -1;
4585
4586         return cached > 0;
4587 }
4588
4589 int block_get_whole_disk(dev_t d, dev_t *ret) {
4590         char *p, *s;
4591         int r;
4592         unsigned n, m;
4593
4594         assert(ret);
4595
4596         /* If it has a queue this is good enough for us */
4597         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4598                 return -ENOMEM;
4599
4600         r = access(p, F_OK);
4601         free(p);
4602
4603         if (r >= 0) {
4604                 *ret = d;
4605                 return 0;
4606         }
4607
4608         /* If it is a partition find the originating device */
4609         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4610                 return -ENOMEM;
4611
4612         r = access(p, F_OK);
4613         free(p);
4614
4615         if (r < 0)
4616                 return -ENOENT;
4617
4618         /* Get parent dev_t */
4619         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4620                 return -ENOMEM;
4621
4622         r = read_one_line_file(p, &s);
4623         free(p);
4624
4625         if (r < 0)
4626                 return r;
4627
4628         r = sscanf(s, "%u:%u", &m, &n);
4629         free(s);
4630
4631         if (r != 2)
4632                 return -EINVAL;
4633
4634         /* Only return this if it is really good enough for us. */
4635         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4636                 return -ENOMEM;
4637
4638         r = access(p, F_OK);
4639         free(p);
4640
4641         if (r >= 0) {
4642                 *ret = makedev(m, n);
4643                 return 0;
4644         }
4645
4646         return -ENOENT;
4647 }
4648
4649 int file_is_priv_sticky(const char *p) {
4650         struct stat st;
4651
4652         assert(p);
4653
4654         if (lstat(p, &st) < 0)
4655                 return -errno;
4656
4657         return
4658                 (st.st_uid == 0 || st.st_uid == getuid()) &&
4659                 (st.st_mode & S_ISVTX);
4660 }
4661
4662 static const char *const ioprio_class_table[] = {
4663         [IOPRIO_CLASS_NONE] = "none",
4664         [IOPRIO_CLASS_RT] = "realtime",
4665         [IOPRIO_CLASS_BE] = "best-effort",
4666         [IOPRIO_CLASS_IDLE] = "idle"
4667 };
4668
4669 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4670
4671 static const char *const sigchld_code_table[] = {
4672         [CLD_EXITED] = "exited",
4673         [CLD_KILLED] = "killed",
4674         [CLD_DUMPED] = "dumped",
4675         [CLD_TRAPPED] = "trapped",
4676         [CLD_STOPPED] = "stopped",
4677         [CLD_CONTINUED] = "continued",
4678 };
4679
4680 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4681
4682 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4683         [LOG_FAC(LOG_KERN)] = "kern",
4684         [LOG_FAC(LOG_USER)] = "user",
4685         [LOG_FAC(LOG_MAIL)] = "mail",
4686         [LOG_FAC(LOG_DAEMON)] = "daemon",
4687         [LOG_FAC(LOG_AUTH)] = "auth",
4688         [LOG_FAC(LOG_SYSLOG)] = "syslog",
4689         [LOG_FAC(LOG_LPR)] = "lpr",
4690         [LOG_FAC(LOG_NEWS)] = "news",
4691         [LOG_FAC(LOG_UUCP)] = "uucp",
4692         [LOG_FAC(LOG_CRON)] = "cron",
4693         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4694         [LOG_FAC(LOG_FTP)] = "ftp",
4695         [LOG_FAC(LOG_LOCAL0)] = "local0",
4696         [LOG_FAC(LOG_LOCAL1)] = "local1",
4697         [LOG_FAC(LOG_LOCAL2)] = "local2",
4698         [LOG_FAC(LOG_LOCAL3)] = "local3",
4699         [LOG_FAC(LOG_LOCAL4)] = "local4",
4700         [LOG_FAC(LOG_LOCAL5)] = "local5",
4701         [LOG_FAC(LOG_LOCAL6)] = "local6",
4702         [LOG_FAC(LOG_LOCAL7)] = "local7"
4703 };
4704
4705 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4706
4707 static const char *const log_level_table[] = {
4708         [LOG_EMERG] = "emerg",
4709         [LOG_ALERT] = "alert",
4710         [LOG_CRIT] = "crit",
4711         [LOG_ERR] = "err",
4712         [LOG_WARNING] = "warning",
4713         [LOG_NOTICE] = "notice",
4714         [LOG_INFO] = "info",
4715         [LOG_DEBUG] = "debug"
4716 };
4717
4718 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
4719
4720 static const char* const sched_policy_table[] = {
4721         [SCHED_OTHER] = "other",
4722         [SCHED_BATCH] = "batch",
4723         [SCHED_IDLE] = "idle",
4724         [SCHED_FIFO] = "fifo",
4725         [SCHED_RR] = "rr"
4726 };
4727
4728 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
4729
4730 static const char* const rlimit_table[] = {
4731         [RLIMIT_CPU] = "LimitCPU",
4732         [RLIMIT_FSIZE] = "LimitFSIZE",
4733         [RLIMIT_DATA] = "LimitDATA",
4734         [RLIMIT_STACK] = "LimitSTACK",
4735         [RLIMIT_CORE] = "LimitCORE",
4736         [RLIMIT_RSS] = "LimitRSS",
4737         [RLIMIT_NOFILE] = "LimitNOFILE",
4738         [RLIMIT_AS] = "LimitAS",
4739         [RLIMIT_NPROC] = "LimitNPROC",
4740         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
4741         [RLIMIT_LOCKS] = "LimitLOCKS",
4742         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
4743         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
4744         [RLIMIT_NICE] = "LimitNICE",
4745         [RLIMIT_RTPRIO] = "LimitRTPRIO",
4746         [RLIMIT_RTTIME] = "LimitRTTIME"
4747 };
4748
4749 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
4750
4751 static const char* const ip_tos_table[] = {
4752         [IPTOS_LOWDELAY] = "low-delay",
4753         [IPTOS_THROUGHPUT] = "throughput",
4754         [IPTOS_RELIABILITY] = "reliability",
4755         [IPTOS_LOWCOST] = "low-cost",
4756 };
4757
4758 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
4759
4760 static const char *const __signal_table[] = {
4761         [SIGHUP] = "HUP",
4762         [SIGINT] = "INT",
4763         [SIGQUIT] = "QUIT",
4764         [SIGILL] = "ILL",
4765         [SIGTRAP] = "TRAP",
4766         [SIGABRT] = "ABRT",
4767         [SIGBUS] = "BUS",
4768         [SIGFPE] = "FPE",
4769         [SIGKILL] = "KILL",
4770         [SIGUSR1] = "USR1",
4771         [SIGSEGV] = "SEGV",
4772         [SIGUSR2] = "USR2",
4773         [SIGPIPE] = "PIPE",
4774         [SIGALRM] = "ALRM",
4775         [SIGTERM] = "TERM",
4776 #ifdef SIGSTKFLT
4777         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
4778 #endif
4779         [SIGCHLD] = "CHLD",
4780         [SIGCONT] = "CONT",
4781         [SIGSTOP] = "STOP",
4782         [SIGTSTP] = "TSTP",
4783         [SIGTTIN] = "TTIN",
4784         [SIGTTOU] = "TTOU",
4785         [SIGURG] = "URG",
4786         [SIGXCPU] = "XCPU",
4787         [SIGXFSZ] = "XFSZ",
4788         [SIGVTALRM] = "VTALRM",
4789         [SIGPROF] = "PROF",
4790         [SIGWINCH] = "WINCH",
4791         [SIGIO] = "IO",
4792         [SIGPWR] = "PWR",
4793         [SIGSYS] = "SYS"
4794 };
4795
4796 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
4797
4798 const char *signal_to_string(int signo) {
4799         static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
4800         const char *name;
4801
4802         name = __signal_to_string(signo);
4803         if (name)
4804                 return name;
4805
4806         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
4807                 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
4808         else
4809                 snprintf(buf, sizeof(buf), "%d", signo);
4810
4811         return buf;
4812 }
4813
4814 int signal_from_string(const char *s) {
4815         int signo;
4816         int offset = 0;
4817         unsigned u;
4818
4819         signo = __signal_from_string(s);
4820         if (signo > 0)
4821                 return signo;
4822
4823         if (startswith(s, "RTMIN+")) {
4824                 s += 6;
4825                 offset = SIGRTMIN;
4826         }
4827         if (safe_atou(s, &u) >= 0) {
4828                 signo = (int) u + offset;
4829                 if (signo > 0 && signo < _NSIG)
4830                         return signo;
4831         }
4832         return -1;
4833 }
4834
4835 bool kexec_loaded(void) {
4836        bool loaded = false;
4837        char *s;
4838
4839        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
4840                if (s[0] == '1')
4841                        loaded = true;
4842                free(s);
4843        }
4844        return loaded;
4845 }
4846
4847 int strdup_or_null(const char *a, char **b) {
4848         char *c;
4849
4850         assert(b);
4851
4852         if (!a) {
4853                 *b = NULL;
4854                 return 0;
4855         }
4856
4857         c = strdup(a);
4858         if (!c)
4859                 return -ENOMEM;
4860
4861         *b = c;
4862         return 0;
4863 }
4864
4865 int prot_from_flags(int flags) {
4866
4867         switch (flags & O_ACCMODE) {
4868
4869         case O_RDONLY:
4870                 return PROT_READ;
4871
4872         case O_WRONLY:
4873                 return PROT_WRITE;
4874
4875         case O_RDWR:
4876                 return PROT_READ|PROT_WRITE;
4877
4878         default:
4879                 return -EINVAL;
4880         }
4881 }
4882
4883 char *format_bytes(char *buf, size_t l, off_t t) {
4884         unsigned i;
4885
4886         static const struct {
4887                 const char *suffix;
4888                 off_t factor;
4889         } table[] = {
4890                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4891                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4892                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
4893                 { "G", 1024ULL*1024ULL*1024ULL },
4894                 { "M", 1024ULL*1024ULL },
4895                 { "K", 1024ULL },
4896         };
4897
4898         for (i = 0; i < ELEMENTSOF(table); i++) {
4899
4900                 if (t >= table[i].factor) {
4901                         snprintf(buf, l,
4902                                  "%llu.%llu%s",
4903                                  (unsigned long long) (t / table[i].factor),
4904                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
4905                                  table[i].suffix);
4906
4907                         goto finish;
4908                 }
4909         }
4910
4911         snprintf(buf, l, "%lluB", (unsigned long long) t);
4912
4913 finish:
4914         buf[l-1] = 0;
4915         return buf;
4916
4917 }
4918
4919 void* memdup(const void *p, size_t l) {
4920         void *r;
4921
4922         assert(p);
4923
4924         r = malloc(l);
4925         if (!r)
4926                 return NULL;
4927
4928         memcpy(r, p, l);
4929         return r;
4930 }
4931
4932 int fd_inc_sndbuf(int fd, size_t n) {
4933         int r, value;
4934         socklen_t l = sizeof(value);
4935
4936         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
4937         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4938                 return 0;
4939
4940         /* If we have the privileges we will ignore the kernel limit. */
4941
4942         value = (int) n;
4943         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
4944                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
4945                         return -errno;
4946
4947         return 1;
4948 }
4949
4950 int fd_inc_rcvbuf(int fd, size_t n) {
4951         int r, value;
4952         socklen_t l = sizeof(value);
4953
4954         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
4955         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
4956                 return 0;
4957
4958         /* If we have the privileges we will ignore the kernel limit. */
4959
4960         value = (int) n;
4961         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
4962                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
4963                         return -errno;
4964         return 1;
4965 }
4966
4967 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
4968         pid_t parent_pid, agent_pid;
4969         int fd;
4970         bool stdout_is_tty, stderr_is_tty;
4971         unsigned n, i;
4972         va_list ap;
4973         char **l;
4974
4975         assert(pid);
4976         assert(path);
4977
4978         parent_pid = getpid();
4979
4980         /* Spawns a temporary TTY agent, making sure it goes away when
4981          * we go away */
4982
4983         agent_pid = fork();
4984         if (agent_pid < 0)
4985                 return -errno;
4986
4987         if (agent_pid != 0) {
4988                 *pid = agent_pid;
4989                 return 0;
4990         }
4991
4992         /* In the child:
4993          *
4994          * Make sure the agent goes away when the parent dies */
4995         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
4996                 _exit(EXIT_FAILURE);
4997
4998         /* Check whether our parent died before we were able
4999          * to set the death signal */
5000         if (getppid() != parent_pid)
5001                 _exit(EXIT_SUCCESS);
5002
5003         /* Don't leak fds to the agent */
5004         close_all_fds(except, n_except);
5005
5006         stdout_is_tty = isatty(STDOUT_FILENO);
5007         stderr_is_tty = isatty(STDERR_FILENO);
5008
5009         if (!stdout_is_tty || !stderr_is_tty) {
5010                 /* Detach from stdout/stderr. and reopen
5011                  * /dev/tty for them. This is important to
5012                  * ensure that when systemctl is started via
5013                  * popen() or a similar call that expects to
5014                  * read EOF we actually do generate EOF and
5015                  * not delay this indefinitely by because we
5016                  * keep an unused copy of stdin around. */
5017                 fd = open("/dev/tty", O_WRONLY);
5018                 if (fd < 0) {
5019                         log_error("Failed to open /dev/tty: %m");
5020                         _exit(EXIT_FAILURE);
5021                 }
5022
5023                 if (!stdout_is_tty)
5024                         dup2(fd, STDOUT_FILENO);
5025
5026                 if (!stderr_is_tty)
5027                         dup2(fd, STDERR_FILENO);
5028
5029                 if (fd > 2)
5030                         close(fd);
5031         }
5032
5033         /* Count arguments */
5034         va_start(ap, path);
5035         for (n = 0; va_arg(ap, char*); n++)
5036                 ;
5037         va_end(ap);
5038
5039         /* Allocate strv */
5040         l = alloca(sizeof(char *) * (n + 1));
5041
5042         /* Fill in arguments */
5043         va_start(ap, path);
5044         for (i = 0; i <= n; i++)
5045                 l[i] = va_arg(ap, char*);
5046         va_end(ap);
5047
5048         execv(path, l);
5049         _exit(EXIT_FAILURE);
5050 }
5051
5052 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5053         struct rlimit highest, fixed;
5054
5055         assert(rlim);
5056
5057         if (setrlimit(resource, rlim) >= 0)
5058                 return 0;
5059
5060         if (errno != EPERM)
5061                 return -errno;
5062
5063         /* So we failed to set the desired setrlimit, then let's try
5064          * to get as close as we can */
5065         assert_se(getrlimit(resource, &highest) == 0);
5066
5067         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5068         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5069
5070         if (setrlimit(resource, &fixed) < 0)
5071                 return -errno;
5072
5073         return 0;
5074 }
5075
5076 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5077         _cleanup_fclose_ FILE *f = NULL;
5078         char *value = NULL;
5079         int r;
5080         bool done = false;
5081         size_t l;
5082         const char *path;
5083
5084         assert(pid >= 0);
5085         assert(field);
5086         assert(_value);
5087
5088         if (pid == 0)
5089                 path = "/proc/self/environ";
5090         else
5091                 path = procfs_file_alloca(pid, "environ");
5092
5093         f = fopen(path, "re");
5094         if (!f)
5095                 return -errno;
5096
5097         l = strlen(field);
5098         r = 0;
5099
5100         do {
5101                 char line[LINE_MAX];
5102                 unsigned i;
5103
5104                 for (i = 0; i < sizeof(line)-1; i++) {
5105                         int c;
5106
5107                         c = getc(f);
5108                         if (_unlikely_(c == EOF)) {
5109                                 done = true;
5110                                 break;
5111                         } else if (c == 0)
5112                                 break;
5113
5114                         line[i] = c;
5115                 }
5116                 line[i] = 0;
5117
5118                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5119                         value = strdup(line + l + 1);
5120                         if (!value)
5121                                 return -ENOMEM;
5122
5123                         r = 1;
5124                         break;
5125                 }
5126
5127         } while (!done);
5128
5129         *_value = value;
5130         return r;
5131 }
5132
5133 bool is_valid_documentation_url(const char *url) {
5134         assert(url);
5135
5136         if (startswith(url, "http://") && url[7])
5137                 return true;
5138
5139         if (startswith(url, "https://") && url[8])
5140                 return true;
5141
5142         if (startswith(url, "file:") && url[5])
5143                 return true;
5144
5145         if (startswith(url, "info:") && url[5])
5146                 return true;
5147
5148         if (startswith(url, "man:") && url[4])
5149                 return true;
5150
5151         return false;
5152 }
5153
5154 bool in_initrd(void) {
5155         static int saved = -1;
5156         struct statfs s;
5157
5158         if (saved >= 0)
5159                 return saved;
5160
5161         /* We make two checks here:
5162          *
5163          * 1. the flag file /etc/initrd-release must exist
5164          * 2. the root file system must be a memory file system
5165          *
5166          * The second check is extra paranoia, since misdetecting an
5167          * initrd can have bad bad consequences due the initrd
5168          * emptying when transititioning to the main systemd.
5169          */
5170
5171         saved = access("/etc/initrd-release", F_OK) >= 0 &&
5172                 statfs("/", &s) >= 0 &&
5173                 is_temporary_fs(&s);
5174
5175         return saved;
5176 }
5177
5178 void warn_melody(void) {
5179         _cleanup_close_ int fd = -1;
5180
5181         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5182         if (fd < 0)
5183                 return;
5184
5185         /* Yeah, this is synchronous. Kinda sucks. But well... */
5186
5187         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5188         usleep(125*USEC_PER_MSEC);
5189
5190         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5191         usleep(125*USEC_PER_MSEC);
5192
5193         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5194         usleep(125*USEC_PER_MSEC);
5195
5196         ioctl(fd, KIOCSOUND, 0);
5197 }
5198
5199 int make_console_stdio(void) {
5200         int fd, r;
5201
5202         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5203
5204         fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5205         if (fd < 0) {
5206                 log_error("Failed to acquire terminal: %s", strerror(-fd));
5207                 return fd;
5208         }
5209
5210         r = make_stdio(fd);
5211         if (r < 0) {
5212                 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5213                 return r;
5214         }
5215
5216         return 0;
5217 }
5218
5219 int get_home_dir(char **_h) {
5220         struct passwd *p;
5221         const char *e;
5222         char *h;
5223         uid_t u;
5224
5225         assert(_h);
5226
5227         /* Take the user specified one */
5228         e = getenv("HOME");
5229         if (e) {
5230                 h = strdup(e);
5231                 if (!h)
5232                         return -ENOMEM;
5233
5234                 *_h = h;
5235                 return 0;
5236         }
5237
5238         /* Hardcode home directory for root to avoid NSS */
5239         u = getuid();
5240         if (u == 0) {
5241                 h = strdup("/root");
5242                 if (!h)
5243                         return -ENOMEM;
5244
5245                 *_h = h;
5246                 return 0;
5247         }
5248
5249         /* Check the database... */
5250         errno = 0;
5251         p = getpwuid(u);
5252         if (!p)
5253                 return errno > 0 ? -errno : -ESRCH;
5254
5255         if (!path_is_absolute(p->pw_dir))
5256                 return -EINVAL;
5257
5258         h = strdup(p->pw_dir);
5259         if (!h)
5260                 return -ENOMEM;
5261
5262         *_h = h;
5263         return 0;
5264 }
5265
5266 int get_shell(char **_s) {
5267         struct passwd *p;
5268         const char *e;
5269         char *s;
5270         uid_t u;
5271
5272         assert(_s);
5273
5274         /* Take the user specified one */
5275         e = getenv("SHELL");
5276         if (e) {
5277                 s = strdup(e);
5278                 if (!s)
5279                         return -ENOMEM;
5280
5281                 *_s = s;
5282                 return 0;
5283         }
5284
5285         /* Hardcode home directory for root to avoid NSS */
5286         u = getuid();
5287         if (u == 0) {
5288                 s = strdup("/bin/sh");
5289                 if (!s)
5290                         return -ENOMEM;
5291
5292                 *_s = s;
5293                 return 0;
5294         }
5295
5296         /* Check the database... */
5297         errno = 0;
5298         p = getpwuid(u);
5299         if (!p)
5300                 return errno > 0 ? -errno : -ESRCH;
5301
5302         if (!path_is_absolute(p->pw_shell))
5303                 return -EINVAL;
5304
5305         s = strdup(p->pw_shell);
5306         if (!s)
5307                 return -ENOMEM;
5308
5309         *_s = s;
5310         return 0;
5311 }
5312
5313 bool filename_is_safe(const char *p) {
5314
5315         if (isempty(p))
5316                 return false;
5317
5318         if (strchr(p, '/'))
5319                 return false;
5320
5321         if (streq(p, "."))
5322                 return false;
5323
5324         if (streq(p, ".."))
5325                 return false;
5326
5327         if (strlen(p) > FILENAME_MAX)
5328                 return false;
5329
5330         return true;
5331 }
5332
5333 bool string_is_safe(const char *p) {
5334         const char *t;
5335
5336         assert(p);
5337
5338         for (t = p; *t; t++) {
5339                 if (*t > 0 && *t < ' ')
5340                         return false;
5341
5342                 if (strchr("\\\"\'", *t))
5343                         return false;
5344         }
5345
5346         return true;
5347 }
5348
5349 /**
5350  * Check if a string contains control characters.
5351  * Spaces and tabs are not considered control characters.
5352  */
5353 bool string_has_cc(const char *p) {
5354         const char *t;
5355
5356         assert(p);
5357
5358         for (t = p; *t; t++)
5359                 if (*t > 0 && *t < ' ' && *t != '\t')
5360                         return true;
5361
5362         return false;
5363 }
5364
5365 bool path_is_safe(const char *p) {
5366
5367         if (isempty(p))
5368                 return false;
5369
5370         if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5371                 return false;
5372
5373         if (strlen(p) > PATH_MAX)
5374                 return false;
5375
5376         /* The following two checks are not really dangerous, but hey, they still are confusing */
5377         if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5378                 return false;
5379
5380         if (strstr(p, "//"))
5381                 return false;
5382
5383         return true;
5384 }
5385
5386 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5387 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5388                  int (*compar) (const void *, const void *, void *), void *arg) {
5389         size_t l, u, idx;
5390         const void *p;
5391         int comparison;
5392
5393         l = 0;
5394         u = nmemb;
5395         while (l < u) {
5396                 idx = (l + u) / 2;
5397                 p = (void *)(((const char *) base) + (idx * size));
5398                 comparison = compar(key, p, arg);
5399                 if (comparison < 0)
5400                         u = idx;
5401                 else if (comparison > 0)
5402                         l = idx + 1;
5403                 else
5404                         return (void *)p;
5405         }
5406         return NULL;
5407 }
5408
5409 bool is_locale_utf8(void) {
5410         const char *set;
5411         static int cached_answer = -1;
5412
5413         if (cached_answer >= 0)
5414                 goto out;
5415
5416         if (!setlocale(LC_ALL, "")) {
5417                 cached_answer = true;
5418                 goto out;
5419         }
5420
5421         set = nl_langinfo(CODESET);
5422         if (!set) {
5423                 cached_answer = true;
5424                 goto out;
5425         }
5426
5427         if (streq(set, "UTF-8")) {
5428                 cached_answer = true;
5429                 goto out;
5430         }
5431
5432         /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5433          * unset and everything can do to UTF-8 nowadays. */
5434         set = setlocale(LC_CTYPE, NULL);
5435         if (!set) {
5436                 cached_answer = true;
5437                 goto out;
5438         }
5439
5440         /* Check result, but ignore the result if C was set
5441          * explicitly. */
5442         cached_answer =
5443                 streq(set, "C") &&
5444                 !getenv("LC_ALL") &&
5445                 !getenv("LC_CTYPE") &&
5446                 !getenv("LANG");
5447
5448 out:
5449         return (bool) cached_answer;
5450 }
5451
5452 const char *draw_special_char(DrawSpecialChar ch) {
5453         static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5454                 /* UTF-8 */ {
5455                         [DRAW_TREE_VERT]          = "\342\224\202 ",            /* │  */
5456                         [DRAW_TREE_BRANCH]        = "\342\224\234\342\224\200", /* ├─ */
5457                         [DRAW_TREE_RIGHT]         = "\342\224\224\342\224\200", /* └─ */
5458                         [DRAW_TREE_SPACE]         = "  ",                       /*    */
5459                         [DRAW_TRIANGULAR_BULLET]  = "\342\200\243 ",            /* ‣  */
5460                         [DRAW_BLACK_CIRCLE]       = "\342\227\217 ",            /* ●  */
5461                 },
5462                 /* ASCII fallback */ {
5463                         [DRAW_TREE_VERT]          = "| ",
5464                         [DRAW_TREE_BRANCH]        = "|-",
5465                         [DRAW_TREE_RIGHT]         = "`-",
5466                         [DRAW_TREE_SPACE]         = "  ",
5467                         [DRAW_TRIANGULAR_BULLET]  = "> ",
5468                         [DRAW_BLACK_CIRCLE]       = "* ",
5469                 }
5470         };
5471
5472         return draw_table[!is_locale_utf8()][ch];
5473 }
5474
5475 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5476         const char *f;
5477         char *t, *r;
5478         size_t l, old_len, new_len;
5479
5480         assert(text);
5481         assert(old_string);
5482         assert(new_string);
5483
5484         old_len = strlen(old_string);
5485         new_len = strlen(new_string);
5486
5487         l = strlen(text);
5488         r = new(char, l+1);
5489         if (!r)
5490                 return NULL;
5491
5492         f = text;
5493         t = r;
5494         while (*f) {
5495                 char *a;
5496                 size_t d, nl;
5497
5498                 if (!startswith(f, old_string)) {
5499                         *(t++) = *(f++);
5500                         continue;
5501                 }
5502
5503                 d = t - r;
5504                 nl = l - old_len + new_len;
5505                 a = realloc(r, nl + 1);
5506                 if (!a)
5507                         goto oom;
5508
5509                 l = nl;
5510                 r = a;
5511                 t = r + d;
5512
5513                 t = stpcpy(t, new_string);
5514                 f += old_len;
5515         }
5516
5517         *t = 0;
5518         return r;
5519
5520 oom:
5521         free(r);
5522         return NULL;
5523 }
5524
5525 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5526         const char *i, *begin = NULL;
5527         enum {
5528                 STATE_OTHER,
5529                 STATE_ESCAPE,
5530                 STATE_BRACKET
5531         } state = STATE_OTHER;
5532         char *obuf = NULL;
5533         size_t osz = 0, isz;
5534         FILE *f;
5535
5536         assert(ibuf);
5537         assert(*ibuf);
5538
5539         /* Strips ANSI color and replaces TABs by 8 spaces */
5540
5541         isz = _isz ? *_isz : strlen(*ibuf);
5542
5543         f = open_memstream(&obuf, &osz);
5544         if (!f)
5545                 return NULL;
5546
5547         for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5548
5549                 switch (state) {
5550
5551                 case STATE_OTHER:
5552                         if (i >= *ibuf + isz) /* EOT */
5553                                 break;
5554                         else if (*i == '\x1B')
5555                                 state = STATE_ESCAPE;
5556                         else if (*i == '\t')
5557                                 fputs("        ", f);
5558                         else
5559                                 fputc(*i, f);
5560                         break;
5561
5562                 case STATE_ESCAPE:
5563                         if (i >= *ibuf + isz) { /* EOT */
5564                                 fputc('\x1B', f);
5565                                 break;
5566                         } else if (*i == '[') {
5567                                 state = STATE_BRACKET;
5568                                 begin = i + 1;
5569                         } else {
5570                                 fputc('\x1B', f);
5571                                 fputc(*i, f);
5572                                 state = STATE_OTHER;
5573                         }
5574
5575                         break;
5576
5577                 case STATE_BRACKET:
5578
5579                         if (i >= *ibuf + isz || /* EOT */
5580                             (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5581                                 fputc('\x1B', f);
5582                                 fputc('[', f);
5583                                 state = STATE_OTHER;
5584                                 i = begin-1;
5585                         } else if (*i == 'm')
5586                                 state = STATE_OTHER;
5587                         break;
5588                 }
5589         }
5590
5591         if (ferror(f)) {
5592                 fclose(f);
5593                 free(obuf);
5594                 return NULL;
5595         }
5596
5597         fclose(f);
5598
5599         free(*ibuf);
5600         *ibuf = obuf;
5601
5602         if (_isz)
5603                 *_isz = osz;
5604
5605         return obuf;
5606 }
5607
5608 int on_ac_power(void) {
5609         bool found_offline = false, found_online = false;
5610         _cleanup_closedir_ DIR *d = NULL;
5611
5612         d = opendir("/sys/class/power_supply");
5613         if (!d)
5614                 return -errno;
5615
5616         for (;;) {
5617                 struct dirent *de;
5618                 _cleanup_close_ int fd = -1, device = -1;
5619                 char contents[6];
5620                 ssize_t n;
5621
5622                 errno = 0;
5623                 de = readdir(d);
5624                 if (!de && errno != 0)
5625                         return -errno;
5626
5627                 if (!de)
5628                         break;
5629
5630                 if (ignore_file(de->d_name))
5631                         continue;
5632
5633                 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5634                 if (device < 0) {
5635                         if (errno == ENOENT || errno == ENOTDIR)
5636                                 continue;
5637
5638                         return -errno;
5639                 }
5640
5641                 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5642                 if (fd < 0) {
5643                         if (errno == ENOENT)
5644                                 continue;
5645
5646                         return -errno;
5647                 }
5648
5649                 n = read(fd, contents, sizeof(contents));
5650                 if (n < 0)
5651                         return -errno;
5652
5653                 if (n != 6 || memcmp(contents, "Mains\n", 6))
5654                         continue;
5655
5656                 close_nointr_nofail(fd);
5657                 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5658                 if (fd < 0) {
5659                         if (errno == ENOENT)
5660                                 continue;
5661
5662                         return -errno;
5663                 }
5664
5665                 n = read(fd, contents, sizeof(contents));
5666                 if (n < 0)
5667                         return -errno;
5668
5669                 if (n != 2 || contents[1] != '\n')
5670                         return -EIO;
5671
5672                 if (contents[0] == '1') {
5673                         found_online = true;
5674                         break;
5675                 } else if (contents[0] == '0')
5676                         found_offline = true;
5677                 else
5678                         return -EIO;
5679         }
5680
5681         return found_online || !found_offline;
5682 }
5683
5684 static int search_and_fopen_internal(const char *path, const char *mode, char **search, FILE **_f) {
5685         char **i;
5686
5687         assert(path);
5688         assert(mode);
5689         assert(_f);
5690
5691         if (!path_strv_canonicalize_uniq(search))
5692                 return -ENOMEM;
5693
5694         STRV_FOREACH(i, search) {
5695                 _cleanup_free_ char *p = NULL;
5696                 FILE *f;
5697
5698                 p = strjoin(*i, "/", path, NULL);
5699                 if (!p)
5700                         return -ENOMEM;
5701
5702                 f = fopen(p, mode);
5703                 if (f) {
5704                         *_f = f;
5705                         return 0;
5706                 }
5707
5708                 if (errno != ENOENT)
5709                         return -errno;
5710         }
5711
5712         return -ENOENT;
5713 }
5714
5715 int search_and_fopen(const char *path, const char *mode, const char **search, FILE **_f) {
5716         _cleanup_strv_free_ char **copy = NULL;
5717
5718         assert(path);
5719         assert(mode);
5720         assert(_f);
5721
5722         if (path_is_absolute(path)) {
5723                 FILE *f;
5724
5725                 f = fopen(path, mode);
5726                 if (f) {
5727                         *_f = f;
5728                         return 0;
5729                 }
5730
5731                 return -errno;
5732         }
5733
5734         copy = strv_copy((char**) search);
5735         if (!copy)
5736                 return -ENOMEM;
5737
5738         return search_and_fopen_internal(path, mode, copy, _f);
5739 }
5740
5741 int search_and_fopen_nulstr(const char *path, const char *mode, const char *search, FILE **_f) {
5742         _cleanup_strv_free_ char **s = NULL;
5743
5744         if (path_is_absolute(path)) {
5745                 FILE *f;
5746
5747                 f = fopen(path, mode);
5748                 if (f) {
5749                         *_f = f;
5750                         return 0;
5751                 }
5752
5753                 return -errno;
5754         }
5755
5756         s = strv_split_nulstr(search);
5757         if (!s)
5758                 return -ENOMEM;
5759
5760         return search_and_fopen_internal(path, mode, s, _f);
5761 }
5762
5763 char *strextend(char **x, ...) {
5764         va_list ap;
5765         size_t f, l;
5766         char *r, *p;
5767
5768         assert(x);
5769
5770         l = f = *x ? strlen(*x) : 0;
5771
5772         va_start(ap, x);
5773         for (;;) {
5774                 const char *t;
5775                 size_t n;
5776
5777                 t = va_arg(ap, const char *);
5778                 if (!t)
5779                         break;
5780
5781                 n = strlen(t);
5782                 if (n > ((size_t) -1) - l) {
5783                         va_end(ap);
5784                         return NULL;
5785                 }
5786
5787                 l += n;
5788         }
5789         va_end(ap);
5790
5791         r = realloc(*x, l+1);
5792         if (!r)
5793                 return NULL;
5794
5795         p = r + f;
5796
5797         va_start(ap, x);
5798         for (;;) {
5799                 const char *t;
5800
5801                 t = va_arg(ap, const char *);
5802                 if (!t)
5803                         break;
5804
5805                 p = stpcpy(p, t);
5806         }
5807         va_end(ap);
5808
5809         *p = 0;
5810         *x = r;
5811
5812         return r + l;
5813 }
5814
5815 char *strrep(const char *s, unsigned n) {
5816         size_t l;
5817         char *r, *p;
5818         unsigned i;
5819
5820         assert(s);
5821
5822         l = strlen(s);
5823         p = r = malloc(l * n + 1);
5824         if (!r)
5825                 return NULL;
5826
5827         for (i = 0; i < n; i++)
5828                 p = stpcpy(p, s);
5829
5830         *p = 0;
5831         return r;
5832 }
5833
5834 void* greedy_realloc(void **p, size_t *allocated, size_t need) {
5835         size_t a;
5836         void *q;
5837
5838         assert(p);
5839         assert(allocated);
5840
5841         if (*allocated >= need)
5842                 return *p;
5843
5844         a = MAX(64u, need * 2);
5845
5846         /* check for overflows */
5847         if (a < need)
5848                 return NULL;
5849
5850         q = realloc(*p, a);
5851         if (!q)
5852                 return NULL;
5853
5854         *p = q;
5855         *allocated = a;
5856         return q;
5857 }
5858
5859 void* greedy_realloc0(void **p, size_t *allocated, size_t need) {
5860         size_t prev;
5861         uint8_t *q;
5862
5863         assert(p);
5864         assert(allocated);
5865
5866         prev = *allocated;
5867
5868         q = greedy_realloc(p, allocated, need);
5869         if (!q)
5870                 return NULL;
5871
5872         if (*allocated > prev)
5873                 memset(&q[prev], 0, *allocated - prev);
5874
5875         return q;
5876 }
5877
5878 bool id128_is_valid(const char *s) {
5879         size_t i, l;
5880
5881         l = strlen(s);
5882         if (l == 32) {
5883
5884                 /* Simple formatted 128bit hex string */
5885
5886                 for (i = 0; i < l; i++) {
5887                         char c = s[i];
5888
5889                         if (!(c >= '0' && c <= '9') &&
5890                             !(c >= 'a' && c <= 'z') &&
5891                             !(c >= 'A' && c <= 'Z'))
5892                                 return false;
5893                 }
5894
5895         } else if (l == 36) {
5896
5897                 /* Formatted UUID */
5898
5899                 for (i = 0; i < l; i++) {
5900                         char c = s[i];
5901
5902                         if ((i == 8 || i == 13 || i == 18 || i == 23)) {
5903                                 if (c != '-')
5904                                         return false;
5905                         } else {
5906                                 if (!(c >= '0' && c <= '9') &&
5907                                     !(c >= 'a' && c <= 'z') &&
5908                                     !(c >= 'A' && c <= 'Z'))
5909                                         return false;
5910                         }
5911                 }
5912
5913         } else
5914                 return false;
5915
5916         return true;
5917 }
5918
5919 void parse_user_at_host(char *arg, char **user, char **host) {
5920         assert(arg);
5921         assert(user);
5922         assert(host);
5923
5924         *host = strchr(arg, '@');
5925         if (*host == NULL)
5926                 *host = arg;
5927         else {
5928                 *host[0]++ = '\0';
5929                 *user = arg;
5930         }
5931 }
5932
5933 int split_pair(const char *s, const char *sep, char **l, char **r) {
5934         char *x, *a, *b;
5935
5936         assert(s);
5937         assert(sep);
5938         assert(l);
5939         assert(r);
5940
5941         if (isempty(sep))
5942                 return -EINVAL;
5943
5944         x = strstr(s, sep);
5945         if (!x)
5946                 return -EINVAL;
5947
5948         a = strndup(s, x - s);
5949         if (!a)
5950                 return -ENOMEM;
5951
5952         b = strdup(x + strlen(sep));
5953         if (!b) {
5954                 free(a);
5955                 return -ENOMEM;
5956         }
5957
5958         *l = a;
5959         *r = b;
5960
5961         return 0;
5962 }
5963
5964 int shall_restore_state(void) {
5965         _cleanup_free_ char *line;
5966         char *w, *state;
5967         size_t l;
5968         int r;
5969
5970         r = proc_cmdline(&line);
5971         if (r < 0)
5972                 return r;
5973         if (r == 0) /* Container ... */
5974                 return 1;
5975
5976         FOREACH_WORD_QUOTED(w, l, line, state)
5977                 if (l == 23 && strneq(w, "systemd.restore_state=0", 23))
5978                         return 0;
5979
5980         return 1;
5981 }
5982
5983 int proc_cmdline(char **ret) {
5984         int r;
5985
5986         if (detect_container(NULL) > 0) {
5987                 *ret = NULL;
5988                 return 0;
5989         }
5990
5991         r = read_one_line_file("/proc/cmdline", ret);
5992         if (r < 0)
5993                 return r;
5994
5995         return 1;
5996 }
5997
5998 int container_get_leader(const char *machine, pid_t *pid) {
5999         _cleanup_free_ char *s = NULL, *class = NULL;
6000         const char *p;
6001         pid_t leader;
6002         int r;
6003
6004         assert(machine);
6005         assert(pid);
6006
6007         p = strappenda("/run/systemd/machines/", machine);
6008         r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6009         if (r == -ENOENT)
6010                 return -EHOSTDOWN;
6011         if (r < 0)
6012                 return r;
6013         if (!s)
6014                 return -EIO;
6015
6016         if (!streq_ptr(class, "container"))
6017                 return -EIO;
6018
6019         r = parse_pid(s, &leader);
6020         if (r < 0)
6021                 return r;
6022         if (leader <= 1)
6023                 return -EIO;
6024
6025         *pid = leader;
6026         return 0;
6027 }
6028
6029 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *root_fd) {
6030         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1;
6031         const char *pidns, *mntns, *root;
6032         int rfd;
6033
6034         assert(pid >= 0);
6035         assert(pidns_fd);
6036         assert(mntns_fd);
6037         assert(root_fd);
6038
6039         mntns = procfs_file_alloca(pid, "ns/mnt");
6040         mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6041         if (mntnsfd < 0)
6042                 return -errno;
6043
6044         pidns = procfs_file_alloca(pid, "ns/pid");
6045         pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6046         if (pidnsfd < 0)
6047                 return -errno;
6048
6049         root = procfs_file_alloca(pid, "root");
6050         rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6051         if (rfd < 0)
6052                 return -errno;
6053
6054         *pidns_fd = pidnsfd;
6055         *mntns_fd = mntnsfd;
6056         *root_fd = rfd;
6057         pidnsfd = -1;
6058         mntnsfd = -1;
6059
6060         return 0;
6061 }
6062
6063 int namespace_enter(int pidns_fd, int mntns_fd, int root_fd) {
6064         assert(pidns_fd >= 0);
6065         assert(mntns_fd >= 0);
6066         assert(root_fd >= 0);
6067
6068         if (setns(pidns_fd, CLONE_NEWPID) < 0)
6069                 return -errno;
6070
6071         if (setns(mntns_fd, CLONE_NEWNS) < 0)
6072                 return -errno;
6073
6074         if (fchdir(root_fd) < 0)
6075                 return -errno;
6076
6077         if (chroot(".") < 0)
6078                 return -errno;
6079
6080         if (setresgid(0, 0, 0) < 0)
6081                 return -errno;
6082
6083         if (setresuid(0, 0, 0) < 0)
6084                 return -errno;
6085
6086         return 0;
6087 }
6088
6089 bool pid_valid(pid_t pid) {
6090         if (pid <= 0)
6091                 return false;
6092
6093         if (kill(pid, 0) >= 0)
6094                 return true;
6095
6096         return errno != ESRCH;
6097 }