src/shared/util.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <signal.h>
  28 #include <stdio.h>
  29 #include <syslog.h>
  30 #include <sched.h>
  31 #include <sys/resource.h>
  32 #include <linux/sched.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <fcntl.h>
  36 #include <dirent.h>
  37 #include <sys/ioctl.h>
  38 #include <linux/vt.h>
  39 #include <linux/tiocl.h>
  40 #include <termios.h>
  41 #include <stdarg.h>
  42 #include <sys/inotify.h>
  43 #include <sys/poll.h>
  44 #include <ctype.h>
  45 #include <sys/prctl.h>
  46 #include <sys/utsname.h>
  47 #include <pwd.h>
  48 #include <netinet/ip.h>
  49 #include <linux/kd.h>
  50 #include <dlfcn.h>
  51 #include <sys/wait.h>
  52 #include <sys/time.h>
  53 #include <glob.h>
  54 #include <grp.h>
  55 #include <sys/mman.h>
  56 #include <sys/vfs.h>
  57 #include <sys/mount.h>
  58 #include <linux/magic.h>
  59 #include <limits.h>
  60 #include <langinfo.h>
  61 #include <locale.h>
  62 #include <sys/personality.h>
  63 #include <libgen.h>
  64 #undef basename
  65
  66 #ifdef HAVE_SYS_AUXV_H
  67 #include <sys/auxv.h>
  68 #endif
  69
  70 #include "macro.h"
  71 #include "util.h"
  72 #include "ioprio.h"
  73 #include "missing.h"
  74 #include "log.h"
  75 #include "strv.h"
  76 #include "label.h"
  77 #include "mkdir.h"
  78 #include "path-util.h"
  79 #include "exit-status.h"
  80 #include "hashmap.h"
  81 #include "env-util.h"
  82 #include "fileio.h"
  83 #include "device-nodes.h"
  84 #include "utf8.h"
  85 #include "gunicode.h"
  86 #include "virt.h"
  87 #include "def.h"
  88
  89 int saved_argc = 0;
  90 char **saved_argv = NULL;
  91
  92 static volatile unsigned cached_columns = 0;
  93 static volatile unsigned cached_lines = 0;
  94
  95 size_t page_size(void) {
  96         static thread_local size_t pgsz = 0;
  97         long r;
  98
  99         if (_likely_(pgsz > 0))
 100                 return pgsz;
 101
 102         r = sysconf(_SC_PAGESIZE);
 103         assert(r > 0);
 104
 105         pgsz = (size_t) r;
 106         return pgsz;
 107 }
 108
 109 bool streq_ptr(const char *a, const char *b) {
 110
 111         /* Like streq(), but tries to make sense of NULL pointers */
 112
 113         if (a && b)
 114                 return streq(a, b);
 115
 116         if (!a && !b)
 117                 return true;
 118
 119         return false;
 120 }
 121
 122 char* endswith(const char *s, const char *postfix) {
 123         size_t sl, pl;
 124
 125         assert(s);
 126         assert(postfix);
 127
 128         sl = strlen(s);
 129         pl = strlen(postfix);
 130
 131         if (pl == 0)
 132                 return (char*) s + sl;
 133
 134         if (sl < pl)
 135                 return NULL;
 136
 137         if (memcmp(s + sl - pl, postfix, pl) != 0)
 138                 return NULL;
 139
 140         return (char*) s + sl - pl;
 141 }
 142
 143 char* first_word(const char *s, const char *word) {
 144         size_t sl, wl;
 145         const char *p;
 146
 147         assert(s);
 148         assert(word);
 149
 150         /* Checks if the string starts with the specified word, either
 151          * followed by NUL or by whitespace. Returns a pointer to the
 152          * NUL or the first character after the whitespace. */
 153
 154         sl = strlen(s);
 155         wl = strlen(word);
 156
 157         if (sl < wl)
 158                 return NULL;
 159
 160         if (wl == 0)
 161                 return (char*) s;
 162
 163         if (memcmp(s, word, wl) != 0)
 164                 return NULL;
 165
 166         p = s + wl;
 167         if (*p == 0)
 168                 return (char*) p;
 169
 170         if (!strchr(WHITESPACE, *p))
 171                 return NULL;
 172
 173         p += strspn(p, WHITESPACE);
 174         return (char*) p;
 175 }
 176
 177 int close_nointr(int fd) {
 178         assert(fd >= 0);
 179
 180         if (close(fd) >= 0)
 181                 return 0;
 182
 183         /*
 184          * Just ignore EINTR; a retry loop is the wrong thing to do on
 185          * Linux.
 186          *
 187          * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
 188          * https://bugzilla.gnome.org/show_bug.cgi?id=682819
 189          * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
 190          * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
 191          */
 192         if (errno == EINTR)
 193                 return 0;
 194
 195         return -errno;
 196 }
 197
 198 int safe_close(int fd) {
 199
 200         /*
 201          * Like close_nointr() but cannot fail. Guarantees errno is
 202          * unchanged. Is a NOP with negative fds passed, and returns
 203          * -1, so that it can be used in this syntax:
 204          *
 205          * fd = safe_close(fd);
 206          */
 207
 208         if (fd >= 0) {
 209                 PROTECT_ERRNO;
 210
 211                 /* The kernel might return pretty much any error code
 212                  * via close(), but the fd will be closed anyway. The
 213                  * only condition we want to check for here is whether
 214                  * the fd was invalid at all... */
 215
 216                 assert_se(close_nointr(fd) != -EBADF);
 217         }
 218
 219         return -1;
 220 }
 221
 222 void close_many(const int fds[], unsigned n_fd) {
 223         unsigned i;
 224
 225         assert(fds || n_fd <= 0);
 226
 227         for (i = 0; i < n_fd; i++)
 228                 safe_close(fds[i]);
 229 }
 230
 231 int unlink_noerrno(const char *path) {
 232         PROTECT_ERRNO;
 233         int r;
 234
 235         r = unlink(path);
 236         if (r < 0)
 237                 return -errno;
 238
 239         return 0;
 240 }
 241
 242 int parse_boolean(const char *v) {
 243         assert(v);
 244
 245         if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
 246                 return 1;
 247         else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
 248                 return 0;
 249
 250         return -EINVAL;
 251 }
 252
 253 int parse_pid(const char *s, pid_t* ret_pid) {
 254         unsigned long ul = 0;
 255         pid_t pid;
 256         int r;
 257
 258         assert(s);
 259         assert(ret_pid);
 260
 261         r = safe_atolu(s, &ul);
 262         if (r < 0)
 263                 return r;
 264
 265         pid = (pid_t) ul;
 266
 267         if ((unsigned long) pid != ul)
 268                 return -ERANGE;
 269
 270         if (pid <= 0)
 271                 return -ERANGE;
 272
 273         *ret_pid = pid;
 274         return 0;
 275 }
 276
 277 int parse_uid(const char *s, uid_t* ret_uid) {
 278         unsigned long ul = 0;
 279         uid_t uid;
 280         int r;
 281
 282         assert(s);
 283         assert(ret_uid);
 284
 285         r = safe_atolu(s, &ul);
 286         if (r < 0)
 287                 return r;
 288
 289         uid = (uid_t) ul;
 290
 291         if ((unsigned long) uid != ul)
 292                 return -ERANGE;
 293
 294         /* Some libc APIs use (uid_t) -1 as special placeholder */
 295         if (uid == (uid_t) 0xFFFFFFFF)
 296                 return -ENXIO;
 297
 298         /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
 299         if (uid == (uid_t) 0xFFFF)
 300                 return -ENXIO;
 301
 302         *ret_uid = uid;
 303         return 0;
 304 }
 305
 306 int safe_atou(const char *s, unsigned *ret_u) {
 307         char *x = NULL;
 308         unsigned long l;
 309
 310         assert(s);
 311         assert(ret_u);
 312
 313         errno = 0;
 314         l = strtoul(s, &x, 0);
 315
 316         if (!x || x == s || *x || errno)
 317                 return errno > 0 ? -errno : -EINVAL;
 318
 319         if ((unsigned long) (unsigned) l != l)
 320                 return -ERANGE;
 321
 322         *ret_u = (unsigned) l;
 323         return 0;
 324 }
 325
 326 int safe_atoi(const char *s, int *ret_i) {
 327         char *x = NULL;
 328         long l;
 329
 330         assert(s);
 331         assert(ret_i);
 332
 333         errno = 0;
 334         l = strtol(s, &x, 0);
 335
 336         if (!x || x == s || *x || errno)
 337                 return errno > 0 ? -errno : -EINVAL;
 338
 339         if ((long) (int) l != l)
 340                 return -ERANGE;
 341
 342         *ret_i = (int) l;
 343         return 0;
 344 }
 345
 346 int safe_atou8(const char *s, uint8_t *ret) {
 347         char *x = NULL;
 348         unsigned long l;
 349
 350         assert(s);
 351         assert(ret);
 352
 353         errno = 0;
 354         l = strtoul(s, &x, 0);
 355
 356         if (!x || x == s || *x || errno)
 357                 return errno > 0 ? -errno : -EINVAL;
 358
 359         if ((unsigned long) (uint8_t) l != l)
 360                 return -ERANGE;
 361
 362         *ret = (uint8_t) l;
 363         return 0;
 364 }
 365
 366 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 367         char *x = NULL;
 368         unsigned long long l;
 369
 370         assert(s);
 371         assert(ret_llu);
 372
 373         errno = 0;
 374         l = strtoull(s, &x, 0);
 375
 376         if (!x || x == s || *x || errno)
 377                 return errno ? -errno : -EINVAL;
 378
 379         *ret_llu = l;
 380         return 0;
 381 }
 382
 383 int safe_atolli(const char *s, long long int *ret_lli) {
 384         char *x = NULL;
 385         long long l;
 386
 387         assert(s);
 388         assert(ret_lli);
 389
 390         errno = 0;
 391         l = strtoll(s, &x, 0);
 392
 393         if (!x || x == s || *x || errno)
 394                 return errno ? -errno : -EINVAL;
 395
 396         *ret_lli = l;
 397         return 0;
 398 }
 399
 400 int safe_atod(const char *s, double *ret_d) {
 401         char *x = NULL;
 402         double d = 0;
 403
 404         assert(s);
 405         assert(ret_d);
 406
 407         RUN_WITH_LOCALE(LC_NUMERIC_MASK, "C") {
 408                 errno = 0;
 409                 d = strtod(s, &x);
 410         }
 411
 412         if (!x || x == s || *x || errno)
 413                 return errno ? -errno : -EINVAL;
 414
 415         *ret_d = (double) d;
 416         return 0;
 417 }
 418
 419 static size_t strcspn_escaped(const char *s, const char *reject) {
 420         bool escaped = false;
 421         size_t n;
 422
 423         for (n=0; s[n]; n++) {
 424                 if (escaped)
 425                         escaped = false;
 426                 else if (s[n] == '\\')
 427                         escaped = true;
 428                 else if (strchr(reject, s[n]))
 429                         break;
 430         }
 431         /* if s ends in \, return index of previous char */
 432         return n - escaped;
 433 }
 434
 435 /* Split a string into words. */
 436 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
 437         const char *current;
 438
 439         current = *state;
 440
 441         if (!*current) {
 442                 assert(**state == '\0');
 443                 return NULL;
 444         }
 445
 446         current += strspn(current, separator);
 447         if (!*current) {
 448                 *state = current;
 449                 return NULL;
 450         }
 451
 452         if (quoted && strchr("\'\"", *current)) {
 453                 char quotechars[2] = {*current, '\0'};
 454
 455                 *l = strcspn_escaped(current + 1, quotechars);
 456                 if (current[*l + 1] == '\0' ||
 457                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
 458                         /* right quote missing or garbage at the end*/
 459                         *state = current;
 460                         return NULL;
 461                 }
 462                 assert(current[*l + 1] == quotechars[0]);
 463                 *state = current++ + *l + 2;
 464         } else if (quoted) {
 465                 *l = strcspn_escaped(current, separator);
 466                 *state = current + *l;
 467         } else {
 468                 *l = strcspn(current, separator);
 469                 *state = current + *l;
 470         }
 471
 472         return current;
 473 }
 474
 475 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
 476         int r;
 477         _cleanup_free_ char *line = NULL;
 478         long unsigned ppid;
 479         const char *p;
 480
 481         assert(pid >= 0);
 482         assert(_ppid);
 483
 484         if (pid == 0) {
 485                 *_ppid = getppid();
 486                 return 0;
 487         }
 488
 489         p = procfs_file_alloca(pid, "stat");
 490         r = read_one_line_file(p, &line);
 491         if (r < 0)
 492                 return r;
 493
 494         /* Let's skip the pid and comm fields. The latter is enclosed
 495          * in () but does not escape any () in its value, so let's
 496          * skip over it manually */
 497
 498         p = strrchr(line, ')');
 499         if (!p)
 500                 return -EIO;
 501
 502         p++;
 503
 504         if (sscanf(p, " "
 505                    "%*c "  /* state */
 506                    "%lu ", /* ppid */
 507                    &ppid) != 1)
 508                 return -EIO;
 509
 510         if ((long unsigned) (pid_t) ppid != ppid)
 511                 return -ERANGE;
 512
 513         *_ppid = (pid_t) ppid;
 514
 515         return 0;
 516 }
 517
 518 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
 519         int r;
 520         _cleanup_free_ char *line = NULL;
 521         const char *p;
 522
 523         assert(pid >= 0);
 524         assert(st);
 525
 526         p = procfs_file_alloca(pid, "stat");
 527         r = read_one_line_file(p, &line);
 528         if (r < 0)
 529                 return r;
 530
 531         /* Let's skip the pid and comm fields. The latter is enclosed
 532          * in () but does not escape any () in its value, so let's
 533          * skip over it manually */
 534
 535         p = strrchr(line, ')');
 536         if (!p)
 537                 return -EIO;
 538
 539         p++;
 540
 541         if (sscanf(p, " "
 542                    "%*c "  /* state */
 543                    "%*d "  /* ppid */
 544                    "%*d "  /* pgrp */
 545                    "%*d "  /* session */
 546                    "%*d "  /* tty_nr */
 547                    "%*d "  /* tpgid */
 548                    "%*u "  /* flags */
 549                    "%*u "  /* minflt */
 550                    "%*u "  /* cminflt */
 551                    "%*u "  /* majflt */
 552                    "%*u "  /* cmajflt */
 553                    "%*u "  /* utime */
 554                    "%*u "  /* stime */
 555                    "%*d "  /* cutime */
 556                    "%*d "  /* cstime */
 557                    "%*d "  /* priority */
 558                    "%*d "  /* nice */
 559                    "%*d "  /* num_threads */
 560                    "%*d "  /* itrealvalue */
 561                    "%llu "  /* starttime */,
 562                    st) != 1)
 563                 return -EIO;
 564
 565         return 0;
 566 }
 567
 568 int fchmod_umask(int fd, mode_t m) {
 569         mode_t u;
 570         int r;
 571
 572         u = umask(0777);
 573         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 574         umask(u);
 575
 576         return r;
 577 }
 578
 579 char *truncate_nl(char *s) {
 580         assert(s);
 581
 582         s[strcspn(s, NEWLINE)] = 0;
 583         return s;
 584 }
 585
 586 int get_process_state(pid_t pid) {
 587         const char *p;
 588         char state;
 589         int r;
 590         _cleanup_free_ char *line = NULL;
 591
 592         assert(pid >= 0);
 593
 594         p = procfs_file_alloca(pid, "stat");
 595         r = read_one_line_file(p, &line);
 596         if (r < 0)
 597                 return r;
 598
 599         p = strrchr(line, ')');
 600         if (!p)
 601                 return -EIO;
 602
 603         p++;
 604
 605         if (sscanf(p, " %c", &state) != 1)
 606                 return -EIO;
 607
 608         return (unsigned char) state;
 609 }
 610
 611 int get_process_comm(pid_t pid, char **name) {
 612         const char *p;
 613         int r;
 614
 615         assert(name);
 616         assert(pid >= 0);
 617
 618         p = procfs_file_alloca(pid, "comm");
 619
 620         r = read_one_line_file(p, name);
 621         if (r == -ENOENT)
 622                 return -ESRCH;
 623
 624         return r;
 625 }
 626
 627 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
 628         _cleanup_fclose_ FILE *f = NULL;
 629         char *r = NULL, *k;
 630         const char *p;
 631         int c;
 632
 633         assert(line);
 634         assert(pid >= 0);
 635
 636         p = procfs_file_alloca(pid, "cmdline");
 637
 638         f = fopen(p, "re");
 639         if (!f)
 640                 return -errno;
 641
 642         if (max_length == 0) {
 643                 size_t len = 0, allocated = 0;
 644
 645                 while ((c = getc(f)) != EOF) {
 646
 647                         if (!GREEDY_REALLOC(r, allocated, len+2)) {
 648                                 free(r);
 649                                 return -ENOMEM;
 650                         }
 651
 652                         r[len++] = isprint(c) ? c : ' ';
 653                 }
 654
 655                 if (len > 0)
 656                         r[len-1] = 0;
 657
 658         } else {
 659                 bool space = false;
 660                 size_t left;
 661
 662                 r = new(char, max_length);
 663                 if (!r)
 664                         return -ENOMEM;
 665
 666                 k = r;
 667                 left = max_length;
 668                 while ((c = getc(f)) != EOF) {
 669
 670                         if (isprint(c)) {
 671                                 if (space) {
 672                                         if (left <= 4)
 673                                                 break;
 674
 675                                         *(k++) = ' ';
 676                                         left--;
 677                                         space = false;
 678                                 }
 679
 680                                 if (left <= 4)
 681                                         break;
 682
 683                                 *(k++) = (char) c;
 684                                 left--;
 685                         }  else
 686                                 space = true;
 687                 }
 688
 689                 if (left <= 4) {
 690                         size_t n = MIN(left-1, 3U);
 691                         memcpy(k, "...", n);
 692                         k[n] = 0;
 693                 } else
 694                         *k = 0;
 695         }
 696
 697         /* Kernel threads have no argv[] */
 698         if (r == NULL || r[0] == 0) {
 699                 _cleanup_free_ char *t = NULL;
 700                 int h;
 701
 702                 free(r);
 703
 704                 if (!comm_fallback)
 705                         return -ENOENT;
 706
 707                 h = get_process_comm(pid, &t);
 708                 if (h < 0)
 709                         return h;
 710
 711                 r = strjoin("[", t, "]", NULL);
 712                 if (!r)
 713                         return -ENOMEM;
 714         }
 715
 716         *line = r;
 717         return 0;
 718 }
 719
 720 int is_kernel_thread(pid_t pid) {
 721         const char *p;
 722         size_t count;
 723         char c;
 724         bool eof;
 725         FILE *f;
 726
 727         if (pid == 0)
 728                 return 0;
 729
 730         assert(pid > 0);
 731
 732         p = procfs_file_alloca(pid, "cmdline");
 733         f = fopen(p, "re");
 734         if (!f)
 735                 return -errno;
 736
 737         count = fread(&c, 1, 1, f);
 738         eof = feof(f);
 739         fclose(f);
 740
 741         /* Kernel threads have an empty cmdline */
 742
 743         if (count <= 0)
 744                 return eof ? 1 : -errno;
 745
 746         return 0;
 747 }
 748
 749 int get_process_capeff(pid_t pid, char **capeff) {
 750         const char *p;
 751
 752         assert(capeff);
 753         assert(pid >= 0);
 754
 755         p = procfs_file_alloca(pid, "status");
 756
 757         return get_status_field(p, "\nCapEff:", capeff);
 758 }
 759
 760 int get_process_exe(pid_t pid, char **name) {
 761         const char *p;
 762         char *d;
 763         int r;
 764
 765         assert(pid >= 0);
 766         assert(name);
 767
 768         p = procfs_file_alloca(pid, "exe");
 769
 770         r = readlink_malloc(p, name);
 771         if (r < 0)
 772                 return r == -ENOENT ? -ESRCH : r;
 773
 774         d = endswith(*name, " (deleted)");
 775         if (d)
 776                 *d = '\0';
 777
 778         return 0;
 779 }
 780
 781 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
 782         _cleanup_fclose_ FILE *f = NULL;
 783         char line[LINE_MAX];
 784         const char *p;
 785
 786         assert(field);
 787         assert(uid);
 788
 789         if (pid == 0)
 790                 return getuid();
 791
 792         p = procfs_file_alloca(pid, "status");
 793         f = fopen(p, "re");
 794         if (!f)
 795                 return -errno;
 796
 797         FOREACH_LINE(line, f, return -errno) {
 798                 char *l;
 799
 800                 l = strstrip(line);
 801
 802                 if (startswith(l, field)) {
 803                         l += strlen(field);
 804                         l += strspn(l, WHITESPACE);
 805
 806                         l[strcspn(l, WHITESPACE)] = 0;
 807
 808                         return parse_uid(l, uid);
 809                 }
 810         }
 811
 812         return -EIO;
 813 }
 814
 815 int get_process_uid(pid_t pid, uid_t *uid) {
 816         return get_process_id(pid, "Uid:", uid);
 817 }
 818
 819 int get_process_gid(pid_t pid, gid_t *gid) {
 820         assert_cc(sizeof(uid_t) == sizeof(gid_t));
 821         return get_process_id(pid, "Gid:", gid);
 822 }
 823
 824 char *strnappend(const char *s, const char *suffix, size_t b) {
 825         size_t a;
 826         char *r;
 827
 828         if (!s && !suffix)
 829                 return strdup("");
 830
 831         if (!s)
 832                 return strndup(suffix, b);
 833
 834         if (!suffix)
 835                 return strdup(s);
 836
 837         assert(s);
 838         assert(suffix);
 839
 840         a = strlen(s);
 841         if (b > ((size_t) -1) - a)
 842                 return NULL;
 843
 844         r = new(char, a+b+1);
 845         if (!r)
 846                 return NULL;
 847
 848         memcpy(r, s, a);
 849         memcpy(r+a, suffix, b);
 850         r[a+b] = 0;
 851
 852         return r;
 853 }
 854
 855 char *strappend(const char *s, const char *suffix) {
 856         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
 857 }
 858
 859 int readlinkat_malloc(int fd, const char *p, char **ret) {
 860         size_t l = 100;
 861         int r;
 862
 863         assert(p);
 864         assert(ret);
 865
 866         for (;;) {
 867                 char *c;
 868                 ssize_t n;
 869
 870                 c = new(char, l);
 871                 if (!c)
 872                         return -ENOMEM;
 873
 874                 n = readlinkat(fd, p, c, l-1);
 875                 if (n < 0) {
 876                         r = -errno;
 877                         free(c);
 878                         return r;
 879                 }
 880
 881                 if ((size_t) n < l-1) {
 882                         c[n] = 0;
 883                         *ret = c;
 884                         return 0;
 885                 }
 886
 887                 free(c);
 888                 l *= 2;
 889         }
 890 }
 891
 892 int readlink_malloc(const char *p, char **ret) {
 893         return readlinkat_malloc(AT_FDCWD, p, ret);
 894 }
 895
 896 int readlink_and_make_absolute(const char *p, char **r) {
 897         _cleanup_free_ char *target = NULL;
 898         char *k;
 899         int j;
 900
 901         assert(p);
 902         assert(r);
 903
 904         j = readlink_malloc(p, &target);
 905         if (j < 0)
 906                 return j;
 907
 908         k = file_in_same_dir(p, target);
 909         if (!k)
 910                 return -ENOMEM;
 911
 912         *r = k;
 913         return 0;
 914 }
 915
 916 int readlink_and_canonicalize(const char *p, char **r) {
 917         char *t, *s;
 918         int j;
 919
 920         assert(p);
 921         assert(r);
 922
 923         j = readlink_and_make_absolute(p, &t);
 924         if (j < 0)
 925                 return j;
 926
 927         s = canonicalize_file_name(t);
 928         if (s) {
 929                 free(t);
 930                 *r = s;
 931         } else
 932                 *r = t;
 933
 934         path_kill_slashes(*r);
 935
 936         return 0;
 937 }
 938
 939 int reset_all_signal_handlers(void) {
 940         int sig;
 941
 942         for (sig = 1; sig < _NSIG; sig++) {
 943                 struct sigaction sa = {
 944                         .sa_handler = SIG_DFL,
 945                         .sa_flags = SA_RESTART,
 946                 };
 947
 948                 if (sig == SIGKILL || sig == SIGSTOP)
 949                         continue;
 950
 951                 /* On Linux the first two RT signals are reserved by
 952                  * glibc, and sigaction() will return EINVAL for them. */
 953                 if ((sigaction(sig, &sa, NULL) < 0))
 954                         if (errno != EINVAL)
 955                                 return -errno;
 956         }
 957
 958         return 0;
 959 }
 960
 961 char *strstrip(char *s) {
 962         char *e;
 963
 964         /* Drops trailing whitespace. Modifies the string in
 965          * place. Returns pointer to first non-space character */
 966
 967         s += strspn(s, WHITESPACE);
 968
 969         for (e = strchr(s, 0); e > s; e --)
 970                 if (!strchr(WHITESPACE, e[-1]))
 971                         break;
 972
 973         *e = 0;
 974
 975         return s;
 976 }
 977
 978 char *delete_chars(char *s, const char *bad) {
 979         char *f, *t;
 980
 981         /* Drops all whitespace, regardless where in the string */
 982
 983         for (f = s, t = s; *f; f++) {
 984                 if (strchr(bad, *f))
 985                         continue;
 986
 987                 *(t++) = *f;
 988         }
 989
 990         *t = 0;
 991
 992         return s;
 993 }
 994
 995 char *file_in_same_dir(const char *path, const char *filename) {
 996         char *e, *r;
 997         size_t k;
 998
 999         assert(path);
1000         assert(filename);
1001
1002         /* This removes the last component of path and appends
1003          * filename, unless the latter is absolute anyway or the
1004          * former isn't */
1005
1006         if (path_is_absolute(filename))
1007                 return strdup(filename);
1008
1009         if (!(e = strrchr(path, '/')))
1010                 return strdup(filename);
1011
1012         k = strlen(filename);
1013         if (!(r = new(char, e-path+1+k+1)))
1014                 return NULL;
1015
1016         memcpy(r, path, e-path+1);
1017         memcpy(r+(e-path)+1, filename, k+1);
1018
1019         return r;
1020 }
1021
1022 int rmdir_parents(const char *path, const char *stop) {
1023         size_t l;
1024         int r = 0;
1025
1026         assert(path);
1027         assert(stop);
1028
1029         l = strlen(path);
1030
1031         /* Skip trailing slashes */
1032         while (l > 0 && path[l-1] == '/')
1033                 l--;
1034
1035         while (l > 0) {
1036                 char *t;
1037
1038                 /* Skip last component */
1039                 while (l > 0 && path[l-1] != '/')
1040                         l--;
1041
1042                 /* Skip trailing slashes */
1043                 while (l > 0 && path[l-1] == '/')
1044                         l--;
1045
1046                 if (l <= 0)
1047                         break;
1048
1049                 if (!(t = strndup(path, l)))
1050                         return -ENOMEM;
1051
1052                 if (path_startswith(stop, t)) {
1053                         free(t);
1054                         return 0;
1055                 }
1056
1057                 r = rmdir(t);
1058                 free(t);
1059
1060                 if (r < 0)
1061                         if (errno != ENOENT)
1062                                 return -errno;
1063         }
1064
1065         return 0;
1066 }
1067
1068 char hexchar(int x) {
1069         static const char table[16] = "0123456789abcdef";
1070
1071         return table[x & 15];
1072 }
1073
1074 int unhexchar(char c) {
1075
1076         if (c >= '0' && c <= '9')
1077                 return c - '0';
1078
1079         if (c >= 'a' && c <= 'f')
1080                 return c - 'a' + 10;
1081
1082         if (c >= 'A' && c <= 'F')
1083                 return c - 'A' + 10;
1084
1085         return -EINVAL;
1086 }
1087
1088 char *hexmem(const void *p, size_t l) {
1089         char *r, *z;
1090         const uint8_t *x;
1091
1092         z = r = malloc(l * 2 + 1);
1093         if (!r)
1094                 return NULL;
1095
1096         for (x = p; x < (const uint8_t*) p + l; x++) {
1097                 *(z++) = hexchar(*x >> 4);
1098                 *(z++) = hexchar(*x & 15);
1099         }
1100
1101         *z = 0;
1102         return r;
1103 }
1104
1105 void *unhexmem(const char *p, size_t l) {
1106         uint8_t *r, *z;
1107         const char *x;
1108
1109         assert(p);
1110
1111         z = r = malloc((l + 1) / 2 + 1);
1112         if (!r)
1113                 return NULL;
1114
1115         for (x = p; x < p + l; x += 2) {
1116                 int a, b;
1117
1118                 a = unhexchar(x[0]);
1119                 if (x+1 < p + l)
1120                         b = unhexchar(x[1]);
1121                 else
1122                         b = 0;
1123
1124                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1125         }
1126
1127         *z = 0;
1128         return r;
1129 }
1130
1131 char octchar(int x) {
1132         return '0' + (x & 7);
1133 }
1134
1135 int unoctchar(char c) {
1136
1137         if (c >= '0' && c <= '7')
1138                 return c - '0';
1139
1140         return -EINVAL;
1141 }
1142
1143 char decchar(int x) {
1144         return '0' + (x % 10);
1145 }
1146
1147 int undecchar(char c) {
1148
1149         if (c >= '0' && c <= '9')
1150                 return c - '0';
1151
1152         return -EINVAL;
1153 }
1154
1155 char *cescape(const char *s) {
1156         char *r, *t;
1157         const char *f;
1158
1159         assert(s);
1160
1161         /* Does C style string escaping. */
1162
1163         r = new(char, strlen(s)*4 + 1);
1164         if (!r)
1165                 return NULL;
1166
1167         for (f = s, t = r; *f; f++)
1168
1169                 switch (*f) {
1170
1171                 case '\a':
1172                         *(t++) = '\\';
1173                         *(t++) = 'a';
1174                         break;
1175                 case '\b':
1176                         *(t++) = '\\';
1177                         *(t++) = 'b';
1178                         break;
1179                 case '\f':
1180                         *(t++) = '\\';
1181                         *(t++) = 'f';
1182                         break;
1183                 case '\n':
1184                         *(t++) = '\\';
1185                         *(t++) = 'n';
1186                         break;
1187                 case '\r':
1188                         *(t++) = '\\';
1189                         *(t++) = 'r';
1190                         break;
1191                 case '\t':
1192                         *(t++) = '\\';
1193                         *(t++) = 't';
1194                         break;
1195                 case '\v':
1196                         *(t++) = '\\';
1197                         *(t++) = 'v';
1198                         break;
1199                 case '\\':
1200                         *(t++) = '\\';
1201                         *(t++) = '\\';
1202                         break;
1203                 case '"':
1204                         *(t++) = '\\';
1205                         *(t++) = '"';
1206                         break;
1207                 case '\'':
1208                         *(t++) = '\\';
1209                         *(t++) = '\'';
1210                         break;
1211
1212                 default:
1213                         /* For special chars we prefer octal over
1214                          * hexadecimal encoding, simply because glib's
1215                          * g_strescape() does the same */
1216                         if ((*f < ' ') || (*f >= 127)) {
1217                                 *(t++) = '\\';
1218                                 *(t++) = octchar((unsigned char) *f >> 6);
1219                                 *(t++) = octchar((unsigned char) *f >> 3);
1220                                 *(t++) = octchar((unsigned char) *f);
1221                         } else
1222                                 *(t++) = *f;
1223                         break;
1224                 }
1225
1226         *t = 0;
1227
1228         return r;
1229 }
1230
1231 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1232         char *r, *t;
1233         const char *f;
1234         size_t pl;
1235
1236         assert(s);
1237
1238         /* Undoes C style string escaping, and optionally prefixes it. */
1239
1240         pl = prefix ? strlen(prefix) : 0;
1241
1242         r = new(char, pl+length+1);
1243         if (!r)
1244                 return NULL;
1245
1246         if (prefix)
1247                 memcpy(r, prefix, pl);
1248
1249         for (f = s, t = r + pl; f < s + length; f++) {
1250
1251                 if (*f != '\\') {
1252                         *(t++) = *f;
1253                         continue;
1254                 }
1255
1256                 f++;
1257
1258                 switch (*f) {
1259
1260                 case 'a':
1261                         *(t++) = '\a';
1262                         break;
1263                 case 'b':
1264                         *(t++) = '\b';
1265                         break;
1266                 case 'f':
1267                         *(t++) = '\f';
1268                         break;
1269                 case 'n':
1270                         *(t++) = '\n';
1271                         break;
1272                 case 'r':
1273                         *(t++) = '\r';
1274                         break;
1275                 case 't':
1276                         *(t++) = '\t';
1277                         break;
1278                 case 'v':
1279                         *(t++) = '\v';
1280                         break;
1281                 case '\\':
1282                         *(t++) = '\\';
1283                         break;
1284                 case '"':
1285                         *(t++) = '"';
1286                         break;
1287                 case '\'':
1288                         *(t++) = '\'';
1289                         break;
1290
1291                 case 's':
1292                         /* This is an extension of the XDG syntax files */
1293                         *(t++) = ' ';
1294                         break;
1295
1296                 case 'x': {
1297                         /* hexadecimal encoding */
1298                         int a, b;
1299
1300                         a = unhexchar(f[1]);
1301                         b = unhexchar(f[2]);
1302
1303                         if (a < 0 || b < 0 || (a == 0 && b == 0)) {
1304                                 /* Invalid escape code, let's take it literal then */
1305                                 *(t++) = '\\';
1306                                 *(t++) = 'x';
1307                         } else {
1308                                 *(t++) = (char) ((a << 4) | b);
1309                                 f += 2;
1310                         }
1311
1312                         break;
1313                 }
1314
1315                 case '0':
1316                 case '1':
1317                 case '2':
1318                 case '3':
1319                 case '4':
1320                 case '5':
1321                 case '6':
1322                 case '7': {
1323                         /* octal encoding */
1324                         int a, b, c;
1325
1326                         a = unoctchar(f[0]);
1327                         b = unoctchar(f[1]);
1328                         c = unoctchar(f[2]);
1329
1330                         if (a < 0 || b < 0 || c < 0 || (a == 0 && b == 0 && c == 0)) {
1331                                 /* Invalid escape code, let's take it literal then */
1332                                 *(t++) = '\\';
1333                                 *(t++) = f[0];
1334                         } else {
1335                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1336                                 f += 2;
1337                         }
1338
1339                         break;
1340                 }
1341
1342                 case 0:
1343                         /* premature end of string.*/
1344                         *(t++) = '\\';
1345                         goto finish;
1346
1347                 default:
1348                         /* Invalid escape code, let's take it literal then */
1349                         *(t++) = '\\';
1350                         *(t++) = *f;
1351                         break;
1352                 }
1353         }
1354
1355 finish:
1356         *t = 0;
1357         return r;
1358 }
1359
1360 char *cunescape_length(const char *s, size_t length) {
1361         return cunescape_length_with_prefix(s, length, NULL);
1362 }
1363
1364 char *cunescape(const char *s) {
1365         assert(s);
1366
1367         return cunescape_length(s, strlen(s));
1368 }
1369
1370 char *xescape(const char *s, const char *bad) {
1371         char *r, *t;
1372         const char *f;
1373
1374         /* Escapes all chars in bad, in addition to \ and all special
1375          * chars, in \xFF style escaping. May be reversed with
1376          * cunescape. */
1377
1378         r = new(char, strlen(s) * 4 + 1);
1379         if (!r)
1380                 return NULL;
1381
1382         for (f = s, t = r; *f; f++) {
1383
1384                 if ((*f < ' ') || (*f >= 127) ||
1385                     (*f == '\\') || strchr(bad, *f)) {
1386                         *(t++) = '\\';
1387                         *(t++) = 'x';
1388                         *(t++) = hexchar(*f >> 4);
1389                         *(t++) = hexchar(*f);
1390                 } else
1391                         *(t++) = *f;
1392         }
1393
1394         *t = 0;
1395
1396         return r;
1397 }
1398
1399 char *ascii_strlower(char *t) {
1400         char *p;
1401
1402         assert(t);
1403
1404         for (p = t; *p; p++)
1405                 if (*p >= 'A' && *p <= 'Z')
1406                         *p = *p - 'A' + 'a';
1407
1408         return t;
1409 }
1410
1411 _pure_ static bool ignore_file_allow_backup(const char *filename) {
1412         assert(filename);
1413
1414         return
1415                 filename[0] == '.' ||
1416                 streq(filename, "lost+found") ||
1417                 streq(filename, "aquota.user") ||
1418                 streq(filename, "aquota.group") ||
1419                 endswith(filename, ".rpmnew") ||
1420                 endswith(filename, ".rpmsave") ||
1421                 endswith(filename, ".rpmorig") ||
1422                 endswith(filename, ".dpkg-old") ||
1423                 endswith(filename, ".dpkg-new") ||
1424                 endswith(filename, ".dpkg-tmp") ||
1425                 endswith(filename, ".swp");
1426 }
1427
1428 bool ignore_file(const char *filename) {
1429         assert(filename);
1430
1431         if (endswith(filename, "~"))
1432                 return true;
1433
1434         return ignore_file_allow_backup(filename);
1435 }
1436
1437 int fd_nonblock(int fd, bool nonblock) {
1438         int flags, nflags;
1439
1440         assert(fd >= 0);
1441
1442         flags = fcntl(fd, F_GETFL, 0);
1443         if (flags < 0)
1444                 return -errno;
1445
1446         if (nonblock)
1447                 nflags = flags | O_NONBLOCK;
1448         else
1449                 nflags = flags & ~O_NONBLOCK;
1450
1451         if (nflags == flags)
1452                 return 0;
1453
1454         if (fcntl(fd, F_SETFL, nflags) < 0)
1455                 return -errno;
1456
1457         return 0;
1458 }
1459
1460 int fd_cloexec(int fd, bool cloexec) {
1461         int flags, nflags;
1462
1463         assert(fd >= 0);
1464
1465         flags = fcntl(fd, F_GETFD, 0);
1466         if (flags < 0)
1467                 return -errno;
1468
1469         if (cloexec)
1470                 nflags = flags | FD_CLOEXEC;
1471         else
1472                 nflags = flags & ~FD_CLOEXEC;
1473
1474         if (nflags == flags)
1475                 return 0;
1476
1477         if (fcntl(fd, F_SETFD, nflags) < 0)
1478                 return -errno;
1479
1480         return 0;
1481 }
1482
1483 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1484         unsigned i;
1485
1486         assert(n_fdset == 0 || fdset);
1487
1488         for (i = 0; i < n_fdset; i++)
1489                 if (fdset[i] == fd)
1490                         return true;
1491
1492         return false;
1493 }
1494
1495 int close_all_fds(const int except[], unsigned n_except) {
1496         _cleanup_closedir_ DIR *d = NULL;
1497         struct dirent *de;
1498         int r = 0;
1499
1500         assert(n_except == 0 || except);
1501
1502         d = opendir("/proc/self/fd");
1503         if (!d) {
1504                 int fd;
1505                 struct rlimit rl;
1506
1507                 /* When /proc isn't available (for example in chroots)
1508                  * the fallback is brute forcing through the fd
1509                  * table */
1510
1511                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1512                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1513
1514                         if (fd_in_set(fd, except, n_except))
1515                                 continue;
1516
1517                         if (close_nointr(fd) < 0)
1518                                 if (errno != EBADF && r == 0)
1519                                         r = -errno;
1520                 }
1521
1522                 return r;
1523         }
1524
1525         while ((de = readdir(d))) {
1526                 int fd = -1;
1527
1528                 if (ignore_file(de->d_name))
1529                         continue;
1530
1531                 if (safe_atoi(de->d_name, &fd) < 0)
1532                         /* Let's better ignore this, just in case */
1533                         continue;
1534
1535                 if (fd < 3)
1536                         continue;
1537
1538                 if (fd == dirfd(d))
1539                         continue;
1540
1541                 if (fd_in_set(fd, except, n_except))
1542                         continue;
1543
1544                 if (close_nointr(fd) < 0) {
1545                         /* Valgrind has its own FD and doesn't want to have it closed */
1546                         if (errno != EBADF && r == 0)
1547                                 r = -errno;
1548                 }
1549         }
1550
1551         return r;
1552 }
1553
1554 bool chars_intersect(const char *a, const char *b) {
1555         const char *p;
1556
1557         /* Returns true if any of the chars in a are in b. */
1558         for (p = a; *p; p++)
1559                 if (strchr(b, *p))
1560                         return true;
1561
1562         return false;
1563 }
1564
1565 bool fstype_is_network(const char *fstype) {
1566         static const char table[] =
1567                 "cifs\0"
1568                 "smbfs\0"
1569                 "sshfs\0"
1570                 "ncpfs\0"
1571                 "ncp\0"
1572                 "nfs\0"
1573                 "nfs4\0"
1574                 "gfs\0"
1575                 "gfs2\0"
1576                 "glusterfs\0";
1577
1578         const char *x;
1579
1580         x = startswith(fstype, "fuse.");
1581         if (x)
1582                 fstype = x;
1583
1584         return nulstr_contains(table, fstype);
1585 }
1586
1587 int chvt(int vt) {
1588         _cleanup_close_ int fd;
1589
1590         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1591         if (fd < 0)
1592                 return -errno;
1593
1594         if (vt < 0) {
1595                 int tiocl[2] = {
1596                         TIOCL_GETKMSGREDIRECT,
1597                         0
1598                 };
1599
1600                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1601                         return -errno;
1602
1603                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1604         }
1605
1606         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1607                 return -errno;
1608
1609         return 0;
1610 }
1611
1612 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1613         struct termios old_termios, new_termios;
1614         char c, line[LINE_MAX];
1615
1616         assert(f);
1617         assert(ret);
1618
1619         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1620                 new_termios = old_termios;
1621
1622                 new_termios.c_lflag &= ~ICANON;
1623                 new_termios.c_cc[VMIN] = 1;
1624                 new_termios.c_cc[VTIME] = 0;
1625
1626                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1627                         size_t k;
1628
1629                         if (t != USEC_INFINITY) {
1630                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1631                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1632                                         return -ETIMEDOUT;
1633                                 }
1634                         }
1635
1636                         k = fread(&c, 1, 1, f);
1637
1638                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1639
1640                         if (k <= 0)
1641                                 return -EIO;
1642
1643                         if (need_nl)
1644                                 *need_nl = c != '\n';
1645
1646                         *ret = c;
1647                         return 0;
1648                 }
1649         }
1650
1651         if (t != USEC_INFINITY) {
1652                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1653                         return -ETIMEDOUT;
1654         }
1655
1656         errno = 0;
1657         if (!fgets(line, sizeof(line), f))
1658                 return errno ? -errno : -EIO;
1659
1660         truncate_nl(line);
1661
1662         if (strlen(line) != 1)
1663                 return -EBADMSG;
1664
1665         if (need_nl)
1666                 *need_nl = false;
1667
1668         *ret = line[0];
1669         return 0;
1670 }
1671
1672 int ask_char(char *ret, const char *replies, const char *text, ...) {
1673         int r;
1674
1675         assert(ret);
1676         assert(replies);
1677         assert(text);
1678
1679         for (;;) {
1680                 va_list ap;
1681                 char c;
1682                 bool need_nl = true;
1683
1684                 if (on_tty())
1685                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1686
1687                 va_start(ap, text);
1688                 vprintf(text, ap);
1689                 va_end(ap);
1690
1691                 if (on_tty())
1692                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1693
1694                 fflush(stdout);
1695
1696                 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1697                 if (r < 0) {
1698
1699                         if (r == -EBADMSG) {
1700                                 puts("Bad input, please try again.");
1701                                 continue;
1702                         }
1703
1704                         putchar('\n');
1705                         return r;
1706                 }
1707
1708                 if (need_nl)
1709                         putchar('\n');
1710
1711                 if (strchr(replies, c)) {
1712                         *ret = c;
1713                         return 0;
1714                 }
1715
1716                 puts("Read unexpected character, please try again.");
1717         }
1718 }
1719
1720 int ask_string(char **ret, const char *text, ...) {
1721         assert(ret);
1722         assert(text);
1723
1724         for (;;) {
1725                 char line[LINE_MAX];
1726                 va_list ap;
1727
1728                 if (on_tty())
1729                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1730
1731                 va_start(ap, text);
1732                 vprintf(text, ap);
1733                 va_end(ap);
1734
1735                 if (on_tty())
1736                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1737
1738                 fflush(stdout);
1739
1740                 errno = 0;
1741                 if (!fgets(line, sizeof(line), stdin))
1742                         return errno ? -errno : -EIO;
1743
1744                 if (!endswith(line, "\n"))
1745                         putchar('\n');
1746                 else {
1747                         char *s;
1748
1749                         if (isempty(line))
1750                                 continue;
1751
1752                         truncate_nl(line);
1753                         s = strdup(line);
1754                         if (!s)
1755                                 return -ENOMEM;
1756
1757                         *ret = s;
1758                         return 0;
1759                 }
1760         }
1761 }
1762
1763 int reset_terminal_fd(int fd, bool switch_to_text) {
1764         struct termios termios;
1765         int r = 0;
1766
1767         /* Set terminal to some sane defaults */
1768
1769         assert(fd >= 0);
1770
1771         /* We leave locked terminal attributes untouched, so that
1772          * Plymouth may set whatever it wants to set, and we don't
1773          * interfere with that. */
1774
1775         /* Disable exclusive mode, just in case */
1776         ioctl(fd, TIOCNXCL);
1777
1778         /* Switch to text mode */
1779         if (switch_to_text)
1780                 ioctl(fd, KDSETMODE, KD_TEXT);
1781
1782         /* Enable console unicode mode */
1783         ioctl(fd, KDSKBMODE, K_UNICODE);
1784
1785         if (tcgetattr(fd, &termios) < 0) {
1786                 r = -errno;
1787                 goto finish;
1788         }
1789
1790         /* We only reset the stuff that matters to the software. How
1791          * hardware is set up we don't touch assuming that somebody
1792          * else will do that for us */
1793
1794         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1795         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1796         termios.c_oflag |= ONLCR;
1797         termios.c_cflag |= CREAD;
1798         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1799
1800         termios.c_cc[VINTR]    =   03;  /* ^C */
1801         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1802         termios.c_cc[VERASE]   = 0177;
1803         termios.c_cc[VKILL]    =  025;  /* ^X */
1804         termios.c_cc[VEOF]     =   04;  /* ^D */
1805         termios.c_cc[VSTART]   =  021;  /* ^Q */
1806         termios.c_cc[VSTOP]    =  023;  /* ^S */
1807         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1808         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1809         termios.c_cc[VWERASE]  =  027;  /* ^W */
1810         termios.c_cc[VREPRINT] =  022;  /* ^R */
1811         termios.c_cc[VEOL]     =    0;
1812         termios.c_cc[VEOL2]    =    0;
1813
1814         termios.c_cc[VTIME]  = 0;
1815         termios.c_cc[VMIN]   = 1;
1816
1817         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1818                 r = -errno;
1819
1820 finish:
1821         /* Just in case, flush all crap out */
1822         tcflush(fd, TCIOFLUSH);
1823
1824         return r;
1825 }
1826
1827 int reset_terminal(const char *name) {
1828         _cleanup_close_ int fd = -1;
1829
1830         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1831         if (fd < 0)
1832                 return fd;
1833
1834         return reset_terminal_fd(fd, true);
1835 }
1836
1837 int open_terminal(const char *name, int mode) {
1838         int fd, r;
1839         unsigned c = 0;
1840
1841         /*
1842          * If a TTY is in the process of being closed opening it might
1843          * cause EIO. This is horribly awful, but unlikely to be
1844          * changed in the kernel. Hence we work around this problem by
1845          * retrying a couple of times.
1846          *
1847          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1848          */
1849
1850         assert(!(mode & O_CREAT));
1851
1852         for (;;) {
1853                 fd = open(name, mode, 0);
1854                 if (fd >= 0)
1855                         break;
1856
1857                 if (errno != EIO)
1858                         return -errno;
1859
1860                 /* Max 1s in total */
1861                 if (c >= 20)
1862                         return -errno;
1863
1864                 usleep(50 * USEC_PER_MSEC);
1865                 c++;
1866         }
1867
1868         if (fd < 0)
1869                 return -errno;
1870
1871         r = isatty(fd);
1872         if (r < 0) {
1873                 safe_close(fd);
1874                 return -errno;
1875         }
1876
1877         if (!r) {
1878                 safe_close(fd);
1879                 return -ENOTTY;
1880         }
1881
1882         return fd;
1883 }
1884
1885 int flush_fd(int fd) {
1886         struct pollfd pollfd = {
1887                 .fd = fd,
1888                 .events = POLLIN,
1889         };
1890
1891         for (;;) {
1892                 char buf[LINE_MAX];
1893                 ssize_t l;
1894                 int r;
1895
1896                 r = poll(&pollfd, 1, 0);
1897                 if (r < 0) {
1898                         if (errno == EINTR)
1899                                 continue;
1900
1901                         return -errno;
1902
1903                 } else if (r == 0)
1904                         return 0;
1905
1906                 l = read(fd, buf, sizeof(buf));
1907                 if (l < 0) {
1908
1909                         if (errno == EINTR)
1910                                 continue;
1911
1912                         if (errno == EAGAIN)
1913                                 return 0;
1914
1915                         return -errno;
1916                 } else if (l == 0)
1917                         return 0;
1918         }
1919 }
1920
1921 int acquire_terminal(
1922                 const char *name,
1923                 bool fail,
1924                 bool force,
1925                 bool ignore_tiocstty_eperm,
1926                 usec_t timeout) {
1927
1928         int fd = -1, notify = -1, r = 0, wd = -1;
1929         usec_t ts = 0;
1930
1931         assert(name);
1932
1933         /* We use inotify to be notified when the tty is closed. We
1934          * create the watch before checking if we can actually acquire
1935          * it, so that we don't lose any event.
1936          *
1937          * Note: strictly speaking this actually watches for the
1938          * device being closed, it does *not* really watch whether a
1939          * tty loses its controlling process. However, unless some
1940          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1941          * its tty otherwise this will not become a problem. As long
1942          * as the administrator makes sure not configure any service
1943          * on the same tty as an untrusted user this should not be a
1944          * problem. (Which he probably should not do anyway.) */
1945
1946         if (timeout != USEC_INFINITY)
1947                 ts = now(CLOCK_MONOTONIC);
1948
1949         if (!fail && !force) {
1950                 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
1951                 if (notify < 0) {
1952                         r = -errno;
1953                         goto fail;
1954                 }
1955
1956                 wd = inotify_add_watch(notify, name, IN_CLOSE);
1957                 if (wd < 0) {
1958                         r = -errno;
1959                         goto fail;
1960                 }
1961         }
1962
1963         for (;;) {
1964                 struct sigaction sa_old, sa_new = {
1965                         .sa_handler = SIG_IGN,
1966                         .sa_flags = SA_RESTART,
1967                 };
1968
1969                 if (notify >= 0) {
1970                         r = flush_fd(notify);
1971                         if (r < 0)
1972                                 goto fail;
1973                 }
1974
1975                 /* We pass here O_NOCTTY only so that we can check the return
1976                  * value TIOCSCTTY and have a reliable way to figure out if we
1977                  * successfully became the controlling process of the tty */
1978                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1979                 if (fd < 0)
1980                         return fd;
1981
1982                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1983                  * if we already own the tty. */
1984                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1985
1986                 /* First, try to get the tty */
1987                 if (ioctl(fd, TIOCSCTTY, force) < 0)
1988                         r = -errno;
1989
1990                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1991
1992                 /* Sometimes it makes sense to ignore TIOCSCTTY
1993                  * returning EPERM, i.e. when very likely we already
1994                  * are have this controlling terminal. */
1995                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1996                         r = 0;
1997
1998                 if (r < 0 && (force || fail || r != -EPERM)) {
1999                         goto fail;
2000                 }
2001
2002                 if (r >= 0)
2003                         break;
2004
2005                 assert(!fail);
2006                 assert(!force);
2007                 assert(notify >= 0);
2008
2009                 for (;;) {
2010                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
2011                         ssize_t l;
2012                         struct inotify_event *e;
2013
2014                         if (timeout != USEC_INFINITY) {
2015                                 usec_t n;
2016
2017                                 n = now(CLOCK_MONOTONIC);
2018                                 if (ts + timeout < n) {
2019                                         r = -ETIMEDOUT;
2020                                         goto fail;
2021                                 }
2022
2023                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2024                                 if (r < 0)
2025                                         goto fail;
2026
2027                                 if (r == 0) {
2028                                         r = -ETIMEDOUT;
2029                                         goto fail;
2030                                 }
2031                         }
2032
2033                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
2034                         if (l < 0) {
2035
2036                                 if (errno == EINTR || errno == EAGAIN)
2037                                         continue;
2038
2039                                 r = -errno;
2040                                 goto fail;
2041                         }
2042
2043                         e = (struct inotify_event*) inotify_buffer;
2044
2045                         while (l > 0) {
2046                                 size_t step;
2047
2048                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2049                                         r = -EIO;
2050                                         goto fail;
2051                                 }
2052
2053                                 step = sizeof(struct inotify_event) + e->len;
2054                                 assert(step <= (size_t) l);
2055
2056                                 e = (struct inotify_event*) ((uint8_t*) e + step);
2057                                 l -= step;
2058                         }
2059
2060                         break;
2061                 }
2062
2063                 /* We close the tty fd here since if the old session
2064                  * ended our handle will be dead. It's important that
2065                  * we do this after sleeping, so that we don't enter
2066                  * an endless loop. */
2067                 safe_close(fd);
2068         }
2069
2070         safe_close(notify);
2071
2072         r = reset_terminal_fd(fd, true);
2073         if (r < 0)
2074                 log_warning("Failed to reset terminal: %s", strerror(-r));
2075
2076         return fd;
2077
2078 fail:
2079         safe_close(fd);
2080         safe_close(notify);
2081
2082         return r;
2083 }
2084
2085 int release_terminal(void) {
2086         static const struct sigaction sa_new = {
2087                 .sa_handler = SIG_IGN,
2088                 .sa_flags = SA_RESTART,
2089         };
2090
2091         _cleanup_close_ int fd = -1;
2092         struct sigaction sa_old;
2093         int r = 0;
2094
2095         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2096         if (fd < 0)
2097                 return -errno;
2098
2099         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2100          * by our own TIOCNOTTY */
2101         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2102
2103         if (ioctl(fd, TIOCNOTTY) < 0)
2104                 r = -errno;
2105
2106         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2107
2108         return r;
2109 }
2110
2111 int sigaction_many(const struct sigaction *sa, ...) {
2112         va_list ap;
2113         int r = 0, sig;
2114
2115         va_start(ap, sa);
2116         while ((sig = va_arg(ap, int)) > 0)
2117                 if (sigaction(sig, sa, NULL) < 0)
2118                         r = -errno;
2119         va_end(ap);
2120
2121         return r;
2122 }
2123
2124 int ignore_signals(int sig, ...) {
2125         struct sigaction sa = {
2126                 .sa_handler = SIG_IGN,
2127                 .sa_flags = SA_RESTART,
2128         };
2129         va_list ap;
2130         int r = 0;
2131
2132         if (sigaction(sig, &sa, NULL) < 0)
2133                 r = -errno;
2134
2135         va_start(ap, sig);
2136         while ((sig = va_arg(ap, int)) > 0)
2137                 if (sigaction(sig, &sa, NULL) < 0)
2138                         r = -errno;
2139         va_end(ap);
2140
2141         return r;
2142 }
2143
2144 int default_signals(int sig, ...) {
2145         struct sigaction sa = {
2146                 .sa_handler = SIG_DFL,
2147                 .sa_flags = SA_RESTART,
2148         };
2149         va_list ap;
2150         int r = 0;
2151
2152         if (sigaction(sig, &sa, NULL) < 0)
2153                 r = -errno;
2154
2155         va_start(ap, sig);
2156         while ((sig = va_arg(ap, int)) > 0)
2157                 if (sigaction(sig, &sa, NULL) < 0)
2158                         r = -errno;
2159         va_end(ap);
2160
2161         return r;
2162 }
2163
2164 void safe_close_pair(int p[]) {
2165         assert(p);
2166
2167         if (p[0] == p[1]) {
2168                 /* Special case pairs which use the same fd in both
2169                  * directions... */
2170                 p[0] = p[1] = safe_close(p[0]);
2171                 return;
2172         }
2173
2174         p[0] = safe_close(p[0]);
2175         p[1] = safe_close(p[1]);
2176 }
2177
2178 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2179         uint8_t *p = buf;
2180         ssize_t n = 0;
2181
2182         assert(fd >= 0);
2183         assert(buf);
2184
2185         while (nbytes > 0) {
2186                 ssize_t k;
2187
2188                 k = read(fd, p, nbytes);
2189                 if (k < 0 && errno == EINTR)
2190                         continue;
2191
2192                 if (k < 0 && errno == EAGAIN && do_poll) {
2193
2194                         /* We knowingly ignore any return value here,
2195                          * and expect that any error/EOF is reported
2196                          * via read() */
2197
2198                         fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2199                         continue;
2200                 }
2201
2202                 if (k <= 0)
2203                         return n > 0 ? n : (k < 0 ? -errno : 0);
2204
2205                 p += k;
2206                 nbytes -= k;
2207                 n += k;
2208         }
2209
2210         return n;
2211 }
2212
2213 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2214         const uint8_t *p = buf;
2215         ssize_t n = 0;
2216
2217         assert(fd >= 0);
2218         assert(buf);
2219
2220         while (nbytes > 0) {
2221                 ssize_t k;
2222
2223                 k = write(fd, p, nbytes);
2224                 if (k < 0 && errno == EINTR)
2225                         continue;
2226
2227                 if (k < 0 && errno == EAGAIN && do_poll) {
2228
2229                         /* We knowingly ignore any return value here,
2230                          * and expect that any error/EOF is reported
2231                          * via write() */
2232
2233                         fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2234                         continue;
2235                 }
2236
2237                 if (k <= 0)
2238                         return n > 0 ? n : (k < 0 ? -errno : 0);
2239
2240                 p += k;
2241                 nbytes -= k;
2242                 n += k;
2243         }
2244
2245         return n;
2246 }
2247
2248 int parse_size(const char *t, off_t base, off_t *size) {
2249
2250         /* Soo, sometimes we want to parse IEC binary suffxies, and
2251          * sometimes SI decimal suffixes. This function can parse
2252          * both. Which one is the right way depends on the
2253          * context. Wikipedia suggests that SI is customary for
2254          * hardrware metrics and network speeds, while IEC is
2255          * customary for most data sizes used by software and volatile
2256          * (RAM) memory. Hence be careful which one you pick!
2257          *
2258          * In either case we use just K, M, G as suffix, and not Ki,
2259          * Mi, Gi or so (as IEC would suggest). That's because that's
2260          * frickin' ugly. But this means you really need to make sure
2261          * to document which base you are parsing when you use this
2262          * call. */
2263
2264         struct table {
2265                 const char *suffix;
2266                 unsigned long long factor;
2267         };
2268
2269         static const struct table iec[] = {
2270                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2271                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2272                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2273                 { "G", 1024ULL*1024ULL*1024ULL },
2274                 { "M", 1024ULL*1024ULL },
2275                 { "K", 1024ULL },
2276                 { "B", 1 },
2277                 { "", 1 },
2278         };
2279
2280         static const struct table si[] = {
2281                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2282                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2283                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2284                 { "G", 1000ULL*1000ULL*1000ULL },
2285                 { "M", 1000ULL*1000ULL },
2286                 { "K", 1000ULL },
2287                 { "B", 1 },
2288                 { "", 1 },
2289         };
2290
2291         const struct table *table;
2292         const char *p;
2293         unsigned long long r = 0;
2294         unsigned n_entries, start_pos = 0;
2295
2296         assert(t);
2297         assert(base == 1000 || base == 1024);
2298         assert(size);
2299
2300         if (base == 1000) {
2301                 table = si;
2302                 n_entries = ELEMENTSOF(si);
2303         } else {
2304                 table = iec;
2305                 n_entries = ELEMENTSOF(iec);
2306         }
2307
2308         p = t;
2309         do {
2310                 long long l;
2311                 unsigned long long l2;
2312                 double frac = 0;
2313                 char *e;
2314                 unsigned i;
2315
2316                 errno = 0;
2317                 l = strtoll(p, &e, 10);
2318
2319                 if (errno > 0)
2320                         return -errno;
2321
2322                 if (l < 0)
2323                         return -ERANGE;
2324
2325                 if (e == p)
2326                         return -EINVAL;
2327
2328                 if (*e == '.') {
2329                         e++;
2330                         if (*e >= '0' && *e <= '9') {
2331                                 char *e2;
2332
2333                                 /* strotoull itself would accept space/+/- */
2334                                 l2 = strtoull(e, &e2, 10);
2335
2336                                 if (errno == ERANGE)
2337                                         return -errno;
2338
2339                                 /* Ignore failure. E.g. 10.M is valid */
2340                                 frac = l2;
2341                                 for (; e < e2; e++)
2342                                         frac /= 10;
2343                         }
2344                 }
2345
2346                 e += strspn(e, WHITESPACE);
2347
2348                 for (i = start_pos; i < n_entries; i++)
2349                         if (startswith(e, table[i].suffix)) {
2350                                 unsigned long long tmp;
2351                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2352                                         return -ERANGE;
2353                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2354                                 if (tmp > ULLONG_MAX - r)
2355                                         return -ERANGE;
2356
2357                                 r += tmp;
2358                                 if ((unsigned long long) (off_t) r != r)
2359                                         return -ERANGE;
2360
2361                                 p = e + strlen(table[i].suffix);
2362
2363                                 start_pos = i + 1;
2364                                 break;
2365                         }
2366
2367                 if (i >= n_entries)
2368                         return -EINVAL;
2369
2370         } while (*p);
2371
2372         *size = r;
2373
2374         return 0;
2375 }
2376
2377 int make_stdio(int fd) {
2378         int r, s, t;
2379
2380         assert(fd >= 0);
2381
2382         r = dup3(fd, STDIN_FILENO, 0);
2383         s = dup3(fd, STDOUT_FILENO, 0);
2384         t = dup3(fd, STDERR_FILENO, 0);
2385
2386         if (fd >= 3)
2387                 safe_close(fd);
2388
2389         if (r < 0 || s < 0 || t < 0)
2390                 return -errno;
2391
2392         /* We rely here that the new fd has O_CLOEXEC not set */
2393
2394         return 0;
2395 }
2396
2397 int make_null_stdio(void) {
2398         int null_fd;
2399
2400         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2401         if (null_fd < 0)
2402                 return -errno;
2403
2404         return make_stdio(null_fd);
2405 }
2406
2407 bool is_device_path(const char *path) {
2408
2409         /* Returns true on paths that refer to a device, either in
2410          * sysfs or in /dev */
2411
2412         return
2413                 path_startswith(path, "/dev/") ||
2414                 path_startswith(path, "/sys/");
2415 }
2416
2417 int dir_is_empty(const char *path) {
2418         _cleanup_closedir_ DIR *d;
2419
2420         d = opendir(path);
2421         if (!d)
2422                 return -errno;
2423
2424         for (;;) {
2425                 struct dirent *de;
2426
2427                 errno = 0;
2428                 de = readdir(d);
2429                 if (!de && errno != 0)
2430                         return -errno;
2431
2432                 if (!de)
2433                         return 1;
2434
2435                 if (!ignore_file(de->d_name))
2436                         return 0;
2437         }
2438 }
2439
2440 char* dirname_malloc(const char *path) {
2441         char *d, *dir, *dir2;
2442
2443         d = strdup(path);
2444         if (!d)
2445                 return NULL;
2446         dir = dirname(d);
2447         assert(dir);
2448
2449         if (dir != d) {
2450                 dir2 = strdup(dir);
2451                 free(d);
2452                 return dir2;
2453         }
2454
2455         return dir;
2456 }
2457
2458 int dev_urandom(void *p, size_t n) {
2459         _cleanup_close_ int fd;
2460         ssize_t k;
2461
2462         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2463         if (fd < 0)
2464                 return errno == ENOENT ? -ENOSYS : -errno;
2465
2466         k = loop_read(fd, p, n, true);
2467         if (k < 0)
2468                 return (int) k;
2469         if ((size_t) k != n)
2470                 return -EIO;
2471
2472         return 0;
2473 }
2474
2475 void random_bytes(void *p, size_t n) {
2476         static bool srand_called = false;
2477         uint8_t *q;
2478         int r;
2479
2480         r = dev_urandom(p, n);
2481         if (r >= 0)
2482                 return;
2483
2484         /* If some idiot made /dev/urandom unavailable to us, he'll
2485          * get a PRNG instead. */
2486
2487         if (!srand_called) {
2488                 unsigned x = 0;
2489
2490 #ifdef HAVE_SYS_AUXV_H
2491                 /* The kernel provides us with a bit of entropy in
2492                  * auxv, so let's try to make use of that to seed the
2493                  * pseudo-random generator. It's better than
2494                  * nothing... */
2495
2496                 void *auxv;
2497
2498                 auxv = (void*) getauxval(AT_RANDOM);
2499                 if (auxv)
2500                         x ^= *(unsigned*) auxv;
2501 #endif
2502
2503                 x ^= (unsigned) now(CLOCK_REALTIME);
2504                 x ^= (unsigned) gettid();
2505
2506                 srand(x);
2507                 srand_called = true;
2508         }
2509
2510         for (q = p; q < (uint8_t*) p + n; q ++)
2511                 *q = rand();
2512 }
2513
2514 void rename_process(const char name[8]) {
2515         assert(name);
2516
2517         /* This is a like a poor man's setproctitle(). It changes the
2518          * comm field, argv[0], and also the glibc's internally used
2519          * name of the process. For the first one a limit of 16 chars
2520          * applies, to the second one usually one of 10 (i.e. length
2521          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2522          * "systemd"). If you pass a longer string it will be
2523          * truncated */
2524
2525         prctl(PR_SET_NAME, name);
2526
2527         if (program_invocation_name)
2528                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2529
2530         if (saved_argc > 0) {
2531                 int i;
2532
2533                 if (saved_argv[0])
2534                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2535
2536                 for (i = 1; i < saved_argc; i++) {
2537                         if (!saved_argv[i])
2538                                 break;
2539
2540                         memzero(saved_argv[i], strlen(saved_argv[i]));
2541                 }
2542         }
2543 }
2544
2545 void sigset_add_many(sigset_t *ss, ...) {
2546         va_list ap;
2547         int sig;
2548
2549         assert(ss);
2550
2551         va_start(ap, ss);
2552         while ((sig = va_arg(ap, int)) > 0)
2553                 assert_se(sigaddset(ss, sig) == 0);
2554         va_end(ap);
2555 }
2556
2557 int sigprocmask_many(int how, ...) {
2558         va_list ap;
2559         sigset_t ss;
2560         int sig;
2561
2562         assert_se(sigemptyset(&ss) == 0);
2563
2564         va_start(ap, how);
2565         while ((sig = va_arg(ap, int)) > 0)
2566                 assert_se(sigaddset(&ss, sig) == 0);
2567         va_end(ap);
2568
2569         if (sigprocmask(how, &ss, NULL) < 0)
2570                 return -errno;
2571
2572         return 0;
2573 }
2574
2575 char* gethostname_malloc(void) {
2576         struct utsname u;
2577
2578         assert_se(uname(&u) >= 0);
2579
2580         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2581                 return strdup(u.nodename);
2582
2583         return strdup(u.sysname);
2584 }
2585
2586 bool hostname_is_set(void) {
2587         struct utsname u;
2588
2589         assert_se(uname(&u) >= 0);
2590
2591         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2592 }
2593
2594 static char *lookup_uid(uid_t uid) {
2595         long bufsize;
2596         char *name;
2597         _cleanup_free_ char *buf = NULL;
2598         struct passwd pwbuf, *pw = NULL;
2599
2600         /* Shortcut things to avoid NSS lookups */
2601         if (uid == 0)
2602                 return strdup("root");
2603
2604         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2605         if (bufsize <= 0)
2606                 bufsize = 4096;
2607
2608         buf = malloc(bufsize);
2609         if (!buf)
2610                 return NULL;
2611
2612         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2613                 return strdup(pw->pw_name);
2614
2615         if (asprintf(&name, UID_FMT, uid) < 0)
2616                 return NULL;
2617
2618         return name;
2619 }
2620
2621 char* getlogname_malloc(void) {
2622         uid_t uid;
2623         struct stat st;
2624
2625         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2626                 uid = st.st_uid;
2627         else
2628                 uid = getuid();
2629
2630         return lookup_uid(uid);
2631 }
2632
2633 char *getusername_malloc(void) {
2634         const char *e;
2635
2636         e = getenv("USER");
2637         if (e)
2638                 return strdup(e);
2639
2640         return lookup_uid(getuid());
2641 }
2642
2643 int getttyname_malloc(int fd, char **r) {
2644         char path[PATH_MAX], *c;
2645         int k;
2646
2647         assert(r);
2648
2649         k = ttyname_r(fd, path, sizeof(path));
2650         if (k > 0)
2651                 return -k;
2652
2653         char_array_0(path);
2654
2655         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2656         if (!c)
2657                 return -ENOMEM;
2658
2659         *r = c;
2660         return 0;
2661 }
2662
2663 int getttyname_harder(int fd, char **r) {
2664         int k;
2665         char *s;
2666
2667         k = getttyname_malloc(fd, &s);
2668         if (k < 0)
2669                 return k;
2670
2671         if (streq(s, "tty")) {
2672                 free(s);
2673                 return get_ctty(0, NULL, r);
2674         }
2675
2676         *r = s;
2677         return 0;
2678 }
2679
2680 int get_ctty_devnr(pid_t pid, dev_t *d) {
2681         int r;
2682         _cleanup_free_ char *line = NULL;
2683         const char *p;
2684         unsigned long ttynr;
2685
2686         assert(pid >= 0);
2687
2688         p = procfs_file_alloca(pid, "stat");
2689         r = read_one_line_file(p, &line);
2690         if (r < 0)
2691                 return r;
2692
2693         p = strrchr(line, ')');
2694         if (!p)
2695                 return -EIO;
2696
2697         p++;
2698
2699         if (sscanf(p, " "
2700                    "%*c "  /* state */
2701                    "%*d "  /* ppid */
2702                    "%*d "  /* pgrp */
2703                    "%*d "  /* session */
2704                    "%lu ", /* ttynr */
2705                    &ttynr) != 1)
2706                 return -EIO;
2707
2708         if (major(ttynr) == 0 && minor(ttynr) == 0)
2709                 return -ENOENT;
2710
2711         if (d)
2712                 *d = (dev_t) ttynr;
2713
2714         return 0;
2715 }
2716
2717 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2718         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
2719         _cleanup_free_ char *s = NULL;
2720         const char *p;
2721         dev_t devnr;
2722         int k;
2723
2724         assert(r);
2725
2726         k = get_ctty_devnr(pid, &devnr);
2727         if (k < 0)
2728                 return k;
2729
2730         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2731
2732         k = readlink_malloc(fn, &s);
2733         if (k < 0) {
2734
2735                 if (k != -ENOENT)
2736                         return k;
2737
2738                 /* This is an ugly hack */
2739                 if (major(devnr) == 136) {
2740                         asprintf(&b, "pts/%u", minor(devnr));
2741                         goto finish;
2742                 }
2743
2744                 /* Probably something like the ptys which have no
2745                  * symlink in /dev/char. Let's return something
2746                  * vaguely useful. */
2747
2748                 b = strdup(fn + 5);
2749                 goto finish;
2750         }
2751
2752         if (startswith(s, "/dev/"))
2753                 p = s + 5;
2754         else if (startswith(s, "../"))
2755                 p = s + 3;
2756         else
2757                 p = s;
2758
2759         b = strdup(p);
2760
2761 finish:
2762         if (!b)
2763                 return -ENOMEM;
2764
2765         *r = b;
2766         if (_devnr)
2767                 *_devnr = devnr;
2768
2769         return 0;
2770 }
2771
2772 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2773         _cleanup_closedir_ DIR *d = NULL;
2774         int ret = 0;
2775
2776         assert(fd >= 0);
2777
2778         /* This returns the first error we run into, but nevertheless
2779          * tries to go on. This closes the passed fd. */
2780
2781         d = fdopendir(fd);
2782         if (!d) {
2783                 safe_close(fd);
2784
2785                 return errno == ENOENT ? 0 : -errno;
2786         }
2787
2788         for (;;) {
2789                 struct dirent *de;
2790                 bool is_dir, keep_around;
2791                 struct stat st;
2792                 int r;
2793
2794                 errno = 0;
2795                 de = readdir(d);
2796                 if (!de) {
2797                         if (errno != 0 && ret == 0)
2798                                 ret = -errno;
2799                         return ret;
2800                 }
2801
2802                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2803                         continue;
2804
2805                 if (de->d_type == DT_UNKNOWN ||
2806                     honour_sticky ||
2807                     (de->d_type == DT_DIR && root_dev)) {
2808                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2809                                 if (ret == 0 && errno != ENOENT)
2810                                         ret = -errno;
2811                                 continue;
2812                         }
2813
2814                         is_dir = S_ISDIR(st.st_mode);
2815                         keep_around =
2816                                 honour_sticky &&
2817                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2818                                 (st.st_mode & S_ISVTX);
2819                 } else {
2820                         is_dir = de->d_type == DT_DIR;
2821                         keep_around = false;
2822                 }
2823
2824                 if (is_dir) {
2825                         int subdir_fd;
2826
2827                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2828                         if (root_dev && st.st_dev != root_dev->st_dev)
2829                                 continue;
2830
2831                         subdir_fd = openat(fd, de->d_name,
2832                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2833                         if (subdir_fd < 0) {
2834                                 if (ret == 0 && errno != ENOENT)
2835                                         ret = -errno;
2836                                 continue;
2837                         }
2838
2839                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2840                         if (r < 0 && ret == 0)
2841                                 ret = r;
2842
2843                         if (!keep_around)
2844                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2845                                         if (ret == 0 && errno != ENOENT)
2846                                                 ret = -errno;
2847                                 }
2848
2849                 } else if (!only_dirs && !keep_around) {
2850
2851                         if (unlinkat(fd, de->d_name, 0) < 0) {
2852                                 if (ret == 0 && errno != ENOENT)
2853                                         ret = -errno;
2854                         }
2855                 }
2856         }
2857 }
2858
2859 _pure_ static int is_temporary_fs(struct statfs *s) {
2860         assert(s);
2861
2862         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
2863                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
2864 }
2865
2866 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2867         struct statfs s;
2868
2869         assert(fd >= 0);
2870
2871         if (fstatfs(fd, &s) < 0) {
2872                 safe_close(fd);
2873                 return -errno;
2874         }
2875
2876         /* We refuse to clean disk file systems with this call. This
2877          * is extra paranoia just to be sure we never ever remove
2878          * non-state data */
2879         if (!is_temporary_fs(&s)) {
2880                 log_error("Attempted to remove disk file system, and we can't allow that.");
2881                 safe_close(fd);
2882                 return -EPERM;
2883         }
2884
2885         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2886 }
2887
2888 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2889         int fd, r;
2890         struct statfs s;
2891
2892         assert(path);
2893
2894         /* We refuse to clean the root file system with this
2895          * call. This is extra paranoia to never cause a really
2896          * seriously broken system. */
2897         if (path_equal(path, "/")) {
2898                 log_error("Attempted to remove entire root file system, and we can't allow that.");
2899                 return -EPERM;
2900         }
2901
2902         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2903         if (fd < 0) {
2904
2905                 if (errno != ENOTDIR)
2906                         return -errno;
2907
2908                 if (!dangerous) {
2909                         if (statfs(path, &s) < 0)
2910                                 return -errno;
2911
2912                         if (!is_temporary_fs(&s)) {
2913                                 log_error("Attempted to remove disk file system, and we can't allow that.");
2914                                 return -EPERM;
2915                         }
2916                 }
2917
2918                 if (delete_root && !only_dirs)
2919                         if (unlink(path) < 0 && errno != ENOENT)
2920                                 return -errno;
2921
2922                 return 0;
2923         }
2924
2925         if (!dangerous) {
2926                 if (fstatfs(fd, &s) < 0) {
2927                         safe_close(fd);
2928                         return -errno;
2929                 }
2930
2931                 if (!is_temporary_fs(&s)) {
2932                         log_error("Attempted to remove disk file system, and we can't allow that.");
2933                         safe_close(fd);
2934                         return -EPERM;
2935                 }
2936         }
2937
2938         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2939         if (delete_root) {
2940
2941                 if (honour_sticky && file_is_priv_sticky(path) > 0)
2942                         return r;
2943
2944                 if (rmdir(path) < 0 && errno != ENOENT) {
2945                         if (r == 0)
2946                                 r = -errno;
2947                 }
2948         }
2949
2950         return r;
2951 }
2952
2953 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2954         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2955 }
2956
2957 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2958         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2959 }
2960
2961 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2962         assert(path);
2963
2964         /* Under the assumption that we are running privileged we
2965          * first change the access mode and only then hand out
2966          * ownership to avoid a window where access is too open. */
2967
2968         if (mode != (mode_t) -1)
2969                 if (chmod(path, mode) < 0)
2970                         return -errno;
2971
2972         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2973                 if (chown(path, uid, gid) < 0)
2974                         return -errno;
2975
2976         return 0;
2977 }
2978
2979 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2980         assert(fd >= 0);
2981
2982         /* Under the assumption that we are running privileged we
2983          * first change the access mode and only then hand out
2984          * ownership to avoid a window where access is too open. */
2985
2986         if (mode != (mode_t) -1)
2987                 if (fchmod(fd, mode) < 0)
2988                         return -errno;
2989
2990         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2991                 if (fchown(fd, uid, gid) < 0)
2992                         return -errno;
2993
2994         return 0;
2995 }
2996
2997 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2998         cpu_set_t *r;
2999         unsigned n = 1024;
3000
3001         /* Allocates the cpuset in the right size */
3002
3003         for (;;) {
3004                 if (!(r = CPU_ALLOC(n)))
3005                         return NULL;
3006
3007                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3008                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3009
3010                         if (ncpus)
3011                                 *ncpus = n;
3012
3013                         return r;
3014                 }
3015
3016                 CPU_FREE(r);
3017
3018                 if (errno != EINVAL)
3019                         return NULL;
3020
3021                 n *= 2;
3022         }
3023 }
3024
3025 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3026         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3027         _cleanup_free_ char *s = NULL;
3028         _cleanup_close_ int fd = -1;
3029         struct iovec iovec[6] = {};
3030         int n = 0;
3031         static bool prev_ephemeral;
3032
3033         assert(format);
3034
3035         /* This is independent of logging, as status messages are
3036          * optional and go exclusively to the console. */
3037
3038         if (vasprintf(&s, format, ap) < 0)
3039                 return log_oom();
3040
3041         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3042         if (fd < 0)
3043                 return fd;
3044
3045         if (ellipse) {
3046                 char *e;
3047                 size_t emax, sl;
3048                 int c;
3049
3050                 c = fd_columns(fd);
3051                 if (c <= 0)
3052                         c = 80;
3053
3054                 sl = status ? sizeof(status_indent)-1 : 0;
3055
3056                 emax = c - sl - 1;
3057                 if (emax < 3)
3058                         emax = 3;
3059
3060                 e = ellipsize(s, emax, 50);
3061                 if (e) {
3062                         free(s);
3063                         s = e;
3064                 }
3065         }
3066
3067         if (prev_ephemeral)
3068                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3069         prev_ephemeral = ephemeral;
3070
3071         if (status) {
3072                 if (!isempty(status)) {
3073                         IOVEC_SET_STRING(iovec[n++], "[");
3074                         IOVEC_SET_STRING(iovec[n++], status);
3075                         IOVEC_SET_STRING(iovec[n++], "] ");
3076                 } else
3077                         IOVEC_SET_STRING(iovec[n++], status_indent);
3078         }
3079
3080         IOVEC_SET_STRING(iovec[n++], s);
3081         if (!ephemeral)
3082                 IOVEC_SET_STRING(iovec[n++], "\n");
3083
3084         if (writev(fd, iovec, n) < 0)
3085                 return -errno;
3086
3087         return 0;
3088 }
3089
3090 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3091         va_list ap;
3092         int r;
3093
3094         assert(format);
3095
3096         va_start(ap, format);
3097         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3098         va_end(ap);
3099
3100         return r;
3101 }
3102
3103 char *replace_env(const char *format, char **env) {
3104         enum {
3105                 WORD,
3106                 CURLY,
3107                 VARIABLE
3108         } state = WORD;
3109
3110         const char *e, *word = format;
3111         char *r = NULL, *k;
3112
3113         assert(format);
3114
3115         for (e = format; *e; e ++) {
3116
3117                 switch (state) {
3118
3119                 case WORD:
3120                         if (*e == '$')
3121                                 state = CURLY;
3122                         break;
3123
3124                 case CURLY:
3125                         if (*e == '{') {
3126                                 if (!(k = strnappend(r, word, e-word-1)))
3127                                         goto fail;
3128
3129                                 free(r);
3130                                 r = k;
3131
3132                                 word = e-1;
3133                                 state = VARIABLE;
3134
3135                         } else if (*e == '$') {
3136                                 if (!(k = strnappend(r, word, e-word)))
3137                                         goto fail;
3138
3139                                 free(r);
3140                                 r = k;
3141
3142                                 word = e+1;
3143                                 state = WORD;
3144                         } else
3145                                 state = WORD;
3146                         break;
3147
3148                 case VARIABLE:
3149                         if (*e == '}') {
3150                                 const char *t;
3151
3152                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3153
3154                                 k = strappend(r, t);
3155                                 if (!k)
3156                                         goto fail;
3157
3158                                 free(r);
3159                                 r = k;
3160
3161                                 word = e+1;
3162                                 state = WORD;
3163                         }
3164                         break;
3165                 }
3166         }
3167
3168         if (!(k = strnappend(r, word, e-word)))
3169                 goto fail;
3170
3171         free(r);
3172         return k;
3173
3174 fail:
3175         free(r);
3176         return NULL;
3177 }
3178
3179 char **replace_env_argv(char **argv, char **env) {
3180         char **ret, **i;
3181         unsigned k = 0, l = 0;
3182
3183         l = strv_length(argv);
3184
3185         ret = new(char*, l+1);
3186         if (!ret)
3187                 return NULL;
3188
3189         STRV_FOREACH(i, argv) {
3190
3191                 /* If $FOO appears as single word, replace it by the split up variable */
3192                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3193                         char *e;
3194                         char **w, **m;
3195                         unsigned q;
3196
3197                         e = strv_env_get(env, *i+1);
3198                         if (e) {
3199                                 int r;
3200
3201                                 r = strv_split_quoted(&m, e);
3202                                 if (r < 0) {
3203                                         ret[k] = NULL;
3204                                         strv_free(ret);
3205                                         return NULL;
3206                                 }
3207                         } else
3208                                 m = NULL;
3209
3210                         q = strv_length(m);
3211                         l = l + q - 1;
3212
3213                         w = realloc(ret, sizeof(char*) * (l+1));
3214                         if (!w) {
3215                                 ret[k] = NULL;
3216                                 strv_free(ret);
3217                                 strv_free(m);
3218                                 return NULL;
3219                         }
3220
3221                         ret = w;
3222                         if (m) {
3223                                 memcpy(ret + k, m, q * sizeof(char*));
3224                                 free(m);
3225                         }
3226
3227                         k += q;
3228                         continue;
3229                 }
3230
3231                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3232                 ret[k] = replace_env(*i, env);
3233                 if (!ret[k]) {
3234                         strv_free(ret);
3235                         return NULL;
3236                 }
3237                 k++;
3238         }
3239
3240         ret[k] = NULL;
3241         return ret;
3242 }
3243
3244 int fd_columns(int fd) {
3245         struct winsize ws = {};
3246
3247         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3248                 return -errno;
3249
3250         if (ws.ws_col <= 0)
3251                 return -EIO;
3252
3253         return ws.ws_col;
3254 }
3255
3256 unsigned columns(void) {
3257         const char *e;
3258         int c;
3259
3260         if (_likely_(cached_columns > 0))
3261                 return cached_columns;
3262
3263         c = 0;
3264         e = getenv("COLUMNS");
3265         if (e)
3266                 safe_atoi(e, &c);
3267
3268         if (c <= 0)
3269                 c = fd_columns(STDOUT_FILENO);
3270
3271         if (c <= 0)
3272                 c = 80;
3273
3274         cached_columns = c;
3275         return c;
3276 }
3277
3278 int fd_lines(int fd) {
3279         struct winsize ws = {};
3280
3281         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3282                 return -errno;
3283
3284         if (ws.ws_row <= 0)
3285                 return -EIO;
3286
3287         return ws.ws_row;
3288 }
3289
3290 unsigned lines(void) {
3291         const char *e;
3292         unsigned l;
3293
3294         if (_likely_(cached_lines > 0))
3295                 return cached_lines;
3296
3297         l = 0;
3298         e = getenv("LINES");
3299         if (e)
3300                 safe_atou(e, &l);
3301
3302         if (l <= 0)
3303                 l = fd_lines(STDOUT_FILENO);
3304
3305         if (l <= 0)
3306                 l = 24;
3307
3308         cached_lines = l;
3309         return cached_lines;
3310 }
3311
3312 /* intended to be used as a SIGWINCH sighandler */
3313 void columns_lines_cache_reset(int signum) {
3314         cached_columns = 0;
3315         cached_lines = 0;
3316 }
3317
3318 bool on_tty(void) {
3319         static int cached_on_tty = -1;
3320
3321         if (_unlikely_(cached_on_tty < 0))
3322                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3323
3324         return cached_on_tty;
3325 }
3326
3327 int files_same(const char *filea, const char *fileb) {
3328         struct stat a, b;
3329
3330         if (stat(filea, &a) < 0)
3331                 return -errno;
3332
3333         if (stat(fileb, &b) < 0)
3334                 return -errno;
3335
3336         return a.st_dev == b.st_dev &&
3337                a.st_ino == b.st_ino;
3338 }
3339
3340 int running_in_chroot(void) {
3341         int ret;
3342
3343         ret = files_same("/proc/1/root", "/");
3344         if (ret < 0)
3345                 return ret;
3346
3347         return ret == 0;
3348 }
3349
3350 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3351         size_t x;
3352         char *r;
3353
3354         assert(s);
3355         assert(percent <= 100);
3356         assert(new_length >= 3);
3357
3358         if (old_length <= 3 || old_length <= new_length)
3359                 return strndup(s, old_length);
3360
3361         r = new0(char, new_length+1);
3362         if (!r)
3363                 return NULL;
3364
3365         x = (new_length * percent) / 100;
3366
3367         if (x > new_length - 3)
3368                 x = new_length - 3;
3369
3370         memcpy(r, s, x);
3371         r[x] = '.';
3372         r[x+1] = '.';
3373         r[x+2] = '.';
3374         memcpy(r + x + 3,
3375                s + old_length - (new_length - x - 3),
3376                new_length - x - 3);
3377
3378         return r;
3379 }
3380
3381 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3382         size_t x;
3383         char *e;
3384         const char *i, *j;
3385         unsigned k, len, len2;
3386
3387         assert(s);
3388         assert(percent <= 100);
3389         assert(new_length >= 3);
3390
3391         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3392         if (ascii_is_valid(s))
3393                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3394
3395         if (old_length <= 3 || old_length <= new_length)
3396                 return strndup(s, old_length);
3397
3398         x = (new_length * percent) / 100;
3399
3400         if (x > new_length - 3)
3401                 x = new_length - 3;
3402
3403         k = 0;
3404         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3405                 int c;
3406
3407                 c = utf8_encoded_to_unichar(i);
3408                 if (c < 0)
3409                         return NULL;
3410                 k += unichar_iswide(c) ? 2 : 1;
3411         }
3412
3413         if (k > x) /* last character was wide and went over quota */
3414                 x ++;
3415
3416         for (j = s + old_length; k < new_length && j > i; ) {
3417                 int c;
3418
3419                 j = utf8_prev_char(j);
3420                 c = utf8_encoded_to_unichar(j);
3421                 if (c < 0)
3422                         return NULL;
3423                 k += unichar_iswide(c) ? 2 : 1;
3424         }
3425         assert(i <= j);
3426
3427         /* we don't actually need to ellipsize */
3428         if (i == j)
3429                 return memdup(s, old_length + 1);
3430
3431         /* make space for ellipsis */
3432         j = utf8_next_char(j);
3433
3434         len = i - s;
3435         len2 = s + old_length - j;
3436         e = new(char, len + 3 + len2 + 1);
3437         if (!e)
3438                 return NULL;
3439
3440         /*
3441         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3442                old_length, new_length, x, len, len2, k);
3443         */
3444
3445         memcpy(e, s, len);
3446         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3447         e[len + 1] = 0x80;
3448         e[len + 2] = 0xa6;
3449
3450         memcpy(e + len + 3, j, len2 + 1);
3451
3452         return e;
3453 }
3454
3455 char *ellipsize(const char *s, size_t length, unsigned percent) {
3456         return ellipsize_mem(s, strlen(s), length, percent);
3457 }
3458
3459 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3460         _cleanup_close_ int fd;
3461         int r;
3462
3463         assert(path);
3464
3465         if (parents)
3466                 mkdir_parents(path, 0755);
3467
3468         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3469         if (fd < 0)
3470                 return -errno;
3471
3472         if (mode > 0) {
3473                 r = fchmod(fd, mode);
3474                 if (r < 0)
3475                         return -errno;
3476         }
3477
3478         if (uid != (uid_t) -1 || gid != (gid_t) -1) {
3479                 r = fchown(fd, uid, gid);
3480                 if (r < 0)
3481                         return -errno;
3482         }
3483
3484         if (stamp != USEC_INFINITY) {
3485                 struct timespec ts[2];
3486
3487                 timespec_store(&ts[0], stamp);
3488                 ts[1] = ts[0];
3489                 r = futimens(fd, ts);
3490         } else
3491                 r = futimens(fd, NULL);
3492         if (r < 0)
3493                 return -errno;
3494
3495         return 0;
3496 }
3497
3498 int touch(const char *path) {
3499         return touch_file(path, false, USEC_INFINITY, (uid_t) -1, (gid_t) -1, 0);
3500 }
3501
3502 char *unquote(const char *s, const char* quotes) {
3503         size_t l;
3504         assert(s);
3505
3506         /* This is rather stupid, simply removes the heading and
3507          * trailing quotes if there is one. Doesn't care about
3508          * escaping or anything. We should make this smarter one
3509          * day...*/
3510
3511         l = strlen(s);
3512         if (l < 2)
3513                 return strdup(s);
3514
3515         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3516                 return strndup(s+1, l-2);
3517
3518         return strdup(s);
3519 }
3520
3521 char *normalize_env_assignment(const char *s) {
3522         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3523         char *eq, *r;
3524
3525         eq = strchr(s, '=');
3526         if (!eq) {
3527                 char *t;
3528
3529                 r = strdup(s);
3530                 if (!r)
3531                         return NULL;
3532
3533                 t = strstrip(r);
3534                 if (t == r)
3535                         return r;
3536
3537                 memmove(r, t, strlen(t) + 1);
3538                 return r;
3539         }
3540
3541         name = strndup(s, eq - s);
3542         if (!name)
3543                 return NULL;
3544
3545         p = strdup(eq + 1);
3546         if (!p)
3547                 return NULL;
3548
3549         value = unquote(strstrip(p), QUOTES);
3550         if (!value)
3551                 return NULL;
3552
3553         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3554                 r = NULL;
3555
3556         return r;
3557 }
3558
3559 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3560         siginfo_t dummy;
3561
3562         assert(pid >= 1);
3563
3564         if (!status)
3565                 status = &dummy;
3566
3567         for (;;) {
3568                 zero(*status);
3569
3570                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3571
3572                         if (errno == EINTR)
3573                                 continue;
3574
3575                         return -errno;
3576                 }
3577
3578                 return 0;
3579         }
3580 }
3581
3582 /*
3583  * Return values:
3584  * < 0 : wait_for_terminate() failed to get the state of the
3585  *       process, the process was terminated by a signal, or
3586  *       failed for an unknown reason.
3587  * >=0 : The process terminated normally, and its exit code is
3588  *       returned.
3589  *
3590  * That is, success is indicated by a return value of zero, and an
3591  * error is indicated by a non-zero value.
3592  */
3593 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3594         int r;
3595         siginfo_t status;
3596
3597         assert(name);
3598         assert(pid > 1);
3599
3600         r = wait_for_terminate(pid, &status);
3601         if (r < 0) {
3602                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3603                 return r;
3604         }
3605
3606         if (status.si_code == CLD_EXITED) {
3607                 if (status.si_status != 0) {
3608                         log_warning("%s failed with error code %i.", name, status.si_status);
3609                         return status.si_status;
3610                 }
3611
3612                 log_debug("%s succeeded.", name);
3613                 return 0;
3614
3615         } else if (status.si_code == CLD_KILLED ||
3616                    status.si_code == CLD_DUMPED) {
3617
3618                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3619                 return -EPROTO;
3620         }
3621
3622         log_warning("%s failed due to unknown reason.", name);
3623         return -EPROTO;
3624 }
3625
3626 noreturn void freeze(void) {
3627
3628         /* Make sure nobody waits for us on a socket anymore */
3629         close_all_fds(NULL, 0);
3630
3631         sync();
3632
3633         for (;;)
3634                 pause();
3635 }
3636
3637 bool null_or_empty(struct stat *st) {
3638         assert(st);
3639
3640         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3641                 return true;
3642
3643         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3644                 return true;
3645
3646         return false;
3647 }
3648
3649 int null_or_empty_path(const char *fn) {
3650         struct stat st;
3651
3652         assert(fn);
3653
3654         if (stat(fn, &st) < 0)
3655                 return -errno;
3656
3657         return null_or_empty(&st);
3658 }
3659
3660 int null_or_empty_fd(int fd) {
3661         struct stat st;
3662
3663         assert(fd >= 0);
3664
3665         if (fstat(fd, &st) < 0)
3666                 return -errno;
3667
3668         return null_or_empty(&st);
3669 }
3670
3671 DIR *xopendirat(int fd, const char *name, int flags) {
3672         int nfd;
3673         DIR *d;
3674
3675         assert(!(flags & O_CREAT));
3676
3677         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3678         if (nfd < 0)
3679                 return NULL;
3680
3681         d = fdopendir(nfd);
3682         if (!d) {
3683                 safe_close(nfd);
3684                 return NULL;
3685         }
3686
3687         return d;
3688 }
3689
3690 int signal_from_string_try_harder(const char *s) {
3691         int signo;
3692         assert(s);
3693
3694         signo = signal_from_string(s);
3695         if (signo <= 0)
3696                 if (startswith(s, "SIG"))
3697                         return signal_from_string(s+3);
3698
3699         return signo;
3700 }
3701
3702 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3703         _cleanup_free_ char *t = NULL, *u = NULL;
3704         size_t enc_len;
3705
3706         u = unquote(tagvalue, "\"\'");
3707         if (!u)
3708                 return NULL;
3709
3710         enc_len = strlen(u) * 4 + 1;
3711         t = new(char, enc_len);
3712         if (!t)
3713                 return NULL;
3714
3715         if (encode_devnode_name(u, t, enc_len) < 0)
3716                 return NULL;
3717
3718         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3719 }
3720
3721 char *fstab_node_to_udev_node(const char *p) {
3722         assert(p);
3723
3724         if (startswith(p, "LABEL="))
3725                 return tag_to_udev_node(p+6, "label");
3726
3727         if (startswith(p, "UUID="))
3728                 return tag_to_udev_node(p+5, "uuid");
3729
3730         if (startswith(p, "PARTUUID="))
3731                 return tag_to_udev_node(p+9, "partuuid");
3732
3733         if (startswith(p, "PARTLABEL="))
3734                 return tag_to_udev_node(p+10, "partlabel");
3735
3736         return strdup(p);
3737 }
3738
3739 bool tty_is_vc(const char *tty) {
3740         assert(tty);
3741
3742         return vtnr_from_tty(tty) >= 0;
3743 }
3744
3745 bool tty_is_console(const char *tty) {
3746         assert(tty);
3747
3748         if (startswith(tty, "/dev/"))
3749                 tty += 5;
3750
3751         return streq(tty, "console");
3752 }
3753
3754 int vtnr_from_tty(const char *tty) {
3755         int i, r;
3756
3757         assert(tty);
3758
3759         if (startswith(tty, "/dev/"))
3760                 tty += 5;
3761
3762         if (!startswith(tty, "tty") )
3763                 return -EINVAL;
3764
3765         if (tty[3] < '0' || tty[3] > '9')
3766                 return -EINVAL;
3767
3768         r = safe_atoi(tty+3, &i);
3769         if (r < 0)
3770                 return r;
3771
3772         if (i < 0 || i > 63)
3773                 return -EINVAL;
3774
3775         return i;
3776 }
3777
3778 char *resolve_dev_console(char **active) {
3779         char *tty;
3780
3781         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3782          * (i.e. not read-only-mounted which is a sign for container setups) */
3783
3784         if (path_is_read_only_fs("/sys") > 0)
3785                 return NULL;
3786
3787         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3788                 return NULL;
3789
3790         /* If multiple log outputs are configured the last one is what
3791          * /dev/console points to */
3792         tty = strrchr(*active, ' ');
3793         if (tty)
3794                 tty++;
3795         else
3796                 tty = *active;
3797
3798         if (streq(tty, "tty0")) {
3799                 char *tmp;
3800
3801                 /* Get the active VC (e.g. tty1) */
3802                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3803                         free(*active);
3804                         tty = *active = tmp;
3805                 }
3806         }
3807
3808         return tty;
3809 }
3810
3811 bool tty_is_vc_resolve(const char *tty) {
3812         _cleanup_free_ char *active = NULL;
3813
3814         assert(tty);
3815
3816         if (startswith(tty, "/dev/"))
3817                 tty += 5;
3818
3819         if (streq(tty, "console")) {
3820                 tty = resolve_dev_console(&active);
3821                 if (!tty)
3822                         return false;
3823         }
3824
3825         return tty_is_vc(tty);
3826 }
3827
3828 const char *default_term_for_tty(const char *tty) {
3829         assert(tty);
3830
3831         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3832 }
3833
3834 bool dirent_is_file(const struct dirent *de) {
3835         assert(de);
3836
3837         if (ignore_file(de->d_name))
3838                 return false;
3839
3840         if (de->d_type != DT_REG &&
3841             de->d_type != DT_LNK &&
3842             de->d_type != DT_UNKNOWN)
3843                 return false;
3844
3845         return true;
3846 }
3847
3848 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3849         assert(de);
3850
3851         if (de->d_type != DT_REG &&
3852             de->d_type != DT_LNK &&
3853             de->d_type != DT_UNKNOWN)
3854                 return false;
3855
3856         if (ignore_file_allow_backup(de->d_name))
3857                 return false;
3858
3859         return endswith(de->d_name, suffix);
3860 }
3861
3862 void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {
3863         pid_t executor_pid;
3864         int r;
3865
3866         assert(directory);
3867
3868         /* Executes all binaries in a directory in parallel and waits
3869          * for them to finish. Optionally a timeout is applied. */
3870
3871         executor_pid = fork();
3872         if (executor_pid < 0) {
3873                 log_error("Failed to fork: %m");
3874                 return;
3875
3876         } else if (executor_pid == 0) {
3877                 _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
3878                 _cleanup_closedir_ DIR *_d = NULL;
3879                 struct dirent *de;
3880                 sigset_t ss;
3881
3882                 /* We fork this all off from a child process so that
3883                  * we can somewhat cleanly make use of SIGALRM to set
3884                  * a time limit */
3885
3886                 reset_all_signal_handlers();
3887
3888                 assert_se(sigemptyset(&ss) == 0);
3889                 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
3890
3891                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3892
3893                 if (!d) {
3894                         d = _d = opendir(directory);
3895                         if (!d) {
3896                                 if (errno == ENOENT)
3897                                         _exit(EXIT_SUCCESS);
3898
3899                                 log_error("Failed to enumerate directory %s: %m", directory);
3900                                 _exit(EXIT_FAILURE);
3901                         }
3902                 }
3903
3904                 pids = hashmap_new(NULL, NULL);
3905                 if (!pids) {
3906                         log_oom();
3907                         _exit(EXIT_FAILURE);
3908                 }
3909
3910                 FOREACH_DIRENT(de, d, break) {
3911                         _cleanup_free_ char *path = NULL;
3912                         pid_t pid;
3913
3914                         if (!dirent_is_file(de))
3915                                 continue;
3916
3917                         path = strjoin(directory, "/", de->d_name, NULL);
3918                         if (!path) {
3919                                 log_oom();
3920                                 _exit(EXIT_FAILURE);
3921                         }
3922
3923                         pid = fork();
3924                         if (pid < 0) {
3925                                 log_error("Failed to fork: %m");
3926                                 continue;
3927                         } else if (pid == 0) {
3928                                 char *_argv[2];
3929
3930                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
3931
3932                                 if (!argv) {
3933                                         _argv[0] = path;
3934                                         _argv[1] = NULL;
3935                                         argv = _argv;
3936                                 } else
3937                                         argv[0] = path;
3938
3939                                 execv(path, argv);
3940                                 log_error("Failed to execute %s: %m", path);
3941                                 _exit(EXIT_FAILURE);
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 host and domain names
6872          * described in RFC6761 plus the redhatism of .localdomain */
6873
6874         return streq(hostname, "localhost") ||
6875                streq(hostname, "localhost.") ||
6876                streq(hostname, "localdomain.") ||
6877                streq(hostname, "localdomain") ||
6878                endswith(hostname, ".localhost") ||
6879                endswith(hostname, ".localhost.") ||
6880                endswith(hostname, ".localdomain") ||
6881                endswith(hostname, ".localdomain.");
6882 }
6883
6884 int take_password_lock(const char *root) {
6885
6886         struct flock flock = {
6887                 .l_type = F_WRLCK,
6888                 .l_whence = SEEK_SET,
6889                 .l_start = 0,
6890                 .l_len = 0,
6891         };
6892
6893         const char *path;
6894         int fd, r;
6895
6896         /* This is roughly the same as lckpwdf(), but not as awful. We
6897          * don't want to use alarm() and signals, hence we implement
6898          * our own trivial version of this.
6899          *
6900          * Note that shadow-utils also takes per-database locks in
6901          * addition to lckpwdf(). However, we don't given that they
6902          * are redundant as they they invoke lckpwdf() first and keep
6903          * it during everything they do. The per-database locks are
6904          * awfully racy, and thus we just won't do them. */
6905
6906         if (root)
6907                 path = strappenda(root, "/etc/.pwd.lock");
6908         else
6909                 path = "/etc/.pwd.lock";
6910
6911         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
6912         if (fd < 0)
6913                 return -errno;
6914
6915         r = fcntl(fd, F_SETLKW, &flock);
6916         if (r < 0) {
6917                 safe_close(fd);
6918                 return -errno;
6919         }
6920
6921         return fd;
6922 }
6923
6924 int is_symlink(const char *path) {
6925         struct stat info;
6926
6927         if (lstat(path, &info) < 0)
6928                 return -errno;
6929
6930         if (S_ISLNK(info.st_mode))
6931                 return 1;
6932
6933         return 0;
6934 }
6935
6936 int unquote_first_word(const char **p, char **ret) {
6937         _cleanup_free_ char *s = NULL;
6938         size_t allocated = 0, sz = 0;
6939
6940         enum {
6941                 START,
6942                 VALUE,
6943                 VALUE_ESCAPE,
6944                 SINGLE_QUOTE,
6945                 SINGLE_QUOTE_ESCAPE,
6946                 DOUBLE_QUOTE,
6947                 DOUBLE_QUOTE_ESCAPE,
6948                 SPACE,
6949         } state = START;
6950
6951         assert(p);
6952         assert(*p);
6953         assert(ret);
6954
6955         /* Parses the first word of a string, and returns it in
6956          * *ret. Removes all quotes in the process. When parsing fails
6957          * (because of an uneven number of quotes or similar), leaves
6958          * the pointer *p at the first invalid character. */
6959
6960         for (;;) {
6961                 char c = **p;
6962
6963                 switch (state) {
6964
6965                 case START:
6966                         if (c == 0)
6967                                 goto finish;
6968                         else if (strchr(WHITESPACE, c))
6969                                 break;
6970
6971                         state = VALUE;
6972                         /* fallthrough */
6973
6974                 case VALUE:
6975                         if (c == 0)
6976                                 goto finish;
6977                         else if (c == '\'')
6978                                 state = SINGLE_QUOTE;
6979                         else if (c == '\\')
6980                                 state = VALUE_ESCAPE;
6981                         else if (c == '\"')
6982                                 state = DOUBLE_QUOTE;
6983                         else if (strchr(WHITESPACE, c))
6984                                 state = SPACE;
6985                         else {
6986                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
6987                                         return -ENOMEM;
6988
6989                                 s[sz++] = c;
6990                         }
6991
6992                         break;
6993
6994                 case VALUE_ESCAPE:
6995                         if (c == 0)
6996                                 return -EINVAL;
6997
6998                         if (!GREEDY_REALLOC(s, allocated, sz+2))
6999                                 return -ENOMEM;
7000
7001                         s[sz++] = c;
7002                         state = VALUE;
7003
7004                         break;
7005
7006                 case SINGLE_QUOTE:
7007                         if (c == 0)
7008                                 return -EINVAL;
7009                         else if (c == '\'')
7010                                 state = VALUE;
7011                         else if (c == '\\')
7012                                 state = SINGLE_QUOTE_ESCAPE;
7013                         else {
7014                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7015                                         return -ENOMEM;
7016
7017                                 s[sz++] = c;
7018                         }
7019
7020                         break;
7021
7022                 case SINGLE_QUOTE_ESCAPE:
7023                         if (c == 0)
7024                                 return -EINVAL;
7025
7026                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7027                                 return -ENOMEM;
7028
7029                         s[sz++] = c;
7030                         state = SINGLE_QUOTE;
7031                         break;
7032
7033                 case DOUBLE_QUOTE:
7034                         if (c == 0)
7035                                 return -EINVAL;
7036                         else if (c == '\"')
7037                                 state = VALUE;
7038                         else if (c == '\\')
7039                                 state = DOUBLE_QUOTE_ESCAPE;
7040                         else {
7041                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7042                                         return -ENOMEM;
7043
7044                                 s[sz++] = c;
7045                         }
7046
7047                         break;
7048
7049                 case DOUBLE_QUOTE_ESCAPE:
7050                         if (c == 0)
7051                                 return -EINVAL;
7052
7053                         if (!GREEDY_REALLOC(s, allocated, sz+2))
7054                                 return -ENOMEM;
7055
7056                         s[sz++] = c;
7057                         state = DOUBLE_QUOTE;
7058                         break;
7059
7060                 case SPACE:
7061                         if (c == 0)
7062                                 goto finish;
7063                         if (!strchr(WHITESPACE, c))
7064                                 goto finish;
7065
7066                         break;
7067                 }
7068
7069                 (*p) ++;
7070         }
7071
7072 finish:
7073         if (!s) {
7074                 *ret = NULL;
7075                 return 0;
7076         }
7077
7078         s[sz] = 0;
7079         *ret = s;
7080         s = NULL;
7081
7082         return 1;
7083 }
7084
7085 int unquote_many_words(const char **p, ...) {
7086         va_list ap;
7087         char **l;
7088         int n = 0, i, c, r;
7089
7090         /* Parses a number of words from a string, stripping any
7091          * quotes if necessary. */
7092
7093         assert(p);
7094
7095         /* Count how many words are expected */
7096         va_start(ap, p);
7097         for (;;) {
7098                 if (!va_arg(ap, char **))
7099                         break;
7100                 n++;
7101         }
7102         va_end(ap);
7103
7104         if (n <= 0)
7105                 return 0;
7106
7107         /* Read all words into a temporary array */
7108         l = newa0(char*, n);
7109         for (c = 0; c < n; c++) {
7110
7111                 r = unquote_first_word(p, &l[c]);
7112                 if (r < 0) {
7113                         int j;
7114
7115                         for (j = 0; j < c; j++)
7116                                 free(l[j]);
7117
7118                         return r;
7119                 }
7120
7121                 if (r == 0)
7122                         break;
7123         }
7124
7125         /* If we managed to parse all words, return them in the passed
7126          * in parameters */
7127         va_start(ap, p);
7128         for (i = 0; i < n; i++) {
7129                 char **v;
7130
7131                 v = va_arg(ap, char **);
7132                 assert(v);
7133
7134                 *v = l[i];
7135         }
7136         va_end(ap);
7137
7138         return c;
7139 }
7140
7141 int free_and_strdup(char **p, const char *s) {
7142         char *t;
7143
7144         assert(p);
7145
7146         /* Replaces a string pointer with an strdup()ed new string,
7147          * possibly freeing the old one. */
7148
7149         if (s) {
7150                 t = strdup(s);
7151                 if (!t)
7152                         return -ENOMEM;
7153         } else
7154                 t = NULL;
7155
7156         free(*p);
7157         *p = t;
7158
7159         return 0;
7160 }