src/shared/util.c

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