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