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