src/shared/util.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <signal.h>
  28 #include <stdio.h>
  29 #include <syslog.h>
  30 #include <sched.h>
  31 #include <sys/resource.h>
  32 #include <linux/sched.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <dirent.h>
  37 #include <sys/ioctl.h>
  38 #include <linux/vt.h>
  39 #include <linux/tiocl.h>
  40 #include <termios.h>
  41 #include <stdarg.h>
  42 #include <sys/inotify.h>
  43 #include <sys/poll.h>
  44 #include <ctype.h>
  45 #include <sys/prctl.h>
  46 #include <sys/utsname.h>
  47 #include <pwd.h>
  48 #include <netinet/ip.h>
  49 #include <linux/kd.h>
  50 #include <dlfcn.h>
  51 #include <sys/wait.h>
  52 #include <sys/time.h>
  53 #include <glob.h>
  54 #include <grp.h>
  55 #include <sys/mman.h>
  56 #include <sys/vfs.h>
  57 #include <linux/magic.h>
  58 #include <limits.h>
  59 #include <langinfo.h>
  60 #include <locale.h>
  61 #include <libgen.h>
  62
  63 #include "macro.h"
  64 #include "util.h"
  65 #include "ioprio.h"
  66 #include "missing.h"
  67 #include "log.h"
  68 #include "strv.h"
  69 #include "label.h"
  70 #include "path-util.h"
  71 #include "exit-status.h"
  72 #include "hashmap.h"
  73 #include "env-util.h"
  74 #include "fileio.h"
  75 #include "device-nodes.h"
  76 #include "utf8.h"
  77 #include "gunicode.h"
  78 #include "virt.h"
  79 #include "def.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 reversed 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 (mode != (mode_t) -1)
