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