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