src/shared/util.c

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