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