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 <string.h>
  23 #include <unistd.h>
  24 #include <errno.h>
  25 #include <stdlib.h>
  26 #include <signal.h>
  27 #include <libintl.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 <poll.h>
  43 #include <ctype.h>
  44 #include <sys/prctl.h>
  45 #include <sys/utsname.h>
  46 #include <pwd.h>
  47 #include <netinet/ip.h>
  48 #include <linux/kd.h>
  49 #include <sys/wait.h>
  50 #include <sys/time.h>
  51 #include <glob.h>
  52 #include <grp.h>
  53 #include <sys/mman.h>
  54 #include <sys/vfs.h>
  55 #include <sys/mount.h>
  56 #include <linux/magic.h>
  57 #include <limits.h>
  58 #include <langinfo.h>
  59 #include <locale.h>
  60 #include <sys/personality.h>
  61 #include <sys/xattr.h>
  62 #include <sys/statvfs.h>
  63 #include <sys/file.h>
  64 #include <linux/fs.h>
  65
  66 /* When we include libgen.h because we need dirname() we immediately
  67  * undefine basename() since libgen.h defines it as a macro to the XDG
  68  * version which is really broken. */
  69 #include <libgen.h>
  70 #undef basename
  71
  72 #ifdef HAVE_SYS_AUXV_H
  73 #include <sys/auxv.h>
  74 #endif
  75
  76 #include "config.h"
  77 #include "macro.h"
  78 #include "util.h"
  79 #include "ioprio.h"
  80 #include "missing.h"
  81 #include "log.h"
  82 #include "strv.h"
  83 #include "mkdir.h"
  84 #include "path-util.h"
  85 #include "exit-status.h"
  86 #include "hashmap.h"
  87 #include "env-util.h"
  88 #include "fileio.h"
  89 #include "device-nodes.h"
  90 #include "utf8.h"
  91 #include "gunicode.h"
  92 #include "virt.h"
  93 #include "def.h"
  94 #include "sparse-endian.h"
  95
  96 /* Put this test here for a lack of better place */
  97 assert_cc(EAGAIN == EWOULDBLOCK);
  98
  99 int saved_argc = 0;
 100 char **saved_argv = NULL;
 101
 102 static volatile unsigned cached_columns = 0;
 103 static volatile unsigned cached_lines = 0;
 104
 105 size_t page_size(void) {
 106         static thread_local size_t pgsz = 0;
 107         long r;
 108
 109         if (_likely_(pgsz > 0))
 110                 return pgsz;
 111
 112         r = sysconf(_SC_PAGESIZE);
 113         assert(r > 0);
 114
 115         pgsz = (size_t) r;
 116         return pgsz;
 117 }
 118
 119 bool streq_ptr(const char *a, const char *b) {
 120
 121         /* Like streq(), but tries to make sense of NULL pointers */
 122
 123         if (a && b)
 124                 return streq(a, b);
 125
 126         if (!a && !b)
 127                 return true;
 128
 129         return false;
 130 }
 131
 132 char* endswith(const char *s, const char *postfix) {
 133         size_t sl, pl;
 134
 135         assert(s);
 136         assert(postfix);
 137
 138         sl = strlen(s);
 139         pl = strlen(postfix);
 140
 141         if (pl == 0)
 142                 return (char*) s + sl;
 143
 144         if (sl < pl)
 145                 return NULL;
 146
 147         if (memcmp(s + sl - pl, postfix, pl) != 0)
 148                 return NULL;
 149
 150         return (char*) s + sl - pl;
 151 }
 152
 153 char* endswith_no_case(const char *s, const char *postfix) {
 154         size_t sl, pl;
 155
 156         assert(s);
 157         assert(postfix);
 158
 159         sl = strlen(s);
 160         pl = strlen(postfix);
 161
 162         if (pl == 0)
 163                 return (char*) s + sl;
 164
 165         if (sl < pl)
 166                 return NULL;
 167
 168         if (strcasecmp(s + sl - pl, postfix) != 0)
 169                 return NULL;
 170
 171         return (char*) s + sl - pl;
 172 }
 173
 174 char* first_word(const char *s, const char *word) {
 175         size_t sl, wl;
 176         const char *p;
 177
 178         assert(s);
 179         assert(word);
 180
 181         /* Checks if the string starts with the specified word, either
 182          * followed by NUL or by whitespace. Returns a pointer to the
 183          * NUL or the first character after the whitespace. */
 184
 185         sl = strlen(s);
 186         wl = strlen(word);
 187
 188         if (sl < wl)
 189                 return NULL;
 190
 191         if (wl == 0)
 192                 return (char*) s;
 193
 194         if (memcmp(s, word, wl) != 0)
 195                 return NULL;
 196
 197         p = s + wl;
 198         if (*p == 0)
 199                 return (char*) p;
 200
 201         if (!strchr(WHITESPACE, *p))
 202                 return NULL;
 203
 204         p += strspn(p, WHITESPACE);
 205         return (char*) p;
 206 }
 207
 208 static size_t cescape_char(char c, char *buf) {
 209         char * buf_old = buf;
 210
 211         switch (c) {
 212
 213                 case '\a':
 214                         *(buf++) = '\\';
 215                         *(buf++) = 'a';
 216                         break;
 217                 case '\b':
 218                         *(buf++) = '\\';
 219                         *(buf++) = 'b';
 220                         break;
 221                 case '\f':
 222                         *(buf++) = '\\';
 223                         *(buf++) = 'f';
 224                         break;
 225                 case '\n':
 226                         *(buf++) = '\\';
 227                         *(buf++) = 'n';
 228                         break;
 229                 case '\r':
 230                         *(buf++) = '\\';
 231                         *(buf++) = 'r';
 232                         break;
 233                 case '\t':
 234                         *(buf++) = '\\';
 235                         *(buf++) = 't';
 236                         break;
 237                 case '\v':
 238                         *(buf++) = '\\';
 239                         *(buf++) = 'v';
 240                         break;
 241                 case '\\':
 242                         *(buf++) = '\\';
 243                         *(buf++) = '\\';
 244                         break;
 245                 case '"':
 246                         *(buf++) = '\\';
 247                         *(buf++) = '"';
 248                         break;
 249                 case '\'':
 250                         *(buf++) = '\\';
 251                         *(buf++) = '\'';
 252                         break;
 253
 254                 default:
 255                         /* For special chars we prefer octal over
 256                          * hexadecimal encoding, simply because glib's
 257                          * g_strescape() does the same */
 258                         if ((c < ' ') || (c >= 127)) {
 259                                 *(buf++) = '\\';
 260                                 *(buf++) = octchar((unsigned char) c >> 6);
 261                                 *(buf++) = octchar((unsigned char) c >> 3);
 262                                 *(buf++) = octchar((unsigned char) c);
 263                         } else
 264                                 *(buf++) = c;
 265                         break;
 266         }
 267
 268         return buf - buf_old;
 269 }
 270
 271 int close_nointr(int fd) {
 272         assert(fd >= 0);
 273
 274         if (close(fd) >= 0)
 275                 return 0;
 276
 277         /*
 278          * Just ignore EINTR; a retry loop is the wrong thing to do on
 279          * Linux.
 280          *
 281          * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
 282          * https://bugzilla.gnome.org/show_bug.cgi?id=682819
 283          * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
 284          * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
 285          */
 286         if (errno == EINTR)
 287                 return 0;
 288
 289         return -errno;
 290 }
 291
 292 int safe_close(int fd) {
 293
 294         /*
 295          * Like close_nointr() but cannot fail. Guarantees errno is
 296          * unchanged. Is a NOP with negative fds passed, and returns
 297          * -1, so that it can be used in this syntax:
 298          *
 299          * fd = safe_close(fd);
 300          */
 301
 302         if (fd >= 0) {
 303                 PROTECT_ERRNO;
 304
 305                 /* The kernel might return pretty much any error code
 306                  * via close(), but the fd will be closed anyway. The
 307                  * only condition we want to check for here is whether
 308                  * the fd was invalid at all... */
 309
 310                 assert_se(close_nointr(fd) != -EBADF);
 311         }
 312
 313         return -1;
 314 }
 315
 316 void close_many(const int fds[], unsigned n_fd) {
 317         unsigned i;
 318
 319         assert(fds || n_fd <= 0);
 320
 321         for (i = 0; i < n_fd; i++)
 322                 safe_close(fds[i]);
 323 }
 324
 325 int unlink_noerrno(const char *path) {
 326         PROTECT_ERRNO;
 327         int r;
 328
 329         r = unlink(path);
 330         if (r < 0)
 331                 return -errno;
 332
 333         return 0;
 334 }
 335
 336 int parse_boolean(const char *v) {
 337         assert(v);
 338
 339         if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
 340                 return 1;
 341         else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
 342                 return 0;
 343
 344         return -EINVAL;
 345 }
 346
 347 int parse_pid(const char *s, pid_t* ret_pid) {
 348         unsigned long ul = 0;
 349         pid_t pid;
 350         int r;
 351
 352         assert(s);
 353         assert(ret_pid);
 354
 355         r = safe_atolu(s, &ul);
 356         if (r < 0)
 357                 return r;
 358
 359         pid = (pid_t) ul;
 360
 361         if ((unsigned long) pid != ul)
 362                 return -ERANGE;
 363
 364         if (pid <= 0)
 365                 return -ERANGE;
 366
 367         *ret_pid = pid;
 368         return 0;
 369 }
 370
 371 int parse_uid(const char *s, uid_t* ret_uid) {
 372         unsigned long ul = 0;
 373         uid_t uid;
 374         int r;
 375
 376         assert(s);
 377         assert(ret_uid);
 378
 379         r = safe_atolu(s, &ul);
 380         if (r < 0)
 381                 return r;
 382
 383         uid = (uid_t) ul;
 384
 385         if ((unsigned long) uid != ul)
 386                 return -ERANGE;
 387
 388         /* Some libc APIs use UID_INVALID as special placeholder */
 389         if (uid == (uid_t) 0xFFFFFFFF)
 390                 return -ENXIO;
 391
 392         /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
 393         if (uid == (uid_t) 0xFFFF)
 394                 return -ENXIO;
 395
 396         *ret_uid = uid;
 397         return 0;
 398 }
 399
 400 int safe_atou(const char *s, unsigned *ret_u) {
 401         char *x = NULL;
 402         unsigned long l;
 403
 404         assert(s);
 405         assert(ret_u);
 406
 407         errno = 0;
 408         l = strtoul(s, &x, 0);
 409
 410         if (!x || x == s || *x || errno)
 411                 return errno > 0 ? -errno : -EINVAL;
 412
 413         if ((unsigned long) (unsigned) l != l)
 414                 return -ERANGE;
 415
 416         *ret_u = (unsigned) l;
 417         return 0;
 418 }
 419
 420 int safe_atoi(const char *s, int *ret_i) {
 421         char *x = NULL;
 422         long l;
 423
 424         assert(s);
 425         assert(ret_i);
 426
 427         errno = 0;
 428         l = strtol(s, &x, 0);
 429
 430         if (!x || x == s || *x || errno)
 431                 return errno > 0 ? -errno : -EINVAL;
 432
 433         if ((long) (int) l != l)
 434                 return -ERANGE;
 435
 436         *ret_i = (int) l;
 437         return 0;
 438 }
 439
 440 int safe_atou8(const char *s, uint8_t *ret) {
 441         char *x = NULL;
 442         unsigned long l;
 443
 444         assert(s);
 445         assert(ret);
 446
 447         errno = 0;
 448         l = strtoul(s, &x, 0);
 449
 450         if (!x || x == s || *x || errno)
 451                 return errno > 0 ? -errno : -EINVAL;
 452
 453         if ((unsigned long) (uint8_t) l != l)
 454                 return -ERANGE;
 455
 456         *ret = (uint8_t) l;
 457         return 0;
 458 }
 459
 460 int safe_atou16(const char *s, uint16_t *ret) {
 461         char *x = NULL;
 462         unsigned long l;
 463
 464         assert(s);
 465         assert(ret);
 466
 467         errno = 0;
 468         l = strtoul(s, &x, 0);
 469
 470         if (!x || x == s || *x || errno)
 471                 return errno > 0 ? -errno : -EINVAL;
 472
 473         if ((unsigned long) (uint16_t) l != l)
 474                 return -ERANGE;
 475
 476         *ret = (uint16_t) l;
 477         return 0;
 478 }
 479
 480 int safe_atoi16(const char *s, int16_t *ret) {
 481         char *x = NULL;
 482         long l;
 483
 484         assert(s);
 485         assert(ret);
 486
 487         errno = 0;
 488         l = strtol(s, &x, 0);
 489
 490         if (!x || x == s || *x || errno)
 491                 return errno > 0 ? -errno : -EINVAL;
 492
 493         if ((long) (int16_t) l != l)
 494                 return -ERANGE;
 495
 496         *ret = (int16_t) l;
 497         return 0;
 498 }
 499
 500 int safe_atollu(const char *s, long long unsigned *ret_llu) {
 501         char *x = NULL;
 502         unsigned long long l;
 503
 504         assert(s);
 505         assert(ret_llu);
 506
 507         errno = 0;
 508         l = strtoull(s, &x, 0);
 509
 510         if (!x || x == s || *x || errno)
 511                 return errno ? -errno : -EINVAL;
 512
 513         *ret_llu = l;
 514         return 0;
 515 }
 516
 517 int safe_atolli(const char *s, long long int *ret_lli) {
 518         char *x = NULL;
 519         long long l;
 520
 521         assert(s);
 522         assert(ret_lli);
 523
 524         errno = 0;
 525         l = strtoll(s, &x, 0);
 526
 527         if (!x || x == s || *x || errno)
 528                 return errno ? -errno : -EINVAL;
 529
 530         *ret_lli = l;
 531         return 0;
 532 }
 533
 534 int safe_atod(const char *s, double *ret_d) {
 535         char *x = NULL;
 536         double d = 0;
 537         locale_t loc;
 538
 539         assert(s);
 540         assert(ret_d);
 541
 542         loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
 543         if (loc == (locale_t) 0)
 544                 return -errno;
 545
 546         errno = 0;
 547         d = strtod_l(s, &x, loc);
 548
 549         if (!x || x == s || *x || errno) {
 550                 freelocale(loc);
 551                 return errno ? -errno : -EINVAL;
 552         }
 553
 554         freelocale(loc);
 555         *ret_d = (double) d;
 556         return 0;
 557 }
 558
 559 static size_t strcspn_escaped(const char *s, const char *reject) {
 560         bool escaped = false;
 561         int n;
 562
 563         for (n=0; s[n]; n++) {
 564                 if (escaped)
 565                         escaped = false;
 566                 else if (s[n] == '\\')
 567                         escaped = true;
 568                 else if (strchr(reject, s[n]))
 569                         break;
 570         }
 571
 572         /* if s ends in \, return index of previous char */
 573         return n - escaped;
 574 }
 575
 576 /* Split a string into words. */
 577 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
 578         const char *current;
 579
 580         current = *state;
 581
 582         if (!*current) {
 583                 assert(**state == '\0');
 584                 return NULL;
 585         }
 586
 587         current += strspn(current, separator);
 588         if (!*current) {
 589                 *state = current;
 590                 return NULL;
 591         }
 592
 593         if (quoted && strchr("\'\"", *current)) {
 594                 char quotechars[2] = {*current, '\0'};
 595
 596                 *l = strcspn_escaped(current + 1, quotechars);
 597                 if (current[*l + 1] == '\0' ||
 598                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
 599                         /* right quote missing or garbage at the end */
 600                         *state = current;
 601                         return NULL;
 602                 }
 603                 assert(current[*l + 1] == quotechars[0]);
 604                 *state = current++ + *l + 2;
 605         } else if (quoted) {
 606                 *l = strcspn_escaped(current, separator);
 607                 if (current[*l] && !strchr(separator, current[*l])) {
 608                         /* unfinished escape */
 609                         *state = current;
 610                         return NULL;
 611                 }
 612                 *state = current + *l;
 613         } else {
 614                 *l = strcspn(current, separator);
 615                 *state = current + *l;
 616         }
 617
 618         return current;
 619 }
 620
 621 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
 622         int r;
 623         _cleanup_free_ char *line = NULL;
 624         long unsigned ppid;
 625         const char *p;
 626
 627         assert(pid >= 0);
 628         assert(_ppid);
 629
 630         if (pid == 0) {
 631                 *_ppid = getppid();
 632                 return 0;
 633         }
 634
 635         p = procfs_file_alloca(pid, "stat");
 636         r = read_one_line_file(p, &line);
 637         if (r < 0)
 638                 return r;
 639
 640         /* Let's skip the pid and comm fields. The latter is enclosed
 641          * in () but does not escape any () in its value, so let's
 642          * skip over it manually */
 643
 644         p = strrchr(line, ')');
 645         if (!p)
 646                 return -EIO;
 647
 648         p++;
 649
 650         if (sscanf(p, " "
 651                    "%*c "  /* state */
 652                    "%lu ", /* ppid */
 653                    &ppid) != 1)
 654                 return -EIO;
 655
 656         if ((long unsigned) (pid_t) ppid != ppid)
 657                 return -ERANGE;
 658
 659         *_ppid = (pid_t) ppid;
 660
 661         return 0;
 662 }
 663
 664 int fchmod_umask(int fd, mode_t m) {
 665         mode_t u;
 666         int r;
 667
 668         u = umask(0777);
 669         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
 670         umask(u);
 671
 672         return r;
 673 }
 674
 675 char *truncate_nl(char *s) {
 676         assert(s);
 677
 678         s[strcspn(s, NEWLINE)] = 0;
 679         return s;
 680 }
 681
 682 int get_process_state(pid_t pid) {
 683         const char *p;
 684         char state;
 685         int r;
 686         _cleanup_free_ char *line = NULL;
 687
 688         assert(pid >= 0);
 689
 690         p = procfs_file_alloca(pid, "stat");
 691         r = read_one_line_file(p, &line);
 692         if (r < 0)
 693                 return r;
 694
 695         p = strrchr(line, ')');
 696         if (!p)
 697                 return -EIO;
 698
 699         p++;
 700
 701         if (sscanf(p, " %c", &state) != 1)
 702                 return -EIO;
 703
 704         return (unsigned char) state;
 705 }
 706
 707 int get_process_comm(pid_t pid, char **name) {
 708         const char *p;
 709         int r;
 710
 711         assert(name);
 712         assert(pid >= 0);
 713
 714         p = procfs_file_alloca(pid, "comm");
 715
 716         r = read_one_line_file(p, name);
 717         if (r == -ENOENT)
 718                 return -ESRCH;
 719
 720         return r;
 721 }
 722
 723 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
 724         _cleanup_fclose_ FILE *f = NULL;
 725         char *r = NULL, *k;
 726         const char *p;
 727         int c;
 728
 729         assert(line);
 730         assert(pid >= 0);
 731
 732         p = procfs_file_alloca(pid, "cmdline");
 733
 734         f = fopen(p, "re");
 735         if (!f)
 736                 return -errno;
 737
 738         if (max_length == 0) {
 739                 size_t len = 0, allocated = 0;
 740
 741                 while ((c = getc(f)) != EOF) {
 742
 743                         if (!GREEDY_REALLOC(r, allocated, len+2)) {
 744                                 free(r);
 745                                 return -ENOMEM;
 746                         }
 747
 748                         r[len++] = isprint(c) ? c : ' ';
 749                 }
 750
 751                 if (len > 0)
 752                         r[len-1] = 0;
 753
 754         } else {
 755                 bool space = false;
 756                 size_t left;
 757
 758                 r = new(char, max_length);
 759                 if (!r)
 760                         return -ENOMEM;
 761
 762                 k = r;
 763                 left = max_length;
 764                 while ((c = getc(f)) != EOF) {
 765
 766                         if (isprint(c)) {
 767                                 if (space) {
 768                                         if (left <= 4)
 769                                                 break;
 770
 771                                         *(k++) = ' ';
 772                                         left--;
 773                                         space = false;
 774                                 }
 775
 776                                 if (left <= 4)
 777                                         break;
 778
 779                                 *(k++) = (char) c;
 780                                 left--;
 781                         }  else
 782                                 space = true;
 783                 }
 784
 785                 if (left <= 4) {
 786                         size_t n = MIN(left-1, 3U);
 787                         memcpy(k, "...", n);
 788                         k[n] = 0;
 789                 } else
 790                         *k = 0;
 791         }
 792
 793         /* Kernel threads have no argv[] */
 794         if (isempty(r)) {
 795                 _cleanup_free_ char *t = NULL;
 796                 int h;
 797
 798                 free(r);
 799
 800                 if (!comm_fallback)
 801                         return -ENOENT;
 802
 803                 h = get_process_comm(pid, &t);
 804                 if (h < 0)
 805                         return h;
 806
 807                 r = strjoin("[", t, "]", NULL);
 808                 if (!r)
 809                         return -ENOMEM;
 810         }
 811
 812         *line = r;
 813         return 0;
 814 }
 815
 816 int is_kernel_thread(pid_t pid) {
 817         const char *p;
 818         size_t count;
 819         char c;
 820         bool eof;
 821         FILE *f;
 822
 823         if (pid == 0)
 824                 return 0;
 825
 826         assert(pid > 0);
 827
 828         p = procfs_file_alloca(pid, "cmdline");
 829         f = fopen(p, "re");
 830         if (!f)
 831                 return -errno;
 832
 833         count = fread(&c, 1, 1, f);
 834         eof = feof(f);
 835         fclose(f);
 836
 837         /* Kernel threads have an empty cmdline */
 838
 839         if (count <= 0)
 840                 return eof ? 1 : -errno;
 841
 842         return 0;
 843 }
 844
 845 int get_process_capeff(pid_t pid, char **capeff) {
 846         const char *p;
 847
 848         assert(capeff);
 849         assert(pid >= 0);
 850
 851         p = procfs_file_alloca(pid, "status");
 852
 853         return get_status_field(p, "\nCapEff:", capeff);
 854 }
 855
 856 static int get_process_link_contents(const char *proc_file, char **name) {
 857         int r;
 858
 859         assert(proc_file);
 860         assert(name);
 861
 862         r = readlink_malloc(proc_file, name);
 863         if (r < 0)
 864                 return r == -ENOENT ? -ESRCH : r;
 865
 866         return 0;
 867 }
 868
 869 int get_process_exe(pid_t pid, char **name) {
 870         const char *p;
 871         char *d;
 872         int r;
 873
 874         assert(pid >= 0);
 875
 876         p = procfs_file_alloca(pid, "exe");
 877         r = get_process_link_contents(p, name);
 878         if (r < 0)
 879                 return r;
 880
 881         d = endswith(*name, " (deleted)");
 882         if (d)
 883                 *d = '\0';
 884
 885         return 0;
 886 }
 887
 888 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
 889         _cleanup_fclose_ FILE *f = NULL;
 890         char line[LINE_MAX];
 891         const char *p;
 892
 893         assert(field);
 894         assert(uid);
 895
 896         if (pid == 0)
 897                 return getuid();
 898
 899         p = procfs_file_alloca(pid, "status");
 900         f = fopen(p, "re");
 901         if (!f)
 902                 return -errno;
 903
 904         FOREACH_LINE(line, f, return -errno) {
 905                 char *l;
 906
 907                 l = strstrip(line);
 908
 909                 if (startswith(l, field)) {
 910                         l += strlen(field);
 911                         l += strspn(l, WHITESPACE);
 912
 913                         l[strcspn(l, WHITESPACE)] = 0;
 914
 915                         return parse_uid(l, uid);
 916                 }
 917         }
 918
 919         return -EIO;
 920 }
 921
 922 int get_process_uid(pid_t pid, uid_t *uid) {
 923         return get_process_id(pid, "Uid:", uid);
 924 }
 925
 926 int get_process_gid(pid_t pid, gid_t *gid) {
 927         assert_cc(sizeof(uid_t) == sizeof(gid_t));
 928         return get_process_id(pid, "Gid:", gid);
 929 }
 930
 931 int get_process_cwd(pid_t pid, char **cwd) {
 932         const char *p;
 933
 934         assert(pid >= 0);
 935
 936         p = procfs_file_alloca(pid, "cwd");
 937
 938         return get_process_link_contents(p, cwd);
 939 }
 940
 941 int get_process_root(pid_t pid, char **root) {
 942         const char *p;
 943
 944         assert(pid >= 0);
 945
 946         p = procfs_file_alloca(pid, "root");
 947
 948         return get_process_link_contents(p, root);
 949 }
 950
 951 int get_process_environ(pid_t pid, char **env) {
 952         _cleanup_fclose_ FILE *f = NULL;
 953         _cleanup_free_ char *outcome = NULL;
 954         int c;
 955         const char *p;
 956         size_t allocated = 0, sz = 0;
 957
 958         assert(pid >= 0);
 959         assert(env);
 960
 961         p = procfs_file_alloca(pid, "environ");
 962
 963         f = fopen(p, "re");
 964         if (!f)
 965                 return -errno;
 966
 967         while ((c = fgetc(f)) != EOF) {
 968                 if (!GREEDY_REALLOC(outcome, allocated, sz + 5))
 969                         return -ENOMEM;
 970
 971                 if (c == '\0')
 972                         outcome[sz++] = '\n';
 973                 else
 974                         sz += cescape_char(c, outcome + sz);
 975         }
 976
 977         outcome[sz] = '\0';
 978         *env = outcome;
 979         outcome = NULL;
 980
 981         return 0;
 982 }
 983
 984 char *strnappend(const char *s, const char *suffix, size_t b) {
 985         size_t a;
 986         char *r;
 987
 988         if (!s && !suffix)
 989                 return strdup("");
 990
 991         if (!s)
 992                 return strndup(suffix, b);
 993
 994         if (!suffix)
 995                 return strdup(s);
 996
 997         assert(s);
 998         assert(suffix);
 999
1000         a = strlen(s);
1001         if (b > ((size_t) -1) - a)
1002                 return NULL;
1003
1004         r = new(char, a+b+1);
1005         if (!r)
1006                 return NULL;
1007
1008         memcpy(r, s, a);
1009         memcpy(r+a, suffix, b);
1010         r[a+b] = 0;
1011
1012         return r;
1013 }
1014
1015 char *strappend(const char *s, const char *suffix) {
1016         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
1017 }
1018
1019 int readlinkat_malloc(int fd, const char *p, char **ret) {
1020         size_t l = 100;
1021         int r;
1022
1023         assert(p);
1024         assert(ret);
1025
1026         for (;;) {
1027                 char *c;
1028                 ssize_t n;
1029
1030                 c = new(char, l);
1031                 if (!c)
1032                         return -ENOMEM;
1033
1034                 n = readlinkat(fd, p, c, l-1);
1035                 if (n < 0) {
1036                         r = -errno;
1037                         free(c);
1038                         return r;
1039                 }
1040
1041                 if ((size_t) n < l-1) {
1042                         c[n] = 0;
1043                         *ret = c;
1044                         return 0;
1045                 }
1046
1047                 free(c);
1048                 l *= 2;
1049         }
1050 }
1051
1052 int readlink_malloc(const char *p, char **ret) {
1053         return readlinkat_malloc(AT_FDCWD, p, ret);
1054 }
1055
1056 int readlink_value(const char *p, char **ret) {
1057         _cleanup_free_ char *link = NULL;
1058         char *value;
1059         int r;
1060
1061         r = readlink_malloc(p, &link);
1062         if (r < 0)
1063                 return r;
1064
1065         value = basename(link);
1066         if (!value)
1067                 return -ENOENT;
1068
1069         value = strdup(value);
1070         if (!value)
1071                 return -ENOMEM;
1072
1073         *ret = value;
1074
1075         return 0;
1076 }
1077
1078 int readlink_and_make_absolute(const char *p, char **r) {
1079         _cleanup_free_ char *target = NULL;
1080         char *k;
1081         int j;
1082
1083         assert(p);
1084         assert(r);
1085
1086         j = readlink_malloc(p, &target);
1087         if (j < 0)
1088                 return j;
1089
1090         k = file_in_same_dir(p, target);
1091         if (!k)
1092                 return -ENOMEM;
1093
1094         *r = k;
1095         return 0;
1096 }
1097
1098 int readlink_and_canonicalize(const char *p, char **r) {
1099         char *t, *s;
1100         int j;
1101
1102         assert(p);
1103         assert(r);
1104
1105         j = readlink_and_make_absolute(p, &t);
1106         if (j < 0)
1107                 return j;
1108
1109         s = canonicalize_file_name(t);
1110         if (s) {
1111                 free(t);
1112                 *r = s;
1113         } else
1114                 *r = t;
1115
1116         path_kill_slashes(*r);
1117
1118         return 0;
1119 }
1120
1121 int reset_all_signal_handlers(void) {
1122         int sig, r = 0;
1123
1124         for (sig = 1; sig < _NSIG; sig++) {
1125                 struct sigaction sa = {
1126                         .sa_handler = SIG_DFL,
1127                         .sa_flags = SA_RESTART,
1128                 };
1129
1130                 /* These two cannot be caught... */
1131                 if (sig == SIGKILL || sig == SIGSTOP)
1132                         continue;
1133
1134                 /* On Linux the first two RT signals are reserved by
1135                  * glibc, and sigaction() will return EINVAL for them. */
1136                 if ((sigaction(sig, &sa, NULL) < 0))
1137                         if (errno != EINVAL && r == 0)
1138                                 r = -errno;
1139         }
1140
1141         return r;
1142 }
1143
1144 int reset_signal_mask(void) {
1145         sigset_t ss;
1146
1147         if (sigemptyset(&ss) < 0)
1148                 return -errno;
1149
1150         if (sigprocmask(SIG_SETMASK, &ss, NULL) < 0)
1151                 return -errno;
1152
1153         return 0;
1154 }
1155
1156 char *strstrip(char *s) {
1157         char *e;
1158
1159         /* Drops trailing whitespace. Modifies the string in
1160          * place. Returns pointer to first non-space character */
1161
1162         s += strspn(s, WHITESPACE);
1163
1164         for (e = strchr(s, 0); e > s; e --)
1165                 if (!strchr(WHITESPACE, e[-1]))
1166                         break;
1167
1168         *e = 0;
1169
1170         return s;
1171 }
1172
1173 char *delete_chars(char *s, const char *bad) {
1174         char *f, *t;
1175
1176         /* Drops all whitespace, regardless where in the string */
1177
1178         for (f = s, t = s; *f; f++) {
1179                 if (strchr(bad, *f))
1180                         continue;
1181
1182                 *(t++) = *f;
1183         }
1184
1185         *t = 0;
1186
1187         return s;
1188 }
1189
1190 char *file_in_same_dir(const char *path, const char *filename) {
1191         char *e, *ret;
1192         size_t k;
1193
1194         assert(path);
1195         assert(filename);
1196
1197         /* This removes the last component of path and appends
1198          * filename, unless the latter is absolute anyway or the
1199          * former isn't */
1200
1201         if (path_is_absolute(filename))
1202                 return strdup(filename);
1203
1204         e = strrchr(path, '/');
1205         if (!e)
1206                 return strdup(filename);
1207
1208         k = strlen(filename);
1209         ret = new(char, (e + 1 - path) + k + 1);
1210         if (!ret)
1211                 return NULL;
1212
1213         memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);
1214         return ret;
1215 }
1216
1217 int rmdir_parents(const char *path, const char *stop) {
1218         size_t l;
1219         int r = 0;
1220
1221         assert(path);
1222         assert(stop);
1223
1224         l = strlen(path);
1225
1226         /* Skip trailing slashes */
1227         while (l > 0 && path[l-1] == '/')
1228                 l--;
1229
1230         while (l > 0) {
1231                 char *t;
1232
1233                 /* Skip last component */
1234                 while (l > 0 && path[l-1] != '/')
1235                         l--;
1236
1237                 /* Skip trailing slashes */
1238                 while (l > 0 && path[l-1] == '/')
1239                         l--;
1240
1241                 if (l <= 0)
1242                         break;
1243
1244                 if (!(t = strndup(path, l)))
1245                         return -ENOMEM;
1246
1247                 if (path_startswith(stop, t)) {
1248                         free(t);
1249                         return 0;
1250                 }
1251
1252                 r = rmdir(t);
1253                 free(t);
1254
1255                 if (r < 0)
1256                         if (errno != ENOENT)
1257                                 return -errno;
1258         }
1259
1260         return 0;
1261 }
1262
1263 char hexchar(int x) {
1264         static const char table[16] = "0123456789abcdef";
1265
1266         return table[x & 15];
1267 }
1268
1269 int unhexchar(char c) {
1270
1271         if (c >= '0' && c <= '9')
1272                 return c - '0';
1273
1274         if (c >= 'a' && c <= 'f')
1275                 return c - 'a' + 10;
1276
1277         if (c >= 'A' && c <= 'F')
1278                 return c - 'A' + 10;
1279
1280         return -EINVAL;
1281 }
1282
1283 char *hexmem(const void *p, size_t l) {
1284         char *r, *z;
1285         const uint8_t *x;
1286
1287         z = r = malloc(l * 2 + 1);
1288         if (!r)
1289                 return NULL;
1290
1291         for (x = p; x < (const uint8_t*) p + l; x++) {
1292                 *(z++) = hexchar(*x >> 4);
1293                 *(z++) = hexchar(*x & 15);
1294         }
1295
1296         *z = 0;
1297         return r;
1298 }
1299
1300 void *unhexmem(const char *p, size_t l) {
1301         uint8_t *r, *z;
1302         const char *x;
1303
1304         assert(p);
1305
1306         z = r = malloc((l + 1) / 2 + 1);
1307         if (!r)
1308                 return NULL;
1309
1310         for (x = p; x < p + l; x += 2) {
1311                 int a, b;
1312
1313                 a = unhexchar(x[0]);
1314                 if (x+1 < p + l)
1315                         b = unhexchar(x[1]);
1316                 else
1317                         b = 0;
1318
1319                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
1320         }
1321
1322         *z = 0;
1323         return r;
1324 }
1325
1326 char octchar(int x) {
1327         return '0' + (x & 7);
1328 }
1329
1330 int unoctchar(char c) {
1331
1332         if (c >= '0' && c <= '7')
1333                 return c - '0';
1334
1335         return -EINVAL;
1336 }
1337
1338 char decchar(int x) {
1339         return '0' + (x % 10);
1340 }
1341
1342 int undecchar(char c) {
1343
1344         if (c >= '0' && c <= '9')
1345                 return c - '0';
1346
1347         return -EINVAL;
1348 }
1349
1350 char *cescape(const char *s) {
1351         char *r, *t;
1352         const char *f;
1353
1354         assert(s);
1355
1356         /* Does C style string escaping. May be reversed with
1357          * cunescape(). */
1358
1359         r = new(char, strlen(s)*4 + 1);
1360         if (!r)
1361                 return NULL;
1362
1363         for (f = s, t = r; *f; f++)
1364                 t += cescape_char(*f, t);
1365
1366         *t = 0;
1367
1368         return r;
1369 }
1370
1371 static int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode) {
1372         int r = 1;
1373
1374         assert(p);
1375         assert(*p);
1376         assert(ret);
1377
1378         /* Unescapes C style. Returns the unescaped character in ret,
1379          * unless we encountered a \u sequence in which case the full
1380          * unicode character is returned in ret_unicode, instead. */
1381
1382         if (length != (size_t) -1 && length < 1)
1383                 return -EINVAL;
1384
1385         switch (p[0]) {
1386
1387         case 'a':
1388                 *ret = '\a';
1389                 break;
1390         case 'b':
1391                 *ret = '\b';
1392                 break;
1393         case 'f':
1394                 *ret = '\f';
1395                 break;
1396         case 'n':
1397                 *ret = '\n';
1398                 break;
1399         case 'r':
1400                 *ret = '\r';
1401                 break;
1402         case 't':
1403                 *ret = '\t';
1404                 break;
1405         case 'v':
1406                 *ret = '\v';
1407                 break;
1408         case '\\':
1409                 *ret = '\\';
1410                 break;
1411         case '"':
1412                 *ret = '"';
1413                 break;
1414         case '\'':
1415                 *ret = '\'';
1416                 break;
1417
1418         case 's':
1419                 /* This is an extension of the XDG syntax files */
1420                 *ret = ' ';
1421                 break;
1422
1423         case 'x': {
1424                 /* hexadecimal encoding */
1425                 int a, b;
1426
1427                 if (length != (size_t) -1 && length < 3)
1428                         return -EINVAL;
1429
1430                 a = unhexchar(p[1]);
1431                 if (a < 0)
1432                         return -EINVAL;
1433
1434                 b = unhexchar(p[2]);
1435                 if (b < 0)
1436                         return -EINVAL;
1437
1438                 /* Don't allow NUL bytes */
1439                 if (a == 0 && b == 0)
1440                         return -EINVAL;
1441
1442                 *ret = (char) ((a << 4U) | b);
1443                 r = 3;
1444                 break;
1445         }
1446
1447         case 'u': {
1448                 /* C++11 style 16bit unicode */
1449
1450                 int a[4];
1451                 unsigned i;
1452                 uint32_t c;
1453
1454                 if (length != (size_t) -1 && length < 5)
1455                         return -EINVAL;
1456
1457                 for (i = 0; i < 4; i++) {
1458                         a[i] = unhexchar(p[1 + i]);
1459                         if (a[i] < 0)
1460                                 return a[i];
1461                 }
1462
1463                 c = ((uint32_t) a[0] << 12U) | ((uint32_t) a[1] << 8U) | ((uint32_t) a[2] << 4U) | (uint32_t) a[3];
1464
1465                 /* Don't allow 0 chars */
1466                 if (c == 0)
1467                         return -EINVAL;
1468
1469                 if (c < 128)
1470                         *ret = c;
1471                 else {
1472                         if (!ret_unicode)
1473                                 return -EINVAL;
1474
1475                         *ret = 0;
1476                         *ret_unicode = c;
1477                 }
1478
1479                 r = 5;
1480                 break;
1481         }
1482
1483         case 'U': {
1484                 /* C++11 style 32bit unicode */
1485
1486                 int a[8];
1487                 unsigned i;
1488                 uint32_t c;
1489
1490                 if (length != (size_t) -1 && length < 9)
1491                         return -EINVAL;
1492
1493                 for (i = 0; i < 8; i++) {
1494                         a[i] = unhexchar(p[1 + i]);
1495                         if (a[i] < 0)
1496                                 return a[i];
1497                 }
1498
1499                 c = ((uint32_t) a[0] << 28U) | ((uint32_t) a[1] << 24U) | ((uint32_t) a[2] << 20U) | ((uint32_t) a[3] << 16U) |
1500                     ((uint32_t) a[4] << 12U) | ((uint32_t) a[5] <<  8U) | ((uint32_t) a[6] <<  4U) |  (uint32_t) a[7];
1501
1502                 /* Don't allow 0 chars */
1503                 if (c == 0)
1504                         return -EINVAL;
1505
1506                 /* Don't allow invalid code points */
1507                 if (!unichar_is_valid(c))
1508                         return -EINVAL;
1509
1510                 if (c < 128)
1511                         *ret = c;
1512                 else {
1513                         if (!ret_unicode)
1514                                 return -EINVAL;
1515
1516                         *ret = 0;
1517                         *ret_unicode = c;
1518                 }
1519
1520                 r = 9;
1521                 break;
1522         }
1523
1524         case '0':
1525         case '1':
1526         case '2':
1527         case '3':
1528         case '4':
1529         case '5':
1530         case '6':
1531         case '7': {
1532                 /* octal encoding */
1533                 int a, b, c;
1534                 uint32_t m;
1535
1536                 if (length != (size_t) -1 && length < 4)
1537                         return -EINVAL;
1538
1539                 a = unoctchar(p[0]);
1540                 if (a < 0)
1541                         return -EINVAL;
1542
1543                 b = unoctchar(p[1]);
1544                 if (b < 0)
1545                         return -EINVAL;
1546
1547                 c = unoctchar(p[2]);
1548                 if (c < 0)
1549                         return -EINVAL;
1550
1551                 /* don't allow NUL bytes */
1552                 if (a == 0 && b == 0 && c == 0)
1553                         return -EINVAL;
1554
1555                 /* Don't allow bytes above 255 */
1556                 m = ((uint32_t) a << 6U) | ((uint32_t) b << 3U) | (uint32_t) c;
1557                 if (m > 255)
1558                         return -EINVAL;
1559
1560                 *ret = m;
1561                 r = 3;
1562                 break;
1563         }
1564
1565         default:
1566                 return -EINVAL;
1567         }
1568
1569         return r;
1570 }
1571
1572 int cunescape_length_with_prefix(const char *s, size_t length, const char *prefix, UnescapeFlags flags, char **ret) {
1573         char *r, *t;
1574         const char *f;
1575         size_t pl;
1576
1577         assert(s);
1578         assert(ret);
1579
1580         /* Undoes C style string escaping, and optionally prefixes it. */
1581
1582         pl = prefix ? strlen(prefix) : 0;
1583
1584         r = new(char, pl+length+1);
1585         if (!r)
1586                 return -ENOMEM;
1587
1588         if (prefix)
1589                 memcpy(r, prefix, pl);
1590
1591         for (f = s, t = r + pl; f < s + length; f++) {
1592                 size_t remaining;
1593                 uint32_t u;
1594                 char c;
1595                 int k;
1596
1597                 remaining = s + length - f;
1598                 assert(remaining > 0);
1599
1600                 if (*f != '\\') {
1601                         /* A literal literal, copy verbatim */
1602                         *(t++) = *f;
1603                         continue;
1604                 }
1605
1606                 if (remaining == 1) {
1607                         if (flags & UNESCAPE_RELAX) {
1608                                 /* A trailing backslash, copy verbatim */
1609                                 *(t++) = *f;
1610                                 continue;
1611                         }
1612
1613                         free(r);
1614                         return -EINVAL;
1615                 }
1616
1617                 k = cunescape_one(f + 1, remaining - 1, &c, &u);
1618                 if (k < 0) {
1619                         if (flags & UNESCAPE_RELAX) {
1620                                 /* Invalid escape code, let's take it literal then */
1621                                 *(t++) = '\\';
1622                                 continue;
1623                         }
1624
1625                         free(r);
1626                         return k;
1627                 }
1628
1629                 if (c != 0)
1630                         /* Non-Unicode? Let's encode this directly */
1631                         *(t++) = c;
1632                 else
1633                         /* Unicode? Then let's encode this in UTF-8 */
1634                         t += utf8_encode_unichar(t, u);
1635
1636                 f += k;
1637         }
1638
1639         *t = 0;
1640
1641         *ret = r;
1642         return t - r;
1643 }
1644
1645 int cunescape_length(const char *s, size_t length, UnescapeFlags flags, char **ret) {
1646         return cunescape_length_with_prefix(s, length, NULL, flags, ret);
1647 }
1648
1649 int cunescape(const char *s, UnescapeFlags flags, char **ret) {
1650         return cunescape_length(s, strlen(s), flags, ret);
1651 }
1652
1653 char *xescape(const char *s, const char *bad) {
1654         char *r, *t;
1655         const char *f;
1656
1657         /* Escapes all chars in bad, in addition to \ and all special
1658          * chars, in \xFF style escaping. May be reversed with
1659          * cunescape(). */
1660
1661         r = new(char, strlen(s) * 4 + 1);
1662         if (!r)
1663                 return NULL;
1664
1665         for (f = s, t = r; *f; f++) {
1666
1667                 if ((*f < ' ') || (*f >= 127) ||
1668                     (*f == '\\') || strchr(bad, *f)) {
1669                         *(t++) = '\\';
1670                         *(t++) = 'x';
1671                         *(t++) = hexchar(*f >> 4);
1672                         *(t++) = hexchar(*f);
1673                 } else
1674                         *(t++) = *f;
1675         }
1676
1677         *t = 0;
1678
1679         return r;
1680 }
1681
1682 char *ascii_strlower(char *t) {
1683         char *p;
1684
1685         assert(t);
1686
1687         for (p = t; *p; p++)
1688                 if (*p >= 'A' && *p <= 'Z')
1689                         *p = *p - 'A' + 'a';
1690
1691         return t;
1692 }
1693
1694 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1695         assert(filename);
1696
1697         return
1698                 filename[0] == '.' ||
1699                 streq(filename, "lost+found") ||
1700                 streq(filename, "aquota.user") ||
1701                 streq(filename, "aquota.group") ||
1702                 endswith(filename, ".rpmnew") ||
1703                 endswith(filename, ".rpmsave") ||
1704                 endswith(filename, ".rpmorig") ||
1705                 endswith(filename, ".dpkg-old") ||
1706                 endswith(filename, ".dpkg-new") ||
1707                 endswith(filename, ".dpkg-tmp") ||
1708                 endswith(filename, ".dpkg-dist") ||
1709                 endswith(filename, ".dpkg-bak") ||
1710                 endswith(filename, ".dpkg-backup") ||
1711                 endswith(filename, ".dpkg-remove") ||
1712                 endswith(filename, ".swp");
1713 }
1714
1715 bool hidden_file(const char *filename) {
1716         assert(filename);
1717
1718         if (endswith(filename, "~"))
1719                 return true;
1720
1721         return hidden_file_allow_backup(filename);
1722 }
1723
1724 int fd_nonblock(int fd, bool nonblock) {
1725         int flags, nflags;
1726
1727         assert(fd >= 0);
1728
1729         flags = fcntl(fd, F_GETFL, 0);
1730         if (flags < 0)
1731                 return -errno;
1732
1733         if (nonblock)
1734                 nflags = flags | O_NONBLOCK;
1735         else
1736                 nflags = flags & ~O_NONBLOCK;
1737
1738         if (nflags == flags)
1739                 return 0;
1740
1741         if (fcntl(fd, F_SETFL, nflags) < 0)
1742                 return -errno;
1743
1744         return 0;
1745 }
1746
1747 int fd_cloexec(int fd, bool cloexec) {
1748         int flags, nflags;
1749
1750         assert(fd >= 0);
1751
1752         flags = fcntl(fd, F_GETFD, 0);
1753         if (flags < 0)
1754                 return -errno;
1755
1756         if (cloexec)
1757                 nflags = flags | FD_CLOEXEC;
1758         else
1759                 nflags = flags & ~FD_CLOEXEC;
1760
1761         if (nflags == flags)
1762                 return 0;
1763
1764         if (fcntl(fd, F_SETFD, nflags) < 0)
1765                 return -errno;
1766
1767         return 0;
1768 }
1769
1770 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1771         unsigned i;
1772
1773         assert(n_fdset == 0 || fdset);
1774
1775         for (i = 0; i < n_fdset; i++)
1776                 if (fdset[i] == fd)
1777                         return true;
1778
1779         return false;
1780 }
1781
1782 int close_all_fds(const int except[], unsigned n_except) {
1783         _cleanup_closedir_ DIR *d = NULL;
1784         struct dirent *de;
1785         int r = 0;
1786
1787         assert(n_except == 0 || except);
1788
1789         d = opendir("/proc/self/fd");
1790         if (!d) {
1791                 int fd;
1792                 struct rlimit rl;
1793
1794                 /* When /proc isn't available (for example in chroots)
1795                  * the fallback is brute forcing through the fd
1796                  * table */
1797
1798                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1799                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1800
1801                         if (fd_in_set(fd, except, n_except))
1802                                 continue;
1803
1804                         if (close_nointr(fd) < 0)
1805                                 if (errno != EBADF && r == 0)
1806                                         r = -errno;
1807                 }
1808
1809                 return r;
1810         }
1811
1812         while ((de = readdir(d))) {
1813                 int fd = -1;
1814
1815                 if (hidden_file(de->d_name))
1816                         continue;
1817
1818                 if (safe_atoi(de->d_name, &fd) < 0)
1819                         /* Let's better ignore this, just in case */
1820                         continue;
1821
1822                 if (fd < 3)
1823                         continue;
1824
1825                 if (fd == dirfd(d))
1826                         continue;
1827
1828                 if (fd_in_set(fd, except, n_except))
1829                         continue;
1830
1831                 if (close_nointr(fd) < 0) {
1832                         /* Valgrind has its own FD and doesn't want to have it closed */
1833                         if (errno != EBADF && r == 0)
1834                                 r = -errno;
1835                 }
1836         }
1837
1838         return r;
1839 }
1840
1841 bool chars_intersect(const char *a, const char *b) {
1842         const char *p;
1843
1844         /* Returns true if any of the chars in a are in b. */
1845         for (p = a; *p; p++)
1846                 if (strchr(b, *p))
1847                         return true;
1848
1849         return false;
1850 }
1851
1852 bool fstype_is_network(const char *fstype) {
1853         static const char table[] =
1854                 "afs\0"
1855                 "cifs\0"
1856                 "smbfs\0"
1857                 "sshfs\0"
1858                 "ncpfs\0"
1859                 "ncp\0"
1860                 "nfs\0"
1861                 "nfs4\0"
1862                 "gfs\0"
1863                 "gfs2\0"
1864                 "glusterfs\0";
1865
1866         const char *x;
1867
1868         x = startswith(fstype, "fuse.");
1869         if (x)
1870                 fstype = x;
1871
1872         return nulstr_contains(table, fstype);
1873 }
1874
1875 int chvt(int vt) {
1876         _cleanup_close_ int fd;
1877
1878         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1879         if (fd < 0)
1880                 return -errno;
1881
1882         if (vt < 0) {
1883                 int tiocl[2] = {
1884                         TIOCL_GETKMSGREDIRECT,
1885                         0
1886                 };
1887
1888                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1889                         return -errno;
1890
1891                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1892         }
1893
1894         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1895                 return -errno;
1896
1897         return 0;
1898 }
1899
1900 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1901         struct termios old_termios, new_termios;
1902         char c, line[LINE_MAX];
1903
1904         assert(f);
1905         assert(ret);
1906
1907         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1908                 new_termios = old_termios;
1909
1910                 new_termios.c_lflag &= ~ICANON;
1911                 new_termios.c_cc[VMIN] = 1;
1912                 new_termios.c_cc[VTIME] = 0;
1913
1914                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1915                         size_t k;
1916
1917                         if (t != USEC_INFINITY) {
1918                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1919                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1920                                         return -ETIMEDOUT;
1921                                 }
1922                         }
1923
1924                         k = fread(&c, 1, 1, f);
1925
1926                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1927
1928                         if (k <= 0)
1929                                 return -EIO;
1930
1931                         if (need_nl)
1932                                 *need_nl = c != '\n';
1933
1934                         *ret = c;
1935                         return 0;
1936                 }
1937         }
1938
1939         if (t != USEC_INFINITY) {
1940                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1941                         return -ETIMEDOUT;
1942         }
1943
1944         errno = 0;
1945         if (!fgets(line, sizeof(line), f))
1946                 return errno ? -errno : -EIO;
1947
1948         truncate_nl(line);
1949
1950         if (strlen(line) != 1)
1951                 return -EBADMSG;
1952
1953         if (need_nl)
1954                 *need_nl = false;
1955
1956         *ret = line[0];
1957         return 0;
1958 }
1959
1960 int ask_char(char *ret, const char *replies, const char *text, ...) {
1961         int r;
1962
1963         assert(ret);
1964         assert(replies);
1965         assert(text);
1966
1967         for (;;) {
1968                 va_list ap;
1969                 char c;
1970                 bool need_nl = true;
1971
1972                 if (on_tty())
1973                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1974
1975                 va_start(ap, text);
1976                 vprintf(text, ap);
1977                 va_end(ap);
1978
1979                 if (on_tty())
1980                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1981
1982                 fflush(stdout);
1983
1984                 r = read_one_char(stdin, &c, USEC_INFINITY, &need_nl);
1985                 if (r < 0) {
1986
1987                         if (r == -EBADMSG) {
1988                                 puts("Bad input, please try again.");
1989                                 continue;
1990                         }
1991
1992                         putchar('\n');
1993                         return r;
1994                 }
1995
1996                 if (need_nl)
1997                         putchar('\n');
1998
1999                 if (strchr(replies, c)) {
2000                         *ret = c;
2001                         return 0;
2002                 }
2003
2004                 puts("Read unexpected character, please try again.");
2005         }
2006 }
2007
2008 int ask_string(char **ret, const char *text, ...) {
2009         assert(ret);
2010         assert(text);
2011
2012         for (;;) {
2013                 char line[LINE_MAX];
2014                 va_list ap;
2015
2016                 if (on_tty())
2017                         fputs(ANSI_HIGHLIGHT_ON, stdout);
2018
2019                 va_start(ap, text);
2020                 vprintf(text, ap);
2021                 va_end(ap);
2022
2023                 if (on_tty())
2024                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
2025
2026                 fflush(stdout);
2027
2028                 errno = 0;
2029                 if (!fgets(line, sizeof(line), stdin))
2030                         return errno ? -errno : -EIO;
2031
2032                 if (!endswith(line, "\n"))
2033                         putchar('\n');
2034                 else {
2035                         char *s;
2036
2037                         if (isempty(line))
2038                                 continue;
2039
2040                         truncate_nl(line);
2041                         s = strdup(line);
2042                         if (!s)
2043                                 return -ENOMEM;
2044
2045                         *ret = s;
2046                         return 0;
2047                 }
2048         }
2049 }
2050
2051 int reset_terminal_fd(int fd, bool switch_to_text) {
2052         struct termios termios;
2053         int r = 0;
2054
2055         /* Set terminal to some sane defaults */
2056
2057         assert(fd >= 0);
2058
2059         /* We leave locked terminal attributes untouched, so that
2060          * Plymouth may set whatever it wants to set, and we don't
2061          * interfere with that. */
2062
2063         /* Disable exclusive mode, just in case */
2064         ioctl(fd, TIOCNXCL);
2065
2066         /* Switch to text mode */
2067         if (switch_to_text)
2068                 ioctl(fd, KDSETMODE, KD_TEXT);
2069
2070         /* Enable console unicode mode */
2071         ioctl(fd, KDSKBMODE, K_UNICODE);
2072
2073         if (tcgetattr(fd, &termios) < 0) {
2074                 r = -errno;
2075                 goto finish;
2076         }
2077
2078         /* We only reset the stuff that matters to the software. How
2079          * hardware is set up we don't touch assuming that somebody
2080          * else will do that for us */
2081
2082         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
2083         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
2084         termios.c_oflag |= ONLCR;
2085         termios.c_cflag |= CREAD;
2086         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
2087
2088         termios.c_cc[VINTR]    =   03;  /* ^C */
2089         termios.c_cc[VQUIT]    =  034;  /* ^\ */
2090         termios.c_cc[VERASE]   = 0177;
2091         termios.c_cc[VKILL]    =  025;  /* ^X */
2092         termios.c_cc[VEOF]     =   04;  /* ^D */
2093         termios.c_cc[VSTART]   =  021;  /* ^Q */
2094         termios.c_cc[VSTOP]    =  023;  /* ^S */
2095         termios.c_cc[VSUSP]    =  032;  /* ^Z */
2096         termios.c_cc[VLNEXT]   =  026;  /* ^V */
2097         termios.c_cc[VWERASE]  =  027;  /* ^W */
2098         termios.c_cc[VREPRINT] =  022;  /* ^R */
2099         termios.c_cc[VEOL]     =    0;
2100         termios.c_cc[VEOL2]    =    0;
2101
2102         termios.c_cc[VTIME]  = 0;
2103         termios.c_cc[VMIN]   = 1;
2104
2105         if (tcsetattr(fd, TCSANOW, &termios) < 0)
2106                 r = -errno;
2107
2108 finish:
2109         /* Just in case, flush all crap out */
2110         tcflush(fd, TCIOFLUSH);
2111
2112         return r;
2113 }
2114
2115 int reset_terminal(const char *name) {
2116         _cleanup_close_ int fd = -1;
2117
2118         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2119         if (fd < 0)
2120                 return fd;
2121
2122         return reset_terminal_fd(fd, true);
2123 }
2124
2125 int open_terminal(const char *name, int mode) {
2126         int fd, r;
2127         unsigned c = 0;
2128
2129         /*
2130          * If a TTY is in the process of being closed opening it might
2131          * cause EIO. This is horribly awful, but unlikely to be
2132          * changed in the kernel. Hence we work around this problem by
2133          * retrying a couple of times.
2134          *
2135          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
2136          */
2137
2138         assert(!(mode & O_CREAT));
2139
2140         for (;;) {
2141                 fd = open(name, mode, 0);
2142                 if (fd >= 0)
2143                         break;
2144
2145                 if (errno != EIO)
2146                         return -errno;
2147
2148                 /* Max 1s in total */
2149                 if (c >= 20)
2150                         return -errno;
2151
2152                 usleep(50 * USEC_PER_MSEC);
2153                 c++;
2154         }
2155
2156         r = isatty(fd);
2157         if (r < 0) {
2158                 safe_close(fd);
2159                 return -errno;
2160         }
2161
2162         if (!r) {
2163                 safe_close(fd);
2164                 return -ENOTTY;
2165         }
2166
2167         return fd;
2168 }
2169
2170 int flush_fd(int fd) {
2171         struct pollfd pollfd = {
2172                 .fd = fd,
2173                 .events = POLLIN,
2174         };
2175
2176         for (;;) {
2177                 char buf[LINE_MAX];
2178                 ssize_t l;
2179                 int r;
2180
2181                 r = poll(&pollfd, 1, 0);
2182                 if (r < 0) {
2183                         if (errno == EINTR)
2184                                 continue;
2185
2186                         return -errno;
2187
2188                 } else if (r == 0)
2189                         return 0;
2190
2191                 l = read(fd, buf, sizeof(buf));
2192                 if (l < 0) {
2193
2194                         if (errno == EINTR)
2195                                 continue;
2196
2197                         if (errno == EAGAIN)
2198                                 return 0;
2199
2200                         return -errno;
2201                 } else if (l == 0)
2202                         return 0;
2203         }
2204 }
2205
2206 int acquire_terminal(
2207                 const char *name,
2208                 bool fail,
2209                 bool force,
2210                 bool ignore_tiocstty_eperm,
2211                 usec_t timeout) {
2212
2213         int fd = -1, notify = -1, r = 0, wd = -1;
2214         usec_t ts = 0;
2215
2216         assert(name);
2217
2218         /* We use inotify to be notified when the tty is closed. We
2219          * create the watch before checking if we can actually acquire
2220          * it, so that we don't lose any event.
2221          *
2222          * Note: strictly speaking this actually watches for the
2223          * device being closed, it does *not* really watch whether a
2224          * tty loses its controlling process. However, unless some
2225          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2226          * its tty otherwise this will not become a problem. As long
2227          * as the administrator makes sure not configure any service
2228          * on the same tty as an untrusted user this should not be a
2229          * problem. (Which he probably should not do anyway.) */
2230
2231         if (timeout != USEC_INFINITY)
2232                 ts = now(CLOCK_MONOTONIC);
2233
2234         if (!fail && !force) {
2235                 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
2236                 if (notify < 0) {
2237                         r = -errno;
2238                         goto fail;
2239                 }
2240
2241                 wd = inotify_add_watch(notify, name, IN_CLOSE);
2242                 if (wd < 0) {
2243                         r = -errno;
2244                         goto fail;
2245                 }
2246         }
2247
2248         for (;;) {
2249                 struct sigaction sa_old, sa_new = {
2250                         .sa_handler = SIG_IGN,
2251                         .sa_flags = SA_RESTART,
2252                 };
2253
2254                 if (notify >= 0) {
2255                         r = flush_fd(notify);
2256                         if (r < 0)
2257                                 goto fail;
2258                 }
2259
2260                 /* We pass here O_NOCTTY only so that we can check the return
2261                  * value TIOCSCTTY and have a reliable way to figure out if we
2262                  * successfully became the controlling process of the tty */
2263                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2264                 if (fd < 0)
2265                         return fd;
2266
2267                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2268                  * if we already own the tty. */
2269                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2270
2271                 /* First, try to get the tty */
2272                 if (ioctl(fd, TIOCSCTTY, force) < 0)
2273                         r = -errno;
2274
2275                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2276
2277                 /* Sometimes it makes sense to ignore TIOCSCTTY
2278                  * returning EPERM, i.e. when very likely we already
2279                  * are have this controlling terminal. */
2280                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
2281                         r = 0;
2282
2283                 if (r < 0 && (force || fail || r != -EPERM)) {
2284                         goto fail;
2285                 }
2286
2287                 if (r >= 0)
2288                         break;
2289
2290                 assert(!fail);
2291                 assert(!force);
2292                 assert(notify >= 0);
2293
2294                 for (;;) {
2295                         union inotify_event_buffer buffer;
2296                         struct inotify_event *e;
2297                         ssize_t l;
2298
2299                         if (timeout != USEC_INFINITY) {
2300                                 usec_t n;
2301
2302                                 n = now(CLOCK_MONOTONIC);
2303                                 if (ts + timeout < n) {
2304                                         r = -ETIMEDOUT;
2305                                         goto fail;
2306                                 }
2307
2308                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2309                                 if (r < 0)
2310                                         goto fail;
2311
2312                                 if (r == 0) {
2313                                         r = -ETIMEDOUT;
2314                                         goto fail;
2315                                 }
2316                         }
2317
2318                         l = read(notify, &buffer, sizeof(buffer));
2319                         if (l < 0) {
2320                                 if (errno == EINTR || errno == EAGAIN)
2321                                         continue;
2322
2323                                 r = -errno;
2324                                 goto fail;
2325                         }
2326
2327                         FOREACH_INOTIFY_EVENT(e, buffer, l) {
2328                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2329                                         r = -EIO;
2330                                         goto fail;
2331                                 }
2332                         }
2333
2334                         break;
2335                 }
2336
2337                 /* We close the tty fd here since if the old session
2338                  * ended our handle will be dead. It's important that
2339                  * we do this after sleeping, so that we don't enter
2340                  * an endless loop. */
2341                 fd = safe_close(fd);
2342         }
2343
2344         safe_close(notify);
2345
2346         r = reset_terminal_fd(fd, true);
2347         if (r < 0)
2348                 log_warning_errno(r, "Failed to reset terminal: %m");
2349
2350         return fd;
2351
2352 fail:
2353         safe_close(fd);
2354         safe_close(notify);
2355
2356         return r;
2357 }
2358
2359 int release_terminal(void) {
2360         static const struct sigaction sa_new = {
2361                 .sa_handler = SIG_IGN,
2362                 .sa_flags = SA_RESTART,
2363         };
2364
2365         _cleanup_close_ int fd = -1;
2366         struct sigaction sa_old;
2367         int r = 0;
2368
2369         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC);
2370         if (fd < 0)
2371                 return -errno;
2372
2373         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2374          * by our own TIOCNOTTY */
2375         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2376
2377         if (ioctl(fd, TIOCNOTTY) < 0)
2378                 r = -errno;
2379
2380         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2381
2382         return r;
2383 }
2384
2385 int sigaction_many(const struct sigaction *sa, ...) {
2386         va_list ap;
2387         int r = 0, sig;
2388
2389         va_start(ap, sa);
2390         while ((sig = va_arg(ap, int)) > 0)
2391                 if (sigaction(sig, sa, NULL) < 0)
2392                         r = -errno;
2393         va_end(ap);
2394
2395         return r;
2396 }
2397
2398 int ignore_signals(int sig, ...) {
2399         struct sigaction sa = {
2400                 .sa_handler = SIG_IGN,
2401                 .sa_flags = SA_RESTART,
2402         };
2403         va_list ap;
2404         int r = 0;
2405
2406         if (sigaction(sig, &sa, NULL) < 0)
2407                 r = -errno;
2408
2409         va_start(ap, sig);
2410         while ((sig = va_arg(ap, int)) > 0)
2411                 if (sigaction(sig, &sa, NULL) < 0)
2412                         r = -errno;
2413         va_end(ap);
2414
2415         return r;
2416 }
2417
2418 int default_signals(int sig, ...) {
2419         struct sigaction sa = {
2420                 .sa_handler = SIG_DFL,
2421                 .sa_flags = SA_RESTART,
2422         };
2423         va_list ap;
2424         int r = 0;
2425
2426         if (sigaction(sig, &sa, NULL) < 0)
2427                 r = -errno;
2428
2429         va_start(ap, sig);
2430         while ((sig = va_arg(ap, int)) > 0)
2431                 if (sigaction(sig, &sa, NULL) < 0)
2432                         r = -errno;
2433         va_end(ap);
2434
2435         return r;
2436 }
2437
2438 void safe_close_pair(int p[]) {
2439         assert(p);
2440
2441         if (p[0] == p[1]) {
2442                 /* Special case pairs which use the same fd in both
2443                  * directions... */
2444                 p[0] = p[1] = safe_close(p[0]);
2445                 return;
2446         }
2447
2448         p[0] = safe_close(p[0]);
2449         p[1] = safe_close(p[1]);
2450 }
2451
2452 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2453         uint8_t *p = buf;
2454         ssize_t n = 0;
2455
2456         assert(fd >= 0);
2457         assert(buf);
2458
2459         while (nbytes > 0) {
2460                 ssize_t k;
2461
2462                 k = read(fd, p, nbytes);
2463                 if (k < 0) {
2464                         if (errno == EINTR)
2465                                 continue;
2466
2467                         if (errno == EAGAIN && do_poll) {
2468
2469                                 /* We knowingly ignore any return value here,
2470                                  * and expect that any error/EOF is reported
2471                                  * via read() */
2472
2473                                 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
2474                                 continue;
2475                         }
2476
2477                         return n > 0 ? n : -errno;
2478                 }
2479
2480                 if (k == 0)
2481                         return n;
2482
2483                 p += k;
2484                 nbytes -= k;
2485                 n += k;
2486         }
2487
2488         return n;
2489 }
2490
2491 int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll) {
2492         ssize_t n;
2493
2494         n = loop_read(fd, buf, nbytes, do_poll);
2495         if (n < 0)
2496                 return n;
2497         if ((size_t) n != nbytes)
2498                 return -EIO;
2499         return 0;
2500 }
2501
2502 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2503         const uint8_t *p = buf;
2504
2505         assert(fd >= 0);
2506         assert(buf);
2507
2508         errno = 0;
2509
2510         while (nbytes > 0) {
2511                 ssize_t k;
2512
2513                 k = write(fd, p, nbytes);
2514                 if (k < 0) {
2515                         if (errno == EINTR)
2516                                 continue;
2517
2518                         if (errno == EAGAIN && do_poll) {
2519                                 /* We knowingly ignore any return value here,
2520                                  * and expect that any error/EOF is reported
2521                                  * via write() */
2522
2523                                 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
2524                                 continue;
2525                         }
2526
2527                         return -errno;
2528                 }
2529
2530                 if (k == 0) /* Can't really happen */
2531                         return -EIO;
2532
2533                 p += k;
2534                 nbytes -= k;
2535         }
2536
2537         return 0;
2538 }
2539
2540 int parse_size(const char *t, off_t base, off_t *size) {
2541
2542         /* Soo, sometimes we want to parse IEC binary suffxies, and
2543          * sometimes SI decimal suffixes. This function can parse
2544          * both. Which one is the right way depends on the
2545          * context. Wikipedia suggests that SI is customary for
2546          * hardrware metrics and network speeds, while IEC is
2547          * customary for most data sizes used by software and volatile
2548          * (RAM) memory. Hence be careful which one you pick!
2549          *
2550          * In either case we use just K, M, G as suffix, and not Ki,
2551          * Mi, Gi or so (as IEC would suggest). That's because that's
2552          * frickin' ugly. But this means you really need to make sure
2553          * to document which base you are parsing when you use this
2554          * call. */
2555
2556         struct table {
2557                 const char *suffix;
2558                 unsigned long long factor;
2559         };
2560
2561         static const struct table iec[] = {
2562                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2563                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2564                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2565                 { "G", 1024ULL*1024ULL*1024ULL },
2566                 { "M", 1024ULL*1024ULL },
2567                 { "K", 1024ULL },
2568                 { "B", 1 },
2569                 { "", 1 },
2570         };
2571
2572         static const struct table si[] = {
2573                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2574                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
2575                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
2576                 { "G", 1000ULL*1000ULL*1000ULL },
2577                 { "M", 1000ULL*1000ULL },
2578                 { "K", 1000ULL },
2579                 { "B", 1 },
2580                 { "", 1 },
2581         };
2582
2583         const struct table *table;
2584         const char *p;
2585         unsigned long long r = 0;
2586         unsigned n_entries, start_pos = 0;
2587
2588         assert(t);
2589         assert(base == 1000 || base == 1024);
2590         assert(size);
2591
2592         if (base == 1000) {
2593                 table = si;
2594                 n_entries = ELEMENTSOF(si);
2595         } else {
2596                 table = iec;
2597                 n_entries = ELEMENTSOF(iec);
2598         }
2599
2600         p = t;
2601         do {
2602                 long long l;
2603                 unsigned long long l2;
2604                 double frac = 0;
2605                 char *e;
2606                 unsigned i;
2607
2608                 errno = 0;
2609                 l = strtoll(p, &e, 10);
2610
2611                 if (errno > 0)
2612                         return -errno;
2613
2614                 if (l < 0)
2615                         return -ERANGE;
2616
2617                 if (e == p)
2618                         return -EINVAL;
2619
2620                 if (*e == '.') {
2621                         e++;
2622                         if (*e >= '0' && *e <= '9') {
2623                                 char *e2;
2624
2625                                 /* strotoull itself would accept space/+/- */
2626                                 l2 = strtoull(e, &e2, 10);
2627
2628                                 if (errno == ERANGE)
2629                                         return -errno;
2630
2631                                 /* Ignore failure. E.g. 10.M is valid */
2632                                 frac = l2;
2633                                 for (; e < e2; e++)
2634                                         frac /= 10;
2635                         }
2636                 }
2637
2638                 e += strspn(e, WHITESPACE);
2639
2640                 for (i = start_pos; i < n_entries; i++)
2641                         if (startswith(e, table[i].suffix)) {
2642                                 unsigned long long tmp;
2643                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
2644                                         return -ERANGE;
2645                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
2646                                 if (tmp > ULLONG_MAX - r)
2647                                         return -ERANGE;
2648
2649                                 r += tmp;
2650                                 if ((unsigned long long) (off_t) r != r)
2651                                         return -ERANGE;
2652
2653                                 p = e + strlen(table[i].suffix);
2654
2655                                 start_pos = i + 1;
2656                                 break;
2657                         }
2658
2659                 if (i >= n_entries)
2660                         return -EINVAL;
2661
2662         } while (*p);
2663
2664         *size = r;
2665
2666         return 0;
2667 }
2668
2669 int make_stdio(int fd) {
2670         int r, s, t;
2671
2672         assert(fd >= 0);
2673
2674         r = dup2(fd, STDIN_FILENO);
2675         s = dup2(fd, STDOUT_FILENO);
2676         t = dup2(fd, STDERR_FILENO);
2677
2678         if (fd >= 3)
2679                 safe_close(fd);
2680
2681         if (r < 0 || s < 0 || t < 0)
2682                 return -errno;
2683
2684         /* Explicitly unset O_CLOEXEC, since if fd was < 3, then
2685          * dup2() was a NOP and the bit hence possibly set. */
2686         fd_cloexec(STDIN_FILENO, false);
2687         fd_cloexec(STDOUT_FILENO, false);
2688         fd_cloexec(STDERR_FILENO, false);
2689
2690         return 0;
2691 }
2692
2693 int make_null_stdio(void) {
2694         int null_fd;
2695
2696         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2697         if (null_fd < 0)
2698                 return -errno;
2699
2700         return make_stdio(null_fd);
2701 }
2702
2703 bool is_device_path(const char *path) {
2704
2705         /* Returns true on paths that refer to a device, either in
2706          * sysfs or in /dev */
2707
2708         return
2709                 path_startswith(path, "/dev/") ||
2710                 path_startswith(path, "/sys/");
2711 }
2712
2713 int dir_is_empty(const char *path) {
2714         _cleanup_closedir_ DIR *d;
2715
2716         d = opendir(path);
2717         if (!d)
2718                 return -errno;
2719
2720         for (;;) {
2721                 struct dirent *de;
2722
2723                 errno = 0;
2724                 de = readdir(d);
2725                 if (!de && errno != 0)
2726                         return -errno;
2727
2728                 if (!de)
2729                         return 1;
2730
2731                 if (!hidden_file(de->d_name))
2732                         return 0;
2733         }
2734 }
2735
2736 char* dirname_malloc(const char *path) {
2737         char *d, *dir, *dir2;
2738
2739         d = strdup(path);
2740         if (!d)
2741                 return NULL;
2742         dir = dirname(d);
2743         assert(dir);
2744
2745         if (dir != d) {
2746                 dir2 = strdup(dir);
2747                 free(d);
2748                 return dir2;
2749         }
2750
2751         return dir;
2752 }
2753
2754 int dev_urandom(void *p, size_t n) {
2755         static int have_syscall = -1;
2756
2757         _cleanup_close_ int fd = -1;
2758         int r;
2759
2760         /* Gathers some randomness from the kernel. This call will
2761          * never block, and will always return some data from the
2762          * kernel, regardless if the random pool is fully initialized
2763          * or not. It thus makes no guarantee for the quality of the
2764          * returned entropy, but is good enough for or usual usecases
2765          * of seeding the hash functions for hashtable */
2766
2767         /* Use the getrandom() syscall unless we know we don't have
2768          * it, or when the requested size is too large for it. */
2769         if (have_syscall != 0 || (size_t) (int) n != n) {
2770                 r = getrandom(p, n, GRND_NONBLOCK);
2771                 if (r == (int) n) {
2772                         have_syscall = true;
2773                         return 0;
2774                 }
2775
2776                 if (r < 0) {
2777                         if (errno == ENOSYS)
2778                                 /* we lack the syscall, continue with
2779                                  * reading from /dev/urandom */
2780                                 have_syscall = false;
2781                         else if (errno == EAGAIN)
2782                                 /* not enough entropy for now. Let's
2783                                  * remember to use the syscall the
2784                                  * next time, again, but also read
2785                                  * from /dev/urandom for now, which
2786                                  * doesn't care about the current
2787                                  * amount of entropy.  */
2788                                 have_syscall = true;
2789                         else
2790                                 return -errno;
2791                 } else
2792                         /* too short read? */
2793                         return -ENODATA;
2794         }
2795
2796         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2797         if (fd < 0)
2798                 return errno == ENOENT ? -ENOSYS : -errno;
2799
2800         return loop_read_exact(fd, p, n, true);
2801 }
2802
2803 void initialize_srand(void) {
2804         static bool srand_called = false;
2805         unsigned x;
2806 #ifdef HAVE_SYS_AUXV_H
2807         void *auxv;
2808 #endif
2809
2810         if (srand_called)
2811                 return;
2812
2813         x = 0;
2814
2815 #ifdef HAVE_SYS_AUXV_H
2816         /* The kernel provides us with a bit of entropy in auxv, so
2817          * let's try to make use of that to seed the pseudo-random
2818          * generator. It's better than nothing... */
2819
2820         auxv = (void*) getauxval(AT_RANDOM);
2821         if (auxv)
2822                 x ^= *(unsigned*) auxv;
2823 #endif
2824
2825         x ^= (unsigned) now(CLOCK_REALTIME);
2826         x ^= (unsigned) gettid();
2827
2828         srand(x);
2829         srand_called = true;
2830 }
2831
2832 void random_bytes(void *p, size_t n) {
2833         uint8_t *q;
2834         int r;
2835
2836         r = dev_urandom(p, n);
2837         if (r >= 0)
2838                 return;
2839
2840         /* If some idiot made /dev/urandom unavailable to us, he'll
2841          * get a PRNG instead. */
2842
2843         initialize_srand();
2844
2845         for (q = p; q < (uint8_t*) p + n; q ++)
2846                 *q = rand();
2847 }
2848
2849 void rename_process(const char name[8]) {
2850         assert(name);
2851
2852         /* This is a like a poor man's setproctitle(). It changes the
2853          * comm field, argv[0], and also the glibc's internally used
2854          * name of the process. For the first one a limit of 16 chars
2855          * applies, to the second one usually one of 10 (i.e. length
2856          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2857          * "systemd"). If you pass a longer string it will be
2858          * truncated */
2859
2860         prctl(PR_SET_NAME, name);
2861
2862         if (program_invocation_name)
2863                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2864
2865         if (saved_argc > 0) {
2866                 int i;
2867
2868                 if (saved_argv[0])
2869                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2870
2871                 for (i = 1; i < saved_argc; i++) {
2872                         if (!saved_argv[i])
2873                                 break;
2874
2875                         memzero(saved_argv[i], strlen(saved_argv[i]));
2876                 }
2877         }
2878 }
2879
2880 void sigset_add_many(sigset_t *ss, ...) {
2881         va_list ap;
2882         int sig;
2883
2884         assert(ss);
2885
2886         va_start(ap, ss);
2887         while ((sig = va_arg(ap, int)) > 0)
2888                 assert_se(sigaddset(ss, sig) == 0);
2889         va_end(ap);
2890 }
2891
2892 int sigprocmask_many(int how, ...) {
2893         va_list ap;
2894         sigset_t ss;
2895         int sig;
2896
2897         assert_se(sigemptyset(&ss) == 0);
2898
2899         va_start(ap, how);
2900         while ((sig = va_arg(ap, int)) > 0)
2901                 assert_se(sigaddset(&ss, sig) == 0);
2902         va_end(ap);
2903
2904         if (sigprocmask(how, &ss, NULL) < 0)
2905                 return -errno;
2906
2907         return 0;
2908 }
2909
2910 char* gethostname_malloc(void) {
2911         struct utsname u;
2912
2913         assert_se(uname(&u) >= 0);
2914
2915         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2916                 return strdup(u.nodename);
2917
2918         return strdup(u.sysname);
2919 }
2920
2921 bool hostname_is_set(void) {
2922         struct utsname u;
2923
2924         assert_se(uname(&u) >= 0);
2925
2926         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2927 }
2928
2929 char *lookup_uid(uid_t uid) {
2930         long bufsize;
2931         char *name;
2932         _cleanup_free_ char *buf = NULL;
2933         struct passwd pwbuf, *pw = NULL;
2934
2935         /* Shortcut things to avoid NSS lookups */
2936         if (uid == 0)
2937                 return strdup("root");
2938
2939         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2940         if (bufsize <= 0)
2941                 bufsize = 4096;
2942
2943         buf = malloc(bufsize);
2944         if (!buf)
2945                 return NULL;
2946
2947         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2948                 return strdup(pw->pw_name);
2949
2950         if (asprintf(&name, UID_FMT, uid) < 0)
2951                 return NULL;
2952
2953         return name;
2954 }
2955
2956 char* getlogname_malloc(void) {
2957         uid_t uid;
2958         struct stat st;
2959
2960         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2961                 uid = st.st_uid;
2962         else
2963                 uid = getuid();
2964
2965         return lookup_uid(uid);
2966 }
2967
2968 char *getusername_malloc(void) {
2969         const char *e;
2970
2971         e = getenv("USER");
2972         if (e)
2973                 return strdup(e);
2974
2975         return lookup_uid(getuid());
2976 }
2977
2978 int getttyname_malloc(int fd, char **ret) {
2979         size_t l = 100;
2980         int r;
2981
2982         assert(fd >= 0);
2983         assert(ret);
2984
2985         for (;;) {
2986                 char path[l];
2987
2988                 r = ttyname_r(fd, path, sizeof(path));
2989                 if (r == 0) {
2990                         const char *p;
2991                         char *c;
2992
2993                         p = startswith(path, "/dev/");
2994                         c = strdup(p ?: path);
2995                         if (!c)
2996                                 return -ENOMEM;
2997
2998                         *ret = c;
2999                         return 0;
3000                 }
3001
3002                 if (r != ERANGE)
3003                         return -r;
3004
3005                 l *= 2;
3006         }
3007
3008         return 0;
3009 }
3010
3011 int getttyname_harder(int fd, char **r) {
3012         int k;
3013         char *s = NULL;
3014
3015         k = getttyname_malloc(fd, &s);
3016         if (k < 0)
3017                 return k;
3018
3019         if (streq(s, "tty")) {
3020                 free(s);
3021                 return get_ctty(0, NULL, r);
3022         }
3023
3024         *r = s;
3025         return 0;
3026 }
3027
3028 int get_ctty_devnr(pid_t pid, dev_t *d) {
3029         int r;
3030         _cleanup_free_ char *line = NULL;
3031         const char *p;
3032         unsigned long ttynr;
3033
3034         assert(pid >= 0);
3035
3036         p = procfs_file_alloca(pid, "stat");
3037         r = read_one_line_file(p, &line);
3038         if (r < 0)
3039                 return r;
3040
3041         p = strrchr(line, ')');
3042         if (!p)
3043                 return -EIO;
3044
3045         p++;
3046
3047         if (sscanf(p, " "
3048                    "%*c "  /* state */
3049                    "%*d "  /* ppid */
3050                    "%*d "  /* pgrp */
3051                    "%*d "  /* session */
3052                    "%lu ", /* ttynr */
3053                    &ttynr) != 1)
3054                 return -EIO;
3055
3056         if (major(ttynr) == 0 && minor(ttynr) == 0)
3057                 return -ENOENT;
3058
3059         if (d)
3060                 *d = (dev_t) ttynr;
3061
3062         return 0;
3063 }
3064
3065 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
3066         char fn[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
3067         _cleanup_free_ char *s = NULL;
3068         const char *p;
3069         dev_t devnr;
3070         int k;
3071
3072         assert(r);
3073
3074         k = get_ctty_devnr(pid, &devnr);
3075         if (k < 0)
3076                 return k;
3077
3078         sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
3079
3080         k = readlink_malloc(fn, &s);
3081         if (k < 0) {
3082
3083                 if (k != -ENOENT)
3084                         return k;
3085
3086                 /* This is an ugly hack */
3087                 if (major(devnr) == 136) {
3088                         if (asprintf(&b, "pts/%u", minor(devnr)) < 0)
3089                                 return -ENOMEM;
3090                 } else {
3091                         /* Probably something like the ptys which have no
3092                          * symlink in /dev/char. Let's return something
3093                          * vaguely useful. */
3094
3095                         b = strdup(fn + 5);
3096                         if (!b)
3097                                 return -ENOMEM;
3098                 }
3099         } else {
3100                 if (startswith(s, "/dev/"))
3101                         p = s + 5;
3102                 else if (startswith(s, "../"))
3103                         p = s + 3;
3104                 else
3105                         p = s;
3106
3107                 b = strdup(p);
3108                 if (!b)
3109                         return -ENOMEM;
3110         }
3111
3112         *r = b;
3113         if (_devnr)
3114                 *_devnr = devnr;
3115
3116         return 0;
3117 }
3118
3119 bool is_temporary_fs(const struct statfs *s) {
3120         assert(s);
3121
3122         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
3123                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
3124 }
3125
3126 int fd_is_temporary_fs(int fd) {
3127         struct statfs s;
3128
3129         if (fstatfs(fd, &s) < 0)
3130                 return -errno;
3131
3132         return is_temporary_fs(&s);
3133 }
3134
3135 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3136         assert(path);
3137
3138         /* Under the assumption that we are running privileged we
3139          * first change the access mode and only then hand out
3140          * ownership to avoid a window where access is too open. */
3141
3142         if (mode != MODE_INVALID)
3143                 if (chmod(path, mode) < 0)
3144                         return -errno;
3145
3146         if (uid != UID_INVALID || gid != GID_INVALID)
3147                 if (chown(path, uid, gid) < 0)
3148                         return -errno;
3149
3150         return 0;
3151 }
3152
3153 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3154         assert(fd >= 0);
3155
3156         /* Under the assumption that we are running privileged we
3157          * first change the access mode and only then hand out
3158          * ownership to avoid a window where access is too open. */
3159
3160         if (mode != MODE_INVALID)
3161                 if (fchmod(fd, mode) < 0)
3162                         return -errno;
3163
3164         if (uid != UID_INVALID || gid != GID_INVALID)
3165                 if (fchown(fd, uid, gid) < 0)
3166                         return -errno;
3167
3168         return 0;
3169 }
3170
3171 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3172         cpu_set_t *r;
3173         unsigned n = 1024;
3174
3175         /* Allocates the cpuset in the right size */
3176
3177         for (;;) {
3178                 if (!(r = CPU_ALLOC(n)))
3179                         return NULL;
3180
3181                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3182                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3183
3184                         if (ncpus)
3185                                 *ncpus = n;
3186
3187                         return r;
3188                 }
3189
3190                 CPU_FREE(r);
3191
3192                 if (errno != EINVAL)
3193                         return NULL;
3194
3195                 n *= 2;
3196         }
3197 }
3198
3199 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
3200         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3201         _cleanup_free_ char *s = NULL;
3202         _cleanup_close_ int fd = -1;
3203         struct iovec iovec[6] = {};
3204         int n = 0;
3205         static bool prev_ephemeral;
3206
3207         assert(format);
3208
3209         /* This is independent of logging, as status messages are
3210          * optional and go exclusively to the console. */
3211
3212         if (vasprintf(&s, format, ap) < 0)
3213                 return log_oom();
3214
3215         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3216         if (fd < 0)
3217                 return fd;
3218
3219         if (ellipse) {
3220                 char *e;
3221                 size_t emax, sl;
3222                 int c;
3223
3224                 c = fd_columns(fd);
3225                 if (c <= 0)
3226                         c = 80;
3227
3228                 sl = status ? sizeof(status_indent)-1 : 0;
3229
3230                 emax = c - sl - 1;
3231                 if (emax < 3)
3232                         emax = 3;
3233
3234                 e = ellipsize(s, emax, 50);
3235                 if (e) {
3236                         free(s);
3237                         s = e;
3238                 }
3239         }
3240
3241         if (prev_ephemeral)
3242                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
3243         prev_ephemeral = ephemeral;
3244
3245         if (status) {
3246                 if (!isempty(status)) {
3247                         IOVEC_SET_STRING(iovec[n++], "[");
3248                         IOVEC_SET_STRING(iovec[n++], status);
3249                         IOVEC_SET_STRING(iovec[n++], "] ");
3250                 } else
3251                         IOVEC_SET_STRING(iovec[n++], status_indent);
3252         }
3253
3254         IOVEC_SET_STRING(iovec[n++], s);
3255         if (!ephemeral)
3256                 IOVEC_SET_STRING(iovec[n++], "\n");
3257
3258         if (writev(fd, iovec, n) < 0)
3259                 return -errno;
3260
3261         return 0;
3262 }
3263
3264 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
3265         va_list ap;
3266         int r;
3267
3268         assert(format);
3269
3270         va_start(ap, format);
3271         r = status_vprintf(status, ellipse, ephemeral, format, ap);
3272         va_end(ap);
3273
3274         return r;
3275 }
3276
3277 char *replace_env(const char *format, char **env) {
3278         enum {
3279                 WORD,
3280                 CURLY,
3281                 VARIABLE
3282         } state = WORD;
3283
3284         const char *e, *word = format;
3285         char *r = NULL, *k;
3286
3287         assert(format);
3288
3289         for (e = format; *e; e ++) {
3290
3291                 switch (state) {
3292
3293                 case WORD:
3294                         if (*e == '$')
3295                                 state = CURLY;
3296                         break;
3297
3298                 case CURLY:
3299                         if (*e == '{') {
3300                                 k = strnappend(r, word, e-word-1);
3301                                 if (!k)
3302                                         goto fail;
3303
3304                                 free(r);
3305                                 r = k;
3306
3307                                 word = e-1;
3308                                 state = VARIABLE;
3309
3310                         } else if (*e == '$') {
3311                                 k = strnappend(r, word, e-word);
3312                                 if (!k)
3313                                         goto fail;
3314
3315                                 free(r);
3316                                 r = k;
3317
3318                                 word = e+1;
3319                                 state = WORD;
3320                         } else
3321                                 state = WORD;
3322                         break;
3323
3324                 case VARIABLE:
3325                         if (*e == '}') {
3326                                 const char *t;
3327
3328                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3329
3330                                 k = strappend(r, t);
3331                                 if (!k)
3332                                         goto fail;
3333
3334                                 free(r);
3335                                 r = k;
3336
3337                                 word = e+1;
3338                                 state = WORD;
3339                         }
3340                         break;
3341                 }
3342         }
3343
3344         k = strnappend(r, word, e-word);
3345         if (!k)
3346                 goto fail;
3347
3348         free(r);
3349         return k;
3350
3351 fail:
3352         free(r);
3353         return NULL;
3354 }
3355
3356 char **replace_env_argv(char **argv, char **env) {
3357         char **ret, **i;
3358         unsigned k = 0, l = 0;
3359
3360         l = strv_length(argv);
3361
3362         ret = new(char*, l+1);
3363         if (!ret)
3364                 return NULL;
3365
3366         STRV_FOREACH(i, argv) {
3367
3368                 /* If $FOO appears as single word, replace it by the split up variable */
3369                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3370                         char *e;
3371                         char **w, **m = NULL;
3372                         unsigned q;
3373
3374                         e = strv_env_get(env, *i+1);
3375                         if (e) {
3376                                 int r;
3377
3378                                 r = strv_split_quoted(&m, e, UNQUOTE_RELAX);
3379                                 if (r < 0) {
3380                                         ret[k] = NULL;
3381                                         strv_free(ret);
3382                                         return NULL;
3383                                 }
3384                         } else
3385                                 m = NULL;
3386
3387                         q = strv_length(m);
3388                         l = l + q - 1;
3389
3390                         w = realloc(ret, sizeof(char*) * (l+1));
3391                         if (!w) {
3392                                 ret[k] = NULL;
3393                                 strv_free(ret);
3394                                 strv_free(m);
3395                                 return NULL;
3396                         }
3397
3398                         ret = w;
3399                         if (m) {
3400                                 memcpy(ret + k, m, q * sizeof(char*));
3401                                 free(m);
3402                         }
3403
3404                         k += q;
3405                         continue;
3406                 }
3407
3408                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3409                 ret[k] = replace_env(*i, env);
3410                 if (!ret[k]) {
3411                         strv_free(ret);
3412                         return NULL;
3413                 }
3414                 k++;
3415         }
3416
3417         ret[k] = NULL;
3418         return ret;
3419 }
3420
3421 int fd_columns(int fd) {
3422         struct winsize ws = {};
3423
3424         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3425                 return -errno;
3426
3427         if (ws.ws_col <= 0)
3428                 return -EIO;
3429
3430         return ws.ws_col;
3431 }
3432
3433 unsigned columns(void) {
3434         const char *e;
3435         int c;
3436
3437         if (_likely_(cached_columns > 0))
3438                 return cached_columns;
3439
3440         c = 0;
3441         e = getenv("COLUMNS");
3442         if (e)
3443                 (void) safe_atoi(e, &c);
3444
3445         if (c <= 0)
3446                 c = fd_columns(STDOUT_FILENO);
3447
3448         if (c <= 0)
3449                 c = 80;
3450
3451         cached_columns = c;
3452         return cached_columns;
3453 }
3454
3455 int fd_lines(int fd) {
3456         struct winsize ws = {};
3457
3458         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3459                 return -errno;
3460
3461         if (ws.ws_row <= 0)
3462                 return -EIO;
3463
3464         return ws.ws_row;
3465 }
3466
3467 unsigned lines(void) {
3468         const char *e;
3469         int l;
3470
3471         if (_likely_(cached_lines > 0))
3472                 return cached_lines;
3473
3474         l = 0;
3475         e = getenv("LINES");
3476         if (e)
3477                 (void) safe_atoi(e, &l);
3478
3479         if (l <= 0)
3480                 l = fd_lines(STDOUT_FILENO);
3481
3482         if (l <= 0)
3483                 l = 24;
3484
3485         cached_lines = l;
3486         return cached_lines;
3487 }
3488
3489 /* intended to be used as a SIGWINCH sighandler */
3490 void columns_lines_cache_reset(int signum) {
3491         cached_columns = 0;
3492         cached_lines = 0;
3493 }
3494
3495 bool on_tty(void) {
3496         static int cached_on_tty = -1;
3497
3498         if (_unlikely_(cached_on_tty < 0))
3499                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3500
3501         return cached_on_tty;
3502 }
3503
3504 int files_same(const char *filea, const char *fileb) {
3505         struct stat a, b;
3506
3507         if (stat(filea, &a) < 0)
3508                 return -errno;
3509
3510         if (stat(fileb, &b) < 0)
3511                 return -errno;
3512
3513         return a.st_dev == b.st_dev &&
3514                a.st_ino == b.st_ino;
3515 }
3516
3517 int running_in_chroot(void) {
3518         int ret;
3519
3520         ret = files_same("/proc/1/root", "/");
3521         if (ret < 0)
3522                 return ret;
3523
3524         return ret == 0;
3525 }
3526
3527 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3528         size_t x;
3529         char *r;
3530
3531         assert(s);
3532         assert(percent <= 100);
3533         assert(new_length >= 3);
3534
3535         if (old_length <= 3 || old_length <= new_length)
3536                 return strndup(s, old_length);
3537
3538         r = new0(char, new_length+1);
3539         if (!r)
3540                 return NULL;
3541
3542         x = (new_length * percent) / 100;
3543
3544         if (x > new_length - 3)
3545                 x = new_length - 3;
3546
3547         memcpy(r, s, x);
3548         r[x] = '.';
3549         r[x+1] = '.';
3550         r[x+2] = '.';
3551         memcpy(r + x + 3,
3552                s + old_length - (new_length - x - 3),
3553                new_length - x - 3);
3554
3555         return r;
3556 }
3557
3558 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3559         size_t x;
3560         char *e;
3561         const char *i, *j;
3562         unsigned k, len, len2;
3563
3564         assert(s);
3565         assert(percent <= 100);
3566         assert(new_length >= 3);
3567
3568         /* if no multibyte characters use ascii_ellipsize_mem for speed */
3569         if (ascii_is_valid(s))
3570                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
3571
3572         if (old_length <= 3 || old_length <= new_length)
3573                 return strndup(s, old_length);
3574
3575         x = (new_length * percent) / 100;
3576
3577         if (x > new_length - 3)
3578                 x = new_length - 3;
3579
3580         k = 0;
3581         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
3582                 int c;
3583
3584                 c = utf8_encoded_to_unichar(i);
3585                 if (c < 0)
3586                         return NULL;
3587                 k += unichar_iswide(c) ? 2 : 1;
3588         }
3589
3590         if (k > x) /* last character was wide and went over quota */
3591                 x ++;
3592
3593         for (j = s + old_length; k < new_length && j > i; ) {
3594                 int c;
3595
3596                 j = utf8_prev_char(j);
3597                 c = utf8_encoded_to_unichar(j);
3598                 if (c < 0)
3599                         return NULL;
3600                 k += unichar_iswide(c) ? 2 : 1;
3601         }
3602         assert(i <= j);
3603
3604         /* we don't actually need to ellipsize */
3605         if (i == j)
3606                 return memdup(s, old_length + 1);
3607
3608         /* make space for ellipsis */
3609         j = utf8_next_char(j);
3610
3611         len = i - s;
3612         len2 = s + old_length - j;
3613         e = new(char, len + 3 + len2 + 1);
3614         if (!e)
3615                 return NULL;
3616
3617         /*
3618         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
3619                old_length, new_length, x, len, len2, k);
3620         */
3621
3622         memcpy(e, s, len);
3623         e[len]   = 0xe2; /* tri-dot ellipsis: … */
3624         e[len + 1] = 0x80;
3625         e[len + 2] = 0xa6;
3626
3627         memcpy(e + len + 3, j, len2 + 1);
3628
3629         return e;
3630 }
3631
3632 char *ellipsize(const char *s, size_t length, unsigned percent) {
3633         return ellipsize_mem(s, strlen(s), length, percent);
3634 }
3635
3636 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
3637         _cleanup_close_ int fd;
3638         int r;
3639
3640         assert(path);
3641
3642         if (parents)
3643                 mkdir_parents(path, 0755);
3644
3645         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
3646         if (fd < 0)
3647                 return -errno;
3648
3649         if (mode > 0) {
3650                 r = fchmod(fd, mode);
3651                 if (r < 0)
3652                         return -errno;
3653         }
3654
3655         if (uid != UID_INVALID || gid != GID_INVALID) {
3656                 r = fchown(fd, uid, gid);
3657                 if (r < 0)
3658                         return -errno;
3659         }
3660
3661         if (stamp != USEC_INFINITY) {
3662                 struct timespec ts[2];
3663
3664                 timespec_store(&ts[0], stamp);
3665                 ts[1] = ts[0];
3666                 r = futimens(fd, ts);
3667         } else
3668                 r = futimens(fd, NULL);
3669         if (r < 0)
3670                 return -errno;
3671
3672         return 0;
3673 }
3674
3675 int touch(const char *path) {
3676         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
3677 }
3678
3679 static char *unquote(const char *s, const char* quotes) {
3680         size_t l;
3681         assert(s);
3682
3683         /* This is rather stupid, simply removes the heading and
3684          * trailing quotes if there is one. Doesn't care about
3685          * escaping or anything.
3686          *
3687          * DON'T USE THIS FOR NEW CODE ANYMORE!*/
3688
3689         l = strlen(s);
3690         if (l < 2)
3691                 return strdup(s);
3692
3693         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3694                 return strndup(s+1, l-2);
3695
3696         return strdup(s);
3697 }
3698
3699 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3700         siginfo_t dummy;
3701
3702         assert(pid >= 1);
3703
3704         if (!status)
3705                 status = &dummy;
3706
3707         for (;;) {
3708                 zero(*status);
3709
3710                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3711
3712                         if (errno == EINTR)
3713                                 continue;
3714
3715                         return -errno;
3716                 }
3717
3718                 return 0;
3719         }
3720 }
3721
3722 /*
3723  * Return values:
3724  * < 0 : wait_for_terminate() failed to get the state of the
3725  *       process, the process was terminated by a signal, or
3726  *       failed for an unknown reason.
3727  * >=0 : The process terminated normally, and its exit code is
3728  *       returned.
3729  *
3730  * That is, success is indicated by a return value of zero, and an
3731  * error is indicated by a non-zero value.
3732  *
3733  * A warning is emitted if the process terminates abnormally,
3734  * and also if it returns non-zero unless check_exit_code is true.
3735  */
3736 int wait_for_terminate_and_warn(const char *name, pid_t pid, bool check_exit_code) {
3737         int r;
3738         siginfo_t status;
3739
3740         assert(name);
3741         assert(pid > 1);
3742
3743         r = wait_for_terminate(pid, &status);
3744         if (r < 0)
3745                 return log_warning_errno(r, "Failed to wait for %s: %m", name);
3746
3747         if (status.si_code == CLD_EXITED) {
3748                 if (status.si_status != 0)
3749                         log_full(check_exit_code ? LOG_WARNING : LOG_DEBUG,
3750                                  "%s failed with error code %i.", name, status.si_status);
3751                 else
3752                         log_debug("%s succeeded.", name);
3753
3754                 return status.si_status;
3755         } else if (status.si_code == CLD_KILLED ||
3756                    status.si_code == CLD_DUMPED) {
3757
3758                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3759                 return -EPROTO;
3760         }
3761
3762         log_warning("%s failed due to unknown reason.", name);
3763         return -EPROTO;
3764 }
3765
3766 noreturn void freeze(void) {
3767
3768         /* Make sure nobody waits for us on a socket anymore */
3769         close_all_fds(NULL, 0);
3770
3771         sync();
3772
3773         for (;;)
3774                 pause();
3775 }
3776
3777 bool null_or_empty(struct stat *st) {
3778         assert(st);
3779
3780         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3781                 return true;
3782
3783         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3784                 return true;
3785
3786         return false;
3787 }
3788
3789 int null_or_empty_path(const char *fn) {
3790         struct stat st;
3791
3792         assert(fn);
3793
3794         if (stat(fn, &st) < 0)
3795                 return -errno;
3796
3797         return null_or_empty(&st);
3798 }
3799
3800 int null_or_empty_fd(int fd) {
3801         struct stat st;
3802
3803         assert(fd >= 0);
3804
3805         if (fstat(fd, &st) < 0)
3806                 return -errno;
3807
3808         return null_or_empty(&st);
3809 }
3810
3811 DIR *xopendirat(int fd, const char *name, int flags) {
3812         int nfd;
3813         DIR *d;
3814
3815         assert(!(flags & O_CREAT));
3816
3817         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
3818         if (nfd < 0)
3819                 return NULL;
3820
3821         d = fdopendir(nfd);
3822         if (!d) {
3823                 safe_close(nfd);
3824                 return NULL;
3825         }
3826
3827         return d;
3828 }
3829
3830 int signal_from_string_try_harder(const char *s) {
3831         int signo;
3832         assert(s);
3833
3834         signo = signal_from_string(s);
3835         if (signo <= 0)
3836                 if (startswith(s, "SIG"))
3837                         return signal_from_string(s+3);
3838
3839         return signo;
3840 }
3841
3842 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3843         _cleanup_free_ char *t = NULL, *u = NULL;
3844         size_t enc_len;
3845
3846         u = unquote(tagvalue, QUOTES);
3847         if (!u)
3848                 return NULL;
3849
3850         enc_len = strlen(u) * 4 + 1;
3851         t = new(char, enc_len);
3852         if (!t)
3853                 return NULL;
3854
3855         if (encode_devnode_name(u, t, enc_len) < 0)
3856                 return NULL;
3857
3858         return strjoin("/dev/disk/by-", by, "/", t, NULL);
3859 }
3860
3861 char *fstab_node_to_udev_node(const char *p) {
3862         assert(p);
3863
3864         if (startswith(p, "LABEL="))
3865                 return tag_to_udev_node(p+6, "label");
3866
3867         if (startswith(p, "UUID="))
3868                 return tag_to_udev_node(p+5, "uuid");
3869
3870         if (startswith(p, "PARTUUID="))
3871                 return tag_to_udev_node(p+9, "partuuid");
3872
3873         if (startswith(p, "PARTLABEL="))
3874                 return tag_to_udev_node(p+10, "partlabel");
3875
3876         return strdup(p);
3877 }
3878
3879 bool tty_is_vc(const char *tty) {
3880         assert(tty);
3881
3882         return vtnr_from_tty(tty) >= 0;
3883 }
3884
3885 bool tty_is_console(const char *tty) {
3886         assert(tty);
3887
3888         if (startswith(tty, "/dev/"))
3889                 tty += 5;
3890
3891         return streq(tty, "console");
3892 }
3893
3894 int vtnr_from_tty(const char *tty) {
3895         int i, r;
3896
3897         assert(tty);
3898
3899         if (startswith(tty, "/dev/"))
3900                 tty += 5;
3901
3902         if (!startswith(tty, "tty") )
3903                 return -EINVAL;
3904
3905         if (tty[3] < '0' || tty[3] > '9')
3906                 return -EINVAL;
3907
3908         r = safe_atoi(tty+3, &i);
3909         if (r < 0)
3910                 return r;
3911
3912         if (i < 0 || i > 63)
3913                 return -EINVAL;
3914
3915         return i;
3916 }
3917
3918 char *resolve_dev_console(char **active) {
3919         char *tty;
3920
3921         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3922          * (i.e. not read-only-mounted which is a sign for container setups) */
3923
3924         if (path_is_read_only_fs("/sys") > 0)
3925                 return NULL;
3926
3927         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3928                 return NULL;
3929
3930         /* If multiple log outputs are configured the last one is what
3931          * /dev/console points to */
3932         tty = strrchr(*active, ' ');
3933         if (tty)
3934                 tty++;
3935         else
3936                 tty = *active;
3937
3938         if (streq(tty, "tty0")) {
3939                 char *tmp;
3940
3941                 /* Get the active VC (e.g. tty1) */
3942                 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp) >= 0) {
3943                         free(*active);
3944                         tty = *active = tmp;
3945                 }
3946         }
3947
3948         return tty;
3949 }
3950
3951 bool tty_is_vc_resolve(const char *tty) {
3952         _cleanup_free_ char *active = NULL;
3953
3954         assert(tty);
3955
3956         if (startswith(tty, "/dev/"))
3957                 tty += 5;
3958
3959         if (streq(tty, "console")) {
3960                 tty = resolve_dev_console(&active);
3961                 if (!tty)
3962                         return false;
3963         }
3964
3965         return tty_is_vc(tty);
3966 }
3967
3968 const char *default_term_for_tty(const char *tty) {
3969         assert(tty);
3970
3971         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt220";
3972 }
3973
3974 bool dirent_is_file(const struct dirent *de) {
3975         assert(de);
3976
3977         if (hidden_file(de->d_name))
3978                 return false;
3979
3980         if (de->d_type != DT_REG &&
3981             de->d_type != DT_LNK &&
3982             de->d_type != DT_UNKNOWN)
3983                 return false;
3984
3985         return true;
3986 }
3987
3988 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3989         assert(de);
3990
3991         if (de->d_type != DT_REG &&
3992             de->d_type != DT_LNK &&
3993             de->d_type != DT_UNKNOWN)
3994                 return false;
3995
3996         if (hidden_file_allow_backup(de->d_name))
3997                 return false;
3998
3999         return endswith(de->d_name, suffix);
4000 }
4001
4002 static int do_execute(char **directories, usec_t timeout, char *argv[]) {
4003         _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
4004         _cleanup_set_free_free_ Set *seen = NULL;
4005         char **directory;
4006
4007         /* We fork this all off from a child process so that we can
4008          * somewhat cleanly make use of SIGALRM to set a time limit */
4009
4010         reset_all_signal_handlers();
4011         reset_signal_mask();
4012
4013         assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4014
4015         pids = hashmap_new(NULL);
4016         if (!pids)
4017                 return log_oom();
4018
4019         seen = set_new(&string_hash_ops);
4020         if (!seen)
4021                 return log_oom();
4022
4023         STRV_FOREACH(directory, directories) {
4024                 _cleanup_closedir_ DIR *d;
4025                 struct dirent *de;
4026
4027                 d = opendir(*directory);
4028                 if (!d) {
4029                         if (errno == ENOENT)
4030                                 continue;
4031
4032                         return log_error_errno(errno, "Failed to open directory %s: %m", *directory);
4033                 }
4034
4035                 FOREACH_DIRENT(de, d, break) {
4036                         _cleanup_free_ char *path = NULL;
4037                         pid_t pid;
4038                         int r;
4039
4040                         if (!dirent_is_file(de))
4041                                 continue;
4042
4043                         if (set_contains(seen, de->d_name)) {
4044                                 log_debug("%1$s/%2$s skipped (%2$s was already seen).", *directory, de->d_name);
4045                                 continue;
4046                         }
4047
4048                         r = set_put_strdup(seen, de->d_name);
4049                         if (r < 0)
4050                                 return log_oom();
4051
4052                         path = strjoin(*directory, "/", de->d_name, NULL);
4053                         if (!path)
4054                                 return log_oom();
4055
4056                         if (null_or_empty_path(path)) {
4057                                 log_debug("%s is empty (a mask).", path);
4058                                 continue;
4059                         }
4060
4061                         pid = fork();
4062                         if (pid < 0) {
4063                                 log_error_errno(errno, "Failed to fork: %m");
4064                                 continue;
4065                         } else if (pid == 0) {
4066                                 char *_argv[2];
4067
4068                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
4069
4070                                 if (!argv) {
4071                                         _argv[0] = path;
4072                                         _argv[1] = NULL;
4073                                         argv = _argv;
4074                                 } else
4075                                         argv[0] = path;
4076
4077                                 execv(path, argv);
4078                                 return log_error_errno(errno, "Failed to execute %s: %m", path);
4079                         }
4080
4081                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
4082
4083                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
4084                         if (r < 0)
4085                                 return log_oom();
4086                         path = NULL;
4087                 }
4088         }
4089
4090         /* Abort execution of this process after the timout. We simply
4091          * rely on SIGALRM as default action terminating the process,
4092          * and turn on alarm(). */
4093
4094         if (timeout != USEC_INFINITY)
4095                 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
4096
4097         while (!hashmap_isempty(pids)) {
4098                 _cleanup_free_ char *path = NULL;
4099                 pid_t pid;
4100
4101                 pid = PTR_TO_UINT(hashmap_first_key(pids));
4102                 assert(pid > 0);
4103
4104                 path = hashmap_remove(pids, UINT_TO_PTR(pid));
4105                 assert(path);
4106
4107                 wait_for_terminate_and_warn(path, pid, true);
4108         }
4109
4110         return 0;
4111 }
4112
4113 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]) {
4114         pid_t executor_pid;
4115         int r;
4116         char *name;
4117         char **dirs = (char**) directories;
4118
4119         assert(!strv_isempty(dirs));
4120
4121         name = basename(dirs[0]);
4122         assert(!isempty(name));
4123
4124         /* Executes all binaries in the directories in parallel and waits
4125          * for them to finish. Optionally a timeout is applied. If a file
4126          * with the same name exists in more than one directory, the
4127          * earliest one wins. */
4128
4129         executor_pid = fork();
4130         if (executor_pid < 0) {
4131                 log_error_errno(errno, "Failed to fork: %m");
4132                 return;
4133
4134         } else if (executor_pid == 0) {
4135                 r = do_execute(dirs, timeout, argv);
4136                 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
4137         }
4138
4139         wait_for_terminate_and_warn(name, executor_pid, true);
4140 }
4141
4142 int kill_and_sigcont(pid_t pid, int sig) {
4143         int r;
4144
4145         r = kill(pid, sig) < 0 ? -errno : 0;
4146
4147         if (r >= 0)
4148                 kill(pid, SIGCONT);
4149
4150         return r;
4151 }
4152
4153 bool nulstr_contains(const char*nulstr, const char *needle) {
4154         const char *i;
4155
4156         if (!nulstr)
4157                 return false;
4158
4159         NULSTR_FOREACH(i, nulstr)
4160                 if (streq(i, needle))
4161                         return true;
4162
4163         return false;
4164 }
4165
4166 bool plymouth_running(void) {
4167         return access("/run/plymouth/pid", F_OK) >= 0;
4168 }
4169
4170 char* strshorten(char *s, size_t l) {
4171         assert(s);
4172
4173         if (l < strlen(s))
4174                 s[l] = 0;
4175
4176         return s;
4177 }
4178
4179 static bool hostname_valid_char(char c) {
4180         return
4181                 (c >= 'a' && c <= 'z') ||
4182                 (c >= 'A' && c <= 'Z') ||
4183                 (c >= '0' && c <= '9') ||
4184                 c == '-' ||
4185                 c == '_' ||
4186                 c == '.';
4187 }
4188
4189 bool hostname_is_valid(const char *s) {
4190         const char *p;
4191         bool dot;
4192
4193         if (isempty(s))
4194                 return false;
4195
4196         /* Doesn't accept empty hostnames, hostnames with trailing or
4197          * leading dots, and hostnames with multiple dots in a
4198          * sequence. Also ensures that the length stays below
4199          * HOST_NAME_MAX. */
4200
4201         for (p = s, dot = true; *p; p++) {
4202                 if (*p == '.') {
4203                         if (dot)
4204                                 return false;
4205
4206                         dot = true;
4207                 } else {
4208                         if (!hostname_valid_char(*p))
4209                                 return false;
4210
4211                         dot = false;
4212                 }
4213         }
4214
4215         if (dot)
4216                 return false;
4217
4218         if (p-s > HOST_NAME_MAX)
4219                 return false;
4220
4221         return true;
4222 }
4223
4224 char* hostname_cleanup(char *s, bool lowercase) {
4225         char *p, *d;
4226         bool dot;
4227
4228         for (p = s, d = s, dot = true; *p; p++) {
4229                 if (*p == '.') {
4230                         if (dot)
4231                                 continue;
4232
4233                         *(d++) = '.';
4234                         dot = true;
4235                 } else if (hostname_valid_char(*p)) {
4236                         *(d++) = lowercase ? tolower(*p) : *p;
4237                         dot = false;
4238                 }
4239
4240         }
4241
4242         if (dot && d > s)
4243                 d[-1] = 0;
4244         else
4245                 *d = 0;
4246
4247         strshorten(s, HOST_NAME_MAX);
4248
4249         return s;
4250 }
4251
4252 bool machine_name_is_valid(const char *s) {
4253
4254         if (!hostname_is_valid(s))
4255                 return false;
4256
4257         /* Machine names should be useful hostnames, but also be
4258          * useful in unit names, hence we enforce a stricter length
4259          * limitation. */
4260
4261         if (strlen(s) > 64)
4262                 return false;
4263
4264         return true;
4265 }
4266
4267 int pipe_eof(int fd) {
4268         struct pollfd pollfd = {
4269                 .fd = fd,
4270                 .events = POLLIN|POLLHUP,
4271         };
4272
4273         int r;
4274
4275         r = poll(&pollfd, 1, 0);
4276         if (r < 0)
4277                 return -errno;
4278
4279         if (r == 0)
4280                 return 0;
4281
4282         return pollfd.revents & POLLHUP;
4283 }
4284
4285 int fd_wait_for_event(int fd, int event, usec_t t) {
4286
4287         struct pollfd pollfd = {
4288                 .fd = fd,
4289                 .events = event,
4290         };
4291
4292         struct timespec ts;
4293         int r;
4294
4295         r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
4296         if (r < 0)
4297                 return -errno;
4298
4299         if (r == 0)
4300                 return 0;
4301
4302         return pollfd.revents;
4303 }
4304
4305 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
4306         FILE *f;
4307         char *t;
4308         int r, fd;
4309
4310         assert(path);
4311         assert(_f);
4312         assert(_temp_path);
4313
4314         r = tempfn_xxxxxx(path, &t);
4315         if (r < 0)
4316                 return r;
4317
4318         fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
4319         if (fd < 0) {
4320                 free(t);
4321                 return -errno;
4322         }
4323
4324         f = fdopen(fd, "we");
4325         if (!f) {
4326                 unlink(t);
4327                 free(t);
4328                 return -errno;
4329         }
4330
4331         *_f = f;
4332         *_temp_path = t;
4333
4334         return 0;
4335 }
4336
4337 int terminal_vhangup_fd(int fd) {
4338         assert(fd >= 0);
4339
4340         if (ioctl(fd, TIOCVHANGUP) < 0)
4341                 return -errno;
4342
4343         return 0;
4344 }
4345
4346 int terminal_vhangup(const char *name) {
4347         _cleanup_close_ int fd;
4348
4349         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4350         if (fd < 0)
4351                 return fd;
4352
4353         return terminal_vhangup_fd(fd);
4354 }
4355
4356 int vt_disallocate(const char *name) {
4357         int fd, r;
4358         unsigned u;
4359
4360         /* Deallocate the VT if possible. If not possible
4361          * (i.e. because it is the active one), at least clear it
4362          * entirely (including the scrollback buffer) */
4363
4364         if (!startswith(name, "/dev/"))
4365                 return -EINVAL;
4366
4367         if (!tty_is_vc(name)) {
4368                 /* So this is not a VT. I guess we cannot deallocate
4369                  * it then. But let's at least clear the screen */
4370
4371                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4372                 if (fd < 0)
4373                         return fd;
4374
4375                 loop_write(fd,
4376                            "\033[r"    /* clear scrolling region */
4377                            "\033[H"    /* move home */
4378                            "\033[2J",  /* clear screen */
4379                            10, false);
4380                 safe_close(fd);
4381
4382                 return 0;
4383         }
4384
4385         if (!startswith(name, "/dev/tty"))
4386                 return -EINVAL;
4387
4388         r = safe_atou(name+8, &u);
4389         if (r < 0)
4390                 return r;
4391
4392         if (u <= 0)
4393                 return -EINVAL;
4394
4395         /* Try to deallocate */
4396         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
4397         if (fd < 0)
4398                 return fd;
4399
4400         r = ioctl(fd, VT_DISALLOCATE, u);
4401         safe_close(fd);
4402
4403         if (r >= 0)
4404                 return 0;
4405
4406         if (errno != EBUSY)
4407                 return -errno;
4408
4409         /* Couldn't deallocate, so let's clear it fully with
4410          * scrollback */
4411         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
4412         if (fd < 0)
4413                 return fd;
4414
4415         loop_write(fd,
4416                    "\033[r"   /* clear scrolling region */
4417                    "\033[H"   /* move home */
4418                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
4419                    10, false);
4420         safe_close(fd);
4421
4422         return 0;
4423 }
4424
4425 int symlink_atomic(const char *from, const char *to) {
4426         _cleanup_free_ char *t = NULL;
4427         int r;
4428
4429         assert(from);
4430         assert(to);
4431
4432         r = tempfn_random(to, &t);
4433         if (r < 0)
4434                 return r;
4435
4436         if (symlink(from, t) < 0)
4437                 return -errno;
4438
4439         if (rename(t, to) < 0) {
4440                 unlink_noerrno(t);
4441                 return -errno;
4442         }
4443
4444         return 0;
4445 }
4446
4447 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
4448         _cleanup_free_ char *t = NULL;
4449         int r;
4450
4451         assert(path);
4452
4453         r = tempfn_random(path, &t);
4454         if (r < 0)
4455                 return r;
4456
4457         if (mknod(t, mode, dev) < 0)
4458                 return -errno;
4459
4460         if (rename(t, path) < 0) {
4461                 unlink_noerrno(t);
4462                 return -errno;
4463         }
4464
4465         return 0;
4466 }
4467
4468 int mkfifo_atomic(const char *path, mode_t mode) {
4469         _cleanup_free_ char *t = NULL;
4470         int r;
4471
4472         assert(path);
4473
4474         r = tempfn_random(path, &t);
4475         if (r < 0)
4476                 return r;
4477
4478         if (mkfifo(t, mode) < 0)
4479                 return -errno;
4480
4481         if (rename(t, path) < 0) {
4482                 unlink_noerrno(t);
4483                 return -errno;
4484         }
4485
4486         return 0;
4487 }
4488
4489 bool display_is_local(const char *display) {
4490         assert(display);
4491
4492         return
4493                 display[0] == ':' &&
4494                 display[1] >= '0' &&
4495                 display[1] <= '9';
4496 }
4497
4498 int socket_from_display(const char *display, char **path) {
4499         size_t k;
4500         char *f, *c;
4501
4502         assert(display);
4503         assert(path);
4504
4505         if (!display_is_local(display))
4506                 return -EINVAL;
4507
4508         k = strspn(display+1, "0123456789");
4509
4510         f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
4511         if (!f)
4512                 return -ENOMEM;
4513
4514         c = stpcpy(f, "/tmp/.X11-unix/X");
4515         memcpy(c, display+1, k);
4516         c[k] = 0;
4517
4518         *path = f;
4519
4520         return 0;
4521 }
4522
4523 int get_user_creds(
4524                 const char **username,
4525                 uid_t *uid, gid_t *gid,
4526                 const char **home,
4527                 const char **shell) {
4528
4529         struct passwd *p;
4530         uid_t u;
4531
4532         assert(username);
4533         assert(*username);
4534
4535         /* We enforce some special rules for uid=0: in order to avoid
4536          * NSS lookups for root we hardcode its data. */
4537
4538         if (streq(*username, "root") || streq(*username, "0")) {
4539                 *username = "root";
4540
4541                 if (uid)
4542                         *uid = 0;
4543
4544                 if (gid)
4545                         *gid = 0;
4546
4547                 if (home)
4548                         *home = "/root";
4549
4550                 if (shell)
4551                         *shell = "/bin/sh";
4552
4553                 return 0;
4554         }
4555
4556         if (parse_uid(*username, &u) >= 0) {
4557                 errno = 0;
4558                 p = getpwuid(u);
4559
4560                 /* If there are multiple users with the same id, make
4561                  * sure to leave $USER to the configured value instead
4562                  * of the first occurrence in the database. However if
4563                  * the uid was configured by a numeric uid, then let's
4564                  * pick the real username from /etc/passwd. */
4565                 if (p)
4566                         *username = p->pw_name;
4567         } else {
4568                 errno = 0;
4569                 p = getpwnam(*username);
4570         }
4571
4572         if (!p)
4573                 return errno > 0 ? -errno : -ESRCH;
4574
4575         if (uid)
4576                 *uid = p->pw_uid;
4577
4578         if (gid)
4579                 *gid = p->pw_gid;
4580
4581         if (home)
4582                 *home = p->pw_dir;
4583
4584         if (shell)
4585                 *shell = p->pw_shell;
4586
4587         return 0;
4588 }
4589
4590 char* uid_to_name(uid_t uid) {
4591         struct passwd *p;
4592         char *r;
4593
4594         if (uid == 0)
4595                 return strdup("root");
4596
4597         p = getpwuid(uid);
4598         if (p)
4599                 return strdup(p->pw_name);
4600
4601         if (asprintf(&r, UID_FMT, uid) < 0)
4602                 return NULL;
4603
4604         return r;
4605 }
4606
4607 char* gid_to_name(gid_t gid) {
4608         struct group *p;
4609         char *r;
4610
4611         if (gid == 0)
4612                 return strdup("root");
4613
4614         p = getgrgid(gid);
4615         if (p)
4616                 return strdup(p->gr_name);
4617
4618         if (asprintf(&r, GID_FMT, gid) < 0)
4619                 return NULL;
4620
4621         return r;
4622 }
4623
4624 int get_group_creds(const char **groupname, gid_t *gid) {
4625         struct group *g;
4626         gid_t id;
4627
4628         assert(groupname);
4629
4630         /* We enforce some special rules for gid=0: in order to avoid
4631          * NSS lookups for root we hardcode its data. */
4632
4633         if (streq(*groupname, "root") || streq(*groupname, "0")) {
4634                 *groupname = "root";
4635
4636                 if (gid)
4637                         *gid = 0;
4638
4639                 return 0;
4640         }
4641
4642         if (parse_gid(*groupname, &id) >= 0) {
4643                 errno = 0;
4644                 g = getgrgid(id);
4645
4646                 if (g)
4647                         *groupname = g->gr_name;
4648         } else {
4649                 errno = 0;
4650                 g = getgrnam(*groupname);
4651         }
4652
4653         if (!g)
4654                 return errno > 0 ? -errno : -ESRCH;
4655
4656         if (gid)
4657                 *gid = g->gr_gid;
4658
4659         return 0;
4660 }
4661
4662 int in_gid(gid_t gid) {
4663         gid_t *gids;
4664         int ngroups_max, r, i;
4665
4666         if (getgid() == gid)
4667                 return 1;
4668
4669         if (getegid() == gid)
4670                 return 1;
4671
4672         ngroups_max = sysconf(_SC_NGROUPS_MAX);
4673         assert(ngroups_max > 0);
4674
4675         gids = alloca(sizeof(gid_t) * ngroups_max);
4676
4677         r = getgroups(ngroups_max, gids);
4678         if (r < 0)
4679                 return -errno;
4680
4681         for (i = 0; i < r; i++)
4682                 if (gids[i] == gid)
4683                         return 1;
4684
4685         return 0;
4686 }
4687
4688 int in_group(const char *name) {
4689         int r;
4690         gid_t gid;
4691
4692         r = get_group_creds(&name, &gid);
4693         if (r < 0)
4694                 return r;
4695
4696         return in_gid(gid);
4697 }
4698
4699 int glob_exists(const char *path) {
4700         _cleanup_globfree_ glob_t g = {};
4701         int k;
4702
4703         assert(path);
4704
4705         errno = 0;
4706         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4707
4708         if (k == GLOB_NOMATCH)
4709                 return 0;
4710         else if (k == GLOB_NOSPACE)
4711                 return -ENOMEM;
4712         else if (k == 0)
4713                 return !strv_isempty(g.gl_pathv);
4714         else
4715                 return errno ? -errno : -EIO;
4716 }
4717
4718 int glob_extend(char ***strv, const char *path) {
4719         _cleanup_globfree_ glob_t g = {};
4720         int k;
4721         char **p;
4722
4723         errno = 0;
4724         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
4725
4726         if (k == GLOB_NOMATCH)
4727                 return -ENOENT;
4728         else if (k == GLOB_NOSPACE)
4729                 return -ENOMEM;
4730         else if (k != 0 || strv_isempty(g.gl_pathv))
4731                 return errno ? -errno : -EIO;
4732
4733         STRV_FOREACH(p, g.gl_pathv) {
4734                 k = strv_extend(strv, *p);
4735                 if (k < 0)
4736                         break;
4737         }
4738
4739         return k;
4740 }
4741
4742 int dirent_ensure_type(DIR *d, struct dirent *de) {
4743         struct stat st;
4744
4745         assert(d);
4746         assert(de);
4747
4748         if (de->d_type != DT_UNKNOWN)
4749                 return 0;
4750
4751         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
4752                 return -errno;
4753
4754         de->d_type =
4755                 S_ISREG(st.st_mode)  ? DT_REG  :
4756                 S_ISDIR(st.st_mode)  ? DT_DIR  :
4757                 S_ISLNK(st.st_mode)  ? DT_LNK  :
4758                 S_ISFIFO(st.st_mode) ? DT_FIFO :
4759                 S_ISSOCK(st.st_mode) ? DT_SOCK :
4760                 S_ISCHR(st.st_mode)  ? DT_CHR  :
4761                 S_ISBLK(st.st_mode)  ? DT_BLK  :
4762                                        DT_UNKNOWN;
4763
4764         return 0;
4765 }
4766
4767 int get_files_in_directory(const char *path, char ***list) {
4768         _cleanup_closedir_ DIR *d = NULL;
4769         size_t bufsize = 0, n = 0;
4770         _cleanup_strv_free_ char **l = NULL;
4771
4772         assert(path);
4773
4774         /* Returns all files in a directory in *list, and the number
4775          * of files as return value. If list is NULL returns only the
4776          * number. */
4777
4778         d = opendir(path);
4779         if (!d)
4780                 return -errno;
4781
4782         for (;;) {
4783                 struct dirent *de;
4784
4785                 errno = 0;
4786                 de = readdir(d);
4787                 if (!de && errno != 0)
4788                         return -errno;
4789                 if (!de)
4790                         break;
4791
4792                 dirent_ensure_type(d, de);
4793
4794                 if (!dirent_is_file(de))
4795                         continue;
4796
4797                 if (list) {
4798                         /* one extra slot is needed for the terminating NULL */
4799                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
4800                                 return -ENOMEM;
4801
4802                         l[n] = strdup(de->d_name);
4803                         if (!l[n])
4804                                 return -ENOMEM;
4805
4806                         l[++n] = NULL;
4807                 } else
4808                         n++;
4809         }
4810
4811         if (list) {
4812                 *list = l;
4813                 l = NULL; /* avoid freeing */
4814         }
4815
4816         return n;
4817 }
4818
4819 char *strjoin(const char *x, ...) {
4820         va_list ap;
4821         size_t l;
4822         char *r, *p;
4823
4824         va_start(ap, x);
4825
4826         if (x) {
4827                 l = strlen(x);
4828
4829                 for (;;) {
4830                         const char *t;
4831                         size_t n;
4832
4833                         t = va_arg(ap, const char *);
4834                         if (!t)
4835                                 break;
4836
4837                         n = strlen(t);
4838                         if (n > ((size_t) -1) - l) {
4839                                 va_end(ap);
4840                                 return NULL;
4841                         }
4842
4843                         l += n;
4844                 }
4845         } else
4846                 l = 0;
4847
4848         va_end(ap);
4849
4850         r = new(char, l+1);
4851         if (!r)
4852                 return NULL;
4853
4854         if (x) {
4855                 p = stpcpy(r, x);
4856
4857                 va_start(ap, x);
4858
4859                 for (;;) {
4860                         const char *t;
4861
4862                         t = va_arg(ap, const char *);
4863                         if (!t)
4864                                 break;
4865
4866                         p = stpcpy(p, t);
4867                 }
4868
4869                 va_end(ap);
4870         } else
4871                 r[0] = 0;
4872
4873         return r;
4874 }
4875
4876 bool is_main_thread(void) {
4877         static thread_local int cached = 0;
4878
4879         if (_unlikely_(cached == 0))
4880                 cached = getpid() == gettid() ? 1 : -1;
4881
4882         return cached > 0;
4883 }
4884
4885 int block_get_whole_disk(dev_t d, dev_t *ret) {
4886         char *p, *s;
4887         int r;
4888         unsigned n, m;
4889
4890         assert(ret);
4891
4892         /* If it has a queue this is good enough for us */
4893         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
4894                 return -ENOMEM;
4895
4896         r = access(p, F_OK);
4897         free(p);
4898
4899         if (r >= 0) {
4900                 *ret = d;
4901                 return 0;
4902         }
4903
4904         /* If it is a partition find the originating device */
4905         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
4906                 return -ENOMEM;
4907
4908         r = access(p, F_OK);
4909         free(p);
4910
4911         if (r < 0)
4912                 return -ENOENT;
4913
4914         /* Get parent dev_t */
4915         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
4916                 return -ENOMEM;
4917
4918         r = read_one_line_file(p, &s);
4919         free(p);
4920
4921         if (r < 0)
4922                 return r;
4923
4924         r = sscanf(s, "%u:%u", &m, &n);
4925         free(s);
4926
4927         if (r != 2)
4928                 return -EINVAL;
4929
4930         /* Only return this if it is really good enough for us. */
4931         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
4932                 return -ENOMEM;
4933
4934         r = access(p, F_OK);
4935         free(p);
4936
4937         if (r >= 0) {
4938                 *ret = makedev(m, n);
4939                 return 0;
4940         }
4941
4942         return -ENOENT;
4943 }
4944
4945 static const char *const ioprio_class_table[] = {
4946         [IOPRIO_CLASS_NONE] = "none",
4947         [IOPRIO_CLASS_RT] = "realtime",
4948         [IOPRIO_CLASS_BE] = "best-effort",
4949         [IOPRIO_CLASS_IDLE] = "idle"
4950 };
4951
4952 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
4953
4954 static const char *const sigchld_code_table[] = {
4955         [CLD_EXITED] = "exited",
4956         [CLD_KILLED] = "killed",
4957         [CLD_DUMPED] = "dumped",
4958         [CLD_TRAPPED] = "trapped",
4959         [CLD_STOPPED] = "stopped",
4960         [CLD_CONTINUED] = "continued",
4961 };
4962
4963 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
4964
4965 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
4966         [LOG_FAC(LOG_KERN)] = "kern",
4967         [LOG_FAC(LOG_USER)] = "user",
4968         [LOG_FAC(LOG_MAIL)] = "mail",
4969         [LOG_FAC(LOG_DAEMON)] = "daemon",
4970         [LOG_FAC(LOG_AUTH)] = "auth",
4971         [LOG_FAC(LOG_SYSLOG)] = "syslog",
4972         [LOG_FAC(LOG_LPR)] = "lpr",
4973         [LOG_FAC(LOG_NEWS)] = "news",
4974         [LOG_FAC(LOG_UUCP)] = "uucp",
4975         [LOG_FAC(LOG_CRON)] = "cron",
4976         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
4977         [LOG_FAC(LOG_FTP)] = "ftp",
4978         [LOG_FAC(LOG_LOCAL0)] = "local0",
4979         [LOG_FAC(LOG_LOCAL1)] = "local1",
4980         [LOG_FAC(LOG_LOCAL2)] = "local2",
4981         [LOG_FAC(LOG_LOCAL3)] = "local3",
4982         [LOG_FAC(LOG_LOCAL4)] = "local4",
4983         [LOG_FAC(LOG_LOCAL5)] = "local5",
4984         [LOG_FAC(LOG_LOCAL6)] = "local6",
4985         [LOG_FAC(LOG_LOCAL7)] = "local7"
4986 };
4987
4988 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
4989
4990 static const char *const log_level_table[] = {
4991         [LOG_EMERG] = "emerg",
4992         [LOG_ALERT] = "alert",
4993         [LOG_CRIT] = "crit",
4994         [LOG_ERR] = "err",
4995         [LOG_WARNING] = "warning",
4996         [LOG_NOTICE] = "notice",
4997         [LOG_INFO] = "info",
4998         [LOG_DEBUG] = "debug"
4999 };
5000
5001 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
5002
5003 static const char* const sched_policy_table[] = {
5004         [SCHED_OTHER] = "other",
5005         [SCHED_BATCH] = "batch",
5006         [SCHED_IDLE] = "idle",
5007         [SCHED_FIFO] = "fifo",
5008         [SCHED_RR] = "rr"
5009 };
5010
5011 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
5012
5013 static const char* const rlimit_table[_RLIMIT_MAX] = {
5014         [RLIMIT_CPU] = "LimitCPU",
5015         [RLIMIT_FSIZE] = "LimitFSIZE",
5016         [RLIMIT_DATA] = "LimitDATA",
5017         [RLIMIT_STACK] = "LimitSTACK",
5018         [RLIMIT_CORE] = "LimitCORE",
5019         [RLIMIT_RSS] = "LimitRSS",
5020         [RLIMIT_NOFILE] = "LimitNOFILE",
5021         [RLIMIT_AS] = "LimitAS",
5022         [RLIMIT_NPROC] = "LimitNPROC",
5023         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
5024         [RLIMIT_LOCKS] = "LimitLOCKS",
5025         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
5026         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
5027         [RLIMIT_NICE] = "LimitNICE",
5028         [RLIMIT_RTPRIO] = "LimitRTPRIO",
5029         [RLIMIT_RTTIME] = "LimitRTTIME"
5030 };
5031
5032 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
5033
5034 static const char* const ip_tos_table[] = {
5035         [IPTOS_LOWDELAY] = "low-delay",
5036         [IPTOS_THROUGHPUT] = "throughput",
5037         [IPTOS_RELIABILITY] = "reliability",
5038         [IPTOS_LOWCOST] = "low-cost",
5039 };
5040
5041 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
5042
5043 static const char *const __signal_table[] = {
5044         [SIGHUP] = "HUP",
5045         [SIGINT] = "INT",
5046         [SIGQUIT] = "QUIT",
5047         [SIGILL] = "ILL",
5048         [SIGTRAP] = "TRAP",
5049         [SIGABRT] = "ABRT",
5050         [SIGBUS] = "BUS",
5051         [SIGFPE] = "FPE",
5052         [SIGKILL] = "KILL",
5053         [SIGUSR1] = "USR1",
5054         [SIGSEGV] = "SEGV",
5055         [SIGUSR2] = "USR2",
5056         [SIGPIPE] = "PIPE",
5057         [SIGALRM] = "ALRM",
5058         [SIGTERM] = "TERM",
5059 #ifdef SIGSTKFLT
5060         [SIGSTKFLT] = "STKFLT",  /* Linux on SPARC doesn't know SIGSTKFLT */
5061 #endif
5062         [SIGCHLD] = "CHLD",
5063         [SIGCONT] = "CONT",
5064         [SIGSTOP] = "STOP",
5065         [SIGTSTP] = "TSTP",
5066         [SIGTTIN] = "TTIN",
5067         [SIGTTOU] = "TTOU",
5068         [SIGURG] = "URG",
5069         [SIGXCPU] = "XCPU",
5070         [SIGXFSZ] = "XFSZ",
5071         [SIGVTALRM] = "VTALRM",
5072         [SIGPROF] = "PROF",
5073         [SIGWINCH] = "WINCH",
5074         [SIGIO] = "IO",
5075         [SIGPWR] = "PWR",
5076         [SIGSYS] = "SYS"
5077 };
5078
5079 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(__signal, int);
5080
5081 const char *signal_to_string(int signo) {
5082         static thread_local char buf[sizeof("RTMIN+")-1 + DECIMAL_STR_MAX(int) + 1];
5083         const char *name;
5084
5085         name = __signal_to_string(signo);
5086         if (name)
5087                 return name;
5088
5089         if (signo >= SIGRTMIN && signo <= SIGRTMAX)
5090                 snprintf(buf, sizeof(buf), "RTMIN+%d", signo - SIGRTMIN);
5091         else
5092                 snprintf(buf, sizeof(buf), "%d", signo);
5093
5094         return buf;
5095 }
5096
5097 int signal_from_string(const char *s) {
5098         int signo;
5099         int offset = 0;
5100         unsigned u;
5101
5102         signo = __signal_from_string(s);
5103         if (signo > 0)
5104                 return signo;
5105
5106         if (startswith(s, "RTMIN+")) {
5107                 s += 6;
5108                 offset = SIGRTMIN;
5109         }
5110         if (safe_atou(s, &u) >= 0) {
5111                 signo = (int) u + offset;
5112                 if (signo > 0 && signo < _NSIG)
5113                         return signo;
5114         }
5115         return -EINVAL;
5116 }
5117
5118 bool kexec_loaded(void) {
5119        bool loaded = false;
5120        char *s;
5121
5122        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
5123                if (s[0] == '1')
5124                        loaded = true;
5125                free(s);
5126        }
5127        return loaded;
5128 }
5129
5130 int prot_from_flags(int flags) {
5131
5132         switch (flags & O_ACCMODE) {
5133
5134         case O_RDONLY:
5135                 return PROT_READ;
5136
5137         case O_WRONLY:
5138                 return PROT_WRITE;
5139
5140         case O_RDWR:
5141                 return PROT_READ|PROT_WRITE;
5142
5143         default:
5144                 return -EINVAL;
5145         }
5146 }
5147
5148 char *format_bytes(char *buf, size_t l, off_t t) {
5149         unsigned i;
5150
5151         static const struct {
5152                 const char *suffix;
5153                 off_t factor;
5154         } table[] = {
5155                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5156                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
5157                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
5158                 { "G", 1024ULL*1024ULL*1024ULL },
5159                 { "M", 1024ULL*1024ULL },
5160                 { "K", 1024ULL },
5161         };
5162
5163         if (t == (off_t) -1)
5164                 return NULL;
5165
5166         for (i = 0; i < ELEMENTSOF(table); i++) {
5167
5168                 if (t >= table[i].factor) {
5169                         snprintf(buf, l,
5170                                  "%llu.%llu%s",
5171                                  (unsigned long long) (t / table[i].factor),
5172                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
5173                                  table[i].suffix);
5174
5175                         goto finish;
5176                 }
5177         }
5178
5179         snprintf(buf, l, "%lluB", (unsigned long long) t);
5180
5181 finish:
5182         buf[l-1] = 0;
5183         return buf;
5184
5185 }
5186
5187 void* memdup(const void *p, size_t l) {
5188         void *r;
5189
5190         assert(p);
5191
5192         r = malloc(l);
5193         if (!r)
5194                 return NULL;
5195
5196         memcpy(r, p, l);
5197         return r;
5198 }
5199
5200 int fd_inc_sndbuf(int fd, size_t n) {
5201         int r, value;
5202         socklen_t l = sizeof(value);
5203
5204         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
5205         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5206                 return 0;
5207
5208         /* If we have the privileges we will ignore the kernel limit. */
5209
5210         value = (int) n;
5211         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
5212                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
5213                         return -errno;
5214
5215         return 1;
5216 }
5217
5218 int fd_inc_rcvbuf(int fd, size_t n) {
5219         int r, value;
5220         socklen_t l = sizeof(value);
5221
5222         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
5223         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
5224                 return 0;
5225
5226         /* If we have the privileges we will ignore the kernel limit. */
5227
5228         value = (int) n;
5229         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
5230                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
5231                         return -errno;
5232         return 1;
5233 }
5234
5235 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
5236         bool stdout_is_tty, stderr_is_tty;
5237         pid_t parent_pid, agent_pid;
5238         sigset_t ss, saved_ss;
5239         unsigned n, i;
5240         va_list ap;
5241         char **l;
5242
5243         assert(pid);
5244         assert(path);
5245
5246         /* Spawns a temporary TTY agent, making sure it goes away when
5247          * we go away */
5248
5249         parent_pid = getpid();
5250
5251         /* First we temporarily block all signals, so that the new
5252          * child has them blocked initially. This way, we can be sure
5253          * that SIGTERMs are not lost we might send to the agent. */
5254         assert_se(sigfillset(&ss) >= 0);
5255         assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
5256
5257         agent_pid = fork();
5258         if (agent_pid < 0) {
5259                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5260                 return -errno;
5261         }
5262
5263         if (agent_pid != 0) {
5264                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
5265                 *pid = agent_pid;
5266                 return 0;
5267         }
5268
5269         /* In the child:
5270          *
5271          * Make sure the agent goes away when the parent dies */
5272         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
5273                 _exit(EXIT_FAILURE);
5274
5275         /* Make sure we actually can kill the agent, if we need to, in
5276          * case somebody invoked us from a shell script that trapped
5277          * SIGTERM or so... */
5278         reset_all_signal_handlers();
5279         reset_signal_mask();
5280
5281         /* Check whether our parent died before we were able
5282          * to set the death signal and unblock the signals */
5283         if (getppid() != parent_pid)
5284                 _exit(EXIT_SUCCESS);
5285
5286         /* Don't leak fds to the agent */
5287         close_all_fds(except, n_except);
5288
5289         stdout_is_tty = isatty(STDOUT_FILENO);
5290         stderr_is_tty = isatty(STDERR_FILENO);
5291
5292         if (!stdout_is_tty || !stderr_is_tty) {
5293                 int fd;
5294
5295                 /* Detach from stdout/stderr. and reopen
5296                  * /dev/tty for them. This is important to
5297                  * ensure that when systemctl is started via
5298                  * popen() or a similar call that expects to
5299                  * read EOF we actually do generate EOF and
5300                  * not delay this indefinitely by because we
5301                  * keep an unused copy of stdin around. */
5302                 fd = open("/dev/tty", O_WRONLY);
5303                 if (fd < 0) {
5304                         log_error_errno(errno, "Failed to open /dev/tty: %m");
5305                         _exit(EXIT_FAILURE);
5306                 }
5307
5308                 if (!stdout_is_tty)
5309                         dup2(fd, STDOUT_FILENO);
5310
5311                 if (!stderr_is_tty)
5312                         dup2(fd, STDERR_FILENO);
5313
5314                 if (fd > 2)
5315                         close(fd);
5316         }
5317
5318         /* Count arguments */
5319         va_start(ap, path);
5320         for (n = 0; va_arg(ap, char*); n++)
5321                 ;
5322         va_end(ap);
5323
5324         /* Allocate strv */
5325         l = alloca(sizeof(char *) * (n + 1));
5326
5327         /* Fill in arguments */
5328         va_start(ap, path);
5329         for (i = 0; i <= n; i++)
5330                 l[i] = va_arg(ap, char*);
5331         va_end(ap);
5332
5333         execv(path, l);
5334         _exit(EXIT_FAILURE);
5335 }
5336
5337 int setrlimit_closest(int resource, const struct rlimit *rlim) {
5338         struct rlimit highest, fixed;
5339
5340         assert(rlim);
5341
5342         if (setrlimit(resource, rlim) >= 0)
5343                 return 0;
5344
5345         if (errno != EPERM)
5346                 return -errno;
5347
5348         /* So we failed to set the desired setrlimit, then let's try
5349          * to get as close as we can */
5350         assert_se(getrlimit(resource, &highest) == 0);
5351
5352         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
5353         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
5354
5355         if (setrlimit(resource, &fixed) < 0)
5356                 return -errno;
5357
5358         return 0;
5359 }
5360
5361 int getenv_for_pid(pid_t pid, const char *field, char **_value) {
5362         _cleanup_fclose_ FILE *f = NULL;
5363         char *value = NULL;
5364         int r;
5365         bool done = false;
5366         size_t l;
5367         const char *path;
5368
5369         assert(pid >= 0);
5370         assert(field);
5371         assert(_value);
5372
5373         path = procfs_file_alloca(pid, "environ");
5374
5375         f = fopen(path, "re");
5376         if (!f)
5377                 return -errno;
5378
5379         l = strlen(field);
5380         r = 0;
5381
5382         do {
5383                 char line[LINE_MAX];
5384                 unsigned i;
5385
5386                 for (i = 0; i < sizeof(line)-1; i++) {
5387                         int c;
5388
5389                         c = getc(f);
5390                         if (_unlikely_(c == EOF)) {
5391                                 done = true;
5392                                 break;
5393                         } else if (c == 0)
5394                                 break;
5395
5396                         line[i] = c;
5397                 }
5398                 line[i] = 0;
5399
5400                 if (memcmp(line, field, l) == 0 && line[l] == '=') {
5401                         value = strdup(line + l + 1);
5402                         if (!value)
5403                                 return -ENOMEM;
5404
5405                         r = 1;
5406                         break;
5407                 }
5408
5409         } while (!done);
5410
5411         *_value = value;
5412         return r;
5413 }
5414
5415 bool http_etag_is_valid(const char *etag) {
5416         if (isempty(etag))
5417                 return false;
5418
5419         if (!endswith(etag, "\""))
5420                 return false;
5421
5422         if (!startswith(etag, "\"") && !startswith(etag, "W/\""))
5423                 return false;
5424
5425         return true;
5426 }
5427
5428 bool http_url_is_valid(const char *url) {
5429         const char *p;
5430
5431         if (isempty(url))
5432                 return false;
5433
5434         p = startswith(url, "http://");
5435         if (!p)
5436                 p = startswith(url, "https://");
5437         if (!p)
5438                 return false;
5439
5440         if (isempty(p))
5441                 return false;
5442
5443         return ascii_is_valid(p);
5444 }
5445
5446 bool documentation_url_is_valid(const char *url) {
5447         const char *p;
5448
5449         if (isempty(url))
5450                 return false;
5451
5452         if (http_url_is_valid(url))
5453                 return true;
5454
5455         p = startswith(url, "file:/");
5456         if (!p)
5457                 p = startswith(url, "info:");
5458         if (!p)
5459                 p = startswith(url, "man:");
5460
5461         if (isempty(p))
5462                 return false;
5463
5464         return ascii_is_valid(p);
5465 }
5466
5467 bool in_initrd(void) {
5468         static int saved = -1;
5469         struct statfs s;
5470
5471         if (saved >= 0)
5472                 return saved;
5473
5474         /* We make two checks here:
5475          *
5476          * 1. the flag file /etc/initrd-release must exist
5477          * 2. the root file system must be a memory file system
5478          *
5479          * The second check is extra paranoia, since misdetecting an
5480          * initrd can have bad bad consequences due the initrd
5481          * emptying when transititioning to the main systemd.
5482          */
5483
5484         saved = access("/etc/initrd-release", F_OK) >= 0 &&
5485                 statfs("/", &s) >= 0 &&
5486                 is_temporary_fs(&s);
5487
5488         return saved;
5489 }
5490
5491 void warn_melody(void) {
5492         _cleanup_close_ int fd = -1;
5493
5494         fd = open("/dev/console", O_WRONLY|O_CLOEXEC|O_NOCTTY);
5495         if (fd < 0)
5496                 return;
5497
5498         /* Yeah, this is synchronous. Kinda sucks. But well... */
5499
5500         ioctl(fd, KIOCSOUND, (int)(1193180/440));
5501         usleep(125*USEC_PER_MSEC);
5502
5503         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5504         usleep(125*USEC_PER_MSEC);
5505
5506         ioctl(fd, KIOCSOUND, (int)(1193180/220));
5507         usleep(125*USEC_PER_MSEC);
5508
5509         ioctl(fd, KIOCSOUND, 0);
5510 }
5511
5512 int make_console_stdio(void) {
5513         int fd, r;
5514
5515         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
5516
5517         fd = acquire_terminal("/dev/console", false, true, true, USEC_INFINITY);
5518         if (fd < 0)
5519                 return log_error_errno(fd, "Failed to acquire terminal: %m");
5520
5521         r = make_stdio(fd);
5522         if (r < 0)
5523                 return log_error_errno(r, "Failed to duplicate terminal fd: %m");
5524
5525         return 0;
5526 }
5527
5528 int get_home_dir(char **_h) {
5529         struct passwd *p;
5530         const char *e;
5531         char *h;
5532         uid_t u;
5533
5534         assert(_h);
5535
5536         /* Take the user specified one */
5537         e = secure_getenv("HOME");
5538         if (e && path_is_absolute(e)) {
5539                 h = strdup(e);
5540                 if (!h)
5541                         return -ENOMEM;
5542
5543                 *_h = h;
5544                 return 0;
5545         }
5546
5547         /* Hardcode home directory for root to avoid NSS */
5548         u = getuid();
5549         if (u == 0) {
5550                 h = strdup("/root");
5551                 if (!h)
5552                         return -ENOMEM;
5553
5554                 *_h = h;
5555                 return 0;
5556         }
5557
5558         /* Check the database... */
5559         errno = 0;
5560         p = getpwuid(u);
5561         if (!p)
5562                 return errno > 0 ? -errno : -ESRCH;
5563
5564         if (!path_is_absolute(p->pw_dir))
5565                 return -EINVAL;
5566
5567         h = strdup(p->pw_dir);
5568         if (!h)
5569                 return -ENOMEM;
5570
5571         *_h = h;
5572         return 0;
5573 }
5574
5575 int get_shell(char **_s) {
5576         struct passwd *p;
5577         const char *e;
5578         char *s;
5579         uid_t u;
5580
5581         assert(_s);
5582
5583         /* Take the user specified one */
5584         e = getenv("SHELL");
5585         if (e) {
5586                 s = strdup(e);
5587                 if (!s)
5588                         return -ENOMEM;
5589
5590                 *_s = s;
5591                 return 0;
5592         }
5593
5594         /* Hardcode home directory for root to avoid NSS */
5595         u = getuid();
5596         if (u == 0) {
5597                 s = strdup("/bin/sh");
5598                 if (!s)
5599                         return -ENOMEM;
5600
5601                 *_s = s;
5602                 return 0;
5603         }
5604
5605         /* Check the database... */
5606         errno = 0;
5607         p = getpwuid(u);
5608         if (!p)
5609                 return errno > 0 ? -errno : -ESRCH;
5610
5611         if (!path_is_absolute(p->pw_shell))
5612                 return -EINVAL;
5613
5614         s = strdup(p->pw_shell);
5615         if (!s)
5616                 return -ENOMEM;
5617
5618         *_s = s;
5619         return 0;
5620 }
5621
5622 bool filename_is_valid(const char *p) {
5623
5624         if (isempty(p))
5625                 return false;
5626
5627         if (strchr(p, '/'))
5628                 return false;
5629
5630         if (streq(p, "."))
5631                 return false;
5632
5633         if (streq(p, ".."))
5634                 return false;
5635
5636         if (strlen(p) > FILENAME_MAX)
5637                 return false;
5638
5639         return true;
5640 }
5641
5642 bool string_is_safe(const char *p) {
5643         const char *t;
5644
5645         if (!p)
5646                 return false;
5647
5648         for (t = p; *t; t++) {
5649                 if (*t > 0 && *t < ' ')
5650                         return false;
5651
5652                 if (strchr("\\\"\'\0x7f", *t))
5653                         return false;
5654         }
5655
5656         return true;
5657 }
5658
5659 /**
5660  * Check if a string contains control characters. If 'ok' is non-NULL
5661  * it may be a string containing additional CCs to be considered OK.
5662  */
5663 bool string_has_cc(const char *p, const char *ok) {
5664         const char *t;
5665
5666         assert(p);
5667
5668         for (t = p; *t; t++) {
5669                 if (ok && strchr(ok, *t))
5670                         continue;
5671
5672                 if (*t > 0 && *t < ' ')
5673                         return true;
5674
5675                 if (*t == 127)
5676                         return true;
5677         }
5678
5679         return false;
5680 }
5681
5682 bool path_is_safe(const char *p) {
5683
5684         if (isempty(p))
5685                 return false;
5686
5687         if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
5688                 return false;
5689
5690         if (strlen(p) > PATH_MAX)
5691                 return false;
5692
5693         /* The following two checks are not really dangerous, but hey, they still are confusing */
5694         if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
5695                 return false;
5696
5697         if (strstr(p, "//"))
5698                 return false;
5699
5700         return true;
5701 }
5702
5703 /* hey glibc, APIs with callbacks without a user pointer are so useless */
5704 void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
5705                  int (*compar) (const void *, const void *, void *), void *arg) {
5706         size_t l, u, idx;
5707         const void *p;
5708         int comparison;
5709
5710         l = 0;
5711         u = nmemb;
5712         while (l < u) {
5713                 idx = (l + u) / 2;
5714                 p = (void *)(((const char *) base) + (idx * size));
5715                 comparison = compar(key, p, arg);
5716                 if (comparison < 0)
5717                         u = idx;
5718                 else if (comparison > 0)
5719                         l = idx + 1;
5720                 else
5721                         return (void *)p;
5722         }
5723         return NULL;
5724 }
5725
5726 void init_gettext(void) {
5727         setlocale(LC_ALL, "");
5728         textdomain(GETTEXT_PACKAGE);
5729 }
5730
5731 bool is_locale_utf8(void) {
5732         const char *set;
5733         static int cached_answer = -1;
5734
5735         if (cached_answer >= 0)
5736                 goto out;
5737
5738         if (!setlocale(LC_ALL, "")) {
5739                 cached_answer = true;
5740                 goto out;
5741         }
5742
5743         set = nl_langinfo(CODESET);
5744         if (!set) {
5745                 cached_answer = true;
5746                 goto out;
5747         }
5748
5749         if (streq(set, "UTF-8")) {
5750                 cached_answer = true;
5751                 goto out;
5752         }
5753
5754         /* For LC_CTYPE=="C" return true, because CTYPE is effectly
5755          * unset and everything can do to UTF-8 nowadays. */
5756         set = setlocale(LC_CTYPE, NULL);
5757         if (!set) {
5758                 cached_answer = true;
5759                 goto out;
5760         }
5761
5762         /* Check result, but ignore the result if C was set
5763          * explicitly. */
5764         cached_answer =
5765                 streq(set, "C") &&
5766                 !getenv("LC_ALL") &&
5767                 !getenv("LC_CTYPE") &&
5768                 !getenv("LANG");
5769
5770 out:
5771         return (bool) cached_answer;
5772 }
5773
5774 const char *draw_special_char(DrawSpecialChar ch) {
5775         static const char *draw_table[2][_DRAW_SPECIAL_CHAR_MAX] = {
5776
5777                 /* UTF-8 */ {
5778                         [DRAW_TREE_VERTICAL]      = "\342\224\202 ",            /* │  */
5779                         [DRAW_TREE_BRANCH]        = "\342\224\234\342\224\200", /* ├─ */
5780                         [DRAW_TREE_RIGHT]         = "\342\224\224\342\224\200", /* └─ */
5781                         [DRAW_TREE_SPACE]         = "  ",                       /*    */
5782                         [DRAW_TRIANGULAR_BULLET]  = "\342\200\243",             /* ‣ */
5783                         [DRAW_BLACK_CIRCLE]       = "\342\227\217",             /* ● */
5784                         [DRAW_ARROW]              = "\342\206\222",             /* → */
5785                         [DRAW_DASH]               = "\342\200\223",             /* – */
5786                 },
5787
5788                 /* ASCII fallback */ {
5789                         [DRAW_TREE_VERTICAL]      = "| ",
5790                         [DRAW_TREE_BRANCH]        = "|-",
5791                         [DRAW_TREE_RIGHT]         = "`-",
5792                         [DRAW_TREE_SPACE]         = "  ",
5793                         [DRAW_TRIANGULAR_BULLET]  = ">",
5794                         [DRAW_BLACK_CIRCLE]       = "*",
5795                         [DRAW_ARROW]              = "->",
5796                         [DRAW_DASH]               = "-",
5797                 }
5798         };
5799
5800         return draw_table[!is_locale_utf8()][ch];
5801 }
5802
5803 char *strreplace(const char *text, const char *old_string, const char *new_string) {
5804         const char *f;
5805         char *t, *r;
5806         size_t l, old_len, new_len;
5807
5808         assert(text);
5809         assert(old_string);
5810         assert(new_string);
5811
5812         old_len = strlen(old_string);
5813         new_len = strlen(new_string);
5814
5815         l = strlen(text);
5816         r = new(char, l+1);
5817         if (!r)
5818                 return NULL;
5819
5820         f = text;
5821         t = r;
5822         while (*f) {
5823                 char *a;
5824                 size_t d, nl;
5825
5826                 if (!startswith(f, old_string)) {
5827                         *(t++) = *(f++);
5828                         continue;
5829                 }
5830
5831                 d = t - r;
5832                 nl = l - old_len + new_len;
5833                 a = realloc(r, nl + 1);
5834                 if (!a)
5835                         goto oom;
5836
5837                 l = nl;
5838                 r = a;
5839                 t = r + d;
5840
5841                 t = stpcpy(t, new_string);
5842                 f += old_len;
5843         }
5844
5845         *t = 0;
5846         return r;
5847
5848 oom:
5849         free(r);
5850         return NULL;
5851 }
5852
5853 char *strip_tab_ansi(char **ibuf, size_t *_isz) {
5854         const char *i, *begin = NULL;
5855         enum {
5856                 STATE_OTHER,
5857                 STATE_ESCAPE,
5858                 STATE_BRACKET
5859         } state = STATE_OTHER;
5860         char *obuf = NULL;
5861         size_t osz = 0, isz;
5862         FILE *f;
5863
5864         assert(ibuf);
5865         assert(*ibuf);
5866
5867         /* Strips ANSI color and replaces TABs by 8 spaces */
5868
5869         isz = _isz ? *_isz : strlen(*ibuf);
5870
5871         f = open_memstream(&obuf, &osz);
5872         if (!f)
5873                 return NULL;
5874
5875         for (i = *ibuf; i < *ibuf + isz + 1; i++) {
5876
5877                 switch (state) {
5878
5879                 case STATE_OTHER:
5880                         if (i >= *ibuf + isz) /* EOT */
5881                                 break;
5882                         else if (*i == '\x1B')
5883                                 state = STATE_ESCAPE;
5884                         else if (*i == '\t')
5885                                 fputs("        ", f);
5886                         else
5887                                 fputc(*i, f);
5888                         break;
5889
5890                 case STATE_ESCAPE:
5891                         if (i >= *ibuf + isz) { /* EOT */
5892                                 fputc('\x1B', f);
5893                                 break;
5894                         } else if (*i == '[') {
5895                                 state = STATE_BRACKET;
5896                                 begin = i + 1;
5897                         } else {
5898                                 fputc('\x1B', f);
5899                                 fputc(*i, f);
5900                                 state = STATE_OTHER;
5901                         }
5902
5903                         break;
5904
5905                 case STATE_BRACKET:
5906
5907                         if (i >= *ibuf + isz || /* EOT */
5908                             (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
5909                                 fputc('\x1B', f);
5910                                 fputc('[', f);
5911                                 state = STATE_OTHER;
5912                                 i = begin-1;
5913                         } else if (*i == 'm')
5914                                 state = STATE_OTHER;
5915                         break;
5916                 }
5917         }
5918
5919         if (ferror(f)) {
5920                 fclose(f);
5921                 free(obuf);
5922                 return NULL;
5923         }
5924
5925         fclose(f);
5926
5927         free(*ibuf);
5928         *ibuf = obuf;
5929
5930         if (_isz)
5931                 *_isz = osz;
5932
5933         return obuf;
5934 }
5935
5936 int on_ac_power(void) {
5937         bool found_offline = false, found_online = false;
5938         _cleanup_closedir_ DIR *d = NULL;
5939
5940         d = opendir("/sys/class/power_supply");
5941         if (!d)
5942                 return errno == ENOENT ? true : -errno;
5943
5944         for (;;) {
5945                 struct dirent *de;
5946                 _cleanup_close_ int fd = -1, device = -1;
5947                 char contents[6];
5948                 ssize_t n;
5949
5950                 errno = 0;
5951                 de = readdir(d);
5952                 if (!de && errno != 0)
5953                         return -errno;
5954
5955                 if (!de)
5956                         break;
5957
5958                 if (hidden_file(de->d_name))
5959                         continue;
5960
5961                 device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
5962                 if (device < 0) {
5963                         if (errno == ENOENT || errno == ENOTDIR)
5964                                 continue;
5965
5966                         return -errno;
5967                 }
5968
5969                 fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5970                 if (fd < 0) {
5971                         if (errno == ENOENT)
5972                                 continue;
5973
5974                         return -errno;
5975                 }
5976
5977                 n = read(fd, contents, sizeof(contents));
5978                 if (n < 0)
5979                         return -errno;
5980
5981                 if (n != 6 || memcmp(contents, "Mains\n", 6))
5982                         continue;
5983
5984                 safe_close(fd);
5985                 fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
5986                 if (fd < 0) {
5987                         if (errno == ENOENT)
5988                                 continue;
5989
5990                         return -errno;
5991                 }
5992
5993                 n = read(fd, contents, sizeof(contents));
5994                 if (n < 0)
5995                         return -errno;
5996
5997                 if (n != 2 || contents[1] != '\n')
5998                         return -EIO;
5999
6000                 if (contents[0] == '1') {
6001                         found_online = true;
6002                         break;
6003                 } else if (contents[0] == '0')
6004                         found_offline = true;
6005                 else
6006                         return -EIO;
6007         }
6008
6009         return found_online || !found_offline;
6010 }
6011
6012 static int search_and_fopen_internal(const char *path, const char *mode, const char *root, char **search, FILE **_f) {
6013         char **i;
6014
6015         assert(path);
6016         assert(mode);
6017         assert(_f);
6018
6019         if (!path_strv_resolve_uniq(search, root))
6020                 return -ENOMEM;
6021
6022         STRV_FOREACH(i, search) {
6023                 _cleanup_free_ char *p = NULL;
6024                 FILE *f;
6025
6026                 if (root)
6027                         p = strjoin(root, *i, "/", path, NULL);
6028                 else
6029                         p = strjoin(*i, "/", path, NULL);
6030                 if (!p)
6031                         return -ENOMEM;
6032
6033                 f = fopen(p, mode);
6034                 if (f) {
6035                         *_f = f;
6036                         return 0;
6037                 }
6038
6039                 if (errno != ENOENT)
6040                         return -errno;
6041         }
6042
6043         return -ENOENT;
6044 }
6045
6046 int search_and_fopen(const char *path, const char *mode, const char *root, const char **search, FILE **_f) {
6047         _cleanup_strv_free_ char **copy = NULL;
6048
6049         assert(path);
6050         assert(mode);
6051         assert(_f);
6052
6053         if (path_is_absolute(path)) {
6054                 FILE *f;
6055
6056                 f = fopen(path, mode);
6057                 if (f) {
6058                         *_f = f;
6059                         return 0;
6060                 }
6061
6062                 return -errno;
6063         }
6064
6065         copy = strv_copy((char**) search);
6066         if (!copy)
6067                 return -ENOMEM;
6068
6069         return search_and_fopen_internal(path, mode, root, copy, _f);
6070 }
6071
6072 int search_and_fopen_nulstr(const char *path, const char *mode, const char *root, const char *search, FILE **_f) {
6073         _cleanup_strv_free_ char **s = NULL;
6074
6075         if (path_is_absolute(path)) {
6076                 FILE *f;
6077
6078                 f = fopen(path, mode);
6079                 if (f) {
6080                         *_f = f;
6081                         return 0;
6082                 }
6083
6084                 return -errno;
6085         }
6086
6087         s = strv_split_nulstr(search);
6088         if (!s)
6089                 return -ENOMEM;
6090
6091         return search_and_fopen_internal(path, mode, root, s, _f);
6092 }
6093
6094 char *strextend(char **x, ...) {
6095         va_list ap;
6096         size_t f, l;
6097         char *r, *p;
6098
6099         assert(x);
6100
6101         l = f = *x ? strlen(*x) : 0;
6102
6103         va_start(ap, x);
6104         for (;;) {
6105                 const char *t;
6106                 size_t n;
6107
6108                 t = va_arg(ap, const char *);
6109                 if (!t)
6110                         break;
6111
6112                 n = strlen(t);
6113                 if (n > ((size_t) -1) - l) {
6114                         va_end(ap);
6115                         return NULL;
6116                 }
6117
6118                 l += n;
6119         }
6120         va_end(ap);
6121
6122         r = realloc(*x, l+1);
6123         if (!r)
6124                 return NULL;
6125
6126         p = r + f;
6127
6128         va_start(ap, x);
6129         for (;;) {
6130                 const char *t;
6131
6132                 t = va_arg(ap, const char *);
6133                 if (!t)
6134                         break;
6135
6136                 p = stpcpy(p, t);
6137         }
6138         va_end(ap);
6139
6140         *p = 0;
6141         *x = r;
6142
6143         return r + l;
6144 }
6145
6146 char *strrep(const char *s, unsigned n) {
6147         size_t l;
6148         char *r, *p;
6149         unsigned i;
6150
6151         assert(s);
6152
6153         l = strlen(s);
6154         p = r = malloc(l * n + 1);
6155         if (!r)
6156                 return NULL;
6157
6158         for (i = 0; i < n; i++)
6159                 p = stpcpy(p, s);
6160
6161         *p = 0;
6162         return r;
6163 }
6164
6165 void* greedy_realloc(void **p, size_t *allocated, size_t need, size_t size) {
6166         size_t a, newalloc;
6167         void *q;
6168
6169         assert(p);
6170         assert(allocated);
6171
6172         if (*allocated >= need)
6173                 return *p;
6174
6175         newalloc = MAX(need * 2, 64u / size);
6176         a = newalloc * size;
6177
6178         /* check for overflows */
6179         if (a < size * need)
6180                 return NULL;
6181
6182         q = realloc(*p, a);
6183         if (!q)
6184                 return NULL;
6185
6186         *p = q;
6187         *allocated = newalloc;
6188         return q;
6189 }
6190
6191 void* greedy_realloc0(void **p, size_t *allocated, size_t need, size_t size) {
6192         size_t prev;
6193         uint8_t *q;
6194
6195         assert(p);
6196         assert(allocated);
6197
6198         prev = *allocated;
6199
6200         q = greedy_realloc(p, allocated, need, size);
6201         if (!q)
6202                 return NULL;
6203
6204         if (*allocated > prev)
6205                 memzero(q + prev * size, (*allocated - prev) * size);
6206
6207         return q;
6208 }
6209
6210 bool id128_is_valid(const char *s) {
6211         size_t i, l;
6212
6213         l = strlen(s);
6214         if (l == 32) {
6215
6216                 /* Simple formatted 128bit hex string */
6217
6218                 for (i = 0; i < l; i++) {
6219                         char c = s[i];
6220
6221                         if (!(c >= '0' && c <= '9') &&
6222                             !(c >= 'a' && c <= 'z') &&
6223                             !(c >= 'A' && c <= 'Z'))
6224                                 return false;
6225                 }
6226
6227         } else if (l == 36) {
6228
6229                 /* Formatted UUID */
6230
6231                 for (i = 0; i < l; i++) {
6232                         char c = s[i];
6233
6234                         if ((i == 8 || i == 13 || i == 18 || i == 23)) {
6235                                 if (c != '-')
6236                                         return false;
6237                         } else {
6238                                 if (!(c >= '0' && c <= '9') &&
6239                                     !(c >= 'a' && c <= 'z') &&
6240                                     !(c >= 'A' && c <= 'Z'))
6241                                         return false;
6242                         }
6243                 }
6244
6245         } else
6246                 return false;
6247
6248         return true;
6249 }
6250
6251 int split_pair(const char *s, const char *sep, char **l, char **r) {
6252         char *x, *a, *b;
6253
6254         assert(s);
6255         assert(sep);
6256         assert(l);
6257         assert(r);
6258
6259         if (isempty(sep))
6260                 return -EINVAL;
6261
6262         x = strstr(s, sep);
6263         if (!x)
6264                 return -EINVAL;
6265
6266         a = strndup(s, x - s);
6267         if (!a)
6268                 return -ENOMEM;
6269
6270         b = strdup(x + strlen(sep));
6271         if (!b) {
6272                 free(a);
6273                 return -ENOMEM;
6274         }
6275
6276         *l = a;
6277         *r = b;
6278
6279         return 0;
6280 }
6281
6282 int shall_restore_state(void) {
6283         _cleanup_free_ char *value = NULL;
6284         int r;
6285
6286         r = get_proc_cmdline_key("systemd.restore_state=", &value);
6287         if (r < 0)
6288                 return r;
6289         if (r == 0)
6290                 return true;
6291
6292         return parse_boolean(value) != 0;
6293 }
6294
6295 int proc_cmdline(char **ret) {
6296         assert(ret);
6297
6298         if (detect_container(NULL) > 0)
6299                 return get_process_cmdline(1, 0, false, ret);
6300         else
6301                 return read_one_line_file("/proc/cmdline", ret);
6302 }
6303
6304 int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
6305         _cleanup_free_ char *line = NULL;
6306         const char *p;
6307         int r;
6308
6309         assert(parse_item);
6310
6311         r = proc_cmdline(&line);
6312         if (r < 0)
6313                 return r;
6314
6315         p = line;
6316         for (;;) {
6317                 _cleanup_free_ char *word = NULL;
6318                 char *value = NULL;
6319
6320                 r = unquote_first_word(&p, &word, UNQUOTE_RELAX);
6321                 if (r < 0)
6322                         return r;
6323                 if (r == 0)
6324                         break;
6325
6326                 /* Filter out arguments that are intended only for the
6327                  * initrd */
6328                 if (!in_initrd() && startswith(word, "rd."))
6329                         continue;
6330
6331                 value = strchr(word, '=');
6332                 if (value)
6333                         *(value++) = 0;
6334
6335                 r = parse_item(word, value);
6336                 if (r < 0)
6337                         return r;
6338         }
6339
6340         return 0;
6341 }
6342
6343 int get_proc_cmdline_key(const char *key, char **value) {
6344         _cleanup_free_ char *line = NULL, *ret = NULL;
6345         bool found = false;
6346         const char *p;
6347         int r;
6348
6349         assert(key);
6350
6351         r = proc_cmdline(&line);
6352         if (r < 0)
6353                 return r;
6354
6355         p = line;
6356         for (;;) {
6357                 _cleanup_free_ char *word = NULL;
6358                 const char *e;
6359
6360                 r = unquote_first_word(&p, &word, UNQUOTE_RELAX);
6361                 if (r < 0)
6362                         return r;
6363                 if (r == 0)
6364                         break;
6365
6366                 /* Filter out arguments that are intended only for the
6367                  * initrd */
6368                 if (!in_initrd() && startswith(word, "rd."))
6369                         continue;
6370
6371                 if (value) {
6372                         e = startswith(word, key);
6373                         if (!e)
6374                                 continue;
6375
6376                         r = free_and_strdup(&ret, e);
6377                         if (r < 0)
6378                                 return r;
6379
6380                         found = true;
6381                 } else {
6382                         if (streq(word, key))
6383                                 found = true;
6384                 }
6385         }
6386
6387         if (value) {
6388                 *value = ret;
6389                 ret = NULL;
6390         }
6391
6392         return found;
6393
6394 }
6395
6396 int container_get_leader(const char *machine, pid_t *pid) {
6397         _cleanup_free_ char *s = NULL, *class = NULL;
6398         const char *p;
6399         pid_t leader;
6400         int r;
6401
6402         assert(machine);
6403         assert(pid);
6404
6405         p = strjoina("/run/systemd/machines/", machine);
6406         r = parse_env_file(p, NEWLINE, "LEADER", &s, "CLASS", &class, NULL);
6407         if (r == -ENOENT)
6408                 return -EHOSTDOWN;
6409         if (r < 0)
6410                 return r;
6411         if (!s)
6412                 return -EIO;
6413
6414         if (!streq_ptr(class, "container"))
6415                 return -EIO;
6416
6417         r = parse_pid(s, &leader);
6418         if (r < 0)
6419                 return r;
6420         if (leader <= 1)
6421                 return -EIO;
6422
6423         *pid = leader;
6424         return 0;
6425 }
6426
6427 int namespace_open(pid_t pid, int *pidns_fd, int *mntns_fd, int *netns_fd, int *root_fd) {
6428         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, netnsfd = -1;
6429         int rfd = -1;
6430
6431         assert(pid >= 0);
6432
6433         if (mntns_fd) {
6434                 const char *mntns;
6435
6436                 mntns = procfs_file_alloca(pid, "ns/mnt");
6437                 mntnsfd = open(mntns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6438                 if (mntnsfd < 0)
6439                         return -errno;
6440         }
6441
6442         if (pidns_fd) {
6443                 const char *pidns;
6444
6445                 pidns = procfs_file_alloca(pid, "ns/pid");
6446                 pidnsfd = open(pidns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6447                 if (pidnsfd < 0)
6448                         return -errno;
6449         }
6450
6451         if (netns_fd) {
6452                 const char *netns;
6453
6454                 netns = procfs_file_alloca(pid, "ns/net");
6455                 netnsfd = open(netns, O_RDONLY|O_NOCTTY|O_CLOEXEC);
6456                 if (netnsfd < 0)
6457                         return -errno;
6458         }
6459
6460         if (root_fd) {
6461                 const char *root;
6462
6463                 root = procfs_file_alloca(pid, "root");
6464                 rfd = open(root, O_RDONLY|O_NOCTTY|O_CLOEXEC|O_DIRECTORY);
6465                 if (rfd < 0)
6466                         return -errno;
6467         }
6468
6469         if (pidns_fd)
6470                 *pidns_fd = pidnsfd;
6471
6472         if (mntns_fd)
6473                 *mntns_fd = mntnsfd;
6474
6475         if (netns_fd)
6476                 *netns_fd = netnsfd;
6477
6478         if (root_fd)
6479                 *root_fd = rfd;
6480
6481         pidnsfd = mntnsfd = netnsfd = -1;
6482
6483         return 0;
6484 }
6485
6486 int namespace_enter(int pidns_fd, int mntns_fd, int netns_fd, int root_fd) {
6487
6488         if (pidns_fd >= 0)
6489                 if (setns(pidns_fd, CLONE_NEWPID) < 0)
6490                         return -errno;
6491
6492         if (mntns_fd >= 0)
6493                 if (setns(mntns_fd, CLONE_NEWNS) < 0)
6494                         return -errno;
6495
6496         if (netns_fd >= 0)
6497                 if (setns(netns_fd, CLONE_NEWNET) < 0)
6498                         return -errno;
6499
6500         if (root_fd >= 0) {
6501                 if (fchdir(root_fd) < 0)
6502                         return -errno;
6503
6504                 if (chroot(".") < 0)
6505                         return -errno;
6506         }
6507
6508         if (setresgid(0, 0, 0) < 0)
6509                 return -errno;
6510
6511         if (setgroups(0, NULL) < 0)
6512                 return -errno;
6513
6514         if (setresuid(0, 0, 0) < 0)
6515                 return -errno;
6516
6517         return 0;
6518 }
6519
6520 bool pid_is_unwaited(pid_t pid) {
6521         /* Checks whether a PID is still valid at all, including a zombie */
6522
6523         if (pid <= 0)
6524                 return false;
6525
6526         if (kill(pid, 0) >= 0)
6527                 return true;
6528
6529         return errno != ESRCH;
6530 }
6531
6532 bool pid_is_alive(pid_t pid) {
6533         int r;
6534
6535         /* Checks whether a PID is still valid and not a zombie */
6536
6537         if (pid <= 0)
6538                 return false;
6539
6540         r = get_process_state(pid);
6541         if (r == -ENOENT || r == 'Z')
6542                 return false;
6543
6544         return true;
6545 }
6546
6547 int getpeercred(int fd, struct ucred *ucred) {
6548         socklen_t n = sizeof(struct ucred);
6549         struct ucred u;
6550         int r;
6551
6552         assert(fd >= 0);
6553         assert(ucred);
6554
6555         r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &u, &n);
6556         if (r < 0)
6557                 return -errno;
6558
6559         if (n != sizeof(struct ucred))
6560                 return -EIO;
6561
6562         /* Check if the data is actually useful and not suppressed due
6563          * to namespacing issues */
6564         if (u.pid <= 0)
6565                 return -ENODATA;
6566         if (u.uid == UID_INVALID)
6567                 return -ENODATA;
6568         if (u.gid == GID_INVALID)
6569                 return -ENODATA;
6570
6571         *ucred = u;
6572         return 0;
6573 }
6574
6575 int getpeersec(int fd, char **ret) {
6576         socklen_t n = 64;
6577         char *s;
6578         int r;
6579
6580         assert(fd >= 0);
6581         assert(ret);
6582
6583         s = new0(char, n);
6584         if (!s)
6585                 return -ENOMEM;
6586
6587         r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6588         if (r < 0) {
6589                 free(s);
6590
6591                 if (errno != ERANGE)
6592                         return -errno;
6593
6594                 s = new0(char, n);
6595                 if (!s)
6596                         return -ENOMEM;
6597
6598                 r = getsockopt(fd, SOL_SOCKET, SO_PEERSEC, s, &n);
6599                 if (r < 0) {
6600                         free(s);
6601                         return -errno;
6602                 }
6603         }
6604
6605         if (isempty(s)) {
6606                 free(s);
6607                 return -EOPNOTSUPP;
6608         }
6609
6610         *ret = s;
6611         return 0;
6612 }
6613
6614 /* This is much like like mkostemp() but is subject to umask(). */
6615 int mkostemp_safe(char *pattern, int flags) {
6616         _cleanup_umask_ mode_t u;
6617         int fd;
6618
6619         assert(pattern);
6620
6621         u = umask(077);
6622
6623         fd = mkostemp(pattern, flags);
6624         if (fd < 0)
6625                 return -errno;
6626
6627         return fd;
6628 }
6629
6630 int open_tmpfile(const char *path, int flags) {
6631         char *p;
6632         int fd;
6633
6634         assert(path);
6635
6636 #ifdef O_TMPFILE
6637         /* Try O_TMPFILE first, if it is supported */
6638         fd = open(path, flags|O_TMPFILE, S_IRUSR|S_IWUSR);
6639         if (fd >= 0)
6640                 return fd;
6641 #endif
6642
6643         /* Fall back to unguessable name + unlinking */
6644         p = strjoina(path, "/systemd-tmp-XXXXXX");
6645
6646         fd = mkostemp_safe(p, flags);
6647         if (fd < 0)
6648                 return fd;
6649
6650         unlink(p);
6651         return fd;
6652 }
6653
6654 int fd_warn_permissions(const char *path, int fd) {
6655         struct stat st;
6656
6657         if (fstat(fd, &st) < 0)
6658                 return -errno;
6659
6660         if (st.st_mode & 0111)
6661                 log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path);
6662
6663         if (st.st_mode & 0002)
6664                 log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path);
6665
6666         if (getpid() == 1 && (st.st_mode & 0044) != 0044)
6667                 log_warning("Configuration file %s is marked world-inaccessible. This has no effect as configuration data is accessible via APIs without restrictions. Proceeding anyway.", path);
6668
6669         return 0;
6670 }
6671
6672 unsigned long personality_from_string(const char *p) {
6673
6674         /* Parse a personality specifier. We introduce our own
6675          * identifiers that indicate specific ABIs, rather than just
6676          * hints regarding the register size, since we want to keep
6677          * things open for multiple locally supported ABIs for the
6678          * same register size. We try to reuse the ABI identifiers
6679          * used by libseccomp. */
6680
6681 #if defined(__x86_64__)
6682
6683         if (streq(p, "x86"))
6684                 return PER_LINUX32;
6685
6686         if (streq(p, "x86-64"))
6687                 return PER_LINUX;
6688
6689 #elif defined(__i386__)
6690
6691         if (streq(p, "x86"))
6692                 return PER_LINUX;
6693 #endif
6694
6695         /* personality(7) documents that 0xffffffffUL is used for
6696          * querying the current personality, hence let's use that here
6697          * as error indicator. */
6698         return 0xffffffffUL;
6699 }
6700
6701 const char* personality_to_string(unsigned long p) {
6702
6703 #if defined(__x86_64__)
6704
6705         if (p == PER_LINUX32)
6706                 return "x86";
6707
6708         if (p == PER_LINUX)
6709                 return "x86-64";
6710
6711 #elif defined(__i386__)
6712
6713         if (p == PER_LINUX)
6714                 return "x86";
6715 #endif
6716
6717         return NULL;
6718 }
6719
6720 uint64_t physical_memory(void) {
6721         long mem;
6722
6723         /* We return this as uint64_t in case we are running as 32bit
6724          * process on a 64bit kernel with huge amounts of memory */
6725
6726         mem = sysconf(_SC_PHYS_PAGES);
6727         assert(mem > 0);
6728
6729         return (uint64_t) mem * (uint64_t) page_size();
6730 }
6731
6732 void hexdump(FILE *f, const void *p, size_t s) {
6733         const uint8_t *b = p;
6734         unsigned n = 0;
6735
6736         assert(s == 0 || b);
6737
6738         while (s > 0) {
6739                 size_t i;
6740
6741                 fprintf(f, "%04x  ", n);
6742
6743                 for (i = 0; i < 16; i++) {
6744
6745                         if (i >= s)
6746                                 fputs("   ", f);
6747                         else
6748                                 fprintf(f, "%02x ", b[i]);
6749
6750                         if (i == 7)
6751                                 fputc(' ', f);
6752                 }
6753
6754                 fputc(' ', f);
6755
6756                 for (i = 0; i < 16; i++) {
6757
6758                         if (i >= s)
6759                                 fputc(' ', f);
6760                         else
6761                                 fputc(isprint(b[i]) ? (char) b[i] : '.', f);
6762                 }
6763
6764                 fputc('\n', f);
6765
6766                 if (s < 16)
6767                         break;
6768
6769                 n += 16;
6770                 b += 16;
6771                 s -= 16;
6772         }
6773 }
6774
6775 int update_reboot_param_file(const char *param) {
6776         int r = 0;
6777
6778         if (param) {
6779
6780                 r = write_string_file(REBOOT_PARAM_FILE, param);
6781                 if (r < 0)
6782                         log_error("Failed to write reboot param to "
6783                                   REBOOT_PARAM_FILE": %s", strerror(-r));
6784         } else
6785                 unlink(REBOOT_PARAM_FILE);
6786
6787         return r;
6788 }
6789
6790 int umount_recursive(const char *prefix, int flags) {
6791         bool again;
6792         int n = 0, r;
6793
6794         /* Try to umount everything recursively below a
6795          * directory. Also, take care of stacked mounts, and keep
6796          * unmounting them until they are gone. */
6797
6798         do {
6799                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6800
6801                 again = false;
6802                 r = 0;
6803
6804                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6805                 if (!proc_self_mountinfo)
6806                         return -errno;
6807
6808                 for (;;) {
6809                         _cleanup_free_ char *path = NULL, *p = NULL;
6810                         int k;
6811
6812                         k = fscanf(proc_self_mountinfo,
6813                                    "%*s "       /* (1) mount id */
6814                                    "%*s "       /* (2) parent id */
6815                                    "%*s "       /* (3) major:minor */
6816                                    "%*s "       /* (4) root */
6817                                    "%ms "       /* (5) mount point */
6818                                    "%*s"        /* (6) mount options */
6819                                    "%*[^-]"     /* (7) optional fields */
6820                                    "- "         /* (8) separator */
6821                                    "%*s "       /* (9) file system type */
6822                                    "%*s"        /* (10) mount source */
6823                                    "%*s"        /* (11) mount options 2 */
6824                                    "%*[^\n]",   /* some rubbish at the end */
6825                                    &path);
6826                         if (k != 1) {
6827                                 if (k == EOF)
6828                                         break;
6829
6830                                 continue;
6831                         }
6832
6833                         r = cunescape(path, UNESCAPE_RELAX, &p);
6834                         if (r < 0)
6835                                 return r;
6836
6837                         if (!path_startswith(p, prefix))
6838                                 continue;
6839
6840                         if (umount2(p, flags) < 0) {
6841                                 r = -errno;
6842                                 continue;
6843                         }
6844
6845                         again = true;
6846                         n++;
6847
6848                         break;
6849                 }
6850
6851         } while (again);
6852
6853         return r ? r : n;
6854 }
6855
6856 static int get_mount_flags(const char *path, unsigned long *flags) {
6857         struct statvfs buf;
6858
6859         if (statvfs(path, &buf) < 0)
6860                 return -errno;
6861         *flags = buf.f_flag;
6862         return 0;
6863 }
6864
6865 int bind_remount_recursive(const char *prefix, bool ro) {
6866         _cleanup_set_free_free_ Set *done = NULL;
6867         _cleanup_free_ char *cleaned = NULL;
6868         int r;
6869
6870         /* Recursively remount a directory (and all its submounts)
6871          * read-only or read-write. If the directory is already
6872          * mounted, we reuse the mount and simply mark it
6873          * MS_BIND|MS_RDONLY (or remove the MS_RDONLY for read-write
6874          * operation). If it isn't we first make it one. Afterwards we
6875          * apply MS_BIND|MS_RDONLY (or remove MS_RDONLY) to all
6876          * submounts we can access, too. When mounts are stacked on
6877          * the same mount point we only care for each individual
6878          * "top-level" mount on each point, as we cannot
6879          * influence/access the underlying mounts anyway. We do not
6880          * have any effect on future submounts that might get
6881          * propagated, they migt be writable. This includes future
6882          * submounts that have been triggered via autofs. */
6883
6884         cleaned = strdup(prefix);
6885         if (!cleaned)
6886                 return -ENOMEM;
6887
6888         path_kill_slashes(cleaned);
6889
6890         done = set_new(&string_hash_ops);
6891         if (!done)
6892                 return -ENOMEM;
6893
6894         for (;;) {
6895                 _cleanup_fclose_ FILE *proc_self_mountinfo = NULL;
6896                 _cleanup_set_free_free_ Set *todo = NULL;
6897                 bool top_autofs = false;
6898                 char *x;
6899                 unsigned long orig_flags;
6900
6901                 todo = set_new(&string_hash_ops);
6902                 if (!todo)
6903                         return -ENOMEM;
6904
6905                 proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
6906                 if (!proc_self_mountinfo)
6907                         return -errno;
6908
6909                 for (;;) {
6910                         _cleanup_free_ char *path = NULL, *p = NULL, *type = NULL;
6911                         int k;
6912
6913                         k = fscanf(proc_self_mountinfo,
6914                                    "%*s "       /* (1) mount id */
6915                                    "%*s "       /* (2) parent id */
6916                                    "%*s "       /* (3) major:minor */
6917                                    "%*s "       /* (4) root */
6918                                    "%ms "       /* (5) mount point */
6919                                    "%*s"        /* (6) mount options (superblock) */
6920                                    "%*[^-]"     /* (7) optional fields */
6921                                    "- "         /* (8) separator */
6922                                    "%ms "       /* (9) file system type */
6923                                    "%*s"        /* (10) mount source */
6924                                    "%*s"        /* (11) mount options (bind mount) */
6925                                    "%*[^\n]",   /* some rubbish at the end */
6926                                    &path,
6927                                    &type);
6928                         if (k != 2) {
6929                                 if (k == EOF)
6930                                         break;
6931
6932                                 continue;
6933                         }
6934
6935                         r = cunescape(path, UNESCAPE_RELAX, &p);
6936                         if (r < 0)
6937                                 return r;
6938
6939                         /* Let's ignore autofs mounts.  If they aren't
6940                          * triggered yet, we want to avoid triggering
6941                          * them, as we don't make any guarantees for
6942                          * future submounts anyway.  If they are
6943                          * already triggered, then we will find
6944                          * another entry for this. */
6945                         if (streq(type, "autofs")) {
6946                                 top_autofs = top_autofs || path_equal(cleaned, p);
6947                                 continue;
6948                         }
6949
6950                         if (path_startswith(p, cleaned) &&
6951                             !set_contains(done, p)) {
6952
6953                                 r = set_consume(todo, p);
6954                                 p = NULL;
6955
6956                                 if (r == -EEXIST)
6957                                         continue;
6958                                 if (r < 0)
6959                                         return r;
6960                         }
6961                 }
6962
6963                 /* If we have no submounts to process anymore and if
6964                  * the root is either already done, or an autofs, we
6965                  * are done */
6966                 if (set_isempty(todo) &&
6967                     (top_autofs || set_contains(done, cleaned)))
6968                         return 0;
6969
6970                 if (!set_contains(done, cleaned) &&
6971                     !set_contains(todo, cleaned)) {
6972                         /* The prefix directory itself is not yet a
6973                          * mount, make it one. */
6974                         if (mount(cleaned, cleaned, NULL, MS_BIND|MS_REC, NULL) < 0)
6975                                 return -errno;
6976
6977                         orig_flags = 0;
6978                         (void) get_mount_flags(cleaned, &orig_flags);
6979                         orig_flags &= ~MS_RDONLY;
6980
6981                         if (mount(NULL, prefix, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0)
6982                                 return -errno;
6983
6984                         x = strdup(cleaned);
6985                         if (!x)
6986                                 return -ENOMEM;
6987
6988                         r = set_consume(done, x);
6989                         if (r < 0)
6990                                 return r;
6991                 }
6992
6993                 while ((x = set_steal_first(todo))) {
6994
6995                         r = set_consume(done, x);
6996                         if (r == -EEXIST)
6997                                 continue;
6998                         if (r < 0)
6999                                 return r;
7000
7001                         /* Try to reuse the original flag set, but
7002                          * don't care for errors, in case of
7003                          * obstructed mounts */
7004                         orig_flags = 0;
7005                         (void) get_mount_flags(x, &orig_flags);
7006                         orig_flags &= ~MS_RDONLY;
7007
7008                         if (mount(NULL, x, NULL, orig_flags|MS_BIND|MS_REMOUNT|(ro ? MS_RDONLY : 0), NULL) < 0) {
7009
7010                                 /* Deal with mount points that are
7011                                  * obstructed by a later mount */
7012
7013                                 if (errno != ENOENT)
7014                                         return -errno;
7015                         }
7016
7017                 }
7018         }
7019 }
7020
7021 int fflush_and_check(FILE *f) {
7022         assert(f);
7023
7024         errno = 0;
7025         fflush(f);
7026
7027         if (ferror(f))
7028                 return errno ? -errno : -EIO;
7029
7030         return 0;
7031 }
7032
7033 int tempfn_xxxxxx(const char *p, char **ret) {
7034         const char *fn;
7035         char *t;
7036
7037         assert(p);
7038         assert(ret);
7039
7040         /*
7041          * Turns this:
7042          *         /foo/bar/waldo
7043          *
7044          * Into this:
7045          *         /foo/bar/.#waldoXXXXXX
7046          */
7047
7048         fn = basename(p);
7049         if (!filename_is_valid(fn))
7050                 return -EINVAL;
7051
7052         t = new(char, strlen(p) + 2 + 6 + 1);
7053         if (!t)
7054                 return -ENOMEM;
7055
7056         strcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn), "XXXXXX");
7057
7058         *ret = path_kill_slashes(t);
7059         return 0;
7060 }
7061
7062 int tempfn_random(const char *p, char **ret) {
7063         const char *fn;
7064         char *t, *x;
7065         uint64_t u;
7066         unsigned i;
7067
7068         assert(p);
7069         assert(ret);
7070
7071         /*
7072          * Turns this:
7073          *         /foo/bar/waldo
7074          *
7075          * Into this:
7076          *         /foo/bar/.#waldobaa2a261115984a9
7077          */
7078
7079         fn = basename(p);
7080         if (!filename_is_valid(fn))
7081                 return -EINVAL;
7082
7083         t = new(char, strlen(p) + 2 + 16 + 1);
7084         if (!t)
7085                 return -ENOMEM;
7086
7087         x = stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn);
7088
7089         u = random_u64();
7090         for (i = 0; i < 16; i++) {
7091                 *(x++) = hexchar(u & 0xF);
7092                 u >>= 4;
7093         }
7094
7095         *x = 0;
7096
7097         *ret = path_kill_slashes(t);
7098         return 0;
7099 }
7100
7101 int tempfn_random_child(const char *p, char **ret) {
7102         char *t, *x;
7103         uint64_t u;
7104         unsigned i;
7105
7106         assert(p);
7107         assert(ret);
7108
7109         /* Turns this:
7110          *         /foo/bar/waldo
7111          * Into this:
7112          *         /foo/bar/waldo/.#3c2b6219aa75d7d0
7113          */
7114
7115         t = new(char, strlen(p) + 3 + 16 + 1);
7116         if (!t)
7117                 return -ENOMEM;
7118
7119         x = stpcpy(stpcpy(t, p), "/.#");
7120
7121         u = random_u64();
7122         for (i = 0; i < 16; i++) {
7123                 *(x++) = hexchar(u & 0xF);
7124                 u >>= 4;
7125         }
7126
7127         *x = 0;
7128
7129         *ret = path_kill_slashes(t);
7130         return 0;
7131 }
7132
7133 /* make sure the hostname is not "localhost" */
7134 bool is_localhost(const char *hostname) {
7135         assert(hostname);
7136
7137         /* This tries to identify local host and domain names
7138          * described in RFC6761 plus the redhatism of .localdomain */
7139
7140         return streq(hostname, "localhost") ||
7141                streq(hostname, "localhost.") ||
7142                streq(hostname, "localdomain.") ||
7143                streq(hostname, "localdomain") ||
7144                endswith(hostname, ".localhost") ||
7145                endswith(hostname, ".localhost.") ||
7146                endswith(hostname, ".localdomain") ||
7147                endswith(hostname, ".localdomain.");
7148 }
7149
7150 int take_password_lock(const char *root) {
7151
7152         struct flock flock = {
7153                 .l_type = F_WRLCK,
7154                 .l_whence = SEEK_SET,
7155                 .l_start = 0,
7156                 .l_len = 0,
7157         };
7158
7159         const char *path;
7160         int fd, r;
7161
7162         /* This is roughly the same as lckpwdf(), but not as awful. We
7163          * don't want to use alarm() and signals, hence we implement
7164          * our own trivial version of this.
7165          *
7166          * Note that shadow-utils also takes per-database locks in
7167          * addition to lckpwdf(). However, we don't given that they
7168          * are redundant as they they invoke lckpwdf() first and keep
7169          * it during everything they do. The per-database locks are
7170          * awfully racy, and thus we just won't do them. */
7171
7172         if (root)
7173                 path = strjoina(root, "/etc/.pwd.lock");
7174         else
7175                 path = "/etc/.pwd.lock";
7176
7177         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
7178         if (fd < 0)
7179                 return -errno;
7180
7181         r = fcntl(fd, F_SETLKW, &flock);
7182         if (r < 0) {
7183                 safe_close(fd);
7184                 return -errno;
7185         }
7186
7187         return fd;
7188 }
7189
7190 int is_symlink(const char *path) {
7191         struct stat info;
7192
7193         if (lstat(path, &info) < 0)
7194                 return -errno;
7195
7196         return !!S_ISLNK(info.st_mode);
7197 }
7198
7199 int is_dir(const char* path, bool follow) {
7200         struct stat st;
7201         int r;
7202
7203         if (follow)
7204                 r = stat(path, &st);
7205         else
7206                 r = lstat(path, &st);
7207         if (r < 0)
7208                 return -errno;
7209
7210         return !!S_ISDIR(st.st_mode);
7211 }
7212
7213 int unquote_first_word(const char **p, char **ret, UnquoteFlags flags) {
7214         _cleanup_free_ char *s = NULL;
7215         size_t allocated = 0, sz = 0;
7216         int r;
7217
7218         enum {
7219                 START,
7220                 VALUE,
7221                 VALUE_ESCAPE,
7222                 SINGLE_QUOTE,
7223                 SINGLE_QUOTE_ESCAPE,
7224                 DOUBLE_QUOTE,
7225                 DOUBLE_QUOTE_ESCAPE,
7226                 SPACE,
7227         } state = START;
7228
7229         assert(p);
7230         assert(*p);
7231         assert(ret);
7232
7233         /* Parses the first word of a string, and returns it in
7234          * *ret. Removes all quotes in the process. When parsing fails
7235          * (because of an uneven number of quotes or similar), leaves
7236          * the pointer *p at the first invalid character. */
7237
7238         for (;;) {
7239                 char c = **p;
7240
7241                 switch (state) {
7242
7243                 case START:
7244                         if (c == 0)
7245                                 goto finish;
7246                         else if (strchr(WHITESPACE, c))
7247                                 break;
7248
7249                         state = VALUE;
7250                         /* fallthrough */
7251
7252                 case VALUE:
7253                         if (c == 0)
7254                                 goto finish;
7255                         else if (c == '\'')
7256                                 state = SINGLE_QUOTE;
7257                         else if (c == '\\')
7258                                 state = VALUE_ESCAPE;
7259                         else if (c == '\"')
7260                                 state = DOUBLE_QUOTE;
7261                         else if (strchr(WHITESPACE, c))
7262                                 state = SPACE;
7263                         else {
7264                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7265                                         return -ENOMEM;
7266
7267                                 s[sz++] = c;
7268                         }
7269
7270                         break;
7271
7272                 case VALUE_ESCAPE:
7273                         if (c == 0) {
7274                                 if (flags & UNQUOTE_RELAX)
7275                                         goto finish;
7276                                 return -EINVAL;
7277                         }
7278
7279                         if (!GREEDY_REALLOC(s, allocated, sz+7))
7280                                 return -ENOMEM;
7281
7282                         if (flags & UNQUOTE_CUNESCAPE) {
7283                                 uint32_t u;
7284
7285                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
7286                                 if (r < 0)
7287                                         return -EINVAL;
7288
7289                                 (*p) += r - 1;
7290
7291                                 if (c != 0)
7292                                         s[sz++] = c; /* normal explicit char */
7293                                 else
7294                                         sz += utf8_encode_unichar(s + sz, u); /* unicode chars we'll encode as utf8 */
7295                         } else
7296                                 s[sz++] = c;
7297
7298                         state = VALUE;
7299                         break;
7300
7301                 case SINGLE_QUOTE:
7302                         if (c == 0) {
7303                                 if (flags & UNQUOTE_RELAX)
7304                                         goto finish;
7305                                 return -EINVAL;
7306                         } else if (c == '\'')
7307                                 state = VALUE;
7308                         else if (c == '\\')
7309                                 state = SINGLE_QUOTE_ESCAPE;
7310                         else {
7311                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7312                                         return -ENOMEM;
7313
7314                                 s[sz++] = c;
7315                         }
7316
7317                         break;
7318
7319                 case SINGLE_QUOTE_ESCAPE:
7320                         if (c == 0) {
7321                                 if (flags & UNQUOTE_RELAX)
7322                                         goto finish;
7323                                 return -EINVAL;
7324                         }
7325
7326                         if (!GREEDY_REALLOC(s, allocated, sz+7))
7327                                 return -ENOMEM;
7328
7329                         if (flags & UNQUOTE_CUNESCAPE) {
7330                                 uint32_t u;
7331
7332                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
7333                                 if (r < 0)
7334                                         return -EINVAL;
7335
7336                                 (*p) += r - 1;
7337
7338                                 if (c != 0)
7339                                         s[sz++] = c;
7340                                 else
7341                                         sz += utf8_encode_unichar(s + sz, u);
7342                         } else
7343                                 s[sz++] = c;
7344
7345                         state = SINGLE_QUOTE;
7346                         break;
7347
7348                 case DOUBLE_QUOTE:
7349                         if (c == 0)
7350                                 return -EINVAL;
7351                         else if (c == '\"')
7352                                 state = VALUE;
7353                         else if (c == '\\')
7354                                 state = DOUBLE_QUOTE_ESCAPE;
7355                         else {
7356                                 if (!GREEDY_REALLOC(s, allocated, sz+2))
7357                                         return -ENOMEM;
7358
7359                                 s[sz++] = c;
7360                         }
7361
7362                         break;
7363
7364                 case DOUBLE_QUOTE_ESCAPE:
7365                         if (c == 0) {
7366                                 if (flags & UNQUOTE_RELAX)
7367                                         goto finish;
7368                                 return -EINVAL;
7369                         }
7370
7371                         if (!GREEDY_REALLOC(s, allocated, sz+7))
7372                                 return -ENOMEM;
7373
7374                         if (flags & UNQUOTE_CUNESCAPE) {
7375                                 uint32_t u;
7376
7377                                 r = cunescape_one(*p, (size_t) -1, &c, &u);
7378                                 if (r < 0)
7379                                         return -EINVAL;
7380
7381                                 (*p) += r - 1;
7382
7383                                 if (c != 0)
7384                                         s[sz++] = c;
7385                                 else
7386                                         sz += utf8_encode_unichar(s + sz, u);
7387                         } else
7388                                 s[sz++] = c;
7389
7390                         state = DOUBLE_QUOTE;
7391                         break;
7392
7393                 case SPACE:
7394                         if (c == 0)
7395                                 goto finish;
7396                         if (!strchr(WHITESPACE, c))
7397                                 goto finish;
7398
7399                         break;
7400                 }
7401
7402                 (*p) ++;
7403         }
7404
7405 finish:
7406         if (!s) {
7407                 *ret = NULL;
7408                 return 0;
7409         }
7410
7411         s[sz] = 0;
7412         *ret = s;
7413         s = NULL;
7414
7415         return 1;
7416 }
7417
7418 int unquote_many_words(const char **p, UnquoteFlags flags, ...) {
7419         va_list ap;
7420         char **l;
7421         int n = 0, i, c, r;
7422
7423         /* Parses a number of words from a string, stripping any
7424          * quotes if necessary. */
7425
7426         assert(p);
7427
7428         /* Count how many words are expected */
7429         va_start(ap, flags);
7430         for (;;) {
7431                 if (!va_arg(ap, char **))
7432                         break;
7433                 n++;
7434         }
7435         va_end(ap);
7436
7437         if (n <= 0)
7438                 return 0;
7439
7440         /* Read all words into a temporary array */
7441         l = newa0(char*, n);
7442         for (c = 0; c < n; c++) {
7443
7444                 r = unquote_first_word(p, &l[c], flags);
7445                 if (r < 0) {
7446                         int j;
7447
7448                         for (j = 0; j < c; j++)
7449                                 free(l[j]);
7450
7451                         return r;
7452                 }
7453
7454                 if (r == 0)
7455                         break;
7456         }
7457
7458         /* If we managed to parse all words, return them in the passed
7459          * in parameters */
7460         va_start(ap, flags);
7461         for (i = 0; i < n; i++) {
7462                 char **v;
7463
7464                 v = va_arg(ap, char **);
7465                 assert(v);
7466
7467                 *v = l[i];
7468         }
7469         va_end(ap);
7470
7471         return c;
7472 }
7473
7474 int free_and_strdup(char **p, const char *s) {
7475         char *t;
7476
7477         assert(p);
7478
7479         /* Replaces a string pointer with an strdup()ed new string,
7480          * possibly freeing the old one. */
7481
7482         if (s) {
7483                 t = strdup(s);
7484                 if (!t)
7485                         return -ENOMEM;
7486         } else
7487                 t = NULL;
7488
7489         free(*p);
7490         *p = t;
7491
7492         return 0;
7493 }
7494
7495 int sethostname_idempotent(const char *s) {
7496         int r;
7497         char buf[HOST_NAME_MAX + 1] = {};
7498
7499         assert(s);
7500
7501         r = gethostname(buf, sizeof(buf));
7502         if (r < 0)
7503                 return -errno;
7504
7505         if (streq(buf, s))
7506                 return 0;
7507
7508         r = sethostname(s, strlen(s));
7509         if (r < 0)
7510                 return -errno;
7511
7512         return 1;
7513 }
7514
7515 int ptsname_malloc(int fd, char **ret) {
7516         size_t l = 100;
7517
7518         assert(fd >= 0);
7519         assert(ret);
7520
7521         for (;;) {
7522                 char *c;
7523
7524                 c = new(char, l);
7525                 if (!c)
7526                         return -ENOMEM;
7527
7528                 if (ptsname_r(fd, c, l) == 0) {
7529                         *ret = c;
7530                         return 0;
7531                 }
7532                 if (errno != ERANGE) {
7533                         free(c);
7534                         return -errno;
7535                 }
7536
7537                 free(c);
7538                 l *= 2;
7539         }
7540 }
7541
7542 int openpt_in_namespace(pid_t pid, int flags) {
7543         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, rootfd = -1;
7544         _cleanup_close_pair_ int pair[2] = { -1, -1 };
7545         union {
7546                 struct cmsghdr cmsghdr;
7547                 uint8_t buf[CMSG_SPACE(sizeof(int))];
7548         } control = {};
7549         struct msghdr mh = {
7550                 .msg_control = &control,
7551                 .msg_controllen = sizeof(control),
7552         };
7553         struct cmsghdr *cmsg;
7554         siginfo_t si;
7555         pid_t child;
7556         int r;
7557
7558         assert(pid > 0);
7559
7560         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &rootfd);
7561         if (r < 0)
7562                 return r;
7563
7564         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
7565                 return -errno;
7566
7567         child = fork();
7568         if (child < 0)
7569                 return -errno;
7570
7571         if (child == 0) {
7572                 int master;
7573
7574                 pair[0] = safe_close(pair[0]);
7575
7576                 r = namespace_enter(pidnsfd, mntnsfd, -1, rootfd);
7577                 if (r < 0)
7578                         _exit(EXIT_FAILURE);
7579
7580                 master = posix_openpt(flags);
7581                 if (master < 0)
7582                         _exit(EXIT_FAILURE);
7583
7584                 cmsg = CMSG_FIRSTHDR(&mh);
7585                 cmsg->cmsg_level = SOL_SOCKET;
7586                 cmsg->cmsg_type = SCM_RIGHTS;
7587                 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
7588                 memcpy(CMSG_DATA(cmsg), &master, sizeof(int));
7589
7590                 mh.msg_controllen = cmsg->cmsg_len;
7591
7592                 if (sendmsg(pair[1], &mh, MSG_NOSIGNAL) < 0)
7593                         _exit(EXIT_FAILURE);
7594
7595                 _exit(EXIT_SUCCESS);
7596         }
7597
7598         pair[1] = safe_close(pair[1]);
7599
7600         r = wait_for_terminate(child, &si);
7601         if (r < 0)
7602                 return r;
7603         if (si.si_code != CLD_EXITED || si.si_status != EXIT_SUCCESS)
7604                 return -EIO;
7605
7606         if (recvmsg(pair[0], &mh, MSG_NOSIGNAL|MSG_CMSG_CLOEXEC) < 0)
7607                 return -errno;
7608
7609         for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg))
7610                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
7611                         int *fds;
7612                         unsigned n_fds;
7613
7614                         fds = (int*) CMSG_DATA(cmsg);
7615                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
7616
7617                         if (n_fds != 1) {
7618                                 close_many(fds, n_fds);
7619                                 return -EIO;
7620                         }
7621
7622                         return fds[0];
7623                 }
7624
7625         return -EIO;
7626 }
7627
7628 ssize_t fgetxattrat_fake(int dirfd, const char *filename, const char *attribute, void *value, size_t size, int flags) {
7629         _cleanup_close_ int fd = -1;
7630         ssize_t l;
7631
7632         /* The kernel doesn't have a fgetxattrat() command, hence let's emulate one */
7633
7634         fd = openat(dirfd, filename, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOATIME|(flags & AT_SYMLINK_NOFOLLOW ? O_NOFOLLOW : 0));
7635         if (fd < 0)
7636                 return -errno;
7637
7638         l = fgetxattr(fd, attribute, value, size);
7639         if (l < 0)
7640                 return -errno;
7641
7642         return l;
7643 }
7644
7645 static int parse_crtime(le64_t le, usec_t *usec) {
7646         uint64_t u;
7647
7648         assert(usec);
7649
7650         u = le64toh(le);
7651         if (u == 0 || u == (uint64_t) -1)
7652                 return -EIO;
7653
7654         *usec = (usec_t) u;
7655         return 0;
7656 }
7657
7658 int fd_getcrtime(int fd, usec_t *usec) {
7659         le64_t le;
7660         ssize_t n;
7661
7662         assert(fd >= 0);
7663         assert(usec);
7664
7665         /* Until Linux gets a real concept of birthtime/creation time,
7666          * let's fake one with xattrs */
7667
7668         n = fgetxattr(fd, "user.crtime_usec", &le, sizeof(le));
7669         if (n < 0)
7670                 return -errno;
7671         if (n != sizeof(le))
7672                 return -EIO;
7673
7674         return parse_crtime(le, usec);
7675 }
7676
7677 int fd_getcrtime_at(int dirfd, const char *name, usec_t *usec, int flags) {
7678         le64_t le;
7679         ssize_t n;
7680
7681         n = fgetxattrat_fake(dirfd, name, "user.crtime_usec", &le, sizeof(le), flags);
7682         if (n < 0)
7683                 return -errno;
7684         if (n != sizeof(le))
7685                 return -EIO;
7686
7687         return parse_crtime(le, usec);
7688 }
7689
7690 int path_getcrtime(const char *p, usec_t *usec) {
7691         le64_t le;
7692         ssize_t n;
7693
7694         assert(p);
7695         assert(usec);
7696
7697         n = getxattr(p, "user.crtime_usec", &le, sizeof(le));
7698         if (n < 0)
7699                 return -errno;
7700         if (n != sizeof(le))
7701                 return -EIO;
7702
7703         return parse_crtime(le, usec);
7704 }
7705
7706 int fd_setcrtime(int fd, usec_t usec) {
7707         le64_t le;
7708
7709         assert(fd >= 0);
7710
7711         if (usec <= 0)
7712                 usec = now(CLOCK_REALTIME);
7713
7714         le = htole64((uint64_t) usec);
7715         if (fsetxattr(fd, "user.crtime_usec", &le, sizeof(le), 0) < 0)
7716                 return -errno;
7717
7718         return 0;
7719 }
7720
7721 int chattr_fd(int fd, unsigned value, unsigned mask) {
7722         unsigned old_attr, new_attr;
7723
7724         assert(fd >= 0);
7725
7726         if (mask == 0)
7727                 return 0;
7728
7729         if (ioctl(fd, FS_IOC_GETFLAGS, &old_attr) < 0)
7730                 return -errno;
7731
7732         new_attr = (old_attr & ~mask) | (value & mask);
7733         if (new_attr == old_attr)
7734                 return 0;
7735
7736         if (ioctl(fd, FS_IOC_SETFLAGS, &new_attr) < 0)
7737                 return -errno;
7738
7739         return 1;
7740 }
7741
7742 int chattr_path(const char *p, unsigned value, unsigned mask) {
7743         _cleanup_close_ int fd = -1;
7744
7745         assert(p);
7746
7747         if (mask == 0)
7748                 return 0;
7749
7750         fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
7751         if (fd < 0)
7752                 return -errno;
7753
7754         return chattr_fd(fd, value, mask);
7755 }
7756
7757 int read_attr_fd(int fd, unsigned *ret) {
7758         assert(fd >= 0);
7759
7760         if (ioctl(fd, FS_IOC_GETFLAGS, ret) < 0)
7761                 return -errno;
7762
7763         return 0;
7764 }
7765
7766 int read_attr_path(const char *p, unsigned *ret) {
7767         _cleanup_close_ int fd = -1;
7768
7769         assert(p);
7770         assert(ret);
7771
7772         fd = open(p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
7773         if (fd < 0)
7774                 return -errno;
7775
7776         return read_attr_fd(fd, ret);
7777 }
7778
7779 int make_lock_file(const char *p, int operation, LockFile *ret) {
7780         _cleanup_close_ int fd = -1;
7781         _cleanup_free_ char *t = NULL;
7782         int r;
7783
7784         /*
7785          * We use UNPOSIX locks if they are available. They have nice
7786          * semantics, and are mostly compatible with NFS. However,
7787          * they are only available on new kernels. When we detect we
7788          * are running on an older kernel, then we fall back to good
7789          * old BSD locks. They also have nice semantics, but are
7790          * slightly problematic on NFS, where they are upgraded to
7791          * POSIX locks, even though locally they are orthogonal to
7792          * POSIX locks.
7793          */
7794
7795         t = strdup(p);
7796         if (!t)
7797                 return -ENOMEM;
7798
7799         for (;;) {
7800                 struct flock fl = {
7801                         .l_type = (operation & ~LOCK_NB) == LOCK_EX ? F_WRLCK : F_RDLCK,
7802                         .l_whence = SEEK_SET,
7803                 };
7804                 struct stat st;
7805
7806                 fd = open(p, O_CREAT|O_RDWR|O_NOFOLLOW|O_CLOEXEC|O_NOCTTY, 0600);
7807                 if (fd < 0)
7808                         return -errno;
7809
7810                 r = fcntl(fd, (operation & LOCK_NB) ? F_OFD_SETLK : F_OFD_SETLKW, &fl);
7811                 if (r < 0) {
7812
7813                         /* If the kernel is too old, use good old BSD locks */
7814                         if (errno == EINVAL)
7815                                 r = flock(fd, operation);
7816
7817                         if (r < 0)
7818                                 return errno == EAGAIN ? -EBUSY : -errno;
7819                 }
7820
7821                 /* If we acquired the lock, let's check if the file
7822                  * still exists in the file system. If not, then the
7823                  * previous exclusive owner removed it and then closed
7824                  * it. In such a case our acquired lock is worthless,
7825                  * hence try again. */
7826
7827                 r = fstat(fd, &st);
7828                 if (r < 0)
7829                         return -errno;
7830                 if (st.st_nlink > 0)
7831                         break;
7832
7833                 fd = safe_close(fd);
7834         }
7835
7836         ret->path = t;
7837         ret->fd = fd;
7838         ret->operation = operation;
7839
7840         fd = -1;
7841         t = NULL;
7842
7843         return r;
7844 }
7845
7846 int make_lock_file_for(const char *p, int operation, LockFile *ret) {
7847         const char *fn;
7848         char *t;
7849
7850         assert(p);
7851         assert(ret);
7852
7853         fn = basename(p);
7854         if (!filename_is_valid(fn))
7855                 return -EINVAL;
7856
7857         t = newa(char, strlen(p) + 2 + 4 + 1);
7858         stpcpy(stpcpy(stpcpy(mempcpy(t, p, fn - p), ".#"), fn), ".lck");
7859
7860         return make_lock_file(t, operation, ret);
7861 }
7862
7863 void release_lock_file(LockFile *f) {
7864         int r;
7865
7866         if (!f)
7867                 return;
7868
7869         if (f->path) {
7870
7871                 /* If we are the exclusive owner we can safely delete
7872                  * the lock file itself. If we are not the exclusive
7873                  * owner, we can try becoming it. */
7874
7875                 if (f->fd >= 0 &&
7876                     (f->operation & ~LOCK_NB) == LOCK_SH) {
7877                         static const struct flock fl = {
7878                                 .l_type = F_WRLCK,
7879                                 .l_whence = SEEK_SET,
7880                         };
7881
7882                         r = fcntl(f->fd, F_OFD_SETLK, &fl);
7883                         if (r < 0 && errno == EINVAL)
7884                                 r = flock(f->fd, LOCK_EX|LOCK_NB);
7885
7886                         if (r >= 0)
7887                                 f->operation = LOCK_EX|LOCK_NB;
7888                 }
7889
7890                 if ((f->operation & ~LOCK_NB) == LOCK_EX)
7891                         unlink_noerrno(f->path);
7892
7893                 free(f->path);
7894                 f->path = NULL;
7895         }
7896
7897         f->fd = safe_close(f->fd);
7898         f->operation = 0;
7899 }
7900
7901 static size_t nul_length(const uint8_t *p, size_t sz) {
7902         size_t n = 0;
7903
7904         while (sz > 0) {
7905                 if (*p != 0)
7906                         break;
7907
7908                 n++;
7909                 p++;
7910                 sz--;
7911         }
7912
7913         return n;
7914 }
7915
7916 ssize_t sparse_write(int fd, const void *p, size_t sz, size_t run_length) {
7917         const uint8_t *q, *w, *e;
7918         ssize_t l;
7919
7920         q = w = p;
7921         e = q + sz;
7922         while (q < e) {
7923                 size_t n;
7924
7925                 n = nul_length(q, e - q);
7926
7927                 /* If there are more than the specified run length of
7928                  * NUL bytes, or if this is the beginning or the end
7929                  * of the buffer, then seek instead of write */
7930                 if ((n > run_length) ||
7931                     (n > 0 && q == p) ||
7932                     (n > 0 && q + n >= e)) {
7933                         if (q > w) {
7934                                 l = write(fd, w, q - w);
7935                                 if (l < 0)
7936                                         return -errno;
7937                                 if (l != q -w)
7938                                         return -EIO;
7939                         }
7940
7941                         if (lseek(fd, n, SEEK_CUR) == (off_t) -1)
7942                                 return -errno;
7943
7944                         q += n;
7945                         w = q;
7946                 } else if (n > 0)
7947                         q += n;
7948                 else
7949                         q ++;
7950         }
7951
7952         if (q > w) {
7953                 l = write(fd, w, q - w);
7954                 if (l < 0)
7955                         return -errno;
7956                 if (l != q - w)
7957                         return -EIO;
7958         }
7959
7960         return q - (const uint8_t*) p;
7961 }
7962
7963 void sigkill_wait(pid_t *pid) {
7964         if (!pid)
7965                 return;
7966         if (*pid <= 1)
7967                 return;
7968
7969         if (kill(*pid, SIGKILL) > 0)
7970                 (void) wait_for_terminate(*pid, NULL);
7971 }
7972
7973 int syslog_parse_priority(const char **p, int *priority, bool with_facility) {
7974         int a = 0, b = 0, c = 0;
7975         int k;
7976
7977         assert(p);
7978         assert(*p);
7979         assert(priority);
7980
7981         if ((*p)[0] != '<')
7982                 return 0;
7983
7984         if (!strchr(*p, '>'))
7985                 return 0;
7986
7987         if ((*p)[2] == '>') {
7988                 c = undecchar((*p)[1]);
7989                 k = 3;
7990         } else if ((*p)[3] == '>') {
7991                 b = undecchar((*p)[1]);
7992                 c = undecchar((*p)[2]);
7993                 k = 4;
7994         } else if ((*p)[4] == '>') {
7995                 a = undecchar((*p)[1]);
7996                 b = undecchar((*p)[2]);
7997                 c = undecchar((*p)[3]);
7998                 k = 5;
7999         } else
8000                 return 0;
8001
8002         if (a < 0 || b < 0 || c < 0 ||
8003             (!with_facility && (a || b || c > 7)))
8004                 return 0;
8005
8006         if (with_facility)
8007                 *priority = a*100 + b*10 + c;
8008         else
8009                 *priority = (*priority & LOG_FACMASK) | c;
8010
8011         *p += k;
8012         return 1;
8013 }
8014
8015 ssize_t string_table_lookup(const char * const *table, size_t len, const char *key) {
8016         size_t i;
8017
8018         if (!key)
8019                 return -1;
8020
8021         for (i = 0; i < len; ++i)
8022                 if (streq_ptr(table[i], key))
8023                         return (ssize_t)i;
8024
8025         return -1;
8026 }
8027
8028 void cmsg_close_all(struct msghdr *mh) {
8029         struct cmsghdr *cmsg;
8030
8031         assert(mh);
8032
8033         for (cmsg = CMSG_FIRSTHDR(mh); cmsg; cmsg = CMSG_NXTHDR(mh, cmsg))
8034                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS)
8035                         close_many((int*) CMSG_DATA(cmsg), (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int));
8036 }
8037
8038 int rename_noreplace(int olddirfd, const char *oldpath, int newdirfd, const char *newpath) {
8039         struct stat buf;
8040         int ret;
8041
8042         ret = renameat2(olddirfd, oldpath, newdirfd, newpath, RENAME_NOREPLACE);
8043         if (ret >= 0)
8044                 return 0;
8045
8046         /* Even though renameat2() exists since Linux 3.15, btrfs added
8047          * support for it later. If it is not implemented, fallback to another
8048          * method. */
8049         if (errno != EINVAL)
8050                 return -errno;
8051
8052         /* The link()/unlink() fallback does not work on directories. But
8053          * renameat() without RENAME_NOREPLACE gives the same semantics on
8054          * directories, except when newpath is an *empty* directory. This is
8055          * good enough. */
8056         ret = fstatat(olddirfd, oldpath, &buf, AT_SYMLINK_NOFOLLOW);
8057         if (ret >= 0 && S_ISDIR(buf.st_mode)) {
8058                 ret = renameat(olddirfd, oldpath, newdirfd, newpath);
8059                 return ret >= 0 ? 0 : -errno;
8060         }
8061
8062         /* If it is not a directory, use the link()/unlink() fallback. */
8063         ret = linkat(olddirfd, oldpath, newdirfd, newpath, 0);
8064         if (ret < 0)
8065                 return -errno;
8066
8067         ret = unlinkat(olddirfd, oldpath, 0);
8068         if (ret < 0) {
8069                 /* backup errno before the following unlinkat() alters it */
8070                 ret = errno;
8071                 (void) unlinkat(newdirfd, newpath, 0);
8072                 errno = ret;
8073                 return -errno;
8074         }
8075
8076         return 0;
8077 }
8078
8079 char *shell_maybe_quote(const char *s) {
8080         const char *p;
8081         char *r, *t;
8082
8083         assert(s);
8084
8085         /* Encloses a string in double quotes if necessary to make it
8086          * OK as shell string. */
8087
8088         for (p = s; *p; p++)
8089                 if (*p <= ' ' ||
8090                     *p >= 127 ||
8091                     strchr(SHELL_NEED_QUOTES, *p))
8092                         break;
8093
8094         if (!*p)
8095                 return strdup(s);
8096
8097         r = new(char, 1+strlen(s)*2+1+1);
8098         if (!r)
8099                 return NULL;
8100
8101         t = r;
8102         *(t++) = '"';
8103         t = mempcpy(t, s, p - s);
8104
8105         for (; *p; p++) {
8106
8107                 if (strchr(SHELL_NEED_ESCAPE, *p))
8108                         *(t++) = '\\';
8109
8110                 *(t++) = *p;
8111         }
8112
8113         *(t++)= '"';
8114         *t = 0;
8115
8116         return r;
8117 }
8118
8119 int parse_mode(const char *s, mode_t *ret) {
8120         char *x;
8121         long l;
8122
8123         assert(s);
8124         assert(ret);
8125
8126         errno = 0;
8127         l = strtol(s, &x, 8);
8128         if (errno != 0)
8129                 return -errno;
8130
8131         if (!x || x == s || *x)
8132                 return -EINVAL;
8133         if (l < 0 || l  > 07777)
8134                 return -ERANGE;
8135
8136         *ret = (mode_t) l;
8137         return 0;
8138 }