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