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