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