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