src/shared/util.c

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