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