src/shared/util.c

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