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