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