src/shared/util.c

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