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         d = fdopendir(fd);
3143         if (!d) {
3144                 close_nointr_nofail(fd);
3145
3146                 return errno == ENOENT ? 0 : -errno;
3147         }
3148
3149         for (;;) {
3150                 struct dirent buf, *de;
3151                 bool is_dir, keep_around = false;
3152                 int r;
3153
3154                 r = readdir_r(d, &buf, &de);
3155                 if (r != 0 && ret == 0) {
3156                         ret = -r;
3157                         break;
3158                 }
3159
3160                 if (!de)
3161                         break;
3162
3163                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
3164                         continue;
3165
3166                 if (de->d_type == DT_UNKNOWN) {
3167                         struct stat st;
3168
3169                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3170                                 if (ret == 0 && errno != ENOENT)
3171                                         ret = -errno;
3172                                 continue;
3173                         }
3174
3175                         if (honour_sticky)
3176                                 keep_around =
3177                                         (st.st_uid == 0 || st.st_uid == getuid()) &&
3178                                         (st.st_mode & S_ISVTX);
3179
3180                         is_dir = S_ISDIR(st.st_mode);
3181
3182                 } else {
3183                         if (honour_sticky) {
3184                                 struct stat st;
3185
3186                                 if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3187                                         if (ret == 0 && errno != ENOENT)
3188                                                 ret = -errno;
3189                                         continue;
3190                                 }
3191
3192                                 keep_around =
3193                                         (st.st_uid == 0 || st.st_uid == getuid()) &&
3194                                         (st.st_mode & S_ISVTX);
3195                         }
3196
3197                         is_dir = de->d_type == DT_DIR;
3198                 }
3199
3200                 if (is_dir) {
3201                         int subdir_fd;
3202
3203                         subdir_fd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3204                         if (subdir_fd < 0) {
3205                                 if (ret == 0 && errno != ENOENT)
3206                                         ret = -errno;
3207                                 continue;
3208                         }
3209
3210                         r = rm_rf_children(subdir_fd, only_dirs, honour_sticky);
3211                         if (r < 0 && ret == 0)
3212                                 ret = r;
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         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3241         if (fd < 0) {
3242
3243                 if (errno != ENOTDIR)
3244                         return -errno;
3245
3246                 if (delete_root && !only_dirs)
3247                         if (unlink(path) < 0 && errno != ENOENT)
3248                                 return -errno;
3249
3250                 return 0;
3251         }
3252
3253         r = rm_rf_children(fd, only_dirs, honour_sticky);
3254
3255         if (delete_root) {
3256
3257                 if (honour_sticky && file_is_priv_sticky(path) > 0)
3258                         return r;
3259
3260                 if (rmdir(path) < 0 && errno != ENOENT) {
3261                         if (r == 0)
3262                                 r = -errno;
3263                 }
3264         }
3265
3266         return r;
3267 }
3268
3269 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3270         assert(path);
3271
3272         /* Under the assumption that we are running privileged we
3273          * first change the access mode and only then hand out
3274          * ownership to avoid a window where access is too open. */
3275
3276         if (mode != (mode_t) -1)
3277                 if (chmod(path, mode) < 0)
3278                         return -errno;
3279
3280         if (uid != (uid_t) -1 || gid != (gid_t) -1)
3281                 if (chown(path, uid, gid) < 0)
3282                         return -errno;
3283
3284         return 0;
3285 }
3286
3287 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3288         assert(fd >= 0);
3289
3290         /* Under the assumption that we are running privileged we
3291          * first change the access mode and only then hand out
3292          * ownership to avoid a window where access is too open. */
3293
3294         if (fchmod(fd, mode) < 0)
3295                 return -errno;
3296
3297         if (fchown(fd, uid, gid) < 0)
3298                 return -errno;
3299
3300         return 0;
3301 }
3302
3303 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3304         cpu_set_t *r;
3305         unsigned n = 1024;
3306
3307         /* Allocates the cpuset in the right size */
3308
3309         for (;;) {
3310                 if (!(r = CPU_ALLOC(n)))
3311                         return NULL;
3312
3313                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3314                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3315
3316                         if (ncpus)
3317                                 *ncpus = n;
3318
3319                         return r;
3320                 }
3321
3322                 CPU_FREE(r);
3323
3324                 if (errno != EINVAL)
3325                         return NULL;
3326
3327                 n *= 2;
3328         }
3329 }
3330
3331 void status_vprintf(const char *status, bool ellipse, const char *format, va_list ap) {
3332         char *s = NULL;
3333         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3334         int fd = -1;
3335         struct iovec iovec[5];
3336         int n = 0;
3337
3338         assert(format);
3339
3340         /* This is independent of logging, as status messages are
3341          * optional and go exclusively to the console. */
3342
3343         if (vasprintf(&s, format, ap) < 0)
3344                 goto finish;
3345
3346         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3347         if (fd < 0)
3348                 goto finish;
3349
3350         if (ellipse) {
3351                 char *e;
3352                 size_t emax, sl;
3353                 int c;
3354
3355                 c = fd_columns(fd);
3356                 if (c <= 0)
3357                         c = 80;
3358
3359                 sl = status ? strlen(status_indent) : 0;
3360
3361                 emax = c - sl - 1;
3362                 if (emax < 3)
3363                         emax = 3;
3364
3365                 e = ellipsize(s, emax, 75);
3366                 if (e) {
3367                         free(s);
3368                         s = e;
3369                 }
3370         }
3371
3372         zero(iovec);
3373
3374         if (status) {
3375                 if (!isempty(status)) {
3376                         IOVEC_SET_STRING(iovec[n++], "[");
3377                         IOVEC_SET_STRING(iovec[n++], status);
3378                         IOVEC_SET_STRING(iovec[n++], "] ");
3379                 } else
3380                         IOVEC_SET_STRING(iovec[n++], status_indent);
3381         }
3382
3383         IOVEC_SET_STRING(iovec[n++], s);
3384         IOVEC_SET_STRING(iovec[n++], "\n");
3385
3386         writev(fd, iovec, n);
3387
3388 finish:
3389         free(s);
3390
3391         if (fd >= 0)
3392                 close_nointr_nofail(fd);
3393 }
3394
3395 void status_printf(const char *status, bool ellipse, const char *format, ...) {
3396         va_list ap;
3397
3398         assert(format);
3399
3400         va_start(ap, format);
3401         status_vprintf(status, ellipse, format, ap);
3402         va_end(ap);
3403 }
3404
3405 void status_welcome(void) {
3406         char *pretty_name = NULL, *ansi_color = NULL;
3407         const char *const_pretty = NULL, *const_color = NULL;
3408         int r;
3409
3410         if ((r = parse_env_file("/etc/os-release", NEWLINE,
3411                                 "PRETTY_NAME", &pretty_name,
3412                                 "ANSI_COLOR", &ansi_color,
3413                                 NULL)) < 0) {
3414
3415                 if (r != -ENOENT)
3416                         log_warning("Failed to read /etc/os-release: %s", strerror(-r));
3417         }
3418
3419         if (!pretty_name && !const_pretty)
3420                 const_pretty = "Linux";
3421
3422         if (!ansi_color && !const_color)
3423                 const_color = "1";
3424
3425         status_printf(NULL,
3426                       false,
3427                       "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
3428                       const_color ? const_color : ansi_color,
3429                       const_pretty ? const_pretty : pretty_name);
3430
3431         free(ansi_color);
3432         free(pretty_name);
3433 }
3434
3435 char *replace_env(const char *format, char **env) {
3436         enum {
3437                 WORD,
3438                 CURLY,
3439                 VARIABLE
3440         } state = WORD;
3441
3442         const char *e, *word = format;
3443         char *r = NULL, *k;
3444
3445         assert(format);
3446
3447         for (e = format; *e; e ++) {
3448
3449                 switch (state) {
3450
3451                 case WORD:
3452                         if (*e == '$')
3453                                 state = CURLY;
3454                         break;
3455
3456                 case CURLY:
3457                         if (*e == '{') {
3458                                 if (!(k = strnappend(r, word, e-word-1)))
3459                                         goto fail;
3460
3461                                 free(r);
3462                                 r = k;
3463
3464                                 word = e-1;
3465                                 state = VARIABLE;
3466
3467                         } else if (*e == '$') {
3468                                 if (!(k = strnappend(r, word, e-word)))
3469                                         goto fail;
3470
3471                                 free(r);
3472                                 r = k;
3473
3474                                 word = e+1;
3475                                 state = WORD;
3476                         } else
3477                                 state = WORD;
3478                         break;
3479
3480                 case VARIABLE:
3481                         if (*e == '}') {
3482                                 const char *t;
3483
3484                                 if (!(t = strv_env_get_with_length(env, word+2, e-word-2)))
3485                                         t = "";
3486
3487                                 if (!(k = strappend(r, t)))
3488                                         goto fail;
3489
3490                                 free(r);
3491                                 r = k;
3492
3493                                 word = e+1;
3494                                 state = WORD;
3495                         }
3496                         break;
3497                 }
3498         }
3499
3500         if (!(k = strnappend(r, word, e-word)))
3501                 goto fail;
3502
3503         free(r);
3504         return k;
3505
3506 fail:
3507         free(r);
3508         return NULL;
3509 }
3510
3511 char **replace_env_argv(char **argv, char **env) {
3512         char **r, **i;
3513         unsigned k = 0, l = 0;
3514
3515         l = strv_length(argv);
3516
3517         if (!(r = new(char*, l+1)))
3518                 return NULL;
3519
3520         STRV_FOREACH(i, argv) {
3521
3522                 /* If $FOO appears as single word, replace it by the split up variable */
3523                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3524                         char *e;
3525                         char **w, **m;
3526                         unsigned q;
3527
3528                         if ((e = strv_env_get(env, *i+1))) {
3529
3530                                 if (!(m = strv_split_quoted(e))) {
3531                                         r[k] = NULL;
3532                                         strv_free(r);
3533                                         return NULL;
3534                                 }
3535                         } else
3536                                 m = NULL;
3537
3538                         q = strv_length(m);
3539                         l = l + q - 1;
3540
3541                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3542                                 r[k] = NULL;
3543                                 strv_free(r);
3544                                 strv_free(m);
3545                                 return NULL;
3546                         }
3547
3548                         r = w;
3549                         if (m) {
3550                                 memcpy(r + k, m, q * sizeof(char*));
3551                                 free(m);
3552                         }
3553
3554                         k += q;
3555                         continue;
3556                 }
3557
3558                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3559                 if (!(r[k++] = replace_env(*i, env))) {
3560                         strv_free(r);
3561                         return NULL;
3562                 }
3563         }
3564
3565         r[k] = NULL;
3566         return r;
3567 }
3568
3569 int fd_columns(int fd) {
3570         struct winsize ws;
3571         zero(ws);
3572
3573         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3574                 return -errno;
3575
3576         if (ws.ws_col <= 0)
3577                 return -EIO;
3578
3579         return ws.ws_col;
3580 }
3581
3582 unsigned columns(void) {
3583         static __thread int parsed_columns = 0;
3584         const char *e;
3585
3586         if (_likely_(parsed_columns > 0))
3587                 return parsed_columns;
3588
3589         e = getenv("COLUMNS");
3590         if (e)
3591                 parsed_columns = atoi(e);
3592
3593         if (parsed_columns <= 0)
3594                 parsed_columns = fd_columns(STDOUT_FILENO);
3595
3596         if (parsed_columns <= 0)
3597                 parsed_columns = 80;
3598
3599         return parsed_columns;
3600 }
3601
3602 int fd_lines(int fd) {
3603         struct winsize ws;
3604         zero(ws);
3605
3606         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3607                 return -errno;
3608
3609         if (ws.ws_row <= 0)
3610                 return -EIO;
3611
3612         return ws.ws_row;
3613 }
3614
3615 unsigned lines(void) {
3616         static __thread int parsed_lines = 0;
3617         const char *e;
3618
3619         if (_likely_(parsed_lines > 0))
3620                 return parsed_lines;
3621
3622         e = getenv("LINES");
3623         if (e)
3624                 parsed_lines = atoi(e);
3625
3626         if (parsed_lines <= 0)
3627                 parsed_lines = fd_lines(STDOUT_FILENO);
3628
3629         if (parsed_lines <= 0)
3630                 parsed_lines = 25;
3631
3632         return parsed_lines;
3633 }
3634
3635 int running_in_chroot(void) {
3636         struct stat a, b;
3637
3638         zero(a);
3639         zero(b);
3640
3641         /* Only works as root */
3642
3643         if (stat("/proc/1/root", &a) < 0)
3644                 return -errno;
3645
3646         if (stat("/", &b) < 0)
3647                 return -errno;
3648
3649         return
3650                 a.st_dev != b.st_dev ||
3651                 a.st_ino != b.st_ino;
3652 }
3653
3654 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3655         size_t x;
3656         char *r;
3657
3658         assert(s);
3659         assert(percent <= 100);
3660         assert(new_length >= 3);
3661
3662         if (old_length <= 3 || old_length <= new_length)
3663                 return strndup(s, old_length);
3664
3665         r = new0(char, new_length+1);
3666         if (!r)
3667                 return r;
3668
3669         x = (new_length * percent) / 100;
3670
3671         if (x > new_length - 3)
3672                 x = new_length - 3;
3673
3674         memcpy(r, s, x);
3675         r[x] = '.';
3676         r[x+1] = '.';
3677         r[x+2] = '.';
3678         memcpy(r + x + 3,
3679                s + old_length - (new_length - x - 3),
3680                new_length - x - 3);
3681
3682         return r;
3683 }
3684
3685 char *ellipsize(const char *s, size_t length, unsigned percent) {
3686         return ellipsize_mem(s, strlen(s), length, percent);
3687 }
3688
3689 int touch(const char *path) {
3690         int fd;
3691
3692         assert(path);
3693
3694         if ((fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644)) < 0)
3695                 return -errno;
3696
3697         close_nointr_nofail(fd);
3698         return 0;
3699 }
3700
3701 char *unquote(const char *s, const char* quotes) {
3702         size_t l;
3703         assert(s);
3704
3705         l = strlen(s);
3706         if (l < 2)
3707                 return strdup(s);
3708
3709         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3710                 return strndup(s+1, l-2);
3711
3712         return strdup(s);
3713 }
3714
3715 char *normalize_env_assignment(const char *s) {
3716         char *name, *value, *p, *r;
3717
3718         p = strchr(s, '=');
3719
3720         if (!p) {
3721                 if (!(r = strdup(s)))
3722                         return NULL;
3723
3724                 return strstrip(r);
3725         }
3726
3727         if (!(name = strndup(s, p - s)))
3728                 return NULL;
3729
3730         if (!(p = strdup(p+1))) {
3731                 free(name);
3732                 return NULL;
3733         }
3734
3735         value = unquote(strstrip(p), QUOTES);
3736         free(p);
3737
3738         if (!value) {
3739                 free(name);
3740                 return NULL;
3741         }
3742
3743         if (asprintf(&r, "%s=%s", name, value) < 0)
3744                 r = NULL;
3745
3746         free(value);
3747         free(name);
3748
3749         return r;
3750 }
3751
3752 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3753         siginfo_t dummy;
3754
3755         assert(pid >= 1);
3756
3757         if (!status)
3758                 status = &dummy;
3759
3760         for (;;) {
3761                 zero(*status);
3762
3763                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3764
3765                         if (errno == EINTR)
3766                                 continue;
3767
3768                         return -errno;
3769                 }
3770
3771                 return 0;
3772         }
3773 }
3774
3775 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3776         int r;
3777         siginfo_t status;
3778
3779         assert(name);
3780         assert(pid > 1);
3781
3782         if ((r = wait_for_terminate(pid, &status)) < 0) {
3783                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3784                 return r;
3785         }
3786
3787         if (status.si_code == CLD_EXITED) {
3788                 if (status.si_status != 0) {
3789                         log_warning("%s failed with error code %i.", name, status.si_status);
3790                         return status.si_status;
3791                 }
3792
3793                 log_debug("%s succeeded.", name);
3794                 return 0;
3795
3796         } else if (status.si_code == CLD_KILLED ||
3797                    status.si_code == CLD_DUMPED) {
3798
3799                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3800                 return -EPROTO;
3801         }
3802
3803         log_warning("%s failed due to unknown reason.", name);
3804         return -EPROTO;
3805
3806 }
3807
3808 _noreturn_ void freeze(void) {
3809
3810         /* Make sure nobody waits for us on a socket anymore */
3811         close_all_fds(NULL, 0);
3812
3813         sync();
3814
3815         for (;;)
3816                 pause();
3817 }
3818
3819 bool null_or_empty(struct stat *st) {
3820         assert(st);
3821
3822         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3823                 return true;
3824
3825         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3826                 return true;
3827
3828         return false;
3829 }
3830
3831 int null_or_empty_path(const char *fn) {
3832         struct stat st;
3833
3834         assert(fn);
3835
3836         if (stat(fn, &st) < 0)
3837                 return -errno;
3838
3839         return null_or_empty(&st);
3840 }
3841
3842 DIR *xopendirat(int fd, const char *name, int flags) {
3843         int nfd;
3844         DIR *d;
3845
3846         if ((nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags)) < 0)
3847                 return NULL;
3848
3849         if (!(d = fdopendir(nfd))) {
3850                 close_nointr_nofail(nfd);
3851                 return NULL;
3852         }
3853
3854         return d;
3855 }
3856
3857 int signal_from_string_try_harder(const char *s) {
3858         int signo;
3859         assert(s);
3860
3861         if ((signo = signal_from_string(s)) <= 0)
3862                 if (startswith(s, "SIG"))
3863                         return signal_from_string(s+3);
3864
3865         return signo;
3866 }
3867
3868 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {
3869
3870         assert(f);
3871         assert(name);
3872         assert(t);
3873
3874         if (!dual_timestamp_is_set(t))
3875                 return;
3876
3877         fprintf(f, "%s=%llu %llu\n",
3878                 name,
3879                 (unsigned long long) t->realtime,
3880                 (unsigned long long) t->monotonic);
3881 }
3882
3883 void dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
3884         unsigned long long a, b;
3885
3886         assert(value);
3887         assert(t);
3888
3889         if (sscanf(value, "%lli %llu", &a, &b) != 2)
3890                 log_debug("Failed to parse finish timestamp value %s", value);
3891         else {
3892                 t->realtime = a;
3893                 t->monotonic = b;
3894         }
3895 }
3896
3897 char *fstab_node_to_udev_node(const char *p) {
3898         char *dn, *t, *u;
3899         int r;
3900
3901         /* FIXME: to follow udev's logic 100% we need to leave valid
3902          * UTF8 chars unescaped */
3903
3904         if (startswith(p, "LABEL=")) {
3905
3906                 if (!(u = unquote(p+6, "\"\'")))
3907                         return NULL;
3908
3909                 t = xescape(u, "/ ");
3910                 free(u);
3911
3912                 if (!t)
3913                         return NULL;
3914
3915                 r = asprintf(&dn, "/dev/disk/by-label/%s", t);
3916                 free(t);
3917
3918                 if (r < 0)
3919                         return NULL;
3920
3921                 return dn;
3922         }
3923
3924         if (startswith(p, "UUID=")) {
3925
3926                 if (!(u = unquote(p+5, "\"\'")))
3927                         return NULL;
3928
3929                 t = xescape(u, "/ ");
3930                 free(u);
3931
3932                 if (!t)
3933                         return NULL;
3934
3935                 r = asprintf(&dn, "/dev/disk/by-uuid/%s", t);
3936                 free(t);
3937
3938                 if (r < 0)
3939                         return NULL;
3940
3941                 return dn;
3942         }
3943
3944         return strdup(p);
3945 }
3946
3947 bool tty_is_vc(const char *tty) {
3948         assert(tty);
3949
3950         if (startswith(tty, "/dev/"))
3951                 tty += 5;
3952
3953         return vtnr_from_tty(tty) >= 0;
3954 }
3955
3956 bool tty_is_console(const char *tty) {
3957         assert(tty);
3958
3959         if (startswith(tty, "/dev/"))
3960                 tty += 5;
3961
3962         return streq(tty, "console");
3963 }
3964
3965 int vtnr_from_tty(const char *tty) {
3966         int i, r;
3967
3968         assert(tty);
3969
3970         if (startswith(tty, "/dev/"))
3971                 tty += 5;
3972
3973         if (!startswith(tty, "tty") )
3974                 return -EINVAL;
3975
3976         if (tty[3] < '0' || tty[3] > '9')
3977                 return -EINVAL;
3978
3979         r = safe_atoi(tty+3, &i);
3980         if (r < 0)
3981                 return r;
3982
3983         if (i < 0 || i > 63)
3984                 return -EINVAL;
3985
3986         return i;
3987 }
3988
3989 bool tty_is_vc_resolve(const char *tty) {
3990         char *active = NULL;
3991         bool b;
3992
3993         assert(tty);
3994
3995         if (startswith(tty, "/dev/"))
3996                 tty += 5;
3997
3998         /* Resolve where /dev/console is pointing to, if /sys is
3999          * actually ours (i.e. not read-only-mounted which is a sign
4000          * for container setups) */
4001         if (streq(tty, "console") && path_is_read_only_fs("/sys") <= 0)
4002                 if (read_one_line_file("/sys/class/tty/console/active", &active) >= 0) {
4003                         /* If multiple log outputs are configured the
4004                          * last one is what /dev/console points to */
4005                         tty = strrchr(active, ' ');
4006                         if (tty)
4007                                 tty++;
4008                         else
4009                                 tty = active;
4010                 }
4011
4012         b = tty_is_vc(tty);
4013         free(active);
4014
4015         return b;
4016 }
4017
4018 const char *default_term_for_tty(const char *tty) {
4019         assert(tty);
4020
4021         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
4022 }
4023
4024 bool dirent_is_file(const struct dirent *de) {
4025         assert(de);
4026
4027         if (ignore_file(de->d_name))
4028                 return false;
4029
4030         if (de->d_type != DT_REG &&
4031             de->d_type != DT_LNK &&
4032             de->d_type != DT_UNKNOWN)
4033                 return false;
4034
4035         return true;
4036 }
4037
4038 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4039         assert(de);
4040
4041         if (!dirent_is_file(de))
4042                 return false;
4043
4044         return endswith(de->d_name, suffix);
4045 }
4046
4047 void execute_directory(const char *directory, DIR *d, char *argv[]) {
4048         DIR *_d = NULL;
4049         struct dirent *de;
4050         Hashmap *pids = NULL;
4051
4052         assert(directory);
4053
4054         /* Executes all binaries in a directory in parallel and waits
4055          * until all they all finished. */
4056
4057         if (!d) {
4058                 if (!(_d = opendir(directory))) {
4059
4060                         if (errno == ENOENT)
4061                                 return;
4062
4063                         log_error("Failed to enumerate directory %s: %m", directory);
4064                         return;
4065                 }
4066
4067                 d = _d;
4068         }
4069
4070         if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
4071                 log_error("Failed to allocate set.");
4072                 goto finish;
4073         }
4074
4075         while ((de = readdir(d))) {
4076                 char *path;
4077                 pid_t pid;
4078                 int k;
4079
4080                 if (!dirent_is_file(de))
4081                         continue;
4082
4083                 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
4084                         log_error("Out of memory");
4085                         continue;
4086                 }
4087
4088                 if ((pid = fork()) < 0) {
4089                         log_error("Failed to fork: %m");
4090                         free(path);
4091                         continue;
4092                 }
4093
4094                 if (pid == 0) {
4095                         char *_argv[2];
4096                         /* Child */
4097
4098                         if (!argv) {
4099                                 _argv[0] = path;
4100                                 _argv[1] = NULL;
4101                                 argv = _argv;
4102                         } else
4103                                 argv[0] = path;
4104
4105                         execv(path, argv);
4106
4107                         log_error("Failed to execute %s: %m", path);
4108                         _exit(EXIT_FAILURE);
4109                 }
4110
4111                 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
4112
4113                 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
4114                         log_error("Failed to add PID to set: %s", strerror(-k));
4115                         free(path);
4116                 }
4117         }
4118
4119         while (!hashmap_isempty(pids)) {
4120                 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
4121                 siginfo_t si;
4122                 char *path;
4123
4124                 zero(si);
4125                 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
4126
4127                         if (errno == EINTR)
4128                                 continue;
4129
4130                         log_error("waitid() failed: %m");
4131                         goto finish;
4132                 }
4133
4134                 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
4135                         if (!is_clean_exit(si.si_code, si.si_status)) {
4136                                 if (si.si_code == CLD_EXITED)
4137                                         log_error("%s exited with exit status %i.", path, si.si_status);
4138                                 else
4139                                         log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
4140                         } else
4141                                 log_debug("%s exited successfully.", path);
4142
4143                         free(path);
4144                 }
4145         }
4146
4147 finish:
4148         if (_d)
4149                 closedir(_d);
4150
4151         if (pids)
4152                 hashmap_free_free(pids);
4153 }
4154
4155 int kill_and_sigcont(pid_t pid, int sig) {
4156         int r;
4157
4158         r = kill(pid, sig) < 0 ? -errno : 0;
4159
4160         if (r >= 0)
4161                 kill(pid, SIGCONT);
4162
4163         return r;
4164 }
4165
4166 bool nulstr_contains(const char*nulstr, const char *needle) {
4167         const char *i;
4168
4169         if (!nulstr)
4170                 return false;
4171
4172         NULSTR_FOREACH(i, nulstr)
4173                 if (streq(i, needle))
4174                         return true;
4175
4176         return false;
4177 }
4178
4179 bool plymouth_running(void) {
4180         return access("/run/plymouth/pid", F_OK) >= 0;
4181 }
4182
4183 void parse_syslog_priority(char **p, int *priority) {
4184         int a = 0, b = 0, c = 0;
4185         int k;
4186
4187         assert(p);
4188         assert(*p);
4189         assert(priority);
4190
4191         if ((*p)[0] != '<')
4192                 return;
4193
4194         if (!strchr(*p, '>'))
4195                 return;
4196
4197         if ((*p)[2] == '>') {
4198                 c = undecchar((*p)[1]);
4199                 k = 3;
4200         } else if ((*p)[3] == '>') {
4201                 b = undecchar((*p)[1]);
4202                 c = undecchar((*p)[2]);
4203                 k = 4;
4204         } else if ((*p)[4] == '>') {
4205                 a = undecchar((*p)[1]);
4206                 b = undecchar((*p)[2]);
4207                 c = undecchar((*p)[3]);
4208                 k = 5;
4209         } else
4210                 return;
4211
4212         if (a < 0 || b < 0 || c < 0)
4213                 return;
4214
4215         *priority = a*100+b*10+c;
4216         *p += k;
4217 }
4218
4219 void skip_syslog_pid(char **buf) {
4220         char *p;
4221
4222         assert(buf);
4223         assert(*buf);
4224
4225         p = *buf;
4226
4227         if (*p != '[')
4228                 return;
4229
4230         p++;
4231         p += strspn(p, "0123456789");
4232
4233         if (*p != ']')
4234                 return;
4235
4236         p++;
4237
4238         *buf = p;
4239 }
4240
4241 void skip_syslog_date(char **buf) {
4242         enum {
4243                 LETTER,
4244                 SPACE,
4245                 NUMBER,
4246                 SPACE_OR_NUMBER,
4247                 COLON
4248         } sequence[] = {
4249                 LETTER, LETTER, LETTER,
4250                 SPACE,
4251                 SPACE_OR_NUMBER, NUMBER,
4252                 SPACE,
4253                 SPACE_OR_NUMBER, NUMBER,
4254                 COLON,
4255                 SPACE_OR_NUMBER, NUMBER,
4256                 COLON,
4257                 SPACE_OR_NUMBER, NUMBER,
4258                 SPACE
4259         };
4260
4261         char *p;
4262         unsigned i;
4263
4264         assert(buf);
4265         assert(*buf);
4266
4267         p = *buf;
4268
4269         for (i = 0; i < ELEMENTSOF(sequence); i++, p++) {
4270
4271                 if (!*p)
4272                         return;
4273
4274                 switch (sequence[i]) {
4275
4276                 case SPACE:
4277                         if (*p != ' ')
4278                                 return;
4279                         break;
4280
4281                 case SPACE_OR_NUMBER:
4282                         if (*p == ' ')
4283                                 break;
4284
4285                         /* fall through */
4286
4287                 case NUMBER:
4288                         if (*p < '0' || *p > '9')
4289                                 return;
4290
4291                         break;
4292
4293                 case LETTER:
4294                         if (!(*p >= 'A' && *p <= 'Z') &&
4295                             !(*p >= 'a' && *p <= 'z'))
4296                                 return;
4297
4298                         break;
4299
4300                 case COLON:
4301                         if (*p != ':')
4302                                 return;
4303                         break;
4304
4305                 }
4306         }
4307
4308         *buf = p;
4309 }
4310
4311 char* strshorten(char *s, size_t l) {
4312         assert(s);
4313
4314         if (l < strlen(s))
4315                 s[l] = 0;
4316
4317         return s;
4318 }
4319
4320 static bool hostname_valid_char(char c) {
4321         return
4322                 (c >= 'a' && c <= 'z') ||
4323                 (c >= 'A' && c <= 'Z') ||
4324                 (c >= '0' && c <= '9') ||
4325                 c == '-' ||
4326                 c == '_' ||
4327                 c == '.';
4328 }
4329
4330 bool hostname_is_valid(const char *s) {
4331         const char *p;
4332
4333         if (isempty(s))
4334                 return false;
4335
4336         for (p = s; *p; p++)
4337                 if (!hostname_valid_char(*p))
4338                         return false;
4339
4340         if (p-s > HOST_NAME_MAX)
4341                 return false;
4342
4343         return true;
4344 }
4345
4346 char* hostname_cleanup(char *s) {
4347         char *p, *d;
4348
4349         for (p = s, d = s; *p; p++)
4350                 if ((*p >= 'a' && *p <= 'z') ||
4351                     (*p >= 'A' && *p <= 'Z') ||
4352                     (*p >= '0' && *p <= '9') ||
4353                     *p == '-' ||
4354                     *p == '_' ||
4355                     *p == '.')
4356                         *(d++) = *p;
4357
4358         *d = 0;
4359
4360         strshorten(s, HOST_NAME_MAX);
4361         return s;
4362 }
4363
4364 int pipe_eof(int fd) {
4365         struct pollfd pollfd;
4366         int r;
4367
4368         zero(pollfd);
4369         pollfd.fd = fd;
4370         pollfd.events = POLLIN|POLLHUP;
4371
4372         r = poll(&pollfd, 1, 0);
4373         if (r < 0)
4374                 return -errno;
4375
4376         if (r == 0)
4377                 return 0;
4378
4379         return pollfd.revents & POLLHUP;
4380 }
4381
4382 int fd_wait_for_event(int fd, int event, usec_t t) {
4383         struct pollfd pollfd;
4384         int r;
4385
4386         zero(pollfd);
4387         pollfd.fd = fd;
4388         pollfd.events = event;
4389
4390         r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
4391         if (r < 0)
4392                 return -errno;
4393
4394         if (r == 0)
4395                 return 0;
4396
4397         return pollfd.revents;
4398 }
4399
4400 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4401         FILE *f;
4402         char *t;
4403         const char *fn;
4404         size_t k;
4405         int fd;
4406
4407         assert(path);
4408         assert(_f);
4409         assert(_temp_path);
4410
4411         t = new(char, strlen(path) + 1 + 6 + 1);
4412         if (!t)
4413                 return -ENOMEM;
4414
4415         fn = path_get_file_name(path);
4416         k = fn-path;
4417         memcpy(t, path, k);
4418         t[k] = '.';
4419         stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
4420
4421         fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
4422         if (fd < 0) {
4423                 free(t);
4424                 return -errno;
4425         }
4426
4427         f = fdopen(fd, "we");
4428         if (!f) {
4429                 unlink(t);
4430                 free(t);
4431                 return -errno;
4432         }
4433
4434         *_f = f;
4435         *_temp_path = t;
4436
4437         return 0;
4438 }
4439
4440 int terminal_vhangup_fd(int fd) {
4441         assert(fd >= 0);
4442
4443         if (ioctl(fd, TIOCVHANGUP) < 0)
4444                 return -errno;
4445
4446         return 0;
4447 }
4448
4449 int terminal_vhangup(const char *name) {
4450         int fd, r;
4451
4452         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4453         if (fd < 0)
4454                 return fd;
4455
4456         r = terminal_vhangup_fd(fd);
4457         close_nointr_nofail(fd);
4458
4459         return r;
4460 }
4461
4462 int vt_disallocate(const char *name) {
4463         int fd, r;
4464         unsigned u;
4465
4466         /* Deallocate the VT if possible. If not possible
4467          * (i.e. because it is the active one), at least clear it
4468          * entirely (including the scrollback buffer) */
4469
4470         if (!startswith(name, "/dev/"))
4471                 return -EINVAL;
4472
4473         if (!tty_is_vc(name)) {
4474                 /* So this is not a VT. I guess we cannot deallocate
4475                  * it then. But let's at least clear the screen */
4476
4477                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4478                 if (fd < 0)
4479                         return fd;
4480
4481                 loop_write(fd,
4482                            "\033[r"    /* clear scrolling region */
4483                            "\033[H"    /* move home */
4484                            "\033[2J",  /* clear screen */
4485                            10, false);
4486                 close_nointr_nofail(fd);
4487
4488                 return 0;
4489         }
4490
4491         if (!startswith(name, "/dev/tty"))
4492                 return -EINVAL;
4493
4494         r = safe_atou(name+8, &u);
4495         if (r < 0)
4496                 return r;
4497
4498         if (u <= 0)
4499                 return -EINVAL;
4500
4501         /* Try to deallocate */
4502         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4503         if (fd < 0)
4504                 return fd;
4505
4506         r = ioctl(fd, VT_DISALLOCATE, u);
4507         close_nointr_nofail(fd);
4508
4509         if (r >= 0)
4510                 return 0;
4511
4512         if (errno != EBUSY)
4513                 return -errno;
4514
4515         /* Couldn't deallocate, so let's clear it fully with
4516          * scrollback */
4517         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4518         if (fd < 0)
4519                 return fd;
4520
4521         loop_write(fd,
4522                    "\033[r"   /* clear scrolling region */
4523                    "\033[H"   /* move home */
4524                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4525                    10, false);
4526         close_nointr_nofail(fd);
4527
4528         return 0;
4529 }
4530
4531 int copy_file(const char *from, const char *to) {
4532         int r, fdf, fdt;
4533
4534         assert(from);
4535         assert(to);
4536
4537         fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4538         if (fdf < 0)
4539                 return -errno;
4540
4541         fdt = open(to, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC|O_NOCTTY, 0644);
4542         if (fdt < 0) {
4543                 close_nointr_nofail(fdf);
4544                 return -errno;
4545         }
4546
4547         for (;;) {
4548                 char buf[PIPE_BUF];
4549                 ssize_t n, k;
4550
4551                 n = read(fdf, buf, sizeof(buf));
4552                 if (n < 0) {
4553                         r = -errno;
4554
4555                         close_nointr_nofail(fdf);
4556                         close_nointr(fdt);
4557                         unlink(to);
4558
4559                         return r;
4560                 }
4561
4562                 if (n == 0)
4563                         break;
4564
4565                 errno = 0;
4566                 k = loop_write(fdt, buf, n, false);
4567                 if (n != k) {
4568                         r = k < 0 ? k : (errno ? -errno : -EIO);
4569
4570                         close_nointr_nofail(fdf);
4571                         close_nointr(fdt);
4572
4573                         unlink(to);
4574                         return r;
4575                 }
4576         }
4577
4578         close_nointr_nofail(fdf);
4579         r = close_nointr(fdt);
4580
4581         if (r < 0) {
4582                 unlink(to);
4583                 return r;
4584         }
4585
4586         return 0;
4587 }
4588
4589 int symlink_or_copy(const char *from, const char *to) {
4590         char *pf = NULL, *pt = NULL;
4591         struct stat a, b;
4592         int r;
4593
4594         assert(from);
4595         assert(to);
4596
4597         if (path_get_parent(from, &pf) < 0 ||
4598             path_get_parent(to, &pt) < 0) {
4599                 r = -ENOMEM;
4600                 goto finish;
4601         }
4602
4603         if (stat(pf, &a) < 0 ||
4604             stat(pt, &b) < 0) {
4605                 r = -errno;
4606                 goto finish;
4607         }
4608
4609         if (a.st_dev != b.st_dev) {
4610                 free(pf);
4611                 free(pt);
4612
4613                 return copy_file(from, to);
4614         }
4615
4616         if (symlink(from, to) < 0) {
4617                 r = -errno;
4618                 goto finish;
4619         }
4620
4621         r = 0;
4622
4623 finish:
4624         free(pf);
4625         free(pt);
4626
4627         return r;
4628 }
4629
4630 int symlink_or_copy_atomic(const char *from, const char *to) {
4631         char *t, *x;
4632         const char *fn;
4633         size_t k;
4634         unsigned long long ull;
4635         unsigned i;
4636         int r;
4637
4638         assert(from);
4639         assert(to);
4640
4641         t = new(char, strlen(to) + 1 + 16 + 1);
4642         if (!t)
4643                 return -ENOMEM;
4644
4645         fn = path_get_file_name(to);
4646         k = fn-to;
4647         memcpy(t, to, k);
4648         t[k] = '.';
4649         x = stpcpy(t+k+1, fn);
4650
4651         ull = random_ull();
4652         for (i = 0; i < 16; i++) {
4653                 *(x++) = hexchar(ull & 0xF);
4654                 ull >>= 4;
4655         }
4656
4657         *x = 0;
4658
4659         r = symlink_or_copy(from, t);
4660         if (r < 0) {
4661                 unlink(t);
4662                 free(t);
4663                 return r;
4664         }
4665
4666         if (rename(t, to) < 0) {
4667                 r = -errno;
4668                 unlink(t);
4669                 free(t);
4670                 return r;
4671         }
4672
4673         free(t);
4674         return r;
4675 }
4676
4677 bool display_is_local(const char *display) {
4678         assert(display);
4679
4680         return
4681                 display[0] == ':' &&
4682                 display[1] >= '0' &&
4683                 display[1] <= '9';
4684 }
4685
4686 int socket_from_display(const char *display, char **path) {
4687         size_t k;
4688         char *f, *c;
4689
4690         assert(display);
4691         assert(path);
4692
4693         if (!display_is_local(display))
4694                 return -EINVAL;
4695
4696         k = strspn(display+1, "0123456789");
4697
4698         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
4699         if (!f)
4700                 return -ENOMEM;
4701
4702         c = stpcpy(f, "/tmp/.X11-unix/X");
4703         memcpy(c, display+1, k);
4704         c[k] = 0;
4705
4706         *path = f;
4707
4708         return 0;
4709 }
4710
4711 int get_user_creds(const char **username, uid_t *uid, gid_t *gid, const char **home) {
4712         struct passwd *p;
4713         uid_t u;
4714
4715         assert(username);
4716         assert(*username);
4717
4718         /* We enforce some special rules for uid=0: in order to avoid
4719          * NSS lookups for root we hardcode its data. */
4720
4721         if (streq(*username, "root") || streq(*username, "0")) {
4722                 *username = "root";
4723
4724                 if (uid)
4725                         *uid = 0;
4726
4727                 if (gid)
4728                         *gid = 0;
4729
4730                 if (home)
4731                         *home = "/root";
4732                 return 0;
4733         }
4734
4735         if (parse_uid(*username, &u) >= 0) {
4736                 errno = 0;
4737                 p = getpwuid(u);
4738
4739                 /* If there are multiple users with the same id, make
4740                  * sure to leave $USER to the configured value instead
4741                  * of the first occurrence in the database. However if
4742                  * the uid was configured by a numeric uid, then let's
4743                  * pick the real username from /etc/passwd. */
4744                 if (p)
4745                         *username = p->pw_name;
4746         } else {
4747                 errno = 0;
4748                 p = getpwnam(*username);
4749         }
4750
4751         if (!p)
4752                 return errno != 0 ? -errno : -ESRCH;
4753
4754         if (uid)
4755                 *uid = p->pw_uid;
4756
4757         if (gid)
4758                 *gid = p->pw_gid;
4759
4760         if (home)
4761                 *home = p->pw_dir;
4762
4763         return 0;
4764 }
4765
4766 int get_group_creds(const char **groupname, gid_t *gid) {
4767         struct group *g;
4768         gid_t id;
4769
4770         assert(groupname);
4771
4772         /* We enforce some special rules for gid=0: in order to avoid
4773          * NSS lookups for root we hardcode its data. */
4774
4775         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4776                 *groupname = "root";
4777
4778                 if (gid)
4779                         *gid = 0;
4780
4781                 return 0;
4782         }
4783
4784         if (parse_gid(*groupname, &id) >= 0) {
4785                 errno = 0;
4786                 g = getgrgid(id);
4787
4788                 if (g)
4789                         *groupname = g->gr_name;
4790         } else {
4791                 errno = 0;
4792                 g = getgrnam(*groupname);
4793         }
4794
4795         if (!g)
4796                 return errno != 0 ? -errno : -ESRCH;
4797
4798         if (gid)
4799                 *gid = g->gr_gid;
4800
4801         return 0;
4802 }
4803
4804 int in_group(const char *name) {
4805         gid_t gid, *gids;
4806         int ngroups_max, r, i;
4807
4808         r = get_group_creds(&name, &gid);
4809         if (r < 0)
4810                 return r;
4811
4812         if (getgid() == gid)
4813                 return 1;
4814
4815         if (getegid() == gid)
4816                 return 1;
4817
4818         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4819         assert(ngroups_max > 0);
4820
4821         gids = alloca(sizeof(gid_t) * ngroups_max);
4822
4823         r = getgroups(ngroups_max, gids);
4824         if (r < 0)
4825                 return -errno;
4826
4827         for (i = 0; i < r; i++)
4828                 if (gids[i] == gid)
4829                         return 1;
4830
4831         return 0;
4832 }
4833
4834 int glob_exists(const char *path) {
4835         glob_t g;
4836         int r, k;
4837
4838         assert(path);
4839
4840         zero(g);
4841         errno = 0;
4842         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4843
4844         if (k == GLOB_NOMATCH)
4845                 r = 0;
4846         else if (k == GLOB_NOSPACE)
4847                 r = -ENOMEM;
4848         else if (k == 0)
4849                 r = !strv_isempty(g.gl_pathv);
4850         else
4851                 r = errno ? -errno : -EIO;
4852
4853         globfree(&g);
4854
4855         return r;
4856 }
4857
4858 int dirent_ensure_type(DIR *d, struct dirent *de) {
4859         struct stat st;
4860
4861         assert(d);
4862         assert(de);
4863
4864         if (de->d_type != DT_UNKNOWN)
4865                 return 0;
4866
4867         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4868                 return -errno;
4869
4870         de->d_type =
4871                 S_ISREG(st.st_mode)  ? DT_REG  :
4872                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4873                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4874                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4875                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4876                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4877                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4878                                        DT_UNKNOWN;
4879
4880         return 0;
4881 }
4882
4883 int in_search_path(const char *path, char **search) {
4884         char **i, *parent;
4885         int r;
4886
4887         r = path_get_parent(path, &parent);
4888         if (r < 0)
4889                 return r;
4890
4891         r = 0;
4892
4893         STRV_FOREACH(i, search) {
4894                 if (path_equal(parent, *i)) {
4895                         r = 1;
4896                         break;
4897                 }
4898         }
4899
4900         free(parent);
4901
4902         return r;
4903 }
4904
4905 int get_files_in_directory(const char *path, char ***list) {
4906         DIR *d;
4907         int r = 0;
4908         unsigned n = 0;
4909         char **l = NULL;
4910
4911         assert(path);
4912
4913         /* Returns all files in a directory in *list, and the number
4914          * of files as return value. If list is NULL returns only the
4915          * number */
4916
4917         d = opendir(path);
4918         if (!d)
4919                 return -errno;
4920
4921         for (;;) {
4922                 struct dirent buffer, *de;
4923                 int k;
4924
4925                 k = readdir_r(d, &buffer, &de);
4926                 if (k != 0) {
4927                         r = -k;
4928                         goto finish;
4929                 }
4930
4931                 if (!de)
4932                         break;
4933
4934                 dirent_ensure_type(d, de);
4935
4936                 if (!dirent_is_file(de))
4937                         continue;
4938
4939                 if (list) {
4940                         if ((unsigned) r >= n) {
4941                                 char **t;
4942
4943                                 n = MAX(16, 2*r);
4944                                 t = realloc(l, sizeof(char*) * n);
4945                                 if (!t) {
4946                                         r = -ENOMEM;
4947                                         goto finish;
4948                                 }
4949
4950                                 l = t;
4951                         }
4952
4953                         assert((unsigned) r < n);
4954
4955                         l[r] = strdup(de->d_name);
4956                         if (!l[r]) {
4957                                 r = -ENOMEM;
4958                                 goto finish;
4959                         }
4960
4961                         l[++r] = NULL;
4962                 } else
4963                         r++;
4964         }
4965
4966 finish:
4967         if (d)
4968                 closedir(d);
4969
4970         if (r >= 0) {
4971                 if (list)
4972                         *list = l;
4973         } else
4974                 strv_free(l);
4975
4976         return r;
4977 }
4978
4979 char *join(const char *x, ...) {
4980         va_list ap;
4981         size_t l;
4982         char *r, *p;
4983
4984         va_start(ap, x);
4985
4986         if (x) {
4987                 l = strlen(x);
4988
4989                 for (;;) {
4990                         const char *t;
4991
4992                         t = va_arg(ap, const char *);
4993                         if (!t)
4994                                 break;
4995
4996                         l += strlen(t);
4997                 }
4998         } else
4999                 l = 0;
5000
5001         va_end(ap);
5002
5003         r = new(char, l+1);
5004         if (!r)
5005                 return NULL;
5006
5007         if (x) {
5008                 p = stpcpy(r, x);
5009
5010                 va_start(ap, x);
5011
5012                 for (;;) {
5013                         const char *t;
5014
5015                         t = va_arg(ap, const char *);
5016                         if (!t)
5017                                 break;
5018
5019                         p = stpcpy(p, t);
5020                 }
5021
5022                 va_end(ap);
5023         } else
5024                 r[0] = 0;
5025
5026         return r;
5027 }
5028
5029 bool is_main_thread(void) {
5030         static __thread int cached = 0;
5031
5032         if (_unlikely_(cached == 0))
5033                 cached = getpid() == gettid() ? 1 : -1;
5034
5035         return cached > 0;
5036 }
5037
5038 int block_get_whole_disk(dev_t d, dev_t *ret) {
5039         char *p, *s;
5040         int r;
5041         unsigned n, m;
5042
5043         assert(ret);
5044
5045         /* If it has a queue this is good enough for us */
5046         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
5047                 return -ENOMEM;
5048
5049         r = access(p, F_OK);
5050         free(p);
5051
5052         if (r >= 0) {
5053                 *ret = d;
5054                 return 0;
5055         }
5056
5057         /* If it is a partition find the originating device */
5058         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
5059                 return -ENOMEM;
5060
5061         r = access(p, F_OK);
5062         free(p);
5063
5064         if (r < 0)
5065                 return -ENOENT;
5066
5067         /* Get parent dev_t */
5068         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
5069                 return -ENOMEM;
5070
5071         r = read_one_line_file(p, &s);
5072         free(p);
5073
5074         if (r < 0)
5075                 return r;
5076
5077         r = sscanf(s, "%u:%u", &m, &n);
5078         free(s);
5079
5080         if (r != 2)
5081                 return -EINVAL;
5082
5083         /* Only return this if it is really good enough for us. */
5084         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
5085                 return -ENOMEM;
5086
5087         r = access(p, F_OK);
5088         free(p);
5089
5090         if (r >= 0) {
5091                 *ret = makedev(m, n);
5092                 return 0;
5093         }
5094
5095         return -ENOENT;
5096 }
5097
5098 int file_is_priv_sticky(const char *p) {
5099         struct stat st;
5100
5101         assert(p);
5102
5103         if (lstat(p, &st) < 0)
5104                 return -errno;
5105
5106         return
5107                 (st.st_uid == 0 || st.st_uid == getuid()) &&
5108                 (st.st_mode & S_ISVTX);
5109 }
5110
5111 static const char *const ioprio_class_table[] = {
5112         [IOPRIO_CLASS_NONE] = "none",
5113         [IOPRIO_CLASS_RT] = "realtime",
5114         [IOPRIO_CLASS_BE] = "best-effort",
5115         [IOPRIO_CLASS_IDLE] = "idle"
5116 };
5117
5118 DEFINE_STRING_TABLE_LOOKUP(ioprio_class, int);
5119
5120 static const char *const sigchld_code_table[] = {
5121         [CLD_EXITED] = "exited",
5122         [CLD_KILLED] = "killed",
5123         [CLD_DUMPED] = "dumped",
5124         [CLD_TRAPPED] = "trapped",
5125         [CLD_STOPPED] = "stopped",
5126         [CLD_CONTINUED] = "continued",
5127 };
5128
5129 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
5130
5131 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
5132         [LOG_FAC(LOG_KERN)] = "kern",
5133         [LOG_FAC(LOG_USER)] = "user",
5134         [LOG_FAC(LOG_MAIL)] = "mail",
5135         [LOG_FAC(LOG_DAEMON)] = "daemon",
5136         [LOG_FAC(LOG_AUTH)] = "auth",
5137         [LOG_FAC(LOG_SYSLOG)] = "syslog",
5138         [LOG_FAC(LOG_LPR)] = "lpr",
5139         [LOG_FAC(LOG_NEWS)] = "news",
5140         [LOG_FAC(LOG_UUCP)] = "uucp",
5141         [LOG_FAC(LOG_CRON)] = "cron",
5142         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5143         [LOG_FAC(LOG_FTP)] = "ftp",
5144         [LOG_FAC(LOG_LOCAL0)] = "local0",
5145         [LOG_FAC(LOG_LOCAL1)] = "local1",
5146         [LOG_FAC(LOG_LOCAL2)] = "local2",
5147         [LOG_FAC(LOG_LOCAL3)] = "local3",
5148         [LOG_FAC(LOG_LOCAL4)] = "local4",
5149         [LOG_FAC(LOG_LOCAL5)] = "local5",
5150         [LOG_FAC(LOG_LOCAL6)] = "local6",
5151         [LOG_FAC(LOG_LOCAL7)] = "local7"
5152 };
5153
5154 DEFINE_STRING_TABLE_LOOKUP(log_facility_unshifted, int);
5155
5156 static const char *const log_level_table[] = {
5157         [LOG_EMERG] = "emerg",
5158         [LOG_ALERT] = "alert",
5159         [LOG_CRIT] = "crit",
5160         [LOG_ERR] = "err",
5161         [LOG_WARNING] = "warning",
5162         [LOG_NOTICE] = "notice",
5163         [LOG_INFO] = "info",
5164         [LOG_DEBUG] = "debug"
5165 };
5166
5167 DEFINE_STRING_TABLE_LOOKUP(log_level, int);
5168
5169 static const char* const sched_policy_table[] = {
5170         [SCHED_OTHER] = "other",
5171         [SCHED_BATCH] = "batch",
5172         [SCHED_IDLE] = "idle",
5173         [SCHED_FIFO] = "fifo",
5174         [SCHED_RR] = "rr"
5175 };
5176
5177 DEFINE_STRING_TABLE_LOOKUP(sched_policy, int);
5178
5179 static const char* const rlimit_table[] = {
5180         [RLIMIT_CPU] = "LimitCPU",
5181         [RLIMIT_FSIZE] = "LimitFSIZE",
5182         [RLIMIT_DATA] = "LimitDATA",
5183         [RLIMIT_STACK] = "LimitSTACK",
5184         [RLIMIT_CORE] = "LimitCORE",
5185         [RLIMIT_RSS] = "LimitRSS",
5186         [RLIMIT_NOFILE] = "LimitNOFILE",
5187         [RLIMIT_AS] = "LimitAS",
5188         [RLIMIT_NPROC] = "LimitNPROC",
5189         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5190         [RLIMIT_LOCKS] = "LimitLOCKS",
5191         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5192         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5193         [RLIMIT_NICE] = "LimitNICE",
5194         [RLIMIT_RTPRIO] = "LimitRTPRIO",
5195         [RLIMIT_RTTIME] = "LimitRTTIME"
5196 };
5197
5198 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5199
5200 static const char* const ip_tos_table[] = {
5201         [IPTOS_LOWDELAY] = "low-delay",
5202         [IPTOS_THROUGHPUT] = "throughput",
5203         [IPTOS_RELIABILITY] = "reliability",
5204         [IPTOS_LOWCOST] = "low-cost",
5205 };
5206
5207 DEFINE_STRING_TABLE_LOOKUP(ip_tos, int);
5208
5209 static const char *const __signal_table[] = {
5210         [SIGHUP] = "HUP",
5211         [SIGINT] = "INT",
5212         [SIGQUIT] = "QUIT",
5213         [SIGILL] = "ILL",
5214         [SIGTRAP] = "TRAP",
5215         [SIGABRT] = "ABRT",
5216         [SIGBUS] = "BUS",
5217         [SIGFPE] = "FPE",
5218         [SIGKILL] = "KILL",
5219         [SIGUSR1] = "USR1",
5220         [SIGSEGV] = "SEGV",
5221         [SIGUSR2] = "USR2",
5222         [SIGPIPE] = "PIPE",
5223         [SIGALRM] = "ALRM",
5224         [SIGTERM] = "TERM",
5225 #ifdef SIGSTKFLT
5226         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
5227 #endif
5228         [SIGCHLD] = "CHLD",
5229         [SIGCONT] = "CONT",
5230         [SIGSTOP] = "STOP",
5231         [SIGTSTP] = "TSTP",
5232         [SIGTTIN] = "TTIN",
5233         [SIGTTOU] = "TTOU",
5234         [SIGURG] = "URG",
5235         [SIGXCPU] = "XCPU",
5236         [SIGXFSZ] = "XFSZ",
5237         [SIGVTALRM] = "VTALRM",
5238         [SIGPROF] = "PROF",
5239         [SIGWINCH] = "WINCH",
5240         [SIGIO] = "IO",
5241         [SIGPWR] = "PWR",
5242         [SIGSYS] = "SYS"
5243 };
5244
5245 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5246
5247 const char *signal_to_string(int signo) {
5248         static __thread char buf[12];
5249         const char *name;
5250
5251         name = __signal_to_string(signo);
5252         if (name)
5253                 return name;
5254
5255         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5256                 snprintf(buf, sizeof(buf) - 1, "RTMIN+%d", signo - SIGRTMIN);
5257         else
5258                 snprintf(buf, sizeof(buf) - 1, "%d", signo);
5259         char_array_0(buf);
5260         return buf;
5261 }
5262
5263 int signal_from_string(const char *s) {
5264         int signo;
5265         int offset = 0;
5266         unsigned u;
5267
5268         signo =__signal_from_string(s);
5269         if (signo > 0)
5270                 return signo;
5271
5272         if (startswith(s, "RTMIN+")) {
5273                 s += 6;
5274                 offset = SIGRTMIN;
5275         }
5276         if (safe_atou(s, &u) >= 0) {
5277                 signo = (int) u + offset;
5278                 if (signo > 0 && signo < _NSIG)
5279                         return signo;
5280         }
5281         return -1;
5282 }
5283
5284 bool kexec_loaded(void) {
5285        bool loaded = false;
5286        char *s;
5287
5288        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5289                if (s[0] == '1')
5290                        loaded = true;
5291                free(s);
5292        }
5293        return loaded;
5294 }
5295
5296 int strdup_or_null(const char *a, char **b) {
5297         char *c;
5298
5299         assert(b);
5300
5301         if (!a) {
5302                 *b = NULL;
5303                 return 0;
5304         }
5305
5306         c = strdup(a);
5307         if (!c)
5308                 return -ENOMEM;
5309
5310         *b = c;
5311         return 0;
5312 }
5313
5314 int prot_from_flags(int flags) {
5315
5316         switch (flags & O_ACCMODE) {
5317
5318         case O_RDONLY:
5319                 return PROT_READ;
5320
5321         case O_WRONLY:
5322                 return PROT_WRITE;
5323
5324         case O_RDWR:
5325                 return PROT_READ|PROT_WRITE;
5326
5327         default:
5328                 return -EINVAL;
5329         }
5330 }
5331
5332 char *format_bytes(char *buf, size_t l, off_t t) {
5333         unsigned i;
5334
5335         static const struct {
5336                 const char *suffix;
5337                 off_t factor;
5338         } table[] = {
5339                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5340                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5341                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5342                 { "G", 1024ULL*1024ULL*1024ULL },
5343                 { "M", 1024ULL*1024ULL },
5344                 { "K", 1024ULL },
5345         };
5346
5347         for (i = 0; i < ELEMENTSOF(table); i++) {
5348
5349                 if (t >= table[i].factor) {
5350                         snprintf(buf, l,
5351                                  "%llu.%llu%s",
5352                                  (unsigned long long) (t / table[i].factor),
5353                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5354                                  table[i].suffix);
5355
5356                         goto finish;
5357                 }
5358         }
5359
5360         snprintf(buf, l, "%lluB", (unsigned long long) t);
5361
5362 finish:
5363         buf[l-1] = 0;
5364         return buf;
5365
5366 }
5367
5368 void* memdup(const void *p, size_t l) {
5369         void *r;
5370
5371         assert(p);
5372
5373         r = malloc(l);
5374         if (!r)
5375                 return NULL;
5376
5377         memcpy(r, p, l);
5378         return r;
5379 }
5380
5381 int fd_inc_sndbuf(int fd, size_t n) {
5382         int r, value;
5383         socklen_t l = sizeof(value);
5384
5385         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5386         if (r >= 0 &&
5387             l == sizeof(value) &&
5388             (size_t) value >= n*2)
5389                 return 0;
5390
5391         value = (int) n;
5392         r = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value));
5393         if (r < 0)
5394                 return -errno;
5395
5396         return 1;
5397 }
5398
5399 int fd_inc_rcvbuf(int fd, size_t n) {
5400         int r, value;
5401         socklen_t l = sizeof(value);
5402
5403         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5404         if (r >= 0 &&
5405             l == sizeof(value) &&
5406             (size_t) value >= n*2)
5407                 return 0;
5408
5409         value = (int) n;
5410         r = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
5411         if (r < 0)
5412                 return -errno;
5413
5414         return 1;
5415 }
5416
5417 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5418         pid_t parent_pid, agent_pid;
5419         int fd;
5420         bool stdout_is_tty, stderr_is_tty;
5421         unsigned n, i;
5422         va_list ap;
5423         char **l;
5424
5425         assert(pid);
5426         assert(path);
5427
5428         parent_pid = getpid();
5429
5430         /* Spawns a temporary TTY agent, making sure it goes away when
5431          * we go away */
5432
5433         agent_pid = fork();
5434         if (agent_pid < 0)
5435                 return -errno;
5436
5437         if (agent_pid != 0) {
5438                 *pid = agent_pid;
5439                 return 0;
5440         }
5441
5442         /* In the child:
5443          *
5444          * Make sure the agent goes away when the parent dies */
5445         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5446                 _exit(EXIT_FAILURE);
5447
5448         /* Check whether our parent died before we were able
5449          * to set the death signal */
5450         if (getppid() != parent_pid)
5451                 _exit(EXIT_SUCCESS);
5452
5453         /* Don't leak fds to the agent */
5454         close_all_fds(except, n_except);
5455
5456         stdout_is_tty = isatty(STDOUT_FILENO);
5457         stderr_is_tty = isatty(STDERR_FILENO);
5458
5459         if (!stdout_is_tty || !stderr_is_tty) {
5460                 /* Detach from stdout/stderr. and reopen
5461                  * /dev/tty for them. This is important to
5462                  * ensure that when systemctl is started via
5463                  * popen() or a similar call that expects to
5464                  * read EOF we actually do generate EOF and
5465                  * not delay this indefinitely by because we
5466                  * keep an unused copy of stdin around. */
5467                 fd = open("/dev/tty", O_WRONLY);
5468                 if (fd < 0) {
5469                         log_error("Failed to open /dev/tty: %m");
5470                         _exit(EXIT_FAILURE);
5471                 }
5472
5473                 if (!stdout_is_tty)
5474                         dup2(fd, STDOUT_FILENO);
5475
5476                 if (!stderr_is_tty)
5477                         dup2(fd, STDERR_FILENO);
5478
5479                 if (fd > 2)
5480                         close(fd);
5481         }
5482
5483         /* Count arguments */
5484         va_start(ap, path);
5485         for (n = 0; va_arg(ap, char*); n++)
5486                 ;
5487         va_end(ap);
5488
5489         /* Allocate strv */
5490         l = alloca(sizeof(char *) * (n + 1));
5491
5492         /* Fill in arguments */
5493         va_start(ap, path);
5494         for (i = 0; i <= n; i++)
5495                 l[i] = va_arg(ap, char*);
5496         va_end(ap);
5497
5498         execv(path, l);
5499         _exit(EXIT_FAILURE);
5500 }
5501
5502 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5503         struct rlimit highest, fixed;
5504
5505         assert(rlim);
5506
5507         if (setrlimit(resource, rlim) >= 0)
5508                 return 0;
5509
5510         if (errno != EPERM)
5511                 return -errno;
5512
5513         /* So we failed to set the desired setrlimit, then let's try
5514          * to get as close as we can */
5515         assert_se(getrlimit(resource, &highest) == 0);
5516
5517         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5518         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5519
5520         if (setrlimit(resource, &fixed) < 0)
5521                 return -errno;
5522
5523         return 0;
5524 }
5525
5526 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5527         char path[sizeof("/proc/")-1+10+sizeof("/environ")], *value = NULL;
5528         int r;
5529         FILE *f;
5530         bool done = false;
5531         size_t l;
5532
5533         assert(field);
5534         assert(_value);
5535
5536         if (pid == 0)
5537                 pid = getpid();
5538
5539         snprintf(path, sizeof(path), "/proc/%lu/environ", (unsigned long) pid);
5540         char_array_0(path);
5541
5542         f = fopen(path, "re");
5543         if (!f)
5544                 return -errno;
5545
5546         l = strlen(field);
5547         r = 0;
5548
5549         do {
5550                 char line[LINE_MAX];
5551                 unsigned i;
5552
5553                 for (i = 0; i < sizeof(line)-1; i++) {
5554                         int c;
5555
5556                         c = getc(f);
5557                         if (_unlikely_(c == EOF)) {
5558                                 done = true;
5559                                 break;
5560                         } else if (c == 0)
5561                                 break;
5562
5563                         line[i] = c;
5564                 }
5565                 line[i] = 0;
5566
5567                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5568                         value = strdup(line + l + 1);
5569                         if (!value) {
5570                                 r = -ENOMEM;
5571                                 break;
5572                         }
5573
5574                         r = 1;
5575                         break;
5576                 }
5577
5578         } while (!done);
5579
5580         fclose(f);
5581
5582         if (r >= 0)
5583                 *_value = value;
5584
5585         return r;
5586 }
5587
5588 int can_sleep(const char *type) {
5589         char *p, *w, *state;
5590         size_t l, k;
5591         bool found = false;
5592         int r;
5593
5594         assert(type);
5595
5596         r = read_one_line_file("/sys/power/state", &p);
5597         if (r < 0)
5598                 return r == -ENOENT ? 0 : r;
5599
5600         k = strlen(type);
5601
5602         FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state) {
5603                 if (l == k && strncmp(w, type, l) == 0) {
5604                         found = true;
5605                         break;
5606                 }
5607         }
5608
5609         free(p);
5610         return found;
5611 }