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