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