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