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