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         if (startswith(p, "LABEL="))
4101                 return tag_to_udev_node(p+6, "label");
4102
4103         if (startswith(p, "UUID="))
4104                 return tag_to_udev_node(p+5, "uuid");
4105
4106         if (startswith(p, "PARTUUID="))
4107                 return tag_to_udev_node(p+9, "partuuid");
4108
4109         if (startswith(p, "PARTLABEL="))
4110                 return tag_to_udev_node(p+10, "partlabel");
4111
4112         return strdup(p);
4113 }
4114
4115 bool tty_is_vc(const char *tty) {
4116         assert(tty);
4117
4118         if (startswith(tty, "/dev/"))
4119                 tty += 5;
4120
4121         return vtnr_from_tty(tty) >= 0;
4122 }
4123
4124 bool tty_is_console(const char *tty) {
4125         assert(tty);
4126
4127         if (startswith(tty, "/dev/"))
4128                 tty += 5;
4129
4130         return streq(tty, "console");
4131 }
4132
4133 int vtnr_from_tty(const char *tty) {
4134         int i, r;
4135
4136         assert(tty);
4137
4138         if (startswith(tty, "/dev/"))
4139                 tty += 5;
4140
4141         if (!startswith(tty, "tty") )
4142                 return -EINVAL;
4143
4144         if (tty[3] < '0' || tty[3] > '9')
4145                 return -EINVAL;
4146
4147         r = safe_atoi(tty+3, &i);
4148         if (r < 0)
4149                 return r;
4150
4151         if (i < 0 || i > 63)
4152                 return -EINVAL;
4153
4154         return i;
4155 }
4156
4157 bool tty_is_vc_resolve(const char *tty) {
4158         char *active = NULL;
4159         bool b;
4160
4161         assert(tty);
4162
4163         if (startswith(tty, "/dev/"))
4164                 tty += 5;
4165
4166         /* Resolve where /dev/console is pointing to, if /sys is
4167          * actually ours (i.e. not read-only-mounted which is a sign
4168          * for container setups) */
4169         if (streq(tty, "console") && path_is_read_only_fs("/sys") <= 0)
4170                 if (read_one_line_file("/sys/class/tty/console/active", &active) >= 0) {
4171                         /* If multiple log outputs are configured the
4172                          * last one is what /dev/console points to */
4173                         tty = strrchr(active, ' ');
4174                         if (tty)
4175                                 tty++;
4176                         else
4177                                 tty = active;
4178                 }
4179
4180         b = tty_is_vc(tty);
4181         free(active);
4182
4183         return b;
4184 }
4185
4186 const char *default_term_for_tty(const char *tty) {
4187         assert(tty);
4188
4189         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
4190 }
4191
4192 bool dirent_is_file(const struct dirent *de) {
4193         assert(de);
4194
4195         if (ignore_file(de->d_name))
4196                 return false;
4197
4198         if (de->d_type != DT_REG &&
4199             de->d_type != DT_LNK &&
4200             de->d_type != DT_UNKNOWN)
4201                 return false;
4202
4203         return true;
4204 }
4205
4206 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4207         assert(de);
4208
4209         if (de->d_type != DT_REG &&
4210             de->d_type != DT_LNK &&
4211             de->d_type != DT_UNKNOWN)
4212                 return false;
4213
4214         if (ignore_file_allow_backup(de->d_name))
4215                 return false;
4216
4217         return endswith(de->d_name, suffix);
4218 }
4219
4220 void execute_directory(const char *directory, DIR *d, char *argv[]) {
4221         DIR *_d = NULL;
4222         struct dirent *de;
4223         Hashmap *pids = NULL;
4224
4225         assert(directory);
4226
4227         /* Executes all binaries in a directory in parallel and waits
4228          * until all they all finished. */
4229
4230         if (!d) {
4231                 if (!(_d = opendir(directory))) {
4232
4233                         if (errno == ENOENT)
4234                                 return;
4235
4236                         log_error("Failed to enumerate directory %s: %m", directory);
4237                         return;
4238                 }
4239
4240                 d = _d;
4241         }
4242
4243         if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
4244                 log_error("Failed to allocate set.");
4245                 goto finish;
4246         }
4247
4248         while ((de = readdir(d))) {
4249                 char *path;
4250                 pid_t pid;
4251                 int k;
4252
4253                 if (!dirent_is_file(de))
4254                         continue;
4255
4256                 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
4257                         log_oom();
4258                         continue;
4259                 }
4260
4261                 if ((pid = fork()) < 0) {
4262                         log_error("Failed to fork: %m");
4263                         free(path);
4264                         continue;
4265                 }
4266
4267                 if (pid == 0) {
4268                         char *_argv[2];
4269                         /* Child */
4270
4271                         if (!argv) {
4272                                 _argv[0] = path;
4273                                 _argv[1] = NULL;
4274                                 argv = _argv;
4275                         } else
4276                                 argv[0] = path;
4277
4278                         execv(path, argv);
4279
4280                         log_error("Failed to execute %s: %m", path);
4281                         _exit(EXIT_FAILURE);
4282                 }
4283
4284                 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
4285
4286                 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
4287                         log_error("Failed to add PID to set: %s", strerror(-k));
4288                         free(path);
4289                 }
4290         }
4291
4292         while (!hashmap_isempty(pids)) {
4293                 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
4294                 siginfo_t si;
4295                 char *path;
4296
4297                 zero(si);
4298                 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
4299
4300                         if (errno == EINTR)
4301                                 continue;
4302
4303                         log_error("waitid() failed: %m");
4304                         goto finish;
4305                 }
4306
4307                 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
4308                         if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
4309                                 if (si.si_code == CLD_EXITED)
4310                                         log_error("%s exited with exit status %i.", path, si.si_status);
4311                                 else
4312                                         log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
4313                         } else
4314                                 log_debug("%s exited successfully.", path);
4315
4316                         free(path);
4317                 }
4318         }
4319
4320 finish:
4321         if (_d)
4322                 closedir(_d);
4323
4324         if (pids)
4325                 hashmap_free_free(pids);
4326 }
4327
4328 int kill_and_sigcont(pid_t pid, int sig) {
4329         int r;
4330
4331         r = kill(pid, sig) < 0 ? -errno : 0;
4332
4333         if (r >= 0)
4334                 kill(pid, SIGCONT);
4335
4336         return r;
4337 }
4338
4339 bool nulstr_contains(const char*nulstr, const char *needle) {
4340         const char *i;
4341
4342         if (!nulstr)
4343                 return false;
4344
4345         NULSTR_FOREACH(i, nulstr)
4346                 if (streq(i, needle))
4347                         return true;
4348
4349         return false;
4350 }
4351
4352 bool plymouth_running(void) {
4353         return access("/run/plymouth/pid", F_OK) >= 0;
4354 }
4355
4356 char* strshorten(char *s, size_t l) {
4357         assert(s);
4358
4359         if (l < strlen(s))
4360                 s[l] = 0;
4361
4362         return s;
4363 }
4364
4365 static bool hostname_valid_char(char c) {
4366         return
4367                 (c >= 'a' && c <= 'z') ||
4368                 (c >= 'A' && c <= 'Z') ||
4369                 (c >= '0' && c <= '9') ||
4370                 c == '-' ||
4371                 c == '_' ||
4372                 c == '.';
4373 }
4374
4375 bool hostname_is_valid(const char *s) {
4376         const char *p;
4377
4378         if (isempty(s))
4379                 return false;
4380
4381         for (p = s; *p; p++)
4382                 if (!hostname_valid_char(*p))
4383                         return false;
4384
4385         if (p-s > HOST_NAME_MAX)
4386                 return false;
4387
4388         return true;
4389 }
4390
4391 char* hostname_cleanup(char *s) {
4392         char *p, *d;
4393
4394         for (p = s, d = s; *p; p++)
4395                 if ((*p >= 'a' && *p <= 'z') ||
4396                     (*p >= 'A' && *p <= 'Z') ||
4397                     (*p >= '0' && *p <= '9') ||
4398                     *p == '-' ||
4399                     *p == '_' ||
4400                     *p == '.')
4401                         *(d++) = *p;
4402
4403         *d = 0;
4404
4405         strshorten(s, HOST_NAME_MAX);
4406         return s;
4407 }
4408
4409 int pipe_eof(int fd) {
4410         struct pollfd pollfd;
4411         int r;
4412
4413         zero(pollfd);
4414         pollfd.fd = fd;
4415         pollfd.events = POLLIN|POLLHUP;
4416
4417         r = poll(&pollfd, 1, 0);
4418         if (r < 0)
4419                 return -errno;
4420
4421         if (r == 0)
4422                 return 0;
4423
4424         return pollfd.revents & POLLHUP;
4425 }
4426
4427 int fd_wait_for_event(int fd, int event, usec_t t) {
4428         struct pollfd pollfd;
4429         int r;
4430
4431         zero(pollfd);
4432         pollfd.fd = fd;
4433         pollfd.events = event;
4434
4435         r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
4436         if (r < 0)
4437                 return -errno;
4438
4439         if (r == 0)
4440                 return 0;
4441
4442         return pollfd.revents;
4443 }
4444
4445 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4446         FILE *f;
4447         char *t;
4448         const char *fn;
4449         size_t k;
4450         int fd;
4451
4452         assert(path);
4453         assert(_f);
4454         assert(_temp_path);
4455
4456         t = new(char, strlen(path) + 1 + 6 + 1);
4457         if (!t)
4458                 return -ENOMEM;
4459
4460         fn = path_get_file_name(path);
4461         k = fn-path;
4462         memcpy(t, path, k);
4463         t[k] = '.';
4464         stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
4465
4466         fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
4467         if (fd < 0) {
4468                 free(t);
4469                 return -errno;
4470         }
4471
4472         f = fdopen(fd, "we");
4473         if (!f) {
4474                 unlink(t);
4475                 free(t);
4476                 return -errno;
4477         }
4478
4479         *_f = f;
4480         *_temp_path = t;
4481
4482         return 0;
4483 }
4484
4485 int terminal_vhangup_fd(int fd) {
4486         assert(fd >= 0);
4487
4488         if (ioctl(fd, TIOCVHANGUP) < 0)
4489                 return -errno;
4490
4491         return 0;
4492 }
4493
4494 int terminal_vhangup(const char *name) {
4495         int fd, r;
4496
4497         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4498         if (fd < 0)
4499                 return fd;
4500
4501         r = terminal_vhangup_fd(fd);
4502         close_nointr_nofail(fd);
4503
4504         return r;
4505 }
4506
4507 int vt_disallocate(const char *name) {
4508         int fd, r;
4509         unsigned u;
4510
4511         /* Deallocate the VT if possible. If not possible
4512          * (i.e. because it is the active one), at least clear it
4513          * entirely (including the scrollback buffer) */
4514
4515         if (!startswith(name, "/dev/"))
4516                 return -EINVAL;
4517
4518         if (!tty_is_vc(name)) {
4519                 /* So this is not a VT. I guess we cannot deallocate
4520                  * it then. But let's at least clear the screen */
4521
4522                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4523                 if (fd < 0)
4524                         return fd;
4525
4526                 loop_write(fd,
4527                            "\033[r"    /* clear scrolling region */
4528                            "\033[H"    /* move home */
4529                            "\033[2J",  /* clear screen */
4530                            10, false);
4531                 close_nointr_nofail(fd);
4532
4533                 return 0;
4534         }
4535
4536         if (!startswith(name, "/dev/tty"))
4537                 return -EINVAL;
4538
4539         r = safe_atou(name+8, &u);
4540         if (r < 0)
4541                 return r;
4542
4543         if (u <= 0)
4544                 return -EINVAL;
4545
4546         /* Try to deallocate */
4547         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4548         if (fd < 0)
4549                 return fd;
4550
4551         r = ioctl(fd, VT_DISALLOCATE, u);
4552         close_nointr_nofail(fd);
4553
4554         if (r >= 0)
4555                 return 0;
4556
4557         if (errno != EBUSY)
4558                 return -errno;
4559
4560         /* Couldn't deallocate, so let's clear it fully with
4561          * scrollback */
4562         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4563         if (fd < 0)
4564                 return fd;
4565
4566         loop_write(fd,
4567                    "\033[r"   /* clear scrolling region */
4568                    "\033[H"   /* move home */
4569                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4570                    10, false);
4571         close_nointr_nofail(fd);
4572
4573         return 0;
4574 }
4575
4576 int copy_file(const char *from, const char *to) {
4577         int r, fdf, fdt;
4578
4579         assert(from);
4580         assert(to);
4581
4582         fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4583         if (fdf < 0)
4584                 return -errno;
4585
4586         fdt = open(to, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC|O_NOCTTY, 0644);
4587         if (fdt < 0) {
4588                 close_nointr_nofail(fdf);
4589                 return -errno;
4590         }
4591
4592         for (;;) {
4593                 char buf[PIPE_BUF];
4594                 ssize_t n, k;
4595
4596                 n = read(fdf, buf, sizeof(buf));
4597                 if (n < 0) {
4598                         r = -errno;
4599
4600                         close_nointr_nofail(fdf);
4601                         close_nointr(fdt);
4602                         unlink(to);
4603
4604                         return r;
4605                 }
4606
4607                 if (n == 0)
4608                         break;
4609
4610                 errno = 0;
4611                 k = loop_write(fdt, buf, n, false);
4612                 if (n != k) {
4613                         r = k < 0 ? k : (errno ? -errno : -EIO);
4614
4615                         close_nointr_nofail(fdf);
4616                         close_nointr(fdt);
4617
4618                         unlink(to);
4619                         return r;
4620                 }
4621         }
4622
4623         close_nointr_nofail(fdf);
4624         r = close_nointr(fdt);
4625
4626         if (r < 0) {
4627                 unlink(to);
4628                 return r;
4629         }
4630
4631         return 0;
4632 }
4633
4634 int symlink_atomic(const char *from, const char *to) {
4635         char *x;
4636         _cleanup_free_ char *t;
4637         const char *fn;
4638         size_t k;
4639         unsigned long long ull;
4640         unsigned i;
4641         int r;
4642
4643         assert(from);
4644         assert(to);
4645
4646         t = new(char, strlen(to) + 1 + 16 + 1);
4647         if (!t)
4648                 return -ENOMEM;
4649
4650         fn = path_get_file_name(to);
4651         k = fn-to;
4652         memcpy(t, to, k);
4653         t[k] = '.';
4654         x = stpcpy(t+k+1, fn);
4655
4656         ull = random_ull();
4657         for (i = 0; i < 16; i++) {
4658                 *(x++) = hexchar(ull & 0xF);
4659                 ull >>= 4;
4660         }
4661
4662         *x = 0;
4663
4664         if (symlink(from, t) < 0)
4665                 return -errno;
4666
4667         if (rename(t, to) < 0) {
4668                 r = -errno;
4669                 unlink(t);
4670                 return r;
4671         }
4672
4673         return 0;
4674 }
4675
4676 bool display_is_local(const char *display) {
4677         assert(display);
4678
4679         return
4680                 display[0] == ':' &&
4681                 display[1] >= '0' &&
4682                 display[1] <= '9';
4683 }
4684
4685 int socket_from_display(const char *display, char **path) {
4686         size_t k;
4687         char *f, *c;
4688
4689         assert(display);
4690         assert(path);
4691
4692         if (!display_is_local(display))
4693                 return -EINVAL;
4694
4695         k = strspn(display+1, "0123456789");
4696
4697         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
4698         if (!f)
4699                 return -ENOMEM;
4700
4701         c = stpcpy(f, "/tmp/.X11-unix/X");
4702         memcpy(c, display+1, k);
4703         c[k] = 0;
4704
4705         *path = f;
4706
4707         return 0;
4708 }
4709
4710 int get_user_creds(
4711                 const char **username,
4712                 uid_t *uid, gid_t *gid,
4713                 const char **home,
4714                 const char **shell) {
4715
4716         struct passwd *p;
4717         uid_t u;
4718
4719         assert(username);
4720         assert(*username);
4721
4722         /* We enforce some special rules for uid=0: in order to avoid
4723          * NSS lookups for root we hardcode its data. */
4724
4725         if (streq(*username, "root") || streq(*username, "0")) {
4726                 *username = "root";
4727
4728                 if (uid)
4729                         *uid = 0;
4730
4731                 if (gid)
4732                         *gid = 0;
4733
4734                 if (home)
4735                         *home = "/root";
4736
4737                 if (shell)
4738                         *shell = "/bin/sh";
4739
4740                 return 0;
4741         }
4742
4743         if (parse_uid(*username, &u) >= 0) {
4744                 errno = 0;
4745                 p = getpwuid(u);
4746
4747                 /* If there are multiple users with the same id, make
4748                  * sure to leave $USER to the configured value instead
4749                  * of the first occurrence in the database. However if
4750                  * the uid was configured by a numeric uid, then let's
4751                  * pick the real username from /etc/passwd. */
4752                 if (p)
4753                         *username = p->pw_name;
4754         } else {
4755                 errno = 0;
4756                 p = getpwnam(*username);
4757         }
4758
4759         if (!p)
4760                 return errno != 0 ? -errno : -ESRCH;
4761
4762         if (uid)
4763                 *uid = p->pw_uid;
4764
4765         if (gid)
4766                 *gid = p->pw_gid;
4767
4768         if (home)
4769                 *home = p->pw_dir;
4770
4771         if (shell)
4772                 *shell = p->pw_shell;
4773
4774         return 0;
4775 }
4776
4777 int get_group_creds(const char **groupname, gid_t *gid) {
4778         struct group *g;
4779         gid_t id;
4780
4781         assert(groupname);
4782
4783         /* We enforce some special rules for gid=0: in order to avoid
4784          * NSS lookups for root we hardcode its data. */
4785
4786         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4787                 *groupname = "root";
4788
4789                 if (gid)
4790                         *gid = 0;
4791
4792                 return 0;
4793         }
4794
4795         if (parse_gid(*groupname, &id) >= 0) {
4796                 errno = 0;
4797                 g = getgrgid(id);
4798
4799                 if (g)
4800                         *groupname = g->gr_name;
4801         } else {
4802                 errno = 0;
4803                 g = getgrnam(*groupname);
4804         }
4805
4806         if (!g)
4807                 return errno != 0 ? -errno : -ESRCH;
4808
4809         if (gid)
4810                 *gid = g->gr_gid;
4811
4812         return 0;
4813 }
4814
4815 int in_group(const char *name) {
4816         gid_t gid, *gids;
4817         int ngroups_max, r, i;
4818
4819         r = get_group_creds(&name, &gid);
4820         if (r < 0)
4821                 return r;
4822
4823         if (getgid() == gid)
4824                 return 1;
4825
4826         if (getegid() == gid)
4827                 return 1;
4828
4829         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4830         assert(ngroups_max > 0);
4831
4832         gids = alloca(sizeof(gid_t) * ngroups_max);
4833
4834         r = getgroups(ngroups_max, gids);
4835         if (r < 0)
4836                 return -errno;
4837
4838         for (i = 0; i < r; i++)
4839                 if (gids[i] == gid)
4840                         return 1;
4841
4842         return 0;
4843 }
4844
4845 int glob_exists(const char *path) {
4846         glob_t g;
4847         int r, k;
4848
4849         assert(path);
4850
4851         zero(g);
4852         errno = 0;
4853         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4854
4855         if (k == GLOB_NOMATCH)
4856                 r = 0;
4857         else if (k == GLOB_NOSPACE)
4858                 r = -ENOMEM;
4859         else if (k == 0)
4860                 r = !strv_isempty(g.gl_pathv);
4861         else
4862                 r = errno ? -errno : -EIO;
4863
4864         globfree(&g);
4865
4866         return r;
4867 }
4868
4869 int dirent_ensure_type(DIR *d, struct dirent *de) {
4870         struct stat st;
4871
4872         assert(d);
4873         assert(de);
4874
4875         if (de->d_type != DT_UNKNOWN)
4876                 return 0;
4877
4878         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4879                 return -errno;
4880
4881         de->d_type =
4882                 S_ISREG(st.st_mode)  ? DT_REG  :
4883                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4884                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4885                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4886                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4887                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4888                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4889                                        DT_UNKNOWN;
4890
4891         return 0;
4892 }
4893
4894 int in_search_path(const char *path, char **search) {
4895         char **i, *parent;
4896         int r;
4897
4898         r = path_get_parent(path, &parent);
4899         if (r < 0)
4900                 return r;
4901
4902         r = 0;
4903
4904         STRV_FOREACH(i, search) {
4905                 if (path_equal(parent, *i)) {
4906                         r = 1;
4907                         break;
4908                 }
4909         }
4910
4911         free(parent);
4912
4913         return r;
4914 }
4915
4916 int get_files_in_directory(const char *path, char ***list) {
4917         DIR *d;
4918         int r = 0;
4919         unsigned n = 0;
4920         char **l = NULL;
4921
4922         assert(path);
4923
4924         /* Returns all files in a directory in *list, and the number
4925          * of files as return value. If list is NULL returns only the
4926          * number */
4927
4928         d = opendir(path);
4929         if (!d)
4930                 return -errno;
4931
4932         for (;;) {
4933                 struct dirent buffer, *de;
4934                 int k;
4935
4936                 k = readdir_r(d, &buffer, &de);
4937                 if (k != 0) {
4938                         r = -k;
4939                         goto finish;
4940                 }
4941
4942                 if (!de)
4943                         break;
4944
4945                 dirent_ensure_type(d, de);
4946
4947                 if (!dirent_is_file(de))
4948                         continue;
4949
4950                 if (list) {
4951                         if ((unsigned) r >= n) {
4952                                 char **t;
4953
4954                                 n = MAX(16, 2*r);
4955                                 t = realloc(l, sizeof(char*) * n);
4956                                 if (!t) {
4957                                         r = -ENOMEM;
4958                                         goto finish;
4959                                 }
4960
4961                                 l = t;
4962                         }
4963
4964                         assert((unsigned) r < n);
4965
4966                         l[r] = strdup(de->d_name);
4967                         if (!l[r]) {
4968                                 r = -ENOMEM;
4969                                 goto finish;
4970                         }
4971
4972                         l[++r] = NULL;
4973                 } else
4974                         r++;
4975         }
4976
4977 finish:
4978         if (d)
4979                 closedir(d);
4980
4981         if (r >= 0) {
4982                 if (list)
4983                         *list = l;
4984         } else
4985                 strv_free(l);
4986
4987         return r;
4988 }
4989
4990 char *strjoin(const char *x, ...) {
4991         va_list ap;
4992         size_t l;
4993         char *r, *p;
4994
4995         va_start(ap, x);
4996
4997         if (x) {
4998                 l = strlen(x);
4999
5000                 for (;;) {
5001                         const char *t;
5002
5003                         t = va_arg(ap, const char *);
5004                         if (!t)
5005                                 break;
5006
5007                         l += strlen(t);
5008                 }
5009         } else
5010                 l = 0;
5011
5012         va_end(ap);
5013
5014         r = new(char, l+1);
5015         if (!r)
5016                 return NULL;
5017
5018         if (x) {
5019                 p = stpcpy(r, x);
5020
5021                 va_start(ap, x);
5022
5023                 for (;;) {
5024                         const char *t;
5025
5026                         t = va_arg(ap, const char *);
5027                         if (!t)
5028                                 break;
5029
5030                         p = stpcpy(p, t);
5031                 }
5032
5033                 va_end(ap);
5034         } else
5035                 r[0] = 0;
5036
5037         return r;
5038 }
5039
5040 bool is_main_thread(void) {
5041         static __thread int cached = 0;
5042
5043         if (_unlikely_(cached == 0))
5044                 cached = getpid() == gettid() ? 1 : -1;
5045
5046         return cached > 0;
5047 }
5048
5049 int block_get_whole_disk(dev_t d, dev_t *ret) {
5050         char *p, *s;
5051         int r;
5052         unsigned n, m;
5053
5054         assert(ret);
5055
5056         /* If it has a queue this is good enough for us */
5057         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
5058                 return -ENOMEM;
5059
5060         r = access(p, F_OK);
5061         free(p);
5062
5063         if (r >= 0) {
5064                 *ret = d;
5065                 return 0;
5066         }
5067
5068         /* If it is a partition find the originating device */
5069         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
5070                 return -ENOMEM;
5071
5072         r = access(p, F_OK);
5073         free(p);
5074
5075         if (r < 0)
5076                 return -ENOENT;
5077
5078         /* Get parent dev_t */
5079         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
5080                 return -ENOMEM;
5081
5082         r = read_one_line_file(p, &s);
5083         free(p);
5084
5085         if (r < 0)
5086                 return r;
5087
5088         r = sscanf(s, "%u:%u", &m, &n);
5089         free(s);
5090
5091         if (r != 2)
5092                 return -EINVAL;
5093
5094         /* Only return this if it is really good enough for us. */
5095         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
5096                 return -ENOMEM;
5097
5098         r = access(p, F_OK);
5099         free(p);
5100
5101         if (r >= 0) {
5102                 *ret = makedev(m, n);
5103                 return 0;
5104         }
5105
5106         return -ENOENT;
5107 }
5108
5109 int file_is_priv_sticky(const char *p) {
5110         struct stat st;
5111
5112         assert(p);
5113
5114         if (lstat(p, &st) < 0)
5115                 return -errno;
5116
5117         return
5118                 (st.st_uid == 0 || st.st_uid == getuid()) &&
5119                 (st.st_mode & S_ISVTX);
5120 }
5121
5122 static const char *const ioprio_class_table[] = {
5123         [IOPRIO_CLASS_NONE] = "none",
5124         [IOPRIO_CLASS_RT] = "realtime",
5125         [IOPRIO_CLASS_BE] = "best-effort",
5126         [IOPRIO_CLASS_IDLE] = "idle"
5127 };
5128
5129 DEFINE_STRING_TABLE_LOOKUP(ioprio_class, int);
5130
5131 static const char *const sigchld_code_table[] = {
5132         [CLD_EXITED] = "exited",
5133         [CLD_KILLED] = "killed",
5134         [CLD_DUMPED] = "dumped",
5135         [CLD_TRAPPED] = "trapped",
5136         [CLD_STOPPED] = "stopped",
5137         [CLD_CONTINUED] = "continued",
5138 };
5139
5140 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
5141
5142 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
5143         [LOG_FAC(LOG_KERN)] = "kern",
5144         [LOG_FAC(LOG_USER)] = "user",
5145         [LOG_FAC(LOG_MAIL)] = "mail",
5146         [LOG_FAC(LOG_DAEMON)] = "daemon",
5147         [LOG_FAC(LOG_AUTH)] = "auth",
5148         [LOG_FAC(LOG_SYSLOG)] = "syslog",
5149         [LOG_FAC(LOG_LPR)] = "lpr",
5150         [LOG_FAC(LOG_NEWS)] = "news",
5151         [LOG_FAC(LOG_UUCP)] = "uucp",
5152         [LOG_FAC(LOG_CRON)] = "cron",
5153         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5154         [LOG_FAC(LOG_FTP)] = "ftp",
5155         [LOG_FAC(LOG_LOCAL0)] = "local0",
5156         [LOG_FAC(LOG_LOCAL1)] = "local1",
5157         [LOG_FAC(LOG_LOCAL2)] = "local2",
5158         [LOG_FAC(LOG_LOCAL3)] = "local3",
5159         [LOG_FAC(LOG_LOCAL4)] = "local4",
5160         [LOG_FAC(LOG_LOCAL5)] = "local5",
5161         [LOG_FAC(LOG_LOCAL6)] = "local6",
5162         [LOG_FAC(LOG_LOCAL7)] = "local7"
5163 };
5164
5165 DEFINE_STRING_TABLE_LOOKUP(log_facility_unshifted, int);
5166
5167 static const char *const log_level_table[] = {
5168         [LOG_EMERG] = "emerg",
5169         [LOG_ALERT] = "alert",
5170         [LOG_CRIT] = "crit",
5171         [LOG_ERR] = "err",
5172         [LOG_WARNING] = "warning",
5173         [LOG_NOTICE] = "notice",
5174         [LOG_INFO] = "info",
5175         [LOG_DEBUG] = "debug"
5176 };
5177
5178 DEFINE_STRING_TABLE_LOOKUP(log_level, int);
5179
5180 static const char* const sched_policy_table[] = {
5181         [SCHED_OTHER] = "other",
5182         [SCHED_BATCH] = "batch",
5183         [SCHED_IDLE] = "idle",
5184         [SCHED_FIFO] = "fifo",
5185         [SCHED_RR] = "rr"
5186 };
5187
5188 DEFINE_STRING_TABLE_LOOKUP(sched_policy, int);
5189
5190 static const char* const rlimit_table[] = {
5191         [RLIMIT_CPU] = "LimitCPU",
5192         [RLIMIT_FSIZE] = "LimitFSIZE",
5193         [RLIMIT_DATA] = "LimitDATA",
5194         [RLIMIT_STACK] = "LimitSTACK",
5195         [RLIMIT_CORE] = "LimitCORE",
5196         [RLIMIT_RSS] = "LimitRSS",
5197         [RLIMIT_NOFILE] = "LimitNOFILE",
5198         [RLIMIT_AS] = "LimitAS",
5199         [RLIMIT_NPROC] = "LimitNPROC",
5200         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5201         [RLIMIT_LOCKS] = "LimitLOCKS",
5202         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5203         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5204         [RLIMIT_NICE] = "LimitNICE",
5205         [RLIMIT_RTPRIO] = "LimitRTPRIO",
5206         [RLIMIT_RTTIME] = "LimitRTTIME"
5207 };
5208
5209 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5210
5211 static const char* const ip_tos_table[] = {
5212         [IPTOS_LOWDELAY] = "low-delay",
5213         [IPTOS_THROUGHPUT] = "throughput",
5214         [IPTOS_RELIABILITY] = "reliability",
5215         [IPTOS_LOWCOST] = "low-cost",
5216 };
5217
5218 DEFINE_STRING_TABLE_LOOKUP(ip_tos, int);
5219
5220 static const char *const __signal_table[] = {
5221         [SIGHUP] = "HUP",
5222         [SIGINT] = "INT",
5223         [SIGQUIT] = "QUIT",
5224         [SIGILL] = "ILL",
5225         [SIGTRAP] = "TRAP",
5226         [SIGABRT] = "ABRT",
5227         [SIGBUS] = "BUS",
5228         [SIGFPE] = "FPE",
5229         [SIGKILL] = "KILL",
5230         [SIGUSR1] = "USR1",
5231         [SIGSEGV] = "SEGV",
5232         [SIGUSR2] = "USR2",
5233         [SIGPIPE] = "PIPE",
5234         [SIGALRM] = "ALRM",
5235         [SIGTERM] = "TERM",
5236 #ifdef SIGSTKFLT
5237         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
5238 #endif
5239         [SIGCHLD] = "CHLD",
5240         [SIGCONT] = "CONT",
5241         [SIGSTOP] = "STOP",
5242         [SIGTSTP] = "TSTP",
5243         [SIGTTIN] = "TTIN",
5244         [SIGTTOU] = "TTOU",
5245         [SIGURG] = "URG",
5246         [SIGXCPU] = "XCPU",
5247         [SIGXFSZ] = "XFSZ",
5248         [SIGVTALRM] = "VTALRM",
5249         [SIGPROF] = "PROF",
5250         [SIGWINCH] = "WINCH",
5251         [SIGIO] = "IO",
5252         [SIGPWR] = "PWR",
5253         [SIGSYS] = "SYS"
5254 };
5255
5256 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5257
5258 const char *signal_to_string(int signo) {
5259         static __thread char buf[12];
5260         const char *name;
5261
5262         name = __signal_to_string(signo);
5263         if (name)
5264                 return name;
5265
5266         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5267                 snprintf(buf, sizeof(buf) - 1, "RTMIN+%d", signo - SIGRTMIN);
5268         else
5269                 snprintf(buf, sizeof(buf) - 1, "%d", signo);
5270         char_array_0(buf);
5271         return buf;
5272 }
5273
5274 int signal_from_string(const char *s) {
5275         int signo;
5276         int offset = 0;
5277         unsigned u;
5278
5279         signo =__signal_from_string(s);
5280         if (signo > 0)
5281                 return signo;
5282
5283         if (startswith(s, "RTMIN+")) {
5284                 s += 6;
5285                 offset = SIGRTMIN;
5286         }
5287         if (safe_atou(s, &u) >= 0) {
5288                 signo = (int) u + offset;
5289                 if (signo > 0 && signo < _NSIG)
5290                         return signo;
5291         }
5292         return -1;
5293 }
5294
5295 bool kexec_loaded(void) {
5296        bool loaded = false;
5297        char *s;
5298
5299        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5300                if (s[0] == '1')
5301                        loaded = true;
5302                free(s);
5303        }
5304        return loaded;
5305 }
5306
5307 int strdup_or_null(const char *a, char **b) {
5308         char *c;
5309
5310         assert(b);
5311
5312         if (!a) {
5313                 *b = NULL;
5314                 return 0;
5315         }
5316
5317         c = strdup(a);
5318         if (!c)
5319                 return -ENOMEM;
5320
5321         *b = c;
5322         return 0;
5323 }
5324
5325 int prot_from_flags(int flags) {
5326
5327         switch (flags & O_ACCMODE) {
5328
5329         case O_RDONLY:
5330                 return PROT_READ;
5331
5332         case O_WRONLY:
5333                 return PROT_WRITE;
5334
5335         case O_RDWR:
5336                 return PROT_READ|PROT_WRITE;
5337
5338         default:
5339                 return -EINVAL;
5340         }
5341 }
5342
5343 char *format_bytes(char *buf, size_t l, off_t t) {
5344         unsigned i;
5345
5346         static const struct {
5347                 const char *suffix;
5348                 off_t factor;
5349         } table[] = {
5350                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5351                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5352                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5353                 { "G", 1024ULL*1024ULL*1024ULL },
5354                 { "M", 1024ULL*1024ULL },
5355                 { "K", 1024ULL },
5356         };
5357
5358         for (i = 0; i < ELEMENTSOF(table); i++) {
5359
5360                 if (t >= table[i].factor) {
5361                         snprintf(buf, l,
5362                                  "%llu.%llu%s",
5363                                  (unsigned long long) (t / table[i].factor),
5364                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5365                                  table[i].suffix);
5366
5367                         goto finish;
5368                 }
5369         }
5370
5371         snprintf(buf, l, "%lluB", (unsigned long long) t);
5372
5373 finish:
5374         buf[l-1] = 0;
5375         return buf;
5376
5377 }
5378
5379 void* memdup(const void *p, size_t l) {
5380         void *r;
5381
5382         assert(p);
5383
5384         r = malloc(l);
5385         if (!r)
5386                 return NULL;
5387
5388         memcpy(r, p, l);
5389         return r;
5390 }
5391
5392 int fd_inc_sndbuf(int fd, size_t n) {
5393         int r, value;
5394         socklen_t l = sizeof(value);
5395
5396         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5397         if (r >= 0 &&
5398             l == sizeof(value) &&
5399             (size_t) value >= n*2)
5400                 return 0;
5401
5402         value = (int) n;
5403         r = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value));
5404         if (r < 0)
5405                 return -errno;
5406
5407         return 1;
5408 }
5409
5410 int fd_inc_rcvbuf(int fd, size_t n) {
5411         int r, value;
5412         socklen_t l = sizeof(value);
5413
5414         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5415         if (r >= 0 &&
5416             l == sizeof(value) &&
5417             (size_t) value >= n*2)
5418                 return 0;
5419
5420         value = (int) n;
5421         r = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
5422         if (r < 0)
5423                 return -errno;
5424
5425         return 1;
5426 }
5427
5428 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5429         pid_t parent_pid, agent_pid;
5430         int fd;
5431         bool stdout_is_tty, stderr_is_tty;
5432         unsigned n, i;
5433         va_list ap;
5434         char **l;
5435
5436         assert(pid);
5437         assert(path);
5438
5439         parent_pid = getpid();
5440
5441         /* Spawns a temporary TTY agent, making sure it goes away when
5442          * we go away */
5443
5444         agent_pid = fork();
5445         if (agent_pid < 0)
5446                 return -errno;
5447
5448         if (agent_pid != 0) {
5449                 *pid = agent_pid;
5450                 return 0;
5451         }
5452
5453         /* In the child:
5454          *
5455          * Make sure the agent goes away when the parent dies */
5456         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5457                 _exit(EXIT_FAILURE);
5458
5459         /* Check whether our parent died before we were able
5460          * to set the death signal */
5461         if (getppid() != parent_pid)
5462                 _exit(EXIT_SUCCESS);
5463
5464         /* Don't leak fds to the agent */
5465         close_all_fds(except, n_except);
5466
5467         stdout_is_tty = isatty(STDOUT_FILENO);
5468         stderr_is_tty = isatty(STDERR_FILENO);
5469
5470         if (!stdout_is_tty || !stderr_is_tty) {
5471                 /* Detach from stdout/stderr. and reopen
5472                  * /dev/tty for them. This is important to
5473                  * ensure that when systemctl is started via
5474                  * popen() or a similar call that expects to
5475                  * read EOF we actually do generate EOF and
5476                  * not delay this indefinitely by because we
5477                  * keep an unused copy of stdin around. */
5478                 fd = open("/dev/tty", O_WRONLY);
5479                 if (fd < 0) {
5480                         log_error("Failed to open /dev/tty: %m");
5481                         _exit(EXIT_FAILURE);
5482                 }
5483
5484                 if (!stdout_is_tty)
5485                         dup2(fd, STDOUT_FILENO);
5486
5487                 if (!stderr_is_tty)
5488                         dup2(fd, STDERR_FILENO);
5489
5490                 if (fd > 2)
5491                         close(fd);
5492         }
5493
5494         /* Count arguments */
5495         va_start(ap, path);
5496         for (n = 0; va_arg(ap, char*); n++)
5497                 ;
5498         va_end(ap);
5499
5500         /* Allocate strv */
5501         l = alloca(sizeof(char *) * (n + 1));
5502
5503         /* Fill in arguments */
5504         va_start(ap, path);
5505         for (i = 0; i <= n; i++)
5506                 l[i] = va_arg(ap, char*);
5507         va_end(ap);
5508
5509         execv(path, l);
5510         _exit(EXIT_FAILURE);
5511 }
5512
5513 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5514         struct rlimit highest, fixed;
5515
5516         assert(rlim);
5517
5518         if (setrlimit(resource, rlim) >= 0)
5519                 return 0;
5520
5521         if (errno != EPERM)
5522                 return -errno;
5523
5524         /* So we failed to set the desired setrlimit, then let's try
5525          * to get as close as we can */
5526         assert_se(getrlimit(resource, &highest) == 0);
5527
5528         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5529         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5530
5531         if (setrlimit(resource, &fixed) < 0)
5532                 return -errno;
5533
5534         return 0;
5535 }
5536
5537 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5538         char path[sizeof("/proc/")-1+10+sizeof("/environ")], *value = NULL;
5539         int r;
5540         FILE *f;
5541         bool done = false;
5542         size_t l;
5543
5544         assert(field);
5545         assert(_value);
5546
5547         if (pid == 0)
5548                 pid = getpid();
5549
5550         snprintf(path, sizeof(path), "/proc/%lu/environ", (unsigned long) pid);
5551         char_array_0(path);
5552
5553         f = fopen(path, "re");
5554         if (!f)
5555                 return -errno;
5556
5557         l = strlen(field);
5558         r = 0;
5559
5560         do {
5561                 char line[LINE_MAX];
5562                 unsigned i;
5563
5564                 for (i = 0; i < sizeof(line)-1; i++) {
5565                         int c;
5566
5567                         c = getc(f);
5568                         if (_unlikely_(c == EOF)) {
5569                                 done = true;
5570                                 break;
5571                         } else if (c == 0)
5572                                 break;
5573
5574                         line[i] = c;
5575                 }
5576                 line[i] = 0;
5577
5578                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5579                         value = strdup(line + l + 1);
5580                         if (!value) {
5581                                 r = -ENOMEM;
5582                                 break;
5583                         }
5584
5585                         r = 1;
5586                         break;
5587                 }
5588
5589         } while (!done);
5590
5591         fclose(f);
5592
5593         if (r >= 0)
5594                 *_value = value;
5595
5596         return r;
5597 }
5598
5599 int can_sleep(const char *type) {
5600         char *w, *state;
5601         size_t l, k;
5602         int r;
5603         _cleanup_free_ char *p = NULL;
5604
5605         assert(type);
5606
5607         r = read_one_line_file("/sys/power/state", &p);
5608         if (r < 0)
5609                 return r == -ENOENT ? 0 : r;
5610
5611         k = strlen(type);
5612         FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state)
5613                 if (l == k && memcmp(w, type, l) == 0)
5614                         return true;
5615
5616         return false;
5617 }
5618
5619 bool is_valid_documentation_url(const char *url) {
5620         assert(url);
5621
5622         if (startswith(url, "http://") && url[7])
5623                 return true;
5624
5625         if (startswith(url, "https://") && url[8])
5626                 return true;
5627
5628         if (startswith(url, "file:") && url[5])
5629                 return true;
5630
5631         if (startswith(url, "info:") && url[5])
5632                 return true;
5633
5634         if (startswith(url, "man:") && url[4])
5635                 return true;
5636
5637         return false;
5638 }
5639
5640 bool in_initrd(void) {
5641         static __thread int saved = -1;
5642         struct statfs s;
5643
5644         if (saved >= 0)
5645                 return saved;
5646
5647         /* We make two checks here:
5648          *
5649          * 1. the flag file /etc/initrd-release must exist
5650          * 2. the root file system must be a memory file system
5651          *
5652          * The second check is extra paranoia, since misdetecting an
5653          * initrd can have bad bad consequences due the initrd
5654          * emptying when transititioning to the main systemd.
5655          */
5656
5657         saved = access("/etc/initrd-release", F_OK) >= 0 &&
5658                 statfs("/", &s) >= 0 &&
5659                 (s.f_type == TMPFS_MAGIC || s.f_type == RAMFS_MAGIC);
5660
5661         return saved;
5662 }
5663
5664 void warn_melody(void) {
5665         _cleanup_close_ int fd = -1;
5666
5667         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5668         if (fd < 0)
5669                 return;
5670
5671         /* Yeah, this is synchronous. Kinda sucks. Bute well... */
5672
5673         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5674         usleep(125*USEC_PER_MSEC);
5675
5676         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5677         usleep(125*USEC_PER_MSEC);
5678
5679         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5680         usleep(125*USEC_PER_MSEC);
5681
5682         ioctl(fd, KIOCSOUND, 0);
5683 }
5684
5685 int make_console_stdio(void) {
5686         int fd, r;
5687
5688         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5689
5690         fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5691         if (fd < 0) {
5692                 log_error("Failed to acquire terminal: %s", strerror(-fd));
5693                 return fd;
5694         }
5695
5696         r = make_stdio(fd);
5697         if (r < 0) {
5698                 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5699                 return r;
5700         }
5701
5702         return 0;
5703 }
5704
5705 int get_home_dir(char **_h) {
5706         char *h;
5707         const char *e;
5708         uid_t u;
5709         struct passwd *p;
5710
5711         assert(_h);
5712
5713         /* Take the user specified one */
5714         e = getenv("HOME");
5715         if (e) {
5716                 h = strdup(e);
5717                 if (!h)
5718                         return -ENOMEM;
5719
5720                 *_h = h;
5721                 return 0;
5722         }
5723
5724         /* Hardcode home directory for root to avoid NSS */
5725         u = getuid();
5726         if (u == 0) {
5727                 h = strdup("/root");
5728                 if (!h)
5729                         return -ENOMEM;
5730
5731                 *_h = h;
5732                 return 0;
5733         }
5734
5735         /* Check the database... */
5736         errno = 0;
5737         p = getpwuid(u);
5738         if (!p)
5739                 return errno ? -errno : -ESRCH;
5740
5741         if (!path_is_absolute(p->pw_dir))
5742                 return -EINVAL;
5743
5744         h = strdup(p->pw_dir);
5745         if (!h)
5746                 return -ENOMEM;
5747
5748         *_h = h;
5749         return 0;
5750 }
5751
5752 int get_shell(char **_sh) {
5753         char *sh;
5754         const char *e;
5755         uid_t u;
5756         struct passwd *p;
5757
5758         assert(_sh);
5759
5760         /* Take the user specified one */
5761         e = getenv("SHELL");
5762         if (e) {
5763                 sh = strdup(e);
5764                 if (!sh)
5765                         return -ENOMEM;
5766
5767                 *_sh = sh;
5768                 return 0;
5769         }
5770
5771         /* Hardcode home directory for root to avoid NSS */
5772         u = getuid();
5773         if (u == 0) {
5774                 sh = strdup("/bin/sh");
5775                 if (!sh)
5776                         return -ENOMEM;
5777
5778                 *_sh = sh;
5779                 return 0;
5780         }
5781
5782         /* Check the database... */
5783         errno = 0;
5784         p = getpwuid(u);
5785         if (!p)
5786                 return errno ? -errno : -ESRCH;
5787
5788         if (!path_is_absolute(p->pw_shell))
5789                 return -EINVAL;
5790
5791         sh = strdup(p->pw_shell);
5792         if (!sh)
5793                 return -ENOMEM;
5794
5795         *_sh = sh;
5796         return 0;
5797 }
5798
5799 void freep(void *p) {
5800         free(*(void**) p);
5801 }
5802
5803 void fclosep(FILE **f) {
5804         if (*f)
5805                 fclose(*f);
5806 }
5807
5808 void closep(int *fd) {
5809         if (*fd >= 0)
5810                 close_nointr_nofail(*fd);
5811 }
5812
5813 void closedirp(DIR **d) {
5814         if (*d)
5815                 closedir(*d);
5816 }
5817
5818 void umaskp(mode_t *u) {
5819         umask(*u);
5820 }