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 = dup2(fd, STDIN_FILENO);
2472         s = dup2(fd, STDOUT_FILENO);
2473         t = dup2(fd, STDERR_FILENO);
2474
2475         if (fd >= 3)
2476                 safe_close(fd);
2477
2478         if (r < 0 || s < 0 || t < 0)
2479                 return -errno;
2480
2481         /* Explicitly unset O_CLOEXEC, since if fd was < 3, then
2482          * dup2() was a NOP and the bit hence possibly set. */
2483         fd_cloexec(STDIN_FILENO, false);
2484         fd_cloexec(STDOUT_FILENO, false);
2485         fd_cloexec(STDERR_FILENO, false);
2486
2487         return 0;
2488 }
2489
2490 int make_null_stdio(void) {
2491         int null_fd;
2492
2493         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2494         if (null_fd < 0)
2495                 return -errno;
2496
2497         return make_stdio(null_fd);
2498 }
2499
2500 bool is_device_path(const char *path) {
2501
2502         /* Returns true on paths that refer to a device, either in
2503          * sysfs or in /dev */
2504
2505         return
2506                 path_startswith(path, "/dev/") ||
2507                 path_startswith(path, "/sys/");
2508 }
2509
2510 int dir_is_empty(const char *path) {
2511         _cleanup_closedir_ DIR *d;
2512
2513         d = opendir(path);
2514         if (!d)
2515                 return -errno;
2516
2517         for (;;) {
2518                 struct dirent *de;
2519
2520                 errno = 0;
2521                 de = readdir(d);
2522                 if (!de && errno != 0)
2523                         return -errno;
2524
2525                 if (!de)
2526                         return 1;
2527
2528                 if (!ignore_file(de->d_name))
2529                         return 0;
2530         }
2531 }
2532
2533 char* dirname_malloc(const char *path) {
2534         char *d, *dir, *dir2;
2535
2536         d = strdup(path);
2537         if (!d)
2538                 return NULL;
2539         dir = dirname(d);
2540         assert(dir);
2541
2542         if (dir != d) {
2543                 dir2 = strdup(dir);
2544                 free(d);
2545                 return dir2;
2546         }
2547
2548         return dir;
2549 }
2550
2551 int dev_urandom(void *p, size_t n) {
2552         static int have_syscall = -1;
2553         int r, fd;
2554         ssize_t k;
2555
2556         /* Gathers some randomness from the kernel. This call will
2557          * never block, and will always return some data from the
2558          * kernel, regardless if the random pool is fully initialized
2559          * or not. It thus makes no guarantee for the quality of the
2560          * returned entropy, but is good enough for or usual usecases
2561          * of seeding the hash functions for hashtable */
2562
2563         /* Use the getrandom() syscall unless we know we don't have
2564          * it, or when the requested size is too large for it. */
2565         if (have_syscall != 0 || (size_t) (int) n != n) {
2566                 r = getrandom(p, n, GRND_NONBLOCK);
2567                 if (r == (int) n) {
2568                         have_syscall = true;
2569                         return 0;
2570                 }
2571
2572                 if (r < 0) {
2573                         if (errno == ENOSYS)
2574                                 /* we lack the syscall, continue with
2575                                  * reading from /dev/urandom */
2576                                 have_syscall = false;
2577                         else if (errno == EAGAIN)
2578                                 /* not enough entropy for now. Let's
2579                                  * remember to use the syscall the
2580                                  * next time, again, but also read
2581                                  * from /dev/urandom for now, which
2582                                  * doesn't care about the current
2583                                  * amount of entropy.  */
2584                                 have_syscall = true;
2585                         else
2586                                 return -errno;
2587                 } else
2588                         /* too short read? */
2589                         return -EIO;
2590         }
2591
2592         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2593         if (fd < 0)
2594                 return errno == ENOENT ? -ENOSYS : -errno;
2595
2596         k = loop_read(fd, p, n, true);
2597         safe_close(fd);
2598
2599         if (k < 0)
2600                 return (int) k;
2601         if ((size_t) k != n)
2602                 return -EIO;
2603
2604         return 0;
2605 }
2606
2607 void initialize_srand(void) {
2608         static bool srand_called = false;
2609         unsigned x;
2610 #ifdef HAVE_SYS_AUXV_H
2611         void *auxv;
2612 #endif
2613
2614         if (srand_called)
2615                 return;
2616
2617         x = 0;
2618
2619 #ifdef HAVE_SYS_AUXV_H
2620         /* The kernel provides us with a bit of entropy in auxv, so
2621          * let's try to make use of that to seed the pseudo-random
2622          * generator. It's better than nothing... */
2623
2624         auxv = (void*) getauxval(AT_RANDOM);
2625         if (auxv)
2626                 x ^= *(unsigned*) auxv;
2627 #endif
2628
2629         x ^= (unsigned) now(CLOCK_REALTIME);
2630         x ^= (unsigned) gettid();
2631
2632         srand(x);
2633         srand_called = true;
2634 }
2635
2636 void random_bytes(void *p, size_t n) {
2637         uint8_t *q;
2638         int r;
2639
2640         r = dev_urandom(p, n);
2641         if (r >= 0)
2642                 return;
2643
2644         /* If some idiot made /dev/urandom unavailable to us, he'll
2645          * get a PRNG instead. */
2646
2647         initialize_srand();
2648
2649         for (q = p; q < (uint8_t*) p + n; q ++)
2650                 *q = rand();
2651 }
2652
2653 void rename_process(const char name[8]) {
2654         assert(name);
2655
2656         /* This is a like a poor man's setproctitle(). It changes the
2657          * comm field, argv[0], and also the glibc's internally used
2658          * name of the process. For the first one a limit of 16 chars
2659          * applies, to the second one usually one of 10 (i.e. length
2660          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2661          * "systemd"). If you pass a longer string it will be
2662          * truncated */
2663
2664         prctl(PR_SET_NAME, name);
2665
2666         if (program_invocation_name)
2667                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2668
2669         if (saved_argc > 0) {
2670                 int i;
2671
2672                 if (saved_argv[0])
2673                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2674
2675                 for (i = 1; i < saved_argc; i++) {
2676                         if (!saved_argv[i])
2677                                 break;
2678
2679                         memzero(saved_argv[i], strlen(saved_argv[i]));
2680                 }
2681         }
2682 }
2683
2684 void sigset_add_many(sigset_t *ss, ...) {
2685         va_list ap;
2686         int sig;
2687
2688         assert(ss);
2689
2690         va_start(ap, ss);
2691         while ((sig = va_arg(ap, int)) > 0)
2692                 assert_se(sigaddset(ss, sig) == 0);
2693         va_end(ap);
2694 }
2695
2696 int sigprocmask_many(int how, ...) {
2697         va_list ap;
2698         sigset_t ss;
2699         int sig;
2700
2701         assert_se(sigemptyset(&ss) == 0);
2702
2703         va_start(ap, how);
2704         while ((sig = va_arg(ap, int)) > 0)
2705                 assert_se(sigaddset(&ss, sig) == 0);
2706         va_end(ap);
2707
2708         if (sigprocmask(how, &ss, NULL) < 0)
2709                 return -errno;
2710
2711         return 0;
2712 }
2713
2714 char* gethostname_malloc(void) {
2715         struct utsname u;
2716
2717         assert_se(uname(&u) >= 0);
2718
2719         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2720                 return strdup(u.nodename);
2721
2722         return strdup(u.sysname);
2723 }
2724
2725 bool hostname_is_set(void) {
2726         struct utsname u;
2727
2728         assert_se(uname(&u) >= 0);
2729
2730         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2731 }
2732
2733 char *lookup_uid(uid_t uid) {
2734         long bufsize;
2735         char *name;
2736         _cleanup_free_ char *buf = NULL;
2737         struct passwd pwbuf, *pw = NULL;
2738
2739         /* Shortcut things to avoid NSS lookups */
2740         if (uid == 0)
2741                 return strdup("root");
2742
2743         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2744         if (bufsize <= 0)
2745                 bufsize = 4096;
2746
2747         buf = malloc(bufsize);
2748         if (!buf)
2749                 return NULL;
2750
2751         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2752                 return strdup(pw->pw_name);
2753
2754         if (asprintf(&name, UID_FMT, uid) < 0)
2755                 return NULL;
2756
2757         return name;
2758 }
2759
2760 char* getlogname_malloc(void) {
2761         uid_t uid;
2762         struct stat st;
2763
2764         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2765                 uid = st.st_uid;
2766         else
2767                 uid = getuid();
2768
2769         return lookup_uid(uid);
2770 }
2771
2772 char *getusername_malloc(void) {
2773         const char *e;
2774
2775         e = getenv("USER");
2776         if (e)
2777                 return strdup(e);
2778
2779         return lookup_uid(getuid());
2780 }
2781
2782 int getttyname_malloc(int fd, char **r) {
2783         char path[PATH_MAX], *c;
2784         int k;
2785
2786         assert(r);
2787
2788         k = ttyname_r(fd, path, sizeof(path));
2789         if (k > 0)
2790                 return -k;
2791
2792         char_array_0(path);
2793
2794         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2795         if (!c)
2796                 return -ENOMEM;
2797
2798         *r = c;
2799         return 0;
2800 }
2801
2802 int getttyname_harder(int fd, char **r) {
2803         int k;
2804         char *s;
2805
2806         k = getttyname_malloc(fd, &s);
2807         if (k < 0)
2808                 return k;
2809
2810         if (streq(s, "tty")) {
2811                 free(s);
2812                 return get_ctty(0, NULL, r);
2813         }
2814
2815         *r = s;
2816         return 0;
2817 }
2818
2819 int get_ctty_devnr(pid_t pid, dev_t *d) {
2820         int r;
2821         _cleanup_free_ char *line = NULL;
2822         const char *p;
2823         unsigned long ttynr;
2824
2825         assert(pid >= 0);
2826
2827         p = procfs_file_alloca(pid, "stat");
2828         r = read_one_line_file(p, &line);
2829         if (r < 0)
2830                 return r;
2831
2832         p = strrchr(line, ')');
2833         if (!p)
2834                 return -EIO;
2835
2836         p++;
2837
2838         if (sscanf(p, " "
2839                    "%*c "  /* state */
2840                    "%*d "  /* ppid */
2841                    "%*d "  /* pgrp */
2842                    "%*d "  /* session */
2843                    "%lu ", /* ttynr */
2844                    &ttynr) != 1)
2845                 return -EIO;
2846
2847         if (major(ttynr) == 0 && minor(ttynr) == 0)
2848                 return -ENOENT;
2849
2850         if (d)
2851                 *d = (dev_t) ttynr;
2852
2853         return 0;
2854 }
2855
2856 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2857         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2858         _cleanup_free_ char *s = NULL;
2859         const char *p;
2860         dev_t devnr;
2861         int k;
2862
2863         assert(r);
2864
2865         k = get_ctty_devnr(pid, &devnr);
2866         if (k < 0)
2867                 return k;
2868
2869         sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
2870
2871         k = readlink_malloc(fn, &s);
2872         if (k < 0) {
2873
2874                 if (k != -ENOENT)
2875                         return k;
2876
2877                 /* This is an ugly hack */
2878                 if (major(devnr) == 136) {
2879                         asprintf(&b, "pts/%u", minor(devnr));
2880                         goto finish;
2881                 }
2882
2883                 /* Probably something like the ptys which have no
2884                  * symlink in /dev/char. Let's return something
2885                  * vaguely useful. */
2886
2887                 b = strdup(fn + 5);
2888                 goto finish;
2889         }
2890
2891         if (startswith(s, "/dev/"))
2892                 p = s + 5;
2893         else if (startswith(s, "../"))
2894                 p = s + 3;
2895         else
2896                 p = s;
2897
2898         b = strdup(p);
2899
2900 finish:
2901         if (!b)
2902                 return -ENOMEM;
2903
2904         *r = b;
2905         if (_devnr)
2906                 *_devnr = devnr;
2907
2908         return 0;
2909 }
2910
2911 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2912         _cleanup_closedir_ DIR *d = NULL;
2913         int ret = 0;
2914
2915         assert(fd >= 0);
2916
2917         /* This returns the first error we run into, but nevertheless
2918          * tries to go on. This closes the passed fd. */
2919
2920         d = fdopendir(fd);
2921         if (!d) {
2922                 safe_close(fd);
2923
2924                 return errno == ENOENT ? 0 : -errno;
2925         }
2926
2927         for (;;) {
2928                 struct dirent *de;
2929                 bool is_dir, keep_around;
2930                 struct stat st;
2931                 int r;
2932
2933                 errno = 0;
2934                 de = readdir(d);
2935                 if (!de) {
2936                         if (errno != 0 && ret == 0)
2937                                 ret = -errno;
2938                         return ret;
2939                 }
2940
2941                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2942                         continue;
2943
2944                 if (de->d_type == DT_UNKNOWN ||
2945                     honour_sticky ||
2946                     (de->d_type == DT_DIR && root_dev)) {
2947                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2948                                 if (ret == 0 && errno != ENOENT)
2949                                         ret = -errno;
2950                                 continue;
2951                         }
2952
2953                         is_dir = S_ISDIR(st.st_mode);
2954                         keep_around =
2955                                 honour_sticky &&
2956                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2957                                 (st.st_mode & S_ISVTX);
2958                 } else {
2959                         is_dir = de->d_type == DT_DIR;
2960                         keep_around = false;
2961                 }
2962
2963                 if (is_dir) {
2964                         int subdir_fd;
2965
2966                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2967                         if (root_dev && st.st_dev != root_dev->st_dev)
2968                                 continue;
2969
2970                         subdir_fd = openat(fd, de->d_name,
2971                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2972                         if (subdir_fd < 0) {
2973                                 if (ret == 0 && errno != ENOENT)
2974                                         ret = -errno;
2975                                 continue;
2976                         }
2977
2978                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2979                         if (r < 0 && ret == 0)
2980                                 ret = r;
2981
2982                         if (!keep_around)
2983                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2984                                         if (ret == 0 && errno != ENOENT)
2985                                                 ret = -errno;
2986                                 }
2987
2988                 } else if (!only_dirs && !keep_around) {
2989
2990                         if (unlinkat(fd, de->d_name, 0) < 0) {
2991                                 if (ret == 0 && errno != ENOENT)
2992                                         ret = -errno;
2993                         }
2994                 }
2995         }
2996 }
2997
2998 _pure_ static int is_temporary_fs(struct statfs *s) {
2999         assert(s);
3000
3001         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
3002                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
3003 }
3004
3005 int is_fd_on_temporary_fs(int fd) {
3006         struct statfs s;
3007
3008         if (fstatfs(fd, &s) < 0)
3009                 return -errno;
3010
3011         return is_temporary_fs(&s);
3012 }
3013
3014 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3015         struct statfs s;
3016
3017         assert(fd >= 0);
3018
3019         if (fstatfs(fd, &s) < 0) {
3020                 safe_close(fd);
3021                 return -errno;
3022         }
3023
3024         /* We refuse to clean disk file systems with this call. This
3025          * is extra paranoia just to be sure we never ever remove
3026          * non-state data */
3027         if (!is_temporary_fs(&s)) {
3028                 log_error("Attempted to remove disk file system, and we can't allow that.");
3029                 safe_close(fd);
3030                 return -EPERM;
3031         }
3032
3033         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
3034 }
3035
3036 static int file_is_priv_sticky(const char *p) {
3037         struct stat st;
3038
3039         assert(p);
3040
3041         if (lstat(p, &st) < 0)
3042                 return -errno;
3043
3044         return
3045                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3046                 (st.st_mode & S_ISVTX);
3047 }
3048
3049 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
3050         int fd, r;
3051         struct statfs s;
3052
3053         assert(path);
3054
3055         /* We refuse to clean the root file system with this
3056          * call. This is extra paranoia to never cause a really
3057          * seriously broken system. */
3058         if (path_equal(path, "/")) {
3059                 log_error("Attempted to remove entire root file system, and we can't allow that.");
3060                 return -EPERM;
3061         }
3062
3063         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3064         if (fd < 0) {
3065
3066                 if (errno != ENOTDIR)
3067                         return -errno;
3068
3069                 if (!dangerous) {
3070                         if (statfs(path, &s) < 0)
3071                                 return -errno;
3072
3073                         if (!is_temporary_fs(&s)) {
3074                                 log_error("Attempted to remove disk file system, and we can't allow that.");
3075                                 return -EPERM;
3076                         }
3077                 }
3078
3079                 if (delete_root && !only_dirs)
3080                         if (unlink(path) < 0 && errno != ENOENT)
3081                                 return -errno;
3082
3083                 return 0;
3084         }
3085
3086         if (!dangerous) {
3087                 if (fstatfs(fd, &s) < 0) {
3088                         safe_close(fd);
3089                         return -errno;
3090                 }
3091
3092                 if (!is_temporary_fs(&s)) {
3093                         log_error("Attempted to remove disk file system, and we can't allow that.");
3094                         safe_close(fd);
3095                         return -EPERM;
3096                 }
3097         }
3098
3099         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
3100         if (delete_root) {
3101
3102                 if (honour_sticky && file_is_priv_sticky(path) > 0)
3103                         return r;
3104
3105                 if (rmdir(path) < 0 && errno != ENOENT) {
3106                         if (r == 0)
3107                                 r = -errno;
3108                 }
3109         }
3110
3111         return r;
3112 }
3113
3114 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3115         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
3116 }
3117
3118 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3119         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
3120 }
3121
3122 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3123         assert(path);
3124
3125         /* Under the assumption that we are running privileged we
3126          * first change the access mode and only then hand out
3127          * ownership to avoid a window where access is too open. */
3128
3129         if (mode != MODE_INVALID)
3130                 if (chmod(path, mode) < 0)
3131                         return -errno;
3132
3133         if (uid != UID_INVALID || gid != GID_INVALID)
3134                 if (chown(path, uid, gid) < 0)
3135                         return -errno;
3136
3137         return 0;
3138 }
3139
3140 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3141         assert(fd >= 0);
3142
3143         /* Under the assumption that we are running privileged we
3144          * first change the access mode and only then hand out
3145          * ownership to avoid a window where access is too open. */
3146
3147         if (mode != MODE_INVALID)
3148                 if (fchmod(fd, mode) < 0)
3149                         return -errno;
3150
3151         if (uid != UID_INVALID || gid != GID_INVALID)
3152                 if (fchown(fd, uid, gid) < 0)
3153                         return -errno;
3154
3155         return 0;
3156 }
3157
3158 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3159         cpu_set_t *r;
3160         unsigned n = 1024;
3161
3162         /* Allocates the cpuset in the right size */
3163
3164         for (;;) {
3165                 if (!(r = CPU_ALLOC(n)))
3166                         return NULL;
3167
3168                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3169                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3170
3171                         if (ncpus)
3172                                 *ncpus = n;
3173
3174                         return r;
3175                 }
3176
3177                 CPU_FREE(r);
3178
3179                 if (errno != EINVAL)
3180                         return NULL;
3181
3182                 n *= 2;
3183         }
3184 }
3185
3186 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3187         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3188         _cleanup_free_ char *s = NULL;
3189         _cleanup_close_ int fd = -1;
3190         struct iovec iovec[6] = {};
3191         int n = 0;
3192         static bool prev_ephemeral;
3193
3194         assert(format);
3195
3196         /* This is independent of logging, as status messages are
3197          * optional and go exclusively to the console. */
3198
3199         if (vasprintf(&s, format, ap) < 0)
3200                 return log_oom();
3201
3202         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3203         if (fd < 0)
3204                 return fd;
3205
3206         if (ellipse) {
3207                 char *e;
3208                 size_t emax, sl;
3209                 int c;
3210
3211                 c = fd_columns(fd);
3212                 if (c <= 0)
3213                         c = 80;
3214
3215                 sl = status ? sizeof(status_indent)-1 : 0;
3216
3217                 emax = c - sl - 1;
3218                 if (emax < 3)
3219                         emax = 3;
3220
3221                 e = ellipsize(s, emax, 50);
3222                 if (e) {
3223                         free(s);
3224                         s = e;
3225                 }
3226         }
3227
3228         if (prev_ephemeral)
3229                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3230         prev_ephemeral = ephemeral;
3231
3232         if (status) {
3233                 if (!isempty(status)) {
3234                         IOVEC_SET_STRING(iovec[n++], "[");
3235                         IOVEC_SET_STRING(iovec[n++], status);
3236                         IOVEC_SET_STRING(iovec[n++], "] ");
3237                 } else
3238                         IOVEC_SET_STRING(iovec[n++], status_indent);
3239         }
3240
3241         IOVEC_SET_STRING(iovec[n++], s);
3242         if (!ephemeral)
3243                 IOVEC_SET_STRING(iovec[n++], "\n");
3244
3245         if (writev(fd, iovec, n) < 0)
3246                 return -errno;
3247
3248         return 0;
3249 }
3250
3251 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3252         va_list ap;
3253         int r;
3254
3255         assert(format);
3256
3257         va_start(ap, format);
3258         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3259         va_end(ap);
3260
3261         return r;
3262 }
3263
3264 char *replace_env(const char *format, char **env) {
3265         enum {
3266                 WORD,
3267                 CURLY,
3268                 VARIABLE
3269         } state = WORD;
3270
3271         const char *e, *word = format;
3272         char *r = NULL, *k;
3273
3274         assert(format);
3275
3276         for (e = format; *e; e ++) {
3277
3278                 switch (state) {
3279
3280                 case WORD:
3281                         if (*e == '$')
3282                                 state = CURLY;
3283                         break;
3284
3285                 case CURLY:
3286                         if (*e == '{') {
3287                                 k = strnappend(r, word, e-word-1);
3288                                 if (!k)
3289                                         goto fail;
3290
3291                                 free(r);
3292                                 r = k;
3293
3294                                 word = e-1;
3295                                 state = VARIABLE;
3296
3297                         } else if (*e == '$') {
3298                                 k = strnappend(r, word, e-word);
3299                                 if (!k)
3300                                         goto fail;
3301
3302                                 free(r);
3303                                 r = k;
3304
3305                                 word = e+1;
3306                                 state = WORD;
3307                         } else
3308                                 state = WORD;
3309                         break;
3310
3311                 case VARIABLE:
3312                         if (*e == '}') {
3313                                 const char *t;
3314
3315                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3316
3317                                 k = strappend(r, t);
3318                                 if (!k)
3319                                         goto fail;
3320
3321                                 free(r);
3322                                 r = k;
3323
3324                                 word = e+1;
3325                                 state = WORD;
3326                         }
3327                         break;
3328                 }
3329         }
3330
3331         k = strnappend(r, word, e-word);
3332         if (!k)
3333                 goto fail;
3334
3335         free(r);
3336         return k;
3337
3338 fail:
3339         free(r);
3340         return NULL;
3341 }
3342
3343 char **replace_env_argv(char **argv, char **env) {
3344         char **ret, **i;
3345         unsigned k = 0, l = 0;
3346
3347         l = strv_length(argv);
3348
3349         ret = new(char*, l+1);
3350         if (!ret)
3351                 return NULL;
3352
3353         STRV_FOREACH(i, argv) {
3354
3355                 /* If $FOO appears as single word, replace it by the split up variable */
3356                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3357                         char *e;
3358                         char **w, **m;
3359                         unsigned q;
3360
3361                         e = strv_env_get(env, *i+1);
3362                         if (e) {
3363                                 int r;
3364
3365                                 r = strv_split_quoted(&m, e, true);
3366                                 if (r < 0) {
3367                                         ret[k] = NULL;
3368                                         strv_free(ret);
3369                                         return NULL;
3370                                 }
3371                         } else
3372                                 m = NULL;
3373
3374                         q = strv_length(m);
3375                         l = l + q - 1;
3376
3377                         w = realloc(ret, sizeof(char*) * (l+1));
3378                         if (!w) {
3379                                 ret[k] = NULL;
3380                                 strv_free(ret);
3381                                 strv_free(m);
3382                                 return NULL;
3383                         }
3384
3385                         ret = w;
3386                         if (m) {
3387                                 memcpy(ret + k, m, q * sizeof(char*));
3388                                 free(m);
3389                         }
3390
3391                         k += q;
3392                         continue;
3393                 }
3394
3395                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3396                 ret[k] = replace_env(*i, env);
3397                 if (!ret[k]) {
3398                         strv_free(ret);
3399                         return NULL;
3400                 }
3401                 k++;
3402         }
3403
3404         ret[k] = NULL;
3405         return ret;
3406 }
3407
3408 int fd_columns(int fd) {
3409         struct winsize ws = {};
3410
3411         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3412                 return -errno;
3413
3414         if (ws.ws_col <= 0)
3415                 return -EIO;
3416
3417         return ws.ws_col;
3418 }
3419
3420 unsigned columns(void) {
3421         const char *e;
3422         int c;
3423
3424         if (_likely_(cached_columns > 0))
3425                 return cached_columns;
3426
3427         c = 0;
3428         e = getenv("COLUMNS");
3429         if (e)
3430                 (void) safe_atoi(e, &c);
3431
3432         if (c <= 0)
3433                 c = fd_columns(STDOUT_FILENO);
3434
3435         if (c <= 0)
3436                 c = 80;
3437
3438         cached_columns = c;
3439         return c;
3440 }
3441
3442 int fd_lines(int fd) {
3443         struct winsize ws = {};
3444
3445         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3446                 return -errno;
3447
3448         if (ws.ws_row <= 0)
3449                 return -EIO;
3450
3451         return ws.ws_row;
3452 }
3453
3454 unsigned lines(void) {
3455         const char *e;
3456         unsigned l;
3457
3458         if (_likely_(cached_lines > 0))
3459                 return cached_lines;
3460
3461         l = 0;
3462         e = getenv("LINES");
3463         if (e)
3464                 (void) safe_atou(e, &l);
3465
3466         if (l <= 0)
3467                 l = fd_lines(STDOUT_FILENO);
3468
3469         if (l <= 0)
3470                 l = 24;
3471
3472         cached_lines = l;
3473         return cached_lines;
3474 }
3475
3476 /* intended to be used as a SIGWINCH sighandler */
3477 void columns_lines_cache_reset(int signum) {
3478         cached_columns = 0;
3479         cached_lines = 0;
3480 }
3481
3482 bool on_tty(void) {
3483         static int cached_on_tty = -1;
3484
3485         if (_unlikely_(cached_on_tty < 0))
3486                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3487
3488         return cached_on_tty;
3489 }
3490
3491 int files_same(const char *filea, const char *fileb) {
3492         struct stat a, b;
3493
3494         if (stat(filea, &a) < 0)
3495                 return -errno;
3496
3497         if (stat(fileb, &b) < 0)
3498                 return -errno;
3499
3500         return a.st_dev == b.st_dev &&
3501                a.st_ino == b.st_ino;
3502 }
3503
3504 int running_in_chroot(void) {
3505         int ret;
3506
3507         ret = files_same("/proc/1/root", "/");
3508         if (ret < 0)
3509                 return ret;
3510
3511         return ret == 0;
3512 }
3513
3514 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3515         size_t x;
3516         char *r;
3517
3518         assert(s);
3519         assert(percent <= 100);
3520         assert(new_length >= 3);
3521
3522         if (old_length <= 3 || old_length <= new_length)
3523                 return strndup(s, old_length);
3524
3525         r = new0(char, new_length+1);
3526         if (!r)
3527                 return NULL;
3528
3529         x = (new_length * percent) / 100;
3530
3531         if (x > new_length - 3)
3532                 x = new_length - 3;
3533
3534         memcpy(r, s, x);
3535         r[x] = '.';
3536         r[x+1] = '.';
3537         r[x+2] = '.';
3538         memcpy(r + x + 3,
3539                s + old_length - (new_length - x - 3),
3540                new_length - x - 3);
3541
3542         return r;
3543 }
3544
3545 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3546         size_t x;
3547         char *e;
3548         const char *i, *j;
3549         unsigned k, len, len2;
3550
3551         assert(s);
3552         assert(percent <= 100);
3553         assert(new_length >= 3);
3554
3555         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3556         if (ascii_is_valid(s))
3557                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3558
3559         if (old_length <= 3 || old_length <= new_length)
3560                 return strndup(s, old_length);
3561
3562         x = (new_length * percent) / 100;
3563
3564         if (x > new_length - 3)
3565                 x = new_length - 3;
3566
3567         k = 0;
3568         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3569                 int c;
3570
3571                 c = utf8_encoded_to_unichar(i);
3572                 if (c < 0)
3573                         return NULL;
3574                 k += unichar_iswide(c) ? 2 : 1;
3575         }
3576
3577         if (k > x) /* last character was wide and went over quota */
3578                 x ++;
3579
3580         for (j = s + old_length; k < new_length && j > i; ) {
3581                 int c;
3582
3583                 j = utf8_prev_char(j);
3584                 c = utf8_encoded_to_unichar(j);
3585                 if (c < 0)
3586                         return NULL;
3587                 k += unichar_iswide(c) ? 2 : 1;
3588         }
3589         assert(i <= j);
3590
3591         /* we don't actually need to ellipsize */
3592         if (i == j)
3593                 return memdup(s, old_length + 1);
3594
3595         /* make space for ellipsis */
3596         j = utf8_next_char(j);
3597
3598         len = i - s;
3599         len2 = s + old_length - j;
3600         e = new(char, len + 3 + len2 + 1);
3601         if (!e)
3602                 return NULL;
3603
3604         /*
3605         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3606                old_length, new_length, x, len, len2, k);
3607         */
3608
3609         memcpy(e, s, len);
3610         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3611         e[len + 1] = 0x80;
3612         e[len + 2] = 0xa6;
3613
3614         memcpy(e + len + 3, j, len2 + 1);
3615
3616         return e;
3617 }
3618
3619 char *ellipsize(const char *s, size_t length, unsigned percent) {
3620         return ellipsize_mem(s, strlen(s), length, percent);
3621 }
3622
3623 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3624         _cleanup_close_ int fd;
3625         int r;
3626
3627         assert(path);
3628
3629         if (parents)
3630                 mkdir_parents(path, 0755);
3631
3632         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3633         if (fd < 0)
3634                 return -errno;
3635
3636         if (mode > 0) {
3637                 r = fchmod(fd, mode);
3638                 if (r < 0)
3639                         return -errno;
3640         }
3641
3642         if (uid != UID_INVALID || gid != GID_INVALID) {
3643                 r = fchown(fd, uid, gid);
3644                 if (r < 0)
3645                         return -errno;
3646         }
3647
3648         if (stamp != USEC_INFINITY) {
3649                 struct timespec ts[2];
3650
3651                 timespec_store(&ts[0], stamp);
3652                 ts[1] = ts[0];
3653                 r = futimens(fd, ts);
3654         } else
3655                 r = futimens(fd, NULL);
3656         if (r < 0)
3657                 return -errno;
3658
3659         return 0;
3660 }
3661
3662 int touch(const char *path) {
3663         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
3664 }
3665
3666 char *unquote(const char *s, const char* quotes) {
3667         size_t l;
3668         assert(s);
3669
3670         /* This is rather stupid, simply removes the heading and
3671          * trailing quotes if there is one. Doesn't care about
3672          * escaping or anything. We should make this smarter one
3673          * day... */
3674
3675         l = strlen(s);
3676         if (l < 2)
3677                 return strdup(s);
3678
3679         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3680                 return strndup(s+1, l-2);
3681
3682         return strdup(s);
3683 }
3684
3685 char *normalize_env_assignment(const char *s) {
3686         _cleanup_free_ char *value = NULL;
3687         const char *eq;
3688         char *p, *name;
3689
3690         eq = strchr(s, '=');
3691         if (!eq) {
3692                 char *r, *t;
3693
3694                 r = strdup(s);
3695                 if (!r)
3696                         return NULL;
3697
3698                 t = strstrip(r);
3699                 if (t != r)
3700                         memmove(r, t, strlen(t) + 1);
3701
3702                 return r;
3703         }
3704
3705         name = strndupa(s, eq - s);
3706         p = strdupa(eq + 1);
3707
3708         value = unquote(strstrip(p), QUOTES);
3709         if (!value)
3710                 return NULL;
3711
3712         return strjoin(strstrip(name), "=", value, NULL);
3713 }
3714
3715 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3716         siginfo_t dummy;
3717
3718         assert(pid >= 1);
3719
3720         if (!status)
3721                 status = &dummy;
3722
3723         for (;;) {
3724                 zero(*status);
3725
3726                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3727
3728                         if (errno == EINTR)
3729                                 continue;
3730
3731                         return -errno;
3732                 }
3733
3734                 return 0;
3735         }
3736 }
3737
3738 /*
3739  * Return values:
3740  * < 0 : wait_for_terminate() failed to get the state of the
3741  *       process, the process was terminated by a signal, or
3742  *       failed for an unknown reason.
3743  * >=0 : The process terminated normally, and its exit code is
3744  *       returned.
3745  *
3746  * That is, success is indicated by a return value of zero, and an
3747  * error is indicated by a non-zero value.
3748  *
3749  * A warning is emitted if the process terminates abnormally,
3750  * and also if it returns non-zero unless check_exit_code is true.
3751  */
3752 int wait_for_terminate_and_warn(const char *name, pid_t pid, bool check_exit_code) {
3753         int r;
3754         siginfo_t status;
3755
3756         assert(name);
3757         assert(pid > 1);
3758
3759         r = wait_for_terminate(pid, &status);
3760         if (r < 0)
3761                 return log_warning_errno(r, "Failed to wait for %s: %m", name);
3762
3763         if (status.si_code == CLD_EXITED) {
3764                 if (status.si_status != 0)
3765                         log_full(check_exit_code ? LOG_WARNING : LOG_DEBUG,
3766                                  "%s failed with error code %i.", name, status.si_status);
3767                 else
3768                         log_debug("%s succeeded.", name);
3769
3770                 return status.si_status;
3771         } else if (status.si_code == CLD_KILLED ||
3772                    status.si_code == CLD_DUMPED) {
3773
3774                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3775                 return -EPROTO;
3776         }
3777
3778         log_warning("%s failed due to unknown reason.", name);
3779         return -EPROTO;
3780 }
3781
3782 noreturn void freeze(void) {
3783
3784         /* Make sure nobody waits for us on a socket anymore */
3785         close_all_fds(NULL, 0);
3786
3787         sync();
3788
3789         for (;;)
3790                 pause();
3791 }
3792
3793 bool null_or_empty(struct stat *st) {
3794         assert(st);
3795
3796         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3797                 return true;
3798
3799         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3800                 return true;
3801
3802         return false;
3803 }
3804
3805 int null_or_empty_path(const char *fn) {
3806         struct stat st;
3807
3808         assert(fn);
3809
3810         if (stat(fn, &st) < 0)
3811                 return -errno;
3812
3813         return null_or_empty(&st);
3814 }
3815
3816 int null_or_empty_fd(int fd) {
3817         struct stat st;
3818
3819         assert(fd >= 0);
3820
3821         if (fstat(fd, &st) < 0)
3822                 return -errno;
3823
3824         return null_or_empty(&st);
3825 }
3826
3827 DIR *xopendirat(int fd, const char *name, int flags) {
3828         int nfd;
3829         DIR *d;
3830
3831         assert(!(flags & O_CREAT));
3832
3833         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3834         if (nfd < 0)
3835                 return NULL;
3836
3837         d = fdopendir(nfd);
3838         if (!d) {
3839                 safe_close(nfd);
3840                 return NULL;
3841         }
3842
3843         return d;
3844 }
3845
3846 int signal_from_string_try_harder(const char *s) {
3847         int signo;
3848         assert(s);
3849
3850         signo = signal_from_string(s);
3851         if (signo <= 0)
3852                 if (startswith(s, "SIG"))
3853                         return signal_from_string(s+3);
3854
3855         return signo;
3856 }
3857
3858 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3859         _cleanup_free_ char *t = NULL, *u = NULL;
3860         size_t enc_len;
3861
3862         u = unquote(tagvalue, "\"\'");
3863         if (!u)
3864                 return NULL;
3865
3866         enc_len = strlen(u) * 4 + 1;
3867         t = new(char, enc_len);
3868         if (!t)
3869                 return NULL;
3870
3871         if (encode_devnode_name(u, t, enc_len) < 0)
3872                 return NULL;
3873
3874         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3875 }
3876
3877 char *fstab_node_to_udev_node(const char *p) {
3878         assert(p);
3879
3880         if (startswith(p, "LABEL="))
3881                 return tag_to_udev_node(p+6, "label");
3882
3883         if (startswith(p, "UUID="))
3884                 return tag_to_udev_node(p+5, "uuid");
3885
3886         if (startswith(p, "PARTUUID="))
3887                 return tag_to_udev_node(p+9, "partuuid");
3888
3889         if (startswith(p, "PARTLABEL="))
3890                 return tag_to_udev_node(p+10, "partlabel");
3891
3892         return strdup(p);
3893 }
3894
3895 bool tty_is_vc(const char *tty) {
3896         assert(tty);
3897
3898         return vtnr_from_tty(tty) >= 0;
3899 }
3900
3901 bool tty_is_console(const char *tty) {
3902         assert(tty);
3903
3904         if (startswith(tty, "/dev/"))
3905                 tty += 5;
3906
3907         return streq(tty, "console");
3908 }
3909
3910 int vtnr_from_tty(const char *tty) {
3911         int i, r;
3912
3913         assert(tty);
3914
3915         if (startswith(tty, "/dev/"))
3916                 tty += 5;
3917
3918         if (!startswith(tty, "tty") )
3919                 return -EINVAL;
3920
3921         if (tty[3] < '0' || tty[3] > '9')
3922                 return -EINVAL;
3923
3924         r = safe_atoi(tty+3, &i);
3925         if (r < 0)
3926                 return r;
3927
3928         if (i < 0 || i > 63)
3929                 return -EINVAL;
3930
3931         return i;
3932 }
3933
3934 char *resolve_dev_console(char **active) {
3935         char *tty;
3936
3937         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3938          * (i.e. not read-only-mounted which is a sign for container setups) */
3939
3940         if (path_is_read_only_fs("/sys") > 0)
3941                 return NULL;
3942
3943         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3944                 return NULL;
3945
3946         /* If multiple log outputs are configured the last one is what
3947          * /dev/console points to */
3948         tty = strrchr(*active, ' ');
3949         if (tty)
3950                 tty++;
3951         else
3952                 tty = *active;
3953
3954         if (streq(tty, "tty0")) {
3955                 char *tmp;
3956
3957                 /* Get the active VC (e.g. tty1) */
3958                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3959                         free(*active);
3960                         tty = *active = tmp;
3961                 }
3962         }
3963
3964         return tty;
3965 }
3966
3967 bool tty_is_vc_resolve(const char *tty) {
3968         _cleanup_free_ char *active = NULL;
3969
3970         assert(tty);
3971
3972         if (startswith(tty, "/dev/"))
3973                 tty += 5;
3974
3975         if (streq(tty, "console")) {
3976                 tty = resolve_dev_console(&active);
3977                 if (!tty)
3978                         return false;
3979         }
3980
3981         return tty_is_vc(tty);
3982 }
3983
3984 const char *default_term_for_tty(const char *tty) {
3985         assert(tty);
3986
3987         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3988 }
3989
3990 bool dirent_is_file(const struct dirent *de) {
3991         assert(de);
3992
3993         if (ignore_file(de->d_name))
3994                 return false;
3995
3996         if (de->d_type != DT_REG &&
3997             de->d_type != DT_LNK &&
3998             de->d_type != DT_UNKNOWN)
3999                 return false;
4000
4001         return true;
4002 }
4003
4004 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4005         assert(de);
4006
4007         if (de->d_type != DT_REG &&
4008             de->d_type != DT_LNK &&
4009             de->d_type != DT_UNKNOWN)
4010                 return false;
4011
4012         if (ignore_file_allow_backup(de->d_name))
4013                 return false;
4014
4015         return endswith(de->d_name, suffix);
4016 }
4017
4018 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
4019         pid_t executor_pid;
4020         int r;
4021
4022         assert(directory);
4023
4024         /* Executes all binaries in a directory in parallel and waits
4025          * for them to finish. Optionally a timeout is applied. */
4026
4027         executor_pid = fork();
4028         if (executor_pid < 0) {
4029                 log_error_errno(errno, "Failed to fork: %m");
4030                 return;
4031
4032         } else if (executor_pid == 0) {
4033                 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
4034                 _cleanup_closedir_ DIR *_d = NULL;
4035                 struct dirent *de;
4036
4037                 /* We fork this all off from a child process so that
4038                  * we can somewhat cleanly make use of SIGALRM to set
4039                  * a time limit */
4040
4041                 reset_all_signal_handlers();
4042                 reset_signal_mask();
4043
4044                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4045
4046                 if (!d) {
4047                         d = _d = opendir(directory);
4048                         if (!d) {
4049                                 if (errno == ENOENT)
4050                                         _exit(EXIT_SUCCESS);
4051
4052                                 log_error_errno(errno, "Failed to enumerate directory %s: %m", directory);
4053                                 _exit(EXIT_FAILURE);
4054                         }
4055                 }
4056
4057                 pids = hashmap_new(NULL);
4058                 if (!pids) {
4059                         log_oom();
4060                         _exit(EXIT_FAILURE);
4061                 }
4062
4063                 FOREACH_DIRENT(de, d, break) {
4064                         _cleanup_free_ char *path = NULL;
4065                         pid_t pid;
4066
4067                         if (!dirent_is_file(de))
4068                                 continue;
4069
4070                         path = strjoin(directory, "/", de->d_name, NULL);
4071                         if (!path) {
4072                                 log_oom();
4073                                 _exit(EXIT_FAILURE);
4074                         }
4075
4076                         pid = fork();
4077                         if (pid < 0) {
4078                                 log_error_errno(errno, "Failed to fork: %m");
4079                                 continue;
4080                         } else if (pid == 0) {
4081                                 char *_argv[2];
4082
4083                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4084
4085                                 if (!argv) {
4086                                         _argv[0] = path;
4087                                         _argv[1] = NULL;
4088                                         argv = _argv;
4089                                 } else
4090                                         argv[0] = path;
4091
4092                                 execv(path, argv);
4093                                 log_error_errno(errno, "Failed to execute %s: %m", path);
4094                                 _exit(EXIT_FAILURE);
4095                         }
4096
4097                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
4098
4099                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
4100                         if (r < 0) {
4101                                 log_oom();
4102                                 _exit(EXIT_FAILURE);
4103                         }
4104
4105                         path = NULL;
4106                 }
4107
4108                 /* Abort execution of this process after the
4109                  * timout. We simply rely on SIGALRM as default action
4110                  * terminating the process, and turn on alarm(). */
4111
4112                 if (timeout != USEC_INFINITY)
4113                         alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
4114
4115                 while (!hashmap_isempty(pids)) {
4116                         _cleanup_free_ char *path = NULL;
4117                         pid_t pid;
4118
4119                         pid = PTR_TO_UINT(hashmap_first_key(pids));
4120                         assert(pid > 0);
4121
4122                         path = hashmap_remove(pids, UINT_TO_PTR(pid));
4123                         assert(path);
4124
4125                         wait_for_terminate_and_warn(path, pid, true);
4126                 }
4127
4128                 _exit(EXIT_SUCCESS);
4129         }
4130
4131         wait_for_terminate_and_warn(directory, executor_pid, true);
4132 }
4133
4134 int kill_and_sigcont(pid_t pid, int sig) {
4135         int r;
4136
4137         r = kill(pid, sig) < 0 ? -errno : 0;
4138
4139         if (r >= 0)
4140                 kill(pid, SIGCONT);
4141
4142         return r;
4143 }
4144
4145 bool nulstr_contains(const char*nulstr, const char *needle) {
4146         const char *i;
4147
4148         if (!nulstr)
4149                 return false;
4150
4151         NULSTR_FOREACH(i, nulstr)
4152                 if (streq(i, needle))
4153                         return true;
4154
4155         return false;
4156 }
4157
4158 bool plymouth_running(void) {
4159         return access("/run/plymouth/pid", F_OK) >= 0;
4160 }
4161
4162 char* strshorten(char *s, size_t l) {
4163         assert(s);
4164
4165         if (l < strlen(s))
4166                 s[l] = 0;
4167
4168         return s;
4169 }
4170
4171 static bool hostname_valid_char(char c) {
4172         return
4173                 (c >= 'a' && c <= 'z') ||
4174                 (c >= 'A' && c <= 'Z') ||
4175                 (c >= '0' && c <= '9') ||
4176                 c == '-' ||
4177                 c == '_' ||
4178                 c == '.';
4179 }
4180
4181 bool hostname_is_valid(const char *s) {
4182         const char *p;
4183         bool dot;
4184
4185         if (isempty(s))
4186                 return false;
4187
4188         for (p = s, dot = true; *p; p++) {
4189                 if (*p == '.') {
4190                         if (dot)
4191                                 return false;
4192
4193                         dot = true;
4194                 } else {
4195                         if (!hostname_valid_char(*p))
4196                                 return false;
4197
4198                         dot = false;
4199                 }
4200         }
4201
4202         if (dot)
4203                 return false;
4204
4205         if (p-s > HOST_NAME_MAX)
4206                 return false;
4207
4208         return true;
4209 }
4210
4211 char* hostname_cleanup(char *s, bool lowercase) {
4212         char *p, *d;
4213         bool dot;
4214
4215         for (p = s, d = s, dot = true; *p; p++) {
4216                 if (*p == '.') {
4217                         if (dot)
4218                                 continue;
4219
4220                         *(d++) = '.';
4221                         dot = true;
4222                 } else if (hostname_valid_char(*p)) {
4223                         *(d++) = lowercase ? tolower(*p) : *p;
4224                         dot = false;
4225                 }
4226
4227         }
4228
4229         if (dot && d > s)
4230                 d[-1] = 0;
4231         else
4232                 *d = 0;
4233
4234         strshorten(s, HOST_NAME_MAX);
4235
4236         return s;
4237 }
4238
4239 bool machine_name_is_valid(const char *s) {
4240
4241         if (!hostname_is_valid(s))
4242                 return false;
4243
4244         /* Machine names should be useful hostnames, but also be
4245          * useful in unit names, hence we enforce a stricter length
4246          * limitation. */
4247
4248         if (strlen(s) > 64)
4249                 return false;
4250
4251         return true;
4252 }
4253
4254 int pipe_eof(int fd) {
4255         struct pollfd pollfd = {
4256                 .fd = fd,
4257                 .events = POLLIN|POLLHUP,
4258         };
4259
4260         int r;
4261
4262         r = poll(&pollfd, 1, 0);
4263         if (r < 0)
4264                 return -errno;
4265
4266         if (r == 0)
4267                 return 0;
4268
4269         return pollfd.revents & POLLHUP;
4270 }
4271
4272 int fd_wait_for_event(int fd, int event, usec_t t) {
4273
4274         struct pollfd pollfd = {
4275                 .fd = fd,
4276                 .events = event,
4277         };
4278
4279         struct timespec ts;
4280         int r;
4281
4282         r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
4283         if (r < 0)
4284                 return -errno;
4285
4286         if (r == 0)
4287                 return 0;
4288
4289         return pollfd.revents;
4290 }
4291
4292 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4293         FILE *f;
4294         char *t;
4295         int r, fd;
4296
4297         assert(path);
4298         assert(_f);
4299         assert(_temp_path);
4300
4301         r = tempfn_xxxxxx(path, &t);
4302         if (r < 0)
4303                 return r;
4304
4305         fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
4306         if (fd < 0) {
4307                 free(t);
4308                 return -errno;
4309         }
4310
4311         f = fdopen(fd, "we");
4312         if (!f) {
4313                 unlink(t);
4314                 free(t);
4315                 return -errno;
4316         }
4317
4318         *_f = f;
4319         *_temp_path = t;
4320
4321         return 0;
4322 }
4323
4324 int terminal_vhangup_fd(int fd) {
4325         assert(fd >= 0);
4326
4327         if (ioctl(fd, TIOCVHANGUP) < 0)
4328                 return -errno;
4329
4330         return 0;
4331 }
4332
4333 int terminal_vhangup(const char *name) {
4334         _cleanup_close_ int fd;
4335
4336         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4337         if (fd < 0)
4338                 return fd;
4339
4340         return terminal_vhangup_fd(fd);
4341 }
4342
4343 int vt_disallocate(const char *name) {
4344         int fd, r;
4345         unsigned u;
4346
4347         /* Deallocate the VT if possible. If not possible
4348          * (i.e. because it is the active one), at least clear it
4349          * entirely (including the scrollback buffer) */
4350
4351         if (!startswith(name, "/dev/"))
4352                 return -EINVAL;
4353
4354         if (!tty_is_vc(name)) {
4355                 /* So this is not a VT. I guess we cannot deallocate
4356                  * it then. But let's at least clear the screen */
4357
4358                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4359                 if (fd < 0)
4360                         return fd;
4361
4362                 loop_write(fd,
4363                            "\033[r"    /* clear scrolling region */
4364                            "\033[H"    /* move home */
4365                            "\033[2J",  /* clear screen */
4366                            10, false);
4367                 safe_close(fd);
4368
4369                 return 0;
4370         }
4371
4372         if (!startswith(name, "/dev/tty"))
4373                 return -EINVAL;
4374
4375         r = safe_atou(name+8, &u);
4376         if (r < 0)
4377                 return r;
4378
4379         if (u <= 0)
4380                 return -EINVAL;
4381
4382         /* Try to deallocate */
4383         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4384         if (fd < 0)
4385                 return fd;
4386
4387         r = ioctl(fd, VT_DISALLOCATE, u);
4388         safe_close(fd);
4389
4390         if (r >= 0)
4391                 return 0;
4392
4393         if (errno != EBUSY)
4394                 return -errno;
4395
4396         /* Couldn't deallocate, so let's clear it fully with
4397          * scrollback */
4398         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4399         if (fd < 0)
4400                 return fd;
4401
4402         loop_write(fd,
4403                    "\033[r"   /* clear scrolling region */
4404                    "\033[H"   /* move home */
4405                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4406                    10, false);
4407         safe_close(fd);
4408
4409         return 0;
4410 }
4411
4412 int symlink_atomic(const char *from, const char *to) {
4413         _cleanup_free_ char *t = NULL;
4414         int r;
4415
4416         assert(from);
4417         assert(to);
4418
4419         r = tempfn_random(to, &t);
4420         if (r < 0)
4421                 return r;
4422
4423         if (symlink(from, t) < 0)
4424                 return -errno;
4425
4426         if (rename(t, to) < 0) {
4427                 unlink_noerrno(t);
4428                 return -errno;
4429         }
4430
4431         return 0;
4432 }
4433
4434 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
4435         _cleanup_free_ char *t = NULL;
4436         int r;
4437
4438         assert(path);
4439
4440         r = tempfn_random(path, &t);
4441         if (r < 0)
4442                 return r;
4443
4444         if (mknod(t, mode, dev) < 0)
4445                 return -errno;
4446
4447         if (rename(t, path) < 0) {
4448                 unlink_noerrno(t);
4449                 return -errno;
4450         }
4451
4452         return 0;
4453 }
4454
4455 int mkfifo_atomic(const char *path, mode_t mode) {
4456         _cleanup_free_ char *t = NULL;
4457         int r;
4458
4459         assert(path);
4460
4461         r = tempfn_random(path, &t);
4462         if (r < 0)
4463                 return r;
4464
4465         if (mkfifo(t, mode) < 0)
4466                 return -errno;
4467
4468         if (rename(t, path) < 0) {
4469                 unlink_noerrno(t);
4470                 return -errno;
4471         }
4472
4473         return 0;
4474 }
4475
4476 bool display_is_local(const char *display) {
4477         assert(display);
4478
4479         return
4480                 display[0] == ':' &&
4481                 display[1] >= '0' &&
4482                 display[1] <= '9';
4483 }
4484
4485 int socket_from_display(const char *display, char **path) {
4486         size_t k;
4487         char *f, *c;
4488
4489         assert(display);
4490         assert(path);
4491
4492         if (!display_is_local(display))
4493                 return -EINVAL;
4494
4495         k = strspn(display+1, "0123456789");
4496
4497         f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4498         if (!f)
4499                 return -ENOMEM;
4500
4501         c = stpcpy(f, "/tmp/.X11-unix/X");
4502         memcpy(c, display+1, k);
4503         c[k] = 0;
4504
4505         *path = f;
4506
4507         return 0;
4508 }
4509
4510 int get_user_creds(
4511                 const char **username,
4512                 uid_t *uid, gid_t *gid,
4513                 const char **home,
4514                 const char **shell) {
4515
4516         struct passwd *p;
4517         uid_t u;
4518
4519         assert(username);
4520         assert(*username);
4521
4522         /* We enforce some special rules for uid=0: in order to avoid
4523          * NSS lookups for root we hardcode its data. */
4524
4525         if (streq(*username, "root") || streq(*username, "0")) {
4526                 *username = "root";
4527
4528                 if (uid)
4529                         *uid = 0;
4530
4531                 if (gid)
4532                         *gid = 0;
4533
4534                 if (home)
4535                         *home = "/root";
4536
4537                 if (shell)
4538                         *shell = "/bin/sh";
4539
4540                 return 0;
4541         }
4542
4543         if (parse_uid(*username, &u) >= 0) {
4544                 errno = 0;
4545                 p = getpwuid(u);
4546
4547                 /* If there are multiple users with the same id, make
4548                  * sure to leave $USER to the configured value instead
4549                  * of the first occurrence in the database. However if
4550                  * the uid was configured by a numeric uid, then let's
4551                  * pick the real username from /etc/passwd. */
4552                 if (p)
4553                         *username = p->pw_name;
4554         } else {
4555                 errno = 0;
4556                 p = getpwnam(*username);
4557         }
4558
4559         if (!p)
4560                 return errno > 0 ? -errno : -ESRCH;
4561
4562         if (uid)
4563                 *uid = p->pw_uid;
4564
4565         if (gid)
4566                 *gid = p->pw_gid;
4567
4568         if (home)
4569                 *home = p->pw_dir;
4570
4571         if (shell)
4572                 *shell = p->pw_shell;
4573
4574         return 0;
4575 }
4576
4577 char* uid_to_name(uid_t uid) {
4578         struct passwd *p;
4579         char *r;
4580
4581         if (uid == 0)
4582                 return strdup("root");
4583
4584         p = getpwuid(uid);
4585         if (p)
4586                 return strdup(p->pw_name);
4587
4588         if (asprintf(&r, UID_FMT, uid) < 0)
4589                 return NULL;
4590
4591         return r;
4592 }
4593
4594 char* gid_to_name(gid_t gid) {
4595         struct group *p;
4596         char *r;
4597
4598         if (gid == 0)
4599                 return strdup("root");
4600
4601         p = getgrgid(gid);
4602         if (p)
4603                 return strdup(p->gr_name);
4604
4605         if (asprintf(&r, GID_FMT, gid) < 0)
4606                 return NULL;
4607
4608         return r;
4609 }
4610
4611 int get_group_creds(const char **groupname, gid_t *gid) {
4612         struct group *g;
4613         gid_t id;
4614
4615         assert(groupname);
4616
4617         /* We enforce some special rules for gid=0: in order to avoid
4618          * NSS lookups for root we hardcode its data. */
4619
4620         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4621                 *groupname = "root";
4622
4623                 if (gid)
4624                         *gid = 0;
4625
4626                 return 0;
4627         }
4628
4629         if (parse_gid(*groupname, &id) >= 0) {
4630                 errno = 0;
4631                 g = getgrgid(id);
4632
4633                 if (g)
4634                         *groupname = g->gr_name;
4635         } else {
4636                 errno = 0;
4637                 g = getgrnam(*groupname);
4638         }
4639
4640         if (!g)
4641                 return errno > 0 ? -errno : -ESRCH;
4642
4643         if (gid)
4644                 *gid = g->gr_gid;
4645
4646         return 0;
4647 }
4648
4649 int in_gid(gid_t gid) {
4650         gid_t *gids;
4651         int ngroups_max, r, i;
4652
4653         if (getgid() == gid)
4654                 return 1;
4655
4656         if (getegid() == gid)
4657                 return 1;
4658
4659         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4660         assert(ngroups_max > 0);
4661
4662         gids = alloca(sizeof(gid_t) * ngroups_max);
4663
4664         r = getgroups(ngroups_max, gids);
4665         if (r < 0)
4666                 return -errno;
4667
4668         for (i = 0; i < r; i++)
4669                 if (gids[i] == gid)
4670                         return 1;
4671
4672         return 0;
4673 }
4674
4675 int in_group(const char *name) {
4676         int r;
4677         gid_t gid;
4678
4679         r = get_group_creds(&name, &gid);
4680         if (r < 0)
4681                 return r;
4682
4683         return in_gid(gid);
4684 }
4685
4686 int glob_exists(const char *path) {
4687         _cleanup_globfree_ glob_t g = {};
4688         int k;
4689
4690         assert(path);
4691
4692         errno = 0;
4693         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4694
4695         if (k == GLOB_NOMATCH)
4696                 return 0;
4697         else if (k == GLOB_NOSPACE)
4698                 return -ENOMEM;
4699         else if (k == 0)
4700                 return !strv_isempty(g.gl_pathv);
4701         else
4702                 return errno ? -errno : -EIO;
4703 }
4704
4705 int glob_extend(char ***strv, const char *path) {
4706         _cleanup_globfree_ glob_t g = {};
4707         int k;
4708         char **p;
4709
4710         errno = 0;
4711         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4712
4713         if (k == GLOB_NOMATCH)
4714                 return -ENOENT;
4715         else if (k == GLOB_NOSPACE)
4716                 return -ENOMEM;
4717         else if (k != 0 || strv_isempty(g.gl_pathv))
4718                 return errno ? -errno : -EIO;
4719
4720         STRV_FOREACH(p, g.gl_pathv) {
4721                 k = strv_extend(strv, *p);
4722                 if (k < 0)
4723                         break;
4724         }
4725
4726         return k;
4727 }
4728
4729 int dirent_ensure_type(DIR *d, struct dirent *de) {
4730         struct stat st;
4731
4732         assert(d);
4733         assert(de);
4734
4735         if (de->d_type != DT_UNKNOWN)
4736                 return 0;
4737
4738         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4739                 return -errno;
4740
4741         de->d_type =
4742                 S_ISREG(st.st_mode)  ? DT_REG  :
4743                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4744                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4745                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4746                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4747                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4748                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4749                                        DT_UNKNOWN;
4750
4751         return 0;
4752 }
4753
4754 int get_files_in_directory(const char *path, char ***list) {
4755         _cleanup_closedir_ DIR *d = NULL;
4756         size_t bufsize = 0, n = 0;
4757         _cleanup_strv_free_ char **l = NULL;
4758
4759         assert(path);
4760
4761         /* Returns all files in a directory in *list, and the number
4762          * of files as return value. If list is NULL returns only the
4763          * number. */
4764
4765         d = opendir(path);
4766         if (!d)
4767                 return -errno;
4768
4769         for (;;) {
4770                 struct dirent *de;
4771
4772                 errno = 0;
4773                 de = readdir(d);
4774                 if (!de && errno != 0)
4775                         return -errno;
4776                 if (!de)
4777                         break;
4778
4779                 dirent_ensure_type(d, de);
4780
4781                 if (!dirent_is_file(de))
4782                         continue;
4783
4784                 if (list) {
4785                         /* one extra slot is needed for the terminating NULL */
4786                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
4787                                 return -ENOMEM;
4788
4789                         l[n] = strdup(de->d_name);
4790                         if (!l[n])
4791                                 return -ENOMEM;
4792
4793                         l[++n] = NULL;
4794                 } else
4795                         n++;
4796         }
4797
4798         if (list) {
4799                 *list = l;
4800                 l = NULL; /* avoid freeing */
4801         }
4802
4803         return n;
4804 }
4805
4806 char *strjoin(const char *x, ...) {
4807         va_list ap;
4808         size_t l;
4809         char *r, *p;
4810
4811         va_start(ap, x);
4812
4813         if (x) {
4814                 l = strlen(x);
4815
4816                 for (;;) {
4817                         const char *t;
4818                         size_t n;
4819
4820                         t = va_arg(ap, const char *);
4821                         if (!t)
4822                                 break;
4823
4824                         n = strlen(t);
4825                         if (n > ((size_t) -1) - l) {
4826                                 va_end(ap);
4827                                 return NULL;
4828                         }
4829
4830                         l += n;
4831                 }
4832         } else
4833                 l = 0;
4834
4835         va_end(ap);
4836
4837         r = new(char, l+1);
4838         if (!r)
4839                 return NULL;
4840
4841         if (x) {
4842                 p = stpcpy(r, x);
4843
4844                 va_start(ap, x);
4845
4846                 for (;;) {
4847                         const char *t;
4848
4849                         t = va_arg(ap, const char *);
4850                         if (!t)
4851                                 break;
4852
4853                         p = stpcpy(p, t);
4854                 }
4855
4856                 va_end(ap);
4857         } else
4858                 r[0] = 0;
4859
4860         return r;
4861 }
4862
4863 bool is_main_thread(void) {
4864         static thread_local int cached = 0;
4865
4866         if (_unlikely_(cached == 0))
4867                 cached = getpid() == gettid() ? 1 : -1;
4868
4869         return cached > 0;
4870 }
4871
4872 int block_get_whole_disk(dev_t d, dev_t *ret) {
4873         char *p, *s;
4874         int r;
4875         unsigned n, m;
4876
4877         assert(ret);
4878
4879         /* If it has a queue this is good enough for us */
4880         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4881                 return -ENOMEM;
4882
4883         r = access(p, F_OK);
4884         free(p);
4885
4886         if (r >= 0) {
4887                 *ret = d;
4888                 return 0;
4889         }
4890
4891         /* If it is a partition find the originating device */
4892         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4893                 return -ENOMEM;
4894
4895         r = access(p, F_OK);
4896         free(p);
4897
4898         if (r < 0)
4899                 return -ENOENT;
4900
4901         /* Get parent dev_t */
4902         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4903                 return -ENOMEM;
4904
4905         r = read_one_line_file(p, &s);
4906         free(p);
4907
4908         if (r < 0)
4909                 return r;
4910
4911         r = sscanf(s, "%u:%u", &m, &n);
4912         free(s);
4913
4914         if (r != 2)
4915                 return -EINVAL;
4916
4917         /* Only return this if it is really good enough for us. */
4918         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4919                 return -ENOMEM;
4920
4921         r = access(p, F_OK);
4922         free(p);
4923
4924         if (r >= 0) {
4925                 *ret = makedev(m, n);
4926                 return 0;
4927         }
4928
4929         return -ENOENT;
4930 }
4931
4932 static const char *const ioprio_class_table[] = {
4933         [IOPRIO_CLASS_NONE] = "none",
4934         [IOPRIO_CLASS_RT] = "realtime",
4935         [IOPRIO_CLASS_BE] = "best-effort",
4936         [IOPRIO_CLASS_IDLE] = "idle"
4937 };
4938
4939 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4940
4941 static const char *const sigchld_code_table[] = {
4942         [CLD_EXITED] = "exited",
4943         [CLD_KILLED] = "killed",
4944         [CLD_DUMPED] = "dumped",
4945         [CLD_TRAPPED] = "trapped",
4946         [CLD_STOPPED] = "stopped",
4947         [CLD_CONTINUED] = "continued",
4948 };
4949
4950 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4951
4952 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4953         [LOG_FAC(LOG_KERN)] = "kern",
4954         [LOG_FAC(LOG_USER)] = "user",
4955         [LOG_FAC(LOG_MAIL)] = "mail",
4956         [LOG_FAC(LOG_DAEMON)] = "daemon",
4957         [LOG_FAC(LOG_AUTH)] = "auth",
4958         [LOG_FAC(LOG_SYSLOG)] = "syslog",
4959         [LOG_FAC(LOG_LPR)] = "lpr",
4960         [LOG_FAC(LOG_NEWS)] = "news",
4961         [LOG_FAC(LOG_UUCP)] = "uucp",
4962         [LOG_FAC(LOG_CRON)] = "cron",
4963         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4964         [LOG_FAC(LOG_FTP)] = "ftp",
4965         [LOG_FAC(LOG_LOCAL0)] = "local0",
4966         [LOG_FAC(LOG_LOCAL1)] = "local1",
4967         [LOG_FAC(LOG_LOCAL2)] = "local2",
4968         [LOG_FAC(LOG_LOCAL3)] = "local3",
4969         [LOG_FAC(LOG_LOCAL4)] = "local4",
4970         [LOG_FAC(LOG_LOCAL5)] = "local5",
4971         [LOG_FAC(LOG_LOCAL6)] = "local6",
4972         [LOG_FAC(LOG_LOCAL7)] = "local7"
4973 };
4974
4975 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4976
4977 static const char *const log_level_table[] = {
4978         [LOG_EMERG] = "emerg",
4979         [LOG_ALERT] = "alert",
4980         [LOG_CRIT] = "crit",
4981         [LOG_ERR] = "err",
4982         [LOG_WARNING] = "warning",
4983         [LOG_NOTICE] = "notice",
4984         [LOG_INFO] = "info",
4985         [LOG_DEBUG] = "debug"
4986 };
4987
4988 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
4989
4990 static const char* const sched_policy_table[] = {
4991         [SCHED_OTHER] = "other",
4992         [SCHED_BATCH] = "batch",
4993         [SCHED_IDLE] = "idle",
4994         [SCHED_FIFO] = "fifo",
4995         [SCHED_RR] = "rr"
4996 };
4997
4998 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
4999
5000 static const char* const rlimit_table[_RLIMIT_MAX] = {
5001         [RLIMIT_CPU] = "LimitCPU",
5002         [RLIMIT_FSIZE] = "LimitFSIZE",
5003         [RLIMIT_DATA] = "LimitDATA",
5004         [RLIMIT_STACK] = "LimitSTACK",
5005         [RLIMIT_CORE] = "LimitCORE",
5006         [RLIMIT_RSS] = "LimitRSS",
5007         [RLIMIT_NOFILE] = "LimitNOFILE",
5008         [RLIMIT_AS] = "LimitAS",
5009         [RLIMIT_NPROC] = "LimitNPROC",
5010         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5011         [RLIMIT_LOCKS] = "LimitLOCKS",
5012         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5013         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5014         [RLIMIT_NICE] = "LimitNICE",
5015         [RLIMIT_RTPRIO] = "LimitRTPRIO",
5016         [RLIMIT_RTTIME] = "LimitRTTIME"
5017 };
5018
5019 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5020
5021 static const char* const ip_tos_table[] = {
5022         [IPTOS_LOWDELAY] = "low-delay",
5023         [IPTOS_THROUGHPUT] = "throughput",
5024         [IPTOS_RELIABILITY] = "reliability",
5025         [IPTOS_LOWCOST] = "low-cost",
5026 };
5027
5028 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
5029
5030 static const char *const __signal_table[] = {
5031         [SIGHUP] = "HUP",
5032         [SIGINT] = "INT",
5033         [SIGQUIT] = "QUIT",
5034         [SIGILL] = "ILL",
5035         [SIGTRAP] = "TRAP",
5036         [SIGABRT] = "ABRT",
5037         [SIGBUS] = "BUS",
5038         [SIGFPE] = "FPE",
5039         [SIGKILL] = "KILL",
5040         [SIGUSR1] = "USR1",
5041         [SIGSEGV] = "SEGV",
5042         [SIGUSR2] = "USR2",
5043         [SIGPIPE] = "PIPE",
5044         [SIGALRM] = "ALRM",
5045         [SIGTERM] = "TERM",
5046 #ifdef SIGSTKFLT
5047         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
5048 #endif
5049         [SIGCHLD] = "CHLD",
5050         [SIGCONT] = "CONT",
5051         [SIGSTOP] = "STOP",
5052         [SIGTSTP] = "TSTP",
5053         [SIGTTIN] = "TTIN",
5054         [SIGTTOU] = "TTOU",
5055         [SIGURG] = "URG",
5056         [SIGXCPU] = "XCPU",
5057         [SIGXFSZ] = "XFSZ",
5058         [SIGVTALRM] = "VTALRM",
5059         [SIGPROF] = "PROF",
5060         [SIGWINCH] = "WINCH",
5061         [SIGIO] = "IO",
5062         [SIGPWR] = "PWR",
5063         [SIGSYS] = "SYS"
5064 };
5065
5066 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5067
5068 const char *signal_to_string(int signo) {
5069         static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
5070         const char *name;
5071
5072         name = __signal_to_string(signo);
5073         if (name)
5074                 return name;
5075
5076         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5077                 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
5078         else
5079                 snprintf(buf, sizeof(buf), "%d", signo);
5080
5081         return buf;
5082 }
5083
5084 int signal_from_string(const char *s) {
5085         int signo;
5086         int offset = 0;
5087         unsigned u;
5088
5089         signo = __signal_from_string(s);
5090         if (signo > 0)
5091                 return signo;
5092
5093         if (startswith(s, "RTMIN+")) {
5094                 s += 6;
5095                 offset = SIGRTMIN;
5096         }
5097         if (safe_atou(s, &u) >= 0) {
5098                 signo = (int) u + offset;
5099                 if (signo > 0 && signo < _NSIG)
5100                         return signo;
5101         }
5102         return -EINVAL;
5103 }
5104
5105 bool kexec_loaded(void) {
5106        bool loaded = false;
5107        char *s;
5108
5109        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5110                if (s[0] == '1')
5111                        loaded = true;
5112                free(s);
5113        }
5114        return loaded;
5115 }
5116
5117 int prot_from_flags(int flags) {
5118
5119         switch (flags & O_ACCMODE) {
5120
5121         case O_RDONLY:
5122                 return PROT_READ;
5123
5124         case O_WRONLY:
5125                 return PROT_WRITE;
5126
5127         case O_RDWR:
5128                 return PROT_READ|PROT_WRITE;
5129
5130         default:
5131                 return -EINVAL;
5132         }
5133 }
5134
5135 char *format_bytes(char *buf, size_t l, off_t t) {
5136         unsigned i;
5137
5138         static const struct {
5139                 const char *suffix;
5140                 off_t factor;
5141         } table[] = {
5142                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5143                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5144                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5145                 { "G", 1024ULL*1024ULL*1024ULL },
5146                 { "M", 1024ULL*1024ULL },
5147                 { "K", 1024ULL },
5148         };
5149
5150         for (i = 0; i < ELEMENTSOF(table); i++) {
5151
5152                 if (t >= table[i].factor) {
5153                         snprintf(buf, l,
5154                                  "%llu.%llu%s",
5155                                  (unsigned long long) (t / table[i].factor),
5156                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5157                                  table[i].suffix);
5158
5159                         goto finish;
5160                 }
5161         }
5162
5163         snprintf(buf, l, "%lluB", (unsigned long long) t);
5164
5165 finish:
5166         buf[l-1] = 0;
5167         return buf;
5168
5169 }
5170
5171 void* memdup(const void *p, size_t l) {
5172         void *r;
5173
5174         assert(p);
5175
5176         r = malloc(l);
5177         if (!r)
5178                 return NULL;
5179
5180         memcpy(r, p, l);
5181         return r;
5182 }
5183
5184 int fd_inc_sndbuf(int fd, size_t n) {
5185         int r, value;
5186         socklen_t l = sizeof(value);
5187
5188         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5189         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5190                 return 0;
5191
5192         /* If we have the privileges we will ignore the kernel limit. */
5193
5194         value = (int) n;
5195         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
5196                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
5197                         return -errno;
5198
5199         return 1;
5200 }
5201
5202 int fd_inc_rcvbuf(int fd, size_t n) {
5203         int r, value;
5204         socklen_t l = sizeof(value);
5205
5206         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5207         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5208                 return 0;
5209
5210         /* If we have the privileges we will ignore the kernel limit. */
5211
5212         value = (int) n;
5213         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
5214                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
5215                         return -errno;
5216         return 1;
5217 }
5218
5219 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5220         bool stdout_is_tty, stderr_is_tty;
5221         pid_t parent_pid, agent_pid;
5222         sigset_t ss, saved_ss;
5223         unsigned n, i;
5224         va_list ap;
5225         char **l;
5226
5227         assert(pid);
5228         assert(path);
5229
5230         /* Spawns a temporary TTY agent, making sure it goes away when
5231          * we go away */
5232
5233         parent_pid = getpid();
5234
5235         /* First we temporarily block all signals, so that the new
5236          * child has them blocked initially. This way, we can be sure
5237          * that SIGTERMs are not lost we might send to the agent. */
5238         assert_se(sigfillset(&ss) >= 0);
5239         assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
5240
5241         agent_pid = fork();
5242         if (agent_pid < 0) {
5243                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5244                 return -errno;
5245         }
5246
5247         if (agent_pid != 0) {
5248                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5249                 *pid = agent_pid;
5250                 return 0;
5251         }
5252
5253         /* In the child:
5254          *
5255          * Make sure the agent goes away when the parent dies */
5256         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5257                 _exit(EXIT_FAILURE);
5258
5259         /* Make sure we actually can kill the agent, if we need to, in
5260          * case somebody invoked us from a shell script that trapped
5261          * SIGTERM or so... */
5262         reset_all_signal_handlers();
5263         reset_signal_mask();
5264
5265         /* Check whether our parent died before we were able
5266          * to set the death signal and unblock the signals */
5267         if (getppid() != parent_pid)
5268                 _exit(EXIT_SUCCESS);
5269
5270         /* Don't leak fds to the agent */
5271         close_all_fds(except, n_except);
5272
5273         stdout_is_tty = isatty(STDOUT_FILENO);
5274         stderr_is_tty = isatty(STDERR_FILENO);
5275
5276         if (!stdout_is_tty || !stderr_is_tty) {
5277                 int fd;
5278
5279                 /* Detach from stdout/stderr. and reopen
5280                  * /dev/tty for them. This is important to
5281                  * ensure that when systemctl is started via
5282                  * popen() or a similar call that expects to
5283                  * read EOF we actually do generate EOF and
5284                  * not delay this indefinitely by because we
5285                  * keep an unused copy of stdin around. */
5286                 fd = open("/dev/tty", O_WRONLY);
5287                 if (fd < 0) {
5288                         log_error_errno(errno, "Failed to open /dev/tty: %m");
5289                         _exit(EXIT_FAILURE);
5290                 }
5291
5292                 if (!stdout_is_tty)
5293                         dup2(fd, STDOUT_FILENO);
5294
5295                 if (!stderr_is_tty)
5296                         dup2(fd, STDERR_FILENO);
5297
5298                 if (fd > 2)
5299                         close(fd);
5300         }
5301
5302         /* Count arguments */
5303         va_start(ap, path);
5304         for (n = 0; va_arg(ap, char*); n++)
5305                 ;
5306         va_end(ap);
5307
5308         /* Allocate strv */
5309         l = alloca(sizeof(char *) * (n + 1));
5310
5311         /* Fill in arguments */
5312         va_start(ap, path);
5313         for (i = 0; i <= n; i++)
5314                 l[i] = va_arg(ap, char*);
5315         va_end(ap);
5316
5317         execv(path, l);
5318         _exit(EXIT_FAILURE);
5319 }
5320
5321 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5322         struct rlimit highest, fixed;
5323
5324         assert(rlim);
5325
5326         if (setrlimit(resource, rlim) >= 0)
5327                 return 0;
5328
5329         if (errno != EPERM)
5330                 return -errno;
5331
5332         /* So we failed to set the desired setrlimit, then let's try
5333          * to get as close as we can */
5334         assert_se(getrlimit(resource, &highest) == 0);
5335
5336         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5337         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5338
5339         if (setrlimit(resource, &fixed) < 0)
5340                 return -errno;
5341
5342         return 0;
5343 }
5344
5345 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5346         _cleanup_fclose_ FILE *f = NULL;
5347         char *value = NULL;
5348         int r;
5349         bool done = false;
5350         size_t l;
5351         const char *path;
5352
5353         assert(pid >= 0);
5354         assert(field);
5355         assert(_value);
5356
5357         path = procfs_file_alloca(pid, "environ");
5358
5359         f = fopen(path, "re");
5360         if (!f)
5361                 return -errno;
5362
5363         l = strlen(field);
5364         r = 0;
5365
5366         do {
5367                 char line[LINE_MAX];
5368                 unsigned i;
5369
5370                 for (i = 0; i < sizeof(line)-1; i++) {
5371                         int c;
5372
5373                         c = getc(f);
5374                         if (_unlikely_(c == EOF)) {
5375                                 done = true;
5376                                 break;
5377                         } else if (c == 0)
5378                                 break;
5379
5380                         line[i] = c;
5381                 }
5382                 line[i] = 0;
5383
5384                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5385                         value = strdup(line + l + 1);
5386                         if (!value)
5387                                 return -ENOMEM;
5388
5389                         r = 1;
5390                         break;
5391                 }
5392
5393         } while (!done);
5394
5395         *_value = value;
5396         return r;
5397 }
5398
5399 bool is_valid_documentation_url(const char *url) {
5400         assert(url);
5401
5402         if (startswith(url, "http://") && url[7])
5403                 return true;
5404
5405         if (startswith(url, "https://") && url[8])
5406                 return true;
5407
5408         if (startswith(url, "file:") && url[5])
5409                 return true;
5410
5411         if (startswith(url, "info:") && url[5])
5412                 return true;
5413
5414         if (startswith(url, "man:") && url[4])
5415                 return true;
5416
5417         return false;
5418 }
5419
5420 bool in_initrd(void) {
5421         static int saved = -1;
5422         struct statfs s;
5423
5424         if (saved >= 0)
5425                 return saved;
5426
5427         /* We make two checks here:
5428          *
5429          * 1. the flag file /etc/initrd-release must exist
5430          * 2. the root file system must be a memory file system
5431          *
5432          * The second check is extra paranoia, since misdetecting an
5433          * initrd can have bad bad consequences due the initrd
5434          * emptying when transititioning to the main systemd.
5435          */
5436
5437         saved = access("/etc/initrd-release", F_OK) >= 0 &&
5438                 statfs("/", &s) >= 0 &&
5439                 is_temporary_fs(&s);
5440
5441         return saved;
5442 }
5443
5444 void warn_melody(void) {
5445         _cleanup_close_ int fd = -1;
5446
5447         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5448         if (fd < 0)
5449                 return;
5450
5451         /* Yeah, this is synchronous. Kinda sucks. But well... */
5452
5453         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5454         usleep(125*USEC_PER_MSEC);
5455
5456         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5457         usleep(125*USEC_PER_MSEC);
5458
5459         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5460         usleep(125*USEC_PER_MSEC);
5461
5462         ioctl(fd, KIOCSOUND, 0);
5463 }
5464
5465 int make_console_stdio(void) {
5466         int fd, r;
5467
5468         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5469
5470         fd = acquire_terminal("/dev/console", false, true, true, USEC_INFINITY);
5471         if (fd < 0)
5472                 return log_error_errno(fd, "Failed to acquire terminal: %m");
5473
5474         r = make_stdio(fd);
5475         if (r < 0)
5476                 return log_error_errno(r, "Failed to duplicate terminal fd: %m");
5477
5478         return 0;
5479 }
5480
5481 int get_home_dir(char **_h) {
5482         struct passwd *p;
5483         const char *e;
5484         char *h;
5485         uid_t u;
5486
5487         assert(_h);
5488
5489         /* Take the user specified one */
5490         e = secure_getenv("HOME");
5491         if (e && path_is_absolute(e)) {
5492                 h = strdup(e);
5493                 if (!h)
5494                         return -ENOMEM;
5495
5496                 *_h = h;
5497                 return 0;
5498         }
5499
5500         /* Hardcode home directory for root to avoid NSS */
5501         u = getuid();
5502         if (u == 0) {
5503                 h = strdup("/root");
5504                 if (!h)
5505                         return -ENOMEM;
5506
5507                 *_h = h;
5508                 return 0;
5509         }
5510
5511         /* Check the database... */
5512         errno = 0;
5513         p = getpwuid(u);
5514         if (!p)
5515                 return errno > 0 ? -errno : -ESRCH;
5516
5517         if (!path_is_absolute(p->pw_dir))
5518                 return -EINVAL;
5519
5520         h = strdup(p->pw_dir);
5521         if (!h)
5522                 return -ENOMEM;
5523
5524         *_h = h;
5525         return 0;
5526 }
5527
5528 int get_shell(char **_s) {
5529         struct passwd *p;
5530         const char *e;
5531         char *s;
5532         uid_t u;
5533
5534         assert(_s);
5535
5536         /* Take the user specified one */
5537         e = getenv("SHELL");
5538         if (e) {
5539                 s = strdup(e);
5540                 if (!s)
5541                         return -ENOMEM;
5542
5543                 *_s = s;
5544                 return 0;
5545         }
5546
5547         /* Hardcode home directory for root to avoid NSS */
5548         u = getuid();
5549         if (u == 0) {
5550                 s = strdup("/bin/sh");
5551                 if (!s)
5552                         return -ENOMEM;
5553
5554                 *_s = s;
5555                 return 0;
5556         }
5557
5558         /* Check the database... */
5559         errno = 0;
5560         p = getpwuid(u);
5561         if (!p)
5562                 return errno > 0 ? -errno : -ESRCH;
5563
5564         if (!path_is_absolute(p->pw_shell))
5565                 return -EINVAL;
5566
5567         s = strdup(p->pw_shell);
5568         if (!s)
5569                 return -ENOMEM;
5570
5571         *_s = s;
5572         return 0;
5573 }
5574
5575 bool filename_is_valid(const char *p) {
5576
5577         if (isempty(p))
5578                 return false;
5579
5580         if (strchr(p, '/'))
5581                 return false;
5582
5583         if (streq(p, "."))
5584                 return false;
5585
5586         if (streq(p, ".."))
5587                 return false;
5588
5589         if (strlen(p) > FILENAME_MAX)
5590                 return false;
5591
5592         return true;
5593 }
5594
5595 bool string_is_safe(const char *p) {
5596         const char *t;
5597
5598         if (!p)
5599                 return false;
5600
5601         for (t = p; *t; t++) {
5602                 if (*t > 0 && *t < ' ')
5603                         return false;
5604
5605                 if (strchr("\\\"\'\0x7f", *t))
5606                         return false;
5607         }
5608
5609         return true;
5610 }
5611
5612 /**
5613  * Check if a string contains control characters. If 'ok' is non-NULL
5614  * it may be a string containing additional CCs to be considered OK.
5615  */
5616 bool string_has_cc(const char *p, const char *ok) {
5617         const char *t;
5618
5619         assert(p);
5620
5621         for (t = p; *t; t++) {
5622                 if (ok && strchr(ok, *t))
5623                         continue;
5624
5625                 if (*t > 0 && *t < ' ')
5626                         return true;
5627
5628                 if (*t == 127)
5629                         return true;
5630         }
5631
5632         return false;
5633 }
5634
5635 bool path_is_safe(const char *p) {
5636
5637         if (isempty(p))
5638                 return false;
5639
5640         if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5641                 return false;
5642
5643         if (strlen(p) > PATH_MAX)
5644                 return false;
5645
5646         /* The following two checks are not really dangerous, but hey, they still are confusing */
5647         if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5648                 return false;
5649
5650         if (strstr(p, "//"))
5651                 return false;
5652
5653         return true;
5654 }
5655
5656 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5657 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5658                  int (*compar) (const void *, const void *, void *), void *arg) {
5659         size_t l, u, idx;
5660         const void *p;
5661         int comparison;
5662
5663         l = 0;
5664         u = nmemb;
5665         while (l < u) {
5666                 idx = (l + u) / 2;
5667                 p = (void *)(((const char *) base) + (idx * size));
5668                 comparison = compar(key, p, arg);
5669                 if (comparison < 0)
5670                         u = idx;
5671                 else if (comparison > 0)
5672                         l = idx + 1;
5673                 else
5674                         return (void *)p;
5675         }
5676         return NULL;
5677 }
5678
5679 bool is_locale_utf8(void) {
5680         const char *set;
5681         static int cached_answer = -1;
5682
5683         if (cached_answer >= 0)
5684                 goto out;
5685
5686         if (!setlocale(LC_ALL, "")) {
5687                 cached_answer = true;
5688                 goto out;
5689         }
5690
5691         set = nl_langinfo(CODESET);
5692         if (!set) {
5693                 cached_answer = true;
5694                 goto out;
5695         }
5696
5697         if (streq(set, "UTF-8")) {
5698                 cached_answer = true;
5699                 goto out;
5700         }
5701
5702         /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5703          * unset and everything can do to UTF-8 nowadays. */
5704         set = setlocale(LC_CTYPE, NULL);
5705         if (!set) {
5706                 cached_answer = true;
5707                 goto out;
5708         }
5709
5710         /* Check result, but ignore the result if C was set
5711          * explicitly. */
5712         cached_answer =
5713                 streq(set, "C") &&
5714                 !getenv("LC_ALL") &&
5715                 !getenv("LC_CTYPE") &&
5716                 !getenv("LANG");
5717
5718 out:
5719         return (bool) cached_answer;
5720 }
5721
5722 const char *draw_special_char(DrawSpecialChar ch) {
5723         static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5724
5725                 /* UTF-8 */ {
5726                         [DRAW_TREE_VERTICAL]      = "\342\224\202 ",            /* │  */
5727                         [DRAW_TREE_BRANCH]        = "\342\224\234\342\224\200", /* ├─ */
5728                         [DRAW_TREE_RIGHT]         = "\342\224\224\342\224\200", /* └─ */
5729                         [DRAW_TREE_SPACE]         = "  ",                       /*    */
5730                         [DRAW_TRIANGULAR_BULLET]  = "\342\200\243",             /* ‣ */
5731                         [DRAW_BLACK_CIRCLE]       = "\342\227\217",             /* ● */
5732                         [DRAW_ARROW]              = "\342\206\222",             /* → */
5733                         [DRAW_DASH]               = "\342\200\223",             /* – */
5734                 },
5735
5736                 /* ASCII fallback */ {
5737                         [DRAW_TREE_VERTICAL]      = "| ",
5738                         [DRAW_TREE_BRANCH]        = "|-",
5739                         [DRAW_TREE_RIGHT]         = "`-",
5740                         [DRAW_TREE_SPACE]         = "  ",
5741                         [DRAW_TRIANGULAR_BULLET]  = ">",
5742                         [DRAW_BLACK_CIRCLE]       = "*",
5743                         [DRAW_ARROW]              = "->",
5744                         [DRAW_DASH]               = "-",
5745                 }
5746         };
5747
5748         return draw_table[!is_locale_utf8()][ch];
5749 }
5750
5751 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5752         const char *f;
5753         char *t, *r;
5754         size_t l, old_len, new_len;
5755
5756         assert(text);
5757         assert(old_string);
5758         assert(new_string);
5759
5760         old_len = strlen(old_string);
5761         new_len = strlen(new_string);
5762
5763         l = strlen(text);
5764         r = new(char, l+1);
5765         if (!r)
5766                 return NULL;
5767
5768         f = text;
5769         t = r;
5770         while (*f) {
5771                 char *a;
5772                 size_t d, nl;
5773
5774                 if (!startswith(f, old_string)) {
5775                         *(t++) = *(f++);
5776                         continue;
5777                 }
5778
5779                 d = t - r;
5780                 nl = l - old_len + new_len;
5781                 a = realloc(r, nl + 1);
5782                 if (!a)
5783                         goto oom;
5784
5785                 l = nl;
5786                 r = a;
5787                 t = r + d;
5788
5789                 t = stpcpy(t, new_string);
5790                 f += old_len;
5791         }
5792
5793         *t = 0;
5794         return r;
5795
5796 oom:
5797         free(r);
5798         return NULL;
5799 }
5800
5801 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5802         const char *i, *begin = NULL;
5803         enum {
5804                 STATE_OTHER,
5805                 STATE_ESCAPE,
5806                 STATE_BRACKET
5807         } state = STATE_OTHER;
5808         char *obuf = NULL;
5809         size_t osz = 0, isz;
5810         FILE *f;
5811
5812         assert(ibuf);
5813         assert(*ibuf);
5814
5815         /* Strips ANSI color and replaces TABs by 8 spaces */
5816
5817         isz = _isz ? *_isz : strlen(*ibuf);
5818
5819         f = open_memstream(&obuf, &osz);
5820         if (!f)
5821                 return NULL;
5822
5823         for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5824
5825                 switch (state) {
5826
5827                 case STATE_OTHER:
5828                         if (i >= *ibuf + isz) /* EOT */
5829                                 break;
5830                         else if (*i == '\x1B')
5831                                 state = STATE_ESCAPE;
5832                         else if (*i == '\t')
5833                                 fputs("        ", f);
5834                         else
5835                                 fputc(*i, f);
5836                         break;
5837
5838                 case STATE_ESCAPE:
5839                         if (i >= *ibuf + isz) { /* EOT */
5840                                 fputc('\x1B', f);
5841                                 break;
5842                         } else if (*i == '[') {
5843                                 state = STATE_BRACKET;
5844                                 begin = i + 1;
5845                         } else {
5846                                 fputc('\x1B', f);
5847                                 fputc(*i, f);
5848                                 state = STATE_OTHER;
5849                         }
5850
5851                         break;
5852
5853                 case STATE_BRACKET:
5854
5855                         if (i >= *ibuf + isz || /* EOT */
5856                             (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5857                                 fputc('\x1B', f);
5858                                 fputc('[', f);
5859                                 state = STATE_OTHER;
5860                                 i = begin-1;
5861                         } else if (*i == 'm')
5862                                 state = STATE_OTHER;
5863                         break;
5864                 }
5865         }
5866
5867         if (ferror(f)) {
5868                 fclose(f);
5869                 free(obuf);
5870                 return NULL;
5871         }
5872
5873         fclose(f);
5874
5875         free(*ibuf);
5876         *ibuf = obuf;
5877
5878         if (_isz)
5879                 *_isz = osz;
5880
5881         return obuf;
5882 }
5883
5884 int on_ac_power(void) {
5885         bool found_offline = false, found_online = false;
5886         _cleanup_closedir_ DIR *d = NULL;
5887
5888         d = opendir("/sys/class/power_supply");
5889         if (!d)
5890                 return -errno;
5891
5892         for (;;) {
5893                 struct dirent *de;
5894                 _cleanup_close_ int fd = -1, device = -1;
5895                 char contents[6];
5896                 ssize_t n;
5897
5898                 errno = 0;
5899                 de = readdir(d);
5900                 if (!de && errno != 0)
5901                         return -errno;
5902
5903                 if (!de)
5904                         break;
5905
5906                 if (ignore_file(de->d_name))
5907                         continue;
5908
5909                 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5910                 if (device < 0) {
5911                         if (errno == ENOENT || errno == ENOTDIR)
5912                                 continue;
5913
5914                         return -errno;
5915                 }
5916
5917                 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5918                 if (fd < 0) {
5919                         if (errno == ENOENT)
5920                                 continue;
5921
5922                         return -errno;
5923                 }
5924
5925                 n = read(fd, contents, sizeof(contents));
5926                 if (n < 0)
5927                         return -errno;
5928
5929                 if (n != 6 || memcmp(contents, "Mains\n", 6))
5930                         continue;
5931
5932                 safe_close(fd);
5933                 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5934                 if (fd < 0) {
5935                         if (errno == ENOENT)
5936                                 continue;
5937
5938                         return -errno;
5939                 }
5940
5941                 n = read(fd, contents, sizeof(contents));
5942                 if (n < 0)
5943                         return -errno;
5944
5945                 if (n != 2 || contents[1] != '\n')
5946                         return -EIO;
5947
5948                 if (contents[0] == '1') {
5949                         found_online = true;
5950                         break;
5951                 } else if (contents[0] == '0')
5952                         found_offline = true;
5953                 else
5954                         return -EIO;
5955         }
5956
5957         return found_online || !found_offline;
5958 }
5959
5960 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
5961         char **i;
5962
5963         assert(path);
5964         assert(mode);
5965         assert(_f);
5966
5967         if (!path_strv_resolve_uniq(search, root))
5968                 return -ENOMEM;
5969
5970         STRV_FOREACH(i, search) {
5971                 _cleanup_free_ char *p = NULL;
5972                 FILE *f;
5973
5974                 if (root)
5975                         p = strjoin(root, *i, "/", path, NULL);
5976                 else
5977                         p = strjoin(*i, "/", path, NULL);
5978                 if (!p)
5979                         return -ENOMEM;
5980
5981                 f = fopen(p, mode);
5982                 if (f) {
5983                         *_f = f;
5984                         return 0;
5985                 }
5986
5987                 if (errno != ENOENT)
5988                         return -errno;
5989         }
5990
5991         return -ENOENT;
5992 }
5993
5994 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
5995         _cleanup_strv_free_ char **copy = NULL;
5996
5997         assert(path);
5998         assert(mode);
5999         assert(_f);
6000
6001         if (path_is_absolute(path)) {
6002                 FILE *f;
6003
6004                 f = fopen(path, mode);
6005                 if (f) {
6006                         *_f = f;
6007                         return 0;
6008                 }
6009
6010                 return -errno;
6011         }
6012
6013         copy = strv_copy((char**) search);
6014         if (!copy)
6015                 return -ENOMEM;
6016
6017         return search_and_fopen_internal(path, mode, root, copy, _f);
6018 }
6019
6020 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
6021         _cleanup_strv_free_ char **s = NULL;
6022
6023         if (path_is_absolute(path)) {
6024                 FILE *f;
6025
6026                 f = fopen(path, mode);
6027                 if (f) {
6028                         *_f = f;
6029                         return 0;
6030                 }
6031
6032                 return -errno;
6033         }
6034
6035         s = strv_split_nulstr(search);
6036         if (!s)
6037                 return -ENOMEM;
6038
6039         return search_and_fopen_internal(path, mode, root, s, _f);
6040 }
6041
6042 char *strextend(char **x, ...) {
6043         va_list ap;
6044         size_t f, l;
6045         char *r, *p;
6046
6047         assert(x);
6048
6049         l = f = *x ? strlen(*x) : 0;
6050
6051         va_start(ap, x);
6052         for (;;) {
6053                 const char *t;
6054                 size_t n;
6055
6056                 t = va_arg(ap, const char *);
6057                 if (!t)
6058                         break;
6059
6060                 n = strlen(t);
6061                 if (n > ((size_t) -1) - l) {
6062                         va_end(ap);
6063                         return NULL;
6064                 }
6065
6066                 l += n;
6067         }
6068         va_end(ap);
6069
6070         r = realloc(*x, l+1);
6071         if (!r)
6072                 return NULL;
6073
6074         p = r + f;
6075
6076         va_start(ap, x);
6077         for (;;) {
6078                 const char *t;
6079
6080                 t = va_arg(ap, const char *);
6081                 if (!t)
6082                         break;
6083
6084                 p = stpcpy(p, t);
6085         }
6086         va_end(ap);
6087
6088         *p = 0;
6089         *x = r;
6090
6091         return r + l;
6092 }
6093
6094 char *strrep(const char *s, unsigned n) {
6095         size_t l;
6096         char *r, *p;
6097         unsigned i;
6098
6099         assert(s);
6100
6101         l = strlen(s);
6102         p = r = malloc(l * n + 1);
6103         if (!r)
6104                 return NULL;
6105
6106         for (i = 0; i < n; i++)
6107                 p = stpcpy(p, s);
6108
6109         *p = 0;
6110         return r;
6111 }
6112
6113 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
6114         size_t a, newalloc;
6115         void *q;
6116
6117         assert(p);
6118         assert(allocated);
6119
6120         if (*allocated >= need)
6121                 return *p;
6122
6123         newalloc = MAX(need * 2, 64u / size);
6124         a = newalloc * size;
6125
6126         /* check for overflows */
6127         if (a < size * need)
6128                 return NULL;
6129
6130         q = realloc(*p, a);
6131         if (!q)
6132                 return NULL;
6133
6134         *p = q;
6135         *allocated = newalloc;
6136         return q;
6137 }
6138
6139 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
6140         size_t prev;
6141         uint8_t *q;
6142
6143         assert(p);
6144         assert(allocated);
6145
6146         prev = *allocated;
6147
6148         q = greedy_realloc(p, allocated, need, size);
6149         if (!q)
6150                 return NULL;
6151
6152         if (*allocated > prev)
6153                 memzero(q + prev * size, (*allocated - prev) * size);
6154
6155         return q;
6156 }
6157
6158 bool id128_is_valid(const char *s) {
6159         size_t i, l;
6160
6161         l = strlen(s);
6162         if (l == 32) {
6163
6164                 /* Simple formatted 128bit hex string */
6165
6166                 for (i = 0; i < l; i++) {
6167                         char c = s[i];
6168
6169                         if (!(c >= '0' && c <= '9') &&
6170                             !(c >= 'a' && c <= 'z') &&
6171                             !(c >= 'A' && c <= 'Z'))
6172                                 return false;
6173                 }
6174
6175         } else if (l == 36) {
6176
6177                 /* Formatted UUID */
6178
6179                 for (i = 0; i < l; i++) {
6180                         char c = s[i];
6181
6182                         if ((i == 8 || i == 13 || i == 18 || i == 23)) {
6183                                 if (c != '-')
6184                                         return false;
6185                         } else {
6186                                 if (!(c >= '0' && c <= '9') &&
6187                                     !(c >= 'a' && c <= 'z') &&
6188                                     !(c >= 'A' && c <= 'Z'))
6189                                         return false;
6190                         }
6191                 }
6192
6193         } else
6194                 return false;
6195
6196         return true;
6197 }
6198
6199 int split_pair(const char *s, const char *sep, char **l, char **r) {
6200         char *x, *a, *b;
6201
6202         assert(s);
6203         assert(sep);
6204         assert(l);
6205         assert(r);
6206
6207         if (isempty(sep))
6208                 return -EINVAL;
6209
6210         x = strstr(s, sep);
6211         if (!x)
6212                 return -EINVAL;
6213
6214         a = strndup(s, x - s);
6215         if (!a)
6216                 return -ENOMEM;
6217
6218         b = strdup(x + strlen(sep));
6219         if (!b) {
6220                 free(a);
6221                 return -ENOMEM;
6222         }
6223
6224         *l = a;
6225         *r = b;
6226
6227         return 0;
6228 }
6229
6230 int shall_restore_state(void) {
6231         _cleanup_free_ char *value = NULL;
6232         int r;
6233
6234         r = get_proc_cmdline_key("systemd.restore_state=", &value);
6235         if (r < 0)
6236                 return r;
6237         if (r == 0)
6238                 return true;
6239
6240         return parse_boolean(value) != 0;
6241 }
6242
6243 int proc_cmdline(char **ret) {
6244         assert(ret);
6245
6246         if (detect_container(NULL) > 0)
6247                 return get_process_cmdline(1, 0, false, ret);
6248         else
6249                 return read_one_line_file("/proc/cmdline", ret);
6250 }
6251
6252 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6253         _cleanup_free_ char *line = NULL;
6254         const char *p;
6255         int r;
6256
6257         assert(parse_item);
6258
6259         r = proc_cmdline(&line);
6260         if (r < 0)
6261                 return r;
6262
6263         p = line;
6264         for (;;) {
6265                 _cleanup_free_ char *word = NULL;
6266                 char *value = NULL;
6267
6268                 r = unquote_first_word(&p, &word, true);
6269                 if (r < 0)
6270                         return r;
6271                 if (r == 0)
6272                         break;
6273
6274                 /* Filter out arguments that are intended only for the
6275                  * initrd */
6276                 if (!in_initrd() && startswith(word, "rd."))
6277                         continue;
6278
6279                 value = strchr(word, '=');
6280                 if (value)
6281                         *(value++) = 0;
6282
6283                 r = parse_item(word, value);
6284                 if (r < 0)
6285                         return r;
6286         }
6287
6288         return 0;
6289 }
6290
6291 int get_proc_cmdline_key(const char *key, char **value) {
6292         _cleanup_free_ char *line = NULL, *ret = NULL;
6293         bool found = false;
6294         const char *p;
6295         int r;
6296
6297         assert(key);
6298
6299         r = proc_cmdline(&line);
6300         if (r < 0)
6301                 return r;
6302
6303         p = line;
6304         for (;;) {
6305                 _cleanup_free_ char *word = NULL;
6306                 const char *e;
6307
6308                 r = unquote_first_word(&p, &word, true);
6309                 if (r < 0)
6310                         return r;
6311                 if (r == 0)
6312                         break;
6313
6314                 /* Filter out arguments that are intended only for the
6315                  * initrd */
6316                 if (!in_initrd() && startswith(word, "rd."))
6317                         continue;
6318
6319                 if (value) {
6320                         e = startswith(word, key);
6321                         if (!e)
6322                                 continue;
6323
6324                         r = free_and_strdup(&ret, e);
6325                         if (r < 0)
6326                                 return r;
6327
6328                         found = true;
6329                 } else {
6330                         if (streq(word, key))
6331                                 found = true;
6332                 }
6333         }
6334
6335         if (value) {
6336                 *value = ret;
6337                 ret = NULL;
6338         }
6339
6340         return found;
6341
6342 }
6343
6344 int container_get_leader(const char *machine, pid_t *pid) {
6345         _cleanup_free_ char *s = NULL, *class = NULL;
6346         const char *p;
6347         pid_t leader;
6348         int r;
6349
6350         assert(machine);
6351         assert(pid);
6352
6353         p = strappenda("/run/systemd/machines/", machine);
6354         r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6355         if (r == -ENOENT)
6356                 return -EHOSTDOWN;
6357         if (r < 0)
6358                 return r;
6359         if (!s)
6360                 return -EIO;
6361
6362         if (!streq_ptr(class, "container"))
6363                 return -EIO;
6364
6365         r = parse_pid(s, &leader);
6366         if (r < 0)
6367                 return r;
6368         if (leader <= 1)
6369                 return -EIO;
6370
6371         *pid = leader;
6372         return 0;
6373 }
6374
6375 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
6376         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
6377         int rfd = -1;
6378
6379         assert(pid >= 0);
6380
6381         if (mntns_fd) {
6382                 const char *mntns;
6383
6384                 mntns = procfs_file_alloca(pid, "ns/mnt");
6385                 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6386                 if (mntnsfd < 0)
6387                         return -errno;
6388         }
6389
6390         if (pidns_fd) {
6391                 const char *pidns;
6392
6393                 pidns = procfs_file_alloca(pid, "ns/pid");
6394                 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6395                 if (pidnsfd < 0)
6396                         return -errno;
6397         }
6398
6399         if (netns_fd) {
6400                 const char *netns;
6401
6402                 netns = procfs_file_alloca(pid, "ns/net");
6403                 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6404                 if (netnsfd < 0)
6405                         return -errno;
6406         }
6407
6408         if (root_fd) {
6409                 const char *root;
6410
6411                 root = procfs_file_alloca(pid, "root");
6412                 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6413                 if (rfd < 0)
6414                         return -errno;
6415         }
6416
6417         if (pidns_fd)
6418                 *pidns_fd = pidnsfd;
6419
6420         if (mntns_fd)
6421                 *mntns_fd = mntnsfd;
6422
6423         if (netns_fd)
6424                 *netns_fd = netnsfd;
6425
6426         if (root_fd)
6427                 *root_fd = rfd;
6428
6429         pidnsfd = mntnsfd = netnsfd = -1;
6430
6431         return 0;
6432 }
6433
6434 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
6435
6436         if (pidns_fd >= 0)
6437                 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6438                         return -errno;
6439
6440         if (mntns_fd >= 0)
6441                 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6442                         return -errno;
6443
6444         if (netns_fd >= 0)
6445                 if (setns(netns_fd, CLONE_NEWNET) < 0)
6446                         return -errno;
6447
6448         if (root_fd >= 0) {
6449                 if (fchdir(root_fd) < 0)
6450                         return -errno;
6451
6452                 if (chroot(".") < 0)
6453                         return -errno;
6454         }
6455
6456         if (setresgid(0, 0, 0) < 0)
6457                 return -errno;
6458
6459         if (setgroups(0, NULL) < 0)
6460                 return -errno;
6461
6462         if (setresuid(0, 0, 0) < 0)
6463                 return -errno;
6464
6465         return 0;
6466 }
6467
6468 bool pid_is_unwaited(pid_t pid) {
6469         /* Checks whether a PID is still valid at all, including a zombie */
6470
6471         if (pid <= 0)
6472                 return false;
6473
6474         if (kill(pid, 0) >= 0)
6475                 return true;
6476
6477         return errno != ESRCH;
6478 }
6479
6480 bool pid_is_alive(pid_t pid) {
6481         int r;
6482
6483         /* Checks whether a PID is still valid and not a zombie */
6484
6485         if (pid <= 0)
6486                 return false;
6487
6488         r = get_process_state(pid);
6489         if (r == -ENOENT || r == 'Z')
6490                 return false;
6491
6492         return true;
6493 }
6494
6495 int getpeercred(int fd, struct ucred *ucred) {
6496         socklen_t n = sizeof(struct ucred);
6497         struct ucred u;
6498         int r;
6499
6500         assert(fd >= 0);
6501         assert(ucred);
6502
6503         r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6504         if (r < 0)
6505                 return -errno;
6506
6507         if (n != sizeof(struct ucred))
6508                 return -EIO;
6509
6510         /* Check if the data is actually useful and not suppressed due
6511          * to namespacing issues */
6512         if (u.pid <= 0)
6513                 return -ENODATA;
6514         if (u.uid == UID_INVALID)
6515                 return -ENODATA;
6516         if (u.gid == GID_INVALID)
6517                 return -ENODATA;
6518
6519         *ucred = u;
6520         return 0;
6521 }
6522
6523 int getpeersec(int fd, char **ret) {
6524         socklen_t n = 64;
6525         char *s;
6526         int r;
6527
6528         assert(fd >= 0);
6529         assert(ret);
6530
6531         s = new0(char, n);
6532         if (!s)
6533                 return -ENOMEM;
6534
6535         r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6536         if (r < 0) {
6537                 free(s);
6538
6539                 if (errno != ERANGE)
6540                         return -errno;
6541
6542                 s = new0(char, n);
6543                 if (!s)
6544                         return -ENOMEM;
6545
6546                 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6547                 if (r < 0) {
6548                         free(s);
6549                         return -errno;
6550                 }
6551         }
6552
6553         if (isempty(s)) {
6554                 free(s);
6555                 return -ENOTSUP;
6556         }
6557
6558         *ret = s;
6559         return 0;
6560 }
6561
6562 /* This is much like like mkostemp() but is subject to umask(). */
6563 int mkostemp_safe(char *pattern, int flags) {
6564         _cleanup_umask_ mode_t u;
6565         int fd;
6566
6567         assert(pattern);
6568
6569         u = umask(077);
6570
6571         fd = mkostemp(pattern, flags);
6572         if (fd < 0)
6573                 return -errno;
6574
6575         return fd;
6576 }
6577
6578 int open_tmpfile(const char *path, int flags) {
6579         char *p;
6580         int fd;
6581
6582         assert(path);
6583
6584 #ifdef O_TMPFILE
6585         /* Try O_TMPFILE first, if it is supported */
6586         fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6587         if (fd >= 0)
6588                 return fd;
6589 #endif
6590
6591         /* Fall back to unguessable name + unlinking */
6592         p = strappenda(path, "/systemd-tmp-XXXXXX");
6593
6594         fd = mkostemp_safe(p, flags);
6595         if (fd < 0)
6596                 return fd;
6597
6598         unlink(p);
6599         return fd;
6600 }
6601
6602 int fd_warn_permissions(const char *path, int fd) {
6603         struct stat st;
6604
6605         if (fstat(fd, &st) < 0)
6606                 return -errno;
6607
6608         if (st.st_mode & 0111)
6609                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6610
6611         if (st.st_mode & 0002)
6612                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6613
6614         if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6615                 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);
6616
6617         return 0;
6618 }
6619
6620 unsigned long personality_from_string(const char *p) {
6621
6622         /* Parse a personality specifier. We introduce our own
6623          * identifiers that indicate specific ABIs, rather than just
6624          * hints regarding the register size, since we want to keep
6625          * things open for multiple locally supported ABIs for the
6626          * same register size. We try to reuse the ABI identifiers
6627          * used by libseccomp. */
6628
6629 #if defined(__x86_64__)
6630
6631         if (streq(p, "x86"))
6632                 return PER_LINUX32;
6633
6634         if (streq(p, "x86-64"))
6635                 return PER_LINUX;
6636
6637 #elif defined(__i386__)
6638
6639         if (streq(p, "x86"))
6640                 return PER_LINUX;
6641 #endif
6642
6643         /* personality(7) documents that 0xffffffffUL is used for
6644          * querying the current personality, hence let's use that here
6645          * as error indicator. */
6646         return 0xffffffffUL;
6647 }
6648
6649 const char* personality_to_string(unsigned long p) {
6650
6651 #if defined(__x86_64__)
6652
6653         if (p == PER_LINUX32)
6654                 return "x86";
6655
6656         if (p == PER_LINUX)
6657                 return "x86-64";
6658
6659 #elif defined(__i386__)
6660
6661         if (p == PER_LINUX)
6662                 return "x86";
6663 #endif
6664
6665         return NULL;
6666 }
6667
6668 uint64_t physical_memory(void) {
6669         long mem;
6670
6671         /* We return this as uint64_t in case we are running as 32bit
6672          * process on a 64bit kernel with huge amounts of memory */
6673
6674         mem = sysconf(_SC_PHYS_PAGES);
6675         assert(mem > 0);
6676
6677         return (uint64_t) mem * (uint64_t) page_size();
6678 }
6679
6680 char* mount_test_option(const char *haystack, const char *needle) {
6681
6682         struct mntent me = {
6683                 .mnt_opts = (char*) haystack
6684         };
6685
6686         assert(needle);
6687
6688         /* Like glibc's hasmntopt(), but works on a string, not a
6689          * struct mntent */
6690
6691         if (!haystack)
6692                 return NULL;
6693
6694         return hasmntopt(&me, needle);
6695 }
6696
6697 void hexdump(FILE *f, const void *p, size_t s) {
6698         const uint8_t *b = p;
6699         unsigned n = 0;
6700
6701         assert(s == 0 || b);
6702
6703         while (s > 0) {
6704                 size_t i;
6705
6706                 fprintf(f, "%04x  ", n);
6707
6708                 for (i = 0; i < 16; i++) {
6709
6710                         if (i >= s)
6711                                 fputs("   ", f);
6712                         else
6713                                 fprintf(f, "%02x ", b[i]);
6714
6715                         if (i == 7)
6716                                 fputc(' ', f);
6717                 }
6718
6719                 fputc(' ', f);
6720
6721                 for (i = 0; i < 16; i++) {
6722
6723                         if (i >= s)
6724                                 fputc(' ', f);
6725                         else
6726                                 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
6727                 }
6728
6729                 fputc('\n', f);
6730
6731                 if (s < 16)
6732                         break;
6733
6734                 n += 16;
6735                 b += 16;
6736                 s -= 16;
6737         }
6738 }
6739
6740 int update_reboot_param_file(const char *param) {
6741         int r = 0;
6742
6743         if (param) {
6744
6745                 r = write_string_file(REBOOT_PARAM_FILE, param);
6746                 if (r < 0)
6747                         log_error("Failed to write reboot param to "
6748                                   REBOOT_PARAM_FILE": %s", strerror(-r));
6749         } else
6750                 unlink(REBOOT_PARAM_FILE);
6751
6752         return r;
6753 }
6754
6755 int umount_recursive(const char *prefix, int flags) {
6756         bool again;
6757         int n = 0, r;
6758
6759         /* Try to umount everything recursively below a
6760          * directory. Also, take care of stacked mounts, and keep
6761          * unmounting them until they are gone. */
6762
6763         do {
6764                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6765
6766                 again = false;
6767                 r = 0;
6768
6769                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6770                 if (!proc_self_mountinfo)
6771                         return -errno;
6772
6773                 for (;;) {
6774                         _cleanup_free_ char *path = NULL, *p = NULL;
6775                         int k;
6776
6777                         k = fscanf(proc_self_mountinfo,
6778                                    "%*s "       /* (1) mount id */
6779                                    "%*s "       /* (2) parent id */
6780                                    "%*s "       /* (3) major:minor */
6781                                    "%*s "       /* (4) root */
6782                                    "%ms "       /* (5) mount point */
6783                                    "%*s"        /* (6) mount options */
6784                                    "%*[^-]"     /* (7) optional fields */
6785                                    "- "         /* (8) separator */
6786                                    "%*s "       /* (9) file system type */
6787                                    "%*s"        /* (10) mount source */
6788                                    "%*s"        /* (11) mount options 2 */
6789                                    "%*[^\n]",   /* some rubbish at the end */
6790                                    &path);
6791                         if (k != 1) {
6792                                 if (k == EOF)
6793                                         break;
6794
6795                                 continue;
6796                         }
6797
6798                         p = cunescape(path);
6799                         if (!p)
6800                                 return -ENOMEM;
6801
6802                         if (!path_startswith(p, prefix))
6803                                 continue;
6804
6805                         if (umount2(p, flags) < 0) {
6806                                 r = -errno;
6807                                 continue;
6808                         }
6809
6810                         again = true;
6811                         n++;
6812
6813                         break;
6814                 }
6815
6816         } while (again);
6817
6818         return r ? r : n;
6819 }
6820
6821 int bind_remount_recursive(const char *prefix, bool ro) {
6822         _cleanup_set_free_free_ Set *done = NULL;
6823         _cleanup_free_ char *cleaned = NULL;
6824         int r;
6825
6826         /* Recursively remount a directory (and all its submounts)
6827          * read-only or read-write. If the directory is already
6828          * mounted, we reuse the mount and simply mark it
6829          * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
6830          * operation). If it isn't we first make it one. Afterwards we
6831          * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
6832          * submounts we can access, too. When mounts are stacked on
6833          * the same mount point we only care for each individual
6834          * "top-level" mount on each point, as we cannot
6835          * influence/access the underlying mounts anyway. We do not
6836          * have any effect on future submounts that might get
6837          * propagated, they migt be writable. This includes future
6838          * submounts that have been triggered via autofs. */
6839
6840         cleaned = strdup(prefix);
6841         if (!cleaned)
6842                 return -ENOMEM;
6843
6844         path_kill_slashes(cleaned);
6845
6846         done = set_new(&string_hash_ops);
6847         if (!done)
6848                 return -ENOMEM;
6849
6850         for (;;) {
6851                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6852                 _cleanup_set_free_free_ Set *todo = NULL;
6853                 bool top_autofs = false;
6854                 char *x;
6855
6856                 todo = set_new(&string_hash_ops);
6857                 if (!todo)
6858                         return -ENOMEM;
6859
6860                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6861                 if (!proc_self_mountinfo)
6862                         return -errno;
6863
6864                 for (;;) {
6865                         _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
6866                         int k;
6867
6868                         k = fscanf(proc_self_mountinfo,
6869                                    "%*s "       /* (1) mount id */
6870                                    "%*s "       /* (2) parent id */
6871                                    "%*s "       /* (3) major:minor */
6872                                    "%*s "       /* (4) root */
6873                                    "%ms "       /* (5) mount point */
6874                                    "%*s"        /* (6) mount options (superblock) */
6875                                    "%*[^-]"     /* (7) optional fields */
6876                                    "- "         /* (8) separator */
6877                                    "%ms "       /* (9) file system type */
6878                                    "%*s"        /* (10) mount source */
6879                                    "%*s"        /* (11) mount options (bind mount) */
6880                                    "%*[^\n]",   /* some rubbish at the end */
6881                                    &path,
6882                                    &type);
6883                         if (k != 2) {
6884                                 if (k == EOF)
6885                                         break;
6886
6887                                 continue;
6888                         }
6889
6890                         p = cunescape(path);
6891                         if (!p)
6892                                 return -ENOMEM;
6893
6894                         /* Let's ignore autofs mounts.  If they aren't
6895                          * triggered yet, we want to avoid triggering
6896                          * them, as we don't make any guarantees for
6897                          * future submounts anyway.  If they are
6898                          * already triggered, then we will find
6899                          * another entry for this. */
6900                         if (streq(type, "autofs")) {
6901                                 top_autofs = top_autofs || path_equal(cleaned, p);
6902                                 continue;
6903                         }
6904
6905                         if (path_startswith(p, cleaned) &&
6906                             !set_contains(done, p)) {
6907
6908                                 r = set_consume(todo, p);
6909                                 p = NULL;
6910
6911                                 if (r == -EEXIST)
6912                                         continue;
6913                                 if (r < 0)
6914                                         return r;
6915                         }
6916                 }
6917
6918                 /* If we have no submounts to process anymore and if
6919                  * the root is either already done, or an autofs, we
6920                  * are done */
6921                 if (set_isempty(todo) &&
6922                     (top_autofs || set_contains(done, cleaned)))
6923                         return 0;
6924
6925                 if (!set_contains(done, cleaned) &&
6926                     !set_contains(todo, cleaned)) {
6927                         /* The prefix directory itself is not yet a
6928                          * mount, make it one. */
6929                         if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
6930                                 return -errno;
6931
6932                         if (mount(NULL, prefix, NULL, MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
6933                                 return -errno;
6934
6935                         x = strdup(cleaned);
6936                         if (!x)
6937                                 return -ENOMEM;
6938
6939                         r = set_consume(done, x);
6940                         if (r < 0)
6941                                 return r;
6942                 }
6943
6944                 while ((x = set_steal_first(todo))) {
6945
6946                         r = set_consume(done, x);
6947                         if (r == -EEXIST)
6948                                 continue;
6949                         if (r < 0)
6950                                 return r;
6951
6952                         if (mount(NULL, x, NULL, MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
6953
6954                                 /* Deal with mount points that are
6955                                  * obstructed by a later mount */
6956
6957                                 if (errno != ENOENT)
6958                                         return -errno;
6959                         }
6960
6961                 }
6962         }
6963 }
6964
6965 int fflush_and_check(FILE *f) {
6966         assert(f);
6967
6968         errno = 0;
6969         fflush(f);
6970
6971         if (ferror(f))
6972                 return errno ? -errno : -EIO;
6973
6974         return 0;
6975 }
6976
6977 int tempfn_xxxxxx(const char *p, char **ret) {
6978         const char *fn;
6979         char *t;
6980
6981         assert(p);
6982         assert(ret);
6983
6984         /*
6985          * Turns this:
6986          *         /foo/bar/waldo
6987          *
6988          * Into this:
6989          *         /foo/bar/.waldoXXXXXX
6990          */
6991
6992         fn = basename(p);
6993         if (!filename_is_valid(fn))
6994                 return -EINVAL;
6995
6996         t = new(char, strlen(p) + 1 + 6 + 1);
6997         if (!t)
6998                 return -ENOMEM;
6999
7000         strcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), "."), fn), "XXXXXX");
7001
7002         *ret = path_kill_slashes(t);
7003         return 0;
7004 }
7005
7006 int tempfn_random(const char *p, char **ret) {
7007         const char *fn;
7008         char *t, *x;
7009         uint64_t u;
7010         unsigned i;
7011
7012         assert(p);
7013         assert(ret);
7014
7015         /*
7016          * Turns this:
7017          *         /foo/bar/waldo
7018          *
7019          * Into this:
7020          *         /foo/bar/.waldobaa2a261115984a9
7021          */
7022
7023         fn = basename(p);
7024         if (!filename_is_valid(fn))
7025                 return -EINVAL;
7026
7027         t = new(char, strlen(p) + 1 + 16 + 1);
7028         if (!t)
7029                 return -ENOMEM;
7030
7031         x = stpcpy(stpcpy(mempcpy(t, p, fn - p), "."), fn);
7032
7033         u = random_u64();
7034         for (i = 0; i < 16; i++) {
7035                 *(x++) = hexchar(u & 0xF);
7036                 u >>= 4;
7037         }
7038
7039         *x = 0;
7040
7041         *ret = path_kill_slashes(t);
7042         return 0;
7043 }
7044
7045 int tempfn_random_child(const char *p, char **ret) {
7046         char *t, *x;
7047         uint64_t u;
7048         unsigned i;
7049
7050         assert(p);
7051         assert(ret);
7052
7053         /* Turns this:
7054          *         /foo/bar/waldo
7055          * Into this:
7056          *         /foo/bar/waldo/.3c2b6219aa75d7d0
7057          */
7058
7059         t = new(char, strlen(p) + 2 + 16 + 1);
7060         if (!t)
7061                 return -ENOMEM;
7062
7063         x = stpcpy(stpcpy(t, p), "/.");
7064
7065         u = random_u64();
7066         for (i = 0; i < 16; i++) {
7067                 *(x++) = hexchar(u & 0xF);
7068                 u >>= 4;
7069         }
7070
7071         *x = 0;
7072
7073         *ret = path_kill_slashes(t);
7074         return 0;
7075 }
7076
7077 /* make sure the hostname is not "localhost" */
7078 bool is_localhost(const char *hostname) {
7079         assert(hostname);
7080
7081         /* This tries to identify local host and domain names
7082          * described in RFC6761 plus the redhatism of .localdomain */
7083
7084         return streq(hostname, "localhost") ||
7085                streq(hostname, "localhost.") ||
7086                streq(hostname, "localdomain.") ||
7087                streq(hostname, "localdomain") ||
7088                endswith(hostname, ".localhost") ||
7089                endswith(hostname, ".localhost.") ||
7090                endswith(hostname, ".localdomain") ||
7091                endswith(hostname, ".localdomain.");
7092 }
7093
7094 int take_password_lock(const char *root) {
7095
7096         struct flock flock = {
7097                 .l_type = F_WRLCK,
7098                 .l_whence = SEEK_SET,
7099                 .l_start = 0,
7100                 .l_len = 0,
7101         };
7102
7103         const char *path;
7104         int fd, r;
7105
7106         /* This is roughly the same as lckpwdf(), but not as awful. We
7107          * don't want to use alarm() and signals, hence we implement
7108          * our own trivial version of this.
7109          *
7110          * Note that shadow-utils also takes per-database locks in
7111          * addition to lckpwdf(). However, we don't given that they
7112          * are redundant as they they invoke lckpwdf() first and keep
7113          * it during everything they do. The per-database locks are
7114          * awfully racy, and thus we just won't do them. */
7115
7116         if (root)
7117                 path = strappenda(root, "/etc/.pwd.lock");
7118         else
7119                 path = "/etc/.pwd.lock";
7120
7121         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
7122         if (fd < 0)
7123                 return -errno;
7124
7125         r = fcntl(fd, F_SETLKW, &flock);
7126         if (r < 0) {
7127                 safe_close(fd);
7128                 return -errno;
7129         }
7130
7131         return fd;
7132 }
7133
7134 int is_symlink(const char *path) {
7135         struct stat info;
7136
7137         if (lstat(path, &info) < 0)
7138                 return -errno;
7139
7140         return !!S_ISLNK(info.st_mode);
7141 }
7142
7143 int is_dir(const char* path, bool follow) {
7144         struct stat st;
7145         int r;
7146
7147         if (follow)
7148                 r = stat(path, &st);
7149         else
7150                 r = lstat(path, &st);
7151         if (r < 0)
7152                 return -errno;
7153
7154         return !!S_ISDIR(st.st_mode);
7155 }
7156
7157 int unquote_first_word(const char **p, char **ret, bool relax) {
7158         _cleanup_free_ char *s = NULL;
7159         size_t allocated = 0, sz = 0;
7160
7161         enum {
7162                 START,
7163                 VALUE,
7164                 VALUE_ESCAPE,
7165                 SINGLE_QUOTE,
7166                 SINGLE_QUOTE_ESCAPE,
7167                 DOUBLE_QUOTE,
7168                 DOUBLE_QUOTE_ESCAPE,
7169                 SPACE,
7170         } state = START;
7171
7172         assert(p);
7173         assert(*p);
7174         assert(ret);
7175
7176         /* Parses the first word of a string, and returns it in
7177          * *ret. Removes all quotes in the process. When parsing fails
7178          * (because of an uneven number of quotes or similar), leaves
7179          * the pointer *p at the first invalid character. */
7180
7181         for (;;) {
7182                 char c = **p;
7183
7184                 switch (state) {
7185
7186                 case START:
7187                         if (c == 0)
7188                                 goto finish;
7189                         else if (strchr(WHITESPACE, c))
7190                                 break;
7191
7192                         state = VALUE;
7193                         /* fallthrough */
7194
7195                 case VALUE:
7196                         if (c == 0)
7197                                 goto finish;
7198                         else if (c == '\'')
7199                                 state = SINGLE_QUOTE;
7200                         else if (c == '\\')
7201                                 state = VALUE_ESCAPE;
7202                         else if (c == '\"')
7203                                 state = DOUBLE_QUOTE;
7204                         else if (strchr(WHITESPACE, c))
7205                                 state = SPACE;
7206                         else {
7207                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7208                                         return -ENOMEM;
7209
7210                                 s[sz++] = c;
7211                         }
7212
7213                         break;
7214
7215                 case VALUE_ESCAPE:
7216                         if (c == 0) {
7217                                 if (relax)
7218                                         goto finish;
7219                                 return -EINVAL;
7220                         }
7221
7222                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7223                                 return -ENOMEM;
7224
7225                         s[sz++] = c;
7226                         state = VALUE;
7227
7228                         break;
7229
7230                 case SINGLE_QUOTE:
7231                         if (c == 0) {
7232                                 if (relax)
7233                                         goto finish;
7234                                 return -EINVAL;
7235                         } else if (c == '\'')
7236                                 state = VALUE;
7237                         else if (c == '\\')
7238                                 state = SINGLE_QUOTE_ESCAPE;
7239                         else {
7240                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7241                                         return -ENOMEM;
7242
7243                                 s[sz++] = c;
7244                         }
7245
7246                         break;
7247
7248                 case SINGLE_QUOTE_ESCAPE:
7249                         if (c == 0) {
7250                                 if (relax)
7251                                         goto finish;
7252                                 return -EINVAL;
7253                         }
7254
7255                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7256                                 return -ENOMEM;
7257
7258                         s[sz++] = c;
7259                         state = SINGLE_QUOTE;
7260                         break;
7261
7262                 case DOUBLE_QUOTE:
7263                         if (c == 0)
7264                                 return -EINVAL;
7265                         else if (c == '\"')
7266                                 state = VALUE;
7267                         else if (c == '\\')
7268                                 state = DOUBLE_QUOTE_ESCAPE;
7269                         else {
7270                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7271                                         return -ENOMEM;
7272
7273                                 s[sz++] = c;
7274                         }
7275
7276                         break;
7277
7278                 case DOUBLE_QUOTE_ESCAPE:
7279                         if (c == 0) {
7280                                 if (relax)
7281                                         goto finish;
7282                                 return -EINVAL;
7283                         }
7284
7285                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7286                                 return -ENOMEM;
7287
7288                         s[sz++] = c;
7289                         state = DOUBLE_QUOTE;
7290                         break;
7291
7292                 case SPACE:
7293                         if (c == 0)
7294                                 goto finish;
7295                         if (!strchr(WHITESPACE, c))
7296                                 goto finish;
7297
7298                         break;
7299                 }
7300
7301                 (*p) ++;
7302         }
7303
7304 finish:
7305         if (!s) {
7306                 *ret = NULL;
7307                 return 0;
7308         }
7309
7310         s[sz] = 0;
7311         *ret = s;
7312         s = NULL;
7313
7314         return 1;
7315 }
7316
7317 int unquote_many_words(const char **p, ...) {
7318         va_list ap;
7319         char **l;
7320         int n = 0, i, c, r;
7321
7322         /* Parses a number of words from a string, stripping any
7323          * quotes if necessary. */
7324
7325         assert(p);
7326
7327         /* Count how many words are expected */
7328         va_start(ap, p);
7329         for (;;) {
7330                 if (!va_arg(ap, char **))
7331                         break;
7332                 n++;
7333         }
7334         va_end(ap);
7335
7336         if (n <= 0)
7337                 return 0;
7338
7339         /* Read all words into a temporary array */
7340         l = newa0(char*, n);
7341         for (c = 0; c < n; c++) {
7342
7343                 r = unquote_first_word(p, &l[c], false);
7344                 if (r < 0) {
7345                         int j;
7346
7347                         for (j = 0; j < c; j++)
7348                                 free(l[j]);
7349
7350                         return r;
7351                 }
7352
7353                 if (r == 0)
7354                         break;
7355         }
7356
7357         /* If we managed to parse all words, return them in the passed
7358          * in parameters */
7359         va_start(ap, p);
7360         for (i = 0; i < n; i++) {
7361                 char **v;
7362
7363                 v = va_arg(ap, char **);
7364                 assert(v);
7365
7366                 *v = l[i];
7367         }
7368         va_end(ap);
7369
7370         return c;
7371 }
7372
7373 int free_and_strdup(char **p, const char *s) {
7374         char *t;
7375
7376         assert(p);
7377
7378         /* Replaces a string pointer with an strdup()ed new string,
7379          * possibly freeing the old one. */
7380
7381         if (s) {
7382                 t = strdup(s);
7383                 if (!t)
7384                         return -ENOMEM;
7385         } else
7386                 t = NULL;
7387
7388         free(*p);
7389         *p = t;
7390
7391         return 0;
7392 }
7393
7394 int sethostname_idempotent(const char *s) {
7395         int r;
7396         char buf[HOST_NAME_MAX + 1] = {};
7397
7398         assert(s);
7399
7400         r = gethostname(buf, sizeof(buf));
7401         if (r < 0)
7402                 return -errno;
7403
7404         if (streq(buf, s))
7405                 return 0;
7406
7407         r = sethostname(s, strlen(s));
7408         if (r < 0)
7409                 return -errno;
7410
7411         return 1;
7412 }