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