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