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