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 #include <limits.h>
  60
  61 #include "macro.h"
  62 #include "util.h"
  63 #include "ioprio.h"
  64 #include "missing.h"
  65 #include "log.h"
  66 #include "strv.h"
  67 #include "label.h"
  68 #include "path-util.h"
  69 #include "exit-status.h"
  70 #include "hashmap.h"
  71
  72 int saved_argc = 0;
  73 char **saved_argv = NULL;
  74
  75 static volatile unsigned cached_columns = 0;
  76 static volatile unsigned cached_lines = 0;
  77
  78 size_t page_size(void) {
  79         static __thread size_t pgsz = 0;
  80         long r;
  81
  82         if (_likely_(pgsz > 0))
  83                 return pgsz;
  84
  85         r = sysconf(_SC_PAGESIZE);
  86         assert(r > 0);
  87
  88         pgsz = (size_t) r;
  89         return pgsz;
  90 }
  91
  92 bool streq_ptr(const char *a, const char *b) {
  93
  94         /* Like streq(), but tries to make sense of NULL pointers */
  95
  96         if (a && b)
  97                 return streq(a, b);
  98
  99         if (!a && !b)
 100                 return true;
 101
 102         return false;
 103 }
 104
 105 usec_t now(clockid_t clock_id) {
 106         struct timespec ts;
 107
 108         assert_se(clock_gettime(clock_id, &ts) == 0);
 109
 110         return timespec_load(&ts);
 111 }
 112
 113 dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
 114         assert(ts);
 115
 116         ts->realtime = now(CLOCK_REALTIME);
 117         ts->monotonic = now(CLOCK_MONOTONIC);
 118
 119         return ts;
 120 }
 121
 122 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
 123         int64_t delta;
 124         assert(ts);
 125
 126         ts->realtime = u;
 127
 128         if (u == 0)
 129                 ts->monotonic = 0;
 130         else {
 131                 delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
 132
 133                 ts->monotonic = now(CLOCK_MONOTONIC);
 134
 135                 if ((int64_t) ts->monotonic > delta)
 136                         ts->monotonic -= delta;
 137                 else
 138                         ts->monotonic = 0;
 139         }
 140
 141         return ts;
 142 }
 143
 144 usec_t timespec_load(const struct timespec *ts) {
 145         assert(ts);
 146
 147         if (ts->tv_sec == (time_t) -1 &&
 148             ts->tv_nsec == (long) -1)
 149                 return (usec_t) -1;
 150
 151         return
 152                 (usec_t) ts->tv_sec * USEC_PER_SEC +
 153                 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
 154 }
 155
 156 struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
 157         assert(ts);
 158
 159         if (u == (usec_t) -1) {
 160                 ts->tv_sec = (time_t) -1;
 161                 ts->tv_nsec = (long) -1;
 162                 return ts;
 163         }
 164
 165         ts->tv_sec = (time_t) (u / USEC_PER_SEC);
 166         ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
 167
 168         return ts;
 169 }
 170
 171 usec_t timeval_load(const struct timeval *tv) {
 172         assert(tv);
 173
 174         if (tv->tv_sec == (time_t) -1 &&
 175             tv->tv_usec == (suseconds_t) -1)
 176                 return (usec_t) -1;
 177
 178         return
 179                 (usec_t) tv->tv_sec * USEC_PER_SEC +
 180                 (usec_t) tv->tv_usec;
 181 }
 182
 183 struct timeval *timeval_store(struct timeval *tv, usec_t u) {
 184         assert(tv);
 185
 186         if (u == (usec_t) -1) {
 187                 tv->tv_sec = (time_t) -1;
 188                 tv->tv_usec = (suseconds_t) -1;
 189                 return tv;
 190         }
 191
 192         tv->tv_sec = (time_t) (u / USEC_PER_SEC);
 193         tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
 194
 195         return tv;
 196 }
 197
 198 char* endswith(const char *s, const char *postfix) {
 199         size_t sl, pl;
 200
 201         assert(s);
 202         assert(postfix);
 203
 204         sl = strlen(s);
 205         pl = strlen(postfix);
 206
 207         if (pl == 0)
 208                 return (char*) s + sl;
 209
 210         if (sl < pl)
 211                 return NULL;
 212
 213         if (memcmp(s + sl - pl, postfix, pl) != 0)
 214                 return NULL;
 215
 216         return (char*) s + sl - pl;
 217 }
 218
 219 char* startswith(const char *s, const char *prefix) {
 220         const char *a, *b;
 221
 222         assert(s);
 223         assert(prefix);
 224
 225         a = s, b = prefix;
 226         for (;;) {
 227                 if (*b == 0)
 228                         return (char*) a;
 229                 if (*a != *b)
 230                         return NULL;
 231
 232                 a++, b++;
 233         }
 234 }
 235
 236 char* startswith_no_case(const char *s, const char *prefix) {
 237         const char *a, *b;
 238
 239         assert(s);
 240         assert(prefix);
 241
 242         a = s, b = prefix;
 243         for (;;) {
 244                 if (*b == 0)
 245                         return (char*) a;
 246                 if (tolower(*a) != tolower(*b))
 247                         return NULL;
 248
 249                 a++, b++;
 250         }
 251 }
 252
 253 bool first_word(const char *s, const char *word) {
 254         size_t sl, wl;
 255
 256         assert(s);
 257         assert(word);
 258
 259         sl = strlen(s);
 260         wl = strlen(word);
 261
 262         if (sl < wl)
 263                 return false;
 264
 265         if (wl == 0)
 266                 return true;
 267
 268         if (memcmp(s, word, wl) != 0)
 269                 return false;
 270
 271         return s[wl] == 0 ||
 272                 strchr(WHITESPACE, s[wl]);
 273 }
 274
 275 int close_nointr(int fd) {
 276         assert(fd >= 0);
 277
 278         for (;;) {
 279                 int r;
 280
 281                 r = close(fd);
 282                 if (r >= 0)
 283                         return r;
 284
 285                 if (errno != EINTR)
 286                         return -errno;
 287         }
 288 }
 289
 290 void close_nointr_nofail(int fd) {
 291         int saved_errno = errno;
 292
 293         /* like close_nointr() but cannot fail, and guarantees errno
 294          * is unchanged */
 295
 296         assert_se(close_nointr(fd) == 0);
 297
 298         errno = saved_errno;
 299 }
 300
 301 void close_many(const int fds[], unsigned n_fd) {
 302         unsigned i;
 303
 304         for (i = 0; i < n_fd; i++)
 305                 close_nointr_nofail(fds[i]);
 306 }
 307
 308 int parse_boolean(const char *v) {
 309         assert(v);
 310
 311         if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
 312                 return 1;
 313         else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
 314                 return 0;
 315
 316         return -EINVAL;
 317 }
 318
 319 int parse_pid(const char *s, pid_t* ret_pid) {
 320         unsigned long ul = 0;
 321         pid_t pid;
 322         int r;
 323
 324         assert(s);
 325         assert(ret_pid);
 326
 327         r = safe_atolu(s, &ul);
 328         if (r < 0)
 329                 return r;
 330
 331         pid = (pid_t) ul;
 332
 333         if ((unsigned long) pid != ul)
 334                 return -ERANGE;
 335
 336         if (pid <= 0)
 337                 return -ERANGE;
 338
 339         *ret_pid = pid;
 340         return 0;
 341 }
 342
 343 int parse_uid(const char *s, uid_t* ret_uid) {
 344         unsigned long ul = 0;
 345         uid_t uid;
 346         int r;
 347
 348         assert(s);
 349         assert(ret_uid);
 350
 351         r = safe_atolu(s, &ul);
 352         if (r < 0)
 353                 return r;
 354
 355         uid = (uid_t) ul;
 356
 357         if ((unsigned long) uid != ul)
 358                 return -ERANGE;
 359
 360         *ret_uid = uid;
 361         return 0;
 362 }
 363
 364 int safe_atou(const char *s, unsigned *ret_u) {
 365         char *x = NULL;
 366         unsigned long l;
 367
 368         assert(s);
 369         assert(ret_u);
 370
 371         errno = 0;
 372         l = strtoul(s, &x, 0);
 373
 374         if (!x || *x || errno)
 375                 return errno ? -errno : -EINVAL;
 376
 377         if ((unsigned long) (unsigned) l != l)
 378                 return -ERANGE;
 379
 380         *ret_u = (unsigned) l;
 381         return 0;
 382 }
 383
 384 int safe_atoi(const char *s, int *ret_i) {
 385         char *x = NULL;
 386         long l;
 387
 388         assert(s);
 389         assert(ret_i);
 390
 391         errno = 0;
 392         l = strtol(s, &x, 0);
 393
 394         if (!x || *x || errno)
 395                 return errno ? -errno : -EINVAL;
 396
 397         if ((long) (int) l != l)
 398                 return -ERANGE;
 399
 400         *ret_i = (int) l;
 401         return 0;
 402 }
 403
 404 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 405         char *x = NULL;
 406         unsigned long long l;
 407
 408         assert(s);
 409         assert(ret_llu);
 410
 411         errno = 0;
 412         l = strtoull(s, &x, 0);
 413
 414         if (!x || *x || errno)
 415                 return errno ? -errno : -EINVAL;
 416
 417         *ret_llu = l;
 418         return 0;
 419 }
 420
 421 int safe_atolli(const char *s, long long int *ret_lli) {
 422         char *x = NULL;
 423         long long l;
 424
 425         assert(s);
 426         assert(ret_lli);
 427
 428         errno = 0;
 429         l = strtoll(s, &x, 0);
 430
 431         if (!x || *x || errno)
 432                 return errno ? -errno : -EINVAL;
 433
 434         *ret_lli = l;
 435         return 0;
 436 }
 437
 438 /* Split a string into words. */
 439 char *split(const char *c, size_t *l, const char *separator, char **state) {
 440         char *current;
 441
 442         current = *state ? *state : (char*) c;
 443
 444         if (!*current || *c == 0)
 445                 return NULL;
 446
 447         current += strspn(current, separator);
 448         *l = strcspn(current, separator);
 449         *state = current+*l;
 450
 451         return (char*) current;
 452 }
 453
 454 /* Split a string into words, but consider strings enclosed in '' and
 455  * "" as words even if they include spaces. */
 456 char *split_quoted(const char *c, size_t *l, char **state) {
 457         char *current, *e;
 458         bool escaped = false;
 459
 460         current = *state ? *state : (char*) c;
 461
 462         if (!*current || *c == 0)
 463                 return NULL;
 464
 465         current += strspn(current, WHITESPACE);
 466
 467         if (*current == '\'') {
 468                 current ++;
 469
 470                 for (e = current; *e; e++) {
 471                         if (escaped)
 472                                 escaped = false;
 473                         else if (*e == '\\')
 474                                 escaped = true;
 475                         else if (*e == '\'')
 476                                 break;
 477                 }
 478
 479                 *l = e-current;
 480                 *state = *e == 0 ? e : e+1;
 481         } else if (*current == '\"') {
 482                 current ++;
 483
 484                 for (e = current; *e; e++) {
 485                         if (escaped)
 486                                 escaped = false;
 487                         else if (*e == '\\')
 488                                 escaped = true;
 489                         else if (*e == '\"')
 490                                 break;
 491                 }
 492
 493                 *l = e-current;
 494                 *state = *e == 0 ? e : e+1;
 495         } else {
 496                 for (e = current; *e; e++) {
 497                         if (escaped)
 498                                 escaped = false;
 499                         else if (*e == '\\')
 500                                 escaped = true;
 501                         else if (strchr(WHITESPACE, *e))
 502                                 break;
 503                 }
 504                 *l = e-current;
 505                 *state = e;
 506         }
 507
 508         return (char*) current;
 509 }
 510
 511 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
 512         int r;
 513         _cleanup_fclose_ FILE *f = NULL;
 514         char fn[PATH_MAX], line[LINE_MAX], *p;
 515         long unsigned ppid;
 516
 517         assert(pid > 0);
 518         assert(_ppid);
 519
 520         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
 521         char_array_0(fn);
 522
 523         f = fopen(fn, "re");
 524         if (!f)
 525                 return -errno;
 526
 527         if (!fgets(line, sizeof(line), f)) {
 528                 r = feof(f) ? -EIO : -errno;
 529                 fclose(f);
 530                 return r;
 531         }
 532
 533         /* Let's skip the pid and comm fields. The latter is enclosed
 534          * in () but does not escape any () in its value, so let's
 535          * skip over it manually */
 536
 537         p = strrchr(line, ')');
 538         if (!p)
 539                 return -EIO;
 540
 541         p++;
 542
 543         if (sscanf(p, " "
 544                    "%*c "  /* state */
 545                    "%lu ", /* ppid */
 546                    &ppid) != 1)
 547                 return -EIO;
 548
 549         if ((long unsigned) (pid_t) ppid != ppid)
 550                 return -ERANGE;
 551
 552         *_ppid = (pid_t) ppid;
 553
 554         return 0;
 555 }
 556
 557 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
 558         _cleanup_fclose_ FILE *f = NULL;
 559         char fn[PATH_MAX], line[LINE_MAX], *p;
 560
 561         assert(pid > 0);
 562         assert(st);
 563
 564         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
 565         char_array_0(fn);
 566
 567         f = fopen(fn, "re");
 568         if (!f)
 569                 return -errno;
 570
 571         if (!fgets(line, sizeof(line), f)) {
 572                 if (ferror(f))
 573                         return -errno;
 574
 575                 return -EIO;
 576         }
 577
 578         /* Let's skip the pid and comm fields. The latter is enclosed
 579          * in () but does not escape any () in its value, so let's
 580          * skip over it manually */
 581
 582         p = strrchr(line, ')');
 583         if (!p)
 584                 return -EIO;
 585
 586         p++;
 587
 588         if (sscanf(p, " "
 589                    "%*c "  /* state */
 590                    "%*d "  /* ppid */
 591                    "%*d "  /* pgrp */
 592                    "%*d "  /* session */
 593                    "%*d "  /* tty_nr */
 594                    "%*d "  /* tpgid */
 595                    "%*u "  /* flags */
 596                    "%*u "  /* minflt */
 597                    "%*u "  /* cminflt */
 598                    "%*u "  /* majflt */
 599                    "%*u "  /* cmajflt */
 600                    "%*u "  /* utime */
 601                    "%*u "  /* stime */
 602                    "%*d "  /* cutime */
 603                    "%*d "  /* cstime */
 604                    "%*d "  /* priority */
 605                    "%*d "  /* nice */
 606                    "%*d "  /* num_threads */
 607                    "%*d "  /* itrealvalue */
 608                    "%llu "  /* starttime */,
 609                    st) != 1)
 610                 return -EIO;
 611
 612         return 0;
 613 }
 614
 615 int write_one_line_file(const char *fn, const char *line) {
 616         _cleanup_fclose_ FILE *f = NULL;
 617
 618         assert(fn);
 619         assert(line);
 620
 621         f = fopen(fn, "we");
 622         if (!f)
 623                 return -errno;
 624
 625         errno = 0;
 626         if (fputs(line, f) < 0)
 627                 return errno ? -errno : -EIO;
 628
 629         if (!endswith(line, "\n"))
 630                 fputc('\n', f);
 631
 632         fflush(f);
 633
 634         if (ferror(f))
 635                 return errno ? -errno : -EIO;
 636
 637         return 0;
 638 }
 639
 640 int fchmod_umask(int fd, mode_t m) {
 641         mode_t u;
 642         int r;
 643
 644         u = umask(0777);
 645         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 646         umask(u);
 647
 648         return r;
 649 }
 650
 651 int write_one_line_file_atomic(const char *fn, const char *line) {
 652         FILE *f;
 653         int r;
 654         char *p;
 655
 656         assert(fn);
 657         assert(line);
 658
 659         r = fopen_temporary(fn, &f, &p);
 660         if (r < 0)
 661                 return r;
 662
 663         fchmod_umask(fileno(f), 0644);
 664
 665         errno = 0;
 666         if (fputs(line, f) < 0) {
 667                 r = -errno;
 668                 goto finish;
 669         }
 670
 671         if (!endswith(line, "\n"))
 672                 fputc('\n', f);
 673
 674         fflush(f);
 675
 676         if (ferror(f)) {
 677                 if (errno != 0)
 678                         r = -errno;
 679                 else
 680                         r = -EIO;
 681         } else {
 682                 if (rename(p, fn) < 0)
 683                         r = -errno;
 684                 else
 685                         r = 0;
 686         }
 687
 688 finish:
 689         if (r < 0)
 690                 unlink(p);
 691
 692         fclose(f);
 693         free(p);
 694
 695         return r;
 696 }
 697
 698 int read_one_line_file(const char *fn, char **line) {
 699         _cleanup_fclose_ FILE *f = NULL;
 700         char t[LINE_MAX], *c;
 701
 702         assert(fn);
 703         assert(line);
 704
 705         f = fopen(fn, "re");
 706         if (!f)
 707                 return -errno;
 708
 709         if (!fgets(t, sizeof(t), f)) {
 710
 711                 if (ferror(f))
 712                         return errno ? -errno : -EIO;
 713
 714                 t[0] = 0;
 715         }
 716
 717         c = strdup(t);
 718         if (!c)
 719                 return -ENOMEM;
 720         truncate_nl(c);
 721
 722         *line = c;
 723         return 0;
 724 }
 725
 726 int read_full_file(const char *fn, char **contents, size_t *size) {
 727         _cleanup_fclose_ FILE *f = NULL;
 728         size_t n, l;
 729         _cleanup_free_ char *buf = NULL;
 730         struct stat st;
 731
 732         f = fopen(fn, "re");
 733         if (!f)
 734                 return -errno;
 735
 736         if (fstat(fileno(f), &st) < 0)
 737                 return -errno;
 738
 739         /* Safety check */
 740         if (st.st_size > 4*1024*1024)
 741                 return -E2BIG;
 742
 743         n = st.st_size > 0 ? st.st_size : LINE_MAX;
 744         l = 0;
 745
 746         for (;;) {
 747                 char *t;
 748                 size_t k;
 749
 750                 t = realloc(buf, n+1);
 751                 if (!t)
 752                         return -ENOMEM;
 753
 754                 buf = t;
 755                 k = fread(buf + l, 1, n - l, f);
 756
 757                 if (k <= 0) {
 758                         if (ferror(f))
 759                                 return -errno;
 760
 761                         break;
 762                 }
 763
 764                 l += k;
 765                 n *= 2;
 766
 767                 /* Safety check */
 768                 if (n > 4*1024*1024)
 769                         return -E2BIG;
 770         }
 771
 772         buf[l] = 0;
 773         *contents = buf;
 774         buf = NULL;
 775
 776         if (size)
 777                 *size = l;
 778
 779         return 0;
 780 }
 781
 782 int parse_env_file(
 783                 const char *fname,
 784                 const char *separator, ...) {
 785
 786         int r = 0;
 787         char *contents = NULL, *p;
 788
 789         assert(fname);
 790         assert(separator);
 791
 792         if ((r = read_full_file(fname, &contents, NULL)) < 0)
 793                 return r;
 794
 795         p = contents;
 796         for (;;) {
 797                 const char *key = NULL;
 798
 799                 p += strspn(p, separator);
 800                 p += strspn(p, WHITESPACE);
 801
 802                 if (!*p)
 803                         break;
 804
 805                 if (!strchr(COMMENTS, *p)) {
 806                         va_list ap;
 807                         char **value;
 808
 809                         va_start(ap, separator);
 810                         while ((key = va_arg(ap, char *))) {
 811                                 size_t n;
 812                                 char *v;
 813
 814                                 value = va_arg(ap, char **);
 815
 816                                 n = strlen(key);
 817                                 if (strncmp(p, key, n) != 0 ||
 818                                     p[n] != '=')
 819                                         continue;
 820
 821                                 p += n + 1;
 822                                 n = strcspn(p, separator);
 823
 824                                 if (n >= 2 &&
 825                                     strchr(QUOTES, p[0]) &&
 826                                     p[n-1] == p[0])
 827                                         v = strndup(p+1, n-2);
 828                                 else
 829                                         v = strndup(p, n);
 830
 831                                 if (!v) {
 832                                         r = -ENOMEM;
 833                                         va_end(ap);
 834                                         goto fail;
 835                                 }
 836
 837                                 if (v[0] == '\0') {
 838                                         /* return empty value strings as NULL */
 839                                         free(v);
 840                                         v = NULL;
 841                                 }
 842
 843                                 free(*value);
 844                                 *value = v;
 845
 846                                 p += n;
 847
 848                                 r ++;
 849                                 break;
 850                         }
 851                         va_end(ap);
 852                 }
 853
 854                 if (!key)
 855                         p += strcspn(p, separator);
 856         }
 857
 858 fail:
 859         free(contents);
 860         return r;
 861 }
 862
 863 int load_env_file(
 864                 const char *fname,
 865                 char ***rl) {
 866
 867         FILE *f;
 868         char **m = NULL;
 869         int r;
 870
 871         assert(fname);
 872         assert(rl);
 873
 874         if (!(f = fopen(fname, "re")))
 875                 return -errno;
 876
 877         while (!feof(f)) {
 878                 char l[LINE_MAX], *p, *u;
 879                 char **t;
 880
 881                 if (!fgets(l, sizeof(l), f)) {
 882                         if (feof(f))
 883                                 break;
 884
 885                         r = -errno;
 886                         goto finish;
 887                 }
 888
 889                 p = strstrip(l);
 890
 891                 if (!*p)
 892                         continue;
 893
 894                 if (strchr(COMMENTS, *p))
 895                         continue;
 896
 897                 if (!(u = normalize_env_assignment(p))) {
 898                         r = log_oom();
 899                         goto finish;
 900                 }
 901
 902                 t = strv_append(m, u);
 903                 free(u);
 904
 905                 if (!t) {
 906                         r = log_oom();
 907                         goto finish;
 908                 }
 909
 910                 strv_free(m);
 911                 m = t;
 912         }
 913
 914         r = 0;
 915
 916         *rl = m;
 917         m = NULL;
 918
 919 finish:
 920         if (f)
 921                 fclose(f);
 922
 923         strv_free(m);
 924
 925         return r;
 926 }
 927
 928 int write_env_file(const char *fname, char **l) {
 929         char **i, *p;
 930         FILE *f;
 931         int r;
 932
 933         r = fopen_temporary(fname, &f, &p);
 934         if (r < 0)
 935                 return r;
 936
 937         fchmod_umask(fileno(f), 0644);
 938
 939         errno = 0;
 940         STRV_FOREACH(i, l) {
 941                 fputs(*i, f);
 942                 fputc('\n', f);
 943         }
 944
 945         fflush(f);
 946
 947         if (ferror(f)) {
 948                 if (errno != 0)
 949                         r = -errno;
 950                 else
 951                         r = -EIO;
 952         } else {
 953                 if (rename(p, fname) < 0)
 954                         r = -errno;
 955                 else
 956                         r = 0;
 957         }
 958
 959         if (r < 0)
 960                 unlink(p);
 961
 962         fclose(f);
 963         free(p);
 964
 965         return r;
 966 }
 967
 968 char *truncate_nl(char *s) {
 969         assert(s);
 970
 971         s[strcspn(s, NEWLINE)] = 0;
 972         return s;
 973 }
 974
 975 int get_process_comm(pid_t pid, char **name) {
 976         int r;
 977
 978         assert(name);
 979
 980         if (pid == 0)
 981                 r = read_one_line_file("/proc/self/comm", name);
 982         else {
 983                 char *p;
 984                 if (asprintf(&p, "/proc/%lu/comm", (unsigned long) pid) < 0)
 985                         return -ENOMEM;
 986
 987                 r = read_one_line_file(p, name);
 988                 free(p);
 989         }
 990
 991         return r;
 992 }
 993
 994 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
 995         char *r, *k;
 996         int c;
 997         bool space = false;
 998         size_t left;
 999         FILE *f;