2928                 if (fchmod(fd, mode) < 0)
2929                         return -errno;
2930
2931         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2932                 if (fchown(fd, uid, gid) < 0)
2933                         return -errno;
2934
2935         return 0;
2936 }
2937
2938 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2939         cpu_set_t *r;
2940         unsigned n = 1024;
2941
2942         /* Allocates the cpuset in the right size */
2943
2944         for (;;) {
2945                 if (!(r = CPU_ALLOC(n)))
2946                         return NULL;
2947
2948                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2949                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2950
2951                         if (ncpus)
2952                                 *ncpus = n;
2953
2954                         return r;
2955                 }
2956
2957                 CPU_FREE(r);
2958
2959                 if (errno != EINVAL)
2960                         return NULL;
2961
2962                 n *= 2;
2963         }
2964 }
2965
2966 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2967         static const char status_indent[] = "         "; /* "[" STATUS "] " */
2968         _cleanup_free_ char *s = NULL;
2969         _cleanup_close_ int fd = -1;
2970         struct iovec iovec[6] = {};
2971         int n = 0;
2972         static bool prev_ephemeral;
2973
2974         assert(format);
2975
2976         /* This is independent of logging, as status messages are
2977          * optional and go exclusively to the console. */
2978
2979         if (vasprintf(&s, format, ap) < 0)
2980                 return log_oom();
2981
2982         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2983         if (fd < 0)
2984                 return fd;
2985
2986         if (ellipse) {
2987                 char *e;
2988                 size_t emax, sl;
2989                 int c;
2990
2991                 c = fd_columns(fd);
2992                 if (c <= 0)
2993                         c = 80;
2994
2995                 sl = status ? sizeof(status_indent)-1 : 0;
2996
2997                 emax = c - sl - 1;
2998                 if (emax < 3)
2999                         emax = 3;
3000
3001                 e = ellipsize(s, emax, 75);
3002                 if (e) {
3003                         free(s);
3004                         s = e;
3005                 }
3006         }
3007
3008         if (prev_ephemeral)
3009                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3010         prev_ephemeral = ephemeral;
3011
3012         if (status) {
3013                 if (!isempty(status)) {
3014                         IOVEC_SET_STRING(iovec[n++], "[");
3015                         IOVEC_SET_STRING(iovec[n++], status);
3016                         IOVEC_SET_STRING(iovec[n++], "] ");
3017                 } else
3018                         IOVEC_SET_STRING(iovec[n++], status_indent);
3019         }
3020
3021         IOVEC_SET_STRING(iovec[n++], s);
3022         if (!ephemeral)
3023                 IOVEC_SET_STRING(iovec[n++], "\n");
3024
3025         if (writev(fd, iovec, n) < 0)
3026                 return -errno;
3027
3028         return 0;
3029 }
3030
3031 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3032         va_list ap;
3033         int r;
3034
3035         assert(format);
3036
3037         va_start(ap, format);
3038         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3039         va_end(ap);
3040
3041         return r;
3042 }
3043
3044 int status_welcome(void) {
3045         _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
3046         int r;
3047
3048         r = parse_env_file("/etc/os-release", NEWLINE,
3049                            "PRETTY_NAME", &pretty_name,
3050                            "ANSI_COLOR", &ansi_color,
3051                            NULL);
3052
3053         if (r < 0 && r != -ENOENT)
3054                 log_warning("Failed to read /etc/os-release: %s", strerror(-r));
3055
3056         return status_printf(NULL, false, false,
3057                              "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
3058                              isempty(ansi_color) ? "1" : ansi_color,
3059                              isempty(pretty_name) ? "Linux" : pretty_name);
3060 }
3061
3062 char *replace_env(const char *format, char **env) {
3063         enum {
3064                 WORD,
3065                 CURLY,
3066                 VARIABLE
3067         } state = WORD;
3068
3069         const char *e, *word = format;
3070         char *r = NULL, *k;
3071
3072         assert(format);
3073
3074         for (e = format; *e; e ++) {
3075
3076                 switch (state) {
3077
3078                 case WORD:
3079                         if (*e == '$')
3080                                 state = CURLY;
3081                         break;
3082
3083                 case CURLY:
3084                         if (*e == '{') {
3085                                 if (!(k = strnappend(r, word, e-word-1)))
3086                                         goto fail;
3087
3088                                 free(r);
3089                                 r = k;
3090
3091                                 word = e-1;
3092                                 state = VARIABLE;
3093
3094                         } else if (*e == '$') {
3095                                 if (!(k = strnappend(r, word, e-word)))
3096                                         goto fail;
3097
3098                                 free(r);
3099                                 r = k;
3100
3101                                 word = e+1;
3102                                 state = WORD;
3103                         } else
3104                                 state = WORD;
3105                         break;
3106
3107                 case VARIABLE:
3108                         if (*e == '}') {
3109                                 const char *t;
3110
3111                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3112
3113                                 k = strappend(r, t);
3114                                 if (!k)
3115                                         goto fail;
3116
3117                                 free(r);
3118                                 r = k;
3119
3120                                 word = e+1;
3121                                 state = WORD;
3122                         }
3123                         break;
3124                 }
3125         }
3126
3127         if (!(k = strnappend(r, word, e-word)))
3128                 goto fail;
3129
3130         free(r);
3131         return k;
3132
3133 fail:
3134         free(r);
3135         return NULL;
3136 }
3137
3138 char **replace_env_argv(char **argv, char **env) {
3139         char **r, **i;
3140         unsigned k = 0, l = 0;
3141
3142         l = strv_length(argv);
3143
3144         if (!(r = new(char*, l+1)))
3145                 return NULL;
3146
3147         STRV_FOREACH(i, argv) {
3148
3149                 /* If $FOO appears as single word, replace it by the split up variable */
3150                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3151                         char *e;
3152                         char **w, **m;
3153                         unsigned q;
3154
3155                         e = strv_env_get(env, *i+1);
3156                         if (e) {
3157
3158                                 if (!(m = strv_split_quoted(e))) {
3159                                         r[k] = NULL;
3160                                         strv_free(r);
3161                                         return NULL;
3162                                 }
3163                         } else
3164                                 m = NULL;
3165
3166                         q = strv_length(m);
3167                         l = l + q - 1;
3168
3169                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3170                                 r[k] = NULL;
3171                                 strv_free(r);
3172                                 strv_free(m);
3173                                 return NULL;
3174                         }
3175
3176                         r = w;
3177                         if (m) {
3178                                 memcpy(r + k, m, q * sizeof(char*));
3179                                 free(m);
3180                         }
3181
3182                         k += q;
3183                         continue;
3184                 }
3185
3186                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3187                 if (!(r[k++] = replace_env(*i, env))) {
3188                         strv_free(r);
3189                         return NULL;
3190                 }
3191         }
3192
3193         r[k] = NULL;
3194         return r;
3195 }
3196
3197 int fd_columns(int fd) {
3198         struct winsize ws = {};
3199
3200         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3201                 return -errno;
3202
3203         if (ws.ws_col <= 0)
3204                 return -EIO;
3205
3206         return ws.ws_col;
3207 }
3208
3209 unsigned columns(void) {
3210         const char *e;
3211         int c;
3212
3213         if (_likely_(cached_columns > 0))
3214                 return cached_columns;
3215
3216         c = 0;
3217         e = getenv("COLUMNS");
3218         if (e)
3219                 safe_atoi(e, &c);
3220
3221         if (c <= 0)
3222                 c = fd_columns(STDOUT_FILENO);
3223
3224         if (c <= 0)
3225                 c = 80;
3226
3227         cached_columns = c;
3228         return c;
3229 }
3230
3231 int fd_lines(int fd) {
3232         struct winsize ws = {};
3233
3234         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3235                 return -errno;
3236
3237         if (ws.ws_row <= 0)
3238                 return -EIO;
3239
3240         return ws.ws_row;
3241 }
3242
3243 unsigned lines(void) {
3244         const char *e;
3245         unsigned l;
3246
3247         if (_likely_(cached_lines > 0))
3248                 return cached_lines;
3249
3250         l = 0;
3251         e = getenv("LINES");
3252         if (e)
3253                 safe_atou(e, &l);
3254
3255         if (l <= 0)
3256                 l = fd_lines(STDOUT_FILENO);
3257
3258         if (l <= 0)
3259                 l = 24;
3260
3261         cached_lines = l;
3262         return cached_lines;
3263 }
3264
3265 /* intended to be used as a SIGWINCH sighandler */
3266 void columns_lines_cache_reset(int signum) {
3267         cached_columns = 0;
3268         cached_lines = 0;
3269 }
3270
3271 bool on_tty(void) {
3272         static int cached_on_tty = -1;
3273
3274         if (_unlikely_(cached_on_tty < 0))
3275                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3276
3277         return cached_on_tty;
3278 }
3279
3280 int running_in_chroot(void) {
3281         struct stat a = {}, b = {};
3282
3283         /* Only works as root */
3284         if (stat("/proc/1/root", &a) < 0)
3285                 return -errno;
3286
3287         if (stat("/", &b) < 0)
3288                 return -errno;
3289
3290         return
3291                 a.st_dev != b.st_dev ||
3292                 a.st_ino != b.st_ino;
3293 }
3294
3295 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3296         size_t x;
3297         char *r;
3298
3299         assert(s);
3300         assert(percent <= 100);
3301         assert(new_length >= 3);
3302
3303         if (old_length <= 3 || old_length <= new_length)
3304                 return strndup(s, old_length);
3305
3306         r = new0(char, new_length+1);
3307         if (!r)
3308                 return NULL;
3309
3310         x = (new_length * percent) / 100;
3311
3312         if (x > new_length - 3)
3313                 x = new_length - 3;
3314
3315         memcpy(r, s, x);
3316         r[x] = '.';
3317         r[x+1] = '.';
3318         r[x+2] = '.';
3319         memcpy(r + x + 3,
3320                s + old_length - (new_length - x - 3),
3321                new_length - x - 3);
3322
3323         return r;
3324 }
3325
3326 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3327         size_t x;
3328         char *e;
3329         const char *i, *j;
3330         unsigned k, len, len2;
3331
3332         assert(s);
3333         assert(percent <= 100);
3334         assert(new_length >= 3);
3335
3336         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3337         if (ascii_is_valid(s))
3338                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3339
3340         if (old_length <= 3 || old_length <= new_length)
3341                 return strndup(s, old_length);
3342
3343         x = (new_length * percent) / 100;
3344
3345         if (x > new_length - 3)
3346                 x = new_length - 3;
3347
3348         k = 0;
3349         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3350                 int c;
3351
3352                 c = utf8_encoded_to_unichar(i);
3353                 if (c < 0)
3354                         return NULL;
3355                 k += unichar_iswide(c) ? 2 : 1;
3356         }
3357
3358         if (k > x) /* last character was wide and went over quota */
3359                 x ++;
3360
3361         for (j = s + old_length; k < new_length && j > i; ) {
3362                 int c;
3363
3364                 j = utf8_prev_char(j);
3365                 c = utf8_encoded_to_unichar(j);
3366                 if (c < 0)
3367                         return NULL;
3368                 k += unichar_iswide(c) ? 2 : 1;
3369         }
3370         assert(i <= j);
3371
3372         /* we don't actually need to ellipsize */
3373         if (i == j)
3374                 return memdup(s, old_length + 1);
3375
3376         /* make space for ellipsis */
3377         j = utf8_next_char(j);
3378
3379         len = i - s;
3380         len2 = s + old_length - j;
3381         e = new(char, len + 3 + len2 + 1);
3382         if (!e)
3383                 return NULL;
3384
3385         /*
3386         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3387                old_length, new_length, x, len, len2, k);
3388         */
3389
3390         memcpy(e, s, len);
3391         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3392         e[len + 1] = 0x80;
3393         e[len + 2] = 0xa6;
3394
3395         memcpy(e + len + 3, j, len2 + 1);
3396
3397         return e;
3398 }
3399
3400 char *ellipsize(const char *s, size_t length, unsigned percent) {
3401         return ellipsize_mem(s, strlen(s), length, percent);
3402 }
3403
3404 int touch(const char *path) {
3405         int fd;
3406
3407         assert(path);
3408
3409         /* This just opens the file for writing, ensuring it
3410          * exists. It doesn't call utimensat() the way /usr/bin/touch
3411          * does it. */
3412
3413         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3414         if (fd < 0)
3415                 return -errno;
3416
3417         close_nointr_nofail(fd);
3418         return 0;
3419 }
3420
3421 char *unquote(const char *s, const char* quotes) {
3422         size_t l;
3423         assert(s);
3424
3425         /* This is rather stupid, simply removes the heading and
3426          * trailing quotes if there is one. Doesn't care about
3427          * escaping or anything. We should make this smarter one
3428          * day...*/
3429
3430         l = strlen(s);
3431         if (l < 2)
3432                 return strdup(s);
3433
3434         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3435                 return strndup(s+1, l-2);
3436
3437         return strdup(s);
3438 }
3439
3440 char *normalize_env_assignment(const char *s) {
3441         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3442         char *eq, *r;
3443
3444         eq = strchr(s, '=');
3445         if (!eq) {
3446                 char *t;
3447
3448                 r = strdup(s);
3449                 if (!r)
3450                         return NULL;
3451
3452                 t = strstrip(r);
3453                 if (t == r)
3454                         return r;
3455
3456                 memmove(r, t, strlen(t) + 1);
3457                 return r;
3458         }
3459
3460         name = strndup(s, eq - s);
3461         if (!name)
3462                 return NULL;
3463
3464         p = strdup(eq + 1);
3465         if (!p)
3466                 return NULL;
3467
3468         value = unquote(strstrip(p), QUOTES);
3469         if (!value)
3470                 return NULL;
3471
3472         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3473                 r = NULL;
3474
3475         return r;
3476 }
3477
3478 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3479         siginfo_t dummy;
3480
3481         assert(pid >= 1);
3482
3483         if (!status)
3484                 status = &dummy;
3485
3486         for (;;) {
3487                 zero(*status);
3488
3489                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3490
3491                         if (errno == EINTR)
3492                                 continue;
3493
3494                         return -errno;
3495                 }
3496
3497                 return 0;
3498         }
3499 }
3500
3501 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3502         int r;
3503         siginfo_t status;
3504
3505         assert(name);
3506         assert(pid > 1);
3507
3508         r = wait_for_terminate(pid, &status);
3509         if (r < 0) {
3510                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3511                 return r;
3512         }
3513
3514         if (status.si_code == CLD_EXITED) {
3515                 if (status.si_status != 0) {
3516                         log_warning("%s failed with error code %i.", name, status.si_status);
3517                         return status.si_status;
3518                 }
3519
3520                 log_debug("%s succeeded.", name);
3521                 return 0;
3522
3523         } else if (status.si_code == CLD_KILLED ||
3524                    status.si_code == CLD_DUMPED) {
3525
3526                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3527                 return -EPROTO;
3528         }
3529
3530         log_warning("%s failed due to unknown reason.", name);
3531         return -EPROTO;
3532 }
3533
3534 _noreturn_ void freeze(void) {
3535
3536         /* Make sure nobody waits for us on a socket anymore */
3537         close_all_fds(NULL, 0);
3538
3539         sync();
3540
3541         for (;;)
3542                 pause();
3543 }
3544
3545 bool null_or_empty(struct stat *st) {
3546         assert(st);
3547
3548         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3549                 return true;
3550
3551         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3552                 return true;
3553
3554         return false;
3555 }
3556
3557 int null_or_empty_path(const char *fn) {
3558         struct stat st;
3559
3560         assert(fn);
3561
3562         if (stat(fn, &st) < 0)
3563                 return -errno;
3564
3565         return null_or_empty(&st);
3566 }
3567
3568 DIR *xopendirat(int fd, const char *name, int flags) {
3569         int nfd;
3570         DIR *d;
3571
3572         assert(!(flags & O_CREAT));
3573
3574         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3575         if (nfd < 0)
3576                 return NULL;
3577
3578         d = fdopendir(nfd);
3579         if (!d) {
3580                 close_nointr_nofail(nfd);
3581                 return NULL;
3582         }
3583
3584         return d;
3585 }
3586
3587 int signal_from_string_try_harder(const char *s) {
3588         int signo;
3589         assert(s);
3590
3591         signo = signal_from_string(s);
3592         if (signo <= 0)
3593                 if (startswith(s, "SIG"))
3594                         return signal_from_string(s+3);
3595
3596         return signo;
3597 }
3598
3599 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3600         _cleanup_free_ char *t = NULL, *u = NULL;
3601         char *dn;
3602         size_t enc_len;
3603
3604         u = unquote(tagvalue, "\"\'");
3605         if (u == NULL)
3606                 return NULL;
3607
3608         enc_len = strlen(u) * 4 + 1;
3609         t = new(char, enc_len);
3610         if (t == NULL)
3611                 return NULL;
3612
3613         if (encode_devnode_name(u, t, enc_len) < 0)
3614                 return NULL;
3615
3616         if (asprintf(&dn, "/dev/disk/by-%s/%s", by, t) < 0)
3617                 return NULL;
3618
3619         return dn;
3620 }
3621
3622 char *fstab_node_to_udev_node(const char *p) {
3623         assert(p);
3624
3625         if (startswith(p, "LABEL="))
3626                 return tag_to_udev_node(p+6, "label");
3627
3628         if (startswith(p, "UUID="))
3629                 return tag_to_udev_node(p+5, "uuid");
3630
3631         if (startswith(p, "PARTUUID="))
3632                 return tag_to_udev_node(p+9, "partuuid");
3633
3634         if (startswith(p, "PARTLABEL="))
3635                 return tag_to_udev_node(p+10, "partlabel");
3636
3637         return strdup(p);
3638 }
3639
3640 bool tty_is_vc(const char *tty) {
3641         assert(tty);
3642
3643         if (startswith(tty, "/dev/"))
3644                 tty += 5;
3645
3646         return vtnr_from_tty(tty) >= 0;
3647 }
3648
3649 bool tty_is_console(const char *tty) {
3650         assert(tty);
3651
3652         if (startswith(tty, "/dev/"))
3653                 tty += 5;
3654
3655         return streq(tty, "console");
3656 }
3657
3658 int vtnr_from_tty(const char *tty) {
3659         int i, r;
3660
3661         assert(tty);
3662
3663         if (startswith(tty, "/dev/"))
3664                 tty += 5;
3665
3666         if (!startswith(tty, "tty") )
3667                 return -EINVAL;
3668
3669         if (tty[3] < '0' || tty[3] > '9')
3670                 return -EINVAL;
3671
3672         r = safe_atoi(tty+3, &i);
3673         if (r < 0)
3674                 return r;
3675
3676         if (i < 0 || i > 63)
3677                 return -EINVAL;
3678
3679         return i;
3680 }
3681
3682 char *resolve_dev_console(char **active) {
3683         char *tty;
3684
3685         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3686          * (i.e. not read-only-mounted which is a sign for container setups) */
3687
3688         if (path_is_read_only_fs("/sys") > 0)
3689                 return NULL;
3690
3691         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3692                 return NULL;
3693
3694         /* If multiple log outputs are configured the last one is what
3695          * /dev/console points to */
3696         tty = strrchr(*active, ' ');
3697         if (tty)
3698                 tty++;
3699         else
3700                 tty = *active;
3701
3702         if (streq(tty, "tty0")) {
3703                 char *tmp;
3704
3705                 /* Get the active VC (e.g. tty1) */
3706                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3707                         free(*active);
3708                         tty = *active = tmp;
3709                 }
3710         }
3711
3712         return tty;
3713 }
3714
3715 bool tty_is_vc_resolve(const char *tty) {
3716         _cleanup_free_ char *active = NULL;
3717
3718         assert(tty);
3719
3720         if (startswith(tty, "/dev/"))
3721                 tty += 5;
3722
3723         if (streq(tty, "console")) {
3724                 tty = resolve_dev_console(&active);
3725                 if (!tty)
3726                         return false;
3727         }
3728
3729         return tty_is_vc(tty);
3730 }
3731
3732 const char *default_term_for_tty(const char *tty) {
3733         assert(tty);
3734
3735         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3736 }
3737
3738 bool dirent_is_file(const struct dirent *de) {
3739         assert(de);
3740
3741         if (ignore_file(de->d_name))
3742                 return false;
3743
3744         if (de->d_type != DT_REG &&
3745             de->d_type != DT_LNK &&
3746             de->d_type != DT_UNKNOWN)
3747                 return false;
3748
3749         return true;
3750 }
3751
3752 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3753         assert(de);
3754
3755         if (de->d_type != DT_REG &&
3756             de->d_type != DT_LNK &&
3757             de->d_type != DT_UNKNOWN)
3758                 return false;
3759
3760         if (ignore_file_allow_backup(de->d_name))
3761                 return false;
3762
3763         return endswith(de->d_name, suffix);
3764 }
3765
3766 void execute_directory(const char *directory, DIR *d, char *argv[]) {
3767         DIR *_d = NULL;
3768         struct dirent *de;
3769         Hashmap *pids = NULL;
3770
3771         assert(directory);
3772
3773         /* Executes all binaries in a directory in parallel and
3774          * waits for them to finish. */
3775
3776         if (!d) {
3777                 if (!(_d = opendir(directory))) {
3778
3779                         if (errno == ENOENT)
3780                                 return;
3781
3782                         log_error("Failed to enumerate directory %s: %m", directory);
3783                         return;
3784                 }
3785
3786                 d = _d;
3787         }
3788
3789         if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
3790                 log_error("Failed to allocate set.");
3791                 goto finish;
3792         }
3793
3794         while ((de = readdir(d))) {
3795                 char *path;
3796                 pid_t pid;
3797                 int k;
3798
3799                 if (!dirent_is_file(de))
3800                         continue;
3801
3802                 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3803                         log_oom();
3804                         continue;
3805                 }
3806
3807                 if ((pid = fork()) < 0) {
3808                         log_error("Failed to fork: %m");
3809                         free(path);
3810                         continue;
3811                 }
3812
3813                 if (pid == 0) {
3814                         char *_argv[2];
3815                         /* Child */
3816
3817                         if (!argv) {
3818                                 _argv[0] = path;
3819                                 _argv[1] = NULL;
3820                                 argv = _argv;
3821                         } else
3822                                 argv[0] = path;
3823
3824                         execv(path, argv);
3825
3826                         log_error("Failed to execute %s: %m", path);
3827                         _exit(EXIT_FAILURE);
3828                 }
3829
3830                 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
3831
3832                 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
3833                         log_error("Failed to add PID to set: %s", strerror(-k));
3834                         free(path);
3835                 }
3836         }
3837
3838         while (!hashmap_isempty(pids)) {
3839                 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
3840                 siginfo_t si = {};
3841                 char *path;
3842
3843                 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
3844
3845                         if (errno == EINTR)
3846                                 continue;
3847
3848                         log_error("waitid() failed: %m");
3849                         goto finish;
3850                 }
3851
3852                 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
3853                         if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
3854                                 if (si.si_code == CLD_EXITED)
3855                                         log_error("%s exited with exit status %i.", path, si.si_status);
3856                                 else
3857                                         log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
3858                         } else
3859                                 log_debug("%s exited successfully.", path);
3860
3861                         free(path);
3862                 }
3863         }
3864
3865 finish:
3866         if (_d)
3867                 closedir(_d);
3868
3869         if (pids)
3870                 hashmap_free_free(pids);
3871 }
3872
3873 int kill_and_sigcont(pid_t pid, int sig) {
3874         int r;
3875
3876         r = kill(pid, sig) < 0 ? -errno : 0;
3877
3878         if (r >= 0)
3879                 kill(pid, SIGCONT);
3880
3881         return r;
3882 }
3883
3884 bool nulstr_contains(const char*nulstr, const char *needle) {
3885         const char *i;
3886
3887         if (!nulstr)
3888                 return false;
3889
3890         NULSTR_FOREACH(i, nulstr)
3891                 if (streq(i, needle))
3892                         return true;
3893
3894         return false;
3895 }
3896
3897 bool plymouth_running(void) {
3898         return access("/run/plymouth/pid", F_OK) >= 0;
3899 }
3900
3901 char* strshorten(char *s, size_t l) {
3902         assert(s);
3903
3904         if (l < strlen(s))
3905                 s[l] = 0;
3906
3907         return s;
3908 }
3909
3910 static bool hostname_valid_char(char c) {
3911         return
3912                 (c >= 'a' && c <= 'z') ||
3913                 (c >= 'A' && c <= 'Z') ||
3914                 (c >= '0' && c <= '9') ||
3915                 c == '-' ||
3916                 c == '_' ||
3917                 c == '.';
3918 }
3919
3920 bool hostname_is_valid(const char *s) {
3921         const char *p;
3922         bool dot;
3923
3924         if (isempty(s))
3925                 return false;
3926
3927         for (p = s, dot = true; *p; p++) {
3928                 if (*p == '.') {
3929                         if (dot)
3930                                 return false;
3931
3932                         dot = true;
3933                 } else {
3934                         if (!hostname_valid_char(*p))
3935                                 return false;
3936
3937                         dot = false;
3938                 }
3939         }
3940
3941         if (dot)
3942                 return false;
3943
3944         if (p-s > HOST_NAME_MAX)
3945                 return false;
3946
3947         return true;
3948 }
3949
3950 char* hostname_cleanup(char *s, bool lowercase) {
3951         char *p, *d;
3952         bool dot;
3953
3954         for (p = s, d = s, dot = true; *p; p++) {
3955                 if (*p == '.') {
3956                         if (dot)
3957                                 continue;
3958
3959                         *(d++) = '.';
3960                         dot = true;
3961                 } else if (hostname_valid_char(*p)) {
3962                         *(d++) = lowercase ? tolower(*p) : *p;
3963                         dot = false;
3964                 }
3965
3966         }
3967
3968         if (dot && d > s)
3969                 d[-1] = 0;
3970         else
3971                 *d = 0;
3972
3973         strshorten(s, HOST_NAME_MAX);
3974
3975         return s;
3976 }
3977
3978 int pipe_eof(int fd) {
3979         int r;
3980         struct pollfd pollfd = {
3981                 .fd = fd,
3982                 .events = POLLIN|POLLHUP,
3983         };
3984
3985         r = poll(&pollfd, 1, 0);
3986         if (r < 0)
3987                 return -errno;
3988
3989         if (r == 0)
3990                 return 0;
3991
3992         return pollfd.revents & POLLHUP;
3993 }
3994
3995 int fd_wait_for_event(int fd, int event, usec_t t) {
3996         int r;
3997         struct pollfd pollfd = {
3998                 .fd = fd,
3999                 .events = event,
4000         };
4001
4002         r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
4003         if (r < 0)
4004                 return -errno;
4005
4006         if (r == 0)
4007                 return 0;
4008
4009         return pollfd.revents;
4010 }
4011
4012 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4013         FILE *f;
4014         char *t;
4015         const char *fn;
4016         size_t k;
4017         int fd;
4018
4019         assert(path);
4020         assert(_f);
4021         assert(_temp_path);
4022
4023         t = new(char, strlen(path) + 1 + 6 + 1);
4024         if (!t)
4025                 return -ENOMEM;
4026
4027         fn = path_get_file_name(path);
4028         k = fn-path;
4029         memcpy(t, path, k);
4030         t[k] = '.';
4031         stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
4032
4033         fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
4034         if (fd < 0) {
4035                 free(t);
4036                 return -errno;
4037         }
4038
4039         f = fdopen(fd, "we");
4040         if (!f) {
4041                 unlink(t);
4042                 free(t);
4043                 return -errno;
4044         }
4045
4046         *_f = f;
4047         *_temp_path = t;
4048
4049         return 0;
4050 }
4051
4052 int terminal_vhangup_fd(int fd) {
4053         assert(fd >= 0);
4054
4055         if (ioctl(fd, TIOCVHANGUP) < 0)
4056                 return -errno;
4057
4058         return 0;
4059 }
4060
4061 int terminal_vhangup(const char *name) {
4062         int fd, r;
4063
4064         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4065         if (fd < 0)
4066                 return fd;
4067
4068         r = terminal_vhangup_fd(fd);
4069         close_nointr_nofail(fd);
4070
4071         return r;
4072 }
4073
4074 int vt_disallocate(const char *name) {
4075         int fd, r;
4076         unsigned u;
4077
4078         /* Deallocate the VT if possible. If not possible
4079          * (i.e. because it is the active one), at least clear it
4080          * entirely (including the scrollback buffer) */
4081
4082         if (!startswith(name, "/dev/"))
4083                 return -EINVAL;
4084
4085         if (!tty_is_vc(name)) {
4086                 /* So this is not a VT. I guess we cannot deallocate
4087                  * it then. But let's at least clear the screen */
4088
4089                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4090                 if (fd < 0)
4091                         return fd;
4092
4093                 loop_write(fd,
4094                            "\033[r"    /* clear scrolling region */
4095                            "\033[H"    /* move home */
4096                            "\033[2J",  /* clear screen */
4097                            10, false);
4098                 close_nointr_nofail(fd);
4099
4100                 return 0;
4101         }
4102
4103         if (!startswith(name, "/dev/tty"))
4104                 return -EINVAL;
4105
4106         r = safe_atou(name+8, &u);
4107         if (r < 0)
4108                 return r;
4109
4110         if (u <= 0)
4111                 return -EINVAL;
4112
4113         /* Try to deallocate */
4114         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4115         if (fd < 0)
4116                 return fd;
4117
4118         r = ioctl(fd, VT_DISALLOCATE, u);
4119         close_nointr_nofail(fd);
4120
4121         if (r >= 0)
4122                 return 0;
4123
4124         if (errno != EBUSY)
4125                 return -errno;
4126
4127         /* Couldn't deallocate, so let's clear it fully with
4128          * scrollback */
4129         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4130         if (fd < 0)
4131                 return fd;
4132
4133         loop_write(fd,
4134                    "\033[r"   /* clear scrolling region */
4135                    "\033[H"   /* move home */
4136                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4137                    10, false);
4138         close_nointr_nofail(fd);
4139
4140         return 0;
4141 }
4142
4143 int copy_file(const char *from, const char *to, int flags) {
4144         _cleanup_close_ int fdf = -1;
4145         int r, fdt;
4146
4147         assert(from);
4148         assert(to);
4149
4150         fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4151         if (fdf < 0)
4152                 return -errno;
4153
4154         fdt = open(to, flags|O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
4155         if (fdt < 0)
4156                 return -errno;
4157
4158         for (;;) {
4159                 char buf[PIPE_BUF];
4160                 ssize_t n, k;
4161
4162                 n = read(fdf, buf, sizeof(buf));
4163                 if (n < 0) {
4164                         r = -errno;
4165
4166                         close_nointr(fdt);
4167                         unlink(to);
4168
4169                         return r;
4170                 }
4171
4172                 if (n == 0)
4173                         break;
4174
4175                 errno = 0;
4176                 k = loop_write(fdt, buf, n, false);
4177                 if (n != k) {
4178                         r = k < 0 ? k : (errno ? -errno : -EIO);
4179
4180                         close_nointr(fdt);
4181                         unlink(to);
4182
4183                         return r;
4184                 }
4185         }
4186
4187         r = close_nointr(fdt);
4188
4189         if (r < 0) {
4190                 unlink(to);
4191                 return r;
4192         }
4193
4194         return 0;
4195 }
4196
4197 int symlink_atomic(const char *from, const char *to) {
4198         char *x;
4199         _cleanup_free_ char *t;
4200         const char *fn;
4201         size_t k;
4202         unsigned long long ull;
4203         unsigned i;
4204         int r;
4205
4206         assert(from);
4207         assert(to);
4208
4209         t = new(char, strlen(to) + 1 + 16 + 1);
4210         if (!t)
4211                 return -ENOMEM;
4212
4213         fn = path_get_file_name(to);
4214         k = fn-to;
4215         memcpy(t, to, k);
4216         t[k] = '.';
4217         x = stpcpy(t+k+1, fn);
4218
4219         ull = random_ull();
4220         for (i = 0; i < 16; i++) {
4221                 *(x++) = hexchar(ull & 0xF);
4222                 ull >>= 4;
4223         }
4224
4225         *x = 0;
4226
4227         if (symlink(from, t) < 0)
4228                 return -errno;
4229
4230         if (rename(t, to) < 0) {
4231                 r = -errno;
4232                 unlink(t);
4233                 return r;
4234         }
4235
4236         return 0;
4237 }
4238
4239 bool display_is_local(const char *display) {
4240         assert(display);
4241
4242         return
4243                 display[0] == ':' &&
4244                 display[1] >= '0' &&
4245                 display[1] <= '9';
4246 }
4247
4248 int socket_from_display(const char *display, char **path) {
4249         size_t k;
4250         char *f, *c;
4251
4252         assert(display);
4253         assert(path);
4254
4255         if (!display_is_local(display))
4256                 return -EINVAL;
4257
4258         k = strspn(display+1, "0123456789");
4259
4260         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
4261         if (!f)
4262                 return -ENOMEM;
4263
4264         c = stpcpy(f, "/tmp/.X11-unix/X");
4265         memcpy(c, display+1, k);
4266         c[k] = 0;
4267
4268         *path = f;
4269
4270         return 0;
4271 }
4272
4273 int get_user_creds(
4274                 const char **username,
4275                 uid_t *uid, gid_t *gid,
4276                 const char **home,
4277                 const char **shell) {
4278
4279         struct passwd *p;
4280         uid_t u;
4281
4282         assert(username);
4283         assert(*username);
4284
4285         /* We enforce some special rules for uid=0: in order to avoid
4286          * NSS lookups for root we hardcode its data. */
4287
4288         if (streq(*username, "root") || streq(*username, "0")) {
4289                 *username = "root";
4290
4291                 if (uid)
4292                         *uid = 0;
4293
4294                 if (gid)
4295                         *gid = 0;
4296
4297                 if (home)
4298                         *home = "/root";
4299
4300                 if (shell)
4301                         *shell = "/bin/sh";
4302
4303                 return 0;
4304         }
4305
4306         if (parse_uid(*username, &u) >= 0) {
4307                 errno = 0;
4308                 p = getpwuid(u);
4309
4310                 /* If there are multiple users with the same id, make
4311                  * sure to leave $USER to the configured value instead
4312                  * of the first occurrence in the database. However if
4313                  * the uid was configured by a numeric uid, then let's
4314                  * pick the real username from /etc/passwd. */
4315                 if (p)
4316                         *username = p->pw_name;
4317         } else {
4318                 errno = 0;
4319                 p = getpwnam(*username);
4320         }
4321
4322         if (!p)
4323                 return errno > 0 ? -errno : -ESRCH;
4324
4325         if (uid)
4326                 *uid = p->pw_uid;
4327
4328         if (gid)
4329                 *gid = p->pw_gid;
4330
4331         if (home)
4332                 *home = p->pw_dir;
4333
4334         if (shell)
4335                 *shell = p->pw_shell;
4336
4337         return 0;
4338 }
4339
4340 char* uid_to_name(uid_t uid) {
4341         struct passwd *p;
4342         char *r;
4343
4344         if (uid == 0)
4345                 return strdup("root");
4346
4347         p = getpwuid(uid);
4348         if (p)
4349                 return strdup(p->pw_name);
4350
4351         if (asprintf(&r, "%lu", (unsigned long) uid) < 0)
4352                 return NULL;
4353
4354         return r;
4355 }
4356
4357 char* gid_to_name(gid_t gid) {
4358         struct group *p;
4359         char *r;
4360
4361         if (gid == 0)
4362                 return strdup("root");
4363
4364         p = getgrgid(gid);
4365         if (p)
4366                 return strdup(p->gr_name);
4367
4368         if (asprintf(&r, "%lu", (unsigned long) gid) < 0)
4369                 return NULL;
4370
4371         return r;
4372 }
4373
4374 int get_group_creds(const char **groupname, gid_t *gid) {
4375         struct group *g;
4376         gid_t id;
4377
4378         assert(groupname);
4379
4380         /* We enforce some special rules for gid=0: in order to avoid
4381          * NSS lookups for root we hardcode its data. */
4382
4383         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4384                 *groupname = "root";
4385
4386                 if (gid)
4387                         *gid = 0;
4388
4389                 return 0;
4390         }
4391
4392         if (parse_gid(*groupname, &id) >= 0) {
4393                 errno = 0;
4394                 g = getgrgid(id);
4395
4396                 if (g)
4397                         *groupname = g->gr_name;
4398         } else {
4399                 errno = 0;
4400                 g = getgrnam(*groupname);
4401         }
4402
4403         if (!g)
4404                 return errno > 0 ? -errno : -ESRCH;
4405
4406         if (gid)
4407                 *gid = g->gr_gid;
4408
4409         return 0;
4410 }
4411
4412 int in_gid(gid_t gid) {
4413         gid_t *gids;
4414         int ngroups_max, r, i;
4415
4416         if (getgid() == gid)
4417                 return 1;
4418
4419         if (getegid() == gid)
4420                 return 1;
4421
4422         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4423         assert(ngroups_max > 0);
4424
4425         gids = alloca(sizeof(gid_t) * ngroups_max);
4426
4427         r = getgroups(ngroups_max, gids);
4428         if (r < 0)
4429                 return -errno;
4430
4431         for (i = 0; i < r; i++)
4432                 if (gids[i] == gid)
4433                         return 1;
4434
4435         return 0;
4436 }
4437
4438 int in_group(const char *name) {
4439         int r;
4440         gid_t gid;
4441
4442         r = get_group_creds(&name, &gid);
4443         if (r < 0)
4444                 return r;
4445
4446         return in_gid(gid);
4447 }
4448
4449 int glob_exists(const char *path) {
4450         _cleanup_globfree_ glob_t g = {};
4451         int k;
4452
4453         assert(path);
4454
4455         errno = 0;
4456         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4457
4458         if (k == GLOB_NOMATCH)
4459                 return 0;
4460         else if (k == GLOB_NOSPACE)
4461                 return -ENOMEM;
4462         else if (k == 0)
4463                 return !strv_isempty(g.gl_pathv);
4464         else
4465                 return errno ? -errno : -EIO;
4466 }
4467
4468 int glob_extend(char ***strv, const char *path) {
4469         _cleanup_globfree_ glob_t g = {};
4470         int k;
4471         char **p;
4472
4473         errno = 0;
4474         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4475
4476         if (k == GLOB_NOMATCH)
4477                 return -ENOENT;
4478         else if (k == GLOB_NOSPACE)
4479                 return -ENOMEM;
4480         else if (k != 0 || strv_isempty(g.gl_pathv))
4481                 return errno ? -errno : -EIO;
4482
4483         STRV_FOREACH(p, g.gl_pathv) {
4484                 k = strv_extend(strv, *p);
4485                 if (k < 0)
4486                         break;
4487         }
4488
4489         return k;
4490 }
4491
4492 int dirent_ensure_type(DIR *d, struct dirent *de) {
4493         struct stat st;
4494
4495         assert(d);
4496         assert(de);
4497
4498         if (de->d_type != DT_UNKNOWN)
4499                 return 0;
4500
4501         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4502                 return -errno;
4503
4504         de->d_type =
4505                 S_ISREG(st.st_mode)  ? DT_REG  :
4506                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4507                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4508                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4509                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4510                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4511                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4512                                        DT_UNKNOWN;
4513
4514         return 0;
4515 }
4516
4517 int in_search_path(const char *path, char **search) {
4518         char **i;
4519         _cleanup_free_ char *parent = NULL;
4520         int r;
4521
4522         r = path_get_parent(path, &parent);
4523         if (r < 0)
4524                 return r;
4525
4526         STRV_FOREACH(i, search)
4527                 if (path_equal(parent, *i))
4528                         return 1;
4529
4530         return 0;
4531 }
4532
4533 int get_files_in_directory(const char *path, char ***list) {
4534         _cleanup_closedir_ DIR *d = NULL;
4535         size_t bufsize = 0, n = 0;
4536         _cleanup_strv_free_ char **l = NULL;
4537
4538         assert(path);
4539
4540         /* Returns all files in a directory in *list, and the number
4541          * of files as return value. If list is NULL returns only the
4542          * number. */
4543
4544         d = opendir(path);
4545         if (!d)
4546                 return -errno;
4547
4548         for (;;) {
4549                 struct dirent *de;
4550                 union dirent_storage buf;
4551                 int k;
4552
4553                 k = readdir_r(d, &buf.de, &de);
4554                 assert(k >= 0);
4555                 if (k > 0)
4556                         return -k;
4557                 if (!de)
4558                         break;
4559
4560                 dirent_ensure_type(d, de);
4561
4562                 if (!dirent_is_file(de))
4563                         continue;
4564
4565                 if (list) {
4566                         /* one extra slot is needed for the terminating NULL */
4567                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
4568                                 return -ENOMEM;
4569
4570                         l[n] = strdup(de->d_name);
4571                         if (!l[n])
4572                                 return -ENOMEM;
4573
4574                         l[++n] = NULL;
4575                 } else
4576                         n++;
4577         }
4578
4579         if (list) {
4580                 *list = l;
4581                 l = NULL; /* avoid freeing */
4582         }
4583
4584         return n;
4585 }
4586
4587 char *strjoin(const char *x, ...) {
4588         va_list ap;
4589         size_t l;
4590         char *r, *p;
4591
4592         va_start(ap, x);
4593
4594         if (x) {
4595                 l = strlen(x);
4596
4597                 for (;;) {
4598                         const char *t;
4599                         size_t n;
4600
4601                         t = va_arg(ap, const char *);
4602                         if (!t)
4603                                 break;
4604
4605                         n = strlen(t);
4606                         if (n > ((size_t) -1) - l) {
4607                                 va_end(ap);
4608                                 return NULL;
4609                         }
4610
4611                         l += n;
4612                 }
4613         } else
4614                 l = 0;
4615
4616         va_end(ap);
4617
4618         r = new(char, l+1);
4619         if (!r)
4620                 return NULL;
4621
4622         if (x) {
4623                 p = stpcpy(r, x);
4624
4625                 va_start(ap, x);
4626
4627                 for (;;) {
4628                         const char *t;
4629
4630                         t = va_arg(ap, const char *);
4631                         if (!t)
4632                                 break;
4633
4634                         p = stpcpy(p, t);
4635                 }
4636
4637                 va_end(ap);
4638         } else
4639                 r[0] = 0;
4640
4641         return r;
4642 }
4643
4644 bool is_main_thread(void) {
4645         static __thread int cached = 0;
4646
4647         if (_unlikely_(cached == 0))
4648                 cached = getpid() == gettid() ? 1 : -1;
4649
4650         return cached > 0;
4651 }
4652
4653 int block_get_whole_disk(dev_t d, dev_t *ret) {
4654         char *p, *s;
4655         int r;
4656         unsigned n, m;
4657
4658         assert(ret);
4659
4660         /* If it has a queue this is good enough for us */
4661         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4662                 return -ENOMEM;
4663
4664         r = access(p, F_OK);
4665         free(p);
4666
4667         if (r >= 0) {
4668                 *ret = d;
4669                 return 0;
4670         }
4671
4672         /* If it is a partition find the originating device */
4673         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4674                 return -ENOMEM;
4675
4676         r = access(p, F_OK);
4677         free(p);
4678
4679         if (r < 0)
4680                 return -ENOENT;
4681
4682         /* Get parent dev_t */
4683         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4684                 return -ENOMEM;
4685
4686         r = read_one_line_file(p, &s);
4687         free(p);
4688
4689         if (r < 0)
4690                 return r;
4691
4692         r = sscanf(s, "%u:%u", &m, &n);
4693         free(s);
4694
4695         if (r != 2)
4696                 return -EINVAL;
4697
4698         /* Only return this if it is really good enough for us. */
4699         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4700                 return -ENOMEM;
4701
4702         r = access(p, F_OK);
4703         free(p);
4704
4705         if (r >= 0) {
4706                 *ret = makedev(m, n);
4707                 return 0;
4708         }
4709
4710         return -ENOENT;
4711 }
4712
4713 int file_is_priv_sticky(const char *p) {
4714         struct stat st;
4715
4716         assert(p);
4717
4718         if (lstat(p, &st) < 0)
4719                 return -errno;
4720
4721         return
4722                 (st.st_uid == 0 || st.st_uid == getuid()) &&
4723                 (st.st_mode & S_ISVTX);
4724 }
4725
4726 static const char *const ioprio_class_table[] = {
4727         [IOPRIO_CLASS_NONE] = "none",
4728         [IOPRIO_CLASS_RT] = "realtime",
4729         [IOPRIO_CLASS_BE] = "best-effort",
4730         [IOPRIO_CLASS_IDLE] = "idle"
4731 };
4732
4733 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4734
4735 static const char *const sigchld_code_table[] = {
4736         [CLD_EXITED] = "exited",
4737         [CLD_KILLED] = "killed",
4738         [CLD_DUMPED] = "dumped",
4739         [CLD_TRAPPED] = "trapped",
4740         [CLD_STOPPED] = "stopped",
4741         [CLD_CONTINUED] = "continued",
4742 };
4743
4744 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4745
4746 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4747         [LOG_FAC(LOG_KERN)] = "kern",
4748         [LOG_FAC(LOG_USER)] = "user",
4749         [LOG_FAC(LOG_MAIL)] = "mail",
4750         [LOG_FAC(LOG_DAEMON)] = "daemon",
4751         [LOG_FAC(LOG_AUTH)] = "auth",
4752         [LOG_FAC(LOG_SYSLOG)] = "syslog",
4753         [LOG_FAC(LOG_LPR)] = "lpr",
4754         [LOG_FAC(LOG_NEWS)] = "news",
4755         [LOG_FAC(LOG_UUCP)] = "uucp",
4756         [LOG_FAC(LOG_CRON)] = "cron",
4757         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4758         [LOG_FAC(LOG_FTP)] = "ftp",
4759         [LOG_FAC(LOG_LOCAL0)] = "local0",
4760         [LOG_FAC(LOG_LOCAL1)] = "local1",
4761         [LOG_FAC(LOG_LOCAL2)] = "local2",
4762         [LOG_FAC(LOG_LOCAL3)] = "local3",
4763         [LOG_FAC(LOG_LOCAL4)] = "local4",
4764         [LOG_FAC(LOG_LOCAL5)] = "local5",
4765         [LOG_FAC(LOG_LOCAL6)] = "local6",
4766         [LOG_FAC(LOG_LOCAL7)] = "local7"
4767 };
4768
4769 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4770
4771 static const char *const log_level_table[] = {
4772         [LOG_EMERG] = "emerg",
4773         [LOG_ALERT] = "alert",
4774         [LOG_CRIT] = "crit",
4775         [LOG_ERR] = "err",
4776         [LOG_WARNING] = "warning",
4777         [LOG_NOTICE] = "notice",
4778         [LOG_INFO] = "info",
4779         [LOG_DEBUG] = "debug"
4780 };
4781
4782 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
4783
4784 static const char* const sched_policy_table[] = {
4785         [SCHED_OTHER] = "other",
4786         [SCHED_BATCH] = "batch",
4787         [SCHED_IDLE] = "idle",
4788         [SCHED_FIFO] = "fifo",
4789         [SCHED_RR] = "rr"
4790 };
4791
4792 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
4793
4794 static const char* const rlimit_table[] = {
4795         [RLIMIT_CPU] = "LimitCPU",
4796         [RLIMIT_FSIZE] = "LimitFSIZE",
4797         [RLIMIT_DATA] = "LimitDATA",
4798         [RLIMIT_STACK] = "LimitSTACK",
4799         [RLIMIT_CORE] = "LimitCORE",
4800         [RLIMIT_RSS] = "LimitRSS",
4801         [RLIMIT_NOFILE] = "LimitNOFILE",
4802         [RLIMIT_AS] = "LimitAS",
4803         [RLIMIT_NPROC] = "LimitNPROC",
4804         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
4805         [RLIMIT_LOCKS] = "LimitLOCKS",
4806         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
4807         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
4808         [RLIMIT_NICE] = "LimitNICE",
4809         [RLIMIT_RTPRIO] = "LimitRTPRIO",
4810         [RLIMIT_RTTIME] = "LimitRTTIME"
4811 };
4812
4813 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
4814
4815 static const char* const ip_tos_table[] = {
4816         [IPTOS_LOWDELAY] = "low-delay",
4817         [IPTOS_THROUGHPUT] = "throughput",
4818         [IPTOS_RELIABILITY] = "reliability",
4819         [IPTOS_LOWCOST] = "low-cost",
4820 };
4821
4822 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
4823
4824 static const char *const __signal_table[] = {
4825         [SIGHUP] = "HUP",
4826         [SIGINT] = "INT",
4827         [SIGQUIT] = "QUIT",
4828         [SIGILL] = "ILL",
4829         [SIGTRAP] = "TRAP",
4830         [SIGABRT] = "ABRT",
4831         [SIGBUS] = "BUS",
4832         [SIGFPE] = "FPE",
4833         [SIGKILL] = "KILL",
4834         [SIGUSR1] = "USR1",
4835         [SIGSEGV] = "SEGV",
4836         [SIGUSR2] = "USR2",
4837         [SIGPIPE] = "PIPE",
4838         [SIGALRM] = "ALRM",
4839         [SIGTERM] = "TERM",
4840 #ifdef SIGSTKFLT
4841         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
4842 #endif
4843         [SIGCHLD] = "CHLD",
4844         [SIGCONT] = "CONT",
4845         [SIGSTOP] = "STOP",
4846         [SIGTSTP] = "TSTP",
4847         [SIGTTIN] = "TTIN",
4848         [SIGTTOU] = "TTOU",
4849         [SIGURG] = "URG",
4850         [SIGXCPU] = "XCPU",
4851         [SIGXFSZ] = "XFSZ",
4852         [SIGVTALRM] = "VTALRM",
4853         [SIGPROF] = "PROF",
4854         [SIGWINCH] = "WINCH",
4855         [SIGIO] = "IO",
4856         [SIGPWR] = "PWR",
4857         [SIGSYS] = "SYS"
4858 };
4859
4860 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
4861
4862 const char *signal_to_string(int signo) {
4863         static __thread char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
4864         const char *name;
4865
4866         name = __signal_to_string(signo);
4867         if (name)
4868                 return name;
4869
4870         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
4871                 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
4872         else
4873                 snprintf(buf, sizeof(buf), "%d", signo);
4874
4875         return buf;
4876 }
4877
4878 int signal_from_string(const char *s) {
4879         int signo;
4880         int offset = 0;
4881         unsigned u;
4882
4883         signo = __signal_from_string(s);
4884         if (signo > 0)
4885                 return signo;
4886
4887         if (startswith(s, "RTMIN+")) {
4888                 s += 6;
4889                 offset = SIGRTMIN;
4890         }
4891         if (safe_atou(s, &u) >= 0) {
4892                 signo = (int) u + offset;
4893                 if (signo > 0 && signo < _NSIG)
4894                         return signo;
4895         }
4896         return -1;
4897 }
4898
4899 bool kexec_loaded(void) {
4900        bool loaded = false;
4901        char *s;
4902
4903        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
4904                if (s[0] == '1')
4905                        loaded = true;
4906                free(s);
4907        }
4908        return loaded;
4909 }
4910
4911 int strdup_or_null(const char *a, char **b) {
4912         char *c;
4913
4914         assert(b);
4915
4916         if (!a) {
4917                 *b = NULL;
4918                 return 0;
4919         }
4920
4921         c = strdup(a);
4922         if (!c)
4923                 return -ENOMEM;
4924
4925         *b = c;
4926         return 0;
4927 }
4928
4929 int prot_from_flags(int flags) {
4930
4931         switch (flags & O_ACCMODE) {
4932
4933         case O_RDONLY:
4934                 return PROT_READ;
4935
4936         case O_WRONLY:
4937                 return PROT_WRITE;
4938
4939         case O_RDWR:
4940                 return PROT_READ|PROT_WRITE;
4941
4942         default:
4943                 return -EINVAL;
4944         }
4945 }
4946
4947 char *format_bytes(char *buf, size_t l, off_t t) {
4948         unsigned i;
4949
4950         static const struct {
4951                 const char *suffix;
4952                 off_t factor;
4953         } table[] = {
4954                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4955                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
4956                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
4957                 { "G", 1024ULL*1024ULL*1024ULL },
4958                 { "M", 1024ULL*1024ULL },
4959                 { "K", 1024ULL },
4960         };
4961
4962         for (i = 0; i < ELEMENTSOF(table); i++) {
4963
4964                 if (t >= table[i].factor) {
4965                         snprintf(buf, l,
4966                                  "%llu.%llu%s",
4967                                  (unsigned long long) (t / table[i].factor),
4968                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
4969                                  table[i].suffix);
4970
4971                         goto finish;
4972                 }
4973         }
4974
4975         snprintf(buf, l, "%lluB", (unsigned long long) t);
4976
4977 finish:
4978         buf[l-1] = 0;
4979         return buf;
4980
4981 }
4982
4983 void* memdup(const void *p, size_t l) {
4984         void *r;
4985
4986         assert(p);
4987
4988         r = malloc(l);
4989         if (!r)
4990                 return NULL;
4991
4992         memcpy(r, p, l);
4993         return r;
4994 }
4995
4996 int fd_inc_sndbuf(int fd, size_t n) {
4997         int r, value;
4998         socklen_t l = sizeof(value);
4999
5000         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5001         if (r >= 0 &&
5002             l == sizeof(value) &&
5003             (size_t) value >= n*2)
5004                 return 0;
5005
5006         value = (int) n;
5007         r = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value));
5008         if (r < 0)
5009                 return -errno;
5010
5011         return 1;
5012 }
5013
5014 int fd_inc_rcvbuf(int fd, size_t n) {
5015         int r, value;
5016         socklen_t l = sizeof(value);
5017
5018         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5019         if (r >= 0 &&
5020             l == sizeof(value) &&
5021             (size_t) value >= n*2)
5022                 return 0;
5023
5024         value = (int) n;
5025         r = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
5026         if (r < 0)
5027                 return -errno;
5028
5029         return 1;
5030 }
5031
5032 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5033         pid_t parent_pid, agent_pid;
5034         int fd;
5035         bool stdout_is_tty, stderr_is_tty;
5036         unsigned n, i;
5037         va_list ap;
5038         char **l;
5039
5040         assert(pid);
5041         assert(path);
5042
5043         parent_pid = getpid();
5044
5045         /* Spawns a temporary TTY agent, making sure it goes away when
5046          * we go away */
5047
5048         agent_pid = fork();
5049         if (agent_pid < 0)
5050                 return -errno;
5051
5052         if (agent_pid != 0) {
5053                 *pid = agent_pid;
5054                 return 0;
5055         }
5056
5057         /* In the child:
5058          *
5059          * Make sure the agent goes away when the parent dies */
5060         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5061                 _exit(EXIT_FAILURE);
5062
5063         /* Check whether our parent died before we were able
5064          * to set the death signal */
5065         if (getppid() != parent_pid)
5066                 _exit(EXIT_SUCCESS);
5067
5068         /* Don't leak fds to the agent */
5069         close_all_fds(except, n_except);
5070
5071         stdout_is_tty = isatty(STDOUT_FILENO);
5072         stderr_is_tty = isatty(STDERR_FILENO);
5073
5074         if (!stdout_is_tty || !stderr_is_tty) {
5075                 /* Detach from stdout/stderr. and reopen
5076                  * /dev/tty for them. This is important to
5077                  * ensure that when systemctl is started via
5078                  * popen() or a similar call that expects to
5079                  * read EOF we actually do generate EOF and
5080                  * not delay this indefinitely by because we
5081                  * keep an unused copy of stdin around. */
5082                 fd = open("/dev/tty", O_WRONLY);
5083                 if (fd < 0) {
5084                         log_error("Failed to open /dev/tty: %m");
5085                         _exit(EXIT_FAILURE);
5086                 }
5087
5088                 if (!stdout_is_tty)
5089                         dup2(fd, STDOUT_FILENO);
5090
5091                 if (!stderr_is_tty)
5092                         dup2(fd, STDERR_FILENO);
5093
5094                 if (fd > 2)
5095                         close(fd);
5096         }
5097
5098         /* Count arguments */
5099         va_start(ap, path);
5100         for (n = 0; va_arg(ap, char*); n++)
5101                 ;
5102         va_end(ap);
5103
5104         /* Allocate strv */
5105         l = alloca(sizeof(char *) * (n + 1));
5106
5107         /* Fill in arguments */
5108         va_start(ap, path);
5109         for (i = 0; i <= n; i++)
5110                 l[i] = va_arg(ap, char*);
5111         va_end(ap);
5112
5113         execv(path, l);
5114         _exit(EXIT_FAILURE);
5115 }
5116
5117 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5118         struct rlimit highest, fixed;
5119
5120         assert(rlim);
5121
5122         if (setrlimit(resource, rlim) >= 0)
5123                 return 0;
5124
5125         if (errno != EPERM)
5126                 return -errno;
5127
5128         /* So we failed to set the desired setrlimit, then let's try
5129          * to get as close as we can */
5130         assert_se(getrlimit(resource, &highest) == 0);
5131
5132         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5133         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5134
5135         if (setrlimit(resource, &fixed) < 0)
5136                 return -errno;
5137
5138         return 0;
5139 }
5140
5141 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5142         _cleanup_fclose_ FILE *f = NULL;
5143         char *value = NULL;
5144         int r;
5145         bool done = false;
5146         size_t l;
5147         const char *path;
5148
5149         assert(pid >= 0);
5150         assert(field);
5151         assert(_value);
5152
5153         if (pid == 0)
5154                 path = "/proc/self/environ";
5155         else
5156                 path = procfs_file_alloca(pid, "environ");
5157
5158         f = fopen(path, "re");
5159         if (!f)
5160                 return -errno;
5161
5162         l = strlen(field);
5163         r = 0;
5164
5165         do {
5166                 char line[LINE_MAX];
5167                 unsigned i;
5168
5169                 for (i = 0; i < sizeof(line)-1; i++) {
5170                         int c;
5171
5172                         c = getc(f);
5173                         if (_unlikely_(c == EOF)) {
5174                                 done = true;
5175                                 break;
5176                         } else if (c == 0)
5177                                 break;
5178
5179                         line[i] = c;
5180                 }
5181                 line[i] = 0;
5182
5183                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5184                         value = strdup(line + l + 1);
5185                         if (!value)
5186                                 return -ENOMEM;
5187
5188                         r = 1;
5189                         break;
5190                 }
5191
5192         } while (!done);
5193
5194         *_value = value;
5195         return r;
5196 }
5197
5198 bool is_valid_documentation_url(const char *url) {
5199         assert(url);
5200
5201         if (startswith(url, "http://") && url[7])
5202                 return true;
5203
5204         if (startswith(url, "https://") && url[8])
5205                 return true;
5206
5207         if (startswith(url, "file:") && url[5])
5208                 return true;
5209
5210         if (startswith(url, "info:") && url[5])
5211                 return true;
5212
5213         if (startswith(url, "man:") && url[4])
5214                 return true;
5215
5216         return false;
5217 }
5218
5219 bool in_initrd(void) {
5220         static __thread int saved = -1;
5221         struct statfs s;
5222
5223         if (saved >= 0)
5224                 return saved;
5225
5226         /* We make two checks here:
5227          *
5228          * 1. the flag file /etc/initrd-release must exist
5229          * 2. the root file system must be a memory file system
5230          *
5231          * The second check is extra paranoia, since misdetecting an
5232          * initrd can have bad bad consequences due the initrd
5233          * emptying when transititioning to the main systemd.
5234          */
5235
5236         saved = access("/etc/initrd-release", F_OK) >= 0 &&
5237                 statfs("/", &s) >= 0 &&
5238                 is_temporary_fs(&s);
5239
5240         return saved;
5241 }
5242
5243 void warn_melody(void) {
5244         _cleanup_close_ int fd = -1;
5245
5246         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5247         if (fd < 0)
5248                 return;
5249
5250         /* Yeah, this is synchronous. Kinda sucks. But well... */
5251
5252         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5253         usleep(125*USEC_PER_MSEC);
5254
5255         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5256         usleep(125*USEC_PER_MSEC);
5257
5258         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5259         usleep(125*USEC_PER_MSEC);
5260
5261         ioctl(fd, KIOCSOUND, 0);
5262 }
5263
5264 int make_console_stdio(void) {
5265         int fd, r;
5266
5267         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5268
5269         fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5270         if (fd < 0) {
5271                 log_error("Failed to acquire terminal: %s", strerror(-fd));
5272                 return fd;
5273         }
5274
5275         r = make_stdio(fd);
5276         if (r < 0) {
5277                 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5278                 return r;
5279         }
5280
5281         return 0;
5282 }
5283
5284 int get_home_dir(char **_h) {
5285         char *h;
5286         const char *e;
5287         uid_t u;
5288         struct passwd *p;
5289
5290         assert(_h);
5291
5292         /* Take the user specified one */
5293         e = getenv("HOME");
5294         if (e) {
5295                 h = strdup(e);
5296                 if (!h)
5297                         return -ENOMEM;
5298
5299                 *_h = h;
5300                 return 0;
5301         }
5302
5303         /* Hardcode home directory for root to avoid NSS */
5304         u = getuid();
5305         if (u == 0) {
5306                 h = strdup("/root");
5307                 if (!h)
5308                         return -ENOMEM;
5309
5310                 *_h = h;
5311                 return 0;
5312         }
5313
5314         /* Check the database... */
5315         errno = 0;
5316         p = getpwuid(u);
5317         if (!p)
5318                 return errno > 0 ? -errno : -ESRCH;
5319
5320         if (!path_is_absolute(p->pw_dir))
5321                 return -EINVAL;
5322
5323         h = strdup(p->pw_dir);
5324         if (!h)
5325                 return -ENOMEM;
5326
5327         *_h = h;
5328         return 0;
5329 }
5330
5331 bool filename_is_safe(const char *p) {
5332
5333         if (isempty(p))
5334                 return false;
5335
5336         if (strchr(p, '/'))
5337                 return false;
5338
5339         if (streq(p, "."))
5340                 return false;
5341
5342         if (streq(p, ".."))
5343                 return false;
5344
5345         if (strlen(p) > FILENAME_MAX)
5346                 return false;
5347
5348         return true;
5349 }
5350
5351 bool string_is_safe(const char *p) {
5352         const char *t;
5353
5354         assert(p);
5355
5356         for (t = p; *t; t++) {
5357                 if (*t > 0 && *t < ' ')
5358                         return false;
5359
5360                 if (strchr("\\\"\'", *t))
5361                         return false;
5362         }
5363
5364         return true;
5365 }
5366
5367 /**
5368  * Check if a string contains control characters.
5369  * Spaces and tabs are not considered control characters.
5370  */
5371 bool string_has_cc(const char *p) {
5372         const char *t;
5373
5374         assert(p);
5375
5376         for (t = p; *t; t++)
5377                 if (*t > 0 && *t < ' ' && *t != '\t')
5378                         return true;
5379
5380         return false;
5381 }
5382
5383 bool path_is_safe(const char *p) {
5384
5385         if (isempty(p))
5386                 return false;
5387
5388         if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5389                 return false;
5390
5391         if (strlen(p) > PATH_MAX)
5392                 return false;
5393
5394         /* The following two checks are not really dangerous, but hey, they still are confusing */
5395         if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5396                 return false;
5397
5398         if (strstr(p, "//"))
5399                 return false;
5400
5401         return true;
5402 }
5403
5404 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5405 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5406                  int (*compar) (const void *, const void *, void *), void *arg) {
5407         size_t l, u, idx;
5408         const void *p;
5409         int comparison;
5410
5411         l = 0;
5412         u = nmemb;
5413         while (l < u) {
5414                 idx = (l + u) / 2;
5415                 p = (void *)(((const char *) base) + (idx * size));
5416                 comparison = compar(key, p, arg);
5417                 if (comparison < 0)
5418                         u = idx;
5419                 else if (comparison > 0)
5420                         l = idx + 1;
5421                 else
5422                         return (void *)p;
5423         }
5424         return NULL;
5425 }
5426
5427 bool is_locale_utf8(void) {
5428         const char *set;
5429         static int cached_answer = -1;
5430
5431         if (cached_answer >= 0)
5432                 goto out;
5433
5434         if (!setlocale(LC_ALL, "")) {
5435                 cached_answer = true;
5436                 goto out;
5437         }
5438
5439         set = nl_langinfo(CODESET);
5440         if (!set) {
5441                 cached_answer = true;
5442                 goto out;
5443         }
5444
5445         if(streq(set, "UTF-8")) {
5446                 cached_answer = true;
5447                 goto out;
5448         }
5449
5450         /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5451          * unset and everything can do to UTF-8 nowadays. */
5452         set = setlocale(LC_CTYPE, NULL);
5453         if (!set) {
5454                 cached_answer = true;
5455                 goto out;
5456         }
5457
5458         /* Check result, but ignore the result if C was set
5459          * explicitly. */
5460         cached_answer =
5461                 streq(set, "C") &&
5462                 !getenv("LC_ALL") &&
5463                 !getenv("LC_CTYPE") &&
5464                 !getenv("LANG");
5465
5466 out:
5467         return (bool) cached_answer;
5468 }
5469
5470 const char *draw_special_char(DrawSpecialChar ch) {
5471         static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5472                 /* UTF-8 */ {
5473                         [DRAW_TREE_VERT]          = "\342\224\202 ",            /* │  */
5474                         [DRAW_TREE_BRANCH]        = "\342\224\234\342\224\200", /* ├─ */
5475                         [DRAW_TREE_RIGHT]         = "\342\224\224\342\224\200", /* └─ */
5476                         [DRAW_TREE_SPACE]         = "  ",                       /*    */
5477                         [DRAW_TRIANGULAR_BULLET]  = "\342\200\243 ",            /* ‣  */
5478                         [DRAW_BLACK_CIRCLE]       = "\342\227\217 ",            /* ●  */
5479                 },
5480                 /* ASCII fallback */ {
5481                         [DRAW_TREE_VERT]          = "| ",
5482                         [DRAW_TREE_BRANCH]        = "|-",
5483                         [DRAW_TREE_RIGHT]         = "`-",
5484                         [DRAW_TREE_SPACE]         = "  ",
5485                         [DRAW_TRIANGULAR_BULLET]  = "> ",
5486                         [DRAW_BLACK_CIRCLE]       = "* ",
5487                 }
5488         };
5489
5490         return draw_table[!is_locale_utf8()][ch];
5491 }
5492
5493 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5494         const char *f;
5495         char *t, *r;
5496         size_t l, old_len, new_len;
5497
5498         assert(text);
5499         assert(old_string);
5500         assert(new_string);
5501
5502         old_len = strlen(old_string);
5503         new_len = strlen(new_string);
5504
5505         l = strlen(text);
5506         r = new(char, l+1);
5507         if (!r)
5508                 return NULL;
5509
5510         f = text;
5511         t = r;
5512         while (*f) {
5513                 char *a;
5514                 size_t d, nl;
5515
5516                 if (!startswith(f, old_string)) {
5517                         *(t++) = *(f++);
5518                         continue;
5519                 }
5520
5521                 d = t - r;
5522                 nl = l - old_len + new_len;
5523                 a = realloc(r, nl + 1);
5524                 if (!a)
5525                         goto oom;
5526
5527                 l = nl;
5528                 r = a;
5529                 t = r + d;
5530
5531                 t = stpcpy(t, new_string);
5532                 f += old_len;
5533         }
5534
5535         *t = 0;
5536         return r;
5537
5538 oom:
5539         free(r);
5540         return NULL;
5541 }
5542
5543 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5544         const char *i, *begin = NULL;
5545         enum {
5546                 STATE_OTHER,
5547                 STATE_ESCAPE,
5548                 STATE_BRACKET
5549         } state = STATE_OTHER;
5550         char *obuf = NULL;
5551         size_t osz = 0, isz;
5552         FILE *f;
5553
5554         assert(ibuf);
5555         assert(*ibuf);
5556
5557         /* Strips ANSI color and replaces TABs by 8 spaces */
5558
5559         isz = _isz ? *_isz : strlen(*ibuf);
5560
5561         f = open_memstream(&obuf, &osz);
5562         if (!f)
5563                 return NULL;
5564
5565         for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5566
5567                 switch (state) {
5568
5569                 case STATE_OTHER:
5570                         if (i >= *ibuf + isz) /* EOT */
5571                                 break;
5572                         else if (*i == '\x1B')
5573                                 state = STATE_ESCAPE;
5574                         else if (*i == '\t')
5575                                 fputs("        ", f);
5576                         else
5577                                 fputc(*i, f);
5578                         break;
5579
5580                 case STATE_ESCAPE:
5581                         if (i >= *ibuf + isz) { /* EOT */
5582                                 fputc('\x1B', f);
5583                                 break;
5584                         } else if (*i == '[') {
5585                                 state = STATE_BRACKET;
5586                                 begin = i + 1;
5587                         } else {
5588                                 fputc('\x1B', f);
5589                                 fputc(*i, f);
5590                                 state = STATE_OTHER;
5591                         }
5592
5593                         break;
5594
5595                 case STATE_BRACKET:
5596
5597                         if (i >= *ibuf + isz || /* EOT */
5598                             (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5599                                 fputc('\x1B', f);
5600                                 fputc('[', f);
5601                                 state = STATE_OTHER;
5602                                 i = begin-1;
5603                         } else if (*i == 'm')
5604                                 state = STATE_OTHER;
5605                         break;
5606                 }
5607         }
5608
5609         if (ferror(f)) {
5610                 fclose(f);
5611                 free(obuf);
5612                 return NULL;
5613         }
5614
5615         fclose(f);
5616
5617         free(*ibuf);
5618         *ibuf = obuf;
5619
5620         if (_isz)
5621                 *_isz = osz;
5622
5623         return obuf;
5624 }
5625
5626 int on_ac_power(void) {
5627         bool found_offline = false, found_online = false;
5628         _cleanup_closedir_ DIR *d = NULL;
5629
5630         d = opendir("/sys/class/power_supply");
5631         if (!d)
5632                 return -errno;
5633
5634         for (;;) {
5635                 struct dirent *de;
5636                 union dirent_storage buf;
5637                 _cleanup_close_ int fd = -1, device = -1;
5638                 char contents[6];
5639                 ssize_t n;
5640                 int k;
5641
5642                 k = readdir_r(d, &buf.de, &de);
5643                 if (k != 0)
5644                         return -k;
5645
5646                 if (!de)
5647                         break;
5648
5649                 if (ignore_file(de->d_name))
5650                         continue;
5651
5652                 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5653                 if (device < 0) {
5654                         if (errno == ENOENT || errno == ENOTDIR)
5655                                 continue;
5656
5657                         return -errno;
5658                 }
5659
5660                 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5661                 if (fd < 0) {
5662                         if (errno == ENOENT)
5663                                 continue;
5664
5665                         return -errno;
5666                 }
5667
5668                 n = read(fd, contents, sizeof(contents));
5669                 if (n < 0)
5670                         return -errno;
5671
5672                 if (n != 6 || memcmp(contents, "Mains\n", 6))
5673                         continue;
5674
5675                 close_nointr_nofail(fd);
5676                 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5677                 if (fd < 0) {
5678                         if (errno == ENOENT)
5679                                 continue;
5680
5681                         return -errno;
5682                 }
5683
5684                 n = read(fd, contents, sizeof(contents));
5685                 if (n < 0)
5686                         return -errno;
5687
5688                 if (n != 2 || contents[1] != '\n')
5689                         return -EIO;
5690
5691                 if (contents[0] == '1') {
5692                         found_online = true;
5693                         break;
5694                 } else if (contents[0] == '0')
5695                         found_offline = true;
5696                 else
5697                         return -EIO;
5698         }
5699
5700         return found_online || !found_offline;
5701 }
5702
5703 static int search_and_fopen_internal(const char *path, const char *mode, char **search, FILE **_f) {
5704         char **i;
5705
5706         assert(path);
5707         assert(mode);
5708         assert(_f);
5709
5710         if (!path_strv_canonicalize_uniq(search))
5711                 return -ENOMEM;
5712
5713         STRV_FOREACH(i, search) {
5714                 _cleanup_free_ char *p = NULL;
5715                 FILE *f;
5716
5717                 p = strjoin(*i, "/", path, NULL);
5718                 if (!p)
5719                         return -ENOMEM;
5720
5721                 f = fopen(p, mode);
5722                 if (f) {
5723                         *_f = f;
5724                         return 0;
5725                 }
5726
5727                 if (errno != ENOENT)
5728                         return -errno;
5729         }
5730
5731         return -ENOENT;
5732 }
5733
5734 int search_and_fopen(const char *path, const char *mode, const char **search, FILE **_f) {
5735         _cleanup_strv_free_ char **copy = NULL;
5736
5737         assert(path);
5738         assert(mode);
5739         assert(_f);
5740
5741         if (path_is_absolute(path)) {
5742                 FILE *f;
5743
5744                 f = fopen(path, mode);
5745                 if (f) {
5746                         *_f = f;
5747                         return 0;
5748                 }
5749
5750                 return -errno;
5751         }
5752
5753         copy = strv_copy((char**) search);
5754         if (!copy)
5755                 return -ENOMEM;
5756
5757         return search_and_fopen_internal(path, mode, copy, _f);
5758 }
5759
5760 int search_and_fopen_nulstr(const char *path, const char *mode, const char *search, FILE **_f) {
5761         _cleanup_strv_free_ char **s = NULL;
5762
5763         if (path_is_absolute(path)) {
5764                 FILE *f;
5765
5766                 f = fopen(path, mode);
5767                 if (f) {
5768                         *_f = f;
5769                         return 0;
5770                 }
5771
5772                 return -errno;
5773         }
5774
5775         s = strv_split_nulstr(search);
5776         if (!s)
5777                 return -ENOMEM;
5778
5779         return search_and_fopen_internal(path, mode, s, _f);
5780 }
5781
5782 int create_tmp_dir(char template[], char** dir_name) {
5783         int r = 0;
5784         char *d = NULL, *dt;
5785
5786         assert(dir_name);
5787
5788         RUN_WITH_UMASK(0077) {
5789                 d = mkdtemp(template);
5790         }
5791         if (!d) {
5792                 log_error("Can't create directory %s: %m", template);
5793                 return -errno;
5794         }
5795
5796         dt = strjoin(d, "/tmp", NULL);
5797         if (!dt) {
5798                 r = log_oom();
5799                 goto fail3;
5800         }
5801
5802         RUN_WITH_UMASK(0000) {
5803                 r = mkdir(dt, 0777);
5804         }
5805         if (r < 0) {
5806                 log_error("Can't create directory %s: %m", dt);
5807                 r = -errno;
5808                 goto fail2;
5809         }
5810         log_debug("Created temporary directory %s", dt);
5811
5812         r = chmod(dt, 0777 | S_ISVTX);
5813         if (r < 0) {
5814                 log_error("Failed to chmod %s: %m", dt);
5815                 r = -errno;
5816                 goto fail1;
5817         }
5818         log_debug("Set sticky bit on %s", dt);
5819
5820         *dir_name = dt;
5821
5822         return 0;
5823 fail1:
5824         rmdir(dt);
5825 fail2:
5826         free(dt);
5827 fail3:
5828         rmdir(template);
5829         return r;
5830 }
5831
5832 char *strextend(char **x, ...) {
5833         va_list ap;
5834         size_t f, l;
5835         char *r, *p;
5836
5837         assert(x);
5838
5839         l = f = *x ? strlen(*x) : 0;
5840
5841         va_start(ap, x);
5842         for (;;) {
5843                 const char *t;
5844                 size_t n;
5845
5846                 t = va_arg(ap, const char *);
5847                 if (!t)
5848                         break;
5849
5850                 n = strlen(t);
5851                 if (n > ((size_t) -1) - l) {
5852                         va_end(ap);
5853                         return NULL;
5854                 }
5855
5856                 l += n;
5857         }
5858         va_end(ap);
5859
5860         r = realloc(*x, l+1);
5861         if (!r)
5862                 return NULL;
5863
5864         p = r + f;
5865
5866         va_start(ap, x);
5867         for (;;) {
5868                 const char *t;
5869
5870                 t = va_arg(ap, const char *);
5871                 if (!t)
5872                         break;
5873
5874                 p = stpcpy(p, t);
5875         }
5876         va_end(ap);
5877
5878         *p = 0;
5879         *x = r;
5880
5881         return r + l;
5882 }
5883
5884 char *strrep(const char *s, unsigned n) {
5885         size_t l;
5886         char *r, *p;
5887         unsigned i;
5888
5889         assert(s);
5890
5891         l = strlen(s);
5892         p = r = malloc(l * n + 1);
5893         if (!r)
5894                 return NULL;
5895
5896         for (i = 0; i < n; i++)
5897                 p = stpcpy(p, s);
5898
5899         *p = 0;
5900         return r;
5901 }
5902
5903 void* greedy_realloc(void **p, size_t *allocated, size_t need) {
5904         size_t a;
5905         void *q;
5906
5907         if (*allocated >= need)
5908                 return *p;
5909
5910         a = MAX(64u, need * 2);
5911         q = realloc(*p, a);
5912         if (!q)
5913                 return NULL;
5914
5915         *p = q;
5916         *allocated = a;
5917         return q;
5918 }
5919
5920 bool id128_is_valid(const char *s) {
5921         size_t i, l;
5922
5923         l = strlen(s);
5924         if (l == 32) {
5925
5926                 /* Simple formatted 128bit hex string */
5927
5928                 for (i = 0; i < l; i++) {
5929                         char c = s[i];
5930
5931                         if (!(c >= '0' && c <= '9') &&
5932                             !(c >= 'a' && c <= 'z') &&
5933                             !(c >= 'A' && c <= 'Z'))
5934                                 return false;
5935                 }
5936
5937         } else if (l == 36) {
5938
5939                 /* Formatted UUID */
5940
5941                 for (i = 0; i < l; i++) {
5942                         char c = s[i];
5943
5944                         if ((i == 8 || i == 13 || i == 18 || i == 23)) {
5945                                 if (c != '-')
5946                                         return false;
5947                         } else {
5948                                 if (!(c >= '0' && c <= '9') &&
5949                                     !(c >= 'a' && c <= 'z') &&
5950                                     !(c >= 'A' && c <= 'Z'))
5951                                         return false;
5952                         }
5953                 }
5954
5955         } else
5956                 return false;
5957
5958         return true;
5959 }
5960
5961 void parse_user_at_host(char *arg, char **user, char **host) {
5962         assert(arg);
5963         assert(user);
5964         assert(host);
5965
5966         *host = strchr(arg, '@');
5967         if (*host == NULL)
5968                 *host = arg;
5969         else {
5970                 *host[0]++ = '\0';
5971                 *user = arg;
5972         }
5973 }
5974
5975 int split_pair(const char *s, const char *sep, char **l, char **r) {
5976         char *x, *a, *b;
5977
5978         assert(s);
5979         assert(sep);
5980         assert(l);
5981         assert(r);
5982
5983         if (isempty(sep))
5984                 return -EINVAL;
5985
5986         x = strstr(s, sep);
5987         if (!x)
5988                 return -EINVAL;
5989
5990         a = strndup(s, x - s);
5991         if (!a)
5992                 return -ENOMEM;
5993
5994         b = strdup(x + strlen(sep));
5995         if (!b) {
5996                 free(a);
5997                 return -ENOMEM;
5998         }
5999
6000         *l = a;
6001         *r = b;
6002
6003         return 0;
6004 }
6005
6006 int shall_restore_state(void) {
6007         _cleanup_free_ char *line;
6008         char *w, *state;
6009         size_t l;
6010         int r;
6011
6012         r = proc_cmdline(&line);
6013         if (r < 0)
6014                 return r;
6015         if (r == 0) /* Container ... */
6016                 return 1;
6017
6018         FOREACH_WORD_QUOTED(w, l, line, state)
6019                 if (l == 23 && memcmp(w, "systemd.restore_state=0", 23))
6020                         return 0;
6021
6022         return 1;
6023 }
6024
6025 int proc_cmdline(char **ret) {
6026         int r;
6027
6028         if (detect_container(NULL) > 0) {
6029                 *ret = NULL;
6030                 return 0;
6031         }
6032
6033         r = read_one_line_file("/proc/cmdline", ret);
6034         if (r < 0)
6035                 return r;
6036
6037         return 1;
6038 }