src/shared/util.c

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