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