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