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 void status_vprintf(const char *status, bool ellipse, const char *format, va_list ap) {
3492         char *s = NULL;
3493         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3494         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                 goto finish;
3505
3506         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3507         if (fd < 0)
3508                 goto finish;
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 ? strlen(status_indent) : 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         writev(fd, iovec, n);
3547
3548 finish:
3549         free(s);
3550
3551         if (fd >= 0)
3552                 close_nointr_nofail(fd);
3553 }
3554
3555 void status_printf(const char *status, bool ellipse, const char *format, ...) {
3556         va_list ap;
3557
3558         assert(format);
3559
3560         va_start(ap, format);
3561         status_vprintf(status, ellipse, format, ap);
3562         va_end(ap);
3563 }
3564
3565 void status_welcome(void) {
3566         char *pretty_name = NULL, *ansi_color = NULL;
3567         const char *const_pretty = NULL, *const_color = NULL;
3568         int r;
3569
3570         if ((r = parse_env_file("/etc/os-release", NEWLINE,
3571                                 "PRETTY_NAME", &pretty_name,
3572                                 "ANSI_COLOR", &ansi_color,
3573                                 NULL)) < 0) {
3574
3575                 if (r != -ENOENT)
3576                         log_warning("Failed to read /etc/os-release: %s", strerror(-r));
3577         }
3578
3579         if (!pretty_name && !const_pretty)
3580                 const_pretty = "Linux";
3581
3582         if (!ansi_color && !const_color)
3583                 const_color = "1";
3584
3585         status_printf(NULL,
3586                       false,
3587                       "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
3588                       const_color ? const_color : ansi_color,
3589                       const_pretty ? const_pretty : pretty_name);
3590
3591         free(ansi_color);
3592         free(pretty_name);
3593 }
3594
3595 char *replace_env(const char *format, char **env) {
3596         enum {
3597                 WORD,
3598                 CURLY,
3599                 VARIABLE
3600         } state = WORD;
3601
3602         const char *e, *word = format;
3603         char *r = NULL, *k;
3604
3605         assert(format);
3606
3607         for (e = format; *e; e ++) {
3608
3609                 switch (state) {
3610
3611                 case WORD:
3612                         if (*e == '$')
3613                                 state = CURLY;
3614                         break;
3615
3616                 case CURLY:
3617                         if (*e == '{') {
3618                                 if (!(k = strnappend(r, word, e-word-1)))
3619                                         goto fail;
3620
3621                                 free(r);
3622                                 r = k;
3623
3624                                 word = e-1;
3625                                 state = VARIABLE;
3626
3627                         } else if (*e == '$') {
3628                                 if (!(k = strnappend(r, word, e-word)))
3629                                         goto fail;
3630
3631                                 free(r);
3632                                 r = k;
3633
3634                                 word = e+1;
3635                                 state = WORD;
3636                         } else
3637                                 state = WORD;
3638                         break;
3639
3640                 case VARIABLE:
3641                         if (*e == '}') {
3642                                 const char *t;
3643
3644                                 if (!(t = strv_env_get_with_length(env, word+2, e-word-2)))
3645                                         t = "";
3646
3647                                 if (!(k = strappend(r, t)))
3648                                         goto fail;
3649
3650                                 free(r);
3651                                 r = k;
3652
3653                                 word = e+1;
3654                                 state = WORD;
3655                         }
3656                         break;
3657                 }
3658         }
3659
3660         if (!(k = strnappend(r, word, e-word)))
3661                 goto fail;
3662
3663         free(r);
3664         return k;
3665
3666 fail:
3667         free(r);
3668         return NULL;
3669 }
3670
3671 char **replace_env_argv(char **argv, char **env) {
3672         char **r, **i;
3673         unsigned k = 0, l = 0;
3674
3675         l = strv_length(argv);
3676
3677         if (!(r = new(char*, l+1)))
3678                 return NULL;
3679
3680         STRV_FOREACH(i, argv) {
3681
3682                 /* If $FOO appears as single word, replace it by the split up variable */
3683                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3684                         char *e;
3685                         char **w, **m;
3686                         unsigned q;
3687
3688                         if ((e = strv_env_get(env, *i+1))) {
3689
3690                                 if (!(m = strv_split_quoted(e))) {
3691                                         r[k] = NULL;
3692                                         strv_free(r);
3693                                         return NULL;
3694                                 }
3695                         } else
3696                                 m = NULL;
3697
3698                         q = strv_length(m);
3699                         l = l + q - 1;
3700
3701                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3702                                 r[k] = NULL;
3703                                 strv_free(r);
3704                                 strv_free(m);
3705                                 return NULL;
3706                         }
3707
3708                         r = w;
3709                         if (m) {
3710                                 memcpy(r + k, m, q * sizeof(char*));
3711                                 free(m);
3712                         }
3713
3714                         k += q;
3715                         continue;
3716                 }
3717
3718                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3719                 if (!(r[k++] = replace_env(*i, env))) {
3720                         strv_free(r);
3721                         return NULL;
3722                 }
3723         }
3724
3725         r[k] = NULL;
3726         return r;
3727 }
3728
3729 int fd_columns(int fd) {
3730         struct winsize ws;
3731         zero(ws);
3732
3733         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3734                 return -errno;
3735
3736         if (ws.ws_col <= 0)
3737                 return -EIO;
3738
3739         return ws.ws_col;
3740 }
3741
3742 static unsigned columns_cached(bool cached) {
3743         static __thread int parsed_columns = 0, env_columns = -1;
3744         const char *e;
3745
3746         if (_likely_(parsed_columns > 0 && cached))
3747                 return parsed_columns;
3748
3749         if (_unlikely_(env_columns == -1)) {
3750                 e = getenv("COLUMNS");
3751                 if (e)
3752                         env_columns = atoi(e);
3753                 else
3754                         env_columns = 0;
3755         }
3756
3757         if (env_columns > 0) {
3758                 parsed_columns = env_columns;
3759                 return parsed_columns;
3760         }
3761
3762         if (parsed_columns <= 0 || !cached)
3763                 parsed_columns = fd_columns(STDOUT_FILENO);
3764
3765         if (parsed_columns <= 0)
3766                 parsed_columns = 80;
3767
3768         return parsed_columns;
3769 }
3770
3771 unsigned columns(void) {
3772         return columns_cached(true);
3773 }
3774
3775 unsigned columns_uncached(void) {
3776         return columns_cached(false);
3777 }
3778
3779 int fd_lines(int fd) {
3780         struct winsize ws;
3781         zero(ws);
3782
3783         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3784                 return -errno;
3785
3786         if (ws.ws_row <= 0)
3787                 return -EIO;
3788
3789         return ws.ws_row;
3790 }
3791
3792 unsigned lines(void) {
3793         static __thread int parsed_lines = 0;
3794         const char *e;
3795
3796         if (_likely_(parsed_lines > 0))
3797                 return parsed_lines;
3798
3799         e = getenv("LINES");
3800         if (e)
3801                 parsed_lines = atoi(e);
3802
3803         if (parsed_lines <= 0)
3804                 parsed_lines = fd_lines(STDOUT_FILENO);
3805
3806         if (parsed_lines <= 0)
3807                 parsed_lines = 25;
3808
3809         return parsed_lines;
3810 }
3811
3812 int running_in_chroot(void) {
3813         struct stat a, b;
3814
3815         zero(a);
3816         zero(b);
3817
3818         /* Only works as root */
3819
3820         if (stat("/proc/1/root", &a) < 0)
3821                 return -errno;
3822
3823         if (stat("/", &b) < 0)
3824                 return -errno;
3825
3826         return
3827                 a.st_dev != b.st_dev ||
3828                 a.st_ino != b.st_ino;
3829 }
3830
3831 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3832         size_t x;
3833         char *r;
3834
3835         assert(s);
3836         assert(percent <= 100);
3837         assert(new_length >= 3);
3838
3839         if (old_length <= 3 || old_length <= new_length)
3840                 return strndup(s, old_length);
3841
3842         r = new0(char, new_length+1);
3843         if (!r)
3844                 return r;
3845
3846         x = (new_length * percent) / 100;
3847
3848         if (x > new_length - 3)
3849                 x = new_length - 3;
3850
3851         memcpy(r, s, x);
3852         r[x] = '.';
3853         r[x+1] = '.';
3854         r[x+2] = '.';
3855         memcpy(r + x + 3,
3856                s + old_length - (new_length - x - 3),
3857                new_length - x - 3);
3858
3859         return r;
3860 }
3861
3862 char *ellipsize(const char *s, size_t length, unsigned percent) {
3863         return ellipsize_mem(s, strlen(s), length, percent);
3864 }
3865
3866 int touch(const char *path) {
3867         int fd;
3868
3869         assert(path);
3870
3871         /* This just opens the file for writing, ensuring it
3872          * exists. It doesn't call utimensat() the way /usr/bin/touch
3873          * does it. */
3874
3875         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3876         if (fd < 0)
3877                 return -errno;
3878
3879         close_nointr_nofail(fd);
3880         return 0;
3881 }
3882
3883 char *unquote(const char *s, const char* quotes) {
3884         size_t l;
3885         assert(s);
3886
3887         /* This is rather stupid, simply removes the heading and
3888          * trailing quotes if there is one. Doesn't care about
3889          * escaping or anything. */
3890
3891         l = strlen(s);
3892         if (l < 2)
3893                 return strdup(s);
3894
3895         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3896                 return strndup(s+1, l-2);
3897
3898         return strdup(s);
3899 }
3900
3901 char *normalize_env_assignment(const char *s) {
3902         char *name, *value, *p, *r;
3903
3904         p = strchr(s, '=');
3905
3906         if (!p) {
3907                 if (!(r = strdup(s)))
3908                         return NULL;
3909
3910                 return strstrip(r);
3911         }
3912
3913         if (!(name = strndup(s, p - s)))
3914                 return NULL;
3915
3916         if (!(p = strdup(p+1))) {
3917                 free(name);
3918                 return NULL;
3919         }
3920
3921         value = unquote(strstrip(p), QUOTES);
3922         free(p);
3923
3924         if (!value) {
3925                 free(name);
3926                 return NULL;
3927         }
3928
3929         if (asprintf(&r, "%s=%s", name, value) < 0)
3930                 r = NULL;
3931
3932         free(value);
3933         free(name);
3934
3935         return r;
3936 }
3937
3938 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3939         siginfo_t dummy;
3940
3941         assert(pid >= 1);
3942
3943         if (!status)
3944                 status = &dummy;
3945
3946         for (;;) {
3947                 zero(*status);
3948
3949                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3950
3951                         if (errno == EINTR)
3952                                 continue;
3953
3954                         return -errno;
3955                 }
3956
3957                 return 0;
3958         }
3959 }
3960
3961 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3962         int r;
3963         siginfo_t status;
3964
3965         assert(name);
3966         assert(pid > 1);
3967
3968         r = wait_for_terminate(pid, &status);
3969         if (r < 0) {
3970                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3971                 return r;
3972         }
3973
3974         if (status.si_code == CLD_EXITED) {
3975                 if (status.si_status != 0) {
3976                         log_warning("%s failed with error code %i.", name, status.si_status);
3977                         return status.si_status;
3978                 }
3979
3980                 log_debug("%s succeeded.", name);
3981                 return 0;
3982
3983         } else if (status.si_code == CLD_KILLED ||
3984                    status.si_code == CLD_DUMPED) {
3985
3986                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3987                 return -EPROTO;
3988         }
3989
3990         log_warning("%s failed due to unknown reason.", name);
3991         return -EPROTO;
3992 }
3993
3994 _noreturn_ void freeze(void) {
3995
3996         /* Make sure nobody waits for us on a socket anymore */
3997         close_all_fds(NULL, 0);
3998
3999         sync();
4000
4001         for (;;)
4002                 pause();
4003 }
4004
4005 bool null_or_empty(struct stat *st) {
4006         assert(st);
4007
4008         if (S_ISREG(st->st_mode) && st->st_size <= 0)
4009                 return true;
4010
4011         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
4012                 return true;
4013
4014         return false;
4015 }
4016
4017 int null_or_empty_path(const char *fn) {
4018         struct stat st;
4019
4020         assert(fn);
4021
4022         if (stat(fn, &st) < 0)
4023                 return -errno;
4024
4025         return null_or_empty(&st);
4026 }
4027
4028 DIR *xopendirat(int fd, const char *name, int flags) {
4029         int nfd;
4030         DIR *d;
4031
4032         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags);
4033         if (nfd < 0)
4034                 return NULL;
4035
4036         d = fdopendir(nfd);
4037         if (!d) {
4038                 close_nointr_nofail(nfd);
4039                 return NULL;
4040         }
4041
4042         return d;
4043 }
4044
4045 int signal_from_string_try_harder(const char *s) {
4046         int signo;
4047         assert(s);
4048
4049         signo = signal_from_string(s);
4050         if (signo <= 0)
4051                 if (startswith(s, "SIG"))
4052                         return signal_from_string(s+3);
4053
4054         return signo;
4055 }
4056
4057 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {
4058
4059         assert(f);
4060         assert(name);
4061         assert(t);
4062
4063         if (!dual_timestamp_is_set(t))
4064                 return;
4065
4066         fprintf(f, "%s=%llu %llu\n",
4067                 name,
4068                 (unsigned long long) t->realtime,
4069                 (unsigned long long) t->monotonic);
4070 }
4071
4072 void dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
4073         unsigned long long a, b;
4074
4075         assert(value);
4076         assert(t);
4077
4078         if (sscanf(value, "%lli %llu", &a, &b) != 2)
4079                 log_debug("Failed to parse finish timestamp value %s", value);
4080         else {
4081                 t->realtime = a;
4082                 t->monotonic = b;
4083         }
4084 }
4085
4086 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
4087         char *dn, *t, *u;
4088         int r;
4089
4090         /* FIXME: to follow udev's logic 100% we need to leave valid
4091          * UTF8 chars unescaped */
4092
4093         u = unquote(tagvalue, "\"\'");
4094         if (u == NULL)
4095                 return NULL;
4096
4097         t = xescape(u, "/ ");
4098         free(u);
4099
4100         if (t == NULL)
4101                 return NULL;
4102
4103         r = asprintf(&dn, "/dev/disk/by-%s/%s", by, t);
4104         free(t);
4105
4106         if (r < 0)
4107                 return NULL;
4108
4109         return dn;
4110 }
4111
4112 char *fstab_node_to_udev_node(const char *p) {
4113         if (startswith(p, "LABEL="))
4114                 return tag_to_udev_node(p+6, "label");
4115
4116         if (startswith(p, "UUID="))
4117                 return tag_to_udev_node(p+5, "uuid");
4118
4119         if (startswith(p, "PARTUUID="))
4120                 return tag_to_udev_node(p+9, "partuuid");
4121
4122         if (startswith(p, "PARTLABEL="))
4123                 return tag_to_udev_node(p+10, "partlabel");
4124
4125         return strdup(p);
4126 }
4127
4128 bool tty_is_vc(const char *tty) {
4129         assert(tty);
4130
4131         if (startswith(tty, "/dev/"))
4132                 tty += 5;
4133
4134         return vtnr_from_tty(tty) >= 0;
4135 }
4136
4137 bool tty_is_console(const char *tty) {
4138         assert(tty);
4139
4140         if (startswith(tty, "/dev/"))
4141                 tty += 5;
4142
4143         return streq(tty, "console");
4144 }
4145
4146 int vtnr_from_tty(const char *tty) {
4147         int i, r;
4148
4149         assert(tty);
4150
4151         if (startswith(tty, "/dev/"))
4152                 tty += 5;
4153
4154         if (!startswith(tty, "tty") )
4155                 return -EINVAL;
4156
4157         if (tty[3] < '0' || tty[3] > '9')
4158                 return -EINVAL;
4159
4160         r = safe_atoi(tty+3, &i);
4161         if (r < 0)
4162                 return r;
4163
4164         if (i < 0 || i > 63)
4165                 return -EINVAL;
4166
4167         return i;
4168 }
4169
4170 bool tty_is_vc_resolve(const char *tty) {
4171         char *active = NULL;
4172         bool b;
4173
4174         assert(tty);
4175
4176         if (startswith(tty, "/dev/"))
4177                 tty += 5;
4178
4179         /* Resolve where /dev/console is pointing to, if /sys is
4180          * actually ours (i.e. not read-only-mounted which is a sign
4181          * for container setups) */
4182         if (streq(tty, "console") && path_is_read_only_fs("/sys") <= 0)
4183                 if (read_one_line_file("/sys/class/tty/console/active", &active) >= 0) {
4184                         /* If multiple log outputs are configured the
4185                          * last one is what /dev/console points to */
4186                         tty = strrchr(active, ' ');
4187                         if (tty)
4188                                 tty++;
4189                         else
4190                                 tty = active;
4191                 }
4192
4193         b = tty_is_vc(tty);
4194         free(active);
4195
4196         return b;
4197 }
4198
4199 const char *default_term_for_tty(const char *tty) {
4200         assert(tty);
4201
4202         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
4203 }
4204
4205 bool dirent_is_file(const struct dirent *de) {
4206         assert(de);
4207
4208         if (ignore_file(de->d_name))
4209                 return false;
4210
4211         if (de->d_type != DT_REG &&
4212             de->d_type != DT_LNK &&
4213             de->d_type != DT_UNKNOWN)
4214                 return false;
4215
4216         return true;
4217 }
4218
4219 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
4220         assert(de);
4221
4222         if (de->d_type != DT_REG &&
4223             de->d_type != DT_LNK &&
4224             de->d_type != DT_UNKNOWN)
4225                 return false;
4226
4227         if (ignore_file_allow_backup(de->d_name))
4228                 return false;
4229
4230         return endswith(de->d_name, suffix);
4231 }
4232
4233 void execute_directory(const char *directory, DIR *d, char *argv[]) {
4234         DIR *_d = NULL;
4235         struct dirent *de;
4236         Hashmap *pids = NULL;
4237
4238         assert(directory);
4239
4240         /* Executes all binaries in a directory in parallel and waits
4241          * until all they all finished. */
4242
4243         if (!d) {
4244                 if (!(_d = opendir(directory))) {
4245
4246                         if (errno == ENOENT)
4247                                 return;
4248
4249                         log_error("Failed to enumerate directory %s: %m", directory);
4250                         return;
4251                 }
4252
4253                 d = _d;
4254         }
4255
4256         if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
4257                 log_error("Failed to allocate set.");
4258                 goto finish;
4259         }
4260
4261         while ((de = readdir(d))) {
4262                 char *path;
4263                 pid_t pid;
4264                 int k;
4265
4266                 if (!dirent_is_file(de))
4267                         continue;
4268
4269                 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
4270                         log_oom();
4271                         continue;
4272                 }
4273
4274                 if ((pid = fork()) < 0) {
4275                         log_error("Failed to fork: %m");
4276                         free(path);
4277                         continue;
4278                 }
4279
4280                 if (pid == 0) {
4281                         char *_argv[2];
4282                         /* Child */
4283
4284                         if (!argv) {
4285                                 _argv[0] = path;
4286                                 _argv[1] = NULL;
4287                                 argv = _argv;
4288                         } else
4289                                 argv[0] = path;
4290
4291                         execv(path, argv);
4292
4293                         log_error("Failed to execute %s: %m", path);
4294                         _exit(EXIT_FAILURE);
4295                 }
4296
4297                 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
4298
4299                 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
4300                         log_error("Failed to add PID to set: %s", strerror(-k));
4301                         free(path);
4302                 }
4303         }
4304
4305         while (!hashmap_isempty(pids)) {
4306                 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
4307                 siginfo_t si;
4308                 char *path;
4309
4310                 zero(si);
4311                 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
4312
4313                         if (errno == EINTR)
4314                                 continue;
4315
4316                         log_error("waitid() failed: %m");
4317                         goto finish;
4318                 }
4319
4320                 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
4321                         if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
4322                                 if (si.si_code == CLD_EXITED)
4323                                         log_error("%s exited with exit status %i.", path, si.si_status);
4324                                 else
4325                                         log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
4326                         } else
4327                                 log_debug("%s exited successfully.", path);
4328
4329                         free(path);
4330                 }
4331         }
4332
4333 finish:
4334         if (_d)
4335                 closedir(_d);
4336
4337         if (pids)
4338                 hashmap_free_free(pids);
4339 }
4340
4341 int kill_and_sigcont(pid_t pid, int sig) {
4342         int r;
4343
4344         r = kill(pid, sig) < 0 ? -errno : 0;
4345
4346         if (r >= 0)
4347                 kill(pid, SIGCONT);
4348
4349         return r;
4350 }
4351
4352 bool nulstr_contains(const char*nulstr, const char *needle) {
4353         const char *i;
4354
4355         if (!nulstr)
4356                 return false;
4357
4358         NULSTR_FOREACH(i, nulstr)
4359                 if (streq(i, needle))
4360                         return true;
4361
4362         return false;
4363 }
4364
4365 bool plymouth_running(void) {
4366         return access("/run/plymouth/pid", F_OK) >= 0;
4367 }
4368
4369 char* strshorten(char *s, size_t l) {
4370         assert(s);
4371
4372         if (l < strlen(s))
4373                 s[l] = 0;
4374
4375         return s;
4376 }
4377
4378 static bool hostname_valid_char(char c) {
4379         return
4380                 (c >= 'a' && c <= 'z') ||
4381                 (c >= 'A' && c <= 'Z') ||
4382                 (c >= '0' && c <= '9') ||
4383                 c == '-' ||
4384                 c == '_' ||
4385                 c == '.';
4386 }
4387
4388 bool hostname_is_valid(const char *s) {
4389         const char *p;
4390
4391         if (isempty(s))
4392                 return false;
4393
4394         for (p = s; *p; p++)
4395                 if (!hostname_valid_char(*p))
4396                         return false;
4397
4398         if (p-s > HOST_NAME_MAX)
4399                 return false;
4400
4401         return true;
4402 }
4403
4404 char* hostname_cleanup(char *s) {
4405         char *p, *d;
4406
4407         for (p = s, d = s; *p; p++)
4408                 if ((*p >= 'a' && *p <= 'z') ||
4409                     (*p >= 'A' && *p <= 'Z') ||
4410                     (*p >= '0' && *p <= '9') ||
4411                     *p == '-' ||
4412                     *p == '_' ||
4413                     *p == '.')
4414                         *(d++) = *p;
4415
4416         *d = 0;
4417
4418         strshorten(s, HOST_NAME_MAX);
4419         return s;
4420 }
4421
4422 int pipe_eof(int fd) {
4423         struct pollfd pollfd;
4424         int r;
4425
4426         zero(pollfd);
4427         pollfd.fd = fd;
4428         pollfd.events = POLLIN|POLLHUP;
4429
4430         r = poll(&pollfd, 1, 0);
4431         if (r < 0)
4432                 return -errno;
4433
4434         if (r == 0)
4435                 return 0;
4436
4437         return pollfd.revents & POLLHUP;
4438 }
4439
4440 int fd_wait_for_event(int fd, int event, usec_t t) {
4441         struct pollfd pollfd;
4442         int r;
4443
4444         zero(pollfd);
4445         pollfd.fd = fd;
4446         pollfd.events = event;
4447
4448         r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
4449         if (r < 0)
4450                 return -errno;
4451
4452         if (r == 0)
4453                 return 0;
4454
4455         return pollfd.revents;
4456 }
4457
4458 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4459         FILE *f;
4460         char *t;
4461         const char *fn;
4462         size_t k;
4463         int fd;
4464
4465         assert(path);
4466         assert(_f);
4467         assert(_temp_path);
4468
4469         t = new(char, strlen(path) + 1 + 6 + 1);
4470         if (!t)
4471                 return -ENOMEM;
4472
4473         fn = path_get_file_name(path);
4474         k = fn-path;
4475         memcpy(t, path, k);
4476         t[k] = '.';
4477         stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
4478
4479         fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
4480         if (fd < 0) {
4481                 free(t);
4482                 return -errno;
4483         }
4484
4485         f = fdopen(fd, "we");
4486         if (!f) {
4487                 unlink(t);
4488                 free(t);
4489                 return -errno;
4490         }
4491
4492         *_f = f;
4493         *_temp_path = t;
4494
4495         return 0;
4496 }
4497
4498 int terminal_vhangup_fd(int fd) {
4499         assert(fd >= 0);
4500
4501         if (ioctl(fd, TIOCVHANGUP) < 0)
4502                 return -errno;
4503
4504         return 0;
4505 }
4506
4507 int terminal_vhangup(const char *name) {
4508         int fd, r;
4509
4510         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4511         if (fd < 0)
4512                 return fd;
4513
4514         r = terminal_vhangup_fd(fd);
4515         close_nointr_nofail(fd);
4516
4517         return r;
4518 }
4519
4520 int vt_disallocate(const char *name) {
4521         int fd, r;
4522         unsigned u;
4523
4524         /* Deallocate the VT if possible. If not possible
4525          * (i.e. because it is the active one), at least clear it
4526          * entirely (including the scrollback buffer) */
4527
4528         if (!startswith(name, "/dev/"))
4529                 return -EINVAL;
4530
4531         if (!tty_is_vc(name)) {
4532                 /* So this is not a VT. I guess we cannot deallocate
4533                  * it then. But let's at least clear the screen */
4534
4535                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4536                 if (fd < 0)
4537                         return fd;
4538
4539                 loop_write(fd,
4540                            "\033[r"    /* clear scrolling region */
4541                            "\033[H"    /* move home */
4542                            "\033[2J",  /* clear screen */
4543                            10, false);
4544                 close_nointr_nofail(fd);
4545
4546                 return 0;
4547         }
4548
4549         if (!startswith(name, "/dev/tty"))
4550                 return -EINVAL;
4551
4552         r = safe_atou(name+8, &u);
4553         if (r < 0)
4554                 return r;
4555
4556         if (u <= 0)
4557                 return -EINVAL;
4558
4559         /* Try to deallocate */
4560         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4561         if (fd < 0)
4562                 return fd;
4563
4564         r = ioctl(fd, VT_DISALLOCATE, u);
4565         close_nointr_nofail(fd);
4566
4567         if (r >= 0)
4568                 return 0;
4569
4570         if (errno != EBUSY)
4571                 return -errno;
4572
4573         /* Couldn't deallocate, so let's clear it fully with
4574          * scrollback */
4575         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4576         if (fd < 0)
4577                 return fd;
4578
4579         loop_write(fd,
4580                    "\033[r"   /* clear scrolling region */
4581                    "\033[H"   /* move home */
4582                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4583                    10, false);
4584         close_nointr_nofail(fd);
4585
4586         return 0;
4587 }
4588
4589 int copy_file(const char *from, const char *to) {
4590         int r, fdf, fdt;
4591
4592         assert(from);
4593         assert(to);
4594
4595         fdf = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
4596         if (fdf < 0)
4597                 return -errno;
4598
4599         fdt = open(to, O_WRONLY|O_CREAT|O_EXCL|O_CLOEXEC|O_NOCTTY, 0644);
4600         if (fdt < 0) {
4601                 close_nointr_nofail(fdf);
4602                 return -errno;
4603         }
4604
4605         for (;;) {
4606                 char buf[PIPE_BUF];
4607                 ssize_t n, k;
4608
4609                 n = read(fdf, buf, sizeof(buf));
4610                 if (n < 0) {
4611                         r = -errno;
4612
4613                         close_nointr_nofail(fdf);
4614                         close_nointr(fdt);
4615                         unlink(to);
4616
4617                         return r;
4618                 }
4619
4620                 if (n == 0)
4621                         break;
4622
4623                 errno = 0;
4624                 k = loop_write(fdt, buf, n, false);
4625                 if (n != k) {
4626                         r = k < 0 ? k : (errno ? -errno : -EIO);
4627
4628                         close_nointr_nofail(fdf);
4629                         close_nointr(fdt);
4630
4631                         unlink(to);
4632                         return r;
4633                 }
4634         }
4635
4636         close_nointr_nofail(fdf);
4637         r = close_nointr(fdt);
4638
4639         if (r < 0) {
4640                 unlink(to);
4641                 return r;
4642         }
4643
4644         return 0;
4645 }
4646
4647 int symlink_atomic(const char *from, const char *to) {
4648         char *x;
4649         _cleanup_free_ char *t;
4650         const char *fn;
4651         size_t k;
4652         unsigned long long ull;
4653         unsigned i;
4654         int r;
4655
4656         assert(from);
4657         assert(to);
4658
4659         t = new(char, strlen(to) + 1 + 16 + 1);
4660         if (!t)
4661                 return -ENOMEM;
4662
4663         fn = path_get_file_name(to);
4664         k = fn-to;
4665         memcpy(t, to, k);
4666         t[k] = '.';
4667         x = stpcpy(t+k+1, fn);
4668
4669         ull = random_ull();
4670         for (i = 0; i < 16; i++) {
4671                 *(x++) = hexchar(ull & 0xF);
4672                 ull >>= 4;
4673         }
4674
4675         *x = 0;
4676
4677         if (symlink(from, t) < 0)
4678                 return -errno;
4679
4680         if (rename(t, to) < 0) {
4681                 r = -errno;
4682                 unlink(t);
4683                 return r;
4684         }
4685
4686         return 0;
4687 }
4688
4689 bool display_is_local(const char *display) {
4690         assert(display);
4691
4692         return
4693                 display[0] == ':' &&
4694                 display[1] >= '0' &&
4695                 display[1] <= '9';
4696 }
4697
4698 int socket_from_display(const char *display, char **path) {
4699         size_t k;
4700         char *f, *c;
4701
4702         assert(display);
4703         assert(path);
4704
4705         if (!display_is_local(display))
4706                 return -EINVAL;
4707
4708         k = strspn(display+1, "0123456789");
4709
4710         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
4711         if (!f)
4712                 return -ENOMEM;
4713
4714         c = stpcpy(f, "/tmp/.X11-unix/X");
4715         memcpy(c, display+1, k);
4716         c[k] = 0;
4717
4718         *path = f;
4719
4720         return 0;
4721 }
4722
4723 int get_user_creds(
4724                 const char **username,
4725                 uid_t *uid, gid_t *gid,
4726                 const char **home,
4727                 const char **shell) {
4728
4729         struct passwd *p;
4730         uid_t u;
4731
4732         assert(username);
4733         assert(*username);
4734
4735         /* We enforce some special rules for uid=0: in order to avoid
4736          * NSS lookups for root we hardcode its data. */
4737
4738         if (streq(*username, "root") || streq(*username, "0")) {
4739                 *username = "root";
4740
4741                 if (uid)
4742                         *uid = 0;
4743
4744                 if (gid)
4745                         *gid = 0;
4746
4747                 if (home)
4748                         *home = "/root";
4749
4750                 if (shell)
4751                         *shell = "/bin/sh";
4752
4753                 return 0;
4754         }
4755
4756         if (parse_uid(*username, &u) >= 0) {
4757                 errno = 0;
4758                 p = getpwuid(u);
4759
4760                 /* If there are multiple users with the same id, make
4761                  * sure to leave $USER to the configured value instead
4762                  * of the first occurrence in the database. However if
4763                  * the uid was configured by a numeric uid, then let's
4764                  * pick the real username from /etc/passwd. */
4765                 if (p)
4766                         *username = p->pw_name;
4767         } else {
4768                 errno = 0;
4769                 p = getpwnam(*username);
4770         }
4771
4772         if (!p)
4773                 return errno != 0 ? -errno : -ESRCH;
4774
4775         if (uid)
4776                 *uid = p->pw_uid;
4777
4778         if (gid)
4779                 *gid = p->pw_gid;
4780
4781         if (home)
4782                 *home = p->pw_dir;
4783
4784         if (shell)
4785                 *shell = p->pw_shell;
4786
4787         return 0;
4788 }
4789
4790 int get_group_creds(const char **groupname, gid_t *gid) {
4791         struct group *g;
4792         gid_t id;
4793
4794         assert(groupname);
4795
4796         /* We enforce some special rules for gid=0: in order to avoid
4797          * NSS lookups for root we hardcode its data. */
4798
4799         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4800                 *groupname = "root";
4801
4802                 if (gid)
4803                         *gid = 0;
4804
4805                 return 0;
4806         }
4807
4808         if (parse_gid(*groupname, &id) >= 0) {
4809                 errno = 0;
4810                 g = getgrgid(id);
4811
4812                 if (g)
4813                         *groupname = g->gr_name;
4814         } else {
4815                 errno = 0;
4816                 g = getgrnam(*groupname);
4817         }
4818
4819         if (!g)
4820                 return errno != 0 ? -errno : -ESRCH;
4821
4822         if (gid)
4823                 *gid = g->gr_gid;
4824
4825         return 0;
4826 }
4827
4828 int in_group(const char *name) {
4829         gid_t gid, *gids;
4830         int ngroups_max, r, i;
4831
4832         r = get_group_creds(&name, &gid);
4833         if (r < 0)
4834                 return r;
4835
4836         if (getgid() == gid)
4837                 return 1;
4838
4839         if (getegid() == gid)
4840                 return 1;
4841
4842         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4843         assert(ngroups_max > 0);
4844
4845         gids = alloca(sizeof(gid_t) * ngroups_max);
4846
4847         r = getgroups(ngroups_max, gids);
4848         if (r < 0)
4849                 return -errno;
4850
4851         for (i = 0; i < r; i++)
4852                 if (gids[i] == gid)
4853                         return 1;
4854
4855         return 0;
4856 }
4857
4858 int glob_exists(const char *path) {
4859         glob_t g;
4860         int r, k;
4861
4862         assert(path);
4863
4864         zero(g);
4865         errno = 0;
4866         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4867
4868         if (k == GLOB_NOMATCH)
4869                 r = 0;
4870         else if (k == GLOB_NOSPACE)
4871                 r = -ENOMEM;
4872         else if (k == 0)
4873                 r = !strv_isempty(g.gl_pathv);
4874         else
4875                 r = errno ? -errno : -EIO;
4876
4877         globfree(&g);
4878
4879         return r;
4880 }
4881
4882 int dirent_ensure_type(DIR *d, struct dirent *de) {
4883         struct stat st;
4884
4885         assert(d);
4886         assert(de);
4887
4888         if (de->d_type != DT_UNKNOWN)
4889                 return 0;
4890
4891         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4892                 return -errno;
4893
4894         de->d_type =
4895                 S_ISREG(st.st_mode)  ? DT_REG  :
4896                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4897                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4898                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4899                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4900                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4901                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4902                                        DT_UNKNOWN;
4903
4904         return 0;
4905 }
4906
4907 int in_search_path(const char *path, char **search) {
4908         char **i, *parent;
4909         int r;
4910
4911         r = path_get_parent(path, &parent);
4912         if (r < 0)
4913                 return r;
4914
4915         r = 0;
4916
4917         STRV_FOREACH(i, search) {
4918                 if (path_equal(parent, *i)) {
4919                         r = 1;
4920                         break;
4921                 }
4922         }
4923
4924         free(parent);
4925
4926         return r;
4927 }
4928
4929 int get_files_in_directory(const char *path, char ***list) {
4930         DIR *d;
4931         int r = 0;
4932         unsigned n = 0;
4933         char **l = NULL;
4934
4935         assert(path);
4936
4937         /* Returns all files in a directory in *list, and the number
4938          * of files as return value. If list is NULL returns only the
4939          * number */
4940
4941         d = opendir(path);
4942         if (!d)
4943                 return -errno;
4944
4945         for (;;) {
4946                 struct dirent buffer, *de;
4947                 int k;
4948
4949                 k = readdir_r(d, &buffer, &de);
4950                 if (k != 0) {
4951                         r = -k;
4952                         goto finish;
4953                 }
4954
4955                 if (!de)
4956                         break;
4957
4958                 dirent_ensure_type(d, de);
4959
4960                 if (!dirent_is_file(de))
4961                         continue;
4962
4963                 if (list) {
4964                         if ((unsigned) r >= n) {
4965                                 char **t;
4966
4967                                 n = MAX(16, 2*r);
4968                                 t = realloc(l, sizeof(char*) * n);
4969                                 if (!t) {
4970                                         r = -ENOMEM;
4971                                         goto finish;
4972                                 }
4973
4974                                 l = t;
4975                         }
4976
4977                         assert((unsigned) r < n);
4978
4979                         l[r] = strdup(de->d_name);
4980                         if (!l[r]) {
4981                                 r = -ENOMEM;
4982                                 goto finish;
4983                         }
4984
4985                         l[++r] = NULL;
4986                 } else
4987                         r++;
4988         }
4989
4990 finish:
4991         if (d)
4992                 closedir(d);
4993
4994         if (r >= 0) {
4995                 if (list)
4996                         *list = l;
4997         } else
4998                 strv_free(l);
4999
5000         return r;
5001 }
5002
5003 char *strjoin(const char *x, ...) {
5004         va_list ap;
5005         size_t l;
5006         char *r, *p;
5007
5008         va_start(ap, x);
5009
5010         if (x) {
5011                 l = strlen(x);
5012
5013                 for (;;) {
5014                         const char *t;
5015
5016                         t = va_arg(ap, const char *);
5017                         if (!t)
5018                                 break;
5019
5020                         l += strlen(t);
5021                 }
5022         } else
5023                 l = 0;
5024
5025         va_end(ap);
5026
5027         r = new(char, l+1);
5028         if (!r)
5029                 return NULL;
5030
5031         if (x) {
5032                 p = stpcpy(r, x);
5033
5034                 va_start(ap, x);
5035
5036                 for (;;) {
5037                         const char *t;
5038
5039                         t = va_arg(ap, const char *);
5040                         if (!t)
5041                                 break;
5042
5043                         p = stpcpy(p, t);
5044                 }
5045
5046                 va_end(ap);
5047         } else
5048                 r[0] = 0;
5049
5050         return r;
5051 }
5052
5053 bool is_main_thread(void) {
5054         static __thread int cached = 0;
5055
5056         if (_unlikely_(cached == 0))
5057                 cached = getpid() == gettid() ? 1 : -1;
5058
5059         return cached > 0;
5060 }
5061
5062 int block_get_whole_disk(dev_t d, dev_t *ret) {
5063         char *p, *s;
5064         int r;
5065         unsigned n, m;
5066
5067         assert(ret);
5068
5069         /* If it has a queue this is good enough for us */
5070         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
5071                 return -ENOMEM;
5072
5073         r = access(p, F_OK);
5074         free(p);
5075
5076         if (r >= 0) {
5077                 *ret = d;
5078                 return 0;
5079         }
5080
5081         /* If it is a partition find the originating device */
5082         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
5083                 return -ENOMEM;
5084
5085         r = access(p, F_OK);
5086         free(p);
5087
5088         if (r < 0)
5089                 return -ENOENT;
5090
5091         /* Get parent dev_t */
5092         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
5093                 return -ENOMEM;
5094
5095         r = read_one_line_file(p, &s);
5096         free(p);
5097
5098         if (r < 0)
5099                 return r;
5100
5101         r = sscanf(s, "%u:%u", &m, &n);
5102         free(s);
5103
5104         if (r != 2)
5105                 return -EINVAL;
5106
5107         /* Only return this if it is really good enough for us. */
5108         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
5109                 return -ENOMEM;
5110
5111         r = access(p, F_OK);
5112         free(p);
5113
5114         if (r >= 0) {
5115                 *ret = makedev(m, n);
5116                 return 0;
5117         }
5118
5119         return -ENOENT;
5120 }
5121
5122 int file_is_priv_sticky(const char *p) {
5123         struct stat st;
5124
5125         assert(p);
5126
5127         if (lstat(p, &st) < 0)
5128                 return -errno;
5129
5130         return
5131                 (st.st_uid == 0 || st.st_uid == getuid()) &&
5132                 (st.st_mode & S_ISVTX);
5133 }
5134
5135 static const char *const ioprio_class_table[] = {
5136         [IOPRIO_CLASS_NONE] = "none",
5137         [IOPRIO_CLASS_RT] = "realtime",
5138         [IOPRIO_CLASS_BE] = "best-effort",
5139         [IOPRIO_CLASS_IDLE] = "idle"
5140 };
5141
5142 DEFINE_STRING_TABLE_LOOKUP(ioprio_class, int);
5143
5144 static const char *const sigchld_code_table[] = {
5145         [CLD_EXITED] = "exited",
5146         [CLD_KILLED] = "killed",
5147         [CLD_DUMPED] = "dumped",
5148         [CLD_TRAPPED] = "trapped",
5149         [CLD_STOPPED] = "stopped",
5150         [CLD_CONTINUED] = "continued",
5151 };
5152
5153 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
5154
5155 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
5156         [LOG_FAC(LOG_KERN)] = "kern",
5157         [LOG_FAC(LOG_USER)] = "user",
5158         [LOG_FAC(LOG_MAIL)] = "mail",
5159         [LOG_FAC(LOG_DAEMON)] = "daemon",
5160         [LOG_FAC(LOG_AUTH)] = "auth",
5161         [LOG_FAC(LOG_SYSLOG)] = "syslog",
5162         [LOG_FAC(LOG_LPR)] = "lpr",
5163         [LOG_FAC(LOG_NEWS)] = "news",
5164         [LOG_FAC(LOG_UUCP)] = "uucp",
5165         [LOG_FAC(LOG_CRON)] = "cron",
5166         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
5167         [LOG_FAC(LOG_FTP)] = "ftp",
5168         [LOG_FAC(LOG_LOCAL0)] = "local0",
5169         [LOG_FAC(LOG_LOCAL1)] = "local1",
5170         [LOG_FAC(LOG_LOCAL2)] = "local2",
5171         [LOG_FAC(LOG_LOCAL3)] = "local3",
5172         [LOG_FAC(LOG_LOCAL4)] = "local4",
5173         [LOG_FAC(LOG_LOCAL5)] = "local5",
5174         [LOG_FAC(LOG_LOCAL6)] = "local6",
5175         [LOG_FAC(LOG_LOCAL7)] = "local7"
5176 };
5177
5178 DEFINE_STRING_TABLE_LOOKUP(log_facility_unshifted, int);
5179
5180 static const char *const log_level_table[] = {
5181         [LOG_EMERG] = "emerg",
5182         [LOG_ALERT] = "alert",
5183         [LOG_CRIT] = "crit",
5184         [LOG_ERR] = "err",
5185         [LOG_WARNING] = "warning",
5186         [LOG_NOTICE] = "notice",
5187         [LOG_INFO] = "info",
5188         [LOG_DEBUG] = "debug"
5189 };
5190
5191 DEFINE_STRING_TABLE_LOOKUP(log_level, int);
5192
5193 static const char* const sched_policy_table[] = {
5194         [SCHED_OTHER] = "other",
5195         [SCHED_BATCH] = "batch",
5196         [SCHED_IDLE] = "idle",
5197         [SCHED_FIFO] = "fifo",
5198         [SCHED_RR] = "rr"
5199 };
5200
5201 DEFINE_STRING_TABLE_LOOKUP(sched_policy, int);
5202
5203 static const char* const rlimit_table[] = {
5204         [RLIMIT_CPU] = "LimitCPU",
5205         [RLIMIT_FSIZE] = "LimitFSIZE",
5206         [RLIMIT_DATA] = "LimitDATA",
5207         [RLIMIT_STACK] = "LimitSTACK",
5208         [RLIMIT_CORE] = "LimitCORE",
5209         [RLIMIT_RSS] = "LimitRSS",
5210         [RLIMIT_NOFILE] = "LimitNOFILE",
5211         [RLIMIT_AS] = "LimitAS",
5212         [RLIMIT_NPROC] = "LimitNPROC",
5213         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5214         [RLIMIT_LOCKS] = "LimitLOCKS",
5215         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5216         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5217         [RLIMIT_NICE] = "LimitNICE",
5218         [RLIMIT_RTPRIO] = "LimitRTPRIO",
5219         [RLIMIT_RTTIME] = "LimitRTTIME"
5220 };
5221
5222 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5223
5224 static const char* const ip_tos_table[] = {
5225         [IPTOS_LOWDELAY] = "low-delay",
5226         [IPTOS_THROUGHPUT] = "throughput",
5227         [IPTOS_RELIABILITY] = "reliability",
5228         [IPTOS_LOWCOST] = "low-cost",
5229 };
5230
5231 DEFINE_STRING_TABLE_LOOKUP(ip_tos, int);
5232
5233 static const char *const __signal_table[] = {
5234         [SIGHUP] = "HUP",
5235         [SIGINT] = "INT",
5236         [SIGQUIT] = "QUIT",
5237         [SIGILL] = "ILL",
5238         [SIGTRAP] = "TRAP",
5239         [SIGABRT] = "ABRT",
5240         [SIGBUS] = "BUS",
5241         [SIGFPE] = "FPE",
5242         [SIGKILL] = "KILL",
5243         [SIGUSR1] = "USR1",
5244         [SIGSEGV] = "SEGV",
5245         [SIGUSR2] = "USR2",
5246         [SIGPIPE] = "PIPE",
5247         [SIGALRM] = "ALRM",
5248         [SIGTERM] = "TERM",
5249 #ifdef SIGSTKFLT
5250         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
5251 #endif
5252         [SIGCHLD] = "CHLD",
5253         [SIGCONT] = "CONT",
5254         [SIGSTOP] = "STOP",
5255         [SIGTSTP] = "TSTP",
5256         [SIGTTIN] = "TTIN",
5257         [SIGTTOU] = "TTOU",
5258         [SIGURG] = "URG",
5259         [SIGXCPU] = "XCPU",
5260         [SIGXFSZ] = "XFSZ",
5261         [SIGVTALRM] = "VTALRM",
5262         [SIGPROF] = "PROF",
5263         [SIGWINCH] = "WINCH",
5264         [SIGIO] = "IO",
5265         [SIGPWR] = "PWR",
5266         [SIGSYS] = "SYS"
5267 };
5268
5269 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5270
5271 const char *signal_to_string(int signo) {
5272         static __thread char buf[12];
5273         const char *name;
5274
5275         name = __signal_to_string(signo);
5276         if (name)
5277                 return name;
5278
5279         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5280                 snprintf(buf, sizeof(buf) - 1, "RTMIN+%d", signo - SIGRTMIN);
5281         else
5282                 snprintf(buf, sizeof(buf) - 1, "%d", signo);
5283         char_array_0(buf);
5284         return buf;
5285 }
5286
5287 int signal_from_string(const char *s) {
5288         int signo;
5289         int offset = 0;
5290         unsigned u;
5291
5292         signo =__signal_from_string(s);
5293         if (signo > 0)
5294                 return signo;
5295
5296         if (startswith(s, "RTMIN+")) {
5297                 s += 6;
5298                 offset = SIGRTMIN;
5299         }
5300         if (safe_atou(s, &u) >= 0) {
5301                 signo = (int) u + offset;
5302                 if (signo > 0 && signo < _NSIG)
5303                         return signo;
5304         }
5305         return -1;
5306 }
5307
5308 bool kexec_loaded(void) {
5309        bool loaded = false;
5310        char *s;
5311
5312        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5313                if (s[0] == '1')
5314                        loaded = true;
5315                free(s);
5316        }
5317        return loaded;
5318 }
5319
5320 int strdup_or_null(const char *a, char **b) {
5321         char *c;
5322
5323         assert(b);
5324
5325         if (!a) {
5326                 *b = NULL;
5327                 return 0;
5328         }
5329
5330         c = strdup(a);
5331         if (!c)
5332                 return -ENOMEM;
5333
5334         *b = c;
5335         return 0;
5336 }
5337
5338 int prot_from_flags(int flags) {
5339
5340         switch (flags & O_ACCMODE) {
5341
5342         case O_RDONLY:
5343                 return PROT_READ;
5344
5345         case O_WRONLY:
5346                 return PROT_WRITE;
5347
5348         case O_RDWR:
5349                 return PROT_READ|PROT_WRITE;
5350
5351         default:
5352                 return -EINVAL;
5353         }
5354 }
5355
5356 char *format_bytes(char *buf, size_t l, off_t t) {
5357         unsigned i;
5358
5359         static const struct {
5360                 const char *suffix;
5361                 off_t factor;
5362         } table[] = {
5363                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5364                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5365                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5366                 { "G", 1024ULL*1024ULL*1024ULL },
5367                 { "M", 1024ULL*1024ULL },
5368                 { "K", 1024ULL },
5369         };
5370
5371         for (i = 0; i < ELEMENTSOF(table); i++) {
5372
5373                 if (t >= table[i].factor) {
5374                         snprintf(buf, l,
5375                                  "%llu.%llu%s",
5376                                  (unsigned long long) (t / table[i].factor),
5377                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5378                                  table[i].suffix);
5379
5380                         goto finish;
5381                 }
5382         }
5383
5384         snprintf(buf, l, "%lluB", (unsigned long long) t);
5385
5386 finish:
5387         buf[l-1] = 0;
5388         return buf;
5389
5390 }
5391
5392 void* memdup(const void *p, size_t l) {
5393         void *r;
5394
5395         assert(p);
5396
5397         r = malloc(l);
5398         if (!r)
5399                 return NULL;
5400
5401         memcpy(r, p, l);
5402         return r;
5403 }
5404
5405 int fd_inc_sndbuf(int fd, size_t n) {
5406         int r, value;
5407         socklen_t l = sizeof(value);
5408
5409         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5410         if (r >= 0 &&
5411             l == sizeof(value) &&
5412             (size_t) value >= n*2)
5413                 return 0;
5414
5415         value = (int) n;
5416         r = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value));
5417         if (r < 0)
5418                 return -errno;
5419
5420         return 1;
5421 }
5422
5423 int fd_inc_rcvbuf(int fd, size_t n) {
5424         int r, value;
5425         socklen_t l = sizeof(value);
5426
5427         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5428         if (r >= 0 &&
5429             l == sizeof(value) &&
5430             (size_t) value >= n*2)
5431                 return 0;
5432
5433         value = (int) n;
5434         r = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value));
5435         if (r < 0)
5436                 return -errno;
5437
5438         return 1;
5439 }
5440
5441 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5442         pid_t parent_pid, agent_pid;
5443         int fd;
5444         bool stdout_is_tty, stderr_is_tty;
5445         unsigned n, i;
5446         va_list ap;
5447         char **l;
5448
5449         assert(pid);
5450         assert(path);
5451
5452         parent_pid = getpid();
5453
5454         /* Spawns a temporary TTY agent, making sure it goes away when
5455          * we go away */
5456
5457         agent_pid = fork();
5458         if (agent_pid < 0)
5459                 return -errno;
5460
5461         if (agent_pid != 0) {
5462                 *pid = agent_pid;
5463                 return 0;
5464         }
5465
5466         /* In the child:
5467          *
5468          * Make sure the agent goes away when the parent dies */
5469         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5470                 _exit(EXIT_FAILURE);
5471
5472         /* Check whether our parent died before we were able
5473          * to set the death signal */
5474         if (getppid() != parent_pid)
5475                 _exit(EXIT_SUCCESS);
5476
5477         /* Don't leak fds to the agent */
5478         close_all_fds(except, n_except);
5479
5480         stdout_is_tty = isatty(STDOUT_FILENO);
5481         stderr_is_tty = isatty(STDERR_FILENO);
5482
5483         if (!stdout_is_tty || !stderr_is_tty) {
5484                 /* Detach from stdout/stderr. and reopen
5485                  * /dev/tty for them. This is important to
5486                  * ensure that when systemctl is started via
5487                  * popen() or a similar call that expects to
5488                  * read EOF we actually do generate EOF and
5489                  * not delay this indefinitely by because we
5490                  * keep an unused copy of stdin around. */
5491                 fd = open("/dev/tty", O_WRONLY);
5492                 if (fd < 0) {
5493                         log_error("Failed to open /dev/tty: %m");
5494                         _exit(EXIT_FAILURE);
5495                 }
5496
5497                 if (!stdout_is_tty)
5498                         dup2(fd, STDOUT_FILENO);
5499
5500                 if (!stderr_is_tty)
5501                         dup2(fd, STDERR_FILENO);
5502
5503                 if (fd > 2)
5504                         close(fd);
5505         }
5506
5507         /* Count arguments */
5508         va_start(ap, path);
5509         for (n = 0; va_arg(ap, char*); n++)
5510                 ;
5511         va_end(ap);
5512
5513         /* Allocate strv */
5514         l = alloca(sizeof(char *) * (n + 1));
5515
5516         /* Fill in arguments */
5517         va_start(ap, path);
5518         for (i = 0; i <= n; i++)
5519                 l[i] = va_arg(ap, char*);
5520         va_end(ap);
5521
5522         execv(path, l);
5523         _exit(EXIT_FAILURE);
5524 }
5525
5526 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5527         struct rlimit highest, fixed;
5528
5529         assert(rlim);
5530
5531         if (setrlimit(resource, rlim) >= 0)
5532                 return 0;
5533
5534         if (errno != EPERM)
5535                 return -errno;
5536
5537         /* So we failed to set the desired setrlimit, then let's try
5538          * to get as close as we can */
5539         assert_se(getrlimit(resource, &highest) == 0);
5540
5541         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5542         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5543
5544         if (setrlimit(resource, &fixed) < 0)
5545                 return -errno;
5546
5547         return 0;
5548 }
5549
5550 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5551         char path[sizeof("/proc/")-1+10+sizeof("/environ")], *value = NULL;
5552         int r;
5553         FILE *f;
5554         bool done = false;
5555         size_t l;
5556
5557         assert(field);
5558         assert(_value);
5559
5560         if (pid == 0)
5561                 pid = getpid();
5562
5563         snprintf(path, sizeof(path), "/proc/%lu/environ", (unsigned long) pid);
5564         char_array_0(path);
5565
5566         f = fopen(path, "re");
5567         if (!f)
5568                 return -errno;
5569
5570         l = strlen(field);
5571         r = 0;
5572
5573         do {
5574                 char line[LINE_MAX];
5575                 unsigned i;
5576
5577                 for (i = 0; i < sizeof(line)-1; i++) {
5578                         int c;
5579
5580                         c = getc(f);
5581                         if (_unlikely_(c == EOF)) {
5582                                 done = true;
5583                                 break;
5584                         } else if (c == 0)
5585                                 break;
5586
5587                         line[i] = c;
5588                 }
5589                 line[i] = 0;
5590
5591                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5592                         value = strdup(line + l + 1);
5593                         if (!value) {
5594                                 r = -ENOMEM;
5595                                 break;
5596                         }
5597
5598                         r = 1;
5599                         break;
5600                 }
5601
5602         } while (!done);
5603
5604         fclose(f);
5605
5606         if (r >= 0)
5607                 *_value = value;
5608
5609         return r;
5610 }
5611
5612 int can_sleep(const char *type) {
5613         char *w, *state;
5614         size_t l, k;
5615         int r;
5616         _cleanup_free_ char *p = NULL;
5617
5618         assert(type);
5619
5620         r = read_one_line_file("/sys/power/state", &p);
5621         if (r < 0)
5622                 return r == -ENOENT ? 0 : r;
5623
5624         k = strlen(type);
5625         FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state)
5626                 if (l == k && memcmp(w, type, l) == 0)
5627                         return true;
5628
5629         return false;
5630 }
5631
5632 bool is_valid_documentation_url(const char *url) {
5633         assert(url);
5634
5635         if (startswith(url, "http://") && url[7])
5636                 return true;
5637
5638         if (startswith(url, "https://") && url[8])
5639                 return true;
5640
5641         if (startswith(url, "file:") && url[5])
5642                 return true;
5643
5644         if (startswith(url, "info:") && url[5])
5645                 return true;
5646
5647         if (startswith(url, "man:") && url[4])
5648                 return true;
5649
5650         return false;
5651 }
5652
5653 bool in_initrd(void) {
5654         static __thread int saved = -1;
5655         struct statfs s;
5656
5657         if (saved >= 0)
5658                 return saved;
5659
5660         /* We make two checks here:
5661          *
5662          * 1. the flag file /etc/initrd-release must exist
5663          * 2. the root file system must be a memory file system
5664          *
5665          * The second check is extra paranoia, since misdetecting an
5666          * initrd can have bad bad consequences due the initrd
5667          * emptying when transititioning to the main systemd.
5668          */
5669
5670         saved = access("/etc/initrd-release", F_OK) >= 0 &&
5671                 statfs("/", &s) >= 0 &&
5672                 (s.f_type == TMPFS_MAGIC || s.f_type == RAMFS_MAGIC);
5673
5674         return saved;
5675 }
5676
5677 void warn_melody(void) {
5678         _cleanup_close_ int fd = -1;
5679
5680         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5681         if (fd < 0)
5682                 return;
5683
5684         /* Yeah, this is synchronous. Kinda sucks. Bute well... */
5685
5686         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5687         usleep(125*USEC_PER_MSEC);
5688
5689         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5690         usleep(125*USEC_PER_MSEC);
5691
5692         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5693         usleep(125*USEC_PER_MSEC);
5694
5695         ioctl(fd, KIOCSOUND, 0);
5696 }
5697
5698 int make_console_stdio(void) {
5699         int fd, r;
5700
5701         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5702
5703         fd = acquire_terminal("/dev/console", false, true, true, (usec_t) -1);
5704         if (fd < 0) {
5705                 log_error("Failed to acquire terminal: %s", strerror(-fd));
5706                 return fd;
5707         }
5708
5709         r = make_stdio(fd);
5710         if (r < 0) {
5711                 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
5712                 return r;
5713         }
5714
5715         return 0;
5716 }
5717
5718 int get_home_dir(char **_h) {
5719         char *h;
5720         const char *e;
5721         uid_t u;
5722         struct passwd *p;
5723
5724         assert(_h);
5725
5726         /* Take the user specified one */
5727         e = getenv("HOME");
5728         if (e) {
5729                 h = strdup(e);
5730                 if (!h)
5731                         return -ENOMEM;
5732
5733                 *_h = h;
5734                 return 0;
5735         }
5736
5737         /* Hardcode home directory for root to avoid NSS */
5738         u = getuid();
5739         if (u == 0) {
5740                 h = strdup("/root");
5741                 if (!h)
5742                         return -ENOMEM;
5743
5744                 *_h = h;
5745                 return 0;
5746         }
5747
5748         /* Check the database... */
5749         errno = 0;
5750         p = getpwuid(u);
5751         if (!p)
5752                 return errno ? -errno : -ESRCH;
5753
5754         if (!path_is_absolute(p->pw_dir))
5755                 return -EINVAL;
5756
5757         h = strdup(p->pw_dir);
5758         if (!h)
5759                 return -ENOMEM;
5760
5761         *_h = h;
5762         return 0;
5763 }
5764
5765 int get_shell(char **_sh) {
5766         char *sh;
5767         const char *e;
5768         uid_t u;
5769         struct passwd *p;
5770
5771         assert(_sh);
5772
5773         /* Take the user specified one */
5774         e = getenv("SHELL");
5775         if (e) {
5776                 sh = strdup(e);
5777                 if (!sh)
5778                         return -ENOMEM;
5779
5780                 *_sh = sh;
5781                 return 0;
5782         }
5783
5784         /* Hardcode home directory for root to avoid NSS */
5785         u = getuid();
5786         if (u == 0) {
5787                 sh = strdup("/bin/sh");
5788                 if (!sh)
5789                         return -ENOMEM;
5790
5791                 *_sh = sh;
5792                 return 0;
5793         }
5794
5795         /* Check the database... */
5796         errno = 0;
5797         p = getpwuid(u);
5798         if (!p)
5799                 return errno ? -errno : -ESRCH;
5800
5801         if (!path_is_absolute(p->pw_shell))
5802                 return -EINVAL;
5803
5804         sh = strdup(p->pw_shell);
5805         if (!sh)
5806                 return -ENOMEM;
5807
5808         *_sh = sh;
5809         return 0;
5810 }
5811
5812 void freep(void *p) {
5813         free(*(void**) p);
5814 }
5815
5816 void fclosep(FILE **f) {
5817         if (*f)
5818                 fclose(*f);
5819 }
5820
5821 void closep(int *fd) {
5822         if (*fd >= 0)
5823                 close_nointr_nofail(*fd);
5824 }
5825
5826 void closedirp(DIR **d) {
5827         if (*d)
5828                 closedir(*d);
5829 }
5830
5831 void umaskp(mode_t *u) {
5832         umask(*u);
5833 }