1000
1001         assert(max_length > 0);
1002         assert(line);
1003
1004         if (pid == 0)
1005                 f = fopen("/proc/self/cmdline", "re");
1006         else {
1007                 char *p;
1008                 if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
1009                         return -ENOMEM;
1010
1011                 f = fopen(p, "re");
1012                 free(p);
1013         }
1014
1015         if (!f)
1016                 return -errno;
1017
1018         r = new(char, max_length);
1019         if (!r) {
1020                 fclose(f);
1021                 return -ENOMEM;
1022         }
1023
1024         k = r;
1025         left = max_length;
1026         while ((c = getc(f)) != EOF) {
1027
1028                 if (isprint(c)) {
1029                         if (space) {
1030                                 if (left <= 4)
1031                                         break;
1032
1033                                 *(k++) = ' ';
1034                                 left--;
1035                                 space = false;
1036                         }
1037
1038                         if (left <= 4)
1039                                 break;
1040
1041                         *(k++) = (char) c;
1042                         left--;
1043                 }  else
1044                         space = true;
1045         }
1046
1047         if (left <= 4) {
1048                 size_t n = MIN(left-1, 3U);
1049                 memcpy(k, "...", n);
1050                 k[n] = 0;
1051         } else
1052                 *k = 0;
1053
1054         fclose(f);
1055
1056         /* Kernel threads have no argv[] */
1057         if (r[0] == 0) {
1058                 char *t;
1059                 int h;
1060
1061                 free(r);
1062
1063                 if (!comm_fallback)
1064                         return -ENOENT;
1065
1066                 h = get_process_comm(pid, &t);
1067                 if (h < 0)
1068                         return h;
1069
1070                 r = strjoin("[", t, "]", NULL);
1071                 free(t);
1072
1073                 if (!r)
1074                         return -ENOMEM;
1075         }
1076
1077         *line = r;
1078         return 0;
1079 }
1080
1081 int is_kernel_thread(pid_t pid) {
1082         char *p;
1083         size_t count;
1084         char c;
1085         bool eof;
1086         FILE *f;
1087
1088         if (pid == 0)
1089                 return 0;
1090
1091         if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
1092                 return -ENOMEM;
1093
1094         f = fopen(p, "re");
1095         free(p);
1096
1097         if (!f)
1098                 return -errno;
1099
1100         count = fread(&c, 1, 1, f);
1101         eof = feof(f);
1102         fclose(f);
1103
1104         /* Kernel threads have an empty cmdline */
1105
1106         if (count <= 0)
1107                 return eof ? 1 : -errno;
1108
1109         return 0;
1110 }
1111
1112 int get_process_exe(pid_t pid, char **name) {
1113         int r;
1114
1115         assert(name);
1116
1117         if (pid == 0)
1118                 r = readlink_malloc("/proc/self/exe", name);
1119         else {
1120                 char *p;
1121                 if (asprintf(&p, "/proc/%lu/exe", (unsigned long) pid) < 0)
1122                         return -ENOMEM;
1123
1124                 r = readlink_malloc(p, name);
1125                 free(p);
1126         }
1127
1128         return r;
1129 }
1130
1131 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
1132         char *p;
1133         FILE *f;
1134         int r;
1135
1136         assert(uid);
1137
1138         if (pid == 0)
1139                 return getuid();
1140
1141         if (asprintf(&p, "/proc/%lu/status", (unsigned long) pid) < 0)
1142                 return -ENOMEM;
1143
1144         f = fopen(p, "re");
1145         free(p);
1146
1147         if (!f)
1148                 return -errno;
1149
1150         while (!feof(f)) {
1151                 char line[LINE_MAX], *l;
1152
1153                 if (!fgets(line, sizeof(line), f)) {
1154                         if (feof(f))
1155                                 break;
1156
1157                         r = -errno;
1158                         goto finish;
1159                 }
1160
1161                 l = strstrip(line);
1162
1163                 if (startswith(l, field)) {
1164                         l += strlen(field);
1165                         l += strspn(l, WHITESPACE);
1166
1167                         l[strcspn(l, WHITESPACE)] = 0;
1168
1169                         r = parse_uid(l, uid);
1170                         goto finish;
1171                 }
1172         }
1173
1174         r = -EIO;
1175
1176 finish:
1177         fclose(f);
1178
1179         return r;
1180 }
1181
1182 int get_process_uid(pid_t pid, uid_t *uid) {
1183         return get_process_id(pid, "Uid:", uid);
1184 }
1185
1186 int get_process_gid(pid_t pid, gid_t *gid) {
1187         return get_process_id(pid, "Gid:", gid);
1188 }
1189
1190 char *strnappend(const char *s, const char *suffix, size_t b) {
1191         size_t a;
1192         char *r;
1193
1194         if (!s && !suffix)
1195                 return strdup("");
1196
1197         if (!s)
1198                 return strndup(suffix, b);
1199
1200         if (!suffix)
1201                 return strdup(s);
1202
1203         assert(s);
1204         assert(suffix);
1205
1206         a = strlen(s);
1207         if (b > ((size_t) -1) - a)
1208                 return NULL;
1209
1210         r = new(char, a+b+1);
1211         if (!r)
1212                 return NULL;
1213
1214         memcpy(r, s, a);
1215         memcpy(r+a, suffix, b);
1216         r[a+b] = 0;
1217
1218         return r;
1219 }
1220
1221 char *strappend(const char *s, const char *suffix) {
1222         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
1223 }
1224
1225 int readlink_malloc(const char *p, char **r) {
1226         size_t l = 100;
1227
1228         assert(p);
1229         assert(r);
1230
1231         for (;;) {
1232                 char *c;
1233                 ssize_t n;
1234
1235                 if (!(c = new(char, l)))
1236                         return -ENOMEM;
1237
1238                 if ((n = readlink(p, c, l-1)) < 0) {
1239                         int ret = -errno;
1240                         free(c);
1241                         return ret;
1242                 }
1243
1244                 if ((size_t) n < l-1) {
1245                         c[n] = 0;
1246                         *r = c;
1247                         return 0;
1248                 }
1249
1250                 free(c);
1251                 l *= 2;
1252         }
1253 }
1254
1255 int readlink_and_make_absolute(const char *p, char **r) {
1256         char *target, *k;
1257         int j;
1258
1259         assert(p);
1260         assert(r);
1261
1262         if ((j = readlink_malloc(p, &target)) < 0)
1263                 return j;
1264
1265         k = file_in_same_dir(p, target);
1266         free(target);
1267
1268         if (!k)
1269                 return -ENOMEM;
1270
1271         *r = k;
1272         return 0;
1273 }
1274
1275 int readlink_and_canonicalize(const char *p, char **r) {
1276         char *t, *s;
1277         int j;
1278
1279         assert(p);
1280         assert(r);
1281
1282         j = readlink_and_make_absolute(p, &t);
1283         if (j < 0)
1284                 return j;
1285
1286         s = canonicalize_file_name(t);
1287         if (s) {
1288                 free(t);
1289                 *r = s;
1290         } else
1291                 *r = t;
1292
1293         path_kill_slashes(*r);
1294
1295         return 0;
1296 }
1297
1298 int reset_all_signal_handlers(void) {
1299         int sig;
1300
1301         for (sig = 1; sig < _NSIG; sig++) {
1302                 struct sigaction sa;
1303
1304                 if (sig == SIGKILL || sig == SIGSTOP)
1305                         continue;
1306
1307                 zero(sa);
1308                 sa.sa_handler = SIG_DFL;
1309                 sa.sa_flags = SA_RESTART;
1310
1311                 /* On Linux the first two RT signals are reserved by
1312                  * glibc, and sigaction() will return EINVAL for them. */
1313                 if ((sigaction(sig, &sa, NULL) < 0))
1314                         if (errno != EINVAL)
1315                                 return -errno;
1316         }
1317
1318         return 0;
1319 }
1320
1321 char *strstrip(char *s) {
1322         char *e;
1323
1324         /* Drops trailing whitespace. Modifies the string in
1325          * place. Returns pointer to first non-space character */
1326
1327         s += strspn(s, WHITESPACE);
1328
1329         for (e = strchr(s, 0); e > s; e --)
1330                 if (!strchr(WHITESPACE, e[-1]))
1331                         break;
1332
1333         *e = 0;
1334
1335         return s;
1336 }
1337
1338 char *delete_chars(char *s, const char *bad) {
1339         char *f, *t;
1340
1341         /* Drops all whitespace, regardless where in the string */
1342
1343         for (f = s, t = s; *f; f++) {
1344                 if (strchr(bad, *f))
1345                         continue;
1346
1347                 *(t++) = *f;
1348         }
1349
1350         *t = 0;
1351
1352         return s;
1353 }
1354
1355 bool in_charset(const char *s, const char* charset) {
1356         const char *i;
1357
1358         assert(s);
1359         assert(charset);
1360
1361         for (i = s; *i; i++)
1362                 if (!strchr(charset, *i))
1363                         return false;
1364
1365         return true;
1366 }
1367
1368 char *file_in_same_dir(const char *path, const char *filename) {
1369         char *e, *r;
1370         size_t k;
1371
1372         assert(path);
1373         assert(filename);
1374
1375         /* This removes the last component of path and appends
1376          * filename, unless the latter is absolute anyway or the
1377          * former isn't */
1378
1379         if (path_is_absolute(filename))
1380                 return strdup(filename);
1381
1382         if (!(e = strrchr(path, '/')))
1383                 return strdup(filename);
1384
1385         k = strlen(filename);
1386         if (!(r = new(char, e-path+1+k+1)))
1387                 return NULL;
1388
1389         memcpy(r, path, e-path+1);
1390         memcpy(r+(e-path)+1, filename, k+1);
1391
1392         return r;
1393 }
1394
1395 int rmdir_parents(const char *path, const char *stop) {
1396         size_t l;
1397         int r = 0;
1398
1399         assert(path);
1400         assert(stop);
1401
1402         l = strlen(path);
1403
1404         /* Skip trailing slashes */
1405         while (l > 0 && path[l-1] == '/')
1406                 l--;
1407
1408         while (l > 0) {
1409                 char *t;
1410
1411                 /* Skip last component */
1412                 while (l > 0 && path[l-1] != '/')
1413                         l--;
1414
1415                 /* Skip trailing slashes */
1416                 while (l > 0 && path[l-1] == '/')
1417                         l--;
1418
1419                 if (l <= 0)
1420                         break;
1421
1422                 if (!(t = strndup(path, l)))
1423                         return -ENOMEM;
1424
1425                 if (path_startswith(stop, t)) {
1426                         free(t);
1427                         return 0;
1428                 }
1429
1430                 r = rmdir(t);
1431                 free(t);
1432
1433                 if (r < 0)
1434                         if (errno != ENOENT)
1435                                 return -errno;
1436         }
1437
1438         return 0;
1439 }
1440
1441
1442 char hexchar(int x) {
1443         static const char table[16] = "0123456789abcdef";
1444
1445         return table[x & 15];
1446 }
1447
1448 int unhexchar(char c) {
1449
1450         if (c >= '0' && c <= '9')
1451                 return c - '0';
1452
1453         if (c >= 'a' && c <= 'f')
1454                 return c - 'a' + 10;
1455
1456         if (c >= 'A' && c <= 'F')
1457                 return c - 'A' + 10;
1458
1459         return -1;
1460 }
1461
1462 char octchar(int x) {
1463         return '0' + (x & 7);
1464 }
1465
1466 int unoctchar(char c) {
1467
1468         if (c >= '0' && c <= '7')
1469                 return c - '0';
1470
1471         return -1;
1472 }
1473
1474 char decchar(int x) {
1475         return '0' + (x % 10);
1476 }
1477
1478 int undecchar(char c) {
1479
1480         if (c >= '0' && c <= '9')
1481                 return c - '0';
1482
1483         return -1;
1484 }
1485
1486 char *cescape(const char *s) {
1487         char *r, *t;
1488         const char *f;
1489
1490         assert(s);
1491
1492         /* Does C style string escaping. */
1493
1494         r = new(char, strlen(s)*4 + 1);
1495         if (!r)
1496                 return NULL;
1497
1498         for (f = s, t = r; *f; f++)
1499
1500                 switch (*f) {
1501
1502                 case '\a':
1503                         *(t++) = '\\';
1504                         *(t++) = 'a';
1505                         break;
1506                 case '\b':
1507                         *(t++) = '\\';
1508                         *(t++) = 'b';
1509                         break;
1510                 case '\f':
1511                         *(t++) = '\\';
1512                         *(t++) = 'f';
1513                         break;
1514                 case '\n':
1515                         *(t++) = '\\';
1516                         *(t++) = 'n';
1517                         break;
1518                 case '\r':
1519                         *(t++) = '\\';
1520                         *(t++) = 'r';
1521                         break;
1522                 case '\t':
1523                         *(t++) = '\\';
1524                         *(t++) = 't';
1525                         break;
1526                 case '\v':
1527                         *(t++) = '\\';
1528                         *(t++) = 'v';
1529                         break;
1530                 case '\\':
1531                         *(t++) = '\\';
1532                         *(t++) = '\\';
1533                         break;
1534                 case '"':
1535                         *(t++) = '\\';
1536                         *(t++) = '"';
1537                         break;
1538                 case '\'':
1539                         *(t++) = '\\';
1540                         *(t++) = '\'';
1541                         break;
1542
1543                 default:
1544                         /* For special chars we prefer octal over
1545                          * hexadecimal encoding, simply because glib's
1546                          * g_strescape() does the same */
1547                         if ((*f < ' ') || (*f >= 127)) {
1548                                 *(t++) = '\\';
1549                                 *(t++) = octchar((unsigned char) *f >> 6);
1550                                 *(t++) = octchar((unsigned char) *f >> 3);
1551                                 *(t++) = octchar((unsigned char) *f);
1552                         } else
1553                                 *(t++) = *f;
1554                         break;
1555                 }
1556
1557         *t = 0;
1558
1559         return r;
1560 }
1561
1562 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1563         char *r, *t;
1564         const char *f;
1565         size_t pl;
1566
1567         assert(s);
1568
1569         /* Undoes C style string escaping, and optionally prefixes it. */
1570
1571         pl = prefix ? strlen(prefix) : 0;
1572
1573         r = new(char, pl+length+1);
1574         if (!r)
1575                 return r;
1576
1577         if (prefix)
1578                 memcpy(r, prefix, pl);
1579
1580         for (f = s, t = r + pl; f < s + length; f++) {
1581
1582                 if (*f != '\\') {
1583                         *(t++) = *f;
1584                         continue;
1585                 }
1586
1587                 f++;
1588
1589                 switch (*f) {
1590
1591                 case 'a':
1592                         *(t++) = '\a';
1593                         break;
1594                 case 'b':
1595                         *(t++) = '\b';
1596                         break;
1597                 case 'f':
1598                         *(t++) = '\f';
1599                         break;
1600                 case 'n':
1601                         *(t++) = '\n';
1602                         break;
1603                 case 'r':
1604                         *(t++) = '\r';
1605                         break;
1606                 case 't':
1607                         *(t++) = '\t';
1608                         break;
1609                 case 'v':
1610                         *(t++) = '\v';
1611                         break;
1612                 case '\\':
1613                         *(t++) = '\\';
1614                         break;
1615                 case '"':
1616                         *(t++) = '"';
1617                         break;
1618                 case '\'':
1619                         *(t++) = '\'';
1620                         break;
1621
1622                 case 's':
1623                         /* This is an extension of the XDG syntax files */
1624                         *(t++) = ' ';
1625                         break;
1626
1627                 case 'x': {
1628                         /* hexadecimal encoding */
1629                         int a, b;
1630
1631                         a = unhexchar(f[1]);
1632                         b = unhexchar(f[2]);
1633
1634                         if (a < 0 || b < 0) {
1635                                 /* Invalid escape code, let's take it literal then */
1636                                 *(t++) = '\\';
1637                                 *(t++) = 'x';
1638                         } else {
1639                                 *(t++) = (char) ((a << 4) | b);
1640                                 f += 2;
1641                         }
1642
1643                         break;
1644                 }
1645
1646                 case '0':
1647                 case '1':
1648                 case '2':
1649                 case '3':
1650                 case '4':
1651                 case '5':
1652                 case '6':
1653                 case '7': {
1654                         /* octal encoding */
1655                         int a, b, c;
1656
1657                         a = unoctchar(f[0]);
1658                         b = unoctchar(f[1]);
1659                         c = unoctchar(f[2]);
1660
1661                         if (a < 0 || b < 0 || c < 0) {
1662                                 /* Invalid escape code, let's take it literal then */
1663                                 *(t++) = '\\';
1664                                 *(t++) = f[0];
1665                         } else {
1666                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1667                                 f += 2;
1668                         }
1669
1670                         break;
1671                 }
1672
1673                 case 0:
1674                         /* premature end of string.*/
1675                         *(t++) = '\\';
1676                         goto finish;
1677
1678                 default:
1679                         /* Invalid escape code, let's take it literal then */
1680                         *(t++) = '\\';
1681                         *(t++) = *f;
1682                         break;
1683                 }
1684         }
1685
1686 finish:
1687         *t = 0;
1688         return r;
1689 }
1690
1691 char *cunescape_length(const char *s, size_t length) {
1692         return cunescape_length_with_prefix(s, length, NULL);
1693 }
1694
1695 char *cunescape(const char *s) {
1696         assert(s);
1697
1698         return cunescape_length(s, strlen(s));
1699 }
1700
1701 char *xescape(const char *s, const char *bad) {
1702         char *r, *t;
1703         const char *f;
1704
1705         /* Escapes all chars in bad, in addition to \ and all special
1706          * chars, in \xFF style escaping. May be reversed with
1707          * cunescape. */
1708
1709         r = new(char, strlen(s) * 4 + 1);
1710         if (!r)
1711                 return NULL;
1712
1713         for (f = s, t = r; *f; f++) {
1714
1715                 if ((*f < ' ') || (*f >= 127) ||
1716                     (*f == '\\') || strchr(bad, *f)) {
1717                         *(t++) = '\\';
1718                         *(t++) = 'x';
1719                         *(t++) = hexchar(*f >> 4);
1720                         *(t++) = hexchar(*f);
1721                 } else
1722                         *(t++) = *f;
1723         }
1724
1725         *t = 0;
1726
1727         return r;
1728 }
1729
1730 char *bus_path_escape(const char *s) {
1731         char *r, *t;
1732         const char *f;
1733
1734         assert(s);
1735
1736         /* Escapes all chars that D-Bus' object path cannot deal
1737          * with. Can be reverse with bus_path_unescape() */
1738
1739         if (!(r = new(char, strlen(s)*3+1)))
1740                 return NULL;
1741
1742         for (f = s, t = r; *f; f++) {
1743
1744                 if (!(*f >= 'A' && *f <= 'Z') &&
1745                     !(*f >= 'a' && *f <= 'z') &&
1746                     !(*f >= '0' && *f <= '9')) {
1747                         *(t++) = '_';
1748                         *(t++) = hexchar(*f >> 4);
1749                         *(t++) = hexchar(*f);
1750                 } else
1751                         *(t++) = *f;
1752         }
1753
1754         *t = 0;
1755
1756         return r;
1757 }
1758
1759 char *bus_path_unescape(const char *f) {
1760         char *r, *t;
1761
1762         assert(f);
1763
1764         if (!(r = strdup(f)))
1765                 return NULL;
1766
1767         for (t = r; *f; f++) {
1768
1769                 if (*f == '_') {
1770                         int a, b;
1771
1772                         if ((a = unhexchar(f[1])) < 0 ||
1773                             (b = unhexchar(f[2])) < 0) {
1774                                 /* Invalid escape code, let's take it literal then */
1775                                 *(t++) = '_';
1776                         } else {
1777                                 *(t++) = (char) ((a << 4) | b);
1778                                 f += 2;
1779                         }
1780                 } else
1781                         *(t++) = *f;
1782         }
1783
1784         *t = 0;
1785
1786         return r;
1787 }
1788
1789 char *ascii_strlower(char *t) {
1790         char *p;
1791
1792         assert(t);
1793
1794         for (p = t; *p; p++)
1795                 if (*p >= 'A' && *p <= 'Z')
1796                         *p = *p - 'A' + 'a';
1797
1798         return t;
1799 }
1800
1801 static bool ignore_file_allow_backup(const char *filename) {
1802         assert(filename);
1803
1804         return
1805                 filename[0] == '.' ||
1806                 streq(filename, "lost+found") ||
1807                 streq(filename, "aquota.user") ||
1808                 streq(filename, "aquota.group") ||
1809                 endswith(filename, ".rpmnew") ||
1810                 endswith(filename, ".rpmsave") ||
1811                 endswith(filename, ".rpmorig") ||
1812                 endswith(filename, ".dpkg-old") ||
1813                 endswith(filename, ".dpkg-new") ||
1814                 endswith(filename, ".swp");
1815 }
1816
1817 bool ignore_file(const char *filename) {
1818         assert(filename);
1819
1820         if (endswith(filename, "~"))
1821                 return false;
1822
1823         return ignore_file_allow_backup(filename);
1824 }
1825
1826 int fd_nonblock(int fd, bool nonblock) {
1827         int flags;
1828
1829         assert(fd >= 0);
1830
1831         if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1832                 return -errno;
1833
1834         if (nonblock)
1835                 flags |= O_NONBLOCK;
1836         else
1837                 flags &= ~O_NONBLOCK;
1838
1839         if (fcntl(fd, F_SETFL, flags) < 0)
1840                 return -errno;
1841
1842         return 0;
1843 }
1844
1845 int fd_cloexec(int fd, bool cloexec) {
1846         int flags;
1847
1848         assert(fd >= 0);
1849
1850         if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1851                 return -errno;
1852
1853         if (cloexec)
1854                 flags |= FD_CLOEXEC;
1855         else
1856                 flags &= ~FD_CLOEXEC;
1857
1858         if (fcntl(fd, F_SETFD, flags) < 0)
1859                 return -errno;
1860
1861         return 0;
1862 }
1863
1864 static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1865         unsigned i;
1866
1867         assert(n_fdset == 0 || fdset);
1868
1869         for (i = 0; i < n_fdset; i++)
1870                 if (fdset[i] == fd)
1871                         return true;
1872
1873         return false;
1874 }
1875
1876 int close_all_fds(const int except[], unsigned n_except) {
1877         DIR *d;
1878         struct dirent *de;
1879         int r = 0;
1880
1881         assert(n_except == 0 || except);
1882
1883         d = opendir("/proc/self/fd");
1884         if (!d) {
1885                 int fd;
1886                 struct rlimit rl;
1887
1888                 /* When /proc isn't available (for example in chroots)
1889                  * the fallback is brute forcing through the fd
1890                  * table */
1891
1892                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1893                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1894
1895                         if (fd_in_set(fd, except, n_except))
1896                                 continue;
1897
1898                         if (close_nointr(fd) < 0)
1899                                 if (errno != EBADF && r == 0)
1900                                         r = -errno;
1901                 }
1902
1903                 return r;
1904         }
1905
1906         while ((de = readdir(d))) {
1907                 int fd = -1;
1908
1909                 if (ignore_file(de->d_name))
1910                         continue;
1911
1912                 if (safe_atoi(de->d_name, &fd) < 0)
1913                         /* Let's better ignore this, just in case */
1914                         continue;
1915
1916                 if (fd < 3)
1917                         continue;
1918
1919                 if (fd == dirfd(d))
1920                         continue;
1921
1922                 if (fd_in_set(fd, except, n_except))
1923                         continue;
1924
1925                 if (close_nointr(fd) < 0) {
1926                         /* Valgrind has its own FD and doesn't want to have it closed */
1927                         if (errno != EBADF && r == 0)
1928                                 r = -errno;
1929                 }
1930         }
1931
1932         closedir(d);
1933         return r;
1934 }
1935
1936 bool chars_intersect(const char *a, const char *b) {
1937         const char *p;
1938
1939         /* Returns true if any of the chars in a are in b. */
1940         for (p = a; *p; p++)
1941                 if (strchr(b, *p))
1942                         return true;
1943
1944         return false;
1945 }
1946
1947 char *format_timestamp(char *buf, size_t l, usec_t t) {
1948         struct tm tm;
1949         time_t sec;
1950
1951         assert(buf);
1952         assert(l > 0);
1953
1954         if (t <= 0)
1955                 return NULL;
1956
1957         sec = (time_t) (t / USEC_PER_SEC);
1958
1959         if (strftime(buf, l, "%a, %Y-%m-%d %H:%M:%S %Z", localtime_r(&sec, &tm)) <= 0)
1960                 return NULL;
1961
1962         return buf;
1963 }
1964
1965 char *format_timestamp_pretty(char *buf, size_t l, usec_t t) {
1966         usec_t n, d;
1967
1968         n = now(CLOCK_REALTIME);
1969
1970         if (t <= 0 || t > n || t + USEC_PER_DAY*7 <= t)
1971                 return NULL;
1972
1973         d = n - t;
1974
1975         if (d >= USEC_PER_YEAR)
1976                 snprintf(buf, l, "%llu years and %llu months ago",
1977                          (unsigned long long) (d / USEC_PER_YEAR),
1978                          (unsigned long long) ((d % USEC_PER_YEAR) / USEC_PER_MONTH));
1979         else if (d >= USEC_PER_MONTH)
1980                 snprintf(buf, l, "%llu months and %llu days ago",
1981                          (unsigned long long) (d / USEC_PER_MONTH),
1982                          (unsigned long long) ((d % USEC_PER_MONTH) / USEC_PER_DAY));
1983         else if (d >= USEC_PER_WEEK)
1984                 snprintf(buf, l, "%llu weeks and %llu days ago",
1985                          (unsigned long long) (d / USEC_PER_WEEK),
1986                          (unsigned long long) ((d % USEC_PER_WEEK) / USEC_PER_DAY));
1987         else if (d >= 2*USEC_PER_DAY)
1988                 snprintf(buf, l, "%llu days ago", (unsigned long long) (d / USEC_PER_DAY));
1989         else if (d >= 25*USEC_PER_HOUR)
1990                 snprintf(buf, l, "1 day and %lluh ago",
1991                          (unsigned long long) ((d - USEC_PER_DAY) / USEC_PER_HOUR));
1992         else if (d >= 6*USEC_PER_HOUR)
1993                 snprintf(buf, l, "%lluh ago",
1994                          (unsigned long long) (d / USEC_PER_HOUR));
1995         else if (d >= USEC_PER_HOUR)
1996                 snprintf(buf, l, "%lluh %llumin ago",
1997                          (unsigned long long) (d / USEC_PER_HOUR),
1998                          (unsigned long long) ((d % USEC_PER_HOUR) / USEC_PER_MINUTE));
1999         else if (d >= 5*USEC_PER_MINUTE)
2000                 snprintf(buf, l, "%llumin ago",
2001                          (unsigned long long) (d / USEC_PER_MINUTE));
2002         else if (d >= USEC_PER_MINUTE)
2003                 snprintf(buf, l, "%llumin %llus ago",
2004                          (unsigned long long) (d / USEC_PER_MINUTE),
2005                          (unsigned long long) ((d % USEC_PER_MINUTE) / USEC_PER_SEC));
2006         else if (d >= USEC_PER_SEC)
2007                 snprintf(buf, l, "%llus ago",
2008                          (unsigned long long) (d / USEC_PER_SEC));
2009         else if (d >= USEC_PER_MSEC)
2010                 snprintf(buf, l, "%llums ago",
2011                          (unsigned long long) (d / USEC_PER_MSEC));
2012         else if (d > 0)
2013                 snprintf(buf, l, "%lluus ago",
2014                          (unsigned long long) d);
2015         else
2016                 snprintf(buf, l, "now");
2017
2018         buf[l-1] = 0;
2019         return buf;
2020 }
2021
2022 char *format_timespan(char *buf, size_t l, usec_t t) {
2023         static const struct {
2024                 const char *suffix;
2025                 usec_t usec;
2026         } table[] = {
2027                 { "w", USEC_PER_WEEK },
2028                 { "d", USEC_PER_DAY },
2029                 { "h", USEC_PER_HOUR },
2030                 { "min", USEC_PER_MINUTE },
2031                 { "s", USEC_PER_SEC },
2032                 { "ms", USEC_PER_MSEC },
2033                 { "us", 1 },
2034         };
2035
2036         unsigned i;
2037         char *p = buf;
2038
2039         assert(buf);
2040         assert(l > 0);
2041
2042         if (t == (usec_t) -1)
2043                 return NULL;
2044
2045         if (t == 0) {
2046                 snprintf(p, l, "0");
2047                 p[l-1] = 0;
2048                 return p;
2049         }
2050
2051         /* The result of this function can be parsed with parse_usec */
2052
2053         for (i = 0; i < ELEMENTSOF(table); i++) {
2054                 int k;
2055                 size_t n;
2056
2057                 if (t < table[i].usec)
2058                         continue;
2059
2060                 if (l <= 1)
2061                         break;
2062
2063                 k = snprintf(p, l, "%s%llu%s", p > buf ? " " : "", (unsigned long long) (t / table[i].usec), table[i].suffix);
2064                 n = MIN((size_t) k, l);
2065
2066                 l -= n;
2067                 p += n;
2068
2069                 t %= table[i].usec;
2070         }
2071
2072         *p = 0;
2073
2074         return buf;
2075 }
2076
2077 bool fstype_is_network(const char *fstype) {
2078         static const char table[] =
2079                 "cifs\0"
2080                 "smbfs\0"
2081                 "ncpfs\0"
2082                 "nfs\0"
2083                 "nfs4\0"
2084                 "gfs\0"
2085                 "gfs2\0";
2086
2087         return nulstr_contains(table, fstype);
2088 }
2089
2090 int chvt(int vt) {
2091         _cleanup_close_ int fd;
2092
2093         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
2094         if (fd < 0)
2095                 return -errno;
2096
2097         if (vt < 0) {
2098                 int tiocl[2] = {
2099                         TIOCL_GETKMSGREDIRECT,
2100                         0
2101                 };
2102
2103                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
2104                         return -errno;
2105
2106                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
2107         }
2108
2109         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
2110                 return -errno;
2111
2112         return 0;
2113 }
2114
2115 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
2116         struct termios old_termios, new_termios;
2117         char c;
2118         char line[LINE_MAX];
2119
2120         assert(f);
2121         assert(ret);
2122
2123         if (tcgetattr(fileno(f), &old_termios) >= 0) {
2124                 new_termios = old_termios;
2125
2126                 new_termios.c_lflag &= ~ICANON;
2127                 new_termios.c_cc[VMIN] = 1;
2128                 new_termios.c_cc[VTIME] = 0;
2129
2130                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
2131                         size_t k;
2132
2133                         if (t != (usec_t) -1) {
2134                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
2135                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
2136                                         return -ETIMEDOUT;
2137                                 }
2138                         }
2139
2140                         k = fread(&c, 1, 1, f);
2141
2142                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
2143
2144                         if (k <= 0)
2145                                 return -EIO;
2146
2147                         if (need_nl)
2148                                 *need_nl = c != '\n';
2149
2150                         *ret = c;
2151                         return 0;
2152                 }
2153         }
2154
2155         if (t != (usec_t) -1)
2156                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
2157                         return -ETIMEDOUT;
2158
2159         if (!fgets(line, sizeof(line), f))
2160                 return -EIO;
2161
2162         truncate_nl(line);
2163
2164         if (strlen(line) != 1)
2165                 return -EBADMSG;
2166
2167         if (need_nl)
2168                 *need_nl = false;
2169
2170         *ret = line[0];
2171         return 0;
2172 }
2173
2174 int ask(char *ret, const char *replies, const char *text, ...) {
2175
2176         assert(ret);
2177         assert(replies);
2178         assert(text);
2179
2180         for (;;) {
2181                 va_list ap;
2182                 char c;
2183                 int r;
2184                 bool need_nl = true;
2185
2186                 if (on_tty())
2187                         fputs(ANSI_HIGHLIGHT_ON, stdout);
2188
2189                 va_start(ap, text);
2190                 vprintf(text, ap);
2191                 va_end(ap);
2192
2193                 if (on_tty())
2194                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
2195
2196                 fflush(stdout);
2197
2198                 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
2199                 if (r < 0) {
2200
2201                         if (r == -EBADMSG) {
2202                                 puts("Bad input, please try again.");
2203                                 continue;
2204                         }
2205
2206                         putchar('\n');
2207                         return r;
2208                 }
2209
2210                 if (need_nl)
2211                         putchar('\n');
2212
2213                 if (strchr(replies, c)) {
2214                         *ret = c;
2215                         return 0;
2216                 }
2217
2218                 puts("Read unexpected character, please try again.");
2219         }
2220 }
2221
2222 int reset_terminal_fd(int fd, bool switch_to_text) {
2223         struct termios termios;
2224         int r = 0;
2225
2226         /* Set terminal to some sane defaults */
2227
2228         assert(fd >= 0);
2229
2230         /* We leave locked terminal attributes untouched, so that
2231          * Plymouth may set whatever it wants to set, and we don't
2232          * interfere with that. */
2233
2234         /* Disable exclusive mode, just in case */
2235         ioctl(fd, TIOCNXCL);
2236
2237         /* Switch to text mode */
2238         if (switch_to_text)
2239                 ioctl(fd, KDSETMODE, KD_TEXT);
2240
2241         /* Enable console unicode mode */
2242         ioctl(fd, KDSKBMODE, K_UNICODE);
2243
2244         if (tcgetattr(fd, &termios) < 0) {
2245                 r = -errno;
2246                 goto finish;
2247         }
2248
2249         /* We only reset the stuff that matters to the software. How
2250          * hardware is set up we don't touch assuming that somebody
2251          * else will do that for us */
2252
2253         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
2254         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
2255         termios.c_oflag |= ONLCR;
2256         termios.c_cflag |= CREAD;
2257         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
2258
2259         termios.c_cc[VINTR]    =   03;  /* ^C */
2260         termios.c_cc[VQUIT]    =  034;  /* ^\ */
2261         termios.c_cc[VERASE]   = 0177;
2262         termios.c_cc[VKILL]    =  025;  /* ^X */
2263         termios.c_cc[VEOF]     =   04;  /* ^D */
2264         termios.c_cc[VSTART]   =  021;  /* ^Q */
2265         termios.c_cc[VSTOP]    =  023;  /* ^S */
2266         termios.c_cc[VSUSP]    =  032;  /* ^Z */
2267         termios.c_cc[VLNEXT]   =  026;  /* ^V */
2268         termios.c_cc[VWERASE]  =  027;  /* ^W */
2269         termios.c_cc[VREPRINT] =  022;  /* ^R */
2270         termios.c_cc[VEOL]     =    0;
2271         termios.c_cc[VEOL2]    =    0;
2272
2273         termios.c_cc[VTIME]  = 0;
2274         termios.c_cc[VMIN]   = 1;
2275
2276         if (tcsetattr(fd, TCSANOW, &termios) < 0)
2277                 r = -errno;
2278
2279 finish:
2280         /* Just in case, flush all crap out */
2281         tcflush(fd, TCIOFLUSH);
2282
2283         return r;
2284 }
2285
2286 int reset_terminal(const char *name) {
2287         int fd, r;
2288
2289         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2290         if (fd < 0)
2291                 return fd;
2292
2293         r = reset_terminal_fd(fd, true);
2294         close_nointr_nofail(fd);
2295
2296         return r;
2297 }
2298
2299 int open_terminal(const char *name, int mode) {
2300         int fd, r;
2301         unsigned c = 0;
2302
2303         /*
2304          * If a TTY is in the process of being closed opening it might
2305          * cause EIO. This is horribly awful, but unlikely to be
2306          * changed in the kernel. Hence we work around this problem by
2307          * retrying a couple of times.
2308          *
2309          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
2310          */
2311
2312         for (;;) {
2313                 fd = open(name, mode);
2314                 if (fd >= 0)
2315                         break;
2316
2317                 if (errno != EIO)
2318                         return -errno;
2319
2320                 /* Max 1s in total */
2321                 if (c >= 20)
2322                         return -errno;
2323
2324                 usleep(50 * USEC_PER_MSEC);
2325                 c++;
2326         }
2327
2328         if (fd < 0)
2329                 return -errno;
2330
2331         r = isatty(fd);
2332         if (r < 0) {
2333                 close_nointr_nofail(fd);
2334                 return -errno;
2335         }
2336
2337         if (!r) {
2338                 close_nointr_nofail(fd);
2339                 return -ENOTTY;
2340         }
2341
2342         return fd;
2343 }
2344
2345 int flush_fd(int fd) {
2346         struct pollfd pollfd;
2347
2348         zero(pollfd);
2349         pollfd.fd = fd;
2350         pollfd.events = POLLIN;
2351
2352         for (;;) {
2353                 char buf[LINE_MAX];
2354                 ssize_t l;
2355                 int r;
2356
2357                 if ((r = poll(&pollfd, 1, 0)) < 0) {
2358
2359                         if (errno == EINTR)
2360                                 continue;
2361
2362                         return -errno;
2363                 }
2364
2365                 if (r == 0)
2366                         return 0;
2367
2368                 if ((l = read(fd, buf, sizeof(buf))) < 0) {
2369
2370                         if (errno == EINTR)
2371                                 continue;
2372
2373                         if (errno == EAGAIN)
2374                                 return 0;
2375
2376                         return -errno;
2377                 }
2378
2379                 if (l <= 0)
2380                         return 0;
2381         }
2382 }
2383
2384 int acquire_terminal(
2385                 const char *name,
2386                 bool fail,
2387                 bool force,
2388                 bool ignore_tiocstty_eperm,
2389                 usec_t timeout) {
2390
2391         int fd = -1, notify = -1, r = 0, wd = -1;
2392         usec_t ts = 0;
2393         struct sigaction sa_old, sa_new;
2394
2395         assert(name);
2396
2397         /* We use inotify to be notified when the tty is closed. We
2398          * create the watch before checking if we can actually acquire
2399          * it, so that we don't lose any event.
2400          *
2401          * Note: strictly speaking this actually watches for the
2402          * device being closed, it does *not* really watch whether a
2403          * tty loses its controlling process. However, unless some
2404          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2405          * its tty otherwise this will not become a problem. As long
2406          * as the administrator makes sure not configure any service
2407          * on the same tty as an untrusted user this should not be a
2408          * problem. (Which he probably should not do anyway.) */
2409
2410         if (timeout != (usec_t) -1)
2411                 ts = now(CLOCK_MONOTONIC);
2412
2413         if (!fail && !force) {
2414                 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
2415                 if (notify < 0) {
2416                         r = -errno;
2417                         goto fail;
2418                 }
2419
2420                 wd = inotify_add_watch(notify, name, IN_CLOSE);
2421                 if (wd < 0) {
2422                         r = -errno;
2423                         goto fail;
2424                 }
2425         }
2426
2427         for (;;) {
2428                 if (notify >= 0) {
2429                         r = flush_fd(notify);
2430                         if (r < 0)
2431                                 goto fail;
2432                 }
2433
2434                 /* We pass here O_NOCTTY only so that we can check the return
2435                  * value TIOCSCTTY and have a reliable way to figure out if we
2436                  * successfully became the controlling process of the tty */
2437                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2438                 if (fd < 0)
2439                         return fd;
2440
2441                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2442                  * if we already own the tty. */
2443                 zero(sa_new);
2444                 sa_new.sa_handler = SIG_IGN;
2445                 sa_new.sa_flags = SA_RESTART;
2446                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2447
2448                 /* First, try to get the tty */
2449                 if (ioctl(fd, TIOCSCTTY, force) < 0)
2450                         r = -errno;
2451
2452                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2453
2454                 /* Sometimes it makes sense to ignore TIOCSCTTY
2455                  * returning EPERM, i.e. when very likely we already
2456                  * are have this controlling terminal. */
2457                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
2458                         r = 0;
2459
2460                 if (r < 0 && (force || fail || r != -EPERM)) {
2461                         goto fail;
2462                 }
2463
2464                 if (r >= 0)
2465                         break;
2466
2467                 assert(!fail);
2468                 assert(!force);
2469                 assert(notify >= 0);
2470
2471                 for (;;) {
2472                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
2473                         ssize_t l;
2474                         struct inotify_event *e;
2475
2476                         if (timeout != (usec_t) -1) {
2477                                 usec_t n;
2478
2479                                 n = now(CLOCK_MONOTONIC);
2480                                 if (ts + timeout < n) {
2481                                         r = -ETIMEDOUT;
2482                                         goto fail;
2483                                 }
2484
2485                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2486                                 if (r < 0)
2487                                         goto fail;
2488
2489                                 if (r == 0) {
2490                                         r = -ETIMEDOUT;
2491                                         goto fail;
2492                                 }
2493                         }
2494
2495                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
2496                         if (l < 0) {
2497
2498                                 if (errno == EINTR || errno == EAGAIN)
2499                                         continue;
2500
2501                                 r = -errno;
2502                                 goto fail;
2503                         }
2504
2505                         e = (struct inotify_event*) inotify_buffer;
2506
2507                         while (l > 0) {
2508                                 size_t step;
2509
2510                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2511                                         r = -EIO;
2512                                         goto fail;
2513                                 }
2514
2515                                 step = sizeof(struct inotify_event) + e->len;
2516                                 assert(step <= (size_t) l);
2517
2518                                 e = (struct inotify_event*) ((uint8_t*) e + step);
2519                                 l -= step;
2520                         }
2521
2522                         break;
2523                 }
2524
2525                 /* We close the tty fd here since if the old session
2526                  * ended our handle will be dead. It's important that
2527                  * we do this after sleeping, so that we don't enter
2528                  * an endless loop. */
2529                 close_nointr_nofail(fd);
2530         }
2531
2532         if (notify >= 0)
2533                 close_nointr_nofail(notify);
2534
2535         r = reset_terminal_fd(fd, true);
2536         if (r < 0)
2537                 log_warning("Failed to reset terminal: %s", strerror(-r));
2538
2539         return fd;
2540
2541 fail:
2542         if (fd >= 0)
2543                 close_nointr_nofail(fd);
2544
2545         if (notify >= 0)
2546                 close_nointr_nofail(notify);
2547
2548         return r;
2549 }
2550
2551 int release_terminal(void) {
2552         int r = 0, fd;
2553         struct sigaction sa_old, sa_new;
2554
2555         if ((fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC)) < 0)
2556                 return -errno;
2557
2558         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2559          * by our own TIOCNOTTY */
2560
2561         zero(sa_new);
2562         sa_new.sa_handler = SIG_IGN;
2563         sa_new.sa_flags = SA_RESTART;
2564         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2565
2566         if (ioctl(fd, TIOCNOTTY) < 0)
2567                 r = -errno;
2568
2569         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2570
2571         close_nointr_nofail(fd);
2572         return r;
2573 }
2574
2575 int sigaction_many(const struct sigaction *sa, ...) {
2576         va_list ap;
2577         int r = 0, sig;
2578
2579         va_start(ap, sa);
2580         while ((sig = va_arg(ap, int)) > 0)
2581                 if (sigaction(sig, sa, NULL) < 0)
2582                         r = -errno;
2583         va_end(ap);
2584
2585         return r;
2586 }
2587
2588 int ignore_signals(int sig, ...) {
2589         struct sigaction sa;
2590         va_list ap;
2591         int r = 0;
2592
2593         zero(sa);
2594         sa.sa_handler = SIG_IGN;
2595         sa.sa_flags = SA_RESTART;
2596
2597         if (sigaction(sig, &sa, NULL) < 0)
2598                 r = -errno;
2599
2600         va_start(ap, sig);
2601         while ((sig = va_arg(ap, int)) > 0)
2602                 if (sigaction(sig, &sa, NULL) < 0)
2603                         r = -errno;
2604         va_end(ap);
2605
2606         return r;
2607 }
2608
2609 int default_signals(int sig, ...) {
2610         struct sigaction sa;
2611         va_list ap;
2612         int r = 0;
2613
2614         zero(sa);
2615         sa.sa_handler = SIG_DFL;
2616         sa.sa_flags = SA_RESTART;
2617
2618         if (sigaction(sig, &sa, NULL) < 0)
2619                 r = -errno;
2620
2621         va_start(ap, sig);
2622         while ((sig = va_arg(ap, int)) > 0)
2623                 if (sigaction(sig, &sa, NULL) < 0)
2624                         r = -errno;
2625         va_end(ap);
2626
2627         return r;
2628 }
2629
2630 int close_pipe(int p[]) {
2631         int a = 0, b = 0;
2632
2633         assert(p);
2634
2635         if (p[0] >= 0) {
2636                 a = close_nointr(p[0]);
2637                 p[0] = -1;
2638         }
2639
2640         if (p[1] >= 0) {
2641                 b = close_nointr(p[1]);
2642                 p[1] = -1;
2643         }
2644
2645         return a < 0 ? a : b;
2646 }
2647
2648 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2649         uint8_t *p;
2650         ssize_t n = 0;
2651
2652         assert(fd >= 0);
2653         assert(buf);
2654
2655         p = buf;
2656
2657         while (nbytes > 0) {
2658                 ssize_t k;
2659
2660                 if ((k = read(fd, p, nbytes)) <= 0) {
2661
2662                         if (k < 0 && errno == EINTR)
2663                                 continue;
2664
2665                         if (k < 0 && errno == EAGAIN && do_poll) {
2666                                 struct pollfd pollfd;
2667
2668                                 zero(pollfd);
2669                                 pollfd.fd = fd;
2670                                 pollfd.events = POLLIN;
2671
2672                                 if (poll(&pollfd, 1, -1) < 0) {
2673                                         if (errno == EINTR)
2674                                                 continue;
2675
2676                                         return n > 0 ? n : -errno;
2677                                 }
2678
2679                                 if (pollfd.revents != POLLIN)
2680                                         return n > 0 ? n : -EIO;
2681
2682                                 continue;
2683                         }
2684
2685                         return n > 0 ? n : (k < 0 ? -errno : 0);
2686                 }
2687
2688                 p += k;
2689                 nbytes -= k;
2690                 n += k;
2691         }
2692
2693         return n;
2694 }
2695
2696 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2697         const uint8_t *p;
2698         ssize_t n = 0;
2699
2700         assert(fd >= 0);
2701         assert(buf);
2702
2703         p = buf;
2704
2705         while (nbytes > 0) {
2706                 ssize_t k;
2707
2708                 k = write(fd, p, nbytes);
2709                 if (k <= 0) {
2710
2711                         if (k < 0 && errno == EINTR)
2712                                 continue;
2713
2714                         if (k < 0 && errno == EAGAIN && do_poll) {
2715                                 struct pollfd pollfd;
2716
2717                                 zero(pollfd);
2718                                 pollfd.fd = fd;
2719                                 pollfd.events = POLLOUT;
2720
2721                                 if (poll(&pollfd, 1, -1) < 0) {
2722                                         if (errno == EINTR)
2723                                                 continue;
2724
2725                                         return n > 0 ? n : -errno;
2726                                 }
2727
2728                                 if (pollfd.revents != POLLOUT)
2729                                         return n > 0 ? n : -EIO;
2730
2731                                 continue;
2732                         }
2733
2734                         return n > 0 ? n : (k < 0 ? -errno : 0);
2735                 }
2736
2737                 p += k;
2738                 nbytes -= k;
2739                 n += k;
2740         }
2741
2742         return n;
2743 }
2744
2745 int parse_usec(const char *t, usec_t *usec) {
2746         static const struct {
2747                 const char *suffix;
2748                 usec_t usec;
2749         } table[] = {
2750                 { "seconds", USEC_PER_SEC },
2751                 { "second", USEC_PER_SEC },
2752                 { "sec", USEC_PER_SEC },
2753                 { "s", USEC_PER_SEC },
2754                 { "minutes", USEC_PER_MINUTE },
2755                 { "minute", USEC_PER_MINUTE },
2756                 { "min", USEC_PER_MINUTE },
2757                 { "months", USEC_PER_MONTH },
2758                 { "month", USEC_PER_MONTH },
2759                 { "msec", USEC_PER_MSEC },
2760                 { "ms", USEC_PER_MSEC },
2761                 { "m", USEC_PER_MINUTE },
2762                 { "hours", USEC_PER_HOUR },
2763                 { "hour", USEC_PER_HOUR },
2764                 { "hr", USEC_PER_HOUR },
2765                 { "h", USEC_PER_HOUR },
2766                 { "days", USEC_PER_DAY },
2767                 { "day", USEC_PER_DAY },
2768                 { "d", USEC_PER_DAY },
2769                 { "weeks", USEC_PER_WEEK },
2770                 { "week", USEC_PER_WEEK },
2771                 { "w", USEC_PER_WEEK },
2772                 { "years", USEC_PER_YEAR },
2773                 { "year", USEC_PER_YEAR },
2774                 { "y", USEC_PER_YEAR },
2775                 { "usec", 1ULL },
2776                 { "us", 1ULL },
2777                 { "", USEC_PER_SEC }, /* default is sec */
2778         };
2779
2780         const char *p;
2781         usec_t r = 0;
2782
2783         assert(t);
2784         assert(usec);
2785
2786         p = t;
2787         do {
2788                 long long l;
2789                 char *e;
2790                 unsigned i;
2791
2792                 errno = 0;
2793                 l = strtoll(p, &e, 10);
2794
2795                 if (errno != 0)
2796                         return -errno;
2797
2798                 if (l < 0)
2799                         return -ERANGE;
2800
2801                 if (e == p)
2802                         return -EINVAL;
2803
2804                 e += strspn(e, WHITESPACE);
2805
2806                 for (i = 0; i < ELEMENTSOF(table); i++)
2807                         if (startswith(e, table[i].suffix)) {
2808                                 r += (usec_t) l * table[i].usec;
2809                                 p = e + strlen(table[i].suffix);
2810                                 break;
2811                         }
2812
2813                 if (i >= ELEMENTSOF(table))
2814                         return -EINVAL;
2815
2816         } while (*p != 0);
2817
2818         *usec = r;
2819
2820         return 0;
2821 }
2822
2823 int parse_nsec(const char *t, nsec_t *nsec) {
2824         static const struct {
2825                 const char *suffix;
2826                 nsec_t nsec;
2827         } table[] = {
2828                 { "seconds", NSEC_PER_SEC },
2829                 { "second", NSEC_PER_SEC },
2830                 { "sec", NSEC_PER_SEC },
2831                 { "s", NSEC_PER_SEC },
2832                 { "minutes", NSEC_PER_MINUTE },
2833                 { "minute", NSEC_PER_MINUTE },
2834                 { "min", NSEC_PER_MINUTE },
2835                 { "months", NSEC_PER_MONTH },
2836                 { "month", NSEC_PER_MONTH },
2837                 { "msec", NSEC_PER_MSEC },
2838                 { "ms", NSEC_PER_MSEC },
2839                 { "m", NSEC_PER_MINUTE },
2840                 { "hours", NSEC_PER_HOUR },
2841                 { "hour", NSEC_PER_HOUR },
2842                 { "hr", NSEC_PER_HOUR },
2843                 { "h", NSEC_PER_HOUR },
2844                 { "days", NSEC_PER_DAY },
2845                 { "day", NSEC_PER_DAY },
2846                 { "d", NSEC_PER_DAY },
2847                 { "weeks", NSEC_PER_WEEK },
2848                 { "week", NSEC_PER_WEEK },
2849                 { "w", NSEC_PER_WEEK },
2850                 { "years", NSEC_PER_YEAR },
2851                 { "year", NSEC_PER_YEAR },
2852                 { "y", NSEC_PER_YEAR },
2853                 { "usec", NSEC_PER_USEC },
2854                 { "us", NSEC_PER_USEC },
2855                 { "nsec", 1ULL },
2856                 { "ns", 1ULL },
2857                 { "", 1ULL }, /* default is nsec */
2858         };
2859
2860         const char *p;
2861         nsec_t r = 0;
2862
2863         assert(t);
2864         assert(nsec);
2865
2866         p = t;
2867         do {
2868                 long long l;
2869                 char *e;
2870                 unsigned i;
2871
2872                 errno = 0;
2873                 l = strtoll(p, &e, 10);
2874
2875                 if (errno != 0)
2876                         return -errno;
2877
2878                 if (l < 0)
2879                         return -ERANGE;
2880
2881                 if (e == p)
2882                         return -EINVAL;
2883
2884                 e += strspn(e, WHITESPACE);
2885
2886                 for (i = 0; i < ELEMENTSOF(table); i++)
2887                         if (startswith(e, table[i].suffix)) {
2888                                 r += (nsec_t) l * table[i].nsec;
2889                                 p = e + strlen(table[i].suffix);
2890                                 break;
2891                         }
2892
2893                 if (i >= ELEMENTSOF(table))
2894                         return -EINVAL;
2895
2896         } while (*p != 0);
2897
2898         *nsec = r;
2899
2900         return 0;
2901 }
2902
2903 int parse_bytes(const char *t, off_t *bytes) {
2904         static const struct {
2905                 const char *suffix;
2906                 off_t factor;
2907         } table[] = {
2908                 { "B", 1 },
2909                 { "K", 1024ULL },
2910                 { "M", 1024ULL*1024ULL },
2911                 { "G", 1024ULL*1024ULL*1024ULL },
2912                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2913                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2914                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2915                 { "", 1 },
2916         };
2917
2918         const char *p;
2919         off_t r = 0;
2920
2921         assert(t);
2922         assert(bytes);
2923
2924         p = t;
2925         do {
2926                 long long l;
2927                 char *e;
2928                 unsigned i;
2929
2930                 errno = 0;
2931                 l = strtoll(p, &e, 10);
2932
2933                 if (errno != 0)
2934                         return -errno;
2935
2936                 if (l < 0)
2937                         return -ERANGE;
2938
2939                 if (e == p)
2940                         return -EINVAL;
2941
2942                 e += strspn(e, WHITESPACE);
2943
2944                 for (i = 0; i < ELEMENTSOF(table); i++)
2945                         if (startswith(e, table[i].suffix)) {
2946                                 r += (off_t) l * table[i].factor;
2947                                 p = e + strlen(table[i].suffix);
2948                                 break;
2949                         }
2950
2951                 if (i >= ELEMENTSOF(table))
2952                         return -EINVAL;
2953
2954         } while (*p != 0);
2955
2956         *bytes = r;
2957
2958         return 0;
2959 }
2960
2961 int make_stdio(int fd) {
2962         int r, s, t;
2963
2964         assert(fd >= 0);
2965
2966         r = dup3(fd, STDIN_FILENO, 0);
2967         s = dup3(fd, STDOUT_FILENO, 0);
2968         t = dup3(fd, STDERR_FILENO, 0);
2969
2970         if (fd >= 3)
2971                 close_nointr_nofail(fd);
2972
2973         if (r < 0 || s < 0 || t < 0)
2974                 return -errno;
2975
2976         /* We rely here that the new fd has O_CLOEXEC not set */
2977
2978         return 0;
2979 }
2980
2981 int make_null_stdio(void) {
2982         int null_fd;
2983
2984         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2985         if (null_fd < 0)
2986                 return -errno;
2987
2988         return make_stdio(null_fd);
2989 }
2990
2991 bool is_device_path(const char *path) {
2992
2993         /* Returns true on paths that refer to a device, either in
2994          * sysfs or in /dev */
2995
2996         return
2997                 path_startswith(path, "/dev/") ||
2998                 path_startswith(path, "/sys/");
2999 }
3000
3001 int dir_is_empty(const char *path) {
3002         _cleanup_closedir_ DIR *d;
3003         int r;
3004
3005         d = opendir(path);
3006         if (!d)
3007                 return -errno;
3008
3009         for (;;) {
3010                 struct dirent *de;
3011                 union dirent_storage buf;
3012
3013                 r = readdir_r(d, &buf.de, &de);
3014                 if (r > 0)
3015                         return -r;
3016
3017                 if (!de)
3018                         return 1;
3019
3020                 if (!ignore_file(de->d_name))
3021                         return 0;
3022         }
3023 }
3024
3025 unsigned long long random_ull(void) {
3026         _cleanup_close_ int fd;
3027         uint64_t ull;
3028         ssize_t r;
3029
3030         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
3031         if (fd < 0)
3032                 goto fallback;
3033
3034         r = loop_read(fd, &ull, sizeof(ull), true);
3035         if (r != sizeof(ull))
3036                 goto fallback;
3037
3038         return ull;
3039
3040 fallback:
3041         return random() * RAND_MAX + random();
3042 }
3043
3044 void rename_process(const char name[8]) {
3045         assert(name);
3046
3047         /* This is a like a poor man's setproctitle(). It changes the
3048          * comm field, argv[0], and also the glibc's internally used
3049          * name of the process. For the first one a limit of 16 chars
3050          * applies, to the second one usually one of 10 (i.e. length
3051          * of "/sbin/init"), to the third one one of 7 (i.e. length of
3052          * "systemd"). If you pass a longer string it will be
3053          * truncated */
3054
3055         prctl(PR_SET_NAME, name);
3056
3057         if (program_invocation_name)
3058                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
3059
3060         if (saved_argc > 0) {
3061                 int i;
3062
3063                 if (saved_argv[0])
3064                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
3065
3066                 for (i = 1; i < saved_argc; i++) {
3067                         if (!saved_argv[i])
3068                                 break;
3069
3070                         memset(saved_argv[i], 0, strlen(saved_argv[i]));
3071                 }
3072         }
3073 }
3074
3075 void sigset_add_many(sigset_t *ss, ...) {
3076         va_list ap;
3077         int sig;
3078
3079         assert(ss);
3080
3081         va_start(ap, ss);
3082         while ((sig = va_arg(ap, int)) > 0)
3083                 assert_se(sigaddset(ss, sig) == 0);
3084         va_end(ap);
3085 }
3086
3087 char* gethostname_malloc(void) {
3088         struct utsname u;
3089
3090         assert_se(uname(&u) >= 0);
3091
3092         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
3093                 return strdup(u.nodename);
3094
3095         return strdup(u.sysname);
3096 }
3097
3098 bool hostname_is_set(void) {
3099         struct utsname u;
3100
3101         assert_se(uname(&u) >= 0);
3102
3103         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
3104 }
3105
3106 static char *lookup_uid(uid_t uid) {
3107         long bufsize;
3108         char *name;
3109         _cleanup_free_ char *buf = NULL;
3110         struct passwd pwbuf, *pw = NULL;
3111
3112         /* Shortcut things to avoid NSS lookups */
3113         if (uid == 0)
3114                 return strdup("root");
3115
3116         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
3117         if (bufsize <= 0)
3118                 bufsize = 4096;
3119
3120         buf = malloc(bufsize);
3121         if (!buf)
3122                 return NULL;
3123
3124         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
3125                 return strdup(pw->pw_name);
3126
3127         if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
3128                 return NULL;
3129
3130         return name;
3131 }
3132
3133 char* getlogname_malloc(void) {
3134         uid_t uid;
3135         struct stat st;
3136
3137         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
3138                 uid = st.st_uid;
3139         else
3140                 uid = getuid();
3141
3142         return lookup_uid(uid);
3143 }
3144
3145 char *getusername_malloc(void) {
3146         const char *e;
3147
3148         e = getenv("USER");
3149         if (e)
3150                 return strdup(e);
3151
3152         return lookup_uid(getuid());
3153 }
3154
3155 int getttyname_malloc(int fd, char **r) {
3156         char path[PATH_MAX], *c;
3157         int k;
3158
3159         assert(r);
3160
3161         k = ttyname_r(fd, path, sizeof(path));
3162         if (k != 0)
3163                 return -k;
3164
3165         char_array_0(path);
3166
3167         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
3168         if (!c)
3169                 return -ENOMEM;
3170
3171         *r = c;
3172         return 0;
3173 }
3174
3175 int getttyname_harder(int fd, char **r) {
3176         int k;
3177         char *s;
3178
3179         k = getttyname_malloc(fd, &s);
3180         if (k < 0)
3181                 return k;
3182
3183         if (streq(s, "tty")) {
3184                 free(s);
3185                 return get_ctty(0, NULL, r);
3186         }
3187
3188         *r = s;
3189         return 0;
3190 }
3191
3192 int get_ctty_devnr(pid_t pid, dev_t *d) {
3193         int k;
3194         char line[LINE_MAX], *p, *fn;
3195         unsigned long ttynr;
3196         FILE *f;
3197
3198         if (asprintf(&fn, "/proc/%lu/stat", (unsigned long) (pid <= 0 ? getpid() : pid)) < 0)
3199                 return -ENOMEM;
3200
3201         f = fopen(fn, "re");
3202         free(fn);
3203         if (!f)
3204                 return -errno;
3205
3206         if (!fgets(line, sizeof(line), f)) {
3207                 k = feof(f) ? -EIO : -errno;
3208                 fclose(f);
3209                 return k;
3210         }
3211
3212         fclose(f);
3213
3214         p = strrchr(line, ')');
3215         if (!p)
3216                 return -EIO;
3217
3218         p++;
3219
3220         if (sscanf(p, " "
3221                    "%*c "  /* state */
3222                    "%*d "  /* ppid */
3223                    "%*d "  /* pgrp */
3224                    "%*d "  /* session */
3225                    "%lu ", /* ttynr */
3226                    &ttynr) != 1)
3227                 return -EIO;
3228
3229         *d = (dev_t) ttynr;
3230         return 0;
3231 }
3232
3233 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
3234         int k;
3235         char fn[PATH_MAX], *s, *b, *p;
3236         dev_t devnr;
3237
3238         assert(r);
3239
3240         k = get_ctty_devnr(pid, &devnr);
3241         if (k < 0)
3242                 return k;
3243
3244         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
3245         char_array_0(fn);
3246
3247         if ((k = readlink_malloc(fn, &s)) < 0) {
3248
3249                 if (k != -ENOENT)
3250                         return k;
3251
3252                 /* This is an ugly hack */
3253                 if (major(devnr) == 136) {
3254                         if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
3255                                 return -ENOMEM;
3256
3257                         *r = b;
3258                         if (_devnr)
3259                                 *_devnr = devnr;
3260
3261                         return 0;
3262                 }
3263
3264                 /* Probably something like the ptys which have no
3265                  * symlink in /dev/char. Let's return something
3266                  * vaguely useful. */
3267
3268                 if (!(b = strdup(fn + 5)))
3269                         return -ENOMEM;
3270
3271                 *r = b;
3272                 if (_devnr)
3273                         *_devnr = devnr;
3274
3275                 return 0;
3276         }
3277
3278         if (startswith(s, "/dev/"))
3279                 p = s + 5;
3280         else if (startswith(s, "../"))
3281                 p = s + 3;
3282         else
3283                 p = s;
3284
3285         b = strdup(p);
3286         free(s);
3287
3288         if (!b)
3289                 return -ENOMEM;
3290
3291         *r = b;
3292         if (_devnr)
3293                 *_devnr = devnr;
3294
3295         return 0;
3296 }
3297
3298 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3299         DIR *d;
3300         int ret = 0;
3301
3302         assert(fd >= 0);
3303
3304         /* This returns the first error we run into, but nevertheless
3305          * tries to go on. This closes the passed fd. */
3306
3307         d = fdopendir(fd);
3308         if (!d) {
3309                 close_nointr_nofail(fd);
3310
3311                 return errno == ENOENT ? 0 : -errno;
3312         }
3313
3314         for (;;) {
3315                 struct dirent *de;
3316                 union dirent_storage buf;
3317                 bool is_dir, keep_around;
3318                 struct stat st;
3319                 int r;
3320
3321                 r = readdir_r(d, &buf.de, &de);
3322                 if (r != 0 && ret == 0) {
3323                         ret = -r;
3324                         break;
3325                 }
3326
3327                 if (!de)
3328                         break;
3329
3330                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
3331                         continue;
3332
3333                 if (de->d_type == DT_UNKNOWN ||
3334                     honour_sticky ||
3335                     (de->d_type == DT_DIR && root_dev)) {
3336                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3337                                 if (ret == 0 && errno != ENOENT)
3338                                         ret = -errno;
3339                                 continue;
3340                         }
3341
3342                         is_dir = S_ISDIR(st.st_mode);
3343                         keep_around =
3344                                 honour_sticky &&
3345                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3346                                 (st.st_mode & S_ISVTX);
3347                 } else {
3348                         is_dir = de->d_type == DT_DIR;
3349                         keep_around = false;
3350                 }
3351
3352                 if (is_dir) {
3353                         int subdir_fd;
3354
3355                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
3356                         if (root_dev && st.st_dev != root_dev->st_dev)
3357                                 continue;
3358
3359                         subdir_fd = openat(fd, de->d_name,
3360                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3361                         if (subdir_fd < 0) {
3362                                 if (ret == 0 && errno != ENOENT)
3363                                         ret = -errno;
3364                                 continue;
3365                         }
3366
3367                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
3368                         if (r < 0 && ret == 0)
3369                                 ret = r;
3370
3371                         if (!keep_around)
3372                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3373                                         if (ret == 0 && errno != ENOENT)
3374                                                 ret = -errno;
3375                                 }
3376
3377                 } else if (!only_dirs && !keep_around) {
3378
3379                         if (unlinkat(fd, de->d_name, 0) < 0) {
3380                                 if (ret == 0 && errno != ENOENT)
3381                                         ret = -errno;
3382                         }
3383                 }
3384         }
3385
3386         closedir(d);
3387
3388         return ret;
3389 }
3390
3391 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3392         struct statfs s;
3393
3394         assert(fd >= 0);
3395
3396         if (fstatfs(fd, &s) < 0) {
3397                 close_nointr_nofail(fd);
3398                 retu