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