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