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