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