src/shared/util.c

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